@vmz/vmz 0.0.2 → 0.0.3

package/dist/invocation.js

@@ -0,0 +1,190 @@
+// @ts-nocheck
+/**
+ * `vmz` CLI invocation modes (JS gate only; Rust binary stays full).
+ *
+ * Three modes — do not collapse them:
+ * - **developer**: monorepo source checkout (`packages/runtimes/vmz`, not under node_modules)
+ * - **project**: app's `node_modules/vmz` or `node_modules/@vmz/vmz` (pnpm/npm/yarn)
+ * - **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 */
+/**
+ * Package root of the running `vmz` / `@vmz/vmz` install (`…/vmz`, not `…/vmz/dist`).
+ * @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 `vmz` / `@vmz/vmz` package root.
+ * @param {string} startDir
+ * @returns {string | null} realpath of package root
+ */
+export function findNearestProjectVmz(startDir) {
+    let dir = path.resolve(startDir);
+    for (;;) {
+        const candidates = [path.join(dir, 'node_modules', 'vmz'), path.join(dir, 'node_modules', '@vmz', 'vmz')];
+        for (const candidate of candidates) {
+            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 for a `vmz` package root (`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;
+}
+/**
+ * Install lives under a `node_modules` tree (npm -g, pnpm store link, etc.).
+ * Workspace source checkout (`packages/runtimes/vmz`) does not → developer mode.
+ * @param {string} packageRoot
+ */
+export function isUnderNodeModules(packageRoot) {
+    const norm = path.normalize(packageRoot);
+    const parts = norm.split(path.sep);
+    return parts.includes('node_modules');
+}
+/**
+ * Classify how this process was launched.
+ *
+ * | mode | thisPackageRoot | rule |
+ * |-------------|-----------------------------------------|-------------------------------------------|
+ * | developer | monorepo `packages/runtimes/vmz` | not under `node_modules` |
+ * | project | app `node_modules/(@vmz/)vmz` | under node_modules ∧ equals nearest |
+ * | global | global / unrelated node_modules install | under node_modules ∧ not nearest project |
+ *
+ * @param {{
+ * cwd?: string,
+ * thisPackageRoot?: string,
+ * }} [opts]
+ * @returns {{
+ * mode: InvocationMode,
+ * cwd: string,
+ * thisPackageRoot: string,
+ * nearestProjectVmz: string | null,
+ * isDeveloper: boolean,
+ * isProjectLocal: boolean,
+ * isGlobalLike: boolean,
+ * }}
+ */
+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',
+    };
+}
+/**
+ * Commands allowed in **global** mode without re-exec / refusal.
+ * Developer + project modes allow the full CLI.
+ * @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 full argv including command (e.g. `['check', '.']`)
+ * @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);
+        });
+    });
+}
+/**
+ * Guard for project-only commands when the current install is **global** mode.
+ * Developer / project → proceed. Global + local present → re-exec. Global alone → refuse.
+ *
+ * @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,13 @@ 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.
+ * 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,7 @@ export function emitLocaleTypedModules(report, outDir) {
     return written;
 }
 /**
- * MessageId rename plan (I1) — WorkspaceEdit-shaped, no parallel rename IR.
+ * 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) {

package/dist/locale-router.d.ts

@@ -1,14 +1,13 @@
 /**
- * Locale I3 router / PageMeta: route realization · canonical · hreflang ·
+ * Locale router / PageMeta: route realization · canonical · hreflang ·
  * Link locale retain · locale-aware cache key.
- * Design: 规划设计/vmz/28 §6 · §10 · 20
  *
  * LocaleId is a RouteNode realization dimension — not part of stable RouteId.
  */
 /**
  * Join locale prefix with a stable route path pattern.
  * @param {string} localeId
- * @param {string} pathPattern  stable path without locale (e.g. /account/profile)
+ * @param {string} pathPattern stable path without locale (e.g. /account/profile)
  * @param {{ strategy?: string, defaultPrefix?: string, defaultLocale?: string }} routing
  */
 export declare function realizeRoutePath(localeId: any, pathPattern: any, routing?: {}): {
@@ -29,10 +28,10 @@ export declare function realizeRoutePath(localeId: any, pathPattern: any, routin
 /**
  * Build RouteId × LocaleId realization table.
  * @param {{
- *   routes: Array<{ routeId: string, path: string }>,
- *   locales: string[],
- *   defaultLocale: string,
- *   routing?: { strategy?: string, defaultPrefix?: string },
+ * routes: Array<{ routeId: string, path: string }>,
+ * locales: string[],
+ * defaultLocale: string,
+ * routing?: { strategy?: string, defaultPrefix?: string },
  * }} input
  */
 export declare function buildLocaleRouteRealizationTable(input: any): {
@@ -55,15 +54,15 @@ export declare function absoluteUrl(origin: any, path: any): string;
 /**
  * Locale-aware PageMeta for one RouteId × LocaleId.
  * @param {{
- *   routeId: string,
- *   localeId: string,
- *   direction?: string,
- *   title: string,
- *   description?: string,
- *   origin: string,
- *   realizations: Array<{ routeId: string, localeId: string, path: string }>,
- *   locales: string[],
- *   defaultLocale: string,
+ * routeId: string,
+ * localeId: string,
+ * direction?: string,
+ * title: string,
+ * description?: string,
+ * origin: string,
+ * realizations: Array<{ routeId: string, localeId: string, path: string }>,
+ * locales: string[],
+ * defaultLocale: string,
  * }} input
  */
 export declare function buildLocalePageMeta(input: any): {
@@ -82,9 +81,9 @@ export declare function buildLocalePageMeta(input: any): {
 /**
  * `<Link to="routeId">` retains current locale — never hand-written localized paths.
  * @param {{
- *   to: string,
- *   currentLocale: string,
- *   realizations: Array<{ routeId: string, localeId: string, path: string }>,
+ * to: string,
+ * currentLocale: string,
+ * realizations: Array<{ routeId: string, localeId: string, path: string }>,
  * }} input
  */
 export declare function resolveLinkHref(input: any): {
@@ -120,13 +119,13 @@ export declare function parseLocaleFromPath(pathname: any, supportedLocales: any
 /**
  * Plan redirect / negotiation for an incoming URL (omit-prefix aware).
  * @param {{
- *   pathname: string,
- *   supportedLocales: string[],
- *   defaultLocale: string,
- *   routing?: { strategy?: string, defaultPrefix?: string },
- *   hostCandidates?: string[],
- *   preference?: string|null,
- *   userChoice?: string|null,
+ * pathname: string,
+ * supportedLocales: string[],
+ * defaultLocale: string,
+ * routing?: { strategy?: string, defaultPrefix?: string },
+ * hostCandidates?: string[],
+ * preference?: string|null,
+ * userChoice?: string|null,
  * }} input
  */
 export declare function planLocalePathNavigation(input: any): {
@@ -157,11 +156,11 @@ export declare function assertLocaleCacheKey(input: any): {
 /**
  * LocaleTransition must commit Route realization + PageMeta together.
  * @param {{
- *   fromLocale: string,
- *   toLocale: string,
- *   routeId: string,
- *   realizations: Array<{ routeId: string, localeId: string, path: string }>,
- *   pageMetaByLocale: Record<string, { locale: string, canonical: string }>,
+ * fromLocale: string,
+ * toLocale: string,
+ * routeId: string,
+ * realizations: Array<{ routeId: string, localeId: string, path: string }>,
+ * pageMetaByLocale: Record<string, { locale: string, canonical: string }>,
  * }} input
  */
 export declare function commitLocaleRouteMetaTransition(input: any): {
@@ -176,16 +175,16 @@ export declare function commitLocaleRouteMetaTransition(input: any): {
     diagnostics: any[];
 };
 /**
- * Aggregate I3 router/meta proof.
+ * Aggregate router/meta proof.
  * @param {{
- *   manifest: {
- *     defaultLocale: string,
- *     locales: Array<{ id: string, direction?: string }>,
- *     routing?: { strategy?: string, defaultPrefix?: string },
- *   },
- *   routes: Array<{ routeId: string, path: string }>,
- *   titles?: Record<string, Record<string, string>>,
- *   origin?: string,
+ * manifest: {
+ * defaultLocale: string,
+ * locales: Array<{ id: string, direction?: string }>,
+ * routing?: { strategy?: string, defaultPrefix?: string },
+ * },
+ * routes: Array<{ routeId: string, path: string }>,
+ * titles?: Record<string, Record<string, string>>,
+ * origin?: string,
  * }} input
  */
 export declare function checkLocaleRouter(input: any): {