@braidlabs/core 0.1.1 → 0.2.0

package/src/weave/channel.js

@@ -0,0 +1,189 @@
+import { BraidError } from '../errors.js';
+import { WEAVE_VERSION, weaveId } from './envelope.js';
+/**
+ * Five seconds: long enough to survive a slow first paint on a cold realm, short enough that a
+ * developer watching a wedged fragment gets a named error inside their attention span rather than
+ * a spinner that never resolves. Individual calls override it — the handshake uses its own.
+ */
+const DEFAULT_TIMEOUT_MS = 5_000;
+export function createBoundaryChannel(options) {
+    const { backing, fragmentId, instance } = options;
+    const defaultTimeoutMs = options.defaultTimeoutMs ?? DEFAULT_TIMEOUT_MS;
+    /** Keyed by `type` and `scope` together — see `on`. `\u0000` cannot occur in either. */
+    const handlers = new Map();
+    const handlerKey = (type, scope) => `${type}\u0000${scope ?? ''}`;
+    const pending = new Map();
+    const closeController = new AbortController();
+    const fail = (message, fixHint) => new BraidError(message, { fragmentId, stage: 'boundary', ...(fixHint === undefined ? {} : { fixHint }) });
+    function settlePending(id, settle) {
+        const entry = pending.get(id);
+        if (!entry)
+            return;
+        pending.delete(id);
+        if (entry.timer !== undefined)
+            clearTimeout(entry.timer);
+        settle(entry);
+    }
+    function post(envelope) {
+        if (closeController.signal.aborted)
+            return;
+        backing.post(envelope);
+    }
+    function onInbound(envelope) {
+        if (closeController.signal.aborted)
+            return;
+        // A reply: match it to its request and settle. An unmatched reply is dropped rather than
+        // reported — it is the normal shape of a request that already timed out, and turning every
+        // slow-but-eventual answer into a console error would train people to ignore the console.
+        if (envelope.re !== undefined) {
+            settlePending(envelope.re, (entry) => {
+                if (envelope.error)
+                    entry.reject(remoteError(envelope.error, fragmentId));
+                else
+                    entry.resolve(envelope.payload);
+            });
+            return;
+        }
+        const handler = handlers.get(handlerKey(envelope.type, envelope.scope));
+        if (!handler) {
+            // An unhandled request must be answered, or the caller waits out its whole deadline for a
+            // message that was never going to arrive. Say which type was unhandled: the most common
+            // cause is a version mismatch between the two ends.
+            if (envelope.reply) {
+                post(replyTo(envelope, undefined, {
+                    message: `no handler for "${envelope.type}"${envelope.scope === undefined ? '' : ` on scope "${envelope.scope}"`}`,
+                    stage: 'boundary',
+                }));
+            }
+            return;
+        }
+        const meta = {
+            fragmentId: envelope.fragmentId,
+            instance: envelope.instance,
+            scope: envelope.scope,
+            type: envelope.type,
+        };
+        let result;
+        try {
+            result = handler(envelope.payload, meta);
+        }
+        catch (error) {
+            if (envelope.reply)
+                post(replyTo(envelope, undefined, errorPayload(error)));
+            // A throw from a fire-and-forget handler has nobody to tell, and swallowing it is how one
+            // fragment's bug becomes another fragment's mystery. Report it where it happened.
+            else
+                console.error(`[braid:${fragmentId}] a "${envelope.type}" handler threw`, error);
+            return;
+        }
+        if (!envelope.reply)
+            return;
+        Promise.resolve(result).then((value) => post(replyTo(envelope, value)), (error) => post(replyTo(envelope, undefined, errorPayload(error))));
+    }
+    function replyTo(request, payload, error) {
+        return {
+            v: WEAVE_VERSION,
+            id: weaveId(),
+            re: request.id,
+            type: request.type,
+            fragmentId,
+            instance,
+            ...(request.scope === undefined ? {} : { scope: request.scope }),
+            ...(payload === undefined ? {} : { payload }),
+            ...(error === undefined ? {} : { error }),
+        };
+    }
+    // Attached before the channel object exists, so that a backing which delivers eagerly cannot
+    // drop a message that arrives between construction and subscription.
+    const detach = backing.receive(onInbound);
+    const channel = {
+        fragmentId,
+        instance,
+        closed: closeController.signal,
+        send(type, payload, sendOptions) {
+            post({
+                v: WEAVE_VERSION,
+                id: weaveId(),
+                type,
+                fragmentId,
+                instance,
+                ...(sendOptions?.scope === undefined ? {} : { scope: sendOptions.scope }),
+                ...(payload === undefined ? {} : { payload }),
+            });
+        },
+        request(type, payload, requestOptions) {
+            if (closeController.signal.aborted) {
+                return Promise.reject(fail(`cannot send "${type}": the boundary channel is closed`));
+            }
+            const id = weaveId();
+            const timeoutMs = requestOptions?.timeoutMs ?? defaultTimeoutMs;
+            const { promise, resolve, reject } = Promise.withResolvers();
+            const timer = timeoutMs > 0
+                ? setTimeout(() => {
+                    settlePending(id, (entry) => entry.reject(fail(`"${type}" got no reply within ${timeoutMs}ms`, 'the fragment may not have booted, may have wedged, or may not handle this message type')));
+                }, timeoutMs)
+                : undefined;
+            pending.set(id, { resolve, reject, timer });
+            post({
+                v: WEAVE_VERSION,
+                id,
+                reply: true,
+                type,
+                fragmentId,
+                instance,
+                ...(requestOptions?.scope === undefined ? {} : { scope: requestOptions.scope }),
+                ...(payload === undefined ? {} : { payload }),
+            });
+            return promise;
+        },
+        on(type, handler, onOptions) {
+            const key = handlerKey(type, onOptions?.scope);
+            handlers.set(key, handler);
+            return () => {
+                if (handlers.get(key) === handler)
+                    handlers.delete(key);
+            };
+        },
+        close() {
+            if (closeController.signal.aborted)
+                return;
+            closeController.abort();
+            // Every in-flight request is rejected before the transport goes away. The alternative — let
+            // them time out — leaves a fragment's teardown path waiting seconds on answers that can no
+            // longer arrive, which is exactly the hang Phase 3 exists to prevent.
+            for (const id of [...pending.keys()]) {
+                settlePending(id, (entry) => entry.reject(fail('the boundary channel closed before a reply arrived')));
+            }
+            handlers.clear();
+            detach();
+            backing.close();
+        },
+    };
+    options.signal?.addEventListener('abort', () => channel.close(), { once: true });
+    return channel;
+}
+function errorPayload(error) {
+    if (error instanceof BraidError) {
+        return {
+            message: error.message,
+            stage: error.stage,
+            ...(error.fixHint === undefined ? {} : { fixHint: error.fixHint }),
+        };
+    }
+    return { message: error instanceof Error ? error.message : String(error) };
+}
+/**
+ * Rebuilds a remote failure as a local `BraidError`.
+ *
+ * The remote's stage is preserved rather than flattened to `boundary`: a contract mismatch that
+ * happened inside the fragment is a contract error that merely *travelled* over the boundary, and
+ * relabelling it would point every reader at the transport instead of at the cause.
+ */
+function remoteError(payload, fragmentId) {
+    return new BraidError(payload.message, {
+        fragmentId,
+        stage: payload.stage ?? 'boundary',
+        ...(payload.fixHint === undefined ? {} : { fixHint: payload.fixHint }),
+    });
+}
+//# sourceMappingURL=channel.js.map

package/src/weave/channel.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"channel.js","sourceRoot":"","sources":["../../../../../libs/core/src/weave/channel.ts"],"names":[],"mappings":"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"}

package/src/weave/closing.d.ts

@@ -0,0 +1,99 @@
+import { BraidError } from '../errors.js';
+import { BoundaryChannel } from './channel.js';
+/**
+ * Teardown as a negotiation.
+ *
+ * Before this, `#teardown()` aborted the instance signal and dropped the subtree in one synchronous
+ * step. That is fine for a fragment whose state is all on screen and wrong for every fragment that
+ * has any. With `libs/data`'s optimistic writes and persistent outbox in the picture, unmounting a
+ * fragment mid-flush discards work the user has already been told was saved — and it does so
+ * silently, which is the part that makes it a bug rather than a limitation.
+ *
+ * ```
+ * host → CLOSE { reason, deadlineMs }
+ *          fragment enters `closing` — flush the outbox, persist drafts, release locks
+ * frag → ACK   { flushed, dropped }
+ *          host completes teardown
+ * ```
+ *
+ * The deadline is not negotiable and not extendable. **A teardown that can block forever is a worse
+ * bug than a teardown that loses a draft**: the first freezes a page the user is trying to leave,
+ * and the second at least leaves them somewhere. So the host proceeds when the deadline expires and
+ * reports what it could not confirm.
+ */
+export declare const CLOSE = "weave/close";
+export declare const DIRTY = "frag/dirty";
+export type CloseReason = 
+/** The slot left the DOM. */
+'unmount'
+/** The same fragment is about to boot again into the same slot. */
+ | 'reload'
+/** The host is navigating away from the route this fragment was mounted for. */
+ | 'navigate';
+export interface ClosePayload {
+    reason: CloseReason;
+    deadlineMs: number;
+}
+export interface CloseSummary {
+    /** Work sent successfully during the close. */
+    flushed: number;
+    /** Work that will not arrive — abandoned, or belonging to a handler that failed. */
+    dropped: number;
+    /**
+     * Work not sent, but safely persisted, so it will be retried on a later boot.
+     *
+     * A third category rather than a rounding of the other two, because it is genuinely neither: an
+     * outbox entry still in IndexedDB has not been flushed and has not been lost. Folding it into
+     * `dropped` would raise an alarm about data that is fine; folding it into `flushed` would claim a
+     * write reached the server when it has not left the device.
+     */
+    deferred?: number;
+}
+export interface CloseResult extends CloseSummary {
+    /** False when the deadline expired first — in which case the counts are what the host could see. */
+    acknowledged: boolean;
+}
+export interface DirtyPayload {
+    /** Human-readable reason the fragment has unsaved work, or null when it no longer does. */
+    reason: string | null;
+}
+export interface CloseFragmentOptions {
+    channel: BoundaryChannel;
+    fragmentId: string;
+    reason: CloseReason;
+    deadlineMs?: number;
+    /** Reports a deadline overrun. Defaults to `console.error`. */
+    onOverrun?(error: BraidError): void;
+}
+/** Host side: asks the fragment to close, and waits — but only for so long. */
+export declare function closeFragment(options: CloseFragmentOptions): Promise<CloseResult>;
+export interface CloseAndDisposeOptions extends CloseFragmentOptions {
+    /** Aborts the instance signal and closes the channel. Called once, after the negotiation ends. */
+    dispose(): void;
+}
+/**
+ * The ordering the whole phase exists to establish: **negotiate, then dispose.**
+ *
+ * Named and extracted rather than inlined into `<fragment-slot>` because it is a one-line sequence
+ * that is worthless in the wrong order — a `dispose()` before the await aborts `env.signal` while
+ * the fragment is still flushing, which is precisely the silent data loss this phase set out to
+ * fix, and it would still pass every test that only checked the counts.
+ */
+export declare function closeAndDispose(options: CloseAndDisposeOptions): Promise<CloseResult>;
+export type ClosingHandler = (reason: CloseReason) => void | Partial<CloseSummary> | Promise<void | Partial<CloseSummary>>;
+export interface ClosingCoordinator {
+    /** Registers work to run before the instance signal aborts. Returns an unregister function. */
+    onClosing(handler: ClosingHandler): () => void;
+    /** Declares (or clears) unsaved work. Pushed to the host as it changes, not asked for at close. */
+    setDirty(reason: string | null): void;
+    readonly dirty: string | null;
+}
+/**
+ * Fragment side: answers CLOSE by running every registered handler, and tracks dirty state.
+ *
+ * Dirty state is a **continuous** channel rather than a question asked during teardown, and that is
+ * deliberate. Asking "do you have unsaved work?" at close time is too late whenever the answer
+ * needs a round trip of its own — and a host that wants to warn the user before a page unload needs
+ * the answer synchronously, at a moment when it cannot await anything at all.
+ */
+export declare function createClosingCoordinator(channel: BoundaryChannel): ClosingCoordinator;

package/src/weave/closing.js

@@ -0,0 +1,130 @@
+import { BraidError } from '../errors.js';
+/**
+ * Teardown as a negotiation.
+ *
+ * Before this, `#teardown()` aborted the instance signal and dropped the subtree in one synchronous
+ * step. That is fine for a fragment whose state is all on screen and wrong for every fragment that
+ * has any. With `libs/data`'s optimistic writes and persistent outbox in the picture, unmounting a
+ * fragment mid-flush discards work the user has already been told was saved — and it does so
+ * silently, which is the part that makes it a bug rather than a limitation.
+ *
+ * ```
+ * host → CLOSE { reason, deadlineMs }
+ *          fragment enters `closing` — flush the outbox, persist drafts, release locks
+ * frag → ACK   { flushed, dropped }
+ *          host completes teardown
+ * ```
+ *
+ * The deadline is not negotiable and not extendable. **A teardown that can block forever is a worse
+ * bug than a teardown that loses a draft**: the first freezes a page the user is trying to leave,
+ * and the second at least leaves them somewhere. So the host proceeds when the deadline expires and
+ * reports what it could not confirm.
+ */
+export const CLOSE = 'weave/close';
+export const DIRTY = 'frag/dirty';
+/** Two seconds: long enough for a queued flush over a slow connection, short enough to leave on. */
+const CLOSE_DEADLINE_MS = 2_000;
+/** Host side: asks the fragment to close, and waits — but only for so long. */
+export async function closeFragment(options) {
+    const { channel, fragmentId, reason } = options;
+    const deadlineMs = options.deadlineMs ?? CLOSE_DEADLINE_MS;
+    const payload = { reason, deadlineMs };
+    try {
+        const summary = await channel.request(CLOSE, payload, { timeoutMs: deadlineMs });
+        return {
+            acknowledged: true,
+            flushed: Number(summary?.flushed ?? 0),
+            dropped: Number(summary?.dropped ?? 0),
+            deferred: Number(summary?.deferred ?? 0),
+        };
+    }
+    catch (cause) {
+        /**
+         * No ACK. The counts are unknown rather than zero, and saying so is the point of this branch —
+         * a fragment that wedged mid-flush may have persisted everything, nothing, or half of it, and
+         * a report of `dropped: 0` here would be a lie told in a reassuring tone.
+         */
+        const error = new BraidError(`the fragment did not acknowledge close within ${deadlineMs}ms`, {
+            fragmentId,
+            stage: 'teardown',
+            cause,
+            fixHint: 'the fragment may have unflushed work — check its env.onClosing() handlers, or raise the deadline ' +
+                'if a slow flush is expected here',
+        });
+        (options.onOverrun ?? ((reported) => console.error(reported)))(error);
+        return { acknowledged: false, flushed: 0, dropped: 0 };
+    }
+}
+/**
+ * The ordering the whole phase exists to establish: **negotiate, then dispose.**
+ *
+ * Named and extracted rather than inlined into `<fragment-slot>` because it is a one-line sequence
+ * that is worthless in the wrong order — a `dispose()` before the await aborts `env.signal` while
+ * the fragment is still flushing, which is precisely the silent data loss this phase set out to
+ * fix, and it would still pass every test that only checked the counts.
+ */
+export async function closeAndDispose(options) {
+    const { dispose, ...closeOptions } = options;
+    const result = await closeFragment(closeOptions);
+    dispose();
+    return result;
+}
+/**
+ * Fragment side: answers CLOSE by running every registered handler, and tracks dirty state.
+ *
+ * Dirty state is a **continuous** channel rather than a question asked during teardown, and that is
+ * deliberate. Asking "do you have unsaved work?" at close time is too late whenever the answer
+ * needs a round trip of its own — and a host that wants to warn the user before a page unload needs
+ * the answer synchronously, at a moment when it cannot await anything at all.
+ */
+export function createClosingCoordinator(channel) {
+    const handlers = new Set();
+    let dirty = null;
+    channel.on(CLOSE, async (payload) => {
+        const { reason } = (payload ?? { reason: 'unmount' });
+        /**
+         * `async` on the wrapper is load-bearing, not stylistic.
+         *
+         * A handler that throws *synchronously* escapes a bare `.map(handler)` before `allSettled` ever
+         * sees it, rejecting the whole CLOSE reply — so one broken handler would take every other
+         * handler's flush down with it and report nothing. The wrapper turns a synchronous throw into a
+         * rejected promise, which is the isolation the bus applies to subscribers for the same reason.
+         */
+        const results = await Promise.allSettled([...handlers].map(async (handler) => handler(reason)));
+        let flushed = 0;
+        let dropped = 0;
+        let deferred = 0;
+        for (const result of results) {
+            if (result.status === 'rejected') {
+                // A handler that throws has failed to flush whatever it was responsible for. Counting it as
+                // a drop is the conservative reading, and the only one that does not overstate success.
+                dropped += 1;
+                console.error('braid: a closing handler threw; its work is reported as dropped', result.reason);
+                continue;
+            }
+            const summary = result.value;
+            if (summary && typeof summary === 'object') {
+                flushed += Number(summary.flushed ?? 0);
+                dropped += Number(summary.dropped ?? 0);
+                deferred += Number(summary.deferred ?? 0);
+            }
+        }
+        return { flushed, dropped, deferred };
+    });
+    return {
+        onClosing(handler) {
+            handlers.add(handler);
+            return () => void handlers.delete(handler);
+        },
+        setDirty(reason) {
+            if (dirty === reason)
+                return;
+            dirty = reason;
+            channel.send(DIRTY, { reason });
+        },
+        get dirty() {
+            return dirty;
+        },
+    };
+}
+//# sourceMappingURL=closing.js.map

package/src/weave/closing.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"closing.js","sourceRoot":"","sources":["../../../../../libs/core/src/weave/closing.ts"],"names":[],"mappings":"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"}

package/src/weave/context-bridge.d.ts

@@ -0,0 +1,81 @@
+import { EnvContext } from '../env/fragment-env.js';
+import type { ContextBusLike } from '../context/context-bus.js';
+import { BoundaryChannel } from './channel.js';
+import { OpenPayload } from './handshake.js';
+import { FragmentCapabilities } from './capabilities.js';
+/**
+ * Context across the boundary — a **mirror**, not a remote call.
+ *
+ * The obvious implementation is a request per read: `env.context.get('cart')` sends `ctx/get` and
+ * awaits a reply. It is also wrong, and wrong in a way that would be very expensive to walk back.
+ * `EnvContext.get` is synchronous today, and a transport that cannot preserve that forces the
+ * signature to become `Promise<unknown>` — which is a public API break, and worse, a break that
+ * would land differently on each tier: synchronous on trusted, asynchronous on untrusted.
+ *
+ * So the fragment holds a local mirror instead. The host seeds it in full at OPEN and pushes every
+ * subsequent change. Reads never leave the realm, so `get` stays synchronous forever and works
+ * unchanged over a `MessagePort` in Phase 5.
+ *
+ * Three consequences worth naming, because each is an improvement rather than a compromise:
+ *
+ * 1. **Projection happens once per change, not once per read.** The host projects a value to the
+ *    fragment's declared version when it pushes; today's bus re-projects on every single `get`.
+ * 2. **Reachability is decided at the handshake**, before any state has crossed, rather than at
+ *    first subscribe. The bus already argues for the earlier of two moments; this is earlier still.
+ * 3. **Phase 6's grants have somewhere to live.** What a fragment may read becomes a question about
+ *    what enters its mirror, asked in one place, rather than a check to remember at every read.
+ */
+export declare const CTX_CHANGED = "ctx/changed";
+export interface ContextChangedPayload {
+    key: string;
+    /** Absent when the key was removed or became unprojectable for this fragment. */
+    value?: unknown;
+}
+export interface AttachContextRouterOptions {
+    /**
+     * The bus this fragment's context is routed to.
+     *
+     * Injected, never imported — see `ContextBusLike`. Most fragments resolve to the page bus; one
+     * given a `scope` resolves to a bus of its own, and this argument is the only thing that differs.
+     */
+    bus: ContextBusLike;
+    /**
+     * Which bus this router speaks for. `undefined` is the page bus.
+     *
+     * Stamped onto every `ctx/changed` it sends and matched against what the mirror expects, so a
+     * fragment attached to two buses can tell their traffic apart. Reserved on the envelope since
+     * Phase 1 for exactly this.
+     */
+    scope?: string;
+    channel: BoundaryChannel;
+    fragmentId: string;
+    /** The versions agreed at handshake, already merged with the manifest's. */
+    contextVersions: Readonly<Record<string, number>>;
+    /**
+     * What this fragment may read. Absent grants everything, which is the pre-capability behaviour.
+     *
+     * Applied here rather than at the read site because the mirror is the choke point: a key that
+     * never enters it cannot be read, cannot be subscribed to, and cannot be inferred from a
+     * subscription that never fires.
+     */
+    capabilities?: FragmentCapabilities;
+    signal: AbortSignal;
+}
+/**
+ * Host side: projects the bus into one fragment's mirror and keeps it current.
+ *
+ * Returns the opening snapshot, which the caller puts on the OPEN payload — the router does not
+ * send it itself, because OPEN carries props too and two messages where one would do is two chances
+ * for a fragment to observe half a world.
+ */
+export declare function attachContextRouter(options: AttachContextRouterOptions): Record<string, unknown>;
+/**
+ * Fragment side: the mirror, presented as the `EnvContext` a fragment already expects.
+ *
+ * Note what is *not* here — no version negotiation, no projection, no Skew. All of that stayed in
+ * the host bus, which is the point: the fragment receives values already in the shape it declared,
+ * so the migration engine never has to run in a realm whose code may be older than the schemas.
+ */
+export declare function createContextMirror(channel: BoundaryChannel, scope?: string): EnvContext & {
+    seed(open: OpenPayload): void;
+};

package/src/weave/context-bridge.js

@@ -0,0 +1,145 @@
+import { createContextGate } from './capabilities.js';
+/**
+ * Context across the boundary — a **mirror**, not a remote call.
+ *
+ * The obvious implementation is a request per read: `env.context.get('cart')` sends `ctx/get` and
+ * awaits a reply. It is also wrong, and wrong in a way that would be very expensive to walk back.
+ * `EnvContext.get` is synchronous today, and a transport that cannot preserve that forces the
+ * signature to become `Promise<unknown>` — which is a public API break, and worse, a break that
+ * would land differently on each tier: synchronous on trusted, asynchronous on untrusted.
+ *
+ * So the fragment holds a local mirror instead. The host seeds it in full at OPEN and pushes every
+ * subsequent change. Reads never leave the realm, so `get` stays synchronous forever and works
+ * unchanged over a `MessagePort` in Phase 5.
+ *
+ * Three consequences worth naming, because each is an improvement rather than a compromise:
+ *
+ * 1. **Projection happens once per change, not once per read.** The host projects a value to the
+ *    fragment's declared version when it pushes; today's bus re-projects on every single `get`.
+ * 2. **Reachability is decided at the handshake**, before any state has crossed, rather than at
+ *    first subscribe. The bus already argues for the earlier of two moments; this is earlier still.
+ * 3. **Phase 6's grants have somewhere to live.** What a fragment may read becomes a question about
+ *    what enters its mirror, asked in one place, rather than a check to remember at every read.
+ */
+export const CTX_CHANGED = 'ctx/changed';
+/**
+ * Host side: projects the bus into one fragment's mirror and keeps it current.
+ *
+ * Returns the opening snapshot, which the caller puts on the OPEN payload — the router does not
+ * send it itself, because OPEN carries props too and two messages where one would do is two chances
+ * for a fragment to observe half a world.
+ */
+export function attachContextRouter(options) {
+    const { bus, channel, fragmentId, contextVersions, signal } = options;
+    const mayRead = createContextGate(options.capabilities, fragmentId);
+    const readFor = (key) => {
+        const as = contextVersions[key];
+        try {
+            return { ok: true, value: bus.get(key, { ...(as === undefined ? {} : { as }), fragmentId }) };
+        }
+        catch (error) {
+            /**
+             * One unprojectable key must not cost the fragment every other key.
+             *
+             * The handshake already refused the versions it could see, so reaching here means a schema
+             * was registered — or a key first published — after this fragment mounted, which is a
+             * deployment race rather than a misconfiguration the developer can fix in advance. Report it
+             * and leave that one key absent.
+             */
+            console.error(`[braid:${fragmentId}] context "${key}" could not be projected for this fragment`, error);
+            return { ok: false };
+        }
+    };
+    const snapshot = {};
+    for (const key of bus.keys()) {
+        if (!mayRead(key))
+            continue;
+        const read = readFor(key);
+        if (read.ok)
+            snapshot[key] = read.value;
+    }
+    const unobserve = bus.observe((key) => {
+        if (signal.aborted)
+            return;
+        /**
+         * A denied key sends **nothing at all** — not a change, not a deletion.
+         *
+         * The obvious implementation sends a valueless `ctx/changed` and lets the mirror treat it as an
+         * absence, which produces the right value and the wrong behaviour: the fragment learns that a
+         * key it was refused exists, and learns the exact moment it changes. That is a timing channel
+         * on precisely the data the grant was written to withhold, and it is invisible in any test that
+         * only checks what `get()` returns.
+         */
+        if (!mayRead(key))
+            return;
+        const read = readFor(key);
+        /**
+         * An unprojectable key *does* send the valueless form, and the difference matters: that key was
+         * granted, so clearing a now-stale mirror entry is the honest thing to do, and the fragment was
+         * always allowed to know it exists.
+         */
+        const payload = read.ok ? { key, value: read.value } : { key };
+        channel.send(CTX_CHANGED, payload, ...(options.scope === undefined ? [] : [{ scope: options.scope }]));
+    });
+    signal.addEventListener('abort', unobserve, { once: true });
+    return snapshot;
+}
+/**
+ * Fragment side: the mirror, presented as the `EnvContext` a fragment already expects.
+ *
+ * Note what is *not* here — no version negotiation, no projection, no Skew. All of that stayed in
+ * the host bus, which is the point: the fragment receives values already in the shape it declared,
+ * so the migration engine never has to run in a realm whose code may be older than the schemas.
+ */
+export function createContextMirror(channel, scope) {
+    const values = new Map();
+    const listeners = new Map();
+    /**
+     * Registered *on this mirror's scope*, so two mirrors on one channel do not displace each other.
+     *
+     * Without scope in the address, a fragment reading both its own bus and the page bus would have
+     * the second registration silently replace the first, and one of the two buses would simply go
+     * quiet — a failure with no error and no symptom except missing updates.
+     */
+    channel.on(CTX_CHANGED, (payload) => {
+        const { key, value } = (payload ?? {});
+        if (typeof key !== 'string')
+            return;
+        if (value === undefined)
+            values.delete(key);
+        else
+            values.set(key, value);
+        for (const listener of [...(listeners.get(key) ?? [])]) {
+            try {
+                listener(value);
+            }
+            catch (error) {
+                // Same isolation rule the bus applies, for the same reason: one component's broken
+                // effect must not present as a different component silently failing to update.
+                console.error(`braid: a "${key}" context subscriber threw; other subscribers were unaffected`, error);
+            }
+        }
+    }, ...(scope === undefined ? [] : [{ scope }]));
+    return {
+        seed(open) {
+            for (const [key, value] of Object.entries(open.context ?? {}))
+                values.set(key, value);
+        },
+        get(key) {
+            return values.get(key);
+        },
+        subscribe(key, listener, subscribeOptions) {
+            let keyListeners = listeners.get(key);
+            if (!keyListeners) {
+                keyListeners = new Set();
+                listeners.set(key, keyListeners);
+            }
+            keyListeners.add(listener);
+            const unsubscribe = () => void keyListeners.delete(listener);
+            subscribeOptions?.signal?.addEventListener('abort', unsubscribe, { once: true });
+            channel.closed.addEventListener('abort', unsubscribe, { once: true });
+            return unsubscribe;
+        },
+    };
+}
+//# sourceMappingURL=context-bridge.js.map