@cotal-ai/lang 0.24.0 → 0.25.0

package/README.md

@@ -8,6 +8,17 @@ implements, and the simulator and dry run that exercise a program with no broker
 **Tier:** `packages/` (the standard). Depends on nothing else in the repo; it knows about effects,
 not about NATS. The host that runs a program on the mesh is `@cotal-ai/runtime`.
 
+**Two engines.** `run`/`resume` are the tree-walker, language version `1`, and it stays the replay
+engine for every run recorded under it. `engine/` is version `2`: a different language, not a faster
+one, and the one fresh driver runs execute on. Each engine stamps the pins it resolves with its own
+version and compares a recorded version against its own, which is why `WALKER_LANGUAGE_VERSION` and
+`ENGINE_LANGUAGE_VERSION` are two constants and `LANGUAGE_VERSION` is an alias for the current
+language, the engine's. A record binds only under the engine that wrote it (L5008). The engine
+requires node 22 or newer and refuses below it with L1000, an implementation limit that is
+deliberately not in the error catalog. A host runs a program in the engine's worker thread with the
+handler either built inside it from cloneable config, or — when the handler is a live object, as a
+driver's is — kept in the host with the effect seam bridged over a message port (`engine/bridge.ts`).
+
 The language is defined by [`spec/cotal-lang.md`](../../spec/cotal-lang.md) (normative; every
 `js` block in it is validated by this package's surface suite) and its wire footprint by
 [SPEC.md §14](../../SPEC.md#14-workflow-runs-v05). The guide is

package/dist/engine/bridge.d.ts

@@ -0,0 +1,71 @@
+/**
+ * The effect bridge: a run in the worker, its effects and its durable journal in the host.
+ *
+ * The module-named handler in `worker.ts` builds the whole effect path inside the thread, which is
+ * right when a handler CAN be built from cloneable config. A driver's handler cannot: it is a live
+ * object holding sockets, a mesh client and a lease-bound journal appender, and shipping any of
+ * that into the isolate that also holds the hostile program would put credentials one Compartment
+ * escape away from the code they exist to confine. This module is the other route: the handler and
+ * the durable store STAY IN THE HOST, and the thread forwards the seam over a MessagePort.
+ *
+ * WHY THIS IS SOUND, measured against the contracts rather than assumed: the durable half of the
+ * journal is `JournalStore.append(entry): Promise<void>`, awaited by `Journal.persist` before a
+ * key joins `order` and before any effect fires — an async contract, which a port hop preserves
+ * with the awaits lining up exactly as they line up over a PubAck today. Every `EffectHandler`
+ * member except `now()` is async for the same reason. What is genuinely synchronous is `now()`
+ * (a journal stamp) and the stop flag, and both go over shared memory: the stop buffer as it
+ * always has, the clock over a dedicated SharedArrayBuffer this module owns — post the request,
+ * `Atomics.wait`, read the answer. The handler's clock is injectable, so the bridge may not
+ * shortcut it with the thread's own `Date.now()`: a simulated clock bridged that way would run a
+ * program under two disagreeing times.
+ *
+ * WHAT CROSSES, and why every crossing is already fenced: effect requests, effect results, journal
+ * entries, a failure's `code`/`kind`/`message`/`detail`, and a bind's `external` — exactly the
+ * values the journal records, which the crossing rule (values.ts) fences at their write sites.
+ * Errors cross with their DOMAIN, because perform.ts grades the two domains differently: the host
+ * side stamps `"effect"` for an `EffectError` and `"host"` for anything else, and the thread
+ * rehydrates the real class so a bridged failure journals byte-for-byte as an in-process one.
+ *
+ * TWO CALLS RUN AGAINST THE ARROW, and both are part of the handler's contract rather than
+ * optional extras: `ctx.bind(external)` (the handler declaring the resource it just created —
+ * host → thread, because the journal it must reach lives in the thread; its durable append then
+ * comes straight back out to the host's store) and `signal.onCancel` (a race loser's cancellation
+ * — thread → host, fired at the mirror the host handler was given). The host never blocks its
+ * loop, which is what makes the one blocking wait in the thread safe: a `now()` posted while the
+ * host is mid-effect is answered by the port handler immediately, from a synchronous clock.
+ */
+import type { MessagePort } from "node:worker_threads";
+import type { EffectHandler } from "../effects.js";
+import type { JournalStore } from "../journal.js";
+/** One 16-byte SharedArrayBuffer: an Int32 answer flag at 0, the Float64 clock value at 8. */
+export declare const CLOCK_BYTES = 16;
+/**
+ * THE THREAD'S HALF: an {@link EffectHandler} and a {@link JournalStore} over the port.
+ *
+ * Owned by the worker entry. The live `EffectContext` of every in-flight effect is kept by `seq`
+ * so a host-initiated `bind` reaches the real context (and through it, the real journal), and so
+ * a cancellation fires at the host the moment the thread's signal fires.
+ */
+export declare function bridgedSeam(port: MessagePort, clock: SharedArrayBuffer): {
+    handler: EffectHandler;
+    store: JournalStore;
+};
+export interface BridgeHost {
+    /** The buffer the thread's `now()` blocks on; hand it to the worker beside the port. */
+    readonly clock: SharedArrayBuffer;
+    /** Stop servicing. Called once the run has answered; a message after that has no run behind it. */
+    close(): void;
+}
+/**
+ * THE HOST'S HALF: service the thread's seam from a live handler and a live store.
+ *
+ * The context handed to the handler is rebuilt around the wire's plain data: `bind` forwards to
+ * the thread (where the journal lives) and its durable append comes back through `store.append`
+ * on this side; `signal` is a mirror the thread's cancellations flip. The host never blocks —
+ * every branch here either answers from a synchronous clock or awaits work it already owns.
+ */
+export declare function serviceBridge(port: MessagePort, seam: {
+    readonly handler: EffectHandler;
+    readonly store: JournalStore;
+}): BridgeHost;
+//# sourceMappingURL=bridge.d.ts.map

package/dist/engine/bridge.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"bridge.d.ts","sourceRoot":"","sources":["../../src/engine/bridge.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAmCG;AAEH,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,qBAAqB,CAAC;AACvD,OAAO,KAAK,EAAiB,aAAa,EAAE,MAAM,eAAe,CAAC;AAElE,OAAO,KAAK,EAAgB,YAAY,EAAE,MAAM,eAAe,CAAC;AAGhE,8FAA8F;AAC9F,eAAO,MAAM,WAAW,KAAK,CAAC;AAuF9B;;;;;;GAMG;AACH,wBAAgB,WAAW,CAAC,IAAI,EAAE,WAAW,EAAE,KAAK,EAAE,iBAAiB,GAAG;IAAE,OAAO,EAAE,aAAa,CAAC;IAAC,KAAK,EAAE,YAAY,CAAA;CAAE,CA+ExH;AAED,MAAM,WAAW,UAAU;IACzB,wFAAwF;IACxF,QAAQ,CAAC,KAAK,EAAE,iBAAiB,CAAC;IAClC,mGAAmG;IACnG,KAAK,IAAI,IAAI,CAAC;CACf;AAED;;;;;;;GAOG;AACH,wBAAgB,aAAa,CAAC,IAAI,EAAE,WAAW,EAAE,IAAI,EAAE;IAAE,QAAQ,CAAC,OAAO,EAAE,aAAa,CAAC;IAAC,QAAQ,CAAC,KAAK,EAAE,YAAY,CAAA;CAAE,GAAG,UAAU,CAkGpI"}

package/dist/engine/bridge.js

@@ -0,0 +1,277 @@
+/**
+ * The effect bridge: a run in the worker, its effects and its durable journal in the host.
+ *
+ * The module-named handler in `worker.ts` builds the whole effect path inside the thread, which is
+ * right when a handler CAN be built from cloneable config. A driver's handler cannot: it is a live
+ * object holding sockets, a mesh client and a lease-bound journal appender, and shipping any of
+ * that into the isolate that also holds the hostile program would put credentials one Compartment
+ * escape away from the code they exist to confine. This module is the other route: the handler and
+ * the durable store STAY IN THE HOST, and the thread forwards the seam over a MessagePort.
+ *
+ * WHY THIS IS SOUND, measured against the contracts rather than assumed: the durable half of the
+ * journal is `JournalStore.append(entry): Promise<void>`, awaited by `Journal.persist` before a
+ * key joins `order` and before any effect fires — an async contract, which a port hop preserves
+ * with the awaits lining up exactly as they line up over a PubAck today. Every `EffectHandler`
+ * member except `now()` is async for the same reason. What is genuinely synchronous is `now()`
+ * (a journal stamp) and the stop flag, and both go over shared memory: the stop buffer as it
+ * always has, the clock over a dedicated SharedArrayBuffer this module owns — post the request,
+ * `Atomics.wait`, read the answer. The handler's clock is injectable, so the bridge may not
+ * shortcut it with the thread's own `Date.now()`: a simulated clock bridged that way would run a
+ * program under two disagreeing times.
+ *
+ * WHAT CROSSES, and why every crossing is already fenced: effect requests, effect results, journal
+ * entries, a failure's `code`/`kind`/`message`/`detail`, and a bind's `external` — exactly the
+ * values the journal records, which the crossing rule (values.ts) fences at their write sites.
+ * Errors cross with their DOMAIN, because perform.ts grades the two domains differently: the host
+ * side stamps `"effect"` for an `EffectError` and `"host"` for anything else, and the thread
+ * rehydrates the real class so a bridged failure journals byte-for-byte as an in-process one.
+ *
+ * TWO CALLS RUN AGAINST THE ARROW, and both are part of the handler's contract rather than
+ * optional extras: `ctx.bind(external)` (the handler declaring the resource it just created —
+ * host → thread, because the journal it must reach lives in the thread; its durable append then
+ * comes straight back out to the host's store) and `signal.onCancel` (a race loser's cancellation
+ * — thread → host, fired at the mirror the host handler was given). The host never blocks its
+ * loop, which is what makes the one blocking wait in the thread safe: a `now()` posted while the
+ * host is mid-effect is answered by the port handler immediately, from a synchronous clock.
+ */
+import { EffectError } from "../effects.js";
+/** One 16-byte SharedArrayBuffer: an Int32 answer flag at 0, the Float64 clock value at 8. */
+export const CLOCK_BYTES = 16;
+/** The ten async members of {@link EffectHandler}, the only methods the bridge will forward. */
+const METHODS = [
+    "spawn",
+    "turn",
+    "ask",
+    "checkpoint",
+    "sleep",
+    "wait",
+    "notify",
+    "monitor",
+    "openConclave",
+    "closeConclave",
+];
+function flatten(e) {
+    if (e instanceof EffectError) {
+        return {
+            domain: "effect",
+            name: e.name,
+            message: e.message,
+            code: e.code,
+            kind: e.kind,
+            ...(e.detail !== undefined ? { detail: e.detail } : {}),
+        };
+    }
+    const err = e;
+    return {
+        domain: "host",
+        name: typeof err?.name === "string" ? err.name : "Error",
+        message: typeof err?.message === "string" ? err.message : String(e),
+        ...(typeof err?.code === "string" ? { code: err.code } : {}),
+        ...(err?.indeterminate === true ? { indeterminate: true } : {}),
+    };
+}
+/**
+ * The thread's side of a flattened error, as the class the grading site expects.
+ *
+ * An `"effect"` failure becomes the real `EffectError`, because perform.ts records it as the
+ * step's outcome; a `"host"` failure becomes a plain Error carrying whatever identifying fields
+ * crossed, because the host domain is graded on shape, not class, and `indeterminate` must survive
+ * for the journal's L5010 text to say the honest thing about an append nobody saw land.
+ */
+function rehydrate(w) {
+    if (w.domain === "effect")
+        return new EffectError(w.code ?? "L4000", w.kind ?? "handler-fault", w.message, w.detail);
+    const e = new Error(w.message);
+    e.name = w.name;
+    if (w.code !== undefined)
+        e.code = w.code;
+    if (w.indeterminate === true)
+        e.indeterminate = true;
+    return e;
+}
+/**
+ * THE THREAD'S HALF: an {@link EffectHandler} and a {@link JournalStore} over the port.
+ *
+ * Owned by the worker entry. The live `EffectContext` of every in-flight effect is kept by `seq`
+ * so a host-initiated `bind` reaches the real context (and through it, the real journal), and so
+ * a cancellation fires at the host the moment the thread's signal fires.
+ */
+export function bridgedSeam(port, clock) {
+    const flag = new Int32Array(clock, 0, 1);
+    const value = new Float64Array(clock, 8, 1);
+    let seq = 0;
+    const pending = new Map();
+    const live = new Map();
+    port.on("message", (m) => {
+        if (m.kind === "answer") {
+            const p = pending.get(m.seq);
+            // An answer nobody is waiting for is a protocol disagreement, not a value to drop quietly.
+            if (p === undefined)
+                throw new Error(`cotal-lang effect bridge: the host answered seq ${m.seq}, which this thread never asked`);
+            pending.delete(m.seq);
+            live.delete(m.seq);
+            if (m.ok)
+                p.resolve(m.value);
+            else
+                p.reject(rehydrate(m.error));
+            return;
+        }
+        if (m.kind === "bind") {
+            const ctx = live.get(m.seq);
+            if (ctx === undefined) {
+                // The effect settled between the handler's bind and this message arriving. The handler's
+                // own await of `bind` is what carries the refusal; answering is all this side can do.
+                port.postMessage({ kind: "bind-answer", bseq: m.bseq, error: { domain: "host", name: "Error", message: `effect ${m.seq} is no longer in flight; its bind cannot reach the journal` } });
+                return;
+            }
+            void ctx.bind(m.external).then(() => port.postMessage({ kind: "bind-answer", bseq: m.bseq }), (e) => port.postMessage({ kind: "bind-answer", bseq: m.bseq, error: flatten(e) }));
+            return;
+        }
+        throw new Error(`cotal-lang effect bridge: the host sent a message kind this thread does not know (${String(m.kind)})`);
+    });
+    const call = (method, req, ctx) => {
+        const s = seq++;
+        live.set(s, ctx);
+        ctx.signal.onCancel((reason) => port.postMessage({ kind: "cancel", seq: s, reason }));
+        const answer = new Promise((resolve, reject) => pending.set(s, { resolve, reject }));
+        port.postMessage({
+            kind: "effect",
+            seq: s,
+            method,
+            req,
+            ctx: {
+                key: ctx.key,
+                requestId: ctx.requestId,
+                attempt: ctx.attempt,
+                ...(ctx.resume !== undefined ? { resume: ctx.resume } : {}),
+            },
+        });
+        return answer;
+    };
+    const handler = {
+        // The flag is cleared BEFORE the request is posted, so a host that answers before this thread
+        // reaches the wait leaves the flag already flipped and the wait returns "not-equal" at once.
+        now() {
+            Atomics.store(flag, 0, 0);
+            port.postMessage({ kind: "now" });
+            Atomics.wait(flag, 0, 0);
+            return value[0];
+        },
+    };
+    for (const m of METHODS) {
+        handler[m] = (req, ctx) => call(m, req, ctx);
+    }
+    const store = {
+        append(entry) {
+            const s = seq++;
+            const answer = new Promise((resolve, reject) => pending.set(s, { resolve: () => resolve(), reject }));
+            port.postMessage({ kind: "append", seq: s, entry });
+            return answer;
+        },
+    };
+    return { handler, store };
+}
+/**
+ * THE HOST'S HALF: service the thread's seam from a live handler and a live store.
+ *
+ * The context handed to the handler is rebuilt around the wire's plain data: `bind` forwards to
+ * the thread (where the journal lives) and its durable append comes back through `store.append`
+ * on this side; `signal` is a mirror the thread's cancellations flip. The host never blocks —
+ * every branch here either answers from a synchronous clock or awaits work it already owns.
+ */
+export function serviceBridge(port, seam) {
+    const clock = new SharedArrayBuffer(CLOCK_BYTES);
+    const flag = new Int32Array(clock, 0, 1);
+    const value = new Float64Array(clock, 8, 1);
+    let bseq = 0;
+    const binds = new Map();
+    const cancels = new Map();
+    port.on("message", (m) => {
+        if (m.kind === "now") {
+            value[0] = seam.handler.now();
+            Atomics.store(flag, 0, 1);
+            Atomics.notify(flag, 0);
+            return;
+        }
+        if (m.kind === "append") {
+            void seam.store.append(m.entry).then(() => port.postMessage({ kind: "answer", seq: m.seq, ok: true, value: undefined }), (e) => port.postMessage({ kind: "answer", seq: m.seq, ok: false, error: flatten(e) }));
+            return;
+        }
+        if (m.kind === "effect") {
+            const seqHere = m.seq;
+            let cancelled = false;
+            let reason;
+            const listeners = [];
+            cancels.set(seqHere, {
+                fire: (r) => {
+                    cancelled = true;
+                    reason = r;
+                    for (const fn of listeners)
+                        fn(r);
+                },
+            });
+            const ctx = {
+                key: m.ctx.key,
+                requestId: m.ctx.requestId,
+                attempt: m.ctx.attempt,
+                ...(m.ctx.resume !== undefined ? { resume: m.ctx.resume } : {}),
+                signal: {
+                    get cancelled() {
+                        return cancelled;
+                    },
+                    get reason() {
+                        return reason;
+                    },
+                    onCancel(fn) {
+                        listeners.push(fn);
+                    },
+                },
+                bind: (external) => {
+                    const b = bseq++;
+                    const answer = new Promise((resolve, reject) => binds.set(b, { resolve, reject }));
+                    port.postMessage({ kind: "bind", bseq: b, seq: seqHere, external });
+                    return answer;
+                },
+            };
+            const method = seam.handler[m.method];
+            // The method set is this module's own constant, so an unknown name is the two sides
+            // disagreeing about the protocol — refused as an answer, never dispatched dynamically.
+            if (!METHODS.includes(m.method) || typeof method !== "function") {
+                port.postMessage({ kind: "answer", seq: seqHere, ok: false, error: { domain: "host", name: "Error", message: `the effect bridge does not forward "${String(m.method)}"` } });
+                cancels.delete(seqHere);
+                return;
+            }
+            void method.call(seam.handler, m.req, ctx).then((v) => {
+                cancels.delete(seqHere);
+                port.postMessage({ kind: "answer", seq: seqHere, ok: true, value: v });
+            }, (e) => {
+                cancels.delete(seqHere);
+                port.postMessage({ kind: "answer", seq: seqHere, ok: false, error: flatten(e) });
+            });
+            return;
+        }
+        if (m.kind === "cancel") {
+            // A cancel finds its mirror only while the effect is in flight: the answer deletes the
+            // mirror, so the walker's post-settle blanket cancellations (aimed at arms that already
+            // returned) do not cross. Deliberate, and pinned by the engine suite's parked-loser cells:
+            // the host handler hears a cancel exactly when its effect is still open, which is the only
+            // time it can act on one.
+            cancels.get(m.seq)?.fire(m.reason);
+            return;
+        }
+        if (m.kind === "bind-answer") {
+            const b = binds.get(m.bseq);
+            if (b === undefined)
+                throw new Error(`cotal-lang effect bridge: the thread answered bind ${m.bseq}, which this host never asked`);
+            binds.delete(m.bseq);
+            if (m.error === undefined)
+                b.resolve();
+            else
+                b.reject(rehydrate(m.error));
+            return;
+        }
+        throw new Error(`cotal-lang effect bridge: the thread sent a message kind this host does not know (${String(m.kind)})`);
+    });
+    return { clock, close: () => port.close() };
+}
+//# sourceMappingURL=bridge.js.map

package/dist/engine/bridge.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"bridge.js","sourceRoot":"","sources":["../../src/engine/bridge.ts"],"names":[],"mappings":"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"}

package/dist/engine/ctx.d.ts

@@ -0,0 +1,140 @@
+/**
+ * `__ctx`: the WHOLE seam between the transformed program and the host.
+ *
+ * The transform emits a CLOSED function expression with zero free identifiers; the host
+ * evaluates it in a Compartment with ZERO endowments and passes this object as the call argument
+ * (the seam contract). So this file is the complete list of what a program can reach. Anything not
+ * here is not reachable, which is why the member list is a surface both sides hold each other to.
+ *
+ * Every law lives here, and every table it needs is IMPORTED. `library.ts` owns the curated method
+ * tables and the free builtins; `values.ts` owns freezing, birth-depth stamping and the crossing
+ * check; `keys.ts` owns key allocation; `journal.ts` owns the entries. Nothing in this file is a
+ * second copy of any of them: a copied table is a table that disagrees with the walker on its
+ * first edit, and the walker is the differential oracle.
+ *
+ * WHAT THIS FILE IS NOT: it is not the walker rewritten. The walker enforces these laws inline
+ * while it walks; here they are the host side of a native program's calls. The behaviours must be
+ * identical and the differential suite is what says so: same programs, walker and engine,
+ * identical journals (entry sequences and step keys, not merely output).
+ */
+import { type EffectHandler } from "../effects.js";
+import type { Journal } from "../journal.js";
+import type { RunPins } from "../pins.js";
+/**
+ * A static per-call-site payload the transform computes from the input AST.
+ *
+ * It exists because the engine has NO AST at run time and one journal field is a function of one:
+ * a settled `race` records a `branchDigest` over its unwalked arms. Without this the engine could
+ * not produce a byte-identical entry for any race that settled, and the differential gate would
+ * fail on shape rather than on behaviour.
+ */
+export interface Site {
+    /** Branch key -> `digest(stripPositions(armBody))`, computed with the walker's own functions. */
+    readonly branchDigests?: Readonly<Record<string, unknown>>;
+}
+/**
+ * The seam. Fourteen members, and the count is the point: a member added here without a joint rule
+ * is a widening, and the transform's surface cell reddens on any call to a name not on this
+ * interface. Thirteen came with the seam contract; `callee` is the fourteenth, added under the
+ * adaptation invariant below.
+ */
+export interface EngineCtx {
+    /** L4013 step budget, plus the yield that keeps the macrotask queue alive and applies the cut. */
+    fuel(): void | Promise<void>;
+    /**
+     * Read a member: L4014 (no prototype reach, curated tables), L4020, L4018 on a computed key.
+     *
+     * `binding` is the cell read, taken as a third argument rather than a fifteenth member. A binding
+     * the transform classified as a CELL is emitted as `get(cell, "v", "x")`, and an absent OWN key
+     * means the declaration has not run yet, which is L2004 for that binding by name. PRESENCE is
+     * `hasOwn` and not truthiness, because `v: undefined` is a binding that HAS been initialised, to
+     * undefined. Without the argument, `get` is byte-unchanged.
+     */
+    get(o: unknown, k: unknown, binding?: string): unknown;
+    /**
+     * Write a member: L2031, L2032, L4014, L4017, L4019. Answers `v`, as an assignment does.
+     *
+     * `binding` is the cell WRITE, taken as a fourth argument for the same reason `get` took a third.
+     * It is present ONLY on an ASSIGNMENT to a cell, never on the declaration's own initialising write,
+     * and an absent OWN key there means the declaration has not run: L2004 naming the binding, in the
+     * walker's assignment words, which are not the read's. The key is LEFT ABSENT by the refusal, so
+     * the declaration that has not run yet still initialises the binding when it does.
+     */
+    set(o: unknown, k: unknown, v: unknown, binding?: string): unknown;
+    /**
+     * Call a member. The single L4020 exception: a method is resolved AT the call and nowhere else.
+     *
+     * `optional` is `o.m?.()`, a flag rather than a fifteenth member. It guards a
+     * NULLISH MEMBER and nothing else (measured on the walker, `?.` softens neither L4014 nor L4011),
+     * and a short-circuited call evaluates NO ARGUMENT, which is why the optional form takes a thunk.
+     *
+     * `chain` is EVERYTHING WRITTEN AFTER the optional call, as a closure. A short-circuit swallows the
+     * whole rest of the chain, and only the host knows a short-circuit happened: measured, `o.z?.().x`
+     * on an absent member is `undefined` while `o.m?.().x` on a member that RETURNS undefined is L4010,
+     * and a guard on the returned value cannot tell those apart, so it would drop a refusal in silence.
+     * Handing the continuation here lets the one place that made the decision apply it.
+     */
+    call(o: unknown, k: unknown, args: unknown[] | (() => unknown[] | Promise<unknown[]>), optional?: boolean, chain?: (value: unknown) => unknown): Promise<unknown>;
+    /** Stamp a freshly built container with this frame's depth (L2032's runtime half). */
+    born<T>(v: T): T;
+    /** A journalled primitive. */
+    effect(name: string, args: unknown[], site?: Site): Promise<unknown>;
+    /** A free builtin: called with `args`, or READ as a value when `args` is omitted. */
+    free(name: string, args?: unknown[]): unknown;
+    /** The thenable gate, before the host's await machinery can run a program closure. */
+    await(v: unknown): Promise<unknown>;
+    /** Template interpolation: L4018, no implicit conversion. */
+    template(parts: readonly string[], values: readonly unknown[]): string;
+    /** The binary operators' coercion law (L4018) and JavaScript's meaning. `===`/`!==` stay native. */
+    binary(op: string, l: unknown, r: unknown): unknown;
+    /** `-`, `+`, `~` under the same law, and `update` for the operand of `++`/`--`. `!`/`typeof` are native. */
+    unary(op: string, v: unknown): unknown;
+    /** The iterability law (L4015): arrays and strings, nothing else. */
+    iter(v: unknown): unknown[];
+    /** The L4011 refusal at a non-function callee. Emitted behind a `typeof`, so only the refusal runs. */
+    callee(v: unknown): unknown;
+    /** At the head of every emitted catch: rethrow the uncatchable, else the program-visible error. */
+    caught(e: unknown): unknown;
+}
+/** What a run hands the seam. */
+export interface EngineRun {
+    readonly runId: string;
+    readonly programHash: string;
+    readonly journal: Journal;
+    readonly handler: EffectHandler;
+    readonly pins: RunPins;
+    readonly onLog?: (line: {
+        scope: string;
+        values: readonly unknown[];
+    }) => void;
+    readonly shouldStop?: () => string | undefined;
+}
+/**
+ * The seam, plus the one thing the HOST needs from it that the program must never see.
+ *
+ * `steps()` is the count charged against the step budget, which a `RunResult` reports so a host can
+ * see how close a program runs to the ceiling before the ceiling is what tells it. It is deliberately
+ * NOT a member of {@link EngineCtx}: everything on that interface is reachable from inside the
+ * compartment, and a program that can read its own fuel gauge can shape its behaviour around one.
+ */
+export declare function createEngine(run: EngineRun): {
+    readonly ctx: EngineCtx;
+    steps(): number;
+};
+/** The seam alone. */
+export declare function createCtx(run: EngineRun): EngineCtx;
+/**
+ * The engine broke its own contract, and no program may catch that.
+ *
+ * The one thing that reaches this today is a native `ReferenceError`. The emitted module is a closed
+ * expression with zero free identifiers, so nothing the program wrote can name a binding that is not
+ * there; a ReferenceError therefore means a TDZ read the transform's classifier missed or an emitter
+ * temporary read before it was bound. It is not the program's error, it is not converted to one, and
+ * it is never mapped to L2004 by reading its message - that mapping would make a compiler bug
+ * indistinguishable from the language rule it imitates.
+ */
+export declare class EngineFault extends Error {
+    readonly cause: unknown;
+    constructor(cause: unknown);
+}
+//# sourceMappingURL=ctx.d.ts.map

package/dist/engine/ctx.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ctx.d.ts","sourceRoot":"","sources":["../../src/engine/ctx.ts"],"names":[],"mappings":"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"}