@vmz/test 0.0.0 → 0.0.2

package/dist/deployment.js

@@ -0,0 +1,181 @@
+/**
+ * Deployment host for `vmz test --mode deployment` (T3).
+ * Proves deployment IR + server capability isolation (client stubs vs #server body).
+ */
+import fs from 'node:fs';
+import path from 'node:path';
+function readJson(p) {
+    try {
+        return JSON.parse(fs.readFileSync(p, 'utf8'));
+    }
+    catch {
+        return null;
+    }
+}
+function resolveServerArtifact(outDir, moduleId) {
+    // moduleId like "#server/components/UserCard"
+    const rel = moduleId.replace(/^#server\//, '').replace(/^\/+/, '');
+    const candidates = [
+        path.join(outDir, '#server', `${rel}.js`),
+        path.join(outDir, '_vmz_server', `${rel}.js`),
+        path.join(outDir, 'src', path.dirname(rel), `${path.basename(rel)}Server.server.js`),
+        path.join(outDir, 'src', `${rel}.server.js`),
+    ];
+    for (const c of candidates) {
+        if (fs.existsSync(c))
+            return c;
+    }
+    return null;
+}
+export function runDeploymentManifest(manifest, ctx) {
+    const diagnostics = [];
+    const fail = (message, extra = {}) => {
+        diagnostics.push({ severity: 'error', message, ...extra });
+    };
+    const program = manifest.program && typeof manifest.program === 'object' ? manifest.program : {};
+    const chunkId = String(program.chunkId || '');
+    const programId = chunkId || null;
+    const plan = manifest.plan && typeof manifest.plan === 'object' ? manifest.plan : {};
+    const planId = plan.ref ? String(plan.ref) : plan.schema ? String(plan.schema) : null;
+    const depPath = path.join(ctx.outDir, 'vmz-deployment.json');
+    if (!fs.existsSync(depPath)) {
+        fail('missing vmz-deployment.json');
+        return { status: 'failed', diagnostics, planId, programId };
+    }
+    const deploy = readJson(depPath);
+    if (!deploy) {
+        fail('unreadable vmz-deployment.json');
+        return { status: 'error', diagnostics, planId, programId };
+    }
+    const units = deploy.units || [];
+    const unit = (chunkId && units.find((u) => String(u.chunkId || '') === chunkId)) ||
+        (chunkId && units.find((u) => String(u.chunkId || '').includes(chunkId))) ||
+        null;
+    const assertions = Array.isArray(manifest.assertions) ? manifest.assertions : [];
+    for (const raw of assertions) {
+        const a = raw && typeof raw === 'object' ? raw : {};
+        const kind = String(a.kind || '');
+        const expect = (a.expect && typeof a.expect === 'object' ? a.expect : {}) || {};
+        if (kind === 'deploymentFile' || kind === 'deployment') {
+            if (expect.schema != null && deploy.schema !== expect.schema) {
+                fail(`deployment schema want ${expect.schema}, got ${deploy.schema}`);
+            }
+            if (expect.deploymentFileSchema != null && deploy.schema !== expect.deploymentFileSchema) {
+                fail(`deployment schema want ${expect.deploymentFileSchema}, got ${deploy.schema}`);
+            }
+            if (expect.resumeComponent != null) {
+                const name = String(expect.resumeComponent);
+                const resumes = unit?.resumeEntries || unit?.resume_entries || [];
+                const hit = resumes.find((e) => (e.component || e.Component) === name);
+                if (!hit) {
+                    // also search all units
+                    const any = units.some((u) => {
+                        const rs = u.resumeEntries || [];
+                        return rs.some((e) => e.component === name);
+                    });
+                    if (!any)
+                        fail(`resumeEntries missing ${name}`);
+                }
+                else if (expect.strategy != null && String(hit.strategy || '') !== String(expect.strategy)) {
+                    fail(`resume strategy want ${expect.strategy}, got ${hit.strategy}`);
+                }
+            }
+            continue;
+        }
+        if (kind === 'serverCapability') {
+            const targetChunk = String(expect.chunkId || chunkId || '');
+            const u = units.find((x) => String(x.chunkId || '') === targetChunk);
+            if (!u) {
+                fail(`deployment unit missing ${targetChunk}`);
+                continue;
+            }
+            const moduleId = u.serverModuleId != null ? String(u.serverModuleId) : '';
+            if (expect.serverModuleId != null && moduleId !== String(expect.serverModuleId)) {
+                fail(`serverModuleId want ${expect.serverModuleId}, got ${moduleId || 'null'}`);
+            }
+            if (!moduleId) {
+                fail(`unit ${targetChunk} has no serverModuleId`);
+                continue;
+            }
+            const caps = u.capabilities || [];
+            const wantCaps = Array.isArray(expect.capabilities) ? expect.capabilities.map(String) : [];
+            for (const c of wantCaps) {
+                if (!caps.includes(c))
+                    fail(`capability missing ${c}: ${JSON.stringify(caps)}`);
+            }
+            continue;
+        }
+        if (kind === 'serverIsolation') {
+            const targetChunk = String(expect.chunkId || chunkId || '');
+            const u = units.find((x) => String(x.chunkId || '') === targetChunk);
+            if (!u) {
+                fail(`deployment unit missing ${targetChunk}`);
+                continue;
+            }
+            const moduleId = u.serverModuleId != null ? String(u.serverModuleId) : '';
+            if (!moduleId) {
+                fail(`unit ${targetChunk} has no serverModuleId for isolation check`);
+                continue;
+            }
+            const serverPath = resolveServerArtifact(ctx.outDir, moduleId);
+            if (!serverPath) {
+                fail(`server artifact missing for ${moduleId}`);
+                continue;
+            }
+            const serverSrc = fs.readFileSync(serverPath, 'utf8');
+            const clientEntry = u.clientEntry != null ? String(u.clientEntry) : `${targetChunk}.client.js`;
+            const clientPath = path.join(ctx.outDir, clientEntry);
+            if (!fs.existsSync(clientPath)) {
+                fail(`client entry missing ${clientEntry}`);
+                continue;
+            }
+            const clientSrc = fs.readFileSync(clientPath, 'utf8');
+            // Server body must exist as a real module (not only a callServer stub file).
+            if (!/export\s+(default\s+)?class\s+\w+/.test(serverSrc) && !/export\s+\{/.test(serverSrc)) {
+                fail(`server artifact looks empty: ${path.relative(ctx.outDir, serverPath)}`);
+            }
+            // Client must route through callServer for declared capabilities (stub isolation).
+            const caps = Array.isArray(expect.capabilities)
+                ? expect.capabilities.map(String)
+                : (u.capabilities || []).map(String);
+            for (const c of caps) {
+                if (!clientSrc.includes('callServer')) {
+                    fail(`client entry missing callServer stub (${clientEntry})`);
+                    break;
+                }
+                if (!clientSrc.includes(JSON.stringify(c)) && !clientSrc.includes(`"${c}"`) && !clientSrc.includes(`'${c}'`)) {
+                    fail(`client stub missing capability name ${c}`);
+                }
+            }
+            // Client must not embed the full server file content (naive leak check).
+            const serverBodyMarker = serverSrc
+                .split('\n')
+                .map((l) => l.trim())
+                .find((l) => l.startsWith('return ') || l.includes('Ada') || l.includes('profile'));
+            if (serverBodyMarker && serverBodyMarker.length > 12 && clientSrc.includes(serverBodyMarker)) {
+                fail(`client appears to embed server body marker: ${serverBodyMarker.slice(0, 80)}`);
+            }
+            continue;
+        }
+        if (kind === 'graph' || kind === 'plan' || kind === 'diagnostic') {
+            continue;
+        }
+        fail(`unknown deployment assertion ${JSON.stringify(kind)}`);
+    }
+    // Optional actions are reserved (no runtime schedule for deployment IR checks).
+    const actions = Array.isArray(manifest.actions) ? manifest.actions : [];
+    for (const raw of actions) {
+        const a = raw && typeof raw === 'object' ? raw : {};
+        const kind = String(a.kind || '');
+        if (kind === 'noop' || kind === '')
+            continue;
+        fail(`unknown deployment action ${JSON.stringify(kind)}`);
+    }
+    const failed = diagnostics.some((d) => d.severity === 'error');
+    return {
+        status: failed ? 'failed' : 'passed',
+        diagnostics,
+        planId,
+        programId,
+    };
+}

package/dist/discover.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Discover VMZ native test manifests (T0).
+ */
+export declare function listManifestFiles(root: string): string[];
+export type DiscoveredManifest = Record<string, unknown> & {
+    file: string;
+    absoluteFile: string;
+};
+export declare function discoverTestManifests(projectRoot: string): {
+    manifests: DiscoveredManifest[];
+    errors: string[];
+};

package/dist/discover.js

@@ -0,0 +1,63 @@
+/**
+ * Discover VMZ native test manifests (T0).
+ */
+import fs from 'node:fs';
+import path from 'node:path';
+import { validateManifest } from './protocol.js';
+const MANIFEST_RE = /\.vmz\.(test|spec)\.json$/i;
+export function listManifestFiles(root) {
+    const abs = path.resolve(root);
+    const out = [];
+    walk(abs, out);
+    out.sort();
+    return out;
+}
+function walk(dir, out) {
+    let entries;
+    try {
+        entries = fs.readdirSync(dir, { withFileTypes: true });
+    }
+    catch {
+        return;
+    }
+    for (const ent of entries) {
+        const name = ent.name;
+        if (name === 'node_modules' || name === 'dist' || name === '.git' || name === 'target') {
+            continue;
+        }
+        const full = path.join(dir, name);
+        if (ent.isDirectory()) {
+            walk(full, out);
+            continue;
+        }
+        if (ent.isFile() && MANIFEST_RE.test(name)) {
+            out.push(full);
+        }
+    }
+}
+export function discoverTestManifests(projectRoot) {
+    const root = path.resolve(projectRoot);
+    const manifests = [];
+    const errors = [];
+    for (const file of listManifestFiles(root)) {
+        let raw;
+        try {
+            raw = JSON.parse(fs.readFileSync(file, 'utf8'));
+        }
+        catch (e) {
+            errors.push(`${file}: ${e instanceof Error ? e.message : String(e)}`);
+            continue;
+        }
+        const v = validateManifest(raw, file);
+        if (!v.ok) {
+            errors.push(v.error);
+            continue;
+        }
+        manifests.push({
+            ...v.manifest,
+            file: path.relative(root, file).split(path.sep).join('/'),
+            absoluteFile: file,
+        });
+    }
+    return { manifests, errors };
+}

package/dist/index.d.ts

@@ -0,0 +1,13 @@
+/**
+ * @vmz/test — programmable VMZ native test surface.
+ * CLI automation lives in `vmz` (`vmz test`); this package runs without it.
+ */
+export * from './protocol.js';
+export * from './discover.js';
+export { buildForCompile, resolveChunkArtifacts, runCompileManifest, type BuildOptions, type BuildResult, type CompileResult, type CreateWorkspaceFn, } from './compile.js';
+export { createLogicHost, installHeadlessDocument, runLogicManifest, type LogicHost, type LogicResult, } from './logic.js';
+export { runSsrManifest, type SsrResult } from './ssr.js';
+export { runResumeManifest, type ResumeResult } from './resume.js';
+export { runDeploymentManifest, type DeploymentResult } from './deployment.js';
+export { runBrowserManifest, resolveBrowserExecutable, type BrowserResult, } from './browser.js';
+export { runManifest, resultsToReport, type ManifestRunResult, type RunManifestOptions, } from './run.js';

package/dist/index.js

@@ -0,0 +1,13 @@
+/**
+ * @vmz/test — programmable VMZ native test surface.
+ * CLI automation lives in `vmz` (`vmz test`); this package runs without it.
+ */
+export * from './protocol.js';
+export * from './discover.js';
+export { buildForCompile, resolveChunkArtifacts, runCompileManifest, } from './compile.js';
+export { createLogicHost, installHeadlessDocument, runLogicManifest, } from './logic.js';
+export { runSsrManifest } from './ssr.js';
+export { runResumeManifest } from './resume.js';
+export { runDeploymentManifest } from './deployment.js';
+export { runBrowserManifest, resolveBrowserExecutable, } from './browser.js';
+export { runManifest, resultsToReport, } from './run.js';

package/dist/logic.d.ts

@@ -0,0 +1,40 @@
+/**
+ * Logic-mode host — headless document (linkedom), same Direct __vmzCreate as production.
+ * Design: 规划设计/vmz/16 — not Browser Host / Playwright.
+ */
+export declare function installHeadlessDocument(): Document;
+export type LogicHost = {
+    document: Document;
+    app: Element;
+    dom: any;
+    Component: any;
+    inst: any;
+    lastPrecision: Record<string, unknown> | null;
+    mount: (props?: object) => Promise<void>;
+    click: (selector?: string) => void;
+    write: (field: string, value: unknown) => void;
+    flush: () => Promise<void>;
+    destroy: () => void;
+    precisionReset: () => void;
+    precisionSnapshot: () => void;
+};
+export declare function createLogicHost(opts: {
+    outDir: string;
+    chunkId: string;
+    components?: Record<string, string>;
+}): Promise<LogicHost>;
+type Diag = {
+    severity: string;
+    message: string;
+    [k: string]: unknown;
+};
+export type LogicResult = {
+    status: 'passed' | 'failed' | 'error';
+    diagnostics: Diag[];
+    planId: string | null;
+    programId: string | null;
+};
+export declare function runLogicManifest(manifest: Record<string, unknown>, ctx: {
+    outDir: string;
+}): Promise<LogicResult>;
+export {};