alepha 0.22.0 → 0.24.0

package/dist/core/index.browser.js

@@ -1,8 +1,5 @@
-import { Type } from "typebox";
-import Format from "typebox/format";
-import { Settings } from "typebox/system";
-import { Compile } from "typebox/compile";
-import * as Value from "typebox/value";
+import { z as z$1 } from "zod";
+import enLocale from "zod/v4/locales/en.js";
 import { createMiddleware as createMiddleware$1 } from "alepha";
 //#region ../../src/core/constants/KIND.ts
 /**
@@ -60,6 +57,316 @@ var TooLateSubstitutionError = class extends AlephaError {
 	}
 };
 //#endregion
+//#region ../../src/core/providers/zodAugment.ts
+const alias = (ctor, name, target) => {
+	const proto = ctor?.prototype;
+	if (!proto || Object.getOwnPropertyDescriptor(proto, name)) return;
+	Object.defineProperty(proto, name, {
+		configurable: true,
+		get() {
+			return this[target];
+		}
+	});
+};
+alias(z$1.ZodObject, "properties", "shape");
+alias(z$1.ZodArray, "items", "element");
+alias(z$1.ZodUnion, "anyOf", "options");
+{
+	const proto = z$1.ZodTuple?.prototype;
+	if (proto && !Object.getOwnPropertyDescriptor(proto, "items")) Object.defineProperty(proto, "items", {
+		configurable: true,
+		get() {
+			return this?._zod?.def?.items ?? [];
+		}
+	});
+}
+//#endregion
+//#region ../../src/core/providers/ZodProvider.ts
+z$1.config(enLocale());
+/** Defaults mirroring TypeProvider's static length caps. */
+const Z_LIMITS = {
+	short: 64,
+	regular: 255,
+	long: 1024,
+	rich: 65535,
+	arrayMaxItems: 1e3
+};
+/** Attach metadata + default without changing the schema's inferred type. */
+const meta = (schema, options) => {
+	if (!options) return schema;
+	const { default: def, ...rest } = options;
+	let s = schema;
+	if (def !== void 0) s = s.default(def);
+	if (Object.keys(rest).length > 0) s = s.meta(rest);
+	return s;
+};
+const applyString = (base, o) => {
+	let s = base;
+	if (o?.minLength != null) s = s.min(o.minLength);
+	if (o?.maxLength != null) s = s.max(o.maxLength);
+	if (o?.pattern) s = s.regex(typeof o.pattern === "string" ? new RegExp(o.pattern) : o.pattern);
+	return s;
+};
+/** zod's native `.format` getter (uuid/email/safeint/…), guarded. */
+const nativeFmt = (s) => {
+	try {
+		return s?.format ?? void 0;
+	} catch {
+		return;
+	}
+};
+/**
+* Read the JSON-Schema-style format tag off a schema (drives ORM columns).
+* Prefers our normalized `.meta({ format })` (typebox vocab: `date-time`,
+* `int64`, `binary`, …) and falls back to zod's native `.format`.
+*/
+const fmt = (s) => {
+	try {
+		return s?.meta?.()?.format ?? nativeFmt(s);
+	} catch {
+		return;
+	}
+};
+/** zod's internal type discriminator (`string` | `number` | …), wrapping-safe. */
+const defType = (s) => s?._zod?.def?.type;
+/** Tag a string-format schema with its JSON-Schema `format` (stays a real `ZodString`). */
+const strFmt = (base, format) => meta(base, { format });
+const z = {
+	/**
+	* Native zod coercion namespace (`z.coerce.number()`, `z.coerce.boolean()`…).
+	* Used at the HTTP/string boundary (query, headers, env) where everything
+	* arrives as a string; request bodies and the ORM stay strict (no coercion).
+	*/
+	coerce: z$1.coerce,
+	object: z$1.object,
+	array: z$1.array,
+	record: z$1.record,
+	tuple: z$1.tuple,
+	union: z$1.union,
+	string: z$1.string,
+	number: z$1.number,
+	boolean: z$1.boolean,
+	null: z$1.null,
+	any: z$1.any,
+	void: z$1.void,
+	undefined: z$1.undefined,
+	literal: z$1.literal,
+	/** Alias for `zod.literal` (legacy `t.const`). */
+	const: z$1.literal,
+	enum: z$1.enum,
+	/** Integer — native `z.int()` (format `safeint`, drives PG INT column). */
+	integer: z$1.int,
+	/** Free-form JSON object (`Record<string, any>`). */
+	json: () => z$1.record(z$1.string(), z$1.any()),
+	text: (options = {}) => {
+		const { size = "regular", trim = true, lowercase = false, maxLength, ...rest } = options;
+		const max = maxLength ?? Z_LIMITS[size] ?? Z_LIMITS.regular;
+		let s = z$1.string().max(max);
+		if (trim) s = s.trim();
+		if (lowercase) s = s.toLowerCase();
+		return meta(applyString(s, rest), {
+			...rest,
+			maxLength: max,
+			"~options": {
+				trim,
+				lowercase
+			}
+		});
+	},
+	shortText: (options = {}) => z.text({
+		...options,
+		size: "short"
+	}),
+	longText: (options = {}) => z.text({
+		...options,
+		size: "long"
+	}),
+	richText: (options = {}) => z.text({
+		...options,
+		size: "rich"
+	}),
+	email: () => strFmt(z$1.email(), "email"),
+	uuid: () => strFmt(z$1.guid(), "uuid"),
+	url: () => strFmt(z$1.url(), "url"),
+	datetime: () => strFmt(z$1.iso.datetime(), "date-time"),
+	date: () => strFmt(z$1.iso.date(), "date"),
+	time: () => strFmt(z$1.iso.time(), "time"),
+	/** bigint as a validated string (no codec). */
+	bigint: () => strFmt(z$1.string().regex(/^-?\d+$/), "bigint"),
+	binary: () => strFmt(z$1.string(), "binary"),
+	duration: () => strFmt(z$1.string(), "duration"),
+	e164: () => z.text({ pattern: "^\\+[1-9]\\d{1,14}$" }),
+	bcp47: () => z.text({ pattern: "^[a-z]{2,3}(?:-[A-Z]{2})?$" }),
+	constantCase: () => z.text({ pattern: "^[A-Z_-]+$" }),
+	int32: () => z$1.int().min(-2147483648).max(2147483647),
+	int64: () => z$1.int().min(-9007199254740991).max(9007199254740991).meta({ format: "int64" }),
+	file: (options) => z$1.any().meta({
+		format: "binary",
+		...options
+	}),
+	stream: () => z$1.any().meta({ format: "stream" }),
+	valueLabel: () => z$1.object({
+		value: z.constantCase(),
+		label: z.text(),
+		description: z.longText().optional()
+	}),
+	/** Pagination wrapper, mirrors `pageSchema(item)`. */
+	page: (item) => z$1.object({
+		content: z$1.array(item),
+		page: z$1.object({
+			number: z$1.int(),
+			size: z$1.int(),
+			offset: z$1.int(),
+			numberOfElements: z$1.int(),
+			totalElements: z$1.int().optional(),
+			totalPages: z$1.int().optional(),
+			isEmpty: z$1.boolean(),
+			isFirst: z$1.boolean(),
+			isLast: z$1.boolean()
+		})
+	}),
+	/** Export a schema to JSON Schema (OpenAPI / form generation). */
+	toJSONSchema: z$1.toJSONSchema,
+	/** Runtime type guards (`z.schema.*`) — schema introspection for ORM + forms. */
+	schema: {
+		isOptional: (s) => s instanceof z$1.ZodOptional,
+		isDefault: (s) => s instanceof z$1.ZodDefault,
+		isObject: (s) => s instanceof z$1.ZodObject,
+		isString: (s) => defType(s) === "string",
+		isNumber: (s) => defType(s) === "number",
+		isBoolean: (s) => s instanceof z$1.ZodBoolean,
+		isArray: (s) => s instanceof z$1.ZodArray,
+		isUnion: (s) => s instanceof z$1.ZodUnion,
+		isNull: (s) => s instanceof z$1.ZodNull,
+		isRecord: (s) => s instanceof z$1.ZodRecord,
+		isEnum: (s) => s instanceof z$1.ZodEnum,
+		isLiteral: (s) => s instanceof z$1.ZodLiteral,
+		isAny: (s) => s instanceof z$1.ZodAny,
+		isNullable: (s) => s instanceof z$1.ZodNullable,
+		isInteger: (s) => defType(s) === "number" && nativeFmt(s) === "safeint",
+		isText: (s) => defType(s) === "string" && !fmt(s),
+		isDateTime: (s) => fmt(s) === "date-time",
+		isDate: (s) => fmt(s) === "date",
+		isTime: (s) => fmt(s) === "time",
+		isBigInt: (s) => fmt(s) === "bigint",
+		isUuid: (s) => fmt(s) === "uuid",
+		isEmail: (s) => fmt(s) === "email",
+		isUrl: (s) => fmt(s) === "url",
+		isBinary: (s) => fmt(s) === "binary",
+		isUUID: (s) => fmt(s) === "uuid",
+		isScalar: (s) => s instanceof z$1.ZodString || s instanceof z$1.ZodNumber || s instanceof z$1.ZodBoolean || s instanceof z$1.ZodNull || s instanceof z$1.ZodLiteral || s instanceof z$1.ZodEnum || s instanceof z$1.ZodDate,
+		isSchema: (s) => s instanceof z$1.ZodType,
+		isTuple: (s) => s instanceof z$1.ZodTuple,
+		isUndefined: (s) => s instanceof z$1.ZodUndefined,
+		isUnsafe: (s) => s instanceof z$1.ZodAny || s instanceof z$1.ZodUnknown,
+		isVoid: (s) => s instanceof z$1.ZodVoid,
+		format: (s) => fmt(s),
+		/** The string values of a `ZodEnum` (typebox-compat for `value.enum`). */
+		enumValues: (s) => {
+			const opts = s?.options;
+			if (Array.isArray(opts)) return opts;
+			const entries = s?._zod?.def?.entries;
+			return entries ? Object.values(entries) : [];
+		},
+		/** Peel optional / nullable / default wrappers to the inner schema. */
+		unwrap: (s) => {
+			let cur = s;
+			while (cur instanceof z$1.ZodOptional || cur instanceof z$1.ZodNullable || cur instanceof z$1.ZodDefault) cur = typeof cur.unwrap === "function" ? cur.unwrap() : cur?._zod?.def?.innerType;
+			return cur;
+		},
+		/**
+		* Read a schema's default value (peeling optional/nullable wrappers), or
+		* `undefined` if there is none. In zod, defaults are a `ZodDefault` wrapper
+		* (not a `default` data property as in typebox), so `"default" in schema`
+		* is NOT a valid test — every schema has a `.default()` method.
+		*/
+		getDefault: (s) => {
+			if (s && Object.hasOwn(s, "default")) return s.default;
+			let cur = s;
+			while (cur) {
+				if (cur instanceof z$1.ZodDefault) {
+					const dv = cur?._zod?.def?.defaultValue;
+					return typeof dv === "function" ? dv() : dv;
+				}
+				if (cur instanceof z$1.ZodOptional || cur instanceof z$1.ZodNullable) {
+					cur = cur.unwrap();
+					continue;
+				}
+				return;
+			}
+		},
+		/** typebox-compat: the object's required (non-optional) field names. */
+		requiredKeys: (s) => {
+			const shape = s?.shape;
+			return shape ? Object.keys(shape).filter((k) => !(shape[k] instanceof z$1.ZodOptional)) : [];
+		}
+	}
+};
+//#endregion
+//#region ../../src/core/providers/TypeProvider.ts
+/**
+* TypeProvider — now a thin compatibility shim over `z` (zod 4).
+*
+* typebox is gone. `t` is just `z`, and the legacy `T*` type names are
+* re-aliased to their zod equivalents so existing call-sites keep compiling
+* while they are migrated to `z` / `Infer`.
+*/
+/** Raw zod namespace (legacy `Type` escape hatch). */
+const Type = z$1;
+/** Legacy `TypeProvider` — kept for its static config knobs. */
+var TypeProvider = class {
+	static DEFAULT_STRING_MAX_LENGTH = 255;
+	static DEFAULT_SHORT_STRING_MAX_LENGTH = 64;
+	static DEFAULT_LONG_STRING_MAX_LENGTH = 1024;
+	static DEFAULT_RICH_STRING_MAX_LENGTH = 65535;
+	static DEFAULT_ARRAY_MAX_ITEMS = 1e3;
+	static translateError = (error, _locale) => error.message ?? "";
+	static setLocale = (_locale) => {};
+	static isValidBigInt = (value) => typeof value === "number" ? Number.isInteger(value) : /^-?\d+$/.test(value.trim());
+};
+//#endregion
+//#region ../../src/core/helpers/coerceStrings.ts
+/**
+* Coerce a single string value coming from a string-only boundary (HTTP query,
+* HTTP headers, environment variables) to the JS type its schema declares.
+*
+* This is the zod-standard `z.coerce` behavior applied only at the edges where
+* inputs are inherently strings — request bodies and the ORM stay strict. A
+* value that cannot be coerced is returned unchanged so the subsequent
+* validation produces a proper rejection. Arrays coerce element-wise.
+*/
+const coerceScalar = (schema, value) => {
+	const base = z.schema.unwrap(schema);
+	if (z.schema.isArray(base) && Array.isArray(value)) {
+		const element = base.element;
+		return value.map((v) => coerceScalar(element, v));
+	}
+	if (z.schema.isString(base) && (typeof value === "number" || typeof value === "boolean")) return String(value);
+	if (typeof value !== "string") return value;
+	if (z.schema.isInteger(base) || z.schema.isNumber(base)) {
+		const n = Number(value);
+		return value.trim() !== "" && !Number.isNaN(n) ? n : value;
+	}
+	if (z.schema.isBoolean(base)) {
+		if (value === "true") return true;
+		if (value === "false") return false;
+		return value;
+	}
+	return value;
+};
+/**
+* Coerce each declared field of an object against its object schema. Used to
+* normalize string-only boundary maps (env vars, query objects) before strict
+* validation. Undeclared keys are passed through untouched.
+*/
+const coerceObject = (schema, value) => {
+	const shape = schema?.shape;
+	if (!shape) return value;
+	const out = { ...value };
+	for (const key of Object.keys(shape)) if (out[key] != null) out[key] = coerceScalar(shape[key], out[key]);
+	return out;
+};
+//#endregion
 //#region ../../src/core/errors/MissingContextError.ts
 var MissingContextError = class extends AlephaError {
 	name = "MissingContextError";
@@ -374,6 +681,24 @@ var AlsProvider = class AlsProvider {
 			current = current[ALS_PARENT];
 		}
 	}
+	/**
+	* Return the raw ALS layer object that owns `key`, walking from the
+	* current layer up through parent forks — the same resolution order as
+	* the default-scope branch of {@link get}. Returns `undefined` when no
+	* active ALS layer (current or any ancestor) has the key.
+	*
+	* Used by `StateManager.register()` to decode a value in place, in
+	* whichever fork layer it physically lives, instead of flattening
+	* fork-scoped state into the app-level store.
+	*/
+	getLayer(key) {
+		if (!this.als) return;
+		let current = this.als.getStore();
+		while (current) {
+			if (key in current) return current;
+			current = current[ALS_PARENT];
+		}
+	}
 	has(key) {
 		if (!this.als) return false;
 		const store = this.als.getStore();
@@ -516,458 +841,6 @@ var HookPrimitive = class extends Primitive {
 };
 $hook[KIND] = HookPrimitive;
 //#endregion
-//#region ../../src/core/helpers/FileLike.ts
-const isTypeFile = (value) => {
-	return value && typeof value === "object" && "format" in value && value.format === "binary";
-};
-const isFileLike = (value) => {
-	return !!value && typeof value === "object" && !Array.isArray(value) && typeof value.name === "string" && typeof value.type === "string" && typeof value.size === "number" && typeof value.stream.bind(value) === "function";
-};
-//#endregion
-//#region ../../src/core/providers/TypeProvider.ts
-Settings.Set({ correctiveParse: true });
-var TypeGuard = class {
-	isBigInt = (value) => Type.IsString(value) && "format" in value && value.format === "bigint";
-	isUUID = (value) => Type.IsString(value) && "format" in value && value.format === "uuid";
-	isObject = Type.IsObject;
-	isNumber = Type.IsNumber;
-	isString = Type.IsString;
-	isBoolean = Type.IsBoolean;
-	isAny = Type.IsAny;
-	isArray = Type.IsArray;
-	isOptional = Type.IsOptional;
-	isUnion = Type.IsUnion;
-	isInteger = Type.IsInteger;
-	isNull = Type.IsNull;
-	isUndefined = Type.IsUndefined;
-	isUnsafe = Type.IsUnsafe;
-	isRecord = Type.IsRecord;
-	isTuple = Type.IsTuple;
-	isVoid = Type.IsVoid;
-	isLiteral = Type.IsLiteral;
-	isSchema = Type.IsSchema;
-	isScalar = (schema) => this.isString(schema) || this.isNumber(schema) || this.isInteger(schema) || this.isBoolean(schema);
-	isFile = isTypeFile;
-	isDateTime = (schema) => {
-		return t.schema.isString(schema) && schema.format === "date-time";
-	};
-	isDate = (schema) => {
-		return t.schema.isString(schema) && schema.format === "date";
-	};
-	isTime = (schema) => {
-		return t.schema.isString(schema) && schema.format === "time";
-	};
-	isDuration = (schema) => {
-		return t.schema.isString(schema) && schema.format === "duration";
-	};
-};
-var TypeProvider = class TypeProvider {
-	static format = Format;
-	static {
-		Format.Set("bigint", (value) => TypeProvider.isValidBigInt(value));
-	}
-	static translateError(error, _locale) {
-		return error.cause.message;
-	}
-	static setLocale(_locale) {}
-	static isValidBigInt(value) {
-		if (typeof value === "number") return Number.isInteger(value);
-		if (!value.trim()) return false;
-		if (!/^-?\d+$/.test(value)) return false;
-		try {
-			BigInt(value);
-			return true;
-		} catch {
-			return false;
-		}
-	}
-	/**
-	* Default maximum length for strings.
-	*
-	* It can be set to a larger value:
-	* ```ts
-	* TypeProvider.DEFAULT_STRING_MAX_LENGTH = 1000000;
-	* TypeProvider.DEFAULT_STRING_MAX_LENGTH = undefined; // no limit (not recommended)
-	* ```
-	*/
-	static DEFAULT_STRING_MAX_LENGTH = 255;
-	/**
-	* Maximum length for short strings, such as names or titles.
-	*/
-	static DEFAULT_SHORT_STRING_MAX_LENGTH = 64;
-	/**
-	* Maximum length for long strings, such as descriptions or comments.
-	* It can be overridden in the string options.
-	*
-	* It can be set to a larger value:
-	* ```ts
-	* TypeProvider.DEFAULT_LONG_STRING_MAX_LENGTH = 2048;
-	* ```
-	*/
-	static DEFAULT_LONG_STRING_MAX_LENGTH = 1024;
-	/**
-	* Maximum length for rich strings, such as HTML or Markdown.
-	* This is a large value to accommodate rich text content.
-	* > It's also the maximum length of PG's TEXT type.
-	*
-	* It can be overridden in the string options.
-	*
-	* It can be set to a larger value:
-	* ```ts
-	* TypeProvider.DEFAULT_RICH_STRING_MAX_LENGTH = 1000000;
-	* ```
-	*/
-	static DEFAULT_RICH_STRING_MAX_LENGTH = 65535;
-	/**
-	* Maximum number of items in an array.
-	* This is a default value to prevent excessive memory usage.
-	* It can be overridden in the array options.
-	*/
-	static DEFAULT_ARRAY_MAX_ITEMS = 1e3;
-	raw = Type;
-	any = Type.Any;
-	void = Type.Void;
-	undefined = Type.Undefined;
-	record = Type.Record;
-	union = Type.Union;
-	tuple = Type.Tuple;
-	null = Type.Null;
-	const = Type.Literal;
-	options = Type.Options;
-	/**
-	* Type guards to check the type of schema.
-	* This is not a runtime type check, but a compile-time type guard.
-	*
-	* @example
-	* ```ts
-	* if (t.schema.isString(schema)) {
-	*   // schema is TString
-	* }
-	* ```
-	*/
-	schema = new TypeGuard();
-	extend(schema, properties, options) {
-		return Type.Interface(Array.isArray(schema) ? schema : [schema], properties, {
-			additionalProperties: false,
-			...options
-		});
-	}
-	pick(schema, keys, options) {
-		return Type.Pick(schema, keys, {
-			additionalProperties: false,
-			...options
-		});
-	}
-	omit(schema, keys, options) {
-		return Type.Omit(schema, keys, {
-			additionalProperties: false,
-			...options
-		});
-	}
-	partial(schema, options) {
-		return Type.Partial(schema, {
-			additionalProperties: false,
-			...options
-		});
-	}
-	/**
-	* Create a schema for an object.
-	* By default, additional properties are not allowed.
-	*
-	* @example
-	* ```ts
-	* const userSchema = t.object({
-	*   id: t.integer(),
-	*   name: t.string(),
-	* });
-	* ```
-	*/
-	object(properties, options) {
-		return Type.Object(properties, {
-			additionalProperties: false,
-			...options
-		});
-	}
-	/**
-	* Create a schema for an array.
-	* By default, the maximum number of items is limited to prevent excessive memory usage.
-	*
-	* @see TypeProvider.DEFAULT_ARRAY_MAX_ITEMS
-	*/
-	array(schema, options) {
-		return Type.Array(schema, {
-			maxItems: TypeProvider.DEFAULT_ARRAY_MAX_ITEMS,
-			...options
-		});
-	}
-	/**
-	* Create a schema for a string.
-	* For db or input fields, consider using `t.text()` instead, which has length limits.
-	*
-	* If you need a string with specific format (e.g. email, uuid), consider using the corresponding method (e.g. `t.email()`, `t.uuid()`).
-	*/
-	string(options = {}) {
-		return Type.String({ ...options });
-	}
-	/**
-	* Create a schema for a string with length limits.
-	* For internal strings without length limits, consider using `t.string()` instead.
-	*
-	* Default size is "regular", which has a max length of 255 characters.
-	*/
-	text(options = {}) {
-		const { size, ...rest } = options;
-		const maxLength = size === "short" ? TypeProvider.DEFAULT_SHORT_STRING_MAX_LENGTH : size === "long" ? TypeProvider.DEFAULT_LONG_STRING_MAX_LENGTH : size === "rich" ? TypeProvider.DEFAULT_RICH_STRING_MAX_LENGTH : TypeProvider.DEFAULT_STRING_MAX_LENGTH;
-		return Type.String({
-			maxLength,
-			"~options": {
-				trim: options.trim ?? true,
-				lowercase: options.lowercase ?? false
-			},
-			...rest
-		});
-	}
-	/**
-	* Create a schema for a JSON object.
-	* This is a record with string keys and any values.
-	*/
-	json(options) {
-		return t.record(t.text(), t.any(), options);
-	}
-	/**
-	* Create a schema for a boolean.
-	*/
-	boolean(options) {
-		return Type.Boolean({ ...options });
-	}
-	/**
-	* Create a schema for a number.
-	*/
-	number(options) {
-		return Type.Number({ ...options });
-	}
-	/**
-	* Create a schema for an integer.
-	*/
-	integer(options) {
-		return Type.Integer({ ...options });
-	}
-	int32(options) {
-		return Type.Integer({
-			minimum: -2147483648,
-			maximum: 2147483647,
-			...options
-		});
-	}
-	/**
-	* Mimic a signed 64-bit integer.
-	*
-	* This is NOT a true int64, as JavaScript cannot represent all int64 values.
-	* It is a number that is an integer and between -9007199254740991 and 9007199254740991.
-	* Use `t.bigint()` for true int64 values represented as strings.
-	*/
-	int64(options) {
-		return Type.Number({
-			format: "int64",
-			multipleOf: 1,
-			minimum: -9007199254740991,
-			maximum: 9007199254740991,
-			...options
-		});
-	}
-	/**
-	* Make a schema optional.
-	*/
-	optional(schema) {
-		return Type.Optional(schema);
-	}
-	/**
-	* Make a schema nullable.
-	*/
-	nullable(schema, options) {
-		return Type.Union([Type.Null(), schema], options);
-	}
-	/**
-	* Create a schema that maps all properties of an object schema to nullable.
-	*/
-	nullify = (schema, options) => Type.Mapped(Type.Identifier("K"), Type.KeyOf(schema), Type.Ref("K"), Type.Union([Type.Index(schema, Type.Ref("K")), Type.Null()]), options);
-	/**
-	* Create a schema for a string enum.
-	*
-	* By default, this creates a real PostgreSQL ENUM type in the database.
-	* Use `{ mode: "text" }` to store as a TEXT column instead.
-	*
-	* @example
-	* ```ts
-	* // PostgreSQL ENUM type (default)
-	* status: t.enum(["pending", "active", "archived"])
-	*
-	* // TEXT column
-	* status: t.enum(["pending", "active", "archived"], { mode: "text" })
-	*
-	* // Shared enum name across tables
-	* status: t.enum(["enabled", "disabled"], { name: "shared_status_enum" })
-	* ```
-	*/
-	enum(values, options) {
-		const { mode, name, ...textOptions } = options ?? {};
-		const schema = Type.Unsafe(t.text({
-			enum: values,
-			pattern: values.map((v) => `^${v}$`).join("|"),
-			...textOptions
-		}));
-		if (mode === "text") Object.assign(schema, { mode: "text" });
-		else Object.assign(schema, { enumName: name });
-		return schema;
-	}
-	/**
-	* Create a schema for a bigint represented as a string.
-	* This is a string that validates bigint format (e.g. "123456789").
-	*/
-	bigint(options) {
-		return t.string({
-			...options,
-			format: "bigint"
-		});
-	}
-	/**
-	* Create a schema for a URL represented as a string.
-	*/
-	url(options) {
-		return this.string({
-			...options,
-			format: "url"
-		});
-	}
-	/**
-	* Create a schema for binary data represented as a base64 string.
-	*/
-	binary(options = {}) {
-		return this.string({
-			...options,
-			format: "binary"
-		});
-	}
-	/**
-	* Create a schema for uuid.
-	*/
-	uuid(options) {
-		return this.string({
-			...options,
-			format: "uuid"
-		});
-	}
-	/**
-	* Create a schema for a file-like object.
-	*
-	* File like mimics the File API in browsers, but is adapted to work in Node.js as well.
-	*
-	* Implementation of file-like objects is handled by "alepha/file" package.
-	*/
-	file(options) {
-		return Type.Unsafe(Type.Any({
-			[OPTIONS]: options,
-			format: "binary"
-		}));
-	}
-	/**
-	* @experimental
-	*/
-	stream() {
-		return Type.Unsafe(Type.Any({
-			format: "stream",
-			type: "string"
-		}));
-	}
-	email(options) {
-		return this.text({
-			...options,
-			format: "email",
-			trim: true,
-			lowercase: true
-		});
-	}
-	e164(options) {
-		return this.text({
-			...options,
-			description: "Phone number in E.164 format, e.g. +1234567890.",
-			pattern: "^\\+[1-9]\\d{1,14}$"
-		});
-	}
-	bcp47(options) {
-		return this.text({
-			...options,
-			description: "BCP 47 language tag, e.g. en, en-US, fr, fr-CA.",
-			pattern: "^[a-z]{2,3}(?:-[A-Z]{2})?$"
-		});
-	}
-	/**
-	* Create a schema for short text, such as names or titles.
-	* Default max length is 64 characters.
-	*/
-	shortText(options) {
-		return this.text({
-			size: "short",
-			...options
-		});
-	}
-	/**
-	* Create a schema for long text, such as descriptions or comments.
-	* Default max length is 1024 characters.
-	*/
-	longText(options) {
-		return this.text({
-			size: "long",
-			...options
-		});
-	}
-	/**
-	* Create a schema for rich text, such as HTML or Markdown.
-	* Default max length is 65535 characters.
-	*/
-	richText(options) {
-		return this.text({
-			size: "rich",
-			...options
-		});
-	}
-	/**
-	* Create a schema for a constant case string e.g. LIKE_THIS.
-	*/
-	constantCase = (options) => this.text({
-		pattern: "^[A-Z_-]+$",
-		...options
-	});
-	/**
-	* Create a schema for an object with a value and label.
-	*/
-	valueLabel = (options) => this.object({
-		value: this.constantCase({ description: "Machine-readable value." }),
-		label: this.text({ description: "Human-readable label." }),
-		description: this.optional(this.text({
-			description: "Description of the value.",
-			size: "long"
-		}))
-	}, options);
-	datetime = (options) => t.text({
-		...options,
-		format: "date-time"
-	});
-	date = (options) => t.text({
-		...options,
-		format: "date"
-	});
-	time = (options) => t.text({
-		...options,
-		format: "time"
-	});
-	duration = (options) => t.text({
-		...options,
-		format: "duration"
-	});
-};
-const t = new TypeProvider();
-//#endregion
 //#region ../../src/core/providers/KeylessJsonSchemaCodec.ts
 /**
 * KeylessJsonSchemaCodec provides schema-driven JSON encoding without keys.
@@ -1085,14 +958,14 @@ var KeylessJsonSchemaCodec = class extends SchemaCodec {
 	}
 	interpretEncode(schema, value) {
 		if (this.isLeaf(schema)) return value;
-		if (t.schema.isBigInt(schema)) return `${value}n`;
-		if (t.schema.isArray(schema)) {
+		if (z.schema.isBigInt(schema)) return `${value}n`;
+		if (z.schema.isArray(schema)) {
 			const arrSchema = schema;
 			if (!Array.isArray(value)) return value;
-			if (t.schema.isScalar(arrSchema.items)) return value;
+			if (z.schema.isScalar(arrSchema.items)) return value;
 			return value.map((e) => this.interpretEncode(arrSchema.items, e));
 		}
-		if (t.schema.isObject(schema)) {
+		if (z.schema.isObject(schema)) {
 			const result = [];
 			for (const { key, isOpt, isNullable, inner } of this.getObjectFields(schema)) {
 				const v = value[key];
@@ -1102,7 +975,7 @@ var KeylessJsonSchemaCodec = class extends SchemaCodec {
 			}
 			return result;
 		}
-		if (t.schema.isOptional(schema) || t.schema.isUnion(schema)) {
+		if (z.schema.isOptional(schema) || z.schema.isUnion(schema)) {
 			const inner = this.unwrap(schema);
 			if (this.isNullable(schema)) return value !== null ? this.interpretEncode(inner, value) : null;
 			return value !== void 0 ? this.interpretEncode(inner, value) : null;
@@ -1111,15 +984,15 @@ var KeylessJsonSchemaCodec = class extends SchemaCodec {
 	}
 	interpretDecode(schema, ctx) {
 		if (this.isLeaf(schema)) return ctx.arr[ctx.i++];
-		if (t.schema.isBigInt(schema)) return BigInt(ctx.arr[ctx.i++].slice(0, -1));
-		if (t.schema.isArray(schema)) {
+		if (z.schema.isBigInt(schema)) return BigInt(ctx.arr[ctx.i++].slice(0, -1));
+		if (z.schema.isArray(schema)) {
 			const arrSchema = schema;
 			const arr = ctx.arr[ctx.i++];
 			if (!Array.isArray(arr)) return arr;
-			if (t.schema.isObject(arrSchema.items)) return arr.map((e) => this.interpretDecodeFromValue(arrSchema.items, e));
+			if (z.schema.isObject(arrSchema.items)) return arr.map((e) => this.interpretDecodeFromValue(arrSchema.items, e));
 			return arr;
 		}
-		if (t.schema.isObject(schema)) {
+		if (z.schema.isObject(schema)) {
 			const result = {};
 			for (const { key, isOpt, isNullable, inner } of this.getObjectFields(schema)) {
 				const val = ctx.arr[ctx.i++];
@@ -1130,37 +1003,37 @@ var KeylessJsonSchemaCodec = class extends SchemaCodec {
 			}
 			return result;
 		}
-		if (t.schema.isOptional(schema) || t.schema.isUnion(schema)) {
+		if (z.schema.isOptional(schema) || z.schema.isUnion(schema)) {
 			const inner = this.unwrap(schema);
 			const val = ctx.arr[ctx.i++];
 			if (val === null) return this.isNullable(schema) ? null : void 0;
-			if (t.schema.isObject(inner) || t.schema.isArray(inner)) return this.interpretDecodeFromValue(inner, val);
+			if (z.schema.isObject(inner) || z.schema.isArray(inner)) return this.interpretDecodeFromValue(inner, val);
 			return val;
 		}
 		return ctx.arr[ctx.i++];
 	}
 	interpretDecodeFromValue(schema, value) {
 		if (this.isLeaf(schema)) return value;
-		if (t.schema.isBigInt(schema)) return BigInt(value.slice(0, -1));
-		if (t.schema.isArray(schema)) {
+		if (z.schema.isBigInt(schema)) return BigInt(value.slice(0, -1));
+		if (z.schema.isArray(schema)) {
 			if (!Array.isArray(value)) return value;
 			const arrSchema = schema;
-			if (t.schema.isObject(arrSchema.items)) return value.map((e) => this.interpretDecodeFromValue(arrSchema.items, e));
+			if (z.schema.isObject(arrSchema.items)) return value.map((e) => this.interpretDecodeFromValue(arrSchema.items, e));
 			return value;
 		}
-		if (t.schema.isObject(schema)) {
+		if (z.schema.isObject(schema)) {
 			const props = schema.properties;
 			const keys = Object.keys(props);
 			const result = {};
 			for (let idx = 0; idx < keys.length; idx++) {
 				const k = keys[idx];
 				const prop = props[k];
-				const isOpt = t.schema.isOptional(prop);
+				const isOpt = z.schema.isOptional(prop);
 				const inner = this.unwrap(prop);
 				const v = value[idx];
 				if (isOpt && v === null) continue;
-				if (t.schema.isObject(inner)) result[k] = this.interpretDecodeFromValue(inner, v);
-				else if (t.schema.isBigInt(inner)) result[k] = BigInt(v.slice(0, -1));
+				if (z.schema.isObject(inner)) result[k] = this.interpretDecodeFromValue(inner, v);
+				else if (z.schema.isBigInt(inner)) result[k] = BigInt(v.slice(0, -1));
 				else result[k] = v;
 			}
 			return result;
@@ -1169,14 +1042,14 @@ var KeylessJsonSchemaCodec = class extends SchemaCodec {
 	}
 	genEnc(schema, ve) {
 		if (this.isLeaf(schema)) return ve;
-		if (t.schema.isBigInt(schema)) return `${ve}+'n'`;
-		if (t.schema.isArray(schema)) {
+		if (z.schema.isBigInt(schema)) return `${ve}+'n'`;
+		if (z.schema.isArray(schema)) {
 			const arrSchema = schema;
 			const itemEnc = this.genEnc(arrSchema.items, "e");
-			if (t.schema.isScalar(arrSchema.items)) return ve;
+			if (z.schema.isScalar(arrSchema.items)) return ve;
 			return `${ve}.map(e=>${itemEnc})`;
 		}
-		if (t.schema.isObject(schema)) {
+		if (z.schema.isObject(schema)) {
 			const parts = [];
 			for (const { key, isOpt, isNullable, inner } of this.getObjectFields(schema)) {
 				const access = `${ve}[${JSON.stringify(key)}]`;
@@ -1187,7 +1060,7 @@ var KeylessJsonSchemaCodec = class extends SchemaCodec {
 			}
 			return `[${parts.join(",")}]`;
 		}
-		if (t.schema.isOptional(schema) || t.schema.isUnion(schema)) {
+		if (z.schema.isOptional(schema) || z.schema.isUnion(schema)) {
 			const inner = this.unwrap(schema);
 			const innerEnc = this.genEnc(inner, ve);
 			if (this.isNullable(schema)) return `${ve}!==null?${innerEnc}:null`;
@@ -1201,13 +1074,13 @@ var KeylessJsonSchemaCodec = class extends SchemaCodec {
 			code: "",
 			result: "a[i++]"
 		};
-		if (t.schema.isBigInt(schema)) return {
+		if (z.schema.isBigInt(schema)) return {
 			code: "",
 			result: "BigInt(a[i++].slice(0,-1))"
 		};
-		if (t.schema.isArray(schema)) {
+		if (z.schema.isArray(schema)) {
 			const arrSchema = schema;
-			if (t.schema.isObject(arrSchema.items)) return {
+			if (z.schema.isObject(arrSchema.items)) return {
 				code: "",
 				result: `a[i++].map(e=>${this.genDecFromValue(arrSchema.items, "e")})`
 			};
@@ -1216,9 +1089,9 @@ var KeylessJsonSchemaCodec = class extends SchemaCodec {
 				result: "a[i++]"
 			};
 		}
-		if (t.schema.isObject(schema)) {
+		if (z.schema.isObject(schema)) {
 			const fields = this.getObjectFields(schema);
-			if (fields.every(({ isOpt, isNullable, inner }) => !isOpt && !isNullable && !t.schema.isObject(inner) && !t.schema.isArray(inner))) return {
+			if (fields.every(({ isOpt, isNullable, inner }) => !isOpt && !isNullable && !z.schema.isObject(inner) && !z.schema.isArray(inner))) return {
 				code: "",
 				result: `{${fields.map(({ key }) => `${JSON.stringify(key)}:a[i++]`).join(",")}}`
 			};
@@ -1231,12 +1104,12 @@ var KeylessJsonSchemaCodec = class extends SchemaCodec {
 				} else if (isNullable) {
 					const nested = this.genDecFromValue(inner, "t");
 					code += `{const t=a[i++];if(t===null){${v}[${sk}]=null;}else{${v}[${sk}]=${nested};}}`;
-				} else if (t.schema.isObject(inner)) {
+				} else if (z.schema.isObject(inner)) {
 					const nested = this.genDecFromValue(inner, "a[i++]");
 					code += `${v}[${sk}]=${nested};`;
-				} else if (t.schema.isArray(inner)) {
+				} else if (z.schema.isArray(inner)) {
 					const arrSchema = inner;
-					if (t.schema.isObject(arrSchema.items)) {
+					if (z.schema.isObject(arrSchema.items)) {
 						const itemTransform = this.genDecFromValue(arrSchema.items, "e");
 						code += `${v}[${sk}]=a[i++].map(e=>${itemTransform});`;
 					} else code += `${v}[${sk}]=a[i++];`;
@@ -1247,7 +1120,7 @@ var KeylessJsonSchemaCodec = class extends SchemaCodec {
 				result: v
 			};
 		}
-		if (t.schema.isOptional(schema) || t.schema.isUnion(schema)) {
+		if (z.schema.isOptional(schema) || z.schema.isUnion(schema)) {
 			const inner = this.unwrap(schema);
 			const innerDec = this.genDec(inner);
 			return {
@@ -1262,16 +1135,16 @@ var KeylessJsonSchemaCodec = class extends SchemaCodec {
 	}
 	genDecFromValue(schema, expr) {
 		if (this.isLeaf(schema)) return expr;
-		if (t.schema.isBigInt(schema)) return `BigInt(${expr}.slice(0,-1))`;
-		if (t.schema.isArray(schema)) {
+		if (z.schema.isBigInt(schema)) return `BigInt(${expr}.slice(0,-1))`;
+		if (z.schema.isArray(schema)) {
 			const items = schema.items;
-			if (t.schema.isObject(items) || t.schema.isBigInt(items)) {
+			if (z.schema.isObject(items) || z.schema.isBigInt(items)) {
 				const v = this.nextVar();
 				return `${expr}.map(${v}=>${this.genDecFromValue(items, v)})`;
 			}
 			return expr;
 		}
-		if (t.schema.isObject(schema)) {
+		if (z.schema.isObject(schema)) {
 			const props = schema.properties;
 			const keys = Object.keys(props);
 			const v = this.nextVar();
@@ -1279,24 +1152,24 @@ var KeylessJsonSchemaCodec = class extends SchemaCodec {
 				const inner = this.unwrap(props[k]);
 				const innerExpr = `${v}[${idx}]`;
 				const sk = JSON.stringify(k);
-				if (t.schema.isObject(inner)) return `${sk}:${this.genDecFromValue(inner, innerExpr)}`;
-				if (t.schema.isBigInt(inner)) return `${sk}:BigInt(${innerExpr}.slice(0,-1))`;
+				if (z.schema.isObject(inner)) return `${sk}:${this.genDecFromValue(inner, innerExpr)}`;
+				if (z.schema.isBigInt(inner)) return `${sk}:BigInt(${innerExpr}.slice(0,-1))`;
 				return `${sk}:${innerExpr}`;
 			}).join(",")}}))()`;
 		}
 		return expr;
 	}
 	isLeaf(schema) {
-		return t.schema.isScalar(schema) || this.isEnum(schema);
+		return z.schema.isScalar(schema) || this.isEnum(schema);
 	}
 	getObjectFields(schema) {
 		const props = schema.properties;
-		const req = new Set(schema.required || []);
+		const req = new Set(z.schema.requiredKeys(schema));
 		return Object.keys(props).map((key) => {
 			const ps = props[key];
 			return {
 				key,
-				isOpt: !req.has(key) || t.schema.isOptional(ps),
+				isOpt: !req.has(key) || z.schema.isOptional(ps),
 				isNullable: this.isNullable(ps),
 				inner: this.unwrap(ps)
 			};
@@ -1306,26 +1179,39 @@ var KeylessJsonSchemaCodec = class extends SchemaCodec {
 		return "enum" in schema && Array.isArray(schema.enum) && (schema.enum?.length ?? 0) > 0;
 	}
 	isNullable(schema) {
-		if (!t.schema.isUnion(schema)) return false;
-		return schema.anyOf?.some((s) => t.schema.isNull(s)) ?? false;
+		let cur = schema;
+		while (cur) {
+			if (z.schema.isNullable(cur)) return true;
+			if (z.schema.isOptional(cur) && typeof cur.unwrap === "function") {
+				cur = cur.unwrap();
+				continue;
+			}
+			break;
+		}
+		if (z.schema.isUnion(schema)) return schema.anyOf?.some((s) => z.schema.isNull(s)) ?? false;
+		return false;
 	}
 	unwrap(schema) {
-		if ("anyOf" in schema && Array.isArray(schema.anyOf)) return schema.anyOf.find((s) => !t.schema.isNull(s)) || schema;
-		return schema;
+		const peeled = z.schema.unwrap(schema);
+		if (z.schema.isUnion(peeled)) {
+			const unionSchema = peeled;
+			if (Array.isArray(unionSchema.anyOf)) return unionSchema.anyOf.find((s) => !z.schema.isNull(s)) || peeled;
+		}
+		return peeled;
 	}
 	/**
 	* Reconstruct an object from a parsed array (for when input is already parsed).
 	*/
 	reconstructObject(schema, arr) {
-		if (!t.schema.isObject(schema)) return arr;
+		if (!z.schema.isObject(schema)) return arr;
 		const result = {};
 		let i = 0;
 		for (const { key, isOpt, isNullable, inner } of this.getObjectFields(schema)) {
 			const val = arr[i++];
 			if (isOpt) {
-				if (val !== null) result[key] = t.schema.isObject(inner) ? this.reconstructObject(inner, val) : val;
-			} else if (isNullable) result[key] = val === null ? null : t.schema.isObject(inner) ? this.reconstructObject(inner, val) : val;
-			else result[key] = t.schema.isObject(inner) ? this.reconstructObject(inner, val) : val;
+				if (val !== null) result[key] = z.schema.isObject(inner) ? this.reconstructObject(inner, val) : val;
+			} else if (isNullable) result[key] = val === null ? null : z.schema.isObject(inner) ? this.reconstructObject(inner, val) : val;
+			else result[key] = z.schema.isObject(inner) ? this.reconstructObject(inner, val) : val;
 		}
 		return result;
 	}
@@ -1344,7 +1230,7 @@ var TypeBoxError = class extends AlephaError {
 			message: "must be defined"
 		};
 		else this.value = {
-			path: error.instancePath,
+			path: error.instancePath ?? "",
 			message: error.message
 		};
 		this.cause = error;
@@ -1352,93 +1238,42 @@ var TypeBoxError = class extends AlephaError {
 };
 //#endregion
 //#region ../../src/core/providers/SchemaValidator.ts
+/**
+* Validates + coerces a value against a zod schema.
+*
+* Trimming / lowercasing / defaults / unknown-key stripping all live in the
+* schema itself now (zod), so this is a thin wrapper over `schema.parse`.
+* No typebox `Compile`, no `eval` — safe inside Cloudflare Workers.
+*/
 var SchemaValidator = class {
-	cache = /* @__PURE__ */ new Map();
-	useEval = true;
-	/**
-	* Validate the value against the provided schema.
-	*
-	* Validation create a new value by applying some preprocessing. (e.g., trimming text)
-	*/
-	validate(schema, value, options = {}) {
-		const newValue = this.beforeParse(schema, value, {
-			trim: options.trim ?? true,
-			nullToUndefined: options.nullToUndefined ?? true,
-			deleteUndefined: options.deleteUndefined ?? true
-		});
-		try {
-			if (!this.useEval) return Value.Parse(schema, newValue);
-			return this.getValidator(schema).Parse(newValue);
-		} catch (error) {
-			if (error.cause?.errors?.[0]) throw new TypeBoxError(error.cause.errors[0]);
-			throw error;
+	validate(schema, value, _options = {}) {
+		const result = schema.safeParse(value);
+		if (!result.success) {
+			const issue = result.error.issues[0];
+			const path = issue?.path?.length ? issue.path.join("/") : "";
+			let message = issue?.message ?? "Validation failed";
+			if (issue?.code === "invalid_type" && /received undefined/i.test(message) && path) message = `'${path}' is required`;
+			throw new TypeBoxError({
+				message,
+				instancePath: path ? `/${path}` : "",
+				params: issue
+			});
 		}
+		return result.data;
 	}
-	/**
-	* Deep clone a schema. Useful when a schema is going to be mutated.
-	*/
-	clone(schema) {
-		return Value.Clone(schema);
-	}
-	getValidator(schema) {
-		if (this.cache.has(schema)) return this.cache.get(schema);
-		const validator = Compile(schema);
-		this.cache.set(schema, validator);
-		return validator;
+	safeValidate(schema, value) {
+		return schema.safeParse(value);
 	}
-	/**
-	* Preprocess the value based on the schema before validation.
-	*
-	* - If the value is `null` and the schema does not allow `null`, it converts it to `undefined`.
-	* - If the value is a string and the schema has a `~options.trim` flag, it trims whitespace from the string.
-	*/
-	beforeParse(schema, value, options) {
-		if (!schema) return value;
-		if (value === null && !this.isSchemaNullable(schema) && options.nullToUndefined) return;
-		if (!schema.type && schema.anyOf) schema = schema.anyOf.find((s) => s.type !== "null" && s.type !== "undefined") || schema;
-		if (Array.isArray(value)) return value.map((it) => this.beforeParse(schema.items, it, options));
-		if (typeof value === "string" && schema.type === "string") {
-			let str = value;
-			if (options.trim && schema["~options"]?.trim) str = str.trim();
-			if (schema["~options"]?.lowercase) str = str.toLowerCase();
-			return str;
-		}
-		if (typeof value === "object" && value !== null && schema.type === "object") {
-			const obj = {};
-			for (const key in value) {
-				const newValue = this.beforeParse(schema.properties?.[key], value[key], options);
-				if (newValue === void 0 && options.deleteUndefined) continue;
-				obj[key] = newValue;
-			}
-			return obj;
-		}
-		return value;
+	/** Zod schemas are immutable — clone is a pass-through. */
+	clone(schema) {
+		return schema;
 	}
 	/**
-	* Used by `beforeParse` to determine if a schema allows null values.
+	* Legacy pre-processing entry point. Coercion now happens inside `parse`,
+	* so this is a no-op kept for call-site compatibility.
 	*/
-	isSchemaNullable = (schema) => {
-		if (!schema) return false;
-		if (schema.type === "null") return true;
-		if (Array.isArray(schema.type) && schema.type.includes("null")) return true;
-		if (schema.anyOf) return schema.anyOf.some((it) => this.isSchemaNullable(it));
-		if (schema.oneOf) return schema.oneOf.some((it) => this.isSchemaNullable(it));
-		if (schema.allOf) return schema.allOf.some((it) => this.isSchemaNullable(it));
-		return false;
-	};
-	onConfigure = $hook({
-		on: "configure",
-		handler: () => {
-			this.useEval = this.canEval();
-		}
-	});
-	canEval() {
-		try {
-			Compile(t.object({ test: t.string() })).Parse({ test: "value" });
-			return true;
-		} catch {
-			return false;
-		}
+	beforeParse(_schema, value, _options) {
+		return value;
 	}
 };
 //#endregion
@@ -1742,16 +1577,16 @@ var EventManager = class {
 * You control how state is structured and validated.
 *
 * Features:
-* - Set a schema for validation
-* - Set a default value for initial state
-* - Rules, like read-only, custom validation, etc.
-* - Automatic getter access in services with {@link $use}
+* - Schema validation on every write (invalid writes throw)
+* - Default value for initial state
+* - Automatic getter access in services with {@link $state}
 * - SSR support (server state automatically serialized and hydrated on client)
-* - React integration (useAtom hook for automatic component re-renders)
-* - Middleware
-* - Persistence adapters (localStorage, Redis, database, file system, cookie, etc.)
-* - State migrations (version upgrades when schema changes)
-* - Documentation generation & devtools integration
+* - React integration (useStore / useSelector hooks for automatic re-renders)
+* - Derived values with {@link $computed} (useComputed hook)
+* - Persistence adapters: cookie (SSR-safe), localStorage, sessionStorage
+* - `serverOnly` flag to keep an atom out of the hydration payload
+* - reset / watch helpers on the state manager
+* - Documentation generation & devtools integration (mutation log)
 *
 * Common use cases:
 * - user preferences
@@ -1764,6 +1599,7 @@ var EventManager = class {
 * If you need to store complex data, consider using identifiers or references instead.
 */
 const $atom = (options) => {
+	if (options.serverOnly && options.persist) throw new AlephaError(`Atom "${options.name}" declares both serverOnly and persist: "${options.persist}", which is a contradiction: serverOnly only guarantees exclusion from the SSR hydration payload, while every persist adapter (cookie, localStorage, sessionStorage) targets the browser by definition — cookie persistence ships the value in a Set-Cookie response header, and web-storage persistence IS the browser. Combining them silently leaks the value through the persistence channel instead of the hydration payload. Remove \`serverOnly\` or \`persist\` from atom "${options.name}".`);
 	return new Atom(options);
 };
 var Atom = class {
@@ -1780,11 +1616,108 @@ var Atom = class {
 };
 $atom[KIND] = "atom";
 //#endregion
+//#region ../../src/core/primitives/$computed.ts
+/**
+* Define a derived, read-only value computed from one or more atoms
+* (or other computed values).
+*
+* Dependencies are declared statically, which keeps the data flow explicit
+* and lets subscribers know exactly which mutations invalidate the value.
+*
+* Computed values are never stored, serialized, hydrated, or persisted —
+* they are recomputed from their dependencies on every read, so they are
+* always correct inside request-scoped (fork) state on the server.
+*
+* ```ts
+* const cartTotal = $computed({
+*   name: "cartTotal",
+*   deps: [cartAtom],
+*   get: (cart) => cart.items.reduce((sum, it) => sum + it.price, 0),
+* });
+*
+* alepha.store.get(cartTotal); // number
+* ```
+*
+* ### Footgun: a `serverOnly` dependency breaks hydration
+*
+* A computed whose deps include a `serverOnly` atom will NOT agree across the
+* SSR boundary. `serverOnly` keeps the atom out of the hydration payload, so
+* the server derives the value from the atom's real value while the browser
+* re-derives it from the atom's *default* — React then hydrates a DOM that
+* does not match the markup it received (a hydration mismatch, and a
+* silently wrong value afterwards).
+*
+* Either keep the computed server-side only (read it via `alepha.store.get`,
+* never through `useComputed`), or derive it from atoms that ship to the
+* browser. Note this cuts the other way too: if the value is safe to send to
+* the browser, the dependency should not have been `serverOnly` to begin
+* with.
+*/
+const $computed = (options) => {
+	return new Computed(options);
+};
+var Computed = class Computed {
+	options;
+	constructor(options) {
+		this.options = options;
+	}
+	get key() {
+		return this.options.name;
+	}
+	/**
+	* Reentrancy guard for {@link keys}. Deps are declared as a `readonly`
+	* array at construction time, so a cycle can't be built through the
+	* public API — but the array itself isn't frozen, so nothing stops a
+	* caller from reaching in and creating one anyway. Without this guard,
+	* a cycle would recurse until the JS engine throws a native
+	* `RangeError`, which violates the repo's "never throw a bare `Error`"
+	* convention.
+	*/
+	resolvingKeys = false;
+	/**
+	* Reentrancy guard for {@link compute}, same rationale as
+	* {@link resolvingKeys}.
+	*/
+	computing = false;
+	/**
+	* Transitive atom keys this computed value depends on. Subscribers
+	* (useComputed, StateManager.watch) use this to know which `state:mutate`
+	* events invalidate the value.
+	*/
+	keys() {
+		if (this.resolvingKeys) throw new AlephaError(`Circular $computed dependency detected at "${this.key}". A computed cannot depend on itself, even transitively.`);
+		this.resolvingKeys = true;
+		try {
+			const out = [];
+			for (const dep of this.options.deps) if (dep instanceof Computed) out.push(...dep.keys());
+			else out.push(dep.key);
+			return [...new Set(out)];
+		} finally {
+			this.resolvingKeys = false;
+		}
+	}
+	/**
+	* Resolve the value using the given dependency resolver.
+	*/
+	compute(resolve) {
+		if (this.computing) throw new AlephaError(`Circular $computed dependency detected at "${this.key}". A computed cannot depend on itself, even transitively.`);
+		this.computing = true;
+		try {
+			const values = this.options.deps.map(resolve);
+			return this.options.get(...values);
+		} finally {
+			this.computing = false;
+		}
+	}
+};
+$computed[KIND] = "computed";
+//#endregion
 //#region ../../src/core/providers/StateManager.ts
 var StateManager = class {
 	als = $inject(AlsProvider);
 	events = $inject(EventManager);
 	codec = $inject(JsonSchemaCodec);
+	validator = $inject(SchemaValidator);
 	atoms = /* @__PURE__ */ new Map();
 	store = {};
 	constructor(store = {}) {
@@ -1804,12 +1737,14 @@ var StateManager = class {
 		const exported = {};
 		if (scope === "current") {
 			if (this.als?.exists()) for (const atom of this.atoms.values()) {
+				if (atom.options.serverOnly) continue;
 				const value = this.als.get(atom.key, "current");
 				if (value !== void 0) exported[atom.key] = value;
 			}
 			return exported;
 		}
 		for (const [key, atom] of this.atoms.entries()) {
+			if (atom.options.serverOnly) continue;
 			const value = this.get(atom, scope);
 			if (value !== void 0) exported[key] = value;
 		}
@@ -1830,15 +1765,172 @@ var StateManager = class {
 		});
 		return atoms;
 	}
+	/**
+	* Return the registered atom for a state key, if any.
+	*/
+	getAtom(key) {
+		return this.atoms.get(key);
+	}
+	/**
+	* Every atom registered so far, whatever store layer (if any) currently
+	* holds its value.
+	*
+	* This is the order-independent way to discover atoms. The
+	* `"state:register"` event fires exactly once per key and `EventManager`
+	* has no replay buffer, so a service instantiated after an atom registered
+	* never hears about it — a real hazard, since `$module.register()`
+	* registers `atoms[]` BEFORE it wires `imports[]` and injects `services[]`.
+	* Services that act on atoms (e.g. the cookie persistence adapter) must
+	* read this registry on demand rather than build their own map from the
+	* event.
+	*/
+	listAtoms() {
+		return [...this.atoms.values()];
+	}
 	register(atom) {
+		if (atom instanceof Computed) throw new AlephaError(`Cannot register computed value "${atom.key}" as an atom. Computed values are derived from their dependencies on every read — they are never stored, serialized, hydrated, or persisted. Register its dependency atoms instead.`);
 		const key = atom.key;
-		if (!this.atoms.has(key)) {
-			this.atoms.set(key, atom);
-			if (!(key in this.store)) this.set(key, atom.options.default, { skipContext: true });
-		}
+		if (this.atoms.has(key)) return this;
+		this.atoms.set(key, atom);
+		const layer = this.als?.getLayer(key);
+		if (layer) this.decodeExisting(atom, key, layer);
+		if (key in this.store) this.decodeExisting(atom, key, this.store);
+		else this.seedDefault(atom, key);
+		this.bindWebStorage(atom);
+		this.events?.emit("state:register", { atom }, { catch: true }).catch(() => null);
 		return this;
 	}
+	/**
+	* Install the atom's declared default into the app-level store.
+	*
+	* Deliberately bypasses {@link set}, for two reasons:
+	*
+	* 1. `set()` short-circuits when the new value equals the currently
+	*    *resolved* value (`prevValue === value` for non-objects) — inside a
+	*    fork that already holds the same primitive value, the app-store write
+	*    would simply never happen.
+	* 2. A registration seed is initialisation, NOT a mutation, so it must not
+	*    emit `state:mutate`. Persistence adapters listen on that event: an
+	*    atom registering lazily mid-request would otherwise emit a mutation
+	*    carrying its *default*, and the cookie adapter would dutifully write
+	*    it back as a `Set-Cookie` — overwriting the very cookie the request
+	*    arrived with.
+	*
+	* A `undefined` default (only reachable for an optional schema) is not
+	* written at all, so the key stays absent from the store — matching the
+	* previous behaviour of `set(key, undefined)`.
+	*/
+	seedDefault(atom, key) {
+		const value = this.cloneDefault(atom);
+		if (value === void 0) return;
+		this.store[key] = value;
+	}
+	/**
+	* A fresh, schema-validated copy of the atom's declared default.
+	*
+	* `atom.options.default` is a module-level object shared by every
+	* container and every request in the process. Handing that exact reference
+	* to the store would let an ordinary `store.mut(atom, s => ...)` mutate the
+	* declaration itself, permanently and process-wide. Every other write path
+	* round-trips through the validator (zod always returns a new object), so
+	* these must too.
+	*/
+	cloneDefault(atom) {
+		if (atom.options.default === void 0) return;
+		return this.validator.validate(atom.schema, atom.options.default);
+	}
+	/**
+	* Decode a value that already exists under an atom's key at registration
+	* time, in place, in whichever layer it physically lives (an ALS fork
+	* layer or the app store) — never flattening a fork-scoped value into the
+	* app-level store.
+	*
+	* On schema mismatch, falls back to the atom's default (written into that
+	* same layer) and emits a warning: a bad seed silently reverting a whole
+	* atom to its defaults should be visible, not indistinguishable from
+	* "nothing was ever set".
+	*/
+	decodeExisting(atom, key, layer) {
+		const current = layer[key];
+		if (current === void 0) return;
+		const result = this.validator.safeValidate(atom.schema, current);
+		if (result.success) {
+			layer[key] = result.data;
+			return;
+		}
+		this.logger?.warn(`Atom "${String(key)}" received an invalid seed value at registration, falling back to its default.`, { issues: result.error.issues });
+		layer[key] = this.cloneDefault(atom);
+	}
+	/**
+	* Web-storage persistence (localStorage / sessionStorage) for atoms
+	* declared with `persist`. Best-effort: quota errors and privacy modes
+	* are swallowed. Cookie persistence is NOT handled here — it needs the
+	* HTTP request cycle and lives in `alepha/server/cookies`
+	* (AtomCookiePersistence), which discovers its atoms through
+	* {@link listAtoms}. Both adapters are therefore registration-order
+	* independent: one `persist` option, one reliability contract.
+	*/
+	bindWebStorage(atom) {
+		const persist = atom.options.persist;
+		if (persist !== "localStorage" && persist !== "sessionStorage") return;
+		const storage = this.getWebStorage(persist);
+		if (!storage) {
+			this.logger?.warn(`Atom "${atom.key}" uses ${persist} persistence, which is unavailable in this environment. Use persist: "cookie" for SSR apps.`);
+			return;
+		}
+		const key = atom.key;
+		try {
+			const raw = storage.getItem(atom.key);
+			if (raw != null) {
+				const result = this.validator.safeValidate(atom.schema, JSON.parse(raw));
+				if (result.success) this.store[key] = result.data;
+				else this.safeRemoveItem(storage, atom.key);
+			}
+		} catch {
+			this.safeRemoveItem(storage, atom.key);
+		}
+		this.events.on("state:mutate", ({ key: mutatedKey, value }) => {
+			if (mutatedKey !== atom.key) return;
+			try {
+				if (value === void 0) storage.removeItem(atom.key);
+				else storage.setItem(atom.key, JSON.stringify(value));
+			} catch {}
+		});
+	}
+	/**
+	* Best-effort `Storage#removeItem`. Some privacy modes throw on every
+	* Storage method, including `removeItem` — this must never escape a
+	* recovery `catch`, or persistence stops being best-effort.
+	*/
+	safeRemoveItem(storage, key) {
+		try {
+			storage.removeItem(key);
+		} catch {}
+	}
+	/**
+	* Resolve a Web Storage area, or undefined when unavailable (server,
+	* privacy mode that throws on access).
+	*/
+	getWebStorage(kind) {
+		try {
+			if (typeof window === "undefined") return;
+			return kind === "localStorage" ? window.localStorage : window.sessionStorage;
+		} catch {
+			return;
+		}
+	}
+	/**
+	* Best-effort logger lookup. `StateManager` lives in `core`, which cannot
+	* depend on the logger module, so this reads the `"alepha.logger"` state
+	* key directly (set by `Alepha.create()`, see `Alepha.ts`) instead of
+	* injecting a logger service. May be `undefined` during early boot, before
+	* the logger is wired up — callers must stay null-safe.
+	*/
+	get logger() {
+		return this.get("alepha.logger");
+	}
 	get(target, scope) {
+		if (target instanceof Computed) return target.compute((dep) => this.get(dep, scope));
 		if (target instanceof Atom) this.register(target);
 		const key = target instanceof Atom ? target.key : target;
 		const store = this.store;
@@ -1846,9 +1938,12 @@ var StateManager = class {
 		return this.als?.exists() ? this.als.get(key, scope) ?? (scope ? void 0 : store[key]) : store[key];
 	}
 	set(target, value, options) {
+		if (target instanceof Computed) throw new AlephaError(`Cannot set computed value "${target.key}". Mutate its dependencies instead.`);
 		if (target instanceof Atom) this.register(target);
 		const key = target instanceof Atom ? target.key : target;
 		const store = this.store;
+		const atom = target instanceof Atom ? target : this.atoms.get(key);
+		if (atom && value !== void 0 && options?.skipValidation !== true) value = this.validator.validate(atom.schema, value);
 		const prevValue = this.get(key);
 		if (prevValue === value && typeof value !== "object") return this;
 		if (options?.skipContext !== true && this.als?.exists()) this.als.set(key, value);
@@ -1860,6 +1955,31 @@ var StateManager = class {
 		}, { catch: true }).catch(() => null);
 		return this;
 	}
+	/**
+	* Reset an atom back to its declared default value.
+	*/
+	reset(atom) {
+		this.register(atom);
+		return this.set(atom, atom.options.default);
+	}
+	watch(target, callback) {
+		if (target instanceof Computed) {
+			const keys = new Set(target.keys());
+			let prev = this.get(target);
+			return this.events.on("state:mutate", (ev) => {
+				if (!keys.has(ev.key)) return;
+				const next = this.get(target);
+				const last = prev;
+				prev = next;
+				callback(next, last);
+			});
+		}
+		if (target instanceof Atom) this.register(target);
+		const key = target instanceof Atom ? target.key : target;
+		return this.events.on("state:mutate", (ev) => {
+			if (ev.key === key) callback(ev.value, ev.prevValue);
+		});
+	}
 	mut(target, mutator) {
 		const updated = mutator(this.get(target));
 		return this.set(target, updated);
@@ -1962,8 +2082,8 @@ var StateManager = class {
 * // But you should use $env() primitive to get typed values from the environment.
 * class App {
 *   env = $env(
-*     t.object({
-*  	   MY_VAR: t.text(),
+*     z.object({
+*  	   MY_VAR: z.text(),
 *     })
 *   );
 * }
@@ -2182,6 +2302,13 @@ var Alepha = class Alepha {
 		return this;
 	}
 	/**
+	* Reset an atom back to its declared default value.
+	*/
+	reset(target) {
+		this.store.reset(target);
+		return this;
+	}
+	/**
 	* True when start() is called.
 	*
 	* -> No more services can be added, it's over, bye!
@@ -2505,7 +2632,7 @@ var Alepha = class Alepha {
 				if (!match.parents.includes(parent) && parent !== service) match.parents.push(parent);
 				return match.instance;
 			}
-			if (this.started) {
+			if (this.started && registry === this.registry) {
 				const mod = service[MODULE]?.name;
 				throw new ContainerLockedError(`Container is locked. No more services can be added. Attempted to inject '${service.name}' from '${parent?.name}'. ${mod ? `Module '${mod}' is not registered ?` : ""}`);
 			}
@@ -2566,7 +2693,7 @@ var Alepha = class Alepha {
 	*/
 	parseEnv(schema) {
 		if (this.cacheEnv.has(schema)) return this.cacheEnv.get(schema);
-		const config = this.codec.validate(schema, this.env);
+		const config = this.codec.validate(schema, coerceObject(schema, this.env));
 		const sortedKeys = Object.keys(config).sort((a, b) => b.length - a.length);
 		let changed = true;
 		for (let pass = 0; changed && pass < 10; pass++) {
@@ -2620,13 +2747,17 @@ var Alepha = class Alepha {
 		const env = {};
 		for (const [schema] of this.cacheEnv.entries()) {
 			const ref = schema;
-			for (const [key, value] of Object.entries(ref.properties)) {
+			const shape = ref.properties ?? {};
+			const required = new Set(z.schema.requiredKeys(ref));
+			for (const [key, value] of Object.entries(shape)) {
 				const prop = value;
+				const inner = z.schema.unwrap(prop);
+				const enumValues = z.schema.isEnum(inner) ? z.schema.enumValues(inner) : void 0;
 				env[key] = {
-					description: prop.description,
-					default: prop.default,
-					required: ref.required?.includes(key) ?? void 0,
-					enum: prop.enum ? [...prop.enum] : void 0
+					description: inner?.description ?? prop?.description,
+					default: z.schema.getDefault(prop),
+					required: required.has(key) ? true : void 0,
+					enum: enumValues?.length ? [...enumValues] : void 0
 				};
 			}
 		}
@@ -2761,222 +2892,86 @@ function createPagination(entities, limit = 10, offset = 0, sort) {
 	};
 }
 //#endregion
-//#region ../../src/core/helpers/jsonSchemaToTypeBox.ts
+//#region ../../src/core/helpers/FileLike.ts
+const isTypeFile = (value) => {
+	return !!value && typeof value === "object" && z.schema.format(value) === "binary";
+};
+const isFileLike = (value) => {
+	return !!value && typeof value === "object" && !Array.isArray(value) && typeof value.name === "string" && typeof value.type === "string" && typeof value.size === "number" && typeof value.stream.bind(value) === "function";
+};
+//#endregion
+//#region ../../src/core/helpers/jsonSchemaToZod.ts
 /**
-* Converts a JSON Schema object to a TypeBox schema using Alepha's type system.
-*
-* This is useful when receiving JSON Schema from an API (e.g., configuration schemas)
-* and needing to use them with TypeBox-based form rendering or validation.
-*
-* **Supports:**
-* - Basic types: string, number, integer, boolean, null, object, array
-* - String formats: email, uuid, date-time, date, time, url/uri, binary, bigint, duration, color
-* - Enums (string enums)
-* - Nested objects with required/optional properties
-* - Arrays with item schemas
-* - Common validation options: minLength, maxLength, minimum, maximum, pattern
-* - anyOf/oneOf/allOf with nullable patterns (e.g., `anyOf: [type, null]` → `t.nullable(type)`)
-* - Alepha ~options (trim, lowercase) pass-through
-*
-* **Not supported:**
-* - $ref (references)
-* - additionalProperties, patternProperties
-* - Complex composition schemas (multiple non-null types in anyOf/oneOf/allOf)
-*
-* @param schema - JSON Schema object to convert
-* @returns TypeBox TSchema
-*
-* @example
-* ```ts
-* const jsonSchema = {
-*   type: "object",
-*   properties: {
-*     email: { type: "string", format: "email" },
-*     age: { type: "integer", minimum: 0 },
-*     active: { type: "boolean" },
-*   },
-*   required: ["email"]
-* };
-*
-* const typeBoxSchema = jsonSchemaToTypeBox(jsonSchema);
-* // Equivalent to:
-* // t.object({
-* //   email: t.email(),
-* //   age: t.optional(t.integer({ minimum: 0 })),
-* //   active: t.optional(t.boolean()),
-* // })
-* ```
+* Convert a JSON Schema object into a zod schema (the inverse of
+* `z.toJSONSchema`). zod 4 has no native `fromJSONSchema`, so this provides the
+* round-trip needed by dynamic, schema-driven UIs (e.g. devtools forms built
+* from an entity's or action's published JSON Schema).
+*
+* Covers the JSON Schema subset Alepha emits: object/array/string (+formats),
+* number/integer, boolean, null, enum, and `anyOf`/`oneOf` (including the
+* nullable `anyOf: [..., { type: "null" }]` shape). Anything unrecognized falls
+* back to `z.any()`.
 */
-function jsonSchemaToTypeBox(schema) {
-	if (schema.const !== void 0) return t.const(schema.const);
-	if (schema.enum && Array.isArray(schema.enum)) {
-		if (schema.enum.every((v) => typeof v === "string")) return t.enum(schema.enum, filterUndefined({
-			title: schema.title,
-			description: schema.description,
-			default: schema.default
-		}));
-		return t.union(schema.enum.map((v) => t.const(v)));
-	}
-	if (schema.anyOf && Array.isArray(schema.anyOf)) {
-		const nullSchema = schema.anyOf.find((s) => s.type === "null");
-		const nonNullSchemas = schema.anyOf.filter((s) => s.type !== "null");
-		if (nullSchema && nonNullSchemas.length === 1) {
-			const converted = jsonSchemaToTypeBox(nonNullSchemas[0]);
-			return t.nullable(converted);
-		}
-		return t.union(schema.anyOf.map((s) => jsonSchemaToTypeBox(s)));
-	}
-	if (schema.allOf && Array.isArray(schema.allOf)) {
-		const nullSchema = schema.allOf.find((s) => s.type === "null");
-		const nonNullSchemas = schema.allOf.filter((s) => s.type !== "null");
-		if (nullSchema && nonNullSchemas.length === 1) {
-			const converted = jsonSchemaToTypeBox(nonNullSchemas[0]);
-			return t.nullable(converted);
-		}
-		if (nonNullSchemas.length > 0) return jsonSchemaToTypeBox(nonNullSchemas[0]);
-	}
-	if (schema.oneOf && Array.isArray(schema.oneOf)) {
-		const nullSchema = schema.oneOf.find((s) => s.type === "null");
-		const nonNullSchemas = schema.oneOf.filter((s) => s.type !== "null");
-		if (nullSchema && nonNullSchemas.length === 1) {
-			const converted = jsonSchemaToTypeBox(nonNullSchemas[0]);
-			return t.nullable(converted);
-		}
-		return t.union(schema.oneOf.map((s) => jsonSchemaToTypeBox(s)));
-	}
-	switch (Array.isArray(schema.type) ? schema.type[0] : schema.type) {
-		case "string": return convertString(schema);
-		case "number": return convertNumber(schema);
-		case "integer": return convertInteger(schema);
-		case "boolean": return convertBoolean(schema);
-		case "null": return t.null();
-		case "object": return convertObject(schema);
-		case "array": return convertArray(schema);
-		default:
-			if (schema.properties) return convertObject(schema);
-			return t.any();
+const jsonSchemaToZod = (schema) => {
+	if (!schema || typeof schema !== "object") return z.any();
+	const variants = schema.anyOf ?? schema.oneOf;
+	if (Array.isArray(variants) && variants.length > 0) {
+		const nonNull = variants.filter((v) => v?.type !== "null" && v !== null);
+		const nullable = nonNull.length !== variants.length;
+		const mapped = nonNull.map(jsonSchemaToZod);
+		let result = mapped.length === 1 ? mapped[0] : z.union(mapped);
+		if (nullable) result = result.nullable();
+		return result;
 	}
-}
-/**
-* Remove undefined values from an object.
-*/
-function filterUndefined(obj) {
-	return Object.fromEntries(Object.entries(obj).filter(([_, v]) => v !== void 0));
-}
-/**
-* Convert JSON Schema string type to TypeBox.
-*/
-function convertString(schema) {
-	const baseOptions = filterUndefined({
-		title: schema.title,
-		description: schema.description,
-		default: schema.default,
-		minLength: schema.minLength,
-		maxLength: schema.maxLength,
-		pattern: schema.pattern
-	});
-	const options = schema["~options"] ? {
-		...baseOptions,
-		"~options": schema["~options"]
-	} : baseOptions;
-	switch (schema.format) {
-		case "email": return t.email(options);
-		case "uuid": return t.uuid(options);
-		case "date-time": return t.datetime(options);
-		case "date": return t.date(options);
-		case "time": return t.time(options);
-		case "url":
-		case "uri": return t.url(options);
-		case "binary": return t.binary(options);
-		case "bigint": return t.bigint(options);
-		case "duration": return t.duration(options);
-		case "color": return t.text({
-			...options,
-			format: "color"
-		});
-		case "e164": return t.e164(options);
-		case "bcp47": return t.bcp47(options);
-		default:
-			if (schema.format) return t.string({
-				...options,
-				format: schema.format
-			});
-			return t.string(options);
+	if (Array.isArray(schema.enum) && schema.enum.length > 0) {
+		const values = schema.enum.filter((v) => typeof v === "string");
+		if (values.length === schema.enum.length) return z.enum(values);
+	}
+	switch (schema.type) {
+		case "object": {
+			const required = Array.isArray(schema.required) ? schema.required : [];
+			const shape = {};
+			for (const [key, value] of Object.entries(schema.properties ?? {})) {
+				const child = jsonSchemaToZod(value);
+				shape[key] = required.includes(key) ? child : child.optional();
+			}
+			return z.object(shape);
+		}
+		case "array": return z.array(jsonSchemaToZod(schema.items ?? {}));
+		case "string": {
+			switch (schema.format) {
+				case "uuid": return z.uuid();
+				case "email": return z.email();
+				case "url":
+				case "uri": return z.url();
+				case "date-time": return z.datetime();
+				case "date": return z.date();
+				case "time": return z.time();
+				case "binary": return z.binary();
+			}
+			let str = z.string();
+			if (typeof schema.minLength === "number") str = str.min(schema.minLength);
+			if (typeof schema.maxLength === "number") str = str.max(schema.maxLength);
+			if (typeof schema.pattern === "string") str = str.regex(new RegExp(schema.pattern));
+			return str;
+		}
+		case "integer": {
+			let int = z.integer();
+			if (typeof schema.minimum === "number") int = int.min(schema.minimum);
+			if (typeof schema.maximum === "number") int = int.max(schema.maximum);
+			return int;
+		}
+		case "number": {
+			let num = z.number();
+			if (typeof schema.minimum === "number") num = num.min(schema.minimum);
+			if (typeof schema.maximum === "number") num = num.max(schema.maximum);
+			return num;
+		}
+		case "boolean": return z.boolean();
+		case "null": return z.null();
+		default: return z.any();
 	}
-}
-/**
-* Convert JSON Schema number type to TypeBox.
-*/
-function convertNumber(schema) {
-	return t.number(filterUndefined({
-		title: schema.title,
-		description: schema.description,
-		default: schema.default,
-		minimum: schema.minimum,
-		maximum: schema.maximum,
-		exclusiveMinimum: schema.exclusiveMinimum,
-		exclusiveMaximum: schema.exclusiveMaximum,
-		multipleOf: schema.multipleOf
-	}));
-}
-/**
-* Convert JSON Schema integer type to TypeBox.
-*/
-function convertInteger(schema) {
-	return t.integer(filterUndefined({
-		title: schema.title,
-		description: schema.description,
-		default: schema.default,
-		minimum: schema.minimum,
-		maximum: schema.maximum,
-		exclusiveMinimum: schema.exclusiveMinimum,
-		exclusiveMaximum: schema.exclusiveMaximum,
-		multipleOf: schema.multipleOf
-	}));
-}
-/**
-* Convert JSON Schema boolean type to TypeBox.
-*/
-function convertBoolean(schema) {
-	return t.boolean(filterUndefined({
-		title: schema.title,
-		description: schema.description,
-		default: schema.default
-	}));
-}
-/**
-* Convert JSON Schema object type to TypeBox.
-*/
-function convertObject(schema) {
-	if (!schema.properties) return t.json(filterUndefined({
-		title: schema.title,
-		description: schema.description
-	}));
-	const required = new Set(schema.required ?? []);
-	const properties = {};
-	for (const [key, propSchema] of Object.entries(schema.properties)) {
-		let converted = jsonSchemaToTypeBox(propSchema);
-		if (!required.has(key)) converted = t.optional(converted);
-		properties[key] = converted;
-	}
-	return t.object(properties, filterUndefined({
-		title: schema.title,
-		description: schema.description
-	}));
-}
-/**
-* Convert JSON Schema array type to TypeBox.
-*/
-function convertArray(schema) {
-	const itemSchema = schema.items ? jsonSchemaToTypeBox(schema.items) : t.any();
-	return t.array(itemSchema, filterUndefined({
-		title: schema.title,
-		description: schema.description,
-		minItems: schema.minItems,
-		maxItems: schema.maxItems,
-		uniqueItems: schema.uniqueItems
-	}));
-}
+};
 //#endregion
 //#region ../../src/core/primitives/$env.ts
 /**
@@ -2995,8 +2990,8 @@ function convertArray(schema) {
 *   log = $logger();
 *
 *   // program expect a var env "HELLO" as string to works
-*   env = $env(t.object({
-*     HELLO: t.text()
+*   env = $env(z.object({
+*     HELLO: z.text()
 *   }));
 *
 *   sayHello = () => this.log.info("Hello ${this.env.HELLO}")
@@ -3007,7 +3002,7 @@ function convertArray(schema) {
 */
 const $env = (type) => {
 	const { alepha } = $context();
-	if (!t.schema.isObject(type)) throw new AlephaError("Type must be an TObject");
+	if (!z.schema.isObject(type)) throw new AlephaError("Type must be an TObject");
 	return alepha.parseEnv(type);
 };
 //#endregion
@@ -3253,7 +3248,7 @@ const $scope = () => {
 *
 * @example
 * ```ts
-* const userState = $atom({ schema: t.object({ name: t.text(), role: t.text() }) });
+* const userState = $atom({ schema: z.object({ name: z.text(), role: z.text() }) });
 *
 * class UserComponent {
 *   user = $state(userState); // Reactive reference to atom state
@@ -3275,39 +3270,30 @@ const $state = (atom) => {
 };
 //#endregion
 //#region ../../src/core/schemas/pageQuerySchema.ts
-const pageQuerySchema = t.object({
-	page: t.optional(t.integer({
-		description: "The page number to retrieve.",
-		minimum: 0,
-		default: 0
-	})),
-	size: t.optional(t.integer({
-		description: "The number of items per page.",
-		minimum: 1,
-		maximum: 100,
-		default: 10
-	})),
-	sort: t.optional(t.text({ description: "Sort by field(s). Multiple columns separated by comma. Prefix with '-' for DESC. Examples: 'name' (ASC), '-createdAt' (DESC), 'role,-name' (role ASC, name DESC)" }))
+const pageQuerySchema = z.object({
+	page: z.integer().min(0).describe("The page number to retrieve.").default(0).optional(),
+	size: z.integer().min(1).max(100).describe("The number of items per page.").default(10).optional(),
+	sort: z.text({ description: "Sort by field(s). Multiple columns separated by comma. Prefix with '-' for DESC. Examples: 'name' (ASC), '-createdAt' (DESC), 'role,-name' (role ASC, name DESC)" }).optional()
 });
 //#endregion
 //#region ../../src/core/schemas/pageSchema.ts
-const pageMetadataSchema = t.object({
-	number: t.integer({ description: "Page number, starting from 0" }),
-	size: t.integer({ description: "Number of items per page (requested page size)" }),
-	offset: t.integer({ description: "Offset in the dataset (page × size)" }),
-	numberOfElements: t.integer({ description: "Number of elements in THIS page (content.length). Different from totalElements which is the total across all pages." }),
-	totalElements: t.optional(t.integer({ description: "Total number of elements across all pages. Only available when counting is enabled." })),
-	totalPages: t.optional(t.integer({ description: "Total number of pages. Only available when `totalElements` is present." })),
-	isEmpty: t.boolean({ description: "Indicates if the current page has no items (numberOfElements === 0)" }),
-	isFirst: t.boolean({ description: "Indicates if this is the first page (number === 0)" }),
-	isLast: t.boolean({ description: "Indicates if this is the last page (no more pages after this)" }),
-	sort: t.optional(t.object({
-		sorted: t.boolean({ description: "Whether the results are sorted" }),
-		fields: t.array(t.object({
-			field: t.text({ description: "The field used for sorting" }),
-			direction: t.enum(["asc", "desc"], { description: "The direction of the sort. Either 'asc' or 'desc'" })
+const pageMetadataSchema = z.object({
+	number: z.integer().describe("Page number, starting from 0"),
+	size: z.integer().describe("Number of items per page (requested page size)"),
+	offset: z.integer().describe("Offset in the dataset (page × size)"),
+	numberOfElements: z.integer().describe("Number of elements in THIS page (content.length). Different from totalElements which is the total across all pages."),
+	totalElements: z.integer().describe("Total number of elements across all pages. Only available when counting is enabled.").optional(),
+	totalPages: z.integer().describe("Total number of pages. Only available when `totalElements` is present.").optional(),
+	isEmpty: z.boolean().describe("Indicates if the current page has no items (numberOfElements === 0)"),
+	isFirst: z.boolean().describe("Indicates if this is the first page (number === 0)"),
+	isLast: z.boolean().describe("Indicates if this is the last page (no more pages after this)"),
+	sort: z.object({
+		sorted: z.boolean().describe("Whether the results are sorted"),
+		fields: z.array(z.object({
+			field: z.text({ description: "The field used for sorting" }),
+			direction: z.enum(["asc", "desc"]).describe("The direction of the sort. Either 'asc' or 'desc'")
 		}))
-	}))
+	}).optional()
 });
 /**
 * Create a pagination schema for the given object schema.
@@ -3317,7 +3303,7 @@ const pageMetadataSchema = t.object({
 *
 * @example
 * ```ts
-* const userSchema = t.object({ id: t.integer(), name: t.text() });
+* const userSchema = z.object({ id: z.integer(), name: z.text() });
 * const userPageSchema = pageSchema(userSchema);
 * ```
 *
@@ -3331,10 +3317,10 @@ const pageMetadataSchema = t.object({
 * })
 * ```
 */
-const pageSchema = (objectSchema, options) => t.object({
-	content: t.array(objectSchema),
+const pageSchema = (objectSchema) => z.object({
+	content: z.array(objectSchema),
 	page: pageMetadataSchema
-}, options);
+});
 TypeProvider.prototype.page = (itemSchema) => pageSchema(itemSchema);
 //#endregion
 //#region ../../src/core/index.browser.ts
@@ -3357,6 +3343,6 @@ const run = (entry, opts) => {
 	return alepha;
 };
 //#endregion
-export { $atom, $context, $env, $hook, $inject, $memoize, $mode, $module, $pipeline, $scope, $state, ALS_PARENT, Alepha, AlephaError, AlsProvider, AppNotStartedError, Atom, CircularDependencyError, CodecManager, ContainerLockedError, EventManager, Format, HookPrimitive, InjectPrimitive, Json, JsonSchemaCodec, KIND, KeylessJsonSchemaCodec, Module, OPTIONS, PipelineHandler, PipelinePrimitive, Primitive, SchemaCodec, SchemaValidator, StateManager, TooLateSubstitutionError, Type, TypeBoxError, TypeGuard, TypeProvider, __alephaRef, createMiddleware, createPagination, createPrimitive, isClass, isFileLike, isTypeFile, jsonSchemaToTypeBox, pageMetadataSchema, pageQuerySchema, pageSchema, run, t };
+export { $atom, $computed, $context, $env, $hook, $inject, $memoize, $mode, $module, $pipeline, $scope, $state, ALS_PARENT, Alepha, AlephaError, AlsProvider, AppNotStartedError, Atom, CircularDependencyError, CodecManager, Computed, ContainerLockedError, EventManager, HookPrimitive, InjectPrimitive, Json, JsonSchemaCodec, KIND, KeylessJsonSchemaCodec, Module, OPTIONS, PipelineHandler, PipelinePrimitive, Primitive, SchemaCodec, SchemaValidator, StateManager, TooLateSubstitutionError, Type, TypeBoxError, TypeProvider, Z_LIMITS, __alephaRef, coerceObject, coerceScalar, createMiddleware, createPagination, createPrimitive, isClass, isFileLike, isTypeFile, jsonSchemaToZod, pageMetadataSchema, pageQuerySchema, pageSchema, run, z };
 
 //# sourceMappingURL=index.browser.js.map