@vmz/test 0.1.9 → 0.1.11

package/dist/browser-serve.js

@@ -2,9 +2,56 @@
  * Browser Host U2 — real VMZ serve-host lifecycle + RouteId → path resolution.
  */
 import { spawn } from 'node:child_process';
+import { createRequire } from 'node:module';
 import fs from 'node:fs';
 import net from 'node:net';
 import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+const require = createRequire(import.meta.url);
+/** Same discovery as `vmz serve` / conformance `serveHostChildEnv`. */
+function resolveNativeNodePath() {
+    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 pkgJson = require.resolve(`${name}/package.json`);
+        const dir = path.dirname(pkgJson);
+        candidates.push(path.join(dir, `vmz.${triple}.node`), path.join(dir, 'vmz.node'));
+    }
+    catch {
+        /* optional dep missing */
+    }
+    const here = path.dirname(fileURLToPath(import.meta.url));
+    candidates.push(path.join(here, '..', '..', '..', 'runtimes', `vmz-${short}`, `vmz.${triple}.node`), path.join(here, '..', '..', '..', 'runtimes', `vmz-${short}`, 'vmz.node'));
+    for (const p of candidates) {
+        if (fs.existsSync(p))
+            return path.resolve(p);
+    }
+    throw new Error(`serve host: vmz native addon not found for ${name}. Run pnpm napi:build\nLooked in:\n${candidates.map((c) => `  - ${c}`).join('\n')}`);
+}
 function freePort() {
     return new Promise((resolve, reject) => {
         const s = net.createServer();
@@ -99,7 +146,13 @@ export async function startServeHost(outDir) {
     const port = await freePort();
     const child = spawn(process.execPath, [hostJs], {
         cwd: outDir,
-        env: { ...process.env, VMZ_DIST: outDir, VMZ_HOST: '127.0.0.1', VMZ_PORT: String(port) },
+        env: {
+            ...process.env,
+            VMZ_DIST: outDir,
+            VMZ_HOST: '127.0.0.1',
+            VMZ_PORT: String(port),
+            VMZ_NATIVE_NODE: resolveNativeNodePath(),
+        },
         stdio: ['ignore', 'pipe', 'pipe'],
     });
     const kill = () => {

package/dist/browser.js

@@ -16,6 +16,7 @@ import http from 'node:http';
 import net from 'node:net';
 import os from 'node:os';
 import path from 'node:path';
+import { resolveComponentEntries } from '@vmz/core/component-registry';
 import { resolveChunkArtifacts } from './compile.js';
 import { createArtifactsDir, writeFailureEvidence, writeTimingOnly } from './browser-evidence.js';
 import { isServeHostManifest, resolveRoutePath, startServeHost } from './browser-serve.js';
@@ -304,8 +305,13 @@ export async function runBrowserManifest(manifest, ctx) {
         page = await browser.newPage();
         page.setDefaultTimeout(15000);
         page.on('console', (msg) => {
-            if (msg.type() === 'error')
-                consoleErrors.push(msg.text());
+            if (msg.type() !== 'error')
+                return;
+            const text = msg.text();
+            // Chrome also logs network 404s here; requestfailed gate carries URL + resource-type filters.
+            if (/Failed to load resource:.+404/i.test(text))
+                return;
+            consoleErrors.push(text);
         });
         page.on('pageerror', (err) => {
             consoleErrors.push(err instanceof Error ? err.message : String(err));
@@ -327,13 +333,18 @@ export async function runBrowserManifest(manifest, ctx) {
         }
         else {
             await page.goto(`${origin}/__vmz/harness`, { waitUntil: 'domcontentloaded' });
-            const components = program.components && typeof program.components === 'object' ? program.components : {};
+            const explicitComponents = program.components && typeof program.components === 'object' ? program.components : undefined;
+            const registryStrict = process.env.CI === 'true' || process.env.GITHUB_ACTIONS === 'true';
+            const registryEntries = await resolveComponentEntries(ctx.outDir, explicitComponents, {
+                strict: registryStrict,
+                closureRoots: [chunkId.replace(/\\/g, '/')],
+            });
             const boot = await page.evaluate(async (cfg) => {
                 const dom = await import(/* @vite-ignore */ `${cfg.origin}/vmz-dom.js`);
                 const Comp = (await import(/* @vite-ignore */ `${cfg.origin}/${cfg.chunkPath}.client.js`)).default;
                 const map = {};
-                for (const [name, chunk] of Object.entries(cfg.components)) {
-                    map[name] = (await import(/* @vite-ignore */ `${cfg.origin}/${chunk}.client.js`)).default;
+                for (const { name, entry } of cfg.registry) {
+                    map[name] = (await import(/* @vite-ignore */ `${cfg.origin}/${entry}`)).default;
                 }
                 if (Object.keys(map).length && typeof dom.registerComponents === 'function') {
                     dom.registerComponents(map);
@@ -357,7 +368,7 @@ export async function runBrowserManifest(manifest, ctx) {
             }, {
                 origin,
                 chunkPath: chunkId.replace(/\\/g, '/'),
-                components,
+                registry: registryEntries,
             });
             if (!boot?.ok) {
                 fail(`browser boot: ${boot?.error || 'unknown'}`);

package/dist/logic.js

@@ -5,6 +5,7 @@ import fs from 'node:fs';
 import path from 'node:path';
 import { pathToFileURL } from 'node:url';
 import { createRequire } from 'node:module';
+import { createRenderHost } from '@vmz/core/render-host';
 import { resolveChunkArtifacts } from './compile.js';
 const require = createRequire(import.meta.url);
 function loadLinkedom() {
@@ -41,16 +42,13 @@ export async function createLogicHost(opts) {
     if (!Component?.__vmzDirect || typeof Component.__vmzCreate !== 'function') {
         throw new Error('logic host requires Direct __vmzCreate (rebuild with current compiler)');
     }
-    if (opts.components && typeof dom.registerComponents === 'function') {
-        const map = {};
-        for (const [name, chunk] of Object.entries(opts.components)) {
-            const cArts = resolveChunkArtifacts(opts.outDir, chunk);
-            if (!cArts.clientPath)
-                throw new Error(`registerComponents: missing ${chunk}.client.js`);
-            map[name] = (await import(pathToFileURL(cArts.clientPath).href)).default;
-        }
-        dom.registerComponents(map);
-    }
+    const strict = process.env.CI === 'true' || process.env.GITHUB_ACTIONS === 'true';
+    const renderHost = await createRenderHost(opts.outDir, {
+        strictDeployment: strict,
+        preload: 'none',
+        explicit: opts.components,
+    });
+    await renderHost.ensureComponents([opts.chunkId.replace(/\\/g, '/')]);
     if (typeof dom.__vmzPrecisionEnable === 'function') {
         dom.__vmzPrecisionEnable(true);
     }

package/dist/resume.js

@@ -2,8 +2,8 @@
  * Resume host for `vmz test --mode resume` (/ first slice).
  * SSR shell → resume adopt → event patch; onMount must not run.
  */
-import path from 'node:path';
 import { pathToFileURL } from 'node:url';
+import { createRenderHost } from '@vmz/core/render-host';
 import { resolveChunkArtifacts } from './compile.js';
 import { installHeadlessDocument } from './logic.js';
 export async function runResumeManifest(manifest, ctx) {
@@ -25,29 +25,24 @@ export async function runResumeManifest(manifest, ctx) {
     }
     installHeadlessDocument();
     globalThis.requestIdleCallback = (cb) => setTimeout(() => cb({ didTimeout: false, timeRemaining: () => 1 }), 0);
-    let dom;
+    const components = program.components && typeof program.components === 'object' ? program.components : undefined;
+    let renderHost;
     let Page;
+    let loaded = {};
     try {
-        dom = await import(pathToFileURL(path.join(ctx.outDir, 'vmz-dom.js')).href);
+        renderHost = await createRenderHost(ctx.outDir, {
+            strictDeployment: process.env.CI === 'true' || process.env.GITHUB_ACTIONS === 'true',
+            preload: 'none',
+            explicit: components,
+        });
+        loaded = await renderHost.ensureComponents([chunkId.replace(/\\/g, '/')]);
         Page = (await import(pathToFileURL(arts.clientPath).href)).default;
     }
     catch (e) {
         fail(`import dist: ${e instanceof Error ? e.message : String(e)}`);
         return { status: 'error', diagnostics, planId: null, programId };
     }
-    const components = program.components && typeof program.components === 'object' ? program.components : undefined;
-    const loaded = {};
-    if (components) {
-        for (const [name, chunk] of Object.entries(components)) {
-            const cArts = resolveChunkArtifacts(ctx.outDir, chunk);
-            if (!cArts.clientPath) {
-                fail(`missing component ${chunk}`);
-                continue;
-            }
-            loaded[name] = (await import(pathToFileURL(cArts.clientPath).href)).default;
-        }
-        dom.registerComponents(loaded);
-    }
+    const dom = renderHost.dom;
     let html = '';
     let island = null;
     let inst = null;

package/dist/ssr.js

@@ -2,8 +2,8 @@
  * SSR / hydrate / stream host for `vmz test --mode ssr` .
  * Same Direct schedule as production via linkedom + renderToString / renderToStream / hydrate.
  */
-import path from 'node:path';
 import { pathToFileURL } from 'node:url';
+import { createRenderHost } from '@vmz/core/render-host';
 import { resolveChunkArtifacts } from './compile.js';
 import { installHeadlessDocument } from './logic.js';
 export async function runSsrManifest(manifest, ctx) {
@@ -24,29 +24,23 @@ export async function runSsrManifest(manifest, ctx) {
         return { status: 'failed', diagnostics, planId: null, programId };
     }
     installHeadlessDocument();
-    let dom;
+    const components = program.components && typeof program.components === 'object' ? program.components : undefined;
+    let renderHost;
     let Component;
     try {
-        dom = await import(pathToFileURL(path.join(ctx.outDir, 'vmz-dom.js')).href);
+        renderHost = await createRenderHost(ctx.outDir, {
+            strictDeployment: process.env.CI === 'true' || process.env.GITHUB_ACTIONS === 'true',
+            preload: 'none',
+            explicit: components,
+        });
+        await renderHost.ensureComponents([chunkId.replace(/\\/g, '/')]);
         Component = (await import(pathToFileURL(arts.clientPath).href)).default;
     }
     catch (e) {
         fail(`import dist: ${e instanceof Error ? e.message : String(e)}`);
         return { status: 'error', diagnostics, planId: null, programId };
     }
-    const components = program.components && typeof program.components === 'object' ? program.components : undefined;
-    if (components) {
-        const map = {};
-        for (const [name, chunk] of Object.entries(components)) {
-            const cArts = resolveChunkArtifacts(ctx.outDir, chunk);
-            if (!cArts.clientPath) {
-                fail(`missing component ${chunk}`);
-                continue;
-            }
-            map[name] = (await import(pathToFileURL(cArts.clientPath).href)).default;
-        }
-        dom.registerComponents(map);
-    }
+    const dom = renderHost.dom;
     let html = '';
     let streamChunks = [];
     let streamAborted = false;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vmz/test",
-  "version": "0.1.9",
+  "version": "0.1.11",
   "type": "module",
   "description": "VMZ native test protocol + Compile/Logic/Browser/SSR/Resume/Deployment hosts",
   "main": "./dist/index.js",
@@ -27,8 +27,8 @@
     "build": "tsc -p tsconfig.json"
   },
   "dependencies": {
-    "@vmz/core": "0.1.9",
-    "@vmz/protocol": "0.1.9",
+    "@vmz/core": "0.1.11",
+    "@vmz/protocol": "0.1.11",
     "linkedom": "^0.18.13",
     "puppeteer-core": "^24.11.2"
   },