foldkit 0.157.0 → 0.158.0

package/dist/runtime/documentMetadata.js

@@ -0,0 +1,148 @@
+import { Array } from 'effect';
+import { textDirectionToAttribute } from '../html/index.js';
+const currentLocationUrl = () => {
+    const { origin, pathname, search } = window.location;
+    return `${origin}${pathname}${search}`;
+};
+const documentMetadataStates = new WeakMap();
+const observeDocumentMetadataMutations = (observer) => {
+    const observedHead = document.head;
+    observer.observe(observedHead, {
+        attributes: true,
+        attributeFilter: ['rel', 'href', 'property', 'content'],
+        childList: true,
+        characterData: true,
+        subtree: true,
+    });
+    observer.observe(document.documentElement, {
+        attributes: true,
+        attributeFilter: ['lang', 'dir'],
+    });
+    return observedHead;
+};
+const getOrCreateDocumentMetadataState = () => {
+    const existingState = documentMetadataStates.get(document);
+    if (existingState !== undefined) {
+        return existingState;
+    }
+    const invalidation = { isInvalidated: true };
+    const observer = new MutationObserver(() => {
+        invalidation.isInvalidated = true;
+    });
+    const metadataState = {
+        elements: {},
+        observer,
+        invalidation,
+        observedHead: observeDocumentMetadataMutations(observer),
+    };
+    documentMetadataStates.set(document, metadataState);
+    return metadataState;
+};
+const findOrCreateDocumentMetadataElements = (metadataState) => {
+    const { elements } = metadataState;
+    let canonical = elements.canonical;
+    if (canonical === undefined || canonical.parentNode !== document.head) {
+        canonical =
+            document.head.querySelector('link[rel="canonical"]') ??
+                document.head.appendChild(document.createElement('link'));
+        elements.canonical = canonical;
+    }
+    let ogUrl = elements.ogUrl;
+    if (ogUrl === undefined || ogUrl.parentNode !== document.head) {
+        ogUrl =
+            document.head.querySelector('meta[property="og:url"]') ??
+                document.head.appendChild(document.createElement('meta'));
+        elements.ogUrl = ogUrl;
+    }
+    return { canonical, ogUrl };
+};
+const readOrCacheCurrentLocationUrl = (metadataState) => {
+    const currentLocationHref = window.location.href;
+    if (metadataState.cachedLocationHref === currentLocationHref &&
+        metadataState.cachedLocationCanonical !== undefined) {
+        return metadataState.cachedLocationCanonical;
+    }
+    const canonicalUrl = currentLocationUrl();
+    metadataState.cachedLocationHref = currentLocationHref;
+    metadataState.cachedLocationCanonical = canonicalUrl;
+    return canonicalUrl;
+};
+const rebindDocumentMetadataObserverToCurrentHead = (metadataState) => {
+    // NOTE: a MutationObserver remains attached to a detached head after
+    // document.head is replaced. Rebind it and invalidate the metadata snapshot
+    // before the next unchanged guard.
+    metadataState.observer.disconnect();
+    metadataState.observedHead = observeDocumentMetadataMutations(metadataState.observer);
+    metadataState.invalidation.isInvalidated = true;
+};
+const reconcileDocumentMetadata = (metadataState, nextMetadata) => {
+    if (document.title !== nextMetadata.title) {
+        document.title = nextMetadata.title;
+    }
+    const { documentElement } = document;
+    if (nextMetadata.lang !== undefined &&
+        documentElement.lang !== nextMetadata.lang) {
+        documentElement.lang = nextMetadata.lang;
+    }
+    if (nextMetadata.dirAttribute !== undefined &&
+        documentElement.dir !== nextMetadata.dirAttribute) {
+        documentElement.dir = nextMetadata.dirAttribute;
+    }
+    const metadataElements = findOrCreateDocumentMetadataElements(metadataState);
+    if (metadataElements.canonical.getAttribute('rel') !== 'canonical') {
+        metadataElements.canonical.setAttribute('rel', 'canonical');
+    }
+    if (metadataElements.canonical.getAttribute('href') !==
+        nextMetadata.canonicalUrl) {
+        metadataElements.canonical.setAttribute('href', nextMetadata.canonicalUrl);
+    }
+    if (metadataElements.ogUrl.getAttribute('property') !== 'og:url') {
+        metadataElements.ogUrl.setAttribute('property', 'og:url');
+    }
+    if (metadataElements.ogUrl.getAttribute('content') !== nextMetadata.ogUrl) {
+        metadataElements.ogUrl.setAttribute('content', nextMetadata.ogUrl);
+    }
+    metadataState.lastApplied = nextMetadata;
+    metadataState.invalidation.isInvalidated = false;
+    // NOTE: clear the records produced by Foldkit's own writes before the
+    // observer callback runs. Otherwise the next unchanged render would be
+    // marked dirty and repeat every DOM read this cache is meant to avoid.
+    metadataState.observer.takeRecords();
+};
+export const applyDocumentMetadata = (nextDocument, mountedRoot) => {
+    if (!mountedRoot || !document.body.contains(mountedRoot)) {
+        return;
+    }
+    const metadataState = getOrCreateDocumentMetadataState();
+    if (metadataState.observedHead !== document.head) {
+        rebindDocumentMetadataObserverToCurrentHead(metadataState);
+    }
+    const canonicalUrl = nextDocument.canonical ?? readOrCacheCurrentLocationUrl(metadataState);
+    const ogUrl = nextDocument.ogUrl ?? canonicalUrl;
+    const dirAttribute = nextDocument.dir === undefined
+        ? undefined
+        : textDirectionToAttribute(nextDocument.dir);
+    // NOTE: MutationObserver callbacks are asynchronous. Consume queued records
+    // synchronously before trusting the unchanged fast path.
+    if (Array.isArrayNonEmpty(metadataState.observer.takeRecords())) {
+        metadataState.invalidation.isInvalidated = true;
+    }
+    const lastApplied = metadataState.lastApplied;
+    const isAppliedMetadataCurrent = !metadataState.invalidation.isInvalidated &&
+        lastApplied !== undefined &&
+        lastApplied.title === nextDocument.title &&
+        lastApplied.lang === nextDocument.lang &&
+        lastApplied.dirAttribute === dirAttribute &&
+        lastApplied.canonicalUrl === canonicalUrl &&
+        lastApplied.ogUrl === ogUrl;
+    if (isAppliedMetadataCurrent) {
+        return;
+    }
+    reconcileDocumentMetadata(metadataState, {
+        title: nextDocument.title,
+        lang: nextDocument.lang,
+        dirAttribute,
+        canonicalUrl,
+        ogUrl,
+    });
+};

package/dist/runtime/duplicateIdScanner.d.ts

@@ -0,0 +1,16 @@
+/** The coalescing scanner: `schedule` queues a scan of a root, `cancel` drops it. */
+export type DuplicateIdScanner = Readonly<{
+    schedule: (root: Node | undefined) => void;
+    cancel: () => void;
+}>;
+/** Coalesces `warnDuplicateIds` scans so rapid successive renders trigger at
+ *  most one full-tree scan per `DUPLICATE_ID_SCAN_INTERVAL_MS`, bounding the
+ *  cost under high-frequency dev rendering such as animationFrame subscriptions
+ *  or per-keystroke input. A real duplicate id persists across renders, so
+ *  scanning the latest tree on a trailing timer never misses a genuine
+ *  collision, and the retained `warnedIds` keeps each id to a single warning.
+ *  Dev-only: the runtime both creates the scanner and calls `schedule` behind
+ *  `import.meta.hot`, so the scanner and its DOM scan tree-shake out of
+ *  production builds. */
+export declare const createDuplicateIdScanner: () => DuplicateIdScanner;
+//# sourceMappingURL=duplicateIdScanner.d.ts.map

package/dist/runtime/duplicateIdScanner.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"duplicateIdScanner.d.ts","sourceRoot":"","sources":["../../src/runtime/duplicateIdScanner.ts"],"names":[],"mappings":"AAiDA,qFAAqF;AACrF,MAAM,MAAM,kBAAkB,GAAG,QAAQ,CAAC;IACxC,QAAQ,EAAE,CAAC,IAAI,EAAE,IAAI,GAAG,SAAS,KAAK,IAAI,CAAA;IAC1C,MAAM,EAAE,MAAM,IAAI,CAAA;CACnB,CAAC,CAAA;AAEF;;;;;;;;yBAQyB;AACzB,eAAO,MAAM,wBAAwB,QAAO,kBAyB3C,CAAA"}

package/dist/runtime/duplicateIdScanner.js

@@ -0,0 +1,70 @@
+import { Array } from 'effect';
+/** Dev-only scan for duplicate DOM ids within the Foldkit-rendered root.
+ *
+ *  Duplicate ids are invalid HTML but browsers do not report them, so
+ *  `getElementById` / `querySelector` silently resolve to the first match and
+ *  focus or ARIA labelling can target the wrong element with no error. The
+ *  scan is scoped to `root` (not the whole document) so unrelated page ids do
+ *  not trigger it, warns rather than throws, and dedupes through `warnedIds`
+ *  so the same collision is reported at most once instead of every render. */
+const warnDuplicateIds = (root, warnedIds) => {
+    if (!(root instanceof Element)) {
+        return;
+    }
+    const seenIds = new Set();
+    const duplicateIds = new Set();
+    const elementsWithId = Array.fromIterable(root.querySelectorAll('[id]'));
+    if (root.id !== '') {
+        elementsWithId.unshift(root);
+    }
+    for (const element of elementsWithId) {
+        const { id } = element;
+        if (seenIds.has(id)) {
+            duplicateIds.add(id);
+        }
+        else {
+            seenIds.add(id);
+        }
+    }
+    for (const id of duplicateIds) {
+        if (!warnedIds.has(id)) {
+            warnedIds.add(id);
+            console.warn(`[foldkit] Duplicate DOM id "${id}" in the rendered tree. Ids must be ` +
+                'unique within the document; otherwise focus and ARIA labelling can ' +
+                'silently target the wrong element. Give each element a unique id.');
+        }
+    }
+};
+const DUPLICATE_ID_SCAN_INTERVAL_MS = 1000;
+/** Coalesces `warnDuplicateIds` scans so rapid successive renders trigger at
+ *  most one full-tree scan per `DUPLICATE_ID_SCAN_INTERVAL_MS`, bounding the
+ *  cost under high-frequency dev rendering such as animationFrame subscriptions
+ *  or per-keystroke input. A real duplicate id persists across renders, so
+ *  scanning the latest tree on a trailing timer never misses a genuine
+ *  collision, and the retained `warnedIds` keeps each id to a single warning.
+ *  Dev-only: the runtime both creates the scanner and calls `schedule` behind
+ *  `import.meta.hot`, so the scanner and its DOM scan tree-shake out of
+ *  production builds. */
+export const createDuplicateIdScanner = () => {
+    const warnedIds = new Set();
+    let timeoutHandle;
+    let latestRoot;
+    const schedule = (root) => {
+        latestRoot = root;
+        if (timeoutHandle !== undefined) {
+            return;
+        }
+        timeoutHandle = setTimeout(() => {
+            timeoutHandle = undefined;
+            warnDuplicateIds(latestRoot, warnedIds);
+        }, DUPLICATE_ID_SCAN_INTERVAL_MS);
+    };
+    const cancel = () => {
+        if (timeoutHandle !== undefined) {
+            clearTimeout(timeoutHandle);
+            timeoutHandle = undefined;
+        }
+        latestRoot = undefined;
+    };
+    return { schedule, cancel };
+};

package/dist/runtime/hmrModelBridge.d.ts

@@ -0,0 +1,4 @@
+import { Effect } from 'effect';
+export declare const preserveModel: (id: string, encodedModel: unknown, isHmrReload: boolean) => void;
+export declare const resolveHmrModel: (runtimeId: string) => Effect.Effect<unknown>;
+//# sourceMappingURL=hmrModelBridge.d.ts.map

package/dist/runtime/hmrModelBridge.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"hmrModelBridge.d.ts","sourceRoot":"","sources":["../../src/runtime/hmrModelBridge.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAgC,MAAM,QAAQ,CAAA;AAa7D,eAAO,MAAM,aAAa,OACpB,MAAM,gBACI,OAAO,eACR,OAAO,KACnB,IASF,CAAA;AAQD,eAAO,MAAM,eAAe,cAAe,MAAM,KAAG,MAAM,CAAC,MAAM,CAAC,OAAO,CAqCxE,CAAA"}

package/dist/runtime/hmrModelBridge.js

@@ -0,0 +1,43 @@
+import { Effect, Exit, Function, Schema, pipe } from 'effect';
+import { PreserveModelMessage, RequestModelMessage, RestoreModelMessage, } from './hmrProtocol.js';
+const encodePreserveModelMessage = Schema.encodeUnknownSync(PreserveModelMessage);
+const encodeRequestModelMessage = Schema.encodeUnknownSync(RequestModelMessage);
+const decodeRestoreModelMessage = Schema.decodeUnknownExit(RestoreModelMessage);
+export const preserveModel = (id, encodedModel, isHmrReload) => {
+    if (import.meta.hot) {
+        import.meta.hot.send('foldkit:preserve-model', encodePreserveModelMessage(PreserveModelMessage.make({ id, model: encodedModel, isHmrReload })));
+    }
+};
+const PLUGIN_RESPONSE_TIMEOUT_MS = 500;
+// NOTE: asks @foldkit/vite-plugin for a model preserved across the last HMR
+// reload. The plugin only serves a model whose preservation was flushed by a
+// reload, so a host-driven dispose-then-embed remount initializes fresh while
+// a code reload restores state.
+export const resolveHmrModel = (runtimeId) => {
+    const hot = import.meta.hot;
+    if (!hot) {
+        return Effect.succeed(undefined);
+    }
+    return pipe(Effect.callback(resume => {
+        const handler = (message) => {
+            Exit.match(decodeRestoreModelMessage(message), {
+                onFailure: Function.constVoid,
+                onSuccess: ({ id, model }) => {
+                    if (id === runtimeId) {
+                        hot.off('foldkit:restore-model', handler);
+                        resume(Effect.succeed(model));
+                    }
+                },
+            });
+        };
+        hot.on('foldkit:restore-model', handler);
+        hot.send('foldkit:request-model', encodeRequestModelMessage(RequestModelMessage.make({ id: runtimeId })));
+        return Effect.sync(() => hot.off('foldkit:restore-model', handler));
+    }), Effect.timeout(PLUGIN_RESPONSE_TIMEOUT_MS), Effect.catchTag('TimeoutError', () => {
+        console.warn('[foldkit] No response from @foldkit/vite-plugin. Add it to your vite.config.ts for HMR model preservation:\n\n' +
+            "  import { foldkit } from '@foldkit/vite-plugin'\n\n" +
+            '  export default defineConfig({ plugins: [foldkit()] })\n\n' +
+            'Starting without HMR support.');
+        return Effect.succeed(undefined);
+    }));
+};

package/dist/runtime/hostConnector.d.ts

@@ -0,0 +1,61 @@
+import { Exit, Option, Schema } from 'effect';
+import { type Inbound, type Outbound, type Ports, type __PortChannels } from '../port/index.js';
+/** Host-side handle for one inbound Port. `send` validates the value by
+ *  decoding it against the Port's Schema: on success the decoded value enters
+ *  the app through the Port's Subscription; on failure nothing reaches the
+ *  app, the failure is logged, and the returned `Exit` carries the
+ *  `SchemaError`. Sends after `dispose` are no-ops. */
+export type InboundPortHandle<Encoded> = Readonly<{
+    send: (value: Encoded) => Exit.Exit<void, Schema.SchemaError>;
+}>;
+/** Host-side handle for one outbound Port. `subscribe` registers a listener
+ *  for the encoded values the app emits with `Port.emit` and returns an
+ *  unsubscribe function. Multiple listeners receive each value in
+ *  registration order. */
+export type OutboundPortHandle<Encoded> = Readonly<{
+    subscribe: (listener: (value: Encoded) => void) => () => void;
+}>;
+/** The inbound half of `PortHandles`: one `InboundPortHandle` per declared
+ *  inbound Port, keyed by Port name. */
+export type InboundPortHandles<InboundPorts> = InboundPorts extends Readonly<Record<string, Inbound<any, any>>> ? {
+    readonly [Name in keyof InboundPorts]: InboundPorts[Name] extends Inbound<any, infer Encoded> ? InboundPortHandle<Encoded> : never;
+} : unknown;
+/** The outbound half of `PortHandles`: one `OutboundPortHandle` per declared
+ *  outbound Port, keyed by Port name. */
+export type OutboundPortHandles<OutboundPorts> = OutboundPorts extends Readonly<Record<string, Outbound<any, any>>> ? {
+    readonly [Name in keyof OutboundPorts]: OutboundPorts[Name] extends Outbound<any, infer Encoded> ? OutboundPortHandle<Encoded> : never;
+} : unknown;
+/** The `ports` field of an `EmbedHandle`: one `InboundPortHandle` or
+ *  `OutboundPortHandle` per declared Port, keyed by Port name. */
+export type PortHandles<P extends Ports | undefined> = P extends Ports ? InboundPortHandles<P['inbound']> & OutboundPortHandles<P['outbound']> : unknown;
+/**
+ * The handle returned by `embed`. The host talks to the embedded app only
+ * through it: `ports.<name>.send` pushes values in, `ports.<name>.subscribe`
+ * listens to values the app emits, and `dispose` shuts the runtime down.
+ *
+ * `dispose` is idempotent. It interrupts the runtime and runs all cleanup:
+ * Subscriptions, ManagedResources, Mounts, listeners, and in-flight Commands
+ * stop, and the rendered DOM is removed with the container element restored
+ * empty in its place, ready for a fresh `embed`.
+ */
+export type EmbedHandle<P extends Ports | undefined = undefined> = Readonly<{
+    ports: PortHandles<P>;
+    dispose: () => void;
+}>;
+export type HostConnector = Readonly<{
+    sendInbound: (portName: string, port: Inbound<any, any>, value: unknown) => Exit.Exit<void, Schema.SchemaError>;
+    addListener: (port: Outbound<any, any>, listener: (encodedValue: unknown) => void) => () => void;
+    deliverOutbound: (port: Outbound<any, any>, encodedValue: unknown) => void;
+    bind: (deliverInbound: (port: Inbound<any, any>, value: unknown) => void) => void;
+    unbind: () => void;
+    dispose: () => void;
+}>;
+export declare const makeHostConnector: () => HostConnector;
+export type PortChannelsBundle = Readonly<{
+    channels: __PortChannels;
+    deliverInbound: (port: Inbound<any, any>, value: unknown) => void;
+}>;
+export declare const makePortChannels: (ports: Ports, maybeConnector: Option.Option<HostConnector>) => PortChannelsBundle;
+export declare const validatePorts: (ports: Ports) => void;
+export declare const buildPortHandles: <P extends Ports | undefined>(ports: P, connector: HostConnector) => PortHandles<P>;
+//# sourceMappingURL=hostConnector.d.ts.map

package/dist/runtime/hostConnector.d.ts.map

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

package/dist/runtime/hostConnector.js

@@ -0,0 +1,141 @@
+import { Cause, Exit, Function, Option, Predicate, Schema } from 'effect';
+import { __makeInboundChannel, } from '../port/index.js';
+export const makeHostConnector = () => {
+    let isDisposed = false;
+    let maybeDeliverInbound = Option.none();
+    const pendingInboundSends = [];
+    const listenersByPort = new Map();
+    const sendInbound = (portName, port, value) => {
+        if (isDisposed) {
+            return Exit.void;
+        }
+        const decodeExit = Schema.decodeUnknownExit(port.schema)(value);
+        Exit.match(decodeExit, {
+            onFailure: cause => {
+                console.error(`[foldkit] Inbound port "${portName}" rejected a value:`, Cause.squash(cause));
+            },
+            onSuccess: decodedValue => {
+                Option.match(maybeDeliverInbound, {
+                    onNone: () => {
+                        pendingInboundSends.push({ port, value: decodedValue });
+                    },
+                    onSome: deliverInbound => deliverInbound(port, decodedValue),
+                });
+            },
+        });
+        return Exit.asVoid(decodeExit);
+    };
+    const addListener = (port, listener) => {
+        if (isDisposed) {
+            return Function.constVoid;
+        }
+        const listeners = listenersByPort.get(port) ?? new Set();
+        listenersByPort.set(port, listeners);
+        listeners.add(listener);
+        return () => {
+            listeners.delete(listener);
+        };
+    };
+    // NOTE: delivery is deferred to a microtask so a host listener never runs
+    // inside the runtime's Command fiber (a listener that synchronously calls
+    // send or dispose must not re-enter the runtime), and so a host that
+    // subscribes synchronously right after embed() returns still receives
+    // emissions from init Commands.
+    const deliverOutbound = (port, encodedValue) => {
+        if (isDisposed) {
+            return;
+        }
+        queueMicrotask(() => {
+            if (isDisposed) {
+                return;
+            }
+            const listeners = listenersByPort.get(port) ?? new Set();
+            listeners.forEach(listener => {
+                try {
+                    listener(encodedValue);
+                }
+                catch (listenerError) {
+                    console.error('[foldkit] An outbound port listener threw:', listenerError);
+                }
+            });
+        });
+    };
+    const bind = (deliverInbound) => {
+        maybeDeliverInbound = Option.some(deliverInbound);
+        const flushedSends = pendingInboundSends.splice(0);
+        flushedSends.forEach(({ port, value }) => deliverInbound(port, value));
+    };
+    const unbind = () => {
+        maybeDeliverInbound = Option.none();
+    };
+    const dispose = () => {
+        isDisposed = true;
+        pendingInboundSends.length = 0;
+        listenersByPort.forEach(listeners => listeners.clear());
+        listenersByPort.clear();
+    };
+    return { sendInbound, addListener, deliverOutbound, bind, unbind, dispose };
+};
+export const makePortChannels = (ports, maybeConnector) => {
+    const inboundChannelsByPort = new Map();
+    Object.values(ports.inbound ?? {}).forEach(port => {
+        inboundChannelsByPort.set(port, __makeInboundChannel());
+    });
+    const outboundPorts = new Set(Object.values(ports.outbound ?? {}));
+    const channels = {
+        isConfigured: true,
+        lookupInbound: port => Option.fromNullishOr(inboundChannelsByPort.get(port)),
+        lookupOutbound: port => outboundPorts.has(port)
+            ? Option.some(encodedValue => Option.match(maybeConnector, {
+                onNone: Function.constVoid,
+                onSome: connector => connector.deliverOutbound(port, encodedValue),
+            }))
+            : Option.none(),
+    };
+    const deliverInbound = (port, value) => {
+        Option.match(Option.fromNullishOr(inboundChannelsByPort.get(port)), {
+            onNone: Function.constVoid,
+            onSome: channel => channel.deliver(value),
+        });
+    };
+    return { channels, deliverInbound };
+};
+export const validatePorts = (ports) => {
+    const inboundEntries = Object.entries(ports.inbound ?? {});
+    const outboundEntries = Object.entries(ports.outbound ?? {});
+    const inboundNames = new Set(inboundEntries.map(([name]) => name));
+    outboundEntries.forEach(([name]) => {
+        if (inboundNames.has(name)) {
+            throw new Error(`[foldkit] Port name "${name}" appears in both inbound and outbound. ` +
+                'Port names share one namespace on the EmbedHandle, so each name ' +
+                'must be unique across both records.');
+        }
+    });
+    const seenPorts = new Set();
+    const allEntries = [...inboundEntries, ...outboundEntries];
+    allEntries.forEach(([name, port]) => {
+        if (seenPorts.has(port)) {
+            throw new Error(`[foldkit] The Port registered as "${name}" is also registered under ` +
+                'another name. Each entry in the ports record needs its own ' +
+                'Port.inbound or Port.outbound value.');
+        }
+        seenPorts.add(port);
+    });
+};
+export const buildPortHandles = (ports, connector) => {
+    const handles = {};
+    if (Predicate.isNotUndefined(ports)) {
+        Object.entries(ports.inbound ?? {}).forEach(([portName, port]) => {
+            handles[portName] = {
+                send: (value) => connector.sendInbound(portName, port, value),
+            };
+        });
+        Object.entries(ports.outbound ?? {}).forEach(([portName, port]) => {
+            handles[portName] = {
+                subscribe: (listener) => connector.addListener(port, listener),
+            };
+        });
+    }
+    /* eslint-disable-next-line @typescript-eslint/consistent-type-assertions */
+    return handles;
+};

package/dist/runtime/hydrationHandoff.d.ts

@@ -0,0 +1,44 @@
+import { Effect, Option, Schema } from 'effect';
+/** Whether a boot adopts a server-rendered root (`Hydrate`) or builds the DOM
+ *  fresh in the container (`Fresh`). */
+export type BootMode = 'Fresh' | 'Hydrate';
+export type HydrationConfig = Readonly<{
+    root: HTMLElement;
+    runtimeId: string;
+    flagsScripts: ReadonlyArray<HTMLScriptElement>;
+    isFlagsRequired: boolean;
+}>;
+export declare const buildSkew: (root: HTMLElement, buildId: unknown, runtimeId: string) => Error | undefined;
+export declare const containRefusedPage: (ownerDocument: Document) => void;
+export declare const hasServerRenderedMarkup: (ownerDocument: Document) => boolean;
+export declare const findDocumentHydration: (container: HTMLElement | null, isFlagsRequired: boolean) => HydrationConfig | undefined;
+/** What the boot takes from the handoff: the server-rendered root the first
+ *  render adopts, when this boot adopts one, and the Effect that produces the
+ *  Flags `init` runs with, from the page's payload or from the app's own
+ *  Flags Effect. */
+export type ResolvedHydrationHandoff<Flags> = Readonly<{
+    maybeHydrationRoot: Option.Option<HTMLElement>;
+    resolveFlags: Effect.Effect<Flags>;
+}>;
+/**
+ * Decides whether this boot adopts the server-rendered root and where its
+ * Flags come from. A hydrating boot with no stamped root, a root served by
+ * another deployment, or a missing, duplicated, or undecodable Flags
+ * payload contains the served page and stops startup. The build id is
+ * compared before the payload text is read and before `init` runs, so
+ * nothing acts on another deployment's data. An HMR-restored Model skips
+ * adoption and gets a fresh patch against the stamped root.
+ */
+export declare const resolveHydrationHandoff: <Flags, Resources>({ bootMode, hydration, bootFlags, configuredFlags, isFlagsRequired, FlagsCodec, hmrModel, container, buildId, provideResources, }: Readonly<{
+    bootMode: BootMode;
+    hydration: HydrationConfig | undefined;
+    bootFlags: Effect.Effect<Flags, never, Resources> | undefined;
+    configuredFlags: Option.Option<Effect.Effect<Flags, never, Resources>>;
+    isFlagsRequired: boolean;
+    FlagsCodec: Schema.Codec<Flags, any, unknown, unknown>;
+    hmrModel: unknown;
+    container: HTMLElement;
+    buildId: string | undefined;
+    provideResources: <A>(effect: Effect.Effect<A, never, Resources>) => Effect.Effect<A>;
+}>) => Effect.Effect<ResolvedHydrationHandoff<Flags>>;
+//# sourceMappingURL=hydrationHandoff.d.ts.map

package/dist/runtime/hydrationHandoff.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"hydrationHandoff.d.ts","sourceRoot":"","sources":["../../src/runtime/hydrationHandoff.ts"],"names":[],"mappings":"AAAA,OAAO,EAAS,MAAM,EAAE,MAAM,EAAa,MAAM,EAAQ,MAAM,QAAQ,CAAA;AAQvE;wCACwC;AACxC,MAAM,MAAM,QAAQ,GAAG,OAAO,GAAG,SAAS,CAAA;AAK1C,MAAM,MAAM,eAAe,GAAG,QAAQ,CAAC;IACrC,IAAI,EAAE,WAAW,CAAA;IACjB,SAAS,EAAE,MAAM,CAAA;IACjB,YAAY,EAAE,aAAa,CAAC,iBAAiB,CAAC,CAAA;IAC9C,eAAe,EAAE,OAAO,CAAA;CACzB,CAAC,CAAA;AAsGF,eAAO,MAAM,SAAS,SACd,WAAW,WACR,OAAO,aACL,MAAM,KAChB,KAAK,GAAG,SAwBV,CAAA;AAmJD,eAAO,MAAM,kBAAkB,kBAAmB,QAAQ,KAAG,IAO5D,CAAA;AAOD,eAAO,MAAM,uBAAuB,kBAAmB,QAAQ,KAAG,OAItD,CAAA;AAEZ,eAAO,MAAM,qBAAqB,cACrB,WAAW,GAAG,IAAI,mBACZ,OAAO,KACvB,eAAe,GAAG,SAyDpB,CAAA;AAED;;;oBAGoB;AACpB,MAAM,MAAM,wBAAwB,CAAC,KAAK,IAAI,QAAQ,CAAC;IACrD,kBAAkB,EAAE,MAAM,CAAC,MAAM,CAAC,WAAW,CAAC,CAAA;IAC9C,YAAY,EAAE,MAAM,CAAC,MAAM,CAAC,KAAK,CAAC,CAAA;CACnC,CAAC,CAAA;AAEF;;;;;;;;GAQG;AACH,eAAO,MAAM,uBAAuB,GAAI,KAAK,EAAE,SAAS,qIAWrD,QAAQ,CAAC;IACV,QAAQ,EAAE,QAAQ,CAAA;IAClB,SAAS,EAAE,eAAe,GAAG,SAAS,CAAA;IACtC,SAAS,EAAE,MAAM,CAAC,MAAM,CAAC,KAAK,EAAE,KAAK,EAAE,SAAS,CAAC,GAAG,SAAS,CAAA;IAC7D,eAAe,EAAE,MAAM,CAAC,MAAM,CAAC,MAAM,CAAC,MAAM,CAAC,KAAK,EAAE,KAAK,EAAE,SAAS,CAAC,CAAC,CAAA;IACtE,eAAe,EAAE,OAAO,CAAA;IACxB,UAAU,EAAE,MAAM,CAAC,KAAK,CAAC,KAAK,EAAE,GAAG,EAAE,OAAO,EAAE,OAAO,CAAC,CAAA;IACtD,QAAQ,EAAE,OAAO,CAAA;IACjB,SAAS,EAAE,WAAW,CAAA;IACtB,OAAO,EAAE,MAAM,GAAG,SAAS,CAAA;IAC3B,gBAAgB,EAAE,CAAC,CAAC,EAClB,MAAM,EAAE,MAAM,CAAC,MAAM,CAAC,CAAC,EAAE,KAAK,EAAE,SAAS,CAAC,KACvC,MAAM,CAAC,MAAM,CAAC,CAAC,CAAC,CAAA;CACtB,CAAC,KAAG,MAAM,CAAC,MAAM,CAAC,wBAAwB,CAAC,KAAK,CAAC,CAuK9C,CAAA"}