@vmz/vmz 0.0.4 → 0.1.1

package/dist/cli.js

@@ -5,7 +5,7 @@
 import { spawn } from 'node:child_process';
 import { copyFileSync, existsSync } from 'node:fs';
 import path from 'node:path';
-import { HOST_PROTOCOL, createWorkspace, getProtocolVersions, resolveCoreRuntimeDist } from './index.js';
+import { HOST_PROTOCOL, createWorkspace, getProtocolVersions, resolveCoreRuntimeDist, resolveNativePath } from './index.js';
 import { createDevSession } from './dev-session.js';
 import { gateGlobalProjectCommand, getInvocationContext, isGlobalAllowedCommand } from './invocation.js';
 import { log } from './log.js';
@@ -16,14 +16,16 @@ import { cmdDocument } from './document-cmd.js';
 import { buildIntegratedDocuments, projectHasDocuments } from './document-integrate.js';
 import { cmdLocale } from './locale-cmd.js';
 import { emitLocaleRuntimeModules, localeHasErrors } from './locale-check.js';
+import { emitLocaleRouteRealization } from './locale-route-emit.js';
 import { cmdApplication } from './application-cmd.js';
 import { cmdArtifact } from './release-cmd.js';
 import { cmdRefactor } from './refactor-cmd.js';
 import { cmdExplain } from './explain-cmd.js';
 import { resolveNativeVmzCli } from './resolve-native-cli.js';
-import { emitWebStatic } from './static-emit.js';
-import { emitSiteDelivery } from './site-delivery.js';
 import { loadVmzConfig } from './plugin-host.js';
+import { normalizeDeliveryAuthoring, selectBuildProfile } from './delivery-profile.js';
+import { packFromDeploymentIr } from './pack.js';
+import { assembleDelivery, emitBuildProof } from './build-assemble.js';
 /**
  * @param {string[]} argv
  */
@@ -104,8 +106,8 @@ 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 dev [path] [options]      Rebuild session; --target mini-program-wechat packs dist/wechat
+  vmz format [path] [--check]   Format .vmz via N-API (oxc formatter + EditorConfig)
   vmz lint [path] [--deny-warnings]  Lint (= check) via N-API
   vmz test [path] [options]     Native test discover / report
   vmz document|docs <cmd>       Project /documents domain 
@@ -120,9 +122,10 @@ Usage:
 
 Options:
   --out-dir, -o <dir>   Output directory (default: dist)
-  --release             Release build (build only)
-  --profile <name>      Delivery profile after build (web-static)
-  --origin <url>        Site origin for web-static canonical/sitemap
+  --release             Release build (omit serve-host; pack minify slot; proof)
+  --profile <name>      Delivery profile (default from config; builtins: web-ssr|web-static|web-client|web-hybrid)
+  --target <id>         Dev preview: browser (default) | mini-program-wechat (pack dist/wechat; WeChat DevTools)
+  --origin <url>        Site origin for static-cdn canonical/sitemap
   --host <host>         Listen host (default: 127.0.0.1)
   --port <port>         Listen port (dev: omit = auto from 5173; set = lock)
   --poll-ms <ms>        Dev watch poll interval (default: 300)
@@ -281,7 +284,11 @@ function cmdCheck(args) {
     try {
         return runWithPlugins(ws, project, outDir, async () => {
             const report = ws.check();
-            const errors = log.diagnostics(report.diagnostics ?? []);
+            const { checkLocales, localeHasErrors } = await import('./locale-check.js');
+            const localeReport = checkLocales({ projectRoot: project, checkUnused: false });
+            // Locale policy is first-class: missing /locales is warning (not silent), hard errors still fail.
+            const errors = log.diagnostics([...(report.diagnostics ?? []), ...(localeReport.diagnostics ?? [])]) ||
+                (localeHasErrors(localeReport) ? 1 : 0);
             log.info(`checked ${report.filesChecked} file(s)`);
             return errors ? 1 : 0;
         });
@@ -290,6 +297,23 @@ function cmdCheck(args) {
         ws.dispose();
     }
 }
+/**
+ * Dedupe locale/build diagnostics by code+path+message (runtime + route emit both report missing manifest).
+ * @param {Array<{ code?: string, path?: string, message?: string, severity?: string }>} list
+ */
+function dedupeDiagnostics(list) {
+    const seen = new Set();
+    /** @type {typeof list} */
+    const out = [];
+    for (const d of list || []) {
+        const key = `${d.code || ''}\0${d.path || ''}\0${d.message || ''}\0${d.severity || ''}`;
+        if (seen.has(key))
+            continue;
+        seen.add(key);
+        out.push(d);
+    }
+    return out;
+}
 /**
  * @param {import('./index.js').Workspace} ws
  * @param {string} project
@@ -316,6 +340,21 @@ async function cmdBuild(args) {
     log.info(`build ${project} → ${outDir}`);
     const ws = createWorkspace({ root: project, outDir });
     try {
+        const cfg = await loadVmzConfig(project);
+        const cliProfile = typeof args.profile === 'string' ? args.profile : '';
+        const norm = normalizeDeliveryAuthoring(cfg.delivery ?? null);
+        if (!norm.ok) {
+            log.diagnostics(norm.diagnostics ?? []);
+            log.error('delivery authoring invalid');
+            return 1;
+        }
+        const selected = selectBuildProfile(norm.table, cliProfile);
+        if (!selected.ok) {
+            log.diagnostics(selected.diagnostics ?? []);
+            log.error(`unknown build --profile ${cliProfile || norm.table.default}`);
+            return 1;
+        }
+        log.info(`delivery profile ${selected.selection.profileId} (assembly=${selected.selection.assembly})`);
         const code = await runWithPlugins(ws, project, outDir, () => {
             const report = ws.build(Boolean(args.release));
             const errors = log.diagnostics(report.diagnostics ?? []);
@@ -330,47 +369,96 @@ async function cmdBuild(args) {
         if (code !== 0)
             return code;
         const localeEmit = emitLocaleRuntimeModules(project, outDir);
+        const localeRoutes = emitLocaleRouteRealization(project, outDir, {
+            origin: typeof args.origin === 'string' ? args.origin : undefined,
+        });
+        // Always surface locale diagnostics (warnings included) — missing /locales must not be silent.
+        // Dedupe: runtime emit + route realization both report the same missing-manifest warning.
+        const localeDiags = dedupeDiagnostics([...(localeEmit.diagnostics ?? []), ...(localeRoutes.diagnostics ?? [])]);
+        log.diagnostics(localeDiags);
         if (!localeEmit.ok || localeHasErrors({ diagnostics: localeEmit.diagnostics })) {
-            log.diagnostics(localeEmit.diagnostics ?? []);
             log.error('locale runtime emit failed');
             return 1;
         }
         if (localeEmit.written.length) {
             log.info(`locale runtime emit (${localeEmit.written.length} module(s))`);
         }
+        if (!localeRoutes.ok) {
+            log.error('locale route realization emit failed');
+            return 1;
+        }
+        if (localeRoutes.written.length) {
+            log.info(`locale route realization (${localeRoutes.written.length} artifact(s))`);
+        }
         if (projectHasDocuments(project)) {
             const docs = await buildIntegratedDocuments({ projectRoot: project, outDir });
             if (!docs.ok)
                 return 1;
         }
-        const cfg = await loadVmzConfig(project);
-        if (cfg.delivery) {
-            log.info(`site-delivery emit ${outDir}`);
-            const site = emitSiteDelivery(outDir, cfg.delivery, {
-                siteId: cfg.application?.id || undefined,
+        let pack = null;
+        try {
+            pack = packFromDeploymentIr(outDir, {
+                release: Boolean(args.release),
+                profileId: selected.selection.profileId,
+                assembly: selected.selection.assembly,
+                coreDist: resolveCoreRuntimeDist(),
+                projectRoot: project,
             });
-            log.info(`site-delivery ok (digest=${String(site.contract.contractDigest).slice(0, 12)}…)`);
+            const lower = pack.manifest?.clientPackageLowering;
+            if (lower?.bareSpecs?.length) {
+                log.info(`pack client packages (${lower.bareSpecs.length} bare → vendor; rewritten=${lower.rewrittenFiles})`);
+            }
+            if (lower?.remainingBareSpecs?.length) {
+                log.warn(`pack client packages: ${lower.remainingBareSpecs.length} bare specifier(s) still unresolved for browser: ${lower.remainingBareSpecs.slice(0, 8).join(', ')}${lower.remainingBareSpecs.length > 8 ? '…' : ''}`);
+            }
+            log.info(`pack ok (units=${pack.manifest.unitCount}, digest=${String(pack.manifest.packDigest).slice(0, 12)}…)`);
         }
-        const profile = typeof args.profile === 'string' ? args.profile : '';
-        if (profile === 'web-static') {
-            const origin = typeof args.origin === 'string' ? args.origin : undefined;
-            log.info(`web-static emit ${outDir}`);
-            const result = await emitWebStatic(outDir, { origin });
-            log.info(`web-static ok (${result.htmlFiles.length} html, ${result.skipped.length} skipped, digest=${result.digest.slice(0, 12)}…)`);
+        catch (err) {
+            log.error(`pack failed: ${err instanceof Error ? err.message : String(err)}`);
+            return 1;
+        }
+        const origin = typeof args.origin === 'string' ? args.origin : undefined;
+        let assemble = null;
+        try {
+            if (selected.selection.assembly === 'static-cdn') {
+                log.info(`web-static emit ${outDir}`);
+            }
+            assemble = await assembleDelivery(outDir, {
+                selection: selected.selection,
+                profile: {
+                    ...selected.profile,
+                    sources: selected.profile.sources || (norm.table.sugar ? norm.table.profiles[norm.table.default]?.sources : null),
+                },
+                siteId: cfg.application?.id || undefined,
+                origin,
+                pack: pack.manifest,
+            });
+            for (const step of assemble.manifest.steps || []) {
+                if (step.kind === 'static-cdn') {
+                    log.info(`web-static ok (${step.htmlFiles} html, ${step.skipped} skipped, digest=${String(step.digest).slice(0, 12)}…)`);
+                }
+                else if (step.kind === 'site-delivery' && step.digest) {
+                    log.info(`site-delivery ok (digest=${String(step.digest).slice(0, 12)}…)`);
+                }
+            }
         }
-        else if (profile) {
-            log.error(`unknown build --profile ${profile} (supported: web-static)`);
+        catch (err) {
+            log.error(`assemble failed: ${err instanceof Error ? err.message : String(err)}`);
             return 1;
         }
+        const proof = emitBuildProof(outDir, {
+            selection: selected.selection,
+            pack: pack.manifest,
+            assemble: assemble.manifest,
+            release: Boolean(args.release),
+        });
+        log.info(`build-proof ok (profile=${proof.proof.profileId}, slots=${proof.proof.semanticIds.join(',')})`);
         return 0;
     }
     finally {
         ws.dispose();
     }
 }
-/**
- * @param {Record<string, string | boolean> & { _: string[] }} args
- */
 async function cmdServe(args) {
     const pathArg = args._[0] ?? '.';
     if (args.build) {
@@ -406,6 +494,7 @@ async function cmdServe(args) {
             VMZ_DIST: outDir,
             VMZ_PORT: String(port),
             VMZ_HOST: host,
+            VMZ_NATIVE_NODE: resolveNativePath(),
         },
         stdio: 'inherit',
     });
@@ -452,6 +541,11 @@ async function cmdDev(args) {
         }
     }
     const pollMs = Number(args['poll-ms'] ?? 300);
+    const targetRaw = typeof args.target === 'string' ? args.target : 'browser';
+    if (targetRaw !== 'browser' && targetRaw !== 'mini-program-wechat') {
+        log.error(`unknown --target ${targetRaw} (browser | mini-program-wechat)`);
+        return 1;
+    }
     const ac = new AbortController();
     const onSig = () => {
         log.info('shutting down…');
@@ -465,6 +559,7 @@ async function cmdDev(args) {
         host,
         port,
         pollMs,
+        target: targetRaw,
         signal: ac.signal,
     });
     try {

package/dist/content-addressed-assets.js

@@ -8,6 +8,7 @@ import crypto from 'node:crypto';
 import fs from 'node:fs';
 import path from 'node:path';
 import { canonicalJson, sha256Hex } from './release-pack.js';
+import { writePrettyJsonFile } from './pretty-json.js';
 export const CONTENT_ADDRESSED_ASSETS_SCHEMA = 'vmz.content_addressed_assets.v0';
 /** Immutable delivery candidates (client-facing bytes). */
 const DEFAULT_CANDIDATES = [
@@ -85,7 +86,7 @@ export function emitContentAddressedAssets(distDir, opts = {}) {
     const vmzDir = path.join(abs, '_vmz');
     fs.mkdirSync(vmzDir, { recursive: true });
     const outPath = path.join(vmzDir, 'content-addressed-assets.json');
-    fs.writeFileSync(outPath, `${JSON.stringify(manifest, null, 2)}\n`, 'utf8');
+    writePrettyJsonFile(outPath, manifest);
     return { manifest, assetsDir, rewrites, manifestPath: outPath };
 }
 /**

package/dist/delivery-profile.d.ts

@@ -0,0 +1,84 @@
+/**
+ * B0 — Delivery profile authoring normalize + CLI --profile resolve.
+ * Pure data only; expands legacy site-delivery sugar into profiles[default].
+ */
+export declare const DELIVERY_PROFILE_AUTHORING_SCHEMA = "vmz.delivery.authoring.v0";
+export declare const BUILD_PROFILE_SELECTION_SCHEMA = "vmz.build.profile_selection.v0";
+/** Browser-era assembly kinds (04 B5). */
+export declare const ASSEMBLIES: readonly string[];
+export declare const SERVER_RUNTIMES: readonly string[];
+/** Official built-in aliases when not overridden in config. */
+export declare const BUILTIN_PROFILES: Readonly<{
+    'web-client': {
+        host: string;
+        assembly: string;
+    };
+    'web-static': {
+        host: string;
+        assembly: string;
+    };
+    'web-ssr': {
+        host: string;
+        assembly: string;
+        serverRuntime: string;
+    };
+    'web-hybrid': {
+        host: string;
+        assembly: string;
+        serverRuntime: string;
+    };
+}>;
+export declare function pickSiteAuthoring(raw: any): {
+    artifact: string;
+    sources: any;
+};
+/**
+ * `delivery.packaging.wechat` — vendor identity, not WeChat JSON / wx APIs.
+ * @param {unknown} raw
+ * @param {Array<{ code: string, message: string }>} diagnostics
+ */
+export declare function pickDeliveryPackaging(raw: any, diagnostics: any): {
+    wechat?: undefined;
+} | {
+    wechat: {};
+};
+export declare function normalizeDeliveryAuthoring(raw: any): {
+    ok: boolean;
+    table: {
+        schema: string;
+        default: string;
+        profiles: {};
+        sugar: boolean;
+    };
+    diagnostics?: undefined;
+} | {
+    ok: boolean;
+    diagnostics: any[];
+    table?: undefined;
+};
+export declare function selectBuildProfile(table: any, cliProfile?: string): {
+    ok: boolean;
+    diagnostics: {
+        code: string;
+        message: string;
+    }[];
+    selection?: undefined;
+    profile?: undefined;
+} | {
+    ok: boolean;
+    selection: {
+        schema: string;
+        profileId: any;
+        host: any;
+        assembly: any;
+        serverRuntime: any;
+        hasSiteSources: boolean;
+        authoringDigest: any;
+        fromCli: boolean;
+    };
+    profile: any;
+    diagnostics?: undefined;
+};
+export declare function semanticIdsForAssembly(assembly: any): string[];
+export declare function canonicalJson(value: any): string;
+export declare function sha256Hex(text: any): string;