@ggui-ai/iframe-runtime 0.1.0-rc.1

package/dist/channel-transport.js

@@ -0,0 +1,344 @@
+/**
+ * Default polling cadence for the iframe-polling transport (ms).
+ * Mirrors the server-side default on
+ * {@link DEFAULT_CHANNEL_POLL_DEFAULT_MS} in
+ * `packages/mcp-server/src/session-channel.ts`. Conservative: 10s
+ * matches a "data is fresh enough" bar without burning the parent
+ * host's `tools/call` quota.
+ */
+export const DEFAULT_IFRAME_POLL_INTERVAL_MS = 10_000;
+/**
+ * Factory.
+ *
+ * Per-channel transport routing — owns the `(stackItemId, channelName)`
+ * registry, the WS-vs-poll decision per channel, and the cross-state
+ * transitions (disconnect → poll fallback, reconnect → re-subscribe).
+ */
+export function createChannelTransportRouter(opts) {
+    /**
+     * Registry keyed by `${stackItemId}:${channelName}`. The composite
+     * key matches the server-side `channelSubs` map shape exactly, so
+     * test snapshots line up.
+     */
+    const channels = new Map();
+    const allowlist = new Set(opts.streamWebSocketLocalTools ?? []);
+    const defaultPollMs = opts.defaultPollIntervalMs ?? DEFAULT_IFRAME_POLL_INTERVAL_MS;
+    /**
+     * WS lifecycle flag. We start in `'connected'` because the router
+     * is created AFTER the subscribe ack — the runtime's bootSequence
+     * resolves `subscribeFn(...)` before threading the manager into
+     * triadWiring's `attachManager` (where the router is constructed).
+     * Status transitions update this; the router uses it to decide
+     * whether to start WS subscribes or skip straight to polling.
+     */
+    let wsStatus = 'connected';
+    let disposed = false;
+    const observe = opts.onObserve ?? (() => { });
+    function keyOf(stackItemId, channelName) {
+        return `${stackItemId}:${channelName}`;
+    }
+    function stopPolling(state) {
+        if (state.pollTimer !== null) {
+            clearInterval(state.pollTimer);
+            state.pollTimer = null;
+        }
+    }
+    function emitToBus(state, payload, complete) {
+        const envelope = {
+            sessionId: opts.sessionId,
+            channel: state.channelName,
+            mode: state.mode,
+            payload,
+            ...(complete === true ? { complete: true } : {}),
+        };
+        opts.streamBus.emit(envelope);
+    }
+    /**
+     * Start an iframe-polling loop for one channel. Idempotent — if a
+     * timer is already running we leave it alone. Fires the first poll
+     * IMMEDIATELY (no `setInterval` lead-in delay) so the first
+     * `useStream` render isn't blocked on a 10-second wait.
+     */
+    function startPolling(state) {
+        if (state.pollTimer !== null)
+            return;
+        const tick = async () => {
+            if (disposed)
+                return;
+            try {
+                const payload = await opts.toolsCall({
+                    toolName: state.toolName,
+                    args: { ...(state.args ?? {}) },
+                });
+                if (disposed)
+                    return;
+                emitToBus(state, payload);
+            }
+            catch {
+                // Swallow — next tick may succeed. The renderer's
+                // observability path already surfaces transport failures
+                // via the WS error route; per-tool poll failures stay quiet
+                // to avoid a noisy bus during transient outages.
+            }
+        };
+        // Fire-and-forget the leading tick + schedule the recurring
+        // ticks. Both are wrapped in the `disposed` guard above.
+        void tick();
+        state.pollTimer = setInterval(() => {
+            void tick();
+        }, defaultPollMs);
+    }
+    /**
+     * Send a `channel_subscribe` WS frame. Server-side bookkeeping is
+     * idempotent on `(sessionId, stackItemId, channelName)`, so re-sends
+     * on reconnect are safe.
+     */
+    function sendSubscribe(state) {
+        opts.send({
+            type: 'channel_subscribe',
+            payload: {
+                sessionId: opts.sessionId,
+                appId: opts.appId,
+                stackItemId: state.stackItemId,
+                channelName: state.channelName,
+                ...(state.args !== undefined ? { args: { ...state.args } } : {}),
+            },
+        });
+    }
+    /**
+     * Send a `channel_unsubscribe` WS frame for a removed channel.
+     * Server-side is also idempotent on unknown pairs.
+     */
+    function sendUnsubscribe(state) {
+        if (wsStatus !== 'connected')
+            return;
+        opts.send({
+            type: 'channel_unsubscribe',
+            payload: {
+                sessionId: opts.sessionId,
+                appId: opts.appId,
+                stackItemId: state.stackItemId,
+                channelName: state.channelName,
+            },
+        });
+    }
+    /**
+     * Bootstrap a channel onto its preferred transport.
+     *
+     *   - `preferWs && wsStatus === 'connected'` → send subscribe,
+     *     observe `'ws'` pick.
+     *   - `preferWs && wsStatus !== 'connected'` → start polling
+     *     fallback NOW so the user sees data while the WS reconnects,
+     *     observe `'poll'` pick. When the WS comes up, we'll attempt
+     *     `sendSubscribe` from `onWsStatusChange`.
+     *   - `!preferWs` → polling, observe `'poll'`.
+     */
+    function activate(state) {
+        if (state.preferWs && !state.permanentPollFallback) {
+            if (wsStatus === 'connected') {
+                sendSubscribe(state);
+                observe({
+                    kind: 'channel-transport-picked',
+                    stackItemId: state.stackItemId,
+                    channelName: state.channelName,
+                    transport: 'ws',
+                });
+                return;
+            }
+            // WS not ready yet — fall through to polling. We'll re-attempt
+            // the subscribe on the next 'connected' transition.
+            startPolling(state);
+            observe({
+                kind: 'channel-transport-picked',
+                stackItemId: state.stackItemId,
+                channelName: state.channelName,
+                transport: 'poll',
+            });
+            return;
+        }
+        startPolling(state);
+        observe({
+            kind: 'channel-transport-picked',
+            stackItemId: state.stackItemId,
+            channelName: state.channelName,
+            transport: 'poll',
+        });
+    }
+    return {
+        applyStackItem: (item) => {
+            if (disposed)
+                return;
+            const seenKeys = new Set();
+            const spec = item.streamSpec ?? {};
+            for (const [channelName, entry] of Object.entries(spec)) {
+                const source = entry.source;
+                // Channels without a `source.tool` declaration stay on the
+                // legacy `data` frame path — agent → server → fan-out. The
+                // router only manages the source-fed subset (1c scope).
+                if (source === undefined ||
+                    source === null ||
+                    typeof source !== 'object' ||
+                    typeof source.tool !== 'string' ||
+                    source.tool.length === 0) {
+                    continue;
+                }
+                const toolName = source.tool;
+                const channelArgs = source.args !== undefined && source.args !== null
+                    ? source.args
+                    : undefined;
+                const k = keyOf(item.stackItemId, channelName);
+                seenKeys.add(k);
+                const existing = channels.get(k);
+                if (existing !== undefined) {
+                    // Same (stackItemId, channelName) — leave the transport
+                    // bookkeeping alone. Spec changes that flip preferWs
+                    // mid-session are out of 1c scope (would require
+                    // re-handshake).
+                    continue;
+                }
+                const state = {
+                    stackItemId: item.stackItemId,
+                    channelName,
+                    toolName,
+                    ...(channelArgs !== undefined ? { args: channelArgs } : {}),
+                    mode: entry.mode ?? 'append',
+                    preferWs: allowlist.has(toolName),
+                    pollTimer: null,
+                    hasReceivedWsPayload: false,
+                    permanentPollFallback: false,
+                };
+                channels.set(k, state);
+                activate(state);
+            }
+            // Tear down any channel for THIS stack item that's no longer in
+            // the spec. Channels for OTHER stack items stay — they belong
+            // to other items that haven't been re-applied yet. Stack-pop /
+            // close-session paths call `dispose()` for the wholesale
+            // teardown.
+            for (const [k, state] of channels) {
+                if (state.stackItemId === item.stackItemId &&
+                    !seenKeys.has(k)) {
+                    stopPolling(state);
+                    sendUnsubscribe(state);
+                    channels.delete(k);
+                }
+            }
+        },
+        handleWsFrame: (msg) => {
+            if (disposed)
+                return false;
+            if (msg.type === 'channel_payload') {
+                const p = msg.payload;
+                const k = keyOf(p.stackItemId, p.channelName);
+                const state = channels.get(k);
+                if (state === undefined)
+                    return false;
+                // First WS payload after a disconnect-fallback → cancel the
+                // polling loop. Server has demonstrably resumed fan-out, so
+                // we don't need the redundant iframe-poll source for this
+                // channel any more (on this lifecycle).
+                if (!state.hasReceivedWsPayload && state.pollTimer !== null) {
+                    stopPolling(state);
+                }
+                state.hasReceivedWsPayload = true;
+                emitToBus(state, p.payload, p.complete);
+                return true;
+            }
+            if (msg.type === 'channel_error') {
+                const p = msg.payload;
+                // Locate by `channelName` only — the error payload doesn't
+                // carry `stackItemId`. We match by channel-name across active
+                // items and apply the permanent-fallback flag to the matching
+                // entries. Same channel name across stack items is rare; the
+                // policy is conservative (fall back ALL matches rather than
+                // miss one).
+                for (const state of channels.values()) {
+                    if (state.channelName !== p.channelName)
+                        continue;
+                    if (p.code === 'CHANNEL_NOT_LOCAL' ||
+                        p.code === 'CHANNEL_UNKNOWN' ||
+                        p.code === 'STACK_ITEM_NOT_FOUND') {
+                        state.permanentPollFallback = true;
+                        startPolling(state);
+                        observe({
+                            kind: 'channel-transport-fallback',
+                            stackItemId: state.stackItemId,
+                            channelName: state.channelName,
+                            reason: 'channel-not-local',
+                        });
+                    }
+                    // POLL_FAILED / SUBSCRIBE_UNAUTHORIZED are transient — the
+                    // server may recover. Don't flip the permanent fallback;
+                    // leave the WS path active. (UNAUTHORIZED would normally
+                    // imply the bootstrap token expired, in which case the
+                    // outer subscribe-fail path tears down the whole socket;
+                    // we don't need to special-case it here.)
+                }
+                return true;
+            }
+            return false;
+        },
+        onWsStatusChange: (status) => {
+            if (disposed)
+                return;
+            const prevStatus = wsStatus;
+            wsStatus = status;
+            if (status === 'disconnected' || status === 'reconnecting') {
+                // Every WS-preferring channel falls back to polling
+                // IMMEDIATELY. The user sees fresh data while the reconnect
+                // ladder runs. Reset the `hasReceivedWsPayload` flag so the
+                // first post-reconnect payload re-triggers the
+                // "stop the polling fallback" transition.
+                for (const state of channels.values()) {
+                    if (!state.preferWs)
+                        continue;
+                    if (state.permanentPollFallback)
+                        continue;
+                    if (state.hasReceivedWsPayload) {
+                        state.hasReceivedWsPayload = false;
+                    }
+                    if (state.pollTimer === null) {
+                        startPolling(state);
+                        observe({
+                            kind: 'channel-transport-fallback',
+                            stackItemId: state.stackItemId,
+                            channelName: state.channelName,
+                            reason: 'ws-disconnect',
+                        });
+                    }
+                }
+                return;
+            }
+            if (status === 'connected' &&
+                (prevStatus === 'disconnected' || prevStatus === 'reconnecting')) {
+                // Reconnected. Re-send `channel_subscribe` for every
+                // WS-preferring channel. Server is idempotent on the (session,
+                // stackItem, channel) triple, so duplicates are safe. We
+                // intentionally LEAVE the polling fallback running until the
+                // first `channel_payload` lands — bridges the gap where the
+                // server's first post-reconnect poll cycle hasn't fired yet.
+                for (const state of channels.values()) {
+                    if (!state.preferWs)
+                        continue;
+                    if (state.permanentPollFallback)
+                        continue;
+                    sendSubscribe(state);
+                    observe({
+                        kind: 'channel-transport-resubscribed',
+                        stackItemId: state.stackItemId,
+                        channelName: state.channelName,
+                    });
+                }
+            }
+        },
+        dispose: () => {
+            if (disposed)
+                return;
+            disposed = true;
+            for (const state of channels.values()) {
+                stopPolling(state);
+            }
+            channels.clear();
+        },
+    };
+}

package/dist/channels/channel-payload.d.ts

@@ -0,0 +1,20 @@
+/**
+ * `channel_payload` + `channel_error` handlers — forward to the
+ * per-channel transport router (`channel-transport.ts`).
+ *
+ * The router owns the streamSpec subscription registry (which channels
+ * are WS-subscribed vs iframe-polling). Forwarding here is a thin
+ * passthrough — the router parses the frame contents against its
+ * subscription map and dispatches to the matching consumer.
+ *
+ * Factored out of `handleTriadMessage` as part of the B3a handler
+ * extraction.
+ */
+import type { ChannelHandler } from '@ggui-ai/channel-client';
+import type { ChannelErrorPayload, ChannelPayloadFrame } from '@ggui-ai/protocol';
+import type { ChannelTransportRouter } from '../channel-transport.js';
+export interface ChannelRouterHandlerDeps {
+    readonly getChannelTransport: () => ChannelTransportRouter;
+}
+export declare function createChannelPayloadHandler(deps: ChannelRouterHandlerDeps): ChannelHandler<ChannelPayloadFrame>;
+export declare function createChannelErrorHandler(deps: ChannelRouterHandlerDeps): ChannelHandler<ChannelErrorPayload>;

package/dist/channels/channel-payload.js

@@ -0,0 +1,34 @@
+/**
+ * `channel_payload` + `channel_error` handlers — forward to the
+ * per-channel transport router (`channel-transport.ts`).
+ *
+ * The router owns the streamSpec subscription registry (which channels
+ * are WS-subscribed vs iframe-polling). Forwarding here is a thin
+ * passthrough — the router parses the frame contents against its
+ * subscription map and dispatches to the matching consumer.
+ *
+ * Factored out of `handleTriadMessage` as part of the B3a handler
+ * extraction.
+ */
+export function createChannelPayloadHandler(deps) {
+    return {
+        type: 'channel_payload',
+        onMessage: (payload) => {
+            deps.getChannelTransport().handleWsFrame({
+                type: 'channel_payload',
+                payload,
+            });
+        },
+    };
+}
+export function createChannelErrorHandler(deps) {
+    return {
+        type: 'channel_error',
+        onMessage: (payload) => {
+            deps.getChannelTransport().handleWsFrame({
+                type: 'channel_error',
+                payload,
+            });
+        },
+    };
+}

package/dist/channels/data.d.ts

@@ -0,0 +1,48 @@
+/**
+ * `data` channel handler — validates inbound stream-envelope payloads
+ * against the active stack item's `streamSpec`, then fans the validated
+ * envelope out via `streamBus`. Invalid payloads drop silently
+ * (matching `GguiSession.handleServerMessage`'s surfacing policy —
+ * the violation is already logged by the validator).
+ *
+ * Also fires `contract-error-emitted` on the optional observability
+ * sink when the envelope arrives on the reserved
+ * `CONTRACT_ERROR_CHANNEL`. Absorbed from `handleObservableMessage`
+ * in `runtime.ts` as part of the B3b cleanup — the handler is now the
+ * sole dispatch surface for `data` frames.
+ *
+ * Factored out of `handleTriadMessage` as part of the B3a handler
+ * extraction; expanded in B3b to absorb the observability-axis
+ * emission previously fired in parallel from `bootSequence`.
+ */
+import type { ChannelHandler } from '@ggui-ai/channel-client';
+import { type CanvasLifecyclePayload, type StreamEnvelope } from '@ggui-ai/protocol';
+import type { ObservabilityEmitter } from '../observability.js';
+import type { StackModel } from '../stack.js';
+import { type RendererValidatorContext } from '../validation.js';
+import type { StreamBus } from '../wire-config.js';
+export interface DataHandlerDeps {
+    readonly stackModel: StackModel;
+    readonly streamBus: StreamBus;
+    readonly validatorCtx: RendererValidatorContext;
+    /**
+     * Optional observability sink. When present, every envelope on the
+     * reserved `_ggui:contract-error` channel fires a
+     * {@link ContractErrorEmittedEvent}. Absent = the observation skips
+     * silently (matches the pre-B3b posture when no `onObserve` is
+     * bound).
+     */
+    readonly onObserve?: ObservabilityEmitter;
+    /**
+     * Optional canvas-mode lifecycle sink. When present, every envelope
+     * on the reserved `_ggui:lifecycle` channel fires this callback
+     * with the parsed payload. Production wires it to mount.tsx's
+     * AnimatorEventBus so the animator pill state machine advances.
+     * Non-canvas iframes leave it absent and the envelopes drop
+     * silently — `validateInboundStreamPayload` rejects lifecycle
+     * payloads when no reserved validator is registered for them
+     * client-side, so they never reach `streamBus.emit` either.
+     */
+    readonly onCanvasLifecycle?: (payload: CanvasLifecyclePayload) => void;
+}
+export declare function createDataHandler(deps: DataHandlerDeps): ChannelHandler<StreamEnvelope>;

package/dist/channels/data.js

@@ -0,0 +1,103 @@
+/**
+ * `data` channel handler — validates inbound stream-envelope payloads
+ * against the active stack item's `streamSpec`, then fans the validated
+ * envelope out via `streamBus`. Invalid payloads drop silently
+ * (matching `GguiSession.handleServerMessage`'s surfacing policy —
+ * the violation is already logged by the validator).
+ *
+ * Also fires `contract-error-emitted` on the optional observability
+ * sink when the envelope arrives on the reserved
+ * `CONTRACT_ERROR_CHANNEL`. Absorbed from `handleObservableMessage`
+ * in `runtime.ts` as part of the B3b cleanup — the handler is now the
+ * sole dispatch surface for `data` frames.
+ *
+ * Factored out of `handleTriadMessage` as part of the B3a handler
+ * extraction; expanded in B3b to absorb the observability-axis
+ * emission previously fired in parallel from `bootSequence`.
+ */
+import { CONTRACT_ERROR_CHANNEL, LIFECYCLE_CHANNEL, } from '@ggui-ai/protocol';
+import { validateInboundStreamPayload, } from '../validation.js';
+export function createDataHandler(deps) {
+    return {
+        type: 'data',
+        onMessage: (envelope) => {
+            if (envelope === undefined ||
+                envelope === null ||
+                typeof envelope.channel !== 'string') {
+                return;
+            }
+            // Observability-axis emission for the reserved contract-error
+            // channel. Fires BEFORE validation because the envelope shape
+            // is owned by the server's reserved validator
+            // (`BUILTIN_RESERVED_VALIDATORS`) — invalid payloads at this
+            // boundary are server-side bugs the host inspector should still
+            // surface, not silently drop.
+            if (envelope.channel === CONTRACT_ERROR_CHANNEL &&
+                deps.onObserve !== undefined) {
+                emitContractErrorFromDataFrame(envelope, deps.onObserve);
+            }
+            // Canvas-mode lifecycle
+            // envelopes — fires BEFORE validation for the same reason as
+            // the contract-error path: the wire shape is server-owned, and
+            // any reachable envelope is a server-emitted signal. The
+            // payload's `kind` discriminator narrows downstream; the
+            // animator host treats unknown kinds as no-ops. Invalid shapes
+            // silently drop here (typeof check) — defensive against future
+            // wire shape drift.
+            if (envelope.channel === LIFECYCLE_CHANNEL &&
+                deps.onCanvasLifecycle !== undefined) {
+                const payload = envelope.payload;
+                if (payload !== null &&
+                    typeof payload === 'object' &&
+                    !Array.isArray(payload) &&
+                    typeof payload.kind === 'string') {
+                    deps.onCanvasLifecycle(payload);
+                }
+            }
+            // Active stack item carries the streamSpec — mirrors
+            // `GguiSession.handleServerMessage`. Top of stack only.
+            const snapshot = deps.stackModel.snapshot();
+            const activeItem = snapshot[snapshot.length - 1];
+            const streamSpec = activeItem !== undefined &&
+                activeItem.type !== 'mcpApps' &&
+                activeItem.type !== 'system'
+                ? activeItem.streamSpec
+                : undefined;
+            const result = validateInboundStreamPayload(streamSpec, envelope.channel, envelope.payload, deps.validatorCtx);
+            if (!result.valid)
+                return;
+            deps.streamBus.emit(envelope);
+        },
+    };
+}
+/**
+ * Narrow a contract-error envelope and emit
+ * {@link ContractErrorEmittedEvent}. Malformed envelopes silently
+ * skip (trust-boundary posture — host inspector gets a row only when
+ * the wire payload carries the required discriminator fields).
+ */
+function emitContractErrorFromDataFrame(envelope, emit) {
+    const payload = envelope.payload;
+    if (payload === null || typeof payload !== 'object' || Array.isArray(payload)) {
+        return;
+    }
+    const shaped = payload;
+    const code = shaped.error !== undefined &&
+        shaped.error !== null &&
+        typeof shaped.error === 'object' &&
+        typeof shaped.error.code === 'string'
+        ? shaped.error.code
+        : undefined;
+    const toolName = typeof shaped.toolName === 'string' ? shaped.toolName : undefined;
+    if (code === undefined || toolName === undefined)
+        return;
+    const event = {
+        kind: 'contract-error-emitted',
+        code,
+        toolName,
+        ...(typeof shaped.actionName === 'string'
+            ? { actionName: shaped.actionName }
+            : {}),
+    };
+    emit(event);
+}

package/dist/channels/drain-ack.d.ts

@@ -0,0 +1,13 @@
+/**
+ * `drain_ack` channel handler — factored out of `runtime.ts` into
+ * the `@ggui-ai/channel-client` layer. The `onMessage` body fans the
+ * payload out to the module-scoped `subscribeDrainAck` listener
+ * registry so per-action state machines stay decoupled from how the
+ * frame arrives on the wire.
+ */
+import type { ChannelHandler } from '@ggui-ai/channel-client';
+import type { DrainAckPayload } from '@ggui-ai/protocol';
+export interface DrainAckHandlerDeps {
+    readonly dispatch: (payload: DrainAckPayload) => void;
+}
+export declare function createDrainAckHandler(deps: DrainAckHandlerDeps): ChannelHandler<DrainAckPayload>;

package/dist/channels/drain-ack.js

@@ -0,0 +1,15 @@
+/**
+ * `drain_ack` channel handler — factored out of `runtime.ts` into
+ * the `@ggui-ai/channel-client` layer. The `onMessage` body fans the
+ * payload out to the module-scoped `subscribeDrainAck` listener
+ * registry so per-action state machines stay decoupled from how the
+ * frame arrives on the wire.
+ */
+export function createDrainAckHandler(deps) {
+    return {
+        type: 'drain_ack',
+        onMessage: (payload) => {
+            deps.dispatch(payload);
+        },
+    };
+}

package/dist/channels/feedback.d.ts

@@ -0,0 +1,14 @@
+/**
+ * `feedback` channel handler — no-op stub.
+ *
+ * Legacy `feedback` frame: older servers emitted this as the round-trip
+ * half of the retired `tool:<name>` client-tool RPC path. Silently
+ * ignored under the `clientCapabilities` reframe; kept as a recognized
+ * type until the WS message union drops `'feedback'`. Registering a
+ * no-op handler is what keeps the registry's dispatch from logging
+ * "no handler for type 'feedback'" warnings — the silence is
+ * intentional, the handler documents that.
+ */
+import type { ChannelHandler } from '@ggui-ai/channel-client';
+import type { JsonObject } from '@ggui-ai/protocol';
+export declare function createFeedbackHandler(): ChannelHandler<JsonObject>;

package/dist/channels/feedback.js

@@ -0,0 +1,19 @@
+/**
+ * `feedback` channel handler — no-op stub.
+ *
+ * Legacy `feedback` frame: older servers emitted this as the round-trip
+ * half of the retired `tool:<name>` client-tool RPC path. Silently
+ * ignored under the `clientCapabilities` reframe; kept as a recognized
+ * type until the WS message union drops `'feedback'`. Registering a
+ * no-op handler is what keeps the registry's dispatch from logging
+ * "no handler for type 'feedback'" warnings — the silence is
+ * intentional, the handler documents that.
+ */
+export function createFeedbackHandler() {
+    return {
+        type: 'feedback',
+        onMessage: () => {
+            /* no-op — legacy stub */
+        },
+    };
+}

package/dist/channels/index.d.ts

@@ -0,0 +1,7 @@
+export { createPropsUpdateHandler, type PropsUpdateHandlerDeps, } from './props-update.js';
+export { createDrainAckHandler, type DrainAckHandlerDeps, } from './drain-ack.js';
+export { createPushHandler, type PushHandlerDeps } from './push.js';
+export { createDataHandler, type DataHandlerDeps } from './data.js';
+export { createFeedbackHandler } from './feedback.js';
+export { createChannelPayloadHandler, createChannelErrorHandler, type ChannelRouterHandlerDeps, } from './channel-payload.js';
+export { createSystemHandler, type SystemHandlerDeps } from './system.js';

package/dist/channels/index.js

@@ -0,0 +1,7 @@
+export { createPropsUpdateHandler, } from './props-update.js';
+export { createDrainAckHandler, } from './drain-ack.js';
+export { createPushHandler } from './push.js';
+export { createDataHandler } from './data.js';
+export { createFeedbackHandler } from './feedback.js';
+export { createChannelPayloadHandler, createChannelErrorHandler, } from './channel-payload.js';
+export { createSystemHandler } from './system.js';