@temelyos/zod 0.0.0-stage → 1.0.0

package/dist/index.js

@@ -0,0 +1,993 @@
+import { ZodArray, ZodCatch, ZodDefault, ZodLazy, ZodLiteral, ZodNonOptional, ZodNullable, ZodOptional, ZodPrefault, ZodReadonly, z } from "zod";
+import { getLogger } from "@temelyos/core/logging/store";
+import { isValidFormat } from "@temelyos/core/format";
+import { getOrSet } from "@temelyos/core/cache";
+import { isMidnight } from "@temelyos/core/date";
+import { isLooseJson } from "@temelyos/core/json";
+import { isObject, isPlainObject, mapValues } from "@temelyos/core/object";
+import { isLanguageCode } from "@temelyos/core/i18n";
+import { isInteger } from "@temelyos/core/number";
+import { isValidPattern } from "@temelyos/core/reg-exp";
+import { SlugPattern } from "@temelyos/core/string";
+import { isSupportedTimezone } from "@temelyos/core/time-zone";
+// src/bounded-number.ts
+/** A number, optionally whole and bounded; a refusal names its bounds as the message's `{0}` and `{1}`. */
+function boundedNumber({ integer = false, max, min }) {
+	return z.number({ error: "Enter a number." }).superRefine((value, ctx) => {
+		if (integer && !Number.isInteger(value)) ctx.addIssue({
+			code: "custom",
+			message: "Enter a whole number."
+		});
+		else if (min !== void 0 && max !== void 0) {
+			if (value < min || value > max) ctx.addIssue({
+				code: "custom",
+				message: "Enter a number from {0} to {1}.",
+				params: {
+					0: min,
+					1: max
+				}
+			});
+		} else if (min !== void 0) {
+			if (value < min) ctx.addIssue({
+				code: "custom",
+				message: "Enter a number of {0} or more.",
+				params: { 0: min }
+			});
+		} else if (max !== void 0 && value > max) ctx.addIssue({
+			code: "custom",
+			message: "Enter a number of {0} or less.",
+			params: { 0: max }
+		});
+	}).meta({
+		...integer && { type: "integer" },
+		...max !== void 0 && { maximum: max },
+		...min !== void 0 && { minimum: min }
+	});
+}
+// src/codec-parts.ts
+/**
+* The schemas a codec built at run time encodes and decodes by, kept in a Zod registry beside it.
+* Typed `unknown[]`: the registry maps schema-typed metadata through `$replace`, which recurses
+* without end on `ZodType`.
+*/
+const codecPartsRegistry = z.registry();
+/** The schemas {@link withCodecParts} named for a codec; undefined for any other schema. */
+function codecParts(schema) {
+	return codecPartsRegistry.get(schema)?.parts;
+}
+/**
+* A codec that builds its schemas at run time (from a model's fields, or a result's columns),
+* with those schemas named, so a reader can check what it encodes and decodes its values by.
+*/
+function withCodecParts(codec, schemas) {
+	codecPartsRegistry.add(codec, { parts: schemas });
+	return codec;
+}
+// src/currency-code.ts
+/** A lower-case ISO 4217 code: `usd`, never `USD` or `$`. */
+const CurrencyCodePattern = /^[a-z]{3}$/;
+/** What a value that is not a currency code says, unless the caller says otherwise. An `error` property so the i18n extractor keeps the key. */
+const invalidCurrency = { error: "Invalid currency code." };
+/** A field that takes a lower-case ISO 4217 code. `missing` is the caller's, for a field nobody filled in. */
+function currencyCode(missing, invalid = invalidCurrency.error) {
+	return z.string().min(1, missing).regex(CurrencyCodePattern, invalid);
+}
+// src/utilities.ts
+const ZOD_WRAPPER_TYPES = [
+	"catch",
+	"default",
+	"lazy",
+	"nonoptional",
+	"nullable",
+	"optional",
+	"promise",
+	"success"
+];
+function getInnerType(schema) {
+	if (schema instanceof ZodOptional || schema instanceof ZodNullable || schema instanceof ZodDefault || schema instanceof ZodCatch) return getInnerType(schema.def.innerType);
+	if (schema instanceof ZodLazy) return getInnerType(schema.def.getter());
+	if (schema instanceof ZodArray) return getInnerType(schema.def.element);
+	return schema;
+}
+function isFieldNullable(schema) {
+	let current = schema;
+	while (isZodOptional(current) || isZodNullable(current)) {
+		if (isZodNullable(current)) return true;
+		current = current.def.innerType;
+	}
+	return false;
+}
+/**
+* Whether `schema` is declared `.optional()`, looking only through `.optional()` and `.nullable()`: what a form or a
+* write may leave empty. For whether a parsed value may lack the field, through any wrapper, use {@link isOptionalOutput}.
+*/
+function isFieldOptional(schema) {
+	let current = schema;
+	while (isZodOptional(current) || isZodNullable(current)) {
+		if (isZodOptional(current)) return true;
+		current = current.def.innerType;
+	}
+	return false;
+}
+/**
+* Whether a value typed by what `schema` outputs may lack the field: optional through any wrapper (lazy, readonly, a
+* union with an optional member), as zod decides it, not filled by a default; and `any` or `unknown`, whose type takes
+* `undefined` already. What a read typed by the schema may lack; for a field declared `.optional()`, {@link isFieldOptional}.
+*/
+function isOptionalOutput(schema) {
+	return schema._zod.optout === "optional" || schema.def.type === "any" || schema.def.type === "unknown";
+}
+function isZodAny(obj) {
+	return isZodType(obj) && obj.def.type === "any";
+}
+function isZodArray(obj) {
+	return isZodType(obj) && obj.def.type === "array";
+}
+function isZodCatch(obj) {
+	return isZodType(obj) && obj.def.type === "catch";
+}
+/** A codec, as `z.codec` builds: a pipe that can also run backwards. Read it as its `out`, what it decodes to. */
+function isZodCodec(obj) {
+	return isZodPipe(obj) && "reverseTransform" in obj.def;
+}
+function isZodDate(obj) {
+	return isZodType(obj) && obj.def.type === "date";
+}
+function isZodDefault(obj) {
+	return isZodType(obj) && obj.def.type === "default";
+}
+function isZodEnum(obj) {
+	return isZodType(obj) && obj.def.type === "enum";
+}
+function isZodIntersection(obj) {
+	return isZodType(obj) && obj.def.type === "intersection";
+}
+function isZodLazy(obj) {
+	return isZodType(obj) && obj.def.type === "lazy";
+}
+function isZodNullable(obj) {
+	return isZodType(obj) && obj.def.type === "nullable";
+}
+function isZodNumber(obj) {
+	return isZodType(obj) && obj.def.type === "number";
+}
+function isZodObject(obj, isLoose) {
+	if (!isZodType(obj) || obj.def.type !== "object") return false;
+	if (typeof isLoose === "undefined") return true;
+	return isLoose === isZodObjectLoose(obj);
+}
+function isZodObjectLoose(obj) {
+	return !!isZodUnknown(obj.def.catchall);
+}
+function isZodOptional(obj) {
+	return isZodType(obj) && obj.def.type === "optional";
+}
+function isZodPipe(obj) {
+	return isZodType(obj) && obj.def.type === "pipe";
+}
+function isZodRecord(obj) {
+	return isZodType(obj) && obj.def.type === "record";
+}
+function isZodString(obj) {
+	return isZodType(obj) && obj.def.type === "string";
+}
+function isZodTransform(obj) {
+	return isZodType(obj) && obj.def.type === "transform";
+}
+function isZodType(obj) {
+	return typeof obj === "object" && obj !== null && "def" in obj && "safeParse" in obj && typeof obj.safeParse === "function";
+}
+function isZodUnion(obj) {
+	return isZodType(obj) && obj.def.type === "union";
+}
+function isZodUnknown(obj) {
+	return isZodType(obj) && obj.def.type === "unknown";
+}
+function isZodWrapper(obj) {
+	return isZodType(obj) && ZOD_WRAPPER_TYPES.includes(obj.def.type);
+}
+// src/field-paths.ts
+function collectFieldPaths(node, prefix, out, shouldSkipArrays, seen) {
+	if (seen.has(node)) return;
+	seen.add(node);
+	if (isZodObject(node)) {
+		const shape = node.shape;
+		for (const key of Object.keys(shape)) {
+			const declared = shape[key];
+			const child = unwrapField(declared, shouldSkipArrays);
+			const path = [...prefix, key];
+			out.push({
+				declared,
+				path: path.join("."),
+				schema: child
+			});
+			collectFieldPaths(child, path, out, shouldSkipArrays, seen);
+		}
+	} else if (isZodUnion(node)) for (const option of node.def.options) collectFieldPaths(unwrapField(option, shouldSkipArrays), prefix, out, shouldSkipArrays, seen);
+	seen.delete(node);
+}
+/**
+* Enumerates the dotted paths of every field reachable by descending `ZodObject`
+* shapes and the branches of `ZodUnion` / `ZodDiscriminatedUnion` (Zod v4 reports
+* both as `def.type === 'union'`). A field declared in more than one union branch
+* is reported once per branch — callers that need uniqueness should dedupe by
+* `path`.
+*
+* Wrapper types (optional/nullable/default/catch/nonoptional/prefault/readonly/lazy) are always unwrapped.
+* Arrays are descended via their element type by default (emitting non-indexed
+* paths like `items.token`, the way `getPathValues` fans out at runtime); pass
+* `{ skipArrays: true }` to stop at arrays instead. Records and other leaves are
+* never descended. Each field is reported with its unwrapped `schema`, which lets
+* callers read per-field metadata (e.g. `sensitive()` markers) without re-walking
+* wrappers, and as its object `declared` it, wrappers kept, which says whether it
+* may be absent (`isOptionalOutput`).
+*
+* The schema-space analogue of `getPathValues` (which extracts values at a path
+* from a runtime object).
+*/
+function getZodFieldPaths(schema, options = {}) {
+	const shouldSkipArrays = options.skipArrays ?? false;
+	const out = [];
+	collectFieldPaths(unwrapField(schema, shouldSkipArrays), [], out, shouldSkipArrays, /* @__PURE__ */ new Set());
+	return out;
+}
+/**
+* Unwraps optional/nullable/default/catch/nonoptional/prefault/readonly/lazy wrappers. Unlike `getInnerType`,
+* arrays are unwrapped to their element type only when `shouldSkipArrays` is
+* false; when true it stops at arrays, leaving them terminal.
+*
+* A wrapper chain that closes on itself (`const Self = z.lazy(() => Self.array())`
+* unwraps lazy → array → lazy → …) stops at the node that repeats — it has no
+* inner type left to reach. The guard has to live here: `collectFieldPaths`'s own
+* one is only consulted after unwrapping has already returned. `seen` is per
+* top-level call, so it never suppresses an unrelated sibling.
+*/
+function unwrapField(schema, shouldSkipArrays, seen = /* @__PURE__ */ new Set()) {
+	if (seen.has(schema)) return schema;
+	seen.add(schema);
+	if (schema instanceof ZodOptional || schema instanceof ZodNullable || schema instanceof ZodDefault || schema instanceof ZodCatch || schema instanceof ZodNonOptional || schema instanceof ZodPrefault || schema instanceof ZodReadonly) return unwrapField(schema.def.innerType, shouldSkipArrays, seen);
+	if (schema instanceof ZodLazy) return unwrapField(schema.def.getter(), shouldSkipArrays, seen);
+	if (!shouldSkipArrays && schema instanceof ZodArray) return unwrapField(schema.def.element, shouldSkipArrays, seen);
+	return schema;
+}
+// src/field-settings.ts
+const buildFieldSettingsSchema = (defaultType) => z.object({
+	default: defaultType.optional(),
+	isOptional: z.boolean().optional(),
+	isVisible: z.boolean().optional(),
+	label: z.string().optional()
+});
+const stringFieldSettingsSchema = buildFieldSettingsSchema(z.string()).extend({
+	maxLength: z.union([z.number(), z.object({
+		message: z.string(),
+		value: z.number()
+	})]).optional(),
+	minLength: z.union([z.number(), z.object({
+		message: z.string(),
+		value: z.number()
+	})]).optional(),
+	regExp: z.union([z.instanceof(RegExp), z.object({
+		message: z.string(),
+		value: z.instanceof(RegExp)
+	})]).optional()
+});
+const numberFieldSettingsSchema = buildFieldSettingsSchema(z.number()).extend({
+	max: z.union([z.number(), z.object({
+		message: z.string(),
+		value: z.number()
+	})]).optional(),
+	min: z.union([z.number(), z.object({
+		message: z.string(),
+		value: z.number()
+	})]).optional()
+});
+const fileFieldSettingsSchema = buildFieldSettingsSchema(z.instanceof(File)).extend({
+	maxBytes: z.union([z.number(), z.object({
+		message: z.string(),
+		value: z.number()
+	})]).optional(),
+	minBytes: z.union([z.number(), z.object({
+		message: z.string(),
+		value: z.number()
+	})]).optional()
+});
+const dropdownFieldSettingsSchema = buildFieldSettingsSchema(z.string()).extend({ values: z.union([z.array(z.string()), z.record(z.string(), z.union([z.string(), z.number()]))]).optional() });
+const AnyFieldSettingsSchema = z.union([
+	stringFieldSettingsSchema,
+	numberFieldSettingsSchema,
+	fileFieldSettingsSchema,
+	dropdownFieldSettingsSchema
+]);
+function applyFieldSettings(schema, fields) {
+	if (!fields) return schema;
+	const updatedShape = Object.assign({}, schema.shape);
+	for (const fieldName in fields) {
+		const fieldSettings = fields[fieldName];
+		if (!(fieldName in schema.shape)) continue;
+		const fieldSchema = schema.shape[fieldName];
+		if (fieldSettings.isVisible === false) {
+			delete updatedShape[fieldName];
+			continue;
+		}
+		const [oldField, wrappers] = getField(fieldSchema);
+		let newField = void 0;
+		if (isStringFieldSettings(fieldSettings)) {
+			if (!isZodString(oldField)) {
+				getLogger().warn(`Field ${fieldName} is not a string, but received StringFieldSettings.`);
+				continue;
+			}
+			newField = createStringField(oldField, fieldSettings);
+		}
+		if (isNumberFieldSettings(fieldSettings)) {
+			if (!isZodNumber(oldField)) {
+				getLogger().warn(`Field ${fieldName} is not a number, but received NumberFieldSettings.`);
+				continue;
+			}
+			newField = createNumberField(oldField, fieldSettings);
+		}
+		if (isDropdownFieldSettings(fieldSettings)) {
+			if (Array.isArray(fieldSettings.values)) {
+				if (!isZodEnum(oldField)) {
+					getLogger().warn(`Field ${fieldName} is not a enum, but received DropdownFieldSettings with an Array.`);
+					continue;
+				}
+			} else if (!isZodEnum(oldField)) {
+				getLogger().warn(`Field ${fieldName} is not a native enum, but received DropdownFieldSettings.`);
+				continue;
+			}
+			newField = createDropdownField(fieldSettings);
+		}
+		if (!newField) continue;
+		newField = applyWrappers(newField, wrappers, fieldSettings);
+		updatedShape[fieldName] = newField;
+	}
+	return z.object(updatedShape);
+}
+function applyWrappers(base, wrappers, settings = {}) {
+	let result = base;
+	let isOptionalApplied = false;
+	let isDefaultApplied = false;
+	for (let i = 0; i < wrappers.length; i++) {
+		const wrapper = wrappers[i];
+		if (isZodDefault(wrapper)) {
+			if (settings.default !== void 0) {
+				result = result.default(settings.default);
+				isDefaultApplied = true;
+			} else result = result.default(wrapper.def.defaultValue);
+		} else if (isZodOptional(wrapper) && settings.isOptional !== false) {
+			result = result.optional();
+			isOptionalApplied = true;
+		} else if (isZodNullable(wrapper)) result = result.nullable();
+		else if (isZodCatch(wrapper)) result = result.catch(wrapper.def.catchValue);
+		else if (isZodLazy(wrapper)) {
+			const inner = result;
+			result = z.lazy(() => inner);
+		} else if (isZodPipe(wrapper)) {
+			if (isZodTransform(wrapper.out)) result = result.transform(wrapper.out.def.transform);
+		}
+	}
+	if (settings.isOptional && !isOptionalApplied) result = result.optional();
+	if (settings.default !== void 0 && !isDefaultApplied) result = result.default(settings.default);
+	return result;
+}
+function createDropdownField(settings) {
+	if (Array.isArray(settings.values)) return z.enum(settings.values);
+	return z.enum(settings.values ?? {});
+}
+function createNumberField(oldField, settings) {
+	let field = z.number();
+	if (settings.min !== void 0) {
+		if (typeof settings.min === "number") {
+			const check = getZodCheck(oldField, "greater_than");
+			let params;
+			if (check?._zod.def.error) params = { error: check._zod.def.error };
+			field = field.min(settings.min, params);
+		} else field = field.min(settings.min.value, settings.min.message);
+	}
+	if (settings.max !== void 0) {
+		if (typeof settings.max === "number") {
+			const check = getZodCheck(oldField, "less_than");
+			let params;
+			if (check?._zod.def.error) params = { error: check._zod.def.error };
+			field = field.max(settings.max, params);
+		} else field = field.max(settings.max.value, settings.max.message);
+	}
+	const carriedChecks = (oldField.def.checks ?? []).filter((check) => {
+		const kind = check._zod.def.check;
+		if (kind === "greater_than") return settings.min === void 0;
+		if (kind === "less_than") return settings.max === void 0;
+		return true;
+	});
+	return carriedChecks.length ? field.check(...carriedChecks) : field;
+}
+function createStringField(oldField, settings) {
+	let field = z.string();
+	if (settings.minLength !== void 0) {
+		if (typeof settings.minLength === "number") {
+			const check = getZodCheck(oldField, "min_length");
+			let params;
+			if (check?._zod.def.error) params = { error: check._zod.def.error };
+			field = field.min(settings.minLength, params);
+		} else field = field.min(settings.minLength.value, settings.minLength.message);
+	}
+	if (settings.maxLength !== void 0) {
+		if (typeof settings.maxLength === "number") {
+			const mlCheck = getZodCheck(oldField, "max_length");
+			let params;
+			if (mlCheck?._zod.def.error) params = { error: mlCheck._zod.def.error };
+			field = field.max(settings.maxLength, params);
+		} else field = field.max(settings.maxLength.value, settings.maxLength.message);
+	}
+	if (settings.regExp !== void 0) {
+		if (settings.regExp instanceof RegExp) {
+			const regCheck = getZodCheck(oldField, "string_format", "regex");
+			let params;
+			if (regCheck?._zod.def.error) params = { error: regCheck._zod.def.error };
+			field = field.regex(settings.regExp, params);
+		} else field = field.regex(settings.regExp.value, settings.regExp.message);
+	}
+	const carriedChecks = (oldField.def.checks ?? []).filter((check) => {
+		const kind = check._zod.def.check;
+		if (kind === "min_length") return settings.minLength === void 0;
+		if (kind === "max_length") return settings.maxLength === void 0;
+		if (kind === "string_format" && check._zod.def.format === "regex") return settings.regExp === void 0;
+		return true;
+	});
+	return carriedChecks.length ? field.check(...carriedChecks) : field;
+}
+function getField(field) {
+	const wrappers = [];
+	let type = field;
+	while (isZodWrapper(type) || isZodPipe(type) && !isZodCodec(type)) {
+		if (isZodPipe(type)) {
+			wrappers.push(type);
+			type = type.in;
+			continue;
+		}
+		wrappers.push(type);
+		type = type.unwrap();
+	}
+	return [type, wrappers.reverse()];
+}
+function getZodCheck(field, check, format) {
+	return field.def.checks?.find((ck) => {
+		if (ck._zod.def.check !== check) return false;
+		if (check !== "string_format") return true;
+		return !format || format === ck._zod.def.format;
+	});
+}
+function isDropdownFieldSettings(settings) {
+	return "values" in settings && !!settings.values;
+}
+function isNumberFieldSettings(settings) {
+	return "min" in settings || "max" in settings;
+}
+function isStringFieldSettings(settings) {
+	return "minLength" in settings || "maxLength" in settings || "regExp" in settings;
+}
+// src/format-template.ts
+/** Text whose every `{token}` names one of `keys`, with no stray braces. */
+function formatTemplate(keys) {
+	return z.string().refine((value) => isValidFormat(value, keys), "Invalid template.");
+}
+// src/hex-string-24.ts
+/**
+* Twenty-four lower-case hex characters: the shape of every id on the wire and in a zod model.
+*
+* Named for the shape rather than for Mongo, because the shape is all a model can see — the
+* Mingo driver mints the same ids without Mongo anywhere near them. Lower case only, which is
+* what every driver here produces, so anything else is a value nothing in the platform minted.
+*/
+const HexString24Pattern = /^[a-f\d]{24}$/;
+/**
+* What a value that is not an id says, unless the caller says otherwise. Generic, because nothing a
+* person picks produces one: only a hand-built request does. An `error` property so the i18n
+* extractor keeps the key.
+*/
+const notAnId = { error: "Invalid id." };
+function hexString24(messages) {
+	if (messages === void 0) return z.string().regex(HexString24Pattern);
+	const { invalid = notAnId.error, missing } = typeof messages === "string" || messages === false ? { missing: messages } : messages;
+	if (missing === false) return z.string({ error: invalid }).refine((value) => value === "" || HexString24Pattern.test(value), { error: invalid }).nullish();
+	const error = (issue) => issue.input === void 0 || issue.input === null || issue.input === "" ? missing : invalid;
+	return z.string({ error }).regex(HexString24Pattern, { error });
+}
+/**
+* An id with nothing said about whose it is.
+*
+* For a stored model, where the field is a shape rather than a question put to a person: a
+* polymorphic subject's `id`, a join's `_id`. A request that a person fills in wants
+* `hexString24(message)` instead, so a mistyped id reads as something other than a regex.
+*/
+const HexString24 = hexString24();
+// src/iso-date.ts
+const isoDateTime = z.iso.datetime({ offset: true });
+const calendarDay = z.iso.date();
+function isDateInput(value) {
+	return value instanceof Date ? !Number.isNaN(value.getTime()) : isoDateTime.safeParse(value).success;
+}
+function isDayInput(value) {
+	return value instanceof Date ? isMidnight(value, true) : calendarDay.safeParse(value).success;
+}
+/** The issue `z.date()` raises, or `message` in its place. */
+function notADate(value, message) {
+	return {
+		code: "invalid_type",
+		expected: "date",
+		input: value,
+		...message !== void 0 && { message }
+	};
+}
+/**
+* The JSON Schema string format of each `isoDate()` input (`date-time`) and each side of an `isoDay()`
+* (`date`), so `toJsonSchema` can tell them from any other `z.custom` or `z.date()`.
+*/
+const dateFormats = z.registry();
+const inputsByMessage = /* @__PURE__ */ new Map();
+const dayInputsByMessage = /* @__PURE__ */ new Map();
+/** What every `isoDay()` decodes to. */
+const dayOutput = z.date();
+dateFormats.add(dayOutput, { format: "date" });
+/**
+* The string format JSON Schema describes a schema with: `date` for a side of an {@link isoDay},
+* `date-time` for an {@link isoDate}'s input; undefined for any other schema.
+*/
+function dateFormat(schema) {
+	return dateFormats.get(schema)?.format;
+}
+/** Whether a field holds a date: `z.date()`, an {@link isoDate} or an {@link isoDay}, under any wrappers. */
+function isDateSchema(schema) {
+	const field = unwrapField(schema, true);
+	return isZodDate(field) || isZodCodec(field) && isZodDate(field.def.out);
+}
+/**
+* A date field that also takes its ISO date-time string, as a value that came through JSON
+* arrives.
+*
+* Typed `Date` on both sides although it accepts a string at runtime: a form validator is a
+* `StandardSchemaV1<FormValues>`, and `z.input` reading `string | Date` would fail it. The cost
+* is `z.encode`, whose declared result is `Date` but which returns the ISO string, which only
+* matters where a value is about to be serialized.
+*
+* A factory, so each field has its own instance to describe, wrap and default. A `message`
+* replaces the refusal's, as `z.date(message)` does.
+*/
+function isoDate(message) {
+	return z.codec(isoDateInput(message), z.date(), {
+		decode: (value) => new Date(value),
+		encode: (date) => date.toISOString()
+	});
+}
+/**
+* What an `isoDate()` takes: a `Date`, or the ISO date-time string JSON carries one as. One
+* instance per message.
+*
+* Refuses with the issue `z.date()` raises, so a refusal reads the same either way.
+*/
+function isoDateInput(message) {
+	return getOrSet(inputsByMessage, message ?? "", () => {
+		const input = z.custom().check((payload) => {
+			if (!isDateInput(payload.value)) payload.issues.push(notADate(payload.value, message));
+		});
+		dateFormats.add(input, { format: "date-time" });
+		if (input._zod.parent) dateFormats.add(input._zod.parent, { format: "date-time" });
+		return input;
+	});
+}
+/**
+* A calendar day: `YYYY-MM-DD` on the wire, that day's UTC midnight as a `Date`, and the UTC day
+* again when encoded. Typed `Date` on both sides, as {@link isoDate} is, and marked `dateOnly`,
+* the metadata a date-only field carries.
+*
+* Refuses anything else (a date-time, a day no calendar has, a `Date` with a time of day) with
+* the issue `z.date()` raises, or `message`.
+*/
+function isoDay(message) {
+	return z.codec(isoDayInput(message), dayOutput, {
+		decode: (value) => value instanceof Date ? value : /* @__PURE__ */ new Date(`${value}T00:00:00.000Z`),
+		encode: (date, payload) => {
+			if (!isMidnight(date, true)) payload.issues.push(notADate(date, message));
+			return date.toISOString().slice(0, 10);
+		}
+	}).meta({ dateOnly: true });
+}
+/** What an `isoDay()` takes: a `Date` at UTC midnight, or `YYYY-MM-DD`. One instance per message. */
+function isoDayInput(message) {
+	return getOrSet(dayInputsByMessage, message ?? "", () => {
+		const input = z.custom().check((payload) => {
+			if (!isDayInput(payload.value)) payload.issues.push(notADate(payload.value, message));
+		});
+		dateFormats.add(input, { format: "date" });
+		if (input._zod.parent) dateFormats.add(input._zod.parent, { format: "date" });
+		return input;
+	});
+}
+// src/json-text.ts
+/** JSON held as text, strict or loose (`parseLooseJson`). A blank value is left to the field's own required rule. */
+const JsonText = z.string().refine((text) => !text.trim() || isLooseJson(text), "Invalid JSON.");
+// src/labelled.ts
+/** The label a field carries, read through the optional/nullable/default wrappers declared around it. */
+function fieldLabel(schema) {
+	for (let current = schema; current; current = current.def?.innerType) {
+		const meta = z.globalRegistry.get(current);
+		if (typeof meta?.title === "string") return {
+			...isStringRecord(meta.options) && { options: meta.options },
+			...typeof meta.reference === "string" && { reference: meta.reference },
+			title: meta.title
+		};
+	}
+}
+function isStringRecord(value) {
+	return isObject(value) && Object.values(value).every((entry) => typeof entry === "string");
+}
+/** A field, labelled. The label carries into the JSON Schema; validation is unchanged. */
+function labelled(schema, label) {
+	return schema.meta({ ...label });
+}
+// src/language-code.ts
+/**
+* A field that takes an ISO 639-1 language, optionally with its region (`fr`, `fr-CA`), that
+* this runtime can name.
+*
+* The message is the caller's, as `timeZone`'s is: the i18n extractor harvests a plain zod
+* message where it is written. `whenEmpty` is separate for a form that distinguishes a field
+* nobody filled in from one filled in wrongly; left out, one message answers for both.
+*/
+function languageCode(message, whenEmpty = message) {
+	return z.string().min(1, whenEmpty).refine(isLanguageCode, message);
+}
+// src/localized-string.ts
+/**
+* A localized value with nothing said about it: any record of language → text, blank included.
+*
+* For a stored model, where a row saved before a rule must still read. A field a person fills
+* in wants `localizedString(messages)` instead, so a blank one is refused in words.
+*/
+const LocalizedString = z.record(z.string(), z.string());
+const LocalizedStringArray = z.record(z.string(), z.array(z.string()));
+/** As {@link LocalizedString}, or a plain string — what a write model takes for a localized field. */
+const LocalizedStringInput = z.union([z.string(), LocalizedString]);
+const LocalizedStringArrayInput = z.union([z.array(z.string()), LocalizedStringArray]);
+/**
+* Whether a localized value has text: a string that isn't blank, or text in at least one
+* language. `undefined`, `null`, `''`, `'   '`, `{}` and `{ en: '', fr: ' ' }` have none.
+*/
+function hasLocalizedText(value) {
+	if (typeof value === "string") return value.trim().length > 0;
+	if (!value || typeof value !== "object") return false;
+	return Object.values(value).some((text) => typeof text === "string" && text.trim().length > 0);
+}
+/** Whether a localized value is at most `max` characters, as a string or in every language it names. */
+function isLocalizedTextWithin(value, max) {
+	if (typeof value === "string") return value.length <= max;
+	if (!value || typeof value !== "object") return true;
+	return Object.values(value).every((text) => typeof text !== "string" || text.length <= max);
+}
+function withText(shape, messages) {
+	if (messages === void 0) return shape(void 0).refine(hasLocalizedText);
+	const { invalid, missing } = typeof messages === "string" ? {
+		invalid: messages,
+		missing: messages
+	} : messages;
+	if (missing === false) return shape(() => invalid).nullish();
+	const error = (issue) => issue.input === void 0 || issue.input === null ? missing : invalid;
+	return shape(error).refine(hasLocalizedText, { error: missing });
+}
+/** A locale record whose every error — the record's, or one language's text — says `error`. */
+const record = (error) => z.record(z.string(), z.string({ error }), { error });
+function localizedString(messages) {
+	return withText(record, messages);
+}
+function localizedStringInput(messages) {
+	return withText((error) => z.union([z.string({ error }), record(error)], { error }), messages);
+}
+const accepts = (schema, value) => schema.safeParse(value).success;
+/**
+* The write-model fields that let a required localized name through blank — for a guard spec to
+* assert is empty.
+*
+* For every exported model `X` with an `AddX` or `UpdateX` beside it: a field `X` requires, and
+* that takes both a string and a locale record, is a required localized name. Its write models
+* must refuse `''` and `{ en: '' }`, which {@link localizedStringInput} does. Returns
+* `UpdateRole.name`-style paths for each one that doesn't. Read from the schemas rather than the
+* source, so it sees what a write actually accepts.
+*/
+function findUncheckedLocalizedFields(models) {
+	const unchecked = [];
+	for (const [name, model] of Object.entries(models)) {
+		if (!(model instanceof z.ZodObject)) continue;
+		const shape = model.shape;
+		const required = Object.keys(shape).filter((key) => {
+			const field = shape[key];
+			return !accepts(field, void 0) && accepts(field, "Name") && accepts(field, { en: "Name" });
+		});
+		if (required.length === 0) continue;
+		for (const writeName of [`Add${name}`, `Update${name}`]) {
+			const write = models[writeName];
+			if (!(write instanceof z.ZodObject)) continue;
+			const writeShape = write.shape;
+			for (const key of required) {
+				const field = writeShape[key];
+				if (field && (accepts(field, "") || accepts(field, { en: "" }))) unchecked.push(`${writeName}.${key}`);
+			}
+		}
+	}
+	return unchecked.sort();
+}
+// src/merge.ts
+/**
+* Adds a Zod type to an existing ZodUnion.
+*/
+function addToUnion(union, object) {
+	return z.union([object, ...union.options]);
+}
+/**
+* Deeply merges two ZodRawShape objects into one.
+*/
+function mergeShapes(shapeA, shapeB) {
+	const mergedShape = { ...shapeA };
+	for (const key in shapeB) if (key in mergedShape) {
+		const valueA = mergedShape[key];
+		const valueB = shapeB[key];
+		if (isZodObject(valueA) && isZodObject(valueB)) {
+			const shapeInnerA = valueA.shape;
+			const shapeInnerB = valueB.shape;
+			mergedShape[key] = z.object(mergeShapes(shapeInnerA, shapeInnerB));
+		} else mergedShape[key] = z.union([valueA, valueB]);
+	} else mergedShape[key] = shapeB[key];
+	return mergedShape;
+}
+// src/nullish.ts
+function nullish(fields) {
+	return z.object(mapValues(fields.shape, (field) => field.nullish()));
+}
+// src/positional-paths.ts
+/** What `segment` names under `node`, looking through arrays the way Mongo's dotted paths do. */
+function childrenOf(node, segment) {
+	if (isZodArray(node)) return flatten(node.def.element).flatMap((element) => childrenOf(element, segment));
+	if (isZodObject(node)) return node.shape[segment] ? flatten(node.shape[segment]) : [];
+	if (isZodRecord(node) && isZodType(node.def.valueType)) return flatten(node.def.valueType);
+	return [];
+}
+function flatten(node) {
+	const unwrapped = unwrapField(node, true);
+	return isZodUnion(unwrapped) ? unwrapped.options.flatMap(flatten) : [unwrapped];
+}
+/** Nodes a path can end at but not pass through: what lies past them can't be named from the schema. */
+const opaqueTypes = /* @__PURE__ */ new Set([
+	"any",
+	"custom",
+	"intersection",
+	"pipe",
+	"record",
+	"transform",
+	"tuple",
+	"unknown"
+]);
+/** What `segment` names under `node` on the way to a deeper field, or `undefined` where the schema can't be followed. */
+function followedChildren(node, segment) {
+	if (opaqueTypes.has(node.def.type)) return void 0;
+	if (isZodObject(node)) return node.shape[segment] ? flatten(node.shape[segment]) : [];
+	if (!isZodArray(node)) return [];
+	const children = flatten(node.def.element).map((element) => followedChildren(element, segment));
+	return children.some((found) => found === void 0) ? void 0 : children.flatMap((found) => found ?? []);
+}
+/**
+* Whether {@link toFieldPath} can follow `path` through `schema`: every segment is reached through objects and
+* arrays (and the wrappers and unions around them), with no pipe, transform, intersection, tuple, record or loose
+* (`any`, `unknown`, `custom`) node before the last. The path may end at one.
+*/
+function isFollowablePath(schema, path) {
+	let nodes = flatten(schema);
+	for (const segment of path.split(".")) {
+		const next = [];
+		for (const node of nodes) {
+			const children = followedChildren(node, segment);
+			if (children === void 0) return false;
+			next.push(...children);
+		}
+		if (next.length === 0) return false;
+		nodes = next;
+	}
+	return true;
+}
+/**
+* `path` with `.$[]` after every segment that `schema` types as an array, except the last:
+* `settings.pages.defaultAccessLevels` -> `settings.pages.$[].defaultAccessLevels`. Returns
+* `path` unchanged when no segment before the last is an array.
+*
+* At a union, every arm is followed; a segment is an array when any arm types it as one.
+*/
+function toAllPositionalPath(schema, path) {
+	const segments = path.split(".");
+	const result = [];
+	let nodes = flatten(schema);
+	for (const [index, segment] of segments.entries()) {
+		const children = nodes.flatMap((node) => {
+			const child = isZodObject(node) ? node.shape[segment] : void 0;
+			return child ? flatten(child) : [];
+		});
+		const arrays = children.filter(isZodArray);
+		result.push(segment);
+		if (arrays.length > 0 && index < segments.length - 1) {
+			result.push("$[]");
+			nodes = arrays.flatMap((array) => flatten(array.def.element));
+		} else nodes = children;
+	}
+	return result.join(".");
+}
+/**
+* The field path `path` names in `schema`, its array positions left out:
+* `lines.0.attachments.$[].title` -> `lines.attachments.title`. A numeric segment is dropped
+* only where `schema` has an array, so a record's key stays: `budgets.2026` is unchanged.
+* `$`, `$[]` and `$[id]` are always positions.
+*/
+function toFieldPath(schema, path) {
+	const result = [];
+	let nodes = flatten(schema);
+	for (const segment of path.split(".")) {
+		const arrays = nodes.filter(isZodArray);
+		if (segment.startsWith("$") || isInteger(segment) && arrays.length > 0) {
+			if (arrays.length > 0) nodes = arrays.flatMap((array) => flatten(array.def.element));
+			continue;
+		}
+		result.push(segment);
+		nodes = nodes.flatMap((node) => childrenOf(node, segment));
+	}
+	return result.join(".");
+}
+// src/reg-exp-pattern.ts
+const RegExpPattern = z.string().refine(isValidPattern, "Invalid regular expression.");
+// src/slug.ts
+/** What a value that is not a slug says. An `error` property so the i18n extractor keeps the key. */
+const invalidSlug = { error: "Use lower-case letters, numbers and dashes." };
+/** A key, identifier or channel in {@link SlugPattern}. `missing` is the field's own message for an empty value, and the only one an empty value gets. */
+function slug(missing = invalidSlug.error) {
+	return z.string().min(1, {
+		abort: true,
+		error: missing
+	}).regex(SlugPattern, invalidSlug.error);
+}
+/** A slug with nothing said about an empty value beyond what any other wrong value gets. */
+const Slug = slug();
+// src/strip-empty-fields.ts
+function isEmpty(value) {
+	if (value === void 0 || value === "") return true;
+	if (Array.isArray(value)) return value.length === 0;
+	return isPlainObject(value) && Object.keys(value).length === 0;
+}
+function resolveShape(schema, values) {
+	if (isZodObject(schema)) return schema.shape;
+	const options = schema.def.options;
+	if (Array.isArray(options)) for (const option of options) {
+		if (!isZodObject(option)) continue;
+		const shape = option.shape;
+		if (Object.entries(shape).every(([key, fieldSchema]) => !(fieldSchema instanceof ZodLiteral) || fieldSchema.def.values.some((literal) => literal === values[key]))) return shape;
+	}
+}
+function stripEmptyFields(schema, values) {
+	return stripEmptyFieldsRecursive(schema, values, /* @__PURE__ */ new Set());
+}
+function stripEmptyFieldsRecursive(schema, values, seen) {
+	const shape = resolveShape(schema, values);
+	if (!shape) return values;
+	const result = { ...values };
+	for (const key of Object.keys(result)) {
+		const fieldSchema = shape[key];
+		if (!fieldSchema) continue;
+		const value = result[key];
+		if (isFieldOptional(fieldSchema) && isEmpty(value)) {
+			delete result[key];
+			continue;
+		}
+		if (value !== null && typeof value === "object" && !Array.isArray(value)) {
+			const innerType = getInnerType(fieldSchema);
+			if (isZodObject(innerType) && !seen.has(value)) {
+				seen.add(value);
+				result[key] = stripEmptyFieldsRecursive(innerType, value, seen);
+				seen.delete(value);
+				if (isFieldOptional(fieldSchema) && isEmpty(result[key])) delete result[key];
+			}
+		}
+	}
+	return result;
+}
+// src/strip-to-schema.ts
+function pick(schemas, value) {
+	const fields = schemas.flatMap(variantsOf);
+	if (Array.isArray(value)) {
+		const elements = fields.filter(isZodArray).map((field) => field.element);
+		return elements.length === 0 ? value : value.map((item) => pick(elements, item));
+	}
+	const shapes = fields.flatMap((field) => isZodObject(field) ? [field.shape] : []);
+	return shapes.length === 0 || !isPlainObject(value) ? value : pickFields(shapes, value);
+}
+/** The fields of `value` that any of `shapes` declares, each picked by every shape that declares it. */
+function pickFields(shapes, value) {
+	const record = value;
+	const picked = {};
+	for (const key of new Set(shapes.flatMap((shape) => Object.keys(shape)))) if (Object.hasOwn(record, key) && record[key] !== void 0) picked[key] = pick(shapes.flatMap((shape) => Object.hasOwn(shape, key) ? [shape[key]] : []), record[key]);
+	return picked;
+}
+/**
+* `value` cut down to the fields `schema` declares, at every depth: through arrays, optionals, nullables, defaults,
+* catches, lazies and the objects of a union or an intersection, merged. Nothing is parsed, so no checks, codecs or defaults run, and a
+* value that doesn't fit its field is copied as it is. `value` itself is picked by its keys, whatever its prototype.
+*/
+function stripToSchema(schema, value) {
+	return pickFields([schema.shape], value);
+}
+/** What `schema` holds a value as, through wrappers and lazies: each option of a union, each side of an intersection, or itself. */
+function variantsOf(schema) {
+	const field = unwrapField(schema, true);
+	if (isZodIntersection(field)) return [...variantsOf(field.def.left), ...variantsOf(field.def.right)];
+	return isZodUnion(field) ? field.options.flatMap(variantsOf) : [field];
+}
+// src/time-zone.ts
+/**
+* A field that takes an IANA zone this runtime can actually format in.
+*
+* The check belongs at the write boundary: an unsupported zone is stored happily and then
+* throws a `RangeError` inside `Intl` on every later read, far from whatever put it there.
+*
+* The message is the CALLER's, as `objectId`'s is, for two reasons. A domain says what it
+* wants in its own words — "Select a valid time zone." on a form, "Invalid time zone." on a
+* public booking — and the i18n extractor harvests a plain zod message where it is written,
+* so a sentence buried in here would reach no dictionary. `whenEmpty` is separate for a form
+* that distinguishes a field nobody filled in from one filled in wrongly; left out, one
+* message answers for both.
+*/
+function timeZone(message, whenEmpty = message) {
+	return z.string().min(1, whenEmpty).refine(isSupportedTimezone, message);
+}
+// src/to-json-schema.ts
+/**
+* A JSON Schema document, as {@link toJsonSchema} produces.
+*
+* An object rather than `unknown` because these schemas exist to be READ: an editor
+* walks `properties` to build its field pickers. As `unknown`, every consumer casts
+* before it can index - at exactly the boundary that was supposed to describe the value.
+*
+* Deliberately not modelled more precisely than "a JSON object". JSON Schema is
+* recursive and open-ended, and restating its grammar here would be a second, worse
+* copy of a specification we do not own.
+*/
+const JsonSchemaDocument = z.record(z.string(), z.unknown());
+/**
+* `z.toJSONSchema`, with dates described rather than refused.
+*
+* zod has no JSON Schema for `z.date()` and throws on it by default, so one date field
+* anywhere in a schema fails the whole conversion - which is how one event with a
+* `startAt` blanked the workflow editor, and why every domain model's schema endpoint
+* answered 500. Here a date is `{ type: 'string', format: 'date-time' }`, the node
+* `z.iso.datetime()` produces, so a reader sees the same field either way, and an
+* `isoDate()` reads the same as `z.date()` on either side; an `isoDay()` is a `format: 'date'`
+* string on either side. The value
+* itself is untouched: a schema that takes a `Date` still takes a `Date`.
+*
+* Use this rather than `z.toJSONSchema`; the lint rule `no-restricted-properties`
+* points there.
+*/
+function toJsonSchema(schema, options = {}) {
+	const otherwise = options.unrepresentable ?? "throw";
+	return z.toJSONSchema(schema, {
+		io: options.io,
+		unrepresentable: ({ zodSchema }) => {
+			const format = dateFormat(zodSchema) ?? (zodSchema._zod.def.type === "date" ? "date-time" : void 0);
+			return format ? {
+				format,
+				type: "string"
+			} : otherwise;
+		}
+	});
+}
+// src/whole-number.ts
+const NonNegativeInteger = boundedNumber({
+	integer: true,
+	min: 0
+});
+const PositiveInteger = boundedNumber({
+	integer: true,
+	min: 1
+});
+export { AnyFieldSettingsSchema, CurrencyCodePattern, HexString24, HexString24Pattern, JsonSchemaDocument, JsonText, LocalizedString, LocalizedStringArray, LocalizedStringArrayInput, LocalizedStringInput, NonNegativeInteger, PositiveInteger, RegExpPattern, Slug, ZOD_WRAPPER_TYPES, addToUnion, applyFieldSettings, boundedNumber, codecParts, currencyCode, fieldLabel, findUncheckedLocalizedFields, formatTemplate, getInnerType, getZodFieldPaths, hasLocalizedText, hexString24, isDateSchema, isFieldNullable, isFieldOptional, isFollowablePath, isLocalizedTextWithin, isOptionalOutput, isZodAny, isZodArray, isZodCatch, isZodCodec, isZodDate, isZodDefault, isZodEnum, isZodIntersection, isZodLazy, isZodNullable, isZodNumber, isZodObject, isZodObjectLoose, isZodOptional, isZodPipe, isZodRecord, isZodString, isZodTransform, isZodType, isZodUnion, isZodUnknown, isZodWrapper, isoDate, isoDay, labelled, languageCode, localizedString, localizedStringInput, mergeShapes, nullish, slug, stripEmptyFields, stripToSchema, timeZone, toAllPositionalPath, toFieldPath, toJsonSchema, unwrapField, withCodecParts };