/** * One artifact-originated call, resolved into the code that actually runs. * * Two surfaces carry these calls, and they must agree exactly: * *  - `execute-action`, when the artifact renders inside an MCP-Apps client; *  - `POST /executions` with an `artifactId`, when it renders on the console's *    own artifact page (there is no MCP client there, so the shell's host *    adapter speaks HTTP instead). * * The same iframe, the same generated component and the same proxy sit behind * both. If only one of them constrained the grammar or applied the bindings, * the other would be a way around it — so the logic lives here and each surface * only formats the outcome in its own vocabulary. * * Resolution is: parse the code against the proxy's grammar, load the artifact, * rewrite the role into a connection, re-emit the call. The code that reaches * the engine is built here from a parsed path and a stored binding; the string * the iframe sent is never executed. */ import { Effect } from "effect";import type { Artifact } from "@executor-js/sdk"; import { resolveCallAddress } from "./artifact-bindings";import { formatToolCallCode, parseToolCallCode } from "./tool-call-code"; export type ArtifactActionResolution =  /** Run this. Built from the parsed path plus the artifact's bindings. */  | { readonly status: "ok"; readonly code: string }  /** Not the shape the proxy emits. */  | { readonly status: "invalid_action_code" }  /** The artifact is missing, or isn't this caller's. One outcome for both, so   *  the channel can't be used to probe for ids that exist. */  | { readonly status: "artifact_unavailable" }  /** The call names an integration role the artifact has no connection for. */  | {      readonly status: "binding_unresolved";      readonly role: string;      readonly integration: string;      readonly message: string;    }; /** * `loadArtifact` is the caller's OWN scoped read. Ownership is therefore * enforced by the same query that fetches the row — an id belonging to someone * else simply doesn't resolve — rather than by a separate check that could * drift from it. * * A missing `artifactId` is treated as an artifact with no bindings: a call * that already carries a full address runs as written (that is the * pre-binding-contract path), a short one has nothing to resolve against and is * refused. */export const resolveArtifactAction = (input: {  readonly code: string;  readonly artifactId: string | undefined;  readonly loadArtifact: (id: string) => Effect.Effect<Artifact | null>;}): Effect.Effect<ArtifactActionResolution> =>  Effect.gen(function* () {    const call = parseToolCallCode(input.code);    if (!call) return { status: "invalid_action_code" } as const;     const artifact =      input.artifactId === undefined ? null : yield* input.loadArtifact(input.artifactId);    if (input.artifactId !== undefined && !artifact) {      return { status: "artifact_unavailable" } as const;    }     const resolved = resolveCallAddress({      path: call.path,      role: call.role,      bindings: artifact?.bindings ?? null,    });    if (!resolved.ok) {      return input.artifactId === undefined        ? ({ status: "artifact_unavailable" } as const)        : ({            status: "binding_unresolved",            role: resolved.role,            integration: resolved.integration,            message: resolved.message,          } as const);    }     return { status: "ok", code: formatToolCallCode(resolved.path, call.args) } as const;  });