@polyengine/runtime 0.1.0-pre.g633468a

package/esm/task/subtask.js

@@ -0,0 +1,135 @@
+// definitions.py `### Subtask State` (line 858): one in-progress call from
+// this component to an import.
+import { assert_, trapIf } from "../cabi/trap.js";
+import { EventCode, Waitable } from "./waitable.js";
+/** definitions.py `Subtask.State` (line 859). */
+export var SubtaskState;
+(function (SubtaskState) {
+    SubtaskState[SubtaskState["STARTING"] = 0] = "STARTING";
+    SubtaskState[SubtaskState["STARTED"] = 1] = "STARTED";
+    SubtaskState[SubtaskState["RETURNED"] = 2] = "RETURNED";
+    SubtaskState[SubtaskState["CANCELLED_BEFORE_STARTED"] = 3] = "CANCELLED_BEFORE_STARTED";
+    SubtaskState[SubtaskState["CANCELLED_BEFORE_RETURNED"] = 4] = "CANCELLED_BEFORE_RETURNED";
+})(SubtaskState || (SubtaskState = {}));
+export class Subtask extends Waitable {
+    state = SubtaskState.STARTING;
+    onCancel = null;
+    cancellationRequested = false;
+    flatResults = [];
+    /**
+     * The callee TASK behind this subtask, when there is one (FACT
+     * cross-component calls; host-import subtasks have none). `subtask.cancel`
+     * needs it under jspi: a cancellation delivered to a suspended activation
+     * resumes it on a MICROTASK (the engine's, not ours), so the async form
+     * must wait until the callee's state is determinate before choosing
+     * between BLOCKED and the resolved state — the same determinacy question
+     * `async-start-call` answers, and it needs the same object to ask it of.
+     */
+    // deno-lint-ignore no-explicit-any
+    calleeTask = null;
+    /**
+     * Handles lent to the callee for the duration of the call. `null` once
+     * `deliverResolve` has run — the reference uses exactly this
+     * `lenders is None` sentinel to mean "resolve delivered" (line 908), so the
+     * nullability is semantic, not an optimization.
+     */
+    lenders = [];
+    /** definitions.py `Subtask.resolved` (line 880). */
+    resolved() {
+        switch (this.state) {
+            case SubtaskState.STARTING:
+            case SubtaskState.STARTED:
+                return false;
+            default:
+                return true;
+        }
+    }
+    /** definitions.py `Subtask.add_lender` (line 890). */
+    addLender(h) {
+        assert_(!this.resolveDelivered() && !this.resolved(), "addLender on a resolved subtask");
+        h.numLends += 1;
+        this.lenders.push(h);
+    }
+    /** definitions.py `Subtask.resolve` (line 895). */
+    resolve(state, flatResults) {
+        assert_(state === SubtaskState.RETURNED || flatResults.length === 0, "non-RETURNED subtask resolution carries results");
+        assert_(!this.resolved(), "resolve on an already-resolved subtask");
+        this.state = state;
+        this.flatResults = flatResults;
+    }
+    /** definitions.py `Subtask.deliver_resolve` (line 902). */
+    deliverResolve() {
+        assert_(!this.resolveDelivered() && this.resolved(), "deliverResolve on an unresolved or already-delivered subtask");
+        for (const h of this.lenders)
+            h.numLends -= 1;
+        this.lenders = null;
+    }
+    /** definitions.py `Subtask.resolve_delivered` (line 908). */
+    resolveDelivered() {
+        assert_(this.lenders !== null || this.resolved(), "lenders released on an unresolved subtask");
+        return this.lenders === null;
+    }
+    /**
+     * Release a never-delivered subtask's lenders after its call broke off a
+     * non-poisoning exit — trap-rethrow past the CALLEE, capability bail, or
+     * an abandoned park (contracts/intrinsics.md v0.2 amendment 2, #91 scope
+     * clarification; the park legs are #102/#106).
+     *
+     * The reference has no analogue because it never resumes after a trap:
+     * the store dies with the lent handles inside it. The resolution state
+     * mirrors `canon_lower`'s `on_resolve(None)` branch (definitions.py
+     * line 2267): CANCELLED_BEFORE_STARTED if the callee never started,
+     * CANCELLED_BEFORE_RETURNED otherwise.
+     *
+     * Idempotent, and a no-op when the resolution was already delivered — a
+     * settled hook can call it unconditionally without disturbing the success
+     * path's own `deliverResolve`.
+     */
+    unwindLenders() {
+        if (!this.resolved()) {
+            this.resolve(this.state === SubtaskState.STARTING
+                ? SubtaskState.CANCELLED_BEFORE_STARTED
+                : SubtaskState.CANCELLED_BEFORE_RETURNED, []);
+        }
+        if (!this.resolveDelivered())
+            this.deliverResolve();
+    }
+    /** definitions.py `Subtask.drop` (line 912). */
+    drop() {
+        trapIf(!this.resolveDelivered(), "cannot drop a subtask which has not yet resolved");
+        super.drop();
+    }
+    /**
+     * definitions.py `canon_lower`'s `on_progress`/`subtask_event` closure
+     * (lines 2297-2298). The event payload is computed **at delivery time** and
+     * delivering it is what runs `deliver_resolve` — so the lent handles are
+     * released exactly when the guest observes the resolution, not when it
+     * happens.
+     *
+     * The `!this.resolveDelivered()` guard has no reference analogue: it exists
+     * so this can coexist with `unwindLenders()` (which may itself have already
+     * delivered the resolve on an abandoned path). The reference's
+     * `subtask_event` calls `deliver_resolve()` unconditionally and would
+     * assert on a double delivery.
+     */
+    setSubtaskPendingEvent(subtaski) {
+        this.setPendingEvent(() => {
+            if (this.resolved() && !this.resolveDelivered())
+                this.deliverResolve();
+            return [EventCode.SUBTASK, subtaski, this.state];
+        });
+    }
+}
+/**
+ * Pack a `canon_lower` async return value: `state | (subtaski << 4)`
+ * (definitions.py line 2306, with the accompanying asserts on the ranges).
+ */
+export function packSubtaskResult(state, subtaski) {
+    assert_(subtaski > 0 && subtaski <= 2 ** 28 - 1, "subtask index out of packing range");
+    assert_(state >= 0 && state < 2 ** 4, "subtask state out of packing range");
+    return (state | (subtaski << 4)) >>> 0;
+}
+/** Inverse of {@link packSubtaskResult}; used by tests mirroring the reference. */
+export function unpackSubtaskResult(packed) {
+    return [(packed & 0xf), packed >>> 4];
+}

package/esm/task/thread.js

@@ -0,0 +1,255 @@
+// definitions.py `class Thread` (line 317), reimplemented over JS generators.
+//
+// Mapping to the reference, state for state:
+//
+//   reference                    here
+//   ------------------------------------------------------------------
+//   cont is None (running)       #state === "running"
+//   cont set, ready_func None    #state === "suspended"
+//   cont set, ready_func set     #state === "waiting"  (in store.waiting)
+//   thread.storage[2]            storage: [0, 0]   (context.{get,set})
+//   thread.index                 index (inst.threads table slot)
+//
+// The reference's `resume()` drives a chain of `switch_to` handoffs
+// (`suspend_then_resume` and friends, lines 408-437). Those are the 🧵
+// shared-everything-threads built-ins, which https://github.com/polymorph-components/polyengine/issues/12 defers along with
+// memory64; `resume()` here therefore handles a single thread, and the
+// switch-to variants are absent rather than approximated.
+import { assert_ } from "../cabi/trap.js";
+import { CANCELLED_FALSE, CANCELLED_TRUE, NeedsJspi, notifyInstancePoisoned, isInstancePoisoned, PendingCapability, popCurrentThread, pushCurrentThread, } from "./scheduler.js";
+export class Thread {
+    task;
+    /**
+     * Per-thread context slots (definitions.py `Thread.storage`, line 323 —
+     * initialised `[0,0]`). `canon_context_{get,set}` (lines 2348/2358) read and
+     * write *this*, not per-task state: two threads of the same task have
+     * independent context. wit-bindgen 0.60 keeps its async task pointer in
+     * slot 0.
+     *
+     * Slots are plain JS numbers: a `context.set` of an i64 value above
+     * 2^53-1 would lose precision. Moot while memory64/threads support is
+     * deferred (issue #12) — revisit this when that issue's closure lands.
+     */
+    storage = [0, 0];
+    /**
+     * The FACT sync-call bracket stack for THIS activation.
+     *
+     * `enter-sync-call` pushes and `exit-sync-call` pops; FACT emits both from
+     * the same activation, so the activation is the continuity that makes this a
+     * stack. See the note on `Task.syncCallStack` for why per-task was not
+     * enough.
+     */
+    // deno-lint-ignore no-explicit-any
+    syncCallStack = [];
+    /** Slot in `inst.threads`, assigned by `Task.registerThread`. */
+    index = null;
+    /** definitions.py `Thread.cancellable` — set at each block point. */
+    cancellable = false;
+    #state = "suspended";
+    #body;
+    #readyFunc = null;
+    #store;
+    // deno-lint-ignore no-explicit-any
+    constructor(task, body) {
+        this.task = task;
+        this.#body = body;
+        this.#store = task.inst.store;
+    }
+    running() {
+        return this.#state === "running";
+    }
+    suspended() {
+        return this.#state === "suspended";
+    }
+    waiting() {
+        return this.#state === "waiting";
+    }
+    done() {
+        return this.#state === "done";
+    }
+    /** definitions.py `Thread.ready` (line 334). */
+    ready() {
+        return this.waiting() && this.#readyFunc !== null && this.#readyFunc();
+    }
+    /** definitions.py `Thread.start_waiting_internal` (line 350). */
+    #startWaiting(readyFunc) {
+        assert_(!this.waiting() && this.#readyFunc === null);
+        this.#readyFunc = readyFunc;
+        this.#state = "waiting";
+        this.#store.startWaiting(this);
+    }
+    /** definitions.py `Thread.stop_waiting_internal` (line 355). */
+    #stopWaiting(cancelled) {
+        assert_(this.waiting() && this.#readyFunc !== null);
+        assert_(cancelled || this.ready(), "stopWaiting on a thread that is neither ready nor cancelled");
+        this.#readyFunc = null;
+        this.#state = "suspended";
+        this.#store.stopWaiting(this);
+    }
+    /** definitions.py `Thread.resume_later` (line 361). */
+    resumeLater() {
+        assert_(this.suspended(), "resume_later on a non-suspended thread");
+        this.#startWaiting(() => true);
+    }
+    /**
+     * definitions.py `Thread.resume` (line 366): run the body until it blocks
+     * again or finishes.
+     *
+     * The reference's loop over `switch_to` targets is omitted (see the module
+     * header). What remains is: leave the waiting list if we were on it, become
+     * the current thread, and step the generator with the cancelled flag.
+     */
+    /** Pending `awaitValue` promise, if this thread is parked on one. */
+    awaiting = null;
+    /** Resume a promise-parked thread with the settled result. */
+    resumeWith(value, failure) {
+        assert_(this.awaiting !== null, "resumeWith on a thread that is not awaiting");
+        this.awaiting = null;
+        this.#store.awaiting.delete(this);
+        this.#state = "suspended";
+        // The reentrance bracket, exactly as `Store.tick` puts around `resume()`.
+        //
+        // Every thread resumption in the reference runs under the instance's
+        // entered lock, and a trap propagating out of the resumed thread skips
+        // `leave_to` — which is the Component Model's instance poisoning
+        // (definitions.py `Store.tick` line 597; see the matching comment in
+        // scheduler.ts). This path is a resumption too — the value arrived
+        // through a Promise instead of a ready-condition, but the thread body
+        // (and any wasm it runs) is the same — so it takes the same bracket.
+        // Without it, a trap delivered as an `awaitValue` rejection (how EVERY
+        // guest trap in a suspended activation arrives under jspi, pin (e))
+        // unwound cleanly and the instance stayed enterable: the second call of
+        // `builtin-trap-poisons-instance.wast` then re-ran the guest and
+        // reported "cannot drop busy stream" where the suite demands the
+        // poisoned-instance "cannot enter component instance".
+        //
+        // Capability signals release the lock, for the same reason as in `tick`:
+        // they mark the RUNTIME incomplete, not the component faulted.
+        const inst = this.task.inst;
+        // A poisoned instance's parked segments never run again: this settle
+        // belongs to an activation that was in flight when a SIBLING activation
+        // trapped (the trap kept the reentrance lock — CM poisoning — and #66
+        // retired the handle tables). Resuming would re-enter the corpse, and
+        // asserting turned one legible trap into an assert cascade (the
+        // wosh-M2 shape: `list too long`, then this assert as second victim).
+        // Retire quietly: the abandoned call's own driver reports, via its
+        // deadlock trap naming the export.
+        if (isInstancePoisoned(inst))
+            return;
+        // The enterability check below is an internal BACKSTOP, not a live gate:
+        // every dispatch site (`Store.serviceSettled`, `driveAsync`'s race-winner
+        // path) now guards enterable-or-poisoned before calling and DEFERS the
+        // tail otherwise (issue #156) — under the shared synthetic root, a host
+        // entry into any instance of the graph makes every sibling
+        // non-enterable, so this assert was reachable, and (mutating before
+        // asserting) it stranded the thread and lost the settle. It stays to
+        // protect the invariant for any future caller.
+        assert_(inst.mayEnterFrom(null), "resumeWith: parked thread's instance is not enterable from the host");
+        inst.enterFrom(null);
+        try {
+            this.#resumeInternal(value, failure);
+        }
+        catch (e) {
+            if (e instanceof NeedsJspi || e instanceof PendingCapability) {
+                inst.leaveTo(null);
+            }
+            else {
+                // The bracket stays broken (instance poisoned, comment above) — same
+                // as `Store.tick`: retire the poisoned table's stream/future ends so
+                // parked host peers settle instead of hanging (#66), and release the
+                // synthetic root so the poisoning stays per-instance (plan v3
+                // amendment 4; `releaseSyntheticRootOnPoison`).
+                inst.releaseSyntheticRootOnPoison();
+                notifyInstancePoisoned(inst, e);
+            }
+            throw e;
+        }
+        inst.leaveTo(null);
+    }
+    resume(cancelled = CANCELLED_FALSE) {
+        assert_(!this.running() && !this.done(), "resume() on a running or finished thread");
+        assert_(this.cancellable || !cancelled, "cancelled resume of a non-cancellable block point");
+        if (this.waiting())
+            this.#stopWaiting(cancelled);
+        this.#resumeInternal(cancelled);
+    }
+    #resumeInternal(sendValue, failure) {
+        this.#state = "running";
+        pushCurrentThread(this);
+        let step;
+        try {
+            step = failure === undefined
+                ? this.#body.next(sendValue)
+                // Throw the rejection *into* the body so a post-resume trap unwinds
+                // through the same `finally`s a synchronous one would (jspi pin (e)).
+                : this.#body.throw(failure.error);
+        }
+        catch (e) {
+            // The body threw (a trap, or one of our capability errors). The thread
+            // is finished either way; the exception propagates to whoever was
+            // driving the scheduler.
+            this.#state = "done";
+            throw e;
+        }
+        finally {
+            popCurrentThread(this);
+        }
+        if (step.done) {
+            this.#state = "done";
+            return;
+        }
+        const req = step.value;
+        this.cancellable = req.cancellable;
+        if (req.awaitValue !== undefined) {
+            // Parked on a Promise, not on a scheduler condition. The driving loop
+            // owns it from here (exec/boundary.ts `drive`); parking through
+            // `noteAwaiting` arms the eager settle tracking the scheduler's
+            // phantom-state gate depends on (see `Store.settled`).
+            this.#state = "suspended";
+            this.awaiting = req.awaitValue;
+            this.#store.noteAwaiting(this, req.awaitValue);
+            return;
+        }
+        if (req.readyFunc === null) {
+            // `suspend`: resumable only by an explicit `resume`/`resumeLater`.
+            this.#state = "suspended";
+        }
+        else {
+            this.#state = "suspended";
+            this.#startWaiting(req.readyFunc);
+        }
+    }
+    /**
+     * definitions.py `Thread.wait_until` (line 396), as a generator-side helper.
+     *
+     * Call it from a thread body with `yield*`:
+     *   `const cancelled = yield* thread.waitUntil(() => cond, true);`
+     *
+     * Deviation from the reference, deliberate: the reference may return
+     * immediately when `ready_func()` already holds
+     * (`if ready_func() and not DETERMINISTIC_PROFILE and random.randint(0,1)`).
+     * We always take the blocking path, i.e. we behave as the reference's
+     * `DETERMINISTIC_PROFILE`. Blocking-then-immediately-ready is observably
+     * equivalent (the scheduler will find this thread ready on the next
+     * candidate scan) and it removes a coin flip from every wait.
+     */
+    *waitUntil(readyFunc, cancellable = false) {
+        assert_(this.running(), "waitUntil on a non-running thread");
+        if (this.task.deliverPendingCancel(cancellable))
+            return CANCELLED_TRUE;
+        const cancelled = yield { readyFunc, cancellable };
+        return cancelled;
+    }
+    /** definitions.py `Thread.suspend` (line 390). */
+    *suspend(cancellable) {
+        assert_(this.running(), "suspend on a non-running thread");
+        if (this.task.deliverPendingCancel(cancellable))
+            return CANCELLED_TRUE;
+        const cancelled = yield { readyFunc: null, cancellable };
+        return cancelled;
+    }
+    /** definitions.py `Thread.yield_` (line 405): `wait_until(lambda: True)`. */
+    *yield_(cancellable) {
+        return yield* this.waitUntil(() => true, cancellable);
+    }
+}

package/esm/task/waitable.js

@@ -0,0 +1,144 @@
+// definitions.py `### Waitable State` (line 754) — the event protocol shared
+// by subtasks and (later) stream/future ends.
+import { assert_, trapIf } from "../cabi/trap.js";
+import { chooseCandidate } from "./scheduler.js";
+/** definitions.py `EventCode` (line 756). */
+export var EventCode;
+(function (EventCode) {
+    EventCode[EventCode["NONE"] = 0] = "NONE";
+    EventCode[EventCode["SUBTASK"] = 1] = "SUBTASK";
+    EventCode[EventCode["STREAM_READ"] = 2] = "STREAM_READ";
+    EventCode[EventCode["STREAM_WRITE"] = 3] = "STREAM_WRITE";
+    EventCode[EventCode["FUTURE_READ"] = 4] = "FUTURE_READ";
+    EventCode[EventCode["FUTURE_WRITE"] = 5] = "FUTURE_WRITE";
+    EventCode[EventCode["TASK_CANCELLED"] = 6] = "TASK_CANCELLED";
+})(EventCode || (EventCode = {}));
+export const NO_EVENT = [EventCode.NONE, 0, 0];
+/**
+ * definitions.py `class Waitable` (line 767).
+ *
+ * The pending event is a **thunk**, not a value: the reference computes the
+ * payload at delivery time (`get_pending_event` calls it), which is what lets
+ * a subtask report its *final* state even if it advanced between the event
+ * being set and being read. Keeping the thunk is load-bearing — see
+ * `Subtask.setPendingEvent`.
+ */
+export class Waitable {
+    pendingEvent = null;
+    wset = null;
+    hasSyncWaiter = false;
+    setPendingEvent(pendingEvent) {
+        this.pendingEvent = pendingEvent;
+    }
+    hasPendingEvent() {
+        return this.pendingEvent !== null;
+    }
+    inWaitableSet() {
+        return this.wset !== null;
+    }
+    /**
+     * definitions.py `Waitable.wait_for_pending_event` (line 786): a
+     * *non-cancellable* block until this waitable has an event, used by the
+     * synchronous `subtask.cancel` path.
+     */
+    *waitForPendingEvent(thread) {
+        assert_(!this.inWaitableSet() && !this.hasSyncWaiter, "waitForPendingEvent on a joined or already-awaited waitable");
+        this.hasSyncWaiter = true;
+        yield* thread.waitUntil(() => this.hasPendingEvent(), false);
+        this.hasSyncWaiter = false;
+    }
+    getPendingEvent() {
+        const pendingEvent = this.pendingEvent;
+        assert_(pendingEvent !== null, "getPendingEvent with no pending event");
+        this.pendingEvent = null;
+        return pendingEvent();
+    }
+    /** definitions.py `Waitable.join` (line 797). */
+    join(wset) {
+        assert_(!this.hasSyncWaiter, "join on a waitable with a sync waiter");
+        if (this.wset) {
+            const i = this.wset.elems.indexOf(this);
+            assert_(i !== -1, "waitable not in its own waitable set");
+            this.wset.elems.splice(i, 1);
+        }
+        this.wset = wset;
+        if (wset)
+            wset.elems.push(this);
+    }
+    /** definitions.py `Waitable.drop` (line 805). */
+    drop() {
+        assert_(!this.hasPendingEvent(), "dropping a waitable with a pending event");
+        assert_(!this.hasSyncWaiter, "dropping a waitable with a sync waiter");
+        this.join(null);
+    }
+}
+const EV_TRACE = (() => {
+    try {
+        return Deno.env.get("CE_EVENT_TRACE") === "1";
+    }
+    catch {
+        return false;
+    }
+})();
+/** definitions.py `class WaitableSet` (line 810). */
+export class WaitableSet {
+    elems = [];
+    numWaiting = 0;
+    hasPendingEvent() {
+        return this.elems.some((w) => w.hasPendingEvent());
+    }
+    /**
+     * definitions.py `WaitableSet.get_pending_event` (line 821). The reference
+     * shuffles `elems` before scanning; we scan in **join order** under the
+     * default FIFO policy (`chooseCandidate` over the ready elements), which is
+     * within the same allowed nondeterminism — see scheduler.ts's policy note.
+     */
+    getPendingEvent() {
+        const ready = this.elems.filter((w) => w.hasPendingEvent());
+        assert_(ready.length > 0, "getPendingEvent on a set with no pending event");
+        const w = chooseCandidate(ready);
+        assert_(w.wset === this, "waitable/waitable-set back-reference mismatch");
+        const ev = w.getPendingEvent();
+        if (EV_TRACE) {
+            console.error(`[event] deliver code=${ev[0]} idx=${ev[1]} payload=${ev[2]} ` +
+                `readyCount=${ready.length} setSize=${this.elems.length} ` +
+                `chosenPos=${this.elems.indexOf(w)}`);
+        }
+        return ev;
+    }
+    /** definitions.py `WaitableSet.wait_for_event_and` (line 829). */
+    *waitForEventAnd(thread, readyFunc, cancellable) {
+        this.numWaiting += 1;
+        try {
+            const cancelled = yield* thread.waitUntil(() => readyFunc() && this.hasPendingEvent(), cancellable);
+            return cancelled
+                ? [EventCode.TASK_CANCELLED, 0, 0]
+                : this.getPendingEvent();
+        }
+        finally {
+            this.numWaiting -= 1;
+        }
+    }
+    /** definitions.py `WaitableSet.wait_for_event` (line 841). */
+    *waitForEvent(thread, cancellable) {
+        return yield* this.waitForEventAnd(thread, () => true, cancellable);
+    }
+    /**
+     * definitions.py `WaitableSet.poll` (line 844). Never blocks, so it is a
+     * plain function rather than a generator.
+     */
+    // deno-lint-ignore no-explicit-any
+    poll(task, cancellable) {
+        if (task.deliverPendingCancel(cancellable)) {
+            return [EventCode.TASK_CANCELLED, 0, 0];
+        }
+        if (!this.hasPendingEvent())
+            return [EventCode.NONE, 0, 0];
+        return this.getPendingEvent();
+    }
+    /** definitions.py `WaitableSet.drop` (line 852). */
+    drop() {
+        trapIf(this.elems.length > 0, "cannot drop waitable set with waitables");
+        trapIf(this.numWaiting > 0, "cannot drop waitable set with waiters");
+    }
+}

package/package.json

@@ -0,0 +1,91 @@
+{
+  "name": "@polyengine/runtime",
+  "version": "0.1.0-pre.g633468a",
+  "description": "A WebAssembly Component Model host for JavaScript engines: plan executor, canonical ABI, 0.3 task scheduler, JSPI bridge, and embedder API.",
+  "homepage": "https://github.com/polymorph-components/polyengine#readme",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/polymorph-components/polyengine.git"
+  },
+  "license": "Apache-2.0",
+  "bugs": {
+    "url": "https://github.com/polymorph-components/polyengine/issues"
+  },
+  "module": "./esm/cabi/mod.js",
+  "types": "./types/cabi/mod.d.ts",
+  "exports": {
+    "./cabi": {
+      "import": {
+        "types": "./types/cabi/mod.d.ts",
+        "default": "./esm/cabi/mod.js"
+      }
+    },
+    "./cache": {
+      "import": {
+        "types": "./types/cache/mod.d.ts",
+        "default": "./esm/cache/mod.js"
+      }
+    },
+    "./plan": {
+      "import": {
+        "types": "./types/plan/mod.d.ts",
+        "default": "./esm/plan/mod.js"
+      }
+    },
+    "./task": {
+      "import": {
+        "types": "./types/task/mod.d.ts",
+        "default": "./esm/task/mod.js"
+      }
+    },
+    "./exec": {
+      "import": {
+        "types": "./types/exec/mod.d.ts",
+        "default": "./esm/exec/mod.js"
+      }
+    },
+    "./embedder": {
+      "import": {
+        "types": "./types/embedder/mod.d.ts",
+        "default": "./esm/embedder/mod.js"
+      }
+    },
+    "./digest": {
+      "import": {
+        "types": "./types/digest/mod.d.ts",
+        "default": "./esm/digest/mod.js"
+      }
+    },
+    "./intrinsics": {
+      "import": {
+        "types": "./types/intrinsics/mod.d.ts",
+        "default": "./esm/intrinsics/mod.js"
+      }
+    },
+    "./shim": {
+      "import": {
+        "types": "./types/shim/mod.d.ts",
+        "default": "./esm/shim/mod.js"
+      }
+    },
+    "./jspi": {
+      "import": {
+        "types": "./types/jspi/mod.d.ts",
+        "default": "./esm/jspi/mod.js"
+      }
+    },
+    "./package.json": "./package.json"
+  },
+  "scripts": {},
+  "type": "module",
+  "engines": {
+    "node": ">=22.14.0"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "dependencies": {
+    "@polyengine/protocol": "0.1.0-pre.g633468a"
+  },
+  "_generatedBy": "dnt@0.43.2"
+}

package/types/cabi/async_values.d.ts

@@ -0,0 +1,35 @@
+import type { LiftLowerContext } from "./context.js";
+import type { BorrowType, OwnType, ValType } from "./types.js";
+import { ErrorContext, type SharedBase } from "../task/streams.js";
+/**
+ * Diagnostic for a handle-table entry that carries the A9 error-context brand
+ * without being one of THIS copy's `ErrorContext`s (amendment A9, issue #83).
+ *
+ * A backstop, deliberately: the embedder's lowering site (embedder/values.ts)
+ * refuses a foreign error-context before it can ever reach a handle table, so
+ * this branch should be unreachable. It exists because "handle is not an
+ * error-context" is precisely the misleading generic that made #83 expensive
+ * to diagnose — if a path ever does get here, it says what happened.
+ *
+ * This layer is below `embedder/`, so it composes the census from
+ * `@polyengine/protocol` directly rather than importing `embedder/copy.ts`.
+ */
+export declare function errorContextTrapMessage(where: string, e: unknown): string;
+export declare function liftStream(cx: LiftLowerContext, i: number, t: ValType & {
+    kind: "stream";
+    element: ValType | null;
+}): SharedBase;
+export declare function liftFuture(cx: LiftLowerContext, i: number, t: ValType & {
+    kind: "future";
+    element: ValType | null;
+}): SharedBase;
+/** definitions.py `lower_stream` (line 1828). */
+export declare function lowerStream(cx: LiftLowerContext, v: SharedBase, t: ValType): number;
+/** definitions.py `lower_future` (line 1833). */
+export declare function lowerFuture(cx: LiftLowerContext, v: SharedBase, t: ValType): number;
+/** definitions.py `lift_error_context` (line 1451). Does NOT remove the handle. */
+export declare function liftErrorContext(cx: LiftLowerContext, i: number): ErrorContext;
+/** definitions.py `lower_error_context` (line 1757). */
+export declare function lowerErrorContext(cx: LiftLowerContext, v: ErrorContext): number;
+/** Unused-import guards for the type-only imports above. */
+export type _AsyncValueTypes = OwnType | BorrowType;

package/types/cabi/bulk_lists.d.ts

@@ -0,0 +1,18 @@
+import { type MemInst } from "./memory.js";
+import type { ComponentValue } from "./types.js";
+export declare const PLATFORM_LITTLE_ENDIAN: boolean;
+/** Kinds these helpers handle (besides them, u8 has its own path). */
+export declare function isBulkListKind(kind: string): boolean;
+/**
+ * Bulk lift of `length` elements of `kind` at `ptr`. Returns `null` when the
+ * kind is not handled here (caller falls back to the per-element loop) —
+ * never for a handled kind on a little-endian platform with an aligned view.
+ * The caller has already trap-checked alignment and bounds.
+ */
+export declare function tryLoadNumericList(mem: MemInst, ptr: number, length: number, kind: string): ComponentValue[] | null;
+/**
+ * Bulk store of `v` as elements of `kind` at `ptr`. Returns false when not
+ * handled (caller falls back). The caller has already trap-checked alignment
+ * and bounds.
+ */
+export declare function tryStoreNumericList(mem: MemInst, v: ArrayLike<ComponentValue>, ptr: number, kind: string): boolean;