@vmz/core 0.1.20 → 0.1.21

package/dist/direct-host-box.d.ts

@@ -0,0 +1,26 @@
+/**
+ * Direct host box model (`ui-direct-host-box`).
+ * Chip hosts opt into `display: contents`; block surfaces keep a real layout box.
+ */
+/** @type {ReadonlySet<string>} */
+export declare const INLINE_HOST_CONTENTS: Set<string>;
+/**
+ * @param {string} name
+ * @param {{ __vmzHostBox?: string } | null | undefined} Ctor
+ * @returns {'contents' | 'block'}
+ */
+export declare function resolveDirectHostBox(name: any, Ctor: any): any;
+/**
+ * Apply host box to a live DOM element (create / hydrate / resume).
+ * @param {HTMLElement} host
+ * @param {string} name
+ * @param {{ __vmzHostBox?: string } | null | undefined} Ctor
+ */
+export declare function applyDirectHostBox(host: any, name: any, Ctor: any): void;
+/**
+ * SSR attrs fragment for host box (only when contents).
+ * @param {string} name
+ * @param {{ __vmzHostBox?: string } | null | undefined} Ctor
+ * @returns {string | null}
+ */
+export declare function directHostBoxStyleAttr(name: any, Ctor: any): string;

package/dist/direct-host-box.js

@@ -0,0 +1,41 @@
+/**
+ * Direct host box model (`ui-direct-host-box`).
+ * Chip hosts opt into `display: contents`; block surfaces keep a real layout box.
+ */
+/** @type {ReadonlySet<string>} */
+export const INLINE_HOST_CONTENTS = new Set(['Button', 'Badge', 'Link', 'Tag', 'Icon']);
+/**
+ * @param {string} name
+ * @param {{ __vmzHostBox?: string } | null | undefined} Ctor
+ * @returns {'contents' | 'block'}
+ */
+export function resolveDirectHostBox(name, Ctor) {
+    const explicit = Ctor && typeof Ctor.__vmzHostBox === 'string' ? Ctor.__vmzHostBox : null;
+    if (explicit === 'contents' || explicit === 'block')
+        return explicit;
+    if (INLINE_HOST_CONTENTS.has(String(name || '')))
+        return 'contents';
+    return 'block';
+}
+/**
+ * Apply host box to a live DOM element (create / hydrate / resume).
+ * @param {HTMLElement} host
+ * @param {string} name
+ * @param {{ __vmzHostBox?: string } | null | undefined} Ctor
+ */
+export function applyDirectHostBox(host, name, Ctor) {
+    if (!host || !host.style)
+        return;
+    if (resolveDirectHostBox(name, Ctor) === 'contents') {
+        host.style.display = 'contents';
+    }
+}
+/**
+ * SSR attrs fragment for host box (only when contents).
+ * @param {string} name
+ * @param {{ __vmzHostBox?: string } | null | undefined} Ctor
+ * @returns {string | null}
+ */
+export function directHostBoxStyleAttr(name, Ctor) {
+    return resolveDirectHostBox(name, Ctor) === 'contents' ? 'display:contents' : null;
+}

package/dist/dom-core.d.ts

@@ -6,6 +6,8 @@
  * Mount and client patches run that same schedule (SSR/hydrate/resume in dom-ssr).
  * Field writes only run registered dep patches — never re-create structure.
  */
+export { applyDirectHostBox, INLINE_HOST_CONTENTS, resolveDirectHostBox } from './direct-host-box.js';
+export { createUnknownComponentElement, markUnknownComponentHost, serializeUnknownComponentNode, UNKNOWN_COMPONENT_ERROR, } from './unknown-component.js';
 /** @param {boolean} [on] */
 export declare function __vmzPrecisionEnable(on?: boolean): void;
 /** @param {boolean} [on] */

package/dist/dom-core.js

@@ -7,14 +7,12 @@
  * Mount and client patches run that same schedule (SSR/hydrate/resume in dom-ssr).
  * Field writes only run registered dep patches — never re-create structure.
  */
+import { applyDirectHostBox } from './direct-host-box.js';
+import { createUnknownComponentElement } from './unknown-component.js';
+export { applyDirectHostBox, INLINE_HOST_CONTENTS, resolveDirectHostBox } from './direct-host-box.js';
+export { createUnknownComponentElement, markUnknownComponentHost, serializeUnknownComponentNode, UNKNOWN_COMPONENT_ERROR, } from './unknown-component.js';
 /** @type {Record<string, new (props?: object) => any>} */
 const components = Object.create(null);
-/**
- * Inline chip hosts that opt into `display: contents` (`ui-direct-host-box`).
- * Block surfaces (DataTable / shells / overlays) must keep a real layout box.
- * @type {Set<string>}
- */
-const INLINE_HOST_CONTENTS = new Set(['Button', 'Badge', 'Link', 'Tag', 'Icon']);
 /**
  * Precision lab counters (test / MCP / benchmarks — not a user API).
  * Primary keys: BindingId (IR). `*ByDep` is transitional stable-string adapter.
@@ -452,22 +450,23 @@ export const directApi = {
             // resume: resume on schedule; EventEntry may lazy-load chunk via __vmzLoadComponent.
             scheduleClientOn(host, String(client), async () => {
                 const Ctor = await resolveComponent(name);
-                if (!Ctor)
-                    throw new Error(`vmz:dom unknown component <${name} />`);
+                if (!Ctor) {
+                    // Replace placeholder island with leaf error node (do not throw page).
+                    const err = createUnknownComponentElement(name, 'island');
+                    host.replaceWith(err);
+                    return;
+                }
                 await resume(Ctor, host, { props: resolved, state: {} });
             });
             return host;
         }
         const Ctor = components[name];
-        if (!Ctor)
-            throw new Error(`vmz:dom unknown component <${name} />`);
-        // Inline chips opt into no-box host (`ui-direct-host-box`). Block surfaces
-        // (tables/shells/overlays) keep a real box — default `contents` breaks
-        // hit-testing / slot hosts (DataTable select timed out in ui-automation).
-        const hostBox = Ctor.__vmzHostBox;
-        if (hostBox === 'contents' || (hostBox == null && INLINE_HOST_CONTENTS.has(String(name)))) {
-            host.style.display = 'contents';
+        if (!Ctor) {
+            return createUnknownComponentElement(name, 'client');
         }
+        // Inline chips → `display: contents` (`ui-direct-host-box`). Block surfaces
+        // keep a real box (DataTable select timed out when defaulting everything).
+        applyDirectHostBox(host, name, Ctor);
         const child = createInstance(Ctor, resolved);
         if (!(Ctor.__vmzDirect && typeof Ctor.__vmzCreate === 'function')) {
             throw new Error(`vmz:dom direct component <${name}> requires __vmzCreate (rebuild child with Direct)`);

package/dist/dom-ssr.js

@@ -3,7 +3,9 @@
  * VMZ DOM SSR / hydrate / resume — precise patches, no VDOM diff.
  * Imports client DOM primitives from ./dom-core.js for tree-shakeable browser entry.
  */
+import { applyDirectHostBox, directHostBoxStyleAttr } from './direct-host-box.js';
 import { applyDomAttr, applyPreservedState, BOOLEAN_HTML_ATTRS, createInstance, destroy, directApi, eventPropHandlerName, getRegisteredComponent, hasMeaningfulChild, isEventEntryStrategy, mount, noteDomCreate, resolveComponent, runDirectCreate, scheduleClientOn, settlePendingChildMounts, snapshotInstanceState, stripFns, } from './dom-core.js';
+import { markUnknownComponentHost, serializeUnknownComponentNode } from './unknown-component.js';
 /** @type {Error | null} last linkedom resolve failure (for clear SSR errors) */
 let _ssrDocumentLastError = null;
 /**
@@ -742,8 +744,9 @@ const serializeApi = {
     },
     component(hostInst, name, props, client) {
         const Ctor = getRegisteredComponent(name);
-        if (!Ctor)
-            throw new Error(`vmz:dom unknown component <${name} />`);
+        if (!Ctor) {
+            return serializeUnknownComponentNode(name);
+        }
         /** @type {Record<string, any>} */
         const resolved = {};
         for (const [k, v] of Object.entries(props || {})) {
@@ -788,6 +791,9 @@ const serializeApi = {
                 'data-vmz-props': JSON.stringify(stripFns(resolved)),
                 'data-vmz-resume': JSON.stringify(resume),
             };
+            const boxStyle = directHostBoxStyleAttr(name, Ctor);
+            if (boxStyle)
+                attrs.style = boxStyle;
             if (isEventEntryStrategy(String(client))) {
                 attrs['data-vmz-entry'] = 'event';
             }
@@ -810,11 +816,9 @@ const serializeApi = {
                 const node = Ctor.__vmzCreate.call(child, serializeApi);
                 /** @type {Record<string, string>} */
                 const attrs = { 'data-vmz': name };
-                const hostBox = Ctor.__vmzHostBox;
-                if (hostBox === 'contents' ||
-                    (hostBox == null && (name === 'Button' || name === 'Badge' || name === 'Link' || name === 'Tag' || name === 'Icon'))) {
-                    attrs.style = 'display:contents';
-                }
+                const boxStyle = directHostBoxStyleAttr(name, Ctor);
+                if (boxStyle)
+                    attrs.style = boxStyle;
                 return {
                     __kind: 'el',
                     tag: 'div',
@@ -892,6 +896,8 @@ export async function resume(Component, container, slice = null) {
         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)
@@ -935,7 +941,7 @@ export function resumeIslands(root = globalThis.document) {
         scheduleClientOn(el, strategy, async () => {
             const Ctor = await resolveComponent(name);
             if (!Ctor) {
-                console.error(`vmz:dom resume: unknown component ${name}`);
+                markUnknownComponentHost(el, name, 'resume');
                 return;
             }
             await resume(Ctor, el);
@@ -961,7 +967,7 @@ export function attachEventEntries(root = globalThis.document) {
         scheduleClientOn(el, strategy, async () => {
             const Ctor = await resolveComponent(name);
             if (!Ctor) {
-                console.error(`vmz:dom EventEntry: unknown component ${name}`);
+                markUnknownComponentHost(el, name, 'event-entry');
                 return;
             }
             await resume(Ctor, el);

package/dist/unknown-component.d.ts

@@ -0,0 +1,40 @@
+/**
+ * Unknown Direct component resilience (`ssr-unknown-component-error-node`).
+ * Leaf failure → subtree error node; do not throw out of document SSR.
+ */
+/** @type {string} */
+export declare const UNKNOWN_COMPONENT_ERROR = "unknown-component";
+/**
+ * Append a leaf diagnostic for tooling (does not replace the error node).
+ * @param {string} name
+ * @param {string} [via]
+ */
+export declare function noteUnknownComponent(name: any, via?: string): void;
+/**
+ * SSR serialize-tree error node (keeps document HTTP 200).
+ * @param {string} name
+ */
+export declare function serializeUnknownComponentNode(name: any): {
+    __kind: string;
+    tag: string;
+    attrs: {
+        'data-vmz-error': string;
+        'data-vmz-component': string;
+    };
+    children: any[];
+    appendChild(c: any): void;
+};
+/**
+ * Live DOM error host (client create / schedule).
+ * @param {string} name
+ * @param {string} [via]
+ * @returns {HTMLElement}
+ */
+export declare function createUnknownComponentElement(name: any, via?: string): HTMLDivElement;
+/**
+ * Mark an existing island host as unknown (resume / EventEntry).
+ * @param {HTMLElement} el
+ * @param {string} name
+ * @param {string} [via]
+ */
+export declare function markUnknownComponentHost(el: any, name: any, via?: string): void;

package/dist/unknown-component.js

@@ -0,0 +1,112 @@
+/**
+ * Unknown Direct component resilience (`ssr-unknown-component-error-node`).
+ * Leaf failure → subtree error node; do not throw out of document SSR.
+ */
+/** @type {string} */
+export const UNKNOWN_COMPONENT_ERROR = 'unknown-component';
+/**
+ * @returns {boolean}
+ */
+function isDevSurface() {
+    try {
+        if (typeof process !== 'undefined' && process.env) {
+            if (process.env.VMZ_DEV === '1' || process.env.VMZ_DEV === 'true')
+                return true;
+            if (process.env.NODE_ENV === 'development')
+                return true;
+        }
+    }
+    catch {
+        /* ignore */
+    }
+    return false;
+}
+/**
+ * Append a leaf diagnostic for tooling (does not replace the error node).
+ * @param {string} name
+ * @param {string} [via]
+ */
+export function noteUnknownComponent(name, via = 'ssr') {
+    const detail = { kind: UNKNOWN_COMPONENT_ERROR, component: String(name || ''), via };
+    try {
+        if (typeof console !== 'undefined' && typeof console.error === 'function') {
+            console.error(`vmz:dom unknown component <${name} /> (${via})`);
+        }
+    }
+    catch {
+        /* ignore */
+    }
+    try {
+        const g = typeof globalThis !== 'undefined' ? globalThis : null;
+        if (!g)
+            return;
+        if (!Array.isArray(g.__VMZ_COMPONENT_ERRORS__)) {
+            g.__VMZ_COMPONENT_ERRORS__ = [];
+        }
+        /** @type {unknown[]} */
+        const bag = g.__VMZ_COMPONENT_ERRORS__;
+        bag.push(detail);
+    }
+    catch {
+        /* ignore */
+    }
+}
+/**
+ * SSR serialize-tree error node (keeps document HTTP 200).
+ * @param {string} name
+ */
+export function serializeUnknownComponentNode(name) {
+    noteUnknownComponent(name, 'ssr');
+    /** @type {Record<string, string>} */
+    const attrs = {
+        'data-vmz-error': UNKNOWN_COMPONENT_ERROR,
+        'data-vmz-component': String(name || ''),
+    };
+    /** @type {any[]} */
+    const children = [];
+    if (isDevSurface()) {
+        children.push({
+            __kind: 'text',
+            value: `Unknown component <${name} />`,
+        });
+    }
+    return {
+        __kind: 'el',
+        tag: 'div',
+        attrs,
+        children,
+        appendChild(c) {
+            if (c != null)
+                this.children.push(c);
+        },
+    };
+}
+/**
+ * Live DOM error host (client create / schedule).
+ * @param {string} name
+ * @param {string} [via]
+ * @returns {HTMLElement}
+ */
+export function createUnknownComponentElement(name, via = 'client') {
+    noteUnknownComponent(name, via);
+    const host = document.createElement('div');
+    host.setAttribute('data-vmz-error', UNKNOWN_COMPONENT_ERROR);
+    host.setAttribute('data-vmz-component', String(name || ''));
+    if (isDevSurface()) {
+        host.textContent = `Unknown component <${name} />`;
+    }
+    return host;
+}
+/**
+ * Mark an existing island host as unknown (resume / EventEntry).
+ * @param {HTMLElement} el
+ * @param {string} name
+ * @param {string} [via]
+ */
+export function markUnknownComponentHost(el, name, via = 'resume') {
+    if (!el)
+        return;
+    noteUnknownComponent(name, via);
+    el.setAttribute('data-vmz-error', UNKNOWN_COMPONENT_ERROR);
+    el.setAttribute('data-vmz-component', String(name || ''));
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vmz/core",
-  "version": "0.1.20",
+  "version": "0.1.21",
   "type": "module",
   "description": "VMZ production runtime core — DOM / SSR / HTTP / WriteBarrier (no compiler)",
   "exports": {
@@ -58,12 +58,12 @@
     "linkedom": "^0.18.13"
   },
   "optionalDependencies": {
-    "@vmz/vmz-win32-x64": "0.1.20",
-    "@vmz/vmz-win32-arm64": "0.1.20",
-    "@vmz/vmz-darwin-x64": "0.1.20",
-    "@vmz/vmz-darwin-arm64": "0.1.20",
-    "@vmz/vmz-linux-x64": "0.1.20",
-    "@vmz/vmz-linux-arm64": "0.1.20"
+    "@vmz/vmz-win32-x64": "0.1.21",
+    "@vmz/vmz-win32-arm64": "0.1.21",
+    "@vmz/vmz-darwin-x64": "0.1.21",
+    "@vmz/vmz-darwin-arm64": "0.1.21",
+    "@vmz/vmz-linux-x64": "0.1.21",
+    "@vmz/vmz-linux-arm64": "0.1.21"
   },
   "publishConfig": {
     "access": "public"