@vmz/vmz 0.0.3 → 0.1.0

package/README.md

@@ -1,4 +1,7 @@
-# VMZ CLI
+# `@vmz/vmz` (bin: `vmz`)
+
+CLI / N-API toolchain host. Runtime mental entry is **`@vmz/core`**; optional official UI is **`@vmz/ui`**; plugins are
+**`@vmz/plugin-*`**. Shelved umbrella name: `@vmz/vmz`.
 
 When a project reaches the point where it has a browser surface, SSR, server work, documents, tests, and several
 deployment concerns, the usual workflow becomes a chain of tools that each see a different version of the application. A
@@ -22,9 +25,8 @@ With VMZ, a normal workflow is expected to answer all of these from the same sou
 - **Test:** what did a user interaction actually cause?
 - **Explain:** why did the compiler make that decision?
 
-Use it when you are adopting VMZ as the application model. It is intentionally not a compatibility compiler for
-arbitrary Vue components, React hooks, or legacy VDOM applications; those ecosystems are better served by their native
-toolchains.
+Use it when you are adopting VMZ as the application model. The CLI targets VMZ-native source and semantics; Vue, React,
+and legacy VDOM ecosystems keep their own toolchains.
 
 ## One tool, several views of the same program
 

package/dist/build-assemble.d.ts

@@ -0,0 +1,52 @@
+/**
+ * B5 Assemble dispatch + B6 build-proof (per-build semantic id slots).
+ */
+export declare const BUILD_PROOF_SCHEMA = "vmz.build.proof.v0";
+export declare const ASSEMBLE_MANIFEST_SCHEMA = "vmz.assemble.manifest.v0";
+/**
+ * @param {string} outDir
+ * @param {any} ctx
+ */
+export declare function assembleDelivery(outDir: any, ctx: any): Promise<{
+    manifest: {
+        schema: string;
+        profileId: any;
+        assembly: any;
+        serverRuntime: any;
+        steps: any[];
+    };
+    path: string;
+}>;
+/**
+ * @param {string} outDir
+ * @param {any} ctx
+ */
+export declare function emitBuildProof(outDir: any, ctx: any): {
+    proof: {
+        schema: string;
+        profileId: any;
+        assembly: any;
+        selectionDigest: any;
+        packDigest: any;
+        assembleDigest: any;
+        release: boolean;
+        semanticIds: string[];
+        slots: {
+            'server-host': {
+                status: string;
+            };
+            'static-delivery': {
+                status: string;
+            };
+            'site-fallback': {
+                status: string;
+            };
+            'asset-graph': {
+                status: string;
+            };
+        };
+        productionReadyClaim: boolean;
+        note: string;
+    };
+    path: string;
+};

package/dist/build-assemble.js

@@ -0,0 +1,191 @@
+/**
+ * B5 Assemble dispatch + B6 build-proof (per-build semantic id slots).
+ */
+// @ts-nocheck
+import { mkdirSync, writeFileSync } from 'node:fs';
+import path from 'node:path';
+import { semanticIdsForAssembly, sha256Hex, canonicalJson } from './delivery-profile.js';
+import { emitServerArtifact } from './server-artifact.js';
+import { emitEmbeddedPackaging } from './embedded-packaging.js';
+import { emitSiteDelivery } from './site-delivery.js';
+import { emitWebStatic } from './static-emit.js';
+export const BUILD_PROOF_SCHEMA = 'vmz.build.proof.v0';
+export const ASSEMBLE_MANIFEST_SCHEMA = 'vmz.assemble.manifest.v0';
+/**
+ * @param {string} outDir
+ * @param {any} ctx
+ */
+export async function assembleDelivery(outDir, ctx) {
+    const { selection, profile } = ctx;
+    const assembly = selection.assembly;
+    const result = {
+        schema: ASSEMBLE_MANIFEST_SCHEMA,
+        profileId: selection.profileId,
+        assembly,
+        serverRuntime: selection.serverRuntime || null,
+        steps: [],
+    };
+    if (assembly === 'static-cdn' || assembly === 'cdn+server') {
+        const staticResult = await emitWebStatic(outDir, { origin: ctx.origin });
+        result.steps.push({
+            kind: 'static-cdn',
+            digest: staticResult.digest,
+            htmlFiles: staticResult.htmlFiles?.length ?? 0,
+            skipped: staticResult.skipped?.length ?? 0,
+        });
+        result.staticDelivery = {
+            digest: staticResult.digest,
+            htmlFiles: staticResult.htmlFiles,
+            skipped: staticResult.skipped,
+        };
+    }
+    if (assembly === 'local-static') {
+        result.steps.push({
+            kind: 'local-static',
+            status: 'modules-ready',
+            note: 'client modules packed; no ServerArtifact',
+        });
+    }
+    if (assembly === 'server-host' || assembly === 'cdn+server') {
+        const server = emitServerArtifact(outDir, {
+            profileId: selection.profileId,
+            assembly,
+            serverRuntime: selection.serverRuntime || 'node',
+            packDigest: ctx.pack?.packDigest || null,
+        });
+        result.steps.push({
+            kind: 'server-host',
+            status: 'emitted',
+            digest: server.artifact.artifactDigest,
+            publicRoutes: server.artifact.publicRoutes?.length ?? 0,
+            internalCapabilities: server.artifact.internalCapabilities?.length ?? 0,
+            httpContractDigest: server.httpContractDigest,
+        });
+        result.serverArtifact = {
+            digest: server.artifact.artifactDigest,
+            httpContractDigest: server.httpContractDigest,
+            schema: server.artifact.schema,
+            selectedRuntime: server.artifact.selectedRuntime,
+        };
+    }
+    const siteAuthoring = profile.sources || null;
+    if (siteAuthoring || assembly === 'rust-embedded') {
+        if (!siteAuthoring) {
+            throw new Error('rust-embedded requires delivery sources (SiteDeliveryContract); cannot assemble without embedded|filesystem|remote baselines');
+        }
+        const site = emitSiteDelivery(outDir, siteAuthoring, {
+            siteId: ctx.siteId,
+        });
+        result.steps.push({
+            kind: 'site-delivery',
+            digest: site.contract.contractDigest,
+        });
+        result.siteDelivery = {
+            digest: site.contract.contractDigest,
+            schema: site.contract.schema,
+        };
+        if (assembly === 'rust-embedded') {
+            const pack = emitEmbeddedPackaging(outDir, {
+                siteId: ctx.siteId,
+                contractDigest: site.contract.contractDigest,
+            });
+            result.steps.push({
+                kind: 'embedded-packaging',
+                digest: pack.index.indexDigest,
+                objectCount: pack.index.objectCount,
+            });
+            result.embeddedPackaging = {
+                digest: pack.index.indexDigest,
+                objectCount: pack.index.objectCount,
+                schema: pack.index.schema,
+            };
+        }
+    }
+    result.packDigest = ctx.pack?.packDigest || null;
+    result.assembleDigest = sha256Hex(canonicalJson({ ...result, assembleDigest: undefined }));
+    const vmzDir = path.join(outDir, '_vmz');
+    mkdirSync(vmzDir, { recursive: true });
+    const file = path.join(vmzDir, 'assemble-manifest.json');
+    writeFileSync(file, `${JSON.stringify(result, null, 2)}\n`, 'utf8');
+    return { manifest: result, path: file };
+}
+/**
+ * @param {string} outDir
+ * @param {any} ctx
+ */
+export function emitBuildProof(outDir, ctx) {
+    const semanticIds = semanticIdsForAssembly(ctx.selection.assembly);
+    const slots = {
+        'server-host': { status: 'not-applicable' },
+        'static-delivery': { status: 'not-applicable' },
+        'site-fallback': { status: 'not-applicable' },
+        'asset-graph': { status: 'not-applicable' },
+    };
+    for (const id of semanticIds) {
+        if (id === 'static-delivery') {
+            const step = (ctx.assemble?.steps || []).find((s) => s.kind === 'static-cdn');
+            slots[id] = step
+                ? { status: 'emitted', detail: `digest=${String(step.digest).slice(0, 12)}` }
+                : { status: 'pending', detail: 'assembly requires static emit' };
+        }
+        else if (id === 'site-fallback') {
+            const siteStep = (ctx.assemble?.steps || []).find((s) => s.kind === 'site-delivery');
+            const packStep = (ctx.assemble?.steps || []).find((s) => s.kind === 'embedded-packaging');
+            if (siteStep && packStep) {
+                slots[id] = {
+                    status: 'emitted',
+                    detail: `contract=${String(siteStep.digest).slice(0, 12)}; pack=${String(packStep.digest).slice(0, 12)}; objects=${packStep.objectCount ?? '?'}`,
+                };
+            }
+            else if (siteStep && siteStep.status !== 'skipped') {
+                slots[id] = {
+                    status: 'pending',
+                    detail: 'site contract emitted; embedded packaging missing',
+                };
+            }
+            else {
+                slots[id] = { status: 'pending', detail: siteStep?.reason || 'no site sources' };
+            }
+        }
+        else if (id === 'server-host') {
+            const step = (ctx.assemble?.steps || []).find((s) => s.kind === 'server-host');
+            slots[id] =
+                step && step.status === 'emitted'
+                    ? {
+                        status: 'emitted',
+                        detail: `digest=${String(step.digest).slice(0, 12)}; routes=${step.publicRoutes ?? 0}; internal=${step.internalCapabilities ?? 0}`,
+                    }
+                    : {
+                        status: 'pending',
+                        detail: step?.note || 'ServerArtifact not emitted',
+                    };
+        }
+        else if (id === 'asset-graph') {
+            slots[id] = {
+                status: ctx.pack?.packDigest ? 'pack-digest' : 'pending',
+                detail: ctx.pack?.packDigest
+                    ? `pack=${String(ctx.pack.packDigest).slice(0, 12)} units=${ctx.pack.unitCount ?? '?'}`
+                    : 'pack missing',
+            };
+        }
+    }
+    const body = {
+        schema: BUILD_PROOF_SCHEMA,
+        profileId: ctx.selection.profileId,
+        assembly: ctx.selection.assembly,
+        selectionDigest: ctx.selection.digest || null,
+        packDigest: ctx.pack?.packDigest || null,
+        assembleDigest: ctx.assemble?.assembleDigest || null,
+        release: Boolean(ctx.release),
+        semanticIds,
+        slots,
+        productionReadyClaim: false,
+        note: 'Aggregate production-ready requires browser-production + cleared production-proof gaps (08)',
+    };
+    body.proofDigest = sha256Hex(canonicalJson({ ...body, proofDigest: undefined }));
+    const vmzDir = path.join(outDir, '_vmz');
+    mkdirSync(vmzDir, { recursive: true });
+    const file = path.join(vmzDir, 'build-proof.json');
+    writeFileSync(file, `${JSON.stringify(body, null, 2)}\n`, 'utf8');
+    return { proof: body, path: file };
+}

package/dist/cdn-policy.d.ts

@@ -0,0 +1,196 @@
+/**
+ * A3-cdn: vendor-neutral CDN policy (cache / redirect / error) + local static host.
+ * Provider adapters only project the same contract — they must not change RouteId/canonical/CSP.
+ */
+export declare const CDN_POLICY_MANIFEST_SCHEMA = "vmz.cdn.policy_manifest.v0";
+export declare const CDN_ADAPTER_PROJECTION_SCHEMA = "vmz.cdn.adapter_projection.v0";
+/** HTML: revalidate. Hashed/static assets: long immutable. */
+export declare const CACHE_HTML = "public, max-age=0, must-revalidate";
+export declare const CACHE_ASSET_IMMUTABLE = "public, max-age=31536000, immutable";
+export declare const CACHE_META = "public, max-age=3600";
+/**
+ * Build CDNPolicyManifest from StaticDeliveryManifest (+ optional redirects / locale artifact).
+ * Locale-prefixed HTML gets LocaleId-encoded cache keys; Accept-Language must not steal body.
+ * @param {Record<string, any>} staticManifest
+ * @param {{
+ *   redirects?: Array<{ from: string, to: string, status?: number, reason?: string }>,
+ *   localeArtifact?: Record<string, any> | null,
+ * }} [opts]
+ */
+export declare function buildCdnPolicyManifest(staticManifest: any, opts?: {}): {
+    schema: string;
+    applicationId: any;
+    deliveryProfile: string;
+    origin: string;
+    spaFallback: boolean;
+    staticManifestDigest: any;
+    redirects: any[];
+    headers: ({
+        match: string;
+        headers: {
+            'cache-control': string;
+            'x-robots-tag'?: undefined;
+        };
+    } | {
+        match: string;
+        headers: {
+            'cache-control': string;
+            'x-robots-tag': string;
+        };
+    })[];
+    errorDocuments: any;
+    routes: any[];
+    localeCache: {
+        strategy: string;
+        varyAcceptLanguage: boolean;
+        defaultLocale: any;
+        routeCount: number;
+        locales: any[];
+    };
+};
+/**
+ * Write CDN policy + adapter projections under dist/_vmz.
+ * @param {string} distDir
+ * @param {Record<string, any>} staticManifest
+ * @param {{ redirects?: Array<{ from: string, to: string, status?: number, reason?: string }> }} [opts]
+ */
+export declare function emitCdnPolicy(distDir: any, staticManifest: any, opts?: {}): {
+    policy: {
+        schema: string;
+        applicationId: any;
+        deliveryProfile: string;
+        origin: string;
+        spaFallback: boolean;
+        staticManifestDigest: any;
+        redirects: any[];
+        headers: ({
+            match: string;
+            headers: {
+                'cache-control': string;
+                'x-robots-tag'?: undefined;
+            };
+        } | {
+            match: string;
+            headers: {
+                'cache-control': string;
+                'x-robots-tag': string;
+            };
+        })[];
+        errorDocuments: any;
+        routes: any[];
+        localeCache: {
+            strategy: string;
+            varyAcceptLanguage: boolean;
+            defaultLocale: any;
+            routeCount: number;
+            locales: any[];
+        };
+    };
+    adapters: {
+        'local-static': {
+            schema: string;
+            adapterId: string;
+            policyDigest: any;
+            host: string;
+            spaFallback: boolean;
+            redirects: any;
+            headers: any;
+            errorDocuments: any;
+            files: {
+                _headers?: undefined;
+                _redirects?: undefined;
+            };
+        } | {
+            schema: string;
+            adapterId: string;
+            policyDigest: any;
+            host: string;
+            spaFallback: boolean;
+            redirects: any;
+            headers: any;
+            errorDocuments: any;
+            files: {
+                _headers: string;
+                _redirects: string;
+            };
+        };
+        netlify: {
+            schema: string;
+            adapterId: string;
+            policyDigest: any;
+            host: string;
+            spaFallback: boolean;
+            redirects: any;
+            headers: any;
+            errorDocuments: any;
+            files: {
+                _headers?: undefined;
+                _redirects?: undefined;
+            };
+        } | {
+            schema: string;
+            adapterId: string;
+            policyDigest: any;
+            host: string;
+            spaFallback: boolean;
+            redirects: any;
+            headers: any;
+            errorDocuments: any;
+            files: {
+                _headers: string;
+                _redirects: string;
+            };
+        };
+    };
+};
+/**
+ * Project vendor-neutral policy to an adapter. Must preserve redirect targets and forbid SPA fallback.
+ * @param {Record<string, any>} policy
+ * @param {'local-static' | 'netlify'} adapterId
+ */
+export declare function projectCdnAdapter(policy: any, adapterId: any): {
+    schema: string;
+    adapterId: string;
+    policyDigest: any;
+    host: string;
+    spaFallback: boolean;
+    redirects: any;
+    headers: any;
+    errorDocuments: any;
+    files: {
+        _headers?: undefined;
+        _redirects?: undefined;
+    };
+} | {
+    schema: string;
+    adapterId: string;
+    policyDigest: any;
+    host: string;
+    spaFallback: boolean;
+    redirects: any;
+    headers: any;
+    errorDocuments: any;
+    files: {
+        _headers: string;
+        _redirects: string;
+    };
+};
+/**
+ * Local static host that applies CDNPolicyManifest (redirects, cache headers, 404 doc).
+ * @param {string} distDir
+ * @param {Record<string, any>} policy
+ * @param {{ host?: string, port?: number }} [opts]
+ * @returns {Promise<{ host: string, port: number, baseUrl: string, close: () => Promise<void> }>}
+ */
+export declare function listenLocalStaticHost(distDir: any, policy: any, opts?: {}): Promise<unknown>;
+/**
+ * @param {string} distDir
+ * @param {Record<string, any>} policy
+ */
+export declare function createLocalStaticHandler(distDir: any, policy: any): (req: any, res: any) => void;
+/**
+ * Minimal glob matcher for CDN header rules (html / js|css|mjs / exact / prefix).
+ * @param {string} pattern
+ * @param {string} pathname
+ */
+export declare function matchGlob(pattern: any, pathname: any): any;