typetify 1.0.0 → 2.1.0

package/dist/chunk-CWHYQWNU.mjs

@@ -0,0 +1,224 @@
+import { __export } from './chunk-J5LGTIGS.mjs';
+
+// src/narrowing/index.ts
+var narrowing_exports = {};
+__export(narrowing_exports, {
+  allOf: () => allOf,
+  arrayOf: () => arrayOf,
+  assertCondition: () => assertCondition,
+  assertDefined: () => assertDefined,
+  assertNotNull: () => assertNotNull,
+  assertType: () => assertType,
+  chainNullable: () => chainNullable,
+  createAssertion: () => createAssertion,
+  createDiscriminantGuard: () => createDiscriminantGuard,
+  excludeNull: () => excludeNull,
+  excludeNullish: () => excludeNullish,
+  excludeUndefined: () => excludeUndefined,
+  exhaustiveCheck: () => exhaustiveCheck,
+  filterBy: () => filterBy,
+  filterByGuard: () => filterByGuard,
+  filterByRefinement: () => filterByRefinement,
+  filterDefined: () => filterDefined,
+  filterDefinedFn: () => filterDefinedFn,
+  filterTruthy: () => filterTruthy,
+  filterTruthyFn: () => filterTruthyFn,
+  literal: () => literal,
+  mapNullable: () => mapNullable,
+  narrowUnion: () => narrowUnion,
+  not: () => not,
+  nullable: () => nullable,
+  objectOf: () => objectOf,
+  oneOf: () => oneOf,
+  optional: () => optional,
+  partitionByGuard: () => partitionByGuard,
+  refine: () => refine,
+  switchUnion: () => switchUnion,
+  withDefault: () => withDefault,
+  withDefaultLazy: () => withDefaultLazy
+});
+
+// src/narrowing/filterDefined.ts
+function filterDefined(array) {
+  return array.filter(
+    (item) => item !== null && item !== void 0
+  );
+}
+function filterDefinedFn() {
+  return (array) => filterDefined(array);
+}
+
+// src/narrowing/filterTruthy.ts
+function filterTruthy(array) {
+  return array.filter((item) => Boolean(item));
+}
+function filterTruthyFn() {
+  return (array) => filterTruthy(array);
+}
+
+// src/narrowing/filterByGuard.ts
+function filterByGuard(array, guard) {
+  return array.filter(guard);
+}
+function filterByRefinement(array, refinement) {
+  return array.filter(refinement);
+}
+function filterBy(guard) {
+  return (array) => filterByGuard(array, guard);
+}
+function partitionByGuard(array, guard) {
+  const matches = [];
+  const nonMatches = [];
+  for (const item of array) {
+    if (guard(item)) {
+      matches.push(item);
+    } else {
+      nonMatches.push(item);
+    }
+  }
+  return [matches, nonMatches];
+}
+
+// src/narrowing/assertType.ts
+function assertType(value, guard, message) {
+  if (!guard(value)) {
+    if (typeof message === "function") {
+      throw message();
+    }
+    throw new TypeError(message ?? `Type assertion failed`);
+  }
+}
+function assertDefined(value, message) {
+  if (value === null || value === void 0) {
+    throw new TypeError(message ?? "Expected value to be defined");
+  }
+}
+function assertNotNull(value, message) {
+  if (value === null) {
+    throw new TypeError(message ?? "Expected value to not be null");
+  }
+}
+function assertCondition(condition, message) {
+  if (!condition) {
+    throw new TypeError(message ?? "Assertion failed");
+  }
+}
+function createAssertion(guard, defaultMessage) {
+  return (value, message) => {
+    assertType(value, guard, message ?? defaultMessage);
+  };
+}
+
+// src/narrowing/narrowUnion.ts
+function narrowUnion(value, key, expected) {
+  return value[key] === expected;
+}
+function createDiscriminantGuard() {
+  return (key, value) => {
+    return (obj) => obj[key] === value;
+  };
+}
+function switchUnion(value, key, handlers) {
+  const discriminant = value[key];
+  const handler = handlers[discriminant];
+  return handler(value);
+}
+function exhaustiveCheck(value, message) {
+  throw new Error(
+    message ?? `Exhaustive check failed: unexpected value ${JSON.stringify(value)}`
+  );
+}
+
+// src/narrowing/excludeNull.ts
+function excludeNull(value, message) {
+  if (value === null) {
+    throw new Error(message ?? "Unexpected null value");
+  }
+  return value;
+}
+function excludeUndefined(value, message) {
+  if (value === void 0) {
+    throw new Error(message ?? "Unexpected undefined value");
+  }
+  return value;
+}
+function excludeNullish(value, message) {
+  if (value === null || value === void 0) {
+    throw new Error(message ?? "Unexpected null or undefined value");
+  }
+  return value;
+}
+function withDefault(value, defaultValue) {
+  return value ?? defaultValue;
+}
+function withDefaultLazy(value, factory) {
+  return value ?? factory();
+}
+function mapNullable(value, fn) {
+  if (value === null) return null;
+  if (value === void 0) return void 0;
+  return fn(value);
+}
+function chainNullable(value, ...fns) {
+  let result = value;
+  for (const fn of fns) {
+    if (result === null || result === void 0) {
+      return result;
+    }
+    result = fn(result);
+  }
+  return result;
+}
+
+// src/narrowing/refine.ts
+function refine(guard1, ...guards) {
+  return ((value) => {
+    if (!guard1(value)) return false;
+    for (const guard of guards) {
+      if (!guard(value)) return false;
+    }
+    return true;
+  });
+}
+function oneOf(...guards) {
+  return ((value) => {
+    return guards.some((guard) => guard(value));
+  });
+}
+function allOf(...guards) {
+  return ((value) => {
+    return guards.every((guard) => guard(value));
+  });
+}
+function not(guard) {
+  return ((value) => !guard(value));
+}
+function arrayOf(guard) {
+  return (value) => {
+    return Array.isArray(value) && value.every(guard);
+  };
+}
+function objectOf(shape) {
+  return (value) => {
+    if (typeof value !== "object" || value === null) return false;
+    const obj = value;
+    return Object.entries(shape).every(([key, guard]) => guard(obj[key]));
+  };
+}
+function literal(expected) {
+  return (value) => value === expected;
+}
+function optional(guard) {
+  return (value) => {
+    return value === void 0 || guard(value);
+  };
+}
+function nullable(guard) {
+  return (value) => {
+    return value === null || guard(value);
+  };
+}
+
+export { allOf, arrayOf, assertCondition, assertDefined, assertNotNull, assertType, chainNullable, createAssertion, createDiscriminantGuard, excludeNull, excludeNullish, excludeUndefined, exhaustiveCheck, filterBy, filterByGuard, filterByRefinement, filterDefined, filterDefinedFn, filterTruthy, filterTruthyFn, literal, mapNullable, narrowUnion, narrowing_exports, not, nullable, objectOf, oneOf, optional, partitionByGuard, refine, switchUnion, withDefault, withDefaultLazy };
+//# sourceMappingURL=chunk-CWHYQWNU.mjs.map
+//# sourceMappingURL=chunk-CWHYQWNU.mjs.map

package/dist/chunk-CWHYQWNU.mjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/narrowing/index.ts","../src/narrowing/filterDefined.ts","../src/narrowing/filterTruthy.ts","../src/narrowing/filterByGuard.ts","../src/narrowing/assertType.ts","../src/narrowing/narrowUnion.ts","../src/narrowing/excludeNull.ts","../src/narrowing/refine.ts"],"names":[],"mappings":"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","file":"chunk-CWHYQWNU.mjs","sourcesContent":["/**\n * Narrowing Module\n * \n * Solutions for TypeScript's type narrowing pain points.\n * Each function transforms uncertain types into certain types.\n */\n\nexport { filterDefined, filterDefinedFn } from './filterDefined'\nexport { filterTruthy, filterTruthyFn } from './filterTruthy'\nexport { filterByGuard, filterByRefinement, filterBy, partitionByGuard } from './filterByGuard'\nexport { assertType, assertDefined, assertNotNull, assertCondition, createAssertion } from './assertType'\nexport { narrowUnion, createDiscriminantGuard, switchUnion, exhaustiveCheck } from './narrowUnion'\nexport { \n  excludeNull, \n  excludeUndefined, \n  excludeNullish, \n  withDefault, \n  withDefaultLazy, \n  mapNullable, \n  chainNullable \n} from './excludeNull'\nexport { \n  refine, \n  oneOf, \n  allOf, \n  not, \n  arrayOf, \n  objectOf, \n  literal, \n  optional, \n  nullable \n} from './refine'\nexport type { TypeGuard, Refinement, GuardedType, Falsy, Truthy, Defined } from './types'\n","import type { Defined } from './types'\n\n/**\n * Filters an array removing null and undefined values with proper type narrowing.\n * \n * This solves the pain point where `array.filter(x => x != null)` returns\n * `(T | null | undefined)[]` instead of `T[]`.\n * \n * @example\n * const users: (User | null | undefined)[] = [user1, null, user2, undefined]\n * const defined = filterDefined(users)\n * // Type: User[] (not (User | null | undefined)[])\n * \n * @example\n * // Works with complex union types\n * const mixed: (string | number | null)[] = ['a', 1, null, 'b', 2]\n * const result = filterDefined(mixed)\n * // Type: (string | number)[]\n */\nexport function filterDefined<T>(\n  array: readonly (T | null | undefined)[]\n): Defined<T>[] {\n  return array.filter(\n    (item): item is Defined<T> => item !== null && item !== undefined\n  )\n}\n\n/**\n * Curried version for use in pipelines\n * \n * @example\n * pipe(\n *   users,\n *   filterDefinedFn(),\n *   map(u => u.name)\n * )\n */\nexport function filterDefinedFn<T>(): (\n  array: readonly (T | null | undefined)[]\n) => Defined<T>[] {\n  return (array) => filterDefined(array)\n}\n","import type { Truthy } from './types'\n\n/**\n * Filters an array removing all falsy values with proper type narrowing.\n * \n * Removes: false, 0, 0n, '', null, undefined\n * \n * @example\n * const values: (string | number | null | undefined | false)[] = \n *   ['hello', 0, '', null, 'world', false, 42]\n * \n * const truthy = filterTruthy(values)\n * // Type: (string | number)[]\n * // Value: ['hello', 'world', 42]\n * \n * @example\n * // Useful for conditional rendering arrays\n * const items = filterTruthy([\n *   showHeader && <Header />,\n *   <Content />,\n *   showFooter && <Footer />\n * ])\n */\nexport function filterTruthy<T>(array: readonly T[]): Truthy<T>[] {\n  return array.filter((item): item is Truthy<T> => Boolean(item))\n}\n\n/**\n * Curried version for use in pipelines\n */\nexport function filterTruthyFn<T>(): (array: readonly T[]) => Truthy<T>[] {\n  return (array) => filterTruthy(array)\n}\n","import type { TypeGuard, Refinement } from './types'\n\n/**\n * Filters an array using a type guard with proper type narrowing.\n * \n * This is the generic solution for filtering with any type guard.\n * \n * @example\n * const items: unknown[] = [1, 'hello', 2, 'world', null]\n * \n * const strings = filterByGuard(items, isString)\n * // Type: string[]\n * \n * const numbers = filterByGuard(items, isNumber)\n * // Type: number[]\n * \n * @example\n * // With custom type guards\n * interface Admin { role: 'admin'; permissions: string[] }\n * interface User { role: 'user' }\n * type Person = Admin | User\n * \n * const isAdmin = (p: Person): p is Admin => p.role === 'admin'\n * const admins = filterByGuard(people, isAdmin)\n * // Type: Admin[]\n */\nexport function filterByGuard<T, S extends T>(\n  array: readonly T[],\n  guard: TypeGuard<T, S>\n): S[] {\n  return array.filter(guard)\n}\n\n/**\n * Filters with a refinement function that has access to index and array\n */\nexport function filterByRefinement<T, S extends T>(\n  array: readonly T[],\n  refinement: Refinement<T, S>\n): S[] {\n  return array.filter(refinement)\n}\n\n/**\n * Creates a filter function from a type guard for use in pipelines\n * \n * @example\n * pipe(\n *   items,\n *   filterBy(isString),\n *   map(s => s.toUpperCase())\n * )\n */\nexport function filterBy<T, S extends T>(\n  guard: TypeGuard<T, S>\n): (array: readonly T[]) => S[] {\n  return (array) => filterByGuard(array, guard)\n}\n\n/**\n * Partitions an array by a type guard into [matches, nonMatches]\n * \n * @example\n * const [strings, others] = partitionByGuard(items, isString)\n * // strings: string[]\n * // others: Exclude<typeof items[number], string>[]\n */\nexport function partitionByGuard<T, S extends T>(\n  array: readonly T[],\n  guard: TypeGuard<T, S>\n): [S[], Exclude<T, S>[]] {\n  const matches: S[] = []\n  const nonMatches: Exclude<T, S>[] = []\n  \n  for (const item of array) {\n    if (guard(item)) {\n      matches.push(item)\n    } else {\n      nonMatches.push(item as Exclude<T, S>)\n    }\n  }\n  \n  return [matches, nonMatches]\n}\n","import type { TypeGuard } from './types'\n\n/**\n * Asserts that a value matches a type guard, throwing if it doesn't.\n * This is an assertion function that narrows the type in the current scope.\n * \n * @example\n * function processUser(data: unknown) {\n *   assertType(data, isUser, 'Expected user data')\n *   // After this line, data is typed as User\n *   console.log(data.name)\n * }\n * \n * @example\n * // With custom error\n * assertType(response, isApiResponse, () => \n *   new ValidationError('Invalid API response', response)\n * )\n */\nexport function assertType<T, S extends T>(\n  value: T,\n  guard: TypeGuard<T, S>,\n  message?: string | (() => Error)\n): asserts value is S {\n  if (!guard(value)) {\n    if (typeof message === 'function') {\n      throw message()\n    }\n    throw new TypeError(message ?? `Type assertion failed`)\n  }\n}\n\n/**\n * Asserts that a value is defined (not null or undefined)\n * \n * @example\n * const user: User | null = findUser(id)\n * assertDefined(user, `User ${id} not found`)\n * // After this line, user is typed as User\n * console.log(user.name)\n */\nexport function assertDefined<T>(\n  value: T | null | undefined,\n  message?: string\n): asserts value is T {\n  if (value === null || value === undefined) {\n    throw new TypeError(message ?? 'Expected value to be defined')\n  }\n}\n\n/**\n * Asserts that a value is not null\n */\nexport function assertNotNull<T>(\n  value: T | null,\n  message?: string\n): asserts value is T {\n  if (value === null) {\n    throw new TypeError(message ?? 'Expected value to not be null')\n  }\n}\n\n/**\n * Asserts a condition and narrows the type\n * \n * @example\n * function process(value: string | number) {\n *   assertCondition(typeof value === 'string', 'Expected string')\n *   // value is now string\n *   return value.toUpperCase()\n * }\n */\nexport function assertCondition(\n  condition: boolean,\n  message?: string\n): asserts condition {\n  if (!condition) {\n    throw new TypeError(message ?? 'Assertion failed')\n  }\n}\n\n/**\n * Creates a type assertion function from a type guard\n * \n * @example\n * const assertUser = createAssertion(isUser, 'Expected User')\n * \n * function process(data: unknown) {\n *   assertUser(data)\n *   // data is now User\n * }\n */\nexport function createAssertion<T, S extends T>(\n  guard: TypeGuard<T, S>,\n  defaultMessage?: string\n): (value: T, message?: string) => asserts value is S {\n  return (value: T, message?: string): asserts value is S => {\n    assertType(value, guard, message ?? defaultMessage)\n  }\n}\n","/**\n * Narrows a discriminated union by its discriminant property.\n * \n * @example\n * type Event = \n *   | { type: 'click'; x: number; y: number }\n *   | { type: 'keypress'; key: string }\n *   | { type: 'scroll'; delta: number }\n * \n * const event: Event = getEvent()\n * \n * if (narrowUnion(event, 'type', 'click')) {\n *   // event is { type: 'click'; x: number; y: number }\n *   console.log(event.x, event.y)\n * }\n */\nexport function narrowUnion<\n  T extends Record<K, PropertyKey>,\n  K extends keyof T,\n  V extends T[K]\n>(\n  value: T,\n  key: K,\n  expected: V\n): value is Extract<T, Record<K, V>> {\n  return value[key] === expected\n}\n\n/**\n * Creates a type guard for a specific discriminant value\n * \n * @example\n * type Result = { status: 'ok'; data: string } | { status: 'error'; message: string }\n * \n * const isOk = createDiscriminantGuard<Result>()('status', 'ok')\n * const isError = createDiscriminantGuard<Result>()('status', 'error')\n * \n * if (isOk(result)) {\n *   console.log(result.data)\n * }\n */\nexport function createDiscriminantGuard<T extends Record<string, unknown>>() {\n  return <K extends keyof T, V extends T[K]>(\n    key: K,\n    value: V\n  ): ((obj: T) => obj is Extract<T, Record<K, V>>) => {\n    return (obj: T): obj is Extract<T, Record<K, V>> => obj[key] === value\n  }\n}\n\n/**\n * Exhaustive switch helper for discriminated unions\n * \n * @example\n * type Shape = \n *   | { kind: 'circle'; radius: number }\n *   | { kind: 'square'; side: number }\n *   | { kind: 'rectangle'; width: number; height: number }\n * \n * function area(shape: Shape): number {\n *   return switchUnion(shape, 'kind', {\n *     circle: (s) => Math.PI * s.radius ** 2,\n *     square: (s) => s.side ** 2,\n *     rectangle: (s) => s.width * s.height,\n *   })\n * }\n */\nexport function switchUnion<\n  T extends Record<K, string>,\n  K extends keyof T,\n  R\n>(\n  value: T,\n  key: K,\n  handlers: { [V in T[K]]: (value: Extract<T, Record<K, V>>) => R }\n): R {\n  const discriminant = value[key] as T[K]\n  const handler = handlers[discriminant]\n  return handler(value as Extract<T, Record<K, T[K]>>)\n}\n\n/**\n * Type-safe exhaustive check that ensures all union cases are handled\n * \n * @example\n * type Status = 'pending' | 'success' | 'error'\n * \n * function handleStatus(status: Status) {\n *   switch (status) {\n *     case 'pending': return 'Loading...'\n *     case 'success': return 'Done!'\n *     case 'error': return 'Failed'\n *     default: return exhaustiveCheck(status)\n *   }\n * }\n */\nexport function exhaustiveCheck(value: never, message?: string): never {\n  throw new Error(\n    message ?? `Exhaustive check failed: unexpected value ${JSON.stringify(value)}`\n  )\n}\n","/**\n * Excludes null from a value's type at runtime and compile time.\n * Throws if the value is null.\n * \n * @example\n * const element: HTMLElement | null = document.getElementById('app')\n * const el = excludeNull(element, 'App element not found')\n * // el is HTMLElement\n */\nexport function excludeNull<T>(\n  value: T | null,\n  message?: string\n): T {\n  if (value === null) {\n    throw new Error(message ?? 'Unexpected null value')\n  }\n  return value\n}\n\n/**\n * Excludes undefined from a value's type at runtime and compile time.\n * Throws if the value is undefined.\n */\nexport function excludeUndefined<T>(\n  value: T | undefined,\n  message?: string\n): T {\n  if (value === undefined) {\n    throw new Error(message ?? 'Unexpected undefined value')\n  }\n  return value\n}\n\n/**\n * Excludes null and undefined from a value's type.\n * Throws if the value is null or undefined.\n */\nexport function excludeNullish<T>(\n  value: T | null | undefined,\n  message?: string\n): T {\n  if (value === null || value === undefined) {\n    throw new Error(message ?? 'Unexpected null or undefined value')\n  }\n  return value\n}\n\n/**\n * Returns the value if defined, otherwise returns the default.\n * Type-safe alternative to the nullish coalescing operator with better inference.\n * \n * @example\n * const config: Config | undefined = loadConfig()\n * const safeConfig = withDefault(config, defaultConfig)\n * // safeConfig is Config (not Config | undefined)\n */\nexport function withDefault<T>(\n  value: T | null | undefined,\n  defaultValue: T\n): T {\n  return value ?? defaultValue\n}\n\n/**\n * Returns the value if defined, otherwise calls the factory function.\n * Useful when the default value is expensive to compute.\n * \n * @example\n * const cached = withDefaultLazy(cache.get(key), () => computeExpensiveValue())\n */\nexport function withDefaultLazy<T>(\n  value: T | null | undefined,\n  factory: () => T\n): T {\n  return value ?? factory()\n}\n\n/**\n * Maps a nullable value, returning null/undefined if the input is null/undefined.\n * \n * @example\n * const user: User | null = findUser(id)\n * const name = mapNullable(user, u => u.name)\n * // name is string | null\n */\nexport function mapNullable<T, U>(\n  value: T | null | undefined,\n  fn: (value: T) => U\n): U | null | undefined {\n  if (value === null) return null\n  if (value === undefined) return undefined\n  return fn(value)\n}\n\n/**\n * Chains nullable operations, similar to optional chaining but with functions.\n * \n * @example\n * const result = chainNullable(\n *   user,\n *   u => u.profile,\n *   p => p.settings,\n *   s => s.theme\n * )\n * // result is Theme | null | undefined\n */\nexport function chainNullable<T, A>(\n  value: T | null | undefined,\n  fn1: (v: T) => A | null | undefined\n): A | null | undefined\nexport function chainNullable<T, A, B>(\n  value: T | null | undefined,\n  fn1: (v: T) => A | null | undefined,\n  fn2: (v: A) => B | null | undefined\n): B | null | undefined\nexport function chainNullable<T, A, B, C>(\n  value: T | null | undefined,\n  fn1: (v: T) => A | null | undefined,\n  fn2: (v: A) => B | null | undefined,\n  fn3: (v: B) => C | null | undefined\n): C | null | undefined\nexport function chainNullable<T, A, B, C, D>(\n  value: T | null | undefined,\n  fn1: (v: T) => A | null | undefined,\n  fn2: (v: A) => B | null | undefined,\n  fn3: (v: B) => C | null | undefined,\n  fn4: (v: C) => D | null | undefined\n): D | null | undefined\nexport function chainNullable(\n  value: unknown,\n  ...fns: Array<(v: unknown) => unknown>\n): unknown {\n  let result = value\n  for (const fn of fns) {\n    if (result === null || result === undefined) {\n      return result\n    }\n    result = fn(result)\n  }\n  return result\n}\n","import type { TypeGuard } from './types'\n\n/**\n * Refines a type by applying multiple type guards in sequence.\n * Each guard further narrows the type.\n * \n * @example\n * const isPositiveNumber = refine(\n *   isNumber,\n *   (n): n is number => n > 0\n * )\n * \n * if (isPositiveNumber(value)) {\n *   // value is number and > 0\n * }\n */\nexport function refine<T, S extends T, R extends S>(\n  guard1: TypeGuard<T, S>,\n  guard2: TypeGuard<S, R>\n): TypeGuard<T, R>\nexport function refine<T, S extends T, R extends S, Q extends R>(\n  guard1: TypeGuard<T, S>,\n  guard2: TypeGuard<S, R>,\n  guard3: TypeGuard<R, Q>\n): TypeGuard<T, Q>\nexport function refine<T, S extends T>(\n  guard1: TypeGuard<T, S>,\n  ...guards: Array<(value: S) => boolean>\n): TypeGuard<T, S> {\n  return ((value: T): value is S => {\n    if (!guard1(value)) return false\n    for (const guard of guards) {\n      if (!guard(value)) return false\n    }\n    return true\n  }) as TypeGuard<T, S>\n}\n\n/**\n * Combines multiple type guards with OR logic.\n * Returns true if any guard matches.\n * \n * @example\n * const isStringOrNumber = oneOf(isString, isNumber)\n * \n * if (isStringOrNumber(value)) {\n *   // value is string | number\n * }\n */\nexport function oneOf<T, S1 extends T>(\n  guard1: TypeGuard<T, S1>\n): TypeGuard<T, S1>\nexport function oneOf<T, S1 extends T, S2 extends T>(\n  guard1: TypeGuard<T, S1>,\n  guard2: TypeGuard<T, S2>\n): TypeGuard<T, S1 | S2>\nexport function oneOf<T, S1 extends T, S2 extends T, S3 extends T>(\n  guard1: TypeGuard<T, S1>,\n  guard2: TypeGuard<T, S2>,\n  guard3: TypeGuard<T, S3>\n): TypeGuard<T, S1 | S2 | S3>\nexport function oneOf<T, S1 extends T, S2 extends T, S3 extends T, S4 extends T>(\n  guard1: TypeGuard<T, S1>,\n  guard2: TypeGuard<T, S2>,\n  guard3: TypeGuard<T, S3>,\n  guard4: TypeGuard<T, S4>\n): TypeGuard<T, S1 | S2 | S3 | S4>\nexport function oneOf<T, S extends T>(\n  ...guards: Array<TypeGuard<T, S>>\n): TypeGuard<T, S> {\n  return ((value: T): value is S => {\n    return guards.some(guard => guard(value))\n  }) as TypeGuard<T, S>\n}\n\n/**\n * Combines multiple type guards with AND logic.\n * Returns true only if all guards match.\n * \n * @example\n * const isNonEmptyString = allOf(\n *   isString,\n *   (s): s is string => s.length > 0\n * )\n */\nexport function allOf<T, S1 extends T>(\n  guard1: TypeGuard<T, S1>\n): TypeGuard<T, S1>\nexport function allOf<T, S1 extends T, S2 extends S1>(\n  guard1: TypeGuard<T, S1>,\n  guard2: TypeGuard<S1, S2>\n): TypeGuard<T, S2>\nexport function allOf<T, S1 extends T, S2 extends S1, S3 extends S2>(\n  guard1: TypeGuard<T, S1>,\n  guard2: TypeGuard<S1, S2>,\n  guard3: TypeGuard<S2, S3>\n): TypeGuard<T, S3>\nexport function allOf<T, S extends T>(\n  ...guards: Array<TypeGuard<T, S>>\n): TypeGuard<T, S> {\n  return ((value: T): value is S => {\n    return guards.every(guard => guard(value))\n  }) as TypeGuard<T, S>\n}\n\n/**\n * Negates a type guard.\n * \n * @example\n * const isNotNull = not(isNull)\n * const items = array.filter(isNotNull)\n */\nexport function not<T, S extends T>(\n  guard: TypeGuard<T, S>\n): TypeGuard<T, Exclude<T, S>> {\n  return ((value: T): value is Exclude<T, S> => !guard(value)) as TypeGuard<T, Exclude<T, S>>\n}\n\n/**\n * Creates a type guard for array elements.\n * \n * @example\n * const isStringArray = arrayOf(isString)\n * \n * if (isStringArray(value)) {\n *   // value is string[]\n * }\n */\nexport function arrayOf<T, S extends T>(\n  guard: TypeGuard<T, S>\n): TypeGuard<unknown, S[]> {\n  return (value: unknown): value is S[] => {\n    return Array.isArray(value) && value.every(guard as TypeGuard<unknown, S>)\n  }\n}\n\n/**\n * Creates a type guard for objects with specific shape.\n * \n * @example\n * const isUser = objectOf({\n *   id: isNumber,\n *   name: isString,\n *   email: isString\n * })\n * \n * if (isUser(data)) {\n *   // data is { id: number; name: string; email: string }\n * }\n */\nexport function objectOf<T extends Record<string, TypeGuard<unknown, unknown>>>(\n  shape: T\n): TypeGuard<unknown, { [K in keyof T]: T[K] extends TypeGuard<unknown, infer S> ? S : never }> {\n  return (value: unknown): value is { [K in keyof T]: T[K] extends TypeGuard<unknown, infer S> ? S : never } => {\n    if (typeof value !== 'object' || value === null) return false\n    const obj = value as Record<string, unknown>\n    return Object.entries(shape).every(([key, guard]) => guard(obj[key]))\n  }\n}\n\n/**\n * Creates a type guard for literal values.\n * \n * @example\n * const isAdmin = literal('admin')\n * const isStatus = oneOf(literal('pending'), literal('done'), literal('error'))\n */\nexport function literal<T extends string | number | boolean>(\n  expected: T\n): TypeGuard<unknown, T> {\n  return (value: unknown): value is T => value === expected\n}\n\n/**\n * Creates a type guard for optional properties.\n * \n * @example\n * const isOptionalString = optional(isString)\n * // Matches string | undefined\n */\nexport function optional<T, S extends T>(\n  guard: TypeGuard<T, S>\n): TypeGuard<T | undefined, S | undefined> {\n  return (value: T | undefined): value is S | undefined => {\n    return value === undefined || guard(value as T)\n  }\n}\n\n/**\n * Creates a type guard for nullable properties.\n * \n * @example\n * const isNullableString = nullable(isString)\n * // Matches string | null\n */\nexport function nullable<T, S extends T>(\n  guard: TypeGuard<T, S>\n): TypeGuard<T | null, S | null> {\n  return (value: T | null): value is S | null => {\n    return value === null || guard(value as T)\n  }\n}\n"]}

package/dist/{chunk-JAOGY4JO.mjs → chunk-FEX5C4OH.mjs}

@@ -1003,5 +1003,5 @@ function mapKeys(obj, fn) {
 }
 
 export { assertType, asyncData, brand, collection, collectionWithId, createActions, createBuilder, createCollection, createMap, createMatcher, createReducer, createSet, createTypedEmitter, deepMerge, defineConst, defineEnum, defineModel, defineStateMachine, defineTuple, formState, fromEntries, identity, impossible, mapKeys, mapValues, match, matchUnion, matchValue, merge, mergeAll, mergeModels, mergeWith, modalState, model, narrow, narrow2, omit, omitModel, persistentCollection, pick, pickModel, renameKeys, showType, t, undoable, v };
-//# sourceMappingURL=chunk-JAOGY4JO.mjs.map
-//# sourceMappingURL=chunk-JAOGY4JO.mjs.map
+//# sourceMappingURL=chunk-FEX5C4OH.mjs.map
+//# sourceMappingURL=chunk-FEX5C4OH.mjs.map

package/dist/chunk-FEX5C4OH.mjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/typed/defineConst.ts","../src/typed/defineEnum.ts","../src/typed/defineTuple.ts","../src/typed/createMap.ts","../src/typed/createSet.ts","../src/typed/brand.ts","../src/typed/narrow.ts","../src/typed/builder.ts","../src/typed/model.ts","../src/typed/v.ts","../src/typed/collection.ts","../src/typed/states.ts","../src/typed/match.ts","../src/typed/debug.ts","../src/typed/merge.ts"],"names":["model","v","matchValue","narrow"],"mappings":"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","file":"chunk-FEX5C4OH.mjs","sourcesContent":["/**\n * Creates a readonly constant with inferred literal type.\n * Useful for defining constants that TypeScript will narrow.\n *\n * @example\n * const STATUS = defineConst({\n *   PENDING: 'pending',\n *   ACTIVE: 'active',\n *   DONE: 'done',\n * })\n * // typeof STATUS.PENDING = 'pending' (not string)\n */\nexport function defineConst<T extends Record<string, unknown>>(\n  obj: T\n): Readonly<T> {\n  return Object.freeze(obj)\n}\n","/**\n * Creates an enum-like object with proper typing.\n * Values are the same as keys.\n *\n * @example\n * const Status = defineEnum(['pending', 'active', 'done'] as const)\n * // Status.pending = 'pending'\n * // type StatusValue = 'pending' | 'active' | 'done'\n */\nexport function defineEnum<T extends readonly string[]>(\n  values: T\n): { readonly [K in T[number]]: K } {\n  const result = {} as { [K in T[number]]: K }\n\n  for (const value of values) {\n    ;(result as Record<string, string>)[value] = value\n  }\n\n  return Object.freeze(result)\n}\n\n/**\n * Extracts the value type from a defineEnum result.\n *\n * @example\n * const Status = defineEnum(['pending', 'active', 'done'] as const)\n * type StatusValue = EnumValue<typeof Status> // 'pending' | 'active' | 'done'\n */\nexport type EnumValue<T extends Record<string, string>> = T[keyof T]\n","/**\n * Creates a tuple with inferred literal types.\n * Useful when you need a tuple type without using 'as const'.\n *\n * @example\n * const coords = defineTuple(10, 20, 30)\n * // type: [number, number, number]\n *\n * const status = defineTuple('pending', 'active', 'done')\n * // type: ['pending', 'active', 'done']\n */\nexport function defineTuple<T extends readonly unknown[]>(\n  ...args: T\n): T {\n  return args\n}\n","/**\n * Creates a type-safe Map with inferred key and value types.\n *\n * @example\n * const userMap = createMap<number, { name: string }>()\n * userMap.set(1, { name: 'John' })\n * const user = userMap.get(1) // { name: string } | undefined\n */\nexport function createMap<K, V>(\n  entries?: readonly (readonly [K, V])[]\n): Map<K, V> {\n  return new Map(entries)\n}\n","/**\n * Creates a type-safe Set with inferred value type.\n *\n * @example\n * const ids = createSet<number>()\n * ids.add(1)\n * ids.has(1) // true\n */\nexport function createSet<T>(values?: readonly T[]): Set<T> {\n  return new Set(values)\n}\n","declare const __brand: unique symbol\n\n/**\n * Creates a branded type. Branded types are structurally identical\n * but nominally different, preventing accidental mixing.\n *\n * @example\n * type UserId = Brand<number, 'UserId'>\n * type PostId = Brand<number, 'PostId'>\n *\n * const userId = 1 as UserId\n * const postId = 2 as PostId\n *\n * function getUser(id: UserId) { ... }\n * getUser(userId) // OK\n * getUser(postId) // Error!\n */\nexport type Brand<T, B extends string> = T & { readonly [__brand]: B }\n\n/**\n * Creates a branded value.\n *\n * @example\n * type UserId = Brand<number, 'UserId'>\n * const userId = brand<UserId>(1)\n */\nexport function brand<T extends Brand<unknown, string>>(value: T extends Brand<infer U, string> ? U : never): T {\n  return value as T\n}\n","/**\n * Narrows a value to a specific type using a type guard.\n * Returns the value if it passes the guard, undefined otherwise.\n *\n * @example\n * const value: unknown = 'hello'\n * const str = narrow(value, isString)\n * // str is string | undefined\n */\nexport function narrow<T, U extends T>(\n  value: T,\n  guard: (value: T) => value is U\n): U | undefined {\n  return guard(value) ? value : undefined\n}\n","/**\n * Type builders for creating complex types with a fluent API.\n */\n\n/**\n * Creates a type-safe builder pattern.\n * Allows step-by-step construction of objects with full type inference.\n *\n * @example\n * interface User { name: string; age: number }\n * const user = createBuilder<User>()\n *   .set('name', 'John')\n *   .set('age', 30)\n *   .build()\n */\nexport function createBuilder<T extends Record<string, unknown>>(\n  initial: Partial<T> = {}\n): TypeBuilder<T> {\n  return {\n    set<K extends keyof T>(key: K, value: T[K]): TypeBuilder<T> {\n      return createBuilder<T>({ ...initial, [key]: value } as Partial<T>)\n    },\n    build(): T {\n      return initial as T\n    },\n    current(): Partial<T> {\n      return initial\n    },\n  }\n}\n\ninterface TypeBuilder<T> {\n  set<K extends keyof T>(key: K, value: T[K]): TypeBuilder<T>\n  build(): T\n  current(): Partial<T>\n}\n\n/**\n * Creates a type-safe state machine definition.\n *\n * @example\n * const machine = defineStateMachine({\n *   initial: 'idle',\n *   states: {\n *     idle: { on: { START: 'running' } },\n *     running: { on: { STOP: 'idle', PAUSE: 'paused' } },\n *     paused: { on: { RESUME: 'running', STOP: 'idle' } },\n *   },\n * })\n */\nexport function defineStateMachine<\n  States extends string,\n  Events extends string,\n  Config extends StateMachineConfig<States, Events>\n>(config: Config): StateMachine<States, Events, Config> {\n  return {\n    config,\n    getInitialState: () => config.initial,\n    transition: (state, event) => {\n      const stateConfig = config.states[state]\n      if (stateConfig && 'on' in stateConfig) {\n        const nextState = (stateConfig.on as Record<string, States>)[event]\n        return nextState ?? state\n      }\n      return state\n    },\n  }\n}\n\ntype StateMachineConfig<States extends string, Events extends string> = {\n  initial: States\n  states: Record<States, { on?: Partial<Record<Events, States>> }>\n}\n\ntype StateMachine<\n  States extends string,\n  Events extends string,\n  Config extends StateMachineConfig<States, Events>\n> = {\n  config: Config\n  getInitialState: () => Config['initial']\n  transition: (state: States, event: Events) => States\n}\n\n/**\n * Creates a discriminated union type from a config object.\n *\n * @example\n * type Actions = DiscriminatedUnion<{\n *   increment: { amount: number }\n *   decrement: { amount: number }\n *   reset: {}\n * }>\n * // Results in:\n * // | { type: 'increment'; amount: number }\n * // | { type: 'decrement'; amount: number }\n * // | { type: 'reset' }\n */\nexport type DiscriminatedUnion<\n  T extends Record<string, object>,\n  TagKey extends string = 'type'\n> = {\n  [K in keyof T]: { [P in TagKey]: K } & T[K]\n}[keyof T]\n\n/**\n * Creates action creators from a discriminated union config.\n *\n * @example\n * const actions = createActions<{\n *   increment: { amount: number }\n *   decrement: { amount: number }\n *   reset: {}\n * }>()\n *\n * actions.increment({ amount: 5 }) // { type: 'increment', amount: 5 }\n */\nexport function createActions<T extends Record<string, object>>(): ActionCreators<T> {\n  return new Proxy({} as ActionCreators<T>, {\n    get: (_, type: string) => {\n      return (payload: object) => ({ type, ...payload })\n    },\n  })\n}\n\ntype ActionCreators<T extends Record<string, object>> = {\n  [K in keyof T]: T[K] extends Record<string, never>\n    ? () => { type: K }\n    : (payload: T[K]) => { type: K } & T[K]\n}\n\n/**\n * Creates a type-safe event emitter.\n *\n * @example\n * const emitter = createTypedEmitter<{\n *   userCreated: { id: string; name: string }\n *   userDeleted: { id: string }\n * }>()\n *\n * emitter.on('userCreated', (data) => console.log(data.name))\n * emitter.emit('userCreated', { id: '1', name: 'John' })\n */\nexport function createTypedEmitter<\n  Events extends Record<string, unknown>\n>(): TypedEmitter<Events> {\n  const listeners = new Map<keyof Events, Set<(data: unknown) => void>>()\n\n  return {\n    on<K extends keyof Events>(\n      event: K,\n      handler: (data: Events[K]) => void\n    ): () => void {\n      if (!listeners.has(event)) {\n        listeners.set(event, new Set())\n      }\n      listeners.get(event)!.add(handler as (data: unknown) => void)\n      return () => {\n        listeners.get(event)?.delete(handler as (data: unknown) => void)\n      }\n    },\n\n    emit<K extends keyof Events>(event: K, data: Events[K]): void {\n      listeners.get(event)?.forEach((handler) => handler(data))\n    },\n\n    off<K extends keyof Events>(\n      event: K,\n      handler: (data: Events[K]) => void\n    ): void {\n      listeners.get(event)?.delete(handler as (data: unknown) => void)\n    },\n\n    clear(): void {\n      listeners.clear()\n    },\n  }\n}\n\ntype TypedEmitter<Events extends Record<string, unknown>> = {\n  on<K extends keyof Events>(\n    event: K,\n    handler: (data: Events[K]) => void\n  ): () => void\n  emit<K extends keyof Events>(event: K, data: Events[K]): void\n  off<K extends keyof Events>(event: K, handler: (data: Events[K]) => void): void\n  clear(): void\n}\n\n/**\n * Creates a type-safe reducer.\n *\n * @example\n * const reducer = createReducer(\n *   { count: 0 },\n *   {\n *     increment: (state, action: { amount: number }) => ({\n *       count: state.count + action.amount,\n *     }),\n *     reset: () => ({ count: 0 }),\n *   }\n * )\n */\nexport function createReducer<\n  State,\n  Handlers extends Record<string, (state: State, action: any) => State>\n>(\n  initialState: State,\n  handlers: Handlers\n): {\n  initialState: State\n  reduce: <K extends keyof Handlers>(\n    state: State,\n    action: { type: K } & (Handlers[K] extends (s: State, a: infer A) => State\n      ? A extends { type: unknown }\n        ? Omit<A, 'type'>\n        : A\n      : never)\n  ) => State\n} {\n  return {\n    initialState,\n    reduce: (state, action) => {\n      const handler = handlers[action.type as keyof Handlers]\n      if (handler) {\n        return handler(state, action)\n      }\n      return state\n    },\n  }\n}\n","/**\n * Model Definition Utilities\n * \n * Transform TypeScript from \"dictionary writing\" to \"Lego building\".\n * Define types using runtime values with automatic type inference.\n */\n\nimport type { Prettify } from './types'\n\n// =============================================================================\n// PRIMITIVE TYPE MARKERS\n// =============================================================================\n\nexport const STRING_MARKER: unique symbol = Symbol('string')\nexport const NUMBER_MARKER: unique symbol = Symbol('number')\nexport const BOOLEAN_MARKER: unique symbol = Symbol('boolean')\nexport const DATE_MARKER: unique symbol = Symbol('date')\nexport const BIGINT_MARKER: unique symbol = Symbol('bigint')\nexport const SYMBOL_MARKER: unique symbol = Symbol('symbol')\nexport const ANY_MARKER: unique symbol = Symbol('any')\nexport const UNKNOWN_MARKER: unique symbol = Symbol('unknown')\nexport const NULL_MARKER: unique symbol = Symbol('null')\nexport const UNDEFINED_MARKER: unique symbol = Symbol('undefined')\n\nexport const t = {\n  string: { [STRING_MARKER]: true } as const,\n  number: { [NUMBER_MARKER]: true } as const,\n  boolean: { [BOOLEAN_MARKER]: true } as const,\n  date: { [DATE_MARKER]: true } as const,\n  bigint: { [BIGINT_MARKER]: true } as const,\n  symbol: { [SYMBOL_MARKER]: true } as const,\n  any: { [ANY_MARKER]: true } as const,\n  unknown: { [UNKNOWN_MARKER]: true } as const,\n  null: { [NULL_MARKER]: true } as const,\n  undefined: { [UNDEFINED_MARKER]: true } as const,\n  \n  /** Array of a type */\n  array: <T>(item: T) => ({ __array: item }) as ArrayMarker<T>,\n  \n  /** Optional field */\n  optional: <T>(type: T) => ({ __optional: type }) as OptionalMarker<T>,\n  \n  /** Nullable field */\n  nullable: <T>(type: T) => ({ __nullable: type }) as NullableMarker<T>,\n  \n  /** Literal value */\n  literal: <T extends string | number | boolean>(value: T) => ({ __literal: value }) as LiteralMarker<T>,\n  \n  /** Union of literals (enum-like) */\n  enum: <T extends readonly (string | number)[]>(...values: T) => ({ __enum: values }) as EnumMarker<T>,\n  \n  /** Union of types */\n  union: <T extends readonly unknown[]>(...types: T) => ({ __union: types }) as UnionMarker<T>,\n  \n  /** Record/Dictionary */\n  record: <V>(valueType: V) => ({ __record: valueType }) as RecordMarker<V>,\n  \n  /** Tuple */\n  tuple: <T extends readonly unknown[]>(...types: T) => ({ __tuple: types }) as TupleMarker<T>,\n  \n  /** Reference to another model */\n  ref: <T>() => ({ __ref: null as unknown as T }) as RefMarker<T>,\n} as const\n\n// Type markers\ntype ArrayMarker<T> = { __array: T }\ntype OptionalMarker<T> = { __optional: T }\ntype NullableMarker<T> = { __nullable: T }\ntype LiteralMarker<T> = { __literal: T }\ntype EnumMarker<T> = { __enum: T }\ntype UnionMarker<T> = { __union: T }\ntype RecordMarker<V> = { __record: V }\ntype TupleMarker<T> = { __tuple: T }\ntype RefMarker<T> = { __ref: T }\n\n// =============================================================================\n// TYPE INFERENCE\n// =============================================================================\n\ntype InferSchema<T> =\n  // Primitives\n  T extends typeof t.string ? string :\n  T extends typeof t.number ? number :\n  T extends typeof t.boolean ? boolean :\n  T extends typeof t.date ? Date :\n  T extends typeof t.bigint ? bigint :\n  T extends typeof t.symbol ? symbol :\n  T extends typeof t.any ? any :\n  T extends typeof t.unknown ? unknown :\n  T extends typeof t.null ? null :\n  T extends typeof t.undefined ? undefined :\n  // Native constructors\n  T extends StringConstructor ? string :\n  T extends NumberConstructor ? number :\n  T extends BooleanConstructor ? boolean :\n  T extends DateConstructor ? Date :\n  T extends BigIntConstructor ? bigint :\n  T extends SymbolConstructor ? symbol :\n  // Markers\n  T extends ArrayMarker<infer U> ? InferSchema<U>[] :\n  T extends OptionalMarker<infer U> ? InferSchema<U> | undefined :\n  T extends NullableMarker<infer U> ? InferSchema<U> | null :\n  T extends LiteralMarker<infer U> ? U :\n  T extends EnumMarker<infer U> ? U extends readonly (infer V)[] ? V : never :\n  T extends UnionMarker<infer U> ? U extends readonly unknown[] ? InferSchema<U[number]> : never :\n  T extends RecordMarker<infer V> ? Record<string, InferSchema<V>> :\n  T extends TupleMarker<infer U> ? U extends readonly unknown[] ? { [K in keyof U]: InferSchema<U[K]> } : never :\n  T extends RefMarker<infer U> ? U :\n  // Literal arrays (enums)\n  T extends readonly (string | number | boolean)[] ? T[number] :\n  // Nested objects\n  T extends object ? { [K in keyof T]: InferSchema<T[K]> } :\n  T\n\n// Extract optional keys\ntype OptionalKeys<T> = {\n  [K in keyof T]: T[K] extends OptionalMarker<unknown> ? K : never\n}[keyof T]\n\n// Extract required keys\ntype RequiredKeys<T> = Exclude<keyof T, OptionalKeys<T>>\n\n// Infer model with proper optional handling\ntype InferModel<T> = Prettify<\n  { [K in RequiredKeys<T>]: InferSchema<T[K]> } &\n  { [K in OptionalKeys<T>]?: InferSchema<T[K] extends OptionalMarker<infer U> ? U : never> }\n>\n\n/**\n * Infer the TypeScript type from a model definition.\n * \n * @example\n * const UserSchema = defineModel({\n *   id: t.number,\n *   name: t.string,\n *   role: t.enum('admin', 'user', 'guest'),\n * })\n * \n * type User = Infer<typeof UserSchema>\n * // { id: number; name: string; role: 'admin' | 'user' | 'guest' }\n */\nexport type Infer<T extends { __schema: unknown }> = T['__schema']\n\n// =============================================================================\n// MODEL DEFINITION\n// =============================================================================\n\ninterface ModelDefinition<T> {\n  __schema: InferModel<T>\n  __definition: T\n  \n  /** Create a new instance with validation */\n  create(data: InferModel<T>): InferModel<T>\n  \n  /** Create a partial instance */\n  partial(data: Partial<InferModel<T>>): Partial<InferModel<T>>\n  \n  /** Check if a value matches the schema */\n  is(value: unknown): value is InferModel<T>\n  \n  /** Extend this model with additional fields */\n  extend<U extends Record<string, unknown>>(\n    extension: U\n  ): ModelDefinition<T & U>\n  \n  /** Pick specific fields */\n  pick<K extends keyof T>(\n    ...keys: K[]\n  ): ModelDefinition<Pick<T, K>>\n  \n  /** Omit specific fields */\n  omit<K extends keyof T>(\n    ...keys: K[]\n  ): ModelDefinition<Omit<T, K>>\n  \n  /** Make all fields optional */\n  asPartial(): ModelDefinition<{ [K in keyof T]: OptionalMarker<T[K]> }>\n  \n  /** Make all fields required */\n  asRequired(): ModelDefinition<{ [K in keyof T]: T[K] extends OptionalMarker<infer U> ? U : T[K] }>\n}\n\n/**\n * Define a model with automatic type inference.\n * \n * @example\n * // Simple model\n * const User = defineModel({\n *   id: t.number,\n *   name: t.string,\n *   email: t.string,\n * })\n * \n * // With enums and optionals\n * const Post = defineModel({\n *   id: t.number,\n *   title: t.string,\n *   status: t.enum('draft', 'published', 'archived'),\n *   author: t.optional(t.string),\n *   tags: t.array(t.string),\n * })\n * \n * // Extract the type\n * type User = Infer<typeof User>\n * type Post = Infer<typeof Post>\n */\nexport function defineModel<T extends Record<string, unknown>>(\n  definition: T\n): ModelDefinition<T> {\n  const model: ModelDefinition<T> = {\n    __schema: null as unknown as InferModel<T>,\n    __definition: definition,\n    \n    create(data) {\n      return data\n    },\n    \n    partial(data) {\n      return data\n    },\n    \n    is(value): value is InferModel<T> {\n      if (typeof value !== 'object' || value === null) return false\n      // Basic structural check\n      for (const key of Object.keys(definition)) {\n        if (!(key in value)) {\n          const fieldDef = definition[key]\n          // Allow missing optional fields\n          if (fieldDef && typeof fieldDef === 'object' && '__optional' in fieldDef) {\n            continue\n          }\n          return false\n        }\n      }\n      return true\n    },\n    \n    extend<U extends Record<string, unknown>>(extension: U) {\n      return defineModel({ ...definition, ...extension } as T & U)\n    },\n    \n    pick<K extends keyof T>(...keys: K[]) {\n      const picked = {} as Pick<T, K>\n      for (const key of keys) {\n        picked[key] = definition[key]\n      }\n      return defineModel(picked)\n    },\n    \n    omit<K extends keyof T>(...keys: K[]) {\n      const omitted = { ...definition } as Omit<T, K>\n      for (const key of keys) {\n        delete (omitted as Record<string, unknown>)[key as string]\n      }\n      return defineModel(omitted)\n    },\n    \n    asPartial() {\n      const partial = {} as { [K in keyof T]: OptionalMarker<T[K]> }\n      for (const key of Object.keys(definition) as (keyof T)[]) {\n        (partial as Record<string, unknown>)[key as string] = { __optional: definition[key] }\n      }\n      return defineModel(partial)\n    },\n    \n    asRequired() {\n      const required = {} as { [K in keyof T]: T[K] extends OptionalMarker<infer U> ? U : T[K] }\n      for (const key of Object.keys(definition) as (keyof T)[]) {\n        const field = definition[key]\n        if (field && typeof field === 'object' && '__optional' in field) {\n          (required as Record<string, unknown>)[key as string] = (field as OptionalMarker<unknown>).__optional\n        } else {\n          (required as Record<string, unknown>)[key as string] = field\n        }\n      }\n      return defineModel(required)\n    },\n  }\n  \n  return model\n}\n\n// =============================================================================\n// QUICK MODEL (Even simpler syntax)\n// =============================================================================\n\n/**\n * Quick model definition using native constructors.\n * Even simpler than defineModel for basic cases.\n * \n * @example\n * const User = model({\n *   id: Number,\n *   name: String,\n *   active: Boolean,\n *   role: ['admin', 'user'] as const,\n * })\n * \n * type User = Infer<typeof User>\n * // { id: number; name: string; active: boolean; role: 'admin' | 'user' }\n */\nexport function model<T extends Record<string, unknown>>(\n  definition: T\n): ModelDefinition<T> {\n  return defineModel(definition)\n}\n\n// =============================================================================\n// MODEL COMPOSITION\n// =============================================================================\n\n/**\n * Merge multiple models into one.\n * \n * @example\n * const Timestamps = defineModel({\n *   createdAt: t.date,\n *   updatedAt: t.date,\n * })\n * \n * const User = defineModel({\n *   id: t.number,\n *   name: t.string,\n * })\n * \n * const UserWithTimestamps = mergeModels(User, Timestamps)\n * type UserWithTimestamps = Infer<typeof UserWithTimestamps>\n */\nexport function mergeModels<\n  A extends ModelDefinition<Record<string, unknown>>,\n  B extends ModelDefinition<Record<string, unknown>>\n>(\n  a: A,\n  b: B\n): ModelDefinition<A['__definition'] & B['__definition']> {\n  return defineModel({\n    ...a.__definition,\n    ...b.__definition,\n  } as A['__definition'] & B['__definition'])\n}\n\n/**\n * Create a model that's a subset of another.\n * \n * @example\n * const User = defineModel({ id: t.number, name: t.string, password: t.string })\n * const PublicUser = pickModel(User, 'id', 'name')\n */\nexport function pickModel<\n  M extends ModelDefinition<Record<string, unknown>>,\n  K extends keyof M['__definition'] & string\n>(\n  model: M,\n  ...keys: K[]\n): ModelDefinition<Pick<M['__definition'], K>> {\n  return model.pick(...keys) as ModelDefinition<Pick<M['__definition'], K>>\n}\n\n/**\n * Create a model without certain fields.\n * \n * @example\n * const User = defineModel({ id: t.number, name: t.string, password: t.string })\n * const SafeUser = omitModel(User, 'password')\n */\nexport function omitModel<\n  M extends ModelDefinition<Record<string, unknown>>,\n  K extends keyof M['__definition'] & string\n>(\n  model: M,\n  ...keys: K[]\n): ModelDefinition<Omit<M['__definition'], K>> {\n  return model.omit(...keys) as ModelDefinition<Omit<M['__definition'], K>>\n}\n","/**\n * Zero-Effort Type System\n * \n * The \"v\" module provides validators with phantom types.\n * Define once, get types for free. No more `type X = Infer<typeof X>`.\n * \n * @example\n * const User = v.object({\n *   id: v.number(),\n *   name: v.string(),\n *   email: v.email(),\n * })\n * \n * // Use the type directly with .T\n * function saveUser(user: typeof User.T) {\n *   console.log(user.name) // Full autocomplete!\n * }\n */\n\n// =============================================================================\n// CORE TYPES\n// =============================================================================\n\nexport interface Validator<T> {\n  parse(value: unknown): T\n  safeParse(value: unknown): { ok: true; value: T } | { ok: false; error: Error }\n  is(value: unknown): value is T\n  readonly T: T\n  optional(): Validator<T | undefined>\n  nullable(): Validator<T | null>\n  default(value: T): Validator<T>\n  transform<U>(fn: (value: T) => U): Validator<U>\n  refine(fn: (value: T) => boolean, message?: string): Validator<T>\n}\n\n// =============================================================================\n// VALIDATOR FACTORY\n// =============================================================================\n\nfunction createValidator<T>(\n  parser: (value: unknown) => T,\n  checker?: (value: unknown) => boolean\n): Validator<T> {\n  const validator: Validator<T> = {\n    parse: parser,\n    \n    safeParse(value: unknown) {\n      try {\n        return { ok: true, value: parser(value) }\n      } catch (e) {\n        return { ok: false, error: e instanceof Error ? e : new Error(String(e)) }\n      }\n    },\n    \n    is(value: unknown): value is T {\n      if (checker) return checker(value)\n      try {\n        parser(value)\n        return true\n      } catch {\n        return false\n      }\n    },\n    \n    T: undefined as unknown as T,\n    \n    optional() {\n      return createValidator<T | undefined>(\n        (val) => val === undefined ? undefined : parser(val),\n        (val) => val === undefined || (checker ? checker(val) : true)\n      )\n    },\n    \n    nullable() {\n      return createValidator<T | null>(\n        (val) => val === null ? null : parser(val),\n        (val) => val === null || (checker ? checker(val) : true)\n      )\n    },\n    \n    default(defaultValue: T) {\n      return createValidator<T>(\n        (val) => val === undefined || val === null ? defaultValue : parser(val)\n      )\n    },\n    \n    transform<U>(fn: (value: T) => U) {\n      return createValidator<U>((val) => fn(parser(val)))\n    },\n    \n    refine(fn: (value: T) => boolean, message = 'Validation failed') {\n      return createValidator<T>((val) => {\n        const parsed = parser(val)\n        if (!fn(parsed)) throw new Error(message)\n        return parsed\n      })\n    },\n  }\n  \n  return validator\n}\n\n// =============================================================================\n// PRIMITIVE VALIDATORS\n// =============================================================================\n\nfunction stringValidator(): Validator<string> {\n  return createValidator(\n    (val) => {\n      if (typeof val !== 'string') throw new Error(`Expected string, got ${typeof val}`)\n      return val\n    },\n    (val) => typeof val === 'string'\n  )\n}\n\nfunction numberValidator(): Validator<number> {\n  return createValidator(\n    (val) => {\n      if (typeof val !== 'number' || Number.isNaN(val)) {\n        throw new Error(`Expected number, got ${typeof val}`)\n      }\n      return val\n    },\n    (val) => typeof val === 'number' && !Number.isNaN(val)\n  )\n}\n\nfunction booleanValidator(): Validator<boolean> {\n  return createValidator(\n    (val) => {\n      if (typeof val !== 'boolean') throw new Error(`Expected boolean, got ${typeof val}`)\n      return val\n    },\n    (val) => typeof val === 'boolean'\n  )\n}\n\nfunction dateValidator(): Validator<Date> {\n  return createValidator(\n    (val) => {\n      if (val instanceof Date) return val\n      if (typeof val === 'string' || typeof val === 'number') {\n        const date = new Date(val)\n        if (Number.isNaN(date.getTime())) throw new Error('Invalid date')\n        return date\n      }\n      throw new Error(`Expected date, got ${typeof val}`)\n    },\n    (val) => val instanceof Date && !Number.isNaN(val.getTime())\n  )\n}\n\nfunction literalValidator<T extends string | number | boolean>(value: T): Validator<T> {\n  return createValidator(\n    (val) => {\n      if (val !== value) throw new Error(`Expected ${String(value)}, got ${String(val)}`)\n      return value\n    },\n    (val) => val === value\n  )\n}\n\nfunction enumValidator<T extends readonly (string | number)[]>(\n  ...values: T\n): Validator<T[number]> {\n  return createValidator(\n    (val) => {\n      if (!values.includes(val as T[number])) {\n        throw new Error(`Expected one of [${values.join(', ')}], got ${String(val)}`)\n      }\n      return val as T[number]\n    },\n    (val) => values.includes(val as T[number])\n  )\n}\n\n// =============================================================================\n// STRING REFINEMENTS\n// =============================================================================\n\nfunction emailValidator(): Validator<string> {\n  const emailRegex = /^[^\\s@]+@[^\\s@]+\\.[^\\s@]+$/\n  return stringValidator().refine((val) => emailRegex.test(val), 'Invalid email')\n}\n\nfunction urlValidator(): Validator<string> {\n  return stringValidator().refine((val) => {\n    try { new URL(val); return true } catch { return false }\n  }, 'Invalid URL')\n}\n\nfunction uuidValidator(): Validator<string> {\n  const uuidRegex = /^[0-9a-f]{8}-[0-9a-f]{4}-[1-5][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i\n  return stringValidator().refine((val) => uuidRegex.test(val), 'Invalid UUID')\n}\n\n// =============================================================================\n// COMPOUND VALIDATORS\n// =============================================================================\n\ntype InferObject<S extends Record<string, Validator<unknown>>> = {\n  [K in keyof S]: S[K]['T']\n}\n\ninterface ObjectValidator<S extends Record<string, Validator<unknown>>> extends Validator<InferObject<S>> {\n  schema: S\n  pick<K extends keyof S>(...keys: K[]): ObjectValidator<Pick<S, K>>\n  omit<K extends keyof S>(...keys: K[]): ObjectValidator<Omit<S, K>>\n  extend<U extends Record<string, Validator<unknown>>>(ext: U): ObjectValidator<S & U>\n  partial(): ObjectValidator<{ [K in keyof S]: Validator<S[K]['T'] | undefined> }>\n  merge<U extends Record<string, Validator<unknown>>>(other: ObjectValidator<U>): ObjectValidator<S & U>\n}\n\nfunction objectValidator<S extends Record<string, Validator<unknown>>>(\n  schema: S\n): ObjectValidator<S> {\n  const base = createValidator<InferObject<S>>(\n    (val) => {\n      if (typeof val !== 'object' || val === null) {\n        throw new Error(`Expected object, got ${typeof val}`)\n      }\n      const result = {} as InferObject<S>\n      const schemaRecord = schema as Record<string, Validator<unknown>>\n      for (const key of Object.keys(schemaRecord)) {\n        const fieldValidator = schemaRecord[key]\n        if (fieldValidator) {\n          (result as Record<string, unknown>)[key] = fieldValidator.parse((val as Record<string, unknown>)[key])\n        }\n      }\n      return result\n    },\n    (val) => {\n      if (typeof val !== 'object' || val === null) return false\n      const schemaRec = schema as Record<string, Validator<unknown>>\n      for (const key of Object.keys(schemaRec)) {\n        const fieldVal = schemaRec[key]\n        if (fieldVal && !fieldVal.is((val as Record<string, unknown>)[key])) return false\n      }\n      return true\n    }\n  )\n  \n  const validator = base as ObjectValidator<S>\n  validator.schema = schema\n  \n  validator.pick = <K extends keyof S>(...keys: K[]) => {\n    const picked = {} as Pick<S, K>\n    for (const key of keys) picked[key] = schema[key]!\n    return objectValidator(picked)\n  }\n  \n  validator.omit = <K extends keyof S>(...keys: K[]) => {\n    const omitted = { ...schema }\n    for (const key of keys) delete (omitted as Record<string, unknown>)[key as string]\n    return objectValidator(omitted as unknown as Omit<S, K>)\n  }\n  \n  validator.extend = <U extends Record<string, Validator<unknown>>>(ext: U) => {\n    return objectValidator({ ...schema, ...ext } as S & U)\n  }\n  \n  validator.partial = () => {\n    const partial = {} as Record<string, Validator<unknown>>\n    const schemaRec = schema as Record<string, Validator<unknown>>\n    for (const key of Object.keys(schemaRec)) {\n      const fieldVal = schemaRec[key]\n      if (fieldVal) partial[key] = fieldVal.optional()\n    }\n    return objectValidator(partial) as ObjectValidator<{ [K in keyof S]: Validator<S[K]['T'] | undefined> }>\n  }\n  \n  validator.merge = <U extends Record<string, Validator<unknown>>>(other: ObjectValidator<U>) => {\n    return objectValidator({ ...schema, ...other.schema } as S & U)\n  }\n  \n  return validator\n}\n\nfunction arrayValidator<T>(itemValidator: Validator<T>): Validator<T[]> {\n  return createValidator(\n    (val) => {\n      if (!Array.isArray(val)) throw new Error(`Expected array, got ${typeof val}`)\n      return val.map((item, i) => {\n        try {\n          return itemValidator.parse(item)\n        } catch (e) {\n          throw new Error(`[${i}]: ${e instanceof Error ? e.message : String(e)}`)\n        }\n      })\n    },\n    (val) => Array.isArray(val) && val.every((item) => itemValidator.is(item))\n  )\n}\n\nfunction tupleValidator<T extends readonly Validator<unknown>[]>(\n  ...validators: T\n): Validator<{ [K in keyof T]: T[K] extends Validator<infer U> ? U : never }> {\n  type Result = { [K in keyof T]: T[K] extends Validator<infer U> ? U : never }\n  return createValidator<Result>(\n    (val) => {\n      if (!Array.isArray(val)) throw new Error(`Expected tuple, got ${typeof val}`)\n      if (val.length !== validators.length) {\n        throw new Error(`Expected ${validators.length} elements, got ${val.length}`)\n      }\n      return validators.map((v, i) => v.parse(val[i])) as Result\n    },\n    (val) => Array.isArray(val) && val.length === validators.length && validators.every((v, i) => v.is(val[i]))\n  )\n}\n\nfunction recordValidator<V>(valueValidator: Validator<V>): Validator<Record<string, V>> {\n  return createValidator(\n    (val) => {\n      if (typeof val !== 'object' || val === null || Array.isArray(val)) {\n        throw new Error(`Expected record, got ${typeof val}`)\n      }\n      const result: Record<string, V> = {}\n      for (const [key, value] of Object.entries(val)) {\n        result[key] = valueValidator.parse(value)\n      }\n      return result\n    },\n    (val) => {\n      if (typeof val !== 'object' || val === null || Array.isArray(val)) return false\n      return Object.values(val).every((v) => valueValidator.is(v))\n    }\n  )\n}\n\nfunction unionValidator<T extends readonly Validator<unknown>[]>(\n  ...validators: T\n): Validator<T[number]['T']> {\n  return createValidator(\n    (val) => {\n      for (const v of validators) {\n        const result = v.safeParse(val)\n        if (result.ok) return result.value as T[number]['T']\n      }\n      throw new Error('Value does not match any union member')\n    },\n    (val) => validators.some((v) => v.is(val))\n  )\n}\n\nfunction intersectionValidator<A, B>(\n  a: Validator<A>,\n  b: Validator<B>\n): Validator<A & B> {\n  return createValidator(\n    (val) => {\n      const parsedA = a.parse(val)\n      const parsedB = b.parse(val)\n      return { ...parsedA, ...parsedB } as A & B\n    },\n    (val) => a.is(val) && b.is(val)\n  )\n}\n\n// =============================================================================\n// THE \"v\" NAMESPACE - Zero Effort API\n// =============================================================================\n\nexport const v = {\n  // Primitives\n  string: stringValidator,\n  number: numberValidator,\n  boolean: booleanValidator,\n  date: dateValidator,\n  \n  // String refinements\n  email: emailValidator,\n  url: urlValidator,\n  uuid: uuidValidator,\n  \n  // Literals & Enums\n  literal: literalValidator,\n  enum: enumValidator,\n  \n  // Compound types\n  object: objectValidator,\n  array: arrayValidator,\n  tuple: tupleValidator,\n  record: recordValidator,\n  union: unionValidator,\n  intersection: intersectionValidator,\n  \n  // Special\n  any: () => createValidator<any>((val) => val),\n  unknown: () => createValidator<unknown>((val) => val),\n  null: () => createValidator<null>((val) => {\n    if (val !== null) throw new Error('Expected null')\n    return null\n  }),\n  undefined: () => createValidator<undefined>((val) => {\n    if (val !== undefined) throw new Error('Expected undefined')\n    return undefined\n  }),\n} as const\n\nexport type { ObjectValidator }\n","/**\n * Type-Safe Collection with Auto-Generated CRUD\n * \n * Define a model once, get a fully typed collection for free.\n * Includes persistence (localStorage/API) and smart filtering.\n * \n * @example\n * const User = v.object({\n *   id: v.number(),\n *   name: v.string(),\n *   role: v.enum('admin', 'user'),\n * })\n * \n * const Users = collection(User)\n * \n * Users.add({ id: 1, name: 'Alice', role: 'admin' })\n * const admin = Users.find('role', 'admin')\n * const names = Users.pluck('name')\n */\n\nimport type { Validator, ObjectValidator } from './v'\n\n// =============================================================================\n// COLLECTION TYPES\n// =============================================================================\n\nexport interface Collection<T> {\n  /** All items in the collection */\n  readonly items: readonly T[]\n  \n  /** Number of items */\n  readonly length: number\n  \n  /** Add an item (returns the added item) */\n  add(item: T): T\n  \n  /** Add multiple items */\n  addMany(items: T[]): T[]\n  \n  /** Update an item by predicate */\n  update(predicate: (item: T) => boolean, updates: Partial<T>): T | undefined\n  \n  /** Update item by key value */\n  updateWhere<K extends keyof T>(key: K, value: T[K], updates: Partial<T>): T | undefined\n  \n  /** Remove items matching predicate */\n  remove(predicate: (item: T) => boolean): T[]\n  \n  /** Remove item by key value */\n  removeWhere<K extends keyof T>(key: K, value: T[K]): T | undefined\n  \n  /** Clear all items */\n  clear(): void\n  \n  /** Find first item matching predicate */\n  findOne(predicate: (item: T) => boolean): T | undefined\n  \n  /** Find item by key value */\n  find<K extends keyof T>(key: K, value: T[K]): T | undefined\n  \n  /** Find all items matching predicate */\n  findMany(predicate: (item: T) => boolean): T[]\n  \n  /** Filter items (alias for findMany) */\n  where(predicate: (item: T) => boolean): T[]\n  \n  /** Filter by key value */\n  whereEquals<K extends keyof T>(key: K, value: T[K]): T[]\n  \n  /** Check if any item matches */\n  some(predicate: (item: T) => boolean): boolean\n  \n  /** Check if all items match */\n  every(predicate: (item: T) => boolean): boolean\n  \n  /** Check if collection contains item with key value */\n  has<K extends keyof T>(key: K, value: T[K]): boolean\n  \n  /** Get first item */\n  first(): T | undefined\n  \n  /** Get last item */\n  last(): T | undefined\n  \n  /** Get item at index */\n  at(index: number): T | undefined\n  \n  /** Map items to new values */\n  map<U>(fn: (item: T, index: number) => U): U[]\n  \n  /** Extract single property from all items */\n  pluck<K extends keyof T>(key: K): T[K][]\n  \n  /** Pick specific properties from all items */\n  pick<K extends keyof T>(...keys: K[]): Pick<T, K>[]\n  \n  /** Omit specific properties from all items */\n  omit<K extends keyof T>(...keys: K[]): Omit<T, K>[]\n  \n  /** Sort items (returns new array) */\n  sortBy<K extends keyof T>(key: K, order?: 'asc' | 'desc'): T[]\n  \n  /** Group items by key */\n  groupBy<K extends keyof T>(key: K): Map<T[K], T[]>\n  \n  /** Get unique values for a key */\n  unique<K extends keyof T>(key: K): T[K][]\n  \n  /** Count items matching predicate */\n  count(predicate?: (item: T) => boolean): number\n  \n  /** Subscribe to changes */\n  subscribe(listener: (items: readonly T[]) => void): () => void\n  \n  /** Convert to array */\n  toArray(): T[]\n  \n  /** Convert to JSON string */\n  toJSON(): string\n  \n  /** Load from JSON string */\n  fromJSON(json: string): void\n}\n\nexport interface CollectionWithId<T, IdKey extends keyof T> extends Collection<T> {\n  /** Find item by ID */\n  byId(id: T[IdKey]): T | undefined\n  \n  /** Update item by ID */\n  updateById(id: T[IdKey], updates: Partial<T>): T | undefined\n  \n  /** Remove item by ID */\n  removeById(id: T[IdKey]): T | undefined\n  \n  /** Check if ID exists */\n  hasId(id: T[IdKey]): boolean\n}\n\nexport interface PersistentCollection<T> extends Collection<T> {\n  /** Save to storage */\n  save(): Promise<void>\n  \n  /** Load from storage */\n  load(): Promise<void>\n  \n  /** Enable auto-save on changes */\n  enableAutoSave(): void\n  \n  /** Disable auto-save */\n  disableAutoSave(): void\n}\n\n// =============================================================================\n// COLLECTION IMPLEMENTATION\n// =============================================================================\n\nclass CollectionImpl<T> implements Collection<T> {\n  private _items: T[] = []\n  private _listeners: Set<(items: readonly T[]) => void> = new Set()\n  \n  get items(): readonly T[] {\n    return this._items\n  }\n  \n  get length(): number {\n    return this._items.length\n  }\n  \n  private notify(): void {\n    for (const listener of this._listeners) {\n      listener(this._items)\n    }\n  }\n  \n  add(item: T): T {\n    this._items.push(item)\n    this.notify()\n    return item\n  }\n  \n  addMany(items: T[]): T[] {\n    this._items.push(...items)\n    this.notify()\n    return items\n  }\n  \n  update(predicate: (item: T) => boolean, updates: Partial<T>): T | undefined {\n    const index = this._items.findIndex(predicate)\n    if (index === -1) return undefined\n    this._items[index] = { ...this._items[index], ...updates } as T\n    this.notify()\n    return this._items[index]\n  }\n  \n  updateWhere<K extends keyof T>(key: K, value: T[K], updates: Partial<T>): T | undefined {\n    return this.update((item) => item[key] === value, updates)\n  }\n  \n  remove(predicate: (item: T) => boolean): T[] {\n    const removed: T[] = []\n    this._items = this._items.filter((item) => {\n      if (predicate(item)) {\n        removed.push(item)\n        return false\n      }\n      return true\n    })\n    if (removed.length > 0) this.notify()\n    return removed\n  }\n  \n  removeWhere<K extends keyof T>(key: K, value: T[K]): T | undefined {\n    const removed = this.remove((item) => item[key] === value)\n    return removed[0]\n  }\n  \n  clear(): void {\n    this._items = []\n    this.notify()\n  }\n  \n  findOne(predicate: (item: T) => boolean): T | undefined {\n    return this._items.find(predicate)\n  }\n  \n  find<K extends keyof T>(key: K, value: T[K]): T | undefined {\n    return this._items.find((item) => item[key] === value)\n  }\n  \n  findMany(predicate: (item: T) => boolean): T[] {\n    return this._items.filter(predicate)\n  }\n  \n  where(predicate: (item: T) => boolean): T[] {\n    return this.findMany(predicate)\n  }\n  \n  whereEquals<K extends keyof T>(key: K, value: T[K]): T[] {\n    return this._items.filter((item) => item[key] === value)\n  }\n  \n  some(predicate: (item: T) => boolean): boolean {\n    return this._items.some(predicate)\n  }\n  \n  every(predicate: (item: T) => boolean): boolean {\n    return this._items.every(predicate)\n  }\n  \n  has<K extends keyof T>(key: K, value: T[K]): boolean {\n    return this._items.some((item) => item[key] === value)\n  }\n  \n  first(): T | undefined {\n    return this._items[0]\n  }\n  \n  last(): T | undefined {\n    return this._items[this._items.length - 1]\n  }\n  \n  at(index: number): T | undefined {\n    return this._items.at(index)\n  }\n  \n  map<U>(fn: (item: T, index: number) => U): U[] {\n    return this._items.map(fn)\n  }\n  \n  pluck<K extends keyof T>(key: K): T[K][] {\n    return this._items.map((item) => item[key])\n  }\n  \n  pick<K extends keyof T>(...keys: K[]): Pick<T, K>[] {\n    return this._items.map((item) => {\n      const picked = {} as Pick<T, K>\n      for (const key of keys) {\n        picked[key] = item[key]\n      }\n      return picked\n    })\n  }\n  \n  omit<K extends keyof T>(...keys: K[]): Omit<T, K>[] {\n    return this._items.map((item) => {\n      const omitted = { ...item }\n      for (const key of keys) {\n        delete (omitted as Record<string, unknown>)[key as string]\n      }\n      return omitted as Omit<T, K>\n    })\n  }\n  \n  sortBy<K extends keyof T>(key: K, order: 'asc' | 'desc' = 'asc'): T[] {\n    return [...this._items].sort((a, b) => {\n      const aVal = a[key]\n      const bVal = b[key]\n      if (aVal < bVal) return order === 'asc' ? -1 : 1\n      if (aVal > bVal) return order === 'asc' ? 1 : -1\n      return 0\n    })\n  }\n  \n  groupBy<K extends keyof T>(key: K): Map<T[K], T[]> {\n    const groups = new Map<T[K], T[]>()\n    for (const item of this._items) {\n      const groupKey = item[key]\n      const group = groups.get(groupKey) || []\n      group.push(item)\n      groups.set(groupKey, group)\n    }\n    return groups\n  }\n  \n  unique<K extends keyof T>(key: K): T[K][] {\n    return [...new Set(this._items.map((item) => item[key]))]\n  }\n  \n  count(predicate?: (item: T) => boolean): number {\n    if (!predicate) return this._items.length\n    return this._items.filter(predicate).length\n  }\n  \n  subscribe(listener: (items: readonly T[]) => void): () => void {\n    this._listeners.add(listener)\n    return () => this._listeners.delete(listener)\n  }\n  \n  toArray(): T[] {\n    return [...this._items]\n  }\n  \n  toJSON(): string {\n    return JSON.stringify(this._items)\n  }\n  \n  fromJSON(json: string): void {\n    this._items = JSON.parse(json)\n    this.notify()\n  }\n}\n\n// =============================================================================\n// COLLECTION WITH ID\n// =============================================================================\n\nclass CollectionWithIdImpl<T, IdKey extends keyof T> \n  extends CollectionImpl<T> \n  implements CollectionWithId<T, IdKey> \n{\n  constructor(private idKey: IdKey) {\n    super()\n  }\n  \n  byId(id: T[IdKey]): T | undefined {\n    return this.find(this.idKey, id)\n  }\n  \n  updateById(id: T[IdKey], updates: Partial<T>): T | undefined {\n    return this.updateWhere(this.idKey, id, updates)\n  }\n  \n  removeById(id: T[IdKey]): T | undefined {\n    return this.removeWhere(this.idKey, id)\n  }\n  \n  hasId(id: T[IdKey]): boolean {\n    return this.has(this.idKey, id)\n  }\n}\n\n// =============================================================================\n// PERSISTENT COLLECTION\n// =============================================================================\n\ninterface StorageAdapter {\n  get(key: string): Promise<string | null>\n  set(key: string, value: string): Promise<void>\n  remove(key: string): Promise<void>\n}\n\nconst localStorageAdapter: StorageAdapter = {\n  async get(key: string) {\n    if (typeof localStorage === 'undefined') return null\n    return localStorage.getItem(key)\n  },\n  async set(key: string, value: string) {\n    if (typeof localStorage === 'undefined') return\n    localStorage.setItem(key, value)\n  },\n  async remove(key: string) {\n    if (typeof localStorage === 'undefined') return\n    localStorage.removeItem(key)\n  },\n}\n\nclass PersistentCollectionImpl<T> \n  extends CollectionImpl<T> \n  implements PersistentCollection<T> \n{\n  private autoSaveEnabled = false\n  private unsubscribe?: () => void\n  \n  constructor(\n    private storageKey: string,\n    private storage: StorageAdapter = localStorageAdapter\n  ) {\n    super()\n  }\n  \n  async save(): Promise<void> {\n    await this.storage.set(this.storageKey, this.toJSON())\n  }\n  \n  async load(): Promise<void> {\n    const data = await this.storage.get(this.storageKey)\n    if (data) {\n      this.fromJSON(data)\n    }\n  }\n  \n  enableAutoSave(): void {\n    if (this.autoSaveEnabled) return\n    this.autoSaveEnabled = true\n    this.unsubscribe = this.subscribe(() => {\n      void this.save()\n    })\n  }\n  \n  disableAutoSave(): void {\n    this.autoSaveEnabled = false\n    this.unsubscribe?.()\n  }\n}\n\n// =============================================================================\n// FACTORY FUNCTIONS\n// =============================================================================\n\n/**\n * Create a typed collection from a validator.\n * \n * @example\n * const User = v.object({ id: v.number(), name: v.string() })\n * const Users = collection(User)\n * \n * Users.add({ id: 1, name: 'Alice' }) // Fully typed!\n * Users.find('name', 'Alice') // Autocomplete on 'name', 'id'\n */\nexport function collection<T>(\n  _validator: Validator<T>\n): Collection<T> {\n  return new CollectionImpl<T>()\n}\n\n/**\n * Create a typed collection with ID-based operations.\n * \n * @example\n * const User = v.object({ id: v.number(), name: v.string() })\n * const Users = collectionWithId(User, 'id')\n * \n * Users.byId(1) // Find by ID\n * Users.updateById(1, { name: 'Bob' }) // Update by ID\n * Users.removeById(1) // Remove by ID\n */\nexport function collectionWithId<\n  T,\n  IdKey extends keyof T\n>(\n  _validator: Validator<T>,\n  idKey: IdKey\n): CollectionWithId<T, IdKey> {\n  return new CollectionWithIdImpl<T, IdKey>(idKey)\n}\n\n/**\n * Create a persistent collection that saves to storage.\n * \n * @example\n * const User = v.object({ id: v.number(), name: v.string() })\n * const Users = persistentCollection(User, 'users')\n * \n * await Users.load() // Load from localStorage\n * Users.add({ id: 1, name: 'Alice' })\n * await Users.save() // Save to localStorage\n * \n * // Or enable auto-save\n * Users.enableAutoSave()\n */\nexport function persistentCollection<T>(\n  _validator: Validator<T>,\n  storageKey: string,\n  storage?: StorageAdapter\n): PersistentCollection<T> {\n  return new PersistentCollectionImpl<T>(storageKey, storage)\n}\n\n/**\n * Create a collection from an object validator with all features.\n * This is the recommended way to create collections.\n * \n * @example\n * const User = v.object({\n *   id: v.number(),\n *   name: v.string(),\n *   role: v.enum('admin', 'user'),\n * })\n * \n * const Users = createCollection(User, {\n *   idKey: 'id',\n *   persist: 'users', // localStorage key\n *   autoSave: true,\n * })\n */\nexport function createCollection<\n  S extends Record<string, Validator<unknown>>\n>(\n  _validator: ObjectValidator<S>,\n  options?: {\n    idKey?: keyof S\n    persist?: string\n    autoSave?: boolean\n    storage?: StorageAdapter\n  }\n): Collection<{ [K in keyof S]: S[K]['T'] }> {\n  \n  type T = { [K in keyof S]: S[K]['T'] }\n  \n  if (options?.persist) {\n    const col = new PersistentCollectionImpl<T>(options.persist, options.storage)\n    if (options.autoSave) col.enableAutoSave()\n    return col\n  }\n  \n  if (options?.idKey) {\n    return new CollectionWithIdImpl<T, keyof T>(options.idKey as keyof T)\n  }\n  \n  return new CollectionImpl<T>()\n}\n","/**\n * Meta-Types for Common State Patterns\n * \n * Pre-built type templates that solve common business logic problems.\n * No more isLoading: boolean + isError: boolean = impossible states!\n */\n\nimport type { Prettify } from './types'\n\n// =============================================================================\n// ASYNC DATA STATE\n// =============================================================================\n\n/**\n * Type-safe async data state.\n * Eliminates impossible states like { isLoading: true, data: User }.\n * \n * @example\n * type UserState = AsyncData<User>\n * \n * // The type is EXACTLY ONE OF:\n * // { status: 'idle' }\n * // { status: 'loading' }\n * // { status: 'success'; data: User }\n * // { status: 'error'; error: Error }\n * \n * function render(state: UserState) {\n *   switch (state.status) {\n *     case 'idle': return 'Ready to load'\n *     case 'loading': return 'Loading...'\n *     case 'success': return `Hello ${state.data.name}`\n *     case 'error': return `Error: ${state.error.message}`\n *   }\n * }\n */\nexport type AsyncData<T, E = Error> =\n  | { status: 'idle' }\n  | { status: 'loading' }\n  | { status: 'success'; data: T }\n  | { status: 'error'; error: E }\n\n/**\n * AsyncData with refresh capability.\n * Tracks if data is being refreshed while showing stale data.\n */\nexport type AsyncDataWithRefresh<T, E = Error> =\n  | { status: 'idle' }\n  | { status: 'loading' }\n  | { status: 'success'; data: T; isRefreshing: boolean }\n  | { status: 'error'; error: E; isRetrying: boolean }\n\n/**\n * Create async data state helpers.\n * \n * @example\n * const userState = asyncData<User>()\n * \n * let state = userState.idle()\n * state = userState.loading()\n * state = userState.success({ id: 1, name: 'John' })\n * state = userState.error(new Error('Failed'))\n */\nexport function asyncData<T, E = Error>(): AsyncDataHelpers<T, E> {\n  return {\n    idle: () => ({ status: 'idle' }),\n    loading: () => ({ status: 'loading' }),\n    success: (data) => ({ status: 'success', data }),\n    error: (error) => ({ status: 'error', error }),\n    \n    isIdle: (state): state is { status: 'idle' } => state.status === 'idle',\n    isLoading: (state): state is { status: 'loading' } => state.status === 'loading',\n    isSuccess: (state): state is { status: 'success'; data: T } => state.status === 'success',\n    isError: (state): state is { status: 'error'; error: E } => state.status === 'error',\n    \n    map: (state, fn) => {\n      if (state.status === 'success') {\n        return { status: 'success', data: fn(state.data) }\n      }\n      return state as AsyncData<never, E>\n    },\n    \n    getOrElse: (state, defaultValue) => {\n      if (state.status === 'success') {\n        return state.data\n      }\n      return defaultValue\n    },\n  }\n}\n\ninterface AsyncDataHelpers<T, E> {\n  idle(): { status: 'idle' }\n  loading(): { status: 'loading' }\n  success(data: T): { status: 'success'; data: T }\n  error(error: E): { status: 'error'; error: E }\n  \n  isIdle(state: AsyncData<T, E>): state is { status: 'idle' }\n  isLoading(state: AsyncData<T, E>): state is { status: 'loading' }\n  isSuccess(state: AsyncData<T, E>): state is { status: 'success'; data: T }\n  isError(state: AsyncData<T, E>): state is { status: 'error'; error: E }\n  \n  map<U>(state: AsyncData<T, E>, fn: (data: T) => U): AsyncData<U, E>\n  getOrElse(state: AsyncData<T, E>, defaultValue: T): T\n}\n\n// =============================================================================\n// FORM STATE\n// =============================================================================\n\n/**\n * Type-safe form state.\n * Tracks form lifecycle from pristine to submitted.\n * \n * @example\n * type LoginForm = FormState<{ email: string; password: string }>\n * \n * // States:\n * // { status: 'pristine'; values: FormValues }\n * // { status: 'dirty'; values: FormValues; touched: Set<keyof FormValues> }\n * // { status: 'validating'; values: FormValues }\n * // { status: 'invalid'; values: FormValues; errors: Record<keyof FormValues, string> }\n * // { status: 'submitting'; values: FormValues }\n * // { status: 'submitted'; values: FormValues }\n * // { status: 'error'; values: FormValues; error: Error }\n */\nexport type FormState<T extends Record<string, unknown>> =\n  | { status: 'pristine'; values: T }\n  | { status: 'dirty'; values: T; touched: Set<keyof T> }\n  | { status: 'validating'; values: T }\n  | { status: 'invalid'; values: T; errors: Partial<Record<keyof T, string>> }\n  | { status: 'submitting'; values: T }\n  | { status: 'submitted'; values: T }\n  | { status: 'error'; values: T; error: Error }\n\n/**\n * Create form state helpers.\n */\nexport function formState<T extends Record<string, unknown>>(\n  initialValues: T\n): FormStateHelpers<T> {\n  return {\n    pristine: () => ({ status: 'pristine', values: initialValues }),\n    dirty: (values, touched) => ({ status: 'dirty', values, touched }),\n    validating: (values) => ({ status: 'validating', values }),\n    invalid: (values, errors) => ({ status: 'invalid', values, errors }),\n    submitting: (values) => ({ status: 'submitting', values }),\n    submitted: (values) => ({ status: 'submitted', values }),\n    error: (values, error) => ({ status: 'error', values, error }),\n    \n    canSubmit: (state) => state.status === 'dirty' || state.status === 'pristine',\n    isSubmitting: (state) => state.status === 'submitting',\n    hasErrors: (state) => state.status === 'invalid',\n  }\n}\n\ninterface FormStateHelpers<T extends Record<string, unknown>> {\n  pristine(): { status: 'pristine'; values: T }\n  dirty(values: T, touched: Set<keyof T>): { status: 'dirty'; values: T; touched: Set<keyof T> }\n  validating(values: T): { status: 'validating'; values: T }\n  invalid(values: T, errors: Partial<Record<keyof T, string>>): { status: 'invalid'; values: T; errors: Partial<Record<keyof T, string>> }\n  submitting(values: T): { status: 'submitting'; values: T }\n  submitted(values: T): { status: 'submitted'; values: T }\n  error(values: T, error: Error): { status: 'error'; values: T; error: Error }\n  \n  canSubmit(state: FormState<T>): boolean\n  isSubmitting(state: FormState<T>): boolean\n  hasErrors(state: FormState<T>): boolean\n}\n\n// =============================================================================\n// PAGINATION STATE\n// =============================================================================\n\n/**\n * Type-safe pagination state.\n * \n * @example\n * type UserList = PaginatedData<User>\n */\nexport type PaginatedData<T> = {\n  items: T[]\n  page: number\n  pageSize: number\n  totalItems: number\n  totalPages: number\n  hasNextPage: boolean\n  hasPrevPage: boolean\n}\n\n/**\n * Async paginated data combining AsyncData with pagination.\n */\nexport type AsyncPaginatedData<T, E = Error> = AsyncData<PaginatedData<T>, E>\n\n// =============================================================================\n// RESOURCE STATE (CRUD)\n// =============================================================================\n\n/**\n * Type-safe CRUD resource state.\n * \n * @example\n * type UserResource = ResourceState<User>\n */\nexport type ResourceState<T, E = Error> = {\n  data: T | null\n  status: 'idle' | 'loading' | 'updating' | 'deleting' | 'error'\n  error: E | null\n  lastUpdated: Date | null\n}\n\n/**\n * Collection resource state for lists.\n */\nexport type CollectionState<T, E = Error> = {\n  items: Map<string | number, T>\n  status: 'idle' | 'loading' | 'error'\n  error: E | null\n  selectedIds: Set<string | number>\n}\n\n// =============================================================================\n// MODAL/DIALOG STATE\n// =============================================================================\n\n/**\n * Type-safe modal state.\n * \n * @example\n * type ConfirmModal = ModalState<{ title: string; message: string }>\n */\nexport type ModalState<T = void> =\n  | { isOpen: false }\n  | { isOpen: true; data: T }\n\n/**\n * Create modal state helpers.\n */\nexport function modalState<T = void>(): ModalStateHelpers<T> {\n  return {\n    closed: () => ({ isOpen: false }),\n    open: (data) => ({ isOpen: true, data }) as { isOpen: true; data: T },\n    isOpen: (state): state is { isOpen: true; data: T } => state.isOpen,\n  }\n}\n\ninterface ModalStateHelpers<T> {\n  closed(): { isOpen: false }\n  open(data: T): { isOpen: true; data: T }\n  isOpen(state: ModalState<T>): state is { isOpen: true; data: T }\n}\n\n// =============================================================================\n// SELECTION STATE\n// =============================================================================\n\n/**\n * Type-safe selection state for lists.\n */\nexport type SelectionState<T extends string | number> =\n  | { mode: 'none' }\n  | { mode: 'single'; selected: T }\n  | { mode: 'multiple'; selected: Set<T> }\n  | { mode: 'all'; excluded: Set<T> }\n\n// =============================================================================\n// WIZARD/STEPPER STATE\n// =============================================================================\n\n/**\n * Type-safe wizard/stepper state.\n * \n * @example\n * type CheckoutWizard = WizardState<{\n *   cart: { items: CartItem[] }\n *   shipping: { address: Address }\n *   payment: { method: PaymentMethod }\n *   confirmation: { orderId: string }\n * }>\n */\nexport type WizardState<Steps extends Record<string, unknown>> = {\n  [K in keyof Steps]: {\n    currentStep: K\n    completedSteps: Exclude<keyof Steps, K>[]\n    data: Partial<Steps>\n  }\n}[keyof Steps]\n\n// =============================================================================\n// NOTIFICATION STATE\n// =============================================================================\n\n/**\n * Type-safe notification/toast state.\n */\nexport type NotificationState<T extends string = 'info' | 'success' | 'warning' | 'error'> = {\n  id: string\n  type: T\n  message: string\n  title?: string\n  duration?: number\n  dismissible?: boolean\n}\n\n// =============================================================================\n// FILTER STATE\n// =============================================================================\n\n/**\n * Type-safe filter state for search/filter UIs.\n * \n * @example\n * type UserFilters = FilterState<{\n *   search: string\n *   role: 'admin' | 'user' | 'guest'\n *   active: boolean\n * }>\n */\nexport type FilterState<T extends Record<string, unknown>> = {\n  filters: Partial<T>\n  activeFilters: (keyof T)[]\n  isFiltering: boolean\n}\n\n// =============================================================================\n// UNDO/REDO STATE\n// =============================================================================\n\n/**\n * Type-safe undo/redo state.\n */\nexport type UndoableState<T> = {\n  current: T\n  past: T[]\n  future: T[]\n  canUndo: boolean\n  canRedo: boolean\n}\n\n/**\n * Create undoable state helpers.\n */\nexport function undoable<T>(initial: T): UndoableStateHelpers<T> {\n  return {\n    init: () => ({\n      current: initial,\n      past: [],\n      future: [],\n      canUndo: false,\n      canRedo: false,\n    }),\n    \n    push: (state, value) => ({\n      current: value,\n      past: [...state.past, state.current],\n      future: [],\n      canUndo: true,\n      canRedo: false,\n    }),\n    \n    undo: (state) => {\n      if (state.past.length === 0) return state\n      const previous = state.past[state.past.length - 1]!\n      return {\n        current: previous,\n        past: state.past.slice(0, -1),\n        future: [state.current, ...state.future],\n        canUndo: state.past.length > 1,\n        canRedo: true,\n      }\n    },\n    \n    redo: (state) => {\n      if (state.future.length === 0) return state\n      const next = state.future[0]!\n      return {\n        current: next,\n        past: [...state.past, state.current],\n        future: state.future.slice(1),\n        canUndo: true,\n        canRedo: state.future.length > 1,\n      }\n    },\n  }\n}\n\ninterface UndoableStateHelpers<T> {\n  init(): UndoableState<T>\n  push(state: UndoableState<T>, value: T): UndoableState<T>\n  undo(state: UndoableState<T>): UndoableState<T>\n  redo(state: UndoableState<T>): UndoableState<T>\n}\n\n// =============================================================================\n// BUILDER TYPE (Fluent Type Construction)\n// =============================================================================\n\n/**\n * Fluent type builder for constructing complex types.\n * \n * @example\n * // Instead of: type Admin = User & { permissions: string[] } & Omit<Account, 'id'>\n * \n * type Admin = Build<User>\n *   ['extend']<{ permissions: string[] }>\n *   ['omit']<'password'>\n *   ['done']\n */\nexport type Build<T> = {\n  extend: <U extends object>() => Build<Prettify<T & U>>\n  pick: <K extends keyof T>() => Build<Pick<T, K>>\n  omit: <K extends keyof T>() => Build<Omit<T, K>>\n  partial: () => Build<Partial<T>>\n  required: () => Build<Required<T>>\n  readonly: () => Build<Readonly<T>>\n  nullable: () => Build<T | null>\n  optional: () => Build<T | undefined>\n  array: () => Build<T[]>\n  promise: () => Build<Promise<T>>\n  done: T\n}\n\n/**\n * Start building a type from a base type.\n * This is a type-level utility, no runtime code needed.\n * \n * @example\n * interface User { id: number; name: string; password: string }\n * \n * // Create a public user type\n * type PublicUser = Build<User>['omit']<'password'>['done']\n * // { id: number; name: string }\n * \n * // Create an admin type\n * type Admin = Build<User>['extend']<{ role: 'admin'; permissions: string[] }>['done']\n * // { id: number; name: string; password: string; role: 'admin'; permissions: string[] }\n */\nexport type TypeBuilder<T> = Build<T>\n","/**\n * Exhaustive Pattern Matching for Discriminated Unions\n * \n * This solves the problem of handling all cases in a union type\n * with compile-time exhaustiveness checking.\n */\n\nimport type { Prettify } from './types'\n\n/**\n * Extracts the discriminant value from a discriminated union member.\n */\ntype DiscriminantValue<T, K extends keyof T> = T extends Record<K, infer V> ? V : never\n\n/**\n * Extracts the union member that matches a specific discriminant value.\n */\ntype ExtractByDiscriminant<T, K extends keyof T, V> = T extends Record<K, V> ? T : never\n\n/**\n * Gets all possible discriminant values from a union.\n */\ntype DiscriminantValues<T, K extends keyof T> = T extends Record<K, infer V> \n  ? V extends string | number | symbol \n    ? V \n    : never \n  : never\n\n/**\n * Pattern matcher builder for discriminated unions.\n * Provides compile-time exhaustiveness checking.\n * \n * @example\n * type Result = \n *   | { status: 'loading' }\n *   | { status: 'success'; data: User }\n *   | { status: 'error'; message: string }\n * \n * const message = match(result, 'status')\n *   .with('loading', () => 'Loading...')\n *   .with('success', (r) => `Hello ${r.data.name}`)\n *   .with('error', (r) => `Error: ${r.message}`)\n *   .exhaustive()\n */\nexport function match<T extends Record<K, string | number | symbol>, K extends keyof T>(\n  value: T,\n  discriminant: K\n): MatchBuilder<T, K, DiscriminantValues<T, K>> {\n  return new MatchBuilderImpl(value, discriminant, {}) as MatchBuilder<T, K, DiscriminantValues<T, K>>\n}\n\n/**\n * Match builder interface with remaining cases tracking.\n */\ninterface MatchBuilder<T, K extends keyof T, Remaining extends string | number | symbol> {\n  /**\n   * Handle a specific case.\n   */\n  with<V extends Remaining, R>(\n    value: V,\n    handler: (matched: Prettify<ExtractByDiscriminant<T, K, V>>) => R\n  ): MatchBuilder<T, K, Exclude<Remaining, V>>\n\n  /**\n   * Complete the match, ensuring all cases are handled.\n   * Only available when all cases have been covered.\n   */\n  exhaustive: [Remaining] extends [never] \n    ? () => unknown\n    : { error: `Missing cases: ${Remaining & string}` }\n\n  /**\n   * Provide a default handler for any remaining cases.\n   */\n  otherwise<R>(handler: (value: T) => R): R\n\n  /**\n   * Run the match and return the result.\n   * Only available when all cases are handled.\n   */\n  run: [Remaining] extends [never] ? () => unknown : { error: `Missing cases: ${Remaining & string}` }\n}\n\n/**\n * Internal implementation of the match builder.\n */\nclass MatchBuilderImpl<T extends Record<K, string | number | symbol>, K extends keyof T> {\n  private value: T\n  private discriminant: K\n  private handlers: Record<string | number | symbol, (value: unknown) => unknown>\n  private result: unknown = undefined\n  private matched = false\n\n  constructor(\n    value: T,\n    discriminant: K,\n    handlers: Record<string | number | symbol, (value: unknown) => unknown>\n  ) {\n    this.value = value\n    this.discriminant = discriminant\n    this.handlers = handlers\n  }\n\n  with<V extends string | number | symbol, R>(\n    matchValue: V,\n    handler: (matched: unknown) => R\n  ): MatchBuilderImpl<T, K> {\n    const newHandlers = { ...this.handlers, [matchValue]: handler }\n    const builder = new MatchBuilderImpl(this.value, this.discriminant, newHandlers)\n    \n    // Check if this case matches\n    const discriminantValue = this.value[this.discriminant] as string | number | symbol\n    if (!this.matched && discriminantValue === matchValue) {\n      builder.result = handler(this.value)\n      builder.matched = true\n    } else {\n      builder.result = this.result\n      builder.matched = this.matched\n    }\n    \n    return builder\n  }\n\n  exhaustive(): unknown {\n    if (this.matched) {\n      return this.result\n    }\n    throw new Error(`No handler matched for discriminant value: ${String(this.value[this.discriminant])}`)\n  }\n\n  otherwise<R>(handler: (value: T) => R): R {\n    if (this.matched) {\n      return this.result as R\n    }\n    return handler(this.value)\n  }\n\n  run(): unknown {\n    return this.exhaustive()\n  }\n}\n\n/**\n * Simple match function for when you want to handle all cases inline.\n * \n * @example\n * type Status = 'pending' | 'success' | 'error'\n * \n * const message = matchValue(status, {\n *   pending: () => 'Loading...',\n *   success: () => 'Done!',\n *   error: () => 'Failed',\n * })\n */\nexport function matchValue<\n  T extends string | number | symbol,\n  Cases extends Record<T, () => unknown>\n>(\n  value: T,\n  cases: Cases\n): ReturnType<Cases[T]> {\n  const handler = cases[value]\n  if (!handler) {\n    throw new Error(`No handler for value: ${String(value)}`)\n  }\n  return handler() as ReturnType<Cases[T]>\n}\n\n/**\n * Match on a discriminated union with a handler object.\n * Provides exhaustiveness checking through the type system.\n * \n * @example\n * type Event = \n *   | { type: 'click'; x: number; y: number }\n *   | { type: 'keypress'; key: string }\n * \n * const result = matchUnion(event, 'type', {\n *   click: (e) => `Clicked at ${e.x}, ${e.y}`,\n *   keypress: (e) => `Pressed ${e.key}`,\n * })\n */\nexport function matchUnion<\n  T extends Record<K, string | number | symbol>,\n  K extends keyof T,\n  Handlers extends {\n    [V in DiscriminantValues<T, K>]: (value: Prettify<ExtractByDiscriminant<T, K, V>>) => unknown\n  }\n>(\n  value: T,\n  discriminant: K,\n  handlers: Handlers\n): ReturnType<Handlers[DiscriminantValues<T, K>]> {\n  const discriminantValue = value[discriminant] as DiscriminantValues<T, K>\n  const handler = handlers[discriminantValue]\n  return handler(value as any) as ReturnType<Handlers[DiscriminantValues<T, K>]>\n}\n\n/**\n * Creates a matcher function for a specific discriminated union type.\n * Useful for reusable matching logic.\n * \n * @example\n * type Result<T> = { ok: true; value: T } | { ok: false; error: Error }\n * \n * const matchResult = createMatcher<Result<User>>()('ok')\n * \n * const name = matchResult(result, {\n *   true: (r) => r.value.name,\n *   false: (r) => 'Unknown',\n * })\n */\nexport function createMatcher<T extends Record<string, unknown>>() {\n  return <K extends keyof T>(discriminant: K) => {\n    return <\n      Handlers extends {\n        [V in DiscriminantValues<T, K>]: (value: Prettify<ExtractByDiscriminant<T, K, V>>) => unknown\n      }\n    >(\n      value: T,\n      handlers: Handlers\n    ): ReturnType<Handlers[DiscriminantValues<T, K>]> => {\n      return matchUnion(value as T & Record<K, string | number | symbol>, discriminant, handlers as any)\n    }\n  }\n}\n\nexport type { DiscriminantValue, ExtractByDiscriminant, DiscriminantValues }\n","/**\n * Type Debugging Utilities\n * \n * These utilities help developers understand and debug complex types.\n * They make type errors more readable and help catch type issues at compile time.\n */\n\n// =============================================================================\n// TYPE ASSERTIONS (Compile-time checks)\n// =============================================================================\n\n/**\n * Asserts that two types are exactly equal.\n * Causes a compile error if they're not.\n * \n * @example\n * type Test = AssertEqual<{ a: 1 }, { a: 1 }> // OK\n * type Fail = AssertEqual<{ a: 1 }, { a: 2 }> // Error!\n */\nexport type AssertEqual<T, U> = (<G>() => G extends T ? 1 : 2) extends <G>() => G extends U ? 1 : 2\n  ? T\n  : { error: 'Types are not equal'; expected: U; actual: T }\n\n/**\n * Asserts that T extends U.\n * \n * @example\n * type Test = AssertExtends<'hello', string> // OK\n * type Fail = AssertExtends<string, 'hello'> // Error!\n */\nexport type AssertExtends<T, U> = T extends U\n  ? T\n  : { error: 'Type does not extend'; type: T; shouldExtend: U }\n\n/**\n * Asserts that a type is not never.\n * Useful for catching accidental never types.\n * \n * @example\n * type Test = AssertNotNever<string> // OK\n * type Fail = AssertNotNever<never> // Error!\n */\nexport type AssertNotNever<T> = [T] extends [never]\n  ? { error: 'Type is never'; hint: 'Check for conflicting intersections or impossible conditions' }\n  : T\n\n/**\n * Asserts that a type is not any.\n * Helps prevent accidental any propagation.\n * \n * @example\n * type Test = AssertNotAny<string> // OK\n * type Fail = AssertNotAny<any> // Error!\n */\nexport type AssertNotAny<T> = 0 extends 1 & T\n  ? { error: 'Type is any'; hint: 'Add proper type annotations' }\n  : T\n\n/**\n * Asserts that a type is not unknown.\n * \n * @example\n * type Test = AssertNotUnknown<string> // OK\n * type Fail = AssertNotUnknown<unknown> // Error!\n */\nexport type AssertNotUnknown<T> = unknown extends T\n  ? 0 extends 1 & T\n    ? T // It's any, not unknown\n    : { error: 'Type is unknown'; hint: 'Add type narrowing or assertions' }\n  : T\n\n// =============================================================================\n// TYPE INSPECTION\n// =============================================================================\n\n/**\n * Forces TypeScript to expand a type for better IDE display.\n * This is the famous \"Prettify\" hack that makes complex types readable.\n * \n * @example\n * type Complex = Pick<Omit<User, 'password'>, 'name' | 'email'> & { role: string }\n * type Readable = Expand<Complex>\n * // Hover shows: { name: string; email: string; role: string }\n */\nexport type Expand<T> = T extends infer O ? { [K in keyof O]: O[K] } : never\n\n/**\n * Recursively expands a type for deep inspection.\n * \n * @example\n * type Nested = { user: Pick<User, 'name'> & { settings: Partial<Settings> } }\n * type Readable = ExpandDeep<Nested>\n * // Shows fully expanded nested structure\n */\nexport type ExpandDeep<T> = T extends object\n  ? T extends infer O\n    ? { [K in keyof O]: ExpandDeep<O[K]> }\n    : never\n  : T\n\n/**\n * Shows the \"shape\" of a type without the actual values.\n * Useful for understanding complex generic types.\n * \n * @example\n * type Shape = TypeShape<{ name: string; age: number; active: boolean }>\n * // { name: 'string'; age: 'number'; active: 'boolean' }\n */\nexport type TypeShape<T> = T extends string\n  ? 'string'\n  : T extends number\n    ? 'number'\n    : T extends boolean\n      ? 'boolean'\n      : T extends null\n        ? 'null'\n        : T extends undefined\n          ? 'undefined'\n          : T extends readonly unknown[]\n            ? 'array'\n            : T extends (...args: unknown[]) => unknown\n              ? 'function'\n              : T extends object\n                ? { [K in keyof T]: TypeShape<T[K]> }\n                : 'unknown'\n\n/**\n * Gets the \"kind\" of a type as a string literal.\n * \n * @example\n * type K1 = TypeKind<string> // 'string'\n * type K2 = TypeKind<{ a: 1 }> // 'object'\n * type K3 = TypeKind<string[]> // 'array'\n */\nexport type TypeKind<T> = [T] extends [never]\n  ? 'never'\n  : T extends string\n    ? 'string'\n    : T extends number\n      ? 'number'\n      : T extends boolean\n        ? 'boolean'\n        : T extends bigint\n          ? 'bigint'\n          : T extends symbol\n            ? 'symbol'\n            : T extends null\n              ? 'null'\n              : T extends undefined\n                ? 'undefined'\n                : T extends readonly unknown[]\n                  ? 'array'\n                  : T extends (...args: unknown[]) => unknown\n                    ? 'function'\n                    : T extends object\n                      ? 'object'\n                      : 'unknown'\n\n// =============================================================================\n// TYPE TESTING UTILITIES\n// =============================================================================\n\n/**\n * Test helper that expects a type to be true.\n * Use with conditional types to create type tests.\n * \n * @example\n * type Test1 = Expect<true> // OK\n * type Test2 = Expect<false> // Error!\n */\nexport type Expect<T extends true> = T\n\n/**\n * Test helper that expects a type to be false.\n * \n * @example\n * type Test1 = ExpectFalse<false> // OK\n * type Test2 = ExpectFalse<true> // Error!\n */\nexport type ExpectFalse<T extends false> = T\n\n/**\n * Checks if two types are exactly equal.\n * Returns true or false.\n * \n * @example\n * type Test = Equal<{ a: 1 }, { a: 1 }> // true\n * type Test2 = Equal<{ a: 1 }, { a: 2 }> // false\n */\nexport type Equal<A, B> = (<T>() => T extends A ? 1 : 2) extends <T>() => T extends B ? 1 : 2\n  ? true\n  : false\n\n/**\n * Checks if two types are not equal.\n * \n * @example\n * type Test = NotEqual<string, number> // true\n * type Test2 = NotEqual<string, string> // false\n */\nexport type NotEqual<A, B> = Equal<A, B> extends true ? false : true\n\n/**\n * Checks if a type is exactly `any`.\n * \n * @example\n * type Test = IsAny<any> // true\n * type Test2 = IsAny<unknown> // false\n */\nexport type IsAny<T> = 0 extends 1 & T ? true : false\n\n/**\n * Checks if a type is exactly `never`.\n * \n * @example\n * type Test = IsNever<never> // true\n * type Test2 = IsNever<void> // false\n */\nexport type IsNever<T> = [T] extends [never] ? true : false\n\n/**\n * Checks if a type is exactly `unknown`.\n * \n * @example\n * type Test = IsUnknown<unknown> // true\n * type Test2 = IsUnknown<any> // false\n */\nexport type IsUnknown<T> = IsAny<T> extends true\n  ? false\n  : unknown extends T\n    ? true\n    : false\n\n/**\n * Checks if a type is a union (has multiple members).\n * \n * @example\n * type Test = IsUnion<'a' | 'b'> // true\n * type Test2 = IsUnion<'a'> // false\n */\nexport type IsUnion<T, U = T> = T extends U\n  ? [U] extends [T]\n    ? false\n    : true\n  : never\n\n/**\n * Checks if a type is a literal (not widened).\n * \n * @example\n * type Test = IsLiteral<'hello'> // true\n * type Test2 = IsLiteral<string> // false\n */\nexport type IsLiteral<T> = T extends string\n  ? string extends T\n    ? false\n    : true\n  : T extends number\n    ? number extends T\n      ? false\n      : true\n    : T extends boolean\n      ? boolean extends T\n        ? false\n        : true\n      : false\n\n// =============================================================================\n// ERROR MESSAGE HELPERS\n// =============================================================================\n\n/**\n * Creates a custom compile-time error message.\n * \n * @example\n * type ValidateAge<T extends number> = T extends number\n *   ? T\n *   : TypeError<'Age must be a number'>\n */\nexport type TypeError<Message extends string> = { __error: Message }\n\n/**\n * Creates a branded error type with context.\n * \n * @example\n * type Result = TypeErrorWithContext<'Invalid type', { expected: string; got: number }>\n */\nexport type TypeErrorWithContext<\n  Message extends string,\n  Context extends Record<string, unknown>\n> = { __error: Message; __context: Context }\n\n/**\n * Validates a type and returns an error if invalid.\n * \n * @example\n * type ValidString<T> = Validate<T, string, 'Expected a string type'>\n */\nexport type Validate<T, Expected, ErrorMessage extends string> = T extends Expected\n  ? T\n  : TypeError<ErrorMessage>\n\n// =============================================================================\n// DEBUGGING FUNCTIONS (Runtime)\n// =============================================================================\n\n/**\n * A no-op function that helps debug types at compile time.\n * Hover over the parameter to see the inferred type.\n * \n * @example\n * const user = { name: 'John', age: 30 }\n * showType(user) // Hover to see type\n */\nexport function showType<T>(_value: T): T {\n  return _value\n}\n\n/**\n * Asserts a type at compile time without runtime overhead.\n * \n * @example\n * const value = getValue()\n * assertType<string>(value) // Compile error if value is not string\n */\nexport function assertType<T>(_value: T): void {\n  // No-op at runtime, type checking at compile time\n}\n\n/**\n * Creates a type-safe \"impossible\" marker.\n * Useful for exhaustiveness checking.\n * \n * @example\n * function handleStatus(status: Status) {\n *   switch (status) {\n *     case 'pending': return 'Loading'\n *     case 'success': return 'Done'\n *     case 'error': return 'Failed'\n *     default: return impossible(status) // Error if cases are missing\n *   }\n * }\n */\nexport function impossible(value: never): never {\n  throw new Error(`Unexpected value: ${JSON.stringify(value)}`)\n}\n\n/**\n * Type-safe identity function that preserves literal types.\n * Useful for type inference in complex scenarios.\n * \n * @example\n * const config = identity({\n *   host: 'localhost',\n *   port: 3000,\n * } as const)\n * // Type is preserved as { readonly host: 'localhost'; readonly port: 3000 }\n */\nexport function identity<T>(value: T): T {\n  return value\n}\n\n/**\n * Narrows a type using a type guard with better inference.\n * \n * @example\n * const items: (string | number)[] = [1, 'a', 2, 'b']\n * const strings = items.filter(narrow((x): x is string => typeof x === 'string'))\n */\nexport function narrow<T, S extends T>(\n  guard: (value: T) => value is S\n): (value: T) => value is S {\n  return guard\n}\n","/**\n * Type-Safe Merge Utilities\n * \n * These functions solve the common problem of merging objects\n * while preserving proper type inference.\n */\n\nimport type { Prettify } from './types'\n\n/**\n * Type for deep merge result.\n */\ntype DeepMergeResult<A, B> = {\n  [K in keyof A | keyof B]: K extends keyof B\n    ? K extends keyof A\n      ? A[K] extends object\n        ? B[K] extends object\n          ? A[K] extends readonly unknown[]\n            ? B[K]\n            : B[K] extends readonly unknown[]\n              ? B[K]\n              : DeepMergeResult<A[K], B[K]>\n          : B[K]\n        : B[K]\n      : B[K]\n    : K extends keyof A\n      ? A[K]\n      : never\n}\n\n/**\n * Merges two objects with proper type inference.\n * The second object's properties override the first.\n * \n * Unlike `{ ...a, ...b }`, this preserves exact types.\n * \n * @example\n * const base = { name: 'John', age: 30 }\n * const override = { age: 31, email: 'john@example.com' }\n * \n * const merged = merge(base, override)\n * // Type: { name: string; age: number; email: string }\n * // Value: { name: 'John', age: 31, email: 'john@example.com' }\n */\nexport function merge<A extends object, B extends object>(\n  a: A,\n  b: B\n): Prettify<Omit<A, keyof B> & B> {\n  return { ...a, ...b } as Prettify<Omit<A, keyof B> & B>\n}\n\n/**\n * Merges multiple objects in sequence.\n * Later objects override earlier ones.\n * \n * @example\n * const result = mergeAll(\n *   { a: 1 },\n *   { b: 2 },\n *   { c: 3, a: 10 }\n * )\n * // Type: { a: number; b: number; c: number }\n * // Value: { a: 10, b: 2, c: 3 }\n */\nexport function mergeAll<T extends object[]>(\n  ...objects: T\n): MergeAllResult<T> {\n  return Object.assign({}, ...objects) as MergeAllResult<T>\n}\n\ntype MergeAllResult<T extends object[]> = T extends [infer First, ...infer Rest]\n  ? Rest extends object[]\n    ? First extends object\n      ? Prettify<Omit<First, keyof MergeAllResult<Rest>> & MergeAllResult<Rest>>\n      : never\n    : First\n  : {}\n\n/**\n * Deep merges two objects, recursively merging nested objects.\n * \n * @example\n * const base = {\n *   user: { name: 'John', settings: { theme: 'light' } }\n * }\n * const override = {\n *   user: { settings: { notifications: true } }\n * }\n * \n * const merged = deepMerge(base, override)\n * // {\n * //   user: {\n * //     name: 'John',\n * //     settings: { theme: 'light', notifications: true }\n * //   }\n * // }\n */\nexport function deepMerge<A extends object, B extends object>(\n  a: A,\n  b: B\n): Prettify<DeepMergeResult<A, B>> {\n  const result = { ...a } as Record<string, unknown>\n\n  for (const key of Object.keys(b)) {\n    const bValue = (b as Record<string, unknown>)[key]\n    const aValue = (a as Record<string, unknown>)[key]\n\n    if (\n      isPlainObject(bValue) &&\n      isPlainObject(aValue)\n    ) {\n      result[key] = deepMerge(\n        aValue as object,\n        bValue as object\n      )\n    } else {\n      result[key] = bValue\n    }\n  }\n\n  return result as Prettify<DeepMergeResult<A, B>>\n}\n\nfunction isPlainObject(value: unknown): value is Record<string, unknown> {\n  return (\n    typeof value === 'object' &&\n    value !== null &&\n    !Array.isArray(value) &&\n    Object.getPrototypeOf(value) === Object.prototype\n  )\n}\n\n/**\n * Merges with explicit handling of conflicting keys.\n * Requires a resolver function for keys that exist in both objects.\n * \n * @example\n * const a = { name: 'John', age: 30 }\n * const b = { name: 'Jane', email: 'jane@example.com' }\n * \n * const merged = mergeWith(a, b, {\n *   name: (aVal, bVal) => `${aVal} & ${bVal}`,\n * })\n * // { name: 'John & Jane', age: 30, email: 'jane@example.com' }\n */\nexport function mergeWith<\n  A extends object,\n  B extends object,\n  Resolvers extends Partial<{\n    [K in keyof A & keyof B]: (a: A[K], b: B[K]) => unknown\n  }>\n>(\n  a: A,\n  b: B,\n  resolvers: Resolvers\n): Prettify<\n  Omit<A, keyof B> &\n  Omit<B, keyof Resolvers> &\n  { [K in keyof Resolvers]: Resolvers[K] extends (a: unknown, b: unknown) => infer R ? R : never }\n> {\n  const result = { ...a, ...b } as Record<string, unknown>\n\n  for (const key of Object.keys(resolvers)) {\n    const resolver = (resolvers as Record<string, ((a: unknown, b: unknown) => unknown) | undefined>)[key]\n    if (resolver && key in a && key in b) {\n      result[key] = resolver(\n        (a as Record<string, unknown>)[key],\n        (b as Record<string, unknown>)[key]\n      )\n    }\n  }\n\n  return result as Prettify<\n    Omit<A, keyof B> &\n    Omit<B, keyof Resolvers> &\n    { [K in keyof Resolvers]: Resolvers[K] extends (a: unknown, b: unknown) => infer R ? R : never }\n  >\n}\n\n/**\n * Creates a new object with only the specified keys.\n * Type-safe alternative to manual property picking.\n * \n * @example\n * const user = { id: 1, name: 'John', email: 'john@example.com', password: 'secret' }\n * const public = pick(user, ['id', 'name', 'email'])\n * // Type: { id: number; name: string; email: string }\n */\nexport function pick<T extends object, K extends keyof T>(\n  obj: T,\n  keys: readonly K[]\n): Prettify<Pick<T, K>> {\n  const result = {} as Pick<T, K>\n  for (const key of keys) {\n    if (key in obj) {\n      result[key] = obj[key]\n    }\n  }\n  return result as Prettify<Pick<T, K>>\n}\n\n/**\n * Creates a new object without the specified keys.\n * Type-safe alternative to manual property omission.\n * \n * @example\n * const user = { id: 1, name: 'John', password: 'secret' }\n * const safe = omit(user, ['password'])\n * // Type: { id: number; name: string }\n */\nexport function omit<T extends object, K extends keyof T>(\n  obj: T,\n  keys: readonly K[]\n): Prettify<Omit<T, K>> {\n  const result = { ...obj }\n  for (const key of keys) {\n    delete (result as Record<string, unknown>)[key as string]\n  }\n  return result as Prettify<Omit<T, K>>\n}\n\n/**\n * Renames keys in an object with type safety.\n * \n * @example\n * const user = { firstName: 'John', lastName: 'Doe' }\n * const renamed = renameKeys(user, { firstName: 'name' })\n * // Type: { name: string; lastName: string }\n */\nexport function renameKeys<\n  T extends object,\n  Mapping extends Partial<Record<keyof T, string>>\n>(\n  obj: T,\n  mapping: Mapping\n): Prettify<\n  Omit<T, keyof Mapping> &\n  { [K in keyof Mapping as Mapping[K] extends string ? Mapping[K] : never]: K extends keyof T ? T[K] : never }\n> {\n  const result: Record<string, unknown> = {}\n\n  for (const key of Object.keys(obj) as (keyof T)[]) {\n    const newKey = mapping[key as keyof Mapping]\n    if (newKey !== undefined) {\n      result[newKey as string] = obj[key]\n    } else {\n      result[key as string] = obj[key]\n    }\n  }\n\n  return result as any\n}\n\n/**\n * Creates an object from entries with proper type inference.\n * Better typed than Object.fromEntries.\n * \n * @example\n * const entries = [['a', 1], ['b', 2]] as const\n * const obj = fromEntries(entries)\n * // Type: { a: 1; b: 2 }\n */\nexport function fromEntries<\n  T extends readonly (readonly [PropertyKey, unknown])[]\n>(\n  entries: T\n): Prettify<{ [E in T[number] as E[0]]: E[1] }> {\n  return Object.fromEntries(entries) as any\n}\n\n/**\n * Maps object values while preserving keys.\n * \n * @example\n * const obj = { a: 1, b: 2, c: 3 }\n * const doubled = mapValues(obj, (v) => v * 2)\n * // Type: { a: number; b: number; c: number }\n * // Value: { a: 2, b: 4, c: 6 }\n */\nexport function mapValues<T extends object, U>(\n  obj: T,\n  fn: (value: T[keyof T], key: keyof T) => U\n): { [K in keyof T]: U } {\n  const result = {} as { [K in keyof T]: U }\n  for (const key of Object.keys(obj) as (keyof T)[]) {\n    result[key] = fn(obj[key], key)\n  }\n  return result\n}\n\n/**\n * Maps object keys while preserving values.\n * \n * @example\n * const obj = { a: 1, b: 2 }\n * const prefixed = mapKeys(obj, (k) => `prefix_${k}`)\n * // { prefix_a: 1, prefix_b: 2 }\n */\nexport function mapKeys<T extends object, K extends string>(\n  obj: T,\n  fn: (key: keyof T) => K\n): { [P in K]: T[keyof T] } {\n  const result = {} as { [P in K]: T[keyof T] }\n  for (const key of Object.keys(obj) as (keyof T)[]) {\n    const newKey = fn(key)\n    result[newKey] = obj[key]\n  }\n  return result\n}\n"]}