@ggui-ai/iframe-runtime 0.14.0 → 0.15.0

package/dist/meta-parse.js

@@ -50,7 +50,7 @@
  * At least one mode MUST be present. Half-live (wsUrl without wsToken)
  * is structurally rejected by the combiner.
  */
-import { PUBLIC_ENV_APP_KEY_RE } from '@ggui-ai/protocol';
+import { PUBLIC_ENV_APP_KEY_RE } from '@ggui-ai/protocol/wire';
 import { parseMcpAppAiGguiRenderMeta } from '@ggui-ai/protocol/integrations/mcp-apps';
 /**
  * Type guard — true iff `value` is a non-null, non-array plain object.

package/dist/observability.d.ts

@@ -179,15 +179,29 @@ export interface UiFeedbackEvent {
     readonly toolName?: string;
 }
 /**
- * The evidence that latched a relay dead zone (ggui#599 cycle-2):
- * `'confirmed-refusal'` — the relay answered a declared refusal code
- * (helper-minted; outranks any positive advertisement), vs
- * `'advert-silent'` — the host never advertised `serverTools` and the
- * attempt failed relay-shaped.
+ * The evidence that latched a relay dead zone:
+ *   - `'confirmed-refusal'` — the relay answered a declared refusal code
+ *     (helper-minted; outranks any positive advertisement) (ggui#599
+ *     cycle-2);
+ *   - `'advert-silent'` — the host never advertised `serverTools` and
+ *     the attempt failed relay-shaped;
+ *   - `'boot-failed'` — the mandatory `ui/initialize` handshake did not
+ *     complete (refused, timed out, or the transport failed), so
+ *     nothing can ever be delivered in this document (ggui#830). Not a
+ *     probe the runtime minted: the outcome of the one request every
+ *     session begins with — the strongest confirmed outcome there is.
+ *     It clears the only way a handshake failure can: the next boot's
+ *     close edge.
+ *
+ * The union is closed per renderer version; nothing in a host branches
+ * on the trigger (the first-party host passes it through untouched) —
+ * the edge is the fact, the trigger is why. A host that does branch on
+ * it should treat a value it does not know as "latched, reason
+ * unknown", never as "not latched".
  *
  * @public
  */
-export type RelayLatchTrigger = 'confirmed-refusal' | 'advert-silent';
+export type RelayLatchTrigger = 'confirmed-refusal' | 'advert-silent' | 'boot-failed';
 /**
  * Fired at the two transition edges of the renderer's
  * relay-incapability latch — the runtime's confirmed determination
@@ -195,7 +209,9 @@ export type RelayLatchTrigger = 'confirmed-refusal' | 'advert-silent';
  *
  *   - `'latched'` — a real user gesture just failed relay-shaped on a
  *     host whose captured capability handshake never advertised
- *     `serverTools`, or the relay answered a declared refusal code.
+ *     `serverTools`, or the relay answered a declared refusal code, or
+ *     the host refused `ui/initialize` itself (`'boot-failed'`,
+ *     ggui#830 — no gesture is needed to know nothing can be delivered).
  *     The runtime now treats relay as confirmed-unavailable: it shows
  *     one persistent explanation, arms the dead-zone cue for every
  *     later gesture, and channel polls fail fast without a transport
@@ -214,9 +230,11 @@ export type RelayLatchTrigger = 'confirmed-refusal' | 'advert-silent';
  * a latch standing from a prior mount closes it with a `'cleared'`
  * edge before the new session starts.
  *
- * Always emitted via the postMessage-to-parent default — the emission
- * sites live in module-level gesture-dispatch code outside the boot
- * graph, so they never flow through an injected `onObserve` sink.
+ * Always emitted via the postMessage-to-parent default, by rule — the
+ * gesture-dispatch emission sites run outside any given boot call, and
+ * the boot-graph site (the `boot-failed` edge, ggui#830) follows the
+ * same rule — so these edges never flow through an injected
+ * `onObserve` sink and a host reads every edge the same way.
  *
  * @public
  */
@@ -249,9 +267,10 @@ export type RelayIncapabilityEvent = {
  * document (pulse, spoken cue, fallback toast); this event makes the
  * attempt COUNTABLE by the host.
  *
- * Contract: exactly one per gesture attempted while latched whose
- * attempt comes back undelivered (relay-shaped failure or a declared
- * refusal); never emitted off-latch, and never from the channel
+ * Contract: exactly one per gesture whose UNDELIVERED outcome
+ * (relay-shaped failure or a declared refusal) lands while the latch
+ * stands — an in-flight gesture that raced the latching one counts;
+ * never emitted off-latch, and never from the channel
  * router's fail-fast ticks. Counted at the outcome, not the tap: the
  * gesture that latched the zone is the `'latched'` edge and the gesture
  * that heals it is the `'cleared'` edge — neither is a dead tap.

package/dist/provisional-renderer.d.ts

@@ -31,7 +31,7 @@
  *     while suspended, matching host-SDK behavior.
  */
 import React, { type ReactNode } from 'react';
-import type { StreamEnvelope } from '@ggui-ai/protocol';
+import type { StreamEnvelope } from '@ggui-ai/protocol/wire';
 export interface ProvisionalMount {
     /**
      * Feed a stream envelope. Ignores non-PREVIEW_CHANNEL envelopes

package/dist/react-renderer.d.ts

@@ -30,7 +30,7 @@
  * TypeScript config doesn't need a JSX runtime plumbing.
  */
 import React, { type ReactNode } from 'react';
-import type { AppTheme } from '@ggui-ai/protocol';
+import type { AppTheme } from '@ggui-ai/protocol/wire';
 export interface ReactRootMountOptions {
     /**
      * GguiSession whose componentCode + props drive the mount. Only

package/dist/registry-subscribe.d.ts

@@ -1,4 +1,4 @@
-import type { AckPayload } from '@ggui-ai/protocol';
+import type { AckPayload } from '@ggui-ai/protocol/wire';
 import type { ConnectionStatus } from '@ggui-ai/protocol/transport/websocket';
 import type { McpAppAiGguiRenderMeta } from '@ggui-ai/protocol/integrations/mcp-apps';
 import type { AnyTransportHandle, ChannelLogger, ChannelRegistry, RegistryPollingOptions, RegistrySseOptions, WsTransportHandle } from '@ggui-ai/live-channel';

package/dist/render-item.d.ts

@@ -1,5 +1,5 @@
 import type { ReactNode } from 'react';
-import type { AppTheme, GguiSession } from '@ggui-ai/protocol';
+import type { AppTheme, GguiSession } from '@ggui-ai/protocol/wire';
 import type { GguiSessionSeedInput } from './types.js';
 import { type WireConfig } from '@ggui-ai/wire';
 import type { StreamBus } from './wire-config.js';

package/dist/runtime-telemetry.js

@@ -1,4 +1,4 @@
-import { RUNTIME_TELEMETRY_MAX_EVENTS } from '@ggui-ai/protocol';
+import { RUNTIME_TELEMETRY_MAX_EVENTS } from '@ggui-ai/protocol/wire';
 const FIRST_FLUSH_DELAY_MS = 4_000;
 const FLUSH_THROTTLE_MS = 8_000;
 const MAX_FLUSHES_PER_SESSION = 12;

package/dist/runtime.d.ts

@@ -25,7 +25,7 @@
  * wrapper, which routes it to the host's `onError` callback.
  */
 import './zod-jitless.js';
-import type { DrainAckPayload, JsonValue, JsonObject, GguiSession } from '@ggui-ai/protocol';
+import type { DrainAckPayload, JsonValue, JsonObject, GguiSession } from '@ggui-ai/protocol/wire';
 import type { WebSocketMessage } from '@ggui-ai/protocol/transport/websocket';
 import { type McpAppAiGguiRenderMeta, type McpAppBootstrapFailedMessage, type McpAppRendererReadyMessage } from '@ggui-ai/protocol/integrations/mcp-apps';
 import type { GguiSessionSeedInput } from './types.js';
@@ -279,10 +279,12 @@ export interface BootSequenceOptions {
      * entirely (matches the ProtocolError posture; the `<McpAppIframe>`
      * host wrapper decides whether to bind this via its `onObserve`
      * prop). Exception: `relay-incapability` events do NOT flow through
-     * this seam — they originate in module-level gesture-dispatch code
-     * outside the boot graph (it runs independently of any given boot
-     * call) and always ride the postMessage-to-parent default, whether
-     * or not this option is bound.
+     * this seam — by rule they always ride the postMessage-to-parent
+     * default, whether or not this option is bound: most emission sites
+     * are module-level gesture-dispatch code that runs independently of
+     * any given boot call, and the one inside the boot graph (the
+     * `boot-failed` edge, ggui#830) follows the same rule so a host reads
+     * every edge the same way.
      */
     readonly onObserve?: ObservabilityEmitter;
     /**
@@ -704,19 +706,22 @@ export declare function dispatchSubmitAction(args: {
 /**
  * Channel-transport router's `tools/call` invoker (ggui#440) —
  * iframe-polling transport, `tools/call` against the parent MCP host
- * via `app.callServerTool` (spec-canonical) when the App handle is
- * set; falls back to raw postMessage pre-handshake or in tests.
+ * via `app.callServerTool` (spec-canonical); with no App bound the
+ * call answers a code-less error envelope — never a raw postMessage.
  * Direct call (no LLM consent loop). Returns the tool's
  * structuredContent (or `content[0]` if that's where the payload
  * landed) as a `JsonValue`. On RPC error we throw — the router
  * catches and silently retries on the next tick.
  *
- * Once a REAL gesture has confirmed this host can't relay (the latch
- * above — set only after {@link dispatchSubmitAction} actually tried
- * and failed on a host with no `serverTools` advertised, with
- * capabilities already captured, AND the failure was relay-shaped —
- * not a well-formed `{ok:false}` result; see `isRelayShapedFailure`),
- * every subsequent poll will fail identically.
+ * Once this document has confirmed it cannot relay (the latch above —
+ * set through the ONE writer on exactly three paths: a REAL gesture
+ * that failed relay-shaped on a host that never advertised
+ * `serverTools`, with capabilities already captured (`advert-silent`);
+ * a declared refusal code answered under a positive advertisement
+ * (`confirmed-refusal`); or the host's own failure of the mandatory
+ * `ui/initialize` handshake, before any gesture (`boot-failed`,
+ * ggui#830) — never a well-formed `{ok:false}` result; see
+ * `isRelayShapedFailure`), every subsequent poll will fail identically.
  *
  * This guard does NOT stop the router's poll loop, and nothing here
  * should ever be written so that it could (ggui#443). It does two
@@ -742,10 +747,13 @@ export declare function dispatchSubmitAction(args: {
  * (ggui's own embed host pre-Task-2 is exactly this case) — silently
  * killing working channel polls forever. That is "absence of a
  * capability blocks an attempt", which the fail-safe constraint
- * forbids. The latch implies `!hostCanRelayToolCalls()` (it only
- * ever sets inside that guard), so testing it alone is sufficient —
- * a host that never fails a real gesture never latches, and its
- * channels keep working.
+ * forbids. The latch is set only by a CONFIRMED OUTCOME — a failed
+ * real gesture (the advert-silent leg, or a confirmed refusal under a
+ * positive advertisement, ggui#599 cycle-2) or a failed handshake
+ * (ggui#830), never by an advertisement's absence — so testing the
+ * latch alone is sufficient: a host that answers its handshake and
+ * never fails a real gesture never latches, and its channels keep
+ * working.
  *
  * Extracted to a named export (rather than an inline closure inside
  * `bootProduction`) so unit tests can drive it directly through the

package/dist/runtime.js

@@ -31,7 +31,7 @@ import { connectionStore } from './connection.js';
 import { MCP_APP_BOOTSTRAP_FAILED_TYPE, MCP_APP_RENDERER_READY_TYPE, parseMcpAppAiGguiRenderMeta, readGguiShellEnvelope, } from '@ggui-ai/protocol/integrations/mcp-apps';
 import { effectiveThemeId, effectiveThemeMode, } from '@ggui-ai/protocol/integrations/theme-binding';
 import { extractLocatorFromToolResult, parseMetaFromGlobal, parseMetaFromToolResult, validateMeta, } from './meta-parse.js';
-import { projectHostContext } from '@ggui-ai/protocol';
+import { projectHostContext } from '@ggui-ai/protocol/wire';
 import { App, PostMessageTransport } from '@modelcontextprotocol/ext-apps';
 import { applyHostContextStyling, attachListener as attachHostContextListener, seed as seedHostContext, } from './host-context-emitter.js';
 import { mapHostPaletteToGguiVars } from './host-palette-bridge.js';
@@ -421,11 +421,35 @@ export async function bootSequence(opts) {
     // covers every boot path; arrivals before a renderer publishes
     // `applyRender` no-op inside the listener.
     installPersistentToolResultListener(app);
+    // Fresh boot ⇒ the relay latch and the connection store start
+    // aligned (ggui#670): a standing latch from a prior mount in a
+    // re-booted document must not outlive the store it was written to.
+    // It runs BEFORE the handshake so that every boot passes the close
+    // edge before it can latch — the boot-failed write below is then
+    // always on-edge (ggui#830 fold): a prior zone ends with its
+    // 'cleared' edge and its summary, never buried under a second
+    // 'latched' with its tally erased.
+    resetRelayLatchForBoot();
     const initResult = await connectApp(app, transport);
     if (!initResult.ok) {
         setStatus(refs, `ui/initialize failed: ${initResult.message}`, 'error');
         retireShellLoadingIndicator(doc);
         emitBootFailure('UI_INITIALIZE_FAILED', initResult.message);
+        // The maximal dead zone (ggui#830): the host refused the handshake
+        // every session begins with, so nothing can be delivered here — the
+        // relay latch sets through its one writer (store false, 'latched'
+        // edge, standing notice) instead of leaving this document with
+        // `isConnected === true`, no explanation and no count. No gesture
+        // is needed for that knowledge, and no gesture is suppressed by it:
+        // every later tap still attempts (attempt-always) and lands as a
+        // counted dead tap. The scope is empty because no bootstrap has
+        // named a session yet; it clears the only way a handshake failure
+        // can — the next boot's close edge, which this boot itself already
+        // passed above, so this write is on-edge by construction. The
+        // gesture gate's pre-capture rule ("never latch before the host has
+        // been asked") does not apply here: the host HAS been asked — this
+        // is its answer to `ui/initialize`, resolved as failure.
+        announceRelayIncapability('boot-failed', {});
         return { ok: false, mountedRender };
     }
     // Record what this host said it can do (ggui#440). Earliest valid
@@ -678,10 +702,6 @@ export async function bootSequence(opts) {
     // Fresh boot ⇒ not superseded (matters only for test re-runs that
     // reuse the module; a real iframe boots once).
     mountSuperseded = false;
-    // Fresh boot ⇒ the relay latch and the connection store start
-    // aligned (ggui#670): a standing latch from a prior mount in a
-    // re-booted document must not outlive the store it was written to.
-    resetRelayLatchForBoot();
     telemetry?.record('boot.path', JSON.stringify({
         hasStaticContent,
         hasLiveTrio,
@@ -1657,7 +1677,11 @@ async function callServerToolSpec(toolName, args) {
  *
  * Unknown codes NEVER confirm — they may be proxy- or server-minted
  * (e.g. `-32603` internal error), and classifying them would misbrand
- * capable mounts. They stay on the per-gesture transient path.
+ * capable mounts. They never CONFIRM (they can latch only through
+ * the advert-silent leg, never on an advertising host); off-latch they
+ * stay on the per-gesture transient path, and inside a standing zone
+ * they count as dead taps like every other undelivered outcome
+ * (ggui#826).
  */
 const CONFIRMED_RELAY_REFUSAL_CODES = new Set([-32601]);
 /**
@@ -1775,6 +1799,20 @@ function classifySubmitActionResponse(resp) {
  * carries a result envelope, so neither is evidence the relay worked.
  */
 function isRelayShapedFailure(resp) {
+    // "Relay-shaped" IS "undelivered" on this leg, by construction — not
+    // by hope (ggui#832, ruled from the hosts' source): every JSON-RPC
+    // error the iframe sees here is host- or transport-minted. The MCP
+    // SDK server turns a tool handler's throw into an `isError` RESULT and
+    // mints JSON-RPC codes only for its own gate; the guuey view-host
+    // answers a rejecting relay with an in-band unavailable RESULT, never
+    // an error; ggui's embed host proxies over HTTP and mints its OWN
+    // codes for a failed proxy. So a server-side outcome always arrives
+    // as a `CallToolResult` (`ok:true` and `ok:false` alike clear the
+    // latch), and an error envelope always means the call did not round
+    // trip. A third-party host that forwarded a server's JSON-RPC error
+    // verbatim would be indistinguishable by code — that is the
+    // host-helper conformance catalog's business (H3 / R1), not this
+    // predicate's.
     // Null-tolerant on `error`, matching `classifySubmitActionResponse`'s
     // own check: an `{error:null, result:{...}}` envelope classifies as
     // success there, so it must also read as NOT relay-shaped-failure
@@ -2308,6 +2346,22 @@ function transitionRelayLatch(next, trigger, scope = {}) {
     relayLatchTrigger = undefined;
     relayLatchScope = {};
 }
+/**
+ * Set the latch AND present it — the three steps every latch-set path
+ * takes, in one place: the transition through the ONE writer (store
+ * flip + `'latched'` edge), a fresh dead zone (unspent cue throttles —
+ * the state belongs to THIS notice, so a second latch-set path never
+ * has to know the clear edge already reset it), and the standing
+ * explanation, marked so the per-gesture cue arms on its dismissal.
+ * Callers: the dispatch outcome gate (a gesture's confirmed relay
+ * failure) and the boot sequence (a refused `ui/initialize`, ggui#830).
+ */
+function announceRelayIncapability(trigger, scope) {
+    transitionRelayLatch(true, trigger, scope);
+    resetRelayCueThrottles();
+    showActionToast('This host cannot relay actions to the agent — interactive controls will not work here.', 'action_required');
+    markRelayNotice();
+}
 /**
  * One {@link RelayDeadTapEvent} per gesture attempted inside a standing
  * dead zone that came back UNDELIVERED (ggui#670 Phase 3). Called from
@@ -2891,39 +2945,46 @@ export function dispatchSubmitAction(args) {
         // helper-minted refusal code, which outranks any positive
         // advertisement (the advertises-but-refuses host previously got a
         // fresh transient toast per tap, forever). Timeouts and unknown
-        // codes never reach the second leg; the un-classify edge for BOTH
-        // is the same response-arrival clear guard above (attempt-always
-        // preserved — nothing here suppresses dispatch, per the #443
-        // doctrine: the attempt is the self-heal sensor).
+        // codes never reach the second leg — they never CONFIRM (the
+        // advert-silent leg alone can latch on them); inside a standing
+        // zone they are counted like every other undelivered outcome by
+        // the branch below (ggui#826). The un-classify edge for
+        // BOTH legs is the same response-arrival clear guard above
+        // (attempt-always preserved — nothing here suppresses dispatch,
+        // per the #443 doctrine: the attempt is the self-heal sensor).
         const confirmedRefusal = isConfirmedRelayRefusal(resp);
+        if (relayIncapabilityAnnounced && isRelayShapedFailure(resp)) {
+            // A gesture whose undelivered outcome landed inside a standing
+            // dead zone — a dead tap, counted for the host (ggui#670 Phase 3);
+            // an in-flight gesture that raced the latching one counts too.
+            // Counted on the OUTCOME and keyed on the LATCH, never on
+            // advertisement (ggui#826): the advertises-but-refuses host
+            // latches by a confirmed refusal, and its later code-less or
+            // timeout failures are exactly the undelivered gestures the
+            // RelayDeadTapEvent contract promises to count. The eligibility
+            // predicate below is the LATCH-SET rule — a timeout or unknown
+            // code never CONFIRMS; it can latch only through the advert-silent
+            // leg, never on an advertising host — and is the wrong key for
+            // counting. Every outcome that
+            // reaches here while the latch stands is relay-shaped by
+            // construction (the response-arrival guard above cleared on any
+            // well-formed result); the conjunct states the contract instead
+            // of trusting that. The latching gesture is the 'latched' edge
+            // and a gesture that heals the zone is the 'cleared' edge —
+            // neither is a dead tap.
+            emitRelayDeadTap(intent, { sessionId, appId });
+            return;
+        }
         if (hostCapabilitiesCaptured() &&
             ((!hostCanRelayToolCalls() && isRelayShapedFailure(resp)) ||
                 confirmedRefusal)) {
-            if (!relayIncapabilityAnnounced) {
-                // Transition edge — the paired 'cleared' edge lives at the
-                // response-arrival guard above. NEVER emit off-edge (e.g. per
-                // channel poll tick): the router ticks on an interval and
-                // would spam; the two edges carry the full information.
-                transitionRelayLatch(true, confirmedRefusal ? 'confirmed-refusal' : 'advert-silent', { sessionId, appId });
-                // Establish the flag's invariant where the notice it describes
-                // is created: a freshly-shown notice is undismissed, and its
-                // dead zone starts with an unspent throttle. Today every
-                // re-latch already passes through the clear edge above (which
-                // resets both), so this is the same value arriving by a second
-                // route — kept because the state belongs to THIS notice, and a
-                // future second latch-set path shouldn't have to know that.
-                resetRelayCueThrottles();
-                showActionToast('This host cannot relay actions to the agent — interactive controls will not work here.', 'action_required');
-                markRelayNotice();
-            }
-            else {
-                // A gesture attempted inside a standing dead zone came back
-                // undelivered — a dead tap, counted for the host (ggui#670
-                // Phase 3). The latching gesture above is the 'latched' edge,
-                // and a gesture that heals the zone is the 'cleared' edge —
-                // neither is a dead tap.
-                emitRelayDeadTap(intent, { sessionId, appId });
-            }
+            // Transition edge — the paired 'cleared' edge lives at the
+            // response-arrival guard above. NEVER emit off-edge (e.g. per
+            // channel poll tick): the router ticks on an interval and
+            // would spam; the two edges carry the full information. A
+            // standing latch never reaches here: its undelivered outcomes
+            // were counted above, and a delivered one cleared it.
+            announceRelayIncapability(confirmedRefusal ? 'confirmed-refusal' : 'advert-silent', { sessionId, appId });
             return;
         }
         showActionToast(`⚠ ${intent} — could not reach the agent`, 'error');
@@ -2932,19 +2993,22 @@ export function dispatchSubmitAction(args) {
 /**
  * Channel-transport router's `tools/call` invoker (ggui#440) —
  * iframe-polling transport, `tools/call` against the parent MCP host
- * via `app.callServerTool` (spec-canonical) when the App handle is
- * set; falls back to raw postMessage pre-handshake or in tests.
+ * via `app.callServerTool` (spec-canonical); with no App bound the
+ * call answers a code-less error envelope — never a raw postMessage.
  * Direct call (no LLM consent loop). Returns the tool's
  * structuredContent (or `content[0]` if that's where the payload
  * landed) as a `JsonValue`. On RPC error we throw — the router
  * catches and silently retries on the next tick.
  *
- * Once a REAL gesture has confirmed this host can't relay (the latch
- * above — set only after {@link dispatchSubmitAction} actually tried
- * and failed on a host with no `serverTools` advertised, with
- * capabilities already captured, AND the failure was relay-shaped —
- * not a well-formed `{ok:false}` result; see `isRelayShapedFailure`),
- * every subsequent poll will fail identically.
+ * Once this document has confirmed it cannot relay (the latch above —
+ * set through the ONE writer on exactly three paths: a REAL gesture
+ * that failed relay-shaped on a host that never advertised
+ * `serverTools`, with capabilities already captured (`advert-silent`);
+ * a declared refusal code answered under a positive advertisement
+ * (`confirmed-refusal`); or the host's own failure of the mandatory
+ * `ui/initialize` handshake, before any gesture (`boot-failed`,
+ * ggui#830) — never a well-formed `{ok:false}` result; see
+ * `isRelayShapedFailure`), every subsequent poll will fail identically.
  *
  * This guard does NOT stop the router's poll loop, and nothing here
  * should ever be written so that it could (ggui#443). It does two
@@ -2970,10 +3034,13 @@ export function dispatchSubmitAction(args) {
  * (ggui's own embed host pre-Task-2 is exactly this case) — silently
  * killing working channel polls forever. That is "absence of a
  * capability blocks an attempt", which the fail-safe constraint
- * forbids. The latch implies `!hostCanRelayToolCalls()` (it only
- * ever sets inside that guard), so testing it alone is sufficient —
- * a host that never fails a real gesture never latches, and its
- * channels keep working.
+ * forbids. The latch is set only by a CONFIRMED OUTCOME — a failed
+ * real gesture (the advert-silent leg, or a confirmed refusal under a
+ * positive advertisement, ggui#599 cycle-2) or a failed handshake
+ * (ggui#830), never by an advertisement's absence — so testing the
+ * latch alone is sufficient: a host that answers its handshake and
+ * never fails a real gesture never latches, and its channels keep
+ * working.
  *
  * Extracted to a named export (rather than an inline closure inside
  * `bootProduction`) so unit tests can drive it directly through the

package/dist/types.d.ts

@@ -15,7 +15,7 @@
  * declared the manager's constructor bag has been retired.
  */
 import type { McpAppAiGguiRenderMeta } from '@ggui-ai/protocol/integrations/mcp-apps';
-import type { HostContextProjection, ComponentGguiSession, SystemGguiSession } from '@ggui-ai/protocol';
+import type { HostContextProjection, ComponentGguiSession, SystemGguiSession } from '@ggui-ai/protocol/wire';
 /**
  * The four server-assigned ledger fields on every wire-delivered
  * {@link GguiSession}. They're stamped by the server's per-render event

package/dist/validation.d.ts

@@ -26,7 +26,7 @@
  * host wrapper explicitly does NOT run this path — its only contract is
  * the postMessage bridge to the renderer iframe.
  */
-import type { ActionSpec, ActionEnvelope, ContextSpec, JsonObject, PropsSpec, ReservedChannelValidator, StreamSpec, ValidationResult } from '@ggui-ai/protocol';
+import type { ActionSpec, ActionEnvelope, ContextSpec, JsonObject, PropsSpec, ReservedChannelValidator, StreamSpec, ValidationResult } from '@ggui-ai/protocol/wire';
 import type { CompiledValidatorSet } from './compiled-validators.js';
 /**
  * Install the precompiled validators loaded from the bootstrap. Called

package/dist/validation.js

@@ -1,4 +1,4 @@
-import { isKnownReservedChannel, validateActionEnvelope, validateContextData, validatePropsData, validateStreamData, } from '@ggui-ai/protocol';
+import { isKnownReservedChannel, validateActionEnvelope, validateContextData, validatePropsData, validateStreamData, } from '@ggui-ai/protocol/wire';
 // =============================================================================
 // Active precompiled-validator set
 // =============================================================================

package/dist/wire-config.d.ts

@@ -16,7 +16,7 @@
  * ProtocolError dual-emission policy, and the tools/call-vs-WS
  * dispatch transport.
  */
-import type { ActionEnvelope, GguiSession } from '@ggui-ai/protocol';
+import type { ActionEnvelope, GguiSession } from '@ggui-ai/protocol/wire';
 import type { GguiSessionSeedInput } from './types.js';
 import { ClientContractViolationError, StreamBus, type WireConfig } from '@ggui-ai/wire';
 import type { WebSocketMessage } from '@ggui-ai/protocol/transport/websocket';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ggui-ai/iframe-runtime",
-  "version": "0.14.0",
+  "version": "0.15.0",
   "description": "The iframe-local ggui runtime: a self-contained ESM bundle that boots inside an MCP Apps host iframe, runs the protocol-version handshake, opens the live-channel WebSocket, and mounts the rendered UI. Bundles React, ReactDOM, and the ggui design system so generated component code has a single seam to read from.",
   "keywords": [
     "ggui",
@@ -41,12 +41,12 @@
     "react": "^19.0.0",
     "react-dom": "^19.0.0",
     "zod": "^4.3.6",
-    "@ggui-ai/gadgets": "0.14.0",
-    "@ggui-ai/preview-a2ui": "0.14.0",
-    "@ggui-ai/live-channel": "0.14.0",
-    "@ggui-ai/protocol": "0.14.0",
-    "@ggui-ai/design": "0.14.0",
-    "@ggui-ai/wire": "0.14.0"
+    "@ggui-ai/design": "0.15.0",
+    "@ggui-ai/gadgets": "0.15.0",
+    "@ggui-ai/live-channel": "0.15.0",
+    "@ggui-ai/preview-a2ui": "0.15.0",
+    "@ggui-ai/protocol": "0.15.0",
+    "@ggui-ai/wire": "0.15.0"
   },
   "peerDependencies": {
     "@modelcontextprotocol/sdk": "^1.27.0"