@polyengine/runtime 0.3.1-pre.gf4b740b → 0.3.1

package/esm/exec/boundary.js

@@ -4,7 +4,7 @@
 // canonical options — docs/architecture.md §4.3 items 2 and 5, degenerate sync case.
 import { coreFuncTypeEquals, CoreValueIter, flattenFunctype, liftFlatValues, LiftLowerContext, lowerFlatValues, MAX_FLAT_ASYNC_PARAMS, MAX_FLAT_PARAMS, MAX_FLAT_RESULTS, trap, trapIf, } from "../cabi/mod.js";
 import { AssertionError, assert_ } from "../cabi/trap.js";
-import { driveSyncLift, clearResumingThread, EventCode, withActivation, hasRealHostCall, hasResumingThread, dispatchableTail, NeedsJspi, needsJspi, setResumingThread, packSubtaskResult, PendingCapability, notifyInstancePoisoned, realHostCalls, storeQuiescent, Subtask, WaitableSet, SubtaskState, Task, Thread, withPoisonCause, } from "../task/mod.js";
+import { driveSyncLift, EventCode, withActivation, hasRealHostCall, dispatchableTail, NeedsJspi, needsJspi, packSubtaskResult, PendingCapability, notifyInstancePoisoned, realHostCalls, storeQuiescent, Subtask, WaitableSet, SubtaskState, Task, Thread, withPoisonCause, } from "../task/mod.js";
 import { currentTask } from "../task/scheduler.js";
 import { PlanError } from "../plan/loader.js";
 import { blockCurrentActivation, enterWasm, } from "../jspi/mod.js";
@@ -290,7 +290,7 @@ function traceDrive(loop, store, done, branch) {
         `waiting=${store.waiting.length}{${waiters}} ` +
         `awaiting=${store.awaiting.size} ` +
         `hostCalls=${store.pendingHostCalls.size} ` +
-        `awaiters={${awaiters}} claim=${hasResumingThread()} done=${doneVerdict}`);
+        `awaiters={${awaiters}} pending=${store.pendingResumptions.size} done=${doneVerdict}`);
 }
 /**
  * Pump `store` until `done()` holds. Returns `undefined` if that was achieved
@@ -326,10 +326,10 @@ function drive(store, done, what) {
         }
         // A thread parked on a Promise (jspi) can only progress after a microtask
         // turn, exactly like an outstanding host call. So can an outstanding
-        // ambient claim: a suspension has been settled and its activation has not
-        // run yet (see `Store.tick`).
-        if (store.awaiting.size > 0 || hasResumingThread()) {
-            traceDrive("drive", store, done, "->async(awaiting/claim)");
+        // pending resumption of THIS store: a suspension has been settled and its
+        // activation has not run yet (see `Store.tick`).
+        if (store.awaiting.size > 0 || store.hasPendingResumptions()) {
+            traceDrive("drive", store, done, "->async(awaiting/pending)");
             return driveAsync(store, done, what);
         }
         if (store.pendingHostCalls.size === 0) {
@@ -407,9 +407,15 @@ export async function driveStoreAsync(store, done, what) {
  *       racing the same parked thread await the *same* tag object and see one
  *       settlement, not two independent ones. This is what makes (a)'s
  *       "queued at tag settlement" premise hold across loops.
- *   (c) The ambient resume claim (`setResumingThread`) serializes the claim
- *       path: a second claimant while one is live is asserted against, and
- *       every loop yields at its top while `hasResumingThread()`.
+ *   (c) The store's pending-resumption set (`Store.pendingResumptions`)
+ *       serializes the resumption path WITHIN a store: every loop driving
+ *       that store yields at its top while `store.hasPendingResumptions()`,
+ *       so a settled activation runs before anything else is scheduled.
+ *       (Until 2026-08-22 this was a module-global single slot with a
+ *       one-claimant assert; per-store multi-entry replaced it — issues #158
+ *       mechanism B and #210. Overlapping loops in the sense meant here are
+ *       loops on the SAME store, which is exactly what (c) still covers;
+ *       loops on different stores never shared a settlement to race for.)
  *
  * (a) is the guarantee; (b) and (c) are what make (a) apply across loops
  * rather than only within one. The one corner (a) does NOT cover — a thread
@@ -610,22 +616,29 @@ async function driveAsync(store, done, what) {
             store.serviceSettled();
             if (store.hostFailure !== undefined)
                 throw takeHostFailure(store);
-            // A live claim is an engine-driven resumption in flight: its activation
-            // has not yet parked again or finished. It will die on its own — parking
-            // consumes it (`blockCurrentActivation`), finishing releases it
-            // (`Store.noteAwaiting`'s settle continuation) — so yield microtasks
-            // until it does. The driver must NOT blanket-clear here: the claim may
-            // have been taken by a guest built-in settling another activation's
-            // suspension (`subtask.cancel` delivering a cancellation), and clearing
-            // it before that activation runs re-opens the mis-attribution window the
-            // claim exists to close.
-            if (hasResumingThread()) {
-                traceDrive("driveAsync", store, done, "yield-claim");
-                // Bounded: a claim that never dies is an internal bug (every path out
-                // of a resumed activation releases it — park, finish, trap), and a
-                // pure-microtask wait would otherwise starve the event loop and every
-                // stall timer with it. Interleave macrotask hops so timers stay alive,
-                // and fail loudly rather than spin forever.
+            // A pending resumption of THIS store is an engine-driven resumption in
+            // flight: its activation has not yet parked again or finished. It will
+            // die on its own — parking consumes it (`blockCurrentActivation`),
+            // finishing releases it (`Store.noteAwaiting`'s settle continuation) — so
+            // yield microtasks until it does. The driver must NOT blanket-clear here:
+            // an entry may have been taken by a guest built-in settling another
+            // activation's suspension (`subtask.cancel` delivering a cancellation),
+            // and clearing it before that activation runs re-opens the
+            // mis-attribution window the entry exists to close.
+            //
+            // PER-STORE (issue #210): this gate used to read a module-global slot, so
+            // an idle store's driver spun here — and died at the hop bound below in
+            // ~311ms — merely because ANOTHER store's guest was dwelling on a slow
+            // host import. Activations never cross stores; another store's pending
+            // resumption is none of this loop's business.
+            if (store.hasPendingResumptions()) {
+                traceDrive("driveAsync", store, done, "yield-pending");
+                // Bounded: a pending entry that never dies is an internal bug (every
+                // path out of a resumed activation releases it — park, finish, trap),
+                // and a pure-microtask wait would otherwise starve the event loop and
+                // every stall timer with it. Interleave macrotask hops so timers stay
+                // alive, and fail loudly rather than spin forever. Scoped per store,
+                // this is again the internal-bug detector it was meant to be.
                 claimHops++;
                 assert_(claimHops < 10_000, "driveAsync: a resumed-activation claim was never released " +
                     "(the activation neither parked, finished, nor trapped)");
@@ -663,7 +676,7 @@ async function driveAsync(store, done, what) {
             // Only a SERVICEABLE tail is a reason to loop again: a queue holding
             // only tails DEFERRED on a non-enterable instance (issue #156) would
             // spin this loop hot — nothing in the cycle awaits.
-            if (store.hasServiceableSettled() || hasResumingThread()) {
+            if (store.hasServiceableSettled() || store.hasPendingResumptions()) {
                 continue;
             }
             // Service promise-parked threads (jspi).
@@ -700,7 +713,7 @@ async function driveAsync(store, done, what) {
                 // without this check it presents as a silent stall instead -- which is
                 // exactly what `tests/jspi/deadlock_test.ts` caught the moment site 2
                 // was lit.
-                if (store.pendingHostCalls.size === 0 && !hasResumingThread()) {
+                if (store.pendingHostCalls.size === 0 && !store.hasPendingResumptions()) {
                     traceDrive("driveAsync", store, done, "deadlock-probe");
                     // Exclude threads whose settle is already QUEUED in `store.settled`
                     // (issue #156): their promise has settled, so racing them wins
@@ -757,7 +770,7 @@ async function driveAsync(store, done, what) {
                         // await always has a `pendingHostCalls` entry, which fails this
                         // probe's precondition); keeping it loud is what makes it an
                         // internal-wedge detector rather than dead code.
-                        if (store.pendingHostCalls.size > 0 || hasResumingThread() ||
+                        if (store.pendingHostCalls.size > 0 || store.hasPendingResumptions() ||
                             store.hasServiceableSettled()) {
                             continue;
                         }
@@ -838,25 +851,31 @@ async function driveAsync(store, done, what) {
                 for (const h of store.pendingHostCalls) {
                     others.push(h.then(() => null, () => null));
                 }
-                // A SPECULATIVE claim: the chosen thread is a promising-wrapped
+                // A SPECULATIVE entry: the chosen thread is a promising-wrapped
                 // activation, and the engine may run its wasm during this await (pin
-                // (i)). It is released unconditionally on the way out — if the
-                // activation is genuinely mid-resumption its own exact claim (minted by
-                // `SuspensionPoint.resume`) is what carries it, and releasing a claim
-                // that names a thread already gone from the queue is a no-op.
-                setResumingThread(chosen);
+                // (i)). It is dropped on the way out — if the activation is genuinely
+                // mid-resumption its own exact entry (minted by
+                // `SuspensionPoint.resume`) is what carries it, and dropping an entry
+                // that names a thread already gone from the set is a no-op.
+                //
+                // ONLY ITS OWN ENTRY (issue #158): the `finally` used to blanket-clear
+                // the single global slot, so a guest-synchronous delivery during the
+                // await — which takes a fresh entry of its own — had that entry
+                // clobbered early, re-opening the window it exists to close. With a set
+                // we can name exactly what we added.
+                store.addPendingResumption(chosen);
                 let winner;
                 try {
                     winner = await Promise.race([chosenTag, ...others]);
                 }
                 finally {
-                    clearResumingThread();
+                    store.removePendingResumption(chosen);
                 }
                 // Resume whichever thread actually settled -- not necessarily the one we
                 // claimed. Resuming only the claimed thread would spin: its promise may
                 // never settle, the same thread would be chosen again next turn, and the
                 // already-settled tags would win the race instantly forever (observed as
-                // an OOM, not a hang). The claim is cleared above before any resumption,
+                // an OOM, not a hang). Our own entry is dropped above before any resumption,
                 // exactly as on the original single-promise path, so this does not widen
                 // the ambient window; it only ensures the loop always makes progress.
                 // Membership is not enough: the corner it misses is a thread the OTHER

package/esm/exec/executor.js

@@ -82,8 +82,26 @@ class Executor {
      * another.
      */
     store = new Store();
-    /** Memoized `unsafe-intrinsic` core functions, by symbol. */
+    /**
+     * Memoized `unsafe-intrinsic` core functions, by DECLARING COMPONENT
+     * INSTANCE and symbol.
+     *
+     * The instance is part of the key because `context.{get,set}` resolve their
+     * thread against it (`currentThreadForInstance`, task/scheduler.ts): the
+     * declaring instance is the one whose core frame is executing when the
+     * intrinsic is called, which is what keeps a JSPI continuation chunk's
+     * `context.set` out of a sibling task's slots. `null` keys the shared
+     * adapter/instance-less flavour (the plan records `instance: null` for FACT
+     * adapter modules).
+     */
     unsafeIntrinsics = new Map();
+    /**
+     * The component instance of the core module currently being instantiated
+     * (`instantiate-module`'s `instance` field; null for a FACT adapter). Read
+     * by `unsafeIntrinsic` while its import list is being resolved — the one
+     * place a core instance's owning component instance is stated by the plan.
+     */
+    #declaringInstance = null;
     /** The single in-flight FACT `prepare-call` state (intrinsics/fact_calls.ts). */
     preparedCall = { current: null };
     /**
@@ -353,6 +371,13 @@ class Executor {
                     // suspension point; every function it exports is therefore
                     // potentially-blocking, and everything else is not.
                     this.sawBlockingImport = false;
+                    // Which component instance this core module belongs to — the plan
+                    // states it here and nowhere else (`instance: null` = FACT adapter,
+                    // contracts/plan-format.md). `unsafeIntrinsic` reads it while the
+                    // import list below is resolved.
+                    this.#declaringInstance = init.instance === null
+                        ? null
+                        : this.componentInstance(init.instance);
                     // ISSUE #88: core wasm permits two imports with the same
                     // (module, field) pair (trusted wasmtime-environ 47.0.3 info.rs
                     // :438-445 gives one flat positional CoreDef per import slot, but
@@ -390,6 +415,10 @@ class Executor {
                             {})[imp.name] =
                             value;
                     });
+                    // Scoped strictly to the import list above: a CoreDef resolved by
+                    // any other initializer (extract-*, resource dtors) names no core
+                    // module, so it must not inherit this one's instance.
+                    this.#declaringInstance = null;
                     let instance;
                     try {
                         instance = await WebAssembly.instantiate(module, importObject);
@@ -670,10 +699,12 @@ class Executor {
         return m;
     }
     unsafeIntrinsic(symbol) {
-        let fn = this.unsafeIntrinsics.get(symbol);
+        const inst = this.#declaringInstance;
+        const key = `${inst === null ? "-" : inst.index}\0${symbol}`;
+        let fn = this.unsafeIntrinsics.get(key);
         if (fn === undefined) {
-            fn = createUnsafeIntrinsic(symbol);
-            this.unsafeIntrinsics.set(symbol, fn);
+            fn = createUnsafeIntrinsic(symbol, inst);
+            this.unsafeIntrinsics.set(key, fn);
         }
         return fn;
     }

package/esm/intrinsics/context.js

@@ -10,7 +10,7 @@
 // memory access for wasmtime's own internals; they have no portable meaning
 // in a JS host and are refused at instantiate time.
 import { assert_, trapIf } from "../cabi/trap.js";
-import { currentThread } from "../task/mod.js";
+import { currentThreadForInstance } from "../task/mod.js";
 import { ambientDebug, dbgId } from "../task/scheduler.js";
 import { UnsupportedFeatureError } from "./errors.js";
 /**
@@ -28,8 +28,8 @@ export const NUM_CONTEXT_SLOTS = 2;
  * in slot 0, which is why this intrinsic is the entry blocker for async
  * guests.
  */
-export function canonContextGet(i) {
-    const thread = currentThread();
+export function canonContextGet(i, inst) {
+    const thread = currentThreadForInstance(inst);
     assert_(i < NUM_CONTEXT_SLOTS, `context.get slot ${i} out of range`);
     const result = thread.storage[i];
     assert_(result < 2 ** 32, "context.get value out of i32 range");
@@ -53,11 +53,11 @@ export function ctxThreadId(t) {
 }
 function trace(msg, thread) {
     const a = ambientDebug();
-    console.error(`[ctx] ${ctxThreadId(thread)} ${msg} storage=${JSON.stringify(thread.storage)} | stack=[${a.stack.map(ctxThreadId).join(",")}] claims=[${a.claims.map(ctxThreadId).join(",")}] resuming=${a.resuming === null ? "-" : ctxThreadId(a.resuming)}`);
+    console.error(`[ctx] ${ctxThreadId(thread)} ${msg} storage=${JSON.stringify(thread.storage)} | stack=[${a.stack.map(ctxThreadId).join(",")}] claims=[${a.claims.map(ctxThreadId).join(",")}]`);
 }
 /** definitions.py `canon_context_set` (line 2358). */
-export function canonContextSet(i, v) {
-    const thread = currentThread();
+export function canonContextSet(i, v, inst) {
+    const thread = currentThreadForInstance(inst);
     assert_(i < NUM_CONTEXT_SLOTS, `context.set slot ${i} out of range`);
     if (CTX_TRACE)
         trace(`set[${i}] = ${v >>> 0}`, thread);
@@ -70,7 +70,17 @@ export function canonContextSet(i, v) {
  * unimplementable symbol fails instantiation rather than the first call
  * (contracts/plan-format.md "Executor obligations").
  */
-export function createUnsafeIntrinsic(symbol) {
+export function createUnsafeIntrinsic(symbol, 
+/**
+ * The component instance whose core module declares this import — the
+ * instance whose frame is, by construction, the one executing when it is
+ * called. `undefined`/`null` (a FACT adapter module, which the plan records
+ * with `instance: null`) falls back to the unscoped ambient. See
+ * `currentThreadForInstance` (task/scheduler.ts) for why this discriminator
+ * is what makes a JSPI continuation chunk's `context.set` land in its own
+ * thread's slots.
+ */
+inst) {
     const match = /^context-(get|set)-i32-(\d+)$/.exec(symbol);
     if (match === null) {
         throw new UnsupportedFeatureError("M2", `component imports the unsafe intrinsic '${symbol}', which has no ` +
@@ -83,8 +93,8 @@ export function createUnsafeIntrinsic(symbol) {
     trapIf(slot >= NUM_CONTEXT_SLOTS, `unsafe intrinsic '${symbol}' addresses context slot ${slot}, but a ` +
         `thread has ${NUM_CONTEXT_SLOTS}`);
     if (match[1] === "get")
-        return () => canonContextGet(slot);
+        return () => canonContextGet(slot, inst);
     return (v) => {
-        canonContextSet(slot, (v ?? 0) >>> 0);
+        canonContextSet(slot, (v ?? 0) >>> 0, inst);
     };
 }

package/esm/jspi/bridge.js

@@ -42,7 +42,7 @@
 // results to become Promises where cabi needs a number synchronously.
 import { assert_ } from "../cabi/trap.js";
 import { isSupported, makePromising, makeSuspending } from "./mechanics.js";
-import { withActivation, claimActivationAmbient, dbgId, consumeClaimIfRunning, maybeCurrentThread, releaseActivationAmbient, setResumingThread, } from "../task/mod.js";
+import { withActivation, claimActivationAmbient, dbgId, maybeCurrentThread, releaseActivationAmbient, } from "../task/mod.js";
 /**
  * Decide the mode for one instantiation.
  *
@@ -474,17 +474,19 @@ export class SuspensionPoint {
             // and the `assert_trap` rows of `big-interleaving-test.wast` detect
             // ("exit-sync-call with an empty sync-call stack").
             //
-            // Symmetry with the success arm below (issue #158): if the DRIVER's slot
-            // is live for the activation currently executing, that activation is the
-            // code delivering this resume (a running guest's `subtask.cancel`, whose
-            // `produce` computes a trap), so its claim window has closed — consume it
-            // rather than false-positive the one-claimant assert in
-            // `setResumingThread`. Without this the assert preempts `#fail(e)` and
-            // the parked guest receives an AssertionError in place of its trap.
-            consumeClaimIfRunning();
+            // Symmetry with the success arm below (issue #158): if a pending
+            // resumption of this store names the activation currently executing,
+            // that activation is the code delivering this resume (a running guest's
+            // `subtask.cancel`, whose `produce` computes a trap), so its window has
+            // closed — retire that entry here. Historically this also avoided a
+            // false-positive one-claimant assert that preempted `#fail(e)`, handing
+            // the parked guest an AssertionError in place of its trap; the assert is
+            // gone with the single-slot claim (#158 mechanism B), but the entry must
+            // still be retired here or the store stays gated on a finished window.
+            this.#store.consumePendingIfRunning();
             if (maybeCurrentThread() === undefined)
                 claimActivationAmbient(this.owner);
-            setResumingThread(this.task?.implicitThread ?? null);
+            this.#store.addPendingResumption(this.task?.implicitThread ?? null);
             this.#fail(e);
             return;
         }
@@ -492,25 +494,25 @@ export class SuspensionPoint {
         // settling the import's Promise hands control to wasm, which will call
         // built-ins with an empty bracket stack. The claim names `owner` — the
         // activation captured when this point was minted — not a guess derived
-        // now; see `owner` and `setResumingThread`.
+        // now; see `owner` and `Store.pendingResumptions`.
         //
-        // If the DRIVER's slot is live for the activation currently executing (it
-        // is the code that called us — a running guest's `subtask.cancel`
-        // delivering a cancellation settles the callee's suspension from inside
-        // its own frame), that claim has served its purpose; consume it rather
-        // than false-positive the one-claimant assert.
-        consumeClaimIfRunning();
+        // If a pending resumption of this store names the activation currently
+        // executing (it is the code that called us — a running guest's
+        // `subtask.cancel` delivering a cancellation settles the callee's
+        // suspension from inside its own frame), that entry has served its
+        // purpose; retire it.
+        this.#store.consumePendingIfRunning();
         // The activation-ambient claim (site (i) in scheduler.ts). Taken only when
         // NOBODY is running right now: if a guest activation is executing, `owner`
         // does not run until that activation yields, and pushing onto a
         // LAST-IN-FIRST-OUT stack now would make `owner` the ambient for the
-        // caller's remaining frame. In that shape `owner` is picked up either by
-        // its own first `Suspending` call (site (ii)) or, before that, by the
-        // driver's `resumingThread` slot at the bottom tier — exactly as it always
-        // was.
+        // caller's remaining frame. In that shape `owner` is picked up by its own
+        // first `Suspending` call (site (ii)); the retired tier-3 slot used to
+        // cover the window before that, and the measurement behind its retirement
+        // (#158, see `resolveAmbient`) says nothing ever read it there.
         if (maybeCurrentThread() === undefined)
             claimActivationAmbient(this.owner);
-        setResumingThread(this.task?.implicitThread ?? null);
+        this.#store.addPendingResumption(this.task?.implicitThread ?? null);
         this.#settle(value);
     }
     /** Abandon this suspension without resuming the guest (teardown paths). */
@@ -577,11 +579,11 @@ export function blockCurrentActivation(input) {
     // and strands the point with no owner (measured: `cancellable.wast:322`
     // then reported `pending-capability: instantiation-time task context`).
     const owner = maybeCurrentThread() ?? input.task?.implicitThread ?? null;
-    // The activation is parking: if it still carried the resumed-ambient claim
-    // from the settle that resumed it, that claim's window closes here (the
-    // other closing edge — the activation FINISHING — is handled by
+    // The activation is parking: if it still carried the pending-resumption
+    // entry from the settle that resumed it, that entry's window closes here
+    // (the other closing edge — the activation FINISHING — is handled by
     // `Store.noteAwaiting`'s settle continuation).
-    consumeClaimIfRunning();
+    input.store.consumePendingIfRunning();
     releaseActivationAmbient(owner);
     const point = new SuspensionPoint(input.store, input.task, input.readyFunc, input.cancellable, input.produce, owner, input.onSettled);
     return point.promise;

package/esm/task/scheduler.js

@@ -269,7 +269,7 @@ export function withActivation(t, fn) {
  * async-context store held: the store was written by `withActivation` and by
  * nothing else, so a built-in reached under a scheduler `resume()` bracket
  * that had not (yet) entered wasm saw NO store, even though `threadStack`
- * named a thread. `consumeClaimIfRunning` — the driver-gate
+ * named a thread. `Store.consumePendingIfRunning` — the driver-gate
  * release whose scheduling effects the corpus pins precisely — asked exactly
  * that question, so it must keep asking exactly that question — measured:
  * routing it through the full `threadStack` instead moved 64 conformance
@@ -280,7 +280,8 @@ export function withActivation(t, fn) {
 const entryStack = [];
 /**
  * "Whose wasm frame are we lexically inside, or running on behalf of?" — the
- * async-context store's replacement, used only by `consumeClaimIfRunning`.
+ * async-context store's replacement, used only by
+ * `Store.consumePendingIfRunning`.
  */
 // deno-lint-ignore no-explicit-any
 function activationOf() {
@@ -346,8 +347,9 @@ function activationOf() {
  * The opposite shape — A settles B's suspension so B runs AFTER A — is
  * deliberately NOT represented here: `SuspensionPoint.resume` pushes only when
  * nothing is currently running, so B never shadows A. B is picked up by its
- * own first `Suspending` call, or before that by the driver's `resumingThread`
- * slot at the bottom tier.
+ * own first `Suspending` call. (Until 2026-08-22 a third ambient tier — the
+ * driver's `resumingThread` slot — also named B here; it was retired with the
+ * slot, see `resolveAmbient` and `Store.pendingResumptions`.)
  *
  * An activation leaves this stack when it parks again
  * (`blockCurrentActivation`) or finishes (its `awaitValue` promise settles —
@@ -364,7 +366,7 @@ const activationClaims = [];
  * direct evidence that `t` is running RIGHT NOW (its Suspending import just
  * returned into its wasm). The previous early-return kept stale order: a
  * nested callee's claim whose release edge is a promise reaction
- * (`Store.noteAwaiting` -> `releaseClaimOf`) outlives the callee by a
+ * (`Store.noteAwaiting` -> `Store.releasePendingOf`) outlives the callee by a
  * microtask, and an outer activation's continuation chunk that resumed in
  * that window re-claimed itself as a NOOP — leaving the finished callee on
  * top, so every ambient read in the rest of the chunk (the next hop's
@@ -395,7 +397,8 @@ export function claimActivationAmbient(t) {
 function traceAmbient(what, t) {
     // Lazy import avoidance: reuse context.ts's ids via a local map.
     console.error(`[amb] ${what} ${dbgId(t)} | stack=[${threadStack.map(dbgId).join(",")}] ` +
-        `claims=[${activationClaims.map(dbgId).join(",")}] resuming=${resumingThread === null ? "-" : dbgId(resumingThread)}\n${(new Error().stack ?? "").split("\n").slice(2, 6).join("\n")}`);
+        `claims=[${activationClaims.map(dbgId).join(",")}]` +
+        `\n${(new Error().stack ?? "").split("\n").slice(2, 6).join("\n")}`);
 }
 const dbgIds = new WeakMap();
 let nextDbgId = 1;
@@ -437,78 +440,17 @@ export function releaseActivationAmbient(t) {
     activationClaims.splice(i, 1);
 }
 // ---------------------------------------------------------------------------
-// The driver's resume claim (a SEPARATE concern from the ambient above)
+// The resumed-but-not-yet-run gate (a SEPARATE concern from the ambient above)
 // ---------------------------------------------------------------------------
-/**
- * The activation whose suspension we have just resolved and which has not run
- * yet — the DRIVER's serialization gate, not an ambient.
- *
- * Keeping this distinct from `activationClaims` matters. This slot answers
- * "may I schedule something else right now?" (`Store.tick` and both driving
- * loops refuse while it is live, which is what forces a microtask yield so the
- * resumed activation actually runs). `activationClaims` answers "whose code is
- * this?". Conflating them — driving off the ambient queue — wedges the loops,
- * because an activation that merely hopped (case (ii) above) legitimately
- * holds an ambient while the scheduler is free to proceed.
- */
-// deno-lint-ignore no-explicit-any
-let resumingThread = null;
-/** Claim the ambient for `t` across an engine-driven resumption. */
-// deno-lint-ignore no-explicit-any
-export function setResumingThread(t) {
-    if (AMBIENT_TRACE)
-        traceAmbient("set-resuming", t);
-    assert_(resumingThread === null || resumingThread === t, "two activations claim the resumed ambient at once — the " +
-        "resolve-one-per-turn discipline was violated");
-    resumingThread = t;
-}
-/** Is a settled-but-not-yet-run activation holding the ambient? */
-export function hasResumingThread() {
-    return resumingThread !== null;
-}
-/** Release the claim; called once we are back in our own continuation. */
-export function clearResumingThread() {
-    resumingThread = null;
-}
-/**
- * Release the driver's claim iff its activation is demonstrably RUNNING —
- * i.e. the claim names the same thread the ACTIVATION AMBIENT names for the
- * code calling us. The claim exists to cover the window between settling a
- * suspension and the resumed activation running; once that activation's own
- * code is on the stack the window is closed, and holding the claim would
- * falsely trip the one-claimant assert when the running activation's built-in
- * settles ANOTHER activation's suspension — `subtask.cancel` delivering a
- * cancellation to a parked callee (cancellable.wast) is exactly that shape.
- * When the two disagree (or no ambient is present) the claim stays, and the
- * assert keeps guarding the genuine two-unrun-claimants bug it was built for.
- *
- * The comparison used to be against the async-context store; it is now
- * against `activationOf()`, which is the same statement made explicitly.
- */
-export function consumeClaimIfRunning() {
-    if (resumingThread !== null && activationOf() === resumingThread) {
-        resumingThread = null;
-    }
-}
-/**
- * Release the claim iff it names `t` — the settle-side half of the claim
- * discipline: a claim taken when `t`'s suspension was settled dies when `t`'s
- * activation finishes (its `awaitValue` promise settles; `Store.noteAwaiting`
- * calls this from the eager settle continuation) or parks again
- * (`blockCurrentActivation` consumes via `consumeClaimIfRunning`).
- *
- * `t` FINISHING also ends its activation ambient, so both are dropped here.
- */
-// deno-lint-ignore no-explicit-any
-export function releaseClaimOf(t) {
-    releaseActivationAmbient(t);
-    if (resumingThread !== null &&
-        (resumingThread === t ||
-            t?.task?.implicitThread ===
-                resumingThread)) {
-        resumingThread = null;
-    }
-}
+//
+// This used to be a module-global single slot, `resumingThread`, doing two
+// jobs: (1) the DRIVER's scheduling gate ("a suspension was settled and its
+// activation has not run yet — do not schedule anything else"), and (2) tier 3
+// of ambient resolution. Job (2) was retired on 2026-08-22 (issue #158) after
+// measurement showed it never decided a read; job (1) is real, but it is
+// per-Store SET semantics, not a global identity slot — see
+// `Store.pendingResumptions` below, and `resolveAmbient` for the retirement
+// evidence.
 const AMBIENT_TRACE = (() => {
     try {
         return Deno.env.get("CE_AMBIENT_TRACE") === "1";
@@ -522,14 +464,17 @@ export function ambientDebug() {
     return {
         stack: [...threadStack],
         claims: [...activationClaims],
-        resuming: resumingThread,
     };
 }
-/** Diagnostic: module-scope state that must NOT survive a completed call. */
+/**
+ * Diagnostic: module-scope AMBIENT state that must NOT survive a completed
+ * call. The scheduling gate is no longer module-scope — a store's
+ * `pendingResumptions` set is the per-Store analogue and is checked there.
+ */
 export function ambientResidue() {
     return {
         stack: threadStack.length,
-        claim: resumingThread !== null || activationClaims.length > 0,
+        claim: activationClaims.length > 0,
     };
 }
 /**
@@ -543,9 +488,9 @@ export function ambientResidue() {
  *      is running outside our frames (a `Suspending` hop or a resumption).
  *      LIFO, because activations nest: an outer activation's built-in can
  *      synchronously enter an inner one's wasm.
- *   3. `resumingThread` -- the driver's claim. Last resort: it names whichever
- *      activation the driver settled or claimed across an await, which is
- *      right for that one and wrong for every other in-flight activation.
+ *   (There is no tier 3. A third tier — `resumingThread`, the driver's
+ *      settle-time claim — existed from M3A-1 until 2026-08-22 and was
+ *      RETIRED, see below.)
  *
  * Tier 2 replaced an async-context store (M3A-1). The store held
  * precisely "the innermost wasm activation currently executing, across the
@@ -565,18 +510,36 @@ export function ambientResidue() {
  * one reader measured as "no change" because the failing sites used the other.
  * Do not add a third reader; extend this one. (`activationOf` above is not a
  * second reader -- it answers a different question, "whose wasm frame are we
- * running on behalf of", and is used only by `consumeClaimIfRunning`.)
+ * running on behalf of", and is used only by
+ * `Store.consumePendingIfRunning`.)
+ *
+ * TIER 3 RETIRED, 2026-08-22 (issue #158). The bottom tier used to be
+ * `resumingThread`, the driver's settle-time claim -- a last resort that named
+ * whichever activation was settled or claimed across an await, right for that
+ * one and wrong for every other in-flight activation. It was removed on the
+ * strength of a re-run of the M3A-1 differential methodology: an instrumented
+ * build counted every read where tiers 1-2 were empty and the slot was live,
+ * and measured ZERO deciding reads across the conformance corpus (FIFO,
+ * 1257/0), both seeded shuffles (`POLYENGINE_SCHED_SEED` 1 and 4242),
+ * test-runtime (all jspi pins), and the smoke-tls three-async-component #24
+ * corpus. A removal build then ran green on every engine lane we have:
+ * test-runtime, test-protocol, conformance (1257/0, no expectation changes),
+ * sched-seeds, the shells (sm + node + jsc + bun, all "OK, matches
+ * expectation"), the browsers (chromium + firefox), smoke-tls and smoke-c0.
+ * The reading: post-#24 the sentinel discipline (tier 2's claim/release edges)
+ * always answers first, so the slot's attribution role was vestigial. Its
+ * other, live role -- the scheduling gate -- survives as the per-Store
+ * `Store.pendingResumptions` set.
  */
 function resolveAmbient() {
     return threadStack[threadStack.length - 1] ??
-        activationClaims[activationClaims.length - 1] ?? resumingThread ??
+        activationClaims[activationClaims.length - 1] ??
         undefined;
 }
 export function currentThread() {
     if (AMBIENT_TRACE && threadStack.length === 0) {
         console.error(`[ambient] bracket empty; claims=${activationClaims.length} ` +
-            `head=${activationClaims[0]?.constructor?.name ?? "none"} ` +
-            `resuming=${resumingThread?.constructor?.name ?? "none"}`);
+            `head=${activationClaims[0]?.constructor?.name ?? "none"}`);
     }
     const t = resolveAmbient();
     if (t === undefined) {
@@ -604,6 +567,76 @@ export function currentThread() {
 export function maybeCurrentThread() {
     return resolveAmbient();
 }
+/**
+ * THE ambient, NARROWED BY THE INSTANCE WHOSE CORE FRAME IS EXECUTING.
+ *
+ * For a built-in whose declaration names a component instance, "who is
+ * running" is not an open question about the whole store: the call arrived
+ * from a core frame OF THAT INSTANCE, so the running activation is one of
+ * that instance's. This narrows `resolveAmbient` accordingly — same tiers,
+ * same order, candidates filtered — and falls back to the unscoped answer
+ * when the instance has no candidate at all (the instantiation-time shape,
+ * and any built-in reached before its instance has a task).
+ *
+ * WHY IT IS NEEDED (polyengine#24's residue; polyvisor#49 trap 1,
+ * `runtime/tests/context_attribution_test.ts`). A JSPI continuation chunk —
+ * the tail of a suspended activation, e.g. wit-bindgen's callback epilogue
+ * restoring its task pointer with `context.set` (rt/async_support.rs:592) —
+ * runs with an EMPTY `threadStack` and, unlike a hop, has no re-anchoring
+ * edge of its own. Tier 2 then answers the newest claim, which is whichever
+ * SIBLING activation suspended most recently. The attribution sentinels
+ * (jspi/bridge.ts) plant that claim one microtask ahead of the chunk, which
+ * is exact when the engine queues the resumption while the settle reaction
+ * returns (measured so in Deno's V8) — and NOT exact in Chromium, where a
+ * wider gap lets a sibling's sentinel land in between. Measured there 3/3:
+ * one task's epilogue wrote its state pointer into another task's slots, and
+ * the starved task's next callback entry hit `assert!(!state.is_null())`
+ * (async_support.rs:578) -> unreachable.
+ *
+ * Ordering discipline cannot fix that class — engine chunk boundaries are not
+ * observable, so every microtask-ordering scheme is a hope. Instance identity
+ * is not a hope: it is static (the declaration), and it is decisive because
+ * ONE INSTANCE CAN ONLY HAVE ONE ACTIVATION MID-FRAME AT A TIME — a callback
+ * invocation holds `inst.exclusiveThread` for its whole extent, suspensions
+ * included (definitions.py line 2187 / `runCallbackLoop`), and a sync or
+ * stackful-async lift holds the entry gate. Two activations that can race for
+ * an unbracketed read are therefore necessarily of different instances, which
+ * is exactly what this discriminates.
+ *
+ * SPEC BASIS. `canon_context_get`/`canon_context_set` (definitions.py 2348 /
+ * 2358) read `current_thread().storage`, and in the reference a built-in is
+ * only ever reached from inside the activation that called it — the identity
+ * is exact by construction, never inferred. This runtime has to reconstruct
+ * it; narrowing the reconstruction to the declaring instance moves it TOWARD
+ * the reference (it can only ever remove candidates the reference would never
+ * have named), never away.
+ */
+// deno-lint-ignore no-explicit-any
+export function currentThreadForInstance(inst) {
+    const t = resolveAmbientForInstance(inst);
+    if (t !== undefined)
+        return t;
+    // No candidate of this instance: the unscoped ladder, including its
+    // `PendingCapability` for the instantiation-time shape.
+    return currentThread();
+}
+function resolveAmbientForInstance(inst) {
+    if (inst === null || inst === undefined)
+        return resolveAmbient();
+    const top = threadStack[threadStack.length - 1];
+    if (top !== undefined && instOf(top) === inst)
+        return top;
+    for (let i = activationClaims.length - 1; i >= 0; i--) {
+        const c = activationClaims[i];
+        if (instOf(c) === inst)
+            return c;
+    }
+    return undefined;
+}
+// deno-lint-ignore no-explicit-any
+function instOf(t) {
+    return t?.task?.inst;
+}
 /** definitions.py `current_task()` (line 309). */
 // deno-lint-ignore no-explicit-any
 export function currentTask() {
@@ -648,6 +681,109 @@ export class Store {
      * is driving the store — which is the call the guest is blocked in.
      */
     hostFailure = undefined;
+    /**
+     * Resumed-but-not-yet-run activations of THIS store — the driver's
+     * scheduling gate, not an ambient.
+     *
+     * Keeping this distinct from `activationClaims` matters. This set answers
+     * "may I schedule something else right now?" (`Store.tick` and both driving
+     * loops refuse while it is non-empty, which is what forces a microtask yield
+     * so the resumed activation actually runs). `activationClaims` answers
+     * "whose code is this?". Conflating them — driving off the ambient queue —
+     * 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.
+     *
+     * 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.
+     *
+     * Release edges, per entry: the activation PARKS again
+     * (`blockCurrentActivation` -> `consumePendingIfRunning`), it FINISHES (its
+     * `awaitValue` promise settles -> `noteAwaiting` -> `releasePendingOf`), or
+     * the driver drops its own speculative entry (`removePendingResumption`).
+     */
+    pendingResumptions = new Set();
+    /**
+     * Record that a suspension of this store has been settled and its
+     * activation has not run yet. Idempotent; a null/undefined activation is
+     * "no entry" (the instantiation-time shape that has no thread at all).
+     *
+     * No one-claimant assert: two entries are legitimate (see
+     * `pendingResumptions`). Two SuspensionPoints of ONE task cannot be pending
+     * simultaneously — a task's single activation suspends at one point at a
+     * time — so collapsing entries by identity loses nothing.
+     */
+    addPendingResumption(t) {
+        if (t === null || t === undefined)
+            return;
+        if (AMBIENT_TRACE)
+            traceAmbient("pending+", t);
+        this.pendingResumptions.add(t);
+    }
+    /** Is some settled-but-not-yet-run activation of this store pending? */
+    hasPendingResumptions() {
+        return this.pendingResumptions.size > 0;
+    }
+    /** Drop exactly `t` (the driver's own speculative entry). */
+    removePendingResumption(t) {
+        if (AMBIENT_TRACE)
+            traceAmbient("pending-", t);
+        this.pendingResumptions.delete(t);
+    }
+    /**
+     * Drop the pending entry iff its activation is demonstrably RUNNING — i.e.
+     * the entry names the same thread the ACTIVATION AMBIENT names for the code
+     * calling us. An entry exists to cover the window between settling a
+     * suspension and the resumed activation running; once that activation's own
+     * code is on the stack the window is closed, and holding the entry would
+     * gate the store on an activation that has already had its turn — while a
+     * running activation's built-in settles ANOTHER activation's suspension
+     * (`subtask.cancel` delivering a cancellation to a parked callee,
+     * cancellable.wast) that other entry must legitimately stay.
+     *
+     * The comparison is against `activationOf()` — the wasm-ENTRY brackets,
+     * deliberately not the full `threadStack` (see `entryStack`: routing it
+     * through the full stack moved 64 conformance commands).
+     */
+    consumePendingIfRunning() {
+        const a = activationOf();
+        if (a !== null && a !== undefined)
+            this.pendingResumptions.delete(a);
+    }
+    /**
+     * Drop the pending entry naming `t` — the settle-side half: an entry taken
+     * when `t`'s suspension was settled dies when `t`'s activation finishes (its
+     * `awaitValue` promise settles; `noteAwaiting` calls this from the eager
+     * settle continuation) or parks again (`blockCurrentActivation` consumes via
+     * `consumePendingIfRunning`).
+     *
+     * The `task.implicitThread` indirection covers entries taken against a
+     * task's implicit thread. `t` FINISHING also ends its activation ambient,
+     * so both are dropped here.
+     */
+    // deno-lint-ignore no-explicit-any
+    releasePendingOf(t) {
+        releaseActivationAmbient(t);
+        this.pendingResumptions.delete(t);
+        const implicit = t?.task
+            ?.implicitThread;
+        if (implicit !== undefined && implicit !== null) {
+            this.pendingResumptions.delete(implicit);
+        }
+    }
     startWaiting(t) {
         assert_(!this.waiting.includes(t), "thread already in the waiting list");
         this.waiting.push(t);
@@ -693,17 +829,17 @@ export class Store {
      * another activation's suspension — `subtask.cancel` delivering a
      * cancellation): the claim taken at settle time must survive until the
      * resumed activation parks again or finishes, and "finished" is exactly
-     * this continuation firing. See `releaseClaimOf`.
+     * this continuation firing. See `releasePendingOf`.
      */
     // deno-lint-ignore no-explicit-any
     noteAwaiting(t, promise) {
         this.awaiting.add(t);
         promise.then((value) => {
             this.settled.push({ t, value, failure: undefined });
-            releaseClaimOf(t);
+            this.releasePendingOf(t);
         }, (e) => {
             this.settled.push({ t, value: undefined, failure: { error: e } });
-            releaseClaimOf(t);
+            this.releasePendingOf(t);
         });
     }
     /**
@@ -863,14 +999,17 @@ export class Store {
         //
         // Settling a suspension hands control to wasm in a *microtask*, not
         // synchronously — so `tick` returns with the resumed activation not yet
-        // run and its ambient claim still outstanding. Resolving a second one
-        // before that happens would overwrite the claim, and the first
-        // activation's built-ins would then attribute themselves to the wrong
-        // task (observed as `exit-sync-call` popping another task's bracket).
-        // Refusing to make progress while a claim is live forces the caller to
-        // yield to the microtask queue first, which is exactly what `driveAsync`
-        // does.
-        if (resumingThread !== null)
+        // run and its pending entry still outstanding. Resolving a second one
+        // before that happens would let the first activation's built-ins
+        // attribute themselves to the wrong task (observed as `exit-sync-call`
+        // popping another task's bracket). Refusing to make progress while an
+        // entry is pending forces the caller to yield to the microtask queue
+        // first, which is exactly what `driveAsync` does.
+        //
+        // THIS STORE's entries only (issue #210): activations never cross stores,
+        // so another store's pending resumption says nothing about what this one
+        // may schedule.
+        if (this.pendingResumptions.size > 0)
             return false;
         // Same discipline, other edge: a settled-but-unserviced activation tail
         // (see `settled`) is mid-"atomic resume" from the reference's point of

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@polyengine/runtime",
-  "version": "0.3.1-pre.gf4b740b",
+  "version": "0.3.1",
   "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": {

package/types/intrinsics/context.d.ts

@@ -14,10 +14,10 @@ export declare const NUM_CONTEXT_SLOTS = 2;
  * in slot 0, which is why this intrinsic is the entry blocker for async
  * guests.
  */
-export declare function canonContextGet(i: number): number;
+export declare function canonContextGet(i: number, inst?: unknown): number;
 export declare function ctxThreadId(t: unknown): string;
 /** definitions.py `canon_context_set` (line 2358). */
-export declare function canonContextSet(i: number, v: number): void;
+export declare function canonContextSet(i: number, v: number, inst?: unknown): void;
 /**
  * Materialize one `unsafe-intrinsic` CoreDef as a core function.
  *
@@ -25,4 +25,14 @@ export declare function canonContextSet(i: number, v: number): void;
  * unimplementable symbol fails instantiation rather than the first call
  * (contracts/plan-format.md "Executor obligations").
  */
-export declare function createUnsafeIntrinsic(symbol: string): CoreFn;
+export declare function createUnsafeIntrinsic(symbol: string, 
+/**
+ * The component instance whose core module declares this import — the
+ * instance whose frame is, by construction, the one executing when it is
+ * called. `undefined`/`null` (a FACT adapter module, which the plan records
+ * with `instance: null`) falls back to the unscoped ambient. See
+ * `currentThreadForInstance` (task/scheduler.ts) for why this discriminator
+ * is what makes a JSPI continuation chunk's `context.set` land in its own
+ * thread's slots.
+ */
+inst?: unknown): CoreFn;

package/types/task/scheduler.d.ts

@@ -129,7 +129,7 @@ export declare function withActivation<T>(t: any, fn: () => T): T;
  * direct evidence that `t` is running RIGHT NOW (its Suspending import just
  * returned into its wasm). The previous early-return kept stale order: a
  * nested callee's claim whose release edge is a promise reaction
- * (`Store.noteAwaiting` -> `releaseClaimOf`) outlives the callee by a
+ * (`Store.noteAwaiting` -> `Store.releasePendingOf`) outlives the callee by a
  * microtask, and an outer activation's continuation chunk that resumed in
  * that window re-claimed itself as a NOOP — leaving the finished callee on
  * top, so every ambient read in the rest of the chunk (the next hop's
@@ -154,51 +154,67 @@ export declare function dbgId(t: unknown): string;
  * second edge for claims taken against a task's implicit thread.
  */
 export declare function releaseActivationAmbient(t: any): void;
-/** Claim the ambient for `t` across an engine-driven resumption. */
-export declare function setResumingThread(t: any): void;
-/** Is a settled-but-not-yet-run activation holding the ambient? */
-export declare function hasResumingThread(): boolean;
-/** Release the claim; called once we are back in our own continuation. */
-export declare function clearResumingThread(): void;
-/**
- * Release the driver's claim iff its activation is demonstrably RUNNING —
- * i.e. the claim names the same thread the ACTIVATION AMBIENT names for the
- * code calling us. The claim exists to cover the window between settling a
- * suspension and the resumed activation running; once that activation's own
- * code is on the stack the window is closed, and holding the claim would
- * falsely trip the one-claimant assert when the running activation's built-in
- * settles ANOTHER activation's suspension — `subtask.cancel` delivering a
- * cancellation to a parked callee (cancellable.wast) is exactly that shape.
- * When the two disagree (or no ambient is present) the claim stays, and the
- * assert keeps guarding the genuine two-unrun-claimants bug it was built for.
- *
- * The comparison used to be against the async-context store; it is now
- * against `activationOf()`, which is the same statement made explicitly.
- */
-export declare function consumeClaimIfRunning(): void;
-/**
- * Release the claim iff it names `t` — the settle-side half of the claim
- * discipline: a claim taken when `t`'s suspension was settled dies when `t`'s
- * activation finishes (its `awaitValue` promise settles; `Store.noteAwaiting`
- * calls this from the eager settle continuation) or parks again
- * (`blockCurrentActivation` consumes via `consumeClaimIfRunning`).
- *
- * `t` FINISHING also ends its activation ambient, so both are dropped here.
- */
-export declare function releaseClaimOf(t: any): void;
 /** Diagnostic (#24 probe): the full ambient state, for tracing. */
 export declare function ambientDebug(): {
     stack: unknown[];
     claims: unknown[];
-    resuming: unknown;
 };
-/** Diagnostic: module-scope state that must NOT survive a completed call. */
+/**
+ * Diagnostic: module-scope AMBIENT state that must NOT survive a completed
+ * call. The scheduling gate is no longer module-scope — a store's
+ * `pendingResumptions` set is the per-Store analogue and is checked there.
+ */
 export declare function ambientResidue(): {
     stack: number;
     claim: boolean;
 };
 export declare function currentThread<T = CurrentThreadLike>(): T;
 export declare function maybeCurrentThread(): CurrentThreadLike | undefined;
+/**
+ * THE ambient, NARROWED BY THE INSTANCE WHOSE CORE FRAME IS EXECUTING.
+ *
+ * For a built-in whose declaration names a component instance, "who is
+ * running" is not an open question about the whole store: the call arrived
+ * from a core frame OF THAT INSTANCE, so the running activation is one of
+ * that instance's. This narrows `resolveAmbient` accordingly — same tiers,
+ * same order, candidates filtered — and falls back to the unscoped answer
+ * when the instance has no candidate at all (the instantiation-time shape,
+ * and any built-in reached before its instance has a task).
+ *
+ * WHY IT IS NEEDED (polyengine#24's residue; polyvisor#49 trap 1,
+ * `runtime/tests/context_attribution_test.ts`). A JSPI continuation chunk —
+ * the tail of a suspended activation, e.g. wit-bindgen's callback epilogue
+ * restoring its task pointer with `context.set` (rt/async_support.rs:592) —
+ * runs with an EMPTY `threadStack` and, unlike a hop, has no re-anchoring
+ * edge of its own. Tier 2 then answers the newest claim, which is whichever
+ * SIBLING activation suspended most recently. The attribution sentinels
+ * (jspi/bridge.ts) plant that claim one microtask ahead of the chunk, which
+ * is exact when the engine queues the resumption while the settle reaction
+ * returns (measured so in Deno's V8) — and NOT exact in Chromium, where a
+ * wider gap lets a sibling's sentinel land in between. Measured there 3/3:
+ * one task's epilogue wrote its state pointer into another task's slots, and
+ * the starved task's next callback entry hit `assert!(!state.is_null())`
+ * (async_support.rs:578) -> unreachable.
+ *
+ * Ordering discipline cannot fix that class — engine chunk boundaries are not
+ * observable, so every microtask-ordering scheme is a hope. Instance identity
+ * is not a hope: it is static (the declaration), and it is decisive because
+ * ONE INSTANCE CAN ONLY HAVE ONE ACTIVATION MID-FRAME AT A TIME — a callback
+ * invocation holds `inst.exclusiveThread` for its whole extent, suspensions
+ * included (definitions.py line 2187 / `runCallbackLoop`), and a sync or
+ * stackful-async lift holds the entry gate. Two activations that can race for
+ * an unbracketed read are therefore necessarily of different instances, which
+ * is exactly what this discriminates.
+ *
+ * SPEC BASIS. `canon_context_get`/`canon_context_set` (definitions.py 2348 /
+ * 2358) read `current_thread().storage`, and in the reference a built-in is
+ * only ever reached from inside the activation that called it — the identity
+ * is exact by construction, never inferred. This runtime has to reconstruct
+ * it; narrowing the reconstruction to the declaring instance moves it TOWARD
+ * the reference (it can only ever remove candidates the reference would never
+ * have named), never away.
+ */
+export declare function currentThreadForInstance<T = CurrentThreadLike>(inst: unknown): T;
 /** definitions.py `current_task()` (line 309). */
 export declare function currentTask(): any;
 /**
@@ -241,6 +257,84 @@ export declare class Store {
      * is driving the store — which is the call the guest is blocked in.
      */
     hostFailure: unknown;
+    /**
+     * Resumed-but-not-yet-run activations of THIS store — the driver's
+     * scheduling gate, not an ambient.
+     *
+     * Keeping this distinct from `activationClaims` matters. This set answers
+     * "may I schedule something else right now?" (`Store.tick` and both driving
+     * loops refuse while it is non-empty, which is what forces a microtask yield
+     * so the resumed activation actually runs). `activationClaims` answers
+     * "whose code is this?". Conflating them — driving off the ambient queue —
+     * 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.
+     *
+     * 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.
+     *
+     * Release edges, per entry: the activation PARKS again
+     * (`blockCurrentActivation` -> `consumePendingIfRunning`), it FINISHES (its
+     * `awaitValue` promise settles -> `noteAwaiting` -> `releasePendingOf`), or
+     * the driver drops its own speculative entry (`removePendingResumption`).
+     */
+    readonly pendingResumptions: Set<unknown>;
+    /**
+     * Record that a suspension of this store has been settled and its
+     * activation has not run yet. Idempotent; a null/undefined activation is
+     * "no entry" (the instantiation-time shape that has no thread at all).
+     *
+     * No one-claimant assert: two entries are legitimate (see
+     * `pendingResumptions`). Two SuspensionPoints of ONE task cannot be pending
+     * simultaneously — a task's single activation suspends at one point at a
+     * time — so collapsing entries by identity loses nothing.
+     */
+    addPendingResumption(t: unknown): void;
+    /** Is some settled-but-not-yet-run activation of this store pending? */
+    hasPendingResumptions(): boolean;
+    /** Drop exactly `t` (the driver's own speculative entry). */
+    removePendingResumption(t: unknown): void;
+    /**
+     * Drop the pending entry iff its activation is demonstrably RUNNING — i.e.
+     * the entry names the same thread the ACTIVATION AMBIENT names for the code
+     * calling us. An entry exists to cover the window between settling a
+     * suspension and the resumed activation running; once that activation's own
+     * code is on the stack the window is closed, and holding the entry would
+     * gate the store on an activation that has already had its turn — while a
+     * running activation's built-in settles ANOTHER activation's suspension
+     * (`subtask.cancel` delivering a cancellation to a parked callee,
+     * cancellable.wast) that other entry must legitimately stay.
+     *
+     * The comparison is against `activationOf()` — the wasm-ENTRY brackets,
+     * deliberately not the full `threadStack` (see `entryStack`: routing it
+     * through the full stack moved 64 conformance commands).
+     */
+    consumePendingIfRunning(): void;
+    /**
+     * Drop the pending entry naming `t` — the settle-side half: an entry taken
+     * when `t`'s suspension was settled dies when `t`'s activation finishes (its
+     * `awaitValue` promise settles; `noteAwaiting` calls this from the eager
+     * settle continuation) or parks again (`blockCurrentActivation` consumes via
+     * `consumePendingIfRunning`).
+     *
+     * The `task.implicitThread` indirection covers entries taken against a
+     * task's implicit thread. `t` FINISHING also ends its activation ambient,
+     * so both are dropped here.
+     */
+    releasePendingOf(t: any): void;
     startWaiting(t: SchedulableThread): void;
     stopWaiting(t: SchedulableThread): void;
     /** Ready waiting threads, in wait order (the FIFO of the default policy). */
@@ -282,7 +376,7 @@ export declare class Store {
      * another activation's suspension — `subtask.cancel` delivering a
      * cancellation): the claim taken at settle time must survive until the
      * resumed activation parks again or finishes, and "finished" is exactly
-     * this continuation firing. See `releaseClaimOf`.
+     * this continuation firing. See `releasePendingOf`.
      */
     noteAwaiting(t: any, promise: Promise<unknown>): void;
     /**