@temelyos/zod 1.0.0 → 1.0.1

package/dist/iso-date.d.ts

@@ -0,0 +1,25 @@
+import { ZodType, z } from "zod";
+/** Whether a field holds a date: `z.date()`, an {@link isoDate} or an {@link isoDay}, under any wrappers. */
+export declare function isDateSchema(schema: ZodType): boolean;
+/**
+ * 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.
+ */
+export declare function isoDate(message?: string): z.ZodCodec<z.ZodCustom<Date, Date>, z.ZodDate>;
+/**
+ * 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`.
+ */
+export declare function isoDay(message?: string): z.ZodCodec<z.ZodCustom<Date, Date>, z.ZodDate>;

package/dist/iso-date.js

@@ -0,0 +1,108 @@
+import { unwrapField } from "./field-paths.js";
+import { isZodCodec, isZodDate } from "./utilities.js";
+import { z } from "zod";
+import { getOrSet } from "@temelyos/core/cache";
+import { isMidnight } from "@temelyos/core/date";
+// 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;
+	});
+}
+export { dateFormat, isDateSchema, isoDate, isoDay };

package/dist/json-text.d.ts

@@ -0,0 +1,3 @@
+import { z } from "zod";
+/** JSON held as text, strict or loose (`parseLooseJson`). A blank value is left to the field's own required rule. */
+export declare const JsonText: z.ZodString;

package/dist/json-text.js

@@ -0,0 +1,6 @@
+import { z } from "zod";
+import { isLooseJson } from "@temelyos/core/json";
+// 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.");
+export { JsonText };

package/dist/labelled.d.ts

@@ -0,0 +1,17 @@
+import { z } from "zod";
+/** The values of an enum field, or of the elements of an array of one. */
+type EnumValue<T extends z.ZodType> = Extract<z.output<T> extends readonly (infer TElement)[] ? TElement : z.output<T>, string>;
+/** How a field is named where the product names fields generically, such as the workflow criteria editor. */
+export interface FieldLabel<TValue extends string = string> {
+  /** A dictionary key naming each value of an enum field, by value. */
+  options?: Record<TValue, string>;
+  /** The kind of record the value is the id of, such as `users`; the editor offers a search of that kind for it. */
+  reference?: string;
+  /** A dictionary key naming the field. */
+  title: string;
+}
+/** The label a field carries, read through the optional/nullable/default wrappers declared around it. */
+export declare function fieldLabel(schema: z.ZodType): FieldLabel | undefined;
+/** A field, labelled. The label carries into the JSON Schema; validation is unchanged. */
+export declare function labelled<T extends z.ZodType>(schema: T, label: FieldLabel<EnumValue<T>>): T;
+export {};

package/dist/labelled.js

@@ -0,0 +1,22 @@
+import { z } from "zod";
+import { isObject } from "@temelyos/core/object";
+// 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 });
+}
+export { fieldLabel, labelled };

package/dist/language-code.d.ts

@@ -0,0 +1,10 @@
+import { z } from "zod";
+/**
+ * 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.
+ */
+export declare function languageCode(message: string, whenEmpty?: string): z.ZodString;

package/dist/language-code.js

@@ -0,0 +1,15 @@
+import { z } from "zod";
+import { isLanguageCode } from "@temelyos/core/i18n";
+// 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);
+}
+export { languageCode };

package/dist/localized-string.d.ts

@@ -0,0 +1,75 @@
+import { z } from "zod";
+/** Text in each language, by language code: `{ en: 'Sales', fr: 'Ventes' }`. */
+export type LocalizedString = Record<string, string>;
+export type LocalizedStringArray = Record<string, string[]>;
+/**
+ * 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.
+ */
+export declare const LocalizedString: z.ZodRecord<z.ZodString, z.ZodString>;
+export declare const LocalizedStringArray: z.ZodRecord<z.ZodString, z.ZodArray<z.ZodString>>;
+/** As {@link LocalizedString}, or a plain string — what a write model takes for a localized field. */
+export declare const LocalizedStringInput: z.ZodUnion<readonly [z.ZodString, z.ZodRecord<z.ZodString, z.ZodString>]>;
+export declare const LocalizedStringArrayInput: z.ZodUnion<readonly [z.ZodArray<z.ZodString>, z.ZodRecord<z.ZodString, z.ZodArray<z.ZodString>>]>;
+export type LocalizedStringArrayInput = z.infer<typeof LocalizedStringArrayInput>;
+export type LocalizedStringInput = z.infer<typeof LocalizedStringInput>;
+/** What a localized field says when it has no text, and when what came is not text at all. */
+export interface LocalizedStringMessages {
+  invalid: string;
+  /** `false` when no text is an answer: absent, `null` and blank then all read as unset. */
+  missing: false | string;
+}
+/**
+ * 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.
+ */
+export declare function hasLocalizedText(value: unknown): boolean;
+/** Whether a localized value is at most `max` characters, as a string or in every language it names. */
+export declare function isLocalizedTextWithin(value: unknown, max: number): boolean;
+/**
+ * A form's localized field — a record, one entry per language — that needs text in some language.
+ *
+ * The messages are the CALLER's, as `hexString24`'s are: "Name is required." belongs to the form
+ * asking for a name.
+ *
+ * One message answers for every case. `{ missing, invalid }` tells them apart: `missing` for no
+ * text at all — absent, `null`, or blank in every language — and `invalid` for a value that is
+ * there but is not text.
+ *
+ * `{ missing: false, invalid }` is the field that may be left empty: absent, `null` and blank
+ * pass through as they came, so the repository can tell a clear from a field left alone.
+ */
+export declare function localizedString(messages?: string | {
+  invalid: string;
+  missing: string;
+}): typeof LocalizedString;
+export declare function localizedString(messages: {
+  invalid: string;
+  missing: false;
+}): z.ZodOptional<z.ZodNullable<typeof LocalizedString>>;
+/**
+ * A model's localized field — a record or a plain string — that needs text in some language, with
+ * {@link localizedString}'s forms and messages; on a `partial()` update model, whenever it is sent.
+ * The refine guards the endpoint only: repository writes skip refines.
+ */
+export declare function localizedStringInput(messages?: string | {
+  invalid: string;
+  missing: string;
+}): typeof LocalizedStringInput;
+export declare function localizedStringInput(messages: {
+  invalid: string;
+  missing: false;
+}): z.ZodOptional<z.ZodNullable<typeof LocalizedStringInput>>;
+/**
+ * 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.
+ */
+export declare function findUncheckedLocalizedFields(models: Record<string, unknown>): string[];

package/dist/localized-string.js

@@ -0,0 +1,80 @@
+import { z } from "zod";
+// 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();
+}
+export { LocalizedString, LocalizedStringArray, LocalizedStringArrayInput, LocalizedStringInput, findUncheckedLocalizedFields, hasLocalizedText, isLocalizedTextWithin, localizedString, localizedStringInput };

package/dist/merge.d.ts

@@ -0,0 +1,14 @@
+import { ZodObject, ZodRawShape, ZodType, ZodUnion } from "zod";
+/**
+ * Recursively merges two ZodRawShape objects into a single shape,
+ * combining overlapping keys into unions where applicable.
+ */
+export type ZodMergeShapes<T extends ZodRawShape, U extends ZodRawShape> = { [K in keyof T | keyof U]: K extends keyof T & keyof U ? T[K] extends ZodObject<ZodRawShape> ? U[K] extends ZodObject<ZodRawShape> ? ZodObject<ZodMergeShapes<T[K]['shape'], U[K]['shape']>> : T[K] | U[K] : T[K] | U[K] : K extends keyof T ? T[K] : K extends keyof U ? U[K] : never; };
+/**
+ * Adds a Zod type to an existing ZodUnion.
+ */
+export declare function addToUnion<TUnion extends ZodUnion, TAny extends ZodType>(union: TUnion, object: TAny): ZodUnion;
+/**
+ * Deeply merges two ZodRawShape objects into one.
+ */
+export declare function mergeShapes<T extends ZodRawShape, U extends ZodRawShape>(shapeA: T, shapeB: U): ZodMergeShapes<T, U>;

package/dist/merge.js

@@ -0,0 +1,26 @@
+import { isZodObject } from "./utilities.js";
+import { z } from "zod";
+// 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;
+}
+export { addToUnion, mergeShapes };

package/dist/nullish.d.ts

@@ -0,0 +1,2 @@
+import { z } from "zod";
+export declare function nullish<TShape extends Record<string, z.ZodType>>(fields: z.ZodObject<TShape>): z.ZodObject<{ -readonly [P in keyof { [TKey in keyof TShape]: z.ZodOptional<z.ZodNullable<TShape[TKey]>>; }]: { [TKey in keyof TShape]: z.ZodOptional<z.ZodNullable<TShape[TKey]>>; }[P]; }, z.core.$strip>;

package/dist/nullish.js

@@ -0,0 +1,7 @@
+import { z } from "zod";
+import { mapValues } from "@temelyos/core/object";
+// src/nullish.ts
+function nullish(fields) {
+	return z.object(mapValues(fields.shape, (field) => field.nullish()));
+}
+export { nullish };

package/dist/positional-paths.d.ts

@@ -0,0 +1,22 @@
+import { ZodType } from "zod";
+/**
+ * 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.
+ */
+export declare function isFollowablePath(schema: ZodType, path: string): boolean;
+/**
+ * `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.
+ */
+export declare function toAllPositionalPath(schema: ZodType, path: string): string;
+/**
+ * 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.
+ */
+export declare function toFieldPath(schema: ZodType, path: string): string;

package/dist/positional-paths.js

@@ -0,0 +1,99 @@
+import { unwrapField } from "./field-paths.js";
+import { isZodArray, isZodObject, isZodRecord, isZodType, isZodUnion } from "./utilities.js";
+import { isInteger } from "@temelyos/core/number";
+// 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(".");
+}
+export { isFollowablePath, toAllPositionalPath, toFieldPath };

package/dist/reg-exp-pattern.d.ts

@@ -0,0 +1,2 @@
+import { z } from "zod";
+export declare const RegExpPattern: z.ZodString;

package/dist/reg-exp-pattern.js

@@ -0,0 +1,5 @@
+import { z } from "zod";
+import { isValidPattern } from "@temelyos/core/reg-exp";
+// src/reg-exp-pattern.ts
+const RegExpPattern = z.string().refine(isValidPattern, "Invalid regular expression.");
+export { RegExpPattern };

package/dist/slug.d.ts

@@ -0,0 +1,5 @@
+import { z } from "zod";
+/** 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. */
+export declare function slug(missing?: string): z.ZodString;
+/** A slug with nothing said about an empty value beyond what any other wrong value gets. */
+export declare const Slug: z.ZodString;

package/dist/slug.js

@@ -0,0 +1,15 @@
+import { z } from "zod";
+import { SlugPattern } from "@temelyos/core/string";
+// 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();
+export { Slug, slug };

package/dist/strip-empty-fields.d.ts

@@ -0,0 +1,2 @@
+import { ZodType, z } from "zod";
+export declare function stripEmptyFields<T extends ZodType>(schema: T, values: z.input<T>): z.infer<T>;

package/dist/strip-empty-fields.js

@@ -0,0 +1,46 @@
+import { getInnerType, isFieldOptional, isZodObject } from "./utilities.js";
+import { ZodLiteral } from "zod";
+import { isPlainObject } from "@temelyos/core/object";
+// 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;
+}
+export { stripEmptyFields };

package/dist/strip-to-schema.d.ts

@@ -0,0 +1,7 @@
+import { z } from "zod";
+/**
+ * `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.
+ */
+export declare function stripToSchema<T extends z.ZodObject>(schema: T, value: object): z.output<T>;