{"version":3,"file":"runtime-checker.mjs","sources":["../../../../src/lib/data/validation/runtime-checker.ts"],"sourcesContent":["/**\n * @file Runtime Type Checker\n * @description Production-grade runtime type checking with type guards,\n * assertion functions, branded types, and narrowing utilities.\n *\n * Features:\n * - Type guard functions for runtime verification\n * - Assertion functions with detailed error messages\n * - Branded types for nominal typing\n * - Type narrowing utilities\n * - Composable checkers\n *\n * @example\n * ```typescript\n * import { is, assert, brand } from '@/lib/data/validation';\n *\n * // Type guards\n * if (is.string(value)) {\n *   value.toUpperCase(); // TypeScript knows it's a string\n * }\n *\n * // Assertions\n * assert.string(value, 'Expected string');\n * value.toUpperCase(); // TypeScript knows it's a string\n *\n * // Branded types\n * type UserId = Brand<string, 'UserId'>;\n * const userId = brand<UserId>(id);\n * ```\n */\n\n// =============================================================================\n// BRANDED TYPES\n// =============================================================================\n\n/**\n * Brand type for nominal typing\n * Prevents accidental assignment between structurally identical types\n */\ndeclare const BRAND: unique symbol;\n\nexport type Brand<T, B extends string> = T & { [BRAND]: B };\n\n/**\n * Create a branded value\n */\nexport function brand<T extends Brand<unknown, string>>(\n  value: T extends Brand<infer U, string> ? U : never\n): T {\n  return value as T;\n}\n\n/**\n * Extract the base type from a branded type\n */\nexport type Unbrand<T> = T extends Brand<infer U, string> ? U : T;\n\n// =============================================================================\n// TYPE GUARD TYPES\n// =============================================================================\n\n/**\n * Type guard function signature\n */\nexport type TypeGuard<T> = (value: unknown) => value is T;\n\n/**\n * Type assertion function signature\n */\nexport type TypeAssertion<T> = (value: unknown, message?: string) => asserts value is T;\n\n/**\n * Runtime check result\n */\nexport interface CheckResult<T> {\n  success: boolean;\n  value: T | undefined;\n  error?: string;\n}\n\n// =============================================================================\n// PRIMITIVE TYPE GUARDS\n// =============================================================================\n\n/**\n * Check if value is a string\n */\nexport function isString(value: unknown): value is string {\n  return typeof value === 'string';\n}\n\n/**\n * Check if value is a number (excludes NaN)\n */\nexport function isNumber(value: unknown): value is number {\n  return typeof value === 'number' && !Number.isNaN(value);\n}\n\n/**\n * Check if value is a boolean\n */\nexport function isBoolean(value: unknown): value is boolean {\n  return typeof value === 'boolean';\n}\n\n/**\n * Check if value is a bigint\n */\nexport function isBigInt(value: unknown): value is bigint {\n  return typeof value === 'bigint';\n}\n\n/**\n * Check if value is a symbol\n */\nexport function isSymbol(value: unknown): value is symbol {\n  return typeof value === 'symbol';\n}\n\n/**\n * Check if value is undefined\n */\nexport function isUndefined(value: unknown): value is undefined {\n  return value === undefined;\n}\n\n/**\n * Check if value is null\n */\nexport function isNull(value: unknown): value is null {\n  return value === null;\n}\n\n/**\n * Check if value is null or undefined\n */\nexport function isNullish(value: unknown): value is null | undefined {\n  return value === null || value === undefined;\n}\n\n/**\n * Check if value is defined (not null or undefined)\n */\nexport function isDefined<T>(value: T | null | undefined): value is T {\n  return value !== null && value !== undefined;\n}\n\n/**\n * Check if value is a function\n */\nexport function isFunction(value: unknown): value is (...args: unknown[]) => unknown {\n  return typeof value === 'function';\n}\n\n// =============================================================================\n// OBJECT TYPE GUARDS\n// =============================================================================\n\n/**\n * Check if value is an object (excludes null and arrays)\n */\nexport function isObject(value: unknown): value is Record<string, unknown> {\n  return typeof value === 'object' && value !== null && !Array.isArray(value);\n}\n\n/**\n * Check if value is a plain object (not a class instance)\n */\nexport function isPlainObject(value: unknown): value is Record<string, unknown> {\n  if (!isObject(value)) return false;\n  const prototype = Object.getPrototypeOf(value) as unknown;\n  return prototype === null || prototype === Object.prototype;\n}\n\n/**\n * Check if value is an array\n */\nexport function isArray(value: unknown): value is unknown[] {\n  return Array.isArray(value);\n}\n\n/**\n * Check if value is an array of specific type\n */\nexport function isArrayOf<T>(value: unknown, guard: TypeGuard<T>): value is T[] {\n  return Array.isArray(value) && value.every(guard);\n}\n\n/**\n * Check if value is a Date\n */\nexport function isDate(value: unknown): value is Date {\n  return value instanceof Date && !isNaN(value.getTime());\n}\n\n/**\n * Check if value is a RegExp\n */\nexport function isRegExp(value: unknown): value is RegExp {\n  return value instanceof RegExp;\n}\n\n/**\n * Check if value is a Map\n */\nexport function isMap<K = unknown, V = unknown>(value: unknown): value is Map<K, V> {\n  return value instanceof Map;\n}\n\n/**\n * Check if value is a Set\n */\nexport function isSet<T = unknown>(value: unknown): value is Set<T> {\n  return value instanceof Set;\n}\n\n/**\n * Check if value is a Promise\n */\nexport function isPromise<T = unknown>(value: unknown): value is Promise<T> {\n  return (\n    value instanceof Promise || (isObject(value) && isFunction((value as { then?: unknown }).then))\n  );\n}\n\n/**\n * Check if value is an Error\n */\nexport function isError(value: unknown): value is Error {\n  return value instanceof Error;\n}\n\n// =============================================================================\n// NUMBER REFINEMENT GUARDS\n// =============================================================================\n\n/**\n * Check if value is an integer\n */\nexport function isInteger(value: unknown): value is number {\n  return isNumber(value) && Number.isInteger(value);\n}\n\n/**\n * Check if value is a positive number\n */\nexport function isPositive(value: unknown): value is number {\n  return isNumber(value) && value > 0;\n}\n\n/**\n * Check if value is a negative number\n */\nexport function isNegative(value: unknown): value is number {\n  return isNumber(value) && value < 0;\n}\n\n/**\n * Check if value is a non-negative number\n */\nexport function isNonNegative(value: unknown): value is number {\n  return isNumber(value) && value >= 0;\n}\n\n/**\n * Check if value is a finite number\n */\nexport function isFinite(value: unknown): value is number {\n  return isNumber(value) && Number.isFinite(value);\n}\n\n/**\n * Check if number is within range (inclusive)\n */\nexport function isInRange(value: unknown, min: number, max: number): value is number {\n  return isNumber(value) && value >= min && value <= max;\n}\n\n// =============================================================================\n// STRING REFINEMENT GUARDS\n// =============================================================================\n\n/**\n * Check if value is a non-empty string\n */\nexport function isNonEmptyString(value: unknown): value is string {\n  return isString(value) && value.length > 0;\n}\n\n/**\n * Check if string matches pattern\n */\nexport function isStringMatching(value: unknown, pattern: RegExp): value is string {\n  return isString(value) && pattern.test(value);\n}\n\n/**\n * Check if value is a valid email\n */\nexport function isEmail(value: unknown): value is string {\n  return isString(value) && /^[^\\s@]+@[^\\s@]+\\.[^\\s@]+$/.test(value);\n}\n\n/**\n * Check if value is a valid URL\n */\nexport function isURL(value: unknown): value is string {\n  if (!isString(value)) return false;\n  try {\n    new URL(value);\n    return true;\n  } catch {\n    return false;\n  }\n}\n\n/**\n * Check if value is a valid UUID\n */\nexport function isUUID(value: unknown): value is string {\n  return (\n    isString(value) &&\n    /^[0-9a-f]{8}-[0-9a-f]{4}-[1-5][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i.test(value)\n  );\n}\n\n/**\n * Check if value is a valid ISO date string\n */\nexport function isISODateString(value: unknown): value is string {\n  if (!isString(value)) return false;\n  const date = new Date(value);\n  return !isNaN(date.getTime()) && value.includes('-');\n}\n\n/**\n * Check if value is a valid JSON string\n */\nexport function isJSONString(value: unknown): value is string {\n  if (!isString(value)) return false;\n  try {\n    JSON.parse(value);\n    return true;\n  } catch {\n    return false;\n  }\n}\n\n// =============================================================================\n// OBJECT SHAPE GUARDS\n// =============================================================================\n\n/**\n * Check if object has a specific key\n */\nexport function hasKey<K extends string>(value: unknown, key: K): value is Record<K, unknown> {\n  return isObject(value) && key in value;\n}\n\n/**\n * Check if object has specific keys\n */\nexport function hasKeys<K extends string>(value: unknown, keys: K[]): value is Record<K, unknown> {\n  return isObject(value) && keys.every((key) => key in value);\n}\n\n/**\n * Check if object has key with specific type\n */\nexport function hasKeyOfType<K extends string, T>(\n  value: unknown,\n  key: K,\n  guard: TypeGuard<T>\n): value is Record<K, T> {\n  return hasKey(value, key) && guard(value[key]);\n}\n\n/**\n * Create a shape guard for objects\n */\nexport function isShapeOf<T extends Record<string, TypeGuard<unknown>>>(\n  shape: T\n): TypeGuard<{ [K in keyof T]: T[K] extends TypeGuard<infer U> ? U : never }> {\n  return (\n    value: unknown\n  ): value is { [K in keyof T]: T[K] extends TypeGuard<infer U> ? U : never } => {\n    if (!isObject(value)) return false;\n    for (const [key, guard] of Object.entries(shape)) {\n      if (!guard(value[key])) return false;\n    }\n    return true;\n  };\n}\n\n// =============================================================================\n// UNION AND LITERAL GUARDS\n// =============================================================================\n\n/**\n * Check if value is one of the specified values\n */\nexport function isOneOf<T extends readonly unknown[]>(\n  value: unknown,\n  values: T\n): value is T[number] {\n  return values.includes(value);\n}\n\n/**\n * Check if value is a specific literal\n */\nexport function isLiteral<T extends string | number | boolean>(\n  value: unknown,\n  literal: T\n): value is T {\n  return value === literal;\n}\n\n/**\n * Create a union type guard\n */\nexport function isUnion<T extends TypeGuard<unknown>[]>(\n  ...guards: T\n): TypeGuard<T[number] extends TypeGuard<infer U> ? U : never> {\n  return (value: unknown): value is T[number] extends TypeGuard<infer U> ? U : never => {\n    return guards.some((guard) => guard(value));\n  };\n}\n\n/**\n * Create an intersection type guard\n */\nexport function isIntersection<T extends TypeGuard<unknown>[]>(\n  ...guards: T\n): TypeGuard<T extends TypeGuard<infer U>[] ? U : never> {\n  return (value: unknown): value is T extends TypeGuard<infer U>[] ? U : never => {\n    return guards.every((guard) => guard(value));\n  };\n}\n\n// =============================================================================\n// ASSERTION FUNCTIONS\n// =============================================================================\n\n/**\n * Assertion error class\n */\nexport class AssertionError extends Error {\n  readonly received: unknown;\n  readonly expected?: string;\n\n  constructor(message: string, received: unknown, expected?: string) {\n    super(message);\n    this.name = 'AssertionError';\n    this.received = received;\n    this.expected = expected;\n  }\n}\n\n/**\n * Create an assertion function from a type guard\n */\nexport function createAssertion<T>(guard: TypeGuard<T>, defaultMessage: string): TypeAssertion<T> {\n  return (value: unknown, message?: string): asserts value is T => {\n    if (!guard(value)) {\n      throw new AssertionError(message ?? defaultMessage, value);\n    }\n  };\n}\n\n/**\n * Assert that value is a string\n */\nexport function assertString(value: unknown, message?: string): asserts value is string {\n  if (!isString(value)) {\n    throw new AssertionError(\n      message ?? `Expected string, received ${typeof value}`,\n      value,\n      'string'\n    );\n  }\n}\n\n/**\n * Assert that value is a number\n */\nexport function assertNumber(value: unknown, message?: string): asserts value is number {\n  if (!isNumber(value)) {\n    throw new AssertionError(\n      message ?? `Expected number, received ${typeof value}`,\n      value,\n      'number'\n    );\n  }\n}\n\n/**\n * Assert that value is a boolean\n */\nexport function assertBoolean(value: unknown, message?: string): asserts value is boolean {\n  if (!isBoolean(value)) {\n    throw new AssertionError(\n      message ?? `Expected boolean, received ${typeof value}`,\n      value,\n      'boolean'\n    );\n  }\n}\n\n/**\n * Assert that value is an object\n */\nexport function assertObject(\n  value: unknown,\n  message?: string\n): asserts value is Record<string, unknown> {\n  if (!isObject(value)) {\n    throw new AssertionError(\n      message ?? `Expected object, received ${typeof value}`,\n      value,\n      'object'\n    );\n  }\n}\n\n/**\n * Assert that value is an array\n */\nexport function assertArray(value: unknown, message?: string): asserts value is unknown[] {\n  if (!isArray(value)) {\n    throw new AssertionError(message ?? `Expected array, received ${typeof value}`, value, 'array');\n  }\n}\n\n/**\n * Assert that value is defined (not null or undefined)\n */\nexport function assertDefined<T>(\n  value: T | null | undefined,\n  message?: string\n): asserts value is T {\n  if (!isDefined(value)) {\n    throw new AssertionError(message ?? 'Expected defined value', value, 'defined');\n  }\n}\n\n/**\n * Assert that value matches a type guard\n */\nexport function assertType<T>(\n  value: unknown,\n  guard: TypeGuard<T>,\n  message?: string\n): asserts value is T {\n  if (!guard(value)) {\n    throw new AssertionError(message ?? 'Type assertion failed', value);\n  }\n}\n\n/**\n * Assert condition is truthy\n */\nexport function assert(condition: unknown, message?: string): asserts condition {\n  if (\n    condition === false ||\n    condition === null ||\n    condition === undefined ||\n    condition === '' ||\n    condition === 0\n  ) {\n    throw new AssertionError(message ?? 'Assertion failed', condition);\n  }\n}\n\n// =============================================================================\n// NARROWING UTILITIES\n// =============================================================================\n\n/**\n * Narrow value to type if guard passes, otherwise return undefined\n */\nexport function narrow<T>(value: unknown, guard: TypeGuard<T>): T | undefined {\n  return guard(value) ? value : undefined;\n}\n\n/**\n * Narrow value to type if guard passes, otherwise return default\n */\nexport function narrowOrDefault<T>(value: unknown, guard: TypeGuard<T>, defaultValue: T): T {\n  return guard(value) ? value : defaultValue;\n}\n\n/**\n * Narrow value with transform\n */\nexport function narrowAndTransform<T, U>(\n  value: unknown,\n  guard: TypeGuard<T>,\n  transform: (value: T) => U\n): U | undefined {\n  return guard(value) ? transform(value) : undefined;\n}\n\n/**\n * Create a safe accessor for object properties\n */\nexport function safeGet<T>(obj: unknown, key: string, guard: TypeGuard<T>): T | undefined {\n  if (!isObject(obj)) return undefined;\n  const value = obj[key];\n  return guard(value) ? value : undefined;\n}\n\n/**\n * Create a deep safe accessor\n */\nexport function safeGetPath<T>(obj: unknown, path: string[], guard: TypeGuard<T>): T | undefined {\n  let current: unknown = obj;\n\n  for (const key of path) {\n    if (!isObject(current)) return undefined;\n    current = current[key];\n  }\n\n  return guard(current) ? current : undefined;\n}\n\n// =============================================================================\n// RUNTIME CHECK UTILITIES\n// =============================================================================\n\n/**\n * Check value and return result object\n */\nexport function check<T>(value: unknown, guard: TypeGuard<T>): CheckResult<T> {\n  if (guard(value)) {\n    return { success: true, value };\n  }\n  return { success: false, value: undefined, error: 'Type check failed' };\n}\n\n/**\n * Check value with custom error message\n */\nexport function checkWithError<T>(\n  value: unknown,\n  guard: TypeGuard<T>,\n  errorMessage: string\n): CheckResult<T> {\n  if (guard(value)) {\n    return { success: true, value };\n  }\n  return { success: false, value: undefined, error: errorMessage };\n}\n\n/**\n * Chain multiple checks\n */\nexport function checkAll<T extends Record<string, [unknown, TypeGuard<unknown>]>>(\n  checks: T\n): {\n  success: boolean;\n  values: { [K in keyof T]: T[K][1] extends TypeGuard<infer U> ? U | undefined : never };\n  errors: string[];\n} {\n  const values: Record<string, unknown> = {};\n  const errors: string[] = [];\n\n  for (const [key, [value, guard]] of Object.entries(checks)) {\n    if (guard(value)) {\n      values[key] = value;\n    } else {\n      errors.push(`${key}: Type check failed`);\n    }\n  }\n\n  return {\n    success: errors.length === 0,\n    values: values as {\n      [K in keyof T]: T[K][1] extends TypeGuard<infer U> ? U | undefined : never;\n    },\n    errors,\n  };\n}\n\n// =============================================================================\n// COMPOSABLE GUARD FACTORY\n// =============================================================================\n\n/**\n * Create a composable type guard\n */\nexport function createGuard<T>(checker: (value: unknown) => boolean): TypeGuard<T> {\n  return checker as TypeGuard<T>;\n}\n\n/**\n * Create a refinement guard\n */\nexport function refine<T, U extends T>(\n  guard: TypeGuard<T>,\n  refinement: (value: T) => value is U\n): TypeGuard<U> {\n  return (value: unknown): value is U => guard(value) && refinement(value);\n}\n\n/**\n * Create an optional guard\n */\nexport function optional<T>(guard: TypeGuard<T>): TypeGuard<T | undefined> {\n  return (value: unknown): value is T | undefined => value === undefined || guard(value);\n}\n\n/**\n * Create a nullable guard\n */\nexport function nullable<T>(guard: TypeGuard<T>): TypeGuard<T | null> {\n  return (value: unknown): value is T | null => value === null || guard(value);\n}\n\n/**\n * Create a record guard\n */\nexport function record<T>(valueGuard: TypeGuard<T>): TypeGuard<Record<string, T>> {\n  return (value: unknown): value is Record<string, T> => {\n    if (!isObject(value)) return false;\n    return Object.values(value).every(valueGuard);\n  };\n}\n\n/**\n * Create a tuple guard\n */\nexport function tuple<T extends TypeGuard<unknown>[]>(\n  ...guards: T\n): TypeGuard<{ [K in keyof T]: T[K] extends TypeGuard<infer U> ? U : never }> {\n  return (\n    value: unknown\n  ): value is { [K in keyof T]: T[K] extends TypeGuard<infer U> ? U : never } => {\n    if (!isArray(value)) return false;\n    if (value.length !== guards.length) return false;\n    return guards.every((guard, index) => guard(value[index]));\n  };\n}\n\n// =============================================================================\n// NAMESPACE EXPORTS (is, assert)\n// =============================================================================\n\n/**\n * Type guard namespace\n */\nexport const is = {\n  // Primitives\n  string: isString,\n  number: isNumber,\n  boolean: isBoolean,\n  bigint: isBigInt,\n  symbol: isSymbol,\n  undefined: isUndefined,\n  null: isNull,\n  nullish: isNullish,\n  defined: isDefined,\n  function: isFunction,\n\n  // Objects\n  object: isObject,\n  plainObject: isPlainObject,\n  array: isArray,\n  arrayOf: isArrayOf,\n  date: isDate,\n  regExp: isRegExp,\n  map: isMap,\n  set: isSet,\n  promise: isPromise,\n  error: isError,\n\n  // Number refinements\n  integer: isInteger,\n  positive: isPositive,\n  negative: isNegative,\n  nonNegative: isNonNegative,\n  finite: isFinite,\n  inRange: isInRange,\n\n  // String refinements\n  nonEmptyString: isNonEmptyString,\n  stringMatching: isStringMatching,\n  email: isEmail,\n  url: isURL,\n  uuid: isUUID,\n  isoDateString: isISODateString,\n  jsonString: isJSONString,\n\n  // Object shape\n  hasKey,\n  hasKeys,\n  hasKeyOfType,\n  shapeOf: isShapeOf,\n\n  // Union and literal\n  oneOf: isOneOf,\n  literal: isLiteral,\n  union: isUnion,\n  intersection: isIntersection,\n} as const;\n\n/**\n * Assertion namespace\n */\nexport const assertIs = {\n  string: assertString,\n  number: assertNumber,\n  boolean: assertBoolean,\n  object: assertObject,\n  array: assertArray,\n  defined: assertDefined,\n  type: assertType,\n  that: assert,\n} as const;\n"],"names":["isString","value","isNumber","isBoolean","isBigInt","isSymbol","isUndefined","isNull","isNullish","isDefined","isFunction","isObject","isPlainObject","prototype","isArray","isArrayOf","guard","isDate","isRegExp","isMap","isSet","isPromise","isError","isInteger","isPositive","isNegative","isNonNegative","isFinite","isInRange","min","max","isNonEmptyString","isStringMatching","pattern","isEmail","isURL","isUUID","isISODateString","date","isJSONString","hasKey","key","hasKeys","keys","hasKeyOfType","isShapeOf","shape","isOneOf","values","isLiteral","literal","isUnion","guards","isIntersection","AssertionError","message","received","expected","assertString","assertNumber","assertBoolean","assertObject","assertArray","assertDefined","assertType","assert","condition","narrow","narrowOrDefault","defaultValue","safeGet","obj","safeGetPath","path","current","is","assertIs"],"mappings":"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"}