@vmz/vmz 0.1.16 → 0.1.18

package/dist/locale-delivery.js

@@ -1,4 +1,3 @@
-// @ts-nocheck
 /**
  * Locale multi-host delivery: Web chunks · Mini packages · Native packs ·
  * Server error envelope / formatter resources.
@@ -7,15 +6,9 @@
  */
 import { createHash } from 'node:crypto';
 import { DIAG_LOCALE_CHUNK_HASH_MISMATCH, DIAG_LOCALE_DELIVERY_FULL_BUNDLE, DIAG_LOCALE_HOST_MESSAGE_DIVERGENCE, DIAG_LOCALE_MINI_CROSS_PACKAGE_UNPROVEN, DIAG_LOCALE_NATIVE_PACK_APP_MISMATCH, DIAG_LOCALE_NATIVE_PACK_HAS_JS, DIAG_LOCALE_NATIVE_PACK_UNSIGNED, DIAG_LOCALE_SERVER_FORMAT_WITHOUT_CONTEXT, DIAG_LOCALE_SERVER_TRANSLATED_ERROR, FORMATTER_DATA_VERSION, LOCALE_CHUNK_MANIFEST_SCHEMA, LOCALE_DELIVERY_CHECK_SCHEMA, LOCALE_DELIVERY_RESOLUTION_SCHEMA, LOCALE_MINI_PACKAGE_PROOF_SCHEMA, LOCALE_NATIVE_PACK_SCHEMA, LOCALE_SERVER_ERROR_ENVELOPE_SCHEMA, } from './locale-schema.js';
-/**
- * @param {unknown} value
- */
 function stableHash(value) {
     return createHash('sha256').update(JSON.stringify(value)).digest('hex').slice(0, 32);
 }
-/**
- * @param {Record<string, string[]>} [fallback]
- */
 export function fallbackDigest(fallback = {}) {
     const keys = Object.keys(fallback).sort();
     const normalized = {};
@@ -23,15 +16,9 @@ export function fallbackDigest(fallback = {}) {
         normalized[k] = [...(fallback[k] || [])];
     return stableHash(normalized);
 }
-/**
- * Hash reachable message variants for one locale.
- * @param {Array<{ messageId: string, variants: Record<string, { template: string }> }>} messages
- * @param {string} localeId
- * @param {string[]} [reachableIds]
- */
+/** Hash reachable message variants for one locale. */
 export function messageCatalogHash(messages, localeId, reachableIds) {
     const allow = reachableIds ? new Set(reachableIds) : null;
-    /** @type {Record<string, string>} */
     const slice = {};
     for (const m of messages || []) {
         if (allow && !allow.has(m.messageId))
@@ -45,25 +32,8 @@ export function messageCatalogHash(messages, localeId, reachableIds) {
         .map((k) => [k, slice[k]]);
     return stableHash(ordered);
 }
-/**
- * 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,
- * }} input
- */
+/** Build LocaleDeliveryResolution for one Host surface. */
 export function buildLocaleDeliveryResolution(input) {
-    /** @type {any[]} */
     const diagnostics = [];
     const supported = [...(input.supportedLocales || [])];
     const defaultLocale = input.defaultLocale;
@@ -80,12 +50,10 @@ export function buildLocaleDeliveryResolution(input) {
             message: `${input.host} delivery must not bundle all ${supported.length} locales by default`,
         });
     }
-    /** @type {Record<string, string>} */
     const messageCatalogHashes = {};
     for (const loc of supported) {
         messageCatalogHashes[loc] = messageCatalogHash(input.messages, loc, reachable);
     }
-    /** @type {any[]} */
     const lazyLocaleChunks = [];
     for (const loc of supported) {
         if (bundled.includes(loc))
@@ -127,26 +95,8 @@ export function buildLocaleDeliveryResolution(input) {
         diagnostics,
     };
 }
-/**
- * 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,
- * }} input
- */
+/** Validate a Native optional locale pack (signed, no JS, bound to app/plan/schema). */
 export function validateNativeLocalePack(input) {
-    /** @type {any[]} */
     const diagnostics = [];
     const pack = input.pack || {};
     if (!pack.signature) {
@@ -211,22 +161,13 @@ 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 }>,
- * }} input
- */
+/** Mini cross-subpackage message dependencies must be proven. */
 export function proveMiniPackageMessages(input) {
-    /** @type {any[]} */
     const diagnostics = [];
-    /** @type {Map<string, Set<string>>} */
     const owned = new Map();
     for (const p of input.packages || []) {
         owned.set(p.id, new Set(p.messageIds || []));
     }
-    /** @type {any[]} */
     const proven = [];
     for (const edge of input.edges || []) {
         const target = owned.get(edge.toPackage);
@@ -251,12 +192,8 @@ export function proveMiniPackageMessages(input) {
         diagnostics,
     };
 }
-/**
- * Server/client boundary: ErrorCode + params only (no translated strings).
- * @param {any} payload
- */
+/** Server/client boundary: ErrorCode + params only (no translated strings). */
 export function assertServerErrorEnvelope(payload) {
-    /** @type {any[]} */
     const diagnostics = [];
     if (payload == null || typeof payload !== 'object') {
         diagnostics.push({
@@ -291,12 +228,8 @@ export function assertServerErrorEnvelope(payload) {
         diagnostics,
     };
 }
-/**
- * Final-user server formatting (mail/export/push) requires explicit LocaleContext.
- * @param {{ localeContext?: { localeId?: string, timeZone?: string }|null, purpose: string }} input
- */
+/** Final-user server formatting (mail/export/push) requires explicit LocaleContext. */
 export function assertServerFormatContext(input) {
-    /** @type {any[]} */
     const diagnostics = [];
     const ctx = input.localeContext;
     if (!ctx?.localeId || !ctx?.timeZone) {
@@ -308,12 +241,8 @@ export function assertServerFormatContext(input) {
     }
     return { ok: diagnostics.length === 0, diagnostics };
 }
-/**
- * Same MessageId / catalog hashes must agree across Host projections.
- * @param {Array<ReturnType<typeof buildLocaleDeliveryResolution>>} resolutions
- */
+/** Same MessageId / catalog hashes must agree across Host projections. */
 export function assertHostMessageInvariant(resolutions) {
-    /** @type {any[]} */
     const diagnostics = [];
     if (!resolutions?.length)
         return { ok: true, diagnostics };
@@ -345,23 +274,8 @@ export function assertHostMessageInvariant(resolutions) {
     }
     return { ok: diagnostics.length === 0, diagnostics };
 }
-/**
- * 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[],
- * }} input
- */
+/** Aggregate delivery proof for fixture / CLI. */
 export function checkLocaleDelivery(input) {
-    /** @type {any[]} */
     const diagnostics = [];
     const supported = (input.manifest?.locales || []).map((l) => l.id);
     const defaultLocale = input.manifest?.defaultLocale;

package/dist/locale-route-emit.d.ts

@@ -3,15 +3,13 @@
  * Consumed by serve-host + static-emit; LocaleId stays out of stable RouteId.
  */
 export declare const LOCALE_ROUTE_REALIZATION_ARTIFACT_SCHEMA = "vmz.locale.route_realization.v0";
-/**
- * @param {string} projectRoot
- * @param {string} distDir
- * @param {{ origin?: string }} [opts]
- */
-export declare function emitLocaleRouteRealization(projectRoot: any, distDir: any, opts?: {}): {
+export interface EmitLocaleRouteRealizationOpts {
+    origin?: string;
+}
+export declare function emitLocaleRouteRealization(projectRoot: string, distDir: string, opts?: EmitLocaleRouteRealizationOpts): {
     ok: boolean;
     written: any[];
-    diagnostics: any;
+    diagnostics: import("./locale-check.js").LocaleDiagnostic[];
     artifact: any;
 } | {
     ok: boolean;
@@ -30,8 +28,24 @@ export declare function emitLocaleRouteRealization(projectRoot: any, distDir: an
             routeId: string;
             path: string;
         }[];
-        realizations: any[];
-        pageMetas: any[];
+        realizations: import("./locale-router.js").LocaleRealization[];
+        pageMetas: {
+            schema: string;
+            routeId: string;
+            locale: string;
+            htmlLang: string;
+            dir: string;
+            title: string;
+            description: string;
+            canonical: string;
+            alternates: {
+                localeId: string;
+                hreflang: string;
+                href: string;
+            }[];
+            diagnostics: import("./locale-router.js").LocaleDiagnostic[];
+            status: string;
+        }[];
     };
     diagnostics: any[];
 };

package/dist/locale-route-emit.js

@@ -1,4 +1,3 @@
-// @ts-nocheck
 /**
  * Emit RouteId × LocaleId realization (+ PageMeta / hreflang seed) into dist/_vmz.
  * Consumed by serve-host + static-emit; LocaleId stays out of stable RouteId.
@@ -10,11 +9,6 @@ import { buildLocalePageMeta, buildLocaleRouteRealizationTable } from './locale-
 import { writePrettyJsonFile } from './pretty-json.js';
 import { listPublicPageUnits, unitBrowserPathPattern } from './route-path.js';
 export const LOCALE_ROUTE_REALIZATION_ARTIFACT_SCHEMA = 'vmz.locale.route_realization.v0';
-/**
- * @param {string} projectRoot
- * @param {string} distDir
- * @param {{ origin?: string }} [opts]
- */
 export function emitLocaleRouteRealization(projectRoot, distDir, opts = {}) {
     const report = checkLocales({ projectRoot, checkUnused: false });
     if (localeHasErrors(report)) {
@@ -54,7 +48,6 @@ export function emitLocaleRouteRealization(projectRoot, distDir, opts = {}) {
         return { ok: false, written: [], diagnostics: table.diagnostics || [], artifact: null };
     }
     const origin = String(opts.origin || process.env.VMZ_SITE_ORIGIN || 'https://example.test').replace(/\/$/, '');
-    /** @type {any[]} */
     const pageMetas = [];
     for (const route of routes) {
         for (const loc of locales) {

package/dist/locale-router.d.ts

@@ -4,94 +4,112 @@
  *
  * 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 {{ strategy?: string, defaultPrefix?: string, defaultLocale?: string }} routing
- */
-export declare function realizeRoutePath(localeId: any, pathPattern: any, routing?: {}): {
+export interface LocaleRoutingOpts {
+    strategy?: string;
+    defaultPrefix?: string;
+    defaultLocale?: string;
+}
+export interface LocaleRouteEntry {
+    routeId: string;
+    path: string;
+}
+export interface LocaleRealization {
+    routeId: string;
+    localeId: string;
+    path: string;
+    pathPattern?: string;
+    prefixed?: boolean;
+    strategy?: string;
+    defaultPrefix?: string;
+    schema?: string;
+}
+export interface LocaleDiagnostic {
+    code: string;
+    severity: string;
+    message: string;
+}
+/** Join locale prefix with a stable route path pattern. */
+export declare function realizeRoutePath(localeId: string, pathPattern: string, routing?: LocaleRoutingOpts): {
     schema: string;
-    localeId: any;
+    localeId: string;
     path: string;
     prefixed: boolean;
-    strategy: any;
+    strategy: string;
     defaultPrefix?: undefined;
 } | {
     schema: string;
-    localeId: any;
+    localeId: string;
     path: string;
     prefixed: boolean;
     strategy: string;
-    defaultPrefix: any;
+    defaultPrefix: string;
 };
-/**
- * Build RouteId × LocaleId realization table.
- * @param {{
- * routes: Array<{ routeId: string, path: string }>,
- * locales: string[],
- * defaultLocale: string,
- * routing?: { strategy?: string, defaultPrefix?: string },
- * }} input
- */
-export declare function buildLocaleRouteRealizationTable(input: any): {
+/** Build RouteId × LocaleId realization table. */
+export declare function buildLocaleRouteRealizationTable(input: {
+    routes: LocaleRouteEntry[];
+    locales: string[];
+    defaultLocale: string;
+    routing?: LocaleRoutingOpts;
+}): {
     schema: string;
     status: string;
     routing: {
-        strategy: any;
-        defaultPrefix: any;
-        defaultLocale: any;
+        strategy: string;
+        defaultPrefix: string;
+        defaultLocale: string;
     };
-    realizations: any[];
-    diagnostics: any[];
+    realizations: LocaleRealization[];
+    diagnostics: LocaleDiagnostic[];
 };
-/**
- * Absolute URL helper.
- * @param {string} origin
- * @param {string} path
- */
-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,
- * }} input
- */
-export declare function buildLocalePageMeta(input: any): {
+/** Absolute URL helper. */
+export declare function absoluteUrl(origin: string, path: string): string;
+/** Locale-aware PageMeta for one RouteId × LocaleId. */
+export declare function buildLocalePageMeta(input: {
+    routeId: string;
+    localeId: string;
+    direction?: string;
+    title: string;
+    description?: string;
+    origin: string;
+    realizations: Array<{
+        routeId: string;
+        localeId: string;
+        path: string;
+    }>;
+    locales: string[];
+    defaultLocale: string;
+}): {
     schema: string;
-    routeId: any;
-    locale: any;
-    htmlLang: any;
-    dir: any;
-    title: any;
-    description: any;
+    routeId: string;
+    locale: string;
+    htmlLang: string;
+    dir: string;
+    title: string;
+    description: string;
     canonical: string;
-    alternates: any[];
-    diagnostics: any[];
+    alternates: {
+        localeId: string;
+        hreflang: string;
+        href: string;
+    }[];
+    diagnostics: LocaleDiagnostic[];
     status: string;
 };
-/**
- * `<Link to="routeId">` retains current locale — never hand-written localized paths.
- * @param {{
- * to: string,
- * currentLocale: string,
- * realizations: Array<{ routeId: string, localeId: string, path: string }>,
- * }} input
- */
-export declare function resolveLinkHref(input: any): {
+/** `<Link to="routeId">` retains current locale — never hand-written localized paths. */
+export declare function resolveLinkHref(input: {
+    to: string;
+    currentLocale: string;
+    realizations: Array<{
+        routeId: string;
+        localeId: string;
+        path: string;
+    }>;
+}): {
     schema: string;
     status: string;
-    to: any;
+    to: string;
     href: any;
-    localeId: any;
+    localeId: string;
     diagnostics: {
         code: string;
         severity: string;
@@ -101,126 +119,135 @@ export declare function resolveLinkHref(input: any): {
 } | {
     schema: string;
     status: string;
-    to: any;
-    routeId: any;
-    localeId: any;
-    href: any;
+    to: string;
+    routeId: string;
+    localeId: string;
+    href: string;
     diagnostics: any[];
 };
-/**
- * Parse locale prefix from a pathname under prefix strategy.
- * @param {string} pathname
- * @param {string[]} supportedLocales
- */
-export declare function parseLocaleFromPath(pathname: any, supportedLocales: any): {
+/** Parse locale prefix from a pathname under prefix strategy. */
+export declare function parseLocaleFromPath(pathname: string, supportedLocales: string[]): {
     localeId: string;
     restPath: string;
 };
-/**
- * Rewrite a same-app href to the given LocaleId via route realization.
- * Stable path (no locale) is recovered first, then re-realized — Link never hardcodes locale.
- * @param {string} href
- * @param {string} localeId
- * @param {{
- *   locales?: Array<{ id: string }|string>,
- *   defaultLocale?: string,
- *   routing?: { strategy?: string, defaultPrefix?: string, defaultLocale?: string },
- * }} artifact
- */
-export declare function localizeSameAppHref(href: any, localeId: any, artifact: any): any;
-/**
- * Rewrite `<a data-vmz-route href>` in HTML body to retain `localeId`.
- * @param {string} html
- * @param {string} localeId
- * @param {Parameters<typeof localizeSameAppHref>[2]} artifact
- * @param {(s: string) => string} [escapeAttr]
- */
-export declare function localizeBodyLinks(html: any, localeId: any, artifact: any, escapeAttr?: (s: any) => string): 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,
- * }} input
- */
-export declare function planLocalePathNavigation(input: any): {
+export interface LocaleHrefArtifact {
+    locales?: Array<{
+        id: string;
+    } | string>;
+    defaultLocale?: string;
+    routing?: LocaleRoutingOpts;
+}
+/** Rewrite a same-app href to the given LocaleId via route realization. */
+export declare function localizeSameAppHref(href: string, localeId: string, artifact: LocaleHrefArtifact): string;
+/** Rewrite `<a data-vmz-route href>` in HTML body to retain `localeId`. */
+export declare function localizeBodyLinks(html: string, localeId: string, artifact: LocaleHrefArtifact, escapeAttr?: (s: string) => string): string;
+/** Plan redirect / negotiation for an incoming URL (omit-prefix aware). */
+export declare function planLocalePathNavigation(input: {
+    pathname: string;
+    supportedLocales: string[];
+    defaultLocale: string;
+    routing?: LocaleRoutingOpts;
+    hostCandidates?: string[];
+    preference?: string | null;
+    userChoice?: string | null;
+}): {
     schema: string;
     kind: string;
     pathname: string;
     routeLocale: string;
-    negotiatedLocale: any;
+    negotiatedLocale: string;
     restPath: string;
-    redirectTo: any;
+    redirectTo: string;
     realizedPath: string;
-    diagnostics: any[];
-    contentLocale: any;
+    diagnostics: LocaleDiagnostic[];
+    contentLocale: string;
 };
-/**
- * Locale-aware cache key — must include LocaleId so Accept-Language cannot steal content.
- * @param {{ routeId: string, localeId: string, path: string }} input
- */
-export declare function localeAwareCacheKey(input: any): string;
-/**
- * Reject Vary: Accept-Language on a cache key that does not encode LocaleId.
- * @param {{ cacheKey: string, varyAcceptLanguage?: boolean, localeId?: string }} input
- */
-export declare function assertLocaleCacheKey(input: any): {
+/** Locale-aware cache key — must include LocaleId so Accept-Language cannot steal content. */
+export declare function localeAwareCacheKey(input: {
+    routeId: string;
+    localeId: string;
+    path: string;
+}): string;
+/** Reject Vary: Accept-Language on a cache key that does not encode LocaleId. */
+export declare function assertLocaleCacheKey(input: {
+    cacheKey: string;
+    varyAcceptLanguage?: boolean;
+    localeId?: string;
+}): {
     ok: boolean;
-    diagnostics: any[];
+    diagnostics: LocaleDiagnostic[];
 };
-/**
- * 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 }>,
- * }} input
- */
-export declare function commitLocaleRouteMetaTransition(input: any): {
+/** LocaleTransition must commit Route realization + PageMeta together. */
+export declare function commitLocaleRouteMetaTransition(input: {
+    fromLocale: string;
+    toLocale: string;
+    routeId: string;
+    realizations: Array<{
+        routeId: string;
+        localeId: string;
+        path: string;
+    }>;
+    pageMetaByLocale: Record<string, {
+        locale: string;
+        canonical: string;
+    }>;
+}): {
     schema: string;
     kind: string;
     status: string;
-    fromLocale: any;
-    toLocale: any;
-    fromPath: any;
-    toPath: any;
-    pageMeta: any;
-    diagnostics: any[];
+    fromLocale: string;
+    toLocale: string;
+    fromPath: string;
+    toPath: string;
+    pageMeta: {
+        locale: string;
+        canonical: string;
+    };
+    diagnostics: LocaleDiagnostic[];
 };
-/**
- * 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,
- * }} input
- */
-export declare function checkLocaleRouter(input: any): {
+/** Aggregate router/meta proof. */
+export declare function checkLocaleRouter(input: {
+    manifest: {
+        defaultLocale: string;
+        locales: Array<{
+            id: string;
+            direction?: string;
+        }>;
+        routing?: LocaleRoutingOpts;
+    };
+    routes: LocaleRouteEntry[];
+    titles?: Record<string, Record<string, string>>;
+    origin?: string;
+}): {
     schema: string;
     status: string;
     realizationTable: {
         schema: string;
         status: string;
         routing: {
-            strategy: any;
-            defaultPrefix: any;
-            defaultLocale: any;
+            strategy: string;
+            defaultPrefix: string;
+            defaultLocale: string;
         };
-        realizations: any[];
-        diagnostics: any[];
+        realizations: LocaleRealization[];
+        diagnostics: LocaleDiagnostic[];
     };
-    pageMetas: any[];
-    diagnostics: any[];
+    pageMetas: {
+        schema: string;
+        routeId: string;
+        locale: string;
+        htmlLang: string;
+        dir: string;
+        title: string;
+        description: string;
+        canonical: string;
+        alternates: {
+            localeId: string;
+            hreflang: string;
+            href: string;
+        }[];
+        diagnostics: LocaleDiagnostic[];
+        status: string;
+    }[];
+    diagnostics: LocaleDiagnostic[];
 };