hanzio 1.1.0 → 2.0.0

package/dist/state/index.d.ts

@@ -46,6 +46,10 @@ export interface StateMachineConfig<TState extends string, TAction extends strin
     stateTransitions: Record<TState, readonly TState[]>;
     validators?: Partial<Record<TState, ValidatorFn<TState, TContext, TAction>>>;
     globalValidator?: ValidatorFn<TState, TContext, TAction>;
+    actionValidators?: Partial<Record<TAction, ValidatorFn<TState, TContext, TAction>>>;
+    initialState?: TState;
+    onTransition?: (context: TContext, from: TState, to: TState, action: TAction) => void | Promise<void>;
+    applyTransition?: boolean;
     actions?: {
         [K in TAction]?: ActionHandlerFn<TContext, TActionDataMap[K], TActionResultMap[K]>;
     };
@@ -74,6 +78,12 @@ export declare class SimpleStateMachine<TState extends string, TAction extends s
      * @returns Map of target states to validation results (true if any action to that state validates)
      */
     getPossibleTransitions(): Promise<Partial<Record<TState, ValidationResult>>>;
+    /**
+     * Checks whether an action can be executed from the current state
+     *
+     * @returns true, or the reason the action is not allowed
+     */
+    canExecute(action: TAction): Promise<ValidationResult>;
     /**
      * Executes an action with additional data
      *
@@ -99,3 +109,14 @@ export declare class SimpleStateMachine<TState extends string, TAction extends s
      */
     getInitialState(): TState | undefined;
 }
+/**
+ * Defines a state machine config once and binds it to items on demand
+ *
+ * @example
+ * const orderMachine = createStateMachine<Status, Action, Order>(config)
+ * const machine = orderMachine.for(order, 'status')
+ */
+export declare function createStateMachine<TState extends string, TAction extends string, TContext, TActionDataMap extends ActionDataMap<TAction> = ActionDataMap<TAction>, TActionResultMap extends ActionResultMap<TAction> = ActionResultMap<TAction>>(config: StateMachineConfig<TState, TAction, TContext, TActionDataMap, TActionResultMap>): {
+    config: StateMachineConfig<TState, TAction, TContext, TActionDataMap, TActionResultMap>;
+    for: (item: TContext, stateKey: StateKey<TContext, TState>) => SimpleStateMachine<TState, TAction, TContext, TActionDataMap, TActionResultMap>;
+};

package/dist/storage/index.d.ts

@@ -0,0 +1,58 @@
+/** The part of the Web `Storage` API (`localStorage`, `sessionStorage`) used here. */
+export interface SyncStorageLike {
+    getItem(key: string): string | null;
+    setItem(key: string, value: string): void;
+    removeItem(key: string): void;
+}
+/** An async key-value store such as React Native's `AsyncStorage`. */
+export interface AsyncStorageLike {
+    getItem(key: string): Promise<string | null>;
+    setItem(key: string, value: string): Promise<void>;
+    removeItem(key: string): Promise<void>;
+}
+export interface StorageItemOptions<T> {
+    key: string;
+    /** Returned when nothing is stored or the stored value can't be read. */
+    fallback: T;
+    /** Validates the deserialized value, e.g. `schema.parse`. Throwing means `fallback`. */
+    parse?: (raw: unknown) => T;
+    /** Defaults to `JSON.stringify`. */
+    serialize?: (value: T) => string;
+    /** Defaults to `JSON.parse`. */
+    deserialize?: (raw: string) => unknown;
+}
+export interface StorageItem<T> {
+    readonly key: string;
+    get(): T;
+    set(value: T): void;
+    remove(): void;
+    /**
+     * Calls `listener` when another tab changes this key (the `storage` event).
+     * A no-op outside browsers. Returns an unsubscribe function.
+     */
+    subscribe(listener: (value: T) => void): () => void;
+}
+export interface AsyncStorageItem<T> {
+    readonly key: string;
+    get(): Promise<T>;
+    set(value: T): Promise<void>;
+    remove(): Promise<void>;
+}
+/** A `Map`-backed `SyncStorageLike`, for tests, SSR, or as a stand-in. */
+export declare function createMemoryStorage(): SyncStorageLike;
+/**
+ * A typed value persisted in `localStorage` (or any `SyncStorageLike`). Never
+ * throws: missing, corrupt or invalid data reads as `fallback`, and when the
+ * storage throws (quota, Safari private mode, sandboxed iframes) the latest
+ * value is kept in memory for this item, so reads stay consistent this session.
+ */
+export declare function createStorageItem<T>(options: StorageItemOptions<T> & {
+    storage?: SyncStorageLike;
+}): StorageItem<T>;
+/**
+ * `createStorageItem` for async stores such as React Native's `AsyncStorage`.
+ * Never rejects; same fallback and in-memory mirror behavior.
+ */
+export declare function createAsyncStorageItem<T>(options: StorageItemOptions<T> & {
+    storage: AsyncStorageLike;
+}): AsyncStorageItem<T>;

package/dist/string/index.d.ts

@@ -1,8 +1,81 @@
+import type { Result } from '../promise';
 export type JsonValue = string | number | boolean | null | JsonObject | JsonArray;
 export type JsonObject = {
     [key: string]: JsonValue | undefined;
 };
 export type JsonArray = Array<JsonValue | undefined>;
-export declare function extractNumber(value: string | null | undefined): number | undefined;
+/**
+ * Parses the first number-like token in a string. Only a `-` directly before
+ * the digits is a sign, so `'2024-01-05'` gives `2024`. Whitespace and the
+ * separator that isn't `decimalSeparator` are treated as thousands separators:
+ * `'1,234.56'` gives `1234.56`, and `'1.234,56'` with `decimalSeparator: ','`
+ * gives `1234.56`.
+ */
+export declare function extractNumber(value: string | null | undefined, options?: {
+    decimalSeparator?: '.' | ',';
+}): number | undefined;
+/**
+ * A stable, short, non-cryptographic hash key (32-bit, 8 hex chars) for
+ * JSON-like input. Object key order and query-string parameter order don't
+ * matter. Collisions become likely above ~10k distinct inputs; use `sha256Id`
+ * where that matters.
+ */
 export declare function generateId(input: JsonValue | undefined): string;
-export declare function slugify(value: string): string;
+/** Like `generateId`, but a SHA-256 hex digest truncated to `length` chars. */
+export declare function sha256Id(input: JsonValue | undefined, length?: number): Promise<string>;
+export type SlugifyOptions = {
+    /** Placed between words (default `'-'`). */
+    separator?: string;
+    /** Default `true`. */
+    lowercase?: boolean;
+    /** Cuts the slug to at most this many characters, without a trailing separator. */
+    maxLength?: number;
+};
+/**
+ * Turns text into a URL slug: strips accents, turns `&` into `and`, splits
+ * words on whitespace and `-_/,:;·`, and drops every other non-ASCII-alphanumeric
+ * character.
+ */
+export declare function slugify(value: string, options?: SlugifyOptions): string;
+/**
+ * JSON.stringify with sorted object keys, so `{ a, b }` and `{ b, a }` produce
+ * the same string. Also encodes values JSON drops or rejects: `bigint`,
+ * `Map` and `Set`. Use it for cache and dedupe keys.
+ */
+export declare function stableStringify(value: unknown): string;
+/**
+ * Cuts text to at most `maxLength` user-visible characters, ellipsis included.
+ * Never splits an emoji or accented letter, and drops whitespace before the
+ * ellipsis. With `wordBoundary`, cuts at the last space unless that would leave
+ * nothing.
+ */
+export declare function truncate(text: string, maxLength: number, options?: {
+    ellipsis?: string;
+    wordBoundary?: boolean;
+}): string;
+/** Collapses every whitespace run (NBSP and newlines included) to one space and trims. */
+export declare function normalizeWhitespace(text: string): string;
+/**
+ * Escapes text for literal use in a `RegExp`. `-` becomes `\x2d` so the result
+ * is also valid with the `u` and `v` flags.
+ */
+export declare function escapeRegExp(text: string): string;
+/** Lowercases and strips accents, so `'Ærø Café'` becomes `'aero cafe'`. */
+export declare function foldForSearch(text: string): string;
+/**
+ * True when every whitespace-separated query term appears in at least one
+ * field, ignoring case and accents. An empty query matches everything.
+ */
+export declare function matchesSearch(query: string, ...fields: (string | null | undefined)[]): boolean;
+/**
+ * Up to `max` (default 2) uppercase letters for an avatar, or `''` when the
+ * value has no letters (phone numbers, `'—'`). One word gives its first
+ * letters (`'Ada'` → `'AD'`), several give first and last (`'Hans Kristoffer
+ * Hansen'` → `'HH'`). An email is read as its local part without the `+tag`:
+ * `'ada.lovelace+news@x.com'` → `'AL'`.
+ */
+export declare function initials(name: string | null | undefined, options?: {
+    max?: number;
+}): string;
+/** `JSON.parse` that returns a `Result` instead of throwing. */
+export declare function safeJsonParse<T = unknown>(text: string): Result<T, SyntaxError>;

package/dist/typedswitch/index.d.ts

@@ -67,7 +67,11 @@
 type RawHandlerReturnType<T> = T extends (...args: any[]) => infer R ? R : never;
 /** Get union of all raw return types from a cases object's values */
 type RawCasesReturnType<Cases> = {
-    [K in keyof Cases]: Cases[K] extends undefined ? never : RawHandlerReturnType<Cases[K]>;
+    [K in keyof Cases]: RawHandlerReturnType<Cases[K]>;
+}[keyof Cases];
+/** Only required, defined handlers guarantee that a case is handled. */
+type HandledCaseKeys<Cases> = {
+    [K in keyof Cases]-?: {} extends Pick<Cases, K> ? never : undefined extends Cases[K] ? never : K;
 }[keyof Cases];
 /** Cases for string input - all cases required */
 export type StringSwitchCases<T extends string, R> = {
@@ -77,26 +81,28 @@ export type StringSwitchCases<T extends string, R> = {
 export type PartialStringSwitchCases<T extends string, R> = {
     [K in T]?: (value: K) => R | Promise<R>;
 };
+/** Discriminant values supported in object mode. Cases are keyed by `${value}`. */
+type Discriminant = string | number | boolean;
+/** Discriminant values of `V` whose case key (`${value}`) is in `Keys` */
+type ValuesForKeys<V, Keys> = V extends Discriminant ? `${V}` extends `${Keys & (string | number)}` ? V : never : never;
+type ObjectCases<T, K extends keyof T, R> = {
+    [V in Extract<T[K], Discriminant> as `${V}`]: (value: Extract<T, Record<K, V>>) => R;
+};
+type PartialObjectCases<T, K extends keyof T, R> = {
+    [V in Extract<T[K], Discriminant> as `${V}`]?: (value: Extract<T, Record<K, V>>) => R;
+};
 /** Cases for object input with custom key - all cases required */
-export type ObjectSwitchCases<T, K extends keyof T, R> = T[K] extends string ? {
-    [V in T[K]]: (value: Extract<T, Record<K, V>>) => R | Promise<R>;
-} : never;
+export type ObjectSwitchCases<T, K extends keyof T, R> = T[K] extends Discriminant ? ObjectCases<T, K, R | Promise<R>> : never;
 /** Partial cases for object input with custom key (when default is provided) */
-export type PartialObjectSwitchCases<T, K extends keyof T, R> = T[K] extends string ? {
-    [V in T[K]]?: (value: Extract<T, Record<K, V>>) => R | Promise<R>;
-} : never;
+export type PartialObjectSwitchCases<T, K extends keyof T, R> = T[K] extends Discriminant ? PartialObjectCases<T, K, R | Promise<R>> : never;
 export declare function typedSwitch<T extends string, Cases extends {
     [K in T]: (value: K) => unknown;
 }>(value: T, cases: Cases): RawCasesReturnType<Cases>;
 export declare function typedSwitch<T extends string, Cases extends {
     [K in T]?: (value: K) => unknown;
-}, DefaultCase extends (value: T) => unknown>(value: T, cases: Cases, defaultCase: DefaultCase): RawCasesReturnType<Cases> | RawHandlerReturnType<DefaultCase>;
-export declare function typedSwitch<T extends Record<string, unknown>, K extends keyof T, TKey extends T[K] & string, Cases extends {
-    [V in TKey]: (value: Extract<T, Record<K, V>>) => unknown;
-}>(value: T, key: K, cases: Cases): RawCasesReturnType<Cases>;
-export declare function typedSwitch<T extends Record<string, unknown>, K extends keyof T, TKey extends T[K] & string, Cases extends {
-    [V in TKey]?: (value: Extract<T, Record<K, V>>) => unknown;
-}, DefaultCase extends (value: T) => unknown>(value: T, key: K, cases: Cases, defaultCase: DefaultCase): RawCasesReturnType<Cases> | RawHandlerReturnType<DefaultCase>;
+}, DefaultCase extends (value: Exclude<T, HandledCaseKeys<Cases>>) => unknown>(value: T, cases: Cases, defaultCase: DefaultCase): RawCasesReturnType<Cases> | RawHandlerReturnType<DefaultCase>;
+export declare function typedSwitch<T extends object, K extends keyof T, Cases extends ObjectCases<T, K, unknown>>(value: T, key: K, cases: Cases): RawCasesReturnType<Cases>;
+export declare function typedSwitch<T extends object, K extends keyof T, Cases extends PartialObjectCases<T, K, unknown>, DefaultCase extends (value: Exclude<T, Record<K, ValuesForKeys<T[K], HandledCaseKeys<Cases>>>>) => unknown>(value: T, key: K, cases: Cases, defaultCase: DefaultCase): RawCasesReturnType<Cases> | RawHandlerReturnType<DefaultCase>;
 export declare function typedSwitch<Constraint, T extends string = string>(value: T, cases: {
     [K in T]: (value: K) => Constraint;
 }): Constraint;
@@ -109,16 +115,21 @@ export declare function typedSwitch<Constraint, T extends string = string>(value
 export declare function typedSwitch<Constraint, T extends string = string>(value: T, cases: {
     [K in T]?: (value: K) => Constraint | Promise<Constraint>;
 }, defaultCase: (value: T) => Constraint | Promise<Constraint>): Constraint | Promise<Constraint>;
-export declare function typedSwitch<Constraint, T extends Record<string, unknown> = Record<string, unknown>, K extends keyof T = keyof T>(value: T, key: K, cases: {
-    [V in T[K] & string]: (value: Extract<T, Record<K, V>>) => Constraint;
-}): Constraint;
-export declare function typedSwitch<Constraint, T extends Record<string, unknown> = Record<string, unknown>, K extends keyof T = keyof T>(value: T, key: K, cases: {
-    [V in T[K] & string]: (value: Extract<T, Record<K, V>>) => Constraint | Promise<Constraint>;
-}): Constraint | Promise<Constraint>;
-export declare function typedSwitch<Constraint, T extends Record<string, unknown> = Record<string, unknown>, K extends keyof T = keyof T>(value: T, key: K, cases: {
-    [V in T[K] & string]?: (value: Extract<T, Record<K, V>>) => Constraint;
-}, defaultCase: (value: T) => Constraint): Constraint;
-export declare function typedSwitch<Constraint, T extends Record<string, unknown> = Record<string, unknown>, K extends keyof T = keyof T>(value: T, key: K, cases: {
-    [V in T[K] & string]?: (value: Extract<T, Record<K, V>>) => Constraint | Promise<Constraint>;
-}, defaultCase: (value: T) => Constraint | Promise<Constraint>): Constraint | Promise<Constraint>;
+export declare function typedSwitch<Constraint, T extends Record<string, unknown> = Record<string, unknown>, K extends keyof T = keyof T>(value: T, key: K, cases: ObjectCases<T, K, Constraint>): Constraint;
+export declare function typedSwitch<Constraint, T extends Record<string, unknown> = Record<string, unknown>, K extends keyof T = keyof T>(value: T, key: K, cases: ObjectCases<T, K, Constraint | Promise<Constraint>>): Constraint | Promise<Constraint>;
+export declare function typedSwitch<Constraint, T extends Record<string, unknown> = Record<string, unknown>, K extends keyof T = keyof T>(value: T, key: K, cases: PartialObjectCases<T, K, Constraint>, defaultCase: (value: T) => Constraint): Constraint;
+export declare function typedSwitch<Constraint, T extends Record<string, unknown> = Record<string, unknown>, K extends keyof T = keyof T>(value: T, key: K, cases: PartialObjectCases<T, K, Constraint | Promise<Constraint>>, defaultCase: (value: T) => Constraint | Promise<Constraint>): Constraint | Promise<Constraint>;
+/**
+ * Exhaustiveness helper for regular `switch` statements. Place it in the
+ * `default` branch: it only type-checks when every case has been handled, and
+ * throws if an unexpected value reaches it at runtime.
+ *
+ * @example
+ * switch (status) {
+ *   case 'success': return 1
+ *   case 'error': return 0
+ *   default: return assertNever(status)
+ * }
+ */
+export declare function assertNever(value: never, message?: string): never;
 export {};

package/dist/types/index.d.ts

@@ -0,0 +1,11 @@
+export type MaybePromise<T> = T | Promise<T>;
+/** Union of an object type's values. */
+export type ValueOf<T> = T[keyof T];
+/** Union of an array or tuple's element types. */
+export type ElementOf<T extends readonly unknown[]> = T[number];
+export type NonEmptyArray<T> = [T, ...T[]];
+/** Flattens intersections into one object type so hovers stay readable. */
+export type Simplify<T> = {
+    [K in keyof T]: T[K];
+} & {};
+export type Nullable<T> = T | null | undefined;

package/dist/url/index.d.ts

@@ -1 +1,50 @@
-export declare function getDomainFaviconUrl(domain: string, size?: number): string;
+export type UrlQueryValue = string | number | boolean | null | undefined;
+export type UrlQueryParams = Record<string, UrlQueryValue | readonly UrlQueryValue[]>;
+/**
+ * Serializes query params. Arrays repeat the key (`a=1&a=2`); `null` and
+ * `undefined` are skipped. Returns the string without a leading `?`.
+ */
+export declare function buildQueryString(params: UrlQueryParams, options?: {
+    encode?: boolean;
+}): string;
+/**
+ * Replaces `:name` placeholders with encoded values. Throws when a placeholder
+ * has no value. Only `:` followed by a letter or `_` counts, so ports like
+ * `:8080` are left alone.
+ */
+export declare function replacePathParams(path: string, params?: Record<string, string | number | boolean | undefined>): string;
+/** Joins base and path with exactly one `/`, fills `:params`, appends query. */
+export declare function buildUrl(base: string, path?: string, options?: {
+    params?: Record<string, string | number | boolean | undefined>;
+    query?: UrlQueryParams;
+}): string;
+/**
+ * Normalizes a domain or URL to its origin: adds `https://` when no scheme is
+ * given and strips any path, query or trailing slash.
+ */
+export declare function normalizeDomain(input: string): string;
+/** Accepts a bare domain (`example.com`) or a full URL. */
+export declare function getDomainFaviconUrl(domainOrUrl: string, size?: number): string;
+/** Removes trailing slashes: `'https://x.com/a/'` → `'https://x.com/a'`. */
+export declare function trimTrailingSlash(url: string): string;
+/** Prefixes `/` unless the path already starts with one. */
+export declare function ensureLeadingSlash(path: string): string;
+type MailtoRecipients = string | readonly string[];
+/**
+ * Builds a `mailto:` link. Spaces become `%20` (not `+`, which mail clients
+ * show literally) and body line breaks become `%0D%0A`.
+ */
+export declare function buildMailto(options: {
+    to?: MailtoRecipients;
+    cc?: MailtoRecipients;
+    bcc?: MailtoRecipients;
+    subject?: string;
+    body?: string;
+}): string;
+/**
+ * Milliseconds to wait from a `Retry-After` header: delta-seconds (fractions
+ * allowed) or an HTTP date relative to `now`. Past dates and negative values
+ * give `0`; a missing or invalid value gives `undefined`.
+ */
+export declare function parseRetryAfter(value: string | null | undefined, now?: number): number | undefined;
+export {};

package/dist/zod/index.d.ts

@@ -1,8 +1,37 @@
 import { z } from 'zod';
+import { toArray } from '../array';
+import { type Result } from '../promise';
+import type { JsonObject, JsonValue } from '../string';
+export { getEnumValues, getObjectShape, unwrapSchema, zodDefaults } from './introspect';
 export { jsonToZodSchemaMapper } from './jsonToZodSchemaMapper';
-export { toGteLteFilter, type ZodMinMaxFilter, zodMinMaxFilter } from './zodMinMaxFilter';
+export { createMinMaxFilter, type MinMaxFilter, toGteLteFilter, toGtLtFilter, type ZodMinMaxFilter, zodMinMaxFilter } from './zodMinMaxFilter';
 export { zodToExample, zodToTypeString } from './zodToTypeString';
 export type GenericId<TypeName extends string> = string & z.$brand<TypeName>;
-export declare function createZId<TypeName extends string>(typeName: TypeName): PropertyKey extends TypeName ? z.ZodString : z.core.$ZodBranded<z.ZodString, TypeName, "out">;
+export declare function createZId<TypeName extends string>(typeName: TypeName, { prefix }?: {
+    prefix?: string;
+}): PropertyKey extends TypeName ? z.ZodString : z.core.$ZodBranded<z.ZodString, TypeName, "out">;
+/** Branded string id: `Id<'User'>` is not assignable to `Id<'Organization'>`. */
+export type Id<TypeName extends string> = GenericId<TypeName>;
+/** Brands a string without checking it (fixtures, trusted sources). */
+export declare function asId<TypeName extends string>(value: string): Id<TypeName>;
+/** Validates a non-empty string and brands it; throws a `ZodError` otherwise. */
+export declare function parseId<TypeName extends string>(typeName: TypeName, value: unknown): Id<TypeName>;
+export declare function safeParseId<TypeName extends string>(typeName: TypeName, value: unknown): Result<Id<TypeName>, z.ZodError>;
+/**
+ * Binds the id helpers to a project's union of entity names once:
+ * `export const { zId, asId, parseId, safeParseId } = createIdHelpers<'User' | 'Organization'>()`
+ */
+export declare function createIdHelpers<TypeNames extends string>(): {
+    zId: <T extends TypeNames>(typeName: T) => PropertyKey extends T ? z.ZodString : z.core.$ZodBranded<z.ZodString, T, "out">;
+    asId: <T extends TypeNames>(value: string) => Id<T>;
+    parseId: <T extends TypeNames>(typeName: T, value: unknown) => Id<T>;
+    safeParseId: <T extends TypeNames>(typeName: T, value: unknown) => Result<Id<T>, z.ZodError<unknown>>;
+};
+/** Any JSON value (no `undefined`, `NaN` or `Infinity`). */
+export declare const zJsonValue: z.ZodType<JsonValue>;
+export declare const zJsonObject: z.ZodType<JsonObject>;
+/** `JSON.parse` + `schema.safeParse` without throwing. */
+export declare function parseJson<S extends z.ZodType>(text: string, schema: S): Result<z.output<S>, SyntaxError | z.ZodError>;
 export declare function zSingleOrArray<T extends z.ZodType>(schema: T): z.ZodUnion<readonly [z.ZodArray<T>, T]>;
-export declare function normalizeSingleOrArray<T>(value: T | readonly T[] | null | undefined): T[];
+/** @deprecated Use `toArray` from `hanzio`. */
+export declare const normalizeSingleOrArray: typeof toArray;

package/dist/zod/introspect.d.ts

@@ -0,0 +1,19 @@
+import type { z } from 'zod';
+import { type Schema } from './zodToTypeString';
+/**
+ * Strips optional/nullable/default/prefault/nonoptional/catch/readonly/lazy
+ * wrappers and pipes (input side) until the schema that carries the shape.
+ */
+export declare function unwrapSchema(schema: Schema): Schema;
+/** Values of a (possibly wrapped) `z.enum`, stringified; `undefined` for other schemas. */
+export declare function getEnumValues(schema: Schema): string[] | undefined;
+/** Shape of a (possibly wrapped) `z.object`; `undefined` for other schemas. */
+export declare function getObjectShape(schema: Schema): Readonly<Record<string, Schema>> | undefined;
+/**
+ * Initial form state for a schema: `.default()` values, `undefined` for
+ * optional, `null` for nullable, first enum/literal/union option, `''`, `0`,
+ * `false`, `[]`, and objects filled per key. Other types give `undefined`.
+ * The result is typed as the schema output but is NOT validated (`''` fails
+ * `.min(1)`, dates stay `undefined`).
+ */
+export declare function zodDefaults<S extends Schema>(schema: S): z.output<S>;

package/dist/zod/jsonToZodSchemaMapper.d.ts

@@ -1,6 +1,8 @@
 import { z } from 'zod';
+type ObjectConfig<V> = V extends Record<string, unknown> ? PropertyConfig<V, Record<string, any>> : never;
+type NestedConfig<V> = V extends readonly (infer E)[] ? ObjectConfig<E> : ObjectConfig<V>;
 type PropertyConfig<T, U> = {
-    [K in keyof T]?: (jsonObject: U) => T[K];
+    [K in keyof T]?: ((jsonObject: U) => T[K]) | NestedConfig<NonNullable<T[K]>>;
 };
 export declare function jsonToZodSchemaMapper<T extends z.ZodType, U extends Record<string, any>>(jsonObject: U, zodSchema: T, config: PropertyConfig<z.infer<T>, U>): z.infer<T>;
 export {};

package/dist/zod/zodMinMaxFilter.d.ts

@@ -1,14 +1,33 @@
 import { z } from 'zod';
+/**
+ * Creates a `{ min?, max? }` filter schema for any comparable value schema,
+ * e.g. `createMinMaxFilter(z.coerce.date())`.
+ */
+export declare function createMinMaxFilter<T extends z.ZodType>(schema: T): z.ZodObject<{
+    min: z.ZodOptional<T>;
+    max: z.ZodOptional<T>;
+}, z.core.$strip>;
 export declare const zodMinMaxFilter: z.ZodObject<{
     min: z.ZodOptional<z.ZodNumber>;
     max: z.ZodOptional<z.ZodNumber>;
 }, z.core.$strip>;
 export type ZodMinMaxFilter = z.infer<typeof zodMinMaxFilter>;
+export type MinMaxFilter<T> = {
+    min?: T;
+    max?: T;
+};
 /**
  * Maps a min/max filter to a generic `gte`/`lte` range object (e.g. ORM-friendly).
  * Returns `undefined` if both bounds are undefined.
  */
-export declare function toGteLteFilter(filter: ZodMinMaxFilter | undefined): {
-    gte?: number;
-    lte?: number;
+export declare function toGteLteFilter<T>(filter: MinMaxFilter<T> | undefined): {
+    gte?: T;
+    lte?: T;
+} | undefined;
+/**
+ * Exclusive variant of `toGteLteFilter`, mapping min/max to `gt`/`lt`.
+ */
+export declare function toGtLtFilter<T>(filter: MinMaxFilter<T> | undefined): {
+    gt?: T;
+    lt?: T;
 } | undefined;

package/dist/zod/zodToTypeString.d.ts

@@ -1,9 +1,14 @@
 import type { z } from 'zod';
+export type Schema = z.core.$ZodType;
+export type Def = z.core.$ZodTypes['_zod']['def'];
+export declare function walk<T>(schema: Schema, onCycle: T, fn: (def: Def) => T): T;
+export declare function defOf(schema: Schema): Def;
 /**
  * Convert a Zod schema to a human-readable TypeScript-like interface string
  */
-export declare function zodToTypeString(schema: z.ZodType, indent?: number): string;
+export declare function zodToTypeString(schema: Schema, indent?: number): string;
 /**
- * Generate example JSON from a Zod schema
+ * Generate example JSON from a Zod schema. Values are JSON-safe: dates become ISO
+ * strings, bigints numbers, sets arrays and maps/records empty objects.
  */
-export declare function zodToExample(schema: z.ZodType): unknown;
+export declare function zodToExample(schema: Schema): unknown;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "hanzio",
-  "version": "1.1.0",
+  "version": "2.0.0",
   "description": "A lightweight set of utility functions for TypeScript",
   "type": "module",
   "module": "./dist/src/index.js",
@@ -28,6 +28,7 @@
     "dist",
     "!src/**/*.test.ts"
   ],
+  "sideEffects": false,
   "exports": {
     ".": {
       "types": "./dist/index.d.ts",
@@ -35,6 +36,72 @@
       "import": "./dist/src/index.js",
       "default": "./dist/src/index.js"
     },
+    "./zod": {
+      "types": "./dist/zod/index.d.ts",
+      "bun": "./src/zod/index.ts",
+      "import": "./dist/src/zod/index.js",
+      "default": "./dist/src/zod/index.js"
+    },
+    "./api-wrapper": {
+      "types": "./dist/api-wrapper/index.d.ts",
+      "bun": "./src/api-wrapper/index.ts",
+      "import": "./dist/src/api-wrapper/index.js",
+      "default": "./dist/src/api-wrapper/index.js"
+    },
+    "./api-wrapper/testing": {
+      "types": "./dist/api-wrapper/testing.d.ts",
+      "bun": "./src/api-wrapper/testing.ts",
+      "import": "./dist/src/api-wrapper/testing.js",
+      "default": "./dist/src/api-wrapper/testing.js"
+    },
+    "./jwt": {
+      "types": "./dist/jwt/index.d.ts",
+      "bun": "./src/jwt/index.ts",
+      "import": "./dist/src/jwt/index.js",
+      "default": "./dist/src/jwt/index.js"
+    },
+    "./sitemap": {
+      "types": "./dist/sitemap/index.d.ts",
+      "bun": "./src/sitemap/index.ts",
+      "import": "./dist/src/sitemap/index.js",
+      "default": "./dist/src/sitemap/index.js"
+    },
+    "./p-queue": {
+      "types": "./dist/p-queue/index.d.ts",
+      "bun": "./src/p-queue/index.ts",
+      "import": "./dist/src/p-queue/index.js",
+      "default": "./dist/src/p-queue/index.js"
+    },
+    "./cool-console-log": {
+      "types": "./dist/cool-console-log/index.d.ts",
+      "bun": "./src/cool-console-log/index.ts",
+      "import": "./dist/src/cool-console-log/index.js",
+      "default": "./dist/src/cool-console-log/index.js"
+    },
+    "./format": {
+      "types": "./dist/format/index.d.ts",
+      "bun": "./src/format/index.ts",
+      "import": "./dist/src/format/index.js",
+      "default": "./dist/src/format/index.js"
+    },
+    "./crypto": {
+      "types": "./dist/crypto/index.d.ts",
+      "bun": "./src/crypto/index.ts",
+      "import": "./dist/src/crypto/index.js",
+      "default": "./dist/src/crypto/index.js"
+    },
+    "./storage": {
+      "types": "./dist/storage/index.d.ts",
+      "bun": "./src/storage/index.ts",
+      "import": "./dist/src/storage/index.js",
+      "default": "./dist/src/storage/index.js"
+    },
+    "./i18n": {
+      "types": "./dist/i18n/index.d.ts",
+      "bun": "./src/i18n/index.ts",
+      "import": "./dist/src/i18n/index.js",
+      "default": "./dist/src/i18n/index.js"
+    },
     "./secrets": {
       "types": "./dist/secrets/index.d.ts",
       "bun": "./src/secrets/index.ts",
@@ -46,31 +113,44 @@
       "bun": "./src/secrets/vite.ts",
       "import": "./dist/src/secrets/vite.js",
       "default": "./dist/src/secrets/vite.js"
+    },
+    "./secrets/worker": {
+      "types": "./dist/secrets/worker.d.ts",
+      "bun": "./src/secrets/worker.ts",
+      "import": "./dist/src/secrets/worker.js",
+      "default": "./dist/src/secrets/worker.js"
     }
   },
   "scripts": {
-    "build": "bun run build:js && bun run build:types",
-    "build:js": "bun build ./src/index.ts ./src/zod/index.ts ./src/api-wrapper/index.ts ./src/jwt/index.ts ./src/sitemap/index.ts ./src/p-queue/index.ts ./src/secrets/index.ts ./src/secrets/infisical.ts ./src/secrets/loaders.ts ./src/secrets/vite.ts --outdir ./dist --target node --packages external",
+    "build": "rm -rf dist && bun run build:js && bun run build:types",
+    "build:js": "bun build ./src/index.ts ./src/zod/index.ts ./src/api-wrapper/index.ts ./src/api-wrapper/testing.ts ./src/jwt/index.ts ./src/sitemap/index.ts ./src/p-queue/index.ts ./src/cool-console-log/index.ts ./src/format/index.ts ./src/crypto/index.ts ./src/storage/index.ts ./src/i18n/index.ts ./src/secrets/index.ts ./src/secrets/vite.ts ./src/secrets/worker.ts --outdir ./dist --target node --packages external --splitting",
     "build:types": "tsgo -p tsconfig.build.json",
     "prepublishOnly": "bun run build",
-    "publish:patch": "npm version patch && npm publish",
-    "publish:minor": "npm version minor && npm publish",
-    "publish:major": "npm version major && npm publish",
     "test": "bun test",
     "lint": "bun run typecheck && bun biome check",
     "lint:write": "bun run typecheck && bun biome check --write",
     "typecheck": "tsgo --noEmit",
-    "prepare": "husky"
+    "prepare": "husky",
+    "test:secrets:runtime": "bun run build && node scripts/verify-secrets.mjs",
+    "test:exports": "bun run build && node scripts/verify-exports.mjs"
   },
   "devDependencies": {
     "@biomejs/biome": "^2.4.6",
+    "@opentelemetry/api": "^1.9.1",
     "@types/bun": "latest",
     "@typescript/native-preview": "^7.0.0-dev.20260306.1",
     "husky": "^9.1.7",
+    "miniflare": "^4.20260730.0",
     "typescript": "^5.7.0",
+    "vite": "^8.2.2",
     "zod": "^4.3.6"
   },
   "peerDependencies": {
     "zod": "^4.3.6"
+  },
+  "peerDependenciesMeta": {
+    "zod": {
+      "optional": true
+    }
   }
 }