fuzor 0.4.0 → 0.5.1

package/dist/server-components/browser.d.ts

@@ -0,0 +1,75 @@
+import * as Effect from "effect/Effect";
+import { type ViewManifest, type Json, type Values, type ViewLimits } from "./protocol.js";
+export type { ViewManifest, ViewSnapshot, ViewNode } from "./protocol.js";
+/** Framework adapters own their context tree; the renderer owns server DOM and lifetimes. */
+export type ClientConnection = {
+    readonly family: object;
+    element(props: Values, children: unknown): unknown;
+    portal(host: HTMLElement, element: unknown, key: string): unknown;
+    slot(host: HTMLElement, children: readonly unknown[]): unknown;
+    group(key: string, children: readonly unknown[]): unknown;
+};
+export type ClientOperation = {
+    readonly signal: AbortSignal;
+    readonly children?: unknown;
+    readonly scope?: string;
+};
+export type ClientResult<A> = A | Promise<A> | Effect.Effect<A, unknown>;
+export type PersistentClient = {
+    update(props: Values, operation?: ClientOperation): ClientResult<void>;
+    dispose(): ClientResult<void>;
+};
+export type PersistentClientModule = {
+    readonly connected?: ClientConnection;
+    mountPersistent(host: HTMLElement, props: Values, operation?: ClientOperation): ClientResult<PersistentClient>;
+};
+export type ClientRegistry = Readonly<Record<string, () => Promise<PersistentClientModule>>>;
+export type ResumableEvent = {
+    readonly type: string;
+    readonly value?: string;
+    readonly checked?: boolean;
+    readonly key?: string;
+};
+export type HandlerContext = {
+    readonly event: ResumableEvent;
+    readonly element: HTMLElement;
+    readonly capture: Values;
+    readonly props: Values;
+    readonly signal: AbortSignal;
+    readonly get: (name: string) => Json;
+    readonly set: (name: string, value: Json) => void;
+};
+export type ResumableHandler = (context: HandlerContext) => ClientResult<void>;
+export type HandlerRegistry = Readonly<Record<string, () => Promise<ResumableHandler>>>;
+/** Opt-in renderer. Template DOM and instance lifetimes outlive individual server requests. */
+export declare function createViewRenderer(outlet: HTMLElement, options: {
+    readonly manifest: ViewManifest;
+    readonly clients?: ClientRegistry;
+    readonly handlers?: HandlerRegistry;
+    readonly limits?: ViewLimits;
+    readonly onError?: (error: unknown) => void;
+    /** Bound imports, mounts, updates and cleanup; default 10 seconds. */
+    readonly clientTimeoutMs?: number;
+}): {
+    render: (payload: unknown) => Promise<boolean>;
+    prepare: (payload: unknown, signal?: AbortSignal) => Promise<(() => Promise<boolean>) | (() => Promise<boolean>)>;
+    sequence: (payload: unknown, signal?: AbortSignal) => Promise<{
+        commit: () => Promise<boolean>;
+        push: (payload: unknown) => Promise<boolean>;
+    } | {
+        commit: () => Promise<boolean>;
+        push: () => Promise<boolean>;
+    }>;
+    followDocument: (push: (payload: unknown) => Promise<boolean>, signal?: AbortSignal) => () => void;
+    clear: () => Promise<void>;
+    /** Adopt the matching SSR tree; native state restores without calling component setup. */
+    resume: () => Promise<boolean>;
+    refresh: (href: string, options?: {
+        readonly base?: string;
+        readonly fetch?: typeof fetch;
+        readonly signal?: AbortSignal;
+    }) => Promise<boolean>;
+    whenIdle: () => Promise<void>;
+    dispose: () => Promise<void>;
+};
+//# sourceMappingURL=browser.d.ts.map

package/dist/server-components/browser.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"browser.d.ts","sourceRoot":"","sources":["../../src/server-components/browser.ts"],"names":[],"mappings":"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"}

package/dist/server-components/browser.js

@@ -0,0 +1,558 @@
+import * as Effect from "effect/Effect";
+import * as Semaphore from "effect/Semaphore";
+import { readViewStream, validateFrame } from "./stream.js";
+import * as Atom from "effect/reactivity/Atom";
+import * as AtomRegistry from "effect/reactivity/AtomRegistry";
+import { scalar, validateSnapshot } from "./protocol.js";
+import { normalizeBase } from "../route-path.js";
+/** Adapt only an external call; all renderer coordination stays in Effect. */
+const external = (call) => Effect.suspend(() => {
+    const controller = new AbortController();
+    return Effect.try({ try: () => call(controller.signal), catch: error => error }).pipe(Effect.flatMap(result => Effect.isEffect(result) ? result : Effect.tryPromise({ try: () => Promise.resolve(result), catch: error => error })), Effect.ensuring(Effect.sync(() => controller.abort())));
+});
+/** Opt-in renderer. Template DOM and instance lifetimes outlive individual server requests. */
+export function createViewRenderer(outlet, options) {
+    const document = outlet.ownerDocument;
+    const clients = options.clients ?? {};
+    const handlers = options.handlers ?? {};
+    const clientIds = new Set(Object.keys(clients));
+    const handlerIds = new Set(Object.keys(handlers));
+    const parsed = new Map();
+    const modules = new Map();
+    const preparationErrors = new Map();
+    const loadedHandlers = new Map();
+    const owned = new WeakMap();
+    let roots = [];
+    let scope;
+    let operationScope;
+    let disposed = false;
+    let generation = 0;
+    const commitLock = Semaphore.makeUnsafe(1);
+    const timeout = options.clientTimeoutMs ?? 10000;
+    if (!Number.isSafeInteger(timeout) || timeout < 1 || timeout > 120000)
+        throw new Error("Client timeout must be between 1 and 120000 milliseconds");
+    let activeOperation;
+    const bounded = (call) => external(call).pipe(Effect.timeout(timeout));
+    const run = (effect, signal) => Effect.runPromise(effect, signal ? { signal } : undefined);
+    let stopDocument;
+    let activeFetch;
+    let disposal;
+    const errors = options.onError ?? console.error;
+    const isInput = (element) => element.tagName === "INPUT" || element.tagName === "TEXTAREA";
+    const write = (element, value) => {
+        const text = scalar(value);
+        if (isInput(element)) {
+            const input = element;
+            if (input.value !== text)
+                input.value = text;
+        }
+        else if (element.textContent !== text)
+            element.textContent = text;
+    };
+    const apply = (instance) => {
+        const node = instance.node;
+        if (node.kind !== "fragment")
+            return;
+        for (const binding of options.manifest.templates[node.template].bindings) {
+            if (binding.kind === "slot")
+                continue;
+            const value = (binding.kind === "state" || binding.kind === "checked") ? instance.registry.get(instance.cells.get(binding.name)) : node.values[binding.name];
+            for (const element of instance.bindings.get(`${binding.kind}:${binding.name}`) ?? []) {
+                if (binding.kind === "checked")
+                    element.checked = value === true;
+                else
+                    write(element, value);
+            }
+        }
+    };
+    const cells = (instance, node) => {
+        for (const binding of options.manifest.templates[node.template].bindings)
+            if ((binding.kind === "state" || binding.kind === "checked") && !instance.cells.has(binding.name)) {
+                const atom = Atom.make(node.state[binding.name] ?? null).pipe(Atom.keepAlive);
+                instance.cells.set(binding.name, atom);
+            }
+    };
+    const nodeSignature = (node) => node.kind === "fragment" ? `fragment:${node.template}` : node.kind === "client" ? `client:${node.component}` : "boundary";
+    const directHosts = (parent) => Array.from(parent.children).filter(element => element.hasAttribute("data-fuzor-key"));
+    const marker = (instance, name) => {
+        const slot = instance.bindings.get(`slot:${name}`)?.[0];
+        if (!slot)
+            throw new Error(`Compiled slot is missing: ${name}`);
+        return slot;
+    };
+    const sameHost = (host, node) => host.getAttribute("data-fuzor-key") === node.key &&
+        (node.kind === "fragment" ? host.localName === "fuzor-fragment" && host.getAttribute("data-fuzor-template") === node.template : node.kind === "boundary" ? host.localName === "fuzor-boundary" : host.localName === "fuzor-client" && host.getAttribute("data-fuzor-component") === node.component);
+    const create = Effect.fnUntraced(function* (node, host) {
+        const adopt = !!host;
+        host ??= document.createElement(node.kind === "fragment" ? "fuzor-fragment" : node.kind === "boundary" ? "fuzor-boundary" : "fuzor-client");
+        host.setAttribute("data-fuzor-key", node.key);
+        if (node.kind !== "boundary")
+            host.setAttribute(node.kind === "fragment" ? "data-fuzor-template" : "data-fuzor-component", node.kind === "fragment" ? node.template : node.component);
+        const instance = { node, host, lifetime: new AbortController(), children: new Map(), registry: AtomRegistry.make(), cells: new Map(), bindings: new Map(), eventLock: Semaphore.makeUnsafe(1), dispose: () => Promise.resolve() };
+        let released = false;
+        let disposal;
+        instance.dispose = () => disposal ??= run(Effect.gen(function* () {
+            if (released)
+                return;
+            released = true;
+            instance.failed = true;
+            instance.lifetime.abort();
+            owned.delete(instance.host);
+            const cleanup = Effect.forEach([...instance.children.values()].flat(), child => external(() => child.dispose()), { concurrency: 8, discard: true });
+            yield* cleanup.pipe(Effect.ensuring(bounded(() => instance.client?.dispose()).pipe(Effect.catchCause(cause => Effect.sync(() => errors(cause))), Effect.ensuring(Effect.sync(() => { instance.registry.dispose(); instance.host.remove(); })))));
+        }));
+        owned.set(host, instance);
+        let complete = false;
+        yield* Effect.addFinalizer(() => complete ? Effect.void : external(() => instance.dispose()).pipe(Effect.catchCause(cause => Effect.sync(() => errors(cause)))));
+        try {
+            if (node.kind === "fragment") {
+                if (!adopt) {
+                    let template = parsed.get(node.template);
+                    if (!template) {
+                        template = document.createElement("template");
+                        template.innerHTML = options.manifest.templates[node.template].html;
+                        parsed.set(node.template, template);
+                    }
+                    host.append(document.importNode(template.content, true));
+                }
+                // Exclude descendants owned by server-produced child fragments/client roots.
+                for (const element of host.querySelectorAll("[data-fuzor-text],[data-fuzor-state],[data-fuzor-checked],[data-fuzor-slot]")) {
+                    if (element.closest("fuzor-fragment,fuzor-client,fuzor-boundary") !== host)
+                        continue;
+                    for (const kind of ["text", "state", "checked", "slot"]) {
+                        const name = element.getAttribute(`data-fuzor-${kind}`);
+                        if (name !== null) {
+                            const key = `${kind}:${name}`;
+                            const values = instance.bindings.get(key) ?? [];
+                            values.push(element);
+                            instance.bindings.set(key, values);
+                        }
+                    }
+                }
+                cells(instance, node);
+                // An input edited before resume is already user state; adopt it without setup replay.
+                if (adopt)
+                    for (const binding of options.manifest.templates[node.template].bindings)
+                        if (binding.kind === "state" || binding.kind === "checked") {
+                            const input = instance.bindings.get(`${binding.kind}:${binding.name}`)?.find(isInput);
+                            if (input && binding.kind === "checked" && input.checked !== input.defaultChecked)
+                                instance.registry.set(instance.cells.get(binding.name), input.checked);
+                            else if (input && binding.kind === "state" && input.value !== input.defaultValue)
+                                instance.registry.set(instance.cells.get(binding.name), input.value);
+                        }
+                apply(instance);
+            }
+            complete = true;
+            return instance;
+        }
+        catch (error) {
+            yield* external(() => instance.dispose());
+            throw error;
+        }
+    }, Effect.scoped);
+    const reconcile = Effect.fnUntraced(function* (parent, previous, nodes, version, adopt, connection) {
+        const byKey = new Map(previous.map(instance => [instance.node.key, instance]));
+        const adoptable = adopt ? directHosts(parent) : [];
+        const next = [];
+        const created = [];
+        let complete = false;
+        yield* Effect.addFinalizer(() => complete ? Effect.void : Effect.forEach(created, instance => external(() => instance.dispose()).pipe(Effect.catchCause(cause => Effect.sync(() => errors(cause)))), { concurrency: 8, discard: true }));
+        try {
+            for (const node of nodes) {
+                if (disposed || version !== generation)
+                    return yield* Effect.fail(new Error("View commit superseded"));
+                let instance = byKey.get(node.key);
+                const retainBoundary = node.kind === "boundary" && node.status !== "resolved" && instance?.boundaryResolved === true;
+                if (instance && (instance.failed || nodeSignature(instance.node) !== nodeSignature(node))) {
+                    yield* external(() => instance.dispose());
+                    byKey.delete(node.key);
+                    instance = undefined;
+                }
+                if (!instance) {
+                    instance = yield* create(node, adoptable.find(host => sameHost(host, node)));
+                    created.push(instance);
+                }
+                else {
+                    byKey.delete(node.key);
+                    instance.node = node;
+                    if (node.kind === "fragment") {
+                        cells(instance, node);
+                        apply(instance);
+                    }
+                }
+                next.push(instance);
+                // New instances are tracked for cleanup if nested reconciliation fails.
+                if (node.kind === "client") {
+                    const target = instance;
+                    const preparationError = preparationErrors.get(`${version}:${node.component}`);
+                    if (preparationError)
+                        return yield* Effect.fail(preparationError);
+                    const module = yield* bounded(() => modules.get(node.component));
+                    const bridge = module.connected;
+                    if (connection && (!bridge || connection.family !== bridge.family))
+                        return yield* Effect.fail(new Error("Connected client children must use the same framework runtime"));
+                    let children;
+                    if (node.children?.length || instance.childrenHost) {
+                        if (!bridge)
+                            return yield* Effect.fail(new Error("Client children require a connected framework adapter"));
+                        instance.childrenHost ??= Array.from(instance.host.children).find(child => child.localName === "fuzor-client-children") ?? document.createElement("fuzor-client-children");
+                        const descendants = yield* reconcile(instance.childrenHost, instance.children.get("client") ?? [], node.children ?? [], version, adopt, bridge);
+                        instance.children.set("client", descendants);
+                        children = bridge.slot(instance.childrenHost, descendants.map(child => child.presentation));
+                    }
+                    if (connection)
+                        instance.presentation = connection.portal(instance.host, bridge.element(node.props, children), node.key);
+                    else if (instance.client) {
+                        yield* bounded(signal => target.client.update(node.props, { signal, children, ...(operationScope ? { scope: operationScope } : {}) })).pipe(Effect.onExit(exit => Effect.sync(() => { if (exit._tag === "Failure")
+                            target.failed = true; })));
+                    }
+                    else {
+                        instance.client = yield* bounded(signal => {
+                            const result = module.mountPersistent(target.host, node.props, { signal, children, ...(operationScope ? { scope: operationScope } : {}) });
+                            if (Effect.isEffect(result))
+                                return result;
+                            if (result && typeof result.then === "function")
+                                return result.then(client => {
+                                    if (signal.aborted)
+                                        void run(bounded(() => client.dispose())).catch(errors);
+                                    return client;
+                                });
+                            return result;
+                        });
+                    }
+                }
+                else if (node.kind === "boundary") {
+                    instance.host.setAttribute("data-fuzor-status", node.status);
+                    if (node.status === "resolved")
+                        instance.boundaryResolved = true;
+                    if (!retainBoundary) {
+                        const boundary = instance;
+                        const descendants = yield* reconcile(instance.host, instance.children.get("content") ?? [], node.children, version, adopt, connection).pipe(Effect.catchCause(cause => Effect.gen(function* () {
+                            if (disposed || version !== generation)
+                                return yield* Effect.failCause(cause);
+                            errors(cause);
+                            // External adapter side effects cannot be rolled back. Release this
+                            // boundary's children and show a local fallback; keep siblings alive.
+                            yield* Effect.forEach(boundary.children.get("content") ?? [], child => external(() => child.dispose()).pipe(Effect.catchCause(error => Effect.sync(() => errors(error)))), { discard: true });
+                            boundary.boundaryResolved = false;
+                            boundary.host.setAttribute("data-fuzor-status", "error");
+                            const fallback = document.createElement("p");
+                            fallback.setAttribute("role", "status");
+                            fallback.textContent = "This section could not be loaded.";
+                            boundary.host.replaceChildren(fallback);
+                            return [];
+                        })));
+                        instance.children.set("content", descendants);
+                    }
+                }
+                else if (node.kind === "fragment") {
+                    for (const binding of options.manifest.templates[node.template].bindings)
+                        if (binding.kind === "slot") {
+                            const slot = marker(instance, binding.name);
+                            const children = yield* reconcile(slot, instance.children.get(binding.name) ?? [], node.slots[binding.name] ?? [], version, adopt, connection);
+                            instance.children.set(binding.name, children);
+                        }
+                }
+            }
+            if (connection)
+                for (const instance of next)
+                    if (instance.node.kind !== "client")
+                        instance.presentation = connection.group(instance.node.key, [...instance.children.values()].flat().map(child => child.presentation));
+            for (const instance of byKey.values())
+                yield* external(() => instance.dispose());
+            let cursor = parent.firstChild;
+            for (const instance of next) {
+                if (instance.host !== cursor)
+                    parent.insertBefore(instance.host, cursor);
+                cursor = instance.host.nextSibling;
+            }
+            // Initial adoption removes fallback/unmatched nodes, without replacing retained hosts.
+            const kept = new Set(next.map(instance => instance.host));
+            for (const child of Array.from(parent.childNodes))
+                if (!kept.has(child))
+                    child.remove();
+            complete = true;
+            return next;
+        }
+        catch (error) {
+            for (const instance of created)
+                yield* external(() => instance.dispose());
+            throw error;
+        }
+    }, Effect.scoped);
+    const prepare = Effect.fnUntraced(function* (snapshot, version) {
+        const required = new Map();
+        const visit = (nodes, recoverable = false) => {
+            for (const node of nodes)
+                if (node.kind === "client") {
+                    required.set(node.component, (required.get(node.component) ?? true) && recoverable);
+                    visit(node.children ?? [], recoverable);
+                }
+                else if (node.kind === "boundary")
+                    visit(node.children, true);
+                else
+                    Object.values(node.slots).forEach(children => visit(children, recoverable));
+        };
+        visit(snapshot.tree);
+        yield* Effect.forEach(required, ([id, recoverable]) => {
+            const failed = preparationErrors.get(`${version}:${id}`);
+            if (failed)
+                return recoverable ? Effect.void : Effect.fail(failed);
+            return bounded(() => {
+                if (!modules.has(id)) {
+                    const load = clients[id]();
+                    modules.set(id, load);
+                    void load.catch(() => { if (modules.get(id) === load)
+                        modules.delete(id); });
+                }
+                return modules.get(id);
+            }).pipe(Effect.flatMap(module => typeof module.mountPersistent === "function" ? Effect.void : Effect.fail(new Error("Client component needs a persistent mount contract"))), Effect.catch(error => Effect.sync(() => { modules.delete(id); if (version === generation)
+                preparationErrors.set(`${version}:${id}`, error); }).pipe(Effect.andThen(recoverable ? Effect.void : Effect.fail(error)))));
+        }, { concurrency: 8, discard: true });
+    });
+    const commit = Effect.fnUntraced(function* (snapshot, version) {
+        if (disposed || version !== generation)
+            return false;
+        const active = document.activeElement;
+        const selection = active && isInput(active) ? [active.selectionStart, active.selectionEnd, active.selectionDirection] : undefined;
+        if (scope !== undefined && scope !== snapshot.scope) {
+            for (const root of roots)
+                yield* external(() => root.dispose());
+            roots = [];
+        }
+        const adopt = scope === undefined;
+        operationScope = snapshot.scope;
+        const next = yield* reconcile(outlet, roots, snapshot.tree, version, adopt);
+        roots = next;
+        scope = snapshot.scope;
+        if (active?.isConnected && document.activeElement !== active) {
+            active.focus({ preventScroll: true });
+            if (selection && selection[0] !== null && selection[1] !== null)
+                try {
+                    active.setSelectionRange(selection[0], selection[1], selection[2] ?? undefined);
+                }
+                catch (error) {
+                    errors(error);
+                }
+        }
+        outlet.dispatchEvent(new document.defaultView.CustomEvent("fuzor:view-commit"));
+        return true;
+    });
+    /** One Effect-owned generation owns every frame, including an in-flight commit. */
+    const sequence = (payload, signal) => {
+        if (disposed)
+            return Promise.reject(new Error("View renderer disposed"));
+        activeOperation?.abort();
+        const controller = new AbortController();
+        activeOperation = controller;
+        const version = ++generation;
+        preparationErrors.clear();
+        const operationSignal = signal ? AbortSignal.any([signal, controller.signal]) : controller.signal;
+        const schedule = (payload) => run(Effect.gen(function* () {
+            if (version !== generation || disposed || operationSignal.aborted)
+                return false;
+            const snapshot = yield* Effect.try({ try: () => validateSnapshot(payload, options.manifest, clientIds, handlerIds, options.limits), catch: error => error });
+            yield* prepare(snapshot, version);
+            return yield* commitLock.withPermit(commit(snapshot, version));
+        }), operationSignal).catch(error => { if (operationSignal.aborted)
+            return false; throw error; });
+        return run(Effect.gen(function* () {
+            const snapshot = yield* Effect.try({ try: () => validateSnapshot(payload, options.manifest, clientIds, handlerIds, options.limits), catch: error => error });
+            yield* prepare(snapshot, version);
+            return { commit: () => schedule(snapshot), push: schedule };
+        }), operationSignal).catch(error => {
+            if (operationSignal.aborted)
+                return { commit: () => Promise.resolve(false), push: () => Promise.resolve(false) };
+            throw error;
+        });
+    };
+    const prepareRender = (payload, signal) => sequence(payload, signal).then(pending => pending.commit);
+    const render = (payload) => prepareRender(payload).then(commit => commit());
+    const followDocument = (push, signal) => {
+        stopDocument?.();
+        let next = 1, bytes = 0, stopped = false;
+        const frameLock = Semaphore.makeUnsafe(1);
+        const stop = () => { stopped = true; observer.disconnect(); signal?.removeEventListener("abort", stop); };
+        const scan = () => {
+            for (const script of document.querySelectorAll("script[data-fuzor-stream]")) {
+                const end = script.nextElementSibling;
+                // The parser may have inserted the start tag before the full JSON arrives.
+                if (!end?.hasAttribute("data-fuzor-frame-end"))
+                    continue;
+                const text = script.textContent ?? "";
+                script.remove();
+                end.remove();
+                void run(frameLock.withPermit(Effect.gen(function* () {
+                    if (stopped || signal?.aborted)
+                        return;
+                    bytes += new TextEncoder().encode(text).byteLength;
+                    if (bytes > 16 * 1024 * 1024 || next > 65)
+                        throw new Error("Document view stream limit exceeded");
+                    const frame = validateFrame(JSON.parse(text), next++);
+                    if (frame.type === "done") {
+                        stop();
+                        return;
+                    }
+                    if (!(yield* external(() => push(frame.snapshot))))
+                        stop();
+                }))).catch(error => { stop(); errors(error); });
+            }
+        };
+        const observer = new document.defaultView.MutationObserver(scan);
+        observer.observe(document.documentElement, { childList: true, subtree: true });
+        signal?.addEventListener("abort", stop, { once: true });
+        stopDocument = stop;
+        scan();
+        return stop;
+    };
+    const clear = () => {
+        generation++;
+        activeOperation?.abort();
+        activeFetch?.abort();
+        stopDocument?.();
+        return run(commitLock.withPermit(Effect.gen(function* () {
+            const previous = roots;
+            roots = [];
+            scope = undefined;
+            yield* Effect.forEach(previous, root => external(() => root.dispose()), { concurrency: 8, discard: true });
+        })));
+    };
+    const eventListener = (event) => {
+        let target = event.target;
+        if (target?.nodeType !== 1)
+            target = target?.parentElement ?? null;
+        const element = target?.closest(`[data-fuzor-on-${event.type}]`);
+        if (!element || !outlet.contains(element))
+            return;
+        const host = element.closest("fuzor-fragment,fuzor-client,fuzor-boundary");
+        const instance = host && owned.get(host);
+        if (!instance || instance.node.kind !== "fragment")
+            return;
+        const name = element.getAttribute(`data-fuzor-on-${event.type}`);
+        const reference = instance.node.handlers[name];
+        if (!reference)
+            return;
+        if (reference.preventDefault)
+            event.preventDefault();
+        const current = target;
+        const snapshot = { type: event.type, ...(current && "value" in current ? { value: current.value, checked: current.checked } : {}), ...("key" in event ? { key: String(event.key) } : {}) };
+        const props = instance.node.values;
+        // Queue by instance, so several clicks during a lazy import keep their order.
+        void run(instance.eventLock.withPermit(Effect.gen(function* () {
+            if (instance.lifetime.signal.aborted)
+                return;
+            if (!loadedHandlers.has(reference.id)) {
+                const load = handlers[reference.id]();
+                loadedHandlers.set(reference.id, load);
+                void load.catch(() => { loadedHandlers.delete(reference.id); });
+            }
+            const handler = yield* bounded(() => loadedHandlers.get(reference.id)).pipe(Effect.catch(error => Effect.sync(() => loadedHandlers.delete(reference.id)).pipe(Effect.andThen(Effect.fail(error)))));
+            if (instance.lifetime.signal.aborted)
+                return;
+            yield* bounded(() => handler({ event: snapshot, element, props, capture: reference.capture ?? {}, signal: instance.lifetime.signal,
+                get: name => { const cell = instance.cells.get(name); if (!cell)
+                    throw new Error(`Unknown state cell: ${name}`); return instance.registry.get(cell); },
+                set: (name, value) => {
+                    if (instance.lifetime.signal.aborted)
+                        return;
+                    const cell = instance.cells.get(name);
+                    if (!cell)
+                        throw new Error(`Unknown state cell: ${name}`);
+                    const binding = instance.node.kind === "fragment" ? options.manifest.templates[instance.node.template].bindings.find(binding => binding.name === name && binding.kind === "checked") : undefined;
+                    if (binding && typeof value !== "boolean")
+                        throw new Error("Checkbox state requires a boolean");
+                    scalar(value);
+                    instance.registry.set(cell, value);
+                    apply(instance);
+                } }));
+        })), instance.lifetime.signal).catch(error => { if (!instance.lifetime.signal.aborted)
+            errors(error); });
+    };
+    const eventTypes = ["click", "input", "change", "submit", "keydown"];
+    eventTypes.forEach(type => outlet.addEventListener(type, eventListener));
+    return {
+        render,
+        prepare: prepareRender,
+        sequence,
+        followDocument,
+        clear,
+        /** Adopt the matching SSR tree; native state restores without calling component setup. */
+        resume: () => run(Effect.gen(function* () {
+            const script = document.querySelector("script[data-fuzor-snapshot]");
+            if (!script)
+                return yield* Effect.fail(new Error("Missing server component snapshot"));
+            const pending = yield* external(() => sequence(JSON.parse(script.textContent ?? "")));
+            const result = yield* external(() => pending.commit());
+            if (result && script.hasAttribute("data-fuzor-streaming"))
+                followDocument(pending.push);
+            return result;
+        })),
+        refresh: (href, options = {}) => {
+            activeFetch?.abort();
+            const controller = new AbortController();
+            activeFetch = controller;
+            const abort = () => controller.abort();
+            options.signal?.addEventListener("abort", abort, { once: true });
+            if (options.signal?.aborted)
+                controller.abort();
+            // Supersede pending preparation immediately, not only after the new response arrives.
+            activeOperation?.abort();
+            const version = ++generation;
+            return run(Effect.gen(function* () {
+                const target = new URL(href, document.baseURI);
+                if (target.origin !== new URL(document.baseURI).origin)
+                    throw new Error("Server view URL must be same-origin");
+                const url = `${normalizeBase(options.base)}_fuzor/render?url=${encodeURIComponent(target.pathname + target.search)}`;
+                const response = yield* external(() => (options.fetch ?? globalThis.fetch)(url, { signal: controller.signal, credentials: "same-origin", headers: { accept: "application/vnd.fuzor.view-stream+json" } }));
+                if (!response.ok)
+                    throw new Error(`Server view request failed: ${response.status}`);
+                if (response.headers.get("content-type")?.includes("application/vnd.fuzor.view-stream+json")) {
+                    let pending;
+                    let committed = true;
+                    const stream = readViewStream(response, controller.signal);
+                    yield* Effect.gen(function* () {
+                        while (committed) {
+                            const part = yield* external(() => stream.next());
+                            if (part.done)
+                                break;
+                            const snapshot = part.value;
+                            if (!pending) {
+                                if (disposed || version !== generation) {
+                                    committed = false;
+                                    break;
+                                }
+                                pending = yield* external(() => sequence(snapshot, controller.signal));
+                                committed = yield* external(() => pending.commit());
+                            }
+                            else
+                                committed = yield* external(() => pending.push(snapshot));
+                        }
+                    }).pipe(Effect.ensuring(external(() => stream.return()).pipe(Effect.catch(error => Effect.sync(() => errors(error))))));
+                    return !!pending && committed;
+                }
+                const payload = yield* external(() => response.json());
+                if (disposed || controller.signal.aborted || version !== generation)
+                    return false;
+                return yield* external(() => render(payload));
+            }).pipe(Effect.ensuring(Effect.sync(() => { options.signal?.removeEventListener("abort", abort); if (activeFetch === controller)
+                activeFetch = undefined; }))), controller.signal);
+        },
+        whenIdle: () => run(Effect.gen(function* () {
+            yield* commitLock.withPermit(Effect.void);
+            const wait = (list) => Effect.forEach(list, instance => instance.eventLock.withPermit(Effect.void).pipe(Effect.flatMap(() => wait([...instance.children.values()].flat()))), { concurrency: 8, discard: true });
+            yield* wait(roots);
+        })),
+        dispose: () => {
+            if (disposal)
+                return disposal;
+            disposed = true;
+            generation++;
+            activeOperation?.abort();
+            activeFetch?.abort();
+            stopDocument?.();
+            eventTypes.forEach(type => outlet.removeEventListener(type, eventListener));
+            return disposal = clear();
+        },
+    };
+}
+//# sourceMappingURL=browser.js.map