alepha 0.22.0 → 0.24.0

package/dist/core/index.d.ts

@@ -1,12 +1,8 @@
 import { AsyncLocalStorage } from "node:async_hooks";
-import { Static as Static$1, StaticDecode, StaticDecode as Static, StaticEncode, StaticEncode as StaticEncode$1, TAny, TAny as TAny$1, TArray, TArray as TArray$1, TArrayOptions, TBigInt, TBoolean, TBoolean as TBoolean$1, TInteger, TInteger as TInteger$1, TInterface, TKeysToIndexer, TKeysToIndexer as TKeysToIndexer$1, TNull, TNull as TNull$1, TNumber, TNumber as TNumber$1, TNumberOptions, TNumberOptions as TNumberOptions$1, TObject, TObject as TObject$1, TObjectOptions, TObjectOptions as TObjectOptions$1, TOmit, TOptional, TOptionalAdd, TOptionalAdd as TOptionalAdd$1, TPartial, TPick, TPick as TPick$1, TProperties, TProperties as TProperties$1, TRecord, TRecord as TRecord$1, TSchema, TSchema as TSchema$1, TSchemaOptions, TString, TString as TString$1, TStringOptions, TStringOptions as TStringOptions$1, TTuple, TUnion, TUnion as TUnion$1, TUnsafe, TUnsafe as TUnsafe$1, TVoid, Type } from "typebox";
-import Format from "typebox/format";
-import { Validator } from "typebox/compile";
+import { z as z$1 } from "zod";
 import { Middleware as Middleware$1 } from "alepha";
-import { TLocalizedValidationError } from "typebox/error";
 import { Readable } from "node:stream";
 import { ReadableStream as ReadableStream$1 } from "node:stream/web";
-
 //#region ../../src/core/constants/KIND.d.ts
 /**
  * Used for identifying primitives.
@@ -153,28 +149,6 @@ interface LoggerInterface {
   error(message: string, data?: unknown): void;
 }
 //#endregion
-//#region ../../src/core/errors/AlephaError.d.ts
-/**
- * Default error class for Alepha.
- */
-declare class AlephaError extends Error {
-  name: string;
-}
-//#endregion
-//#region ../../src/core/errors/TypeBoxError.d.ts
-declare class TypeBoxError extends AlephaError {
-  name: string;
-  readonly cause: TLocalizedValidationError;
-  readonly value: {
-    path: string;
-    message: string;
-  };
-  constructor(error: TLocalizedValidationError);
-}
-interface TypeBoxErrorParams {
-  requiredProperties?: string[];
-}
-//#endregion
 //#region ../../src/core/helpers/FileLike.d.ts
 interface FileLike {
   /**
@@ -232,327 +206,296 @@ interface FileLike {
 /**
  * TypeBox view of FileLike.
  */
-type TFile = TUnsafe$1<FileLike>;
-declare const isTypeFile: (value: TSchema$1) => value is TFile;
+type TFile = TUnsafe<FileLike>;
+declare const isTypeFile: (value: TSchema) => value is TFile;
 declare const isFileLike: (value: any) => value is FileLike;
 type StreamLike = ReadableStream | ReadableStream$1 | Readable | NodeJS.ReadableStream;
-type TStream = TUnsafe$1<StreamLike>;
+type TStream = TUnsafe<StreamLike>;
 //#endregion
-//#region ../../src/core/providers/TypeProvider.d.ts
-declare class TypeGuard {
-  isBigInt: (value: TSchema$1) => value is TString$1;
-  isUUID: (value: TSchema$1) => value is TString$1;
-  isObject: typeof Type.IsObject;
-  isNumber: typeof Type.IsNumber;
-  isString: typeof Type.IsString;
-  isBoolean: typeof Type.IsBoolean;
-  isAny: typeof Type.IsAny;
-  isArray: typeof Type.IsArray;
-  isOptional: typeof Type.IsOptional;
-  isUnion: typeof Type.IsUnion;
-  isInteger: typeof Type.IsInteger;
-  isNull: typeof Type.IsNull;
-  isUndefined: typeof Type.IsUndefined;
-  isUnsafe: typeof Type.IsUnsafe;
-  isRecord: typeof Type.IsRecord;
-  isTuple: typeof Type.IsTuple;
-  isVoid: typeof Type.IsVoid;
-  isLiteral: typeof Type.IsLiteral;
-  isSchema: typeof Type.IsSchema;
-  isScalar: (schema: TSchema$1) => boolean;
-  isFile: (value: TSchema$1) => value is TFile;
-  isDateTime: (schema: unknown) => boolean;
-  isDate: (schema: unknown) => boolean;
-  isTime: (schema: unknown) => boolean;
-  isDuration: (schema: unknown) => boolean;
-}
-declare module "typebox" {
-  interface TString {
-    format?: string;
-    minLength?: number;
-    maxLength?: number;
+//#region ../../src/core/providers/zodAugment.d.ts
+/**
+ * Legacy-compatibility shims so typebox-era structural accessors keep working
+ * on zod schemas (the "short path" for the migration — avoids rewriting
+ * hundreds of schema-walking call-sites):
+ *
+ *   typebox            zod            alias added here
+ *   ----------------   ------------   ----------------
+ *   obj.properties     obj.shape      .properties -> .shape
+ *   array.items        array.element  .items      -> .element
+ *   union.anyOf        union.options  .anyOf      -> .options
+ *
+ * Both the runtime (prototype getters) and the type-level (`declare module`
+ * interface merge) are provided, so `schema.properties` resolves and typechecks.
+ *
+ * Imported for side-effects by ZodProvider so it loads with the `z` core.
+ */
+declare module "zod" {
+  interface ZodObject {
+    /** typebox-compat alias for {@link ZodObject.shape}. */
+    readonly properties: this["shape"];
   }
-  interface TNumber {
-    format?: "int64";
+  interface ZodArray {
+    /** typebox-compat alias for {@link ZodArray.element}. */
+    readonly items: this["element"];
   }
+  interface ZodUnion {
+    /** typebox-compat alias for {@link ZodUnion.options}. */
+    readonly anyOf: this["options"];
+  }
+  interface ZodTuple {
+    /** typebox-compat alias for the tuple's element schemas. */
+    readonly items: readonly import("zod").ZodType[];
+  }
+}
+//#endregion
+//#region ../../src/core/providers/ZodProvider.d.ts
+/**
+ * Alepha's `z` — a thin, enhanceable wrapper over zod 4 that mirrors the
+ * ergonomics of the legacy typebox `t` provider (same call-shapes, so existing
+ * `t.*` call-sites become a near-mechanical rename), while delegating all
+ * validation + static-type inference to zod.
+ *
+ * Design notes:
+ * - No encode/decode. string -> string, number -> number. Validation is a plain
+ *   `schema.parse(value)` — zod does NOT use `Function`/`eval`, so this is safe
+ *   inside Cloudflare Workers (unlike typebox's `Compile`).
+ * - Metadata (`title`, `description`, `format`, custom `~options`) rides on zod's
+ *   native `.meta()` registry, so `z.toJSONSchema()` round-trips it for OpenAPI
+ *   + form generation. Defaults use `.default()`.
+ */
+type ZType = z$1.ZodType;
+type ZObject<T extends z$1.ZodRawShape = any> = z$1.ZodObject<T>;
+/** Replaces typebox `Static<T>`. */
+type Infer<T extends z$1.ZodType> = z$1.infer<T>;
+/**
+ * Shallow output-extraction for `T extends SomeSchema ? Static<T> : Fallback`
+ * conditional positions.
+ *
+ * Reads zod's `_zod.output` directly (a single shallow conditional) instead of
+ * first testing `T extends TRequestBody` / `TResponseBody` — those tests compare
+ * `T` against 5-6 member unions of deeply-recursive zod class types, and that
+ * structural assignability check is what trips TypeScript's instantiation-depth
+ * limit (TS2589) inside `$action`'s generics. The extracted type is identical to
+ * `Static<T>` for any real schema; non-schema `T` (e.g. `undefined`) yields
+ * `Fallback`.
+ */
+type SchemaOutput<T, Fallback = any> = [T] extends [{
+  _zod: {
+    output: infer O;
+  };
+}] ? O : Fallback;
+interface SchemaOptions {
+  title?: string;
+  description?: string;
+  default?: unknown;
+  format?: string;
+  /** Alepha string transforms, kept for JSON-Schema round-trip parity. */
+  "~options"?: {
+    trim?: boolean;
+    lowercase?: boolean;
+  };
+  [key: string]: unknown;
 }
+interface StringOptions extends SchemaOptions {
+  minLength?: number;
+  maxLength?: number;
+  pattern?: string | RegExp;
+}
+interface NumberOptions extends SchemaOptions {
+  minimum?: number;
+  maximum?: number;
+}
+interface TextOptions extends StringOptions {
+  size?: "short" | "regular" | "long" | "rich";
+  trim?: boolean;
+  lowercase?: boolean;
+}
+/** Defaults mirroring TypeProvider's static length caps. */
+declare const Z_LIMITS: {
+  short: number;
+  regular: number;
+  long: number;
+  rich: number;
+  arrayMaxItems: number;
+};
+declare 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: typeof z$1.coerce;
+  object: typeof z$1.object;
+  array: typeof z$1.array;
+  record: typeof z$1.record;
+  tuple: typeof z$1.tuple;
+  union: typeof z$1.union;
+  string: typeof z$1.string;
+  number: typeof z$1.number;
+  boolean: typeof z$1.boolean;
+  null: typeof z$1.null;
+  any: typeof z$1.any;
+  void: typeof z$1.void;
+  undefined: typeof z$1.undefined;
+  literal: typeof z$1.literal;
+  /** Alias for `zod.literal` (legacy `t.const`). */
+  const: typeof z$1.literal;
+  enum: typeof z$1.enum;
+  /** Integer — native `z.int()` (format `safeint`, drives PG INT column). */
+  integer: typeof z$1.int;
+  /** Free-form JSON object (`Record<string, any>`). */
+  json: () => z$1.ZodRecord<z$1.ZodString, z$1.ZodAny>;
+  text: (options?: TextOptions) => z$1.ZodString;
+  shortText: (options?: TextOptions) => z$1.ZodString;
+  longText: (options?: TextOptions) => z$1.ZodString;
+  richText: (options?: TextOptions) => z$1.ZodString;
+  email: () => z$1.ZodString;
+  uuid: () => z$1.ZodString;
+  url: () => z$1.ZodString;
+  datetime: () => z$1.ZodString;
+  date: () => z$1.ZodString;
+  time: () => z$1.ZodString;
+  /** bigint as a validated string (no codec). */
+  bigint: () => z$1.ZodString;
+  binary: () => z$1.ZodString;
+  duration: () => z$1.ZodString;
+  e164: () => z$1.ZodString;
+  bcp47: () => z$1.ZodString;
+  constantCase: () => z$1.ZodString;
+  int32: () => z$1.ZodInt;
+  int64: () => z$1.ZodInt;
+  file: (options?: {
+    maxSize?: number;
+  }) => z$1.ZodAny;
+  stream: () => z$1.ZodAny;
+  valueLabel: () => z$1.ZodObject<{
+    value: z$1.ZodString;
+    label: z$1.ZodString;
+    description: z$1.ZodOptional<z$1.ZodString>;
+  }, z$1.core.$strip>;
+  /** Pagination wrapper, mirrors `pageSchema(item)`. */
+  page: <T extends z$1.ZodType>(item: T) => z$1.ZodObject<{
+    content: z$1.ZodArray<T>;
+    page: z$1.ZodObject<{
+      number: z$1.ZodInt;
+      size: z$1.ZodInt;
+      offset: z$1.ZodInt;
+      numberOfElements: z$1.ZodInt;
+      totalElements: z$1.ZodOptional<z$1.ZodInt>;
+      totalPages: z$1.ZodOptional<z$1.ZodInt>;
+      isEmpty: z$1.ZodBoolean;
+      isFirst: z$1.ZodBoolean;
+      isLast: z$1.ZodBoolean;
+    }, z$1.core.$strip>;
+  }, z$1.core.$strip>;
+  /** Export a schema to JSON Schema (OpenAPI / form generation). */
+  toJSONSchema: typeof z$1.toJSONSchema;
+  /** Runtime type guards (`z.schema.*`) — schema introspection for ORM + forms. */
+  schema: {
+    isOptional: (s: any) => s is z$1.ZodOptional<z$1.core.$ZodType<unknown, unknown, z$1.core.$ZodTypeInternals<unknown, unknown>>>;
+    isDefault: (s: any) => s is z$1.ZodDefault<z$1.core.$ZodType<unknown, unknown, z$1.core.$ZodTypeInternals<unknown, unknown>>>;
+    isObject: (s: any) => s is z$1.ZodObject<z$1.core.$ZodLooseShape, z$1.core.$strip>;
+    isString: (s: any) => boolean;
+    isNumber: (s: any) => boolean;
+    isBoolean: (s: any) => s is z$1.ZodBoolean;
+    isArray: (s: any) => s is z$1.ZodArray<z$1.core.$ZodType<unknown, unknown, z$1.core.$ZodTypeInternals<unknown, unknown>>>;
+    isUnion: (s: any) => s is z$1.ZodUnion<readonly z$1.core.$ZodType<unknown, unknown, z$1.core.$ZodTypeInternals<unknown, unknown>>[]>;
+    isNull: (s: any) => s is z$1.ZodNull;
+    isRecord: (s: any) => s is z$1.ZodRecord<z$1.core.$ZodRecordKey, z$1.core.$ZodType<unknown, unknown, z$1.core.$ZodTypeInternals<unknown, unknown>>>;
+    isEnum: (s: any) => boolean;
+    isLiteral: (s: any) => boolean;
+    isAny: (s: any) => s is z$1.ZodAny;
+    isNullable: (s: any) => s is z$1.ZodNullable<z$1.core.$ZodType<unknown, unknown, z$1.core.$ZodTypeInternals<unknown, unknown>>>;
+    isInteger: (s: any) => boolean;
+    isText: (s: any) => boolean;
+    isDateTime: (s: any) => boolean;
+    isDate: (s: any) => boolean;
+    isTime: (s: any) => boolean;
+    isBigInt: (s: any) => boolean;
+    isUuid: (s: any) => boolean;
+    isEmail: (s: any) => boolean;
+    isUrl: (s: any) => boolean;
+    isBinary: (s: any) => boolean;
+    isUUID: (s: any) => boolean;
+    isScalar: (s: any) => boolean;
+    isSchema: (s: any) => s is z$1.ZodType<unknown, unknown, z$1.core.$ZodTypeInternals<unknown, unknown>>;
+    isTuple: (s: any) => s is z$1.ZodTuple<readonly z$1.core.$ZodType<unknown, unknown, z$1.core.$ZodTypeInternals<unknown, unknown>>[], z$1.core.$ZodType<unknown, unknown, z$1.core.$ZodTypeInternals<unknown, unknown>> | null>;
+    isUndefined: (s: any) => s is z$1.ZodUndefined;
+    isUnsafe: (s: any) => s is z$1.ZodAny | z$1.ZodUnknown;
+    isVoid: (s: any) => s is z$1.ZodVoid;
+    format: (s: any) => string | undefined;
+    /** The string values of a `ZodEnum` (typebox-compat for `value.enum`). */
+    enumValues: (s: any) => string[];
+    /** Peel optional / nullable / default wrappers to the inner schema. */
+    unwrap: (s: any) => any;
+    /**
+     * 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: any) => unknown;
+    /** typebox-compat: the object's required (non-optional) field names. */
+    requiredKeys: (s: any) => string[];
+  };
+};
+type Z = typeof z;
+//#endregion
+//#region ../../src/core/providers/TypeProvider.d.ts
+/** Raw zod namespace (legacy `Type` escape hatch). */
+declare const Type: typeof z$1;
+type Static<T extends ZType> = Infer<T>;
+type StaticDecode<T extends ZType> = Infer<T>;
+type StaticEncode<T extends ZType> = Infer<T>;
+type TSchema = ZType;
+type TObject<T extends z$1.ZodRawShape = any> = ZObject<T>;
+type TProperties = z$1.ZodRawShape;
+type TString = z$1.ZodString;
+type TNumber = z$1.ZodNumber;
+type TInteger = z$1.ZodNumber;
+type TBoolean = z$1.ZodBoolean;
+type TArray<T extends ZType = ZType> = z$1.ZodArray<T>;
+type TUnion<_T extends ZType[] = ZType[]> = z$1.ZodUnion;
+type TRecord = z$1.ZodRecord<any, any>;
+type TTuple = ZType;
+type TNull = z$1.ZodNull;
+type TAny = z$1.ZodAny;
+type TVoid = z$1.ZodVoid;
+type TBigInt = z$1.ZodString;
+type TUnsafe<_T = unknown> = ZType;
+type TOptional<T extends ZType = ZType> = z$1.ZodOptional<T>;
+type TOptionalAdd<T extends ZType = ZType> = z$1.ZodOptional<T>;
+type TPick<T extends ZObject = ZObject, _K = unknown> = T;
+type TOmit<T extends ZObject = ZObject, _K = unknown> = T;
+type TPartial<_T extends ZObject = ZObject> = ZObject;
+type TInterface<_T = unknown, _U = unknown> = ZObject;
+type TKeysToIndexer<_T = unknown> = any;
+type TSchemaOptions = SchemaOptions;
+type TStringOptions = StringOptions;
+type TNumberOptions = NumberOptions;
+type TObjectOptions = SchemaOptions;
+type TArrayOptions = SchemaOptions;
+type TextLength = "short" | "regular" | "long" | "rich";
+type TTextOptions = TextOptions;
+interface TEnumOptions extends TextOptions {
+  /** `"text"` = TEXT column; omitted = a real PostgreSQL ENUM type. */
+  mode?: "text";
+  /** Custom PG ENUM type name (shared across tables). */
+  name?: string;
+}
+/** Legacy `TypeProvider` — kept for its static config knobs. */
 declare class TypeProvider {
-  static format: typeof Format;
-  static translateError(error: TypeBoxError, _locale?: string): string;
-  static setLocale(_locale: string): void;
-  static isValidBigInt(value: string | number): boolean;
-  /**
-   * 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: number | undefined;
-  /**
-   * Maximum length for short strings, such as names or titles.
-   */
   static DEFAULT_SHORT_STRING_MAX_LENGTH: number | undefined;
-  /**
-   * 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: number | undefined;
-  /**
-   * 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: number | undefined;
-  /**
-   * 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: number;
-  raw: typeof Type;
-  any: typeof Type.Any;
-  void: typeof Type.Void;
-  undefined: typeof Type.Undefined;
-  record: typeof Type.Record;
-  union: typeof Type.Union;
-  tuple: typeof Type.Tuple;
-  null: typeof Type.Null;
-  const: typeof Type.Literal;
-  options: typeof 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
-   * }
-   * ```
-   */
-  readonly schema: TypeGuard;
-  extend<T extends TSchema$1[], U extends TProperties$1>(schema: [...T], properties: U, options?: TSchemaOptions): TInterface<T, U>;
-  extend<T extends TObject$1, U extends TProperties$1>(schema: T, properties: U, options?: TSchemaOptions): TInterface<[T], U>;
-  pick<T extends TObject$1, Indexer extends PropertyKey[]>(schema: T, keys: [...Indexer], options?: TObjectOptions$1): TPick$1<T, TKeysToIndexer$1<Indexer>>;
-  omit<T extends TObject$1, Indexer extends PropertyKey[]>(schema: T, keys: [...Indexer], options?: TObjectOptions$1): TOmit<T, TKeysToIndexer$1<Indexer>>;
-  partial<T extends TSchema$1>(schema: T, options?: TSchemaOptions): TPartial<T>;
-  /**
-   * 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<T extends TProperties$1>(properties: T, options?: TObjectOptions$1): TObject$1<T>;
-  /**
-   * 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<T extends TSchema$1>(schema: T, options?: TArrayOptions): TArray$1<T>;
-  /**
-   * 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?: TStringOptions$1): TString$1;
-  /**
-   * 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?: TTextOptions): TString$1;
-  /**
-   * Create a schema for a JSON object.
-   * This is a record with string keys and any values.
-   */
-  json<T = any>(options?: TSchemaOptions): TRecord$1<string, TAny$1>;
-  /**
-   * Create a schema for a boolean.
-   */
-  boolean(options?: TSchemaOptions): TBoolean$1;
-  /**
-   * Create a schema for a number.
-   */
-  number(options?: TNumberOptions$1): TNumber$1;
-  /**
-   * Create a schema for an integer.
-   */
-  integer(options?: TNumberOptions$1): TInteger$1;
-  int32(options?: TNumberOptions$1): TInteger$1;
-  /**
-   * 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?: TNumberOptions$1): TNumber$1;
-  /**
-   * Make a schema optional.
-   */
-  optional<T extends TSchema$1>(schema: T): TOptionalAdd$1<T>;
-  /**
-   * Make a schema nullable.
-   */
-  nullable<T extends TSchema$1>(schema: T, options?: TObjectOptions$1): TUnion$1<[TNull$1, T]>;
-  /**
-   * Create a schema that maps all properties of an object schema to nullable.
-   */
-  nullify: (schema: TSchema$1, options?: TObjectOptions$1) => TSchema$1;
-  /**
-   * 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<T extends string[]>(values: [...T], options?: TEnumOptions): TUnsafe$1<T[number]>;
-  /**
-   * Create a schema for a bigint represented as a string.
-   * This is a string that validates bigint format (e.g. "123456789").
-   */
-  bigint(options?: TStringOptions$1): TString$1;
-  /**
-   * Create a schema for a URL represented as a string.
-   */
-  url(options?: TStringOptions$1): TString$1;
-  /**
-   * Create a schema for binary data represented as a base64 string.
-   */
-  binary(options?: TStringOptions$1): TString$1;
-  /**
-   * Create a schema for uuid.
-   */
-  uuid(options?: TStringOptions$1): TString$1;
-  /**
-   * 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?: {
-    maxSize?: number;
-  }): TFile;
-  /**
-   * @experimental
-   */
-  stream(): TStream;
-  email(options?: TStringOptions$1): TString$1;
-  e164(options?: TStringOptions$1): TString$1;
-  bcp47(options?: TStringOptions$1): TString$1;
-  /**
-   * Create a schema for short text, such as names or titles.
-   * Default max length is 64 characters.
-   */
-  shortText(options?: TStringOptions$1): TString$1;
-  /**
-   * Create a schema for long text, such as descriptions or comments.
-   * Default max length is 1024 characters.
-   */
-  longText(options?: TStringOptions$1): TString$1;
-  /**
-   * Create a schema for rich text, such as HTML or Markdown.
-   * Default max length is 65535 characters.
-   */
-  richText(options?: TStringOptions$1): TString$1;
-  /**
-   * Create a schema for a constant case string e.g. LIKE_THIS.
-   */
-  constantCase: (options?: TStringOptions$1) => TString$1;
-  /**
-   * Create a schema for an object with a value and label.
-   */
-  valueLabel: (options?: TObjectOptions$1) => TObject$1<{
-    value: TString$1;
-    label: TString$1;
-    description: Type.TOptional<TString$1>;
-  }>;
-  datetime: (options?: TStringOptions$1) => TString$1;
-  date: (options?: TStringOptions$1) => TString$1;
-  time: (options?: TStringOptions$1) => TString$1;
-  duration: (options?: TStringOptions$1) => TString$1;
-}
-type TextLength = "short" | "regular" | "long" | "rich";
-interface TEnumOptions extends TTextOptions {
-  /**
-   * Storage mode for the enum.
-   *
-   * - `"text"` — stores as a TEXT column in the database.
-   * - When omitted, creates a real PostgreSQL ENUM type.
-   */
-  mode?: "text";
-  /**
-   * Custom name for the PostgreSQL ENUM type.
-   *
-   * Use this to share the same enum type across multiple tables.
-   * If not specified, the name is auto-generated from the table and column names.
-   */
-  name?: string;
-}
-interface TTextOptions extends TStringOptions$1 {
-  /**
-   * Predefined size of the text.
-   *
-   * - `short` - short text, such as names or titles. Default max length is 64 characters.
-   * - `regular` - regular text, such as single-line input. Default max length is 255 characters.
-   * - `long` - long text, such as descriptions or comments. Default max length is 1024 characters.
-   * - `rich` - rich text, such as HTML or Markdown. Default max length is 65535 characters.
-   *
-   * You can override the default max length by specifying `maxLength` in the options.
-   *
-   * @default "regular"
-   */
-  size?: TextLength;
-  /**
-   * Trim whitespace from both ends of the string.
-   *
-   * @default true
-   */
-  trim?: boolean;
-  /**
-   * Convert the string to lowercase.
-   *
-   * @default false
-   */
-  lowercase?: boolean;
+  static translateError: (error: {
+    message?: string;
+  }, _locale?: string) => string;
+  static setLocale: (_locale: string) => void;
+  static isValidBigInt: (value: string | number) => boolean;
 }
-declare const t: TypeProvider;
 //#endregion
 //#region ../../src/core/primitives/$atom.d.ts
 /**
@@ -566,16 +509,16 @@ declare const t: TypeProvider;
  * 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
@@ -588,27 +531,166 @@ declare const t: TypeProvider;
  * If you need to store complex data, consider using identifiers or references instead.
  */
 declare const $atom: {
-  <T extends TObject<TProperties$2> | TArray$1, N extends string>(options: AtomOptions<T, N>): Atom<T, N>;
+  <T extends ZType, N extends string>(options: AtomOptions<T, N>): Atom<T, N>;
   [KIND]: string;
 };
-type AtomOptions<T extends TAtomObject, N extends string> = {
+/**
+ * Persistence adapter for an atom.
+ */
+type AtomPersist = "cookie" | "localStorage" | "sessionStorage";
+type AtomOptions<T extends ZType, N extends string> = {
   name: N;
   schema: T;
   description?: string;
-} & (T extends TOptionalAdd<T> ? {
+  /**
+   * Persist this atom outside the in-memory store.
+   *
+   * - `"cookie"` — synced to an HTTP cookie by the `alepha/server/cookies`
+   *   module. Works on the server AND in the browser, so it is the only
+   *   correct adapter for SSR apps: the server reads it while rendering and
+   *   the first paint matches the persisted state.
+   * - `"localStorage"` / `"sessionStorage"` — browser Web Storage. Fine for
+   *   pure SPA apps. The server cannot see these values; registering such
+   *   an atom during SSR logs a warning.
+   *
+   * Values are validated against the schema when read back; invalid or
+   * corrupted entries are discarded and the default is used.
+   *
+   * **Security: cookie-persisted atoms are attacker-controlled.** The
+   * cookie written by `persist: "cookie"` is unsigned, unencrypted, and
+   * freely writable by any client-side script (`AtomCookiePersistence`'s
+   * `cookieOptions()` sets no `sign`, `encrypt`, or `httpOnly`) — a request
+   * can present any value it wants for it. Never persist trust-bearing
+   * state — user ids, roles, entitlements, permissions — in a
+   * `persist: "cookie"` atom. If you need a signed, encrypted, and/or
+   * `httpOnly` cookie, declare an explicit
+   * `$cookie({ key: atom.key, sign: true, encrypt: true, httpOnly: true, ... })`
+   * binding instead — that is the escape hatch for trust-bearing values.
+   */
+  persist?: AtomPersist;
+  /**
+   * Exclude this atom from the SSR hydration export
+   * (`StateManager.exportAtoms()`).
+   *
+   * This is the ONLY guarantee `serverOnly` makes: the value is never
+   * written into the `<script id="__ssr">` JSON block serialized into the
+   * HTML payload. It says nothing about any other channel a value can
+   * reach the browser through.
+   *
+   * **Cannot be combined with `persist`.** Every persistence 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. Declaring
+   * `serverOnly: true` together with any `persist` value throws
+   * `AlephaError` at `$atom()` call time, because the persistence channel
+   * would leak the exact value `serverOnly` is meant to keep server-side.
+   *
+   * Use `serverOnly` for atoms that may hold secrets or internal
+   * request-scoped state that must never leave the server, and never pair
+   * it with `persist`.
+   *
+   * **Never make a `serverOnly` atom a dependency of a `$computed` that the
+   * browser reads through `useComputed`.** A computed is re-derived, never
+   * serialized: the server derives it from the atom's real value, and the
+   * browser — which never received that value — re-derives it from the
+   * atom's default. The two disagree, producing a React hydration mismatch
+   * and a silently wrong value from then on. Keep such a computed
+   * server-side (`alepha.store.get`), or derive it from atoms that ship.
+   */
+  serverOnly?: boolean;
+} & (T extends z$1.ZodOptional<any> ? {
   default?: Static<T>;
 } : {
   default: Static<T>;
 });
-declare class Atom<T extends TAtomObject = TObject, N extends string = string> {
+declare class Atom<T extends ZType = TObject, N extends string = string> {
   readonly options: AtomOptions<T, N>;
   get schema(): T;
   get key(): N;
   constructor(options: AtomOptions<T, N>);
 }
-type TProperties$2 = any;
-type TAtomObject = TObject<any> | TArray$1;
-type AtomStatic<T extends TAtomObject> = T extends TOptionalAdd<T> ? Static<T> | undefined : Static<T>;
+type TAtomObject = ZType;
+type AtomStatic<T extends ZType> = T extends z$1.ZodOptional<any> ? Static<T> | undefined : Static<T>;
+//#endregion
+//#region ../../src/core/primitives/$computed.d.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.
+ */
+declare const $computed: {
+  <const D extends ReadonlyArray<AnyDep>, R, N extends string = string>(options: ComputedOptions<D, R, N>): Computed<R, N>;
+  [KIND]: string;
+};
+type AnyDep = Atom<any, any> | Computed<any, any>;
+type DepValues<D extends ReadonlyArray<AnyDep>> = { [K in keyof D]: D[K] extends Atom<infer T, any> ? AtomStatic<T> : D[K] extends Computed<infer R2, any> ? R2 : never; };
+interface ComputedOptions<D extends ReadonlyArray<AnyDep>, R, N extends string = string> {
+  name: N;
+  deps: D;
+  get: (...values: DepValues<D>) => R;
+  description?: string;
+}
+declare class Computed<R = unknown, N extends string = string> {
+  readonly options: ComputedOptions<any, R, N>;
+  constructor(options: ComputedOptions<any, R, N>);
+  get key(): N;
+  /**
+   * 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.
+   */
+  protected resolvingKeys: boolean;
+  /**
+   * Reentrancy guard for {@link compute}, same rationale as
+   * {@link resolvingKeys}.
+   */
+  protected computing: boolean;
+  /**
+   * Transitive atom keys this computed value depends on. Subscribers
+   * (useComputed, StateManager.watch) use this to know which `state:mutate`
+   * events invalidate the value.
+   */
+  keys(): string[];
+  /**
+   * Resolve the value using the given dependency resolver.
+   */
+  compute(resolve: (dep: AnyDep) => unknown): R;
+}
 //#endregion
 //#region ../../src/core/primitives/$inject.d.ts
 /**
@@ -803,6 +885,17 @@ declare class AlsProvider {
   run<R>(callback: () => R, data?: Record<string, any>): R;
   exists(): boolean;
   get<T>(key: string, scope?: StateScope): T | undefined;
+  /**
+   * 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: string): AsyncLocalStorageData | undefined;
   has(key: string): boolean;
   set<T>(key: string, value: T): void;
 }
@@ -842,9 +935,9 @@ declare class JsonSchemaCodec extends SchemaCodec {
   protected readonly json: Json;
   protected readonly encoder: TextEncoder;
   protected readonly decoder: TextDecoder;
-  encodeToString<T extends TSchema$1>(schema: T, value: Static<T>): string;
-  encodeToBinary<T extends TSchema$1>(schema: T, value: Static<T>): Uint8Array;
-  decode<T>(schema: TSchema$1, value: unknown): T;
+  encodeToString<T extends TSchema>(schema: T, value: Static<T>): string;
+  encodeToBinary<T extends TSchema>(schema: T, value: Static<T>): Uint8Array;
+  decode<T>(schema: TSchema, value: unknown): T;
 }
 //#endregion
 //#region ../../src/core/providers/KeylessJsonSchemaCodec.d.ts
@@ -868,7 +961,7 @@ interface KeylessCodecOptions {
  * to be a simple JSON array instead of an object with keys.
  */
 declare class KeylessJsonSchemaCodec extends SchemaCodec {
-  protected readonly cache: Map<TSchema$1, KeylessCodec<any>>;
+  protected readonly cache: Map<import("alepha").ZType, KeylessCodec<any>>;
   protected readonly textEncoder: TextEncoder;
   protected readonly textDecoder: TextDecoder;
   protected varCounter: number;
@@ -885,15 +978,15 @@ declare class KeylessJsonSchemaCodec extends SchemaCodec {
   /**
    * Encode value to a keyless JSON string.
    */
-  encodeToString<T extends TSchema$1>(schema: T, value: Static<T>): string;
+  encodeToString<T extends TSchema>(schema: T, value: Static<T>): string;
   /**
    * Encode value to binary (UTF-8 encoded keyless JSON).
    */
-  encodeToBinary<T extends TSchema$1>(schema: T, value: Static<T>): Uint8Array;
+  encodeToBinary<T extends TSchema>(schema: T, value: Static<T>): Uint8Array;
   /**
    * Decode keyless JSON string or binary to value.
    */
-  decode<T>(schema: TSchema$1, value: unknown): T;
+  decode<T>(schema: TSchema, value: unknown): T;
   /**
    * Test if `new Function()` is available (not blocked by CSP).
    */
@@ -902,80 +995,70 @@ declare class KeylessJsonSchemaCodec extends SchemaCodec {
    * Get a compiled codec for the given schema.
    * Codecs are cached for reuse.
    */
-  protected getCodec<T>(schema: TSchema$1): KeylessCodec<T>;
+  protected getCodec<T>(schema: TSchema): KeylessCodec<T>;
   protected nextVar(): string;
   /**
    * Compile codec using `new Function()` for maximum performance.
    * Only used when CSP allows and useFunctionCompilation is true.
    */
-  protected compileWithFunction(schema: TSchema$1): KeylessCodec;
+  protected compileWithFunction(schema: TSchema): KeylessCodec;
   /**
    * Compile codec using interpreter-based approach.
    * Safer (no eval/Function) but slower. Used in browser by default.
    */
-  protected compileInterpreted(schema: TSchema$1): KeylessCodec;
-  protected interpretEncode(schema: TSchema$1, value: any): any;
-  protected interpretDecode(schema: TSchema$1, ctx: {
+  protected compileInterpreted(schema: TSchema): KeylessCodec;
+  protected interpretEncode(schema: TSchema, value: any): any;
+  protected interpretDecode(schema: TSchema, ctx: {
     arr: any[];
     i: number;
   }): any;
-  protected interpretDecodeFromValue(schema: TSchema$1, value: any): any;
-  protected genEnc(schema: TSchema$1, ve: string): string;
-  protected genDec(schema: TSchema$1): {
+  protected interpretDecodeFromValue(schema: TSchema, value: any): any;
+  protected genEnc(schema: TSchema, ve: string): string;
+  protected genDec(schema: TSchema): {
     code: string;
     result: string;
   };
-  protected genDecFromValue(schema: TSchema$1, expr: string): string;
-  protected isLeaf(schema: TSchema$1): boolean;
-  protected getObjectFields(schema: TObject$1): Array<{
+  protected genDecFromValue(schema: TSchema, expr: string): string;
+  protected isLeaf(schema: TSchema): boolean;
+  protected getObjectFields(schema: TObject): Array<{
     key: string;
     isOpt: boolean;
     isNullable: boolean;
-    inner: TSchema$1;
+    inner: TSchema;
   }>;
-  protected isEnum(schema: TSchema$1): boolean;
-  protected isNullable(schema: TSchema$1): boolean;
-  protected unwrap(schema: TSchema$1): TSchema$1;
+  protected isEnum(schema: TSchema): boolean;
+  protected isNullable(schema: TSchema): boolean;
+  protected unwrap(schema: TSchema): TSchema;
   /**
    * Reconstruct an object from a parsed array (for when input is already parsed).
    */
-  protected reconstructObject(schema: TSchema$1, arr: any[]): any;
+  protected reconstructObject(schema: TSchema, arr: any[]): any;
 }
 //#endregion
 //#region ../../src/core/providers/SchemaValidator.d.ts
-declare class SchemaValidator {
-  protected cache: Map<TSchema$1, Validator<import("typebox").TProperties, TSchema$1, unknown, unknown>>;
-  protected useEval: boolean;
-  /**
-   * Validate the value against the provided schema.
-   *
-   * Validation create a new value by applying some preprocessing. (e.g., trimming text)
-   */
-  validate<T extends TSchema$1>(schema: T, value: unknown, options?: ValidateOptions): Static<T>;
-  /**
-   * Deep clone a schema. Useful when a schema is going to be mutated.
-   */
-  clone<T extends TSchema$1>(schema: T): T;
-  protected getValidator<T extends TSchema$1>(schema: T): Validator<{}, T>;
-  /**
-   * 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: any, value: any, options: ValidateOptions): any;
-  /**
-   * Used by `beforeParse` to determine if a schema allows null values.
-   */
-  protected isSchemaNullable: (schema: any) => boolean;
-  protected onConfigure: import("alepha").HookPrimitive<"configure">;
-  protected canEval(): boolean;
-}
 interface ValidateOptions {
   trim?: boolean;
   nullToUndefined?: boolean;
   deleteUndefined?: boolean;
 }
+/**
+ * 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.
+ */
+declare class SchemaValidator {
+  validate<T extends TSchema>(schema: T, value: unknown, _options?: ValidateOptions): Static<T>;
+  safeValidate<T extends TSchema>(schema: T, value: unknown): import("zod").ZodSafeParseResult<import("zod").output<T>>;
+  /** Zod schemas are immutable — clone is a pass-through. */
+  clone<T extends TSchema>(schema: T): T;
+  /**
+   * Legacy pre-processing entry point. Coercion now happens inside `parse`,
+   * so this is a no-op kept for call-site compatibility.
+   */
+  beforeParse(_schema: unknown, value: unknown, _options?: ValidateOptions): unknown;
+}
 //#endregion
 //#region ../../src/core/providers/CodecManager.d.ts
 type Encoding = "object" | "string" | "binary";
@@ -999,7 +1082,7 @@ interface EncodeOptions<T extends Encoding = Encoding> {
    */
   validation?: ValidateOptions | false;
 }
-type EncodeResult<T extends TSchema$1, E extends Encoding> = E extends "string" ? string : E extends "binary" ? Uint8Array : StaticEncode$1<T>;
+type EncodeResult<T extends TSchema, E extends Encoding> = E extends "string" ? string : E extends "binary" ? Uint8Array : StaticEncode<T>;
 interface DecodeOptions {
   /**
    * The encoder to use (e.g., 'json', 'protobuf', 'msgpack')
@@ -1038,17 +1121,17 @@ declare class CodecManager {
   /**
    * Encode data using the specified codec and output format.
    */
-  encode<T extends TSchema$1, E extends Encoding = "object">(schema: T, value: unknown, options?: EncodeOptions<E>): EncodeResult<T, E>;
+  encode<T extends TSchema, E extends Encoding = "object">(schema: T, value: unknown, options?: EncodeOptions<E>): EncodeResult<T, E>;
   /**
    * Decode data using the specified codec.
    */
-  decode<T extends TSchema$1>(schema: T, data: any, options?: DecodeOptions): Static<T>;
+  decode<T extends TSchema>(schema: T, data: any, options?: DecodeOptions): Static<T>;
   /**
    * Validate decoded data against the schema.
    *
    * This is automatically called before encoding or after decoding.
    */
-  validate<T extends TSchema$1>(schema: T, value: unknown, options?: ValidateOptions): Static<T>;
+  validate<T extends TSchema>(schema: T, value: unknown, options?: ValidateOptions): Static<T>;
 }
 interface CodecRegisterOptions {
   name: string;
@@ -1147,7 +1230,8 @@ declare class StateManager<State$1 extends object = State> {
   protected readonly als: AlsProvider;
   protected readonly events: EventManager;
   protected readonly codec: JsonSchemaCodec;
-  protected readonly atoms: Map<keyof State$1, Atom<TObject$1<import("typebox").TProperties>, string>>;
+  protected readonly validator: SchemaValidator;
+  protected readonly atoms: Map<keyof State$1, Atom<TObject, string>>;
   protected store: Partial<State$1>;
   constructor(store?: Partial<State$1>);
   /**
@@ -1162,7 +1246,98 @@ declare class StateManager<State$1 extends object = State> {
    */
   exportAtoms(scope?: "current" | "app"): Record<string, unknown>;
   getAtoms(context?: boolean): Array<AtomWithValue>;
+  /**
+   * Return the registered atom for a state key, if any.
+   */
+  getAtom(key: string): Atom | undefined;
+  /**
+   * 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(): Array<Atom>;
   register(atom: Atom<any>): 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)`.
+   */
+  protected seedDefault(atom: Atom<any>, key: keyof State$1): void;
+  /**
+   * 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.
+   */
+  protected cloneDefault(atom: Atom<any>): unknown;
+  /**
+   * 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".
+   */
+  protected decodeExisting(atom: Atom<any>, key: keyof State$1, layer: Record<string, any>): void;
+  /**
+   * 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.
+   */
+  protected bindWebStorage(atom: Atom<any>): void;
+  /**
+   * 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.
+   */
+  protected safeRemoveItem(storage: Storage, key: string): void;
+  /**
+   * Resolve a Web Storage area, or undefined when unavailable (server,
+   * privacy mode that throws on access).
+   */
+  protected getWebStorage(kind: "localStorage" | "sessionStorage"): Storage | undefined;
+  /**
+   * 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.
+   */
+  protected get logger(): LoggerInterface | undefined;
   /**
    * Get a value from the state with proper typing.
    *
@@ -1172,6 +1347,7 @@ declare class StateManager<State$1 extends object = State> {
    *   - `"parent"`: Read only from the immediate parent fork layer.
    *   - `"app"`: Read only from the root (app-level) store.
    */
+  get<R>(target: Computed<R>, scope?: StateScope): R;
   get<T extends TAtomObject>(target: Atom<T>, scope?: StateScope): Static<T>;
   get<Key extends keyof State$1>(target: Key, scope?: StateScope): State$1[Key] | undefined;
   /**
@@ -1179,10 +1355,38 @@ declare class StateManager<State$1 extends object = State> {
    */
   set<T extends TAtomObject>(target: Atom<T>, value: AtomStatic<T>, options?: SetStateOptions): this;
   set<Key extends keyof State$1>(target: Key, value: State$1[Key] | undefined, options?: SetStateOptions): this;
+  /**
+   * Reset an atom back to its declared default value.
+   */
+  reset<T extends TAtomObject>(atom: Atom<T>): this;
+  /**
+   * Observe mutations of an atom, a computed value, or a raw state key
+   * outside React. Returns an unsubscribe function.
+   *
+   * **`Computed` overload, server-side caveat.** A computed has no stored
+   * value, so the watcher keeps the last computed result in a single `prev`
+   * closure variable, created once at subscription time and shared by every
+   * invocation. Request-scoped (fork) state is not: two concurrent requests
+   * resolve different values for the same dependency atoms. So the
+   * `prevValue` handed to the callback is "the value this watcher computed
+   * last time it fired", which may well have been computed inside a
+   * *different* request's fork. `value` is always correct (it is computed
+   * fresh, inside the mutating context); only `prevValue` can cross request
+   * boundaries.
+   *
+   * That is fine for `watch`'s intended use — app-level, non-React
+   * observation of app-level state (React subscribes through `useComputed`,
+   * which is per-component and browser-side, where there is only ever one
+   * "request"). Do not build per-request logic on a computed's `prevValue`
+   * on the server.
+   */
+  watch<T extends TAtomObject>(target: Atom<T>, callback: (value: Static<T>, prevValue: Static<T> | undefined) => void): () => void;
+  watch<R>(target: Computed<R>, callback: (value: R, prevValue: R | undefined) => void): () => void;
+  watch<Key extends keyof State$1>(target: Key, callback: (value: State$1[Key] | undefined, prevValue: State$1[Key] | undefined) => void): () => void;
   /**
    * Mutate a value in the state.
    */
-  mut<T extends TObject$1>(target: Atom<T>, mutator: (current: Static<T>) => Static<T>): this;
+  mut<T extends TObject>(target: Atom<T>, mutator: (current: Static<T>) => Static<T>): this;
   mut<Key extends keyof State$1>(target: Key, mutator: (current: State$1[Key] | undefined) => State$1[Key] | undefined): this;
   /**
    * Check if a key exists in the state.
@@ -1206,10 +1410,15 @@ declare class StateManager<State$1 extends object = State> {
    */
   keys(): (keyof State$1)[];
 }
-type OnlyArray<T extends object> = { [K in keyof T]: NonNullable<T[K]> extends Array<any> ? K : never };
+type OnlyArray<T extends object> = { [K in keyof T]: NonNullable<T[K]> extends Array<any> ? K : never; };
 interface SetStateOptions {
   skipContext?: boolean;
   skipEvents?: boolean;
+  /**
+   * Skip schema validation for this write. Internal escape hatch for
+   * callers that have already validated the value (e.g. hydration).
+   */
+  skipValidation?: boolean;
 }
 //#endregion
 //#region ../../src/core/Alepha.d.ts
@@ -1273,8 +1482,8 @@ interface SetStateOptions {
  * // 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(),
  *     })
  *   );
  * }
@@ -1443,10 +1652,15 @@ declare class Alepha {
   get env(): Readonly<Env>;
   constructor(state?: Partial<State>);
   fork<R>(callback: () => R, data?: Record<string, any>): R;
-  get<T extends TAtomObject>(target: Atom<T>, scope?: StateScope): Static$1<T>;
+  get<R>(target: Computed<R>, scope?: StateScope): R;
+  get<T extends TAtomObject>(target: Atom<T>, scope?: StateScope): Static<T>;
   get<Key extends keyof State>(target: Key, scope?: StateScope): State[Key] | undefined;
   set<T extends TAtomObject>(target: Atom<T>, value: AtomStatic<T>): this;
   set<Key extends keyof State>(target: Key, value: State[Key] | undefined): this;
+  /**
+   * Reset an atom back to its declared default value.
+   */
+  reset<T extends TAtomObject>(target: Atom<T>): this;
   /**
    * True when start() is called.
    *
@@ -1660,7 +1874,7 @@ declare class Alepha {
    * @param schema - The schema object to apply environment variables to.
    * @return The schema object with environment variables applied.
    */
-  parseEnv<T extends TObject$1>(schema: T): Static$1<T>;
+  parseEnv<T extends TObject>(schema: T): Static<T>;
   /**
    * Get all environment variable schemas and their parsed values.
    *
@@ -1776,8 +1990,8 @@ interface State {
    *   db = $inject(DatabaseProvider);
    *   alepha = $inject(Alepha);
    *   env = $env(
-   *     t.object({
-   *       MIGRATE: t.optional(t.boolean()),
+   *     z.object({
+   *       MIGRATE: z.boolean().optional(),
    *     }),
    *   );
    *
@@ -1873,6 +2087,15 @@ interface Hooks {
      */
     prevValue: any;
   };
+  /**
+   * Triggered the first time an atom is registered in the state manager.
+   */
+  "state:register": {
+    /**
+     * The atom that was registered.
+     */
+    atom: Atom<any, any>;
+  };
 }
 //#endregion
 //#region ../../src/core/interfaces/Run.d.ts
@@ -1906,6 +2129,14 @@ interface RunOptions {
  */
 declare const OPTIONS: unique symbol;
 //#endregion
+//#region ../../src/core/errors/AlephaError.d.ts
+/**
+ * Default error class for Alepha.
+ */
+declare class AlephaError extends Error {
+  name: string;
+}
+//#endregion
 //#region ../../src/core/errors/AppNotStartedError.d.ts
 declare class AppNotStartedError extends AlephaError {
   readonly name = "AppNotStartedError";
@@ -1930,25 +2161,66 @@ declare class TooLateSubstitutionError extends AlephaError {
   constructor(original: string, substitution: string);
 }
 //#endregion
+//#region ../../src/core/errors/TypeBoxError.d.ts
+/** Minimal validation-error shape (decoupled from any schema lib). */
+interface ValidationErrorLike {
+  message: string;
+  instancePath?: string;
+  params?: unknown;
+}
+declare class TypeBoxError extends AlephaError {
+  name: string;
+  readonly cause: ValidationErrorLike;
+  readonly value: {
+    path: string;
+    message: string;
+  };
+  constructor(error: ValidationErrorLike);
+}
+interface TypeBoxErrorParams {
+  requiredProperties?: string[];
+}
+//#endregion
+//#region ../../src/core/helpers/coerceStrings.d.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.
+ */
+declare const coerceScalar: (schema: unknown, value: unknown) => unknown;
+/**
+ * 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.
+ */
+declare const coerceObject: (schema: unknown, value: Record<string, unknown>) => Record<string, unknown>;
+//#endregion
 //#region ../../src/core/schemas/pageSchema.d.ts
-declare const pageMetadataSchema: TObject<{
-  number: import("typebox").TInteger;
-  size: import("typebox").TInteger;
-  offset: import("typebox").TInteger;
-  numberOfElements: import("typebox").TInteger;
-  totalElements: import("typebox").TOptional<import("typebox").TInteger>;
-  totalPages: import("typebox").TOptional<import("typebox").TInteger>;
-  isEmpty: import("typebox").TBoolean;
-  isFirst: import("typebox").TBoolean;
-  isLast: import("typebox").TBoolean;
-  sort: import("typebox").TOptional<TObject<{
-    sorted: import("typebox").TBoolean;
-    fields: TArray<TObject<{
-      field: import("typebox").TString;
-      direction: import("typebox").TUnsafe<"asc" | "desc">;
-    }>>;
-  }>>;
-}>;
+declare const pageMetadataSchema: import("zod").ZodObject<{
+  number: import("zod").ZodInt;
+  size: import("zod").ZodInt;
+  offset: import("zod").ZodInt;
+  numberOfElements: import("zod").ZodInt;
+  totalElements: import("zod").ZodOptional<import("zod").ZodInt>;
+  totalPages: import("zod").ZodOptional<import("zod").ZodInt>;
+  isEmpty: import("zod").ZodBoolean;
+  isFirst: import("zod").ZodBoolean;
+  isLast: import("zod").ZodBoolean;
+  sort: import("zod").ZodOptional<import("zod").ZodObject<{
+    sorted: import("zod").ZodBoolean;
+    fields: import("zod").ZodArray<import("zod").ZodObject<{
+      field: import("zod").ZodString;
+      direction: import("zod").ZodEnum<{
+        asc: "asc";
+        desc: "desc";
+      }>;
+    }, import("zod/v4/core").$strip>>;
+  }, import("zod/v4/core").$strip>>;
+}, import("zod/v4/core").$strip>;
 /**
  * Create a pagination schema for the given object schema.
  *
@@ -1957,7 +2229,7 @@ declare const pageMetadataSchema: TObject<{
  *
  * @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);
  * ```
  *
@@ -1971,7 +2243,7 @@ declare const pageMetadataSchema: TObject<{
  * })
  * ```
  */
-declare const pageSchema: <T extends TObject | TRecord>(objectSchema: T, options?: TObjectOptions) => TPage<T>;
+declare const pageSchema: <T extends TObject | TRecord>(objectSchema: T) => TPage<T>;
 type TPage<T extends TObject | TRecord> = TObject<{
   content: TArray<T>;
   page: typeof pageMetadataSchema;
@@ -2021,7 +2293,7 @@ declare module "alepha" {
      */
     page<T extends TObject | TRecord>(itemSchema: T): TPage<T>;
   }
-} //# sourceMappingURL=pageSchema.d.ts.map
+}
 //#endregion
 //#region ../../src/core/helpers/createPagination.d.ts
 /**
@@ -2073,88 +2345,19 @@ declare function createPagination<T>(entities: T[], limit?: number, offset?: num
   direction: "asc" | "desc";
 }>): Page<T>;
 //#endregion
-//#region ../../src/core/helpers/jsonSchemaToTypeBox.d.ts
-/**
- * JSON Schema representation for conversion to TypeBox.
- */
-interface JsonSchemaObject {
-  type?: string | string[];
-  properties?: Record<string, JsonSchemaObject>;
-  required?: string[];
-  items?: JsonSchemaObject;
-  enum?: (string | number | boolean)[];
-  const?: unknown;
-  format?: string;
-  title?: string;
-  description?: string;
-  default?: unknown;
-  minLength?: number;
-  maxLength?: number;
-  minimum?: number;
-  maximum?: number;
-  exclusiveMinimum?: number;
-  exclusiveMaximum?: number;
-  multipleOf?: number;
-  pattern?: string;
-  minItems?: number;
-  maxItems?: number;
-  uniqueItems?: boolean;
-  "~options"?: {
-    trim?: boolean;
-    lowercase?: boolean;
-  };
-  oneOf?: JsonSchemaObject[];
-  anyOf?: JsonSchemaObject[];
-  allOf?: JsonSchemaObject[];
-  not?: JsonSchemaObject;
-  $ref?: string;
-}
+//#region ../../src/core/helpers/jsonSchemaToZod.d.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()`.
  */
-declare function jsonSchemaToTypeBox(schema: JsonSchemaObject): any;
+declare const jsonSchemaToZod: (schema: any) => ZType;
 //#endregion
 //#region ../../src/core/helpers/ref.d.ts
 /**
@@ -2169,6 +2372,64 @@ declare const __alephaRef: {
   };
   parent?: Service;
 };
+/**
+ * Note:
+ *
+ * This file is used to share context between $primitives and the Alepha core during the injection phase.
+ *
+ * There is no side effect as long as Alepha is not used concurrently in multiple contexts (which is not the case).
+ *
+ * // __alephaRef === undefined
+ * // begin alepha.with()
+ * //   __alephaRef.context = alepha
+ * //   ... injection phase ...
+ * //   __alephaRef.context = undefined
+ * // end alepha.with()
+ * // __alephaRef === undefined
+ *
+ * As .with() is synchronous, there is no risk of context leakage.
+ *
+ * ---------------------------------------------------------------------------------------------------------------------
+ *
+ * Why this helper?
+ *
+ * It allows to avoid passing Alepha instance to every $hook, $inject, etc. calls. It's a beautiful syntactic sugar.
+ *
+ * With sugar:
+ *
+ * class A {
+ *   on = $hook( ... ) // <- __alephaRef is set here
+ * }
+ *
+ * Without sugar:
+ *
+ * class A {
+ *   constructor(alepha: Alepha) {
+ *     this.on = $hook(alepha, ... ) // <- no need of __alephaRef
+ *   }
+ * }
+ *
+ * One main goal of Alepha is working with classes but without the class verbosity.
+ * Forcing to pass Alepha instance in constructors would be a step back in that direction!
+ *
+ * ---------------------------------------------------------------------------------------------------------------------
+ *
+ * TODO: harden the cursor against mid-instantiation throws.
+ *
+ * Today, the cleanup of `__alephaRef.alepha`, `__alephaRef.service`, `__alephaRef.parent`
+ * is performed by the caller after the synchronous instantiation returns. If the
+ * instantiation throws (e.g., a primitive factory blows up, or a user constructor
+ * raises), the cursor can be left holding stale references until the next
+ * instantiation overwrites them. In practice this is harmless because Alepha is
+ * single-threaded synchronous during boot and the next inject() rewrites the
+ * cursor — but it is a sharp edge for debuggers (frame inspection shows ghost
+ * state) and any future tooling that introspects __alephaRef out-of-band.
+ *
+ * Plan: wrap each cursor mutation in Alepha.ts in a try/finally that snapshots
+ * the previous value and restores it on exit (even on throw). Equivalent to a
+ * lexically-scoped "with" — pushes/pops cleanly. Should be a 5-line refactor in
+ * Alepha.ts:1131-1132 once we touch it.
+ */
 //#endregion
 //#region ../../src/core/interfaces/Pagination.d.ts
 /**
@@ -2287,8 +2548,8 @@ interface ContextPrimitive {
  *   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}")
@@ -2297,7 +2558,7 @@ interface ContextPrimitive {
  * run(alepha.with(App));
  * ```
  */
-declare const $env: <T extends TObject$1>(type: T) => Static$1<T>;
+declare const $env: <T extends TObject>(type: T) => Static<T>;
 //#endregion
 //#region ../../src/core/primitives/$hook.d.ts
 /**
@@ -2486,7 +2747,6 @@ declare const $mode: (args: ModeOptions) => boolean;
  * ```
  */
 declare function $pipeline<T extends (...args: any[]) => any>(options: PipelineOptions<T>): PipelinePrimitiveFn<T>;
-declare namespace $pipeline {}
 declare class PipelinePrimitive<TOptions extends PipelinePrimitiveOptions = PipelinePrimitiveOptions> extends Primitive<TOptions> {
   readonly handler: PipelineHandler;
   get middlewares(): MiddlewareMetadata[];
@@ -2595,7 +2855,7 @@ declare const $scope: () => Middleware;
  *
  * @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
@@ -2609,11 +2869,11 @@ declare const $scope: () => Middleware;
 declare const $state: <T extends TAtomObject, N extends string>(atom: Atom<T, N>) => Readonly<Static<T>>;
 //#endregion
 //#region ../../src/core/schemas/pageQuerySchema.d.ts
-declare const pageQuerySchema: import("typebox").TObject<{
-  page: import("typebox").TOptional<import("typebox").TInteger>;
-  size: import("typebox").TOptional<import("typebox").TInteger>;
-  sort: import("typebox").TOptional<import("typebox").TString>;
-}>;
+declare const pageQuerySchema: import("zod").ZodObject<{
+  page: import("zod").ZodOptional<import("zod").ZodDefault<import("zod").ZodInt>>;
+  size: import("zod").ZodOptional<import("zod").ZodDefault<import("zod").ZodInt>>;
+  sort: import("zod").ZodOptional<import("zod").ZodString>;
+}, import("zod/v4/core").$strip>;
 type PageQuery = Static<typeof pageQuerySchema>;
 //#endregion
 //#region ../../src/core/index.d.ts
@@ -2649,5 +2909,5 @@ declare const AlephaCore: Service<import("alepha").Module>;
  */
 declare const run: (entry: Alepha | Service | Array<Service>, opts?: RunOptions) => Alepha;
 //#endregion
-export { $atom, $context, $env, $hook, $inject, $memoize, $mode, $module, $pipeline, $scope, $state, ALS_PARENT, AbstractClass, Alepha, AlephaCore, AlephaDump, AlephaDumpEnvVariable, AlephaError, AlsProvider, AppNotStartedError, Async, AsyncFn, AsyncLocalStorageData, Atom, AtomOptions, AtomStatic, AtomWithValue, CircularDependencyError, CodecManager, CodecRegisterOptions, CompileOptions, CompiledEventExecutor, ContainerLockedError, ContextPrimitive, CreateMiddlewareOptions, DecodeOptions, EncodeOptions, EncodeResult, Encoding, Env, EventManager, FileLike, Format, Hook, HookOptions, HookPrimitive, Hooks, InjectOptions, InjectPrimitive, InstantiableClass, Json, JsonSchemaCodec, JsonSchemaObject, KIND, KeylessCodec, KeylessCodecOptions, KeylessJsonSchemaCodec, LogLevel, LoggerInterface, MaybePromise, MemoizeOptions, Middleware, MiddlewareMetadata, ModeOptions, Module, ModulePrimitiveOptions, OPTIONS, Page, PageMetadata, PageQuery, PageRequest, PipelineHandler, PipelineOptions, PipelinePrimitive, PipelinePrimitiveFn, PipelinePrimitiveOptions, Primitive, PrimitiveArgs, PrimitiveConfig, PrimitiveFactoryLike, RunFunction, SchemaCodec, SchemaValidator, Service, ServiceEntry, ServiceSubstitution, SetStateOptions, SortDirection, SortField, State, StateManager, StateScope, type Static, type StaticDecode, type StaticEncode, StreamLike, type TAny, type TArray, TAtomObject, type TBigInt, type TBoolean, TEnumOptions, TFile, type TInteger, type TKeysToIndexer, type TNull, type TNumber, type TNumberOptions, type TObject, type TObjectOptions, type TOptional, type TOptionalAdd, TPage, type TPick, type TProperties, type TRecord, type TSchema, TStream, type TString, type TStringOptions, TTextOptions, type TTuple, type TUnion, type TUnsafe, type TVoid, TextLength, TooLateSubstitutionError, Type, TypeBoxError, TypeBoxErrorParams, TypeGuard, TypeProvider, ValidateOptions, WithModule, __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, AbstractClass, Alepha, AlephaCore, AlephaDump, AlephaDumpEnvVariable, AlephaError, AlsProvider, AnyDep, AppNotStartedError, Async, AsyncFn, AsyncLocalStorageData, Atom, AtomOptions, AtomPersist, AtomStatic, AtomWithValue, CircularDependencyError, CodecManager, CodecRegisterOptions, CompileOptions, CompiledEventExecutor, Computed, ComputedOptions, ContainerLockedError, ContextPrimitive, CreateMiddlewareOptions, DecodeOptions, DepValues, EncodeOptions, EncodeResult, Encoding, Env, EventManager, FileLike, Hook, HookOptions, HookPrimitive, Hooks, Infer, InjectOptions, InjectPrimitive, InstantiableClass, Json, JsonSchemaCodec, KIND, KeylessCodec, KeylessCodecOptions, KeylessJsonSchemaCodec, LogLevel, LoggerInterface, MaybePromise, MemoizeOptions, Middleware, MiddlewareMetadata, ModeOptions, Module, ModulePrimitiveOptions, NumberOptions, OPTIONS, Page, PageMetadata, PageQuery, PageRequest, PipelineHandler, PipelineOptions, PipelinePrimitive, PipelinePrimitiveFn, PipelinePrimitiveOptions, Primitive, PrimitiveArgs, PrimitiveConfig, PrimitiveFactoryLike, RunFunction, SchemaCodec, SchemaOptions, SchemaOutput, SchemaValidator, Service, ServiceEntry, ServiceSubstitution, SetStateOptions, SortDirection, SortField, State, StateManager, StateScope, Static, StaticDecode, StaticEncode, StreamLike, StringOptions, TAny, TArray, TArrayOptions, TAtomObject, TBigInt, TBoolean, TEnumOptions, TFile, TInteger, TInterface, TKeysToIndexer, TNull, TNumber, TNumberOptions, TObject, TObjectOptions, TOmit, TOptional, TOptionalAdd, TPage, TPartial, TPick, TProperties, TRecord, TSchema, TSchemaOptions, TStream, TString, TStringOptions, TTextOptions, TTuple, TUnion, TUnsafe, TVoid, TextLength, TextOptions, TooLateSubstitutionError, Type, TypeBoxError, TypeBoxErrorParams, TypeProvider, ValidateOptions, ValidationErrorLike, WithModule, Z, ZObject, ZType, Z_LIMITS, __alephaRef, coerceObject, coerceScalar, createMiddleware, createPagination, createPrimitive, isClass, isFileLike, isTypeFile, jsonSchemaToZod, pageMetadataSchema, pageQuerySchema, pageSchema, run, z };
 //# sourceMappingURL=index.d.ts.map