@vmz/core 0.2.5 → 0.2.6

package/dist/browser/resume/adopt.js

@@ -0,0 +1,168 @@
+import { directApi, noteDomCreate, runDirectCreate, } from '../dom-core.js';
+function createResumeAdopt(pool, rootEl) {
+    const used = new WeakSet();
+    const scopeStack = [pool];
+    const walkTexts = (root, visit) => {
+        if (!root)
+            return;
+        if (root.nodeType === 3) {
+            visit(root);
+            return;
+        }
+        if (root.nodeType !== 1)
+            return;
+        for (let c = root.firstChild; c; c = c.nextSibling)
+            walkTexts(c, visit);
+    };
+    const currentScope = () => scopeStack[scopeStack.length - 1] || pool;
+    const markElement = (n) => {
+        used.add(n);
+        if (typeof n.getAttribute === 'function') {
+            const k = n.getAttribute('data-vmz-key');
+            if (k != null && n.__vmzKey == null)
+                n.__vmzKey = k;
+        }
+        // Private child pool ??never dump into the parent/global pool (that let
+        // if branches reclaim Drawer/sibling hosts parked as uncles).
+        const childPool = document.createDocumentFragment();
+        while (n.firstChild)
+            childPool.appendChild(n.firstChild);
+        n.__vmzResumePool = childPool;
+        return n;
+    };
+    function* elementCandidates() {
+        const scope = currentScope();
+        if (scope === pool && rootEl && !used.has(rootEl))
+            yield rootEl;
+        // Snapshot ??adopt may move nodes out of scope while iterating.
+        const kids = [...scope.childNodes];
+        for (const n of kids) {
+            if (n.nodeType === 1 && !used.has(n)) {
+                yield n;
+            }
+        }
+    }
+    function* textCandidates() {
+        const scope = currentScope();
+        const kids = [...scope.childNodes];
+        for (const n of kids) {
+            const found = [];
+            walkTexts(n, (t) => {
+                if (!used.has(t))
+                    found.push(t);
+            });
+            for (const t of found)
+                yield t;
+        }
+    }
+    const adoptElement = (tag) => {
+        const want = String(tag || 'div').toLowerCase();
+        for (const el of elementCandidates()) {
+            if (String(el.tagName).toLowerCase() === want)
+                return markElement(el);
+        }
+        noteDomCreate();
+        return document.createElement(tag || 'div');
+    };
+    const adoptText = (value) => {
+        for (const n of textCandidates()) {
+            used.add(n);
+            if (value != null && value !== '')
+                n.textContent = String(value);
+            return n;
+        }
+        noteDomCreate();
+        return document.createTextNode(value == null ? '' : String(value));
+    };
+    const componentHost = (name) => {
+        const want = String(name || '');
+        for (const el of elementCandidates()) {
+            if (String(el.tagName).toLowerCase() !== 'div')
+                continue;
+            if (el.getAttribute('data-vmz') !== want)
+                continue;
+            return markElement(el);
+        }
+        return null;
+    };
+    const enter = (node) => {
+        if (!node || !node.__vmzResumePool)
+            return false;
+        scopeStack.push(node.__vmzResumePool);
+        return true;
+    };
+    const leave = () => {
+        if (scopeStack.length <= 1)
+            return;
+        scopeStack.pop();
+    };
+    const scopeDepth = () => scopeStack.length;
+    const rewindScope = (depth) => {
+        const d = Math.max(1, Number(depth) || 1);
+        while (scopeStack.length > d)
+            scopeStack.pop();
+    };
+    /**
+     * Isolate the next top-level SSR sibling as the only candidates for an
+     * if/else branch create (commercial Card: Empty branch must not adopt Drawer).
+     */
+    const beginBranchScope = () => {
+        const parent = currentScope();
+        const branchPool = document.createDocumentFragment();
+        for (const n of [...parent.childNodes]) {
+            if (n.nodeType === 1 && !used.has(n)) {
+                branchPool.appendChild(n);
+                break;
+            }
+        }
+        scopeStack.push(branchPool);
+        const depth = scopeStack.length;
+        return () => {
+            while (branchPool.firstChild)
+                branchPool.removeChild(branchPool.firstChild);
+            rewindScope(depth - 1);
+        };
+    };
+    return {
+        el: adoptElement,
+        text: adoptText,
+        componentHost,
+        enter,
+        leave,
+        scopeDepth,
+        rewindScope,
+        beginBranchScope,
+    };
+}
+export function runDirectResume(Component, inst, container) {
+    const rootEl = [...container.childNodes].find((n) => n.nodeType === 1 || (n.nodeType === 3 && String(n.textContent).trim() !== ''));
+    if (!rootEl || rootEl.nodeType !== 1) {
+        return runDirectCreate(Component, inst);
+    }
+    // Park SSR descendants so create can append if/each structure without orphan siblings.
+    const pool = document.createDocumentFragment();
+    while (rootEl.firstChild)
+        pool.appendChild(rootEl.firstChild);
+    const prevInst = directApi._inst;
+    const prevBranch = directApi._branchBinds;
+    const prevItems = directApi._itemPatches;
+    const prevEach = directApi._eachCtx;
+    const prevAdopt = directApi._resumeAdopt;
+    directApi._inst = inst;
+    directApi._branchBinds = null;
+    directApi._itemPatches = null;
+    directApi._eachCtx = null;
+    directApi._resumeAdopt = createResumeAdopt(pool, rootEl);
+    try {
+        return Component.__vmzCreate.call(inst, directApi);
+    }
+    finally {
+        directApi._resumeAdopt = prevAdopt;
+        directApi._inst = prevInst;
+        directApi._branchBinds = prevBranch;
+        directApi._itemPatches = prevItems;
+        directApi._eachCtx = prevEach;
+        while (pool.firstChild)
+            pool.removeChild(pool.firstChild);
+    }
+}

package/dist/browser/resume/hydrate.d.ts

@@ -0,0 +1,4 @@
+export declare function hydrateRoute(Page: any, container: any, props?: {}, layoutCtors?: any[], opts?: {}): Promise<any>;
+export declare function hydrateRoutePage(Page: any, container: any, props?: any, opts?: any): Promise<any>;
+export declare function hydrate(Component: any, container: any, props?: any, opts?: any): Promise<any>;
+export declare function hydrateIslands(root?: Document): void;

package/dist/browser/resume/hydrate.js

@@ -0,0 +1,107 @@
+import { applyPreservedState, createInstance, destroy, findOwnedDefaultSlot, hasMeaningfulChild, mount, runDirectCreate, settlePendingChildMounts, snapshotInstanceState, } from '../dom-core.js';
+import { runDirectResume } from './adopt.js';
+import { resumeIslands } from './resume.js';
+export async function hydrateRoute(Page, container, props = {}, layoutCtors = [], opts = {}) {
+    if (typeof document === 'undefined') {
+        throw new Error('vmz:dom hydrateRoute() requires a document (browser)');
+    }
+    if (container.__vmzInst) {
+        destroy(container.__vmzInst);
+        container.__vmzInst = null;
+    }
+    container.__vmzPageHost = null;
+    container.__vmzLayoutInsts = null;
+    const layoutInsts = [];
+    let host = container;
+    const ctors = Array.isArray(layoutCtors) ? layoutCtors.filter(Boolean) : [];
+    for (const Layout of ctors) {
+        const inst = await mount(Layout, host, {});
+        layoutInsts.push(inst);
+        const slot = findOwnedDefaultSlot(inst.__vmzDomRoot);
+        const outlet = document.createElement('div');
+        outlet.setAttribute('data-vmz-outlet', '');
+        if (slot && slot.parentNode)
+            slot.replaceWith(outlet);
+        else if (inst.__vmzDomRoot && typeof inst.__vmzDomRoot.appendChild === 'function') {
+            inst.__vmzDomRoot.appendChild(outlet);
+        }
+        else {
+            host.appendChild(outlet);
+        }
+        host = outlet;
+    }
+    const pageInst = await hydrate(Page, host, props, opts);
+    container.__vmzPageHost = host;
+    container.__vmzLayoutInsts = layoutInsts;
+    // Outer layout (or page if no layouts) owns the #app instance for destroy().
+    container.__vmzInst = layoutInsts[0] || pageInst;
+    return pageInst;
+}
+export async function hydrateRoutePage(Page, container, props = {}, opts = {}) {
+    if (typeof document === 'undefined') {
+        throw new Error('vmz:dom hydrateRoutePage() requires a document (browser)');
+    }
+    const pageHost = container.__vmzPageHost || container;
+    if (pageHost.__vmzInst) {
+        destroy(pageHost.__vmzInst);
+        pageHost.__vmzInst = null;
+    }
+    const pageInst = await hydrate(Page, pageHost, props, opts);
+    container.__vmzPageHost = pageHost;
+    const layouts = container.__vmzLayoutInsts;
+    if (!Array.isArray(layouts) || layouts.length === 0) {
+        container.__vmzInst = pageInst;
+    }
+    return pageInst;
+}
+export async function hydrate(Component, container, props = {}, opts = {}) {
+    if (typeof document === 'undefined') {
+        throw new Error('vmz:dom hydrate() requires a document (browser)');
+    }
+    let preserved = null;
+    if (opts.preserveState && typeof opts.preserveState === 'object') {
+        preserved = opts.preserveState;
+    }
+    else if (opts.preserveState === true && container.__vmzInst) {
+        preserved = snapshotInstanceState(container.__vmzInst);
+    }
+    if (container.__vmzInst) {
+        destroy(container.__vmzInst);
+        container.__vmzInst = null;
+    }
+    const inst = createInstance(Component, props);
+    if (preserved) {
+        applyPreservedState(inst, preserved);
+    }
+    // production Direct emit: hydrate uses the same Direct schedule as resume (no render).
+    if (!(Component && Component.__vmzDirect && typeof Component.__vmzCreate === 'function')) {
+        throw new Error(`vmz:dom hydrate() requires __vmzCreate (Direct); blueprint render() removed (production Direct emit)`);
+    }
+    // Wire DOM + events BEFORE awaiting onMount. SSR shell is already visible; if we
+    // wait on RPC/bootstrap first, buttons look real but have no listeners (dead UI).
+    // onMount may still patch state / redirect afterwards (same end state as SSR order).
+    if (!hasMeaningfulChild(container)) {
+        const node = runDirectCreate(Component, inst);
+        if (node) {
+            inst.__vmzDomRoot = node;
+            container.appendChild(node);
+        }
+    }
+    else {
+        // Deep adopt: park SSR children, rebuild schedule, reclaim nodes (no orphan siblings).
+        const node = runDirectResume(Component, inst, container);
+        if (node)
+            inst.__vmzDomRoot = node;
+    }
+    await settlePendingChildMounts(inst);
+    container.__vmzInst = inst;
+    const runMount = opts.skipOnMount !== true && !preserved && typeof inst.onMount === 'function';
+    if (runMount) {
+        await inst.onMount();
+    }
+    return inst;
+}
+export function hydrateIslands(root = globalThis.document) {
+    // resume: hydrateIslands is an alias for resumeIslands (same Plan attach).
+    return resumeIslands(root);
+}

package/dist/browser/resume/resume.d.ts

@@ -0,0 +1,3 @@
+export declare function resume(Component: any, container: any, slice?: any): Promise<any>;
+export declare function resumeIslands(root?: Document): void;
+export declare function attachEventEntries(root?: Document): void;

package/dist/browser/resume/resume.js

@@ -0,0 +1,102 @@
+import { applyDirectHostBox } from '../direct-host-box.js';
+import { applyPreservedState, createInstance, destroy, hasMeaningfulChild, isEventEntryStrategy, resolveComponent, runDirectCreate, scheduleClientOn, } from '../dom-core.js';
+import { markUnknownComponentHost } from '../unknown-component.js';
+import { runDirectResume } from './adopt.js';
+export async function resume(Component, container, slice = null) {
+    if (typeof document === 'undefined') {
+        throw new Error('vmz:dom resume() requires a document (browser)');
+    }
+    let parsed = slice;
+    if (!parsed) {
+        const raw = container.getAttribute('data-vmz-resume');
+        if (raw) {
+            try {
+                parsed = JSON.parse(raw);
+            }
+            catch {
+                parsed = null;
+            }
+        }
+    }
+    if (!parsed) {
+        let props = {};
+        try {
+            props = JSON.parse(container.getAttribute('data-vmz-props') || '{}');
+        }
+        catch {
+            props = {};
+        }
+        parsed = { props, state: {} };
+    }
+    if (container.__vmzInst) {
+        destroy(container.__vmzInst);
+        container.__vmzInst = null;
+    }
+    const hostName = container.getAttribute('data-vmz') || container.getAttribute('data-vmz-island') || Component.name || '';
+    applyDirectHostBox(container, hostName, Component);
+    const props = parsed.props || {};
+    const inst = createInstance(Component, props);
+    if (parsed.state)
+        applyPreservedState(inst, parsed.state);
+    // Intentionally never call onMount ??SSR already completed that work.
+    if (Component.__vmzDirect && typeof Component.__vmzCreate === 'function') {
+        if (!hasMeaningfulChild(container)) {
+            const node = runDirectCreate(Component, inst);
+            if (node) {
+                inst.__vmzDomRoot = node;
+                container.appendChild(node);
+            }
+        }
+        else {
+            // Island leaf adopt: preserve Element identity (resume nodeIdentity).
+            const node = runDirectResume(Component, inst, container);
+            if (node)
+                inst.__vmzDomRoot = node;
+        }
+    }
+    else {
+        throw new Error(`vmz:dom resume() requires __vmzCreate (Direct); blueprint render() removed (production Direct emit)`);
+    }
+    container.__vmzInst = inst;
+    container.__vmzResumed = true;
+    return inst;
+}
+export function resumeIslands(root = globalThis.document) {
+    if (!root || typeof root.querySelectorAll !== 'function') {
+        throw new Error('vmz:dom resumeIslands() requires a DOM root');
+    }
+    const nodes = [...root.querySelectorAll('[data-vmz-island]')];
+    for (const el of nodes) {
+        const name = el.getAttribute('data-vmz-island');
+        const strategy = el.getAttribute('data-vmz-client') || 'load';
+        scheduleClientOn(el, strategy, async () => {
+            const Ctor = await resolveComponent(name);
+            if (!Ctor) {
+                markUnknownComponentHost(el, name, 'resume');
+                return;
+            }
+            await resume(Ctor, el);
+        });
+    }
+}
+export function attachEventEntries(root = globalThis.document) {
+    if (!root || typeof root.querySelectorAll !== 'function') {
+        throw new Error('vmz:dom attachEventEntries() requires a DOM root');
+    }
+    const nodes = [...root.querySelectorAll('[data-vmz-island]')];
+    for (const el of nodes) {
+        const strategy = el.getAttribute('data-vmz-client') || '';
+        if (!isEventEntryStrategy(strategy))
+            continue;
+        const name = el.getAttribute('data-vmz-island');
+        el.setAttribute('data-vmz-entry', 'event');
+        scheduleClientOn(el, strategy, async () => {
+            const Ctor = await resolveComponent(name);
+            if (!Ctor) {
+                markUnknownComponentHost(el, name, 'event-entry');
+                return;
+            }
+            await resume(Ctor, el);
+        });
+    }
+}

package/dist/faces/dom.browser.d.ts

@@ -4,4 +4,5 @@
  * Full barrel remains `@vmz/core/dom` (`dom.js` / dist `vmz-dom.js`) for Node host.
  */
 export * from '../browser/dom-core.js';
-export { attachEventEntries, hydrate, hydrateIslands, hydrateRoute, hydrateRoutePage, resume, resumeIslands } from '../ssr/dom-ssr.js';
+export { hydrate, hydrateIslands, hydrateRoute, hydrateRoutePage } from '../browser/resume/hydrate.js';
+export { attachEventEntries, resume, resumeIslands } from '../browser/resume/resume.js';

package/dist/faces/dom.browser.js

@@ -4,4 +4,5 @@
  * Full barrel remains `@vmz/core/dom` (`dom.js` / dist `vmz-dom.js`) for Node host.
  */
 export * from '../browser/dom-core.js';
-export { attachEventEntries, hydrate, hydrateIslands, hydrateRoute, hydrateRoutePage, resume, resumeIslands } from '../ssr/dom-ssr.js';
+export { hydrate, hydrateIslands, hydrateRoute, hydrateRoutePage } from '../browser/resume/hydrate.js';
+export { attachEventEntries, resume, resumeIslands } from '../browser/resume/resume.js';

package/dist/host/{deployment-registry.d.ts → deployment/deployment-registry.d.ts}

@@ -2,7 +2,7 @@
  * Deployment graph — component registry bootstrap (shared by all SSR/DOM hosts).
  * Parse/validate and graph queries delegate to Rust vmz-artifacts via N-API.
  */
-import type { BootstrapComponentRegistryOpts, ComponentEntry, ComponentRegistryMap, DedupeComponentEntriesOpts, DeploymentDocument, ImportComponentEntriesOpts, LoadComponentEntriesOpts } from '../shared/host.types.js';
+import type { BootstrapComponentRegistryOpts, ComponentEntry, ComponentRegistryMap, DedupeComponentEntriesOpts, DeploymentDocument, ImportComponentEntriesOpts, LoadComponentEntriesOpts } from '../../shared/host.types.js';
 export declare const DEPLOYMENT_SCHEMA = "vmz.deployment.v0";
 export declare function readDeploymentDocument(distDir: string, opts?: {
     strict?: boolean;

package/dist/host/{deployment-registry.js → deployment/deployment-registry.js}

@@ -5,7 +5,7 @@
 import fs from 'node:fs';
 import path from 'node:path';
 import { pathToFileURL } from 'node:url';
-import { requireNativeFn } from './native-addon.js';
+import { requireNativeFn } from '../native-addon.js';
 export const DEPLOYMENT_SCHEMA = 'vmz.deployment.v0';
 function parseDeploymentJson(jsonText) {
     requireNativeFn('deploymentValidate')(jsonText);

package/dist/host/list-client-components.d.ts

@@ -3,8 +3,8 @@
  * Shared by serve-host SSR, static emit, and test hosts (plan-only host).
  */
 import type { ClientComponentListEntry, ComponentRegistryMap, ListClientComponentsOpts, PreloadComponentRegistryOpts } from '../shared/host.types.js';
-export { DEPLOYMENT_SCHEMA, readDeploymentDocument, componentEntriesFromDeployment, collectDependsOnClosure, dedupeComponentEntriesByTag, mergeExplicitComponentEntries, loadComponentEntries, importAndRegisterComponentEntries, bootstrapComponentRegistry, } from './deployment-registry.js';
-export { createRenderHost } from './render-host.js';
+export { DEPLOYMENT_SCHEMA, readDeploymentDocument, componentEntriesFromDeployment, collectDependsOnClosure, dedupeComponentEntriesByTag, mergeExplicitComponentEntries, loadComponentEntries, importAndRegisterComponentEntries, bootstrapComponentRegistry, } from './deployment/deployment-registry.js';
+export { createRenderHost } from './render/render-host.js';
 export declare function listClientComponents(dir: string, opts?: ListClientComponentsOpts): Promise<ClientComponentListEntry[]>;
 export declare function listClientComponentsSync(dir: string, opts?: ListClientComponentsOpts): ClientComponentListEntry[];
 export declare function mergeComponentEntries(entries: ClientComponentListEntry[], explicit?: Record<string, string>): ClientComponentListEntry[];

package/dist/host/list-client-components.js

@@ -4,9 +4,9 @@
  */
 import path from 'node:path';
 import { pathToFileURL } from 'node:url';
-import { componentEntriesFromDeployment, dedupeComponentEntriesByTag, mergeExplicitComponentEntries, readDeploymentDocument, } from './deployment-registry.js';
-export { DEPLOYMENT_SCHEMA, readDeploymentDocument, componentEntriesFromDeployment, collectDependsOnClosure, dedupeComponentEntriesByTag, mergeExplicitComponentEntries, loadComponentEntries, importAndRegisterComponentEntries, bootstrapComponentRegistry, } from './deployment-registry.js';
-export { createRenderHost } from './render-host.js';
+import { componentEntriesFromDeployment, dedupeComponentEntriesByTag, mergeExplicitComponentEntries, readDeploymentDocument, } from './deployment/deployment-registry.js';
+export { DEPLOYMENT_SCHEMA, readDeploymentDocument, componentEntriesFromDeployment, collectDependsOnClosure, dedupeComponentEntriesByTag, mergeExplicitComponentEntries, loadComponentEntries, importAndRegisterComponentEntries, bootstrapComponentRegistry, } from './deployment/deployment-registry.js';
+export { createRenderHost } from './render/render-host.js';
 export async function listClientComponents(dir, opts = {}) {
     const strict = opts.strict === true;
     const deployment = readDeploymentDocument(dir, { strict });
@@ -60,7 +60,7 @@ export function mergeComponentEntries(entries, explicit) {
     }));
 }
 export async function resolveComponentEntries(distDir, explicit, opts = {}) {
-    const { loadComponentEntries } = await import('./deployment-registry.js');
+    const { loadComponentEntries } = await import('./deployment/deployment-registry.js');
     const entries = await loadComponentEntries(distDir, {
         strict: opts.strict,
         closureRoots: opts.closureRoots,

package/dist/host/{render-host.d.ts → render/render-host.d.ts}

@@ -4,10 +4,10 @@
  */
 export declare function createRenderHost(distDir: string, opts?: Record<string, unknown>): Promise<{
     distDir: string;
-    deployment: import("../shared/host.types.js").DeploymentDocument;
+    deployment: import("../../shared/host.types.js").DeploymentDocument;
     dom: any;
     loadedChunkIds: Set<string>;
-    ensureComponents: (rootChunkIds?: string[] | null) => Promise<import("../shared/host.types.js").ComponentRegistryMap>;
+    ensureComponents: (rootChunkIds?: string[] | null) => Promise<import("../../shared/host.types.js").ComponentRegistryMap>;
     closureChunkIds: (rootChunkIds?: string[] | null) => Set<string>;
     renderToString: any;
     renderToStream: any;

package/dist/host/{render-host.js → render/render-host.js}

@@ -4,7 +4,7 @@
  */
 import path from 'node:path';
 import { pathToFileURL } from 'node:url';
-import { bootstrapComponentRegistry, collectDependsOnClosure, importAndRegisterComponentEntries, loadComponentEntries, readDeploymentDocument, } from './deployment-registry.js';
+import { bootstrapComponentRegistry, collectDependsOnClosure, importAndRegisterComponentEntries, loadComponentEntries, readDeploymentDocument, } from '../deployment/deployment-registry.js';
 export async function createRenderHost(distDir, opts = {}) {
     const strict = opts.strictDeployment === true || opts.strict === true;
     const domPath = path.join(distDir, 'vmz-dom.js');

package/dist/host/{route-layout-chain.js → render/route-layout-chain.js}

@@ -1,7 +1,7 @@
 /**
  * Layout chain from Deployment Plan only (plan-only host).
  */
-import { readDeploymentDocument } from './deployment-registry.js';
+import { readDeploymentDocument } from '../deployment/deployment-registry.js';
 /** Chunk id for `src/Application.vmz` emit (`Application.client.js`). */
 export const APPLICATION_SHELL_CHUNK = 'Application';
 /**

package/dist/host/serve/bootstrap.d.ts

@@ -0,0 +1 @@
+export declare function bootstrapServeHost(): Promise<void>;

package/dist/host/serve/bootstrap.js

@@ -0,0 +1,25 @@
+import path from 'node:path';
+import { pathToFileURL } from 'node:url';
+import { setServerModuleResolver } from '../../faces/vmz-runtime.js';
+import { installDevImportTokenHooks, normalizeDevError, softReload } from './hmr-dev.js';
+import { bustUrl } from './page-catalog.js';
+import { installAppModuleResolveHooks } from './paths.js';
+import { serveState } from './state.js';
+export async function bootstrapServeHost() {
+    installAppModuleResolveHooks();
+    globalThis.__VMZ_RPC_ORIGIN = `http://${serveState.host}:${serveState.port}`;
+    installDevImportTokenHooks();
+    setServerModuleResolver((moduleId) => {
+        const rel = moduleId.replace(/^#server\//, '') + '.js';
+        return bustUrl(pathToFileURL(path.join(serveState.distDir, '#server', rel)).href);
+    });
+    try {
+        await softReload({ quiet: true });
+        serveState.ready = true;
+    }
+    catch (err) {
+        serveState.lastDevError = normalizeDevError(err);
+        serveState.ready = true;
+        console.error('vmz serve: initial load failed (dev host stays up)', serveState.lastDevError.message);
+    }
+}

package/dist/host/serve/constants.d.ts

@@ -0,0 +1,6 @@
+export declare const ROUTE_CATALOG_SCHEMA = "vmz.route.catalog.v0";
+export declare const ROUTE_CATALOG_REL = "_vmz/route-catalog.json";
+export declare const LOCALE_LINK_PLAN_REL = "_vmz/locale-link-plan.json";
+export declare const THEME_STORE_KEY = "vmz-theme";
+export declare const LOCALE_STORE_KEY = "vmz.locale";
+export declare const SHUTDOWN_TIMEOUT_MS: number;

package/dist/host/serve/constants.js

@@ -0,0 +1,6 @@
+export const ROUTE_CATALOG_SCHEMA = 'vmz.route.catalog.v0';
+export const ROUTE_CATALOG_REL = '_vmz/route-catalog.json';
+export const LOCALE_LINK_PLAN_REL = '_vmz/locale-link-plan.json';
+export const THEME_STORE_KEY = 'vmz-theme';
+export const LOCALE_STORE_KEY = 'vmz.locale';
+export const SHUTDOWN_TIMEOUT_MS = Number(process.env.VMZ_SHUTDOWN_TIMEOUT_MS || 10000);

package/dist/host/serve/hmr-dev.d.ts

@@ -0,0 +1,34 @@
+export declare function installDevImportTokenHooks(): void;
+export declare function notifySse(event: string): void;
+export declare function normalizeDevError(err: unknown): {
+    message: string;
+    stack: string;
+    at: number;
+} | {
+    message: string;
+    at: number;
+    stack?: undefined;
+};
+export declare function emitDevErrorHtml(err: {
+    message?: string;
+    stack?: string;
+}): AsyncGenerator<any, void, unknown>;
+export declare function softReload(opts?: {
+    quiet?: boolean;
+    payload?: Record<string, unknown>;
+}): Promise<{
+    affectedChunks: string[];
+    seedChunks: string[];
+    full: boolean;
+    islandHmr: boolean;
+    mode: string;
+    eventOnlyShell: boolean;
+    pageCount: number;
+    reloadedPages: number;
+    reloadAllPages: boolean;
+    buildId: string;
+    sourceRevision: string;
+    bundleRevision: string;
+    serveRevision: string;
+    token: number;
+}>;