@nicolastoulemont/std 0.9.0 → 0.10.0

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

@@ -1 +0,0 @@
-{"version":3,"file":"index-BaRJVkLo.d.mts","names":[],"sources":["../src/adt/adt.match.ts","../src/adt/adt.types.ts","../src/adt/adt.union.ts","../src/adt/adt.variant.ts","../src/adt/adt.ts"],"sourcesContent":[],"mappings":"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"}

package/dist/index-BipW0MC3.d.mts

@@ -1,64 +0,0 @@
-import { t as Result } from "./result.types-BKzChyWY.mjs";
-import { a as RefinementSchema, c as ValidationError, i as Refine, l as ValidationIssue, n as Input, o as SyncRefinementSchema, r as Output, s as SyncSchema, t as Infer } from "./schema.types-w1WK4kGS.mjs";
-import { StandardSchemaV1 } from "@standard-schema/spec";
-
-//#region src/schema/schema.d.ts
-declare namespace schema_d_exports {
-  export { Infer, Input, Is, Output, Refine, RefineFn, RefinementSchema, SyncRefinementSchema, SyncSchema, ValidationError, ValidationIssue, is, parse, refine };
-}
-/**
- * Create a schema-backed parser.
- *
- * For sync schemas the returned parser is sync.
- * For general Standard Schema values the returned parser is async.
- */
-declare function parse<S extends SyncSchema>(schema: S): (value: Input<S>) => Result<Output<S>, ValidationError>;
-declare function parse<S extends StandardSchemaV1>(schema: S): (value: Input<S>) => Promise<Result<Output<S>, ValidationError>>;
-type RefineFn = {
-  <S extends SyncSchema, Base extends Input<S>>(value: Base, schema: S): value is Refine<Base, S>;
-  <S extends SyncSchema>(schema: S): <Base extends Input<S>>(value: Base) => value is Refine<Base, S>;
-};
-type Is = {
-  <Base, Sub extends Base>(value: Base, schema: SyncRefinementSchema<Base, Sub>): value is Sub;
-  <S extends SyncSchema>(value: unknown, schema: S): value is Output<S>;
-  <Base, Sub extends Base>(schema: SyncRefinementSchema<Base, Sub>): (value: Base) => value is Sub;
-  <S extends SyncSchema>(schema: S): (value: unknown) => value is Output<S>;
-};
-/**
- * Create a sync-only schema-backed reusable type guard that preserves the original value shape.
- *
- * Use this when a schema validates only a subset of a broader in-memory value
- * and you need the preserved shape to survive higher-order APIs like
- * `Array.filter`. The narrowed type is `Base & Output<typeof schema>`, not the
- * exact schema output.
- *
- * Supports both data-first and data-last styles:
- * - Data-first: `Schema.refine(value, schema)`
- * - Data-last: `Schema.refine(schema)(value)`
- *
- * Only use this with sync proof schemas that validate properties already
- * present on the original value. Transforms, defaults, and coercions are not
- * safe here because they can change the schema output without changing the
- * original input value.
- */
-declare function refine<S extends SyncSchema, Base extends Input<S>>(value: Base, schema: S): value is Refine<Base, S>;
-declare function refine<S extends SyncSchema>(schema: S): <Base extends Input<S>>(value: Base) => value is Refine<Base, S>;
-/**
- * Create a sync-only schema-backed proof guard.
- *
- * On `unknown` values this narrows to the exact schema output. On already-typed
- * values, TypeScript preserves the current shape during direct control-flow
- * checks. Use `Schema.refine` when that preserved shape must survive
- * higher-order APIs like `Array.filter`.
- *
- * Supports both data-first and data-last styles:
- * - Data-first: `Schema.is(value, schema)`
- * - Data-last: `Schema.is(schema)(value)`
- */
-declare function is<Base, Sub extends Base>(value: Base, schema: SyncRefinementSchema<Base, Sub>): value is Sub;
-declare function is<S extends SyncSchema>(value: unknown, schema: S): value is Output<S>;
-declare function is<Base, Sub extends Base>(schema: SyncRefinementSchema<Base, Sub>): (value: Base) => value is Sub;
-declare function is<S extends SyncSchema>(schema: S): (value: unknown) => value is Output<S>;
-//#endregion
-export { schema_d_exports as t };
-//# sourceMappingURL=index-BipW0MC3.d.mts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"index-BipW0MC3.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,EAwDtB,CAxDsB,CAAA,EAAA,CAAA,aAyDf,KAzDe,CAyDT,CAzDS,CAAA,CAAA,CAAA,KAAA,EAyDE,IAzDF,EAAA,GAAA,KAAA,IAyDoB,MAzDpB,CAyD4B,IAzD5B,EAyDkC,CAzDlC,CAAA;;;AAoBhC;;;;;;;;;;AAEiC,iBA0DjB,EA1DiB,CAAA,IAAA,EAAA,YA0DI,IA1DJ,CAAA,CAAA,KAAA,EA0DiB,IA1DjB,EAAA,MAAA,EA0D+B,oBA1D/B,CA0DoD,IA1DpD,EA0D0D,GA1D1D,CAAA,CAAA,EAAA,KAAA,IA0D0E,GA1D1E;AAAwB,iBA2DzC,EA3DyC,CAAA,UA2D5B,UA3D4B,CAAA,CAAA,KAAA,EAAA,OAAA,EAAA,MAAA,EA2DQ,CA3DR,CAAA,EAAA,KAAA,IA2DqB,MA3DrB,CA2D4B,CA3D5B,CAAA;AAAN,iBA4DnC,EA5DmC,CAAA,IAAA,EAAA,YA4Dd,IA5Dc,CAAA,CAAA,MAAA,EA4DA,oBA5DA,CA4DqB,IA5DrB,EA4D2B,GA5D3B,CAAA,CAAA,EAAA,CAAA,KAAA,EA4D0C,IA5D1C,EAAA,GAAA,KAAA,IA4D4D,GA5D5D;AAAiB,iBA6DpD,EA7DoD,CAAA,UA6DvC,UA7DuC,CAAA,CAAA,MAAA,EA6DnB,CA7DmB,CAAA,EAAA,CAAA,KAAA,EAAA,OAAA,EAAA,GAAA,KAAA,IA6Dc,MA7Dd,CA6DqB,CA7DrB,CAAA"}

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

@@ -1 +0,0 @@
-{"version":3,"file":"index-D6pjHqlK.d.mts","names":[],"sources":["../src/data/data.types.ts","../src/data/data.array.ts","../src/data/data.entity.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":"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"}

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

@@ -1 +0,0 @@
-{"version":3,"file":"index-D8rDE60Y.d.mts","names":[],"sources":["../src/order/order.types.ts","../src/order/order.ts"],"sourcesContent":[],"mappings":"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"}

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

@@ -1 +0,0 @@
-{"version":3,"file":"index-DR7hzXU4.d.mts","names":[],"sources":["../src/multithread/multithread.types.ts","../src/multithread/multithread.ts"],"sourcesContent":[],"mappings":"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"}

package/dist/is-plain-object-BoFjRafL.mjs

@@ -1,2 +0,0 @@
-const e=16777619,t=()=>({hashes:new WeakMap,inProgress:new WeakSet,objectIds:new WeakMap,nextObjectId:1}),n=(e,t)=>{let n=e.objectIds.get(t);if(n!==void 0)return n;let r=e.nextObjectId;return e.objectIds.set(t,r),e.nextObjectId++,r},r=(t,i)=>{let a=2166136261;if(t===null)return a^1853189228;if(t===void 0)return a^1970168933;switch(typeof t){case`boolean`:return a^(t?1:0);case`number`:return Number.isNaN(t)?a^5136718:Number.isFinite(t)?a^(t|0)^(t*1e6|0):a^(t>0?4812390:759787110);case`string`:for(let n=0;n<t.length;n++)a^=t.codePointAt(n),a=Math.imul(a,e);return a>>>0;case`object`:{let o=t,s=i.hashes.get(o);if(s!==void 0)return s;if(i.inProgress.has(o))return(a^1668899692^n(i,o))>>>0;if(t instanceof Date)return a^r(t.getTime(),i);if(i.inProgress.add(o),n(i,o),Array.isArray(t)){a^=23389;for(let n=0;n<t.length;n++)a^=r(t[n],i),a=Math.imul(a,e);let n=a>>>0;return i.inProgress.delete(o),i.hashes.set(o,n),n}a^=31613;let c=t,l=Object.keys(c).toSorted();for(let t of l)a^=r(t,i),a=Math.imul(a,e),a^=r(c[t],i),a=Math.imul(a,e);let u=a>>>0;return i.inProgress.delete(o),i.hashes.set(o,u),u}default:return a}};function i(e){return r(e,t())}const a=(e,t,n)=>{let r=e.get(t);return r?.has(n)===!0?!0:r===void 0?(e.set(t,new WeakSet([n])),!1):(r.add(n),!1)},o=(e,t,n)=>{if(e===t)return!0;if(typeof e!=typeof t||e===null||t===null||typeof e!=`object`||typeof t!=`object`)return!1;if(a(n,e,t))return!0;if(e instanceof Date&&t instanceof Date)return e.getTime()===t.getTime();if(Array.isArray(e)&&Array.isArray(t))return e.length===t.length?e.every((e,r)=>o(e,t[r],n)):!1;if(Array.isArray(e)!==Array.isArray(t))return!1;let r=e,i=t,s=Object.keys(r),c=Object.keys(i);return s.length===c.length?s.every(e=>o(r[e],i[e],n)):!1};function s(e,t){return o(e,t,new WeakMap)}function c(e){return(t,n)=>t===n?!0:t._tag!==e||n._tag!==e?!1:s(t,n)}function l(e){return t=>t._tag===e?i(t):0}function u(e){return(t,n)=>t===n?!0:t._tag!==n._tag||!e.includes(t._tag)?!1:s(t,n)}function d(e){return t=>e.includes(t._tag)?i(t):0}function f(e){return typeof e!=`object`||!e?!1:Object.getPrototypeOf(e)===null||Object.getPrototypeOf(e)===Object.prototype}export{l as a,c as i,u as n,s as o,d as r,i as s,f as t};
-//# sourceMappingURL=is-plain-object-BoFjRafL.mjs.map

package/dist/is-plain-object-BoFjRafL.mjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"is-plain-object-BoFjRafL.mjs","names":["result"],"sources":["../src/equality/equality.ts","../src/shared/is-plain-object.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","/**\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"],"mappings":"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"}

package/dist/layer-C5A-EM0h.mjs

@@ -1,2 +0,0 @@
-import{t as e}from"./chunk-oQKkju2G.mjs";import{t}from"./fx.types-DyQVgTS8.mjs";import{i as n,n as r,r as i}from"./context-0xDbwtpx.mjs";import{n as a,t as o}from"./service-resolution-BefYr4nR.mjs";var s=e({err:()=>h,fx:()=>g,merge:()=>y,ok:()=>m,provide:()=>v,scoped:()=>_});const c=(e,n)=>({_tag:`Layer`,_ROut:void 0,_E:void 0,_RIn:void 0,_Sync:void 0,build:()=>({_tag:`SyncFx`,[t]:{_A:()=>void 0,_E:()=>void 0,_R:()=>void 0},*[Symbol.iterator](){return i(e,n)}})}),l=e=>({_tag:`Layer`,_ROut:void 0,_E:void 0,_RIn:void 0,_Sync:void 0,build:()=>({_tag:`SyncFx`,[t]:{_A:()=>void 0,_E:()=>e,_R:()=>void 0},*[Symbol.iterator](){throw yield e,Error(`Unreachable`)}})});function u(e){return n=>({_tag:`Layer`,_ROut:void 0,_E:void 0,_RIn:void 0,_Sync:void 0,build:()=>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 e=yield r.value;r=await t.next(e)}return i(e,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 e=yield r.value;r=t.next(e)}return i(e,r.value)}}})}function d(e){return n=>({_tag:`Layer`,_ROut:void 0,_E:void 0,_RIn:void 0,_Sync:void 0,build:(r,a)=>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 e=r.value;if(o(e)?.key===`@std/Scope`)r=await t.next(a);else{let n=yield e;r=await t.next(n)}}return i(e,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 e=r.value;if(o(e)?.key===`@std/Scope`)r=t.next(a);else{let n=yield e;r=t.next(n)}}return i(e,r.value)}}})}function f(e){return r=>({_tag:`Layer`,_ROut:void 0,_E:void 0,_RIn:void 0,_Sync:void 0,build:(i,o)=>{let s=e.build(i,o);return s._tag===`AsyncFx`?{_tag:`AsyncFx`,[t]:{_A:()=>void 0,_E:()=>void 0,_R:()=>void 0},async*[Symbol.asyncIterator](){let e=s[Symbol.asyncIterator](),t=await e.next();for(;t.done!==!0;){let n=yield t.value;t=await e.next(n)}let c=t.value,l=r.build(i,o);if(l._tag===`AsyncFx`){let e=l[Symbol.asyncIterator](),t=await e.next();for(;t.done!==!0;){let n=t.value,r=a(c,n);if(r!==void 0){t=await e.next(r);continue}let i=yield n;t=await e.next(i)}return n(c,t.value)}let u=l[Symbol.iterator](),d=u.next();for(;d.done!==!0;){let e=d.value,t=a(c,e);if(t!==void 0){d=u.next(t);continue}let n=yield e;d=u.next(n)}return n(c,d.value)}}:{_tag:`SyncFx`,[t]:{_A:()=>void 0,_E:()=>void 0,_R:()=>void 0},*[Symbol.iterator](){let e=s[Symbol.iterator](),t=e.next();for(;t.done!==!0;){let n=yield t.value;t=e.next(n)}let c=t.value,l=r.build(i,o);if(l._tag===`SyncFx`){let e=l[Symbol.iterator](),t=e.next();for(;t.done!==!0;){let n=t.value,r=a(c,n);if(r!==void 0){t=e.next(r);continue}let i=yield n;t=e.next(i)}return n(c,t.value)}throw Error(`Cannot use async layer in sync context`)}}}})}function p(...e){return{_tag:`Layer`,_ROut:void 0,_E:void 0,_RIn:void 0,_Sync:void 0,build:(i,o)=>e.some(e=>e.build(i,o)._tag===`AsyncFx`)?{_tag:`AsyncFx`,[t]:{_A:()=>void 0,_E:()=>void 0,_R:()=>void 0},async*[Symbol.asyncIterator](){let t=r();for(let r of e){let e=r.build(i,o);if(e._tag===`AsyncFx`){let r=e[Symbol.asyncIterator](),i=await r.next();for(;i.done!==!0;){let e=i.value,n=a(t,e);if(n!==void 0){i=await r.next(n);continue}let o=yield e;i=await r.next(o)}t=n(t,i.value)}else{let r=e[Symbol.iterator](),i=r.next();for(;i.done!==!0;){let e=i.value,n=a(t,e);if(n!==void 0){i=r.next(n);continue}let o=yield e;i=r.next(o)}t=n(t,i.value)}}return t}}:{_tag:`SyncFx`,[t]:{_A:()=>void 0,_E:()=>void 0,_R:()=>void 0},*[Symbol.iterator](){let t=r();for(let r of e){let e=r.build(i,o);if(e._tag!==`SyncFx`)throw Error(`Expected sync layer in sync context`);let s=e[Symbol.iterator](),c=s.next();for(;c.done!==!0;){let e=c.value,n=a(t,e);if(n!==void 0){c=s.next(n);continue}let r=yield e;c=s.next(r)}t=n(t,c.value)}return t}}}}const m=c,h=l,g=u,_=d,v=f,y=p;export{y as n,s as t};
-//# sourceMappingURL=layer-C5A-EM0h.mjs.map

package/dist/layer-C5A-EM0h.mjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"layer-C5A-EM0h.mjs","names":["Context.make","fx","layerGen","layerResult","Context.merge","Context.empty"],"sources":["../src/layer/layer.ts"],"sourcesContent":["/**\n * Layer construction and composition for service dependency graphs.\n *\n * **Mental model**\n * - A `Layer` builds one or more services, potentially requiring other services.\n * - Compose layers and provide dependencies before running `Fx`.\n *\n * **Common tasks**\n * - Build from values with `Layer.ok`.\n * - Build from effects with `Layer.fx` or `Layer.scoped`.\n * - Compose with `Layer.provide` and `Layer.merge`.\n *\n * **Gotchas**\n * - Async layers force async execution paths.\n * - Scoped layers require scope finalization.\n *\n * **Quickstart**\n *\n * @example\n * ```ts\n * import { Fx, Layer, Provide, Service } from \"@nicolastoulemont/std\"\n *\n * const Port = Service.tag<number>(\"Port\")\n * const program = Fx.gen(function* () {\n *   return yield* Port\n * })\n * const exit = Fx.run(Provide.layer(Layer.ok(Port, 3000))(program))\n * // => { _tag: \"Ok\", value: 3000 }\n * ```\n *\n * @module\n */\nimport * as Context from \"../context/context\"\nimport type { Context as ContextType } from \"../context/context\"\nimport { FxTypeId } from \"../fx/fx.types\"\nimport type { RunnableFx, SyncFx, AsyncFx, FxYield } from \"../fx/fx.types\"\nimport type { ScopeService, ExcludeScope } from \"../scope/scope\"\nimport type { ServiceClass } from \"../service/service\"\nimport { asServiceRequest, resolveService } from \"../service/service-resolution\"\nimport type { Layer as LayerType, MergeROut, MergeError, UnprovidedDeps, AllSync } from \"./layer.types\"\n\n/* oxlint-disable no-unsafe-type-assertion -- Layer composition carries erased generic channels and phantom type slots that require assertion-based reconstruction. */\n\n/**\n * Create a layer from a synchronous value (no dependencies).\n */\nconst layerOk = <S>(service: ServiceClass<S>, impl: S): LayerType<S, never, never, true> => ({\n  _tag: \"Layer\",\n  _ROut: undefined as unknown as S,\n  _E: undefined as never,\n  _RIn: undefined as never,\n  _Sync: undefined as unknown as true,\n  build: (): SyncFx<ContextType<S>> => ({\n    _tag: \"SyncFx\",\n    [FxTypeId]: {\n      _A: () => undefined as unknown as ContextType<S>,\n      _E: () => undefined as never,\n      _R: () => undefined as never,\n    },\n    // oxlint-disable-next-line require-yield\n    *[Symbol.iterator](): Generator<never, ContextType<S>, unknown> {\n      return Context.make(service, impl)\n    },\n  }),\n})\n\n/**\n * Create a layer that always fails with an error.\n */\nconst layerErr = <E>(error: E): LayerType<never, E, never, true> => ({\n  _tag: \"Layer\",\n  _ROut: undefined as never,\n  _E: undefined as unknown as E,\n  _RIn: undefined as never,\n  _Sync: undefined as unknown as true,\n  build: (): SyncFx<ContextType, E> => ({\n    _tag: \"SyncFx\",\n    [FxTypeId]: {\n      _A: () => undefined as never,\n      _E: () => error,\n      _R: () => undefined as never,\n    },\n    *[Symbol.iterator](): Generator<E, never, unknown> {\n      yield error\n      throw new Error(\"Unreachable\")\n    },\n  }),\n})\n\n/**\n * Create a layer from an Fx computation (can have dependencies).\n * The Sync type parameter is inferred from the input fx:\n * - SyncFx input → Layer with Sync=true\n * - AsyncFx input → Layer with Sync=false\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.fx(Port)(Fx.gen(function* () {\n *   return 3000\n * }))\n * const program = Fx.gen(function* () {\n *   return yield* Port\n * })\n * const exit = Fx.run(Provide.layer(portLayer)(program))\n * // => { _tag: \"Ok\", value: 3000 }\n * ```\n */\nfunction layerFx<S>(service: ServiceClass<S>): {\n  <E, R>(fx: SyncFx<S, E, R>): LayerType<S, E, R, true>\n  <E, R>(fx: AsyncFx<S, E, R>): LayerType<S, E, R, false>\n  <E, R>(fx: RunnableFx<S, E, R>): LayerType<S, E, R>\n}\nfunction layerFx<S>(service: ServiceClass<S>) {\n  return <E, R>(fx: RunnableFx<S, E, R>): LayerType<S, E, R> => ({\n    _tag: \"Layer\",\n    _ROut: undefined as unknown as S,\n    _E: undefined as unknown as E,\n    _RIn: undefined as unknown as R,\n    _Sync: undefined as unknown as boolean,\n    build: (): RunnableFx<ContextType<S>, E, R> => {\n      if (fx._tag === \"AsyncFx\") {\n        return {\n          _tag: \"AsyncFx\",\n          [FxTypeId]: {\n            _A: () => undefined as unknown as ContextType<S>,\n            _E: () => undefined as unknown as E,\n            _R: () => undefined as unknown as R,\n          },\n          async *[Symbol.asyncIterator](): AsyncGenerator<FxYield<E, R>, ContextType<S>, unknown> {\n            const gen = fx[Symbol.asyncIterator]()\n            let result = await gen.next()\n            while (result.done !== true) {\n              const value = yield result.value\n              // oxlint-disable-next-line no-await-in-loop\n              result = await gen.next(value)\n            }\n            return Context.make(service, result.value)\n          },\n        } as AsyncFx<ContextType<S>, E, R>\n      }\n\n      return {\n        _tag: \"SyncFx\",\n        [FxTypeId]: {\n          _A: () => undefined as unknown as ContextType<S>,\n          _E: () => undefined as unknown as E,\n          _R: () => undefined as unknown as R,\n        },\n        *[Symbol.iterator](): Generator<FxYield<E, R>, ContextType<S>, unknown> {\n          const gen = fx[Symbol.iterator]()\n          let result = gen.next()\n          while (result.done !== true) {\n            const value = yield result.value\n            result = gen.next(value)\n          }\n          return Context.make(service, result.value)\n        },\n      } as SyncFx<ContextType<S>, E, R>\n    },\n  })\n}\n\n/**\n * Create a scoped layer (with resource cleanup).\n * The Sync type parameter is inferred from the input fx.\n *\n * @example\n * ```ts\n * import { Fx, Layer, Provide, Scope, Service } from \"@nicolastoulemont/std\"\n *\n * const Resource = Service.tag<{ readonly id: number }>(\"Resource\")\n * const ScopeTag = Service.tag<Scope.ScopeService>(\"@std/Scope\")\n * let finalized = 0\n *\n * const resourceLayer = Layer.scoped(Resource)(Fx.gen(function* () {\n *   const scope = yield* ScopeTag\n *   yield* scope.addFinalizer(() =>\n *     Fx.gen(function* () {\n *       finalized += 1\n *     }),\n *   )\n *   return { id: 1 }\n * }))\n * const program = Fx.gen(function* () {\n *   return (yield* Resource).id\n * })\n * const exit = Fx.run(Provide.layer(resourceLayer)(program))\n * // => { _tag: \"Ok\", value: 1 }\n * ```\n */\nfunction layerScoped<S>(service: ServiceClass<S>): {\n  <E, R>(fx: SyncFx<S, E, R | ScopeService>): LayerType<S, E, ExcludeScope<R>, true>\n  <E, R>(fx: AsyncFx<S, E, R | ScopeService>): LayerType<S, E, ExcludeScope<R>, false>\n  <E, R>(fx: RunnableFx<S, E, R | ScopeService>): LayerType<S, E, ExcludeScope<R>>\n}\nfunction layerScoped<S>(service: ServiceClass<S>) {\n  return <E, R>(fx: RunnableFx<S, E, R | ScopeService>): LayerType<S, E, ExcludeScope<R>> => ({\n    _tag: \"Layer\",\n    _ROut: undefined as unknown as S,\n    _E: undefined as unknown as E,\n    _RIn: undefined as unknown as ExcludeScope<R>,\n    _Sync: undefined as unknown as boolean,\n    build: (_memoMap, scope): RunnableFx<ContextType<S>, E, ExcludeScope<R>> => {\n      if (fx._tag === \"AsyncFx\") {\n        return {\n          _tag: \"AsyncFx\",\n          [FxTypeId]: {\n            _A: () => undefined as unknown as ContextType<S>,\n            _E: () => undefined as unknown as E,\n            _R: () => undefined as unknown as ExcludeScope<R>,\n          },\n          async *[Symbol.asyncIterator](): AsyncGenerator<FxYield<E, ExcludeScope<R>>, ContextType<S>, unknown> {\n            const gen = fx[Symbol.asyncIterator]()\n            let result = await gen.next()\n            while (result.done !== true) {\n              const yielded = result.value\n              const serviceRequest = asServiceRequest(yielded)\n              if (serviceRequest?.key === \"@std/Scope\") {\n                // oxlint-disable-next-line no-await-in-loop\n                result = await gen.next(scope)\n              } else {\n                const value = yield yielded as FxYield<E, ExcludeScope<R>>\n                // oxlint-disable-next-line no-await-in-loop\n                result = await gen.next(value)\n              }\n            }\n            return Context.make(service, result.value)\n          },\n        } as AsyncFx<ContextType<S>, E, ExcludeScope<R>>\n      }\n\n      return {\n        _tag: \"SyncFx\",\n        [FxTypeId]: {\n          _A: () => undefined as unknown as ContextType<S>,\n          _E: () => undefined as unknown as E,\n          _R: () => undefined as unknown as ExcludeScope<R>,\n        },\n        *[Symbol.iterator](): Generator<FxYield<E, ExcludeScope<R>>, ContextType<S>, unknown> {\n          const gen = fx[Symbol.iterator]()\n          let result = gen.next()\n          while (result.done !== true) {\n            const yielded = result.value\n            const serviceRequest = asServiceRequest(yielded)\n            if (serviceRequest?.key === \"@std/Scope\") {\n              result = gen.next(scope)\n            } else {\n              const value = yield yielded as FxYield<E, ExcludeScope<R>>\n              result = gen.next(value)\n            }\n          }\n          return Context.make(service, result.value)\n        },\n      } as SyncFx<ContextType<S>, E, ExcludeScope<R>>\n    },\n  })\n}\n\n// ============================================================================\n// Layer Composition\n// ============================================================================\n\n/**\n * Provide dependencies to a layer and merge outputs.\n * Sync is preserved only if both the deps layer and the consuming layer are sync.\n *\n * @example\n * ```ts\n * import { Fx, Layer, Provide, Service } from \"@nicolastoulemont/std\"\n *\n * const Port = Service.tag<number>(\"Port\")\n * const Server = Service.tag<{ readonly port: number }>(\"Server\")\n * const portLayer = Layer.ok(Port, 3000)\n * const serverLayer = Layer.fx(Server)(Fx.gen(function* () {\n *   const port = yield* Port\n *   return { port }\n * }))\n * const provided = Layer.provide(portLayer)(serverLayer)\n * const program = Fx.gen(function* () {\n *   return (yield* Server).port\n * })\n * const exit = Fx.run(Provide.layer(provided)(program))\n * // => { _tag: \"Ok\", value: 3000 }\n * ```\n */\nfunction layerProvide<DepsROut, DepsE, DepsRIn, DepsSync extends boolean>(\n  deps: LayerType<DepsROut, DepsE, DepsRIn, DepsSync>,\n): {\n  <ROut, E, RIn extends DepsROut, LayerSync extends boolean>(\n    layer: LayerType<ROut, E, RIn, LayerSync>,\n  ): LayerType<ROut | DepsROut, E | DepsE, DepsRIn, LayerSync extends true ? DepsSync : false>\n}\nfunction layerProvide<DepsROut, DepsE, DepsRIn>(deps: LayerType<DepsROut, DepsE, DepsRIn>) {\n  return <ROut, E, RIn extends DepsROut>(\n    layer: LayerType<ROut, E, RIn>,\n  ): LayerType<ROut | DepsROut, E | DepsE, DepsRIn> => ({\n    _tag: \"Layer\",\n    _ROut: undefined as unknown as ROut | DepsROut,\n    _E: undefined as unknown as E | DepsE,\n    _RIn: undefined as unknown as DepsRIn,\n    _Sync: undefined as unknown as boolean,\n    build: (memoMap, scope): RunnableFx<ContextType<ROut | DepsROut>, E | DepsE, DepsRIn> => {\n      const depsBuildFx = deps.build(memoMap, scope)\n\n      if (depsBuildFx._tag === \"AsyncFx\") {\n        return {\n          _tag: \"AsyncFx\",\n          [FxTypeId]: {\n            _A: () => undefined as unknown as ContextType<ROut | DepsROut>,\n            _E: () => undefined as unknown as E | DepsE,\n            _R: () => undefined as unknown as DepsRIn,\n          },\n          async *[Symbol.asyncIterator](): AsyncGenerator<\n            FxYield<E | DepsE, DepsRIn>,\n            ContextType<ROut | DepsROut>,\n            unknown\n          > {\n            const depsGen = depsBuildFx[Symbol.asyncIterator]()\n            let depsResult = await depsGen.next()\n            while (depsResult.done !== true) {\n              const value = yield depsResult.value\n              // oxlint-disable-next-line no-await-in-loop\n              depsResult = await depsGen.next(value)\n            }\n            const depsCtx = depsResult.value\n\n            const layerBuildFx = layer.build(memoMap, scope)\n            if (layerBuildFx._tag === \"AsyncFx\") {\n              const layerGen = layerBuildFx[Symbol.asyncIterator]()\n              let layerResult = await layerGen.next()\n              while (layerResult.done !== true) {\n                const yielded = layerResult.value\n                const service = resolveService(depsCtx, yielded)\n                if (service !== undefined) {\n                  // oxlint-disable-next-line no-await-in-loop\n                  layerResult = await layerGen.next(service)\n                  continue\n                }\n                const value = yield yielded as FxYield<E, DepsRIn>\n                // oxlint-disable-next-line no-await-in-loop\n                layerResult = await layerGen.next(value)\n              }\n              return Context.merge(depsCtx, layerResult.value)\n            }\n\n            const layerGen = layerBuildFx[Symbol.iterator]()\n            let layerResult = layerGen.next()\n            while (layerResult.done !== true) {\n              const yielded = layerResult.value\n              const service = resolveService(depsCtx, yielded)\n              if (service !== undefined) {\n                layerResult = layerGen.next(service)\n                continue\n              }\n              const value = yield yielded as FxYield<E, DepsRIn>\n              layerResult = layerGen.next(value)\n            }\n            return Context.merge(depsCtx, layerResult.value)\n          },\n        } as AsyncFx<ContextType<ROut | DepsROut>, E | DepsE, DepsRIn>\n      }\n\n      return {\n        _tag: \"SyncFx\",\n        [FxTypeId]: {\n          _A: () => undefined as unknown as ContextType<ROut | DepsROut>,\n          _E: () => undefined as unknown as E | DepsE,\n          _R: () => undefined as unknown as DepsRIn,\n        },\n        *[Symbol.iterator](): Generator<FxYield<E | DepsE, DepsRIn>, ContextType<ROut | DepsROut>, unknown> {\n          const depsGen = depsBuildFx[Symbol.iterator]()\n          let depsResult = depsGen.next()\n          while (depsResult.done !== true) {\n            const value = yield depsResult.value\n            depsResult = depsGen.next(value)\n          }\n          const depsCtx = depsResult.value\n\n          const layerBuildFx = layer.build(memoMap, scope)\n          if (layerBuildFx._tag === \"SyncFx\") {\n            const syncGen = layerBuildFx[Symbol.iterator]()\n            let layerResult = syncGen.next()\n            while (layerResult.done !== true) {\n              const yielded = layerResult.value\n              const service = resolveService(depsCtx, yielded)\n              if (service !== undefined) {\n                layerResult = syncGen.next(service)\n                continue\n              }\n              const value = yield yielded as FxYield<E, DepsRIn>\n              layerResult = syncGen.next(value)\n            }\n            return Context.merge(depsCtx, layerResult.value)\n          }\n          throw new Error(\"Cannot use async layer in sync context\")\n        },\n      } as SyncFx<ContextType<ROut | DepsROut>, E | DepsE, DepsRIn>\n    },\n  })\n}\n\n/**\n * Merge multiple layers with automatic dependency resolution.\n * The merged layer is sync only if ALL input layers are sync.\n *\n * @example\n * ```ts\n * import { Fx, Layer, Provide, Service } from \"@nicolastoulemont/std\"\n *\n * const Logger = Service.tag<{ readonly prefix: string }>(\"Logger\")\n * const Clock = Service.tag<{ readonly now: () => number }>(\"Clock\")\n * const merged = Layer.merge(\n *   Layer.ok(Logger, { prefix: \"dev\" }),\n *   Layer.ok(Clock, { now: () => 123 }),\n * )\n * const program = Fx.gen(function* () {\n *   const logger = yield* Logger\n *   const clock = yield* Clock\n *   return `${logger.prefix}:${clock.now()}`\n * })\n * const exit = Fx.run(Provide.layer(merged)(program))\n * // => { _tag: \"Ok\", value: \"dev:123\" }\n * ```\n */\nfunction layerMerge<L extends LayerType<unknown, unknown, unknown>[]>(\n  ...layers: L\n): LayerType<MergeROut<L>, MergeError<L>, UnprovidedDeps<L>, AllSync<L>>\nfunction layerMerge<L extends LayerType<unknown, unknown, unknown>[]>(\n  ...layers: L\n): LayerType<MergeROut<L>, MergeError<L>, UnprovidedDeps<L>> {\n  return {\n    _tag: \"Layer\",\n    _ROut: undefined as unknown as MergeROut<L>,\n    _E: undefined as unknown as MergeError<L>,\n    _RIn: undefined as unknown as UnprovidedDeps<L>,\n    _Sync: undefined as unknown as boolean,\n    build: (memoMap, scope): RunnableFx<ContextType<MergeROut<L>>, MergeError<L>, UnprovidedDeps<L>> => {\n      const hasAsync = layers.some((l) => l.build(memoMap, scope)._tag === \"AsyncFx\")\n\n      if (hasAsync) {\n        return {\n          _tag: \"AsyncFx\",\n          [FxTypeId]: {\n            _A: () => undefined as unknown as ContextType<MergeROut<L>>,\n            _E: () => undefined as unknown as MergeError<L>,\n            _R: () => undefined as unknown as UnprovidedDeps<L>,\n          },\n          async *[Symbol.asyncIterator](): AsyncGenerator<\n            FxYield<MergeError<L>, UnprovidedDeps<L>>,\n            ContextType<MergeROut<L>>,\n            unknown\n          > {\n            let ctx = Context.empty() as ContextType<unknown>\n            for (const layer of layers) {\n              const buildFx = layer.build(memoMap, scope)\n              if (buildFx._tag === \"AsyncFx\") {\n                const gen = buildFx[Symbol.asyncIterator]()\n                // oxlint-disable-next-line no-await-in-loop\n                let result = await gen.next()\n                while (result.done !== true) {\n                  const yielded = result.value\n                  const service = resolveService(ctx, yielded)\n                  if (service !== undefined) {\n                    // oxlint-disable-next-line no-await-in-loop\n                    result = await gen.next(service)\n                    continue\n                  }\n                  const value = yield yielded as FxYield<MergeError<L>, UnprovidedDeps<L>>\n                  // oxlint-disable-next-line no-await-in-loop\n                  result = await gen.next(value)\n                }\n                ctx = Context.merge(ctx, result.value)\n              } else {\n                const gen = buildFx[Symbol.iterator]()\n                let result = gen.next()\n                while (result.done !== true) {\n                  const yielded = result.value\n                  const service = resolveService(ctx, yielded)\n                  if (service !== undefined) {\n                    result = gen.next(service)\n                    continue\n                  }\n                  const value = yield yielded as FxYield<MergeError<L>, UnprovidedDeps<L>>\n                  result = gen.next(value)\n                }\n                ctx = Context.merge(ctx, result.value)\n              }\n            }\n            return ctx as ContextType<MergeROut<L>>\n          },\n        } as AsyncFx<ContextType<MergeROut<L>>, MergeError<L>, UnprovidedDeps<L>>\n      }\n\n      return {\n        _tag: \"SyncFx\",\n        [FxTypeId]: {\n          _A: () => undefined as unknown as ContextType<MergeROut<L>>,\n          _E: () => undefined as unknown as MergeError<L>,\n          _R: () => undefined as unknown as UnprovidedDeps<L>,\n        },\n        *[Symbol.iterator](): Generator<FxYield<MergeError<L>, UnprovidedDeps<L>>, ContextType<MergeROut<L>>, unknown> {\n          let ctx = Context.empty() as ContextType<unknown>\n          for (const layer of layers) {\n            const buildFx = layer.build(memoMap, scope)\n            if (buildFx._tag !== \"SyncFx\") {\n              throw new Error(\"Expected sync layer in sync context\")\n            }\n            const gen = buildFx[Symbol.iterator]()\n            let result = gen.next()\n            while (result.done !== true) {\n              const yielded = result.value\n              const service = resolveService(ctx, yielded)\n              if (service !== undefined) {\n                result = gen.next(service)\n                continue\n              }\n              const value = yield yielded as FxYield<MergeError<L>, UnprovidedDeps<L>>\n              result = gen.next(value)\n            }\n            ctx = Context.merge(ctx, result.value)\n          }\n          return ctx as ContextType<MergeROut<L>>\n        },\n      } as SyncFx<ContextType<MergeROut<L>>, MergeError<L>, UnprovidedDeps<L>>\n    },\n  }\n}\n\n/**\n * Create a successful no-dependency layer from a plain service value.\n *\n * @example\n * ```ts\n * import { Fx, Layer, Provide, Service } from \"@nicolastoulemont/std\"\n *\n * const Port = Service.tag<number>(\"Port\")\n * const program = Fx.gen(function* () {\n *   return yield* Port\n * })\n * const exit = Fx.run(Provide.layer(Layer.ok(Port, 3000))(program))\n * // => { _tag: \"Ok\", value: 3000 }\n * ```\n */\nexport const ok = layerOk\n\n/**\n * Create a layer that always fails with an error.\n *\n * @example\n * ```ts\n * import { Fx, Layer, Provide } from \"@nicolastoulemont/std\"\n *\n * const program = Fx.gen(function* () {\n *   return 1\n * })\n * const exit = Fx.run(Provide.layer(Layer.err(\"missing-config\"))(program))\n * // => { _tag: \"Err\", error: \"missing-config\" }\n * ```\n */\nexport const err = layerErr\n\n/**\n * Create a layer from an effectful service builder.\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.fx(Port)(Fx.gen(function* () {\n *   return 3000\n * }))\n * const program = Fx.gen(function* () {\n *   return yield* Port\n * })\n * const exit = Fx.run(Provide.layer(portLayer)(program))\n * // => { _tag: \"Ok\", value: 3000 }\n * ```\n */\nexport const fx = layerFx\n\n/**\n * Create a scoped layer that registers resource finalizers.\n *\n * @example\n * ```ts\n * import { Fx, Layer, Provide, Scope, Service } from \"@nicolastoulemont/std\"\n *\n * const Resource = Service.tag<{ readonly id: number }>(\"Resource\")\n * const ScopeTag = Service.tag<Scope.ScopeService>(\"@std/Scope\")\n * let finalized = 0\n *\n * const resourceLayer = Layer.scoped(Resource)(Fx.gen(function* () {\n *   const scope = yield* ScopeTag\n *   yield* scope.addFinalizer(() =>\n *     Fx.gen(function* () {\n *       finalized += 1\n *     }),\n *   )\n *   return { id: 1 }\n * }))\n * const program = Fx.gen(function* () {\n *   return (yield* Resource).id\n * })\n * const exit = Fx.run(Provide.layer(resourceLayer)(program))\n * // => { _tag: \"Ok\", value: 1 }\n * ```\n */\nexport const scoped = layerScoped\n\n/**\n * Provide one layer to another, satisfying dependencies.\n *\n * @example\n * ```ts\n * import { Fx, Layer, Provide, Service } from \"@nicolastoulemont/std\"\n *\n * const Port = Service.tag<number>(\"Port\")\n * const Server = Service.tag<{ readonly port: number }>(\"Server\")\n * const portLayer = Layer.ok(Port, 3000)\n * const serverLayer = Layer.fx(Server)(Fx.gen(function* () {\n *   const port = yield* Port\n *   return { port }\n * }))\n * const provided = Layer.provide(portLayer)(serverLayer)\n * const program = Fx.gen(function* () {\n *   return (yield* Server).port\n * })\n * const exit = Fx.run(Provide.layer(provided)(program))\n * // => { _tag: \"Ok\", value: 3000 }\n * ```\n */\nexport const provide = layerProvide\n\n/**\n * Merge multiple layers into a single composite layer.\n *\n * @example\n * ```ts\n * import { Fx, Layer, Provide, Service } from \"@nicolastoulemont/std\"\n *\n * const Logger = Service.tag<{ readonly prefix: string }>(\"Logger\")\n * const Clock = Service.tag<{ readonly now: () => number }>(\"Clock\")\n * const merged = Layer.merge(\n *   Layer.ok(Logger, { prefix: \"dev\" }),\n *   Layer.ok(Clock, { now: () => 123 }),\n * )\n * const program = Fx.gen(function* () {\n *   const logger = yield* Logger\n *   const clock = yield* Clock\n *   return `${logger.prefix}:${clock.now()}`\n * })\n * const exit = Fx.run(Provide.layer(merged)(program))\n * // => { _tag: \"Ok\", value: \"dev:123\" }\n * ```\n */\nexport const merge = layerMerge\n\n/* oxlint-enable no-unsafe-type-assertion */\n"],"mappings":"oRA8CA,MAAM,GAAc,EAA0B,KAA+C,CAC3F,KAAM,QACN,MAAO,IAAA,GACP,GAAI,IAAA,GACJ,KAAM,IAAA,GACN,MAAO,IAAA,GACP,WAAsC,CACpC,KAAM,UACL,GAAW,CACV,OAAU,IAAA,GACV,OAAU,IAAA,GACV,OAAU,IAAA,GACX,CAED,EAAE,OAAO,WAAuD,CAC9D,OAAOA,EAAa,EAAS,EAAK,EAErC,EACF,EAKK,EAAe,IAAgD,CACnE,KAAM,QACN,MAAO,IAAA,GACP,GAAI,IAAA,GACJ,KAAM,IAAA,GACN,MAAO,IAAA,GACP,WAAsC,CACpC,KAAM,UACL,GAAW,CACV,OAAU,IAAA,GACV,OAAU,EACV,OAAU,IAAA,GACX,CACD,EAAE,OAAO,WAA0C,CAEjD,MADA,MAAM,EACI,MAAM,cAAc,EAEjC,EACF,EA4BD,SAAS,EAAW,EAA0B,CAC5C,MAAc,KAAiD,CAC7D,KAAM,QACN,MAAO,IAAA,GACP,GAAI,IAAA,GACJ,KAAM,IAAA,GACN,MAAO,IAAA,GACP,UACMC,EAAG,OAAS,UACP,CACL,KAAM,WACL,GAAW,CACV,OAAU,IAAA,GACV,OAAU,IAAA,GACV,OAAU,IAAA,GACX,CACD,OAAQ,OAAO,gBAAyE,CACtF,IAAM,EAAMA,EAAG,OAAO,gBAAgB,CAClC,EAAS,MAAM,EAAI,MAAM,CAC7B,KAAO,EAAO,OAAS,IAAM,CAC3B,IAAM,EAAQ,MAAM,EAAO,MAE3B,EAAS,MAAM,EAAI,KAAK,EAAM,CAEhC,OAAOD,EAAa,EAAS,EAAO,MAAM,EAE7C,CAGI,CACL,KAAM,UACL,GAAW,CACV,OAAU,IAAA,GACV,OAAU,IAAA,GACV,OAAU,IAAA,GACX,CACD,EAAE,OAAO,WAA+D,CACtE,IAAM,EAAMC,EAAG,OAAO,WAAW,CAC7B,EAAS,EAAI,MAAM,CACvB,KAAO,EAAO,OAAS,IAAM,CAC3B,IAAM,EAAQ,MAAM,EAAO,MAC3B,EAAS,EAAI,KAAK,EAAM,CAE1B,OAAOD,EAAa,EAAS,EAAO,MAAM,EAE7C,CAEJ,EAoCH,SAAS,EAAe,EAA0B,CAChD,MAAc,KAA8E,CAC1F,KAAM,QACN,MAAO,IAAA,GACP,GAAI,IAAA,GACJ,KAAM,IAAA,GACN,MAAO,IAAA,GACP,OAAQ,EAAU,IACZC,EAAG,OAAS,UACP,CACL,KAAM,WACL,GAAW,CACV,OAAU,IAAA,GACV,OAAU,IAAA,GACV,OAAU,IAAA,GACX,CACD,OAAQ,OAAO,gBAAuF,CACpG,IAAM,EAAMA,EAAG,OAAO,gBAAgB,CAClC,EAAS,MAAM,EAAI,MAAM,CAC7B,KAAO,EAAO,OAAS,IAAM,CAC3B,IAAM,EAAU,EAAO,MAEvB,GADuB,EAAiB,EAAQ,EAC5B,MAAQ,aAE1B,EAAS,MAAM,EAAI,KAAK,EAAM,KACzB,CACL,IAAM,EAAQ,MAAM,EAEpB,EAAS,MAAM,EAAI,KAAK,EAAM,EAGlC,OAAOD,EAAa,EAAS,EAAO,MAAM,EAE7C,CAGI,CACL,KAAM,UACL,GAAW,CACV,OAAU,IAAA,GACV,OAAU,IAAA,GACV,OAAU,IAAA,GACX,CACD,EAAE,OAAO,WAA6E,CACpF,IAAM,EAAMC,EAAG,OAAO,WAAW,CAC7B,EAAS,EAAI,MAAM,CACvB,KAAO,EAAO,OAAS,IAAM,CAC3B,IAAM,EAAU,EAAO,MAEvB,GADuB,EAAiB,EAAQ,EAC5B,MAAQ,aAC1B,EAAS,EAAI,KAAK,EAAM,KACnB,CACL,IAAM,EAAQ,MAAM,EACpB,EAAS,EAAI,KAAK,EAAM,EAG5B,OAAOD,EAAa,EAAS,EAAO,MAAM,EAE7C,CAEJ,EAqCH,SAAS,EAAuC,EAA2C,CACzF,MACE,KACoD,CACpD,KAAM,QACN,MAAO,IAAA,GACP,GAAI,IAAA,GACJ,KAAM,IAAA,GACN,MAAO,IAAA,GACP,OAAQ,EAAS,IAAwE,CACvF,IAAM,EAAc,EAAK,MAAM,EAAS,EAAM,CA4D9C,OA1DI,EAAY,OAAS,UAChB,CACL,KAAM,WACL,GAAW,CACV,OAAU,IAAA,GACV,OAAU,IAAA,GACV,OAAU,IAAA,GACX,CACD,OAAQ,OAAO,gBAIb,CACA,IAAM,EAAU,EAAY,OAAO,gBAAgB,CAC/C,EAAa,MAAM,EAAQ,MAAM,CACrC,KAAO,EAAW,OAAS,IAAM,CAC/B,IAAM,EAAQ,MAAM,EAAW,MAE/B,EAAa,MAAM,EAAQ,KAAK,EAAM,CAExC,IAAM,EAAU,EAAW,MAErB,EAAe,EAAM,MAAM,EAAS,EAAM,CAChD,GAAI,EAAa,OAAS,UAAW,CACnC,IAAME,EAAW,EAAa,OAAO,gBAAgB,CACjDC,EAAc,MAAMD,EAAS,MAAM,CACvC,KAAOC,EAAY,OAAS,IAAM,CAChC,IAAM,EAAUA,EAAY,MACtB,EAAU,EAAe,EAAS,EAAQ,CAChD,GAAI,IAAY,IAAA,GAAW,CAEzB,EAAc,MAAMD,EAAS,KAAK,EAAQ,CAC1C,SAEF,IAAM,EAAQ,MAAM,EAEpB,EAAc,MAAMA,EAAS,KAAK,EAAM,CAE1C,OAAOE,EAAc,EAASD,EAAY,MAAM,CAGlD,IAAM,EAAW,EAAa,OAAO,WAAW,CAC5C,EAAc,EAAS,MAAM,CACjC,KAAO,EAAY,OAAS,IAAM,CAChC,IAAM,EAAU,EAAY,MACtB,EAAU,EAAe,EAAS,EAAQ,CAChD,GAAI,IAAY,IAAA,GAAW,CACzB,EAAc,EAAS,KAAK,EAAQ,CACpC,SAEF,IAAM,EAAQ,MAAM,EACpB,EAAc,EAAS,KAAK,EAAM,CAEpC,OAAOC,EAAc,EAAS,EAAY,MAAM,EAEnD,CAGI,CACL,KAAM,UACL,GAAW,CACV,OAAU,IAAA,GACV,OAAU,IAAA,GACV,OAAU,IAAA,GACX,CACD,EAAE,OAAO,WAA2F,CAClG,IAAM,EAAU,EAAY,OAAO,WAAW,CAC1C,EAAa,EAAQ,MAAM,CAC/B,KAAO,EAAW,OAAS,IAAM,CAC/B,IAAM,EAAQ,MAAM,EAAW,MAC/B,EAAa,EAAQ,KAAK,EAAM,CAElC,IAAM,EAAU,EAAW,MAErB,EAAe,EAAM,MAAM,EAAS,EAAM,CAChD,GAAI,EAAa,OAAS,SAAU,CAClC,IAAM,EAAU,EAAa,OAAO,WAAW,CAC3C,EAAc,EAAQ,MAAM,CAChC,KAAO,EAAY,OAAS,IAAM,CAChC,IAAM,EAAU,EAAY,MACtB,EAAU,EAAe,EAAS,EAAQ,CAChD,GAAI,IAAY,IAAA,GAAW,CACzB,EAAc,EAAQ,KAAK,EAAQ,CACnC,SAEF,IAAM,EAAQ,MAAM,EACpB,EAAc,EAAQ,KAAK,EAAM,CAEnC,OAAOA,EAAc,EAAS,EAAY,MAAM,CAElD,MAAU,MAAM,yCAAyC,EAE5D,EAEJ,EA6BH,SAAS,EACP,GAAG,EACwD,CAC3D,MAAO,CACL,KAAM,QACN,MAAO,IAAA,GACP,GAAI,IAAA,GACJ,KAAM,IAAA,GACN,MAAO,IAAA,GACP,OAAQ,EAAS,IACE,EAAO,KAAM,GAAM,EAAE,MAAM,EAAS,EAAM,CAAC,OAAS,UAAU,CAGtE,CACL,KAAM,WACL,GAAW,CACV,OAAU,IAAA,GACV,OAAU,IAAA,GACV,OAAU,IAAA,GACX,CACD,OAAQ,OAAO,gBAIb,CACA,IAAI,EAAMC,GAAe,CACzB,IAAK,IAAM,KAAS,EAAQ,CAC1B,IAAM,EAAU,EAAM,MAAM,EAAS,EAAM,CAC3C,GAAI,EAAQ,OAAS,UAAW,CAC9B,IAAM,EAAM,EAAQ,OAAO,gBAAgB,CAEvC,EAAS,MAAM,EAAI,MAAM,CAC7B,KAAO,EAAO,OAAS,IAAM,CAC3B,IAAM,EAAU,EAAO,MACjB,EAAU,EAAe,EAAK,EAAQ,CAC5C,GAAI,IAAY,IAAA,GAAW,CAEzB,EAAS,MAAM,EAAI,KAAK,EAAQ,CAChC,SAEF,IAAM,EAAQ,MAAM,EAEpB,EAAS,MAAM,EAAI,KAAK,EAAM,CAEhC,EAAMD,EAAc,EAAK,EAAO,MAAM,KACjC,CACL,IAAM,EAAM,EAAQ,OAAO,WAAW,CAClC,EAAS,EAAI,MAAM,CACvB,KAAO,EAAO,OAAS,IAAM,CAC3B,IAAM,EAAU,EAAO,MACjB,EAAU,EAAe,EAAK,EAAQ,CAC5C,GAAI,IAAY,IAAA,GAAW,CACzB,EAAS,EAAI,KAAK,EAAQ,CAC1B,SAEF,IAAM,EAAQ,MAAM,EACpB,EAAS,EAAI,KAAK,EAAM,CAE1B,EAAMA,EAAc,EAAK,EAAO,MAAM,EAG1C,OAAO,GAEV,CAGI,CACL,KAAM,UACL,GAAW,CACV,OAAU,IAAA,GACV,OAAU,IAAA,GACV,OAAU,IAAA,GACX,CACD,EAAE,OAAO,WAAsG,CAC7G,IAAI,EAAMC,GAAe,CACzB,IAAK,IAAM,KAAS,EAAQ,CAC1B,IAAM,EAAU,EAAM,MAAM,EAAS,EAAM,CAC3C,GAAI,EAAQ,OAAS,SACnB,MAAU,MAAM,sCAAsC,CAExD,IAAM,EAAM,EAAQ,OAAO,WAAW,CAClC,EAAS,EAAI,MAAM,CACvB,KAAO,EAAO,OAAS,IAAM,CAC3B,IAAM,EAAU,EAAO,MACjB,EAAU,EAAe,EAAK,EAAQ,CAC5C,GAAI,IAAY,IAAA,GAAW,CACzB,EAAS,EAAI,KAAK,EAAQ,CAC1B,SAEF,IAAM,EAAQ,MAAM,EACpB,EAAS,EAAI,KAAK,EAAM,CAE1B,EAAMD,EAAc,EAAK,EAAO,MAAM,CAExC,OAAO,GAEV,CAEJ,CAkBH,MAAa,EAAK,EAgBL,EAAM,EAoBN,EAAK,EA6BL,EAAS,EAwBT,EAAU,EAwBV,EAAQ"}

package/dist/multithread-Cyc8Bz45.mjs

@@ -1,19 +0,0 @@
-import{t as e}from"./chunk-oQKkju2G.mjs";import{t}from"./fx.types-DyQVgTS8.mjs";import{i as n,t as r}from"./result-D3VY0qBG.mjs";var i=e({configure:()=>ae,filter:()=>Y,firstSuccess:()=>ie,flatMap:()=>Q,forEach:()=>K,map:()=>U,race:()=>te,run:()=>L,shutdown:()=>oe,task:()=>z});const a=`@nicolastoulemont/std/multithread/cancelled`;let o,s=!1,c;const l=new WeakMap,u=(e,t=`Optional peer dependency "multithreading" is unavailable. Install it to use Multithread APIs.`)=>({_tag:`MultithreadRuntimeUnavailableError`,message:t,cause:e}),d=(e=`Multithread runtime is already initialized and can no longer be configured.`)=>({_tag:`MultithreadRuntimeAlreadyInitializedError`,message:e}),f=(e,t)=>({_tag:`MultithreadWorkerExecutionError`,message:e,cause:t}),p=(e=`Multithread operation was cancelled before completion.`)=>({_tag:`MultithreadCancelledError`,message:e}),m=(e,t)=>({_tag:`MultithreadAllFailedError`,message:e,errors:t}),h=e=>e instanceof Error?e.message:typeof e==`string`?e:void 0,g=e=>{let t=h(e);return t===a||t===`Task aborted`},_=e=>{let t=h(e);return typeof t==`string`&&t.startsWith(`Could not parse coordinates from:`)},v=e=>{if(typeof e!=`object`||!e||!(`_tag`in e))return!1;let t=Reflect.get(e,`_tag`);return t===`Ok`?`value`in e:t===`Err`?`error`in e:!1},y=e=>n(e),b=e=>r(e),x=e=>v(e)?e:y(e),S=(e,t)=>v(e)?e._tag===`Err`?Promise.resolve(b(e.error)):t(e.value).result():t(e),C=(e,t)=>{if(typeof e!=`number`||!Number.isFinite(e))return t;let n=Math.floor(e);return n>0?n:t},w=e=>typeof e==`function`,T=e=>typeof e==`object`&&!!e,E=e=>T(e)?e:void 0,D=()=>o===void 0?typeof navigator<`u`&&typeof navigator.hardwareConcurrency==`number`?C(navigator.hardwareConcurrency,4):4:o.maxWorkers,O=()=>typeof SharedArrayBuffer==`function`?new Int32Array(new SharedArrayBuffer(Int32Array.BYTES_PER_ELEMENT)):null,k=()=>{let e=O(),t=new Set,n=!1;return{signal:e,isCancelled:()=>n||e!==null&&Atomics.load(e,0)===1,cancel:()=>{if(n)return;n=!0,e!==null&&(Atomics.store(e,0,1),Atomics.notify(e,0));let r=Array.from(t);t.clear();for(let e of r)try{e()}catch{}},onCancel:e=>{if(n){e();return}t.add(e)}}},A=async()=>{try{return c??=import(`multithreading`),y(await c)}catch(e){return b(u(e))}},j=async()=>{let e=await A();if(e._tag===`Err`)return e;let t=e.value;if(!s)try{o!==void 0&&t.initRuntime(o),s=!0}catch(e){return b(f(`Failed to initialize multithreading runtime.`,e))}return y(t)},M=e=>{let t=l.get(e);if(t!==void 0)return t;let n=e.toString(),r=Function(`
-return async function (...__args) {
-  const __signal = __args.pop()
-  const __isCancelled = () => __signal !== null && Atomics.load(__signal, 0) === 1
-  const __throwIfCancelled = () => {
-    if (__isCancelled()) {
-      throw new Error(${JSON.stringify(a)})
-    }
-  }
-  const __ctx = {
-    signal: __signal,
-    isCancelled: __isCancelled,
-    throwIfCancelled: __throwIfCancelled,
-  }
-  const __worker = (${n})
-  return await __worker(...__args, __ctx)
-}
-`)();return l.set(e,r),r},N=e=>{let n=k(),r,i=()=>r===void 0?n.isCancelled()?(r=Promise.resolve(b(p())),r):(r=e(n).catch(e=>b(f(`Multithread operation failed.`,e))).then(e=>n.isCancelled()?b(p()):e),r):r,a=(e,t)=>i().then(e,t);return{_tag:`MultithreadOp`,[t]:{_A:()=>void 0,_E:()=>void 0,_R:()=>void 0},result:i,abort:()=>{n.cancel()},then:a,async*[Symbol.asyncIterator](){let e=await i();if(e._tag===`Err`)throw yield e.error,Error(`Unreachable: Fx.gen should short-circuit on yielded Multithread errors`);return e.value}}},P=async(e,t,n)=>{if(n.isCancelled())return b(p());let r={signal:n.signal,isCancelled:()=>n.isCancelled(),throwIfCancelled:()=>{if(n.isCancelled())throw Error(a)}};try{let i=await e(...t,r);if(n.isCancelled())return b(p());let a=x(i);return a._tag===`Err`?b(a.error):y(a.value)}catch(e){return n.isCancelled()||g(e)?b(p()):b(f(`Multithread worker failed during execution.`,e))}},F=(e,t)=>N(async n=>{if(n.isCancelled())return b(p());let r=await j();if(r._tag===`Err`)return b(r.error);let i=r.value,a=M(e),o;try{let e=i.move(...t,n.signal);o=i.spawn(e,a),n.onCancel(()=>{o?.abort()})}catch(r){return _(r)?P(e,t,n):n.isCancelled()||g(r)?b(p()):b(f(`Failed to start multithread worker.`,r))}try{let e=await o.join();if(n.isCancelled())return b(p());if(!e.ok){let t=e.error??Error(`Multithread worker returned an unknown error.`);return g(t)?b(p()):b(f(`Multithread worker failed during execution.`,t))}let t=x(e.value);return t._tag===`Err`?b(t.error):y(t.value)}catch(e){return n.isCancelled()||g(e)?b(p()):b(f(`Failed to join multithread worker.`,e))}});function I(e,...t){if(!w(e))throw TypeError(`Multithread.run expects a worker function as first argument.`);return F(e,t)}const L=I;function R(e){if(!w(e))throw TypeError(`Multithread.task expects a worker function.`);return(...t)=>F(e,t)}const z=R,B=(e,t,n,r)=>e.length===0?Promise.resolve(y([])):new Promise(i=>{let a=new Map,o=[],s=0,c=0,l=0,u=!1,d=()=>{for(let e of a.values())e.abort();a.clear()},m=e=>{u||(u=!0,d(),i(e))};r.onCancel(()=>{m(b(p()))});let h=(t,n)=>{(async()=>{try{let r=await n.result();if(--s,a.delete(t),u)return;if(r._tag===`Err`){m(b(r.error));return}if(o[t]=r.value,l+=1,l===e.length){u=!0,i(y(o));return}_()}catch(e){if(--s,a.delete(t),u)return;if(r.isCancelled()||g(e)){m(b(p()));return}m(b(f(`Failed while executing multithread batch.`,e)))}})()},_=()=>{for(;!u&&s<n&&c<e.length;){let n=c;c+=1;let r=t(e[n],n);a.set(n,r),s+=1,h(n,r)}};_()}),V=(e,t,n)=>N(r=>B(e,(e,n)=>F(t,[e,n]),C(n?.parallelism,D()),r));function H(e,t,n){if(typeof e==`function`){let n=E(t);return(t=>S(t,t=>V(t,e,n)))}if(typeof t!=`function`)throw TypeError(`Multithread.map(values, worker, options) requires a worker function.`);return S(e,e=>V(e,t,n))}const U=H,W=(e,t,n)=>N(async r=>{let i=await B(e,(e,n)=>F(t,[e,n]),C(n?.parallelism,D()),r);return i._tag===`Err`?b(i.error):y(void 0)});function G(e,t,n){if(typeof e==`function`){let n=E(t);return(t=>S(t,t=>W(t,e,n)))}if(typeof t!=`function`)throw TypeError(`Multithread.forEach(values, worker, options) requires a worker function.`);return S(e,e=>W(e,t,n))}const K=G,q=(e,t,n)=>N(async r=>{let i=await B(e,(e,n)=>F(t,[e,n]),C(n?.parallelism,D()),r);if(i._tag===`Err`)return b(i.error);let a=[];for(let t=0;t<e.length;t+=1)i.value[t]===!0&&a.push(e[t]);return y(a)});function J(e,t,n){if(typeof e==`function`){let n=E(t);return(t=>S(t,t=>q(t,e,n)))}if(typeof t!=`function`)throw TypeError(`Multithread.filter(values, worker, options) requires a worker function.`);return S(e,e=>q(e,t,n))}const Y=J,X=(e,t,n)=>N(async r=>{let i=await B(e,(e,n)=>F(t,[e,n]),C(n?.parallelism,D()),r);if(i._tag===`Err`)return b(i.error);let a=[];for(let e of i.value)a.push(...e);return y(a)});function Z(e,t,n){if(typeof e==`function`){let n=E(t);return(t=>S(t,t=>X(t,e,n)))}if(typeof t!=`function`)throw TypeError(`Multithread.flatMap(values, worker, options) requires a worker function.`);return S(e,e=>X(e,t,n))}const Q=Z,$=e=>N(t=>e.length===0?Promise.resolve(b(m(`Cannot race an empty list of operations.`,[]))):new Promise(n=>{let r=!1,i=()=>{for(let t of e)t.abort()},a=e=>{r||(r=!0,i(),n(e))};t.onCancel(()=>{a(b(p()))});let o=e=>{(async()=>{try{a(await e.result())}catch(e){if(t.isCancelled()||g(e)){a(b(p()));return}a(b(f(`Multithread race failed.`,e)))}})()};for(let t of e)o(t)}));function ee(e){return S(e,e=>$(e))}const te=ee,ne=e=>N(t=>e.length===0?Promise.resolve(b(m(`Cannot select a first success from an empty list of operations.`,[]))):new Promise(n=>{let r=Array.from({length:e.length}),i=e.length,a=!1,o=()=>{for(let t of e)t.abort()},s=e=>{a||(a=!0,o(),n(e))};t.onCancel(()=>{s(b(p()))});let c=(e,n)=>{(async()=>{try{let t=await e.result();if(a)return;if(t._tag===`Ok`){s(y(t.value));return}r[n]=t.error,--i,i===0&&s(b(m(`All multithread operations failed before any success was produced.`,r.filter(e=>e!==void 0))))}catch(e){if(a)return;if(t.isCancelled()||g(e)){s(b(p()));return}r[n]=f(`Multithread operation rejected unexpectedly.`,e),--i,i===0&&s(b(m(`All multithread operations failed before any success was produced.`,r.filter(e=>e!==void 0))))}})()};e.forEach((e,t)=>{c(e,t)})}));function re(e){return S(e,e=>ne(e))}const ie=re,ae=e=>s?b(d()):(o={maxWorkers:C(e.maxWorkers,1)},y(void 0)),oe=async()=>{if(!s)return y(void 0);let e=await A();if(e._tag===`Err`)return s=!1,b(e.error);try{return e.value.shutdown(),y(void 0)}catch(e){return b(f(`Failed to shutdown multithreading runtime.`,e))}finally{s=!1}};export{i as t};
-//# sourceMappingURL=multithread-Cyc8Bz45.mjs.map

package/dist/multithread-Cyc8Bz45.mjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"multithread-Cyc8Bz45.mjs","names":[],"sources":["../src/multithread/multithread.ts"],"sourcesContent":["/**\n * Parallel worker orchestration helpers built on optional `multithreading` runtime.\n *\n * **Mental model**\n * - `MultithreadOp` represents cancelable worker execution.\n * - Use `run`, `task`, and collection combinators (`map`, `forEach`, `race`).\n *\n * **Common tasks**\n * - Execute one worker with `Multithread.run`.\n * - Create reusable tasks with `Multithread.task`.\n * - Process collections in parallel with `Multithread.map` / `forEach`.\n *\n * **Gotchas**\n * - Requires optional `multithreading` peer dependency.\n * - Runtime should be configured before first operation.\n *\n * **Quickstart**\n *\n * @example\n * ```ts\n * import { Multithread } from \"@nicolastoulemont/std\"\n *\n * const op = Multithread.run((ctx) => (ctx.isCancelled() ? 0 : 42))\n * // => cancelable operation with result() and abort()\n * ```\n *\n * @module\n */\nimport { FxTypeId } from \"../fx/fx.types\"\nimport { err, ok } from \"../result/result\"\nimport type { Result as ResultType } from \"../result/result.types\"\nimport type {\n  MultithreadAllFailedError,\n  MultithreadCancelledError,\n  MultithreadCtx,\n  MultithreadError,\n  MultithreadFilter,\n  MultithreadFilterWorker,\n  MultithreadFirstSuccess,\n  MultithreadFlatMap,\n  MultithreadFlatMapWorker,\n  MultithreadForEach,\n  MultithreadMap,\n  MultithreadMapWorker,\n  MultithreadOp,\n  MultithreadParallelOptions,\n  MultithreadRace,\n  MultithreadRun,\n  MultithreadRuntimeAlreadyInitializedError,\n  MultithreadRuntimeUnavailableError,\n  MultithreadSignal,\n  MultithreadTask,\n  MultithreadWorkerExecutionError,\n  WorkerReturn,\n} from \"./multithread.types\"\nexport {\n  /**\n   * Re-exported worker context passed to multithread workers.\n   *\n   * @example\n   * ```ts\n   * import { Multithread } from \"@nicolastoulemont/std\"\n   *\n   * type Example = Multithread.MultithreadCtx\n   * ```\n   *\n   */\n  type MultithreadCtx,\n} from \"./multithread.types\"\nexport {\n  /**\n   * Re-exported union of multithread runtime and worker errors.\n   *\n   * @example\n   * ```ts\n   * import { Multithread } from \"@nicolastoulemont/std\"\n   *\n   * type Example = Multithread.MultithreadError\n   * ```\n   *\n   */\n  type MultithreadError,\n} from \"./multithread.types\"\nexport {\n  /**\n   * Re-exported cancelable multithread operation type.\n   *\n   * @example\n   * ```ts\n   * import { Multithread } from \"@nicolastoulemont/std\"\n   *\n   * type Example = Multithread.MultithreadOp<unknown, unknown>\n   * ```\n   *\n   */\n  type MultithreadOp,\n} from \"./multithread.types\"\n\n/**\n * Internal runtime shape loaded from the optional \"multithreading\" peer dependency.\n */\ntype MultithreadingRuntime = {\n  initRuntime(config: { maxWorkers: number }): void\n  shutdown(): void\n  move<Args extends unknown[]>(...args: Args): unknown\n  spawn<R>(\n    payload: unknown,\n    fn: (...args: unknown[]) => R | Promise<R>,\n  ): {\n    join(): Promise<{ ok: boolean; value?: R; error?: Error }>\n    abort(): void\n  }\n}\n\ntype WorkerLike = (...args: unknown[]) => unknown\ntype WorkerEntrypoint = (...args: unknown[]) => Promise<unknown>\n\ntype InternalCancelController = {\n  readonly signal: MultithreadSignal\n  isCancelled(): boolean\n  cancel(): void\n  onCancel(listener: () => void): void\n}\n\nconst CANCELLED_ERROR_MESSAGE = \"@nicolastoulemont/std/multithread/cancelled\"\n\nlet runtimeConfig: { maxWorkers: number } | undefined\nlet runtimeInitialized = false\nlet runtimeImportPromise: Promise<MultithreadingRuntime> | undefined\n\nconst workerEntrypointCache = new WeakMap<object, WorkerEntrypoint>()\n\nconst makeRuntimeUnavailableError = (\n  cause?: unknown,\n  message = 'Optional peer dependency \"multithreading\" is unavailable. Install it to use Multithread APIs.',\n): MultithreadRuntimeUnavailableError => ({\n  _tag: \"MultithreadRuntimeUnavailableError\",\n  message,\n  cause,\n})\n\nconst makeRuntimeAlreadyInitializedError = (\n  message = \"Multithread runtime is already initialized and can no longer be configured.\",\n): MultithreadRuntimeAlreadyInitializedError => ({\n  _tag: \"MultithreadRuntimeAlreadyInitializedError\",\n  message,\n})\n\nconst makeWorkerExecutionError = (message: string, cause: unknown): MultithreadWorkerExecutionError => ({\n  _tag: \"MultithreadWorkerExecutionError\",\n  message,\n  cause,\n})\n\nconst makeCancelledError = (\n  message = \"Multithread operation was cancelled before completion.\",\n): MultithreadCancelledError => ({\n  _tag: \"MultithreadCancelledError\",\n  message,\n})\n\nconst makeAllFailedError = (message: string, errors: readonly unknown[]): MultithreadAllFailedError => ({\n  _tag: \"MultithreadAllFailedError\",\n  message,\n  errors,\n})\n\nconst getErrorMessage = (cause: unknown): string | undefined =>\n  cause instanceof Error ? cause.message : typeof cause === \"string\" ? cause : undefined\n\nconst isCancelledCause = (cause: unknown): boolean => {\n  const message = getErrorMessage(cause)\n  return message === CANCELLED_ERROR_MESSAGE || message === \"Task aborted\"\n}\n\nconst isCallerLocationFailure = (cause: unknown): boolean => {\n  const message = getErrorMessage(cause)\n  return typeof message === \"string\" && message.startsWith(\"Could not parse coordinates from:\")\n}\n\nconst isResultLike = (value: unknown): value is ResultType<unknown, unknown> => {\n  if (typeof value !== \"object\" || value === null || !(\"_tag\" in value)) return false\n  const tag = Reflect.get(value, \"_tag\")\n  if (tag === \"Ok\") return \"value\" in value\n  if (tag === \"Err\") return \"error\" in value\n  return false\n}\n\nconst resultOk = <A>(value: A): ResultType<A, never> => ok(value)\nconst resultErr = <E>(error: E): ResultType<never, E> => err(error)\n\nconst normalizeWorkerReturn = <A, E>(value: unknown): ResultType<A, E> => {\n  if (isResultLike(value)) {\n    // oxlint-disable-next-line typescript-eslint/no-unsafe-type-assertion -- isResultLike confirms runtime shape; generic channels are erased.\n    return value as ResultType<A, E>\n  }\n  // oxlint-disable-next-line typescript-eslint/no-unsafe-type-assertion -- Worker return value is user-defined and mapped to generic success type.\n  return resultOk(value as A)\n}\n\nconst runFromInputResult = (\n  input: unknown,\n  execute: (value: unknown) => MultithreadOp<unknown, unknown>,\n): MultithreadOp<unknown, unknown> | Promise<ResultType<unknown, unknown>> => {\n  if (!isResultLike(input)) {\n    return execute(input)\n  }\n\n  if (input._tag === \"Err\") {\n    return Promise.resolve(resultErr(input.error))\n  }\n\n  return execute(input.value).result()\n}\n\nconst normalizeParallelism = (parallelism: number | undefined, fallback: number): number => {\n  if (typeof parallelism !== \"number\" || !Number.isFinite(parallelism)) return fallback\n  const rounded = Math.floor(parallelism)\n  return rounded > 0 ? rounded : fallback\n}\n\nconst isWorkerLike = (value: unknown): value is WorkerLike => typeof value === \"function\"\n\nconst isParallelOptions = (value: unknown): value is MultithreadParallelOptions =>\n  typeof value === \"object\" && value !== null\n\nconst resolveParallelOptions = (value: unknown): MultithreadParallelOptions | undefined =>\n  isParallelOptions(value) ? value : undefined\n\nconst getDefaultParallelism = (): number => {\n  if (runtimeConfig !== undefined) {\n    return runtimeConfig.maxWorkers\n  }\n  if (typeof navigator !== \"undefined\" && typeof navigator.hardwareConcurrency === \"number\") {\n    return normalizeParallelism(navigator.hardwareConcurrency, 4)\n  }\n  return 4\n}\n\nconst createSharedSignal = (): MultithreadSignal => {\n  if (typeof SharedArrayBuffer !== \"function\") return null\n  return new Int32Array(new SharedArrayBuffer(Int32Array.BYTES_PER_ELEMENT))\n}\n\nconst createCancelController = (): InternalCancelController => {\n  const signal = createSharedSignal()\n  const listeners = new Set<() => void>()\n  let cancelled = false\n\n  const isCancelled = (): boolean => cancelled || (signal !== null && Atomics.load(signal, 0) === 1)\n\n  const cancel = (): void => {\n    if (cancelled) return\n    cancelled = true\n\n    if (signal !== null) {\n      Atomics.store(signal, 0, 1)\n      Atomics.notify(signal, 0)\n    }\n\n    const activeListeners = Array.from(listeners)\n    listeners.clear()\n\n    for (const listener of activeListeners) {\n      try {\n        listener()\n      } catch {\n        // Intentionally ignore listener disposal errors during cancellation fanout.\n      }\n    }\n  }\n\n  const onCancel = (listener: () => void): void => {\n    if (cancelled) {\n      listener()\n      return\n    }\n    listeners.add(listener)\n  }\n\n  return {\n    signal,\n    isCancelled,\n    cancel,\n    onCancel,\n  }\n}\n\nconst loadRuntimeModule = async (): Promise<ResultType<MultithreadingRuntime, MultithreadError>> => {\n  try {\n    runtimeImportPromise ??= import(\"multithreading\") as Promise<MultithreadingRuntime>\n    return resultOk(await runtimeImportPromise)\n  } catch (cause) {\n    return resultErr(makeRuntimeUnavailableError(cause))\n  }\n}\n\nconst getRuntime = async (): Promise<ResultType<MultithreadingRuntime, MultithreadError>> => {\n  const runtimeResult = await loadRuntimeModule()\n  if (runtimeResult._tag === \"Err\") return runtimeResult\n\n  const runtime = runtimeResult.value\n\n  if (!runtimeInitialized) {\n    try {\n      if (runtimeConfig !== undefined) {\n        runtime.initRuntime(runtimeConfig)\n      }\n      runtimeInitialized = true\n    } catch (cause) {\n      return resultErr(makeWorkerExecutionError(\"Failed to initialize multithreading runtime.\", cause))\n    }\n  }\n\n  return resultOk(runtime)\n}\n\nconst createWorkerEntrypoint = <Args extends readonly unknown[], A, E>(\n  worker: (...args: [...Args, MultithreadCtx]) => WorkerReturn<A, E>,\n): WorkerEntrypoint => {\n  const cached = workerEntrypointCache.get(worker)\n  if (cached !== undefined) {\n    return cached\n  }\n\n  const source = worker.toString()\n  // oxlint-disable-next-line typescript-eslint/no-implied-eval, typescript-eslint/no-unsafe-type-assertion -- Worker code must be reconstructed from serialized callback source and typed at runtime.\n  const factory = new Function(\n    `\nreturn async function (...__args) {\n  const __signal = __args.pop()\n  const __isCancelled = () => __signal !== null && Atomics.load(__signal, 0) === 1\n  const __throwIfCancelled = () => {\n    if (__isCancelled()) {\n      throw new Error(${JSON.stringify(CANCELLED_ERROR_MESSAGE)})\n    }\n  }\n  const __ctx = {\n    signal: __signal,\n    isCancelled: __isCancelled,\n    throwIfCancelled: __throwIfCancelled,\n  }\n  const __worker = (${source})\n  return await __worker(...__args, __ctx)\n}\n`,\n  ) as () => WorkerEntrypoint\n\n  const entrypoint = factory()\n  workerEntrypointCache.set(worker, entrypoint)\n  return entrypoint\n}\n\nconst createMultithreadOperation = <A, E>(\n  execute: (controller: InternalCancelController) => Promise<ResultType<A, E | MultithreadError>>,\n): MultithreadOp<A, E | MultithreadError> => {\n  const controller = createCancelController()\n  let runPromise: Promise<ResultType<A, E | MultithreadError>> | undefined\n\n  const start = (): Promise<ResultType<A, E | MultithreadError>> => {\n    if (runPromise !== undefined) return runPromise\n\n    if (controller.isCancelled()) {\n      runPromise = Promise.resolve(resultErr(makeCancelledError()))\n      return runPromise\n    }\n\n    runPromise = execute(controller)\n      .catch((cause: unknown) => resultErr(makeWorkerExecutionError(\"Multithread operation failed.\", cause)))\n      .then((result) => {\n        if (controller.isCancelled()) {\n          return resultErr(makeCancelledError())\n        }\n        return result\n      })\n\n    return runPromise\n  }\n\n  const then: PromiseLike<ResultType<A, E | MultithreadError>>[\"then\"] = (onfulfilled, onrejected) =>\n    start().then(onfulfilled, onrejected)\n\n  return {\n    _tag: \"MultithreadOp\",\n    [FxTypeId]: {\n      // oxlint-disable-next-line typescript-eslint/no-unsafe-type-assertion -- Fx marker channels are phantom-only type metadata.\n      _A: () => undefined as unknown as A,\n      // oxlint-disable-next-line typescript-eslint/no-unsafe-type-assertion -- Fx marker channels are phantom-only type metadata.\n      _E: () => undefined as unknown as E | MultithreadError,\n      // oxlint-disable-next-line typescript-eslint/no-unsafe-type-assertion -- Fx marker channels are phantom-only type metadata.\n      _R: () => undefined as never,\n    },\n    result: start,\n    abort: () => {\n      controller.cancel()\n    },\n    // oxlint-disable-next-line eslint-plugin-unicorn/no-thenable -- MultithreadOp is intentionally PromiseLike for `await op` ergonomics.\n    then,\n    async *[Symbol.asyncIterator](): AsyncGenerator<E | MultithreadError, A, unknown> {\n      const result = await start()\n      if (result._tag === \"Err\") {\n        yield result.error\n        throw new Error(\"Unreachable: Fx.gen should short-circuit on yielded Multithread errors\")\n      }\n      return result.value\n    },\n  }\n}\n\nconst runWorkerLocally = async <Args extends readonly unknown[], A, E>(\n  worker: (...args: [...Args, MultithreadCtx]) => WorkerReturn<A, E>,\n  args: Args,\n  controller: InternalCancelController,\n): Promise<ResultType<A, E | MultithreadError>> => {\n  if (controller.isCancelled()) {\n    return resultErr(makeCancelledError())\n  }\n\n  const ctx: MultithreadCtx = {\n    signal: controller.signal,\n    isCancelled: () => controller.isCancelled(),\n    throwIfCancelled: () => {\n      if (controller.isCancelled()) throw new Error(CANCELLED_ERROR_MESSAGE)\n    },\n  }\n\n  try {\n    const value = await worker(...args, ctx)\n\n    if (controller.isCancelled()) {\n      return resultErr(makeCancelledError())\n    }\n\n    const normalized = normalizeWorkerReturn<A, E>(value)\n    if (normalized._tag === \"Err\") {\n      return resultErr(normalized.error)\n    }\n\n    return resultOk(normalized.value)\n  } catch (cause) {\n    if (controller.isCancelled() || isCancelledCause(cause)) {\n      return resultErr(makeCancelledError())\n    }\n    return resultErr(makeWorkerExecutionError(\"Multithread worker failed during execution.\", cause))\n  }\n}\n\nconst runDataFirst = <Args extends readonly unknown[], A, E>(\n  worker: (...args: [...Args, MultithreadCtx]) => WorkerReturn<A, E>,\n  args: Args,\n): MultithreadOp<A, E | MultithreadError> =>\n  createMultithreadOperation(async (controller): Promise<ResultType<A, E | MultithreadError>> => {\n    if (controller.isCancelled()) {\n      return resultErr(makeCancelledError())\n    }\n\n    const runtimeResult = await getRuntime()\n    if (runtimeResult._tag === \"Err\") return resultErr(runtimeResult.error)\n\n    const runtime = runtimeResult.value\n    const entrypoint = createWorkerEntrypoint(worker)\n\n    let joinHandle: ReturnType<MultithreadingRuntime[\"spawn\"]> | undefined\n\n    try {\n      const movedPayload = runtime.move(...args, controller.signal)\n      joinHandle = runtime.spawn(movedPayload, entrypoint)\n      controller.onCancel(() => {\n        joinHandle?.abort()\n      })\n    } catch (cause) {\n      if (isCallerLocationFailure(cause)) {\n        return runWorkerLocally(worker, args, controller)\n      }\n      if (controller.isCancelled() || isCancelledCause(cause)) {\n        return resultErr(makeCancelledError())\n      }\n      return resultErr(makeWorkerExecutionError(\"Failed to start multithread worker.\", cause))\n    }\n\n    try {\n      const joined = await joinHandle.join()\n\n      if (controller.isCancelled()) {\n        return resultErr(makeCancelledError())\n      }\n\n      if (!joined.ok) {\n        const joinError = joined.error ?? new Error(\"Multithread worker returned an unknown error.\")\n        if (isCancelledCause(joinError)) {\n          return resultErr(makeCancelledError())\n        }\n        return resultErr(makeWorkerExecutionError(\"Multithread worker failed during execution.\", joinError))\n      }\n\n      const normalized = normalizeWorkerReturn<A, E>(joined.value)\n      if (normalized._tag === \"Err\") {\n        return resultErr(normalized.error)\n      }\n      return resultOk(normalized.value)\n    } catch (cause) {\n      if (controller.isCancelled() || isCancelledCause(cause)) {\n        return resultErr(makeCancelledError())\n      }\n      return resultErr(makeWorkerExecutionError(\"Failed to join multithread worker.\", cause))\n    }\n  })\n\nfunction runOverload<A, E = never>(\n  worker: (ctx: MultithreadCtx) => WorkerReturn<A, E>,\n): MultithreadOp<A, E | MultithreadError>\nfunction runOverload<Args extends readonly unknown[], A, E = never>(\n  worker: (...args: [...Args, MultithreadCtx]) => WorkerReturn<A, E>,\n  ...args: Args\n): MultithreadOp<A, E | MultithreadError>\nfunction runOverload(worker: unknown, ...args: unknown[]): MultithreadOp<unknown, unknown> {\n  if (!isWorkerLike(worker)) {\n    throw new TypeError(\"Multithread.run expects a worker function as first argument.\")\n  }\n  return runDataFirst(worker, args)\n}\n\n/**\n * Execute one worker task as a cancelable `MultithreadOp`.\n *\n * @example\n * ```ts\n * import { Multithread } from \"@nicolastoulemont/std\"\n *\n * const op = Multithread.run((ctx) => (ctx.isCancelled() ? 0 : 42))\n * // => cancelable operation with result() and abort()\n * ```\n */\nexport const run: MultithreadRun = runOverload\n\nfunction taskOverload<A, E = never>(\n  worker: (ctx: MultithreadCtx) => WorkerReturn<A, E>,\n): () => MultithreadOp<A, E | MultithreadError>\nfunction taskOverload<Args extends readonly unknown[], A, E = never>(\n  worker: (...args: [...Args, MultithreadCtx]) => WorkerReturn<A, E>,\n): (...args: Args) => MultithreadOp<A, E | MultithreadError>\nfunction taskOverload(worker: unknown): (...args: unknown[]) => MultithreadOp<unknown, unknown> {\n  if (!isWorkerLike(worker)) {\n    throw new TypeError(\"Multithread.task expects a worker function.\")\n  }\n  return (...args: unknown[]) => runDataFirst(worker, args)\n}\n\n/**\n * Create a reusable worker task factory.\n *\n * @example\n * ```ts\n * import { Multithread } from \"@nicolastoulemont/std\"\n *\n * const create = Multithread.task((ctx) => (ctx.isCancelled() ? 0 : 16))\n * const op = create()\n * // => operation that resolves to 16 when executed\n * ```\n */\nexport const task: MultithreadTask = taskOverload\n\nconst executeInParallel = <A, B, E>(\n  values: readonly A[],\n  createItemOperation: (value: A, index: number) => MultithreadOp<B, E | MultithreadError>,\n  parallelism: number,\n  controller: InternalCancelController,\n): Promise<ResultType<readonly B[], E | MultithreadError>> => {\n  if (values.length === 0) {\n    return Promise.resolve(resultOk<readonly B[]>([]))\n  }\n\n  return new Promise<ResultType<readonly B[], E | MultithreadError>>((resolve) => {\n    const operations = new Map<number, MultithreadOp<B, E | MultithreadError>>()\n    const output: B[] = []\n\n    let inFlight = 0\n    let nextIndex = 0\n    let completed = 0\n    let settled = false\n\n    const abortAll = (): void => {\n      for (const operation of operations.values()) {\n        operation.abort()\n      }\n      operations.clear()\n    }\n\n    const settle = (result: ResultType<readonly B[], E | MultithreadError>): void => {\n      if (settled) return\n      settled = true\n      abortAll()\n      resolve(result)\n    }\n\n    controller.onCancel(() => {\n      settle(resultErr(makeCancelledError()))\n    })\n\n    const handleOperation = (index: number, operation: MultithreadOp<B, E | MultithreadError>): void => {\n      void (async () => {\n        try {\n          const result = await operation.result()\n\n          inFlight -= 1\n          operations.delete(index)\n\n          if (settled) return\n\n          if (result._tag === \"Err\") {\n            settle(resultErr(result.error))\n            return\n          }\n\n          output[index] = result.value\n          completed += 1\n\n          if (completed === values.length) {\n            settled = true\n            resolve(resultOk(output))\n            return\n          }\n\n          launch()\n        } catch (cause) {\n          inFlight -= 1\n          operations.delete(index)\n\n          if (settled) return\n\n          if (controller.isCancelled() || isCancelledCause(cause)) {\n            settle(resultErr(makeCancelledError()))\n            return\n          }\n\n          settle(resultErr(makeWorkerExecutionError(\"Failed while executing multithread batch.\", cause)))\n        }\n      })()\n    }\n\n    const launch = (): void => {\n      while (!settled && inFlight < parallelism && nextIndex < values.length) {\n        const index = nextIndex\n        nextIndex += 1\n\n        const operation = createItemOperation(values[index]!, index)\n        operations.set(index, operation)\n        inFlight += 1\n\n        handleOperation(index, operation)\n      }\n    }\n\n    launch()\n  })\n}\n\nconst mapDataFirst = <A, B, E>(\n  values: readonly A[],\n  worker: MultithreadMapWorker<A, B, E>,\n  options?: MultithreadParallelOptions,\n): MultithreadOp<readonly B[], E | MultithreadError> =>\n  createMultithreadOperation((controller) => {\n    const parallelism = normalizeParallelism(options?.parallelism, getDefaultParallelism())\n    return executeInParallel(values, (value, index) => runDataFirst(worker, [value, index]), parallelism, controller)\n  })\n\nfunction mapOverload<A, B, E = never>(\n  values: readonly A[],\n  worker: MultithreadMapWorker<A, B, E>,\n  options?: MultithreadParallelOptions,\n): MultithreadOp<readonly B[], E | MultithreadError>\nfunction mapOverload<A, B, E = never, InputE = never>(\n  values: ResultType<readonly A[], InputE>,\n  worker: MultithreadMapWorker<A, B, E>,\n  options?: MultithreadParallelOptions,\n): Promise<ResultType<readonly B[], E | InputE | MultithreadError>>\nfunction mapOverload<A, B, E = never>(\n  worker: MultithreadMapWorker<A, B, E>,\n  options?: MultithreadParallelOptions,\n): <Input extends readonly A[] | ResultType<readonly A[], unknown>>(\n  values: Input,\n) => Input extends ResultType<readonly A[], infer ResultInputE>\n  ? Promise<ResultType<readonly B[], E | ResultInputE | MultithreadError>>\n  : MultithreadOp<readonly B[], E | MultithreadError>\nfunction mapOverload<A, B, E = never, InputE = never>(\n  valuesOrWorker: readonly A[] | ResultType<readonly A[], InputE> | MultithreadMapWorker<A, B, E>,\n  workerOrOptions?: MultithreadMapWorker<A, B, E> | MultithreadParallelOptions,\n  options?: MultithreadParallelOptions,\n):\n  | MultithreadOp<readonly B[], E | MultithreadError>\n  | Promise<ResultType<readonly B[], E | InputE | MultithreadError>>\n  | (<Input extends readonly A[] | ResultType<readonly A[], unknown>>(\n      values: Input,\n    ) => Input extends ResultType<readonly A[], infer ResultInputE>\n      ? Promise<ResultType<readonly B[], E | ResultInputE | MultithreadError>>\n      : MultithreadOp<readonly B[], E | MultithreadError>) {\n  if (typeof valuesOrWorker === \"function\") {\n    const curriedOptions = resolveParallelOptions(workerOrOptions)\n    return ((values: readonly A[] | ResultType<readonly A[], unknown>) =>\n      runFromInputResult(values, (resolvedValues) =>\n        mapDataFirst(resolvedValues as readonly A[], valuesOrWorker, curriedOptions),\n      )) as <Input extends readonly A[] | ResultType<readonly A[], unknown>>(\n      values: Input,\n    ) => Input extends ResultType<readonly A[], infer ResultInputE>\n      ? Promise<ResultType<readonly B[], E | ResultInputE | MultithreadError>>\n      : MultithreadOp<readonly B[], E | MultithreadError>\n  }\n\n  if (typeof workerOrOptions !== \"function\") {\n    throw new TypeError(\"Multithread.map(values, worker, options) requires a worker function.\")\n  }\n\n  return runFromInputResult(valuesOrWorker, (resolvedValues) =>\n    mapDataFirst(resolvedValues as readonly A[], workerOrOptions, options),\n  ) as\n    | MultithreadOp<readonly B[], E | MultithreadError>\n    | Promise<ResultType<readonly B[], E | InputE | MultithreadError>>\n}\n\n/**\n * Map a collection in parallel.\n *\n * @example\n * ```ts\n * import { Multithread } from \"@nicolastoulemont/std\"\n *\n * const op = Multithread.map([1, 2, 3], (value) => value * 2)\n * // => operation that resolves to [2, 4, 6]\n * ```\n */\nexport const map: MultithreadMap = mapOverload\n\nconst forEachDataFirst = <A, E>(\n  values: readonly A[],\n  worker: MultithreadMapWorker<A, unknown, E>,\n  options?: MultithreadParallelOptions,\n): MultithreadOp<void, E | MultithreadError> =>\n  createMultithreadOperation(async (controller): Promise<ResultType<void, E | MultithreadError>> => {\n    const mapped = await executeInParallel(\n      values,\n      (value, index) => runDataFirst(worker, [value, index]),\n      normalizeParallelism(options?.parallelism, getDefaultParallelism()),\n      controller,\n    )\n\n    if (mapped._tag === \"Err\") return resultErr(mapped.error)\n    return resultOk(undefined)\n  })\n\nfunction forEachOverload<A, E = never>(\n  values: readonly A[],\n  worker: MultithreadMapWorker<A, unknown, E>,\n  options?: MultithreadParallelOptions,\n): MultithreadOp<void, E | MultithreadError>\nfunction forEachOverload<A, E = never, InputE = never>(\n  values: ResultType<readonly A[], InputE>,\n  worker: MultithreadMapWorker<A, unknown, E>,\n  options?: MultithreadParallelOptions,\n): Promise<ResultType<void, E | InputE | MultithreadError>>\nfunction forEachOverload<A, E = never>(\n  worker: MultithreadMapWorker<A, unknown, E>,\n  options?: MultithreadParallelOptions,\n): <Input extends readonly A[] | ResultType<readonly A[], unknown>>(\n  values: Input,\n) => Input extends ResultType<readonly A[], infer ResultInputE>\n  ? Promise<ResultType<void, E | ResultInputE | MultithreadError>>\n  : MultithreadOp<void, E | MultithreadError>\nfunction forEachOverload<A, E = never, InputE = never>(\n  valuesOrWorker: readonly A[] | ResultType<readonly A[], InputE> | MultithreadMapWorker<A, unknown, E>,\n  workerOrOptions?: MultithreadMapWorker<A, unknown, E> | MultithreadParallelOptions,\n  options?: MultithreadParallelOptions,\n):\n  | MultithreadOp<void, E | MultithreadError>\n  | Promise<ResultType<void, E | InputE | MultithreadError>>\n  | (<Input extends readonly A[] | ResultType<readonly A[], unknown>>(\n      values: Input,\n    ) => Input extends ResultType<readonly A[], infer ResultInputE>\n      ? Promise<ResultType<void, E | ResultInputE | MultithreadError>>\n      : MultithreadOp<void, E | MultithreadError>) {\n  if (typeof valuesOrWorker === \"function\") {\n    const curriedOptions = resolveParallelOptions(workerOrOptions)\n    return ((values: readonly A[] | ResultType<readonly A[], unknown>) =>\n      runFromInputResult(values, (resolvedValues) =>\n        forEachDataFirst(resolvedValues as readonly A[], valuesOrWorker, curriedOptions),\n      )) as <Input extends readonly A[] | ResultType<readonly A[], unknown>>(\n      values: Input,\n    ) => Input extends ResultType<readonly A[], infer ResultInputE>\n      ? Promise<ResultType<void, E | ResultInputE | MultithreadError>>\n      : MultithreadOp<void, E | MultithreadError>\n  }\n\n  if (typeof workerOrOptions !== \"function\") {\n    throw new TypeError(\"Multithread.forEach(values, worker, options) requires a worker function.\")\n  }\n\n  return runFromInputResult(valuesOrWorker, (resolvedValues) =>\n    forEachDataFirst(resolvedValues as readonly A[], workerOrOptions, options),\n  ) as MultithreadOp<void, E | MultithreadError> | Promise<ResultType<void, E | InputE | MultithreadError>>\n}\n\n/**\n * Run side-effecting parallel work for each item.\n *\n * @example\n * ```ts\n * import { Multithread } from \"@nicolastoulemont/std\"\n *\n * const op = Multithread.forEach([\"a\", \"b\"], (value) => value.toUpperCase())\n * // => operation that resolves to void after all items complete\n * ```\n */\nexport const forEach: MultithreadForEach = forEachOverload\n\nconst filterDataFirst = <A, E>(\n  values: readonly A[],\n  worker: MultithreadFilterWorker<A, E>,\n  options?: MultithreadParallelOptions,\n): MultithreadOp<readonly A[], E | MultithreadError> =>\n  createMultithreadOperation(async (controller): Promise<ResultType<readonly A[], E | MultithreadError>> => {\n    const decisions = await executeInParallel(\n      values,\n      (value, index) => runDataFirst(worker, [value, index]),\n      normalizeParallelism(options?.parallelism, getDefaultParallelism()),\n      controller,\n    )\n\n    if (decisions._tag === \"Err\") return resultErr(decisions.error)\n\n    const filtered: A[] = []\n    for (let index = 0; index < values.length; index += 1) {\n      if (decisions.value[index] === true) {\n        filtered.push(values[index]!)\n      }\n    }\n\n    return resultOk(filtered)\n  })\n\nfunction filterOverload<A, E = never>(\n  values: readonly A[],\n  worker: MultithreadFilterWorker<A, E>,\n  options?: MultithreadParallelOptions,\n): MultithreadOp<readonly A[], E | MultithreadError>\nfunction filterOverload<A, E = never, InputE = never>(\n  values: ResultType<readonly A[], InputE>,\n  worker: MultithreadFilterWorker<A, E>,\n  options?: MultithreadParallelOptions,\n): Promise<ResultType<readonly A[], E | InputE | MultithreadError>>\nfunction filterOverload<A, E = never>(\n  worker: MultithreadFilterWorker<A, E>,\n  options?: MultithreadParallelOptions,\n): <Input extends readonly A[] | ResultType<readonly A[], unknown>>(\n  values: Input,\n) => Input extends ResultType<readonly A[], infer ResultInputE>\n  ? Promise<ResultType<readonly A[], E | ResultInputE | MultithreadError>>\n  : MultithreadOp<readonly A[], E | MultithreadError>\nfunction filterOverload<A, E = never, InputE = never>(\n  valuesOrWorker: readonly A[] | ResultType<readonly A[], InputE> | MultithreadFilterWorker<A, E>,\n  workerOrOptions?: MultithreadFilterWorker<A, E> | MultithreadParallelOptions,\n  options?: MultithreadParallelOptions,\n):\n  | MultithreadOp<readonly A[], E | MultithreadError>\n  | Promise<ResultType<readonly A[], E | InputE | MultithreadError>>\n  | (<Input extends readonly A[] | ResultType<readonly A[], unknown>>(\n      values: Input,\n    ) => Input extends ResultType<readonly A[], infer ResultInputE>\n      ? Promise<ResultType<readonly A[], E | ResultInputE | MultithreadError>>\n      : MultithreadOp<readonly A[], E | MultithreadError>) {\n  if (typeof valuesOrWorker === \"function\") {\n    const curriedOptions = resolveParallelOptions(workerOrOptions)\n    return ((values: readonly A[] | ResultType<readonly A[], unknown>) =>\n      runFromInputResult(values, (resolvedValues) =>\n        filterDataFirst(resolvedValues as readonly A[], valuesOrWorker, curriedOptions),\n      )) as <Input extends readonly A[] | ResultType<readonly A[], unknown>>(\n      values: Input,\n    ) => Input extends ResultType<readonly A[], infer ResultInputE>\n      ? Promise<ResultType<readonly A[], E | ResultInputE | MultithreadError>>\n      : MultithreadOp<readonly A[], E | MultithreadError>\n  }\n\n  if (typeof workerOrOptions !== \"function\") {\n    throw new TypeError(\"Multithread.filter(values, worker, options) requires a worker function.\")\n  }\n\n  return runFromInputResult(valuesOrWorker, (resolvedValues) =>\n    filterDataFirst(resolvedValues as readonly A[], workerOrOptions, options),\n  ) as\n    | MultithreadOp<readonly A[], E | MultithreadError>\n    | Promise<ResultType<readonly A[], E | InputE | MultithreadError>>\n}\n\n/**\n * Filter a collection in parallel.\n *\n * @example\n * ```ts\n * import { Multithread } from \"@nicolastoulemont/std\"\n *\n * const op = Multithread.filter([1, 2, 3, 4], (value) => value % 2 === 0)\n * // => operation that resolves to [2, 4]\n * ```\n */\nexport const filter: MultithreadFilter = filterOverload\n\nconst flatMapDataFirst = <A, B, E>(\n  values: readonly A[],\n  worker: MultithreadFlatMapWorker<A, B, E>,\n  options?: MultithreadParallelOptions,\n): MultithreadOp<readonly B[], E | MultithreadError> =>\n  createMultithreadOperation(async (controller): Promise<ResultType<readonly B[], E | MultithreadError>> => {\n    const chunks = await executeInParallel(\n      values,\n      (value, index) => runDataFirst(worker, [value, index]),\n      normalizeParallelism(options?.parallelism, getDefaultParallelism()),\n      controller,\n    )\n\n    if (chunks._tag === \"Err\") return resultErr(chunks.error)\n\n    const flattened: B[] = []\n    for (const chunk of chunks.value) {\n      flattened.push(...chunk)\n    }\n\n    return resultOk(flattened)\n  })\n\nfunction flatMapOverload<A, B, E = never>(\n  values: readonly A[],\n  worker: MultithreadFlatMapWorker<A, B, E>,\n  options?: MultithreadParallelOptions,\n): MultithreadOp<readonly B[], E | MultithreadError>\nfunction flatMapOverload<A, B, E = never, InputE = never>(\n  values: ResultType<readonly A[], InputE>,\n  worker: MultithreadFlatMapWorker<A, B, E>,\n  options?: MultithreadParallelOptions,\n): Promise<ResultType<readonly B[], E | InputE | MultithreadError>>\nfunction flatMapOverload<A, B, E = never>(\n  worker: MultithreadFlatMapWorker<A, B, E>,\n  options?: MultithreadParallelOptions,\n): <Input extends readonly A[] | ResultType<readonly A[], unknown>>(\n  values: Input,\n) => Input extends ResultType<readonly A[], infer ResultInputE>\n  ? Promise<ResultType<readonly B[], E | ResultInputE | MultithreadError>>\n  : MultithreadOp<readonly B[], E | MultithreadError>\nfunction flatMapOverload<A, B, E = never, InputE = never>(\n  valuesOrWorker: readonly A[] | ResultType<readonly A[], InputE> | MultithreadFlatMapWorker<A, B, E>,\n  workerOrOptions?: MultithreadFlatMapWorker<A, B, E> | MultithreadParallelOptions,\n  options?: MultithreadParallelOptions,\n):\n  | MultithreadOp<readonly B[], E | MultithreadError>\n  | Promise<ResultType<readonly B[], E | InputE | MultithreadError>>\n  | (<Input extends readonly A[] | ResultType<readonly A[], unknown>>(\n      values: Input,\n    ) => Input extends ResultType<readonly A[], infer ResultInputE>\n      ? Promise<ResultType<readonly B[], E | ResultInputE | MultithreadError>>\n      : MultithreadOp<readonly B[], E | MultithreadError>) {\n  if (typeof valuesOrWorker === \"function\") {\n    const curriedOptions = resolveParallelOptions(workerOrOptions)\n    return ((values: readonly A[] | ResultType<readonly A[], unknown>) =>\n      runFromInputResult(values, (resolvedValues) =>\n        flatMapDataFirst(resolvedValues as readonly A[], valuesOrWorker, curriedOptions),\n      )) as <Input extends readonly A[] | ResultType<readonly A[], unknown>>(\n      values: Input,\n    ) => Input extends ResultType<readonly A[], infer ResultInputE>\n      ? Promise<ResultType<readonly B[], E | ResultInputE | MultithreadError>>\n      : MultithreadOp<readonly B[], E | MultithreadError>\n  }\n\n  if (typeof workerOrOptions !== \"function\") {\n    throw new TypeError(\"Multithread.flatMap(values, worker, options) requires a worker function.\")\n  }\n\n  return runFromInputResult(valuesOrWorker, (resolvedValues) =>\n    flatMapDataFirst(resolvedValues as readonly A[], workerOrOptions, options),\n  ) as\n    | MultithreadOp<readonly B[], E | MultithreadError>\n    | Promise<ResultType<readonly B[], E | InputE | MultithreadError>>\n}\n\n/**\n * Flat-map a collection in parallel.\n *\n * @example\n * ```ts\n * import { Multithread } from \"@nicolastoulemont/std\"\n *\n * const op = Multithread.flatMap([1, 2], (value) => [value, value * 10])\n * // => operation that resolves to [1, 10, 2, 20]\n * ```\n */\nexport const flatMap: MultithreadFlatMap = flatMapOverload\n\nconst raceDataFirst = <A, E>(operations: readonly MultithreadOp<A, E>[]): MultithreadOp<A, E | MultithreadError> =>\n  createMultithreadOperation((controller): Promise<ResultType<A, E | MultithreadError>> => {\n    if (operations.length === 0) {\n      return Promise.resolve(resultErr(makeAllFailedError(\"Cannot race an empty list of operations.\", [])))\n    }\n\n    return new Promise<ResultType<A, E | MultithreadError>>((resolve) => {\n      let settled = false\n\n      const abortAll = (): void => {\n        for (const operation of operations) {\n          operation.abort()\n        }\n      }\n\n      const settle = (result: ResultType<A, E | MultithreadError>): void => {\n        if (settled) return\n        settled = true\n        abortAll()\n        resolve(result)\n      }\n\n      controller.onCancel(() => {\n        settle(resultErr(makeCancelledError()))\n      })\n\n      const watchOperation = (operation: MultithreadOp<A, E>): void => {\n        void (async () => {\n          try {\n            const result = await operation.result()\n            settle(result)\n          } catch (cause) {\n            if (controller.isCancelled() || isCancelledCause(cause)) {\n              settle(resultErr(makeCancelledError()))\n              return\n            }\n\n            settle(resultErr(makeWorkerExecutionError(\"Multithread race failed.\", cause)))\n          }\n        })()\n      }\n\n      for (const operation of operations) {\n        watchOperation(operation)\n      }\n    })\n  })\n\nfunction raceOverload<A, E>(operations: readonly MultithreadOp<A, E>[]): MultithreadOp<A, E | MultithreadError>\nfunction raceOverload<A, E, InputE = never>(\n  operations: ResultType<readonly MultithreadOp<A, E>[], InputE>,\n): Promise<ResultType<A, E | InputE | MultithreadError>>\nfunction raceOverload<Ops extends readonly MultithreadOp<unknown, unknown>[]>(\n  operations: Ops,\n): MultithreadOp<\n  Ops[number] extends MultithreadOp<infer A, unknown> ? A : never,\n  (Ops[number] extends MultithreadOp<unknown, infer OpE> ? OpE : never) | MultithreadError\n>\nfunction raceOverload<Ops extends readonly MultithreadOp<unknown, unknown>[], InputE = never>(\n  operations: ResultType<Ops, InputE>,\n): Promise<\n  ResultType<\n    Ops[number] extends MultithreadOp<infer A, unknown> ? A : never,\n    (Ops[number] extends MultithreadOp<unknown, infer OpE> ? OpE : never) | InputE | MultithreadError\n  >\n>\nfunction raceOverload(\n  operations:\n    | readonly MultithreadOp<unknown, unknown>[]\n    | ResultType<readonly MultithreadOp<unknown, unknown>[], unknown>,\n): MultithreadOp<unknown, unknown> | Promise<ResultType<unknown, unknown>> {\n  return runFromInputResult(operations, (resolvedOperations) =>\n    raceDataFirst(resolvedOperations as readonly MultithreadOp<unknown, unknown>[]),\n  )\n}\n\n/**\n * Resolve with the first successfully completed operation.\n *\n * @example\n * ```ts\n * import { Multithread } from \"@nicolastoulemont/std\"\n *\n * const fast = Multithread.run(() => 1)\n * const slow = Multithread.run(() => 2)\n * const op = Multithread.race([fast, slow])\n * // => operation that resolves with the first finished result\n * ```\n */\nexport const race: MultithreadRace = raceOverload\n\nconst firstSuccessDataFirst = <A, E>(\n  operations: readonly MultithreadOp<A, E>[],\n): MultithreadOp<A, E | MultithreadError> =>\n  createMultithreadOperation((controller): Promise<ResultType<A, E | MultithreadError>> => {\n    if (operations.length === 0) {\n      return Promise.resolve(\n        resultErr(makeAllFailedError(\"Cannot select a first success from an empty list of operations.\", [])),\n      )\n    }\n\n    return new Promise<ResultType<A, E | MultithreadError>>((resolve) => {\n      const failures: unknown[] = Array.from({ length: operations.length })\n      let pending = operations.length\n      let settled = false\n\n      const abortAll = (): void => {\n        for (const operation of operations) {\n          operation.abort()\n        }\n      }\n\n      const settle = (result: ResultType<A, E | MultithreadError>): void => {\n        if (settled) return\n        settled = true\n        abortAll()\n        resolve(result)\n      }\n\n      controller.onCancel(() => {\n        settle(resultErr(makeCancelledError()))\n      })\n\n      const watchOperation = (operation: MultithreadOp<A, E>, index: number): void => {\n        void (async () => {\n          try {\n            const result = await operation.result()\n\n            if (settled) return\n\n            if (result._tag === \"Ok\") {\n              settle(resultOk(result.value))\n              return\n            }\n\n            failures[index] = result.error\n            pending -= 1\n\n            if (pending === 0) {\n              settle(\n                resultErr(\n                  makeAllFailedError(\n                    \"All multithread operations failed before any success was produced.\",\n                    failures.filter((failure) => failure !== undefined),\n                  ),\n                ),\n              )\n            }\n          } catch (cause) {\n            if (settled) return\n\n            if (controller.isCancelled() || isCancelledCause(cause)) {\n              settle(resultErr(makeCancelledError()))\n              return\n            }\n\n            failures[index] = makeWorkerExecutionError(\"Multithread operation rejected unexpectedly.\", cause)\n            pending -= 1\n\n            if (pending === 0) {\n              settle(\n                resultErr(\n                  makeAllFailedError(\n                    \"All multithread operations failed before any success was produced.\",\n                    failures.filter((failure) => failure !== undefined),\n                  ),\n                ),\n              )\n            }\n          }\n        })()\n      }\n\n      operations.forEach((operation, index) => {\n        watchOperation(operation, index)\n      })\n    })\n  })\n\nfunction firstSuccessOverload<A, E>(operations: readonly MultithreadOp<A, E>[]): MultithreadOp<A, E | MultithreadError>\nfunction firstSuccessOverload<A, E, InputE = never>(\n  operations: ResultType<readonly MultithreadOp<A, E>[], InputE>,\n): Promise<ResultType<A, E | InputE | MultithreadError>>\nfunction firstSuccessOverload<Ops extends readonly MultithreadOp<unknown, unknown>[]>(\n  operations: Ops,\n): MultithreadOp<\n  Ops[number] extends MultithreadOp<infer A, unknown> ? A : never,\n  (Ops[number] extends MultithreadOp<unknown, infer OpE> ? OpE : never) | MultithreadError\n>\nfunction firstSuccessOverload<Ops extends readonly MultithreadOp<unknown, unknown>[], InputE = never>(\n  operations: ResultType<Ops, InputE>,\n): Promise<\n  ResultType<\n    Ops[number] extends MultithreadOp<infer A, unknown> ? A : never,\n    (Ops[number] extends MultithreadOp<unknown, infer OpE> ? OpE : never) | InputE | MultithreadError\n  >\n>\nfunction firstSuccessOverload(\n  operations:\n    | readonly MultithreadOp<unknown, unknown>[]\n    | ResultType<readonly MultithreadOp<unknown, unknown>[], unknown>,\n): MultithreadOp<unknown, unknown> | Promise<ResultType<unknown, unknown>> {\n  return runFromInputResult(operations, (resolvedOperations) =>\n    firstSuccessDataFirst(resolvedOperations as readonly MultithreadOp<unknown, unknown>[]),\n  )\n}\n\n/**\n * Return the first successful operation, aggregating failures if none succeed.\n *\n * @example\n * ```ts\n * import { Multithread } from \"@nicolastoulemont/std\"\n *\n * import { Result } from \"@nicolastoulemont/std\"\n *\n * const fail = Multithread.run(() => Result.err(\"boom\"))\n * const pass = Multithread.run(() => Result.ok(1))\n * const op = Multithread.firstSuccess([fail, pass])\n * // => operation that resolves with 1\n * ```\n */\nexport const firstSuccess: MultithreadFirstSuccess = firstSuccessOverload\n\n/**\n * Configure max worker count used by the underlying runtime.\n *\n * Must be called before first multithread operation starts.\n *\n * @example\n * ```ts\n * import { Multithread } from \"@nicolastoulemont/std\"\n *\n * const configured = Multithread.configure({ maxWorkers: 4 })\n * // => { _tag: \"Ok\", value: undefined }\n * ```\n */\nexport const configure = (config: { maxWorkers: number }): ResultType<void, MultithreadError> => {\n  if (runtimeInitialized) {\n    return resultErr(makeRuntimeAlreadyInitializedError())\n  }\n\n  runtimeConfig = {\n    maxWorkers: normalizeParallelism(config.maxWorkers, 1),\n  }\n\n  return resultOk(undefined)\n}\n\n/**\n * Shutdown worker runtime.\n *\n * This function is idempotent.\n *\n * @example\n * ```ts\n * import { Multithread } from \"@nicolastoulemont/std\"\n *\n * const shutdownPromise = Multithread.shutdown()\n * // => Promise<Result<void, MultithreadError>>\n * ```\n */\nexport const shutdown = async (): Promise<ResultType<void, MultithreadError>> => {\n  if (!runtimeInitialized) {\n    return resultOk(undefined)\n  }\n\n  const runtimeResult = await loadRuntimeModule()\n  if (runtimeResult._tag === \"Err\") {\n    runtimeInitialized = false\n    return resultErr(runtimeResult.error)\n  }\n\n  try {\n    runtimeResult.value.shutdown()\n    return resultOk(undefined)\n  } catch (cause) {\n    return resultErr(makeWorkerExecutionError(\"Failed to shutdown multithreading runtime.\", cause))\n  } finally {\n    runtimeInitialized = false\n  }\n}\n"],"mappings":"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"}

package/dist/pipeable-Dp1_23zH.mjs

@@ -1,2 +0,0 @@
-import{t as e}from"./flow-CNyLsPGb.mjs";function t(...t){return t.length===0?this:e(...t)(this)}export{t};
-//# sourceMappingURL=pipeable-Dp1_23zH.mjs.map

package/dist/provide-CuccogWx.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{n as s}from"./layer-C5A-EM0h.mjs";import{t as c}from"./scope-gVt4PESc.mjs";var l=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}},u=e({context:()=>p,layer:()=>d,layers:()=>f,service:()=>m});function d(e){return i=>{let s=e.build(new l,c())._tag,u=()=>{let t=new l,n=c();return{scope:n,layerBuildFx:e.build(t,n)}};return s===`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)))}}}}}function f(...e){return d(s(...e))}const p=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}},m=(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{u as t};
-//# sourceMappingURL=provide-CuccogWx.mjs.map

package/dist/provide-CuccogWx.mjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"provide-CuccogWx.mjs","names":["layer","service","layer","makeScope","fxGen","fxResult","service","layers","mergeLayers"],"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 { merge as mergeLayers } from \"../layer/layer\"\nimport type { AllSync, Layer as LayerType, MergeError, MergeROut, UnprovidedDeps } 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\ntype LayerList = [LayerType<unknown, unknown, unknown>, ...LayerType<unknown, unknown, unknown>[]]\ntype CompleteLayers<L extends LayerList> = UnprovidedDeps<L> extends never ? L : never\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: LayerType<ROut, E2, never, LayerSync>,\n): <Fx extends RunnableFx<unknown, unknown, ROut>>(fx: Fx) => ProvideResult<E2, LayerSync, Fx>\nexport function layer<ROut, E2>(layer: LayerType<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 multiple layers to an Fx computation.\n * Equivalent to `Provide.layer(Layer.merge(...layers))`, but keeps the call site flatter.\n *\n * @param layers - Layers whose combined external requirements are fully satisfied\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, pipe } from \"@nicolastoulemont/std\"\n *\n * const Document = Service.tag<{ readonly getById: (id: string) => string }>(\"Document\")\n * const Team = Service.tag<{ readonly canRead: (id: string) => boolean }>(\"Team\")\n *\n * const program = Fx.gen(function* () {\n *   const document = yield* Document\n *   const team = yield* Team\n *   return team.canRead(\"doc-1\") ? document.getById(\"doc-1\") : \"forbidden\"\n * })\n *\n * const exit = Fx.run(\n *   pipe(\n *     program,\n *     Provide.layers(\n *       Layer.ok(Document, { getById: (id) => id }),\n *       Layer.ok(Team, { canRead: () => true }),\n *     ),\n *   ),\n * )\n * // => { _tag: \"Ok\", value: \"doc-1\" }\n * ```\n */\nexport function layers<L extends LayerList>(\n  ...layers: CompleteLayers<L>\n): <Fx extends RunnableFx<unknown, unknown, MergeROut<L>>>(fx: Fx) => ProvideResult<MergeError<L>, AllSync<L>, Fx>\nexport function layers(...layers: LayerList) {\n  return layer(mergeLayers(...layers))\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":"8TAmCA,IAAa,EAAb,KAAqB,CACnB,MAAgB,IAAI,IAiBpB,WACE,EACA,EACA,EAC8B,CAC9B,IAAM,EAAS,KAAK,MAAM,IAAIA,EAAkB,CAGhD,GAAI,GAAQ,QACV,MAAO,CACL,KAAM,UACL,GAAW,CACV,OAAU,EAAO,QACjB,OAAU,IAAA,GACV,OAAU,IAAA,GACX,CACD,QAAW,EAAG,EAAO,QAAyB,CAE9C,EAAE,OAAO,WAAkE,CACzE,OAAO,EAAO,SAEjB,CAIH,GAAI,GAAQ,QACV,MAAO,CACL,KAAM,WACL,GAAW,CACV,OAAU,IAAA,GACV,OAAU,IAAA,GACV,OAAU,IAAA,GACX,CACD,IAAK,SAEI,EADK,MAAM,EAAO,QACM,CAGjC,OAAQ,OAAO,gBAA4E,CAEzF,OADY,MAAM,EAAO,SAG5B,CAIH,KAAK,MAAM,IAAIA,EAAmB,CAAE,SAAU,GAAM,CAAC,CAGrD,IAAM,EAAUA,EAAM,MAAM,KAAM,EAAM,CAClC,EAAW,KAAK,MAGtB,GAAI,EAAQ,OAAS,UAAW,CAE9B,IAAM,GAAgB,SAAY,CAChC,IAAM,EAAM,EAAQ,OAAO,gBAAgB,CACvC,EAAS,MAAM,EAAI,MAAM,CAG7B,KAAO,EAAO,OAAS,IAAM,CAC3B,IAAM,EAAU,EAAO,MACjB,EAAiB,EAAiB,EAAQ,CAChD,GAAI,IAAmB,IAAA,GAErB,MAAM,EAER,IAAMC,EAAU,EAAK,UAAU,IAAI,EAAe,IAAI,CACtD,GAAIA,IAAY,IAAA,GACd,MAAU,MAAM,YAAY,EAAe,IAAI,gCAAgC,CAGjF,EAAS,MAAM,EAAI,KAAKA,EAAQ,CAGlC,IAAM,EAAM,EAAO,MAEnB,OADA,EAAS,IAAID,EAAmB,CAAE,QAAS,EAAK,CAAC,CAC1C,KACL,CAIJ,OAFA,KAAK,MAAM,IAAIA,EAAmB,CAAE,QAAS,EAAc,CAAC,CAErD,CACL,KAAM,WACL,GAAW,CACV,OAAU,IAAA,GACV,OAAU,IAAA,GACV,OAAU,IAAA,GACX,CACD,IAAK,SAAY,CACf,GAAI,CAEF,OAAO,EADK,MAAM,EACJ,OACP,EAAG,CACV,MAAO,CACL,GAAI,GACJ,MAAO,EACP,EAAE,OAAO,WAAY,CAEnB,MADA,MAAM,EACI,MAAM,cAAc,EAEjC,GAGL,OAAQ,OAAO,gBAA4E,CACzF,GAAI,CAEF,OADY,MAAM,QAEX,EAAG,CAEV,MADA,MAAM,EACI,MAAM,cAAe,CAAE,MAAO,EAAG,CAAC,GAGjD,CAIH,MAAO,CACL,KAAM,UACL,GAAW,CACV,OAAU,IAAA,GACV,OAAU,IAAA,GACV,OAAU,IAAA,GACX,CACD,QAAW,CACT,IAAM,EAAM,EAAQ,OAAO,WAAW,CAClC,EAAS,EAAI,MAAM,CAGvB,KAAO,EAAO,OAAS,IAAM,CAC3B,IAAM,EAAU,EAAO,MACjB,EAAiB,EAAiB,EAAQ,CAChD,GAAI,IAAmB,IAAA,GAErB,MAAO,CACL,GAAI,GACJ,MAAO,EACP,EAAE,OAAO,WAAY,CAEnB,MADA,MAAM,EACI,MAAM,cAAc,EAEjC,CAEH,IAAMC,EAAU,EAAK,UAAU,IAAI,EAAe,IAAI,CACtD,GAAIA,IAAY,IAAA,GACd,MAAU,MAAM,YAAY,EAAe,IAAI,gCAAgC,CAEjF,EAAS,EAAI,KAAKA,EAAQ,CAG5B,IAAM,EAAM,EAAO,MAEnB,OADA,EAAS,IAAID,EAAmB,CAAE,QAAS,EAAK,CAAC,CAC1C,EAAG,EAAI,EAEhB,EAAE,OAAO,WAAkE,CACzE,IAAM,EAAM,EAAQ,OAAO,WAAW,CAClC,EAAS,EAAI,MAAM,CAGvB,KAAO,EAAO,OAAS,IAAM,CAC3B,IAAM,EAAU,EAAO,MACjB,EAAiB,EAAiB,EAAQ,CAChD,GAAI,IAAmB,IAAA,GAGrB,MADA,MAAM,EACI,MAAM,cAAc,CAEhC,IAAMC,EAAU,EAAK,UAAU,IAAI,EAAe,IAAI,CACtD,GAAIA,IAAY,IAAA,GACd,MAAU,MAAM,YAAY,EAAe,IAAI,gCAAgC,CAEjF,EAAS,EAAI,KAAKA,EAAQ,CAI5B,OADA,EAAS,IAAID,EAAmB,CAAE,QAAS,EAAO,MAAO,CAAC,CACnD,EAAO,OAEjB,CAOH,OAAc,CACZ,KAAK,MAAM,OAAO,CAMpB,IAAI,MAAe,CACjB,OAAO,KAAK,MAAM,mECpKtB,SAAgB,EAAgB,EAA4B,CAC1D,MAA8B,IAAmD,CAG/E,IAAM,EAAgBE,EAAM,MAAM,IAAI,EAAWC,GAAW,CAAC,CAAC,KAExD,MAGD,CACH,IAAM,EAAU,IAAI,EACd,EAAQA,GAAW,CACzB,MAAO,CACL,QACA,aAAcD,EAAM,MAAM,EAAS,EAAM,CAC1C,EA8FH,OA3FI,IAAkB,WAAa,EAAG,OAAS,UACtC,CACL,KAAM,WACL,GAAW,CACV,OAAU,IAAA,GACV,OAAU,IAAA,GACV,OAAU,IAAA,GACX,CACD,OAAQ,OAAO,gBAAgF,CAC7F,GAAM,CAAE,QAAO,gBAAiB,GAAqB,CAErD,GAAI,CAEF,IAAI,EAEJ,GAAI,EAAa,OAAS,UAAW,CACnC,IAAM,EAAM,EAAa,OAAO,gBAAgB,CAC5C,EAAS,MAAM,EAAI,MAAM,CAE7B,KAAO,EAAO,OAAS,IACrB,MAAM,EAAO,MAEb,EAAS,MAAM,EAAI,KAAK,IAAA,GAAU,CAEpC,EAAM,EAAO,UACR,CACL,IAAM,EAAM,EAAa,OAAO,WAAW,CACvC,EAAS,EAAI,MAAM,CAEvB,KAAO,EAAO,OAAS,IACrB,MAAM,EAAO,MACb,EAAS,EAAI,KAAK,IAAA,GAAU,CAE9B,EAAM,EAAO,MAIf,GAAI,EAAG,OAAS,UAAW,CACzB,IAAME,EAAQ,EAAG,OAAO,gBAAgB,CACpCC,EAAW,MAAMD,EAAM,MAAM,CAEjC,KAAOC,EAAS,OAAS,IAAM,CAC7B,IAAM,EAAUA,EAAS,MAEnBC,EAAU,EAAe,EAAK,EAAQ,CAC5C,GAAIA,IAAY,IAAA,GAAW,CAEzB,EAAW,MAAMF,EAAM,KAAKE,EAAQ,CACpC,SAIF,IAAM,EAAQ,MAAM,EAEpB,EAAW,MAAMF,EAAM,KAAK,EAAM,CAGpC,OAAOC,EAAS,MAIlB,IAAM,EAAQ,EAAG,OAAO,WAAW,CAC/B,EAAW,EAAM,MAAM,CAE3B,KAAO,EAAS,OAAS,IAAM,CAC7B,IAAM,EAAU,EAAS,MAEnBC,EAAU,EAAe,EAAK,EAAQ,CAC5C,GAAIA,IAAY,IAAA,GAAW,CACzB,EAAW,EAAM,KAAKA,EAAQ,CAC9B,SAGF,IAAM,EAAQ,MAAM,EACpB,EAAW,EAAM,KAAK,EAAM,CAG9B,OAAO,EAAS,aACR,CACR,IAAM,EAAc,EAAM,MAAM,EAAG,IAAA,GAAU,CAAC,CAC1C,EAAY,OAAS,UACvB,MAAM,EAAS,EAAY,CAE3B,EAAQ,EAAY,GAI3B,CAII,CACL,KAAM,UACL,GAAW,CACV,OAAU,IAAA,GACV,OAAU,IAAA,GACV,OAAU,IAAA,GACX,CACD,EAAE,OAAO,WAAsE,CAC7E,GAAM,CAAE,QAAO,gBAAiB,GAAqB,CAErD,GAAI,EAAa,OAAS,UACxB,MAAU,MACR,+HACD,CAGH,GAAI,CAEF,IAAM,EAAW,EAAa,OAAO,WAAW,CAC5C,EAAc,EAAS,MAAM,CAEjC,KAAO,EAAY,OAAS,IAC1B,MAAM,EAAY,MAClB,EAAc,EAAS,KAAK,IAAA,GAAU,CAGxC,IAAM,EAAM,EAAY,MAGlB,EAAQ,EAAG,OAAO,WAAW,CAC/B,EAAW,EAAM,MAAM,CAE3B,KAAO,EAAS,OAAS,IAAM,CAC7B,IAAM,EAAU,EAAS,MAEnBA,EAAU,EAAe,EAAK,EAAQ,CAC5C,GAAIA,IAAY,IAAA,GAAW,CACzB,EAAW,EAAM,KAAKA,EAAQ,CAC9B,SAGF,IAAM,EAAQ,MAAM,EACpB,EAAW,EAAM,KAAK,EAAM,CAG9B,OAAO,EAAS,aACR,CAGR,EAFoB,EAAM,MAAM,EAAG,IAAA,GAAU,CAAC,CAEV,GAGzC,EAuCL,SAAgB,EAAO,GAAGC,EAAmB,CAC3C,OAAO,EAAMC,EAAY,GAAGD,EAAO,CAAC,CA2BtC,MAAa,EACP,GACG,GACD,EAAG,OAAS,UACP,CACL,KAAM,WACL,GAAW,CACV,OAAU,IAAA,GACV,OAAU,IAAA,GACV,OAAU,IAAA,GACX,CACD,OAAQ,OAAO,gBAAgE,CAC7E,IAAM,EAAM,EAAG,OAAO,gBAAgB,CAClC,EAAS,MAAM,EAAI,MAAM,CAE7B,KAAO,EAAO,OAAS,IAAM,CAC3B,IAAM,EAAU,EAAO,MAEjB,EAAiB,EAAiB,EAAQ,CAChD,GAAI,IAAmB,IAAA,GAAW,CAChC,MAAM,EAEN,EAAS,MAAM,EAAI,KAAK,IAAA,GAAU,CAClC,SAEF,IAAMD,EAAU,EAAI,UAAU,IAAI,EAAe,IAAI,CACrD,GAAIA,IAAY,IAAA,GACd,MAAU,MAAM,YAAY,EAAe,IAAI,aAAa,CAG9D,EAAS,MAAM,EAAI,KAAKA,EAAQ,CAGlC,OAAO,EAAO,OAEjB,CAGI,CACL,KAAM,UACL,GAAW,CACV,OAAU,IAAA,GACV,OAAU,IAAA,GACV,OAAU,IAAA,GACX,CACD,EAAE,OAAO,WAAsD,CAC7D,IAAM,EAAM,EAAG,OAAO,WAAW,CAC7B,EAAS,EAAI,MAAM,CAEvB,KAAO,EAAO,OAAS,IAAM,CAC3B,IAAM,EAAU,EAAO,MAEjB,EAAiB,EAAiB,EAAQ,CAChD,GAAI,IAAmB,IAAA,GAAW,CAChC,MAAM,EACN,EAAS,EAAI,KAAK,IAAA,GAAU,CAC5B,SAEF,IAAMA,EAAU,EAAI,UAAU,IAAI,EAAe,IAAI,CACrD,GAAIA,IAAY,IAAA,GACd,MAAU,MAAM,YAAY,EAAe,IAAI,aAAa,CAE9D,EAAS,EAAI,KAAKA,EAAQ,CAG5B,OAAO,EAAO,OAEjB,CA2BQ,GACP,EAA0B,IACpB,GACJ,EAAG,OAAS,UACP,CACL,KAAM,WACL,GAAW,CACV,OAAU,IAAA,GACV,OAAU,IAAA,GACV,OAAU,IAAA,GACX,CACD,OAAQ,OAAO,gBAAwE,CACrF,IAAM,EAAM,EAAG,OAAO,gBAAgB,CAClC,EAAS,MAAM,EAAI,MAAM,CAE7B,KAAO,EAAO,OAAS,IAAM,CAC3B,IAAM,EAAU,EAAO,MAGvB,GADuB,EAAiB,EAAQ,EAC5B,MAAQA,EAAQ,IAElC,EAAS,MAAM,EAAI,KAAK,EAAK,KACxB,CACL,IAAM,EAAQ,MAAM,EAEpB,EAAS,MAAM,EAAI,KAAK,EAAM,EAIlC,OAAO,EAAO,OAEjB,CAGI,CACL,KAAM,UACL,GAAW,CACV,OAAU,IAAA,GACV,OAAU,IAAA,GACV,OAAU,IAAA,GACX,CACD,EAAE,OAAO,WAA8D,CACrE,IAAM,EAAM,EAAG,OAAO,WAAW,CAC7B,EAAS,EAAI,MAAM,CAEvB,KAAO,EAAO,OAAS,IAAM,CAC3B,IAAM,EAAU,EAAO,MAGvB,GADuB,EAAiB,EAAQ,EAC5B,MAAQA,EAAQ,IAClC,EAAS,EAAI,KAAK,EAAK,KAClB,CACL,IAAM,EAAQ,MAAM,EACpB,EAAS,EAAI,KAAK,EAAM,EAI5B,OAAO,EAAO,OAEjB"}

package/dist/schema-DstB1_VK.mjs

@@ -1,2 +0,0 @@
-import{t as e}from"./chunk-oQKkju2G.mjs";import{t}from"./dual-fN6OUwN_.mjs";import{n}from"./flow-CNyLsPGb.mjs";import{t as r}from"./result-D3VY0qBG.mjs";import{n as i,r as a,t as o}from"./schema.shared-Bjyroa6b.mjs";var s=e({is:()=>f,parse:()=>c,refine:()=>u});function c(e){return t=>{try{let a=e[`~standard`].validate(t);return n(a)?Promise.resolve(a).then(e=>i(e),e=>r(o(e))):i(a)}catch(e){return r(o(e))}}}const l=t(2,(e,t)=>a(t,e,`Schema.refine()`)._tag===`Ok`);function u(...e){return l(...e)}const d=t(2,(e,t)=>a(t,e,`Schema.is()`)._tag===`Ok`);function f(...e){return d(...e)}export{s as t};
-//# sourceMappingURL=schema-DstB1_VK.mjs.map

package/dist/schema-DstB1_VK.mjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"schema-DstB1_VK.mjs","names":["Result.err"],"sources":["../src/schema/schema.ts"],"sourcesContent":["import { Result } from \"../result\"\nimport type { Result as ResultType } from \"../result/result.types\"\n/**\n * Standard Schema-backed parsing and refinement helpers.\n *\n * **Mental model**\n * - `Schema.parse` is for boundary validation and parsing.\n * - `Schema.is` is a sync-only proof guard for direct in-memory checks.\n * - `Schema.refine` is the reusable preserved-shape guard for higher-order APIs like `Array.filter`.\n *\n * **Common tasks**\n * - Parse loose external data into validated subtypes.\n * - Use `Schema.is` for direct control-flow checks against already-typed values.\n * - Reuse a schema as a preserved-shape predicate with `Schema.refine`.\n * - Name reusable narrowed types with `Schema.Refine<Base, typeof schema>` or exact schema outputs with `Schema.Infer<typeof schema>`.\n *\n * **Gotchas**\n * - `Schema.parse` may be sync or async based on the schema type you preserve.\n * - `Schema.refine` and `Schema.is` support both data-first and data-last styles.\n * - `Schema.refine` and `Schema.is` are sync-only.\n * - `Schema.is` and `Schema.refine` must only be used with proof schemas that validate the current value in place.\n * - Transforms, defaults, coercions, and other output-changing schemas should use `Schema.parse`.\n * - `Schema.is` narrows `unknown` to the exact schema output, but in direct control flow TypeScript preserves the current value shape.\n * - `Schema.refine` exists for the cases where you need that preserved shape to survive higher-order APIs like `Array.filter`.\n *\n * @module\n */\nimport { dual } from \"../shared/dual\"\nimport { isPromise } from \"../shared/is-promise\"\nimport { toThrownValidationError, toValidationResult, validateSync } from \"./schema.shared\"\nimport type {\n  Input,\n  Output,\n  Refine as Refined,\n  SyncRefinementSchema,\n  SyncSchema,\n  ValidationError,\n} from \"./schema.types\"\nimport type { StandardSchemaV1 } from \"@standard-schema/spec\"\n\nexport type {\n  Infer,\n  Input,\n  Output,\n  Refine,\n  RefinementSchema,\n  SyncRefinementSchema,\n  SyncSchema,\n  ValidationError,\n  ValidationIssue,\n} from \"./schema.types\"\n\n/**\n * Create a schema-backed parser.\n *\n * For sync schemas the returned parser is sync.\n * For general Standard Schema values the returned parser is async.\n */\nexport function parse<S extends SyncSchema>(schema: S): (value: Input<S>) => ResultType<Output<S>, ValidationError>\nexport function parse<S extends StandardSchemaV1>(\n  schema: S,\n): (value: Input<S>) => Promise<ResultType<Output<S>, ValidationError>>\nexport function parse<S extends StandardSchemaV1>(schema: S) {\n  return (value: Input<S>) => {\n    try {\n      const result = schema[\"~standard\"].validate(value)\n\n      if (isPromise(result)) {\n        return Promise.resolve(result).then(\n          (validated) => toValidationResult(validated),\n          (error) => Result.err(toThrownValidationError(error)),\n        )\n      }\n\n      return toValidationResult(result)\n    } catch (error) {\n      return Result.err(toThrownValidationError(error))\n    }\n  }\n}\n\nexport type RefineFn = {\n  <S extends SyncSchema, Base extends Input<S>>(value: Base, schema: S): value is Refined<Base, S>\n  <S extends SyncSchema>(schema: S): <Base extends Input<S>>(value: Base) => value is Refined<Base, S>\n}\n\nexport type Is = {\n  <Base, Sub extends Base>(value: Base, schema: SyncRefinementSchema<Base, Sub>): value is Sub\n  <S extends SyncSchema>(value: unknown, schema: S): value is Output<S>\n  <Base, Sub extends Base>(schema: SyncRefinementSchema<Base, Sub>): (value: Base) => value is Sub\n  <S extends SyncSchema>(schema: S): (value: unknown) => value is Output<S>\n}\n\n/* oxlint-disable no-explicit-any, no-unsafe-return, no-unsafe-type-assertion -- dual() requires a single implementation signature */\nconst refineImpl = dual(2, (value: unknown, schema: SyncSchema) => {\n  return validateSync(schema, value, \"Schema.refine()\")._tag === \"Ok\"\n}) as RefineFn\n\n/**\n * Create a sync-only schema-backed reusable type guard that preserves the original value shape.\n *\n * Use this when a schema validates only a subset of a broader in-memory value\n * and you need the preserved shape to survive higher-order APIs like\n * `Array.filter`. The narrowed type is `Base & Output<typeof schema>`, not the\n * exact schema output.\n *\n * Supports both data-first and data-last styles:\n * - Data-first: `Schema.refine(value, schema)`\n * - Data-last: `Schema.refine(schema)(value)`\n *\n * Only use this with sync proof schemas that validate properties already\n * present on the original value. Transforms, defaults, and coercions are not\n * safe here because they can change the schema output without changing the\n * original input value.\n */\nexport function refine<S extends SyncSchema, Base extends Input<S>>(value: Base, schema: S): value is Refined<Base, S>\nexport function refine<S extends SyncSchema>(\n  schema: S,\n): <Base extends Input<S>>(value: Base) => value is Refined<Base, S>\nexport function refine(...args: [value: unknown, schema: SyncSchema] | [schema: SyncSchema]) {\n  return (refineImpl as (...args: [unknown, SyncSchema] | [SyncSchema]) => boolean | ((value: unknown) => boolean))(\n    ...args,\n  )\n}\n\nconst isImpl = dual(2, (value: unknown, schema: SyncSchema) => {\n  return validateSync(schema, value, \"Schema.is()\")._tag === \"Ok\"\n}) as Is\n\n/**\n * Create a sync-only schema-backed proof guard.\n *\n * On `unknown` values this narrows to the exact schema output. On already-typed\n * values, TypeScript preserves the current shape during direct control-flow\n * checks. Use `Schema.refine` when that preserved shape must survive\n * higher-order APIs like `Array.filter`.\n *\n * Supports both data-first and data-last styles:\n * - Data-first: `Schema.is(value, schema)`\n * - Data-last: `Schema.is(schema)(value)`\n */\nexport function is<Base, Sub extends Base>(value: Base, schema: SyncRefinementSchema<Base, Sub>): value is Sub\nexport function is<S extends SyncSchema>(value: unknown, schema: S): value is Output<S>\nexport function is<Base, Sub extends Base>(schema: SyncRefinementSchema<Base, Sub>): (value: Base) => value is Sub\nexport function is<S extends SyncSchema>(schema: S): (value: unknown) => value is Output<S>\nexport function is(...args: [value: unknown, schema: SyncSchema] | [schema: SyncSchema]) {\n  return (isImpl as (...args: [unknown, SyncSchema] | [SyncSchema]) => boolean | ((value: unknown) => boolean))(...args)\n}\n/* oxlint-enable no-explicit-any, no-unsafe-return, no-unsafe-type-assertion */\n"],"mappings":"qQA8DA,SAAgB,EAAkC,EAAW,CAC3D,MAAQ,IAAoB,CAC1B,GAAI,CACF,IAAM,EAAS,EAAO,aAAa,SAAS,EAAM,CASlD,OAPI,EAAU,EAAO,CACZ,QAAQ,QAAQ,EAAO,CAAC,KAC5B,GAAc,EAAmB,EAAU,CAC3C,GAAUA,EAAW,EAAwB,EAAM,CAAC,CACtD,CAGI,EAAmB,EAAO,OAC1B,EAAO,CACd,OAAOA,EAAW,EAAwB,EAAM,CAAC,GAkBvD,MAAM,EAAa,EAAK,GAAI,EAAgB,IACnC,EAAa,EAAQ,EAAO,kBAAkB,CAAC,OAAS,KAC/D,CAuBF,SAAgB,EAAO,GAAG,EAAmE,CAC3F,OAAQ,EACN,GAAG,EACJ,CAGH,MAAM,EAAS,EAAK,GAAI,EAAgB,IAC/B,EAAa,EAAQ,EAAO,cAAc,CAAC,OAAS,KAC3D,CAkBF,SAAgB,EAAG,GAAG,EAAmE,CACvF,OAAQ,EAAsG,GAAG,EAAK"}

package/dist/schema.shared-Bjyroa6b.mjs

@@ -1,2 +0,0 @@
-import{n as e}from"./flow-CNyLsPGb.mjs";import{i as t,t as n}from"./result-D3VY0qBG.mjs";function r(e){return typeof e==`object`&&e&&`key`in e?e.key:e}function i(e){return e.map(e=>({message:e.message,path:e.path?.map(r)}))}function a(e){return e.issues?n({issues:i(e.issues)}):t(e.value)}function o(e){return e instanceof Error&&e.message.length>0?e.message:typeof e==`string`&&e.length>0?e:`Schema validation failed.`}function s(e){return{issues:[{message:o(e)}]}}function c(t,n,r){let i=t[`~standard`].validate(n);if(e(i))throw TypeError(`Async validation is not supported in ${r}.`);return a(i)}export{a as n,c as r,s as t};
-//# sourceMappingURL=schema.shared-Bjyroa6b.mjs.map