@abot-ai/runtime 1.0.0

package/dist/src/runtime/orchestration/role-executors/registry.js

@@ -0,0 +1,39 @@
+import { RoleActivationLoop } from "./activation/loop.js";
+import { ChildInvocationTransaction } from "./child-invocation/transaction.js";
+export function createRoleExecutorRegistry(executors) {
+    return new RoleExecutorRuntime(executors).registry;
+}
+class RoleExecutorRuntime {
+    byRoleId;
+    roleIds;
+    registry;
+    constructor(executors) {
+        const byRoleId = new Map(executors.map((executor) => [executor.roleId, executor]));
+        if (byRoleId.size !== executors.length) {
+            throw new Error("duplicate_role_executor");
+        }
+        this.byRoleId = byRoleId;
+        this.roleIds = Object.freeze([...byRoleId.keys()]);
+        this.registry = Object.freeze({
+            roleIds: this.roleIds,
+            invokeChild: async (input) => this.invokeChild(input),
+            execute: async (input) => this.execute(input),
+        });
+    }
+    invokeChild(input) {
+        return new ChildInvocationTransaction({
+            input,
+            registeredRoleIds: this.roleIds,
+            isRoleRegistered: (roleId) => this.byRoleId.has(roleId),
+            executeRole: async (executionInput) => this.execute(executionInput),
+        }).run();
+    }
+    execute(input) {
+        return new RoleActivationLoop({
+            input,
+            registeredRoleIds: this.roleIds,
+            executorByRoleId: this.byRoleId,
+            invokeChild: async (childInput) => this.invokeChild(childInput),
+        }).run();
+    }
+}

package/dist/src/runtime/orchestration/role-executors/shared/diagnostic-context.d.ts

@@ -0,0 +1,9 @@
+import { type RoleExecutorAttemptDiagnosticContext, traceRoleExecutorResolved } from "../diagnostics.js";
+export type RoleExecutorDiagnosticContext = Parameters<typeof traceRoleExecutorResolved>[0];
+export declare function createDiagnostic(input: RoleExecutorDiagnosticContext): RoleExecutorDiagnosticContext;
+export declare function createAttemptDiagnostic(input: Readonly<{
+    requestId: unknown;
+    callId: unknown;
+    attemptedRoleId?: RoleExecutorAttemptDiagnosticContext["attemptedRoleId"];
+    registeredRoleIds: RoleExecutorAttemptDiagnosticContext["registeredRoleIds"];
+}>): RoleExecutorAttemptDiagnosticContext;

package/dist/src/runtime/orchestration/role-executors/shared/diagnostic-context.js

@@ -0,0 +1,16 @@
+export function createDiagnostic(input) {
+    return Object.freeze(input);
+}
+export function createAttemptDiagnostic(input) {
+    return Object.freeze({
+        requestIdLength: boundedAttemptLength(input.requestId),
+        callIdLength: boundedAttemptLength(input.callId),
+        ...(input.attemptedRoleId
+            ? { attemptedRoleId: input.attemptedRoleId }
+            : {}),
+        registeredRoleIds: input.registeredRoleIds,
+    });
+}
+function boundedAttemptLength(input) {
+    return typeof input === "string" ? Math.min(input.length, 257) : 0;
+}

package/dist/src/runtime/orchestration/role-executors/shared/runtime-invariants.d.ts

@@ -0,0 +1,14 @@
+import type { RoleCallFrame, RoleCallLedger, RoleCallLedgerHead } from "../../role-calls/index.js";
+import type { RoleExecutorDiagnosticContext } from "./diagnostic-context.js";
+export declare function sameCallFrame(left: RoleCallFrame, right: RoleCallFrame): boolean;
+export declare function sameCallIdentity(left: RoleCallFrame, right: RoleCallFrame): boolean;
+export declare function sameWorkerCapabilityScope(left: RoleCallFrame["workerCapabilityScope"], right: RoleCallFrame["workerCapabilityScope"]): boolean;
+export declare function sameStrings(left: readonly string[], right: readonly string[]): boolean;
+export declare function readLedgerOrReject(params: Readonly<{
+    ledger: RoleCallLedger;
+    diagnostic: RoleExecutorDiagnosticContext;
+    turnCount: number;
+}>): RoleCallLedgerHead;
+export declare function stateError(issueCode: string): Error;
+export declare function continuationError(roleId: string, issueCode: string): Error;
+export declare function childInvocationError(roleId: string, issueCode: string): Error;

package/dist/src/runtime/orchestration/role-executors/shared/runtime-invariants.js

@@ -0,0 +1,45 @@
+import { traceRoleExecutorStateRejected } from "../diagnostics.js";
+export function sameCallFrame(left, right) {
+    return (sameCallIdentity(left, right) &&
+        left.status === right.status &&
+        left.activationCount === right.activationCount);
+}
+export function sameCallIdentity(left, right) {
+    return (left.callId === right.callId &&
+        left.parentCallId === right.parentCallId &&
+        left.roleId === right.roleId &&
+        left.depth === right.depth &&
+        left.objective === right.objective &&
+        left.workingDirectory === right.workingDirectory &&
+        left.resultRef === right.resultRef &&
+        sameWorkerCapabilityScope(left.workerCapabilityScope, right.workerCapabilityScope) &&
+        sameStrings(left.dependencyResultRefs, right.dependencyResultRefs) &&
+        sameStrings(left.childCallIds, right.childCallIds));
+}
+export function sameWorkerCapabilityScope(left, right) {
+    if (left === undefined || right === undefined)
+        return left === right;
+    return sameStrings(left.catalogGroupIds, right.catalogGroupIds);
+}
+export function sameStrings(left, right) {
+    return (left.length === right.length &&
+        left.every((value, index) => value === right[index]));
+}
+export function readLedgerOrReject(params) {
+    try {
+        return params.ledger.current();
+    }
+    catch {
+        traceRoleExecutorStateRejected(params.diagnostic, "ledger_read_failed", params.turnCount);
+        throw stateError("ledger_read_failed");
+    }
+}
+export function stateError(issueCode) {
+    return new Error(`role_executor_state_invalid:${issueCode}`);
+}
+export function continuationError(roleId, issueCode) {
+    return new Error(`role_executor_continuation_invalid:${roleId}:${issueCode}`);
+}
+export function childInvocationError(roleId, issueCode) {
+    return new Error(`role_executor_child_invocation_invalid:${roleId}:${issueCode}`);
+}

package/dist/src/runtime/orchestration/roles.d.ts

@@ -0,0 +1,7 @@
+export declare const RUNTIME_ROOT_ROLE_ID: "supervisor";
+export declare const RUNTIME_DELEGATE_ROLE_IDS: readonly ["planner", "worker", "researcher", "reviewer"];
+export declare const RUNTIME_ROLE_IDS: readonly ["supervisor", "planner", "worker", "researcher", "reviewer"];
+export type RuntimeRootRoleId = typeof RUNTIME_ROOT_ROLE_ID;
+export type RuntimeDelegateRoleId = (typeof RUNTIME_DELEGATE_ROLE_IDS)[number];
+export type RuntimeRoleId = (typeof RUNTIME_ROLE_IDS)[number];
+export declare function isRuntimeDelegateRoleId(value: unknown): value is RuntimeDelegateRoleId;

package/dist/src/runtime/orchestration/roles.js

@@ -0,0 +1,15 @@
+export const RUNTIME_ROOT_ROLE_ID = "supervisor";
+export const RUNTIME_DELEGATE_ROLE_IDS = Object.freeze([
+    "planner",
+    "worker",
+    "researcher",
+    "reviewer",
+]);
+export const RUNTIME_ROLE_IDS = Object.freeze([
+    RUNTIME_ROOT_ROLE_ID,
+    ...RUNTIME_DELEGATE_ROLE_IDS,
+]);
+export function isRuntimeDelegateRoleId(value) {
+    return (typeof value === "string" &&
+        RUNTIME_DELEGATE_ROLE_IDS.includes(value));
+}

package/dist/src/runtime/orchestration/state-head.d.ts

@@ -0,0 +1,110 @@
+declare const canonicalStateHeadBrand: unique symbol;
+/**
+ * One exact, request-scoped view of canonical runtime state and policy.
+ *
+ * Public fields are immutable data for downstream projection. Write authority
+ * comes only from exact object identity with the channel that issued the head;
+ * a structural clone, cast, or head from another request has no authority.
+ */
+export type CanonicalStateHead<TKind extends string, TState extends object, TPolicy extends object> = Readonly<{
+    kind: TKind;
+    revision: number;
+    state: TState;
+    policy: TPolicy;
+    readonly [canonicalStateHeadBrand]: true;
+}>;
+export type CanonicalStateHeadCandidate<TState extends object, TPolicy extends object> = Readonly<{
+    state: TState;
+    policy: TPolicy;
+}>;
+export type CanonicalStateHeadCommitContext<TKind extends string, TState extends object, TPolicy extends object> = Readonly<{
+    previousHead: CanonicalStateHead<TKind, TState, TPolicy>;
+    head: CanonicalStateHead<TKind, TState, TPolicy>;
+}>;
+export type CanonicalStateHeadAfterCommit<TKind extends string, TState extends object, TPolicy extends object> = (context: CanonicalStateHeadCommitContext<TKind, TState, TPolicy>) => void;
+export type CanonicalStateHeadCommitFailureCode = "transaction_closed" | "invalid_candidate" | "candidate_not_frozen" | "invalid_after_commit_hook";
+export type CanonicalStateHeadCommitResult<TKind extends string, TState extends object, TPolicy extends object, TIssue> = Readonly<{
+    ok: true;
+    status: "committed";
+    previousHead: CanonicalStateHead<TKind, TState, TPolicy>;
+    head: CanonicalStateHead<TKind, TState, TPolicy>;
+}> | Readonly<{
+    ok: false;
+    status: "rejected";
+    code: CanonicalStateHeadCommitFailureCode;
+    head: CanonicalStateHead<TKind, TState, TPolicy>;
+    issues?: readonly TIssue[];
+}> | Readonly<{
+    ok: false;
+    status: "committed_with_fault";
+    code: "after_commit_fault";
+    previousHead: CanonicalStateHead<TKind, TState, TPolicy>;
+    head: CanonicalStateHead<TKind, TState, TPolicy>;
+}>;
+export type CanonicalStateHeadTransaction<TKind extends string, TState extends object, TPolicy extends object, TIssue> = Readonly<{
+    /** The exact head that passed compare-and-set admission for this callback. */
+    head: CanonicalStateHead<TKind, TState, TPolicy>;
+    /**
+     * Validates and installs one candidate synchronously. The optional hook runs
+     * after the head advances and before commit returns, so a caller may invoke
+     * commit while a narrower physical-resource lock is still held.
+     */
+    commit(candidate: CanonicalStateHeadCandidate<TState, TPolicy>, afterCommit?: CanonicalStateHeadAfterCommit<TKind, TState, TPolicy>): CanonicalStateHeadCommitResult<TKind, TState, TPolicy, TIssue>;
+}>;
+export type CanonicalStateHeadTransactionFailureCode = "invalid_transaction_request" | "invalid_expected_head" | "stale_head" | CanonicalStateHeadCommitFailureCode | "transaction_callback_fault";
+export type CanonicalStateHeadTransactionResult<T, TKind extends string, TState extends object, TPolicy extends object, TIssue> = Readonly<{
+    ok: true;
+    status: "unchanged";
+    head: CanonicalStateHead<TKind, TState, TPolicy>;
+    value: T;
+}> | Readonly<{
+    ok: true;
+    status: "committed";
+    previousHead: CanonicalStateHead<TKind, TState, TPolicy>;
+    head: CanonicalStateHead<TKind, TState, TPolicy>;
+    value: T;
+}> | Readonly<{
+    ok: false;
+    status: "rejected";
+    code: CanonicalStateHeadTransactionFailureCode;
+    head: CanonicalStateHead<TKind, TState, TPolicy>;
+    issues?: readonly TIssue[];
+}> | Readonly<{
+    ok: false;
+    status: "committed_with_fault";
+    code: "after_commit_fault" | "transaction_callback_fault";
+    previousHead: CanonicalStateHead<TKind, TState, TPolicy>;
+    head: CanonicalStateHead<TKind, TState, TPolicy>;
+}>;
+export type CanonicalStateHeadReader<TKind extends string, TState extends object, TPolicy extends object> = Readonly<{
+    current(): CanonicalStateHead<TKind, TState, TPolicy>;
+}>;
+export type CanonicalStateHeadCommitObservers<TKind extends string, TState extends object, TPolicy extends object> = Readonly<{
+    /** Registers one trusted synchronous observer for every canonical commit. */
+    subscribe(observer: CanonicalStateHeadAfterCommit<TKind, TState, TPolicy>): void;
+}>;
+export type CanonicalStateHeadWriter<TKind extends string, TState extends object, TPolicy extends object, TIssue> = Readonly<{
+    transaction<T>(input: Readonly<{
+        expectedHead: unknown;
+        run(transaction: CanonicalStateHeadTransaction<TKind, TState, TPolicy, TIssue>): Promise<T> | T;
+    }>): Promise<CanonicalStateHeadTransactionResult<T, TKind, TState, TPolicy, TIssue>>;
+}>;
+export type CanonicalStateHeadChannel<TKind extends string, TState extends object, TPolicy extends object, TIssue> = Readonly<{
+    reader: CanonicalStateHeadReader<TKind, TState, TPolicy>;
+    writer: CanonicalStateHeadWriter<TKind, TState, TPolicy, TIssue>;
+    commits: CanonicalStateHeadCommitObservers<TKind, TState, TPolicy>;
+}>;
+export type CanonicalStateHeadCompositeValidator<TState extends object, TPolicy extends object, TIssue> = (candidate: CanonicalStateHeadCandidate<TState, TPolicy>) => readonly TIssue[];
+export type CanonicalStateHeadFactory<TKind extends string, TState extends object, TPolicy extends object, TIssue> = (input: CanonicalStateHeadCandidate<TState, TPolicy>) => CanonicalStateHeadChannel<TKind, TState, TPolicy, TIssue>;
+/**
+ * Configures the shared canonical-head mechanism for one runtime state shape.
+ * The caller supplies only its compatibility kind and synchronous composite
+ * validator; compare-and-set, freezing, revision, and observer semantics stay
+ * owned here.
+ */
+export declare function createCanonicalStateHeadFactory<TKind extends string, TState extends object, TPolicy extends object, TIssue>(options: Readonly<{
+    compatibilityHeadKind: TKind;
+    validationLabel: string;
+    validateCandidate: CanonicalStateHeadCompositeValidator<TState, TPolicy, TIssue>;
+}>): CanonicalStateHeadFactory<TKind, TState, TPolicy, TIssue>;
+export {};

package/dist/src/runtime/orchestration/state-head.js

@@ -0,0 +1,349 @@
+import { consumeUnexpectedThenable } from "./synchronous-boundary.js";
+const canonicalStateHeadBrand = Symbol("CanonicalStateHead");
+/**
+ * Configures the shared canonical-head mechanism for one runtime state shape.
+ * The caller supplies only its compatibility kind and synchronous composite
+ * validator; compare-and-set, freezing, revision, and observer semantics stay
+ * owned here.
+ */
+export function createCanonicalStateHeadFactory(options) {
+    const compatibilityHeadKind = options.compatibilityHeadKind;
+    const validationLabel = options.validationLabel;
+    const validateCandidate = options.validateCandidate;
+    if (typeof compatibilityHeadKind !== "string" ||
+        !compatibilityHeadKind ||
+        typeof validationLabel !== "string" ||
+        !validationLabel ||
+        typeof validateCandidate !== "function") {
+        throw new TypeError("Invalid canonical state-head factory options.");
+    }
+    return function createCanonicalStateHead(input) {
+        const initialCandidate = captureValidatedCandidate(input, validateCandidate);
+        if (!initialCandidate.ok) {
+            throw new TypeError(`Cannot create a ${validationLabel}: ${initialCandidate.code}.`);
+        }
+        const issuedHeads = new WeakSet();
+        const commitObservers = new Set();
+        let currentHead = issueHead(compatibilityHeadKind, 0, initialCandidate.candidate.state, initialCandidate.candidate.policy, issuedHeads);
+        let writerTail = Promise.resolve();
+        const reader = Object.freeze({
+            current() {
+                return currentHead;
+            },
+        });
+        const writer = Object.freeze({
+            transaction(transactionInput) {
+                const capturedInput = captureTransactionInput(transactionInput);
+                const execute = () => executeTransaction({
+                    transactionInput: capturedInput,
+                    compatibilityHeadKind,
+                    validateCandidate,
+                    issuedHeads,
+                    readCurrent: () => currentHead,
+                    installCurrent: (head) => {
+                        currentHead = head;
+                    },
+                    commitObservers,
+                });
+                const result = writerTail.then(execute, execute);
+                writerTail = result.then(() => undefined, () => undefined);
+                return result;
+            },
+        });
+        const commits = Object.freeze({
+            subscribe(observer) {
+                if (typeof observer !== "function") {
+                    throw new TypeError("A synchronous state-head commit observer is required.");
+                }
+                commitObservers.add(observer);
+            },
+        });
+        return Object.freeze({ reader, writer, commits });
+    };
+}
+function captureTransactionInput(input) {
+    try {
+        if (typeof input !== "object" || input === null) {
+            return Object.freeze({ ok: false });
+        }
+        const expectedHead = input.expectedHead;
+        const run = input.run;
+        if (typeof run !== "function")
+            return Object.freeze({ ok: false });
+        return Object.freeze({
+            ok: true,
+            expectedHead,
+            run: run,
+        });
+    }
+    catch {
+        return Object.freeze({ ok: false });
+    }
+}
+async function executeTransaction(params) {
+    if (!params.transactionInput.ok) {
+        return rejectedTransaction("invalid_transaction_request", params.readCurrent());
+    }
+    const { expectedHead, run } = params.transactionInput;
+    if (typeof expectedHead !== "object" ||
+        expectedHead === null ||
+        !params.issuedHeads.has(expectedHead)) {
+        return rejectedTransaction("invalid_expected_head", params.readCurrent());
+    }
+    const admittedHead = params.readCurrent();
+    if (expectedHead !== admittedHead) {
+        return rejectedTransaction("stale_head", admittedHead);
+    }
+    let open = true;
+    let commitUsed = false;
+    let commitResult;
+    const transaction = Object.freeze({
+        head: admittedHead,
+        commit(candidate, afterCommit) {
+            if (!open || commitUsed) {
+                return rejectedCommit("transaction_closed", params.readCurrent());
+            }
+            commitUsed = true;
+            if (afterCommit !== undefined && typeof afterCommit !== "function") {
+                commitResult = rejectedCommit("invalid_after_commit_hook", params.readCurrent());
+                return commitResult;
+            }
+            const capturedCandidate = captureValidatedCandidate(candidate, params.validateCandidate);
+            if (!capturedCandidate.ok) {
+                commitResult = rejectedCommit(capturedCandidate.code, params.readCurrent(), capturedCandidate.issues);
+                return commitResult;
+            }
+            const previousHead = params.readCurrent();
+            const head = issueHead(params.compatibilityHeadKind, previousHead.revision + 1, capturedCandidate.candidate.state, capturedCandidate.candidate.policy, params.issuedHeads);
+            params.installCurrent(head);
+            let postCommitFault = false;
+            const context = Object.freeze({ previousHead, head });
+            for (const observer of [...params.commitObservers]) {
+                try {
+                    const observerResult = observer(context);
+                    if (consumeUnexpectedThenable(observerResult)) {
+                        postCommitFault = true;
+                    }
+                }
+                catch {
+                    postCommitFault = true;
+                }
+            }
+            if (afterCommit) {
+                try {
+                    const hookResult = afterCommit(context);
+                    if (consumeUnexpectedThenable(hookResult)) {
+                        postCommitFault = true;
+                    }
+                }
+                catch {
+                    postCommitFault = true;
+                }
+            }
+            if (postCommitFault) {
+                commitResult = Object.freeze({
+                    ok: false,
+                    status: "committed_with_fault",
+                    code: "after_commit_fault",
+                    previousHead,
+                    head,
+                });
+                return commitResult;
+            }
+            commitResult = Object.freeze({
+                ok: true,
+                status: "committed",
+                previousHead,
+                head,
+            });
+            return commitResult;
+        },
+    });
+    let value;
+    try {
+        value = await run(transaction);
+    }
+    catch {
+        open = false;
+        if (commitResult?.status === "committed") {
+            return Object.freeze({
+                ok: false,
+                status: "committed_with_fault",
+                code: "transaction_callback_fault",
+                previousHead: commitResult.previousHead,
+                head: commitResult.head,
+            });
+        }
+        if (commitResult?.status === "committed_with_fault") {
+            return commitResult;
+        }
+        return rejectedTransaction("transaction_callback_fault", params.readCurrent());
+    }
+    open = false;
+    if (!commitResult) {
+        return Object.freeze({
+            ok: true,
+            status: "unchanged",
+            head: admittedHead,
+            value,
+        });
+    }
+    if (commitResult.status === "rejected") {
+        return Object.freeze({
+            ok: false,
+            status: "rejected",
+            code: commitResult.code,
+            head: commitResult.head,
+            ...(commitResult.issues ? { issues: commitResult.issues } : {}),
+        });
+    }
+    if (commitResult.status === "committed_with_fault") {
+        return commitResult;
+    }
+    return Object.freeze({
+        ok: true,
+        status: "committed",
+        previousHead: commitResult.previousHead,
+        head: commitResult.head,
+        value,
+    });
+}
+function issueHead(compatibilityHeadKind, revision, state, policy, issuedHeads) {
+    const head = Object.freeze({
+        kind: compatibilityHeadKind,
+        revision,
+        state,
+        policy,
+        [canonicalStateHeadBrand]: true,
+    });
+    issuedHeads.add(head);
+    return head;
+}
+function captureValidatedCandidate(value, validateCandidate) {
+    try {
+        const candidate = captureCandidateDescriptorValues(value);
+        if (!candidate) {
+            return Object.freeze({ ok: false, code: "invalid_candidate" });
+        }
+        if (!isRecursivelyFrozenData(candidate.state) ||
+            !isRecursivelyFrozenData(candidate.policy)) {
+            return Object.freeze({
+                ok: false,
+                code: "candidate_not_frozen",
+            });
+        }
+        const issues = validateCandidate(candidate);
+        if (!Array.isArray(issues)) {
+            return Object.freeze({ ok: false, code: "invalid_candidate" });
+        }
+        if (issues.length > 0) {
+            return Object.freeze({
+                ok: false,
+                code: "invalid_candidate",
+                issues: Object.freeze([...issues]),
+            });
+        }
+        return Object.freeze({ ok: true, candidate });
+    }
+    catch {
+        return Object.freeze({ ok: false, code: "invalid_candidate" });
+    }
+}
+function captureCandidateDescriptorValues(value) {
+    if (typeof value !== "object" || value === null || Array.isArray(value)) {
+        return undefined;
+    }
+    try {
+        const prototype = Object.getPrototypeOf(value);
+        if (prototype !== Object.prototype && prototype !== null)
+            return undefined;
+        const descriptors = Object.getOwnPropertyDescriptors(value);
+        const keys = Reflect.ownKeys(descriptors);
+        if (keys.length !== 2 ||
+            !keys.includes("state") ||
+            !keys.includes("policy")) {
+            return undefined;
+        }
+        const state = descriptors.state;
+        const policy = descriptors.policy;
+        if (!state ||
+            !("value" in state) ||
+            !state.enumerable ||
+            !policy ||
+            !("value" in policy) ||
+            !policy.enumerable) {
+            return undefined;
+        }
+        return Object.freeze({
+            state: state.value,
+            policy: policy.value,
+        });
+    }
+    catch {
+        return undefined;
+    }
+}
+function isRecursivelyFrozenData(value, visiting = new WeakSet(), validated = new WeakSet()) {
+    if (value === null ||
+        typeof value === "string" ||
+        typeof value === "number" ||
+        typeof value === "boolean" ||
+        typeof value === "undefined") {
+        return true;
+    }
+    if (typeof value !== "object")
+        return false;
+    if (validated.has(value))
+        return true;
+    if (visiting.has(value))
+        return false;
+    visiting.add(value);
+    try {
+        if (!Object.isFrozen(value))
+            return false;
+        const prototype = Object.getPrototypeOf(value);
+        if (!Array.isArray(value) &&
+            prototype !== Object.prototype &&
+            prototype !== null) {
+            return false;
+        }
+        const descriptors = Object.getOwnPropertyDescriptors(value);
+        const valid = Reflect.ownKeys(descriptors).every((key) => {
+            if (Array.isArray(value) && key === "length")
+                return true;
+            if (typeof key !== "string")
+                return false;
+            const descriptor = descriptors[key];
+            return (Boolean(descriptor) &&
+                "value" in descriptor &&
+                isRecursivelyFrozenData(descriptor.value, visiting, validated));
+        });
+        if (valid)
+            validated.add(value);
+        return valid;
+    }
+    catch {
+        return false;
+    }
+    finally {
+        visiting.delete(value);
+    }
+}
+function rejectedCommit(code, head, issues) {
+    return Object.freeze({
+        ok: false,
+        status: "rejected",
+        code,
+        head,
+        ...(issues ? { issues } : {}),
+    });
+}
+function rejectedTransaction(code, head, issues) {
+    return Object.freeze({
+        ok: false,
+        status: "rejected",
+        code,
+        head,
+        ...(issues ? { issues } : {}),
+    });
+}

package/dist/src/runtime/orchestration/synchronous-boundary.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Observes an unexpected thenable at a synchronous orchestration boundary.
+ * Rejection handlers are attached immediately so the boundary can fail closed
+ * without leaking an unhandled rejection into the process.
+ */
+export declare function consumeUnexpectedThenable(value: unknown): boolean;

package/dist/src/runtime/orchestration/synchronous-boundary.js

@@ -0,0 +1,26 @@
+/**
+ * Observes an unexpected thenable at a synchronous orchestration boundary.
+ * Rejection handlers are attached immediately so the boundary can fail closed
+ * without leaking an unhandled rejection into the process.
+ */
+export function consumeUnexpectedThenable(value) {
+    if (!((typeof value === "object" && value !== null) ||
+        typeof value === "function")) {
+        return false;
+    }
+    try {
+        const then = value.then;
+        if (typeof then !== "function")
+            return false;
+        try {
+            Reflect.apply(then, value, [() => undefined, () => undefined]);
+        }
+        catch {
+            // The owning synchronous boundary reports the fault to its caller.
+        }
+        return true;
+    }
+    catch {
+        return true;
+    }
+}

package/dist/src/runtime/orchestration/worker-capabilities/binding.d.ts

@@ -0,0 +1,13 @@
+import { type RoleCallDependencyResult, type RoleCallFrame, type RoleCallLedger } from "../role-calls/index.js";
+import { type WorkerCapabilityAdapter, type WorkerCapabilityBinding, type WorkerCapabilityExecutionFreshness } from "./contracts.js";
+export declare function createRoleCapabilityBinding<TContext>(params: {
+    requestId: string;
+    context: TContext;
+    call: RoleCallFrame;
+    ledger: RoleCallLedger;
+    adapters: readonly WorkerCapabilityAdapter<TContext>[];
+    dependencyResults?: readonly RoleCallDependencyResult[];
+    executionFreshness?: WorkerCapabilityExecutionFreshness;
+}): WorkerCapabilityBinding<TContext>;
+/** Compatibility name for the existing Worker contract and focused callers. */
+export declare const createWorkerCapabilityBinding: typeof createRoleCapabilityBinding;