@vmz/vmz 0.0.1 → 0.0.3

package/dist/resolve.js

@@ -0,0 +1,55 @@
+// @ts-nocheck
+/**
+ * Shared project path resolution for the Node CLI host .
+ */
+import { existsSync, readFileSync } from 'node:fs';
+import path from 'node:path';
+/**
+ * @param {string} startDir
+ * @returns {string | null}
+ */
+export function findPackageJson(startDir) {
+    let dir = path.resolve(startDir);
+    for (;;) {
+        const candidate = path.join(dir, 'package.json');
+        if (existsSync(candidate))
+            return candidate;
+        const parent = path.dirname(dir);
+        if (parent === dir)
+            return null;
+        dir = parent;
+    }
+}
+/**
+ * Resolve project root + out dir from CLI args / cwd.
+ * Prefers an explicit path; otherwise walks up for package.json with `src/`.
+ *
+ * @param {{ cwd?: string, path?: string, outDir?: string }} opts
+ */
+export function resolveWorkspaceDirs(opts = {}) {
+    const cwd = opts.cwd ?? process.cwd();
+    const input = path.resolve(cwd, opts.path ?? '.');
+    let project = input;
+    if (!existsSync(path.join(project, 'src')) && !existsSync(path.join(project, 'package.json'))) {
+        const pkg = findPackageJson(cwd);
+        if (pkg)
+            project = path.dirname(pkg);
+    }
+    const outDir = opts.outDir ? (path.isAbsolute(opts.outDir) ? opts.outDir : path.join(project, opts.outDir)) : path.join(project, 'dist');
+    return { project, outDir, cwd };
+}
+/**
+ * @param {string} projectRoot
+ * @returns {{ name?: string, private?: boolean } | null}
+ */
+export function readPackageMeta(projectRoot) {
+    const pkgPath = path.join(projectRoot, 'package.json');
+    if (!existsSync(pkgPath))
+        return null;
+    try {
+        return JSON.parse(readFileSync(pkgPath, 'utf8'));
+    }
+    catch {
+        return null;
+    }
+}

package/dist/test-cmd.d.ts

@@ -0,0 +1,9 @@
+/**
+ * `vmz test` command — discovery / build / filter / TestReport orchestration.
+ * Semantics live in `@vmz/test` (optional peer — not installed with bare `@vmz/vmz`).
+ */
+/**
+ * @param {Record<string, string | boolean> & { _: string[] }} args
+ * @returns {Promise<number>}
+ */
+export declare function cmdTest(args: any): Promise<0 | 1 | 2>;

package/dist/test-cmd.js

@@ -0,0 +1,363 @@
+// @ts-nocheck
+/**
+ * `vmz test` command — discovery / build / filter / TestReport orchestration.
+ * Semantics live in `@vmz/test` (optional peer — not installed with bare `@vmz/vmz`).
+ */
+import path from 'node:path';
+import { createWorkspace } from './index.js';
+import { log } from './log.js';
+/**
+ * @returns {Promise<typeof import('@vmz/test')>}
+ */
+async function loadTestPackage() {
+    try {
+        return await import('@vmz/test');
+    }
+    catch (e) {
+        const detail = e instanceof Error ? e.message : String(e);
+        throw new Error('`vmz test` needs `@vmz/test` (optional peer of `@vmz/vmz`).\n' + '  Install:  pnpm add -D @vmz/test\n' + `  Detail: ${detail}`);
+    }
+}
+/**
+ * @param {Record<string, string | boolean> & { _: string[] }} args
+ * @returns {Promise<number>}
+ */
+export async function cmdTest(args) {
+    let test;
+    try {
+        test = await loadTestPackage();
+    }
+    catch (e) {
+        log.error(e instanceof Error ? e.message : String(e));
+        return 1;
+    }
+    const { discoverTestManifests, buildTestReport, parseModes, buildForCompile, runCompileManifest, runLogicManifest, runSsrManifest, runResumeManifest, runBrowserManifest, runDeploymentManifest, } = test;
+    const project = path.resolve(String(args._[0] || '.'));
+    let modes;
+    try {
+        modes = parseModes(/** @type {string|boolean|undefined} */ (args.mode));
+    }
+    catch (e) {
+        log.error(e instanceof Error ? e.message : String(e));
+        return 1;
+    }
+    const wantList = args.list === true;
+    const wantJson = args.json === true || typeof args.json === 'string';
+    const filter = typeof args.filter === 'string' && args.filter ? String(args.filter) : null;
+    const outDirArg = typeof args['out-dir'] === 'string' ? args['out-dir'] : undefined;
+    const wantAffected = args.affected === true || args.target === 'changed' || args.target === 'affected';
+    const applicationId = typeof args.application === 'string' && args.application ? String(args.application) : null;
+    const mountedId = typeof args.mounted === 'string' && args.mounted ? String(args.mounted) : null;
+    if (applicationId && mountedId) {
+        log.error('use either --application <id> or --mounted <id>, not both');
+        return 1;
+    }
+    const { manifests, errors } = discoverTestManifests(project);
+    for (const err of errors) {
+        log.error(err);
+    }
+    let selected = manifests;
+    if (filter) {
+        const re = (() => {
+            try {
+                return new RegExp(filter);
+            }
+            catch {
+                return null;
+            }
+        })();
+        selected = manifests.filter((m) => {
+            const id = String(m.id || '');
+            const file = String(m.file || '');
+            if (re)
+                return re.test(id) || re.test(file);
+            return id.includes(filter) || file.includes(filter);
+        });
+    }
+    const scopeId = applicationId || mountedId;
+    if (scopeId) {
+        const mode = applicationId ? 'application' : 'mounted';
+        log.info(`test ${mode} scope: ApplicationId=${scopeId}` + (mountedId ? ' contracts=relocation,host_boundary' : ' scope=standalone'));
+        selected = selected.filter((m) => {
+            const app = (m.applicationId && String(m.applicationId)) || (m.application && String(m.application)) || '';
+            const file = String(m.file || '');
+            const id = String(m.id || '');
+            if (app)
+                return app === scopeId;
+            return file.includes(scopeId) || id.includes(scopeId);
+        });
+    }
+    /** @type {null | { schema: string, reason: string, testIds: string[], affectedChunkIds: string[], status: string }} */
+    let testSelection = null;
+    if (wantAffected) {
+        const outDir = outDirArg ? path.resolve(outDirArg) : path.join(project, 'dist');
+        const ws = createWorkspace({ root: project, outDir });
+        try {
+            if (typeof ws.selectTestsAffected !== 'function') {
+                log.error('selectTestsAffected missing on Workspace — rebuild native (`pnpm napi:build`)');
+                return 1;
+            }
+            const raw = ws.selectTestsAffected();
+            try {
+                testSelection = JSON.parse(raw);
+            }
+            catch (e) {
+                log.error(`test selection not JSON: ${e}`);
+                return 1;
+            }
+            log.info(`affected selection: ${testSelection.status} — ${testSelection.reason} (chunks=${(testSelection.affectedChunkIds || []).length})`);
+            const ids = new Set((testSelection.testIds || []).map(String));
+            const chunks = new Set((testSelection.affectedChunkIds || []).map(String));
+            if (ids.size > 0) {
+                selected = selected.filter((m) => ids.has(String(m.id || '')));
+            }
+            else if (chunks.size > 0) {
+                // Scaffold fallback: match manifest program.chunkId until graph->test edges exist.
+                selected = selected.filter((m) => {
+                    const program = m.program && typeof m.program === 'object' ? m.program : {};
+                    const chunk = program.chunkId ? String(program.chunkId) : '';
+                    return chunk && chunks.has(chunk);
+                });
+            }
+            else {
+                selected = [];
+            }
+        }
+        finally {
+            ws.dispose();
+        }
+    }
+    if (modes.length === 1 && modes[0] !== 'all') {
+        const mode = modes[0];
+        selected = selected.filter((m) => Array.isArray(m.modes) && m.modes.includes(mode));
+    }
+    else if (!modes.includes('all')) {
+        selected = selected.filter((m) => Array.isArray(m.modes) && m.modes.some((x) => modes.includes(x)));
+    }
+    /** @type {Array<{
+     * testId: string,
+     * file: string,
+     * modes: string[],
+     * programId: string|null,
+     * planId: string|null,
+     * status: string,
+     * diagnostics: unknown[],
+     * }>} */
+    let tests;
+    if (wantList) {
+        tests = selected.map((m) => {
+            const program = m.program && typeof m.program === 'object' ? m.program : {};
+            const plan = m.plan && typeof m.plan === 'object' ? m.plan : {};
+            return {
+                testId: String(m.id),
+                file: String(m.file),
+                modes: Array.isArray(m.modes) ? m.modes.map(String) : [],
+                programId: program.chunkId ? String(program.chunkId) : null,
+                planId: plan.ref ? String(plan.ref) : plan.schema ? String(plan.schema) : null,
+                status: 'listed',
+                diagnostics: [],
+            };
+        });
+    }
+    else {
+        const modeActive = (name) => modes.includes('all') || modes.includes(name);
+        const needsBuild = selected.length > 0 &&
+            selected.some((m) => {
+                const mm = Array.isArray(m.modes) ? m.modes : [];
+                return ((mm.includes('compile') && modeActive('compile')) ||
+                    (mm.includes('logic') && modeActive('logic')) ||
+                    (mm.includes('ssr') && modeActive('ssr')) ||
+                    (mm.includes('resume') && modeActive('resume')) ||
+                    (mm.includes('browser') && modeActive('browser')) ||
+                    (mm.includes('deployment') && modeActive('deployment')));
+            });
+        /** @type {string|null} */
+        let buildOut = null;
+        /** @type {unknown[]} */
+        let buildDiags = [];
+        /** @type {string|null} */
+        let buildError = null;
+        if (needsBuild) {
+            const built = buildForCompile(project, outDirArg ? path.resolve(outDirArg) : undefined, {
+                createWorkspace,
+            });
+            buildOut = built.outDir;
+            buildDiags = built.diagnostics || [];
+            if (!built.ok) {
+                buildError = built.error || 'build failed';
+                log.error(buildError);
+            }
+        }
+        tests = [];
+        for (const m of selected) {
+            const program = m.program && typeof m.program === 'object' ? m.program : {};
+            const plan = m.plan && typeof m.plan === 'object' ? m.plan : {};
+            const mModes = Array.isArray(m.modes) ? m.modes.map(String) : [];
+            const base = {
+                testId: String(m.id),
+                file: String(m.file),
+                modes: mModes,
+                programId: program.chunkId ? String(program.chunkId) : null,
+                planId: plan.ref ? String(plan.ref) : plan.schema ? String(plan.schema) : null,
+                status: 'skipped',
+                diagnostics: /** @type {unknown[]} */ ([]),
+            };
+            const doCompile = mModes.includes('compile') && modeActive('compile');
+            const doLogic = mModes.includes('logic') && modeActive('logic');
+            const doSsr = mModes.includes('ssr') && modeActive('ssr');
+            const doResume = mModes.includes('resume') && modeActive('resume');
+            const doBrowser = mModes.includes('browser') && modeActive('browser');
+            const doDeployment = mModes.includes('deployment') && modeActive('deployment');
+            if (!doCompile && !doLogic && !doSsr && !doResume && !doBrowser && !doDeployment) {
+                base.status = 'skipped';
+                base.diagnostics = [
+                    {
+                        severity: 'info',
+                        message: `modes [${mModes.join(',')}] not executed in this vmz test slice`,
+                    },
+                ];
+                tests.push(base);
+                continue;
+            }
+            if (buildError || !buildOut) {
+                base.status = 'error';
+                base.diagnostics = [...buildDiags, { severity: 'error', message: buildError || 'build unavailable' }];
+                tests.push(base);
+                continue;
+            }
+            /** @type {unknown[]} */
+            const diags = [];
+            /** @type {string[]} */
+            const statuses = [];
+            if (doCompile) {
+                const result = runCompileManifest(m, { outDir: buildOut });
+                statuses.push(result.status);
+                diags.push(...result.diagnostics);
+                base.programId = result.programId ?? base.programId;
+                base.planId = result.planId ?? base.planId;
+            }
+            if (doLogic) {
+                const result = await runLogicManifest(m, { outDir: buildOut });
+                statuses.push(result.status);
+                diags.push(...result.diagnostics);
+                base.programId = result.programId ?? base.programId;
+                base.planId = result.planId ?? base.planId;
+            }
+            if (doSsr) {
+                const result = await runSsrManifest(m, { outDir: buildOut });
+                statuses.push(result.status);
+                diags.push(...result.diagnostics);
+                base.programId = result.programId ?? base.programId;
+                base.planId = result.planId ?? base.planId;
+            }
+            if (doResume) {
+                const result = await runResumeManifest(m, { outDir: buildOut });
+                statuses.push(result.status);
+                diags.push(...result.diagnostics);
+                base.programId = result.programId ?? base.programId;
+                base.planId = result.planId ?? base.planId;
+            }
+            if (doDeployment) {
+                const result = runDeploymentManifest(m, { outDir: buildOut });
+                statuses.push(result.status);
+                diags.push(...result.diagnostics);
+                base.programId = result.programId ?? base.programId;
+                base.planId = result.planId ?? base.planId;
+            }
+            if (doBrowser) {
+                const result = await runBrowserManifest(m, { outDir: buildOut });
+                statuses.push(result.status);
+                diags.push(...result.diagnostics);
+                base.programId = result.programId ?? base.programId;
+                base.planId = result.planId ?? base.planId;
+            }
+            base.diagnostics = diags;
+            if (statuses.includes('error'))
+                base.status = 'error';
+            else if (statuses.includes('failed'))
+                base.status = 'failed';
+            else if (statuses.every((s) => s === 'passed'))
+                base.status = 'passed';
+            else
+                base.status = statuses[0] || 'skipped';
+            tests.push(base);
+        }
+    }
+    const failed = tests.some((t) => t.status === 'failed' || t.status === 'error');
+    const reportStatus = errors.length
+        ? 'error'
+        : wantList
+            ? tests.length
+                ? 'listed'
+                : 'empty'
+            : failed
+                ? 'failed'
+                : tests.length === 0
+                    ? 'empty'
+                    : 'passed';
+    const report = buildTestReport({
+        project: path.relative(process.cwd(), project) || '.',
+        modes,
+        tests,
+        status: reportStatus,
+    });
+    if (wantList && !wantJson) {
+        if (tests.length === 0) {
+            console.log(`vmz test: no manifests under ${project}`);
+        }
+        else {
+            console.log(`vmz test: ${tests.length} test(s) under ${project}`);
+            for (const t of tests) {
+                console.log(` ${t.testId}\t${t.file}\t[${t.modes.join(',')}]`);
+            }
+        }
+        if (errors.length) {
+            console.log(`vmz test: ${errors.length} manifest error(s)`);
+        }
+        return errors.length ? 2 : 0;
+    }
+    if (wantJson) {
+        const text = `${JSON.stringify(report, null, 2)}\n`;
+        if (typeof args.json === 'string' && args.json !== 'true') {
+            const { writeFileSync } = await import('node:fs');
+            writeFileSync(path.resolve(String(args.json)), text);
+            if (!wantList) {
+                console.log(`vmz test: wrote ${args.json}`);
+            }
+        }
+        else {
+            process.stdout.write(text);
+        }
+        if (errors.length)
+            return 2;
+        if (!wantList && failed)
+            return 1;
+        return 0;
+    }
+    console.log(`vmz test: ${tests.length} test(s) — ${reportStatus}`);
+    for (const t of tests) {
+        console.log(` ${t.status}\t${t.testId}\t${t.file}`);
+        for (const d of t.diagnostics || []) {
+            if (d && typeof d === 'object' && d.severity === 'error') {
+                console.log(` ! ${d.message}`);
+                if (process.env.GITHUB_ACTIONS === 'true') {
+                    const msg = String(d.message || 'error').replace(/[\r\n]+/g, ' ');
+                    console.log(`::error title=vmz test ${t.testId}::${msg}`);
+                }
+            }
+        }
+        if (process.env.GITHUB_ACTIONS === 'true' &&
+            (t.status === 'failed' || t.status === 'error') &&
+            !(t.diagnostics || []).some((d) => d && typeof d === 'object' && d.severity === 'error')) {
+            console.log(`::error title=vmz test ${t.testId}::status=${t.status}`);
+        }
+    }
+    if (tests.length === 0) {
+        console.log(' (add *.vmz.test.json manifests)');
+    }
+    if (errors.length)
+        return 2;
+    if (failed)
+        return 1;
+    return 0;
+}

package/dist/test-compile.d.ts

@@ -0,0 +1,2 @@
+/** @deprecated Import from `@vmz/test` — transitional re-export. */
+export { buildForCompile, resolveChunkArtifacts, runCompileManifest, } from '@vmz/test';

package/dist/test-compile.js

@@ -0,0 +1,3 @@
+// @ts-nocheck
+/** @deprecated Import from `@vmz/test` — transitional re-export. */
+export { buildForCompile, resolveChunkArtifacts, runCompileManifest, } from '@vmz/test';

package/dist/test-discover.d.ts

@@ -0,0 +1,2 @@
+/** @deprecated Import from `@vmz/test` — transitional re-export. */
+export * from '@vmz/test/discover';

package/dist/test-discover.js

@@ -0,0 +1,3 @@
+// @ts-nocheck
+/** @deprecated Import from `@vmz/test` — transitional re-export. */
+export * from '@vmz/test/discover';

package/dist/test-logic.d.ts

@@ -0,0 +1,2 @@
+/** @deprecated Import from `@vmz/test` — transitional re-export. */
+export { createLogicHost, runLogicManifest, installHeadlessDocument } from '@vmz/test';

package/dist/test-logic.js

@@ -0,0 +1,3 @@
+// @ts-nocheck
+/** @deprecated Import from `@vmz/test` — transitional re-export. */
+export { createLogicHost, runLogicManifest, installHeadlessDocument } from '@vmz/test';

package/dist/test-protocol.d.ts

@@ -0,0 +1,2 @@
+/** @deprecated Import from `@vmz/test` — transitional re-export. */
+export * from '@vmz/test/protocol';

package/dist/test-protocol.js

@@ -0,0 +1,3 @@
+// @ts-nocheck
+/** @deprecated Import from `@vmz/test` — transitional re-export. */
+export * from '@vmz/test/protocol';

package/dist/watch-diff.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Track per-file fingerprints so dev rebuilds only dirty leaves (session).
+ */
+/**
+ * @param {string} srcDir
+ * @returns {Map<string, string>}
+ */
+export declare function fileFingerprintMap(srcDir: any): Map<any, any>;
+/**
+ * @param {Map<string, string>} prev
+ * @param {Map<string, string>} next
+ * @returns {{ changed: string[], deleted: string[] }}
+ */
+export declare function diffFingerprints(prev: any, next: any): {
+    changed: any[];
+    deleted: any[];
+};

package/dist/watch-diff.js

@@ -0,0 +1,56 @@
+// @ts-nocheck
+/**
+ * Track per-file fingerprints so dev rebuilds only dirty leaves (session).
+ */
+import { existsSync, readdirSync, statSync } from 'node:fs';
+import path from 'node:path';
+const WATCH_EXT = new Set(['.vmz', '.ts', '.tsx', '.js', '.mjs', '.css', '.json']);
+/**
+ * @param {string} srcDir
+ * @returns {Map<string, string>}
+ */
+export function fileFingerprintMap(srcDir) {
+    /** @type {Map<string, string>} */
+    const map = new Map();
+    walk(srcDir, (file) => {
+        const st = statSync(file);
+        map.set(file, `${st.mtimeMs}|${st.size}`);
+    });
+    return map;
+}
+/**
+ * @param {Map<string, string>} prev
+ * @param {Map<string, string>} next
+ * @returns {{ changed: string[], deleted: string[] }}
+ */
+export function diffFingerprints(prev, next) {
+    /** @type {string[]} */
+    const changed = [];
+    /** @type {string[]} */
+    const deleted = [];
+    for (const [file, fp] of next) {
+        if (prev.get(file) !== fp)
+            changed.push(file);
+    }
+    for (const file of prev.keys()) {
+        if (!next.has(file))
+            deleted.push(file);
+    }
+    return { changed, deleted };
+}
+/**
+ * @param {string} dir
+ * @param {(file: string) => void} fn
+ */
+function walk(dir, fn) {
+    if (!existsSync(dir))
+        return;
+    for (const name of readdirSync(dir)) {
+        const full = path.join(dir, name);
+        const st = statSync(full);
+        if (st.isDirectory())
+            walk(full, fn);
+        else if (WATCH_EXT.has(path.extname(name)))
+            fn(full);
+    }
+}

package/package.json

@@ -1,12 +1,105 @@
 {
   "name": "@vmz/vmz",
-  "version": "0.0.1",
-  "description": "VMZ placeholder 鈥?not for production use.",
+  "version": "0.0.3",
+  "type": "module",
+  "description": "VMZ Node toolchain — N-API workspace session + CLI",
   "license": "MIT",
-  "private": false,
+  "bin": {
+    "vmz": "./bin/vmz.js"
+  },
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "default": "./dist/index.js"
+    },
+    "./cli": {
+      "types": "./dist/cli.d.ts",
+      "default": "./dist/cli.js"
+    },
+    "./dev-session": {
+      "types": "./dist/dev-session.d.ts",
+      "default": "./dist/dev-session.js"
+    },
+    "./plugin-host": {
+      "types": "./dist/plugin-host.d.ts",
+      "default": "./dist/plugin-host.js"
+    },
+    "./bundler-adapter": {
+      "types": "./dist/bundler-adapter.d.ts",
+      "default": "./dist/bundler-adapter.js"
+    },
+    "./test-protocol": {
+      "types": "./dist/test-protocol.d.ts",
+      "default": "./dist/test-protocol.js"
+    },
+    "./test-discover": {
+      "types": "./dist/test-discover.d.ts",
+      "default": "./dist/test-discover.js"
+    },
+    "./document-check": {
+      "types": "./dist/document-check.d.ts",
+      "default": "./dist/document-check.js"
+    },
+    "./document-schema": {
+      "types": "./dist/document-schema.d.ts",
+      "default": "./dist/document-schema.js"
+    }
+  },
+  "dependencies": {
+    "@vmz/core": "0.0.3",
+    "@vmz/plugin": "0.0.3",
+    "@vmz/protocol": "0.0.3",
+    "jiti": "^2.6.1",
+    "json5": "^2.2.3"
+  },
+  "peerDependencies": {
+    "@vmz/plugin-markdown-it": "0.0.3",
+    "@vmz/test": "0.0.3",
+    "typescript": "^5.8.3"
+  },
+  "peerDependenciesMeta": {
+    "@vmz/plugin-markdown-it": {
+      "optional": true
+    },
+    "@vmz/test": {
+      "optional": true
+    },
+    "typescript": {
+      "optional": true
+    }
+  },
   "files": [
+    "bin",
+    "dist",
     "README.md"
   ],
+  "scripts": {
+    "build:native": "node ../../../scripts/build/napi.mjs",
+    "build": "pnpm run build:native && pnpm run build:js",
+    "test": "node --experimental-strip-types ./tests/run-node-tests.ts",
+    "verify": "node --import ../../../scripts/test/resolve-ts-from-js.mjs --experimental-strip-types ./tests/conformance/run.ts",
+    "verify:list": "node --import ../../../scripts/test/resolve-ts-from-js.mjs --experimental-strip-types ./tests/conformance/run.ts --list",
+    "build:js": "tsc -p tsconfig.json && node ../../../scripts/build/copy-vmz-public-api.mjs"
+  },
+  "keywords": [
+    "vmz",
+    "napi",
+    "compiler",
+    "cli"
+  ],
+  "optionalDependencies": {
+    "@vmz/vmz-win32-x64": "0.0.3",
+    "@vmz/vmz-win32-arm64": "0.0.3",
+    "@vmz/vmz-darwin-x64": "0.0.3",
+    "@vmz/vmz-darwin-arm64": "0.0.3",
+    "@vmz/vmz-linux-x64": "0.0.3",
+    "@vmz/vmz-linux-arm64": "0.0.3"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
   "repository": {
     "type": "git",
     "url": "git+https://github.com/doki-land/vmz-framework.git"