@nicolastoulemont/std 0.8.2 → 0.9.0

package/dist/adt-CPG_sa8q.mjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"adt-CPG_sa8q.mjs","names":["match","validateSchemaSync","variant","union","variant","unionImpl","variantImpl","matchImpl"],"sources":["../src/adt/adt.match.ts","../src/shared/is-plain-object.ts","../src/adt/adt.utils.ts","../src/adt/adt.codec.ts","../src/adt/adt.variant.ts","../src/adt/adt.union.ts","../src/adt/adt.ts"],"sourcesContent":["/**\n * Handler functions for each variant in a discriminated union.\n * Each key maps to a function that receives the variant value and returns TResult.\n *\n * @template T - The discriminated union type (must have readonly _tag)\n * @template TResult - The return type of all handlers\n */\ntype AdtMatchHandlers<T extends { readonly _tag: string }, TResult> = {\n  [K in T[\"_tag\"]]: (value: Extract<T, { readonly _tag: K }>) => TResult\n}\n\n/**\n * Exhaustive pattern matching for discriminated unions.\n *\n * TypeScript will error if any variant is missing from handlers,\n * ensuring exhaustive handling of all cases.\n *\n * @template T - The discriminated union type (must have readonly _tag)\n * @template TResult - The return type of all handlers\n * @template Handlers - The handler object type (inferred)\n * @param value - A discriminated union value with _tag\n * @param handlers - An object with a handler function for each variant\n * @returns The result of calling the matching handler\n *\n * @see {@link union} for creating discriminated unions\n * @see {@link variant} for creating individual variant types\n *\n * @example\n * ```ts\n * import { Adt } from \"@nicolastoulemont/std\"\n * import { z } from \"zod\"\n *\n * // Adt accepts any Standard Schema-compatible schema, such as zod, valibot, or arktype.\n * const Circle = Adt.variant(\"Circle\", z.object({ radius: z.number() }))\n * const Square = Adt.variant(\"Square\", z.object({ size: z.number() }))\n * const Shape = Adt.union(\"Shape\", { Circle, Square })\n * type Shape = Adt.Infer<typeof Shape>\n *\n * function describeShape(shape: Shape): string {\n *   return Adt.match(shape, {\n *     Circle: (c) => `Circle with radius ${c.radius}`,\n *     Square: (s) => `Square with size ${s.size}`,\n *   })\n * }\n * ```\n */\nexport function match<\n  T extends { readonly _tag: string },\n  TResult,\n  Handlers extends AdtMatchHandlers<T, TResult> = AdtMatchHandlers<T, TResult>,\n>(value: T, handlers: Handlers): TResult {\n  const tag = value._tag as keyof Handlers\n  const handler = handlers[tag]\n  // oxlint-disable-next-line no-explicit-any, no-unsafe-argument, no-unsafe-type-assertion -- Required for variant dispatch\n  return handler(value as any)\n}\n","/**\n * Check if a value is a plain object.\n * A plain object is an object created with `{}`, `Object.create(null)`, or `new Object()`.\n * Arrays, functions, dates, maps, etc. are not considered plain objects.\n */\nexport function isPlainObject(value: unknown): value is Record<PropertyKey, unknown> {\n  if (value === null || typeof value !== \"object\") {\n    return false\n  }\n\n  return Object.getPrototypeOf(value) === null || Object.getPrototypeOf(value) === Object.prototype\n}\n","import { validateSync as validateSchemaSync } from \"../schema/schema.shared\"\nimport { isPlainObject } from \"../shared/is-plain-object\"\nimport type { AdtVariant } from \"./adt.types\"\nimport type { StandardSchemaV1 } from \"@standard-schema/spec\"\n\n/**\n * Check if a value is an AdtVariant created by variant().\n * AdtVariants are callable functions with static properties.\n */\nexport function isVariant(value: unknown): value is AdtVariant {\n  return typeof value === \"function\" && \"_variant\" in value && value[\"_variant\"] === true\n}\n\n/**\n * Validate data using a Standard Schema, enforcing sync-only validation.\n * Throws if the schema returns a Promise.\n */\nexport function validateSync<T>(schema: StandardSchemaV1<unknown, T>, data: unknown, _tag: string) {\n  return validateSchemaSync(schema, data, `ADT variant \"${_tag}\"`)\n}\n\n/**\n * Create a type guard function for a specific _tag.\n */\nexport function createIsGuard<Tag extends string, T>(\n  _tag: Tag,\n): (value: unknown) => value is T & { readonly _tag: Tag } {\n  return (value: unknown): value is T & { readonly _tag: Tag } => {\n    return isPlainObject(value) && \"_tag\" in value && value[\"_tag\"] === _tag\n  }\n}\n\n/**\n * Create a type guard function for multiple _tags (AdtUnion root guard).\n */\nexport function createIsAnyGuard<T>(_tags: readonly string[]): (value: unknown) => value is T {\n  const _tagSet = new Set(_tags)\n  return (value: unknown): value is T => {\n    return isPlainObject(value) && \"_tag\" in value && typeof value[\"_tag\"] === \"string\" && _tagSet.has(value[\"_tag\"])\n  }\n}\n","import { ok, err } from \"../result/result\"\nimport type { Result } from \"../result/result.types\"\nimport type { ValidationError } from \"../schema/schema.types\"\nimport type { Discriminator } from \"../shared/discriminator.types\"\nimport type {\n  AdtCodecConstraint,\n  AdtCodecDef,\n  AdtCodecError,\n  AdtInferInput,\n  AdtInferOutput,\n  ToMethods,\n  FromMethods,\n} from \"./adt.types\"\nimport { validateSync } from \"./adt.utils\"\nimport type { StandardSchemaV1 } from \"@standard-schema/spec\"\n\n/**\n * Create a AdtCodecError with consistent structure.\n */\nfunction createCodecError(\n  kind: AdtCodecError[\"kind\"],\n  message: string,\n  cause?: unknown,\n  validationIssues?: ValidationError[\"issues\"],\n): AdtCodecError {\n  if (cause !== undefined && validationIssues !== undefined) {\n    return { kind, message, cause, validationIssues }\n  }\n  if (cause !== undefined) {\n    return { kind, message, cause }\n  }\n  if (validationIssues !== undefined) {\n    return { kind, message, validationIssues }\n  }\n  return { kind, message }\n}\n\n/**\n * Built-in JSON codec that works with any schema.\n * Encodes to JSON string and decodes with JSON.parse.\n */\nfunction createJsonCodec<Tag extends string, S extends StandardSchemaV1>(\n  _tag: Tag,\n): AdtCodecDef<AdtInferOutput<S> & Discriminator<Tag>, string, AdtInferInput<S>> {\n  return {\n    to: (value) => {\n      // JSON.stringify can throw for circular references, BigInt, etc.\n      // We let it throw and catch it in the wrapper\n      return JSON.stringify(value)\n    },\n    /* oxlint-disable no-unsafe-assignment, no-unsafe-type-assertion, no-unsafe-return -- Required for JSON parsing which returns unknown types */\n    from: (input: string) => {\n      try {\n        const parsed = JSON.parse(input)\n        // Return parsed object without _tag - it will be added during validation\n        if (typeof parsed === \"object\" && parsed !== null && \"_tag\" in parsed) {\n          const { _tag: _, ...rest } = parsed\n          return rest as AdtInferInput<S>\n        }\n        return parsed\n      } catch {\n        return null\n      }\n    },\n    /* oxlint-enable no-unsafe-assignment, no-unsafe-type-assertion, no-unsafe-return */\n  }\n}\n\n/**\n * Create the \"to\" methods object with JSON codec and custom codecs.\n * All methods return Result<T, AdtCodecError> for consistent error handling.\n */\nexport function createToMethods<\n  Tag extends string,\n  S extends StandardSchemaV1,\n  Codecs extends AdtCodecConstraint<Tag, S> | undefined = undefined,\n>(_tag: Tag, schema: S, customCodecs?: Codecs): ToMethods<S, Codecs> {\n  type Output = AdtInferOutput<S> & Discriminator<Tag>\n\n  const jsonCodec = createJsonCodec<Tag, S>(_tag)\n\n  // eslint-disable-next-line @typescript-eslint/no-explicit-any\n  const to: Record<string, (value: AdtInferInput<S>) => Result<any, AdtCodecError>> = {\n    json: (value: AdtInferInput<S>): Result<string, AdtCodecError> => {\n      // First, create a validated variant to ensure the encoded payload is well-typed.\n      // oxlint-disable-next-line no-unsafe-type-assertion -- Required for spreading generic input into object\n      const taggedInput = { ...(value as object), _tag }\n      const result = validateSync(schema, taggedInput, _tag)\n\n      if (result._tag === \"Err\") {\n        return err(\n          createCodecError(\n            \"ValidationError\",\n            `Cannot encode invalid data: ${result.error.issues.map((i) => i.message).join(\", \")}`,\n            undefined,\n            result.error.issues,\n          ),\n        )\n      }\n\n      try {\n        // oxlint-disable-next-line no-unsafe-type-assertion -- Required for validated value cast\n        return ok(jsonCodec.to(result.value as Output))\n      } catch (e) {\n        return err(\n          createCodecError(\"EncodingError\", `JSON encoding failed: ${e instanceof Error ? e.message : String(e)}`, e),\n        )\n      }\n    },\n  }\n\n  // Add custom codecs\n  if (customCodecs) {\n    // eslint-disable-next-line @typescript-eslint/no-explicit-any\n    for (const [name, codec] of Object.entries(customCodecs) as Array<[string, AdtCodecDef<Output, any, any>]>) {\n      // eslint-disable-next-line @typescript-eslint/no-explicit-any\n      to[name] = (value: AdtInferInput<S>): Result<any, AdtCodecError> => {\n        // Validate input first\n        // oxlint-disable-next-line no-unsafe-type-assertion -- Required for spreading generic input\n        const taggedInput = { ...(value as object), _tag }\n        const result = validateSync(schema, taggedInput, _tag)\n\n        if (result._tag === \"Err\") {\n          return err(\n            createCodecError(\n              \"ValidationError\",\n              `Cannot encode invalid data: ${result.error.issues.map((i) => i.message).join(\", \")}`,\n              undefined,\n              result.error.issues,\n            ),\n          )\n        }\n\n        try {\n          // oxlint-disable-next-line no-unsafe-type-assertion -- Required for validated value cast\n          return ok(codec.to(result.value as Output))\n        } catch (e) {\n          return err(\n            createCodecError(\n              \"EncodingError\",\n              `Encoding with codec '${name}' failed: ${e instanceof Error ? e.message : String(e)}`,\n              e,\n            ),\n          )\n        }\n      }\n    }\n  }\n\n  // oxlint-disable-next-line no-unsafe-type-assertion -- Required for generic return type\n  return to as ToMethods<S, Codecs>\n}\n\n/**\n * Create the \"from\" methods object with JSON codec and custom codecs.\n * All methods return Result<T, AdtCodecError> for consistent error handling.\n */\nexport function createFromMethods<\n  Tag extends string,\n  S extends StandardSchemaV1,\n  Codecs extends AdtCodecConstraint<Tag, S> | undefined = undefined,\n>(_tag: Tag, schema: S, customCodecs?: Codecs): FromMethods<Tag, S, Codecs> {\n  type Output = AdtInferOutput<S> & Discriminator<Tag>\n\n  const jsonCodec = createJsonCodec<Tag, S>(_tag)\n\n  // eslint-disable-next-line @typescript-eslint/no-explicit-any\n  const from: Record<string, (input: any) => Result<Output, AdtCodecError>> = {\n    json: (input: string): Result<Output, AdtCodecError> => {\n      // Decode\n      const decoded = jsonCodec.from(input)\n      if (decoded === null) {\n        return err(createCodecError(\"DecodingError\", \"Invalid JSON format\"))\n      }\n\n      // Validate through schema\n      // oxlint-disable-next-line no-unsafe-type-assertion -- Required for spreading decoded value\n      const taggedInput = { ...(decoded as object), _tag }\n      const result = validateSync(schema, taggedInput, _tag)\n\n      if (result._tag === \"Err\") {\n        return err(\n          createCodecError(\"ValidationError\", \"Decoded data failed schema validation\", undefined, result.error.issues),\n        )\n      }\n\n      // Ensure _tag in output\n      // oxlint-disable-next-line no-unsafe-type-assertion -- Required for output construction\n      const output = { ...(result.value as object), _tag } as Output\n      return ok(output)\n    },\n  }\n\n  // Add custom codecs\n  if (customCodecs) {\n    // eslint-disable-next-line @typescript-eslint/no-explicit-any\n    for (const [name, codec] of Object.entries(customCodecs) as Array<[string, AdtCodecDef<Output, any, any>]>) {\n      from[name] = (input: unknown): Result<Output, AdtCodecError> => {\n        // Decode\n        let decoded: unknown\n        try {\n          decoded = codec.from(input)\n        } catch (e) {\n          return err(createCodecError(\"DecodingError\", `Decoding with codec '${name}' threw an error`, e))\n        }\n\n        if (decoded === null) {\n          return err(createCodecError(\"DecodingError\", `Codec '${name}' failed to decode input`))\n        }\n\n        // Validate through schema\n        // oxlint-disable-next-line no-unsafe-type-assertion -- Required for spreading decoded value\n        const taggedInput = { ...(decoded as object), _tag }\n        const result = validateSync(schema, taggedInput, _tag)\n\n        if (result._tag === \"Err\") {\n          return err(\n            createCodecError(\n              \"ValidationError\",\n              \"Decoded data failed schema validation\",\n              undefined,\n              result.error.issues,\n            ),\n          )\n        }\n\n        // Ensure _tag in output\n        // oxlint-disable-next-line no-unsafe-type-assertion -- Required for output construction\n        const output = { ...(result.value as object), _tag } as Output\n        return ok(output)\n      }\n    }\n  }\n\n  // oxlint-disable-next-line no-unsafe-type-assertion -- Required for generic return type\n  return from as FromMethods<Tag, S, Codecs>\n}\n","import { createEqualsMethod, createHashMethod } from \"../equality/equality\"\nimport { ok, err } from \"../result/result\"\nimport type { Result } from \"../result/result.types\"\nimport type { ValidationError } from \"../schema/schema.types\"\nimport type { Discriminator } from \"../shared/discriminator.types\"\nimport { createToMethods, createFromMethods } from \"./adt.codec\"\nimport type { AdtCodecConstraint, AdtInferInput, AdtInferOutput, AdtVariant } from \"./adt.types\"\nimport { createIsGuard, validateSync } from \"./adt.utils\"\nimport type { StandardSchemaV1 } from \"@standard-schema/spec\"\n\n/**\n * Create a standalone tagged variant from a Standard Schema with optional codecs.\n *\n * Variants can be used independently or composed into an AdtUnion via union().\n * All defaults should be defined at the schema level (e.g., Zod's .default()).\n *\n * @template Tag - The string literal type for the _tag discriminator\n * @template S - The Standard Schema type for validation\n * @template Codecs - Optional codec definitions for custom serialization formats\n * @param _tag - The _tag discriminator value\n * @param schema - A Standard Schema compliant validator\n * @param codecs - Optional codec definitions for custom serialization formats\n * @returns A callable AdtVariant with is(), to, and from methods\n *\n * @see {@link union} for composing variants into discriminated unions\n * @see {@link tagged} for unvalidated tagged value constructors\n *\n * @example\n * ```ts\n * const CircleSchema = z.object({\n *   radius: z.number().positive(),\n *   color: z.string().default('blue')\n * })\n *\n * // Basic variant with JSON codec (always included)\n * const Circle = variant('Circle', CircleSchema)\n *\n * const result = Circle({ radius: 10 })\n * // { _tag: \"Ok\", value: { _tag: \"Circle\", radius: 10, color: \"blue\" } }\n *\n * Circle.is(someValue) // type guard\n *\n * const json = Circle.to.json({ radius: 10 }) // JSON string\n * const result2 = Circle.from.json(json) // Result<Circle, AdtCodecError>\n *\n * // Variant with custom codec\n * const Circle2 = variant('Circle', CircleSchema, {\n *   graphic: {\n *     to: (circle) => `(${circle.radius})`,\n *     from: (input: string) => {\n *       const match = input.match(/^\\((\\d+)\\)$/)\n *       return match ? { radius: parseInt(match[1]!) } : null\n *     }\n *   }\n * })\n *\n * const graphic = Circle2.to.graphic({ radius: 10 }) // \"(10)\"\n * const result3 = Circle2.from.graphic(\"(10)\") // Result<Circle, AdtCodecError>\n * ```\n */\n// Overload: with codecs\nexport function variant<Tag extends string, S extends StandardSchemaV1, Codecs extends AdtCodecConstraint<Tag, S>>(\n  _tag: Tag,\n  schema: S,\n  codecs: Codecs,\n): AdtVariant<Tag, S, Codecs>\n\n// Overload: without codecs\nexport function variant<Tag extends string, S extends StandardSchemaV1>(_tag: Tag, schema: S): AdtVariant<Tag, S>\n\n// Implementation\nexport function variant<\n  Tag extends string,\n  S extends StandardSchemaV1,\n  Codecs extends AdtCodecConstraint<Tag, S> | undefined,\n>(_tag: Tag, schema: S, codecs?: Codecs): AdtVariant<Tag, S, Codecs> {\n  type Output = AdtInferOutput<S> & Discriminator<Tag>\n\n  const isGuard = createIsGuard<Tag, Output>(_tag)\n  const to = createToMethods(_tag, schema, codecs)\n  const from = createFromMethods(_tag, schema, codecs)\n  const equals = createEqualsMethod<Tag, AdtInferOutput<S>>(_tag)\n  const hash = createHashMethod<Tag, AdtInferOutput<S>>(_tag)\n\n  // Constructor function\n  const constructor = (input: AdtInferInput<S>): Result<Output, ValidationError> => {\n    // Add _tag to the input before validation\n    // oxlint-disable-next-line no-unsafe-type-assertion -- Required for spreading generic input\n    const taggedInput = { ...(input as object), _tag }\n\n    // Validate using the schema\n    const result = validateSync(schema, taggedInput, _tag)\n\n    if (result._tag === \"Err\") {\n      return err(result.error)\n    }\n\n    // Ensure _tag is in the output (schema might strip unknown keys)\n    // oxlint-disable-next-line no-unsafe-type-assertion -- Required for output construction\n    const output = { ...(result.value as object), _tag } as Output\n    return ok(output)\n  }\n\n  // Attach static properties to constructor function\n  constructor._variant = true as const\n  constructor._tag = _tag\n  constructor.schema = schema\n  if (codecs) {\n    // oxlint-disable-next-line no-unsafe-type-assertion -- Conditional assignment of codecs\n    ;(constructor as { codecs?: Codecs }).codecs = codecs\n  }\n  constructor.is = isGuard\n  constructor.to = to\n  constructor.from = from\n  constructor.equals = equals\n  constructor.hash = hash\n\n  return constructor as AdtVariant<Tag, S, Codecs>\n}\n","import { createADTEqualsMethod, createADTHashMethod } from \"../equality/equality\"\nimport type { AdtUnion, AdtVariantDef, AdtVariant } from \"./adt.types\"\nimport { createIsAnyGuard, isVariant } from \"./adt.utils\"\nimport { variant } from \"./adt.variant\"\nimport type { StandardSchemaV1 } from \"@standard-schema/spec\"\n\n/**\n * Compose records or schemas into a discriminated union (AdtUnion).\n *\n * Accepts either:\n * - Pre-built AdtVariants from variant() (codecs are preserved)\n * - Raw Standard Schema validators (will be wrapped internally)\n *\n * When using pre-built records, the object key overrides the original _tag.\n *\n * @template R - Record of variant names to AdtVariants or StandardSchema validators\n * @param name - The name of this AdtUnion (for identification)\n * @param records - An object mapping _tag names to AdtVariants or schemas\n * @returns An AdtUnion object with accessors for each variant\n *\n * @see {@link variant} for creating individual variant types\n * @see {@link match} for exhaustive pattern matching on AdtUnion values\n *\n * @example\n * ```ts\n * // From pre-built variants\n * const Circle = variant('Circle', CircleSchema)\n * const Square = variant('Square', SquareSchema)\n * const Shape = union('Shape', { Circle, Square })\n *\n * // From raw schemas (JSON codec is automatically included)\n * const Shape = union('Shape', {\n *   Circle: CircleSchema,\n *   Square: SquareSchema\n * })\n *\n * // JSON codec works on all variants\n * Shape.Circle.to.json({ radius: 10 })\n * Shape.Circle.from.json(jsonString)\n *\n * // Mixed\n * const Shape = union('Shape', {\n *   Circle,              // Pre-built variant\n *   Square: SquareSchema // Raw schema\n * })\n *\n * // Usage\n * Shape.Circle({ radius: 10 })\n * Shape.is(someValue)        // type guard for any variant\n * Shape.Circle.is(someValue) // type guard for Circle\n * ```\n */\nexport function union<R extends Record<string, AdtVariantDef>>(name: string, records: R): AdtUnion<R> {\n  const tags = Object.keys(records)\n  const variants: Record<string, AdtVariant> = {}\n\n  for (const [_tag, def] of Object.entries(records)) {\n    if (isVariant(def)) {\n      // Pre-built AdtVariant - key overrides original _tag\n      if (def._tag === _tag) {\n        // _tag matches key, use as-is (preserves codecs)\n        variants[_tag] = def\n        // oxlint-disable-next-line strict-boolean-expressions -- codecs can be undefined\n      } else if (def.codecs) {\n        // _tag differs from key - create new variant with key as _tag\n        // Preserve codecs\n        variants[_tag] = variant(_tag, def.schema, def.codecs)\n      } else {\n        // _tag differs from key and no codecs\n        variants[_tag] = variant(_tag, def.schema)\n      }\n    } else {\n      // Raw schema - wrap in variant\n      // Note: Even without custom codecs, this still gets JSON codec!\n      // oxlint-disable-next-line no-unsafe-type-assertion -- def is a StandardSchemaV1 in this branch\n      variants[_tag] = variant(_tag, def as StandardSchemaV1)\n    }\n  }\n\n  // Create the root type guard for any variant\n  const isAnyVariant = createIsAnyGuard(tags)\n  const equals = createADTEqualsMethod(tags)\n  const hash = createADTHashMethod(tags)\n\n  // oxlint-disable-next-line no-unsafe-type-assertion -- Required for generic AdtUnion return type\n  return {\n    _name: name,\n    is: isAnyVariant,\n    equals,\n    hash,\n    ...variants,\n  } as AdtUnion<R>\n}\n","/**\n * Tagged union builders and match helpers.\n *\n * **Mental model**\n * - `Adt` helps build discriminated unions with runtime validation.\n * - Use `union`, `variant`, and `match` to model algebraic data types.\n *\n * **Common tasks**\n * - Define variants with `Adt.variant`.\n * - Combine variants with `Adt.union`.\n * - Pattern-match with `Adt.match`.\n *\n * **Gotchas**\n * - `Adt` codec/type helpers are mostly type-level.\n * - Prefer namespace imports from `@nicolastoulemont/std`.\n *\n * **Quickstart**\n *\n * @example\n * ```ts\n * import { Adt } from \"@nicolastoulemont/std\"\n * import { z } from \"zod\"\n *\n * // Adt accepts any Standard Schema-compatible schema, such as zod, valibot, or arktype.\n * const CircleSchema = z.object({ radius: z.number() })\n *\n * const Shape = Adt.union(\"Shape\", { Circle: CircleSchema })\n * const result = Shape.Circle({ radius: 2 })\n * // => { _tag: \"Ok\", value: { _tag: \"Circle\", radius: 2 } }\n * ```\n *\n * @module\n */\nimport { match as matchImpl } from \"./adt.match\"\nimport type {\n  AdtInfer as AdtInferType,\n  AdtVariantNames as AdtVariantNamesType,\n  AdtVariantOf as AdtVariantOfType,\n} from \"./adt.types\"\nimport { union as unionImpl } from \"./adt.union\"\nimport { variant as variantImpl } from \"./adt.variant\"\n\n/**\n * Re-exported ADT inferred union helper.\n *\n * @example\n * ```ts\n * import { Adt } from \"@nicolastoulemont/std\"\n * import { z } from \"zod\"\n *\n * // Adt accepts any Standard Schema-compatible schema, such as zod, valibot, or arktype.\n * const Shape = Adt.union(\"Shape\", {\n *   Circle: z.object({ radius: z.number() }),\n * })\n * type Shape = Adt.Infer<typeof Shape>\n * ```\n */\nexport type Infer<T> = AdtInferType<T>\n\n/**\n * Re-exported union variant name helper.\n *\n * @example\n * ```ts\n * import { Adt } from \"@nicolastoulemont/std\"\n * import { z } from \"zod\"\n *\n * // Adt accepts any Standard Schema-compatible schema, such as zod, valibot, or arktype.\n * const Shape = Adt.union(\"Shape\", {\n *   Circle: z.object({ radius: z.number() }),\n * })\n * type Names = Adt.VariantNames<typeof Shape>\n * ```\n */\nexport type VariantNames<T> = AdtVariantNamesType<T>\n\n/**\n * Re-exported helper to extract a specific variant from an ADT.\n *\n * @example\n * ```ts\n * import { Adt } from \"@nicolastoulemont/std\"\n * import { z } from \"zod\"\n *\n * // Adt accepts any Standard Schema-compatible schema, such as zod, valibot, or arktype.\n * const Shape = Adt.union(\"Shape\", {\n *   Circle: z.object({ radius: z.number() }),\n * })\n * type Circle = Adt.VariantOf<typeof Shape, \"Circle\">\n * ```\n */\nexport type VariantOf<T, K extends string> = AdtVariantOfType<T, K>\n\n/**\n * Build an ADT union from named variants.\n *\n * @example\n * ```ts\n * import { Adt } from \"@nicolastoulemont/std\"\n * import { z } from \"zod\"\n *\n * // Adt accepts any Standard Schema-compatible schema, such as zod, valibot, or arktype.\n * const CircleSchema = z.object({ radius: z.number() })\n *\n * const Shape = Adt.union(\"Shape\", { Circle: CircleSchema })\n * const result = Shape.Circle({ radius: 2 })\n * // => { _tag: \"Ok\", value: { _tag: \"Circle\", radius: 2 } }\n * ```\n */\nexport const union = unionImpl\n\n/**\n * Define one ADT variant with schema-backed validation.\n *\n * @example\n * ```ts\n * import { Adt } from \"@nicolastoulemont/std\"\n * import { z } from \"zod\"\n *\n * // Adt accepts any Standard Schema-compatible schema, such as zod, valibot, or arktype.\n * const CircleSchema = z.object({ radius: z.number() })\n *\n * const Circle = Adt.variant(\"Circle\", CircleSchema)\n * const result = Circle({ radius: 2 })\n * // => { _tag: \"Ok\", value: { _tag: \"Circle\", radius: 2 } }\n * ```\n */\nexport const variant = variantImpl\n\n/**\n * Match over ADT variants by discriminator tag.\n *\n * @example\n * ```ts\n * import { Adt } from \"@nicolastoulemont/std\"\n *\n * const label = Adt.match({ _tag: \"Circle\", radius: 2 } as const, {\n *   Circle: (circle) => `r=${circle.radius}` ,\n * })\n * // => \"r=2\"\n * ```\n */\nexport const match = matchImpl\n"],"mappings":"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"}

package/dist/data-BHYPdqWZ.mjs

@@ -1,2 +0,0 @@
-import{t as e}from"./chunk-oQKkju2G.mjs";import{a as t,i as n,o as r,r as i}from"./equality-BX6BUidG.mjs";import{t as a}from"./fx.types-DyQVgTS8.mjs";function o(e){let n=[...e];Object.defineProperty(n,`equals`,{value:e=>t(n,e),enumerable:!1,writable:!1,configurable:!1}),Object.defineProperty(n,`hash`,{value:()=>r(n),enumerable:!1,writable:!1,configurable:!1});let i=n.map.bind(n);Object.defineProperty(n,`map`,{value:e=>o(i(e)),enumerable:!1,writable:!1,configurable:!1});let a=n.filter.bind(n);Object.defineProperty(n,`filter`,{value:e=>o(a(e)),enumerable:!1,writable:!1,configurable:!1});let s=n.slice.bind(n);Object.defineProperty(n,`slice`,{value:(e,t)=>o(s(e,t)),enumerable:!1,writable:!1,configurable:!1});let c=n.concat.bind(n);return Object.defineProperty(n,`concat`,{value:(...e)=>o(c(...e)),enumerable:!1,writable:!1,configurable:!1}),Object.freeze(n)}function s(e){let n={...e};return Object.defineProperty(n,`equals`,{value:e=>t(n,e),enumerable:!1,writable:!1,configurable:!1}),Object.defineProperty(n,`hash`,{value:()=>r(n),enumerable:!1,writable:!1,configurable:!1}),Object.freeze(n)}function c(e){let t=t=>Object.freeze({...t,_tag:e});return t.is=t=>typeof t==`object`&&!!t&&`_tag`in t&&t._tag===e,t.equals=i(e),t.hash=n(e),t._tag=e,t}function l(e){return class extends Error{static _tag=e;_tag=e;[a]={_A:()=>void 0,_E:()=>this,_R:()=>void 0};constructor(...t){super(e),this.name=e;let n=t[0];n&&Object.assign(this,n),Object.setPrototypeOf(this,new.target.prototype)}*[Symbol.iterator](){throw yield this,Error(`Unreachable: Fx.gen should short-circuit on error`)}}}function u(...e){let n=[...e];return Object.defineProperty(n,`equals`,{value:e=>t(n,e),enumerable:!1,writable:!1,configurable:!1}),Object.defineProperty(n,`hash`,{value:()=>r(n),enumerable:!1,writable:!1,configurable:!1}),Object.freeze(n)}var d=e({TaggedError:()=>p,array:()=>g,struct:()=>m,tagged:()=>f,tuple:()=>h});const f=c,p=l,m=s,h=u,g=o;export{d as n,p as t};
-//# sourceMappingURL=data-BHYPdqWZ.mjs.map

package/dist/data-BHYPdqWZ.mjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"data-BHYPdqWZ.mjs","names":["array","struct","tagged","TaggedError","tuple","taggedImpl","TaggedErrorImpl","structImpl","tupleImpl","arrayImpl"],"sources":["../src/data/data.array.ts","../src/data/data.struct.ts","../src/data/data.tagged.ts","../src/data/data.tagged-error.ts","../src/data/data.tuple.ts","../src/data/data.ts"],"sourcesContent":["import { deepEquals, deepHash } from \"../equality/equality\"\nimport type { ArrayValue } from \"./data.types\"\n\n/**\n * Create an array with structural equality.\n *\n * The returned array is frozen (immutable) and has non-enumerable\n * equals() and hash() methods for structural comparison.\n *\n * The map() and filter() methods are overridden to return ArrayValue,\n * enabling method chaining with preserved equality semantics.\n *\n * @template T - The element type of the array\n * @param items - The array elements\n * @returns A frozen array with equals(), hash(), map(), and filter()\n *\n * @see {@link tuple} for fixed-length typed tuples\n * @see {@link struct} for object value types\n *\n * @example\n * ```ts\n * const arr1 = array([1, 2, 3])\n * const arr2 = array([1, 2, 3])\n *\n * arr1.equals(arr2) // true\n * arr1.hash() // number\n *\n * // Chainable operations return ArrayValue\n * arr1.map(x => x * 2) // ArrayValue<number>\n * arr1.filter(x => x > 1) // ArrayValue<number>\n *\n * // Chained equality check\n * arr1.map(x => x * 2).equals(array([2, 4, 6])) // true\n *\n * // Array is frozen\n * arr1[0] = 5 // TypeError\n * arr1.push(4) // TypeError\n * ```\n */\nexport function array<T>(items: readonly T[]): ArrayValue<T> {\n  const value = [...items]\n\n  // Add equals method (non-enumerable)\n  Object.defineProperty(value, \"equals\", {\n    value: (other: readonly T[]) => deepEquals(value, other),\n    enumerable: false,\n    writable: false,\n    configurable: false,\n  })\n\n  // Add hash method (non-enumerable)\n  Object.defineProperty(value, \"hash\", {\n    value: () => deepHash(value),\n    enumerable: false,\n    writable: false,\n    configurable: false,\n  })\n\n  // Override map to return ArrayValue\n  const originalMap = value.map.bind(value)\n  Object.defineProperty(value, \"map\", {\n    value: <U>(fn: (item: T, index: number, arr: readonly T[]) => U): ArrayValue<U> => {\n      return array(originalMap(fn))\n    },\n    enumerable: false,\n    writable: false,\n    configurable: false,\n  })\n\n  // Override filter to return ArrayValue\n  const originalFilter = value.filter.bind(value)\n  Object.defineProperty(value, \"filter\", {\n    value: (fn: (item: T, index: number, arr: readonly T[]) => boolean): ArrayValue<T> => {\n      return array(originalFilter(fn))\n    },\n    enumerable: false,\n    writable: false,\n    configurable: false,\n  })\n\n  // Override slice to return ArrayValue\n  const originalSlice = value.slice.bind(value)\n  Object.defineProperty(value, \"slice\", {\n    value: (start?: number, end?: number): ArrayValue<T> => {\n      return array(originalSlice(start, end))\n    },\n    enumerable: false,\n    writable: false,\n    configurable: false,\n  })\n\n  // Override concat to return ArrayValue\n  const originalConcat = value.concat.bind(value)\n  Object.defineProperty(value, \"concat\", {\n    value: (...args: readonly (T | readonly T[])[]): ArrayValue<T> => {\n      // oxlint-disable-next-line no-unsafe-type-assertion -- Required for concat argument spread\n      return array(originalConcat(...(args as T[][])))\n    },\n    enumerable: false,\n    writable: false,\n    configurable: false,\n  })\n\n  // oxlint-disable-next-line no-unsafe-type-assertion -- Required for generic array return type\n  return Object.freeze(value) as unknown as ArrayValue<T>\n}\n","import { deepEquals, deepHash } from \"../equality/equality\"\nimport type { StructValue } from \"./data.types\"\n\n/**\n * Create a frozen value object with structural equality.\n *\n * Unlike tagged(), struct() does not add a _tag discriminator.\n * Use this for simple value objects that don't need discrimination.\n *\n * The returned object is frozen (immutable) and has non-enumerable\n * equals() and hash() methods for structural comparison.\n *\n * @template T - The object shape type\n * @param input - The object to wrap\n * @returns A frozen object with equals() and hash() methods\n *\n * @see {@link tagged} for discriminated value objects with _tag\n * @see {@link array} for array value types\n *\n * @example\n * ```ts\n * const point = struct({ x: 10, y: 20 })\n * const point2 = struct({ x: 10, y: 20 })\n *\n * point.equals(point2) // true\n * point.hash() // number\n *\n * // Object is frozen\n * point.x = 5 // TypeError\n *\n * // equals/hash are non-enumerable\n * Object.keys(point) // [\"x\", \"y\"]\n * ```\n */\nexport function struct<T extends Record<string, unknown>>(input: T): StructValue<T> {\n  const value = { ...input }\n\n  // Add equals method (non-enumerable)\n  Object.defineProperty(value, \"equals\", {\n    value: (other: T) => deepEquals(value, other),\n    enumerable: false,\n    writable: false,\n    configurable: false,\n  })\n\n  // Add hash method (non-enumerable)\n  Object.defineProperty(value, \"hash\", {\n    value: () => deepHash(value),\n    enumerable: false,\n    writable: false,\n    configurable: false,\n  })\n\n  // oxlint-disable-next-line no-unsafe-type-assertion -- Required for generic struct return type\n  return Object.freeze(value) as StructValue<T>\n}\n","import { createEqualsMethod, createHashMethod } from \"../equality/equality\"\nimport type { Discriminator } from \"../shared/discriminator.types\"\nimport type { TaggedConstructor, TaggedValue } from \"./data.types\"\n\n/**\n * Create a tagged value constructor without schema validation.\n *\n * Unlike variant(), this creates values directly without validation.\n * Values are frozen and have structural equality via equals() and hash() methods.\n *\n * @template T - The data shape type (excluding _tag)\n * @param tag - The _tag discriminator value\n * @returns A constructor function with is(), equals(), and hash() methods\n *\n * @see {@link variant} for validated variant with schema support\n * @see {@link struct} for untagged value objects\n *\n * @example\n * ```ts\n * const Person = tagged<{ name: string; age: number }>(\"Person\")\n *\n * const alice = Person({ name: \"Alice\", age: 30 })\n * // => { _tag: \"Person\", name: \"Alice\", age: 30 }\n *\n * Person.equals(alice, Person({ name: \"Alice\", age: 30 })) // true\n * Person.is(alice) // true\n *\n * // Type guard usage\n * if (Person.is(unknownValue)) {\n *   console.log(unknownValue.name) // TypeScript knows it's a Person\n * }\n *\n * // Values are frozen (immutable)\n * alice.name = \"Bob\" // TypeError\n * ```\n */\nexport function tagged<T extends Record<string, unknown>>(tag: string): TaggedConstructor<typeof tag, T> {\n  type Output = TaggedValue<typeof tag, T>\n\n  // Constructor function\n  const constructor = (input: T): Output => {\n    return Object.freeze({ ...input, _tag: tag }) as Output\n  }\n\n  // Type guard\n  constructor.is = (value: unknown): value is Output => {\n    return (\n      typeof value === \"object\" &&\n      value !== null &&\n      \"_tag\" in value &&\n      // oxlint-disable-next-line no-unsafe-type-assertion -- Already checked with 'in' operator\n      (value as Discriminator)._tag === tag\n    )\n  }\n\n  // Equality (static method on constructor)\n  constructor.equals = createEqualsMethod<typeof tag, T>(tag)\n\n  // Hashing (static method on constructor)\n  constructor.hash = createHashMethod<typeof tag, T>(tag)\n\n  // Store tag for reflection\n  constructor._tag = tag\n\n  return constructor as TaggedConstructor<typeof tag, T>\n}\n","import { FxTypeId } from \"../fx/fx.types\"\nimport type { TaggedErrorFactory } from \"./data.tagged-error.types\"\n\n/* oxlint-disable no-unsafe-type-assertion -- Tagged error factories intentionally cast to preserve ergonomic constructor signatures and Fx marker channels. */\n\n/**\n * Create a class-based tagged error type (Effect-style syntax).\n * Returns a class that can be extended to create custom error types.\n * Errors are native Error objects with proper stack traces and instanceof support.\n * Implements Yieldable protocol so errors can be directly yielded in Fx.gen computations.\n *\n * @template Tag - The error tag (discriminator string)\n * @param tag - The error tag\n * @returns A class that can be extended with custom data\n *\n * @example\n * ```ts\n * // Error with data\n * class NotFoundError extends TaggedError(\"NotFoundError\")<{ id: string }> {}\n * const err = new NotFoundError({ id: \"123\" })\n * err.id // \"123\"\n * err._tag // \"NotFoundError\"\n * err.stack // Error stack trace\n *\n * // Error without data\n * class UnauthorizedError extends TaggedError(\"UnauthorizedError\") {}\n * const err2 = new UnauthorizedError()\n *\n * // Direct yielding in Fx.gen computation\n * const program = Fx.gen(function* () {\n *   yield* new NotFoundError({ id: \"123\" })  // Short-circuits with error\n * })\n *\n * // instanceof checks work\n * if (err instanceof NotFoundError) {\n *   console.log(err.id)\n * }\n * ```\n */\nexport function TaggedError<Tag extends string>(tag: Tag): TaggedErrorFactory<Tag> {\n  return class TaggedErrorImpl<Data extends object = object> extends Error {\n    static readonly _tag: Tag = tag\n    readonly _tag: Tag = tag\n\n    readonly [FxTypeId] = {\n      _A: () => undefined as never,\n      _E: () => this as TaggedErrorImpl<Data>,\n      _R: () => undefined as never,\n    }\n\n    constructor(...args: keyof Data extends never ? [] : [data: Data]) {\n      super(tag)\n      this.name = tag\n      const data = args[0]\n      if (data) Object.assign(this, data)\n      Object.setPrototypeOf(this, new.target.prototype)\n    }\n\n    *[Symbol.iterator](): Generator<this, never, unknown> {\n      yield this\n      throw new Error(\"Unreachable: Fx.gen should short-circuit on error\")\n    }\n  } as unknown as TaggedErrorFactory<Tag>\n}\n\n/* oxlint-enable no-unsafe-type-assertion */\n","import { deepEquals, deepHash } from \"../equality/equality\"\nimport type { TupleValue } from \"./data.types\"\n\n/**\n * Create a tuple with structural equality.\n *\n * The returned tuple is frozen (immutable) and has non-enumerable\n * equals() and hash() methods for structural comparison.\n *\n * @template T - The tuple type as a readonly array of element types\n * @param args - The tuple elements\n * @returns A frozen tuple-like array with equals() and hash() methods\n *\n * @see {@link array} for variable-length arrays with equality\n * @see {@link struct} for object value types\n *\n * @example\n * ```ts\n * const t1 = tuple(1, \"hello\", true)\n * const t2 = tuple(1, \"hello\", true)\n *\n * t1.equals(t2) // true\n * t1.hash() // number\n *\n * // Access elements (typed)\n * t1[0] // number\n * t1[1] // string\n * t1[2] // boolean\n *\n * // Tuple is frozen\n * t1[0] = 5 // TypeError\n * ```\n */\nexport function tuple<T extends readonly unknown[]>(...args: T): TupleValue<T> {\n  const value = [...args]\n\n  // Add equals method (non-enumerable)\n  Object.defineProperty(value, \"equals\", {\n    value: (other: readonly unknown[]) => deepEquals(value, other),\n    enumerable: false,\n    writable: false,\n    configurable: false,\n  })\n\n  // Add hash method (non-enumerable)\n  Object.defineProperty(value, \"hash\", {\n    value: () => deepHash(value),\n    enumerable: false,\n    writable: false,\n    configurable: false,\n  })\n\n  // oxlint-disable-next-line no-unsafe-type-assertion -- Required for generic tuple return type\n  return Object.freeze(value) as unknown as TupleValue<T>\n}\n","/**\n * Structural data constructors for tagged objects, tuples, arrays, and records.\n *\n * **Mental model**\n * - `Data` helpers create immutable-friendly values with structural equality semantics.\n * - Use `tagged` and `TaggedError` to model domain objects and errors.\n *\n * **Common tasks**\n * - Build tagged records via `Data.tagged`.\n * - Define typed tagged errors with `Data.TaggedError`.\n * - Create structural containers with `Data.struct`, `Data.tuple`, and `Data.array`.\n *\n * **Gotchas**\n * - These constructors are value-level utilities, not validation schemas.\n * - Prefer explicit tagged names for debugging and pattern matching.\n *\n * **Quickstart**\n *\n * @example\n * ```ts\n * import { Data } from \"@nicolastoulemont/std\"\n *\n * const User = Data.tagged<{ id: string }>(\"User\")\n * const user = User({ id: \"u1\" })\n * // => { _tag: \"User\", id: \"u1\" }\n * ```\n *\n * @module\n */\nimport { array as arrayImpl } from \"./data.array\"\nimport { struct as structImpl } from \"./data.struct\"\nimport { tagged as taggedImpl } from \"./data.tagged\"\nimport { TaggedError as TaggedErrorImpl } from \"./data.tagged-error\"\nexport type { TaggedErrorClass, TaggedErrorCore, TaggedErrorFactory, TaggedErrorInstance } from \"./data.tagged-error.types\"\nimport { tuple as tupleImpl } from \"./data.tuple\"\n\n/**\n * Construct tagged data objects.\n *\n * @example\n * ```ts\n * import { Data } from \"@nicolastoulemont/std\"\n *\n * const User = Data.tagged<{ id: string }>(\"User\")\n * const user = User({ id: \"u1\" })\n * // => { _tag: \"User\", id: \"u1\" }\n * ```\n */\nexport const tagged = taggedImpl\n\n/**\n * Construct tagged error classes.\n *\n * @example\n * ```ts\n * import { Data } from \"@nicolastoulemont/std\"\n *\n * class NotFoundError extends Data.TaggedError(\"NotFoundError\")<{ id: string }> {}\n * const error = new NotFoundError({ id: \"u1\" })\n * // => { _tag: \"NotFoundError\", id: \"u1\" }\n * ```\n */\nexport const TaggedError = TaggedErrorImpl\n\n/**\n * Construct immutable-like structs with stable structural behavior.\n *\n * @example\n * ```ts\n * import { Data } from \"@nicolastoulemont/std\"\n *\n * const point = Data.struct({ x: 1, y: 2 })\n * const same = point.equals({ x: 1, y: 2 })\n * // => true\n * ```\n */\nexport const struct = structImpl\n\n/**\n * Construct immutable-like tuples with stable structural behavior.\n *\n * @example\n * ```ts\n * import { Data } from \"@nicolastoulemont/std\"\n *\n * const pair = Data.tuple(\"left\", 1)\n * const first = pair[0]\n * // => \"left\"\n * ```\n */\nexport const tuple = tupleImpl\n\n/**\n * Construct immutable-like arrays with stable structural behavior.\n *\n * @example\n * ```ts\n * import { Data } from \"@nicolastoulemont/std\"\n *\n * const ids = Data.array([\"a\", \"b\"])\n * const upper = ids.map((id) => id.toUpperCase())\n * // => [\"A\", \"B\"]\n * ```\n */\nexport const array = arrayImpl\n"],"mappings":"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"}

package/dist/equality-BX6BUidG.mjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"equality-BX6BUidG.mjs","names":["result"],"sources":["../src/equality/equality.ts"],"sourcesContent":["import type { Discriminator } from \"../shared/discriminator.types\"\n\n// ============================================================================\n// Hashing (FNV-1a inspired algorithm)\n// ============================================================================\n\nconst FNV_OFFSET = 2166136261\nconst FNV_PRIME = 16777619\n// \"cycl\"\nconst CYCLE_MARKER = 0x6379636c\n\ntype HashState = {\n  readonly hashes: WeakMap<object, number>\n  readonly inProgress: WeakSet<object>\n  readonly objectIds: WeakMap<object, number>\n  nextObjectId: number\n}\n\nconst createHashState = (): HashState => ({\n  hashes: new WeakMap<object, number>(),\n  inProgress: new WeakSet<object>(),\n  objectIds: new WeakMap<object, number>(),\n  nextObjectId: 1,\n})\n\nconst getObjectId = (state: HashState, value: object): number => {\n  const existing = state.objectIds.get(value)\n  if (existing !== undefined) return existing\n  const id = state.nextObjectId\n  state.objectIds.set(value, id)\n  state.nextObjectId++\n  return id\n}\n\nconst deepHashInternal = (value: unknown, state: HashState): number => {\n  let hash = FNV_OFFSET\n\n  // \"null\" as hex\n  if (value === null) return hash ^ 0x6e756c6c\n  // \"unde\" as hex\n  if (value === undefined) return hash ^ 0x756e6465\n\n  /* oxlint-disable unicorn/prefer-math-trunc, no-case-declarations, switch-exhaustiveness-check -- Bitwise ops are intentional for FNV-1a hash: | 0 truncates to signed 32-bit, >>> 0 converts to unsigned 32-bit (Math.trunc cannot do this). Default case handles function, symbol, bigint. */\n  switch (typeof value) {\n    case \"boolean\":\n      return hash ^ (value ? 1 : 0)\n\n    case \"number\": {\n      // Handle special cases: \"NaN\" as hex\n      if (Number.isNaN(value)) return hash ^ 0x4e614e\n      if (!Number.isFinite(value)) return hash ^ (value > 0 ? 0x496e66 : 0x2d496e66)\n      // Mix the number bits into hash\n      return hash ^ (value | 0) ^ ((value * 1000000) | 0)\n    }\n\n    case \"string\":\n      for (let i = 0; i < value.length; i++) {\n        hash ^= value.codePointAt(i)!\n        hash = Math.imul(hash, FNV_PRIME)\n      }\n      // Convert to unsigned 32-bit\n      return hash >>> 0\n\n    case \"object\": {\n      const objectValue = value\n\n      const existingHash = state.hashes.get(objectValue)\n      if (existingHash !== undefined) return existingHash\n\n      if (state.inProgress.has(objectValue)) {\n        return (hash ^ CYCLE_MARKER ^ getObjectId(state, objectValue)) >>> 0\n      }\n\n      if (value instanceof Date) {\n        return hash ^ deepHashInternal(value.getTime(), state)\n      }\n\n      state.inProgress.add(objectValue)\n      getObjectId(state, objectValue)\n\n      if (Array.isArray(value)) {\n        // \"[]\" as hex\n        hash ^= 0x5b5d\n        for (let i = 0; i < value.length; i++) {\n          hash ^= deepHashInternal(value[i], state)\n          hash = Math.imul(hash, FNV_PRIME)\n        }\n        const result = hash >>> 0\n        state.inProgress.delete(objectValue)\n        state.hashes.set(objectValue, result)\n        return result\n      }\n\n      // Plain object: \"{}\" as hex\n      hash ^= 0x7b7d\n      // oxlint-disable-next-line no-unsafe-type-assertion -- Required for object iteration\n      const obj = value as Record<string, unknown>\n      // Sort keys for consistency\n      const keys = Object.keys(obj).toSorted()\n      for (const key of keys) {\n        hash ^= deepHashInternal(key, state)\n        hash = Math.imul(hash, FNV_PRIME)\n        hash ^= deepHashInternal(obj[key], state)\n        hash = Math.imul(hash, FNV_PRIME)\n      }\n      const result = hash >>> 0\n      state.inProgress.delete(objectValue)\n      state.hashes.set(objectValue, result)\n      return result\n    }\n\n    default:\n      // Handles: function, symbol, bigint\n      return hash\n  }\n  /* oxlint-enable unicorn/prefer-math-trunc, no-case-declarations */\n}\n\n/**\n * Compute a 32-bit hash code for any value using an FNV-1a inspired algorithm.\n *\n * Handles: primitives, null, undefined, Date, arrays, plain objects, and cyclic structures.\n * Object keys are sorted for deterministic hashing regardless of insertion order.\n *\n * @param value - The value to hash (any type)\n * @returns A 32-bit unsigned integer hash code\n *\n * @example\n * ```ts\n * deepHash({ a: 1, b: 2 }) // deterministic number\n * deepHash({ b: 2, a: 1 }) // same number (keys sorted)\n * deepHash([1, 2, 3]) === deepHash([1, 2, 3]) // true\n * ```\n */\nexport function deepHash(value: unknown): number {\n  return deepHashInternal(value, createHashState())\n}\n\ntype EqualsState = WeakMap<object, WeakSet<object>>\n\nconst markComparedPair = (state: EqualsState, a: object, b: object): boolean => {\n  const compared = state.get(a)\n  if (compared?.has(b) === true) return true\n  if (compared === undefined) {\n    state.set(a, new WeakSet<object>([b]))\n    return false\n  }\n  compared.add(b)\n  return false\n}\n\nconst deepEqualsInternal = (a: unknown, b: unknown, state: EqualsState): boolean => {\n  // Same reference or both null/undefined\n  if (a === b) return true\n\n  // Different types\n  if (typeof a !== typeof b) return false\n\n  // Handle null\n  if (a === null || b === null) return false\n\n  // Primitives (already checked === above)\n  if (typeof a !== \"object\") return false\n  if (typeof b !== \"object\") return false\n\n  const aObjRef = a\n  const bObjRef = b\n\n  if (markComparedPair(state, aObjRef, bObjRef)) return true\n\n  // Date comparison\n  if (a instanceof Date && b instanceof Date) {\n    return a.getTime() === b.getTime()\n  }\n\n  // Array comparison\n  if (Array.isArray(a) && Array.isArray(b)) {\n    if (a.length !== b.length) return false\n    return a.every((item, index) => deepEqualsInternal(item, b[index], state))\n  }\n\n  // Plain object comparison\n  if (Array.isArray(a) !== Array.isArray(b)) return false\n\n  // oxlint-disable-next-line no-unsafe-type-assertion -- Required for object comparison\n  const aObj = a as Record<string, unknown>\n  // oxlint-disable-next-line no-unsafe-type-assertion -- Required for object comparison\n  const bObj = b as Record<string, unknown>\n\n  const aKeys = Object.keys(aObj)\n  const bKeys = Object.keys(bObj)\n\n  if (aKeys.length !== bKeys.length) return false\n\n  return aKeys.every((key) => deepEqualsInternal(aObj[key], bObj[key], state))\n}\n\n// ============================================================================\n// Equality\n// ============================================================================\n\n/**\n * Deep structural equality comparison for two values.\n *\n * Compares by value rather than reference. Handles:\n * - Primitives (===)\n * - null and undefined\n * - Date objects (by timestamp)\n * - Arrays (element-wise, same length required)\n * - Plain objects (key-value pairs, same keys required)\n * - Cyclic/self-referential object graphs\n *\n * @param a - First value to compare\n * @param b - Second value to compare\n * @returns true if values are structurally equal\n *\n * @example\n * ```ts\n * deepEquals({ x: 1 }, { x: 1 }) // true\n * deepEquals([1, 2], [1, 2]) // true\n * deepEquals(new Date(0), new Date(0)) // true\n * deepEquals({ a: 1 }, { a: 1, b: 2 }) // false (different keys)\n * ```\n */\nexport function deepEquals(a: unknown, b: unknown): boolean {\n  return deepEqualsInternal(a, b, new WeakMap<object, WeakSet<object>>())\n}\n\n// ============================================================================\n// Factory Functions\n// ============================================================================\n\n/**\n * Create an equals method for a specific record type.\n *\n * Returns a function that compares two values of the same record type.\n * Returns false if either value doesn't have the expected _tag.\n *\n * @template Tag - The discriminator string literal type\n * @template T - The record's data type (excluding _tag)\n * @param _tag - The expected _tag discriminator value\n * @returns A binary equality function for the record type\n *\n * @example\n * ```ts\n * const equalsPoint = createEqualsMethod<'Point', { x: number; y: number }>('Point')\n * equalsPoint(\n *   { _tag: 'Point', x: 1, y: 2 },\n *   { _tag: 'Point', x: 1, y: 2 }\n * ) // true\n * ```\n */\nexport function createEqualsMethod<Tag extends string, T>(\n  _tag: Tag,\n): (a: T & Discriminator<Tag>, b: T & Discriminator<Tag>) => boolean {\n  return (a, b) => {\n    if (a === b) return true\n    if (a._tag !== _tag || b._tag !== _tag) return false\n    return deepEquals(a, b)\n  }\n}\n\n/**\n * Create a hash method for a specific record type.\n *\n * Returns a function that computes a hash code for values of the record type.\n * Returns 0 if the value doesn't have the expected _tag.\n *\n * @template Tag - The discriminator string literal type\n * @template T - The record's data type (excluding _tag)\n * @param _tag - The expected _tag discriminator value\n * @returns A unary hash function for the record type\n *\n * @example\n * ```ts\n * const hashPoint = createHashMethod<'Point', { x: number; y: number }>('Point')\n * hashPoint({ _tag: 'Point', x: 1, y: 2 }) // number\n * ```\n */\nexport function createHashMethod<Tag extends string, T>(_tag: Tag): (value: T & Discriminator<Tag>) => number {\n  return (value) => {\n    if (value._tag !== _tag) return 0\n    return deepHash(value)\n  }\n}\n\n/**\n * Create an equals method for an ADT (any variant).\n *\n * Returns a function that compares two ADT values for structural equality.\n * Values must have the same _tag and be a known variant.\n *\n * @template T - The ADT type (union of all variants with _tag)\n * @param tags - Array of valid _tag values for this ADT\n * @returns A binary equality function for any variant of the ADT\n *\n * @example\n * ```ts\n * const equalsShape = createADTEqualsMethod<Circle | Square>(['Circle', 'Square'])\n * equalsShape(circle1, circle2) // true if structurally equal\n * equalsShape(circle, square) // false (different _tag)\n * ```\n */\nexport function createADTEqualsMethod<T extends { readonly _tag: string }>(tags: string[]): (a: T, b: T) => boolean {\n  return (a, b) => {\n    if (a === b) return true\n    if (a._tag !== b._tag) return false\n    if (!tags.includes(a._tag)) return false\n    return deepEquals(a, b)\n  }\n}\n\n/**\n * Create a hash method for an ADT (any variant).\n *\n * Returns a function that computes a hash code for any variant of the ADT.\n * Returns 0 if the value's _tag is not a known variant.\n *\n * @template T - The ADT type (union of all variants with _tag)\n * @param tags - Array of valid _tag values for this ADT\n * @returns A unary hash function for any variant of the ADT\n *\n * @example\n * ```ts\n * const hashShape = createADTHashMethod<Circle | Square>(['Circle', 'Square'])\n * hashShape(circle) // number\n * hashShape(square) // number\n * ```\n */\nexport function createADTHashMethod<T extends { readonly _tag: string }>(tags: string[]): (value: T) => number {\n  return (value) => {\n    if (!tags.includes(value._tag)) return 0\n    return deepHash(value)\n  }\n}\n"],"mappings":"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"}

package/dist/index-B2Z7-XGR.d.mts.map

@@ -1 +0,0 @@
-{"version":3,"file":"index-B2Z7-XGR.d.mts","names":[],"sources":["../src/data/data.types.ts","../src/data/data.array.ts","../src/data/data.struct.ts","../src/data/data.tagged.ts","../src/data/data.tagged-error.types.ts","../src/data/data.tagged-error.ts","../src/data/data.tuple.ts","../src/data/data.ts"],"sourcesContent":[],"mappings":";;;;;;;;AAUY,KAAA,WAAW,CAAA,YAAA,MAAA,EAAA,CAAA,CAAA,GAA0B,QAA1B,CAAmC,CAAnC,CAAA,GAAwC,aAAxC,CAAsD,GAAtD,CAAA;;;;;;AAOX,KAAA,iBAAiB,CAAA,YAAA,MAAA,EAAA,CAAA,CAAA,GAAA;EAEZ;EAEP,SAAA,IAAA,EAFO,GAEP;EAAgB;EAAK,CAAA,KAAA,EAArB,CAAqB,CAAA,EAAjB,WAAiB,CAAL,GAAK,EAAA,CAAA,CAAA;EAAjB;EAE6B,EAAA,CAAA,KAAA,EAAA,OAAA,CAAA,EAAA,KAAA,IAAZ,WAAY,CAAA,GAAA,EAAK,CAAL,CAAA;EAAK;EAAjB,MAAA,CAAA,CAAA,EAEnB,WAFmB,CAEP,GAFO,EAEF,CAFE,CAAA,EAAA,CAAA,EAEK,WAFL,CAEiB,GAFjB,EAEsB,CAFtB,CAAA,CAAA,EAAA,OAAA;EAEP;EAAK,IAAA,CAAA,KAAA,EAEf,WAFe,CAEH,GAFG,EAEE,CAFF,CAAA,CAAA,EAAA,MAAA;CAAjB;;;;;AAEmB,KAWnB,WAXmB,CAAA,UAWG,MAXH,CAAA,MAAA,EAAA,OAAA,CAAA,CAAA,GAW8B,QAX9B,CAWuC,CAXvC,CAAA,GAAA;EAAjB;EAAW,MAAA,CAAA,KAAA,EAaT,CAbS,CAAA,EAAA,OAAA;EAWb;EAAsB,IAAA,EAAA,EAAA,MAAA;CAAoC;;;;AAetE;AACuB,KADX,UACW,CAAA,UAAA,SAAA,OAAA,EAAA,CAAA,GAAA,iBAAI,MAAJ,CAAI,GAAA,CAAA,CAAE,CAAF,CAAA,EAAE,GAAA;EAEV,SAAA,MAAA,EAAA,CAAA,CAAA,QAAA,CAAA;EAMqB;EAAjB,MAAA,CAAA,KAAA,EAAA,SAAA,OAAA,EAAA,CAAA,EAAA,OAAA;EAAgB;EAa3B,IAAA,EAAA,EAAA,MAAU;EACM,CAAA,MAAA,CAAA,QAAA,GAAA,EAdL,gBAcK,CAdY,CAcZ,CAAA,MAAA,CAAA,CAAA;CAGD;;;;;;;AAIuC,KARtD,UAQsD,CAAA,KAAA,CAAA,GAAA;EAE9C,UAAA,KAAA,EAAA,MAAA,CAAA,EATQ,CASR;EAAkC,SAAA,MAAA,EAAA,MAAA;EAA6B;EAAX,MAAA,CAAA,KAAA,EANxD,UAMwD,CAN7C,CAM6C,CAAA,GAAA,SAN/B,CAM+B,EAAA,CAAA,EAAA,OAAA;EAEhC;EAAjB,IAAA,EAAA,EAAA,MAAA;EAEF;EAAkC,GAAA,CAAA,CAAA,CAAA,CAAA,EAAA,EAAA,CAAA,IAAA,EANnC,CAMmC,EAAA,KAAA,EAAA,MAAA,EAAA,KAAA,EAAA,SAND,CAMC,EAAA,EAAA,GANO,CAMP,CAAA,EANW,UAMX,CANsB,CAMtB,CAAA;EACrC;EAAkC,MAAA,CAAA,EAAA,EAAA,CAAA,IAAA,EALhC,CAKgC,EAAA,KAAA,EAAA,MAAA,EAAA,KAAA,EAAA,SALE,CAKF,EAAA,EAAA,GAAA,OAAA,CAAA,EALoB,UAKpB,CAL+B,CAK/B,CAAA;EAAkB,CAAA,MAAA,CAAA,QAAA,GAAA,EAH/C,gBAG+C,CAH9B,CAG8B,CAAA;EAC/C,OAAA,CAAA,EAAA,EAAA,CAAA,IAAA,EAFF,CAEE,EAAA,KAAA,EAAA,MAAA,EAAA,KAAA,EAAA,SAFgC,CAEhC,EAAA,EAAA,GAAA,IAAA,CAAA,EAAA,IAAA;EAAkC,IAAA,CAAA,EAAA,EAAA,CAAA,IAAA,EADvC,CACuC,EAAA,KAAA,EAAA,MAAA,EAAA,KAAA,EAAA,SADL,CACK,EAAA,EAAA,GAAA,OAAA,CAAA,EADa,CACb,GAAA,SAAA;EACvC,SAAA,CAAA,EAAA,EAAA,CAAA,IAAA,EADK,CACL,EAAA,KAAA,EAAA,MAAA,EAAA,KAAA,EAAA,SADuC,CACvC,EAAA,EAAA,GAAA,OAAA,CAAA,EAAA,MAAA;EAAkC,IAAA,CAAA,EAAA,EAAA,CAAA,IAAA,EAAlC,CAAkC,EAAA,KAAA,EAAA,MAAA,EAAA,KAAA,EAAA,SAAA,CAAA,EAAA,EAAA,GAAA,OAAA,CAAA,EAAA,OAAA;EACjC,KAAA,CAAA,EAAA,EAAA,CAAA,IAAA,EAAA,CAAA,EAAA,KAAA,EAAA,MAAA,EAAA,KAAA,EAAA,SAAkC,CAAlC,EAAA,EAAA,GAAA,OAAA,CAAA,EAAA,OAAA;EAAkC,QAAA,CAAA,IAAA,EACpC,CADoC,CAAA,EAAA,OAAA;EACpC,OAAA,CAAA,IAAA,EACD,CADC,CAAA,EAAA,MAAA;EACD,MAAA,CAAA,CAAA,CAAA,CAAA,EAAA,EAAA,CAAA,GAAA,EACM,CADN,EAAA,IAAA,EACe,CADf,EAAA,KAAA,EAAA,MAAA,EAAA,KAAA,EAAA,SACiD,CADjD,EAAA,EAAA,GACyD,CADzD,EAAA,OAAA,EACqE,CADrE,CAAA,EACyE,CADzE;EACM,KAAA,CAAA,KAAA,CAAA,EAAA,MAAA,EAAA,GAAA,CAAA,EAAA,MAAA,CAAA,EACiB,UADjB,CAC4B,CAD5B,CAAA;EAAS,MAAA,CAAA,GAAA,KAAA,EAAA,SAAA,CAEF,CAFE,GAAA,SAEW,CAFX,EAAA,CAAA,EAAA,CAAA,EAEoB,UAFpB,CAE+B,CAF/B,CAAA;EAAkC,IAAA,CAAA,SAAA,CAAA,EAAA,MAAA,CAAA,EAAA,MAAA;CAAQ;;;;;;;AAtFzE;;;;;;AAOA;;;;;;;;;;;;;;;;;;;AAqBA;;;;;;AAeA;AACuB,iBCfP,ODeO,CAAA,CAAA,CAAA,CAAA,KAAA,EAAA,SCfkB,CDelB,EAAA,CAAA,ECfwB,UDexB,CCfmC,CDenC,CAAA;;;;;;;AA5CvB;;;;;;AAOA;;;;;;;;;;;;;;;;;;;AAqBA;;AAAsE,iBEJtD,QFIsD,CAAA,UEJrC,MFIqC,CAAA,MAAA,EAAA,OAAA,CAAA,CAAA,CAAA,KAAA,EEJL,CFIK,CAAA,EEJD,WFIC,CEJW,CFIX,CAAA;;;;;;;AA5BtE;;;;;;AAOA;;;;;;;;;;;;;;;;;;;AAqBA;;;AAA6D,iBGF7C,QHE6C,CAAA,UGF5B,MHE4B,CAAA,MAAA,EAAA,OAAA,CAAA,CAAA,CAAA,GAAA,EAAA,MAAA,CAAA,EGFW,iBHEX,CAAA,OGFoC,GHEpC,EGFyC,CHEzC,CAAA;;;UInC5C,0EACP,OAAO,UAAU,oBAAoB,KAAK;iBACnC;uBACM,UAAU,oBAAoB,KAAK;;AJI1D;;;;;;AAOA;;AAIU,KIJE,mBJIF,CAAA,YAAA,MAAA,EAAA,aAAA,MAAA,GAAA,MAAA,CAAA,GIJ0E,eJI1E,CIJ0F,GJI1F,EIJ+F,IJI/F,CAAA,GIHR,QJGQ,CIHC,IJGD,CAAA;;;;;;;AAIc,KICZ,gBJDY,CAAA,YAAA,MAAA,EAAA,aAAA,MAAA,GAAA,MAAA,CAAA,GAAA;EAAK,KAAA,GAAA,IAAA,EAAA,MIEP,IJFO,SAAA,KAAA,GAAA,EAAA,GAAA,CAAA,IAAA,EIE0B,IJF1B,CAAA,CAAA,EIEkC,mBJFlC,CIEsD,GJFtD,EIE2D,IJF3D,CAAA;EAAjB,SAAA,IAAA,EIGK,GJHL;CAAoC;;;;;;;AAapC,KIDA,kBJCW,CAAA,YAAA,MAAA,CAAA,GID8B,gBJC9B,CID+C,GJC/C,CAAA,GAAA;EAAW,IAAA,CAAA,aAAA,MAAA,GAAA,MAAA,CAAA,CAAA,GAAA,IAAA,EAAA,MICf,IJDe,SAAA,KAAA,GAAA,EAAA,GAAA,CAAA,IAAA,EICkB,IJDlB,CAAA,CAAA,EIE7B,mBJF6B,CIET,GJFS,EIEJ,IJFI,CAAA;CAAoC;;;;;;;AA5BtE;;;;;;AAOA;;;;;;;;;;;;;;;;;;;AAqBA;;;;;AAEiB,iBKDD,aLCC,CAAA,YAAA,MAAA,CAAA,CAAA,GAAA,EKDoC,GLCpC,CAAA,EKD0C,kBLC1C,CKD6D,GLC7D,CAAA;;;;;;;AA9BjB;;;;;;AAOA;;;;;;;;;;;;;;;;;;;AAqBA;AAAkC,iBMLlB,ONKkB,CAAA,UAAA,SAAA,OAAA,EAAA,CAAA,CAAA,GAAA,IAAA,EML2B,CNK3B,CAAA,EML+B,UNK/B,CML0C,CNK1C,CAAA;AAAA;;;;AAelC;;;;;;;;AAsBA;;;AAIgB,cO/BH,MP+BG,EAAA,OO/BG,QP+BH;;;;;;;;;;;;;AAUK,cO3BR,WP2BQ,EAAA,OO3BG,aP2BH;;;;;;;;;;;;;AAOC,cOpBT,MPoBS,EAAA,OOpBH,QPoBG;;;;;;;;;;;;;cONT,cAAK;;;ANnDlB;;;;;;;;ACLA;;AAAiE,cKsEpD,KLtEoD,EAAA,OKsE/C,OLtE+C"}

package/dist/index-B41_sFR6.d.mts.map

@@ -1 +0,0 @@
-{"version":3,"file":"index-B41_sFR6.d.mts","names":[],"sources":["../src/schema/schema.ts"],"sourcesContent":[],"mappings":";;;;;;;;;;;;;;iBA0DgB,gBAAgB,oBAAoB,YAAY,MAAM,OAAO,OAAW,OAAO,IAAI;iBACnF,gBAAgB,0BACtB,YACC,MAAM,OAAO,QAAQ,OAAW,OAAO,IAAI;KAoB1C,QAAA;aACC,yBAAyB,MAAM,WAAW,cAAc,aAAa,OAAQ,MAAM;aACnF,oBAAoB,kBAAkB,MAAM,WAAW,kBAAkB,OAAQ,MAAM;;KAGxF,EAAA;qBACS,aAAa,cAAc,qBAAqB,MAAM,gBAAgB;aAC9E,oCAAoC,aAAa,OAAO;qBAChD,cAAc,qBAAqB,MAAM,eAAe,kBAAkB;aAClF,oBAAoB,iCAAiC,OAAO;;AAhCzE;;;;;;;;;;AACA;;;;;;;AAEsD,iBAsDtC,MAtDsC,CAAA,UAsDrB,UAtDqB,EAAA,aAsDI,KAtDJ,CAsDU,CAtDV,CAAA,CAAA,CAAA,KAAA,EAsDqB,IAtDrB,EAAA,MAAA,EAsDmC,CAtDnC,CAAA,EAAA,KAAA,IAsDgD,MAtDhD,CAsDwD,IAtDxD,EAsD8D,CAtD9D,CAAA;AAAtB,iBAuDhB,MAvDgB,CAAA,UAuDC,UAvDD,CAAA,CAAA,MAAA,EAuDqB,CAvDrB,CAAA,EAAA,CAAA,aAuDuC,KAvDvC,CAuD6C,CAvD7C,CAAA,CAAA,CAAA,KAAA,EAuDwD,IAvDxD,EAAA,GAAA,KAAA,IAuD0E,MAvD1E,CAuDkF,IAvDlF,EAuDwF,CAvDxF,CAAA;;;AAoBhC;;;;;;;;;;AAEiC,iBAsDjB,EAtDiB,CAAA,IAAA,EAAA,YAsDI,IAtDJ,CAAA,CAAA,KAAA,EAsDiB,IAtDjB,EAAA,MAAA,EAsD+B,oBAtD/B,CAsDoD,IAtDpD,EAsD0D,GAtD1D,CAAA,CAAA,EAAA,KAAA,IAsD0E,GAtD1E;AAAwB,iBAuDzC,EAvDyC,CAAA,UAuD5B,UAvD4B,CAAA,CAAA,KAAA,EAAA,OAAA,EAAA,MAAA,EAuDQ,CAvDR,CAAA,EAAA,KAAA,IAuDqB,MAvDrB,CAuD4B,CAvD5B,CAAA;AAAN,iBAwDnC,EAxDmC,CAAA,IAAA,EAAA,YAwDd,IAxDc,CAAA,CAAA,MAAA,EAwDA,oBAxDA,CAwDqB,IAxDrB,EAwD2B,GAxD3B,CAAA,CAAA,EAAA,CAAA,KAAA,EAwD0C,IAxD1C,EAAA,GAAA,KAAA,IAwD4D,GAxD5D;AAAiB,iBAyDpD,EAzDoD,CAAA,UAyDvC,UAzDuC,CAAA,CAAA,MAAA,EAyDnB,CAzDmB,CAAA,EAAA,CAAA,KAAA,EAAA,OAAA,EAAA,GAAA,KAAA,IAyDc,MAzDd,CAyDqB,CAzDrB,CAAA"}

package/dist/index-crtzMG48.d.mts.map

@@ -1 +0,0 @@
-{"version":3,"file":"index-crtzMG48.d.mts","names":[],"sources":["../src/provide/provide.ts"],"sourcesContent":[],"mappings":";;;;;;;;;;;;KAoBK,iBAAiB,UAAU;;;;KAK3B,iBAAiB,UAAU;AAlBsB;AAaZ;AAKA;;;;;;KAUrC,aAMqC,CAAA,EAAA,EAAA,kBAAA,OAAA,EAAA,WAH7B,UAG6B,CAAA,OAAA,EAAA,OAAA,EAAA,OAAA,CAAA,CAAA,GAFtC,SAEsC,SAAA,IAAA,GADtC,EACsC,CAAA,MAAA,CAAA,SAAA,QAAA,GAApC,MAAoC,CAA7B,WAA6B,CAAjB,EAAiB,CAAA,EAAZ,WAAY,CAAA,EAAA,CAAA,GAAM,EAAN,CAAA,GACpC,OADoC,CAC5B,WAD4B,CAChB,EADgB,CAAA,EACX,WADW,CACC,EADD,CAAA,GACO,EADP,CAAA,GAEtC,SAFsC,SAAA,KAAA,GAGpC,OAHoC,CAG5B,WAH4B,CAGhB,EAHgB,CAAA,EAGX,WAHW,CAGC,EAHD,CAAA,GAGO,EAHP,CAAA,GAIpC,UAJoC,CAIzB,WAJyB,CAIb,EAJa,CAAA,EAIR,WAJQ,CAII,EAJJ,CAAA,GAIU,EAJV,CAAA;;;;;;;;;;;;;;;;;;;;;;;;AAiC1C;;;;AACS,iBADO,KACP,CAAA,IAAA,EAAA,EAAA,EAAA,kBAAA,OAAA,CAAA,CAAA,KAAA,EAAA,KAAA,CAAM,IAAN,EAAY,EAAZ,EAAA,KAAA,EAAuB,SAAvB,CAAA,CAAA,EAAA,CAAA,WACM,UADN,CAAA,OAAA,EAAA,OAAA,EACmC,IADnC,CAAA,CAAA,CAAA,EAAA,EAC8C,EAD9C,EAAA,GACqD,aADrD,CACmE,EADnE,EACuE,SADvE,EACkF,EADlF,CAAA;;;;;;;;;AA+LT;;;;;;;;;;;AA8FA;AAC4B,cA/Ff,OA+Fe,EAAA,CAAA,CAAA,CAAA,CAAA,GAAA,EA9FjB,OA8FiB,CA9FT,CA8FS,CAAA,EAAA,GAAA,CAAA,CAAA,EAAA,CAAA,CAAA,CAAA,EAAA,EA7Ff,UA6Fe,CA7FJ,CA6FI,EA7FD,CA6FC,EA7FE,CA6FF,CAAA,EAAA,GA7FO,UA6FP,CA7FkB,CA6FlB,EA7FqB,CA6FrB,CAAA;;;;;;;;;;;;;;;;;;;;;cADf,sBACE,aAAa,UAAU,oBACtB,WAAW,GAAG,GAAG,IAAI,OAAK,WAAW,GAAG,GAAG,QAAQ,GAAG"}

package/dist/provide--yZE8x-n.mjs

@@ -1,2 +0,0 @@
-import{t as e}from"./chunk-oQKkju2G.mjs";import{t}from"./fx.types-DyQVgTS8.mjs";import{i as n}from"./result-D3VY0qBG.mjs";import{n as r,t as i}from"./service-resolution-BefYr4nR.mjs";import{n as a,t as o}from"./fx.runtime-jQxh77s3.mjs";import{t as s}from"./scope-gVt4PESc.mjs";var c=class{cache=new Map;getOrBuild(e,r,a){let o=this.cache.get(e);if(o?.context)return{_tag:`SyncFx`,[t]:{_A:()=>o.context,_E:()=>void 0,_R:()=>void 0},run:()=>n(o.context),*[Symbol.iterator](){return o.context}};if(o?.promise)return{_tag:`AsyncFx`,[t]:{_A:()=>void 0,_E:()=>void 0,_R:()=>void 0},run:async()=>n(await o.promise),async*[Symbol.asyncIterator](){return await o.promise}};this.cache.set(e,{building:!0});let s=e.build(this,r),c=this.cache;if(s._tag===`AsyncFx`){let r=(async()=>{let t=s[Symbol.asyncIterator](),n=await t.next();for(;n.done!==!0;){let e=n.value,r=i(e);if(r===void 0)throw e;let o=a._services.get(r.key);if(o===void 0)throw Error(`Service "${r.key}" not found during layer build`);n=await t.next(o)}let r=n.value;return c.set(e,{context:r}),r})();return this.cache.set(e,{promise:r}),{_tag:`AsyncFx`,[t]:{_A:()=>void 0,_E:()=>void 0,_R:()=>void 0},run:async()=>{try{return n(await r)}catch(e){return{ok:!1,error:e,*[Symbol.iterator](){throw yield e,Error(`Unreachable`)}}}},async*[Symbol.asyncIterator](){try{return await r}catch(e){throw yield e,Error(`Unreachable`,{cause:e})}}}}return{_tag:`SyncFx`,[t]:{_A:()=>void 0,_E:()=>void 0,_R:()=>void 0},run:()=>{let t=s[Symbol.iterator](),r=t.next();for(;r.done!==!0;){let e=r.value,n=i(e);if(n===void 0)return{ok:!1,error:e,*[Symbol.iterator](){throw yield e,Error(`Unreachable`)}};let o=a._services.get(n.key);if(o===void 0)throw Error(`Service "${n.key}" not found during layer build`);r=t.next(o)}let o=r.value;return c.set(e,{context:o}),n(o)},*[Symbol.iterator](){let t=s[Symbol.iterator](),n=t.next();for(;n.done!==!0;){let e=n.value,r=i(e);if(r===void 0)throw yield e,Error(`Unreachable`);let o=a._services.get(r.key);if(o===void 0)throw Error(`Service "${r.key}" not found during layer build`);n=t.next(o)}return c.set(e,{context:n.value}),n.value}}}clear(){this.cache.clear()}get size(){return this.cache.size}},l=e({context:()=>d,layer:()=>u,service:()=>f});function u(e){return i=>{let l=e.build(new c,s())._tag,u=()=>{let t=new c,n=s();return{scope:n,layerBuildFx:e.build(t,n)}};return l===`AsyncFx`||i._tag===`AsyncFx`?{_tag:`AsyncFx`,[t]:{_A:()=>void 0,_E:()=>void 0,_R:()=>void 0},async*[Symbol.asyncIterator](){let{scope:e,layerBuildFx:t}=u();try{let e;if(t._tag===`AsyncFx`){let n=t[Symbol.asyncIterator](),r=await n.next();for(;r.done!==!0;)yield r.value,r=await n.next(void 0);e=r.value}else{let n=t[Symbol.iterator](),r=n.next();for(;r.done!==!0;)yield r.value,r=n.next(void 0);e=r.value}if(i._tag===`AsyncFx`){let t=i[Symbol.asyncIterator](),n=await t.next();for(;n.done!==!0;){let i=n.value,a=r(e,i);if(a!==void 0){n=await t.next(a);continue}let o=yield i;n=await t.next(o)}return n.value}let n=i[Symbol.iterator](),a=n.next();for(;a.done!==!0;){let t=a.value,i=r(e,t);if(i!==void 0){a=n.next(i);continue}let o=yield t;a=n.next(o)}return a.value}finally{let t=e.close(n(void 0));t._tag===`AsyncFx`?await o(t):a(t)}}}:{_tag:`SyncFx`,[t]:{_A:()=>void 0,_E:()=>void 0,_R:()=>void 0},*[Symbol.iterator](){let{scope:e,layerBuildFx:t}=u();if(t._tag===`AsyncFx`)throw Error(`Provide.layer sync execution encountered an async layer build. Ensure async layers are treated as async at composition time.`);try{let e=t[Symbol.iterator](),n=e.next();for(;n.done!==!0;)yield n.value,n=e.next(void 0);let a=n.value,o=i[Symbol.iterator](),s=o.next();for(;s.done!==!0;){let e=s.value,t=r(a,e);if(t!==void 0){s=o.next(t);continue}let n=yield e;s=o.next(n)}return s.value}finally{a(e.close(n(void 0)))}}}}}const d=e=>n=>n._tag===`AsyncFx`?{_tag:`AsyncFx`,[t]:{_A:()=>void 0,_E:()=>void 0,_R:()=>void 0},async*[Symbol.asyncIterator](){let t=n[Symbol.asyncIterator](),r=await t.next();for(;r.done!==!0;){let n=r.value,a=i(n);if(a===void 0){yield n,r=await t.next(void 0);continue}let o=e._services.get(a.key);if(o===void 0)throw Error(`Service "${a.key}" not found`);r=await t.next(o)}return r.value}}:{_tag:`SyncFx`,[t]:{_A:()=>void 0,_E:()=>void 0,_R:()=>void 0},*[Symbol.iterator](){let t=n[Symbol.iterator](),r=t.next();for(;r.done!==!0;){let n=r.value,a=i(n);if(a===void 0){yield n,r=t.next(void 0);continue}let o=e._services.get(a.key);if(o===void 0)throw Error(`Service "${a.key}" not found`);r=t.next(o)}return r.value}},f=(e,n)=>r=>r._tag===`AsyncFx`?{_tag:`AsyncFx`,[t]:{_A:()=>void 0,_E:()=>void 0,_R:()=>void 0},async*[Symbol.asyncIterator](){let t=r[Symbol.asyncIterator](),a=await t.next();for(;a.done!==!0;){let r=a.value;if(i(r)?.key===e.key)a=await t.next(n);else{let e=yield r;a=await t.next(e)}}return a.value}}:{_tag:`SyncFx`,[t]:{_A:()=>void 0,_E:()=>void 0,_R:()=>void 0},*[Symbol.iterator](){let t=r[Symbol.iterator](),a=t.next();for(;a.done!==!0;){let r=a.value;if(i(r)?.key===e.key)a=t.next(n);else{let e=yield r;a=t.next(e)}}return a.value}};export{l as t};
-//# sourceMappingURL=provide--yZE8x-n.mjs.map

package/dist/provide--yZE8x-n.mjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"provide--yZE8x-n.mjs","names":["layer","service","layer","makeScope","fxGen","fxResult","service"],"sources":["../src/provide/memo-map.ts","../src/provide/provide.ts"],"sourcesContent":["import type { Context } from \"../context/context\"\nimport { FxTypeId } from \"../fx/fx.types\"\nimport type { RunnableFx, SyncFx, AsyncFx, FxYield } from \"../fx/fx.types\"\nimport type { Layer } from \"../layer/layer.types\"\nimport { ok } from \"../result/result\"\nimport type { ScopeService } from \"../scope/scope\"\nimport { asServiceRequest } from \"../service/service-resolution\"\n\n/* oxlint-disable no-unsafe-type-assertion, only-throw-error -- MemoMap bridges erased generic Fx channels and re-emits typed domain errors from generator boundaries. */\n\n// ============================================================================\n// MemoMap\n// ============================================================================\n\ntype AnyLayer = Layer<unknown, unknown, unknown>\n\n/**\n * MemoMap caches built layers so each layer is only built once.\n * Multiple dependents share the same service instance.\n *\n * This implements the \"service singleton\" pattern where a service\n * is instantiated once and shared across all consumers.\n *\n * @example\n * ```ts\n * // Database is built once, shared by DocumentService and TeamService\n * const AppLayer = Layer.merge(\n *   ConfigLive,\n *   LoggerLive,\n *   DatabaseLive,       // Built once\n *   DocumentServiceLive, // Uses shared Database\n *   TeamServiceLive,     // Uses same Database instance\n * )\n * ```\n */\nexport class MemoMap {\n  private cache = new Map<\n    AnyLayer,\n    {\n      promise?: Promise<Context<unknown>>\n      context?: Context<unknown>\n      building?: boolean\n    }\n  >()\n\n  /**\n   * Get a cached context or build the layer if not cached.\n   *\n   * @param layer - The layer to get or build\n   * @param scope - The scope for resource management\n   * @param deps - Context containing the layer's dependencies\n   * @returns A RunnableFx producing the layer's context\n   */\n  getOrBuild<ROut, E, RIn>(\n    layer: Layer<ROut, E, RIn>,\n    scope: ScopeService,\n    deps: Context<RIn>,\n  ): RunnableFx<Context<ROut>, E> {\n    const cached = this.cache.get(layer as AnyLayer)\n\n    // Already built - return cached context\n    if (cached?.context) {\n      return {\n        _tag: \"SyncFx\",\n        [FxTypeId]: {\n          _A: () => cached.context as Context<ROut>,\n          _E: () => undefined as unknown as E,\n          _R: () => undefined as never,\n        },\n        run: () => ok(cached.context as Context<ROut>),\n        // oxlint-disable-next-line require-yield\n        *[Symbol.iterator](): Generator<FxYield<E, never>, Context<ROut>, unknown> {\n          return cached.context as Context<ROut>\n        },\n      } as SyncFx<Context<ROut>, E>\n    }\n\n    // Building in progress (async) - wait for it\n    if (cached?.promise) {\n      return {\n        _tag: \"AsyncFx\",\n        [FxTypeId]: {\n          _A: () => undefined as unknown as Context<ROut>,\n          _E: () => undefined as unknown as E,\n          _R: () => undefined as never,\n        },\n        run: async () => {\n          const ctx = await cached.promise!\n          return ok(ctx as Context<ROut>)\n        },\n        // oxlint-disable-next-line require-yield\n        async *[Symbol.asyncIterator](): AsyncGenerator<FxYield<E, never>, Context<ROut>, unknown> {\n          const ctx = await cached.promise!\n          return ctx as Context<ROut>\n        },\n      } as AsyncFx<Context<ROut>, E>\n    }\n\n    // Need to build - mark as building\n    this.cache.set(layer as AnyLayer, { building: true })\n\n    // Build the layer with provided dependencies\n    const buildFx = layer.build(this, scope)\n    const cacheRef = this.cache\n\n    // Determine if async\n    if (buildFx._tag === \"AsyncFx\") {\n      // Create a promise for the build\n      const buildPromise = (async () => {\n        const gen = buildFx[Symbol.asyncIterator]()\n        let result = await gen.next()\n\n        // Resolve service requests from deps\n        while (result.done !== true) {\n          const yielded = result.value\n          const serviceRequest = asServiceRequest(yielded)\n          if (serviceRequest === undefined) {\n            // It's an error - rethrow\n            throw yielded\n          }\n          const service = deps._services.get(serviceRequest.key)\n          if (service === undefined) {\n            throw new Error(`Service \"${serviceRequest.key}\" not found during layer build`)\n          }\n          // oxlint-disable-next-line no-await-in-loop\n          result = await gen.next(service)\n        }\n\n        const ctx = result.value\n        cacheRef.set(layer as AnyLayer, { context: ctx })\n        return ctx\n      })()\n\n      this.cache.set(layer as AnyLayer, { promise: buildPromise })\n\n      return {\n        _tag: \"AsyncFx\",\n        [FxTypeId]: {\n          _A: () => undefined as unknown as Context<ROut>,\n          _E: () => undefined as unknown as E,\n          _R: () => undefined as never,\n        },\n        run: async () => {\n          try {\n            const ctx = await buildPromise\n            return ok(ctx)\n          } catch (e) {\n            return {\n              ok: false,\n              error: e as E,\n              *[Symbol.iterator]() {\n                yield e as E\n                throw new Error(\"Unreachable\")\n              },\n            }\n          }\n        },\n        async *[Symbol.asyncIterator](): AsyncGenerator<FxYield<E, never>, Context<ROut>, unknown> {\n          try {\n            const ctx = await buildPromise\n            return ctx\n          } catch (e) {\n            yield e as E\n            throw new Error(\"Unreachable\", { cause: e })\n          }\n        },\n      } as AsyncFx<Context<ROut>, E>\n    }\n\n    // Sync build\n    return {\n      _tag: \"SyncFx\",\n      [FxTypeId]: {\n        _A: () => undefined as unknown as Context<ROut>,\n        _E: () => undefined as unknown as E,\n        _R: () => undefined as never,\n      },\n      run: () => {\n        const gen = buildFx[Symbol.iterator]()\n        let result = gen.next()\n\n        // Resolve service requests from deps\n        while (result.done !== true) {\n          const yielded = result.value\n          const serviceRequest = asServiceRequest(yielded)\n          if (serviceRequest === undefined) {\n            // It's an error\n            return {\n              ok: false,\n              error: yielded as E,\n              *[Symbol.iterator]() {\n                yield yielded as E\n                throw new Error(\"Unreachable\")\n              },\n            }\n          }\n          const service = deps._services.get(serviceRequest.key)\n          if (service === undefined) {\n            throw new Error(`Service \"${serviceRequest.key}\" not found during layer build`)\n          }\n          result = gen.next(service)\n        }\n\n        const ctx = result.value\n        cacheRef.set(layer as AnyLayer, { context: ctx })\n        return ok(ctx)\n      },\n      *[Symbol.iterator](): Generator<FxYield<E, never>, Context<ROut>, unknown> {\n        const gen = buildFx[Symbol.iterator]()\n        let result = gen.next()\n\n        // Resolve service requests from deps\n        while (result.done !== true) {\n          const yielded = result.value\n          const serviceRequest = asServiceRequest(yielded)\n          if (serviceRequest === undefined) {\n            // It's an error - yield it\n            yield yielded as E\n            throw new Error(\"Unreachable\")\n          }\n          const service = deps._services.get(serviceRequest.key)\n          if (service === undefined) {\n            throw new Error(`Service \"${serviceRequest.key}\" not found during layer build`)\n          }\n          result = gen.next(service)\n        }\n\n        cacheRef.set(layer as AnyLayer, { context: result.value })\n        return result.value\n      },\n    } as SyncFx<Context<ROut>, E>\n  }\n\n  /**\n   * Clear the cache.\n   * Useful for testing.\n   */\n  clear(): void {\n    this.cache.clear()\n  }\n\n  /**\n   * Get the number of cached layers.\n   */\n  get size(): number {\n    return this.cache.size\n  }\n}\n\n/* oxlint-enable no-unsafe-type-assertion, only-throw-error */\n","import type { Context } from \"../context/context\"\nimport { runSync, runAsync } from \"../fx/fx.runtime\"\nimport { FxTypeId } from \"../fx/fx.types\"\nimport type { RunnableFx, SyncFx, AsyncFx, FxYield } from \"../fx/fx.types\"\nimport type { Layer } from \"../layer/layer.types\"\nimport { ok } from \"../result/result\"\nimport { make as makeScope } from \"../scope/scope\"\nimport type { ServiceClass } from \"../service/service\"\nimport { asServiceRequest, resolveService } from \"../service/service-resolution\"\nimport { MemoMap } from \"./memo-map\"\n\n/* oxlint-disable no-unsafe-type-assertion -- layer/service re-thread generic Fx channels through runtime service injection points. */\n\n// ============================================================================\n// Provide Layer\n// ============================================================================\n\n/**\n * Extract the value type from an Fx.\n */\ntype FxValueType<F> = F extends RunnableFx<infer A, unknown, unknown> ? A : never\n\n/**\n * Extract the error type from an Fx.\n */\ntype FxErrorType<F> = F extends RunnableFx<unknown, infer E, unknown> ? E : never\n\n/**\n * Type for the result of provide based on layer sync and fx type.\n * Uses infer to extract A and E from the actual Fx type.\n * - Sync layer + SyncFx → SyncFx\n * - Sync layer + AsyncFx → AsyncFx\n * - Async layer + any fx → AsyncFx\n * - Unknown sync layer + any fx → RunnableFx (fallback)\n */\ntype ProvideResult<\n  E2,\n  LayerSync extends boolean,\n  Fx extends RunnableFx<unknown, unknown, unknown>,\n> = LayerSync extends true\n  ? Fx[\"_tag\"] extends \"SyncFx\"\n    ? SyncFx<FxValueType<Fx>, FxErrorType<Fx> | E2>\n    : AsyncFx<FxValueType<Fx>, FxErrorType<Fx> | E2>\n  : LayerSync extends false\n    ? AsyncFx<FxValueType<Fx>, FxErrorType<Fx> | E2>\n    : RunnableFx<FxValueType<Fx>, FxErrorType<Fx> | E2>\n\n/**\n * Provide a layer to an Fx computation, resolving all service requirements.\n * Creates a new scope for resource management.\n *\n * Type preservation:\n * - Sync layer + SyncFx → SyncFx\n * - Sync layer + AsyncFx → AsyncFx\n * - Async layer + any fx → AsyncFx\n * - Unknown sync layer + any fx → RunnableFx (fallback)\n *\n * @param layer - The layer providing services (must have no external requirements)\n * @returns A function that takes an Fx and returns an Fx with dependencies resolved\n *\n * @example\n * ```ts\n * import { Fx, Layer, Provide, Service } from \"@nicolastoulemont/std\"\n *\n * const Port = Service.tag<number>(\"Port\")\n * const portLayer = Layer.ok(Port, 3000)\n * const readPort = Fx.gen(function* () {\n *   return yield* Port\n * })\n * const provided = Provide.layer(portLayer)(readPort)\n * const exit = Fx.run(provided)\n * // => { _tag: \"Ok\", value: 3000 }\n * ```\n */\nexport function layer<ROut, E2, LayerSync extends boolean>(\n  layer: Layer<ROut, E2, never, LayerSync>,\n): <Fx extends RunnableFx<unknown, unknown, ROut>>(fx: Fx) => ProvideResult<E2, LayerSync, Fx>\nexport function layer<ROut, E2>(layer: Layer<ROut, E2>) {\n  return <A, E, R extends ROut>(fx: RunnableFx<A, E, R>): RunnableFx<A, E | E2> => {\n    // Build mode selection should remain stable for this wrapper,\n    // while actual layer state (scope + memoization) must be per-execution.\n    const layerBuildTag = layer.build(new MemoMap(), makeScope())._tag\n\n    const createRunLayerState = (): {\n      readonly scope: ReturnType<typeof makeScope>\n      readonly layerBuildFx: ReturnType<typeof layer.build>\n    } => {\n      const memoMap = new MemoMap()\n      const scope = makeScope()\n      return {\n        scope,\n        layerBuildFx: layer.build(memoMap, scope),\n      }\n    }\n\n    if (layerBuildTag === \"AsyncFx\" || fx._tag === \"AsyncFx\") {\n      return {\n        _tag: \"AsyncFx\",\n        [FxTypeId]: {\n          _A: () => undefined as unknown as A,\n          _E: () => undefined as unknown as E | E2,\n          _R: () => undefined as never,\n        },\n        async *[Symbol.asyncIterator](): AsyncGenerator<FxYield<E | E2, Exclude<R, ROut>>, A, unknown> {\n          const { scope, layerBuildFx } = createRunLayerState()\n\n          try {\n            // Build the layer\n            let ctx: Context<ROut>\n\n            if (layerBuildFx._tag === \"AsyncFx\") {\n              const gen = layerBuildFx[Symbol.asyncIterator]()\n              let result = await gen.next()\n\n              while (result.done !== true) {\n                yield result.value as E2\n                // oxlint-disable-next-line no-await-in-loop\n                result = await gen.next(undefined)\n              }\n              ctx = result.value\n            } else {\n              const gen = layerBuildFx[Symbol.iterator]()\n              let result = gen.next()\n\n              while (result.done !== true) {\n                yield result.value as E2\n                result = gen.next(undefined)\n              }\n              ctx = result.value\n            }\n\n            // Run the fx with the context\n            if (fx._tag === \"AsyncFx\") {\n              const fxGen = fx[Symbol.asyncIterator]()\n              let fxResult = await fxGen.next()\n\n              while (fxResult.done !== true) {\n                const yielded = fxResult.value\n\n                const service = resolveService(ctx, yielded)\n                if (service !== undefined) {\n                  // oxlint-disable-next-line no-await-in-loop\n                  fxResult = await fxGen.next(service)\n                  continue\n                }\n\n                // Pass through (error or unsatisfied service)\n                const value = yield yielded as FxYield<E, Exclude<R, ROut>>\n                // oxlint-disable-next-line no-await-in-loop\n                fxResult = await fxGen.next(value)\n              }\n\n              return fxResult.value\n            }\n\n            // Sync fx\n            const fxGen = fx[Symbol.iterator]()\n            let fxResult = fxGen.next()\n\n            while (fxResult.done !== true) {\n              const yielded = fxResult.value\n\n              const service = resolveService(ctx, yielded)\n              if (service !== undefined) {\n                fxResult = fxGen.next(service)\n                continue\n              }\n\n              const value = yield yielded as FxYield<E, Exclude<R, ROut>>\n              fxResult = fxGen.next(value)\n            }\n\n            return fxResult.value\n          } finally {\n            const closeResult = scope.close(ok(undefined))\n            if (closeResult._tag === \"AsyncFx\") {\n              await runAsync(closeResult)\n            } else {\n              runSync(closeResult)\n            }\n          }\n        },\n      } as AsyncFx<A, E | E2>\n    }\n\n    // Both sync\n    return {\n      _tag: \"SyncFx\",\n      [FxTypeId]: {\n        _A: () => undefined as unknown as A,\n        _E: () => undefined as unknown as E | E2,\n        _R: () => undefined as never,\n      },\n      *[Symbol.iterator](): Generator<FxYield<E | E2, Exclude<R, ROut>>, A, unknown> {\n        const { scope, layerBuildFx } = createRunLayerState()\n\n        if (layerBuildFx._tag === \"AsyncFx\") {\n          throw new Error(\n            \"Provide.layer sync execution encountered an async layer build. Ensure async layers are treated as async at composition time.\",\n          )\n        }\n\n        try {\n          // Build the layer\n          const layerGen = layerBuildFx[Symbol.iterator]()\n          let layerResult = layerGen.next()\n\n          while (layerResult.done !== true) {\n            yield layerResult.value as E2\n            layerResult = layerGen.next(undefined)\n          }\n\n          const ctx = layerResult.value\n\n          // Run the fx with the context\n          const fxGen = fx[Symbol.iterator]()\n          let fxResult = fxGen.next()\n\n          while (fxResult.done !== true) {\n            const yielded = fxResult.value\n\n            const service = resolveService(ctx, yielded)\n            if (service !== undefined) {\n              fxResult = fxGen.next(service)\n              continue\n            }\n\n            const value = yield yielded as FxYield<E, Exclude<R, ROut>>\n            fxResult = fxGen.next(value)\n          }\n\n          return fxResult.value\n        } finally {\n          const closeResult = scope.close(ok(undefined))\n          // In sync-only branch, closeResult is always SyncFx\n          runSync(closeResult as SyncFx<void>)\n        }\n      },\n    } as SyncFx<A, E | E2>\n  }\n}\n\n// ============================================================================\n// Provide Context\n// ============================================================================\n\n/**\n * Provide a context directly to an Fx computation.\n *\n * @param ctx - The context containing services\n * @returns A function that takes an Fx and returns an Fx with dependencies resolved\n *\n * @example\n * ```ts\n * import { Context, Fx, Provide, Service } from \"@nicolastoulemont/std\"\n *\n * const Port = Service.tag<number>(\"Port\")\n * const ctx = Context.make(Port, 3000)\n * const readPort = Fx.gen(function* () {\n *   return yield* Port\n * })\n * const provided = Provide.context(ctx)(readPort)\n * const exit = Fx.run(provided)\n * // => { _tag: \"Ok\", value: 3000 }\n * ```\n */\nexport const context =\n  <R>(ctx: Context<R>) =>\n  <A, E>(fx: RunnableFx<A, E, R>): RunnableFx<A, E> => {\n    if (fx._tag === \"AsyncFx\") {\n      return {\n        _tag: \"AsyncFx\",\n        [FxTypeId]: {\n          _A: () => undefined as unknown as A,\n          _E: () => undefined as unknown as E,\n          _R: () => undefined as never,\n        },\n        async *[Symbol.asyncIterator](): AsyncGenerator<FxYield<E, never>, A, unknown> {\n          const gen = fx[Symbol.asyncIterator]()\n          let result = await gen.next()\n\n          while (result.done !== true) {\n            const yielded = result.value\n\n            const serviceRequest = asServiceRequest(yielded)\n            if (serviceRequest === undefined) {\n              yield yielded as E\n              // oxlint-disable-next-line no-await-in-loop\n              result = await gen.next(undefined)\n              continue\n            }\n            const service = ctx._services.get(serviceRequest.key)\n            if (service === undefined) {\n              throw new Error(`Service \"${serviceRequest.key}\" not found`)\n            }\n            // oxlint-disable-next-line no-await-in-loop\n            result = await gen.next(service)\n          }\n\n          return result.value\n        },\n      } as AsyncFx<A, E>\n    }\n\n    return {\n      _tag: \"SyncFx\",\n      [FxTypeId]: {\n        _A: () => undefined as unknown as A,\n        _E: () => undefined as unknown as E,\n        _R: () => undefined as never,\n      },\n      *[Symbol.iterator](): Generator<FxYield<E, never>, A, unknown> {\n        const gen = fx[Symbol.iterator]()\n        let result = gen.next()\n\n        while (result.done !== true) {\n          const yielded = result.value\n\n          const serviceRequest = asServiceRequest(yielded)\n          if (serviceRequest === undefined) {\n            yield yielded as E\n            result = gen.next(undefined)\n            continue\n          }\n          const service = ctx._services.get(serviceRequest.key)\n          if (service === undefined) {\n            throw new Error(`Service \"${serviceRequest.key}\" not found`)\n          }\n          result = gen.next(service)\n        }\n\n        return result.value\n      },\n    } as SyncFx<A, E>\n  }\n\n// ============================================================================\n// Provide Service\n// ============================================================================\n\n/**\n * Provide a single service to an Fx computation.\n *\n * @param service - The service class (tag)\n * @param impl - The service implementation\n * @returns A function that takes an Fx and returns an Fx with the service provided\n *\n * @example\n * ```ts\n * import { Fx, Provide, Service } from \"@nicolastoulemont/std\"\n *\n * const Port = Service.tag<number>(\"Port\")\n * const readPort = Fx.gen(function* () {\n *   return yield* Port\n * })\n * const provided = Provide.service(Port, 3000)(readPort)\n * const exit = Fx.run(provided)\n * // => { _tag: \"Ok\", value: 3000 }\n * ```\n */\nexport const service =\n  <S>(service: ServiceClass<S>, impl: S) =>\n  <A, E, R>(fx: RunnableFx<A, E, R | S>): RunnableFx<A, E, Exclude<R, S>> => {\n    if (fx._tag === \"AsyncFx\") {\n      return {\n        _tag: \"AsyncFx\",\n        [FxTypeId]: {\n          _A: () => undefined as unknown as A,\n          _E: () => undefined as unknown as E,\n          _R: () => undefined as unknown as Exclude<R, S>,\n        },\n        async *[Symbol.asyncIterator](): AsyncGenerator<FxYield<E, Exclude<R, S>>, A, unknown> {\n          const gen = fx[Symbol.asyncIterator]()\n          let result = await gen.next()\n\n          while (result.done !== true) {\n            const yielded = result.value\n\n            const serviceRequest = asServiceRequest(yielded)\n            if (serviceRequest?.key === service.key) {\n              // oxlint-disable-next-line no-await-in-loop\n              result = await gen.next(impl)\n            } else {\n              const value = yield yielded as FxYield<E, Exclude<R, S>>\n              // oxlint-disable-next-line no-await-in-loop\n              result = await gen.next(value)\n            }\n          }\n\n          return result.value\n        },\n      } as AsyncFx<A, E, Exclude<R, S>>\n    }\n\n    return {\n      _tag: \"SyncFx\",\n      [FxTypeId]: {\n        _A: () => undefined as unknown as A,\n        _E: () => undefined as unknown as E,\n        _R: () => undefined as unknown as Exclude<R, S>,\n      },\n      *[Symbol.iterator](): Generator<FxYield<E, Exclude<R, S>>, A, unknown> {\n        const gen = fx[Symbol.iterator]()\n        let result = gen.next()\n\n        while (result.done !== true) {\n          const yielded = result.value\n\n          const serviceRequest = asServiceRequest(yielded)\n          if (serviceRequest?.key === service.key) {\n            result = gen.next(impl)\n          } else {\n            const value = yield yielded as FxYield<E, Exclude<R, S>>\n            result = gen.next(value)\n          }\n        }\n\n        return result.value\n      },\n    } as SyncFx<A, E, Exclude<R, S>>\n  }\n\n/* oxlint-enable no-unsafe-type-assertion */\n"],"mappings":"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"}

package/dist/schema.types-E1pjcc0Y.d.mts.map

@@ -1 +0,0 @@
-{"version":3,"file":"schema.types-E1pjcc0Y.d.mts","names":[],"sources":["../src/schema/schema.types.ts"],"sourcesContent":[],"mappings":";;;;;;;AAMA;AAA4B,KAAhB,KAAgB,CAAA,UAAA,gBAAA,CAAA,GAAoB,WAApB,CAAgC,CAAhC,CAAA,WAAA,CAAA,CAAA,OAAA,CAAA,CAAA,CAAA,OAAA,CAAA;;;;AAKhB,KAAA,MAAM,CAAA,UAAW,gBAAX,CAAA,GAA+B,WAA/B,CAA2C,CAA3C,CAAA,WAAA,CAAA,CAAA,OAAA,CAAA,CAAA,CAAA,QAAA,CAAA;;;;;AAQlB;;AAAuD,KAA3C,KAA2C,CAAA,UAA3B,gBAA2B,CAAA,GAAP,MAAO,CAAA,CAAA,CAAA;;;AAUvD;;;;;;AAEe,KAFH,MAEG,CAAA,IAAA,EAAA,UAFoB,gBAEpB,CAAA,GAFwC,IAExC,SAFqD,KAErD,CAF2D,CAE3D,CAAA,GADX,IACW,SAAA,OAAA,GAAT,QAAS,CAAA,IAAA,GAAO,MAAP,CAAc,CAAd,CAAA,CAAA,GAAA,KAAA,GAAA,KAAA;;;;AAAD,KAOF,eAAA,GAPE;EAOF,SAAA,OAAA,EAAe,MAAA;EAQf,SAAA,IAAA,CAAA,EANM,aAMS,CANK,WAOC,CAAA,GAAA,SAAd;AAOnB,CAAA;;;;AAAkE,KARtD,eAAA,GAQsD;EAAL,SAAA,MAAA,EAP1C,aAO0C,CAP5B,eAO4B,CAAA;CACf;;;;;AACZ,KAFtB,UAEuC,CAAA,SAAA,OAAA,EAAA,UAFA,MAEA,CAAA,GAFU,IAEV,CAFe,gBAEf,CAFgC,MAEhC,EAFwC,OAExC,CAAA,EAAA,WAAA,CAAA,GAAA;EAAM,SAAA,WAAA,EADjC,IACiC,CAD5B,gBAC4B,CADX,MACW,EADH,OACG,CAAA,CAAA,WAAA,CAAA,EAAA,UAAA,CAAA,GAAA;IAO7C,QAAA,EAAA,CAAA,KAAgB,EAAA,OAAA,EAAA,GAPM,gBAAA,CAAiB,MAOvB,CAP8B,OAO9B,CAAA;EAAmB,CAAA;CAAyB;;;;AAK5D,KALA,gBAKoB,CAAA,IAAA,EAAA,YALe,IAKf,CAAA,GALuB,gBAKvB,CALwC,IAKxC,EAL8C,GAK9C,CAAA;;;;AAA2B,KAA/C,oBAA+C,CAAA,IAAA,EAAA,YAAR,IAAQ,CAAA,GAAA,UAAA,CAAW,IAAX,EAAiB,GAAjB,CAAA"}