@polyengine/runtime 0.5.1 → 0.6.0

package/types/jspi/bridge.d.ts

@@ -8,7 +8,8 @@ export type SuspensionMode = "plain" | "jspi";
  * `requested` is the embedder's opt-in. We additionally require the engine to
  * actually implement JSPI: on an engine without it every blocking site falls
  * back to the precise `NeedsJspi` it raised before this module existed, which
- * is the M3 browser-matrix degradation path (docs/milestones.md M3).
+ * is the browser-matrix degradation path for engines without JSPI (see
+ * `just browsers`).
  */
 export declare function chooseMode(requested: boolean | undefined, needed?: boolean): SuspensionMode;
 /**
@@ -140,8 +141,8 @@ export declare class SuspensionPoint<T = unknown> implements SchedulableThread {
      * transition this point takes — produce-success, produce-throw, or
      * `abandon` (issue #102). It is the seam a blocking built-in uses to
      * discharge state it owns for the duration of the park (the FACT
-     * start-calls' borrow-lender scopes, contracts/intrinsics.md v0.2
-     * amendment 2) without having to trust that `produce` runs.
+     * start-calls' borrow-lender scopes, contracts/intrinsics.md §A's
+     * trap-unwind/lender-release obligation) without having to trust that `produce` runs.
      *
      * INVARIANTS this hook must respect, so bridge.ts's own contracts are
      * not disturbed:
@@ -180,8 +181,8 @@ export declare class SuspensionPoint<T = unknown> implements SchedulableThread {
      * transition this point takes — produce-success, produce-throw, or
      * `abandon` (issue #102). It is the seam a blocking built-in uses to
      * discharge state it owns for the duration of the park (the FACT
-     * start-calls' borrow-lender scopes, contracts/intrinsics.md v0.2
-     * amendment 2) without having to trust that `produce` runs.
+     * start-calls' borrow-lender scopes, contracts/intrinsics.md §A's
+     * trap-unwind/lender-release obligation) without having to trust that `produce` runs.
      *
      * INVARIANTS this hook must respect, so bridge.ts's own contracts are
      * not disturbed:

package/types/plan/format.d.ts

@@ -53,10 +53,9 @@ export interface WirePlan {
      * `ResourceIndex = importedResources.length + DefinedResourceIndex`
      * (wasmtime `Component::resource_index`).
      *
-     * plan-format.md v0.1 amendment #2 documents this as a *gap*; the field is
-     * a **v0.2 proposal** emitted by the shim. Optional here so plans produced
-     * by a v0.1 shim still load — absent is read as "no imported resources",
-     * which is exactly what v0.1 asserted.
+     * The `importedResources` field (contracts/plan-format.md schema); optional
+     * here so plans produced by an older shim still load — absent is read as
+     * "no imported resources".
      */
     importedResources?: WireImportedResource[];
     imports: WireImport[];
@@ -157,9 +156,9 @@ export interface WireExportItem {
 }
 /**
  * Trampoline declarations, tag-for-tag with the wasmtime `Trampoline` enum.
- * Only the M0-relevant variants are given precise field types; the rest are
- * matched by `kind` and rejected at instantiate time with milestone-aware
- * errors (contracts/intrinsics.md §B).
+ * Only the variants the executor implements are given precise field types;
+ * the rest are matched by `kind` and rejected at instantiate time with
+ * capability-aware errors (contracts/intrinsics.md §B).
  * @internal
  */
 export type WireTrampoline = {
@@ -190,8 +189,9 @@ export type WireTrampoline = {
      */
     results: number;
     /**
-     * `results` interned into `plan.types` as a tuple type (plan v3,
-     * contracts/plan-format.md v3 amendment 3). `null` is accepted on the
+     * `results` interned into `plan.types` as a tuple type (the task-return
+     * trampoline's raw `results` key + interned `resultType`;
+     * contracts/plan-format.md schema). `null` is accepted on the
      * wire for a task with no declared result type; the current producer
      * never emits it (wasmtime's `TaskReturn.results` is not an `Option` —
      * a no-result task carries the empty tuple).
@@ -343,7 +343,8 @@ export type WireExport = {
 }
 /**
  * An exported embedded core module; `module` indexes the static module
- * space (`modules`). plan-format.md v4 amendment 2.
+ * space (`modules`); the `module` export kind (contracts/plan-format.md
+ * schema notes).
  */
  | {
     kind: "module";

package/types/plan/loader.d.ts

@@ -35,7 +35,7 @@ export declare class TranslateError extends Error {
  * the *resource*-table mapping before, a different space) — and
  * `task-return`'s `resultType` / raw `results` split, which lets a FACT
  * callee task carry its declared result type.
- * v2 (M2 phase 2c): `streamTables` / `futureTables` — the element types the
+ * v2: `streamTables` / `futureTables` — the element types the
  * stream and future built-ins need to size their copy buffers.
  * v1 (contracts/plan-format.md v0.3): `CoreDef` gained `"unsafe-intrinsic"`.
  * The change is purely additive, but the contract's compat rule is a strict
@@ -72,7 +72,7 @@ export interface LoadedPlan {
     /**
      * Number of imported resource types. `ResourceIndex =
      * numImportedResources + DefinedResourceIndex`
-     * (plan-format.md v0.1 amendment #2 / v0.2 `importedResources`).
+     * (the `importedResources` field; contracts/plan-format.md schema).
      */
     numImportedResources: number;
     /** Element type per stream table (plan v2); `null` = zero-width payload. */

package/types/shim/translator.d.ts

@@ -18,8 +18,8 @@ export declare class Translator {
      * (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
+     * patch or a different toolchain producing different codegen). Digesting
+     * the actual bytes is the only sound cache key
      * component for translator identity.
      */
     readonly buildHash: string | null;

package/types/task/mod.d.ts

@@ -1,4 +1,5 @@
 import { Table } from "../cabi/handles.js";
+import { COMPONENT_INSTANCE } from "../cabi/context.js";
 import type { ComponentInstanceLike } from "../cabi/context.js";
 import type { ComponentValue, FuncType } from "../cabi/types.js";
 import { type Cancelled, Store } from "./scheduler.js";
@@ -10,8 +11,6 @@ export * from "./thread.js";
 export * from "./waitable.js";
 export * from "./subtask.js";
 export * from "./streams.js";
-/** Constructor marker: "this one IS the root, do not give it a parent". */
-declare const ROOT_TOKEN: unique symbol;
 /** Anything a component instance's handle table can hold. */
 export type HandleTableEntry = unknown;
 /**
@@ -21,8 +20,19 @@ export type HandleTableEntry = unknown;
  * `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.
+ * may_leave; there is no bitmask). Initial value 1 (true).
+ *
+ * There is no `may_enter` counterpart and no instance tree: at the pinned
+ * reference (definitions.py @ 2f13265, CM#705) there is no `may_enter`,
+ * `parent`, `entering_set`, `enter_from` or `leave_to`, so nothing gates
+ * entry into a live instance. What polyengine adds beyond the reference is
+ * per-instance POISONING — a named divergence
+ * living entirely in ./scheduler.ts (`isInstancePoisoned`, `entryRefusal`),
+ * not in any state on this class.
+ *
+ * `COMPONENT_INSTANCE` brands this class as a real component instance for
+ * the layers that only see the structural `ComponentInstanceLike`
+ * (cabi/handles.ts `isComponentInstance`; cabi must not import task/).
  */
 export declare class ComponentInstanceState implements ComponentInstanceLike {
     readonly index: number;
@@ -30,103 +40,18 @@ export declare class ComponentInstanceState implements ComponentInstanceLike {
     handles: Table<HandleTableEntry>;
     /** definitions.py `ComponentInstance.threads` — a Table, so `thread.index`. */
     readonly threads: Table<Thread>;
-    mayEnter: boolean;
+    /** cabi's real-instance discriminator; see the class doc. */
+    readonly [COMPONENT_INSTANCE] = true;
     /** definitions.py `backpressure: int` — a *counter* (backpressure.{inc,dec}). */
     backpressure: number;
     /** definitions.py `num_waiting_to_enter`. */
     numWaitingToEnter: number;
     /** definitions.py `exclusive_thread`. */
     exclusiveThread: Thread | 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: ComponentInstanceState | null;
     readonly store: 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: Store): ComponentInstanceState;
-    /** Is this the synthetic root (never a real component instance)? */
-    get isSyntheticRoot(): boolean;
-    constructor(index: number, store?: Store, root?: typeof ROOT_TOKEN);
-    /**
-     * 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(): void;
+    constructor(index: number, store?: Store);
     get mayLeave(): boolean;
     set mayLeave(v: boolean);
-    /** definitions.py `ComponentInstance.self_and_ancestors` (line 236). */
-    selfAndAncestors(): Set<ComponentInstanceState>;
-    /**
-     * 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: ComponentInstanceState | null): Set<ComponentInstanceState>;
-    /** definitions.py `ComponentInstance.may_enter_from` (line 214). */
-    mayEnterFrom(caller: ComponentInstanceState | null): boolean;
-    /** definitions.py `ComponentInstance.enter_from` (line 220). */
-    enterFrom(caller: ComponentInstanceState | null): void;
-    /** definitions.py `ComponentInstance.leave_to` (line 225). */
-    leaveTo(caller: ComponentInstanceState | null): void;
-    /** Backwards-compatible host-entry helpers (the M0 spelling). */
-    enter(): void;
-    leave(): void;
 }
 /** definitions.py `Task.State` (line 445). */
 export type TaskState = "initial" | "started" | "pending-cancel" | "cancel-delivered" | "resolved";
@@ -190,7 +115,8 @@ export declare class Task {
      * 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
+     * (the task-return trampoline's raw `results` key + interned `resultType`;
+     * contracts/plan-format.md schema). 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
@@ -238,10 +164,13 @@ export declare class Task {
     /** definitions.py `Task.unregister_thread` (line 510). */
     unregisterThread(thread: Thread): void;
     /**
-     * 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`).
+     * definitions.py `Task.request_cancellation` (@ 2f13265). Delivered to a
+     * cancellable thread if one exists; otherwise recorded as pending, to be
+     * picked up at the next cancellable block point (`deliverPendingCancel`).
+     *
+     * `caller` is retained for the call-site shape (fact_calls.ts's
+     * `subtask.onCancel`) and for diagnostics; no condition here consults it
+     * (CM#705: entry into a live instance is ungated).
      */
     requestCancellation(caller: ComponentInstanceState | null): void;
     /** definitions.py `Task.deliver_pending_cancel` (line 536). */

package/types/task/scheduler.d.ts

@@ -46,8 +46,28 @@ export declare class NeedsJspi extends Error {
 }
 export declare function needsJspi(what: string): never;
 /**
- * Failure raised where a capability scheduled for a later M2 phase is
- * required. Same rationale as `NeedsJspi`: never a `Trap`.
+ * Failure raised when a synchronous entry into an instance would race a
+ * pending lift (contracts/embedder-api.md §"Functions and async",
+ * failure-ladder arm 2).
+ *
+ * In jspi mode a promising-wrapped entry settles through a microtask hop even
+ * when nothing suspended, and the hop-quiescence gate (exec/boundary.ts)
+ * defers Promise-surface calls that would enter during that window. A
+ * synchronous caller — a resource constructor, or the embedder's `sync()`
+ * adapter — cannot be deferred, so it refuses instead.
+ *
+ * Deliberately *not* a `Trap`, and deliberately raised BEFORE the instance is
+ * entered: nothing was entered, so there is nothing to poison. The refusal is
+ * transient — the instance stays enterable, and the call succeeds on retry
+ * once the in-flight activity settles, or immediately through the
+ * Promise-shaped surface, which defers rather than refusing.
+ */
+export declare class SyncEntryBusy extends Error {
+    constructor(what: string);
+}
+/**
+ * Failure raised where a not-yet-implemented capability is required. Same
+ * rationale as `NeedsJspi`: never a `Trap`.
  */
 export declare class PendingCapability extends Error {
     constructor(what: string);
@@ -65,17 +85,6 @@ export declare function notifyInstancePoisoned(inst: {
     handles: Iterable<unknown>;
 }, cause: unknown): void;
 export declare function isInstancePoisoned(inst: object): boolean;
-/**
- * May a settled activation tail for parked thread `t` be DISPATCHED now
- * (issue #156)? True iff its instance is host-enterable — `Thread.resumeWith`
- * brackets the resumption with `enterFrom(null)` — or POISONED, in which case
- * `resumeWith`'s early return retires it and deferring would leak forever.
- *
- * CONTRACT: a parked entry without a reachable `task.inst` (the partial
- * thread doubles the host-pump tests park in `Store.awaiting`) holds no
- * reentrance state, so there is nothing to defer on: dispatchable.
- */
-export declare function dispatchableTail(t: any): boolean;
 /**
  * The recorded cause of an instance's poisoning: the original trap that
  * broke the enter/leave bracket (polyengine#145). `undefined` when the instance
@@ -85,16 +94,39 @@ export declare function dispatchableTail(t: any): boolean;
 export declare function instancePoisonCause(inst: object): unknown;
 /**
  * Append the recorded poison cause to an entry-refusal trap message
- * (polyengine#145 ask 1). "cannot enter component instance" covers two states
- * that send an embedder down entirely different debugging paths — a
- * transient reentrance overlap (retry later, look for caller-side call
- * overlap) and a permanently poisoned instance (the corpse of an earlier
- * trap, which this suffix names). Only the poisoned case gets the suffix:
- * the transient message stays byte-identical, and the suffix is
+ * (polyengine#145 ask 1). "cannot enter component instance" has exactly one
+ * cause — a permanently poisoned instance, the corpse of an earlier trap —
+ * and this
+ * suffix names the trap that made it one. The call is kept unconditional at
+ * the refusal sites (returning `base` unchanged for an unmarked instance) so
+ * the message construction stays in one place; the suffix is
  * conformance-safe because the official suite matches trap messages by
  * substring (harness/src/runner.ts).
  */
 export declare function withPoisonCause(inst: object, base: string): string;
+/**
+ * The entry-refusal decision, in one place: may `caller` enter `callee` right
+ * now, and if not, what does the refusal trap say? Returns `null` when entry
+ * is allowed, otherwise the exact trap message for `base`.
+ *
+ * POISONING IS THE WHOLE MECHANISM (CM#705). There is no transient
+ * reentrance gate: at the pinned reference (definitions.py @ 2f13265)
+ * `may_enter`, `entering_set`, `enter_from`, `leave_to` and
+ * `ComponentInstance.parent` do not exist — `Store.lift` runs `canon_lift`
+ * with no gate at all, so host-mediated reentrance into a live instance is
+ * simply VALID.
+ *
+ * Against that, per-instance poisoning is polyengine's NAMED DIVERGENCE. A
+ * trapped instance is a corpse — entry is refused permanently, with the
+ * recorded cause appended (polyengine#145 ask 1) — where wasmtime instead
+ * kills the whole store. The reference never faces the question because a
+ * trap there is the end of the world.
+ *
+ * The `caller !== callee` guard keeps a self-call out of the refusal: a dtor
+ * invoked from inside its own instance (cabi/handles.ts) is the live case —
+ * it must not be refused by its own instance's marker.
+ */
+export declare function entryRefusal(callee: object, caller: unknown, base: string): string | null;
 /** Test hook: switch policy at runtime. `null` restores FIFO. */
 export declare function schedulerSeedForTesting(value: number | null): void;
 /**
@@ -277,22 +309,18 @@ export declare class Store {
      * wedges the loops, because an activation that merely hopped legitimately
      * holds an ambient while the scheduler is free to proceed.
      *
-     * PER-STORE and MULTI-ENTRY since 2026-08-22 (issues #158 mechanism B,
-     * #210). It was one module-global slot with a one-claimant assert, which
-     * (a) could not represent two legitimately-pending engine resumptions — a
-     * running activation X delivering a resume to Z while Y's resumption was
-     * still pending crashed on the assert — and (b) made every driver on every
-     * store yield while ANY store held a claim, so an idle store's
-     * `driveStoreAsync` died at the 10,000-hop assert (~311ms) while another
-     * store merely dwelt on a slow host import. The assert's invariant was
-     * tier-3 attribution unambiguity, which no longer exists (see
-     * `resolveAmbient`), so it is gone with the slot; the entries and their
-     * release edges are otherwise unchanged, per entry.
+     * PER-STORE and MULTI-ENTRY (issues #158 mechanism B, #210), both load
+     * bearing. MULTI-ENTRY because two engine resumptions can legitimately be
+     * pending at once: a running activation X may deliver a resume to Z while
+     * Y's resumption is still outstanding, and a one-claimant gate cannot
+     * represent that. PER-STORE because a claim held store-wide makes every
+     * driver on EVERY store yield: an idle store's `driveStoreAsync` dies at
+     * the 10,000-hop assert (~311ms) while another store merely dwells on a
+     * slow host import.
      *
      * Cross-store de-serialization is safe by disjointness: an activation
-     * belongs to exactly one store. Same-store it is strictly more conservative
-     * than the old slot — the gate keeps refusing until EVERY pending entry has
-     * died, rather than crashing on the second.
+     * belongs to exactly one store. Same-store the set is conservative — the
+     * gate keeps refusing until EVERY pending entry has died.
      *
      * Release edges, per entry: the activation PARKS again
      * (`blockCurrentActivation` -> `consumePendingIfRunning`), it FINISHES (its
@@ -395,37 +423,28 @@ export declare class Store {
      * throw (trap unwinding); callers propagate or park it exactly as they do
      * for `tick`.
      *
-     * A tail whose instance is NOT host-enterable is DEFERRED IN PLACE — left
-     * in the queue, skipped here — until the lock releases (issue #156).
-     * `resumeWith` brackets the resumption with `enterFrom(null)`, and under
-     * the shared synthetic per-instantiation root a host entry into ANY
-     * instance of the graph locks the root, so while one instance is entered a
-     * sibling's tail cannot be dispatched: dispatching it tripped
-     * `resumeWith`'s enterability assert (which, mutating before asserting,
-     * also stranded the thread and lost the settle).
+     * Every non-stale tail is dispatched immediately, in queue order: there is
+     * no enterability condition to defer on (CM#705).
      *
-     * Deferral is safe because `!inst.mayEnterFrom(null)` is EXACTLY `tick`'s
-     * candidate-filter predicate on the same instance: while a tail of `inst`
-     * is deferred, `tick` cannot resume any thread of `inst` either, so the
-     * phantom-state gate the queue exists to enforce is preserved per-instance
-     * by construction.
+     * The ordering discipline is therefore settle order, full stop — and it is
+     * the reason this queue exists rather than a direct resumption from the
+     * settle continuation: in definitions.py the tail runs atomically inside
+     * the entered bracket, so the phantom-state gate (`tick` refuses while an
+     * unserviced tail is queued, see `hasServiceableSettled`) is what keeps a
+     * parked activation's tail from being observed out of order.
      *
-     * The ordering discipline is therefore per-instance settle order. Cross-
-     * instance order relaxes only when enterability defers a tail, which is
-     * conforming schedule nondeterminism: in definitions.py the tail runs
-     * atomically inside the entered bracket, so a host entry admitted during a
-     * park necessarily orders before the parked activation's tail there.
-     *
-     * A POISONED instance's tail is still dispatched: `resumeWith`'s poison
-     * early-return retires it, and deferring it would leak forever — a
-     * poisoned leaf keeps its lock permanently.
+     * A POISONED instance's tail is dispatched like any other: `resumeWith`'s
+     * poison early-return retires it, so it drains rather than leaking.
      */
     serviceSettled(): boolean;
     /**
-     * "Would a `serviceSettled` call make progress right now?" — i.e. some
-     * entry is stale (would be removed) or serviceable (would be dispatched).
-     * A queue holding ONLY deferred tails (issue #156) answers false: `tick`
-     * must not be gated by them, and the driving loops must not spin on them.
+     * "Would a `serviceSettled` call make progress right now?" — i.e. is any
+     * entry queued at all. Every entry either dispatches or is dropped as
+     * stale, so a non-empty queue always makes progress.
+     *
+     * It exists to gate `tick` (and to keep the driving loops from parking)
+     * behind unserviced tails: resuming some other thread while a settled tail
+     * waits would expose the out-of-order state the queue is there to prevent.
      */
     hasServiceableSettled(): boolean;
     /**
@@ -473,9 +492,9 @@ export declare class Store {
      */
     hasRunnableWork(inst: unknown, excludeTask: unknown): boolean;
     /**
-     * definitions.py `Store.tick` (line 597): resume one ready thread, bracketed
-     * by the reentrance gate for a host-initiated entry (`enter_from(None)` /
-     * `leave_to(None)`).
+     * definitions.py `Store.tick` (@ 2f13265): resume one ready thread. There
+     * is no bracket and no gate — the reference body is exactly "pick a ready
+     * thread, resume it" (CM#705).
      *
      * Returns false when no thread was ready, so callers can distinguish
      * "made progress" from "stuck" without inspecting the queue themselves.

package/types/task/streams.d.ts

@@ -77,7 +77,7 @@ export interface RendezvousBuffer {
     write(vs: PayloadChunk): void;
 }
 /**
- * A21: the peer half of a direct rendezvous — a buffer that can expose its
+ * direct-access byte edge: the peer half of a direct rendezvous — a buffer that can expose its
  * remaining range as bytes and be advanced without a copy.
  *
  * Implemented by `GuestBuffer` (a view into guest linear memory: the
@@ -99,7 +99,7 @@ export interface ByteWindow {
     endWindow?(): void;
 }
 /**
- * A21: the parked direct session, as the rendezvous sees it. It presents the
+ * direct-access byte edge: the parked direct session, as the rendezvous sees it. It presents the
  * ordinary buffer surface (so `remain()`/`isZeroLength()` keep the reference
  * control flow working) but its `read`/`write` are never called — the seam
  * routes it through `runDirect` instead.
@@ -159,7 +159,7 @@ export declare class SharedStreamImpl implements SharedBase {
      * OUT of a guest table. The receiver — the host, or the destination of a
      * guest-to-guest hop, in which case the immediately following lower fires
      * `onLowered` — may now act on the transferred end. Host wrappers use it to
-     * re-arm their activity (#162, embedder-api amendment A15). Guest-owned
+     * re-arm their activity (#162, contracts/embedder-api.md §"Streams and futures"). Guest-owned
      * objects leave it unset.
      */
     onLifted: ((inst: {
@@ -210,7 +210,7 @@ export declare class SharedFutureImpl implements SharedBase {
      * OUT of a guest table. The receiver — the host, or the destination of a
      * guest-to-guest hop, in which case the immediately following lower fires
      * `onLowered` — may now act on the transferred end. Host wrappers use it to
-     * re-arm their activity (#162, embedder-api amendment A15). Guest-owned
+     * re-arm their activity (#162, contracts/embedder-api.md §"Streams and futures"). Guest-owned
      * objects leave it unset.
      */
     onLifted: ((inst: {
@@ -351,51 +351,35 @@ interface PoisonedInstanceLike {
  * **poisoned** guest instance is retired silently via `resetPending`.
  * Notifying it would queue a phantom event into the corpse's waitables, and
  * a later driving loop servicing it would resume machinery whose instance
- * can no longer be entered (`tick` asserts enterability). Host sentinels are
+ * can no longer be entered (`tick` excludes poisoned instances). Host sentinels are
  * not instances at all, so they are always notified.
  *
- * #100: THE HEALTH TEST IS "POISONED", NOT "`mayEnter === false`". The
- * original test used non-enterability as a proxy for deadness. The proxy is
- * unsound in one direction, and the unsoundness stranded healthy tasks:
- *
- *  * (sound half, #84 audit) a healthy guest peer always parks with
- *    `mayEnter === true`. Every park — the callback ABI's waitable-set wait,
- *    and equally a sync-lowered/JSPI peer blocked inside `finishCopy`'s
- *    SITE 4 via `blockCurrentActivation` — yields the thread out of the
- *    scheduler's enter/leave bracket, and the bracket's `leaveTo` runs on the
- *    way out (task/scheduler.ts `Store.tick` :905-917, task/thread.ts
- *    `Thread.resumeWith` :157-179, whose resume-side
- *    `assert_(mayEnterFrom(null))` would fire otherwise). Blocking inside a
- *    wasm frame does NOT hold the enter bracket.
- *  * (unsound converse) `mayEnter === false` does not imply "poisoned". An
- *    instance that is merely mid-call is also non-enterable, and a CALLER
- *    instance stays non-enterable for the whole duration of a
- *    cross-component (FACT) call into an instance that traps
- *    (`ComponentInstanceState.enterFrom` clears `mayEnter` on the callee's
- *    entering set only, task/mod.ts). A *different*, healthy task of that
- *    caller, parked on an end of a stream/future the trapping callee also
- *    held, was classified dead here and retired silently — stranded, the
- *    exact outcome #66 exists to prevent.
+ * #100: THE HEALTH TEST IS "POISONED", NOT "BUSY". Deadness must be judged
+ * by the poison marker and nothing weaker: any liveness proxy that also
+ * covers a merely mid-call instance is unsound in one direction and strands
+ * healthy tasks. Under such a proxy a caller mid cross-component (FACT) call
+ * into an instance that trapped would drag its *other*, healthy tasks down
+ * with it — one parked on an end of a stream/future the trapping callee also
+ * held would be classified dead here and retired silently, the exact outcome
+ * #66 exists to prevent.
  *
  * So the test consults the poison marker itself. It is per-instance and
- * recorded at the single seam every bracket-break site routes through
+ * recorded at the single seam every poisoning site routes through
  * (`notifyInstancePoisoned`, task/scheduler.ts: exec/boundary.ts `poison`,
  * `Store.tick`, `Thread.resumeWith`, the FACT cross-component catches in
  * intrinsics/fact_calls.ts, and cabi/handles.ts's gated destructor call),
  * and it is recorded *before* the retirement walk runs, so an instance's own
  * parked ends still see it during its own walk. `retiredInstances` is
  * consulted alongside it because the walk is also reachable directly (it is
- * set at walk entry, so the two agree); neither ever contains the synthetic
- * per-instantiation root, which every poison site skips or releases (plan v3
- * amendment 4, `releaseSyntheticRootOnPoison`).
+ * set at walk entry, so the two agree).
  *
  * Why this does not re-open review B2 (phantom events into a corpse): the
  * concern is that a DROPPED event queued onto a waitable of an instance that
  * can never be entered again would be serviced by a later driving loop and
- * resume machinery whose `tick` asserts enterability. "Can never be entered
- * again" is precisely poisoning — a mid-call instance's `mayEnter` is
- * restored by its own `leaveTo` when the call returns, and its parked task
- * then resumes normally and consumes the event. The narrowed predicate
+ * resume machinery `tick` deliberately excludes. "Can never be entered
+ * again" is precisely poisoning — a merely mid-call instance is entirely
+ * ordinary, and its parked task resumes normally and consumes the event.
+ * The narrowed predicate
  * therefore excludes exactly the population B2 is about, and admits only
  * peers that will run again.
  *
@@ -407,8 +391,9 @@ export declare function dropSharedForTeardown(shared: SharedStreamImpl | SharedF
  * Retire every live stream/future end in a trap-poisoned instance's handle
  * table (#66).
  *
- * Rationale: after a trap breaks the enter/leave bracket, `mayEnter` stays
- * false forever, so no task of this instance can ever rendezvous again. Its
+ * Rationale: a trapped instance is a corpse (polyengine's per-instance
+ * poisoning divergence), so no task of this instance can ever rendezvous
+ * again. Its
  * table's `CopyEnd`s are therefore unreachable-forever — leaving their shared
  * objects live strands the peers: a parked HOST operation never settles (its
  * promise hangs), and a LATER host operation would "succeed" against the
@@ -416,7 +401,7 @@ export declare function dropSharedForTeardown(shared: SharedStreamImpl | SharedF
  * Dropping the shared object now converts both into the spec-shaped DROPPED
  * outcome, and the recorded failure lets the embedder layer brand it.
  *
- * Called from every bracket-break site — exec/boundary.ts `poison()` (the
+ * Called from every poisoning site — exec/boundary.ts `poison()` (the
  * sync-lift path), scheduler.ts `Store.tick` and thread.ts
  * `Thread.resumeWith` (traps during a resumed thread), and the FACT
  * cross-component catches (intrinsics/fact_calls.ts, callee side) — with the

package/types/task/subtask.d.ts

@@ -54,8 +54,8 @@ export declare class Subtask extends Waitable {
     /**
      * 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).
+     * an abandoned park (contracts/intrinsics.md §A's trap-unwind/lender-release
+     * obligation; 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

package/types/task/waitable.d.ts

@@ -12,7 +12,6 @@ export declare enum EventCode {
 }
 /** definitions.py `EventTuple` = `(EventCode, int, int)`. */
 export type EventTuple = [code: EventCode, p1: number, p2: number];
-export declare const NO_EVENT: EventTuple;
 /**
  * definitions.py `class Waitable` (line 767).
  *