@cosmicdrift/kumiko-renderer 0.373.0 → 0.377.0

package/dist/headless/form/form-controller.js

@@ -0,0 +1,409 @@
+import { createStore } from "../store/index.js";
+import { groupIssuesByPath, relevantFieldIssues, zodErrorToFieldIssues } from "./zod-bridge.js";
+// Paths without the prefix (hook-level errors, "(root)") pass through unchanged.
+function stripServerFieldPathPrefix(issues, prefix) {
+    return issues.map((issue) => issue.path.startsWith(prefix) ? { ...issue, path: issue.path.slice(prefix.length) } : issue);
+}
+// Resolve one condition-value (boolean | predicate) against current values + ctx.
+// `undefined` means "condition not declared"; the caller substitutes the
+// field-default (visible:true, readonly:false, required:false).
+function evalCondition(condition, fallback, values, ctx) {
+    if (condition === undefined)
+        return fallback;
+    if (typeof condition === "boolean")
+        return condition;
+    return condition(values, ctx);
+}
+function computeFieldStates(rules, values, ctx) {
+    if (!rules)
+        return {};
+    const out = {};
+    for (const [fieldKey, rule] of Object.entries(rules)) {
+        out[fieldKey] = {
+            visible: evalCondition(rule.visible, true, values, ctx),
+            readonly: evalCondition(rule.readonly, false, values, ctx),
+            required: evalCondition(rule.required, false, values, ctx),
+        };
+    }
+    return out;
+}
+// Reference equality only. For primitive-valued fields this is exact; for
+// object/array fields it treats "same reference" as "unchanged" — callers
+// who mutate in place instead of swapping references (which is bad form
+// anyway, but common in ad-hoc tests) would miss a change. Kumiko's
+// form-controller contract is that mutators build new references.
+// Object.is is chosen over === so NaN !== NaN doesn't mark a field dirty
+// after you re-type the same number back in.
+function valuesDiff(current, initial) {
+    const out = {};
+    // Iterate over BOTH sides — a field that existed on initial but was
+    // deleted from current (via `setValues({ foo: undefined })`) still
+    // counts as a change.
+    // FormValues<T> does not allow keyof-T iteration (T is generic). Cast
+    // to Record<string, unknown> for dynamic-key inspection.
+    const cur = current; // @cast-boundary form-values
+    const ini = initial; // @cast-boundary form-values
+    const o = out; // @cast-boundary form-values
+    const keys = new Set([...Object.keys(cur), ...Object.keys(ini)]);
+    for (const key of keys) {
+        const a = cur[key];
+        const b = ini[key];
+        if (!Object.is(a, b)) {
+            o[key] = a;
+        }
+    }
+    return out;
+}
+// buildInitialValues seeds untouched optional fields with "" for controlled
+// inputs; a `.optional()` server schema accepts undefined but not "".
+// String-only: number/money seed to 0 and boolean seeds to false, and an
+// untouched optional field of those types still submits that seed instead
+// of being omitted — no validation error surfaces it, unlike the "" case.
+// Fixing that needs real per-field seed-tracking (which value was actually
+// user-set vs. defaulted), not just a wider strip predicate here.
+function stripUntouchedEmptyStrings(values, initial, forceIncludeEmpty) {
+    const v = values; // @cast-boundary form-values
+    const ini = initial; // @cast-boundary form-values
+    let out;
+    for (const key of Object.keys(v)) {
+        // Value-based seed strip, except keys previously submitted as "" after a
+        // real clear — those must survive post-rebase submits (#1858).
+        if (!forceIncludeEmpty.has(key) && v[key] === "" && ini[key] === "") {
+            out ??= { ...v };
+            delete out[key];
+        }
+    }
+    return (out ?? v);
+}
+// Shallow-freeze so accidental mutations on the snapshot (e.g. a test
+// writing `snapshot.values.title = "x"`) throw in strict mode instead of
+// silently diverging from the controller's internal state. Deep-freeze
+// would be safer but expensive — keeping it shallow matches React's own
+// immutability expectations and leaves room for sub-controllers to manage
+// their own sub-trees without double-frozen parents blocking them.
+function freezeSnapshot(snapshot) {
+    return Object.freeze(snapshot);
+}
+function omitPayloadFields(payload, omitFields) {
+    if (!omitFields || omitFields.length === 0)
+        return payload;
+    if (typeof payload !== "object" || payload === null || Array.isArray(payload))
+        return payload;
+    return Object.fromEntries(Object.entries(payload).filter(([key]) => !omitFields.includes(key)));
+}
+export function createFormController(options) {
+    // Shallow copy so mutating the input after creation doesn't bleed into
+    // the controller's internal state. `initial` stays fixed across the
+    // controller's lifetime unless rebase() replaces it.
+    let values = { ...options.initial };
+    let initial = { ...options.initial };
+    let errors = Object.freeze({});
+    // Keys last submitted as "" (intentional clear). Survives rebase so a later
+    // submit of other fields does not drop them (#1858).
+    const forceIncludeEmpty = new Set();
+    // ctx is cast-held as TCtx; `undefined` is valid when callers don't
+    // declare conditional predicates that depend on it.
+    let ctx = options.ctx ?? undefined;
+    // Snapshot lives in a Store — same reference across getSnapshot() calls
+    // until a mutator invalidates it via setState. React's useSyncExternalStore
+    // compares snapshot identity to decide on a re-render; the Store holds the
+    // identity stable until invalidate() swaps it for a fresh build.
+    const snapshotStore = createStore(buildSnapshot());
+    // In-flight submit tracker. When a submit() is pending, a second call
+    // awaits the same promise instead of firing a parallel write — avoids
+    // double-submission on double-click and keeps the rebase semantics
+    // coherent (rebasing twice in quick succession would mis-align the
+    // baseline with what the server actually saw).
+    let submitInFlight = null;
+    function buildSnapshot() {
+        const changes = valuesDiff(values, initial);
+        const isDirty = Object.keys(changes).length > 0;
+        const fields = Object.freeze(computeFieldStates(options.fields, values, ctx));
+        return freezeSnapshot({
+            values,
+            initial,
+            changes,
+            isDirty,
+            isUnchanged: !isDirty,
+            errors,
+            fields,
+        });
+    }
+    function invalidate() {
+        snapshotStore.setState(buildSnapshot());
+    }
+    // Local shared implementations so submit() can call validate/rebase
+    // without the this-in-object-literal dance. Both also expose themselves
+    // as methods on the returned controller.
+    // Clears/replaces errors for a scoped run without touching fields outside
+    // the scope — a step-2 validate() that comes back clean must not wipe
+    // step-1's still-unresolved errors from an earlier submit() (or vice
+    // versa when step-2 newly has issues).
+    function replaceScopedErrors(isInScope, grouped) {
+        if (isInScope === undefined) {
+            errors = Object.freeze(grouped);
+            // skip: unscoped replace — wholesale overwrite, nothing left to merge
+            return;
+        }
+        const merged = {};
+        for (const [path, issues] of Object.entries(errors)) {
+            if (!isInScope(path))
+                merged[path] = issues;
+        }
+        Object.assign(merged, grouped);
+        errors = Object.freeze(merged);
+    }
+    function runValidate(scope, opts) {
+        // See the validate() doc comment in types.ts for the scope contract.
+        // A scope entry matches its exact path and everything below it, but not
+        // siblings: `address.city` must not pull in `address.zip` (#1898).
+        const isInScope = scope === undefined
+            ? undefined
+            : (path) => scope.some((entry) => path === entry || path.startsWith(`${entry}.`));
+        const includeRoot = opts?.includeRoot === true;
+        if (!options.schema) {
+            if (Object.keys(errors).length > 0) {
+                replaceScopedErrors(isInScope, {});
+                invalidate();
+            }
+            return true;
+        }
+        const fieldStates = computeFieldStates(options.fields, values, ctx);
+        const parsed = options.schema.safeParse(values);
+        if (parsed.success) {
+            if (Object.keys(errors).length > 0) {
+                replaceScopedErrors(isInScope, {});
+                invalidate();
+            }
+            return true;
+        }
+        const hiddenFields = new Set();
+        for (const [fieldKey, state] of Object.entries(fieldStates)) {
+            if (!state.visible)
+                hiddenFields.add(fieldKey);
+        }
+        // Root-level .refine() issues use path "(root)". Wizard step validate()
+        // still drops them (#1885); submit() passes includeRoot so RenderEdit
+        // fields={…} cannot silently skip cross-field rules (#1907).
+        const relevantIssues = relevantFieldIssues(zodErrorToFieldIssues(parsed.error), {
+            hiddenFields,
+            ...(scope !== undefined && { scope }),
+            includeRoot,
+        });
+        if (relevantIssues.length === 0) {
+            if (Object.keys(errors).length > 0) {
+                replaceScopedErrors(isInScope, {});
+                invalidate();
+            }
+            return true;
+        }
+        replaceScopedErrors(isInScope, groupIssuesByPath(relevantIssues));
+        invalidate();
+        return false;
+    }
+    function runRebase() {
+        initial = { ...values };
+        if (Object.keys(errors).length > 0)
+            errors = Object.freeze({});
+        invalidate();
+    }
+    // Stale-submit-safe rebase. Difference to runRebase: the baseline is
+    // taken from the values that were actually SENT to the server, not
+    // from `values` at the moment the server replied. If the user typed
+    // into a field while the submit was in flight, those edits stay as
+    // dirty changes after the call — they never made it to the server, so
+    // pretending they did (via `initial = { ...values }`) would mask unsaved
+    // input. The race shows up as "user edits a field during a 2s save, sees
+    // it as saved, closes the tab — the edit is lost". This path keeps
+    // `values` untouched; only `initial` shifts to the submitted snapshot.
+    function runRebaseToSnapshot(snapped) {
+        initial = { ...snapped };
+        if (Object.keys(errors).length > 0)
+            errors = Object.freeze({});
+        invalidate();
+    }
+    return {
+        getSnapshot: snapshotStore.getSnapshot,
+        subscribe: snapshotStore.subscribe,
+        setField(key, value) {
+            // skip: value unchanged, avoid notify/re-render on identical set
+            // avoids a notify + re-render for "setField with same value" which
+            // happens a lot in controlled inputs on every keystroke of an
+            // untouched field.
+            if (Object.is(values[key], value))
+                return;
+            values = { ...values, [key]: value };
+            invalidate();
+        },
+        setValues(partial) {
+            // skip: partial matches current values, avoid no-op notify
+            // partial that matches current values shouldn't fire listeners.
+            let changed = false;
+            const v = values; // @cast-boundary form-values
+            const p = partial; // @cast-boundary form-values
+            for (const k of Object.keys(p)) {
+                if (!Object.is(v[k], p[k])) {
+                    changed = true;
+                    break;
+                }
+            }
+            // skip: no key in partial actually changed, avoid no-op notify
+            if (!changed)
+                return;
+            values = { ...values, ...partial };
+            invalidate();
+        },
+        clearErrors(path) {
+            if (path === undefined) {
+                // skip: no errors present, avoid no-op notify
+                if (Object.keys(errors).length === 0)
+                    return;
+                errors = Object.freeze({});
+            }
+            else {
+                // skip: path has no error entry, avoid no-op notify
+                if (!(path in errors))
+                    return;
+                const next = { ...errors };
+                delete next[path];
+                errors = Object.freeze(next);
+            }
+            invalidate();
+        },
+        setErrors(nextErrors) {
+            errors = Object.freeze({ ...nextErrors });
+            invalidate();
+        },
+        validate: runValidate,
+        reset() {
+            const alreadyClean = !snapshotStore.getSnapshot().isDirty && Object.keys(errors).length === 0;
+            // skip: already at baseline with no errors, no-op reset
+            if (alreadyClean)
+                return;
+            values = { ...initial };
+            errors = Object.freeze({});
+            forceIncludeEmpty.clear();
+            invalidate();
+        },
+        rebase: runRebase,
+        setCtx(nextCtx) {
+            // Cast back to TCtx: setCtx's public signature takes unknown so
+            // callers don't need to plumb generics. If conditions depend on ctx
+            // and callers pass the wrong shape, the predicate throws at
+            // evaluation time — which is the same fail mode as any other
+            // callback contract violation.
+            ctx = nextCtx;
+            invalidate();
+        },
+        async submit() {
+            const submitCfg = options.submit;
+            if (!submitCfg) {
+                throw new Error("createFormController: submit() called without a `submit` config. Configure `{ dispatcher, type }` on the controller or drive dispatching manually.");
+            }
+            // Concurrent-submit guard: a double-click (two invocations before
+            // the first network call returned) would otherwise fire two writes
+            // AND rebase twice — compounding with the stale-submit race below.
+            // Serialize: subsequent calls await the in-flight promise. Same
+            // pattern the server-side event-dispatcher uses (inFlightTurns).
+            if (submitInFlight)
+                return submitInFlight;
+            if (!runValidate(submitCfg.validateScope, { includeRoot: true })) {
+                return { validationBlocked: true, isSuccess: false };
+            }
+            const payloadMode = submitCfg.payloadMode ?? "values";
+            // Capture the whole snapshot AT submit-time. The user may keep
+            // typing while the network call is in flight; on success we rebase
+            // ONLY to the values that were actually sent, leaving any
+            // subsequent edits as a fresh dirty delta. Without this, an edit
+            // during the await would be swallowed into the new baseline and
+            // the user would see it as "saved" despite the server never seeing
+            // it. Same snapshot is fed to buildPayload — a custom transformer
+            // (nested-write case) sees exactly what submit() sees.
+            const submittedSnapshot = snapshotStore.getSnapshot();
+            const submittedValues = submittedSnapshot.values;
+            // buildPayload wins over payloadMode when both are set.
+            let payload;
+            if (submitCfg.buildPayload) {
+                payload = submitCfg.buildPayload(submittedSnapshot);
+            }
+            else if (payloadMode === "changes") {
+                if (submittedSnapshot.isUnchanged) {
+                    return {
+                        validationBlocked: false,
+                        isSuccess: true,
+                        isNoOp: true,
+                        data: submittedValues,
+                    };
+                }
+                payload = submittedSnapshot.changes;
+            }
+            else if (submitCfg.stripEmptySeeds === false) {
+                payload = submittedValues;
+            }
+            else {
+                payload = stripUntouchedEmptyStrings(submittedValues, submittedSnapshot.initial, forceIncludeEmpty);
+            }
+            payload = omitPayloadFields(payload, submitCfg.omitFields);
+            // Only enforced here, right before the write actually happens — a
+            // form that never reaches this point (blocked by validation, or a
+            // clean payloadMode "changes" no-op) must not throw just because no
+            // dispatcher was ever wired up.
+            const dispatcher = submitCfg.dispatcher;
+            if (!dispatcher) {
+                // Return SubmitResult (not throw) so RenderEdit's banner path shows
+                // the misconfiguration instead of an unhandled rejection on save.
+                return {
+                    validationBlocked: false,
+                    isSuccess: false,
+                    isNoOp: false,
+                    error: {
+                        code: "misconfigured",
+                        httpStatus: 500,
+                        i18nKey: "errors.internal",
+                        message: "createFormController: submit() called without a dispatcher (dispatcher was absent when the form mounted). Pass `submit.dispatcher` explicitly, or mount a <DispatcherProvider> above this form.",
+                    },
+                };
+            }
+            const runWrite = async () => {
+                const result = await dispatcher.write(submitCfg.type, payload);
+                if (result.isSuccess) {
+                    // Remember intentional empty clears so post-rebase submits keep them (#1858).
+                    if (payload && typeof payload === "object" && !Array.isArray(payload)) {
+                        for (const [k, v] of Object.entries(payload)) {
+                            if (v === "")
+                                forceIncludeEmpty.add(k);
+                            else
+                                forceIncludeEmpty.delete(k);
+                        }
+                    }
+                    // Rebase to the SNAPSHOT, not to the current values — see
+                    // runRebaseToSnapshot comment for why.
+                    runRebaseToSnapshot(submittedValues);
+                    return { validationBlocked: false, isSuccess: true, isNoOp: false, data: result.data };
+                }
+                const serverFields = result.error.details?.fields;
+                if (serverFields && serverFields.length > 0) {
+                    const prefix = submitCfg.serverFieldPathPrefix;
+                    const mappedFields = prefix
+                        ? stripServerFieldPathPrefix(serverFields, prefix)
+                        : serverFields;
+                    errors = Object.freeze(groupIssuesByPath(mappedFields));
+                    invalidate();
+                    const error = prefix
+                        ? { ...result.error, details: { ...result.error.details, fields: mappedFields } }
+                        : result.error;
+                    return { validationBlocked: false, isSuccess: false, isNoOp: false, error };
+                }
+                return { validationBlocked: false, isSuccess: false, isNoOp: false, error: result.error };
+            };
+            const writeInFlight = runWrite();
+            submitInFlight = writeInFlight;
+            try {
+                return await writeInFlight;
+            }
+            finally {
+                submitInFlight = null;
+            }
+        },
+    };
+}

package/dist/headless/form/index.d.ts

@@ -0,0 +1,3 @@
+export { createFormController } from "./form-controller.ts";
+export type { FieldConditionPredicate, FieldConditions, FieldConditionValue, FieldState, FormController, FormControllerOptions, FormSnapshot, FormValues, SubmitConfig, SubmitPayloadMode, SubmitResult, } from "./types.ts";
+export { groupIssuesByPath, I18N_KEY_PARAM, relevantFieldIssues, zodErrorToFieldIssues, } from "./zod-bridge.ts";

package/dist/headless/form/index.js

@@ -0,0 +1,2 @@
+export { createFormController } from "./form-controller.js";
+export { groupIssuesByPath, I18N_KEY_PARAM, relevantFieldIssues, zodErrorToFieldIssues, } from "./zod-bridge.js";

package/dist/headless/form/types.d.ts

@@ -0,0 +1,76 @@
+import type { ZodType } from "zod";
+import type { Dispatcher, FieldIssue, WriteResult } from "../dispatcher/index.ts";
+export type FormValues = Record<string, unknown>;
+export type FormScopeKey<TValues extends FormValues> = (keyof TValues & string) | `${keyof TValues & string}.${string}`;
+export type FieldConditionPredicate<TValues extends FormValues, TCtx> = (values: TValues, ctx: TCtx) => boolean;
+export type FieldConditionValue<TValues extends FormValues, TCtx> = boolean | FieldConditionPredicate<TValues, TCtx>;
+export type FieldConditions<TValues extends FormValues, TCtx = unknown> = {
+    readonly visible?: FieldConditionValue<TValues, TCtx>;
+    readonly readonly?: FieldConditionValue<TValues, TCtx>;
+    readonly required?: FieldConditionValue<TValues, TCtx>;
+};
+export type FieldState = {
+    readonly visible: boolean;
+    readonly readonly: boolean;
+    readonly required: boolean;
+};
+export type FormSnapshot<TValues extends FormValues> = {
+    readonly values: TValues;
+    readonly initial: TValues;
+    readonly changes: Partial<TValues>;
+    readonly isDirty: boolean;
+    readonly isUnchanged: boolean;
+    readonly errors: Readonly<Record<string, readonly FieldIssue[]>>;
+    readonly fields: Readonly<Record<string, FieldState>>;
+};
+export type FormController<TValues extends FormValues> = {
+    getSnapshot(): FormSnapshot<TValues>;
+    subscribe(listener: () => void): () => void;
+    setField<K extends keyof TValues>(key: K, value: TValues[K]): void;
+    setValues(partial: Partial<TValues>): void;
+    clearErrors(path?: string): void;
+    setErrors(errors: Readonly<Record<string, readonly FieldIssue[]>>): void;
+    validate(scope?: readonly FormScopeKey<TValues>[]): boolean;
+    reset(): void;
+    rebase(): void;
+    setCtx(ctx: unknown): void;
+    submit<TData = unknown>(): Promise<SubmitResult<TData>>;
+};
+export type FormControllerOptions<TValues extends FormValues, TCtx = unknown> = {
+    readonly initial: TValues;
+    readonly schema?: ZodType;
+    readonly fields?: Readonly<Record<string, FieldConditions<TValues, TCtx>>>;
+    readonly ctx?: TCtx;
+    readonly submit?: SubmitConfig<TValues>;
+};
+export type SubmitPayloadMode = "values" | "changes";
+export type SubmitConfig<TValues extends FormValues = FormValues> = {
+    readonly dispatcher?: Dispatcher;
+    readonly type: string;
+    readonly payloadMode?: SubmitPayloadMode;
+    /** Only applies to payloadMode "values". Controls whether untouched
+     *  empty-string fields (still equal to their initial "" seed) are
+     *  stripped from the payload before dispatch — see SubmitPayloadMode's
+     *  "values" doc for why the stripping exists. Default `true` (current
+     *  behavior). Set `false` to send those fields as `""` unchanged. */
+    readonly stripEmptySeeds?: boolean;
+    /** Top-level payload keys removed right before dispatch, for fields that
+     *  are shown or validated but must not reach the write handler. Applied
+     *  to the built payload only when it is a plain object. */
+    readonly omitFields?: readonly string[];
+    readonly buildPayload?: (snapshot: FormSnapshot<TValues>) => unknown;
+    readonly serverFieldPathPrefix?: string;
+    /** Restricts submit()'s internal validate() call to these field names —
+     *  same contract as validate()'s `scope` param. Set by RenderEdit when the
+     *  caller's `fields` prop narrows which fields are rendered, so an
+     *  unrendered required field can't block a submit the user can't fix.
+     *  Omitted = unscoped (existing behavior, validates everything). */
+    readonly validateScope?: readonly string[];
+};
+export type SubmitResult<TData = unknown> = ({
+    readonly validationBlocked: false;
+    readonly isNoOp?: boolean;
+} & WriteResult<TData>) | {
+    readonly validationBlocked: true;
+    readonly isSuccess: false;
+};

package/dist/headless/form/types.js

@@ -0,0 +1 @@
+export {};

package/dist/headless/form/zod-bridge.d.ts

@@ -0,0 +1,10 @@
+import type { ZodError } from "zod";
+import type { FieldIssue } from "../dispatcher/index.ts";
+export declare function zodErrorToFieldIssues(error: ZodError): FieldIssue[];
+export declare function relevantFieldIssues(issues: readonly FieldIssue[], opts: {
+    readonly hiddenFields: ReadonlySet<string>;
+    readonly scope?: readonly string[];
+    readonly includeRoot?: boolean;
+}): FieldIssue[];
+export declare const I18N_KEY_PARAM = "i18nKey";
+export declare function groupIssuesByPath(issues: readonly FieldIssue[]): Record<string, readonly FieldIssue[]>;

package/dist/headless/form/zod-bridge.js

@@ -0,0 +1,103 @@
+// 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
+// identically to the same field failing zod on the server, so the UI's
+// error-display path doesn't branch on provenance.
+//
+// Duplicated here (not imported) so ui-core remains free of
+// @cosmicdrift/kumiko-framework — this package has to bundle for browsers and Expo,
+// where a server-oriented framework dep would balloon bundle size and drag
+// in Node-only modules (postgres, drizzle, bullmq) even if only types are
+// consumed.
+//
+// Keep this list in sync with the server-side mirror — Zod version bumps
+// 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",
+];
+// 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) {
+    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 }),
+        };
+    });
+}
+// The issues that count for validity: hidden fields never block, and a
+// scope narrows to the listed paths (an entry matches itself and everything
+// below it, not siblings — #1898). `includeRoot` keeps "(root)" refine issues
+// inside a scope (submit passes it, #1907). Shared by the controller's
+// validate() and RenderEdit's `valid` dry-run so the two cannot drift.
+export function relevantFieldIssues(issues, opts) {
+    const { hiddenFields, scope, includeRoot } = opts;
+    return issues.filter((issue) => {
+        const rootField = issue.path.split(".")[0] ?? "";
+        if (hiddenFields.has(rootField))
+            return false;
+        if (scope === undefined)
+            return true;
+        if (includeRoot === true && issue.path === "(root)")
+            return true;
+        return scope.some((entry) => issue.path === entry || issue.path.startsWith(`${entry}.`));
+    });
+}
+// 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) {
+    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) {
+    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) {
+    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/headless/format/document-values.d.ts

@@ -0,0 +1,12 @@
+export declare const DOCUMENT_FALLBACK_CURRENCY = "EUR";
+export declare function formatDocumentMoney(value: unknown, tenantCurrency: string, locale: string): string;
+export type DocumentDateOptions = {
+    /** Append the time of day. Only instants and offset date-times carry one; a
+     *  date-only value prints just the date. */
+    readonly time?: boolean;
+    /** IANA zone an instant is shown in (default UTC). Offset date-times keep
+     *  their own wall clock. */
+    readonly timeZone?: string;
+};
+export declare function formatDocumentDate(value: unknown, locale: string, options?: DocumentDateOptions): string;
+export declare function formatDocumentPercent(value: unknown, locale: string): string;