@ggui-ai/iframe-runtime 0.1.0-rc.3 → 0.2.0-alpha.3

package/dist/channels/props-update.js

@@ -1,130 +1,54 @@
 /**
- * `props_update` channel handler — factored out of `runtime.ts` into
- * the `@ggui-ai/channel-client` layer.
+ * `props_update` channel handler — patches the currently-mounted
+ * render's props in place via the renderer's `applyRender`
+ * callback.
  *
- * Receives a `{stackItemId, props}` payload from the live channel, validates
- * the new props against the stack item's cached `propsSpec`, patches
- * the in-model entry, and re-applies the renderer so React picks up
- * the change.
+ * Post-stack-removal (2026-05-27): each iframe holds exactly one
+ * mounted render. The handler reads the current render via
+ * `getCurrentRender()`, validates the inbound props against its
+ * cached `propsSpec`, and re-applies the patched render through
+ * `applyRender` — the same callback the render handler uses, so the
+ * React update surface is unified.
  *
  * Skips when:
- *   - `stackItemId` is empty or not a string.
+ *   - `renderId` is empty or not a string.
  *   - `props` is null / not an object (defensive — server can't emit
  *     this shape, but the dispatcher routes the frame on type alone).
- *   - No matching stack item exists (server raced ahead of our pop).
- *   - The matched item is `mcpApps` / `system` (no `propsSpec`; server
- *     should never emit `props_update` for these).
+ *   - No render is currently mounted (`getCurrentRender` returns null).
+ *   - The current render's id doesn't match `payload.renderId` —
+ *     the server may have raced ahead of an in-flight render swap.
+ *   - The current render is `mcpApps` / `system` (no `propsSpec`;
+ *     server should never emit `props_update` for these).
  *   - The new props fail validation against the cached spec.
  *
- * An OPTIONAL polling descriptor provides a fallback transport —
- * when `polling` is supplied at factory time, `PollingTransport`
- * polls `/api/bootstrap/<shortCode>` and synthesizes a frame
- * whenever `propsJson` diffs from the last seen hash. WS hosts are
- * unaffected (the `polling` descriptor is inert under `WSTransport`).
+ * R6 (2026-05-26) retired the per-handler polling descriptor. Polling
+ * is now registry-level — the iframe-runtime composes the
+ * `/api/renders/:id/state?wsToken=<token>` URL and a snapshot-parsing
+ * function once at bind time (see `runtime.ts`); a single fetch per
+ * tick projects the slice envelope into per-handler frames the
+ * `PollingTransport` dispatches.
  */
 import { validateInboundPropsPayload } from '../validation.js';
-const DEFAULT_POLLING_INTERVAL_MS = 2000;
-/**
- * Tiny FNV-1a 32-bit hash — stable, no protocol dep, ~5 LOC. We only
- * need diff detection (not collision resistance), so the trade-off is
- * fine. Returns a hex string for human-readable logs.
- */
-function fnv1a(input) {
-    let hash = 0x811c9dc5;
-    for (let i = 0; i < input.length; i += 1) {
-        hash ^= input.charCodeAt(i);
-        // 32-bit FNV prime multiplication via additive bit-shifts.
-        hash = (hash + ((hash << 1) + (hash << 4) + (hash << 7) + (hash << 8) + (hash << 24))) >>> 0;
-    }
-    return hash.toString(16);
-}
 export function createPropsUpdateHandler(deps) {
-    const polling = buildPollingDescriptor(deps);
     return {
         type: 'props_update',
         onMessage: async (payload) => {
-            const { stackItemId, props } = payload;
-            if (typeof stackItemId !== 'string' || stackItemId.length === 0)
+            const { renderId, props } = payload;
+            if (typeof renderId !== 'string' || renderId.length === 0)
                 return;
             if (props === null || typeof props !== 'object')
                 return;
-            const target = deps.stackModel
-                .snapshot()
-                .find((item) => item.id === stackItemId);
-            if (target === undefined)
+            const current = deps.getCurrentRender();
+            if (current === null)
+                return;
+            if (current.id !== renderId)
                 return;
-            if (target.type === 'mcpApps' || target.type === 'system')
+            if (current.type === 'mcpApps' || current.type === 'system')
                 return;
-            const result = validateInboundPropsPayload(target.propsSpec, props);
+            const result = validateInboundPropsPayload(current.propsSpec, props);
             if (!result.valid)
                 return;
-            const nextSnapshot = deps.stackModel
-                .snapshot()
-                .map((item) => {
-                if (item.id !== stackItemId)
-                    return item;
-                if (item.type === 'mcpApps' || item.type === 'system')
-                    return item;
-                return { ...item, props };
-            });
-            deps.stackModel.setAll(nextSnapshot);
-            await deps.getStackRenderer().applyStack(deps.stackModel.snapshot());
-        },
-        ...(polling !== undefined ? { polling } : {}),
-    };
-}
-function buildPollingDescriptor(deps) {
-    const { pollingUrl } = deps;
-    if (typeof pollingUrl !== 'string' || pollingUrl.length === 0) {
-        return undefined;
-    }
-    const url = pollingUrl;
-    // Closure state — last-seen propsJson hash + last-seen stackItemId.
-    // Diff detection: emit only on change. First-poll fires (lastSeenHash
-    // is null initially) so the iframe gets the current props as its
-    // starting state when WS is absent.
-    let lastSeenHash = null;
-    let lastSeenStackItemId = null;
-    return {
-        url,
-        intervalMs: deps.pollingIntervalMs ?? DEFAULT_POLLING_INTERVAL_MS,
-        parse: (body) => {
-            if (body === null || typeof body !== 'object')
-                return null;
-            const propsJson = body.propsJson;
-            const bootstrapStackItemId = body
-                .stackItemId;
-            if (typeof propsJson !== 'string' ||
-                typeof bootstrapStackItemId !== 'string' ||
-                bootstrapStackItemId.length === 0) {
-                return null;
-            }
-            const hash = fnv1a(propsJson);
-            if (hash === lastSeenHash &&
-                bootstrapStackItemId === lastSeenStackItemId) {
-                return null; // Unchanged — skip dispatch.
-            }
-            lastSeenHash = hash;
-            lastSeenStackItemId = bootstrapStackItemId;
-            let parsedProps;
-            try {
-                parsedProps = JSON.parse(propsJson);
-            }
-            catch {
-                return null;
-            }
-            if (parsedProps === null ||
-                typeof parsedProps !== 'object' ||
-                Array.isArray(parsedProps)) {
-                return null;
-            }
-            // JSON.parse of an object literal yields a JsonObject by
-            // construction — JSON only carries JsonValue-compatible
-            // structure. Narrow to the protocol's typed shape.
-            return {
-                stackItemId: bootstrapStackItemId,
-                props: parsedProps,
-            };
+            await deps.applyRender({ ...current, props });
         },
     };
 }

package/dist/channels/render-frame.d.ts

@@ -0,0 +1,52 @@
+/**
+ * `render` channel handler — folds an inbound `render` frame into the
+ * single-render mount slot and (when transport wiring is present)
+ * activates the per-channel transport router against the newly-
+ * mounted render.
+ *
+ * Post-render-identity-collapse (2026-05-27): each iframe holds
+ * exactly one mounted render for its lifetime. The handler routes the
+ * inbound `render` to a caller-supplied `applyRender` callback that
+ * either mounts (first frame) or re-applies (subsequent frames to the
+ * same id). Frames addressed to a different `renderId` are out-of-spec
+ * and drop with a console warning — the host spawns a fresh iframe
+ * per unique render id.
+ *
+ * Placeholder mode (boot.test.ts and the C7a placeholder-only spec)
+ * omits `applyRender` + `getChannelTransport`. The handler still fires
+ * for those callers — status log keeps firing — but no React mount
+ * happens. The boot-without-renderer path remains testable.
+ */
+import type { ChannelHandler } from '@ggui-ai/live-channel';
+import type { RenderPayload, Render } from '@ggui-ai/protocol';
+import type { ChannelTransportRouter } from '../channel-transport.js';
+import { type StatusRefs } from '../status-dom.js';
+export interface RenderHandlerDeps {
+    /**
+     * Status DOM refs the connected-status log updates. Required —
+     * even renderer-mode consumers want a `[ggui:connected]` console
+     * log on every render frame for operator-visible boot debugging.
+     */
+    readonly statusRefs: StatusRefs;
+    /**
+     * Pin — when set, render frames with a different `renderId`
+     * are dropped with a console warning. Set by the renderer hook to
+     * the render id the iframe was bootstrapped against (every
+     * post-displayMode iframe is pinned to a single render).
+     */
+    readonly pinnedRenderId?: string;
+    /**
+     * Apply the inbound render to the single mount slot. Absent in
+     * placeholder mode (no React mount). When present, the handler
+     * `await`s the apply before activating the per-channel transport
+     * so the router targets the render React already mounted.
+     */
+    readonly applyRender?: (render: Render) => Promise<void>;
+    /**
+     * Renderer-mode hook — returns the per-channel transport router so
+     * the render handler can activate `source.tool` channel subscriptions
+     * against the newly-mounted render. Absent in placeholder-only mode.
+     */
+    readonly getChannelTransport?: () => ChannelTransportRouter;
+}
+export declare function createRenderHandler(deps: RenderHandlerDeps): ChannelHandler<RenderPayload>;

package/dist/channels/render-frame.js

@@ -0,0 +1,53 @@
+/**
+ * `render` channel handler — folds an inbound `render` frame into the
+ * single-render mount slot and (when transport wiring is present)
+ * activates the per-channel transport router against the newly-
+ * mounted render.
+ *
+ * Post-render-identity-collapse (2026-05-27): each iframe holds
+ * exactly one mounted render for its lifetime. The handler routes the
+ * inbound `render` to a caller-supplied `applyRender` callback that
+ * either mounts (first frame) or re-applies (subsequent frames to the
+ * same id). Frames addressed to a different `renderId` are out-of-spec
+ * and drop with a console warning — the host spawns a fresh iframe
+ * per unique render id.
+ *
+ * Placeholder mode (boot.test.ts and the C7a placeholder-only spec)
+ * omits `applyRender` + `getChannelTransport`. The handler still fires
+ * for those callers — status log keeps firing — but no React mount
+ * happens. The boot-without-renderer path remains testable.
+ */
+import { setConnectedStatus } from '../status-dom.js';
+export function createRenderHandler(deps) {
+    return {
+        type: 'render',
+        onMessage: async (payload) => {
+            const render = payload.render;
+            if (deps.pinnedRenderId !== undefined && render.id !== deps.pinnedRenderId) {
+                // Out-of-spec: each iframe is pinned to exactly one render id
+                // post-displayMode-divergence; the host spawns a fresh iframe
+                // per render. A frame for some other id means the host wired
+                // the wrong render or the server is broadcasting cross-render
+                // frames.
+                // eslint-disable-next-line no-console
+                console.warn(`[ggui:render] ignoring render for ${render.id} — iframe pinned to ${deps.pinnedRenderId}`);
+                return;
+            }
+            if (deps.applyRender !== undefined) {
+                await deps.applyRender(render);
+            }
+            setConnectedStatus(deps.statusRefs);
+            const channelTransport = deps.getChannelTransport?.();
+            if (channelTransport === undefined)
+                return;
+            if (render.type === 'mcpApps' || render.type === 'system')
+                return;
+            channelTransport.applyRender({
+                renderId: render.id,
+                ...(render.streamSpec !== undefined
+                    ? { streamSpec: render.streamSpec }
+                    : {}),
+            });
+        },
+    };
+}

package/dist/channels/system.d.ts

@@ -17,7 +17,7 @@
  *     it, so there's nothing actionable to surface.
  *   - `onObserve` absent — the observation has nowhere to go.
  */
-import type { ChannelHandler } from '@ggui-ai/channel-client';
+import type { ChannelHandler } from '@ggui-ai/live-channel';
 import type { SystemPayload } from '@ggui-ai/protocol';
 import type { ObservabilityEmitter } from '../observability.js';
 export interface SystemHandlerDeps {

package/dist/compiled-validators.d.ts

@@ -38,3 +38,18 @@ export declare const EMPTY_COMPILED_VALIDATOR_SET: CompiledValidatorSet;
  * bootstrap carries no `compiledValidators`.
  */
 export declare function loadCompiledValidators(meta: CompiledContractValidators | undefined, warn?: (message: string, detail: unknown) => void): Promise<CompiledValidatorSet>;
+/**
+ * #109 content-addressable variant: fetch the validator-bundle URL,
+ * dynamic-import the response, then delegate to
+ * {@link loadCompiledValidators}. Returns {@link EMPTY_COMPILED_VALIDATOR_SET}
+ * when `url` is undefined OR the fetch/import fails — sidecar
+ * semantics, the server-side `assertActionContract` gate remains
+ * authoritative on validator absence.
+ *
+ * Response shape: an ES module whose `default` export is a
+ * {@link CompiledContractValidators} object (produced server-side by
+ * `bundleCompiledValidatorsAsModule`). `Cache-Control: immutable` so
+ * repeat pushes with the same contract hit browser cache with no
+ * round-trip.
+ */
+export declare function loadCompiledValidatorsFromUrl(url: string | undefined, warn?: (message: string, detail: unknown) => void): Promise<CompiledValidatorSet>;

package/dist/compiled-validators.js

@@ -72,3 +72,34 @@ export async function loadCompiledValidators(meta, warn) {
         context,
     };
 }
+/**
+ * #109 content-addressable variant: fetch the validator-bundle URL,
+ * dynamic-import the response, then delegate to
+ * {@link loadCompiledValidators}. Returns {@link EMPTY_COMPILED_VALIDATOR_SET}
+ * when `url` is undefined OR the fetch/import fails — sidecar
+ * semantics, the server-side `assertActionContract` gate remains
+ * authoritative on validator absence.
+ *
+ * Response shape: an ES module whose `default` export is a
+ * {@link CompiledContractValidators} object (produced server-side by
+ * `bundleCompiledValidatorsAsModule`). `Cache-Control: immutable` so
+ * repeat pushes with the same contract hit browser cache with no
+ * round-trip.
+ */
+export async function loadCompiledValidatorsFromUrl(url, warn) {
+    if (url === undefined)
+        return EMPTY_COMPILED_VALIDATOR_SET;
+    try {
+        const mod = (await import(/* @vite-ignore */ url));
+        const compiled = mod.default;
+        if (compiled === null || typeof compiled !== 'object') {
+            warn?.('[ggui:validators] contract bundle: default export is not an object', compiled);
+            return EMPTY_COMPILED_VALIDATOR_SET;
+        }
+        return loadCompiledValidators(compiled, warn);
+    }
+    catch (err) {
+        warn?.(`[ggui:validators] contract bundle: failed to load ${url}`, err);
+        return EMPTY_COMPILED_VALIDATOR_SET;
+    }
+}

package/dist/context-observer.d.ts

@@ -47,7 +47,7 @@ import type { JsonSchema } from '@ggui-ai/protocol';
 import type { GguiContextRegistry } from './globals.js';
 /**
  * Wire-shape entry for a single contextSpec slot, mirrored from
- * {@link import('@ggui-ai/protocol/integrations/mcp-apps').GguiBootstrapMeta.contextSlots}.
+ * {@link import('@ggui-ai/protocol/integrations/mcp-apps').McpAppAiGguiRenderMeta.contextSlots}.
  */
 export interface ContextSlotInfo {
     readonly name: string;
@@ -110,14 +110,74 @@ export declare function installContextRegistry(registry: GguiContextRegistry, re
  * Identity bundle carried alongside every snapshot post. The runtime
  * captures these from the bootstrap envelope at boot and threads
  * them through `createContextStateHost` so each snapshot's two
- * destinations (host + server) carry the same authoritative session
+ * destinations (host + server) carry the same authoritative render
  * binding. Absent on dev / test code paths that don't have a real
  * bootstrap; the server mirror is skipped in that case.
+ *
+ * Post-render-identity-collapse (2026-05-27): the previous
+ * `{sessionId, appId, stackItemId}` tuple collapsed to
+ * `{renderId, appId}` — render is the single identity key.
  */
 export interface ContextPostIdentity {
-    readonly sessionId: string;
+    readonly renderId: string;
     readonly appId: string;
-    readonly stackItemId: string;
+}
+/**
+ * Snapshot poster contract — fans the same snapshot out to two
+ * destinations:
+ *
+ *   1. {@link postUpdateModelContext} — spec-canonical
+ *      `ui/update-model-context` notification. Production wires this
+ *      to `app.updateModelContext(...)`; tests inject a spy.
+ *   2. {@link postContextMirror} — server mirror via the
+ *      `ggui_runtime_sync_context` tools/call. Production wires this
+ *      to a raw `postToParent` envelope (the existing host-relay
+ *      path); tests inject a spy.
+ *
+ * Splitting the seam keeps spec-canonical MCP-Apps notifications
+ * (Destination 1) on the App method surface while leaving the
+ * non-spec `tools/call` server mirror (Destination 2) on the raw
+ * postMessage channel — matches the broader Phase 1.19b.3 followup
+ * scope (notifications via App; tools/call audit stays on raw post
+ * until a separate cleanup migrates it).
+ */
+/**
+ * Params shape accepted by the spec-canonical
+ * `app.updateModelContext` method — re-imported from
+ * `@modelcontextprotocol/ext-apps` via `Parameters<App['updateModelContext']>`
+ * in the runtime so the production poster can forward verbatim
+ * without a type cast.
+ *
+ * Tests building a recording {@link ContextSnapshotPoster} construct
+ * a `{ content: [{type: 'text', text}] }` payload — the only shape
+ * the iframe-runtime emits today.
+ */
+export interface UpdateModelContextParams {
+    content?: Array<{
+        type: 'text';
+        text: string;
+    }>;
+    structuredContent?: Record<string, unknown>;
+}
+export interface ContextSnapshotPoster {
+    /**
+     * Fire the spec-canonical `ui/update-model-context` notification
+     * carrying the prose snapshot text. Production: routes through
+     * `app.updateModelContext` (no-op when no App is bound).
+     */
+    readonly postUpdateModelContext: (params: UpdateModelContextParams) => void;
+    /**
+     * Fire the `ggui_runtime_sync_context` tools/call server mirror.
+     * Production: raw postMessage envelope (the host relays to the
+     * MCP server). Caller is responsible for honoring `identity`
+     * presence — pass an undefined-returning closure to disable the
+     * mirror.
+     */
+    readonly postContextMirror: (params: {
+        readonly renderId: string;
+        readonly appId: string;
+        readonly snapshot: Record<string, unknown>;
+    }) => void;
 }
 /**
  * React surface the host factories need. Production callers pass
@@ -133,7 +193,7 @@ export type ReactCoreForHost = Pick<typeof import('react'), 'createElement' | 'F
  * these per declared slot (via {@link createContextStateHost}).
  *
  * Built as a factory so the runtime can pass dependencies (`react`,
- * `postToParent`, `consoleWarn`) without re-importing in this module
+ * `poster`, `consoleWarn`) without re-importing in this module
  * — keeps the file pure and unit-testable.
  *
  * Exported because `__tests__/context-observer.test.ts` mounts it
@@ -141,7 +201,7 @@ export type ReactCoreForHost = Pick<typeof import('react'), 'createElement' | 'F
  */
 export declare function createSingleSlotProvider(deps: {
     readonly react: ReactCoreForHost;
-    readonly postToParent: (envelope: unknown) => void;
+    readonly poster: ContextSnapshotPoster;
     readonly consoleWarn?: (...args: unknown[]) => void;
     /** Identity bundle threaded into every snapshot post — server
      *  mirror skipped when undefined. */
@@ -174,7 +234,7 @@ export declare function createSingleSlotProvider(deps: {
  */
 export declare function createContextStateHost(deps: {
     readonly react: ReactCoreForHost;
-    readonly postToParent: (envelope: unknown) => void;
+    readonly poster: ContextSnapshotPoster;
     readonly consoleWarn?: (...args: unknown[]) => void;
     /** Identity bundle for the server-mirror destination. Threaded
      *  unchanged into `createSingleSlotProvider` so every slot's debounced
@@ -202,4 +262,4 @@ export declare function createContextStateHost(deps: {
  * bare module). Runtime call sites pass the active slots so the leak
  * path is closed by construction.
  */
-export declare function reemitLastContextValues(postToParent: (envelope: unknown) => void, activeSlotNames?: ReadonlySet<string>, identity?: ContextPostIdentity): void;
+export declare function reemitLastContextValues(poster: ContextSnapshotPoster, activeSlotNames?: ReadonlySet<string>, identity?: ContextPostIdentity): void;

package/dist/context-observer.js

@@ -82,64 +82,44 @@ function specFor(slot) {
  *      — the existing path; agent's LLM reads these via
  *      `read_widget_context` for in-turn awareness.
  *   2. `tools/call` for `ggui_runtime_sync_context` — the server mirror.
- *      Server stores the snapshot on the active StackItem; chat-
+ *      Server stores the snapshot on the active Render; chat-
  *      history rehydrate seeds `contextSlots[i].default` with the
  *      snapshotted values, restoring the user's last-known state.
  *
- * Both posts are postMessage to the parent — fire-and-forget,
- * non-blocking, naturally concurrent (queued back-to-back to the
- * postMessage channel; the host receives them in order without
- * blocking either delivery on the other). No explicit `Promise.all`
- * is needed: postMessage isn't a promise-returning API; both calls
- * return synchronously and the channel handles the ordering. This
- * is the right primitive for a snapshot mirror — neither destination
- * needs to wait for the other to ACK.
+ * Both destinations are fire-and-forget; the channel queues them
+ * back-to-back, no sequential dependency between them. This is the
+ * right primitive for a snapshot mirror — neither destination needs
+ * to wait for the other to ACK.
  *
  * Snapshot replaces an earlier per-slot delta format
  * (`[ggui:context-slot] {slot,value}`). Empirical: claude.ai's host
  * treats each `ui/update-model-context` post as a REPLACE of the
  * widget's tracked context, not a per-slot merge. Server mirror
- * matches: REPLACE-per-(sessionId, stackItemId), last-write-wins.
- * Both destinations therefore stay structurally consistent.
+ * matches: REPLACE-per-renderId, last-write-wins. Both destinations
+ * therefore stay structurally consistent.
  *
  * Server-mirror skipped when `identity` is undefined — dev/test code
  * paths that don't supply a real bootstrap shouldn't pollute the
  * server's store with synthetic ids.
  */
-function postContextSnapshot(postToParent, snapshot, identity) {
+function postContextSnapshot(poster, snapshot, identity) {
     // Destination 1: host. Always fires.
     const text = `[ggui:context] ${JSON.stringify(snapshot)}`;
-    postToParent({
-        jsonrpc: '2.0',
-        id: Math.floor(Math.random() * 1e9),
-        method: 'ui/update-model-context',
-        params: {
-            content: [
-                {
-                    type: 'text',
-                    text,
-                },
-            ],
-        },
+    poster.postUpdateModelContext({
+        content: [
+            {
+                type: 'text',
+                text,
+            },
+        ],
     });
     // Destination 2: server mirror. Skipped when identity is absent
-    // (dev / test paths without a real bootstrap). Both destinations
-    // are postMessage — the channel queues these back-to-back, no
-    // sequential dependency between them.
+    // (dev / test paths without a real bootstrap).
     if (identity) {
-        postToParent({
-            jsonrpc: '2.0',
-            id: Math.floor(Math.random() * 1e9),
-            method: 'tools/call',
-            params: {
-                name: 'ggui_runtime_sync_context',
-                arguments: {
-                    sessionId: identity.sessionId,
-                    appId: identity.appId,
-                    stackItemId: identity.stackItemId,
-                    snapshot,
-                },
-            },
+        poster.postContextMirror({
+            renderId: identity.renderId,
+            appId: identity.appId,
+            snapshot,
         });
     }
 }
@@ -163,14 +143,14 @@ function buildSnapshot() {
  * these per declared slot (via {@link createContextStateHost}).
  *
  * Built as a factory so the runtime can pass dependencies (`react`,
- * `postToParent`, `consoleWarn`) without re-importing in this module
+ * `poster`, `consoleWarn`) without re-importing in this module
  * — keeps the file pure and unit-testable.
  *
  * Exported because `__tests__/context-observer.test.ts` mounts it
  * standalone to verify the value→post→Provider cycle.
  */
 export function createSingleSlotProvider(deps) {
-    const { react, postToParent, consoleWarn, identity } = deps;
+    const { react, poster, consoleWarn, identity } = deps;
     const SingleSlotProvider = (props) => {
         const { slot, children } = props;
         // Slot-owned state. Re-mounts re-seed from `slot.default` because
@@ -204,7 +184,7 @@ export function createSingleSlotProvider(deps) {
                 // treats `ui/update-model-context` as REPLACE, so deltas
                 // wiped the un-mentioned slots).
                 contextSlotLastValues.set(slot.name, value);
-                postContextSnapshot(postToParent, buildSnapshot(), identity);
+                postContextSnapshot(poster, buildSnapshot(), identity);
             };
             if (slot.debounceMs <= 0) {
                 // Immediate path — tests + step / tab switches use this.
@@ -292,7 +272,7 @@ export function createContextStateHost(deps) {
  * bare module). Runtime call sites pass the active slots so the leak
  * path is closed by construction.
  */
-export function reemitLastContextValues(postToParent, activeSlotNames, identity) {
+export function reemitLastContextValues(poster, activeSlotNames, identity) {
     if (activeSlotNames !== undefined) {
         // Drain stale keys before re-emitting. Keep the map a faithful
         // reflection of the active mount.
@@ -307,6 +287,6 @@ export function reemitLastContextValues(postToParent, activeSlotNames, identity)
     // delta on the host side; the host ended up with only the
     // LAST-fired slot. One snapshot delivers all slots atomically.
     if (contextSlotLastValues.size > 0) {
-        postContextSnapshot(postToParent, buildSnapshot(), identity);
+        postContextSnapshot(poster, buildSnapshot(), identity);
     }
 }