@vmz/core 0.1.12 → 0.1.14

package/dist/deployment-registry.d.ts

@@ -1,6 +1,6 @@
 /**
  * Deployment graph → component registry bootstrap (shared by all SSR/DOM hosts).
- * Replaces ad-hoc registerComponents calls with an explicit preload contract.
+ * Parse/validate and graph queries delegate to Rust vmz-artifacts via N-API.
  */
 export declare const DEPLOYMENT_SCHEMA = "vmz.deployment.v0";
 /**
@@ -13,7 +13,7 @@ export declare function readDeploymentDocument(distDir: any, opts?: {}): any;
  * @param {any} deployment
  * @returns {Array<{ chunkId: string, name: string, entry: string, source: string }>}
  */
-export declare function componentEntriesFromDeployment(deployment: any): any[];
+export declare function componentEntriesFromDeployment(deployment: any): any;
 /**
  * @param {any} deployment
  * @param {string[]} rootChunkIds

package/dist/deployment-registry.js

@@ -1,13 +1,22 @@
 // @ts-nocheck
 /**
  * Deployment graph → component registry bootstrap (shared by all SSR/DOM hosts).
- * Replaces ad-hoc registerComponents calls with an explicit preload contract.
+ * Parse/validate and graph queries delegate to Rust vmz-artifacts via N-API.
  */
 import fs from 'node:fs';
 import { readdir } from 'node:fs/promises';
 import path from 'node:path';
 import { pathToFileURL } from 'node:url';
+import { requireNativeFn } from './native-addon.js';
 export const DEPLOYMENT_SCHEMA = 'vmz.deployment.v0';
+/**
+ * @param {string} jsonText
+ * @returns {any}
+ */
+function parseDeploymentJson(jsonText) {
+    requireNativeFn('deploymentValidate')(jsonText);
+    return JSON.parse(jsonText);
+}
 /**
  * @param {string} distDir
  * @param {{ strict?: boolean }} [opts]
@@ -31,45 +40,22 @@ export function readDeploymentDocument(distDir, opts = {}) {
             throw new Error(`vmz: cannot read vmz-deployment.json: ${e instanceof Error ? e.message : e}`);
         return null;
     }
-    let doc;
     try {
-        doc = JSON.parse(raw);
+        return parseDeploymentJson(raw);
     }
     catch (e) {
         if (strict)
             throw new Error(`vmz: invalid vmz-deployment.json: ${e instanceof Error ? e.message : e}`);
         return null;
     }
-    if (doc.schema !== DEPLOYMENT_SCHEMA) {
-        if (strict)
-            throw new Error(`vmz: unsupported deployment schema ${doc.schema}`);
-        return null;
-    }
-    return doc;
 }
 /**
  * @param {any} deployment
  * @returns {Array<{ chunkId: string, name: string, entry: string, source: string }>}
  */
 export function componentEntriesFromDeployment(deployment) {
-    /** @type {Array<{ chunkId: string, name: string, entry: string, source: string }>} */
-    const out = [];
-    for (const unit of deployment.units || []) {
-        if (unit?.kind !== 'component')
-            continue;
-        const chunkId = String(unit.chunkId || '').replace(/\\/g, '/');
-        const name = chunkId.split('/').pop();
-        if (!name)
-            continue;
-        const entry = String(unit.clientEntry || `${chunkId}.client.js`).replace(/\\/g, '/');
-        out.push({
-            chunkId,
-            name,
-            entry,
-            source: String(unit.source || ''),
-        });
-    }
-    return out.sort((a, b) => a.chunkId.localeCompare(b.chunkId));
+    const json = JSON.stringify(deployment);
+    return requireNativeFn('deploymentComponentEntries')(json);
 }
 /**
  * @param {any} deployment
@@ -77,30 +63,9 @@ export function componentEntriesFromDeployment(deployment) {
  * @returns {Set<string>}
  */
 export function collectDependsOnClosure(deployment, rootChunkIds) {
-    /** @type {Map<string, any>} */
-    const byId = new Map();
-    for (const unit of deployment.units || []) {
-        byId.set(String(unit.chunkId || '').replace(/\\/g, '/'), unit);
-    }
-    /** @type {Set<string>} */
-    const out = new Set();
-    /** @type {string[]} */
-    const stack = rootChunkIds.map((id) => String(id).replace(/\\/g, '/')).filter(Boolean);
-    while (stack.length) {
-        const id = stack.pop();
-        if (!id || out.has(id))
-            continue;
-        out.add(id);
-        const unit = byId.get(id);
-        if (!unit)
-            continue;
-        for (const dep of unit.dependsOn || []) {
-            const d = String(dep).replace(/\\/g, '/');
-            if (!out.has(d))
-                stack.push(d);
-        }
-    }
-    return out;
+    const json = JSON.stringify(deployment);
+    const ids = requireNativeFn('deploymentDependsOnClosure')(json, rootChunkIds);
+    return new Set(ids);
 }
 /**
  * Resolve tag conflicts; strict mode throws, dev mode warns and keeps last chunkId.

package/dist/dom-core.js

@@ -498,6 +498,14 @@ export const directApi = {
             if (typeof propName !== 'string' || !propName || propName.startsWith('#'))
                 return;
             child[propName] = raw;
+            if (typeof child.__vmzOnParentProp === 'function') {
+                try {
+                    child.__vmzOnParentProp(propName, raw);
+                }
+                catch (err) {
+                    console.error('vmz:dom __vmzOnParentProp', err);
+                }
+            }
             scheduleRefresh(child, { type: 'replace', root: propName });
         });
     },

package/dist/native-addon.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Discover and load the vmz N-API addon (same contract as `@vmz/vmz` loadNative).
+ */
+/**
+ * @returns {any}
+ */
+export declare function loadNativeAddon(): any;
+/**
+ * @param {string} fnName
+ * @returns {any}
+ */
+export declare function requireNativeFn(fnName: any): any;

package/dist/native-addon.js

@@ -0,0 +1,116 @@
+// @ts-nocheck
+/**
+ * Discover and load the vmz N-API addon (same contract as `@vmz/vmz` loadNative).
+ */
+import { existsSync } from 'node:fs';
+import { createRequire } from 'node:module';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+const require = createRequire(import.meta.url);
+/** @type {any | null | undefined} */
+let _nativeAddon;
+/**
+ * @returns {string}
+ */
+function platformTriple() {
+    const { platform, arch } = process;
+    if (platform === 'win32' && arch === 'x64')
+        return 'win32-x64-msvc';
+    if (platform === 'win32' && arch === 'arm64')
+        return 'win32-arm64-msvc';
+    if (platform === 'darwin' && arch === 'arm64')
+        return 'darwin-arm64';
+    if (platform === 'darwin' && arch === 'x64')
+        return 'darwin-x64';
+    if (platform === 'linux' && arch === 'x64')
+        return 'linux-x64-gnu';
+    if (platform === 'linux' && arch === 'arm64')
+        return 'linux-arm64-gnu';
+    return `${platform}-${arch}`;
+}
+/**
+ * @param {string} triple
+ * @returns {string}
+ */
+function platformShort(triple) {
+    if (triple === 'win32-x64-msvc')
+        return 'win32-x64';
+    if (triple === 'win32-arm64-msvc')
+        return 'win32-arm64';
+    if (triple === 'linux-x64-gnu')
+        return 'linux-x64';
+    if (triple === 'linux-arm64-gnu')
+        return 'linux-arm64';
+    return triple;
+}
+/**
+ * @returns {string[]}
+ */
+function nativeCandidatePaths() {
+    const triple = platformTriple();
+    const short = platformShort(triple);
+    const name = `@vmz/vmz-${short}`;
+    /** @type {string[]} */
+    const candidates = [];
+    try {
+        const resolved = require.resolve(`${name}/package.json`);
+        const dir = path.dirname(resolved);
+        candidates.push(path.join(dir, `vmz.${triple}.node`), path.join(dir, 'vmz.node'));
+    }
+    catch {
+        /* optional dep not installed */
+    }
+    let dir = path.dirname(fileURLToPath(import.meta.url));
+    for (let depth = 0; depth < 12; depth++) {
+        candidates.push(path.join(dir, 'node_modules', name, `vmz.${triple}.node`), path.join(dir, 'node_modules', name, 'vmz.node'));
+        const parent = path.dirname(dir);
+        if (parent === dir)
+            break;
+        dir = parent;
+    }
+    return candidates;
+}
+/**
+ * @returns {any}
+ */
+export function loadNativeAddon() {
+    if (_nativeAddon !== undefined) {
+        if (!_nativeAddon) {
+            throw new Error('vmz native addon missing — run `pnpm napi:build`');
+        }
+        return _nativeAddon;
+    }
+    try {
+        const envPath = (typeof process.env.VMZ_NATIVE_NODE === 'string' && process.env.VMZ_NATIVE_NODE.trim()) || '';
+        if (envPath) {
+            _nativeAddon = require(path.resolve(envPath));
+            return _nativeAddon;
+        }
+        for (const p of nativeCandidatePaths()) {
+            if (existsSync(p)) {
+                _nativeAddon = require(p);
+                return _nativeAddon;
+            }
+        }
+        _nativeAddon = null;
+    }
+    catch {
+        _nativeAddon = null;
+    }
+    if (!_nativeAddon) {
+        throw new Error('vmz native addon missing — run `pnpm napi:build`');
+    }
+    return _nativeAddon;
+}
+/**
+ * @param {string} fnName
+ * @returns {any}
+ */
+export function requireNativeFn(fnName) {
+    const native = loadNativeAddon();
+    const fn = native[fnName];
+    if (typeof fn !== 'function') {
+        throw new Error(`vmz native addon missing ${fnName} — run \`pnpm napi:build\``);
+    }
+    return fn;
+}

package/dist/serve-host.mjs

@@ -24,10 +24,70 @@ import path from 'node:path';
 import { fileURLToPath, pathToFileURL } from 'node:url';
 import { createRenderHost } from './render-host.js';
 import { listClientComponents } from './list-client-components.js';
+import { loadNativeAddon } from './native-addon.js';
 import { resolveRouteLayoutChain } from './route-layout-chain.js';
 import { handleNodeRequest, setRoutes, setServerModuleResolver } from './vmz-runtime.js';
 const require = createRequire(import.meta.url);
 const distDir = process.env.VMZ_DIST ? path.resolve(process.env.VMZ_DIST) : path.dirname(fileURLToPath(import.meta.url));
+/** App project root for bare import / JSON resolve (dev SSR ≡ build node_modules). */
+function projectRootForResolve() {
+    const fromEnv = typeof process.env.VMZ_PROJECT_ROOT === 'string' ? process.env.VMZ_PROJECT_ROOT.trim() : '';
+    if (fromEnv)
+        return path.resolve(fromEnv);
+    return process.cwd();
+}
+/** @type {ReturnType<typeof createRequire> | null} */
+let appPackageRequire = null;
+function appPackageRequireResolve() {
+    if (!appPackageRequire) {
+        const root = projectRootForResolve();
+        const pkg = path.join(root, 'package.json');
+        appPackageRequire = existsSync(pkg) ? createRequire(pkg) : require;
+    }
+    return appPackageRequire;
+}
+/**
+ * Dev/prod serve-host: resolve workspace peers + JSON imports from the app package root.
+ * Dist-relative ESM cannot see app `node_modules` without this hook.
+ */
+function installAppModuleResolveHooks() {
+    registerHooks({
+        resolve(specifier, context, nextResolve) {
+            if (!specifier ||
+                specifier.startsWith('.') ||
+                specifier.startsWith('node:') ||
+                specifier.startsWith('file:') ||
+                specifier.startsWith('#')) {
+                return nextResolve(specifier, context);
+            }
+            try {
+                const resolved = appPackageRequireResolve().resolve(specifier);
+                return { url: pathToFileURL(resolved).href, shortCircuit: true };
+            }
+            catch {
+                return nextResolve(specifier, context);
+            }
+        },
+        load(url, context, nextLoad) {
+            const pathOnly = url.split('?')[0].split('#')[0];
+            if (!pathOnly.endsWith('.json'))
+                return nextLoad(url, context);
+            try {
+                const filePath = fileURLToPath(pathOnly);
+                const raw = readFileSync(filePath, 'utf8');
+                return {
+                    format: 'module',
+                    shortCircuit: true,
+                    source: `export default ${raw}`,
+                };
+            }
+            catch {
+                return nextLoad(url, context);
+            }
+        },
+    });
+}
+installAppModuleResolveHooks();
 const host = process.env.VMZ_HOST || '127.0.0.1';
 const port = Number(process.env.VMZ_PORT || process.env.PORT || 5173);
 const isDev = process.env.VMZ_DEV === '1' || process.env.VMZ_DEV === 'true';
@@ -102,12 +162,6 @@ let shuttingDown = false;
 let ready = false;
 /** @type {{ message: string, stack?: string, at: number } | null} */
 let lastDevError = null;
-/**
- * Native CodeGenerators handle — must be declared before top-level `await softReload()`
- * (TDZ: requireNativeGenerator may run during that await).
- * @type {any}
- */
-let _nativeGen;
 setServerModuleResolver((moduleId) => {
     const rel = moduleId.replace(/^#server\//, '') + '.js';
     return bustUrl(pathToFileURL(path.join(distDir, '#server', rel)).href);
@@ -341,7 +395,7 @@ function normalizeActionResult(acted) {
  * @param {string} marker
  */
 async function* emitAccessShell(marker) {
-    const native = requireNativeGenerator();
+    const native = loadNativeAddon();
     if (typeof native.generateHtmlShell !== 'function') {
         throw new Error('vmz native addon missing generateHtmlShell — rebuild with `pnpm napi:build`');
     }
@@ -547,7 +601,7 @@ async function* emitPageHtml(Page, chunkId, eventOnlyShell, props = {}, opts = {
     }
     if (signal?.aborted)
         return;
-    const native = requireNativeGenerator();
+    const native = loadNativeAddon();
     if (typeof native.generatePageShell !== 'function') {
         throw new Error('vmz native addon missing generatePageShell — rebuild with `pnpm napi:build`');
     }
@@ -907,7 +961,7 @@ async function* emitDevErrorHtml(err) {
     };
   })();
   </script>`;
-    const native = requireNativeGenerator();
+    const native = loadNativeAddon();
     if (typeof native.generateHtmlShell !== 'function') {
         throw new Error('vmz native addon missing generateHtmlShell — rebuild with `pnpm napi:build`');
     }
@@ -1323,7 +1377,7 @@ async function runRouteGate(pathname, chunkId) {
  */
 function emitEntryClient(eager, lazy, token) {
     const q = `?t=${token}`;
-    const native = requireNativeGenerator();
+    const native = loadNativeAddon();
     if (typeof native.generateServeEntryClient !== 'function') {
         throw new Error('vmz native addon missing generateServeEntryClient — rebuild with `pnpm napi:build`');
     }
@@ -1336,81 +1390,12 @@ function emitEntryClient(eager, lazy, token) {
  */
 function emitEntryEvent(token) {
     const q = `?t=${token}`;
-    const native = requireNativeGenerator();
+    const native = loadNativeAddon();
     if (typeof native.generateServeEntryEvent !== 'function') {
         throw new Error('vmz native addon missing generateServeEntryEvent — rebuild with `pnpm napi:build`');
     }
     return native.generateServeEntryEvent(q);
 }
-/**
- * Load vmz N-API CodeGenerators (same discovery as `@vmz/vmz` native-addon).
- * @returns {any}
- */
-function requireNativeGenerator() {
-    if (_nativeGen !== undefined) {
-        if (!_nativeGen) {
-            throw new Error('vmz native addon missing — run `pnpm napi:build` (serve entry printers live in vmz-generator via N-API)');
-        }
-        return _nativeGen;
-    }
-    try {
-        const envPath = (typeof process.env.VMZ_NATIVE_NODE === 'string' && process.env.VMZ_NATIVE_NODE.trim()) || '';
-        if (envPath) {
-            _nativeGen = require(path.resolve(envPath));
-            return _nativeGen;
-        }
-        const { platform, arch } = process;
-        let triple = `${platform}-${arch}`;
-        if (platform === 'win32' && arch === 'x64')
-            triple = 'win32-x64-msvc';
-        else if (platform === 'win32' && arch === 'arm64')
-            triple = 'win32-arm64-msvc';
-        else if (platform === 'darwin' && arch === 'arm64')
-            triple = 'darwin-arm64';
-        else if (platform === 'darwin' && arch === 'x64')
-            triple = 'darwin-x64';
-        else if (platform === 'linux' && arch === 'x64')
-            triple = 'linux-x64-gnu';
-        else if (platform === 'linux' && arch === 'arm64')
-            triple = 'linux-arm64-gnu';
-        const short = triple === 'win32-x64-msvc'
-            ? 'win32-x64'
-            : triple === 'win32-arm64-msvc'
-                ? 'win32-arm64'
-                : triple === 'linux-x64-gnu'
-                    ? 'linux-x64'
-                    : triple === 'linux-arm64-gnu'
-                        ? 'linux-arm64'
-                        : triple;
-        const name = `@vmz/vmz-${short}`;
-        /** @type {string[]} */
-        const candidates = [];
-        try {
-            const resolved = require.resolve(`${name}/package.json`);
-            const dir = path.dirname(resolved);
-            candidates.push(path.join(dir, `vmz.${triple}.node`), path.join(dir, 'vmz.node'));
-        }
-        catch {
-            /* optional */
-        }
-        const here = path.dirname(fileURLToPath(import.meta.url));
-        candidates.push(path.join(here, 'node_modules', name, `vmz.${triple}.node`), path.join(here, 'node_modules', name, 'vmz.node'), path.join(here, '..', 'node_modules', name, `vmz.${triple}.node`), path.join(here, '..', 'node_modules', name, 'vmz.node'));
-        for (const p of candidates) {
-            if (existsSync(p)) {
-                _nativeGen = require(p);
-                return _nativeGen;
-            }
-        }
-        _nativeGen = null;
-    }
-    catch {
-        _nativeGen = null;
-    }
-    if (!_nativeGen) {
-        throw new Error('vmz native addon missing — run `pnpm napi:build` (serve entry printers live in vmz-generator via N-API)');
-    }
-    return _nativeGen;
-}
 /**
  * Style Theme cookie / localStorage key (host contract, not a second theme API).
  */

package/package.json

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