@polyengine/runtime 0.1.0-pre.g633468a

package/esm/shim/translator.js

@@ -0,0 +1,94 @@
+// Client for the translator shim's wasm32 C-ABI (crates/translator-shim).
+// Platform-neutral: callers provide the shim module/bytes; file loading is
+// embedder territory.
+//
+// C-ABI (see crates/translator-shim/src/lib.rs `cabi`):
+//   ts_alloc(len) -> ptr
+//   ts_translate(ptr, len, out_len_ptr) -> out_ptr   (out = envelope JSON)
+//   ts_dealloc(ptr, len)
+import { loadEnvelope, PlanError } from "../plan/loader.js";
+/** An instantiated translator shim. One instance is reusable across calls. */
+export class Translator {
+    #exports;
+    /**
+     * sha256 of the shim wasm bytes this instance was built from, hex-encoded;
+     * `null` when constructed from a pre-compiled `WebAssembly.Module` with no
+     * bytes available (module identity can't be recovered post-compile).
+     *
+     * This is the honest translator "build hash" for the artifact cache
+     * (docs/architecture.md §10): the wire envelope's `producer` block records
+     * `{shimVersion, wasmtimeEnviron, features}`, which does NOT change when
+     * the shim wasm is rebuilt from the same source versions (e.g. a local
+     * patch or a different toolchain producing different codegen) — see the
+     * M3-B dispatch. Digesting the actual bytes is the only sound cache key
+     * component for translator identity.
+     */
+    buildHash;
+    constructor(exports, buildHash) {
+        this.#exports = exports;
+        this.buildHash = buildHash;
+        for (const name of ["memory", "ts_alloc", "ts_dealloc", "ts_translate"]) {
+            if (!(name in this.#exports)) {
+                throw new PlanError(`shim module missing export '${name}'`);
+            }
+        }
+    }
+    /** Instantiate from compiled module or raw wasm bytes. */
+    static async create(source) {
+        let module;
+        let buildHash = null;
+        if (source instanceof WebAssembly.Module) {
+            module = source;
+        }
+        else {
+            module = await WebAssembly.compile(source.slice().buffer);
+            const digest = await crypto.subtle.digest("SHA-256", source.slice().buffer);
+            buildHash = Array.from(new Uint8Array(digest)).map((b) => b.toString(16).padStart(2, "0")).join("");
+        }
+        const instance = await WebAssembly.instantiate(module, {});
+        return new Translator(instance.exports, buildHash);
+    }
+    /**
+     * Wrap an ALREADY-INSTANTIATED shim — the ESM wasm-module import path
+     * (issue #16 delivery design): `import * as shim from ".../translator_shim.wasm"`
+     * hands back an instantiated namespace (the shim imports nothing, so the
+     * ESM integration instantiates it trivially), and this wraps it with no
+     * further compile or copy.
+     *
+     * Sharing note: ESM gives ONE instance per realm, so every `fromExports`
+     * wrapper over the same namespace shares linear memory. That is safe by
+     * construction — `translate` is synchronous end-to-end (alloc → call →
+     * copy out → dealloc within one JS frame), so calls can never interleave —
+     * but treat the wrappers as equivalent, not independent.
+     *
+     * `buildHash` (hex sha-256 of the shim wasm bytes) cannot be recovered
+     * from an instance; pass it when known — a published package can ship the
+     * hash of the exact asset it carries — or leave it absent and the
+     * artifact cache politely refuses to key on translator identity
+     * (cache/core.ts).
+     */
+    static fromExports(exports, opts = {}) {
+        return new Translator(exports, opts.buildHash ?? null);
+    }
+    /** Translate a component binary into plan v0 + adapter artifacts. */
+    translate(componentBytes) {
+        const json = this.translateRaw(componentBytes);
+        const { wire, adapters } = loadEnvelope(json);
+        return { plan: wire, adapters, envelopeJson: json };
+    }
+    /** Translate, returning the raw envelope JSON without validation. */
+    translateRaw(componentBytes) {
+        const ex = this.#exports;
+        const inPtr = ex.ts_alloc(componentBytes.length);
+        new Uint8Array(ex.memory.buffer, inPtr, componentBytes.length).set(componentBytes);
+        const outLenPtr = ex.ts_alloc(4);
+        const outPtr = ex.ts_translate(inPtr, componentBytes.length, outLenPtr);
+        // Re-acquire views: translation may have grown (detached) the memory.
+        const outLen = new DataView(ex.memory.buffer).getUint32(outLenPtr, true);
+        const json = new TextDecoder().decode(new Uint8Array(ex.memory.buffer, outPtr, outLen));
+        ex.ts_dealloc(outPtr, outLen);
+        ex.ts_dealloc(outLenPtr, 4);
+        ex.ts_dealloc(inPtr, componentBytes.length);
+        return json;
+    }
+}

package/esm/task/mod.js

@@ -0,0 +1,483 @@
+// The 0.3 task model (docs/architecture.md §6): `ComponentInstance`, `Task`, and the
+// re-export surface of the task core. Thread, Waitable/WaitableSet, Subtask
+// and the scheduler live in sibling modules; see ./scheduler.ts for the
+// scheduling-policy rationale and the generator-based thread model.
+//
+// Structural correspondence to definitions.py is the design constraint here:
+// where this file diverges, the divergence is called out in a comment with
+// the reference's line number. The two systematic divergences are
+//
+//   1. threads are generators, not OS threads (./scheduler.ts header), and
+//   2. the shared-everything-threads built-ins (`thread.suspend-then-resume`
+//      and friends, 🧵) are absent rather than approximated — https://github.com/polymorph-components/polyengine/issues/12
+//      defers that feature with memory64.
+import { Table } from "../cabi/handles.js";
+import { assert_, trapIf } from "../cabi/trap.js";
+import { CANCELLED_TRUE, chooseCandidate, Store, dbgId, NeedsJspi, notifyInstancePoisoned, PendingCapability, } from "./scheduler.js";
+import { Thread } from "./thread.js";
+import { Waitable, WaitableSet } from "./waitable.js";
+import { Subtask } from "./subtask.js";
+export * from "./scheduler.js";
+export * from "./thread.js";
+export * from "./waitable.js";
+export * from "./subtask.js";
+export * from "./streams.js";
+/**
+ * Synthetic-root registry: one root per `Store` (see
+ * `ComponentInstanceState.rootOf`). A `WeakMap` so a dead store's root dies
+ * with it.
+ */
+const syntheticRoots = new WeakMap();
+/** `index` of the synthetic root — outside the real instance index space. */
+const ROOT_INDEX = -1;
+/** Constructor marker: "this one IS the root, do not give it a parent". */
+const ROOT_TOKEN = Symbol("synthetic-root");
+/**
+ * Per-component-instance runtime state (definitions.py `ComponentInstance`,
+ * line 191).
+ *
+ * `mayLeave` is backed by a real `WebAssembly.Global(i32, mutable)` because
+ * FACT adapters import that global (`flags` namespace) and read/write it as
+ * the may_leave boolean (wasmtime 47 FACT treats the whole flags global as
+ * may_leave; there is no bitmask). Initial value 1 (true). `mayEnter` is
+ * host-side state: nothing wasm-visible reads it.
+ */
+export class ComponentInstanceState {
+    index;
+    flags;
+    handles = new Table();
+    /** definitions.py `ComponentInstance.threads` — a Table, so `thread.index`. */
+    threads = new Table();
+    mayEnter = true;
+    /** definitions.py `backpressure: int` — a *counter* (backpressure.{inc,dec}). */
+    backpressure = 0;
+    /** definitions.py `num_waiting_to_enter`. */
+    numWaitingToEnter = 0;
+    /** definitions.py `exclusive_thread`. */
+    exclusiveThread = null;
+    /**
+     * definitions.py `ComponentInstance.parent`.
+     *
+     * The plan still gives us a flat instance space, but the tree is no longer
+     * needed: every instance of one instantiation gets the same **synthetic
+     * root** as its parent (contracts/plan-format.md v3 amendment 4 /
+     * polyengine#101). See `enteringSet` for why that is observably equivalent to
+     * the real chain. The root itself has no parent.
+     */
+    parent;
+    store;
+    /**
+     * The synthetic per-instantiation root (v3 amendment 4). One per `Store`:
+     * a `Store` is exactly one component instantiation's scheduling scope, so
+     * "all `ComponentInstanceState`s sharing a `Store`" is the set that shares
+     * a top-level component — which is the granularity wasmtime's own
+     * top-level-instance-id comparison uses (concurrent.rs:1876-1886).
+     *
+     * It is a real `ComponentInstanceState` (index -1) rather than a bare flag
+     * so it flows through `selfAndAncestors`/`enteringSet` unchanged; its
+     * handle table stays empty and no task ever runs on it.
+     */
+    static rootOf(store) {
+        let root = syntheticRoots.get(store);
+        if (root === undefined) {
+            root = new ComponentInstanceState(ROOT_INDEX, store, ROOT_TOKEN);
+            syntheticRoots.set(store, root);
+        }
+        return root;
+    }
+    /** Is this the synthetic root (never a real component instance)? */
+    get isSyntheticRoot() {
+        return this.index === ROOT_INDEX && this.parent === null;
+    }
+    constructor(index, store, root) {
+        this.index = index;
+        this.store = store ?? new Store();
+        this.flags = new WebAssembly.Global({ value: "i32", mutable: true }, 1);
+        // The root is its own tree's top; everything else hangs off it. Built
+        // lazily here so no call site has to remember to wire it up.
+        this.parent = root === ROOT_TOKEN
+            ? null
+            : ComponentInstanceState.rootOf(this.store);
+    }
+    /**
+     * Release the synthetic root after a trap broke the enter/leave bracket
+     * (v3 amendment 4, and a **named divergence** from the reference).
+     *
+     * definitions.py poisons the whole entering set: `Store.lift` never reaches
+     * `leave_to`, so the root — which is in every host entry's entering set —
+     * stays `may_enter == False` forever and NO instance of the component can
+     * be entered again. wasmtime is the same by other means (it poisons the
+     * store). polyengine deliberately supports post-trap re-entry of instances the
+     * trap did not touch (exec/boundary.ts `poison`: "sibling instances stay
+     * usable, which is why the lock is released per-instance rather than by
+     * poisoning a whole store the way wasmtime does"), and the synthetic root
+     * must not silently convert that documented divergence into store-wide
+     * poisoning. So a trap poisons the LEAF set only, and the root is released
+     * here — the reentrance gate the root exists for (a *second, concurrent*
+     * host entry) is about a live entry, and after a trap unwinds to the host
+     * there is none.
+     */
+    releaseSyntheticRootOnPoison() {
+        for (const inst of this.selfAndAncestors()) {
+            if (inst.isSyntheticRoot)
+                inst.mayEnter = true;
+        }
+    }
+    get mayLeave() {
+        return this.flags.value !== 0;
+    }
+    set mayLeave(v) {
+        this.flags.value = v ? 1 : 0;
+    }
+    /** definitions.py `ComponentInstance.self_and_ancestors` (line 236). */
+    selfAndAncestors() {
+        const s = new Set([this]);
+        let a = this.parent;
+        while (a !== null) {
+            s.add(a);
+            a = a.parent;
+        }
+        return s;
+    }
+    /**
+     * definitions.py `ComponentInstance.entering_set` (line 230):
+     * `self_and_ancestors() - caller.self_and_ancestors()`.
+     *
+     * CONTRACT (contracts/plan-format.md v3 amendment 4, polyengine#101): the plan
+     * still carries no wire form for the component-instance tree, and it no
+     * longer needs one. Every instance's parent is the synthetic
+     * per-instantiation root, so:
+     *
+     *   * host entry (`caller === null`): `{this, root}` — the reference's
+     *     entering set for a host entry is `self_and_ancestors()`, which always
+     *     contains the top-level root, so a second host entry anywhere in the
+     *     tree trips on the root either way. This is the divergence #101
+     *     reported (host -> A.f -> host import -> host enters a *different*
+     *     instance): now caught.
+     *   * guest-to-guest (`caller !== null`): `{this}` — the root is in the
+     *     caller's ancestor set and cancels out. Intermediate ancestors would
+     *     be the only difference from the real chain, and they are never
+     *     reachably consulted: FACT compiles same-instance and ancestor calls
+     *     to unconditional compile-time traps, and sibling cycles are
+     *     unreachable because instance imports form a DAG (polyengine#99
+     *     adjudication).
+     *
+     * So the synthetic root is observably equivalent to the full chain, and it
+     * matches wasmtime's own shortcut — a top-level instance-id comparison
+     * (concurrent.rs:1876-1886) — by construction. This reopens only if some
+     * future upstream shape makes nesting depth observable.
+     *
+     * One deliberate departure remains, at the trap path rather than here: see
+     * `releaseSyntheticRootOnPoison`.
+     */
+    enteringSet(caller) {
+        const mine = this.selfAndAncestors();
+        if (caller === null)
+            return mine;
+        for (const c of caller.selfAndAncestors())
+            mine.delete(c);
+        return mine;
+    }
+    /** definitions.py `ComponentInstance.may_enter_from` (line 214). */
+    mayEnterFrom(caller) {
+        for (const inst of this.enteringSet(caller)) {
+            if (!inst.mayEnter)
+                return false;
+        }
+        return true;
+    }
+    /** definitions.py `ComponentInstance.enter_from` (line 220). */
+    enterFrom(caller) {
+        for (const inst of this.enteringSet(caller)) {
+            assert_(inst.mayEnter, "enter_from without may_enter");
+            inst.mayEnter = false;
+        }
+    }
+    /** definitions.py `ComponentInstance.leave_to` (line 225). */
+    leaveTo(caller) {
+        for (const inst of this.enteringSet(caller)) {
+            assert_(!inst.mayEnter, "leave_to without a matching enter_from");
+            inst.mayEnter = true;
+        }
+    }
+    /** Backwards-compatible host-entry helpers (the M0 spelling). */
+    enter() {
+        this.enterFrom(null);
+    }
+    leave() {
+        this.leaveTo(null);
+    }
+}
+/** definitions.py `LiftOptions.equal` (line 643): encoding + memory identity. */
+export function liftOptionsEqual(a, b) {
+    return a.stringEncoding === b.stringEncoding && a.memory === b.memory;
+}
+/**
+ * One export activation (definitions.py `class Task`, line 444). Also the
+ * task-side borrow scope: `numBorrows` satisfies cabi's `TaskBorrowScope`.
+ */
+const ADMIT_TRACE = (() => {
+    try {
+        return Deno.env.get("CE_SP_TRACE") === "1";
+    }
+    catch {
+        return false;
+    }
+})();
+export class Task {
+    ft;
+    opts;
+    inst;
+    onStart;
+    onResolve;
+    state = "initial";
+    /** TaskBorrowScope (cabi/context.ts): live borrows lowered into this task. */
+    numBorrows = 0;
+    implicitThread = null;
+    threads = [];
+    /**
+     * True for a task created by a FACT cross-component call
+     * (`prepare-call`, see intrinsics/fact_calls.ts).
+     *
+     * Such a task's `onStart` / `onResolve` carry **flat core values**, not
+     * lifted component values: FACT fuses the caller-side lift and callee-side
+     * lower into a pair of adapter functions (`[async-start]` / `[async-return]`)
+     * that run *in wasm*, so the host only shuttles the core values between
+     * them. definitions.py has no analogue because it has no fused adapters —
+     * there, `canon_lift` lowers the params and `canon_lower`'s `on_resolve`
+     * lifts the results, both in the host. The observable semantics are
+     * identical; only which side of the boundary performs the copy differs.
+     *
+     * `canon_task_return` consults this to decide whether to lift its flat
+     * arguments (host-boundary task) or pass them straight through (FACT task).
+     */
+    factPassthrough = false;
+    /**
+     * Plan v3: does `ft.results` hold this FACT task's *declared* result type?
+     *
+     * A FACT callee task's result type arrives as the raw wasmtime
+     * `TypeTupleIndex` `prepare-call` passes as `task_return_type`; v3's
+     * `task-return.results` / `resultType` pair is the dictionary for it
+     * (contracts/plan-format.md v3 amendment 3). It resolves for every callee
+     * that has a `task.return` trampoline of its own — which is every callee
+     * that can call `task.return` — but a callee with none (sync-lifted,
+     * reached through an async-to-sync adapter) contributes no entry, and then
+     * `ft.results` is the empty placeholder it was before v3. Only when this is
+     * true may `canon_task_return` compare against it.
+     */
+    factResultTypesKnown = false;
+    /**
+     * In-flight FACT sync-call brackets for THIS task
+     * (`enter-sync-call`/`exit-sync-call`).
+     *
+     * MOVED to `Thread` (see `Thread.syncCallStack`). Per-task was already an
+     * improvement on per-executor, but it is still not the right unit: a task
+     * can own several threads, so one activation's `exit-sync-call` could pop a
+     * sibling activation's scope. Tracing big-interleaving showed exactly that
+     * -- tasks whose `enter` count exceeded their `exit` count by one, and other
+     * tasks taking an `exit` at depth 0, with the `ctx` fallback never firing.
+     *
+     * The bracket belongs to the ACTIVATION that opened it: FACT emits the
+     * matching `enter-sync-call` and `exit-sync-call` from the same wasm
+     * activation by construction, so riding the activation identity makes the
+     * exit find the same stack the enter used no matter which task the scheduler
+     * considers current in between (the 3i bracket-spans-suspension ruling).
+     */
+    constructor(ft, opts, inst, onStart, onResolve) {
+        this.ft = ft;
+        this.opts = opts;
+        this.inst = inst;
+        this.onStart = onStart;
+        this.onResolve = onResolve;
+    }
+    /**
+     * definitions.py `Task.needs_exclusive` (line 473): an async-typed task
+     * needs the instance's exclusive thread unless it is a *stackful* async
+     * lift. Sync-lowered (`not opts.async_`) and callback-ABI tasks both do.
+     */
+    needsExclusive() {
+        assert_(this.ft.async === true, "needs_exclusive on a sync-typed task");
+        return !this.opts.async_ || this.opts.callback;
+    }
+    /**
+     * definitions.py `Task.enter_implicit_thread` (line 477) — the backpressure
+     * and exclusivity gate, in full.
+     *
+     * Returns false when the task was cancelled while waiting to enter, in
+     * which case the caller must return immediately (the task is already
+     * resolved by `cancel()`).
+     */
+    *enterImplicitThread(thread) {
+        assert_(this.state === "initial", "enter_implicit_thread after start");
+        this.implicitThread = thread;
+        if (this.ft.async === true) {
+            const hasBackpressure = () => this.inst.backpressure > 0 ||
+                (this.needsExclusive() && this.inst.exclusiveThread !== null);
+            // The `num_waiting_to_enter > 0` disjunct is what makes entry a queue
+            // rather than a stampede: once anyone is waiting, later arrivals wait
+            // too, even if backpressure has since cleared.
+            if (hasBackpressure() || this.inst.numWaitingToEnter > 0) {
+                this.inst.numWaitingToEnter += 1;
+                let cancelled;
+                try {
+                    cancelled = yield* thread.waitUntil(() => !hasBackpressure(), true);
+                }
+                finally {
+                    this.inst.numWaitingToEnter -= 1;
+                }
+                if (cancelled) {
+                    this.cancel();
+                    return false;
+                }
+            }
+            if (this.needsExclusive()) {
+                assert_(this.inst.exclusiveThread === null, "entering with the exclusive thread already taken");
+                this.inst.exclusiveThread = thread;
+            }
+        }
+        if (ADMIT_TRACE) {
+            console.error(`[admit] task=${dbgId(this)} thread=${dbgId(thread)}`);
+        }
+        this.registerThread(thread);
+        return true;
+    }
+    /** definitions.py `Task.register_thread` (line 497). */
+    registerThread(thread) {
+        assert_(!this.threads.includes(thread) && thread.task === this, "register_thread of a foreign or duplicate thread");
+        this.threads.push(thread);
+        assert_(thread.index === null, "register_thread of an indexed thread");
+        thread.index = this.inst.threads.add(thread);
+    }
+    /** definitions.py `Task.exit_implicit_thread` (line 503). */
+    exitImplicitThread(thread) {
+        assert_(thread === this.implicitThread, "exit of a non-implicit thread");
+        this.unregisterThread(thread);
+        if (this.ft.async === true && this.needsExclusive()) {
+            // definitions.py lines 506-508, verbatim shape: assert-held, then
+            // release. The former release-if-held tolerance existed only for the
+            // removed release-at-BLOCK divergence (issue #43); under the hold rule
+            // the implicit thread of a needs-exclusive task holds the slot from
+            // `enter_implicit_thread` to here, without exception.
+            assert_(this.inst.exclusiveThread === thread, "exit_implicit_thread without holding the exclusive thread");
+            this.inst.exclusiveThread = null;
+        }
+    }
+    /** definitions.py `Task.unregister_thread` (line 510). */
+    unregisterThread(thread) {
+        const i = this.threads.indexOf(thread);
+        assert_(i !== -1 && thread.task === this, "unregister of a foreign thread");
+        this.threads.splice(i, 1);
+        if (this.threads.length === 0) {
+            trapIf(this.state !== "resolved", "task finished all threads without resolving");
+            assert_(this.numBorrows === 0, "task exited with live borrows");
+        }
+        assert_(thread.index !== null, "unregister of an unindexed thread");
+        this.inst.threads.remove(thread.index);
+        thread.index = null;
+    }
+    /**
+     * definitions.py `Task.request_cancellation` (line 519). Delivered to a
+     * cancellable thread if one exists and the instance is enterable; otherwise
+     * recorded as pending, to be picked up at the next cancellable block point
+     * (`deliverPendingCancel`).
+     */
+    requestCancellation(caller) {
+        if (this.state === "initial") {
+            this.state = "cancel-delivered";
+            this.implicitThread.resume(CANCELLED_TRUE);
+            return;
+        }
+        assert_(this.state === "started", `request_cancellation in state ${this.state}`);
+        let candidates = this.threads.filter((t) => t.cancellable);
+        const excludeImplicit = this.ft.async === true && this.needsExclusive() &&
+            this.inst.exclusiveThread !== null &&
+            this.inst.exclusiveThread !== this.implicitThread;
+        if (excludeImplicit) {
+            candidates = candidates.filter((t) => t !== this.implicitThread);
+        }
+        // Suspension points of this task's activation are frames OF the implicit
+        // thread, so they obey the same exclusion (definitions.py line 526: with
+        // another thread holding the exclusive slot, the implicit thread may not
+        // run).
+        if (!excludeImplicit) {
+            const store = this.inst.store;
+            for (const w of store.waiting) {
+                if (w.task === this && w.cancellable === true &&
+                    !candidates.includes(w)) {
+                    candidates.push(w);
+                }
+            }
+        }
+        if (candidates.length > 0 && this.inst.mayEnterFrom(caller)) {
+            this.state = "cancel-delivered";
+            this.inst.enterFrom(caller);
+            try {
+                chooseCandidate(candidates).resume(CANCELLED_TRUE);
+            }
+            catch (e) {
+                // Deliberately NOT a `finally`, mirroring `Store.tick`'s
+                // bracket-break discipline (scheduler.ts): the reference wraps the
+                // delivery `resume(Cancelled.TRUE)` in no handler at all
+                // (definitions.py `Task.request_cancellation`, lines 519-532; the
+                // delivery is line 531), so a Trap escaping it never reaches
+                // `leave_to` on line 532 — the entered set stays locked, i.e. the
+                // Component Model's instance poisoning. A `finally` here would
+                // un-poison a half-unwound callee.
+                //
+                // Capability signals are the exception, exactly as in `tick`: they
+                // mark this RUNTIME incomplete, not the component faulted, and in
+                // the reference the blocking operation completes and `leave_to` IS
+                // reached.
+                if (e instanceof NeedsJspi || e instanceof PendingCapability) {
+                    this.inst.leaveTo(caller);
+                }
+                else {
+                    // The synthetic root is released so the poisoning stays
+                    // per-instance (plan v3 amendment 4); for a guest caller the
+                    // entering set is the leaf alone and the release is a no-op.
+                    this.inst.releaseSyntheticRootOnPoison();
+                    notifyInstancePoisoned(this.inst, e);
+                }
+                throw e;
+            }
+            this.inst.leaveTo(caller);
+        }
+        else {
+            this.state = "pending-cancel";
+        }
+    }
+    /** definitions.py `Task.deliver_pending_cancel` (line 536). */
+    deliverPendingCancel(cancellable) {
+        if (cancellable && this.state === "pending-cancel") {
+            this.state = "cancel-delivered";
+            return true;
+        }
+        return false;
+    }
+    /** definitions.py `Task.start` (line 542). */
+    start() {
+        assert_(this.state === "initial", "start on a started task");
+        this.state = "started";
+        return this.onStart();
+    }
+    /** definitions.py `Task.return_` (line 547). */
+    return_(result) {
+        trapIf(this.state === "resolved", "task.return on a resolved task");
+        // Wording parity with wasmtime's exit-time check, pinned by
+        // drop-cross-task-borrow.wast:309.
+        trapIf(this.numBorrows > 0, "borrow handles still remain at the end of the call");
+        this.onResolve(result);
+        this.state = "resolved";
+    }
+    /** definitions.py `Task.cancel` (line 554). */
+    cancel() {
+        trapIf(this.state !== "cancel-delivered", "task.cancel without a delivered cancellation request");
+        // Same definitions.py check as `return_` (num_borrows at exit); same
+        // call-end wording.
+        trapIf(this.numBorrows > 0, "borrow handles still remain at the end of the call");
+        this.onResolve(null);
+        this.state = "resolved";
+    }
+}
+/** Convenience re-exports so `../task/mod.ts` remains the single entry point. */
+export { Store, Subtask, Thread, Waitable, WaitableSet };