@cosmicdrift/kumiko-headless 0.328.0 → 0.329.0

package/{src/form/zod-bridge.ts → dist/form/zod-bridge.js}

@@ -1,6 +1,3 @@
-import type { ZodError, ZodIssue } from "zod";
-import type { FieldIssue } from "../dispatcher";
-
 // Translates a ZodError into the same FieldIssue shape the server emits via
 // its own zod-bridge (packages/framework/src/errors/zod-bridge.ts). The two
 // bridges stay in sync on purpose: a field failing zod on the client reads
@@ -17,75 +14,72 @@ import type { FieldIssue } from "../dispatcher";
 // tend to introduce new param keys, and the server's classes.test.ts is
 // what catches them. A value added there should be added here too.
 const ISSUE_PARAM_KEYS = [
-  "minimum",
-  "maximum",
-  "expected",
-  "received",
-  "type",
-  "inclusive",
-  "exact",
-  "keys",
-  // Zod 4 additions
-  "format",
-  "divisor",
-  "values",
-  "pattern",
-] as const;
-
+    "minimum",
+    "maximum",
+    "expected",
+    "received",
+    "type",
+    "inclusive",
+    "exact",
+    "keys",
+    // Zod 4 additions
+    "format",
+    "divisor",
+    "values",
+    "pattern",
+];
 // Flat FieldIssue list — same shape as server-side ValidationError.fields.
 // The form-controller groups this by `path` for its snapshot's errors map.
-export function zodErrorToFieldIssues(error: ZodError): FieldIssue[] {
-  return error.issues.map<FieldIssue>((issue) => {
-    const params = extractIssueParams(issue);
-    return {
-      // Empty-path issues (top-level object/array failures) use "(root)" so
-      // the form-controller has a stable key to show "form itself is
-      // malformed" errors under — matches what the server does.
-      path: issue.path.map(String).join(".") || "(root)",
-      code: issue.code,
-      i18nKey: resolveI18nKey(issue),
-      ...(params && { params }),
-    };
-  });
+export function zodErrorToFieldIssues(error) {
+    return error.issues.map((issue) => {
+        const params = extractIssueParams(issue);
+        return {
+            // Empty-path issues (top-level object/array failures) use "(root)" so
+            // the form-controller has a stable key to show "form itself is
+            // malformed" errors under — matches what the server does.
+            path: issue.path.map(String).join(".") || "(root)",
+            code: issue.code,
+            i18nKey: resolveI18nKey(issue),
+            ...(params && { params }),
+        };
+    });
 }
-
 // Same magic key both sides of a superRefine can set to opt out of the
 // generic `errors.validation.custom` message — see form-schema.ts.
 export const I18N_KEY_PARAM = "i18nKey";
-
 // `code: "custom"` is zod's catch-all for every superRefine/refine check;
 // left mechanical it'd collapse onto one generic key, so a superRefine can
 // set `params[I18N_KEY_PARAM]` to override it. Keep in sync with the server
 // mirror (packages/framework/src/errors/zod-bridge.ts).
-function resolveI18nKey(issue: ZodIssue): string {
-  if (issue.code === "custom") {
-    const override = issue.params?.[I18N_KEY_PARAM];
-    if (typeof override === "string") return override;
-  }
-  return `errors.validation.${issue.code}`;
+function resolveI18nKey(issue) {
+    if (issue.code === "custom") {
+        const override = issue.params?.[I18N_KEY_PARAM];
+        if (typeof override === "string")
+            return override;
+    }
+    return `errors.validation.${issue.code}`;
 }
-
-function extractIssueParams(issue: ZodIssue): Readonly<Record<string, unknown>> | undefined {
-  const out: Record<string, unknown> = {};
-  const bag = issue as unknown as Record<string, unknown>; // @cast-boundary zod-issue
-  for (const key of ISSUE_PARAM_KEYS) {
-    if (bag[key] !== undefined) out[key] = bag[key];
-  }
-  return Object.keys(out).length > 0 ? out : undefined;
+function extractIssueParams(issue) {
+    const out = {};
+    const bag = issue; // @cast-boundary zod-issue
+    for (const key of ISSUE_PARAM_KEYS) {
+        if (bag[key] !== undefined)
+            out[key] = bag[key];
+    }
+    return Object.keys(out).length > 0 ? out : undefined;
 }
-
 // Groups a flat FieldIssue list into the `errors` map carried by a
 // FormSnapshot. A field with multiple issues (e.g. both "required" and
 // "min") keeps both — UIs that only render the first can pick the first
 // element, those that want a full list have it.
-export function groupIssuesByPath(
-  issues: readonly FieldIssue[],
-): Record<string, readonly FieldIssue[]> {
-  const out: Record<string, FieldIssue[]> = {};
-  for (const issue of issues) {
-    const bucket = out[issue.path];
-    if (bucket) bucket.push(issue);
-    else out[issue.path] = [issue];
-  }
-  return out;
+export function groupIssuesByPath(issues) {
+    const out = {};
+    for (const issue of issues) {
+        const bucket = out[issue.path];
+        if (bucket)
+            bucket.push(issue);
+        else
+            out[issue.path] = [issue];
+    }
+    return out;
 }

package/dist/format/escape.d.ts

@@ -0,0 +1,5 @@
+export declare function escapeHtml(s: string): string;
+export declare function escapeHtmlAttr(s: string): string;
+export declare function escapeXml(s: string): string;
+export declare function stripControlChars(value: string): string;
+export declare function isSafeHref(href: string): boolean;

package/{src/format/escape.ts → dist/format/escape.js}

@@ -1,28 +1,25 @@
-export function escapeHtml(s: string): string {
-  return s
-    .replace(/&/g, "&")
-    .replace(/</g, "&lt;")
-    .replace(/>/g, "&gt;")
-    .replace(/"/g, "&quot;");
+export function escapeHtml(s) {
+    return s
+        .replace(/&/g, "&amp;")
+        .replace(/</g, "&lt;")
+        .replace(/>/g, "&gt;")
+        .replace(/"/g, "&quot;");
 }
-
 // Superset of escapeHtml for attribute contexts: additionally escapes ' so
 // single-quoted attributes cannot be broken out of.
-export function escapeHtmlAttr(s: string): string {
-  return escapeHtml(s).replace(/'/g, "&#39;");
+export function escapeHtmlAttr(s) {
+    return escapeHtml(s).replace(/'/g, "&#39;");
 }
-
 // Shared API for app repos (publicstatus badge-SVG renders XML by hand) —
 // no in-repo consumer yet, deliberately exported for cross-repo dedup.
-export function escapeXml(s: string): string {
-  return s
-    .replace(/&/g, "&amp;")
-    .replace(/</g, "&lt;")
-    .replace(/>/g, "&gt;")
-    .replace(/"/g, "&quot;")
-    .replace(/'/g, "&apos;");
+export function escapeXml(s) {
+    return s
+        .replace(/&/g, "&amp;")
+        .replace(/</g, "&lt;")
+        .replace(/>/g, "&gt;")
+        .replace(/"/g, "&quot;")
+        .replace(/'/g, "&apos;");
 }
-
 // Strips ASCII control chars + space (codepoints 0x00-0x20 and 0x7f) — the
 // same characters browsers strip before scheme detection. `.trim()` alone
 // only removes leading/trailing whitespace, so a scheme like
@@ -31,15 +28,15 @@ export function escapeXml(s: string): string {
 // `return true`, and the browser then normalizes it back to "javascript:"
 // and executes it. Written as a char-code filter rather than a regex range
 // to avoid embedding literal control characters in source.
-export function stripControlChars(value: string): string {
-  let result = "";
-  for (const ch of value) {
-    const code = ch.codePointAt(0) ?? 0;
-    if (code > 0x20 && code !== 0x7f) result += ch;
-  }
-  return result;
+export function stripControlChars(value) {
+    let result = "";
+    for (const ch of value) {
+        const code = ch.codePointAt(0) ?? 0;
+        if (code > 0x20 && code !== 0x7f)
+            result += ch;
+    }
+    return result;
 }
-
 // http(s)/mailto or scheme-less (relative/anchor) allowed; javascript:,
 // data:, vbscript:, etc. rejected. Shared between renderer-web's Link
 // primitive and page-render's server-side markdown renderer (both take
@@ -53,27 +50,26 @@ export function stripControlChars(value: string): string {
 // (not delete) so the scheme check sees what the browser will execute —
 // deleting "&colon;" would leave no colon at all, which reads as a safe
 // scheme-less href, exactly backwards.
-const NAMED_HTML_ENTITY_CHARS: Record<string, string> = {
-  colon: ":",
-  tab: "\t",
-  newline: "\n",
-  semi: ";",
-  amp: "&",
+const NAMED_HTML_ENTITY_CHARS = {
+    colon: ":",
+    tab: "\t",
+    newline: "\n",
+    semi: ";",
+    amp: "&",
 };
-
-function decodeHtmlEntities(value: string): string {
-  return value.replace(/&(#x[0-9a-f]+|#[0-9]+|[a-z][a-z0-9]*);/gi, (match, entity: string) => {
-    if (entity[0] === "#") {
-      const isHex = entity[1]?.toLowerCase() === "x";
-      const code = Number.parseInt(isHex ? entity.slice(2) : entity.slice(1), isHex ? 16 : 10);
-      return Number.isFinite(code) ? String.fromCodePoint(code) : match;
-    }
-    return NAMED_HTML_ENTITY_CHARS[entity.toLowerCase()] ?? match;
-  });
+function decodeHtmlEntities(value) {
+    return value.replace(/&(#x[0-9a-f]+|#[0-9]+|[a-z][a-z0-9]*);/gi, (match, entity) => {
+        if (entity[0] === "#") {
+            const isHex = entity[1]?.toLowerCase() === "x";
+            const code = Number.parseInt(isHex ? entity.slice(2) : entity.slice(1), isHex ? 16 : 10);
+            return Number.isFinite(code) ? String.fromCodePoint(code) : match;
+        }
+        return NAMED_HTML_ENTITY_CHARS[entity.toLowerCase()] ?? match;
+    });
 }
-
-export function isSafeHref(href: string): boolean {
-  const trimmed = stripControlChars(decodeHtmlEntities(href)).toLowerCase();
-  if (!/^[a-z][a-z0-9+.-]*:/.test(trimmed)) return true;
-  return /^(?:https?|mailto):/.test(trimmed);
+export function isSafeHref(href) {
+    const trimmed = stripControlChars(decodeHtmlEntities(href)).toLowerCase();
+    if (!/^[a-z][a-z0-9+.-]*:/.test(trimmed))
+        return true;
+    return /^(?:https?|mailto):/.test(trimmed);
 }

package/dist/format/html-template.d.ts

@@ -0,0 +1,9 @@
+export declare class RawHtml {
+    readonly html: string;
+    constructor(html: string);
+    toString(): string;
+}
+/** Markiert bereits escaptes/vertrauenswürdiges Markup für html`...`. */
+export declare function raw(html: string): RawHtml;
+export type HtmlValue = string | number | boolean | null | undefined | RawHtml | ReadonlyArray<HtmlValue>;
+export declare function html(strings: TemplateStringsArray, ...values: ReadonlyArray<HtmlValue>): RawHtml;

package/dist/format/html-template.js

@@ -0,0 +1,39 @@
+// html`...` — Tagged-Template, das jede Interpolation automatisch HTML-escaped.
+// Macht Escaping strukturell statt per-Callsite-Konvention: vergessen ist
+// unmöglich, bewusst rohes HTML braucht ein explizites raw(). Der
+// HTML-Escape-Guard (kumiko-guards) akzeptiert html`...` als safe.
+import { escapeHtml } from "./escape.js";
+export class RawHtml {
+    html;
+    constructor(html) {
+        this.html = html;
+    }
+    toString() {
+        return this.html;
+    }
+}
+/** Markiert bereits escaptes/vertrauenswürdiges Markup für html`...`. */
+export function raw(html) {
+    return new RawHtml(html);
+}
+function renderValue(value) {
+    if (value === null || value === undefined)
+        return "";
+    if (value instanceof RawHtml)
+        return value.html;
+    if (Array.isArray(value))
+        return value.map(renderValue).join("");
+    if (typeof value === "string")
+        return escapeHtml(value);
+    return String(value);
+}
+// Rückgabe ist RawHtml, damit Fragmente verschachtelbar sind ohne doppelt zu
+// escapen: `html`<div>${item}</div>`` innerhalb eines äußeren html`...`
+// passiert unverändert durch. toString() liefert das fertige Markup.
+export function html(strings, ...values) {
+    let out = strings[0] ?? "";
+    values.forEach((value, i) => {
+        out += renderValue(value) + (strings[i + 1] ?? "");
+    });
+    return new RawHtml(out);
+}

package/dist/format/index.d.ts

@@ -0,0 +1,10 @@
+import { Temporal } from "temporal-polyfill";
+export declare function toInstant(raw: string): Temporal.Instant;
+/** Exported for UnitKey parity tests against @cosmicdrift/kumiko-types/screen. */
+export declare const UNIT_FORMAT_KEYS: readonly string[];
+export { escapeHtml, escapeHtmlAttr, escapeXml, isSafeHref, stripControlChars } from "./escape.js";
+export { type HtmlValue, html, RawHtml, raw } from "./html-template.js";
+export { currencyDecimals } from "./money.js";
+export declare function applyFormatSpec(spec: {
+    format: string;
+} & Record<string, unknown>, value: unknown, translate?: (key: string) => string): string;

package/dist/format/index.js

@@ -0,0 +1,192 @@
+// Pure format utilities — no web or platform dependencies.
+// Shared between renderer-web, renderer-native, and server-side tests.
+import { Temporal } from "temporal-polyfill";
+function toPlainDate(raw) {
+    try {
+        return Temporal.PlainDate.from(raw);
+    }
+    catch {
+        // "date"-typed field stored as a full instant (day-boundary timestamp) —
+        // take the calendar date in the local zone rather than fail.
+        return toInstant(raw).toZonedDateTimeISO(Temporal.Now.timeZoneId()).toPlainDate();
+    }
+}
+// Temporal.Instant.from is stricter than the `new Date(raw)` this replaced:
+// it requires a UTC designator/offset (Z/+hh:mm). Timestamps without one
+// (e.g. "2026-07-18T12:00:00", still valid input to `new Date`) throw here
+// instead of parsing — fall back to reading them as a local wall-clock time,
+// same posture as toPlainDate's own fallback above.
+export function toInstant(raw) {
+    try {
+        return Temporal.Instant.from(raw);
+    }
+    catch {
+        return Temporal.PlainDateTime.from(raw).toZonedDateTime(Temporal.Now.timeZoneId()).toInstant();
+    }
+}
+function formatDateCell(value, type, opts) {
+    try {
+        const raw = typeof value === "string" ? value : String(value);
+        const locale = opts?.locale;
+        if (opts?.dateStyle || opts?.timeStyle) {
+            if (type === "date") {
+                // ponytail: timeStyle is ignored here on purpose — a PlainDate has no
+                // time component to format, so a timeStyle-only "date" field falls
+                // back to PlainDate's default dateStyle instead of rendering a time.
+                return toPlainDate(raw).toLocaleString(locale, {
+                    dateStyle: opts.dateStyle,
+                });
+            }
+            return toInstant(raw).toLocaleString(locale, {
+                dateStyle: opts.dateStyle,
+                timeStyle: opts.timeStyle,
+            });
+        }
+        if (type === "date") {
+            return toPlainDate(raw).toLocaleString(locale, {
+                year: "numeric",
+                month: "2-digit",
+                day: "2-digit",
+            });
+        }
+        return toInstant(raw).toLocaleString(locale, {
+            year: "numeric",
+            month: "short",
+            day: "numeric",
+            hour: "2-digit",
+            minute: "2-digit",
+        });
+    }
+    catch {
+        return String(value);
+    }
+}
+// No `locale` fallback to a browser API here (headless has none) — passing
+// `undefined` to Intl.NumberFormat resolves the runtime's default locale,
+// the same value a browser's navigator.language-based guess would produce.
+function formatNumberCell(value, locale, grouping = true) {
+    if (typeof value !== "number" || !Number.isFinite(value))
+        return String(value);
+    try {
+        return new Intl.NumberFormat(locale, { useGrouping: grouping }).format(value);
+    }
+    catch {
+        // Malformed BCP-47 locale tag — mirrors formatDateCell's fallback above.
+        return String(value);
+    }
+}
+// Two-tier unit table for `{ format: "unit" }`. Keys mirror
+// @cosmicdrift/kumiko-types' UnitKey (kept as a local literal union instead
+// of an import — headless has no build-time dependency on kumiko-types
+// today, and applyFormatSpec's spec param is already an untyped
+// Record<string, unknown>, cast per-case like every other format below).
+const UNIT_INTL_IDS = {
+    km: "kilometer",
+    m: "meter",
+    kg: "kilogram",
+    percent: "percent",
+    mi: "mile",
+};
+// "m2" (square meter) has no ECMA-402 sanctioned unit — Intl.NumberFormat
+// throws RangeError for "square-meter". Locale-format the number and append
+// the literal suffix instead of going through `style: "unit"`.
+const UNIT_SUFFIXES = { m2: "m²" };
+function isIntlUnit(unit) {
+    return Object.hasOwn(UNIT_INTL_IDS, unit);
+}
+function isSuffixUnit(unit) {
+    return Object.hasOwn(UNIT_SUFFIXES, unit);
+}
+function formatUnitCell(value, unit, locale, unitDisplay) {
+    const n = typeof value === "number" ? value : Number(value);
+    if (unit === undefined || !Number.isFinite(n))
+        return String(value);
+    if (isIntlUnit(unit)) {
+        try {
+            return new Intl.NumberFormat(locale, {
+                style: "unit",
+                unit: UNIT_INTL_IDS[unit],
+                unitDisplay,
+            }).format(n);
+        }
+        catch {
+            // Malformed BCP-47 locale tag — mirrors formatNumberCell's fallback below.
+            return formatNumberCell(n, locale);
+        }
+    }
+    if (isSuffixUnit(unit)) {
+        return `${formatNumberCell(n, locale)} ${UNIT_SUFFIXES[unit]}`;
+    }
+    return String(value);
+}
+/** Exported for UnitKey parity tests against @cosmicdrift/kumiko-types/screen. */
+export const UNIT_FORMAT_KEYS = [
+    ...Object.keys(UNIT_INTL_IDS),
+    ...Object.keys(UNIT_SUFFIXES),
+];
+export { escapeHtml, escapeHtmlAttr, escapeXml, isSafeHref, stripControlChars } from "./escape.js";
+export { html, RawHtml, raw } from "./html-template.js";
+export { currencyDecimals } from "./money.js";
+export function applyFormatSpec(spec, value, translate) {
+    const isEmpty = value === null || value === undefined || value === "";
+    // priority renders its emptyLabel for empty values — every other format
+    // collapses empty to "".
+    if (isEmpty && spec.format !== "priority")
+        return "";
+    switch (spec.format) {
+        case "timestamp":
+        case "date":
+            return formatDateCell(value, spec.format, {
+                locale: spec["locale"],
+                dateStyle: spec["dateStyle"],
+                timeStyle: spec.format === "timestamp"
+                    ? spec["timeStyle"]
+                    : undefined,
+            });
+        case "boolean": {
+            if (value === true) {
+                const trueLabel = spec["trueLabel"];
+                return trueLabel === undefined ? "✓" : (translate?.(trueLabel) ?? trueLabel);
+            }
+            if (value === false) {
+                const falseLabel = spec["falseLabel"];
+                return falseLabel === undefined ? "" : (translate?.(falseLabel) ?? falseLabel);
+            }
+            return "";
+        }
+        case "currency": {
+            const sym = spec["symbol"] ?? "";
+            return sym.length > 0 ? `${value} ${sym}` : String(value);
+        }
+        case "number":
+        case "decimal":
+        case "bigInt":
+            return formatNumberCell(value, spec["locale"], spec["grouping"] ?? true);
+        case "unit":
+            return formatUnitCell(value, spec["unit"], spec["locale"], spec["unitDisplay"] ?? "short");
+        case "priority": {
+            const emptyLabel = spec["emptyLabel"] ?? "—";
+            const prefix = spec["prefix"] ?? "";
+            if (isEmpty || value === 0)
+                return emptyLabel;
+            return `${prefix}${value}`;
+        }
+        case "enumOption": {
+            const raw = typeof value === "string" ? value : String(value);
+            const keyPrefix = spec["keyPrefix"];
+            if (keyPrefix === undefined || translate === undefined)
+                return raw;
+            const key = `${keyPrefix}${raw}`;
+            const translated = translate(key);
+            return translated === key ? raw : translated;
+        }
+        case "json":
+            return JSON.stringify(value, null, spec["indent"] ?? 2);
+        default:
+            if (typeof process !== "undefined" && process.env.NODE_ENV !== "production") {
+                // biome-ignore lint/suspicious/noConsole: dev-only warning
+                console.warn(`[kumiko] applyFormatSpec: unknown format key "${spec.format}" — registered via FieldFormatRegistry module augmentation?`);
+            }
+            return typeof value === "string" ? value : String(value);
+    }
+}

package/dist/format/money.d.ts

@@ -0,0 +1 @@
+export declare function currencyDecimals(code: string): number;

package/{src/format/money.ts → dist/format/money.js}

@@ -3,9 +3,10 @@
 // MoneyInput (minor-unit display factor) and RenderField's minor/major-unit
 // conversion (kumiko-framework#1923) — a single source keeps both sides
 // scaling the same currency the same way.
-export function currencyDecimals(code: string): number {
-  if (code === "JPY" || code === "KRW" || code === "VND" || code === "ISK") return 0;
-  if (code === "BHD" || code === "JOD" || code === "KWD" || code === "OMR" || code === "TND")
-    return 3;
-  return 2;
+export function currencyDecimals(code) {
+    if (code === "JPY" || code === "KRW" || code === "VND" || code === "ISK")
+        return 0;
+    if (code === "BHD" || code === "JOD" || code === "KWD" || code === "OMR" || code === "TND")
+        return 3;
+    return 2;
 }

package/dist/index.d.ts

@@ -0,0 +1,14 @@
+export type { ParsedRefTarget } from "@cosmicdrift/kumiko-framework/ui-types";
+export { parseRefTarget } from "@cosmicdrift/kumiko-framework/ui-types";
+export type { AssetResolution, AssetResolveContext, AssetResolver, BadgeProps, ButtonProps, CardProps, DatePickerProps, IconProps, LocaleResolver, ModalProps, NumberInputProps, PrimitiveCommonProps, PrimitivesContract, SelectOption, SelectProps, TextInputProps, ToastIntent, ToastProps, ToggleProps, } from "./contracts/index.js";
+export type { BatchResult, Command, Dispatcher, DispatcherError, DispatcherStatus, FieldIssue, PendingFile, PendingWrite, QueryOpts, QueryResult, StreamOpts, WriteOpts, WriteResult, } from "./dispatcher/index.js";
+export { StreamFrame, type StreamFrameEvent } from "./dispatcher/index.js";
+export type { FieldConditionPredicate, FieldConditions, FieldConditionValue, FieldState, FormController, FormControllerOptions, FormSnapshot, FormValues, SubmitConfig, SubmitPayloadMode, SubmitResult, } from "./form/index.js";
+export { createFormController, I18N_KEY_PARAM } from "./form/index.js";
+export { applyFormatSpec, currencyDecimals, escapeHtml, escapeHtmlAttr, escapeXml, type HtmlValue, html, isSafeHref, RawHtml, raw, stripControlChars, toInstant, } from "./format/index.js";
+export type { NavDefinition, NavNode, NavRegistrySlice, NavTree, ResolveNavigationOptions, } from "./nav/index.js";
+export { resolveNavigation } from "./nav/index.js";
+export type { Store, WritableStore } from "./store/index.js";
+export { createStore, shallowEqual } from "./store/index.js";
+export type { ComputeEditViewModelInput, ComputeListViewModelInput, DerivedCellRoundingTarget, EditExtensionSectionViewModel, EditFieldSpec, EditFieldsSectionViewModel, EditFieldViewModel, EditRelatedListSectionViewModel, EditSectionSpec, EditSectionViewModel, EditViewModel, EditWriteFormSectionViewModel, EmbeddedDerivedOp, EmbeddedListCellViewModel, EmbeddedListIssueGroups, FieldConditionCtx, FieldRenderer, ListColumnSpec, ListColumnViewModel, ListRowViewModel, ListViewModel, RuntimeRenderer, ScreenSlots, Translate, } from "./view-model/index.js";
+export { computeDerivedCellValue, computeEditViewModel, computeListViewModel, embeddedCellLabelKey, embeddedCellOptionLabelKey, fieldLabelKey, fieldOptionLabelKey, fieldOptionLabelKeyPrefix, groupEmbeddedListIssues, roundDerivedCellValue, sumEmbeddedListColumn, } from "./view-model/index.js";

package/dist/index.js

@@ -0,0 +1,9 @@
+// Re-Export aus framework/ui-types damit Renderer-Code denselben
+// Parser nutzt wie der Server-Boot-Validator (Cross-Feature-Refs).
+export { parseRefTarget } from "@cosmicdrift/kumiko-framework/ui-types";
+export { StreamFrame } from "./dispatcher/index.js";
+export { createFormController, I18N_KEY_PARAM } from "./form/index.js";
+export { applyFormatSpec, currencyDecimals, escapeHtml, escapeHtmlAttr, escapeXml, html, isSafeHref, RawHtml, raw, stripControlChars, toInstant, } from "./format/index.js";
+export { resolveNavigation } from "./nav/index.js";
+export { createStore, shallowEqual } from "./store/index.js";
+export { computeDerivedCellValue, computeEditViewModel, computeListViewModel, embeddedCellLabelKey, embeddedCellOptionLabelKey, fieldLabelKey, fieldOptionLabelKey, fieldOptionLabelKeyPrefix, groupEmbeddedListIssues, roundDerivedCellValue, sumEmbeddedListColumn, } from "./view-model/index.js";

package/dist/locale-routing/index.d.ts

@@ -0,0 +1,39 @@
+import type { LocaleResolver } from "../contracts/index.js";
+export type LocaleRouterConfig<TPage extends string> = {
+    /** Canonical default, usually "de". No URL prefix. */
+    readonly defaultLocale: string;
+    /** Locales that get a URL prefix, e.g. ["en"] → /en/... */
+    readonly prefixedLocales: readonly string[];
+    /** Prefix segment per locale, default: locale code ("en" → "/en"). */
+    readonly prefixFor?: (locale: string) => string;
+    /** Logical page → path per locale. Every page must define defaultLocale path. */
+    readonly routes: Record<TPage, Record<string, string>>;
+    /** Legacy slug-only paths for detectLang/resolvePage, e.g. { en: ["/features"] }. */
+    readonly localeHints?: Readonly<Record<string, readonly string[]>>;
+    /** Fallback page when altLocalePath cannot resolve pathname. Default: "home". */
+    readonly homePage?: TPage;
+};
+export type LocaleRouter<TPage extends string> = {
+    detectLang(pathname: string): string;
+    publicPath(page: TPage, locale: string): string;
+    resolvePage(pathname: string): TPage | undefined;
+    altLocalePath(pathname: string, targetLocale?: string): string;
+    sectionAnchor(page: TPage, locale: string, fragment: string): string;
+};
+export declare function createLocaleRouter<TPage extends string>(config: LocaleRouterConfig<TPage>): LocaleRouter<TPage>;
+export type WrapUrlLocaleResolverOptions = {
+    resolvePage: (pathname: string) => string | undefined;
+    detectLang: (pathname: string) => string;
+    pathname?: () => string | undefined;
+    /** Optional pathname-change subscription (browser default: popstate). */
+    subscribePathname?: (listener: () => void) => () => void;
+    /** When set, translate against the URL-resolved locale instead of base.translate
+     *  (needed for fixed-T / cloneInstance resolvers that are not locale-live). */
+    translateFor?: (locale: string, key: string, params?: Readonly<Record<string, unknown>>) => string;
+};
+/**
+ * Prefer URL-derived locale when `resolvePage` matches the current path;
+ * otherwise defer to `base.locale()`. Passes through setLocale and the rest of LocaleResolver.
+ * Without `translateFor`, `base.translate` must already be locale-live.
+ */
+export declare function wrapUrlLocaleResolver(base: LocaleResolver, options: WrapUrlLocaleResolverOptions): LocaleResolver;