@vmz/vmz 0.0.2 → 0.0.4

package/dist/invocation.js

@@ -0,0 +1,169 @@
+// @ts-nocheck
+/**
+ * `vmz` CLI invocation modes (JS gate only; Rust binary stays full).
+ *
+ * Product install face: workspace `vmz` / publish `@vmz/vmz` (bin still `vmz`).
+ *
+ * Three modes — do not collapse them:
+ * - **developer**: monorepo source checkout (`packages/runtimes/vmz`, not under node_modules)
+ * - **project**: app's nearest `node_modules/vmz` or `node_modules/@vmz/vmz`
+ * - **global**: npm/pnpm global (or any install under node_modules that is not the nearest project one)
+ *
+ */
+import { spawn } from 'node:child_process';
+import { existsSync, realpathSync } from 'node:fs';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+/** @typedef {'developer' | 'project' | 'global'} InvocationMode */
+const PROJECT_PKG_SEGMENTS = [['@vmz', 'vmz'], ['vmz']];
+/**
+ * Package root of the running `vmz` / `@vmz/vmz` install.
+ * @param {string} [fromUrl]
+ */
+export function resolveThisPackageRoot(fromUrl = import.meta.url) {
+    return path.resolve(path.dirname(fileURLToPath(fromUrl)), '..');
+}
+/**
+ * @param {string} p
+ */
+function tryRealpath(p) {
+    try {
+        return realpathSync(p);
+    }
+    catch {
+        return path.resolve(p);
+    }
+}
+/**
+ * Walk from `startDir` for nearest project CLI package root.
+ * @param {string} startDir
+ * @returns {string | null}
+ */
+export function findNearestProjectVmz(startDir) {
+    let dir = path.resolve(startDir);
+    for (;;) {
+        for (const segments of PROJECT_PKG_SEGMENTS) {
+            const candidate = path.join(dir, 'node_modules', ...segments);
+            const pkgJson = path.join(candidate, 'package.json');
+            if (existsSync(pkgJson)) {
+                return tryRealpath(candidate);
+            }
+        }
+        const parent = path.dirname(dir);
+        if (parent === dir)
+            return null;
+        dir = parent;
+    }
+}
+/**
+ * Resolve CLI entry (`bin/vmz.js`).
+ * @param {string} packageRoot
+ * @returns {string | null}
+ */
+export function resolveVmzBin(packageRoot) {
+    const bin = path.join(packageRoot, 'bin', 'vmz.js');
+    if (existsSync(bin))
+        return tryRealpath(bin);
+    return null;
+}
+/**
+ * @param {string} packageRoot
+ */
+export function isUnderNodeModules(packageRoot) {
+    const norm = path.normalize(packageRoot);
+    const parts = norm.split(path.sep);
+    return parts.includes('node_modules');
+}
+/**
+ * @param {{
+ * cwd?: string,
+ * thisPackageRoot?: string,
+ * }} [opts]
+ */
+export function getInvocationContext(opts = {}) {
+    const cwd = path.resolve(opts.cwd ?? process.cwd());
+    const thisPackageRoot = tryRealpath(opts.thisPackageRoot ?? resolveThisPackageRoot());
+    const nearestProjectVmz = findNearestProjectVmz(cwd);
+    const underNm = isUnderNodeModules(thisPackageRoot);
+    /** @type {InvocationMode} */
+    let mode;
+    if (!underNm) {
+        mode = 'developer';
+    }
+    else if (nearestProjectVmz != null && nearestProjectVmz === thisPackageRoot) {
+        mode = 'project';
+    }
+    else {
+        mode = 'global';
+    }
+    return {
+        mode,
+        cwd,
+        thisPackageRoot,
+        nearestProjectVmz,
+        isDeveloper: mode === 'developer',
+        isProjectLocal: mode === 'project',
+        /** @deprecated prefer `mode === 'global'`; kept for call sites */
+        isGlobalLike: mode === 'global',
+    };
+}
+/**
+ * @param {string | undefined} cmd
+ */
+export function isGlobalAllowedCommand(cmd) {
+    if (!cmd)
+        return true;
+    return (cmd === 'help' ||
+        cmd === '-h' ||
+        cmd === '--help' ||
+        cmd === 'version' ||
+        cmd === '-V' ||
+        cmd === '--version' ||
+        cmd === 'new' ||
+        cmd === 'init');
+}
+/**
+ * @param {string} bin
+ * @param {string[]} argv
+ * @returns {Promise<number>}
+ */
+export function reexecProjectVmz(bin, argv) {
+    return new Promise((resolve) => {
+        const child = spawn(process.execPath, [bin, ...argv], {
+            stdio: 'inherit',
+            env: process.env,
+        });
+        child.on('error', () => resolve(1));
+        child.on('exit', (code, signal) => {
+            if (signal)
+                resolve(1);
+            else
+                resolve(code ?? 1);
+        });
+    });
+}
+/**
+ * @returns {Promise<{ action: 'proceed' } | { action: 'exit', code: number }>}
+ */
+export async function gateGlobalProjectCommand(opts) {
+    const { argv, cwd = process.cwd(), thisPackageRoot, reexec = reexecProjectVmz, logError = (msg) => console.error(msg) } = opts;
+    const ctx = getInvocationContext({ cwd, thisPackageRoot });
+    if (ctx.mode !== 'global') {
+        return { action: 'proceed' };
+    }
+    if (ctx.nearestProjectVmz && ctx.nearestProjectVmz !== ctx.thisPackageRoot) {
+        const bin = resolveVmzBin(ctx.nearestProjectVmz);
+        if (!bin) {
+            logError('found project `vmz` / `@vmz/vmz` but bin/vmz.js is missing.');
+            return { action: 'exit', code: 1 };
+        }
+        const code = await reexec(bin, argv);
+        return { action: 'exit', code };
+    }
+    logError('this `vmz` is a global install (mode=global); project commands need a project install.');
+    logError('Install in the app:  pnpm add -D @vmz/vmz');
+    logError('Or scaffold:         vmz new <dir>');
+    logError('Then run:            pnpm exec vmz <command>');
+    logError('(developer mode: run from vmz-framework packages/runtimes/vmz source — full CLI)');
+    return { action: 'exit', code: 1 };
+}

package/dist/locale-check.d.ts

@@ -67,7 +67,7 @@ export declare function checkLocales(opts: any): {
 };
 /**
  * Scan src for `#locales/<catalog>` imports and `messageId` string literals after import.
- * First-slice heuristic — full VPG edges land with compiler I1 deepen.
+ * First-slice heuristic — full VPG edges land with compiler deepen.
  */
 export declare function scanLocaleUsages(projectRoot: any): {
     catalogs: Set<unknown>;
@@ -75,13 +75,29 @@ export declare function scanLocaleUsages(projectRoot: any): {
     importedNames: Map<any, any>;
 };
 /**
- * Emit typed module stubs for `#locales/*` (I1 surface).
+ * Emit typed module stubs for `#locales/*` ( surface).
  * @param {ReturnType<typeof checkLocales>} report
  * @param {string} outDir
  */
 export declare function emitLocaleTypedModules(report: any, outDir: any): any[];
 /**
- * MessageId rename plan (I1) — WorkspaceEdit-shaped, no parallel rename IR.
+ * Emit runtime `#locales/<catalog>.js` into application `dist/` and rewrite
+ * client imports from `#locales/...` to relative ESM paths.
+ *
+ * Variant pick reads `html[data-locale]` (else defaultLocale). Thin bridge until
+ * host LocaleTransition reloads locale-scoped chunks (I2/I4).
+ *
+ * @param {string} projectRoot
+ * @param {string} distDir
+ * @returns {{ ok: boolean, written: string[], diagnostics: any[] }}
+ */
+export declare function emitLocaleRuntimeModules(projectRoot: any, distDir: any): {
+    ok: boolean;
+    written: any[];
+    diagnostics: any;
+};
+/**
+ * MessageId rename plan — WorkspaceEdit-shaped, no parallel rename IR.
  * @param {ReturnType<typeof checkLocales>} report
  * @param {string} fromId
  * @param {string} toId

package/dist/locale-check.js

@@ -1,7 +1,6 @@
 // @ts-nocheck
 /**
- * Locale I0 check + I1 message contracts / typed module projection.
- * Design: 规划设计/vmz/28 · I0/I1
+ * Locale check + message contracts / typed module projection.
  *
  * Not an I18n IR: filesystem + MessageCatalogManifest projection into VPG-shaped views.
  */
@@ -485,7 +484,7 @@ export function checkLocales(opts) {
             }
         }
     }
-    // I1: scan source for #locales/* imports / message references.
+    // scan source for #locales/* imports / message references.
     const used = scanLocaleUsages(projectRoot);
     /** @type {any[]} */
     const typedModules = [];
@@ -611,7 +610,7 @@ function walkCatalogFiles(dir, fn) {
 }
 /**
  * Scan src for `#locales/<catalog>` imports and `messageId` string literals after import.
- * First-slice heuristic — full VPG edges land with compiler I1 deepen.
+ * First-slice heuristic — full VPG edges land with compiler deepen.
  */
 export function scanLocaleUsages(projectRoot) {
     /** @type {Set<string>} */
@@ -658,7 +657,7 @@ function walkSource(dir, fn) {
     }
 }
 /**
- * Emit typed module stubs for `#locales/*` (I1 surface).
+ * Emit typed module stubs for `#locales/*` ( surface).
  * @param {ReturnType<typeof checkLocales>} report
  * @param {string} outDir
  */
@@ -696,7 +695,132 @@ export function emitLocaleTypedModules(report, outDir) {
     return written;
 }
 /**
- * MessageId rename plan (I1) — WorkspaceEdit-shaped, no parallel rename IR.
+ * Emit runtime `#locales/<catalog>.js` into application `dist/` and rewrite
+ * client imports from `#locales/...` to relative ESM paths.
+ *
+ * Variant pick reads `html[data-locale]` (else defaultLocale). Thin bridge until
+ * host LocaleTransition reloads locale-scoped chunks (I2/I4).
+ *
+ * @param {string} projectRoot
+ * @param {string} distDir
+ * @returns {{ ok: boolean, written: string[], diagnostics: any[] }}
+ */
+export function emitLocaleRuntimeModules(projectRoot, distDir) {
+    const localesRoot = path.join(projectRoot, 'locales');
+    if (!fs.existsSync(localesRoot)) {
+        return { ok: true, written: [], diagnostics: [] };
+    }
+    const report = checkLocales({ projectRoot, checkUnused: false });
+    if (localeHasErrors(report)) {
+        return { ok: false, written: [], diagnostics: report.diagnostics || [] };
+    }
+    const defaultLocale = report.manifest?.defaultLocale || 'zh-hans';
+    const byId = new Map((report.messageCatalog?.messages || []).map((m) => [m.messageId, m]));
+    /** @type {string[]} */
+    const written = [];
+    const localesOut = path.join(distDir, 'locales');
+    fs.mkdirSync(localesOut, { recursive: true });
+    for (const mod of report.typedModules || []) {
+        const lines = [
+            `/** Generated ${mod.module} — runtime LocalizedText (defaultLocale=${defaultLocale}) */`,
+            `const __vmzDefaultLocale = ${JSON.stringify(defaultLocale)};`,
+            `function __vmzLocaleId() {`,
+            `  try {`,
+            `    const stored = localStorage.getItem("vmz.locale");`,
+            `    if (stored) return stored;`,
+            `  } catch {}`,
+            `  if (typeof document !== "undefined") {`,
+            `    const d = document.documentElement?.getAttribute("data-locale");`,
+            `    if (d) return d;`,
+            `    const lang = document.documentElement?.lang;`,
+            `    if (lang === "en" || lang === "en-US" || lang === "en-us") return "en-us";`,
+            `    if (lang === "zh" || lang === "zh-CN" || lang === "zh-Hans" || lang === "zh-hans") return "zh-hans";`,
+            `  }`,
+            `  return __vmzDefaultLocale;`,
+            `}`,
+            `function __vmzFormat(template, args) {`,
+            `  if (!args) return String(template ?? "");`,
+            `  return String(template ?? "").replace(/\\{(\\w+)(?:,\\s*\\w+)?\\}/g, (m, name) =>`,
+            `    Object.prototype.hasOwnProperty.call(args, name) ? String(args[name]) : m`,
+            `  );`,
+            `}`,
+            `function __vmzPick(variants, args) {`,
+            `  const id = __vmzLocaleId();`,
+            `  const template = variants[id] ?? variants[__vmzDefaultLocale] ?? "";`,
+            `  return __vmzFormat(template, args);`,
+            `}`,
+            '',
+        ];
+        for (const exp of mod.exports || []) {
+            const node = byId.get(exp.messageId);
+            const variants = {};
+            if (node?.variants) {
+                for (const [loc, v] of Object.entries(node.variants)) {
+                    variants[loc] = v.template;
+                }
+            }
+            const lit = JSON.stringify(variants);
+            if ((exp.params || []).length) {
+                lines.push(`export function ${exp.exportName}(args) { return __vmzPick(${lit}, args); }`);
+            }
+            else {
+                lines.push(`export function ${exp.exportName}() { return __vmzPick(${lit}); }`);
+            }
+        }
+        lines.push('');
+        const file = path.join(localesOut, `${mod.catalogId}.js`);
+        fs.mkdirSync(path.dirname(file), { recursive: true });
+        fs.writeFileSync(file, lines.join('\n'), 'utf8');
+        written.push(file);
+    }
+    rewriteLocaleImportsInDist(distDir);
+    return { ok: true, written, diagnostics: report.diagnostics || [] };
+}
+/**
+ * @param {string} distDir
+ */
+function rewriteLocaleImportsInDist(distDir) {
+    /** @type {string[]} */
+    const files = [];
+    walkDistJs(distDir, (file) => files.push(file));
+    for (const file of files) {
+        let text = fs.readFileSync(file, 'utf8');
+        if (!text.includes('#locales/'))
+            continue;
+        const fromDir = path.dirname(file);
+        // Emit path is dist/locales/*.js — `#` cannot appear in ESM file URLs (fragment).
+        const next = text.replace(/from\s*(["'])#locales\/([^"']+)\1/g, (_m, quote, id) => {
+            const target = path.join(distDir, 'locales', `${id}.js`);
+            let rel = path.relative(fromDir, target).replace(/\\/g, '/');
+            if (!rel.startsWith('.'))
+                rel = `./${rel}`;
+            return `from ${quote}${rel}${quote}`;
+        });
+        if (next !== text)
+            fs.writeFileSync(file, next, 'utf8');
+    }
+}
+/**
+ * @param {string} dir
+ * @param {(file: string) => void} fn
+ */
+function walkDistJs(dir, fn) {
+    if (!fs.existsSync(dir))
+        return;
+    for (const ent of fs.readdirSync(dir, { withFileTypes: true })) {
+        const full = path.join(dir, ent.name);
+        if (ent.isDirectory()) {
+            if (ent.name === 'node_modules')
+                continue;
+            walkDistJs(full, fn);
+        }
+        else if (ent.name.endsWith('.js') || ent.name.endsWith('.mjs')) {
+            fn(full);
+        }
+    }
+}
+/**
+ * MessageId rename plan — WorkspaceEdit-shaped, no parallel rename IR.
  * @param {ReturnType<typeof checkLocales>} report
  * @param {string} fromId
  * @param {string} toId

package/dist/locale-cmd.js

@@ -1,7 +1,6 @@
 // @ts-nocheck
 /**
- * `vmz locale` CLI (I0–I5).
- * Design: 规划设计/vmz/28 §12
+ * `vmz locale` CLI (–).
  */
 import fs from 'node:fs';
 import path from 'node:path';
@@ -14,7 +13,7 @@ import { checkLocaleRuntime } from './locale-runtime.js';
 import { checkLocaleConformance, diffLocaleCatalogs, explainLocaleMessage, extractHardcodedText, pseudoLocalizeCatalog, } from './locale-tooling.js';
 import { log } from './log.js';
 function printLocaleHelp() {
-    console.log(`vmz locale — /locales application i18n (I0–I5)
+    console.log(`vmz locale — /locales application i18n (–)
 
 Usage:
   vmz locale check [project]       Check locales.json5 + catalogs + param contracts
@@ -160,7 +159,7 @@ function cmdLocaleRename(args) {
     else {
         log.info(`rename plan ${fromId} → ${toId} edits=${plan.edits.length}`);
         for (const e of plan.edits)
-            console.log(`  ${e.path}`);
+            console.log(` ${e.path}`);
     }
     return plan.status === 'ready' ? 0 : 1;
 }
@@ -329,7 +328,7 @@ function cmdLocaleExplain(args) {
     else {
         log.info(`explain ${report.messageId}: resolved=${report.resolvedLocale} params=${(report.params || []).map((p) => p.name).join(',') || '(none)'}`);
         for (const [loc, v] of Object.entries(report.variants || {})) {
-            console.log(`  ${loc}\t${v.template}`);
+            console.log(` ${loc}\t${v.template}`);
         }
     }
     return report.status === 'ready' ? 0 : 1;
@@ -355,9 +354,9 @@ function cmdLocaleDiff(args) {
     else {
         log.info(`diff ${baseLocale} → ${targetLocale}: missing=${report.summary.missingInTarget} changed=${report.summary.changed} params=${report.summary.paramMismatches}`);
         for (const id of report.missingInTarget || [])
-            console.log(`  - missing ${id}`);
+            console.log(` - missing ${id}`);
         for (const c of report.changed || [])
-            console.log(`  ~ ${c.messageId}`);
+            console.log(` ~ ${c.messageId}`);
     }
     return 0;
 }

package/dist/locale-delivery.d.ts

@@ -12,18 +12,18 @@ export declare function messageCatalogHash(messages: any, localeId: any, reachab
 /**
  * Build LocaleDeliveryResolution for one Host surface.
  * @param {{
- *   host: 'web'|'mini'|'native'|'server',
- *   applicationId: string,
- *   deliveryId: string,
- *   planVersion?: string,
- *   supportedLocales: string[],
- *   defaultLocale: string,
- *   fallback?: Record<string, string[]>,
- *   routingRealization?: unknown,
- *   messages: Array<{ messageId: string, variants: Record<string, { template: string }> }>,
- *   reachableMessageIds?: string[],
- *   bundledLocales?: string[],
- *   allowFullClientBundle?: boolean,
+ * host: 'web'|'mini'|'native'|'server',
+ * applicationId: string,
+ * deliveryId: string,
+ * planVersion?: string,
+ * supportedLocales: string[],
+ * defaultLocale: string,
+ * fallback?: Record<string, string[]>,
+ * routingRealization?: unknown,
+ * messages: Array<{ messageId: string, variants: Record<string, { template: string }> }>,
+ * reachableMessageIds?: string[],
+ * bundledLocales?: string[],
+ * allowFullClientBundle?: boolean,
  * }} input
  */
 export declare function buildLocaleDeliveryResolution(input: any): {
@@ -55,19 +55,19 @@ export declare function buildLocaleDeliveryResolution(input: any): {
 /**
  * Validate a Native optional locale pack (signed, no JS, bound to app/plan/schema).
  * @param {{
- *   pack: {
- *     schema?: string,
- *     applicationId: string,
- *     planVersion: string,
- *     localeId: string,
- *     signature?: string,
- *     catalog?: Record<string, string>,
- *     formatterDataVersion?: string,
- *     entries?: Array<{ path: string, kind?: string }>,
- *     executable?: boolean,
- *   },
- *   expectedApplicationId: string,
- *   expectedPlanVersion: string,
+ * pack: {
+ * schema?: string,
+ * applicationId: string,
+ * planVersion: string,
+ * localeId: string,
+ * signature?: string,
+ * catalog?: Record<string, string>,
+ * formatterDataVersion?: string,
+ * entries?: Array<{ path: string, kind?: string }>,
+ * executable?: boolean,
+ * },
+ * expectedApplicationId: string,
+ * expectedPlanVersion: string,
  * }} input
  */
 export declare function validateNativeLocalePack(input: any): {
@@ -88,8 +88,8 @@ export declare function validateNativeLocalePack(input: any): {
 /**
  * Mini cross-subpackage message dependencies must be proven.
  * @param {{
- *   packages: Array<{ id: string, messageIds: string[] }>,
- *   edges: Array<{ fromPackage: string, toPackage: string, messageId: string }>,
+ * packages: Array<{ id: string, messageIds: string[] }>,
+ * edges: Array<{ fromPackage: string, toPackage: string, messageId: string }>,
  * }} input
  */
 export declare function proveMiniPackageMessages(input: any): {
@@ -134,18 +134,18 @@ export declare function assertHostMessageInvariant(resolutions: any): {
     diagnostics: any[];
 };
 /**
- * Aggregate I4 delivery proof for fixture / CLI.
+ * Aggregate delivery proof for fixture / CLI.
  * @param {{
- *   manifest: {
- *     defaultLocale: string,
- *     locales: Array<{ id: string }>,
- *     fallback?: Record<string, string[]>,
- *     routing?: unknown,
- *   },
- *   messages: Array<{ messageId: string, variants: Record<string, { template: string }> }>,
- *   applicationId?: string,
- *   planVersion?: string,
- *   reachableMessageIds?: string[],
+ * manifest: {
+ * defaultLocale: string,
+ * locales: Array<{ id: string }>,
+ * fallback?: Record<string, string[]>,
+ * routing?: unknown,
+ * },
+ * messages: Array<{ messageId: string, variants: Record<string, { template: string }> }>,
+ * applicationId?: string,
+ * planVersion?: string,
+ * reachableMessageIds?: string[],
  * }} input
  */
 export declare function checkLocaleDelivery(input: any): {

package/dist/locale-delivery.js

@@ -1,8 +1,7 @@
 // @ts-nocheck
 /**
- * Locale I4 multi-host delivery: Web chunks · Mini packages · Native packs ·
+ * Locale multi-host delivery: Web chunks · Mini packages · Native packs ·
  * Server error envelope / formatter resources.
- * Design: 规划设计/vmz/28 §9–§10
  *
  * Same MessageNode projects to all Surfaces; LocaleId is not a WebSurface concern.
  */
@@ -49,18 +48,18 @@ export function messageCatalogHash(messages, localeId, reachableIds) {
 /**
  * Build LocaleDeliveryResolution for one Host surface.
  * @param {{
- *   host: 'web'|'mini'|'native'|'server',
- *   applicationId: string,
- *   deliveryId: string,
- *   planVersion?: string,
- *   supportedLocales: string[],
- *   defaultLocale: string,
- *   fallback?: Record<string, string[]>,
- *   routingRealization?: unknown,
- *   messages: Array<{ messageId: string, variants: Record<string, { template: string }> }>,
- *   reachableMessageIds?: string[],
- *   bundledLocales?: string[],
- *   allowFullClientBundle?: boolean,
+ * host: 'web'|'mini'|'native'|'server',
+ * applicationId: string,
+ * deliveryId: string,
+ * planVersion?: string,
+ * supportedLocales: string[],
+ * defaultLocale: string,
+ * fallback?: Record<string, string[]>,
+ * routingRealization?: unknown,
+ * messages: Array<{ messageId: string, variants: Record<string, { template: string }> }>,
+ * reachableMessageIds?: string[],
+ * bundledLocales?: string[],
+ * allowFullClientBundle?: boolean,
  * }} input
  */
 export function buildLocaleDeliveryResolution(input) {
@@ -131,19 +130,19 @@ export function buildLocaleDeliveryResolution(input) {
 /**
  * Validate a Native optional locale pack (signed, no JS, bound to app/plan/schema).
  * @param {{
- *   pack: {
- *     schema?: string,
- *     applicationId: string,
- *     planVersion: string,
- *     localeId: string,
- *     signature?: string,
- *     catalog?: Record<string, string>,
- *     formatterDataVersion?: string,
- *     entries?: Array<{ path: string, kind?: string }>,
- *     executable?: boolean,
- *   },
- *   expectedApplicationId: string,
- *   expectedPlanVersion: string,
+ * pack: {
+ * schema?: string,
+ * applicationId: string,
+ * planVersion: string,
+ * localeId: string,
+ * signature?: string,
+ * catalog?: Record<string, string>,
+ * formatterDataVersion?: string,
+ * entries?: Array<{ path: string, kind?: string }>,
+ * executable?: boolean,
+ * },
+ * expectedApplicationId: string,
+ * expectedPlanVersion: string,
  * }} input
  */
 export function validateNativeLocalePack(input) {
@@ -215,8 +214,8 @@ export function validateNativeLocalePack(input) {
 /**
  * Mini cross-subpackage message dependencies must be proven.
  * @param {{
- *   packages: Array<{ id: string, messageIds: string[] }>,
- *   edges: Array<{ fromPackage: string, toPackage: string, messageId: string }>,
+ * packages: Array<{ id: string, messageIds: string[] }>,
+ * edges: Array<{ fromPackage: string, toPackage: string, messageId: string }>,
  * }} input
  */
 export function proveMiniPackageMessages(input) {
@@ -347,18 +346,18 @@ export function assertHostMessageInvariant(resolutions) {
     return { ok: diagnostics.length === 0, diagnostics };
 }
 /**
- * Aggregate I4 delivery proof for fixture / CLI.
+ * Aggregate delivery proof for fixture / CLI.
  * @param {{
- *   manifest: {
- *     defaultLocale: string,
- *     locales: Array<{ id: string }>,
- *     fallback?: Record<string, string[]>,
- *     routing?: unknown,
- *   },
- *   messages: Array<{ messageId: string, variants: Record<string, { template: string }> }>,
- *   applicationId?: string,
- *   planVersion?: string,
- *   reachableMessageIds?: string[],
+ * manifest: {
+ * defaultLocale: string,
+ * locales: Array<{ id: string }>,
+ * fallback?: Record<string, string[]>,
+ * routing?: unknown,
+ * },
+ * messages: Array<{ messageId: string, variants: Record<string, { template: string }> }>,
+ * applicationId?: string,
+ * planVersion?: string,
+ * reachableMessageIds?: string[],
  * }} input
  */
 export function checkLocaleDelivery(input) {