@temelyos/zod 1.0.0 → 1.0.1

package/dist/bounded-number.d.ts

@@ -0,0 +1,8 @@
+import { z } from "zod";
+export interface NumberBounds {
+  integer?: boolean;
+  max?: number;
+  min?: number;
+}
+/** A number, optionally whole and bounded; a refusal names its bounds as the message's `{0}` and `{1}`. */
+export declare function boundedNumber({ integer, max, min }: NumberBounds): z.ZodNumber;

package/dist/bounded-number.js

@@ -0,0 +1,36 @@
+import { z } from "zod";
+// 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 }
+	});
+}
+export { boundedNumber };

package/dist/codec-parts.d.ts

@@ -0,0 +1,8 @@
+import { ZodType } from "zod";
+/** The schemas {@link withCodecParts} named for a codec; undefined for any other schema. */
+export declare function codecParts(schema: ZodType): readonly ZodType[] | undefined;
+/**
+ * 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.
+ */
+export declare function withCodecParts<T extends ZodType>(codec: T, schemas: readonly ZodType[]): T;

package/dist/codec-parts.js

@@ -0,0 +1,21 @@
+import { z } from "zod";
+// 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;
+}
+export { codecParts, withCodecParts };

package/dist/currency-code.d.ts

@@ -0,0 +1,5 @@
+import { z } from "zod";
+/** A lower-case ISO 4217 code: `usd`, never `USD` or `$`. */
+export declare const CurrencyCodePattern: RegExp;
+/** A field that takes a lower-case ISO 4217 code. `missing` is the caller's, for a field nobody filled in. */
+export declare function currencyCode(missing: string, invalid?: string): z.ZodString;

package/dist/currency-code.js

@@ -0,0 +1,11 @@
+import { z } from "zod";
+// 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);
+}
+export { CurrencyCodePattern, currencyCode };

package/dist/field-paths.d.ts

@@ -0,0 +1,54 @@
+import { ZodType } from "zod";
+export interface GetZodFieldPathsOptions {
+  /**
+   * When `true`, arrays are treated as terminal leaves and NOT descended (no
+   * `items.token`-style paths are emitted). Defaults to `false` — arrays are
+   * descended via their element type, matching how `getPathValues` fans out
+   * across arrays at runtime.
+   *
+   * Callers whose downstream path-consumer cannot fan out across arrays — e.g.
+   * `getSensitivePaths`, whose redact step (`splitSensitive`) walks plain objects
+   * only and would silently skip an array-borne path — should set this to `true`.
+   */
+  skipArrays?: boolean;
+}
+export interface ZodFieldPath {
+  /** The field's schema as its object declares it, wrappers kept: what says whether it may be absent. */
+  declared: ZodType;
+  /** Dotted path to the field within the schema, e.g. `auth.apiKey`. */
+  path: string;
+  /** The field's schema with wrapper types (see `unwrapField`) removed. A codec is left whole: ask `isDateSchema` what it holds. */
+  schema: ZodType;
+}
+/**
+ * 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).
+ */
+export declare function getZodFieldPaths(schema: ZodType, options?: GetZodFieldPathsOptions): ZodFieldPath[];
+/**
+ * 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.
+ */
+export declare function unwrapField(schema: ZodType, shouldSkipArrays: boolean, seen?: Set<ZodType>): ZodType;

package/dist/field-paths.js

@@ -0,0 +1,67 @@
+import { isZodObject, isZodUnion } from "./utilities.js";
+import { ZodArray, ZodCatch, ZodDefault, ZodLazy, ZodNonOptional, ZodNullable, ZodOptional, ZodPrefault, ZodReadonly } from "zod";
+// 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;
+}
+export { getZodFieldPaths, unwrapField };

package/dist/field-settings.d.ts

@@ -0,0 +1,119 @@
+import { UnwrapZodType } from "./types.js";
+import { ZodEnum, ZodFile, ZodNumber, ZodObject, ZodRawShape, ZodString, core, z } from "zod";
+export interface BaseFieldSettings<T> {
+  default?: T;
+  isOptional?: boolean;
+  isVisible?: boolean;
+  label?: string;
+}
+declare const stringFieldSettingsSchema: ZodObject<{
+  default: z.ZodOptional<ZodString>;
+  isOptional: z.ZodOptional<z.ZodBoolean>;
+  isVisible: z.ZodOptional<z.ZodBoolean>;
+  label: z.ZodOptional<ZodString>;
+  maxLength: z.ZodOptional<z.ZodUnion<readonly [ZodNumber, ZodObject<{
+    message: ZodString;
+    value: ZodNumber;
+  }, core.$strip>]>>;
+  minLength: z.ZodOptional<z.ZodUnion<readonly [ZodNumber, ZodObject<{
+    message: ZodString;
+    value: ZodNumber;
+  }, core.$strip>]>>;
+  regExp: z.ZodOptional<z.ZodUnion<readonly [z.ZodInstanceOf<RegExp>, ZodObject<{
+    message: ZodString;
+    value: z.ZodInstanceOf<RegExp>;
+  }, core.$strip>]>>;
+}, core.$strip>;
+export type StringFieldSettings = z.infer<typeof stringFieldSettingsSchema>;
+declare const numberFieldSettingsSchema: ZodObject<{
+  default: z.ZodOptional<ZodNumber>;
+  isOptional: z.ZodOptional<z.ZodBoolean>;
+  isVisible: z.ZodOptional<z.ZodBoolean>;
+  label: z.ZodOptional<ZodString>;
+  max: z.ZodOptional<z.ZodUnion<readonly [ZodNumber, ZodObject<{
+    message: ZodString;
+    value: ZodNumber;
+  }, core.$strip>]>>;
+  min: z.ZodOptional<z.ZodUnion<readonly [ZodNumber, ZodObject<{
+    message: ZodString;
+    value: ZodNumber;
+  }, core.$strip>]>>;
+}, core.$strip>;
+export type NumberFieldSettings = z.infer<typeof numberFieldSettingsSchema>;
+declare const fileFieldSettingsSchema: ZodObject<{
+  default: z.ZodOptional<z.ZodInstanceOf<File>>;
+  isOptional: z.ZodOptional<z.ZodBoolean>;
+  isVisible: z.ZodOptional<z.ZodBoolean>;
+  label: z.ZodOptional<ZodString>;
+  maxBytes: z.ZodOptional<z.ZodUnion<readonly [ZodNumber, ZodObject<{
+    message: ZodString;
+    value: ZodNumber;
+  }, core.$strip>]>>;
+  minBytes: z.ZodOptional<z.ZodUnion<readonly [ZodNumber, ZodObject<{
+    message: ZodString;
+    value: ZodNumber;
+  }, core.$strip>]>>;
+}, core.$strip>;
+export type FileFieldSettings = z.infer<typeof fileFieldSettingsSchema>;
+declare const dropdownFieldSettingsSchema: ZodObject<{
+  default: z.ZodOptional<ZodString>;
+  isOptional: z.ZodOptional<z.ZodBoolean>;
+  isVisible: z.ZodOptional<z.ZodBoolean>;
+  label: z.ZodOptional<ZodString>;
+  values: z.ZodOptional<z.ZodUnion<readonly [z.ZodArray<ZodString>, z.ZodRecord<ZodString, z.ZodUnion<readonly [ZodString, ZodNumber]>>]>>;
+}, core.$strip>;
+export type DropdownFieldSettings = z.infer<typeof dropdownFieldSettingsSchema>;
+export declare const AnyFieldSettingsSchema: z.ZodUnion<readonly [ZodObject<{
+  default: z.ZodOptional<ZodString>;
+  isOptional: z.ZodOptional<z.ZodBoolean>;
+  isVisible: z.ZodOptional<z.ZodBoolean>;
+  label: z.ZodOptional<ZodString>;
+  maxLength: z.ZodOptional<z.ZodUnion<readonly [ZodNumber, ZodObject<{
+    message: ZodString;
+    value: ZodNumber;
+  }, core.$strip>]>>;
+  minLength: z.ZodOptional<z.ZodUnion<readonly [ZodNumber, ZodObject<{
+    message: ZodString;
+    value: ZodNumber;
+  }, core.$strip>]>>;
+  regExp: z.ZodOptional<z.ZodUnion<readonly [z.ZodInstanceOf<RegExp>, ZodObject<{
+    message: ZodString;
+    value: z.ZodInstanceOf<RegExp>;
+  }, core.$strip>]>>;
+}, core.$strip>, ZodObject<{
+  default: z.ZodOptional<ZodNumber>;
+  isOptional: z.ZodOptional<z.ZodBoolean>;
+  isVisible: z.ZodOptional<z.ZodBoolean>;
+  label: z.ZodOptional<ZodString>;
+  max: z.ZodOptional<z.ZodUnion<readonly [ZodNumber, ZodObject<{
+    message: ZodString;
+    value: ZodNumber;
+  }, core.$strip>]>>;
+  min: z.ZodOptional<z.ZodUnion<readonly [ZodNumber, ZodObject<{
+    message: ZodString;
+    value: ZodNumber;
+  }, core.$strip>]>>;
+}, core.$strip>, ZodObject<{
+  default: z.ZodOptional<z.ZodInstanceOf<File>>;
+  isOptional: z.ZodOptional<z.ZodBoolean>;
+  isVisible: z.ZodOptional<z.ZodBoolean>;
+  label: z.ZodOptional<ZodString>;
+  maxBytes: z.ZodOptional<z.ZodUnion<readonly [ZodNumber, ZodObject<{
+    message: ZodString;
+    value: ZodNumber;
+  }, core.$strip>]>>;
+  minBytes: z.ZodOptional<z.ZodUnion<readonly [ZodNumber, ZodObject<{
+    message: ZodString;
+    value: ZodNumber;
+  }, core.$strip>]>>;
+}, core.$strip>, ZodObject<{
+  default: z.ZodOptional<ZodString>;
+  isOptional: z.ZodOptional<z.ZodBoolean>;
+  isVisible: z.ZodOptional<z.ZodBoolean>;
+  label: z.ZodOptional<ZodString>;
+  values: z.ZodOptional<z.ZodUnion<readonly [z.ZodArray<ZodString>, z.ZodRecord<ZodString, z.ZodUnion<readonly [ZodString, ZodNumber]>>]>>;
+}, core.$strip>]>;
+export type AnyFieldSettings = z.infer<typeof AnyFieldSettingsSchema>;
+export type FieldSettings<T extends ZodObject<ZodRawShape>> = { [K in keyof T['shape']]?: UnwrapZodType<T['shape'][K]> extends ZodString ? StringFieldSettings : UnwrapZodType<T['shape'][K]> extends ZodNumber ? NumberFieldSettings : UnwrapZodType<T['shape'][K]> extends ZodEnum<any> ? DropdownFieldSettings : UnwrapZodType<T['shape'][K]> extends ZodFile ? FileFieldSettings : BaseFieldSettings<z.infer<T['shape'][K]>>; };
+export declare function applyFieldSettings<T extends ZodRawShape>(schema: ZodObject<T>, fields?: FieldSettings<ZodObject<T>>): ZodObject<T>;
+export {};

package/dist/field-settings.js

@@ -0,0 +1,219 @@
+import { isZodCatch, isZodCodec, isZodDefault, isZodEnum, isZodLazy, isZodNullable, isZodNumber, isZodOptional, isZodPipe, isZodString, isZodTransform, isZodWrapper } from "./utilities.js";
+import { z } from "zod";
+import { getLogger } from "@temelyos/core/logging/store";
+// 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;
+}
+export { AnyFieldSettingsSchema, applyFieldSettings, applyWrappers, createDropdownField, createNumberField, createStringField, getField, getZodCheck };

package/dist/format-template.d.ts

@@ -0,0 +1,3 @@
+import { z } from "zod";
+/** Text whose every `{token}` names one of `keys`, with no stray braces. */
+export declare function formatTemplate(keys: readonly string[]): z.ZodString;

package/dist/format-template.js

@@ -0,0 +1,8 @@
+import { z } from "zod";
+import { isValidFormat } from "@temelyos/core/format";
+// 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.");
+}
+export { formatTemplate };

package/dist/hex-string-24.d.ts

@@ -0,0 +1,45 @@
+import { z } from "zod";
+/**
+ * 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.
+ */
+export declare const HexString24Pattern: RegExp;
+/** What an id field says when nothing was chosen, and when what came is not an id. */
+export interface HexString24Messages {
+  /** Defaults to "Invalid id.". */
+  invalid?: string;
+  /** `false` when nothing chosen is an answer: absent, `null` and `''` then all read as unset. */
+  missing: false | string;
+}
+/**
+ * A field holding one id.
+ *
+ * The message is the CALLER's, as `timeZone`'s is: "Select an owner." belongs to the form asking
+ * for an owner, not here. It answers for nothing chosen: absent, `null`, or the empty string a
+ * cleared select sends. A value that is there but is not an id says "Invalid id.", or `invalid`
+ * when the caller names one. Left out entirely, zod says what it says about a pattern, which is
+ * unreadable, and the reason a request schema should pass one.
+ *
+ * `{ missing: false }`, or `false` for short, is the field that may be left unset: absent, `null`
+ * and `''` pass through as they came, so the repository can tell a clear (`''`) from a field left
+ * alone.
+ */
+export declare function hexString24(messages?: string | {
+  invalid?: string;
+  missing: string;
+}): z.ZodString;
+export declare function hexString24(messages: false | {
+  invalid?: string;
+  missing: false;
+}): z.ZodOptional<z.ZodNullable<z.ZodString>>;
+/**
+ * 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.
+ */
+export declare const HexString24: z.ZodString;

package/dist/hex-string-24.js

@@ -0,0 +1,32 @@
+import { z } from "zod";
+// 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();
+export { HexString24, HexString24Pattern, hexString24 };