@vmz/vmz 0.0.1 → 0.0.2

package/dist/cli.js

@@ -0,0 +1,370 @@
+// @ts-nocheck
+/**
+ * Node CLI command implementations (N2).
+ */
+import { spawn } from 'node:child_process';
+import { existsSync } from 'node:fs';
+import path from 'node:path';
+import { HOST_PROTOCOL, createWorkspace, getProtocolVersions } from './index.js';
+import { createDevSession } from './dev-session.js';
+import { log } from './log.js';
+import { readPackageMeta, resolveWorkspaceDirs } from './resolve.js';
+import { cmdTest } from './test-cmd.js';
+import { cmdDocument } from './document-cmd.js';
+import { buildIntegratedDocuments, projectHasDocuments } from './document-integrate.js';
+import { cmdLocale } from './locale-cmd.js';
+import { cmdApplication } from './application-cmd.js';
+import { cmdRefactor } from './refactor-cmd.js';
+import { cmdExplain } from './explain-cmd.js';
+/**
+ * @param {string[]} argv
+ */
+export function parseArgs(argv) {
+    /** @type {Record<string, string | boolean> & { _: string[] }} */
+    const out = { _: [] };
+    for (let i = 0; i < argv.length; i++) {
+        const a = argv[i];
+        if (a === '--') {
+            out._.push(...argv.slice(i + 1));
+            break;
+        }
+        if (a.startsWith('--')) {
+            const eq = a.indexOf('=');
+            if (eq !== -1) {
+                out[a.slice(2, eq)] = a.slice(eq + 1);
+                continue;
+            }
+            const key = a.slice(2);
+            const next = argv[i + 1];
+            if (next && !next.startsWith('-')) {
+                out[key] = next;
+                i += 1;
+            }
+            else {
+                out[key] = true;
+            }
+            continue;
+        }
+        if (a.startsWith('-') && a.length === 2) {
+            const key = a === '-o' ? 'out-dir' : a.slice(1);
+            const next = argv[i + 1];
+            if (next && !next.startsWith('-')) {
+                out[key] = next;
+                i += 1;
+            }
+            else {
+                out[key] = true;
+            }
+            continue;
+        }
+        out._.push(a);
+    }
+    return out;
+}
+export function printHelp() {
+    console.log(`vmz — Node toolchain host (N-API workspace)
+
+Usage:
+  vmz check [path]              Check project via Workspace
+  vmz build [path] [options]    Build project via Workspace
+  vmz serve [path] [options]    Serve dist (optional --build)
+  vmz dev [path] [options]      Long-lived rebuild session (no CLI spawn)
+  vmz format [path] [--check]   Format .vmz via N-API (oxc codegen)
+  vmz lint [path] [--deny-warnings]  Lint (= check) via N-API
+  vmz test [path] [options]     Native test discover / report (T0+)
+  vmz document|docs <cmd>       Project /documents domain (D0: check)
+  vmz application <cmd>         Application Collection / Mount (M0–M5)
+  vmz refactor <cmd>            DX rename plans / apply (X1)
+  vmz explain [style] <target>  DX causal explain (style Theme chain)
+  vmz version                   Show host + native protocol versions
+  vmz help                      Show this help
+
+Options:
+  --out-dir, -o <dir>   Output directory (default: dist)
+  --release             Release build (build only)
+  --host <host>         Listen host (default: 127.0.0.1)
+  --port <port>         Listen port (default: 5173)
+  --poll-ms <ms>        Dev watch poll interval (default: 300)
+  --build               Build before serve
+  --check               Format check-only (format)
+  --deny-warnings       Treat warnings as errors (lint)
+  --list                List discovered tests (test)
+  --json [file]         Emit TestReport / DocumentManifest / ApplicationCheckReport JSON
+  --mode <modes>        compile|logic|browser|ssr|resume|deployment|all (test)
+  --filter <pattern>    Filter by test id or file (test)
+  --application <id>    Run only tests for ApplicationId (standalone scope)
+  --mounted <id>        Run relocation + host-boundary tests for ApplicationId
+  --affected            Select tests from dirty VPG units (test; DX)
+  --root <dir>          Project root (document check)
+  --strict              Strict document locale/PageKey coverage (document check)
+`);
+}
+/**
+ * @param {string[]} argv
+ * @returns {Promise<number>}
+ */
+export async function runCli(argv) {
+    const [cmd, ...rest] = argv;
+    if (!cmd || cmd === 'help' || cmd === '-h' || cmd === '--help') {
+        printHelp();
+        return 0;
+    }
+    if (cmd === 'version' || cmd === '-V' || cmd === '--version') {
+        return cmdVersion();
+    }
+    const args = parseArgs(rest);
+    switch (cmd) {
+        case 'check':
+            return cmdCheck(args);
+        case 'build':
+            return cmdBuild(args);
+        case 'serve':
+            return cmdServe(args);
+        case 'dev':
+            return cmdDev(args);
+        case 'format':
+            return cmdFormat(args);
+        case 'lint':
+            return cmdLint(args);
+        case 'test':
+            return cmdTest(args);
+        case 'document':
+        case 'docs':
+            return cmdDocument(rest);
+        case 'locale':
+        case 'locales':
+            return cmdLocale(rest);
+        case 'application':
+        case 'applications':
+        case 'app':
+            return cmdApplication(rest);
+        case 'refactor':
+            return cmdRefactor(rest);
+        case 'explain':
+            return cmdExplain(rest);
+        default:
+            log.error(`unknown command \`${cmd}\``);
+            printHelp();
+            return 1;
+    }
+}
+function cmdVersion() {
+    const native = getProtocolVersions();
+    console.log(`vmz host ${HOST_PROTOCOL}`);
+    console.log(`native host=${native.hostProtocol} compiler=${native.compilerProtocol} program_ir=${native.programIrSchema} plugin=${native.pluginProtocol}`);
+    return 0;
+}
+/**
+ * @param {Record<string, string | boolean> & { _: string[] }} args
+ */
+function cmdCheck(args) {
+    const pathArg = args._[0] ?? '.';
+    const { project, outDir } = resolveWorkspaceDirs({
+        path: pathArg,
+        outDir: typeof args['out-dir'] === 'string' ? args['out-dir'] : undefined,
+    });
+    const meta = readPackageMeta(project);
+    log.info(`check ${project}${meta?.name ? ` (${meta.name})` : ''}`);
+    const ws = createWorkspace({ root: project, outDir });
+    try {
+        return runWithPlugins(ws, project, outDir, async () => {
+            const report = ws.check();
+            const errors = log.diagnostics(report.diagnostics ?? []);
+            log.info(`checked ${report.filesChecked} file(s)`);
+            return errors ? 1 : 0;
+        });
+    }
+    finally {
+        ws.dispose();
+    }
+}
+/**
+ * @param {import('./index.js').Workspace} ws
+ * @param {string} project
+ * @param {string} outDir
+ * @param {() => Promise<number> | number} fn
+ */
+async function runWithPlugins(ws, project, outDir, fn) {
+    const { loadVmzConfig, applyPlugins } = await import('./plugin-host.js');
+    const { plugins, engines } = await loadVmzConfig(project);
+    if (plugins.length) {
+        await applyPlugins(ws, plugins, { project, outDir, engines });
+    }
+    return await fn();
+}
+/**
+ * @param {Record<string, string | boolean> & { _: string[] }} args
+ */
+async function cmdBuild(args) {
+    const pathArg = args._[0] ?? '.';
+    const { project, outDir } = resolveWorkspaceDirs({
+        path: pathArg,
+        outDir: typeof args['out-dir'] === 'string' ? args['out-dir'] : undefined,
+    });
+    log.info(`build ${project} → ${outDir}`);
+    const ws = createWorkspace({ root: project, outDir });
+    try {
+        const code = await runWithPlugins(ws, project, outDir, () => {
+            const report = ws.build(Boolean(args.release));
+            const errors = log.diagnostics(report.diagnostics ?? []);
+            if (errors)
+                return 1;
+            for (const p of report.emitted ?? []) {
+                console.log(`emitted ${p}`);
+            }
+            log.info(`build ok (${(report.emitted ?? []).length} file(s))`);
+            return 0;
+        });
+        if (code !== 0)
+            return code;
+        if (projectHasDocuments(project)) {
+            const docs = await buildIntegratedDocuments({ projectRoot: project, outDir });
+            if (!docs.ok)
+                return 1;
+        }
+        return 0;
+    }
+    finally {
+        ws.dispose();
+    }
+}
+/**
+ * @param {Record<string, string | boolean> & { _: string[] }} args
+ */
+async function cmdServe(args) {
+    const pathArg = args._[0] ?? '.';
+    if (args.build) {
+        const code = await cmdBuild(args);
+        if (code !== 0)
+            return code;
+    }
+    const { project, outDir } = resolveWorkspaceDirs({
+        path: pathArg,
+        outDir: typeof args['out-dir'] === 'string' ? args['out-dir'] : undefined,
+    });
+    const hostJs = path.join(outDir, 'vmz-serve-host.mjs');
+    if (!existsSync(hostJs)) {
+        log.error(`missing ${hostJs} — run \`vmz build\` first (or pass --build)`);
+        return 1;
+    }
+    const host = typeof args.host === 'string' ? args.host : '127.0.0.1';
+    const port = Number(args.port ?? 5173);
+    log.info(`serve http://${host}:${port}`);
+    const node = process.env.VMZ_NODE || process.execPath;
+    const child = spawn(node, [hostJs], {
+        cwd: project,
+        env: {
+            ...process.env,
+            VMZ_DIST: outDir,
+            VMZ_PORT: String(port),
+            VMZ_HOST: host,
+        },
+        stdio: 'inherit',
+    });
+    return await new Promise((resolve) => {
+        const shutdown = () => {
+            child.kill();
+        };
+        process.once('SIGINT', shutdown);
+        process.once('SIGTERM', shutdown);
+        child.on('exit', (code, signal) => {
+            process.off('SIGINT', shutdown);
+            process.off('SIGTERM', shutdown);
+            if (signal)
+                resolve(0);
+            else
+                resolve(code ?? 1);
+        });
+    });
+}
+/**
+ * @param {Record<string, string | boolean> & { _: string[] }} args
+ */
+async function cmdDev(args) {
+    const pathArg = args._[0] ?? '.';
+    const { project, outDir } = resolveWorkspaceDirs({
+        path: pathArg,
+        outDir: typeof args['out-dir'] === 'string' ? args['out-dir'] : undefined,
+    });
+    const host = typeof args.host === 'string' ? args.host : '127.0.0.1';
+    const port = Number(args.port ?? 5173);
+    const pollMs = Number(args['poll-ms'] ?? 300);
+    const ac = new AbortController();
+    const onSig = () => {
+        log.info('shutting down…');
+        ac.abort();
+    };
+    process.on('SIGINT', onSig);
+    process.on('SIGTERM', onSig);
+    const session = createDevSession({
+        project,
+        outDir,
+        host,
+        port,
+        pollMs,
+        signal: ac.signal,
+    });
+    try {
+        await session.start();
+        return 0;
+    }
+    catch (err) {
+        if (ac.signal.aborted)
+            return 0;
+        log.error(String(err));
+        return 1;
+    }
+    finally {
+        process.off('SIGINT', onSig);
+        process.off('SIGTERM', onSig);
+        await session.stop();
+    }
+}
+/**
+ * @param {Record<string, string | boolean> & { _: string[] }} args
+ */
+function cmdFormat(args) {
+    const pathArg = args._[0] ?? '.';
+    const { project, outDir } = resolveWorkspaceDirs({
+        path: pathArg,
+        outDir: typeof args['out-dir'] === 'string' ? args['out-dir'] : undefined,
+    });
+    const checkOnly = Boolean(args.check);
+    log.info(`format ${project}${checkOnly ? ' --check' : ''}`);
+    const ws = createWorkspace({ root: project, outDir });
+    try {
+        const report = ws.format(checkOnly);
+        const errors = log.diagnostics(report.diagnostics ?? []);
+        if (checkOnly) {
+            log.info(`checked ${report.filesChecked} file(s); ${report.filesNeedWrite} need write`);
+            return errors || report.filesNeedWrite > 0 ? 1 : 0;
+        }
+        log.info(`formatted ${report.filesWritten}/${report.filesChecked} file(s)`);
+        return errors ? 1 : 0;
+    }
+    finally {
+        ws.dispose();
+    }
+}
+/**
+ * @param {Record<string, string | boolean> & { _: string[] }} args
+ */
+function cmdLint(args) {
+    const pathArg = args._[0] ?? '.';
+    const { project, outDir } = resolveWorkspaceDirs({
+        path: pathArg,
+        outDir: typeof args['out-dir'] === 'string' ? args['out-dir'] : undefined,
+    });
+    const denyWarnings = Boolean(args['deny-warnings']);
+    log.info(`lint ${project}`);
+    const ws = createWorkspace({ root: project, outDir });
+    try {
+        const report = ws.lint(denyWarnings);
+        const errors = log.diagnostics(report.diagnostics ?? [], { denyWarnings });
+        log.info(`linted ${report.filesChecked} file(s)`);
+        return errors ? 1 : 0;
+    }
+    finally {
+        ws.dispose();
+    }
+}

package/dist/dev-session.d.ts

@@ -0,0 +1,35 @@
+/**
+ * Long-lived Node dev session (N2/N4).
+ *
+ * Rebuilds go through the N-API `Workspace` — never spawn `cargo` / `vmz-tools`.
+ * N4: only dirty leaves are marked; Workspace emits affected deployment units.
+ */
+/**
+ * @typedef {object} DevSessionOptions
+ * @property {string} project
+ * @property {string} outDir
+ * @property {string} [host]
+ * @property {number} [port]
+ * @property {number} [pollMs]
+ * @property {AbortSignal} [signal]
+ * @property {typeof createWorkspace} [createWorkspaceFn]
+ * @property {(opts: { project: string, outDir: string, host: string, port: number }) => import('node:child_process').ChildProcess} [spawnHostFn]
+ * @property {(host: string, port: number, payload?: object) => Promise<void>} [softReloadFn]
+ */
+/**
+ * @param {DevSessionOptions} options
+ */
+export declare function createDevSession(options: any): {
+    ws: any;
+    rebuild: (changes: any) => any;
+    start: () => Promise<void>;
+    stop: () => Promise<void>;
+    project: any;
+    outDir: any;
+    host: any;
+    port: any;
+};
+/** @deprecated use fileFingerprintMap */
+export declare function srcFingerprint(srcDir: any): number;
+/** @deprecated */
+export declare function listWatchedFiles(srcDir: any): any[];

package/dist/dev-session.js

@@ -0,0 +1,290 @@
+// @ts-nocheck
+/**
+ * Long-lived Node dev session (N2/N4).
+ *
+ * Rebuilds go through the N-API `Workspace` — never spawn `cargo` / `vmz-tools`.
+ * N4: only dirty leaves are marked; Workspace emits affected deployment units.
+ */
+import { spawn } from 'node:child_process';
+import { existsSync } from 'node:fs';
+import path from 'node:path';
+import { buildIntegratedDocuments, projectHasDocuments } from './document-integrate.js';
+import { createWorkspace } from './index.js';
+import { log } from './log.js';
+import { diffFingerprints, fileFingerprintMap } from './watch-diff.js';
+/**
+ * @typedef {object} DevSessionOptions
+ * @property {string} project
+ * @property {string} outDir
+ * @property {string} [host]
+ * @property {number} [port]
+ * @property {number} [pollMs]
+ * @property {AbortSignal} [signal]
+ * @property {typeof createWorkspace} [createWorkspaceFn]
+ * @property {(opts: { project: string, outDir: string, host: string, port: number }) => import('node:child_process').ChildProcess} [spawnHostFn]
+ * @property {(host: string, port: number, payload?: object) => Promise<void>} [softReloadFn]
+ */
+/**
+ * @param {DevSessionOptions} options
+ */
+export function createDevSession(options) {
+    const project = options.project;
+    const outDir = options.outDir;
+    const host = options.host ?? '127.0.0.1';
+    const port = options.port ?? 5173;
+    const pollMs = Math.max(50, options.pollMs ?? 300);
+    const createWs = options.createWorkspaceFn ?? createWorkspace;
+    const spawnHost = options.spawnHostFn ?? defaultSpawnHost;
+    const softReload = options.softReloadFn ?? defaultSoftReload;
+    const ws = createWs({ root: project, outDir });
+    /** @type {import('node:child_process').ChildProcess | null} */
+    let child = null;
+    let stopped = false;
+    /**
+     * @param {Array<{ path: string, kind: 'update' | 'delete' }>} [changes]
+     */
+    function rebuild(changes) {
+        if (changes?.length)
+            ws.updateFiles(changes);
+        return ws.build();
+    }
+    function printReport(report, label) {
+        const errors = log.diagnostics(report.diagnostics ?? []);
+        if (errors) {
+            log.error(`${label} failed (${errors} error(s))`);
+            return false;
+        }
+        const mode = report.full ? 'full' : 'affected';
+        const chunks = (report.affectedChunks || []).join(', ') || '(none)';
+        log.info(`${label} ok (${mode}; chunks=[${chunks}]; ${(report.emitted ?? []).length} emitted)`);
+        return true;
+    }
+    async function start() {
+        const src = path.join(project, 'src');
+        if (!existsSync(src)) {
+            throw new Error(`vmz dev: missing src/ under ${project}`);
+        }
+        log.info('initial build (N-API workspace, full)…');
+        // Empty dirty → full project build (N4).
+        const initial = rebuild();
+        if (!printReport(initial, 'build')) {
+            throw new Error('vmz dev: initial build failed');
+        }
+        if (projectHasDocuments(project)) {
+            const docs = await buildIntegratedDocuments({ projectRoot: project, outDir });
+            if (!docs.ok) {
+                throw new Error('vmz dev: integrated document build failed');
+            }
+        }
+        const hostJs = path.join(outDir, 'vmz-serve-host.mjs');
+        if (!existsSync(hostJs)) {
+            throw new Error(`vmz dev: missing ${hostJs}`);
+        }
+        child = spawnHost({ project, outDir, host, port });
+        const docsRoot = path.join(project, 'documents');
+        const watchRoots = [src].concat(existsSync(docsRoot) ? [docsRoot] : []);
+        log.info(`dev → http://${host}:${port} (watching ${watchRoots.join(', ')})`);
+        /** @type {Map<string, Map<string, string>>} */
+        let fingerprints = new Map();
+        for (const root of watchRoots) {
+            fingerprints.set(root, fileFingerprintMap(root));
+        }
+        const signal = options.signal;
+        const onAbort = () => {
+            void stop();
+        };
+        signal?.addEventListener('abort', onAbort, { once: true });
+        try {
+            while (!stopped && !signal?.aborted) {
+                await sleep(pollMs);
+                if (stopped || signal?.aborted)
+                    break;
+                if (child && child.exitCode != null) {
+                    throw new Error(`vmz serve-host exited: ${child.exitCode}`);
+                }
+                /** @type {{ srcChanged: string[], srcDeleted: string[], docsDirty: boolean }} */
+                let batch = { srcChanged: [], srcDeleted: [], docsDirty: false };
+                try {
+                    // Probe only — keep prior fingerprints until debounce resample
+                    // (same contract as pre-docs watcher: empty second pass would miss soft reload).
+                    for (const root of watchRoots) {
+                        const prev = fingerprints.get(root) || new Map();
+                        const next = fileFingerprintMap(root);
+                        const diff = diffFingerprints(prev, next);
+                        if (root === src) {
+                            batch.srcChanged = diff.changed;
+                            batch.srcDeleted = diff.deleted;
+                        }
+                        else if (diff.changed.length || diff.deleted.length) {
+                            batch.docsDirty = true;
+                        }
+                    }
+                }
+                catch (err) {
+                    log.warn('watch error:', err);
+                    continue;
+                }
+                if (!batch.srcChanged.length && !batch.srcDeleted.length && !batch.docsDirty)
+                    continue;
+                await sleep(200);
+                // Resample against the same prior fingerprints, then commit.
+                batch = { srcChanged: [], srcDeleted: [], docsDirty: false };
+                for (const root of watchRoots) {
+                    const prev = fingerprints.get(root) || new Map();
+                    const next = fileFingerprintMap(root);
+                    const diff = diffFingerprints(prev, next);
+                    fingerprints.set(root, next);
+                    if (root === src) {
+                        batch.srcChanged = diff.changed;
+                        batch.srcDeleted = diff.deleted;
+                    }
+                    else if (diff.changed.length || diff.deleted.length) {
+                        batch.docsDirty = true;
+                    }
+                }
+                if (!batch.srcChanged.length && !batch.srcDeleted.length && !batch.docsDirty)
+                    continue;
+                let needFullReload = batch.docsDirty;
+                if (batch.srcChanged.length || batch.srcDeleted.length) {
+                    log.info(`change detected (${batch.srcChanged.length} update, ${batch.srcDeleted.length} delete) — affected rebuild…`);
+                    const changes = [
+                        ...batch.srcChanged.map((p) => ({ path: p, kind: /** @type {'update'} */ ('update') })),
+                        ...batch.srcDeleted.map((p) => ({ path: p, kind: /** @type {'delete'} */ ('delete') })),
+                    ];
+                    const report = rebuild(changes);
+                    if (!printReport(report, 'rebuild')) {
+                        log.warn('rebuild failed — keeping previous server');
+                        continue;
+                    }
+                    if (batch.docsDirty || projectHasDocuments(project)) {
+                        // App rebuild may refresh designs CSS consumed by documents.
+                        const docs = await buildIntegratedDocuments({ projectRoot: project, outDir });
+                        if (!docs.ok) {
+                            log.warn('document mount rebuild failed — keeping previous docs');
+                        }
+                        else {
+                            needFullReload = true;
+                        }
+                    }
+                    try {
+                        await softReload(host, port, {
+                            affectedChunks: report.affectedChunks ?? [],
+                            seedChunks: report.seedChunks ?? [],
+                            full: Boolean(report.full) || needFullReload,
+                            islandHmr: Boolean(report.islandHmr) && !needFullReload,
+                        });
+                        log.info(needFullReload
+                            ? 'soft reload ok (full page; docs)'
+                            : report.islandHmr
+                                ? 'soft reload ok (island HMR)'
+                                : 'soft reload ok (full page)');
+                    }
+                    catch (err) {
+                        log.warn(`soft reload failed (${err}) — restarting serve-host…`);
+                        killChild(child);
+                        child = spawnHost({ project, outDir, host, port });
+                    }
+                    continue;
+                }
+                if (batch.docsDirty) {
+                    log.info('documents change detected — rebuilding document mount…');
+                    const docs = await buildIntegratedDocuments({ projectRoot: project, outDir });
+                    if (!docs.ok) {
+                        log.warn('document mount rebuild failed — keeping previous docs');
+                        continue;
+                    }
+                    try {
+                        await softReload(host, port, { full: true, islandHmr: false });
+                        log.info('soft reload ok (full page; docs)');
+                    }
+                    catch (err) {
+                        log.warn(`soft reload failed (${err}) — restarting serve-host…`);
+                        killChild(child);
+                        child = spawnHost({ project, outDir, host, port });
+                    }
+                }
+            }
+        }
+        finally {
+            signal?.removeEventListener('abort', onAbort);
+            await stop();
+        }
+    }
+    async function stop() {
+        if (stopped)
+            return;
+        stopped = true;
+        killChild(child);
+        child = null;
+        try {
+            ws.dispose();
+        }
+        catch {
+            /* ignore */
+        }
+    }
+    return { ws, rebuild, start, stop, project, outDir, host, port };
+}
+/** @deprecated use fileFingerprintMap */
+export function srcFingerprint(srcDir) {
+    const map = fileFingerprintMap(srcDir);
+    let h = 0xcbf29ce484222325n;
+    const keys = [...map.keys()].sort();
+    for (const k of keys) {
+        for (const b of Buffer.from(`${k}|${map.get(k)}`)) {
+            h = (h * 0x100000001b3n + BigInt(b)) & 0xffffffffffffffffn;
+        }
+    }
+    return Number(h & 0xffffffffffffffffn);
+}
+/** @deprecated */
+export function listWatchedFiles(srcDir) {
+    return [...fileFingerprintMap(srcDir).keys()];
+}
+function defaultSpawnHost(opts) {
+    const hostJs = path.join(opts.outDir, 'vmz-serve-host.mjs');
+    const node = process.env.VMZ_NODE || process.execPath;
+    return spawn(node, [hostJs], {
+        cwd: opts.project,
+        env: {
+            ...process.env,
+            VMZ_DIST: opts.outDir,
+            VMZ_PORT: String(opts.port),
+            VMZ_HOST: opts.host,
+            VMZ_DEV: '1',
+        },
+        stdio: ['ignore', 'inherit', 'inherit'],
+    });
+}
+/**
+ * @param {string} host
+ * @param {number} port
+ * @param {object} [payload]
+ */
+async function defaultSoftReload(host, port, payload = {}) {
+    const url = `http://${host}:${port}/__vmz/reload`;
+    const body = JSON.stringify(payload);
+    const res = await fetch(url, {
+        method: 'POST',
+        headers: { 'content-type': 'application/json' },
+        body,
+    });
+    if (!res.ok)
+        throw new Error(`HTTP ${res.status}`);
+    const json = await res.json().catch(() => ({}));
+    if (!json?.ok)
+        throw new Error(JSON.stringify(json));
+}
+function killChild(child) {
+    if (!child || child.killed)
+        return;
+    try {
+        child.kill();
+    }
+    catch {
+        /* ignore */
+    }
+}
+function sleep(ms) {
+    return new Promise((r) => setTimeout(r, ms));
+}