@vmz/vmz 0.0.4 → 0.1.0

package/dist/server-artifact.d.ts

@@ -0,0 +1,140 @@
+/**
+ * P4 ServerArtifact — compiled route decision tree + public ServerRoute contracts
+ * + internal capability units + selected runtime adapter. Web Standards Fetch entry.
+ */
+export declare const SERVER_ARTIFACT_SCHEMA = "vmz.server.artifact.v0";
+export declare const HTTP_CONTRACT_SCHEMA = "vmz.http.contract.v0";
+export declare const SERVER_RUNTIME_ADAPTER_SCHEMA = "vmz.server.runtime_adapter.v0";
+/**
+ * @param {string} outDir
+ * @param {{
+ *   profileId?: string | null,
+ *   assembly?: string | null,
+ *   serverRuntime?: string | null,
+ *   packDigest?: string | null,
+ * }} [opts]
+ */
+export declare function emitServerArtifact(outDir: any, opts?: {}): {
+    artifact: {
+        schema: string;
+        profileId: any;
+        assembly: any;
+        selectedRuntime: string;
+        entry: {
+            kind: string;
+            standards: string[];
+            rpcPath: string;
+        };
+        httpContract: {
+            schema: string;
+            digest: string;
+        };
+        publicRoutes: {
+            verb: string;
+            path: string;
+            moduleId: string;
+            method: string;
+            className: string;
+            visibility: string;
+            kind: string;
+        }[];
+        internalCapabilities: any[];
+        middlewareUnits: any[];
+        routeDecisionTree: ({
+            id: string;
+            match: {
+                method: string;
+                path: string;
+            };
+            action: string;
+            target: {
+                moduleId: string;
+                method: string;
+            };
+            visibility: string;
+        } | {
+            id: string;
+            match: {
+                method: string;
+                path: string;
+            };
+            action: string;
+            visibility: string;
+        })[];
+        deploymentSchema: any;
+        packDigest: any;
+        adapters: {
+            node: {
+                kind: string;
+                status: string;
+                entry: string;
+            };
+            worker: {
+                kind: string;
+                status: string;
+                entry: string;
+            };
+            deno: {
+                kind: string;
+                status: string;
+                entry: string;
+            };
+            bun: {
+                kind: string;
+                status: string;
+                entry: string;
+            };
+            'rust-host': {
+                kind: string;
+                status: string;
+                entry: string;
+            };
+        };
+    };
+    path: string;
+    httpContractDigest: string;
+};
+/**
+ * @param {Record<string, any>} artifact
+ * @param {string} adapterId
+ */
+export declare function projectServerRuntimeAdapter(artifact: any, adapterId: any): {
+    host: string;
+    invoke: string;
+    status: string;
+    schema: string;
+    adapterId: string;
+    artifactDigest: any;
+    httpContractDigest: any;
+    spaFallback: boolean;
+    entry: any;
+    publicRouteCount: any;
+    internalCapabilityCount: any;
+} | {
+    host: string;
+    invoke: string;
+    status: string;
+    note: string;
+    schema: string;
+    adapterId: string;
+    artifactDigest: any;
+    httpContractDigest: any;
+    spaFallback: boolean;
+    entry: any;
+    publicRouteCount: any;
+    internalCapabilityCount: any;
+} | {
+    host: string;
+    invoke: string;
+    status: string;
+    note: string;
+    consumes: string[];
+    schema: string;
+    adapterId: string;
+    artifactDigest: any;
+    httpContractDigest: any;
+    spaFallback: boolean;
+    entry: any;
+    publicRouteCount: any;
+    internalCapabilityCount: any;
+};

package/dist/server-artifact.js

@@ -0,0 +1,205 @@
+/**
+ * P4 ServerArtifact — compiled route decision tree + public ServerRoute contracts
+ * + internal capability units + selected runtime adapter. Web Standards Fetch entry.
+ */
+// @ts-nocheck
+import crypto from 'node:crypto';
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from 'node:fs';
+import path from 'node:path';
+import { SERVER_RUNTIMES } from './delivery-profile.js';
+export const SERVER_ARTIFACT_SCHEMA = 'vmz.server.artifact.v0';
+export const HTTP_CONTRACT_SCHEMA = 'vmz.http.contract.v0';
+export const SERVER_RUNTIME_ADAPTER_SCHEMA = 'vmz.server.runtime_adapter.v0';
+const DEFAULT_RPC_PATH = '/__vmz/rpc';
+/**
+ * @param {string} outDir
+ * @param {{
+ *   profileId?: string | null,
+ *   assembly?: string | null,
+ *   serverRuntime?: string | null,
+ *   packDigest?: string | null,
+ * }} [opts]
+ */
+export function emitServerArtifact(outDir, opts = {}) {
+    const deployment = readJson(path.join(outDir, 'vmz-deployment.json')) || { schema: null, units: [] };
+    const routes = readJson(path.join(outDir, 'vmz-routes.json'));
+    const routeRows = Array.isArray(routes) ? routes : [];
+    const selectedRuntime = normalizeRuntime(opts.serverRuntime);
+    const units = Array.isArray(deployment.units) ? deployment.units : [];
+    const publicRoutes = routeRows.map((r) => ({
+        verb: String(r.verb || 'GET').toUpperCase(),
+        path: String(r.path || ''),
+        moduleId: String(r.moduleId || ''),
+        method: String(r.method || ''),
+        className: r.className != null ? String(r.className) : null,
+        visibility: 'public',
+        kind: 'server-route',
+    }));
+    const publicKeys = new Set(publicRoutes.map((r) => `${r.moduleId}::${r.method}`));
+    /** @type {Array<Record<string, unknown>>} */
+    const internalCapabilities = [];
+    for (const u of units) {
+        const moduleId = u.serverModuleId != null ? String(u.serverModuleId) : '';
+        if (!moduleId)
+            continue;
+        const caps = Array.isArray(u.capabilities) ? u.capabilities.map(String) : [];
+        for (const method of caps) {
+            const key = `${moduleId}::${method}`;
+            if (publicKeys.has(key))
+                continue;
+            internalCapabilities.push({
+                chunkId: String(u.chunkId || ''),
+                moduleId,
+                method,
+                visibility: 'internal',
+                kind: 'capability',
+            });
+        }
+    }
+    const routeDecisionTree = [
+        {
+            id: 'rpc',
+            match: { method: 'POST', path: DEFAULT_RPC_PATH },
+            action: 'invoke-rpc',
+            visibility: 'internal-transport',
+        },
+        ...publicRoutes.map((r, i) => ({
+            id: `public-route-${i}`,
+            match: { method: r.verb, path: r.path },
+            action: 'invoke-server-route',
+            target: { moduleId: r.moduleId, method: r.method },
+            visibility: 'public',
+        })),
+    ];
+    const httpContractBody = {
+        schema: HTTP_CONTRACT_SCHEMA,
+        rpcPath: DEFAULT_RPC_PATH,
+        publicRoutes: publicRoutes.map((r) => ({
+            verb: r.verb,
+            path: r.path,
+            moduleId: r.moduleId,
+            method: r.method,
+        })),
+        internalCapabilityCount: internalCapabilities.length,
+        entry: 'fetch',
+    };
+    const httpContractDigest = sha256Hex(canonicalJson(httpContractBody));
+    const artifact = {
+        schema: SERVER_ARTIFACT_SCHEMA,
+        profileId: opts.profileId || null,
+        assembly: opts.assembly || null,
+        selectedRuntime,
+        entry: {
+            kind: 'fetch',
+            standards: ['Request', 'Response', 'Streams', 'AbortSignal'],
+            rpcPath: DEFAULT_RPC_PATH,
+        },
+        httpContract: {
+            schema: HTTP_CONTRACT_SCHEMA,
+            digest: httpContractDigest,
+        },
+        publicRoutes,
+        internalCapabilities,
+        middlewareUnits: [],
+        routeDecisionTree,
+        deploymentSchema: deployment.schema || null,
+        packDigest: opts.packDigest || null,
+        adapters: {
+            node: { kind: 'node-http', status: 'runtime', entry: 'handleNodeRequest' },
+            worker: { kind: 'fetch', status: 'runtime', entry: 'handleFetchRequest' },
+            deno: { kind: 'fetch', status: 'projected', entry: 'handleFetchRequest' },
+            bun: { kind: 'fetch', status: 'projected', entry: 'handleFetchRequest' },
+            'rust-host': { kind: 'contract-projection', status: 'projected', entry: 'fetch' },
+        },
+    };
+    artifact.artifactDigest = sha256Hex(canonicalJson({ ...artifact, artifactDigest: undefined }));
+    const vmzDir = path.join(outDir, '_vmz');
+    mkdirSync(vmzDir, { recursive: true });
+    const file = path.join(vmzDir, 'server-artifact.json');
+    writeFileSync(file, `${JSON.stringify(artifact, null, 2)}\n`, 'utf8');
+    const adapterDir = path.join(vmzDir, 'adapters');
+    mkdirSync(adapterDir, { recursive: true });
+    for (const adapterId of ['worker', 'rust-host']) {
+        const projection = projectServerRuntimeAdapter(artifact, adapterId);
+        const dir = path.join(adapterDir, adapterId);
+        mkdirSync(dir, { recursive: true });
+        writeFileSync(path.join(dir, 'adapter.json'), `${JSON.stringify(projection, null, 2)}\n`, 'utf8');
+    }
+    return { artifact, path: file, httpContractDigest };
+}
+/**
+ * @param {Record<string, any>} artifact
+ * @param {string} adapterId
+ */
+export function projectServerRuntimeAdapter(artifact, adapterId) {
+    const id = String(adapterId || '').trim();
+    if (!SERVER_RUNTIMES.includes(id) && id !== 'worker') {
+        throw new Error(`projectServerRuntimeAdapter: unknown adapter ${id}`);
+    }
+    const base = {
+        schema: SERVER_RUNTIME_ADAPTER_SCHEMA,
+        adapterId: id,
+        artifactDigest: artifact.artifactDigest,
+        httpContractDigest: artifact.httpContract?.digest || null,
+        spaFallback: false,
+        entry: artifact.entry,
+        publicRouteCount: Array.isArray(artifact.publicRoutes) ? artifact.publicRoutes.length : 0,
+        internalCapabilityCount: Array.isArray(artifact.internalCapabilities)
+            ? artifact.internalCapabilities.length
+            : 0,
+    };
+    if (id === 'node') {
+        return { ...base, host: 'node:http', invoke: 'handleNodeRequest', status: 'runtime' };
+    }
+    if (id === 'worker' || id === 'deno' || id === 'bun') {
+        return {
+            ...base,
+            host: 'fetch',
+            invoke: 'handleFetchRequest',
+            status: id === 'worker' ? 'runtime' : 'projected',
+            note: id === 'worker'
+                ? 'Fetch entry; live thin gated via worker-shaped subprocess host'
+                : 'Fetch contract projection; live runtime not gated',
+        };
+    }
+    // rust-host
+    return {
+        ...base,
+        host: 'rust-fetch-consumer',
+        invoke: 'fetch',
+        status: 'projected',
+        note: 'contract projection only — live Rust host binary parity not gated',
+        consumes: ['server-artifact.json', 'vmz-routes.json', 'vmz-deployment.json'],
+    };
+}
+function normalizeRuntime(raw) {
+    const v = String(raw || 'node').trim();
+    return SERVER_RUNTIMES.includes(v) ? v : 'node';
+}
+function readJson(file) {
+    if (!existsSync(file))
+        return null;
+    try {
+        return JSON.parse(readFileSync(file, 'utf8'));
+    }
+    catch {
+        return null;
+    }
+}
+function canonicalJson(value) {
+    return JSON.stringify(sortKeys(value));
+}
+function sortKeys(value) {
+    if (Array.isArray(value))
+        return value.map(sortKeys);
+    if (value && typeof value === 'object') {
+        const out = {};
+        for (const k of Object.keys(value).sort())
+            out[k] = sortKeys(value[k]);
+        return out;
+    }
+    return value;
+}
+function sha256Hex(text) {
+    return crypto.createHash('sha256').update(text, 'utf8').digest('hex');
+}

package/dist/server-language-backend.d.ts

@@ -0,0 +1,89 @@
+/**
+ * Server Language DSL backends (lang on `<script server>`).
+ * Author surface is a VMZ DSL flavor — not full target-language source.
+ */
+/** @typedef {'ts' | 'rust' | 'python' | 'java'} ServerLangId */
+export declare const SERVER_LANG_IDS: readonly string[];
+/** @type {Record<string, ServerLangId>} */
+export declare const SERVER_LANG_ALIASES: Readonly<{
+    ts: "ts";
+    typescript: "ts";
+    rust: "rust";
+    python: "python";
+    java: "java";
+}>;
+/**
+ * @typedef {{
+ *   langId: ServerLangId,
+ *   aliases: string[],
+ *   compatibleRuntimes: string[],
+ *   implemented: boolean,
+ *   artifactRoot: string,
+ * }} ServerLanguageBackendMeta
+ */
+/** @type {Record<ServerLangId, ServerLanguageBackendMeta>} */
+export declare const SERVER_LANGUAGE_BACKENDS: Readonly<{
+    ts: {
+        langId: string;
+        aliases: string[];
+        compatibleRuntimes: string[];
+        implemented: boolean;
+        artifactRoot: string;
+    };
+    rust: {
+        langId: string;
+        aliases: string[];
+        compatibleRuntimes: string[];
+        implemented: boolean;
+        artifactRoot: string;
+    };
+    python: {
+        langId: string;
+        aliases: string[];
+        compatibleRuntimes: string[];
+        implemented: boolean;
+        artifactRoot: string;
+    };
+    java: {
+        langId: string;
+        aliases: string[];
+        compatibleRuntimes: string[];
+        implemented: boolean;
+        artifactRoot: string;
+    };
+}>;
+/**
+ * Resolve author `lang` attr (or null/undefined for default TS).
+ * @param {string | null | undefined} raw
+ * @returns {{
+ *   ok: true, langId: ServerLangId, backend: ServerLanguageBackendMeta
+ * } | {
+ *   ok: false, code: string, message: string
+ * }}
+ */
+export declare function resolveServerLanguage(raw: any): {
+    ok: boolean;
+    code: string;
+    message: string;
+    langId?: undefined;
+    backend?: undefined;
+} | {
+    ok: boolean;
+    langId: any;
+    backend: any;
+    code?: undefined;
+    message?: undefined;
+};
+/**
+ * @param {ServerLangId} langId
+ * @param {string | null | undefined} serverRuntime
+ */
+export declare function assertLangRuntimePair(langId: any, serverRuntime: any): {
+    ok: boolean;
+    code: string;
+    message: string;
+} | {
+    ok: boolean;
+    code?: undefined;
+    message?: undefined;
+};

package/dist/server-language-backend.js

@@ -0,0 +1,121 @@
+/**
+ * Server Language DSL backends (lang on `<script server>`).
+ * Author surface is a VMZ DSL flavor — not full target-language source.
+ */
+// @ts-nocheck
+/** @typedef {'ts' | 'rust' | 'python' | 'java'} ServerLangId */
+export const SERVER_LANG_IDS = Object.freeze(['ts', 'rust', 'python', 'java']);
+/** @type {Record<string, ServerLangId>} */
+export const SERVER_LANG_ALIASES = Object.freeze({
+    ts: 'ts',
+    typescript: 'ts',
+    rust: 'rust',
+    python: 'python',
+    java: 'java',
+});
+/**
+ * @typedef {{
+ *   langId: ServerLangId,
+ *   aliases: string[],
+ *   compatibleRuntimes: string[],
+ *   implemented: boolean,
+ *   artifactRoot: string,
+ * }} ServerLanguageBackendMeta
+ */
+/** @type {Record<ServerLangId, ServerLanguageBackendMeta>} */
+export const SERVER_LANGUAGE_BACKENDS = Object.freeze({
+    ts: {
+        langId: 'ts',
+        aliases: ['ts', 'typescript'],
+        compatibleRuntimes: ['node', 'worker', 'deno', 'bun'],
+        implemented: true,
+        artifactRoot: 'dist/#server',
+    },
+    rust: {
+        langId: 'rust',
+        aliases: ['rust'],
+        compatibleRuntimes: ['rust-host'],
+        implemented: true,
+        artifactRoot: 'target/vmz/server-rust',
+    },
+    python: {
+        langId: 'python',
+        aliases: ['python'],
+        compatibleRuntimes: ['python-host'],
+        implemented: false,
+        artifactRoot: 'target/vmz/server-python',
+    },
+    java: {
+        langId: 'java',
+        aliases: ['java'],
+        compatibleRuntimes: ['jvm-host'],
+        implemented: false,
+        artifactRoot: 'target/vmz/server-java',
+    },
+});
+/**
+ * Resolve author `lang` attr (or null/undefined for default TS).
+ * @param {string | null | undefined} raw
+ * @returns {{
+ *   ok: true, langId: ServerLangId, backend: ServerLanguageBackendMeta
+ * } | {
+ *   ok: false, code: string, message: string
+ * }}
+ */
+export function resolveServerLanguage(raw) {
+    const trimmed = raw == null ? '' : String(raw).trim();
+    if (!trimmed) {
+        return { ok: true, langId: 'ts', backend: SERVER_LANGUAGE_BACKENDS.ts };
+    }
+    const langId = SERVER_LANG_ALIASES[trimmed];
+    if (!langId) {
+        return {
+            ok: false,
+            code: 'vmz::server::unknown_language',
+            message: `unknown script language \`${trimmed}\`; use ts|typescript|rust|python|java`,
+        };
+    }
+    const backend = SERVER_LANGUAGE_BACKENDS[langId];
+    if (!backend.implemented) {
+        return {
+            ok: false,
+            code: 'vmz::server::language_backend_unimplemented',
+            message: `\`<script server lang="${langId}">\` is registered but not implemented yet`,
+        };
+    }
+    return { ok: true, langId, backend };
+}
+/**
+ * @param {ServerLangId} langId
+ * @param {string | null | undefined} serverRuntime
+ */
+export function assertLangRuntimePair(langId, serverRuntime) {
+    const backend = SERVER_LANGUAGE_BACKENDS[langId];
+    if (!backend) {
+        return {
+            ok: false,
+            code: 'vmz::server::unknown_language',
+            message: `unknown langId ${langId}`,
+        };
+    }
+    if (langId === 'ts') {
+        // TS stays compatible with existing node/worker defaults; rust-host rejects ts.
+        if (serverRuntime === 'rust-host' || serverRuntime === 'python-host' || serverRuntime === 'jvm-host') {
+            return {
+                ok: false,
+                code: 'vmz::server::lang_runtime_mismatch',
+                message: `lang=ts is incompatible with serverRuntime=${serverRuntime}`,
+            };
+        }
+        return { ok: true };
+    }
+    const rt = String(serverRuntime || '').trim();
+    if (!backend.compatibleRuntimes.includes(rt)) {
+        return {
+            ok: false,
+            code: 'vmz::server::lang_runtime_mismatch',
+            message: `lang=${langId} requires serverRuntime in [${backend.compatibleRuntimes.join('|')}] (got ${rt || '(none)'})`,
+        };
+    }
+    return { ok: true };
+}

package/dist/static-emit.d.ts

@@ -29,11 +29,13 @@ export declare function emitWebStatic(distDir: any, opts?: {}): Promise<{
             chunkId: any;
             htmlPath: any;
             classification: any;
+            localeId: any;
             seo: {
                 title: any;
                 description: any;
                 canonical: any;
                 robots: any;
+                alternates: any;
             };
         }[];
         skipped: any[];
@@ -75,7 +77,14 @@ export declare function emitWebStatic(distDir: any, opts?: {}): Promise<{
             };
         })[];
         errorDocuments: any;
-        routes: any;
+        routes: any[];
+        localeCache: {
+            strategy: string;
+            varyAcceptLanguage: boolean;
+            defaultLocale: any;
+            routeCount: number;
+            locales: any[];
+        };
     };
     cdnAdapters: {
         'local-static': {