@maxanstey-meridian/tandem 0.1.6 → 0.3.0

package/dist/index.js

@@ -38,8 +38,10 @@ export class ContractValidationError extends TandemError {
         this.problems = problems;
     }
 }
-function callbackError(error) {
-    return error instanceof ContractValidationError
+const callbackSucceeded = (value) => JSON.stringify({ succeeded: true, value });
+const callbackFailed = (error) => JSON.stringify({
+    succeeded: false,
+    error: error instanceof ContractValidationError
         ? {
             name: error.name,
             message: error.message,
@@ -49,94 +51,48 @@ function callbackError(error) {
         : {
             name: error instanceof Error ? error.name : "Error",
             message: error instanceof Error ? error.message : String(error),
-        };
-}
+        },
+});
+/** Synchronous callbacks cannot observe cancellation; they receive a signal that never aborts. */
+const neverAborted = new AbortController().signal;
 class CallbackRegistry {
-    #sync = new Map();
-    #async = new Map();
+    #callbacks = new Map();
     #next = 0;
     #disposed = false;
     registerSync(callback) {
-        const id = this.#allocate();
-        this.#sync.set(id, callback);
-        return id;
+        return this.#register(callback);
     }
     registerAsync(callback) {
-        const id = this.#allocate();
-        this.#async.set(id, callback);
-        return id;
+        return this.#register(callback);
     }
-    invokeSync(id, state, input) {
+    /** Never throws: failures travel back to the bridge as an encoded `CallbackResult`. */
+    invoke(id, state, input, signal) {
         try {
-            const callback = this.#sync.get(id);
+            const callback = this.#callbacks.get(id);
             if (!callback) {
                 throw new Error(`Unknown internal callback '${id}'.`);
             }
-            return JSON.stringify({
-                succeeded: true,
-                value: callback(state, input),
-            });
+            const value = callback(state, input, signal);
+            return typeof value === "string"
+                ? callbackSucceeded(value)
+                : value.then(callbackSucceeded, callbackFailed);
         }
         catch (error) {
-            return JSON.stringify({
-                succeeded: false,
-                error: callbackError(error),
-            });
-        }
-    }
-    async invokeAsync(id, state, input, signal) {
-        try {
-            const callback = this.#async.get(id);
-            if (!callback) {
-                throw new Error(`Unknown internal async callback '${id}'.`);
-            }
-            return JSON.stringify({
-                succeeded: true,
-                value: await callback(state, input, signal),
-            });
-        }
-        catch (error) {
-            return JSON.stringify({
-                succeeded: false,
-                error: callbackError(error),
-            });
+            return callbackFailed(error);
         }
     }
     dispose() {
         this.#disposed = true;
-        this.#sync.clear();
-        this.#async.clear();
+        this.#callbacks.clear();
     }
-    #allocate() {
+    #register(callback) {
         if (this.#disposed) {
             throw new Error("Callback registry has been disposed.");
         }
-        return `c${this.#next++}`;
-    }
-}
-function callbackContractFailure(error) {
-    const marker = "TANDEM_CALLBACK_CONTRACT:";
-    const message = error instanceof Error ? error.message : String(error);
-    const start = message.indexOf(marker);
-    if (start < 0) {
-        return null;
-    }
-    try {
-        return JSON.parse(message.slice(start + marker.length));
-    }
-    catch {
-        return null;
-    }
-}
-function isCancellationError(error, signalAborted) {
-    if (!(error instanceof Error)) {
-        return false;
-    }
-    if (error.message.includes("JavaScript callback failed:") && !signalAborted) {
-        return false;
+        const id = `c${this.#next++}`;
+        this.#callbacks.set(id, callback);
+        return id;
     }
-    return (error.name === "AbortError" ||
-        /\b(?:operation was cancel(?:l)?ed|operation was aborted|this operation was aborted)\b/i.test(error.message));
 }
 function path(parts) {
     return parts.length === 0
@@ -176,43 +132,24 @@ function parse(schema, value, boundary) {
     }
     return result;
 }
+/**
+ * The walker is the whole losslessness check: a stringify/parse round-trip compares only enumerable
+ * data, so it misses accessors and non-enumerable properties, and it cannot name the failing path.
+ */
 function serializeBoundary(schema, value, boundary) {
     const parsed = parse(schema, value, boundary);
     const problem = jsonValueProblem(parsed, "$", new WeakSet());
     if (problem) {
         throw new ContractValidationError(boundary, [problem]);
     }
-    let json;
-    try {
-        json = JSON.stringify(parsed);
-    }
-    catch (error) {
-        throw new ContractValidationError(boundary, [
-            {
-                path: "$",
-                message: `Value is not JSON-serializable: ${error instanceof Error ? error.message : String(error)}`,
-            },
-        ]);
-    }
-    if (json === undefined) {
-        throw new ContractValidationError(boundary, [
-            { path: "$", message: "Top-level undefined is not JSON-serializable." },
-        ]);
-    }
-    const roundTripped = JSON.parse(json);
-    if (!isDeepStrictEqual(roundTripped, parsed)) {
-        throw new ContractValidationError(boundary, [
-            { path: "$", message: "Value is not losslessly JSON-serializable." },
-        ]);
-    }
-    return json;
+    return JSON.stringify(parsed);
 }
 function jsonValueProblem(value, valuePath, seen) {
     if (value === undefined) {
         return { path: valuePath, message: "undefined is not JSON-serializable." };
     }
-    if (typeof value === "number" && !Number.isFinite(value)) {
-        return { path: valuePath, message: "Non-finite numbers are not JSON-serializable." };
+    if (typeof value === "number" && (!Number.isFinite(value) || Object.is(value, -0))) {
+        return { path: valuePath, message: "Non-finite numbers and -0 are not JSON-serializable." };
     }
     if (typeof value === "bigint" || typeof value === "symbol" || typeof value === "function") {
         return { path: valuePath, message: `${typeof value} values are not JSON-serializable.` };
@@ -312,164 +249,133 @@ function inputJsonSchema(schema, boundary) {
         ]);
     }
 }
-class NodeImplementation {
-    id;
-    persist;
-    [participantBrand];
-    constructor(id, persist) {
-        this.id = id;
-        this.persist = persist;
-    }
-}
-class StageImplementation extends NodeImplementation {
-    execute;
-    kind = "stage";
-    constructor(id, persist, execute) {
-        super(id, persist);
-        this.execute = execute;
-    }
-}
+const positiveInt32 = z.int32({ error: "must be a positive 32-bit integer" }).min(1);
+const nonBlankString = z
+    .string({ error: "must be a non-blank string" })
+    .refine((value) => value.trim().length > 0, { error: "must be a non-blank string" });
+const hasUnique = (items, key) => new Set(items.map(key)).size === items.length;
+/** The participant brand only pins `TState` for the type checker; `kind` identifies records at runtime. */
+const keepState = (state) => state;
 export function stage(definition) {
-    return new StageImplementation(definition.id, definition.persist, definition.execute);
+    const record = {
+        ...definition,
+        [participantBrand]: keepState,
+        kind: "stage",
+    };
+    return Object.freeze(record);
 }
 const taskAgentBrand = Symbol("taskAgent");
-class TaskAgentImplementation {
-    id;
-    input;
-    result;
-    [taskAgentBrand] = true;
-    state;
-    participant;
-    constructor(id, input, result, definition) {
-        this.id = id;
-        this.input = input;
-        this.result = result;
-        this.state = z.object({ input, output: z.object({ value: result }).nullable() });
-        this.participant = agent({
+export function taskAgent(definition) {
+    const { validateFor } = definition.output;
+    const record = {
+        [taskAgentBrand]: true,
+        id: definition.id,
+        input: definition.input,
+        result: definition.result,
+        state: z.object({
+            input: definition.input,
+            output: z.object({ value: definition.result }).nullable(),
+        }),
+        participant: agent({
             ...definition,
             message: (state) => definition.message(state.input),
             output: {
                 ...definition.output,
-                validateFor: definition.output.validateFor
-                    ? (state, value) => definition.output.validateFor(state.input, value)
-                    : undefined,
-                apply: (state, value) => ({
-                    ...state,
-                    output: { value },
-                }),
+                validateFor: validateFor ? (state, value) => validateFor(state.input, value) : undefined,
+                apply: (state, value) => ({ ...state, output: { value } }),
             },
-        });
-    }
-}
-export function taskAgent(definition) {
-    return new TaskAgentImplementation(definition.id, definition.input, definition.result, definition);
+        }),
+    };
+    return Object.freeze(record);
 }
-class CollectionImplementation extends NodeImplementation {
-    definition;
-    kind = "collection";
-    constructor(definition) {
-        super(definition.id, definition.persist);
-        this.definition = definition;
+/** Task agents are only created by `taskAgent()`, whose record is the returned object. */
+function taskAgentRecord(reference) {
+    if (!("participant" in reference)) {
+        throw new TandemError("Use taskAgent to declare collection agents.");
     }
+    return reference;
 }
+const collectionOptionsSchema = z.object({
+    max: positiveInt32,
+    agents: z
+        .array(z.object({ id: z.string() }))
+        .refine((agents) => hasUnique(agents, (agent) => agent.id), { error: "must have unique IDs" }),
+});
 export function collection(definition) {
-    if (!Number.isInteger(definition.max) || definition.max < 1 || definition.max > 2147483647) {
-        throw new TandemError("Collection max must be a positive 32-bit integer.");
-    }
-    if (new Set(definition.agents.map((agent) => agent.id)).size !== definition.agents.length) {
-        throw new TandemError("Collection agent IDs must be unique.");
-    }
-    return new CollectionImplementation(definition);
-}
-class InteractionImplementation extends NodeImplementation {
-    requestSchema;
-    responseSchema;
-    request;
-    apply;
-    kind = "interaction";
-    requestType;
-    responseType;
-    constructor(id, persist, requestSchema, responseSchema, request, apply) {
-        super(id, persist);
-        this.requestSchema = requestSchema;
-        this.responseSchema = responseSchema;
-        this.request = request;
-        this.apply = apply;
-    }
+    parseDefinition(collectionOptionsSchema, definition, `Collection '${definition.id}'`);
+    const record = {
+        ...definition,
+        [participantBrand]: keepState,
+        kind: "collection",
+    };
+    return Object.freeze(record);
 }
 export function interaction(definition) {
-    return new InteractionImplementation(definition.id, definition.persist, definition.requestSchema, definition.responseSchema, definition.request, definition.apply);
-}
-class InteractionHandlersImplementation {
-    [interactionHandlersBrand] = true;
-    entries = [];
-    #interactions = new Set();
-    handle(interaction, handler) {
-        const opaque = interaction;
-        if (this.#interactions.has(opaque)) {
-            throw new TandemError(`Interaction '${interaction.id}' already has a handler.`);
-        }
-        this.#interactions.add(opaque);
-        this.entries.push({
-            interaction: opaque,
-            handle: handler,
-        });
-        return this;
-    }
+    const record = {
+        ...definition,
+        [participantBrand]: keepState,
+        kind: "interaction",
+    };
+    return Object.freeze(record);
 }
+const registeredHandlers = new WeakMap();
 export function interactions() {
-    return new InteractionHandlersImplementation();
+    const entries = [];
+    const handlers = {
+        [interactionHandlersBrand]: true,
+        handle(interaction, handler) {
+            if (entries.some((entry) => entry.interaction === interaction)) {
+                throw new TandemError(`Interaction '${interaction.id}' already has a handler.`);
+            }
+            entries.push({
+                // An interaction is the record `interaction()` built; its types are erased for storage.
+                interaction: interaction,
+                handle: handler,
+            });
+            return handlers;
+        },
+    };
+    registeredHandlers.set(handlers, entries);
+    return Object.freeze(handlers);
 }
-class CapabilityImplementation {
-    name;
-    instructions;
-    schema;
-    validateFor;
-    apply;
-    summarize;
-    requestJsonSchema;
-    constructor(name, instructions, schema, validateFor, apply, summarize) {
-        this.name = name;
-        this.instructions = instructions;
-        this.schema = schema;
-        this.validateFor = validateFor;
-        this.apply = apply;
-        this.summarize = summarize;
-        this.requestJsonSchema = inputJsonSchema(schema, `capability '${name}' schema`);
-    }
-    [compileCapabilityBrand]({ id, stateSchema, callbacks, }) {
-        const validate = callbacks.registerSync((_, input) => issues(this.schema, input));
-        const validateFor = this.validateFor
-            ? callbacks.registerSync((state, input) => validationProblems(this.validateFor(parseJson(stateSchema, state, `${id} state`), parseJson(this.schema, input, `${id} capability '${this.name}' request`)), `${id} capability '${this.name}' contextual validation`))
-            : undefined;
-        const apply = callbacks.registerSync((state, input) => serializeBoundary(stateSchema, this.apply(parseJson(stateSchema, state, `${id} state`), parseJson(this.schema, input, `${id} capability '${this.name}' request`)), `${id} applied state`));
-        const summary = callbacks.registerSync((_, input) => this.summarize(parseJson(this.schema, input, `${id} capability '${this.name}' request`)));
+export function capability(definition) {
+    const { name, instructions, schema, validateFor, apply, summarize } = definition;
+    requireInstructions(instructions, `Capability '${name}' instructions`);
+    const requestJsonSchema = inputJsonSchema(schema, `capability '${name}' schema`);
+    const compile = ({ id, stateSchema, callbacks }) => {
+        const parseState = (state) => parseJson(stateSchema, state, `${id} state`);
+        const parseRequest = (input) => parseJson(schema, input, `${id} capability '${name}' request`);
         return {
-            name: this.name,
-            instructions: this.instructions,
-            jsonSchema: this.requestJsonSchema,
-            validateCallback: validate,
-            validateForCallback: validateFor,
-            applyCallback: apply,
-            summaryCallback: summary,
-            valueType: `${id}.capability.${this.name}`,
+            name,
+            instructions,
+            jsonSchema: requestJsonSchema,
+            validateCallback: callbacks.registerSync((_, input) => issues(schema, input)),
+            validateForCallback: validateFor
+                ? callbacks.registerSync((state, input) => validationProblems(validateFor(parseState(state), parseRequest(input)), `${id} capability '${name}' contextual validation`))
+                : undefined,
+            applyCallback: callbacks.registerSync((state, input) => serializeBoundary(stateSchema, apply(parseState(state), parseRequest(input)), `${id} applied state`)),
+            summaryCallback: callbacks.registerSync((_, input) => summarize(parseRequest(input))),
+            valueType: `${id}.capability.${name}`,
         };
-    }
-}
-export function capability(definition) {
-    requireInstructions(definition.instructions, `Capability '${definition.name}' instructions`);
-    return new CapabilityImplementation(definition.name, definition.instructions, definition.schema, definition.validateFor, definition.apply, definition.summarize);
-}
-class AgentToolGroupImplementation {
-    predicate;
-    tools;
-    [toolGroupBrand];
-    constructor(predicate, tools) {
-        this.predicate = predicate;
-        this.tools = tools;
-        this[toolGroupBrand] = predicate ?? (() => true);
-    }
+    };
+    const record = {
+        name,
+        requestJsonSchema,
+        [compileCapabilityBrand]: compile,
+    };
+    return Object.freeze(record);
 }
+const agentToolInvocationSchema = z.strictObject({
+    name: z.string(),
+    effect: z.enum([
+        "read",
+        "workspaceMutation",
+        "processExecution",
+        "lifecycleTransition",
+        "unclassified",
+    ]),
+    arguments: z.unknown(),
+});
 function createToolGroup(predicate, tools) {
     if (tools.length === 0) {
         throw new TandemError("An agent tool group cannot be empty.");
@@ -484,264 +390,154 @@ function createToolGroup(predicate, tools) {
         }
         seen.add(tool);
     }
-    return new AgentToolGroupImplementation(predicate, tools);
+    const record = {
+        [toolGroupBrand]: predicate ?? (() => true),
+        predicate,
+        tools,
+    };
+    return Object.freeze(record);
 }
 export const agentTools = {
     always: (...tools) => createToolGroup(undefined, tools),
     when: (predicate, ...tools) => createToolGroup(predicate, tools),
 };
-class AgentWorkspaceImplementation {
-    path;
-    commands;
-    commandSource;
-    constructor(path, commandSource) {
-        this.path = path;
-        this.commandSource =
-            typeof commandSource === "function" || commandSource === undefined
-                ? commandSource
-                : commandSource.map(copyAgentCommand);
-        this.commands = { [commandSelectionBrand]: this };
-    }
-    withTools(groups, options) {
-        if (groups.length === 0) {
-            throw new TandemError("An agent workspace requires tool groups.");
-        }
-        const implementations = groups.map((group) => {
-            if (!(group instanceof AgentToolGroupImplementation)) {
-                throw new TandemError("Agent tool groups must be created by agentTools.");
-            }
-            return group;
-        });
-        if (options?.interceptTool !== undefined && typeof options.interceptTool !== "function") {
-            throw new TandemError("Workspace tool interceptor must be a function.");
-        }
-        return new AgentWorkspaceConfigurationImplementation(this, implementations, options?.interceptTool);
-    }
-}
-class AgentWorkspaceConfigurationImplementation {
-    workspace;
-    groups;
-    interceptTool;
-    [workspaceBrand];
-    constructor(workspace, groups, interceptTool) {
-        this.workspace = workspace;
-        this.groups = groups;
-        this.interceptTool = interceptTool;
-    }
-}
 export function agentWorkspace(definition) {
     if (typeof definition.path !== "function") {
         throw new TandemError("Workspace path is required.");
     }
-    if (definition.commands !== undefined && typeof definition.commands !== "function") {
-        validateAgentCommands(definition.commands, "Workspace commands");
-    }
-    return new AgentWorkspaceImplementation(definition.path, definition.commands);
-}
-function copyAgentCommand(command) {
-    return command.arguments === undefined
-        ? { ...command }
-        : {
-            ...command,
-            arguments: [...command.arguments],
-        };
-}
-function validateAgentCommands(commands, context) {
-    if (!Array.isArray(commands)) {
-        throw new TandemError(`${context} must be an array.`);
-    }
-    for (const [commandIndex, command] of commands.entries()) {
-        const commandContext = `${context}[${commandIndex}]`;
-        if (typeof command !== "object" || command === null) {
-            throw new TandemError(`${commandContext} must be a command.`);
-        }
-        const candidate = command;
-        if (typeof candidate.name !== "string" || !/^[A-Za-z_][A-Za-z0-9_]*$/.test(candidate.name)) {
-            throw new TandemError(`${commandContext}.name must be a valid tool name.`);
-        }
-        if (typeof candidate.description !== "string" || candidate.description.trim().length === 0) {
-            throw new TandemError(`${commandContext}.description must be non-blank.`);
-        }
-        if (typeof candidate.command !== "string" || candidate.command.trim().length === 0) {
-            throw new TandemError(`${commandContext}.command must be non-blank.`);
-        }
-        if (candidate.arguments !== undefined && !Array.isArray(candidate.arguments)) {
-            throw new TandemError(`${commandContext}.arguments must be an array of strings.`);
-        }
-        const argumentList = candidate.arguments ?? [];
-        if (argumentList.length > 16) {
-            throw new TandemError(`${commandContext}.arguments accepts at most 16 arguments.`);
-        }
-        for (const [argumentIndex, argument] of argumentList.entries()) {
-            const argumentContext = `${commandContext}.arguments[${argumentIndex}]`;
-            if (typeof argument !== "string") {
-                throw new TandemError(`${argumentContext} must be a string.`);
-            }
-            if (argument.trim().length === 0) {
-                throw new TandemError(`${argumentContext} must not be blank.`);
+    const workspace = Object.freeze({
+        path: definition.path,
+        // Parsing copies a static catalogue, so later mutation by the caller cannot change it.
+        commandSource: typeof definition.commands === "function" || definition.commands === undefined
+            ? definition.commands
+            : parseDefinition(agentCommandsSchema, definition.commands, "Workspace commands"),
+    });
+    return Object.freeze({
+        commands: Object.freeze({ [commandSelectionBrand]: workspace }),
+        withTools(groups, options) {
+            if (groups.length === 0) {
+                throw new TandemError("An agent workspace requires tool groups.");
             }
-            if (argument.length > 200) {
-                throw new TandemError(`${argumentContext} must be at most 200 characters.`);
+            const records = groups.map((group) => {
+                if (!("tools" in group)) {
+                    throw new TandemError("Agent tool groups must be created by agentTools.");
+                }
+                // A tool group record is the object `agentTools` returned.
+                return group;
+            });
+            if (options?.interceptTool !== undefined && typeof options.interceptTool !== "function") {
+                throw new TandemError("Workspace tool interceptor must be a function.");
             }
-        }
-    }
+            const configuration = {
+                [workspaceBrand]: keepState,
+                workspace,
+                groups: records,
+                interceptTool: options?.interceptTool,
+            };
+            return Object.freeze(configuration);
+        },
+    });
 }
+const agentCommandsSchema = z.array(z.strictObject({
+    name: z
+        .string({ error: "must be a valid tool name" })
+        .regex(/^[A-Za-z_][A-Za-z0-9_]*$/, { error: "must be a valid tool name" }),
+    description: nonBlankString,
+    command: nonBlankString,
+    arguments: z
+        .array(z
+        .string({ error: "must be a string" })
+        .refine((value) => value.trim().length > 0, { error: "must not be blank" })
+        .max(200, { error: "must be at most 200 characters" }), { error: "must be an array of strings" })
+        .max(16, { error: "accepts at most 16 arguments" })
+        .optional(),
+}), { error: "must be an array" });
+const skillSchema = z.object({ directory: nonBlankString });
 export function skill(definition) {
-    if (typeof definition.directory !== "string" || definition.directory.trim().length === 0) {
-        throw new TandemError("Skill directory must be a non-blank string.");
-    }
-    return { directory: definition.directory };
-}
-class AgentImplementation extends NodeImplementation {
-    instructions;
-    client;
-    message;
-    output;
-    granted;
-    skills;
-    workspace;
-    temperature;
-    maxOutputTokens;
-    reasoning;
-    continueSession;
-    checkpoint;
-    timeoutMs;
-    kind = "agent";
-    constructor(id, persist, instructions, client, message, output, granted, skills, workspace, temperature, maxOutputTokens, reasoning, continueSession, checkpoint, timeoutMs) {
-        super(id, persist);
-        this.instructions = instructions;
-        this.client = client;
-        this.message = message;
-        this.output = output;
-        this.granted = granted;
-        this.skills = skills;
-        this.workspace = workspace;
-        this.temperature = temperature;
-        this.maxOutputTokens = maxOutputTokens;
-        this.reasoning = reasoning;
-        this.continueSession = continueSession;
-        this.checkpoint = checkpoint;
-        this.timeoutMs = timeoutMs;
-    }
+    return parseDefinition(skillSchema, definition, "Skill");
 }
+const capabilityReference = z.custom();
+const agentOutputSchema = z.discriminatedUnion("raw", [
+    z.object({
+        raw: z.literal(true),
+        schema: z.undefined({ error: "is forbidden for raw output" }).optional(),
+        parse: z.custom((value) => typeof value === "function", {
+            error: "must be a function for raw output",
+        }),
+    }),
+    z.object({
+        raw: z.undefined().optional(),
+        parse: z.undefined({ error: "requires raw output mode" }).optional(),
+    }),
+], { error: "must be true" });
+const agentOptionsSchema = z
+    .object({
+    output: agentOutputSchema.optional(),
+    reasoning: z
+        .object({
+        effort: z
+            .enum(["none", "low", "medium", "high"], {
+            error: "must be 'none', 'low', 'medium' or 'high'",
+        })
+            .optional(),
+        maxTokens: z
+            .int32({ error: "must be a 32-bit integer of at least 1024" })
+            .min(1024)
+            .optional(),
+    })
+        .refine((value) => (value.effort === undefined) !== (value.maxTokens === undefined), {
+        error: "must specify exactly one of effort or maxTokens",
+    })
+        .optional(),
+    capabilities: z
+        .array(capabilityReference)
+        .refine((items) => hasUnique(items, (item) => item.name), {
+        error: "must not contain a duplicate capability",
+    })
+        .optional(),
+    skills: z
+        .array(skillSchema)
+        .refine((items) => hasUnique(items, (item) => item.directory), {
+        error: "must not repeat a skill directory",
+    })
+        .optional(),
+    temperature: z.number({ error: "must be between 0 and 2" }).min(0).max(2).optional(),
+    maxOutputTokens: positiveInt32.optional(),
+    checkpoint: z
+        .object({
+        contextWindowTokens: positiveInt32,
+        maxOutputTokens: positiveInt32,
+        checkpointAtPercent: z.int({ error: "must be between 1 and 99" }).min(1).max(99),
+        capability: capabilityReference,
+        session: z.enum(["retain", "reset"], { error: "must be 'retain' or 'reset'" }).optional(),
+        disableCompaction: z.boolean({ error: "must be a boolean" }).optional(),
+    })
+        .refine((value) => value.maxOutputTokens < value.contextWindowTokens, {
+        path: ["maxOutputTokens"],
+        error: "must be smaller than contextWindowTokens",
+    })
+        .optional(),
+})
+    .refine((value) => value.checkpoint === undefined ||
+    (value.capabilities ?? []).includes(value.checkpoint.capability), { path: ["checkpoint", "capability"], error: "must be attached to the agent" });
 export function agent(definition) {
     const rawOutput = definition.output && "raw" in definition.output && definition.output.raw === true;
     if (!rawOutput || typeof definition.instructions !== "string") {
         requireInstructions(definition.instructions, `Agent '${definition.id}' instructions`);
     }
-    const reasoningEffort = definition.reasoning?.effort;
-    const reasoningMaxTokens = definition.reasoning?.maxTokens;
-    if (definition.reasoning &&
-        (reasoningEffort !== undefined) === (reasoningMaxTokens !== undefined)) {
-        throw new TandemError(`Agent '${definition.id}' reasoning must specify exactly one of effort or maxTokens.`);
-    }
-    if (reasoningEffort !== undefined &&
-        !["none", "low", "medium", "high"].includes(reasoningEffort)) {
-        throw new TandemError(`Agent '${definition.id}' has an invalid reasoning effort.`);
-    }
-    if (reasoningMaxTokens !== undefined) {
-        if (!Number.isSafeInteger(reasoningMaxTokens) ||
-            reasoningMaxTokens < 1024 ||
-            reasoningMaxTokens > 2_147_483_647) {
-            throw new TandemError(`Agent '${definition.id}' reasoning maxTokens must be a 32-bit integer of at least 1024.`);
-        }
-    }
-    if (definition.output) {
-        if (!rawOutput || typeof definition.output.instructions !== "string") {
-            requireInstructions(definition.output.instructions, `Agent '${definition.id}' output instructions`);
-        }
-        if ("raw" in definition.output) {
-            if (definition.output.raw !== true) {
-                throw new TandemError(`Agent '${definition.id}' output raw must be true.`);
-            }
-            if ("schema" in definition.output) {
-                throw new TandemError(`Agent '${definition.id}' output schema is forbidden for raw output.`);
-            }
-            if (typeof definition.output.parse !== "function") {
-                throw new TandemError(`Agent '${definition.id}' raw output requires a parse function.`);
-            }
-        }
-        else if ("parse" in definition.output) {
-            throw new TandemError(`Agent '${definition.id}' output parse requires raw output mode.`);
-        }
-    }
-    const capabilities = definition.capabilities ?? [];
-    const names = new Set();
-    for (const item of capabilities) {
-        if (names.has(item.name)) {
-            throw new TandemError(`Agent '${definition.id}' has duplicate capability '${item.name}'.`);
-        }
-        else {
-            names.add(item.name);
-        }
-    }
-    const skills = definition.skills ?? [];
-    const skillDirectories = new Set();
-    for (const item of skills) {
-        if (typeof item?.directory !== "string" || item.directory.trim().length === 0) {
-            throw new TandemError(`Agent '${definition.id}' has a skill with an invalid directory.`);
-        }
-        if (!skillDirectories.add(item.directory)) {
-            throw new TandemError(`Agent '${definition.id}' has the skill directory '${item.directory}' more than once.`);
-        }
-    }
-    if (definition.temperature !== undefined &&
-        (!Number.isFinite(definition.temperature) ||
-            definition.temperature < 0 ||
-            definition.temperature > 2)) {
-        throw new TandemError(`Agent '${definition.id}' temperature must be between 0 and 2.`);
-    }
-    if (definition.maxOutputTokens !== undefined &&
-        (!Number.isSafeInteger(definition.maxOutputTokens) ||
-            definition.maxOutputTokens <= 0 ||
-            definition.maxOutputTokens > 2_147_483_647)) {
-        throw new TandemError(`Agent '${definition.id}' maxOutputTokens must be a positive 32-bit integer.`);
+    if (definition.output && (!rawOutput || typeof definition.output.instructions !== "string")) {
+        requireInstructions(definition.output.instructions, `Agent '${definition.id}' output instructions`);
     }
     if (definition.checkpoint) {
-        const checkpoint = definition.checkpoint;
-        if (!Number.isSafeInteger(checkpoint.contextWindowTokens) ||
-            checkpoint.contextWindowTokens <= 0 ||
-            checkpoint.contextWindowTokens > 2_147_483_647) {
-            throw new TandemError(`Agent '${definition.id}' checkpoint contextWindowTokens must be a positive 32-bit integer.`);
-        }
-        if (!Number.isSafeInteger(checkpoint.maxOutputTokens) ||
-            checkpoint.maxOutputTokens <= 0 ||
-            checkpoint.maxOutputTokens > 2_147_483_647 ||
-            checkpoint.maxOutputTokens >= checkpoint.contextWindowTokens) {
-            throw new TandemError(`Agent '${definition.id}' checkpoint maxOutputTokens must be a positive 32-bit integer smaller than contextWindowTokens.`);
-        }
-        if (!Number.isSafeInteger(checkpoint.checkpointAtPercent) ||
-            checkpoint.checkpointAtPercent <= 0 ||
-            checkpoint.checkpointAtPercent >= 100) {
-            throw new TandemError(`Agent '${definition.id}' checkpoint checkpointAtPercent must be between 1 and 99.`);
-        }
-        if (!capabilities.includes(checkpoint.capability)) {
-            throw new TandemError(`Agent '${definition.id}' checkpoint capability must be attached to the agent.`);
-        }
-        requireInstructions(checkpoint.instructions, `Agent '${definition.id}' checkpoint instructions`);
-        if (checkpoint.session !== undefined &&
-            checkpoint.session !== "retain" &&
-            checkpoint.session !== "reset") {
-            throw new TandemError(`Agent '${definition.id}' checkpoint session must be 'retain' or 'reset'.`);
-        }
-        if (checkpoint.disableCompaction !== undefined &&
-            typeof checkpoint.disableCompaction !== "boolean") {
-            throw new TandemError(`Agent '${definition.id}' checkpoint disableCompaction must be a boolean.`);
-        }
-    }
-    return new AgentImplementation(definition.id, definition.persist, definition.instructions, definition.client, definition.message, definition.output, capabilities, skills, definition.workspace, definition.temperature, definition.maxOutputTokens, definition.reasoning, definition.continueSession ?? false, definition.checkpoint, definition.timeoutMs);
-}
-class ParallelImplementation extends NodeImplementation {
-    branches;
-    max;
-    merge;
-    kind = "parallel";
-    constructor(id, persist, branches, max, merge) {
-        super(id, persist);
-        this.branches = branches;
-        this.max = max;
-        this.merge = merge;
+        requireInstructions(definition.checkpoint.instructions, `Agent '${definition.id}' checkpoint instructions`);
     }
+    parseDefinition(agentOptionsSchema, definition, `Agent '${definition.id}'`);
+    const record = {
+        ...definition,
+        [participantBrand]: keepState,
+        kind: "agent",
+    };
+    return Object.freeze(record);
 }
 export function parallel(definition) {
     if (!definition) {
@@ -749,33 +545,43 @@ export function parallel(definition) {
     }
     return createParallel(definition);
 }
+const parallelOptionsSchema = z.object({
+    max: positiveInt32.optional(),
+    branches: z
+        .record(z.string(), z.custom())
+        .refine((branches) => Object.keys(branches).every((id) => id.trim().length > 0), {
+        error: "must not have a blank branch ID",
+    })
+        .refine((branches) => Object.keys(branches).length >= 2, {
+        error: "requires at least two branches",
+    })
+        .refine((branches) => hasUnique(Object.values(branches), (participant) => participant), {
+        error: "must own a distinct participant per branch",
+    }),
+});
 function createParallel(definition) {
-    if (definition.max !== undefined &&
-        (!Number.isInteger(definition.max) || definition.max < 1 || definition.max > 2147483647)) {
-        throw new TandemError(`Parallel group '${definition.id}' max must be a positive 32-bit integer.`);
-    }
-    const entries = Object.entries(definition.branches);
-    if (entries.length < 2) {
-        throw new TandemError(`Parallel group '${definition.id}' requires at least two branches.`);
-    }
-    const participants = new Set(entries.map(([, participant]) => participant));
-    if (participants.size !== entries.length) {
-        throw new TandemError(`Parallel group '${definition.id}' must own a distinct participant per branch.`);
-    }
-    return new ParallelImplementation(definition.id, definition.persist, definition.branches, definition.max, definition.merge);
-}
-class TerminalImplementation extends NodeImplementation {
-    failed;
-    summary;
-    kind = "terminal";
-    constructor(id, persist, failed, summary) {
-        super(id, persist);
-        this.failed = failed;
-        this.summary = summary;
-    }
+    parseDefinition(parallelOptionsSchema, definition, `Parallel group '${definition.id}'`);
+    const record = {
+        ...definition,
+        [participantBrand]: keepState,
+        kind: "parallel",
+    };
+    return Object.freeze(record);
 }
 export function output(definition) {
-    return new TerminalImplementation(definition.id, definition.persist, definition.failed ?? false, definition.summary);
+    const record = {
+        ...definition,
+        [participantBrand]: keepState,
+        kind: "terminal",
+    };
+    return Object.freeze(record);
+}
+/**
+ * Every node is the frozen record its factory built; the exported node interfaces are opaque views
+ * of those records, with the request/output/item types erased here.
+ */
+function nodeRecord(node) {
+    return node;
 }
 export function route(definition) {
     return definition;
@@ -784,43 +590,39 @@ export function pipeline(definition) {
     const start = definition.start;
     const members = new Set(definition.nodes);
     if (members.size !== definition.nodes.length) {
-        throw new Error("Pipeline nodes must contain each participant object exactly once.");
+        throw new TandemError("Pipeline nodes must contain each participant object exactly once.");
     }
     const ids = new Set(definition.nodes.map((node) => node.id));
     if (ids.size !== definition.nodes.length) {
-        throw new Error("Pipeline node IDs must be unique.");
+        throw new TandemError("Pipeline node IDs must be unique.");
     }
     const ownedParticipants = new Set();
-    for (const node of definition.nodes) {
+    for (const node of definition.nodes.map(nodeRecord)) {
         if (node.kind !== "parallel") {
             continue;
         }
-        const parallelNode = node;
-        for (const [branchId, participant] of Object.entries(parallelNode.branches)) {
-            if (branchId.trim().length === 0) {
-                throw new Error(`Parallel group '${node.id}' contains a blank branch ID.`);
-            }
+        for (const participant of Object.values(node.branches)) {
             if (members.has(participant)) {
-                throw new Error(`Parallel branch participant '${participant.id}' cannot also be a parent pipeline node.`);
+                throw new TandemError(`Parallel branch participant '${participant.id}' cannot also be a parent pipeline node.`);
             }
             if (!ownedParticipants.add(participant)) {
-                throw new Error(`Parallel branch participant '${participant.id}' is owned more than once.`);
+                throw new TandemError(`Parallel branch participant '${participant.id}' is owned more than once.`);
             }
             if (ids.has(participant.id)) {
-                throw new Error(`Pipeline participant ID '${participant.id}' must be globally unique.`);
+                throw new TandemError(`Pipeline participant ID '${participant.id}' must be globally unique.`);
             }
             ids.add(participant.id);
         }
     }
     if (!members.has(definition.start)) {
-        throw new Error(`Pipeline start '${definition.start.id}' must be the registered participant object.`);
+        throw new TandemError(`Pipeline start '${definition.start.id}' must be the registered participant object.`);
     }
     if (start.kind === "terminal") {
-        throw new Error(`Pipeline start '${start.id}' cannot be a terminal.`);
+        throw new TandemError(`Pipeline start '${start.id}' cannot be a terminal.`);
     }
     for (const item of definition.routes) {
         if (!members.has(item.from) || !members.has(item.to)) {
-            throw new Error(`Route '${item.label}' endpoints must be registered participant objects.`);
+            throw new TandemError(`Route '${item.label}' endpoints must be registered participant objects.`);
         }
     }
     const unconditionalRoutes = new Map();
@@ -831,22 +633,21 @@ export function pipeline(definition) {
         const key = `${item.from.id}\u0000${item.outcome ?? "default"}`;
         const existing = unconditionalRoutes.get(key);
         if (existing) {
-            throw new Error(`Routes '${existing.label}' and '${item.label}' are both unconditional from '${item.from.id}'.`);
+            throw new TandemError(`Routes '${existing.label}' and '${item.label}' are both unconditional from '${item.from.id}'.`);
         }
         unconditionalRoutes.set(key, item);
     }
     if (new Set(definition.outputs).size !== definition.outputs.length) {
-        throw new Error("Pipeline outputs must contain each terminal exactly once.");
+        throw new TandemError("Pipeline outputs must contain each terminal exactly once.");
     }
     for (const item of definition.outputs) {
         if (!members.has(item)) {
-            throw new Error(`Output '${item.id}' must be the registered participant object.`);
+            throw new TandemError(`Output '${item.id}' must be the registered participant object.`);
         }
     }
     const reachable = new Set([start]);
     const pending = [start];
-    while (pending.length > 0) {
-        const source = pending.pop();
+    for (let source = pending.pop(); source !== undefined; source = pending.pop()) {
         for (const item of definition.routes) {
             if (item.from === source && !reachable.has(item.to)) {
                 reachable.add(item.to);
@@ -857,12 +658,12 @@ export function pipeline(definition) {
     const outputs = new Set(definition.outputs);
     for (const node of reachable) {
         if (node.kind === "terminal" && !outputs.has(node)) {
-            throw new Error(`Reachable terminal '${node.id}' must be listed in outputs.`);
+            throw new TandemError(`Reachable terminal '${node.id}' must be listed in outputs.`);
         }
     }
     for (const item of definition.outputs) {
         if (!reachable.has(item)) {
-            throw new Error(`Output '${item.id}' must be reachable from start '${start.id}'.`);
+            throw new TandemError(`Output '${item.id}' must be reachable from start '${start.id}'.`);
         }
     }
     return { ...definition, persist: definition.persist ?? false };
@@ -870,65 +671,61 @@ export function pipeline(definition) {
 /** Projects an instantiated pipeline without compiling, registering, or invoking callbacks. */
 export function inspectPipeline(graph) {
     const inspectNode = (node) => {
-        const implementation = node;
-        const persist = implementation.persist;
-        if (implementation instanceof CollectionImplementation) {
-            return {
-                id: node.id,
-                kind: "collection",
-                persist,
-                max: implementation.definition.max,
-                agents: implementation.definition.agents.map((agent) => node.id + "/" + agent.id),
-            };
-        }
-        if (node.kind === "interaction") {
-            const interaction = implementation;
-            return {
-                id: node.id,
-                kind: "interaction",
-                persist,
-                interaction: {
-                    requestSchema: z.toJSONSchema(interaction.requestSchema, { io: "input" }),
-                    responseSchema: z.toJSONSchema(interaction.responseSchema, { io: "input" }),
-                },
-            };
-        }
-        if (node.kind === "agent") {
-            const agent = implementation;
-            return {
-                id: node.id,
-                kind: "agent",
-                persist,
-                agent: {
-                    capabilities: agent.granted.map((item) => ({
-                        name: item.name,
-                        requestSchema: JSON.parse(item.requestJsonSchema),
-                    })),
-                    ...(!agent.output || "raw" in agent.output
-                        ? {}
-                        : { outputSchema: z.toJSONSchema(agent.output.schema, { io: "input" }) }),
-                    workspace: agent.workspace !== undefined,
-                },
-            };
-        }
-        if (node.kind === "parallel") {
-            const parallel = implementation;
-            return {
-                id: node.id,
-                kind: "parallel",
-                persist,
-                ...(parallel.max !== undefined ? { max: parallel.max } : {}),
-                branches: Object.entries(parallel.branches).map(([id, participant]) => ({
+        const record = nodeRecord(node);
+        const { id, persist } = record;
+        switch (record.kind) {
+            case "stage":
+                return { id, kind: "stage", persist };
+            case "terminal":
+                return { id, kind: record.failed ? "failure" : "completion", persist };
+            case "collection":
+                return {
                     id,
-                    participant: inspectNode(participant),
-                })),
-            };
-        }
-        if (node.kind === "terminal") {
-            const terminal = implementation;
-            return { id: node.id, kind: terminal.failed ? "failure" : "completion", persist };
+                    kind: "collection",
+                    persist,
+                    max: record.max,
+                    agents: record.agents.map((agent) => `${id}/${agent.id}`),
+                };
+            case "interaction":
+                return {
+                    id,
+                    kind: "interaction",
+                    persist,
+                    interaction: {
+                        requestSchema: z.toJSONSchema(record.requestSchema, { io: "input" }),
+                        responseSchema: z.toJSONSchema(record.responseSchema, { io: "input" }),
+                    },
+                };
+            case "agent":
+                return {
+                    id,
+                    kind: "agent",
+                    persist,
+                    agent: {
+                        capabilities: (record.capabilities ?? []).map((item) => ({
+                            name: item.name,
+                            requestSchema: JSON.parse(item.requestJsonSchema),
+                        })),
+                        ...(!record.output || "raw" in record.output
+                            ? {}
+                            : { outputSchema: z.toJSONSchema(record.output.schema, { io: "input" }) }),
+                        workspace: record.workspace !== undefined,
+                    },
+                };
+            case "parallel":
+                return {
+                    id,
+                    kind: "parallel",
+                    persist,
+                    ...(record.max !== undefined ? { max: record.max } : {}),
+                    branches: Object.entries(record.branches).map(([branchId, participant]) => ({
+                        id: branchId,
+                        participant: inspectNode(participant),
+                    })),
+                };
+            default:
+                return record;
         }
-        return { id: node.id, kind: "stage", persist };
     };
     return {
         name: graph.name,
@@ -948,123 +745,86 @@ export function inspectPipeline(graph) {
         outputs: graph.outputs.map((item) => item.id),
     };
 }
-const runObservationSchema = z.discriminatedUnion("kind", [
-    z
-        .object({
-        version: z.literal(1),
-        kind: z.literal("stepStarted"),
-        stepId: z.string().min(1),
-        visitId: z.string().nullable().optional(),
-    })
-        .strict(),
-    z
-        .object({
-        version: z.literal(1),
-        kind: z.literal("stepCompleted"),
-        stepId: z.string().min(1),
-        visitId: z.string().nullable().optional(),
-    })
-        .strict(),
-    z
-        .object({
-        version: z.literal(1),
-        kind: z.literal("stepCancelled"),
-        stepId: z.string().min(1),
-        visitId: z.string().nullable().optional(),
-    })
-        .strict(),
-    z
-        .object({
-        version: z.literal(1),
-        kind: z.literal("stepFaulted"),
-        stepId: z.string().min(1),
-        visitId: z.string().nullable().optional(),
-        error: z.string(),
-    })
-        .strict(),
-    z
-        .object({
-        version: z.literal(1),
-        kind: z.literal("agentText"),
-        stepId: z.string().min(1),
-        visitId: z.string().nullable().optional(),
-        text: z.string(),
-    })
-        .strict(),
-    z
-        .object({
-        version: z.literal(1),
-        kind: z.literal("agentModelSelected"),
-        stepId: z.string().min(1),
-        visitId: z.string().nullable().optional(),
-        modelId: z.string().min(1),
-    })
-        .strict(),
-    z
-        .object({
-        version: z.literal(1),
-        kind: z.literal("agentReasoning"),
-        stepId: z.string().min(1),
-        visitId: z.string().nullable().optional(),
-        text: z.string(),
-    })
-        .strict(),
+const observationBase = z.object({
+    version: z.literal(1),
+    stepId: z.string().min(1),
+    visitId: z.string().nullable().optional(),
+});
+const observation = (kind, shape) => observationBase.extend({ kind: z.literal(kind), ...shape }).strict();
+const tokenCount = z.number().int().nonnegative();
+const runObservationSchema = z
+    .discriminatedUnion("kind", [
+    observation("stepStarted", {}),
+    observation("stepCompleted", {}),
+    observation("stepCancelled", {}),
+    observation("stepFaulted", { error: z.string() }),
+    observation("agentText", { text: z.string() }),
+    observation("agentReasoning", { text: z.string() }),
+    observation("agentModelSelected", { modelId: z.string().min(1) }),
+    observation("agentUsage", {
+        inputTokens: tokenCount,
+        outputTokens: tokenCount,
+        reasoningTokens: tokenCount,
+        currentContextTokens: tokenCount,
+        contextWindowTokens: tokenCount.nullable(),
+    }),
+    observation("structuredOutputRejected", {
+        attempt: z.number().int().positive(),
+        problems: z
+            .array(z
+            .object({ field: z.string(), message: z.string().min(1) })
+            .strict()
+            .readonly())
+            .readonly(),
+        rawResponse: z.string(),
+    }),
+])
+    .readonly();
+const acceptedValueFields = z
+    .object({
+    kind: z.enum([
+        "StructuredOutputAccepted",
+        "CapabilityAccepted",
+        "InteractionRequested",
+        "InteractionAnswered",
+        "StepCompleted",
+    ]),
+    stepId: z.string().min(1),
+    visitId: z.string().nullable().optional(),
+    valueType: z.string().min(1).nullable(),
+    payload: z.unknown(),
+})
+    .strict();
+const acceptedValuesSchema = z.array(acceptedValueFields.refine((value) => value.valueType !== null || value.payload !== null, {
+    message: "valueType and payload cannot both be null",
+}));
+const validationProblemsSchema = z.array(z.object({ path: z.string(), message: z.string() }).strict());
+/** How the bridge reports the end of a run; only a bridge defect rejects instead. */
+const runEnvelopeSchema = z.discriminatedUnion("status", [
     z
         .object({
-        version: z.literal(1),
-        kind: z.literal("agentUsage"),
-        stepId: z.string().min(1),
-        visitId: z.string().nullable().optional(),
-        inputTokens: z.number().int().nonnegative(),
-        outputTokens: z.number().int().nonnegative(),
-        reasoningTokens: z.number().int().nonnegative(),
-        currentContextTokens: z.number().int().nonnegative(),
-        contextWindowTokens: z.number().int().nonnegative().nullable(),
+        status: z.enum(["succeeded", "failed"]),
+        runId: z.uuid(),
+        state: z.unknown(),
+        summary: z.string().nullable(),
     })
         .strict(),
+    z.object({ status: z.literal("cancelled"), runId: z.uuid() }).strict(),
     z
         .object({
-        version: z.literal(1),
-        kind: z.literal("structuredOutputRejected"),
-        stepId: z.string().min(1),
-        visitId: z.string().nullable().optional(),
-        attempt: z.number().int().positive(),
-        problems: z.array(z.object({ field: z.string(), message: z.string().min(1) }).strict()),
-        rawResponse: z.string(),
+        status: z.literal("contract"),
+        runId: z.uuid(),
+        boundary: z.string(),
+        problems: validationProblemsSchema,
     })
         .strict(),
+    z.object({ status: z.literal("faulted"), runId: z.uuid(), message: z.string() }).strict(),
 ]);
-const acceptedKinds = [
-    "StructuredOutputAccepted",
-    "CapabilityAccepted",
-    "InteractionRequested",
-    "InteractionAnswered",
-    "StepCompleted",
-];
-const acceptedValueSchema = z
-    .object({
-    kind: z.enum(acceptedKinds),
-    visitId: z.string().nullable().optional(),
-    stepId: z.string().min(1),
-    valueType: z.string().min(1).nullable(),
-    payload: z.unknown().nullable(),
-})
-    .strict()
-    .refine((value) => value.valueType !== null || value.payload !== null, {
-    message: "valueType and payload cannot both be null",
-});
-const acceptedValuesSchema = z.array(acceptedValueSchema);
-const runResultSchema = z
-    .object({
-    runId: z.uuid(),
-    succeeded: z.boolean(),
-    state: z.unknown(),
-    summary: z.string().nullable(),
-})
-    .strict();
+/** Lazy (and cached by the module loader) so importing the authoring API never starts .NET. */
+const loadRuntime = () => import("./runtime/loader.mjs");
 export async function inspectAccepted(options) {
     try {
-        const { inspectAcceptedAsync } = await import("./runtime/loader.mjs");
+        const { inspectAcceptedAsync } = await loadRuntime();
         return parseJson(acceptedValuesSchema, await inspectAcceptedAsync(options.ledgerPath, options.runId), "accepted values").map((value) => ({
             version: 1,
             kind: value.kind,
@@ -1089,33 +849,31 @@ export async function run(graph, initial, options = {}) {
     const callbacks = new CallbackRegistry();
     try {
         const nodes = graph.nodes.map((node) => compileNode(node, graph.state, callbacks));
-        const routes = graph.routes.map((item) => {
-            const callback = item.when
-                ? callbacks.registerSync((state) => String(item.when(parseJson(graph.state, state, `route '${item.label}' state`))))
-                : undefined;
-            return {
-                source: item.from.id,
-                target: item.to.id,
-                label: item.label,
-                outcome: item.outcome,
-                predicateCallback: callback,
-            };
-        });
+        const routes = graph.routes.map(({ from, to, label, outcome, when }) => ({
+            source: from.id,
+            target: to.id,
+            label,
+            outcome,
+            predicateCallback: when
+                ? callbacks.registerSync((state) => String(when(parseJson(graph.state, state, `route '${label}' state`))))
+                : undefined,
+        }));
         const handlerEntries = interactionHandlerEntries(options.interactions);
         const members = new Set(graph.nodes);
         const interactionHandlers = handlerEntries.map((entry, index) => {
             if (!members.has(entry.interaction)) {
                 throw new TandemError(`Interaction handler '${entry.interaction.id}' must target a participant in pipeline '${graph.name}'.`);
             }
-            const implementation = entry.interaction;
+            const { id, requestSchema, responseSchema } = entry.interaction;
             const handleCallback = callbacks.registerAsync(async (_, input, signal) => {
-                const response = await entry.handle(parseJson(implementation.requestSchema, input, `${implementation.id} request input`), { signal });
+                const response = await entry.handle(parseJson(requestSchema, input, `${id} request input`), { signal });
                 signal.throwIfAborted();
-                return serializeBoundary(implementation.responseSchema, response, `${implementation.id} response`);
+                return serializeBoundary(responseSchema, response, `${id} response`);
             });
             return { id: `h${index}`, target: entry.interaction.id, handleCallback };
         });
-        const observationCallback = options.observe
+        const { observe } = options;
+        const observationCallback = observe
             ? callbacks.registerAsync(async (_, input, signal) => {
                 const event = parseJson(runObservationSchema, input, "run observation");
                 const observationSignal = options.signal?.aborted === true
@@ -1123,11 +881,11 @@ export async function run(graph, initial, options = {}) {
                     : event.kind === "stepCancelled" && !signal.aborted
                         ? AbortSignal.abort()
                         : signal;
-                await options.observe(event, { signal: observationSignal });
+                await observe(event, { signal: observationSignal });
                 return "";
             })
             : undefined;
-        const { runRegisteredGraphAsync } = await import("./runtime/loader.mjs");
+        const { runRegisteredGraphAsync } = await loadRuntime();
         const resultJson = await runRegisteredGraphAsync(JSON.stringify({
             contractVersion: 10,
             name: graph.name,
@@ -1143,21 +901,34 @@ export async function run(graph, initial, options = {}) {
             routes,
             outputs: graph.outputs.map((item) => item.id),
             interactionHandlers,
-        }), (id, state, input) => callbacks.invokeSync(id, state, input), (id, state, input, signal) => callbacks.invokeAsync(id, state, input, signal), options.signal);
-        const result = parseJson(runResultSchema, resultJson, "run result");
-        return { ...result, state: parse(graph.state, result.state, "final state") };
+        }), (id, state, input) => {
+            const result = callbacks.invoke(id, state, input, neverAborted);
+            return typeof result === "string"
+                ? result
+                : callbackFailed(new Error(`Internal callback '${id}' is asynchronous.`));
+        }, async (id, state, input, signal) => callbacks.invoke(id, state, input, signal), options.signal);
+        const envelope = parseJson(runEnvelopeSchema, resultJson, "run result");
+        switch (envelope.status) {
+            case "succeeded":
+            case "failed":
+                return {
+                    runId: envelope.runId,
+                    succeeded: envelope.status === "succeeded",
+                    state: parse(graph.state, envelope.state, "final state"),
+                    summary: envelope.summary,
+                };
+            case "cancelled":
+                throw new TandemCancellationError(new Error("The run was cancelled."));
+            case "contract":
+                throw new ContractValidationError(envelope.boundary, envelope.problems);
+            case "faulted":
+                throw new TandemRuntimeError("run", new Error(envelope.message));
+        }
     }
     catch (error) {
         if (error instanceof TandemError) {
             throw error;
         }
-        const callbackFailure = callbackContractFailure(error);
-        if (callbackFailure) {
-            throw new ContractValidationError(callbackFailure.boundary, callbackFailure.problems);
-        }
-        if (isCancellationError(error, options.signal?.aborted === true)) {
-            throw new TandemCancellationError(error);
-        }
         throw new TandemRuntimeError("run", error);
     }
     finally {
@@ -1165,27 +936,13 @@ export async function run(graph, initial, options = {}) {
     }
 }
 function participantPersists(node) {
-    const implementation = node;
-    if (implementation.persist) {
-        return true;
-    }
-    return implementation instanceof ParallelImplementation
-        ? Object.values(implementation.branches).some((branch) => branch.persist === true)
-        : false;
+    const record = nodeRecord(node);
+    return (record.persist === true ||
+        (record.kind === "parallel" && Object.values(record.branches).some(participantPersists)));
 }
 function issues(schema, input) {
-    let value;
     try {
-        value = JSON.parse(input);
-    }
-    catch {
-        return JSON.stringify([{ path: "$", message: "Invalid JSON" }]);
-    }
-    return issuesParsed(schema, value);
-}
-function issuesParsed(schema, value) {
-    try {
-        parse(schema, value, "agent contract");
+        parseJson(schema, input, "agent contract");
         return "";
     }
     catch (error) {
@@ -1195,7 +952,6 @@ function issuesParsed(schema, value) {
         throw error;
     }
 }
-const validationProblemsSchema = z.array(z.object({ path: z.string(), message: z.string() }).strict());
 function validationProblems(problems, boundary) {
     return JSON.stringify(parse(validationProblemsSchema, problems, boundary));
 }
@@ -1206,180 +962,182 @@ function requireInstructions(instructions, boundary) {
         ]);
     }
 }
+/** Authoring errors read as "<subject> <field path> <problem>", e.g. "Agent 'a' checkpoint session must be ...". */
+function parseDefinition(schema, value, subject) {
+    const result = schema.safeParse(value);
+    if (result.success) {
+        return result.data;
+    }
+    const problems = result.error.issues.map((issue) => {
+        const field = issue.path
+            .map((part) => (typeof part === "number" ? `[${part}]` : ` ${String(part)}`))
+            .join("");
+        return `${field} ${issue.message}`;
+    });
+    throw new TandemError(`${subject}${problems.join(";")}.`);
+}
 function interactionHandlerEntries(handlers) {
     if (!handlers) {
         return [];
     }
-    if (!(handlers instanceof InteractionHandlersImplementation)) {
+    const entries = registeredHandlers.get(handlers);
+    if (!entries) {
         throw new TandemError("interactions must be created by interactions().");
     }
-    return handlers.entries;
+    return entries;
 }
 function compileNode(node, stateSchema, callbacks) {
-    const implementation = node;
-    const base = { id: node.id, persist: implementation.persist };
-    if (implementation instanceof CollectionImplementation) {
-        const definition = implementation.definition;
-        const agents = definition.agents.map((value) => {
-            if (!(value instanceof TaskAgentImplementation))
-                throw new TandemError("Use taskAgent to declare collection agents.");
-            return compileNode(value.participant, value.state, callbacks);
-        });
-        const itemsCallback = callbacks.registerSync((state) => serializeBoundary(z.array(definition.item), definition.items(parseJson(stateSchema, state, node.id + " state")), node.id + " items"));
-        const runCallback = callbacks.registerAsync(async (item, scopeId, signal) => {
-            let active = false;
-            let closed = false;
-            const context = {
-                signal,
-                async run(value, input) {
-                    if (closed)
-                        throw new TandemError("Collection scope has ended.");
-                    if (active)
-                        throw new TandemError("Collection item agents must be awaited serially.");
-                    if (!definition.agents.includes(value) || !(value instanceof TaskAgentImplementation)) {
-                        throw new TandemError("Agent is not declared in this collection.");
-                    }
-                    signal.throwIfAborted();
-                    active = true;
-                    try {
-                        const { runCollectionAgentAsync } = await import("./runtime/loader.mjs");
-                        const response = await runCollectionAgentAsync(scopeId, value.id, serializeBoundary(value.state, { input, output: null }, value.id + " input"));
-                        const state = parseJson(value.state, response, value.id + " output");
-                        if (state.output === null)
-                            throw new TandemError("Agent returned no output.");
-                        return parse(value.result, state.output.value, value.id + " result");
-                    }
-                    finally {
-                        active = false;
-                    }
-                },
+    const record = nodeRecord(node);
+    const { id } = record;
+    const base = { id, persist: record.persist };
+    const parseState = (state, boundary) => parseJson(stateSchema, state, `${id} ${boundary}`);
+    switch (record.kind) {
+        case "stage":
+            return {
+                ...base,
+                kind: "stage",
+                runCallback: callbacks.registerAsync(async (state, _, signal) => serializeBoundary(stateSchema, await record.execute(parseState(state, "input"), { signal }), `${id} output`)),
             };
-            try {
-                const result = await definition.execute(parseJson(definition.item, item, node.id + " item"), context);
-                if (active)
-                    throw new TandemError("Collection item returned before its agent completed.");
-                signal.throwIfAborted();
-                return serializeBoundary(definition.result, result, node.id + " result");
-            }
-            finally {
-                closed = true;
-            }
-        });
-        const applyCallback = callbacks.registerSync((state, results) => serializeBoundary(stateSchema, definition.apply(parseJson(stateSchema, state, node.id + " state"), parseJson(z.array(definition.result), results, node.id + " results")), node.id + " output"));
-        return {
-            ...base,
-            kind: "collection",
-            agents,
-            max: definition.max,
-            itemsCallback,
-            runCallback,
-            applyCallback,
-        };
+        case "terminal":
+            return {
+                ...base,
+                kind: record.failed ? "failure" : "completion",
+                summaryCallback: callbacks.registerSync((state) => record.summary(parseState(state, "state"))),
+            };
+        case "interaction":
+            return {
+                ...base,
+                kind: "interaction",
+                requestCallback: callbacks.registerSync((state) => serializeBoundary(record.requestSchema, record.request(parseState(state, "state")), `${id} request`)),
+                applyCallback: callbacks.registerSync((state, input) => serializeBoundary(stateSchema, record.apply(parseState(state, "state"), parseJson(record.responseSchema, input, `${id} response input`)), `${id} applied state`)),
+            };
+        case "collection":
+            return compileCollection(record, stateSchema, callbacks);
+        case "agent":
+            return compileAgent(record, stateSchema, callbacks);
+        case "parallel": {
+            const branches = Object.entries(record.branches);
+            const branchStates = z.strictObject(Object.fromEntries(branches.map(([branchId]) => [branchId, stateSchema])));
+            return {
+                ...base,
+                kind: "parallel",
+                ...(record.max !== undefined ? { max: record.max } : {}),
+                branches: branches.map(([branchId, participant]) => ({
+                    id: branchId,
+                    participant: compileNode(participant, stateSchema, callbacks),
+                })),
+                mergeCallback: callbacks.registerSync((state, input) => serializeBoundary(stateSchema, record.merge(parseState(state, "merge baseline"), parseJson(branchStates, input, `${id} merge branches`)), `${id} merged state`)),
+            };
+        }
+        default:
+            return record;
     }
-    if (implementation instanceof StageImplementation) {
-        const run = callbacks.registerAsync(async (state, _, signal) => serializeBoundary(stateSchema, await implementation.execute(parseJson(stateSchema, state, `${node.id} input`), {
+}
+function compileCollection(collection, stateSchema, callbacks) {
+    const { id } = collection;
+    const agents = collection.agents.map((reference) => {
+        const task = taskAgentRecord(reference);
+        return compileNode(task.participant, task.state, callbacks);
+    });
+    const itemsCallback = callbacks.registerSync((state) => serializeBoundary(z.array(collection.item), collection.items(parseJson(stateSchema, state, `${id} state`)), `${id} items`));
+    const runCallback = callbacks.registerAsync(async (item, scopeId, signal) => {
+        let active = false;
+        let closed = false;
+        const context = {
             signal,
-        }), `${node.id} output`));
-        return { ...base, kind: "stage", runCallback: run };
-    }
-    if (implementation instanceof InteractionImplementation) {
-        const request = callbacks.registerSync((state) => serializeBoundary(implementation.requestSchema, implementation.request(parseJson(stateSchema, state, `${node.id} state`)), `${node.id} request`));
-        const apply = callbacks.registerSync((state, input) => serializeBoundary(stateSchema, implementation.apply(parseJson(stateSchema, state, `${node.id} state`), parseJson(implementation.responseSchema, input, `${node.id} response input`)), `${node.id} applied state`));
-        return {
-            ...base,
-            kind: "interaction",
-            requestCallback: request,
-            applyCallback: apply,
-        };
-    }
-    if (implementation instanceof AgentImplementation) {
-        const message = callbacks.registerSync((state) => implementation.message(parseJson(stateSchema, state, `${node.id} message state`)));
-        const output = implementation.output
-            ? compileAgentOutput(node.id, implementation.output, stateSchema, callbacks)
-            : undefined;
-        const capabilities = implementation.granted.map((item) => item[compileCapabilityBrand]({ id: node.id, stateSchema, callbacks }));
-        const workspace = implementation.workspace
-            ? compileWorkspace(node.id, implementation.workspace, stateSchema, callbacks)
-            : undefined;
-        return {
-            ...base,
-            kind: "agent",
-            instructions: implementation.instructions,
-            client: { ...implementation.client, verifyModel: implementation.client.verifyModel ?? false },
-            messageCallback: message,
-            output,
-            capabilities,
-            skillDirectories: implementation.skills.map((item) => item.directory),
-            temperature: implementation.temperature,
-            maxOutputTokens: implementation.maxOutputTokens,
-            reasoning: implementation.reasoning,
-            continueSession: implementation.continueSession,
-            checkpoint: implementation.checkpoint
-                ? {
-                    contextWindowTokens: implementation.checkpoint.contextWindowTokens,
-                    maxOutputTokens: implementation.checkpoint.maxOutputTokens,
-                    checkpointAtPercent: implementation.checkpoint.checkpointAtPercent,
-                    capabilityName: implementation.checkpoint.capability.name,
-                    instructions: implementation.checkpoint.instructions,
-                    messageCallback: callbacks.registerSync((state, input) => implementation.checkpoint.message(parseJson(stateSchema, state, `${node.id} checkpoint state`), Number(input))),
-                    resetSession: (implementation.checkpoint.session ?? "reset") === "reset",
-                    disableCompaction: implementation.checkpoint.disableCompaction ?? false,
+            async run(value, input) {
+                if (closed)
+                    throw new TandemError("Collection scope has ended.");
+                if (active)
+                    throw new TandemError("Collection item agents must be awaited serially.");
+                if (!collection.agents.includes(value)) {
+                    throw new TandemError("Agent is not declared in this collection.");
                 }
-                : undefined,
-            timeoutMilliseconds: implementation.timeoutMs,
-            workspace,
+                const task = taskAgentRecord(value);
+                signal.throwIfAborted();
+                active = true;
+                try {
+                    const { runCollectionAgentAsync } = await loadRuntime();
+                    const response = await runCollectionAgentAsync(scopeId, task.id, serializeBoundary(task.state, { input, output: null }, `${task.id} input`));
+                    const state = parseJson(task.state, response, `${task.id} output`);
+                    if (state.output === null)
+                        throw new TandemError("Agent returned no output.");
+                    return parse(task.result, state.output.value, `${task.id} result`);
+                }
+                finally {
+                    active = false;
+                }
+            },
         };
-    }
-    if (implementation instanceof ParallelImplementation) {
-        const entries = Object.entries(implementation.branches);
-        const branchIds = entries.map(([branchId]) => branchId);
-        const mergeCallback = callbacks.registerSync((state, input) => {
-            const baseline = parseJson(stateSchema, state, `${node.id} merge baseline`);
-            let raw;
-            try {
-                raw = JSON.parse(input);
-            }
-            catch {
-                throw new ContractValidationError(`${node.id} merge branches`, [
-                    { path: "$", message: "Invalid JSON" },
-                ]);
-            }
-            if (raw === null || typeof raw !== "object" || Array.isArray(raw)) {
-                throw new ContractValidationError(`${node.id} merge branches`, [
-                    { path: "$", message: "Expected a branch-state object." },
-                ]);
-            }
-            const values = raw;
-            if (!isDeepStrictEqual(Object.keys(values).sort(), [...branchIds].sort())) {
-                throw new ContractValidationError(`${node.id} merge branches`, [
-                    { path: "$", message: "Branch-state keys do not match the authored branches." },
-                ]);
+        try {
+            const result = await collection.execute(parseJson(collection.item, item, `${id} item`), context);
+            if (active)
+                throw new TandemError("Collection item returned before its agent completed.");
+            signal.throwIfAborted();
+            return serializeBoundary(collection.result, result, `${id} result`);
+        }
+        finally {
+            closed = true;
+        }
+    });
+    const applyCallback = callbacks.registerSync((state, results) => serializeBoundary(stateSchema, collection.apply(parseJson(stateSchema, state, `${id} state`), parseJson(z.array(collection.result), results, `${id} results`)), `${id} output`));
+    return {
+        id,
+        persist: collection.persist,
+        kind: "collection",
+        agents,
+        max: collection.max,
+        itemsCallback,
+        runCallback,
+        applyCallback,
+    };
+}
+function compileAgent(agent, stateSchema, callbacks) {
+    const { id, checkpoint } = agent;
+    const message = callbacks.registerSync((state) => agent.message(parseJson(stateSchema, state, `${id} message state`)));
+    const output = agent.output
+        ? compileAgentOutput(id, agent.output, stateSchema, callbacks)
+        : undefined;
+    const capabilities = (agent.capabilities ?? []).map((item) => item[compileCapabilityBrand]({ id, stateSchema, callbacks }));
+    const workspace = agent.workspace
+        ? compileWorkspace(id, agent.workspace, stateSchema, callbacks)
+        : undefined;
+    return {
+        id,
+        persist: agent.persist,
+        kind: "agent",
+        instructions: agent.instructions,
+        client: { ...agent.client, verifyModel: agent.client.verifyModel ?? false },
+        messageCallback: message,
+        output,
+        capabilities,
+        skillDirectories: (agent.skills ?? []).map((item) => item.directory),
+        temperature: agent.temperature,
+        maxOutputTokens: agent.maxOutputTokens,
+        reasoning: agent.reasoning,
+        continueSession: agent.continueSession ?? false,
+        checkpoint: checkpoint
+            ? {
+                contextWindowTokens: checkpoint.contextWindowTokens,
+                maxOutputTokens: checkpoint.maxOutputTokens,
+                checkpointAtPercent: checkpoint.checkpointAtPercent,
+                capabilityName: checkpoint.capability.name,
+                instructions: checkpoint.instructions,
+                messageCallback: callbacks.registerSync((state, input) => checkpoint.message(parseJson(stateSchema, state, `${id} checkpoint state`), Number(input))),
+                resetSession: (checkpoint.session ?? "reset") === "reset",
+                disableCompaction: checkpoint.disableCompaction ?? false,
             }
-            const parsed = Object.fromEntries(branchIds.map((branchId) => [
-                branchId,
-                parse(stateSchema, values[branchId], `${node.id} branch '${branchId}' state`),
-            ]));
-            return serializeBoundary(stateSchema, implementation.merge(baseline, parsed), `${node.id} merged state`);
-        });
-        return {
-            ...base,
-            kind: "parallel",
-            ...(implementation.max !== undefined ? { max: implementation.max } : {}),
-            branches: entries.map(([id, participant]) => ({
-                id,
-                participant: compileNode(participant, stateSchema, callbacks),
-            })),
-            mergeCallback,
-        };
-    }
-    const terminal = implementation;
-    const summary = callbacks.registerSync((state) => terminal.summary(parseJson(stateSchema, state, `${node.id} state`)));
-    return { ...base, kind: terminal.failed ? "failure" : "completion", summaryCallback: summary };
+            : undefined,
+        timeoutMilliseconds: agent.timeoutMs,
+        workspace,
+    };
 }
-function compileWorkspace(id, configuration, stateSchema, callbacks) {
-    if (!(configuration instanceof AgentWorkspaceConfigurationImplementation)) {
+function compileWorkspace(id, authored, stateSchema, callbacks) {
+    if (!("groups" in authored)) {
         throw new TandemError(`Agent '${id}' workspace must be created by agentWorkspace().withTools().`);
     }
+    // A workspace configuration is the record `withTools()` returned.
+    const configuration = authored;
     const workspace = configuration.workspace;
     const pathCallback = callbacks.registerSync((state) => {
         const value = workspace.path(parseJson(stateSchema, state, `${id} workspace path state`));
@@ -1390,18 +1148,10 @@ function compileWorkspace(id, configuration, stateSchema, callbacks) {
     });
     const commandsCallback = callbacks.registerSync((state) => {
         const typedState = parseJson(stateSchema, state, `${id} workspace commands state`);
-        const value = typeof workspace.commandSource === "function"
-            ? workspace.commandSource(typedState)
+        const commands = typeof workspace.commandSource === "function"
+            ? parseDefinition(agentCommandsSchema, workspace.commandSource(typedState), `Agent '${id}' workspace commands`)
             : (workspace.commandSource ?? []);
-        validateAgentCommands(value, `Agent '${id}' workspace commands`);
-        return serializeBoundary(z.array(z
-            .object({
-            name: z.string(),
-            description: z.string(),
-            command: z.string(),
-            arguments: z.array(z.string()).optional(),
-        })
-            .strict()), value, `${id} workspace commands`);
+        return JSON.stringify(commands);
     });
     const selected = new Set();
     const toolGroups = configuration.groups.map((group, index) => {
@@ -1429,9 +1179,10 @@ function compileWorkspace(id, configuration, stateSchema, callbacks) {
                 includeCommands = true;
             }
         }
-        const whenCallback = group.predicate
+        const { predicate } = group;
+        const whenCallback = predicate
             ? callbacks.registerSync((state) => {
-                const value = group.predicate(parseJson(stateSchema, state, `${id} tool group ${index} state`));
+                const value = predicate(parseJson(stateSchema, state, `${id} tool group ${index} state`));
                 if (typeof value !== "boolean") {
                     throw new TandemError(`Agent '${id}' tool group ${index} predicate must return a boolean.`);
                 }
@@ -1440,17 +1191,10 @@ function compileWorkspace(id, configuration, stateSchema, callbacks) {
             : undefined;
         return { tools, includeCommands, whenCallback };
     });
-    const interceptCallback = configuration.interceptTool
+    const { interceptTool } = configuration;
+    const interceptCallback = interceptTool
         ? callbacks.registerAsync(async (state, input, signal) => {
-            const typedState = parseJson(stateSchema, state, `${id} tool interception state`);
-            let invocation;
-            try {
-                invocation = JSON.parse(input);
-            }
-            catch {
-                throw new TandemError(`Agent '${id}' received an invalid tool interception payload.`);
-            }
-            const result = await configuration.interceptTool(typedState, invocation, { signal });
+            const result = await interceptTool(parseJson(stateSchema, state, `${id} tool interception state`), parseJson(agentToolInvocationSchema, input, `${id} tool interception payload`), { signal });
             if (result !== null && typeof result !== "string") {
                 throw new TandemError(`Agent '${id}' tool interceptor must return a string or null.`);
             }
@@ -1460,27 +1204,34 @@ function compileWorkspace(id, configuration, stateSchema, callbacks) {
     return { pathCallback, commandsCallback, toolGroups, interceptCallback };
 }
 function compileAgentOutput(id, output, stateSchema, callbacks) {
-    const raw = output.raw === true;
-    const validate = raw
-        ? callbacks.registerSync((_, input) => issuesParsed(z.unknown(), output.parse(JSON.parse(input))))
-        : callbacks.registerSync((_, input) => issues(output.schema, input));
-    const validateFor = output.validateFor
-        ? callbacks.registerSync((state, input) => validationProblems(output.validateFor(parseJson(stateSchema, state, `${id} state`), raw ? JSON.parse(input) : parseJson(output.schema, input, `${id} output`)), `${id} output contextual validation`))
-        : undefined;
-    const apply = callbacks.registerSync((state, input) => serializeBoundary(stateSchema, output.apply(parseJson(stateSchema, state, `${id} state`), raw ? JSON.parse(input) : parseJson(output.schema, input, `${id} output`)), `${id} applied state`));
+    let decode;
+    let format;
+    if ("raw" in output) {
+        const { parse } = output;
+        // The bridge hands back exactly the JSON that rawParseCallback produced from `parse`.
+        decode = (input) => JSON.parse(input);
+        format = {
+            raw: true,
+            rawParseCallback: callbacks.registerSync((_, input) => JSON.stringify(parse(input))),
+        };
+    }
+    else {
+        const { schema } = output;
+        decode = (input) => parseJson(schema, input, `${id} output`);
+        format = {
+            jsonSchema: inputJsonSchema(schema, `${id} output schema`),
+            validateCallback: callbacks.registerSync((_, input) => issues(schema, input)),
+        };
+    }
+    const { validateFor, apply } = output;
+    const parseState = (state) => parseJson(stateSchema, state, `${id} state`);
     return {
         instructions: output.instructions,
-        ...(raw
-            ? {
-                raw: true,
-                rawParseCallback: callbacks.registerSync((_, input) => JSON.stringify(output.parse(input))),
-            }
-            : {
-                jsonSchema: inputJsonSchema(output.schema, `${id} output schema`),
-                validateCallback: validate,
-            }),
-        validateForCallback: validateFor,
-        applyCallback: apply,
+        ...format,
+        validateForCallback: validateFor
+            ? callbacks.registerSync((state, input) => validationProblems(validateFor(parseState(state), decode(input)), `${id} output contextual validation`))
+            : undefined,
+        applyCallback: callbacks.registerSync((state, input) => serializeBoundary(stateSchema, apply(parseState(state), decode(input)), `${id} applied state`)),
         valueType: `${id}.output`,
     };
 }