@vmz/vmz 0.1.0 → 0.1.1

package/dist/locale-route-emit.js

@@ -7,34 +7,9 @@ import fs from 'node:fs';
 import path from 'node:path';
 import { checkLocales, localeHasErrors } from './locale-check.js';
 import { buildLocalePageMeta, buildLocaleRouteRealizationTable } from './locale-router.js';
+import { writePrettyJsonFile } from './pretty-json.js';
+import { listPublicPageUnits, unitBrowserPathPattern } from './route-path.js';
 export const LOCALE_ROUTE_REALIZATION_ARTIFACT_SCHEMA = 'vmz.locale.route_realization.v0';
-/**
- * @param {string} chunkId
- */
-function pathPatternFromChunk(chunkId) {
-    const rel = String(chunkId || '').replace(/^pages\//, '');
-    const parts = rel.split('/').filter(Boolean);
-    const segs = [];
-    for (let i = 0; i < parts.length; i++) {
-        const p = parts[i];
-        if (p === 'index' && i === parts.length - 1)
-            continue;
-        segs.push(p);
-    }
-    return segs.length ? `/${segs.join('/')}` : '/';
-}
-/**
- * Layouts are not public RouteNodes for locale realization / SEO.
- * @param {string} chunkId
- */
-function isPublicPageChunk(chunkId) {
-    const id = String(chunkId || '');
-    if (!id.startsWith('pages/'))
-        return false;
-    if (/(^|\/)Layout$/.test(id))
-        return false;
-    return true;
-}
 /**
  * @param {string} projectRoot
  * @param {string} distDir
@@ -59,10 +34,10 @@ export function emitLocaleRouteRealization(projectRoot, distDir, opts = {}) {
         };
     }
     const deployment = JSON.parse(fs.readFileSync(deploymentPath, 'utf8'));
-    const pages = (deployment.units || []).filter((u) => u.kind === 'page' && isPublicPageChunk(String(u.chunkId)));
+    const pages = listPublicPageUnits(deployment);
     const routes = pages.map((u) => ({
         routeId: String(u.chunkId),
-        path: pathPatternFromChunk(String(u.chunkId)),
+        path: unitBrowserPathPattern(u),
     }));
     const localeEntries = report.manifest?.locales || [];
     const locales = localeEntries.map((l) => l.id);
@@ -117,14 +92,14 @@ export function emitLocaleRouteRealization(projectRoot, distDir, opts = {}) {
     const vmzDir = path.join(distDir, '_vmz');
     fs.mkdirSync(vmzDir, { recursive: true });
     const outPath = path.join(vmzDir, 'locale-route-realization.json');
-    fs.writeFileSync(outPath, `${JSON.stringify(artifact, null, 2)}\n`, 'utf8');
+    writePrettyJsonFile(outPath, artifact);
     const manifestOut = path.join(vmzDir, 'locale-manifest.json');
-    fs.writeFileSync(manifestOut, `${JSON.stringify({
+    writePrettyJsonFile(manifestOut, {
         schema: 'vmz.locale.manifest.v0',
         defaultLocale,
         locales: artifact.locales,
         routing: artifact.routing,
-    }, null, 2)}\n`, 'utf8');
+    });
     return {
         ok: true,
         written: ['_vmz/locale-route-realization.json', '_vmz/locale-manifest.json'],

package/dist/mini-host.d.ts

@@ -0,0 +1,47 @@
+/**
+ * VMZ-owned deterministic Mini Host (TemplateSurface).
+ * Interprets MiniProgramArtifact tables — not vendor runtime, not WXML.
+ */
+/**
+ * Create a deterministic Mini Host over a deploy package + on-disk artifacts.
+ * @param {object} opts
+ * @param {MiniDeployPackage} opts.package
+ * @param {(artifactPath: string) => MiniPageArtifact} opts.loadArtifact
+ */
+export declare function createMiniHost(opts: any): {
+    package: any;
+    /** @param {string} [chunkId] */
+    mount(chunkId: any): {
+        chunkId: any;
+        data: {};
+    };
+    /** @param {string} handlerId */
+    dispatchEvent(handlerId: any): {
+        handlerId: any;
+        method: any;
+        patchPaths: any[];
+        data: {};
+    };
+    /** @param {string} routeId */
+    navigate(routeId: any): {
+        routeId: any;
+        chunkId: any;
+        data: {};
+    };
+    /** @param {string} method */
+    callServerStub(method: any): {
+        method: any;
+        scheme: string;
+        transport: string;
+        pending: boolean;
+        bodyShipped: boolean;
+    };
+    getState(): {
+        chunkId: any;
+        data: {};
+        appliedPatches: any[];
+        navigations: any[];
+        serverCalls: any[];
+        lifecycle: any[];
+    };
+};

package/dist/mini-host.js

@@ -0,0 +1,202 @@
+/**
+ * VMZ-owned deterministic Mini Host (TemplateSurface).
+ * Interprets MiniProgramArtifact tables — not vendor runtime, not WXML.
+ */
+/**
+ * @typedef {object} MiniDeployPackage
+ * @property {string} schema
+ * @property {string} [platformId]
+ * @property {object} [host]
+ * @property {object} [vendorTooling]
+ * @property {object} [constraints]
+ * @property {Array<{chunkId?: string, artifactPath?: string}>} [artifacts]
+ * @property {Array<{routeId?: string, chunkId?: string}>} [pages]
+ * @property {Array<{routeId?: string, fromChunkId?: string}>} [routeLinks]
+ * @property {Array<{method?: string, chunkId?: string}>} [serverCapabilities]
+ */
+/**
+ * @typedef {object} MiniPageArtifact
+ * @property {string} [template]
+ * @property {string} [logic]
+ * @property {string} [eventTable]
+ * @property {string} [dataPatchTable]
+ * @property {string} [manifest]
+ * @property {string} [style]
+ * @property {string} [platformId]
+ */
+/**
+ * @param {unknown} value
+ * @returns {any}
+ */
+function parseMaybeJson(value) {
+    if (value == null)
+        return null;
+    if (typeof value === 'object')
+        return value;
+    if (typeof value === 'string') {
+        try {
+            return JSON.parse(value);
+        }
+        catch {
+            return null;
+        }
+    }
+    return null;
+}
+/**
+ * @param {string} path
+ * @param {Record<string, unknown>} data
+ * @param {unknown} value
+ */
+function setDataPath(path, data, value) {
+    const parts = String(path).split('.').filter(Boolean);
+    if (!parts.length)
+        return;
+    /** @type {any} */
+    let cur = data;
+    for (let i = 0; i < parts.length - 1; i++) {
+        const key = parts[i];
+        if (cur[key] == null || typeof cur[key] !== 'object')
+            cur[key] = {};
+        cur = cur[key];
+    }
+    cur[parts[parts.length - 1]] = value;
+}
+/**
+ * Create a deterministic Mini Host over a deploy package + on-disk artifacts.
+ * @param {object} opts
+ * @param {MiniDeployPackage} opts.package
+ * @param {(artifactPath: string) => MiniPageArtifact} opts.loadArtifact
+ */
+export function createMiniHost(opts) {
+    const pkg = opts.package;
+    if (!pkg || pkg.schema !== 'vmz.mini.deploy_package.v0') {
+        throw new Error(`createMiniHost: expected vmz.mini.deploy_package.v0, got ${pkg?.schema}`);
+    }
+    if (pkg.constraints?.wxmlEmitter === true || pkg.constraints?.wxssEmitter === true) {
+        throw new Error('createMiniHost: package must not claim WXML/WXSS emitter');
+    }
+    if (pkg.constraints?.serverImplInMiniPackage === true) {
+        throw new Error('createMiniHost: server impl must not ship in mini package');
+    }
+    if (pkg.host?.schema !== 'vmz.mini.host.v0' || pkg.host?.kind !== 'deterministic-interpreter') {
+        throw new Error(`createMiniHost: invalid host descriptor ${JSON.stringify(pkg.host)}`);
+    }
+    if (pkg.vendorTooling?.role !== 'transport-conformance') {
+        throw new Error('createMiniHost: vendor tooling must stay transport-conformance');
+    }
+    if (pkg.vendorTooling?.invokedInCi !== false) {
+        throw new Error('createMiniHost: vendor tooling must not be invoked in CI gate');
+    }
+    /** @type {string | null} */
+    let currentChunkId = null;
+    /** @type {MiniPageArtifact | null} */
+    let currentArt = null;
+    /** @type {Record<string, unknown>} */
+    let data = {};
+    /** @type {string[]} */
+    const appliedPatches = [];
+    /** @type {Array<{method: string, scheme: string}>} */
+    const serverCalls = [];
+    /** @type {string[]} */
+    const navigations = [];
+    /** @type {string[]} */
+    const lifecycle = [];
+    function resolveArtifact(chunkId) {
+        const row = (pkg.artifacts || []).find((a) => a.chunkId === chunkId);
+        if (!row?.artifactPath) {
+            throw new Error(`createMiniHost: unknown chunk ${chunkId}`);
+        }
+        return opts.loadArtifact(row.artifactPath);
+    }
+    return {
+        package: pkg,
+        /** @param {string} [chunkId] */
+        mount(chunkId) {
+            const pages = pkg.pages || [];
+            const home = pages.find((p) => p.routeId === 'IndexPage' || String(p.chunkId || '').includes('pages/index')) || pages[0];
+            const pick = chunkId || home?.chunkId || pkg.artifacts?.[0]?.chunkId;
+            if (!pick)
+                throw new Error('createMiniHost.mount: no page chunk');
+            currentArt = resolveArtifact(pick);
+            currentChunkId = pick;
+            const logic = parseMaybeJson(currentArt.logic) || {};
+            data = structuredClone(logic.initialData || {});
+            lifecycle.push('mount');
+            return { chunkId: pick, data };
+        },
+        /** @param {string} handlerId */
+        dispatchEvent(handlerId) {
+            if (!currentArt)
+                throw new Error('createMiniHost.dispatchEvent: not mounted');
+            const events = parseMaybeJson(currentArt.eventTable);
+            if (!events || events.schema !== 'vmz.mini.event_table.v0') {
+                throw new Error('createMiniHost: missing event_table');
+            }
+            const handler = (events.handlers || []).find((h) => h.handlerId === handlerId);
+            if (!handler)
+                throw new Error(`createMiniHost: unknown handler ${handlerId}`);
+            const stamp = `patched:${handler.method || handlerId}`;
+            for (const p of handler.patchPaths || []) {
+                setDataPath(p, data, stamp);
+                appliedPatches.push(p);
+            }
+            lifecycle.push(`event:${handlerId}`);
+            return {
+                handlerId,
+                method: handler.method,
+                patchPaths: [...(handler.patchPaths || [])],
+                data,
+            };
+        },
+        /** @param {string} routeId */
+        navigate(routeId) {
+            const pages = pkg.pages || [];
+            const hit = pages.find((p) => p.routeId === routeId) || pages.find((p) => String(p.chunkId || '').includes(routeId));
+            if (!hit?.chunkId) {
+                throw new Error(`createMiniHost.navigate: unknown RouteId ${routeId}`);
+            }
+            const links = pkg.routeLinks || [];
+            const linked = !links.length || links.some((l) => l.routeId === routeId) || String(currentChunkId || '') === hit.chunkId;
+            if (!linked && currentChunkId) {
+                // Allow workspace-level pages even without a Link from current page.
+            }
+            currentArt = resolveArtifact(hit.chunkId);
+            currentChunkId = hit.chunkId;
+            const logic = parseMaybeJson(currentArt.logic) || {};
+            data = structuredClone(logic.initialData || {});
+            navigations.push(routeId);
+            lifecycle.push(`navigate:${routeId}`);
+            return { routeId, chunkId: hit.chunkId, data };
+        },
+        /** @param {string} method */
+        callServerStub(method) {
+            const caps = pkg.serverCapabilities || [];
+            const hit = caps.find((c) => c.method === method);
+            if (!hit)
+                throw new Error(`createMiniHost.callServerStub: unknown ${method}`);
+            if (pkg.constraints?.serverImplInMiniPackage !== false) {
+                throw new Error('createMiniHost: server impl leaked into mini package');
+            }
+            serverCalls.push({ method, scheme: '#server' });
+            lifecycle.push(`server-stub:${method}`);
+            return {
+                method,
+                scheme: '#server',
+                transport: 'mini-request',
+                pending: true,
+                bodyShipped: false,
+            };
+        },
+        getState() {
+            return {
+                chunkId: currentChunkId,
+                data: structuredClone(data),
+                appliedPatches: [...appliedPatches],
+                navigations: [...navigations],
+                serverCalls: [...serverCalls],
+                lifecycle: [...lifecycle],
+            };
+        },
+    };
+}

package/dist/native-addon.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Load the N-API addon or throw (production printers must not fall back to TS).
+ * @returns {any}
+ */
+export declare function requireNativeAddon(): any;
+/**
+ * @returns {any | null}
+ */
+export declare function tryLoadNativeAddon(): any;

package/dist/native-addon.js

@@ -0,0 +1,84 @@
+// @ts-nocheck
+/**
+ * Load the N-API `.node` addon without importing `index.js`
+ * (avoids cycles with modules re-exported from the package entry).
+ */
+import fs 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} */
+let cached;
+/**
+ * Load the N-API addon or throw (production printers must not fall back to TS).
+ * @returns {any}
+ */
+export function requireNativeAddon() {
+    const native = tryLoadNativeAddon();
+    if (!native) {
+        throw new Error('vmz native addon missing — run `pnpm napi:build` (CodeGenerators live in vmz-generator via N-API)');
+    }
+    return native;
+}
+/**
+ * @returns {any | null}
+ */
+export function tryLoadNativeAddon() {
+    if (cached !== undefined)
+        return cached;
+    try {
+        const envPath = (typeof process.env.VMZ_NATIVE_NODE === 'string' && process.env.VMZ_NATIVE_NODE.trim()) || '';
+        if (envPath) {
+            cached = require(path.resolve(envPath));
+            return cached;
+        }
+        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 pkgRoot = path.join(path.dirname(fileURLToPath(import.meta.url)), '..');
+        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 */
+        }
+        candidates.push(path.join(pkgRoot, 'node_modules', name, `vmz.${triple}.node`), path.join(pkgRoot, 'node_modules', name, 'vmz.node'));
+        for (const p of candidates) {
+            if (fs.existsSync(p)) {
+                cached = require(p);
+                return cached;
+            }
+        }
+        cached = null;
+    }
+    catch {
+        cached = null;
+    }
+    return cached;
+}

package/dist/pack-client-packages.d.ts

@@ -0,0 +1,25 @@
+/**
+ * Browser-safe client package lowering (Pack stage thin slice).
+ *
+ * Bare npm/workspace imports are legal on the author surface (01/04).
+ * Browser ESM cannot resolve them. Pack materializes reachable package
+ * modules under `dist/vendor/<pkg>/…` and rewrites importers to relative paths.
+ *
+ * Not full oxc chunk-split/minify (`oxc-pending` remains for release minify).
+ */
+/**
+ * @param {string} outDir
+ * @param {{ projectRoot?: string | null }} [opts]
+ * @returns {{ rewrittenFiles: number, vendoredModules: string[], bareSpecs: string[] }}
+ */
+export declare function packClientBareImports(outDir: any, opts?: {}): {
+    rewrittenFiles: number;
+    vendoredModules: string[];
+    bareSpecs: any[];
+    unresolvedBareSpecs: any[];
+    skippedVmzExports: any[];
+    remainingBareSpecs: any[];
+};
+/** @param {string} js */
+export declare function collectBareSpecs(js: any): unknown[];
+export declare function rewriteRelativeTsSpecs(js: any): any;