@vmz/core 0.3.12 → 0.3.14

package/dist/shared/host.types.d.ts

@@ -66,6 +66,13 @@ export type DedupeComponentEntriesOpts = {
 export type ImportComponentEntriesOpts = {
     cacheBust?: string | number;
     loaded?: Set<string>;
+    /**
+     * Import the unpacked client tree (`${chunkId}.client.js`) even when
+     * `_vmz/pack-node-manifest.json` exists. Client hosts (headless logic
+     * mounts) execute unpacked client bytes, so their registry must use the
+     * same tree. Node/SSR hosts keep the default packed-node lookup.
+     */
+    unpacked?: boolean;
 };
 export type BootstrapComponentRegistryOpts = LoadComponentEntriesOpts & ImportComponentEntriesOpts & {
     preload?: 'all' | 'closure' | 'none';
@@ -109,5 +116,7 @@ export type RenderHostOpts = {
     preload?: 'all' | 'closure' | 'none';
     cacheBust?: string | number;
     rootChunkIds?: string[] | null;
+    /** Client hosts import registry entries from the unpacked client tree. */
+    unpackedEntries?: boolean;
     [key: string]: unknown;
 };

package/dist/shared/html-digest.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Content identity for `v-html` payloads shared by SSR and resume.
+ *
+ * The browser serializer expands self-closing tags (`<path/>` becomes
+ * `<path></path>`), so comparing a generated markup string with the serialized
+ * SSR DOM always misses. SSR therefore records the digest of the exact string
+ * it wrote, and resume compares that marker with the digest of the string it
+ * would write. The digest is taken over the generated string only: no DOM
+ * serialization, no normalization.
+ *
+ * Two independent 32-bit FNV-1a lanes plus the code-unit length give 64 bits of
+ * identity without pulling a crypto dependency into the browser bundle.
+ */
+export declare const HTML_HASH_ATTR = "data-vmz-html-hash";
+export declare function htmlDigest(value: string): string;

package/dist/shared/html-digest.js

@@ -0,0 +1,25 @@
+/**
+ * Content identity for `v-html` payloads shared by SSR and resume.
+ *
+ * The browser serializer expands self-closing tags (`<path/>` becomes
+ * `<path></path>`), so comparing a generated markup string with the serialized
+ * SSR DOM always misses. SSR therefore records the digest of the exact string
+ * it wrote, and resume compares that marker with the digest of the string it
+ * would write. The digest is taken over the generated string only: no DOM
+ * serialization, no normalization.
+ *
+ * Two independent 32-bit FNV-1a lanes plus the code-unit length give 64 bits of
+ * identity without pulling a crypto dependency into the browser bundle.
+ */
+export const HTML_HASH_ATTR = 'data-vmz-html-hash';
+export function htmlDigest(value) {
+    const text = value == null ? '' : String(value);
+    let laneA = 0x811c9dc5;
+    let laneB = 0x9e3779b9;
+    for (let i = 0; i < text.length; i++) {
+        const code = text.charCodeAt(i);
+        laneA = Math.imul(laneA ^ code, 0x01000193) >>> 0;
+        laneB = Math.imul(laneB ^ code, 0x85ebca77) >>> 0;
+    }
+    return `${text.length.toString(36)}-${laneA.toString(36)}-${laneB.toString(36)}`;
+}

package/dist/ssr/onmount.d.ts

@@ -0,0 +1,37 @@
+/**
+ * SSR `onMount` execution budget.
+ *
+ * Contract: every per-instance `onMount` await during SSR is bounded (default
+ * 5000ms, hosts may override via `opts.onMountBudgetMs`). Budget exhaustion and
+ * `signal` abort are the same event: the render terminates and fails — no
+ * half-baked HTML, no silent empty-string downgrade, no retry. An `onMount`
+ * that throws propagates its original error unchanged.
+ */
+export declare const DEFAULT_SSR_ONMOUNT_BUDGET_MS = 5000;
+/** `onMount` exceeded the SSR budget. Carries component, budget and elapsed. */
+export declare class SsrOnMountTimeoutError extends Error {
+    readonly component: string;
+    readonly budgetMs: number;
+    readonly elapsedMs: number;
+    constructor(component: string, budgetMs: number, elapsedMs: number);
+}
+/** The host signal aborted a bounded `onMount` await. */
+export declare class SsrRenderAbortError extends Error {
+    readonly component: string;
+    constructor(component: string);
+}
+export type SsrOnMountContext = {
+    budgetMs: number;
+    signal: AbortSignal | null;
+};
+/** Read the host options into a budget context (`opts.onMountBudgetMs`, `opts.signal`). */
+export declare function ssrOnMountContext(opts: any): SsrOnMountContext;
+/** Best-effort component label for diagnostics. */
+export declare function ssrComponentName(Component: any, inst: any): string;
+/**
+ * Await one instance's `onMount` under the budget. The race is settled exactly
+ * once; a late-resolving author promise after timeout/abort is dropped. The
+ * budget timer itself bounds the wait, so a hung `onMount` can never stall the
+ * host past `budgetMs`.
+ */
+export declare function awaitSsrOnMount(inst: any, component: string, ctx: SsrOnMountContext): Promise<void>;

package/dist/ssr/onmount.js

@@ -0,0 +1,94 @@
+/**
+ * SSR `onMount` execution budget.
+ *
+ * Contract: every per-instance `onMount` await during SSR is bounded (default
+ * 5000ms, hosts may override via `opts.onMountBudgetMs`). Budget exhaustion and
+ * `signal` abort are the same event: the render terminates and fails — no
+ * half-baked HTML, no silent empty-string downgrade, no retry. An `onMount`
+ * that throws propagates its original error unchanged.
+ */
+export const DEFAULT_SSR_ONMOUNT_BUDGET_MS = 5000;
+/** `onMount` exceeded the SSR budget. Carries component, budget and elapsed. */
+export class SsrOnMountTimeoutError extends Error {
+    component;
+    budgetMs;
+    elapsedMs;
+    constructor(component, budgetMs, elapsedMs) {
+        super(`vmz:ssr onMount budget exceeded: component=${component} budget=${budgetMs}ms elapsed=${elapsedMs}ms`);
+        this.name = 'SsrOnMountTimeoutError';
+        this.component = component;
+        this.budgetMs = budgetMs;
+        this.elapsedMs = elapsedMs;
+    }
+}
+/** The host signal aborted a bounded `onMount` await. */
+export class SsrRenderAbortError extends Error {
+    component;
+    constructor(component) {
+        super(`vmz:ssr onMount aborted by host signal: component=${component}`);
+        this.name = 'SsrRenderAbortError';
+        this.component = component;
+    }
+}
+/** Read the host options into a budget context (`opts.onMountBudgetMs`, `opts.signal`). */
+export function ssrOnMountContext(opts) {
+    const raw = opts && opts.onMountBudgetMs;
+    const budgetMs = Number.isFinite(raw) && Number(raw) > 0 ? Number(raw) : DEFAULT_SSR_ONMOUNT_BUDGET_MS;
+    const signal = opts && opts.signal ? opts.signal : null;
+    return { budgetMs, signal };
+}
+/** Best-effort component label for diagnostics. */
+export function ssrComponentName(Component, inst) {
+    return ((Component && (Component.__vmzTag || Component.name)) ||
+        (inst && inst.constructor && inst.constructor.name) ||
+        'AnonymousComponent');
+}
+/**
+ * Await one instance's `onMount` under the budget. The race is settled exactly
+ * once; a late-resolving author promise after timeout/abort is dropped. The
+ * budget timer itself bounds the wait, so a hung `onMount` can never stall the
+ * host past `budgetMs`.
+ */
+export async function awaitSsrOnMount(inst, component, ctx) {
+    const onMount = inst && inst.onMount;
+    if (typeof onMount !== 'function')
+        return;
+    if (ctx.signal && ctx.signal.aborted)
+        throw new SsrRenderAbortError(component);
+    const startedAt = Date.now();
+    let timer = null;
+    let onAbort = null;
+    try {
+        await new Promise((resolve, reject) => {
+            let settled = false;
+            const settle = (fn) => {
+                if (settled)
+                    return;
+                settled = true;
+                fn();
+            };
+            timer = setTimeout(() => {
+                settle(() => reject(new SsrOnMountTimeoutError(component, ctx.budgetMs, Date.now() - startedAt)));
+            }, ctx.budgetMs);
+            if (ctx.signal) {
+                onAbort = () => settle(() => reject(new SsrRenderAbortError(component)));
+                ctx.signal.addEventListener('abort', onAbort, { once: true });
+            }
+            let result;
+            try {
+                result = onMount.call(inst);
+            }
+            catch (err) {
+                settle(() => reject(err));
+                return;
+            }
+            Promise.resolve(result).then(() => settle(resolve), (err) => settle(() => reject(err)));
+        });
+    }
+    finally {
+        if (timer)
+            clearTimeout(timer);
+        if (ctx.signal && onAbort)
+            ctx.signal.removeEventListener('abort', onAbort);
+    }
+}

package/dist/ssr/render.js

@@ -1,5 +1,6 @@
 import { createInstance, destroy, } from '../browser/dom-core.js';
 import { ensureSsrDocument } from './document.js';
+import { awaitSsrOnMount, ssrComponentName, ssrOnMountContext } from './onmount.js';
 import { flattenSerializeNode, runDirectSerializeTreeWithMounts, streamSerializeChunks } from './serialize.js';
 export async function renderToString(Component, props = {}, opts = {}) {
     ensureSsrDocument();
@@ -7,16 +8,15 @@ export async function renderToString(Component, props = {}, opts = {}) {
     if (signal && signal.aborted)
         return '';
     const inst = createInstance(Component, props);
-    if (typeof inst.onMount === 'function') {
-        await inst.onMount();
-    }
+    const onMountCtx = ssrOnMountContext(opts);
+    await awaitSsrOnMount(inst, ssrComponentName(Component, inst), onMountCtx);
     if (signal && signal.aborted)
         return '';
     // production Direct emit: SSR only via Direct serialize schedule ??never `render`.
     if (!(Component && Component.__vmzDirect && typeof Component.__vmzCreate === 'function')) {
         throw new Error(`vmz:dom renderToString() requires __vmzCreate (Direct); blueprint render() removed (production Direct emit)`);
     }
-    const root = await runDirectSerializeTreeWithMounts(Component, inst);
+    const root = await runDirectSerializeTreeWithMounts(Component, inst, onMountCtx);
     if (opts && opts.slotHtml != null)
         injectDefaultSlotHtml(root, opts.slotHtml);
     return flattenSerializeNode(root);
@@ -29,15 +29,14 @@ export async function* renderToStream(Component, props = {}, opts = {}) {
         return;
     const inst = createInstance(Component, props);
     try {
-        if (typeof inst.onMount === 'function') {
-            await inst.onMount();
-        }
+        const onMountCtx = ssrOnMountContext(opts);
+        await awaitSsrOnMount(inst, ssrComponentName(Component, inst), onMountCtx);
         if (aborted())
             return;
         if (!(Component && Component.__vmzDirect && typeof Component.__vmzCreate === 'function')) {
             throw new Error(`vmz:dom renderToStream() requires __vmzCreate (Direct); blueprint render() removed (production Direct emit)`);
         }
-        const root = await runDirectSerializeTreeWithMounts(Component, inst);
+        const root = await runDirectSerializeTreeWithMounts(Component, inst, onMountCtx);
         if (opts && opts.slotHtml != null)
             injectDefaultSlotHtml(root, opts.slotHtml);
         if (aborted())

package/dist/ssr/serialize.d.ts

@@ -1,3 +1,3 @@
-export declare function runDirectSerializeTreeWithMounts(Component: any, inst: any): Promise<any>;
+export declare function runDirectSerializeTreeWithMounts(Component: any, inst: any, onMountCtx?: any): Promise<any>;
 export declare function flattenSerializeNode(node: any): any;
 export declare function streamSerializeChunks(node: any): any;