@nicolastoulemont/std 0.9.0 → 0.11.0

package/dist/{flow-CNyLsPGb.mjs.map → flow-D8_tllWl.mjs.map}

@@ -1 +1 @@
-{"version":3,"file":"flow-CNyLsPGb.mjs","names":[],"sources":["../src/shared/is-promise.ts","../src/functions/flow.ts"],"sourcesContent":["/**\n * Check if a value is a Promise.\n */\nexport function isPromise(value: unknown): value is PromiseLike<unknown> {\n  if (value === null) return false\n  if (typeof value !== \"object\" && typeof value !== \"function\") return false\n  return typeof (value as { then?: unknown }).then === \"function\"\n}\n","/**\n * Point-free function composition utilities.\n *\n * **Mental model**\n * - `flow(fn1, fn2...)` returns a new composed function.\n * - Each function receives the previous function output.\n *\n * **Common tasks**\n * - Build reusable transformation functions.\n * - Compose sync and async processing steps.\n *\n * **Gotchas**\n * - The first function controls the input parameter list.\n * - For immediate execution on a value, use `pipe`.\n *\n * **Quickstart**\n *\n * @example\n * ```ts\n * import { flow } from \"@nicolastoulemont/std\"\n *\n * const toLabel = flow((n: number) => n + 1, (n) => `value:${n}`)\n * ```\n *\n * @module\n */\nimport { isPromise } from \"../shared/is-promise\"\nimport type { λ } from \"../shared/lambda.types\"\nimport type { FlowdFun } from \"./flow.types\"\n\n/**\n * Given a list of functions returns a function that will execute the given\n * functions one after another, always passing the result of the previous\n * function as an argument to the next function.\n *\n * If one of the given functions returns a promise, the promise will be resolved\n * before being passed to the next function.\n *\n * Type inference: This function provides automatic type inference for chains of\n * 1-15 functions. Each function's parameter type is automatically inferred from\n * the previous function's return type. For chains longer than 15 functions,\n * types must be explicitly specified.\n *\n * Async support: Functions can return Promises. The runtime automatically awaits\n * Promises before passing values to subsequent functions, and parameter types\n * use `Awaited<T>` to reflect this behavior. The final return type will be\n * Promise<T> if any function returns a Promise.\n *\n * @see {@link pipe} for immediate execution with an initial value\n *\n * @example\n * ```ts\n * import { flow } from \"@nicolastoulemont/std\"\n *\n * const toLabel = flow((n: number) => n + 1, (n) => `value:${n}`)\n * const result = toLabel(2)\n * // => \"value:3\"\n * ```\n */\n// 1 function\nexport function flow<A extends unknown[], B>(f1: (...args: A) => B): FlowdFun<[typeof f1]>\n// 2 functions\nexport function flow<A extends unknown[], B, C>(\n  f1: (...args: A) => B,\n  f2: (arg: Awaited<B>) => C,\n): FlowdFun<[typeof f1, typeof f2]>\n// 3 functions\nexport function flow<A extends unknown[], B, C, D>(\n  f1: (...args: A) => B,\n  f2: (arg: Awaited<B>) => C,\n  f3: (arg: Awaited<C>) => D,\n): FlowdFun<[typeof f1, typeof f2, typeof f3]>\n// 4 functions\nexport function flow<A extends unknown[], B, C, D, E>(\n  f1: (...args: A) => B,\n  f2: (arg: Awaited<B>) => C,\n  f3: (arg: Awaited<C>) => D,\n  f4: (arg: Awaited<D>) => E,\n): FlowdFun<[typeof f1, typeof f2, typeof f3, typeof f4]>\n// 5 functions\nexport function flow<A extends unknown[], B, C, D, E, F>(\n  f1: (...args: A) => B,\n  f2: (arg: Awaited<B>) => C,\n  f3: (arg: Awaited<C>) => D,\n  f4: (arg: Awaited<D>) => E,\n  f5: (arg: Awaited<E>) => F,\n): FlowdFun<[typeof f1, typeof f2, typeof f3, typeof f4, typeof f5]>\n// 6 functions\nexport function flow<A extends unknown[], B, C, D, E, F, G>(\n  f1: (...args: A) => B,\n  f2: (arg: Awaited<B>) => C,\n  f3: (arg: Awaited<C>) => D,\n  f4: (arg: Awaited<D>) => E,\n  f5: (arg: Awaited<E>) => F,\n  f6: (arg: Awaited<F>) => G,\n): FlowdFun<[typeof f1, typeof f2, typeof f3, typeof f4, typeof f5, typeof f6]>\n// 7 functions\nexport function flow<A extends unknown[], B, C, D, E, F, G, H>(\n  f1: (...args: A) => B,\n  f2: (arg: Awaited<B>) => C,\n  f3: (arg: Awaited<C>) => D,\n  f4: (arg: Awaited<D>) => E,\n  f5: (arg: Awaited<E>) => F,\n  f6: (arg: Awaited<F>) => G,\n  f7: (arg: Awaited<G>) => H,\n): FlowdFun<[typeof f1, typeof f2, typeof f3, typeof f4, typeof f5, typeof f6, typeof f7]>\n// 8 functions\nexport function flow<A extends unknown[], B, C, D, E, F, G, H, I>(\n  f1: (...args: A) => B,\n  f2: (arg: Awaited<B>) => C,\n  f3: (arg: Awaited<C>) => D,\n  f4: (arg: Awaited<D>) => E,\n  f5: (arg: Awaited<E>) => F,\n  f6: (arg: Awaited<F>) => G,\n  f7: (arg: Awaited<G>) => H,\n  f8: (arg: Awaited<H>) => I,\n): FlowdFun<[typeof f1, typeof f2, typeof f3, typeof f4, typeof f5, typeof f6, typeof f7, typeof f8]>\n// 9 functions\nexport function flow<A extends unknown[], B, C, D, E, F, G, H, I, J>(\n  f1: (...args: A) => B,\n  f2: (arg: Awaited<B>) => C,\n  f3: (arg: Awaited<C>) => D,\n  f4: (arg: Awaited<D>) => E,\n  f5: (arg: Awaited<E>) => F,\n  f6: (arg: Awaited<F>) => G,\n  f7: (arg: Awaited<G>) => H,\n  f8: (arg: Awaited<H>) => I,\n  f9: (arg: Awaited<I>) => J,\n): FlowdFun<[typeof f1, typeof f2, typeof f3, typeof f4, typeof f5, typeof f6, typeof f7, typeof f8, typeof f9]>\n// 10 functions\nexport function flow<A extends unknown[], B, C, D, E, F, G, H, I, J, K>(\n  f1: (...args: A) => B,\n  f2: (arg: Awaited<B>) => C,\n  f3: (arg: Awaited<C>) => D,\n  f4: (arg: Awaited<D>) => E,\n  f5: (arg: Awaited<E>) => F,\n  f6: (arg: Awaited<F>) => G,\n  f7: (arg: Awaited<G>) => H,\n  f8: (arg: Awaited<H>) => I,\n  f9: (arg: Awaited<I>) => J,\n  f10: (arg: Awaited<J>) => K,\n): FlowdFun<\n  [typeof f1, typeof f2, typeof f3, typeof f4, typeof f5, typeof f6, typeof f7, typeof f8, typeof f9, typeof f10]\n>\n// 11 functions\nexport function flow<A extends unknown[], B, C, D, E, F, G, H, I, J, K, L>(\n  f1: (...args: A) => B,\n  f2: (arg: Awaited<B>) => C,\n  f3: (arg: Awaited<C>) => D,\n  f4: (arg: Awaited<D>) => E,\n  f5: (arg: Awaited<E>) => F,\n  f6: (arg: Awaited<F>) => G,\n  f7: (arg: Awaited<G>) => H,\n  f8: (arg: Awaited<H>) => I,\n  f9: (arg: Awaited<I>) => J,\n  f10: (arg: Awaited<J>) => K,\n  f11: (arg: Awaited<K>) => L,\n): FlowdFun<\n  [\n    typeof f1,\n    typeof f2,\n    typeof f3,\n    typeof f4,\n    typeof f5,\n    typeof f6,\n    typeof f7,\n    typeof f8,\n    typeof f9,\n    typeof f10,\n    typeof f11,\n  ]\n>\n// 12 functions\nexport function flow<A extends unknown[], B, C, D, E, F, G, H, I, J, K, L, M>(\n  f1: (...args: A) => B,\n  f2: (arg: Awaited<B>) => C,\n  f3: (arg: Awaited<C>) => D,\n  f4: (arg: Awaited<D>) => E,\n  f5: (arg: Awaited<E>) => F,\n  f6: (arg: Awaited<F>) => G,\n  f7: (arg: Awaited<G>) => H,\n  f8: (arg: Awaited<H>) => I,\n  f9: (arg: Awaited<I>) => J,\n  f10: (arg: Awaited<J>) => K,\n  f11: (arg: Awaited<K>) => L,\n  f12: (arg: Awaited<L>) => M,\n): FlowdFun<\n  [\n    typeof f1,\n    typeof f2,\n    typeof f3,\n    typeof f4,\n    typeof f5,\n    typeof f6,\n    typeof f7,\n    typeof f8,\n    typeof f9,\n    typeof f10,\n    typeof f11,\n    typeof f12,\n  ]\n>\n// 13 functions\nexport function flow<A extends unknown[], B, C, D, E, F, G, H, I, J, K, L, M, N>(\n  f1: (...args: A) => B,\n  f2: (arg: Awaited<B>) => C,\n  f3: (arg: Awaited<C>) => D,\n  f4: (arg: Awaited<D>) => E,\n  f5: (arg: Awaited<E>) => F,\n  f6: (arg: Awaited<F>) => G,\n  f7: (arg: Awaited<G>) => H,\n  f8: (arg: Awaited<H>) => I,\n  f9: (arg: Awaited<I>) => J,\n  f10: (arg: Awaited<J>) => K,\n  f11: (arg: Awaited<K>) => L,\n  f12: (arg: Awaited<L>) => M,\n  f13: (arg: Awaited<M>) => N,\n): FlowdFun<\n  [\n    typeof f1,\n    typeof f2,\n    typeof f3,\n    typeof f4,\n    typeof f5,\n    typeof f6,\n    typeof f7,\n    typeof f8,\n    typeof f9,\n    typeof f10,\n    typeof f11,\n    typeof f12,\n    typeof f13,\n  ]\n>\n// 14 functions\nexport function flow<A extends unknown[], B, C, D, E, F, G, H, I, J, K, L, M, N, O>(\n  f1: (...args: A) => B,\n  f2: (arg: Awaited<B>) => C,\n  f3: (arg: Awaited<C>) => D,\n  f4: (arg: Awaited<D>) => E,\n  f5: (arg: Awaited<E>) => F,\n  f6: (arg: Awaited<F>) => G,\n  f7: (arg: Awaited<G>) => H,\n  f8: (arg: Awaited<H>) => I,\n  f9: (arg: Awaited<I>) => J,\n  f10: (arg: Awaited<J>) => K,\n  f11: (arg: Awaited<K>) => L,\n  f12: (arg: Awaited<L>) => M,\n  f13: (arg: Awaited<M>) => N,\n  f14: (arg: Awaited<N>) => O,\n): FlowdFun<\n  [\n    typeof f1,\n    typeof f2,\n    typeof f3,\n    typeof f4,\n    typeof f5,\n    typeof f6,\n    typeof f7,\n    typeof f8,\n    typeof f9,\n    typeof f10,\n    typeof f11,\n    typeof f12,\n    typeof f13,\n    typeof f14,\n  ]\n>\n// 15 functions\nexport function flow<A extends unknown[], B, C, D, E, F, G, H, I, J, K, L, M, N, O, P>(\n  f1: (...args: A) => B,\n  f2: (arg: Awaited<B>) => C,\n  f3: (arg: Awaited<C>) => D,\n  f4: (arg: Awaited<D>) => E,\n  f5: (arg: Awaited<E>) => F,\n  f6: (arg: Awaited<F>) => G,\n  f7: (arg: Awaited<G>) => H,\n  f8: (arg: Awaited<H>) => I,\n  f9: (arg: Awaited<I>) => J,\n  f10: (arg: Awaited<J>) => K,\n  f11: (arg: Awaited<K>) => L,\n  f12: (arg: Awaited<L>) => M,\n  f13: (arg: Awaited<M>) => N,\n  f14: (arg: Awaited<N>) => O,\n  f15: (arg: Awaited<O>) => P,\n): FlowdFun<\n  [\n    typeof f1,\n    typeof f2,\n    typeof f3,\n    typeof f4,\n    typeof f5,\n    typeof f6,\n    typeof f7,\n    typeof f8,\n    typeof f9,\n    typeof f10,\n    typeof f11,\n    typeof f12,\n    typeof f13,\n    typeof f14,\n    typeof f15,\n  ]\n>\n// Implementation signature (fallback for 16+ functions)\nexport function flow<Fns extends [λ, ...λ[]]>(...fns: Fns): FlowdFun<Fns> {\n  // oxlint-disable-next-line\n  return ((...args) => {\n    // oxlint-disable-next-line\n    let nextArgs: unknown[] = args\n\n    for (let i = 0; i < fns.length; i++) {\n      // oxlint-disable-next-line\n      const [result] = (nextArgs = [fns[i]?.(...nextArgs)])\n      if (isPromise(result)) return resolveAsync(result, fns.slice(i + 1))\n    }\n\n    return nextArgs[0]\n  }) as FlowdFun<Fns>\n}\n\nconst resolveAsync = async (result: unknown, funs: λ[]) => {\n  // oxlint-disable-next-line\n  for (const fun of funs) result = fun(await result)\n  return await result\n}\n"],"mappings":"AAGA,SAAgB,EAAU,EAA+C,CAGvE,OAFI,IAAU,MACV,OAAO,GAAU,UAAY,OAAO,GAAU,WAAmB,GAC9D,OAAQ,EAA6B,MAAS,WC2SvD,SAAgB,EAA8B,GAAG,EAAyB,CAExE,QAAS,GAAG,IAAS,CAEnB,IAAI,EAAsB,EAE1B,IAAK,IAAI,EAAI,EAAG,EAAI,EAAI,OAAQ,IAAK,CAEnC,GAAM,CAAC,GAAW,EAAW,CAAC,EAAI,KAAK,GAAG,EAAS,CAAC,CACpD,GAAI,EAAU,EAAO,CAAE,OAAO,EAAa,EAAQ,EAAI,MAAM,EAAI,EAAE,CAAC,CAGtE,OAAO,EAAS,KAIpB,MAAM,EAAe,MAAO,EAAiB,IAAc,CAEzD,IAAK,IAAM,KAAO,EAAM,EAAS,EAAI,MAAM,EAAO,CAClD,OAAO,MAAM"}
+{"version":3,"file":"flow-D8_tllWl.mjs","names":[],"sources":["../src/shared/is-promise.ts","../src/functions/flow.ts"],"sourcesContent":["/**\n * Check if a value is a Promise.\n */\nexport function isPromise(value: unknown): value is PromiseLike<unknown> {\n  if (value === null) return false\n  if (typeof value !== \"object\" && typeof value !== \"function\") return false\n  return typeof (value as { then?: unknown }).then === \"function\"\n}\n","/**\n * Point-free function composition utilities.\n *\n * **Mental model**\n * - `flow(fn1, fn2...)` returns a new composed function.\n * - Each function receives the previous function output.\n *\n * **Common tasks**\n * - Build reusable transformation functions.\n * - Compose sync and async processing steps.\n *\n * **Gotchas**\n * - The first function controls the input parameter list.\n * - For immediate execution on a value, use `pipe`.\n *\n * **Quickstart**\n *\n * @example\n * ```ts\n * import { flow } from \"@nicolastoulemont/std\"\n *\n * const toLabel = flow((n: number) => n + 1, (n) => `value:${n}`)\n * ```\n *\n * @module\n */\nimport { isPromise } from \"../shared/is-promise\"\nimport type { λ } from \"../shared/lambda.types\"\nimport type { FlowdFun } from \"./flow.types\"\n\n/**\n * Given a list of functions returns a function that will execute the given\n * functions one after another, always passing the result of the previous\n * function as an argument to the next function.\n *\n * If one of the given functions returns a promise, the promise will be resolved\n * before being passed to the next function.\n *\n * Type inference: This function provides automatic type inference for chains of\n * 1-15 functions. Each function's parameter type is automatically inferred from\n * the previous function's return type. For chains longer than 15 functions,\n * types must be explicitly specified.\n *\n * Async support: Functions can return Promises. The runtime automatically awaits\n * Promises before passing values to subsequent functions, and parameter types\n * use `Awaited<T>` to reflect this behavior. The final return type will be\n * Promise<T> if any function returns a Promise.\n *\n * @see {@link pipe} for immediate execution with an initial value\n *\n * @example\n * ```ts\n * import { flow } from \"@nicolastoulemont/std\"\n *\n * const toLabel = flow((n: number) => n + 1, (n) => `value:${n}`)\n * const result = toLabel(2)\n * // => \"value:3\"\n * ```\n */\n// 1 function\nexport function flow<A extends unknown[], B>(f1: (...args: A) => B): FlowdFun<[typeof f1]>\n// 2 functions\nexport function flow<A extends unknown[], B, C>(\n  f1: (...args: A) => B,\n  f2: (arg: Awaited<B>) => C,\n): FlowdFun<[typeof f1, typeof f2]>\n// 3 functions\nexport function flow<A extends unknown[], B, C, D>(\n  f1: (...args: A) => B,\n  f2: (arg: Awaited<B>) => C,\n  f3: (arg: Awaited<C>) => D,\n): FlowdFun<[typeof f1, typeof f2, typeof f3]>\n// 4 functions\nexport function flow<A extends unknown[], B, C, D, E>(\n  f1: (...args: A) => B,\n  f2: (arg: Awaited<B>) => C,\n  f3: (arg: Awaited<C>) => D,\n  f4: (arg: Awaited<D>) => E,\n): FlowdFun<[typeof f1, typeof f2, typeof f3, typeof f4]>\n// 5 functions\nexport function flow<A extends unknown[], B, C, D, E, F>(\n  f1: (...args: A) => B,\n  f2: (arg: Awaited<B>) => C,\n  f3: (arg: Awaited<C>) => D,\n  f4: (arg: Awaited<D>) => E,\n  f5: (arg: Awaited<E>) => F,\n): FlowdFun<[typeof f1, typeof f2, typeof f3, typeof f4, typeof f5]>\n// 6 functions\nexport function flow<A extends unknown[], B, C, D, E, F, G>(\n  f1: (...args: A) => B,\n  f2: (arg: Awaited<B>) => C,\n  f3: (arg: Awaited<C>) => D,\n  f4: (arg: Awaited<D>) => E,\n  f5: (arg: Awaited<E>) => F,\n  f6: (arg: Awaited<F>) => G,\n): FlowdFun<[typeof f1, typeof f2, typeof f3, typeof f4, typeof f5, typeof f6]>\n// 7 functions\nexport function flow<A extends unknown[], B, C, D, E, F, G, H>(\n  f1: (...args: A) => B,\n  f2: (arg: Awaited<B>) => C,\n  f3: (arg: Awaited<C>) => D,\n  f4: (arg: Awaited<D>) => E,\n  f5: (arg: Awaited<E>) => F,\n  f6: (arg: Awaited<F>) => G,\n  f7: (arg: Awaited<G>) => H,\n): FlowdFun<[typeof f1, typeof f2, typeof f3, typeof f4, typeof f5, typeof f6, typeof f7]>\n// 8 functions\nexport function flow<A extends unknown[], B, C, D, E, F, G, H, I>(\n  f1: (...args: A) => B,\n  f2: (arg: Awaited<B>) => C,\n  f3: (arg: Awaited<C>) => D,\n  f4: (arg: Awaited<D>) => E,\n  f5: (arg: Awaited<E>) => F,\n  f6: (arg: Awaited<F>) => G,\n  f7: (arg: Awaited<G>) => H,\n  f8: (arg: Awaited<H>) => I,\n): FlowdFun<[typeof f1, typeof f2, typeof f3, typeof f4, typeof f5, typeof f6, typeof f7, typeof f8]>\n// 9 functions\nexport function flow<A extends unknown[], B, C, D, E, F, G, H, I, J>(\n  f1: (...args: A) => B,\n  f2: (arg: Awaited<B>) => C,\n  f3: (arg: Awaited<C>) => D,\n  f4: (arg: Awaited<D>) => E,\n  f5: (arg: Awaited<E>) => F,\n  f6: (arg: Awaited<F>) => G,\n  f7: (arg: Awaited<G>) => H,\n  f8: (arg: Awaited<H>) => I,\n  f9: (arg: Awaited<I>) => J,\n): FlowdFun<[typeof f1, typeof f2, typeof f3, typeof f4, typeof f5, typeof f6, typeof f7, typeof f8, typeof f9]>\n// 10 functions\nexport function flow<A extends unknown[], B, C, D, E, F, G, H, I, J, K>(\n  f1: (...args: A) => B,\n  f2: (arg: Awaited<B>) => C,\n  f3: (arg: Awaited<C>) => D,\n  f4: (arg: Awaited<D>) => E,\n  f5: (arg: Awaited<E>) => F,\n  f6: (arg: Awaited<F>) => G,\n  f7: (arg: Awaited<G>) => H,\n  f8: (arg: Awaited<H>) => I,\n  f9: (arg: Awaited<I>) => J,\n  f10: (arg: Awaited<J>) => K,\n): FlowdFun<\n  [typeof f1, typeof f2, typeof f3, typeof f4, typeof f5, typeof f6, typeof f7, typeof f8, typeof f9, typeof f10]\n>\n// 11 functions\nexport function flow<A extends unknown[], B, C, D, E, F, G, H, I, J, K, L>(\n  f1: (...args: A) => B,\n  f2: (arg: Awaited<B>) => C,\n  f3: (arg: Awaited<C>) => D,\n  f4: (arg: Awaited<D>) => E,\n  f5: (arg: Awaited<E>) => F,\n  f6: (arg: Awaited<F>) => G,\n  f7: (arg: Awaited<G>) => H,\n  f8: (arg: Awaited<H>) => I,\n  f9: (arg: Awaited<I>) => J,\n  f10: (arg: Awaited<J>) => K,\n  f11: (arg: Awaited<K>) => L,\n): FlowdFun<\n  [\n    typeof f1,\n    typeof f2,\n    typeof f3,\n    typeof f4,\n    typeof f5,\n    typeof f6,\n    typeof f7,\n    typeof f8,\n    typeof f9,\n    typeof f10,\n    typeof f11,\n  ]\n>\n// 12 functions\nexport function flow<A extends unknown[], B, C, D, E, F, G, H, I, J, K, L, M>(\n  f1: (...args: A) => B,\n  f2: (arg: Awaited<B>) => C,\n  f3: (arg: Awaited<C>) => D,\n  f4: (arg: Awaited<D>) => E,\n  f5: (arg: Awaited<E>) => F,\n  f6: (arg: Awaited<F>) => G,\n  f7: (arg: Awaited<G>) => H,\n  f8: (arg: Awaited<H>) => I,\n  f9: (arg: Awaited<I>) => J,\n  f10: (arg: Awaited<J>) => K,\n  f11: (arg: Awaited<K>) => L,\n  f12: (arg: Awaited<L>) => M,\n): FlowdFun<\n  [\n    typeof f1,\n    typeof f2,\n    typeof f3,\n    typeof f4,\n    typeof f5,\n    typeof f6,\n    typeof f7,\n    typeof f8,\n    typeof f9,\n    typeof f10,\n    typeof f11,\n    typeof f12,\n  ]\n>\n// 13 functions\nexport function flow<A extends unknown[], B, C, D, E, F, G, H, I, J, K, L, M, N>(\n  f1: (...args: A) => B,\n  f2: (arg: Awaited<B>) => C,\n  f3: (arg: Awaited<C>) => D,\n  f4: (arg: Awaited<D>) => E,\n  f5: (arg: Awaited<E>) => F,\n  f6: (arg: Awaited<F>) => G,\n  f7: (arg: Awaited<G>) => H,\n  f8: (arg: Awaited<H>) => I,\n  f9: (arg: Awaited<I>) => J,\n  f10: (arg: Awaited<J>) => K,\n  f11: (arg: Awaited<K>) => L,\n  f12: (arg: Awaited<L>) => M,\n  f13: (arg: Awaited<M>) => N,\n): FlowdFun<\n  [\n    typeof f1,\n    typeof f2,\n    typeof f3,\n    typeof f4,\n    typeof f5,\n    typeof f6,\n    typeof f7,\n    typeof f8,\n    typeof f9,\n    typeof f10,\n    typeof f11,\n    typeof f12,\n    typeof f13,\n  ]\n>\n// 14 functions\nexport function flow<A extends unknown[], B, C, D, E, F, G, H, I, J, K, L, M, N, O>(\n  f1: (...args: A) => B,\n  f2: (arg: Awaited<B>) => C,\n  f3: (arg: Awaited<C>) => D,\n  f4: (arg: Awaited<D>) => E,\n  f5: (arg: Awaited<E>) => F,\n  f6: (arg: Awaited<F>) => G,\n  f7: (arg: Awaited<G>) => H,\n  f8: (arg: Awaited<H>) => I,\n  f9: (arg: Awaited<I>) => J,\n  f10: (arg: Awaited<J>) => K,\n  f11: (arg: Awaited<K>) => L,\n  f12: (arg: Awaited<L>) => M,\n  f13: (arg: Awaited<M>) => N,\n  f14: (arg: Awaited<N>) => O,\n): FlowdFun<\n  [\n    typeof f1,\n    typeof f2,\n    typeof f3,\n    typeof f4,\n    typeof f5,\n    typeof f6,\n    typeof f7,\n    typeof f8,\n    typeof f9,\n    typeof f10,\n    typeof f11,\n    typeof f12,\n    typeof f13,\n    typeof f14,\n  ]\n>\n// 15 functions\nexport function flow<A extends unknown[], B, C, D, E, F, G, H, I, J, K, L, M, N, O, P>(\n  f1: (...args: A) => B,\n  f2: (arg: Awaited<B>) => C,\n  f3: (arg: Awaited<C>) => D,\n  f4: (arg: Awaited<D>) => E,\n  f5: (arg: Awaited<E>) => F,\n  f6: (arg: Awaited<F>) => G,\n  f7: (arg: Awaited<G>) => H,\n  f8: (arg: Awaited<H>) => I,\n  f9: (arg: Awaited<I>) => J,\n  f10: (arg: Awaited<J>) => K,\n  f11: (arg: Awaited<K>) => L,\n  f12: (arg: Awaited<L>) => M,\n  f13: (arg: Awaited<M>) => N,\n  f14: (arg: Awaited<N>) => O,\n  f15: (arg: Awaited<O>) => P,\n): FlowdFun<\n  [\n    typeof f1,\n    typeof f2,\n    typeof f3,\n    typeof f4,\n    typeof f5,\n    typeof f6,\n    typeof f7,\n    typeof f8,\n    typeof f9,\n    typeof f10,\n    typeof f11,\n    typeof f12,\n    typeof f13,\n    typeof f14,\n    typeof f15,\n  ]\n>\n// Implementation signature (fallback for 16+ functions)\nexport function flow<Fns extends [λ, ...λ[]]>(...fns: Fns): FlowdFun<Fns> {\n  // oxlint-disable-next-line\n  return ((...args) => {\n    // oxlint-disable-next-line\n    let nextArgs: unknown[] = args\n\n    for (let i = 0; i < fns.length; i++) {\n      // oxlint-disable-next-line\n      const [result] = (nextArgs = [fns[i]?.(...nextArgs)])\n      if (isPromise(result)) return resolveAsync(result, fns.slice(i + 1))\n    }\n\n    return nextArgs[0]\n  }) as FlowdFun<Fns>\n}\n\nconst resolveAsync = async (result: unknown, funs: λ[]) => {\n  // oxlint-disable-next-line\n  for (const fun of funs) result = fun(await result)\n  return await result\n}\n"],"mappings":"AAGA,SAAgB,EAAU,EAA+C,CAGvE,OAFI,IAAU,MACV,OAAO,GAAU,UAAY,OAAO,GAAU,WAAmB,GAC9D,OAAQ,EAA6B,MAAS,WC2SvD,SAAgB,EAA8B,GAAG,EAAyB,CAExE,QAAS,GAAG,IAAS,CAEnB,IAAI,EAAsB,EAE1B,IAAK,IAAI,EAAI,EAAG,EAAI,EAAI,OAAQ,IAAK,CAEnC,GAAM,CAAC,GAAW,EAAW,CAAC,EAAI,KAAK,GAAG,EAAS,CAAC,CACpD,GAAI,EAAU,EAAO,CAAE,OAAO,EAAa,EAAQ,EAAI,MAAM,EAAI,EAAE,CAAC,CAGtE,OAAO,EAAS,KAIpB,MAAM,EAAe,MAAO,EAAiB,IAAc,CAEzD,IAAK,IAAM,KAAO,EAAM,EAAS,EAAI,MAAM,EAAO,CAClD,OAAO,MAAM"}

package/dist/functions/index.d.mts

@@ -1,2 +1,2 @@
-import { n as flow, t as pipe } from "../index-D7mFNjot.mjs";
+import { n as flow, t as pipe } from "../index-BtPFPfja.mjs";
 export { flow, pipe };

package/dist/functions/index.mjs

@@ -1 +1 @@
-import{t as e}from"../flow-CNyLsPGb.mjs";import{t}from"../functions-ByAk682_.mjs";export{e as flow,t as pipe};
+import{t as e}from"../flow-D8_tllWl.mjs";import{t}from"../functions-DmOZ7O4j.mjs";export{e as flow,t as pipe};

package/dist/functions-DmOZ7O4j.mjs

@@ -0,0 +1,2 @@
+import{t as e}from"./flow-D8_tllWl.mjs";function t(t,...n){return e(...n)(t)}export{t};
+//# sourceMappingURL=functions-DmOZ7O4j.mjs.map

package/dist/{functions-ByAk682_.mjs.map → functions-DmOZ7O4j.mjs.map}

@@ -1 +1 @@
-{"version":3,"file":"functions-ByAk682_.mjs","names":[],"sources":["../src/functions/pipe.ts"],"sourcesContent":["/**\n * Data-first function composition utilities.\n *\n * **Mental model**\n * - `pipe(value, fn1, fn2...)` applies functions left-to-right.\n * - Supports sync/async chains and preserves type inference across overloads.\n *\n * **Common tasks**\n * - Build readable transformation pipelines.\n * - Mix sync and async functions in the same chain.\n *\n * **Gotchas**\n * - The first argument is always the input value.\n * - For point-free composition, use `flow`.\n *\n * **Quickstart**\n *\n * @example\n * ```ts\n * import { pipe } from \"@nicolastoulemont/std\"\n *\n * const result = pipe(2, (n) => n + 1, (n) => n * 2)\n * ```\n *\n * @module\n */\nimport type { λ } from \"../shared/lambda.types\"\nimport { flow } from \"./flow\"\nimport type { PipeReturn } from \"./pipe.types\"\n\n/**\n * Like `flow` but takes an argument as its first parameter and invokes the pipe\n * with it.\n *\n * Note: unlike in `flow`, the first function of the pipe must take exactly one\n * argument.\n *\n * Type inference: This function provides automatic type inference for chains of\n * 1-15 functions. Each function's parameter type is automatically inferred from\n * the previous function's return type. For chains longer than 15 functions,\n * types must be explicitly specified.\n *\n * Async support: Functions can return Promises. The runtime automatically awaits\n * Promises before passing values to subsequent functions, and parameter types\n * use `Awaited<T>` to reflect this behavior. The final return type will be\n * Promise<T> if any function returns a Promise.\n *\n * @see {@link flow} for point-free function composition (returns a function)\n *\n * @example\n * ```ts\n * import { pipe } from \"@nicolastoulemont/std\"\n *\n * const result = pipe(2, (n) => n + 1, (n) => n * 3)\n * // => 9\n * ```\n */\n// 1 function\nexport function pipe<A, B>(arg: A, f1: (arg: A) => B): PipeReturn<[typeof f1], A>\n// 2 functions\nexport function pipe<A, B, C>(\n  arg: A,\n  f1: (arg: A) => B,\n  f2: (arg: Awaited<B>) => C,\n): PipeReturn<[typeof f1, typeof f2], A>\n// 3 functions\nexport function pipe<A, B, C, D>(\n  arg: A,\n  f1: (arg: A) => B,\n  f2: (arg: Awaited<B>) => C,\n  f3: (arg: Awaited<C>) => D,\n): PipeReturn<[typeof f1, typeof f2, typeof f3], A>\n// 4 functions\nexport function pipe<A, B, C, D, E>(\n  arg: A,\n  f1: (arg: A) => B,\n  f2: (arg: Awaited<B>) => C,\n  f3: (arg: Awaited<C>) => D,\n  f4: (arg: Awaited<D>) => E,\n): PipeReturn<[typeof f1, typeof f2, typeof f3, typeof f4], A>\n// 5 functions\nexport function pipe<A, B, C, D, E, F>(\n  arg: A,\n  f1: (arg: A) => B,\n  f2: (arg: Awaited<B>) => C,\n  f3: (arg: Awaited<C>) => D,\n  f4: (arg: Awaited<D>) => E,\n  f5: (arg: Awaited<E>) => F,\n): PipeReturn<[typeof f1, typeof f2, typeof f3, typeof f4, typeof f5], A>\n// 6 functions\nexport function pipe<A, B, C, D, E, F, G>(\n  arg: A,\n  f1: (arg: A) => B,\n  f2: (arg: Awaited<B>) => C,\n  f3: (arg: Awaited<C>) => D,\n  f4: (arg: Awaited<D>) => E,\n  f5: (arg: Awaited<E>) => F,\n  f6: (arg: Awaited<F>) => G,\n): PipeReturn<[typeof f1, typeof f2, typeof f3, typeof f4, typeof f5, typeof f6], A>\n// 7 functions\nexport function pipe<A, B, C, D, E, F, G, H>(\n  arg: A,\n  f1: (arg: A) => B,\n  f2: (arg: Awaited<B>) => C,\n  f3: (arg: Awaited<C>) => D,\n  f4: (arg: Awaited<D>) => E,\n  f5: (arg: Awaited<E>) => F,\n  f6: (arg: Awaited<F>) => G,\n  f7: (arg: Awaited<G>) => H,\n): PipeReturn<[typeof f1, typeof f2, typeof f3, typeof f4, typeof f5, typeof f6, typeof f7], A>\n// 8 functions\nexport function pipe<A, B, C, D, E, F, G, H, I>(\n  arg: A,\n  f1: (arg: A) => B,\n  f2: (arg: Awaited<B>) => C,\n  f3: (arg: Awaited<C>) => D,\n  f4: (arg: Awaited<D>) => E,\n  f5: (arg: Awaited<E>) => F,\n  f6: (arg: Awaited<F>) => G,\n  f7: (arg: Awaited<G>) => H,\n  f8: (arg: Awaited<H>) => I,\n): PipeReturn<[typeof f1, typeof f2, typeof f3, typeof f4, typeof f5, typeof f6, typeof f7, typeof f8], A>\n// 9 functions\nexport function pipe<A, B, C, D, E, F, G, H, I, J>(\n  arg: A,\n  f1: (arg: A) => B,\n  f2: (arg: Awaited<B>) => C,\n  f3: (arg: Awaited<C>) => D,\n  f4: (arg: Awaited<D>) => E,\n  f5: (arg: Awaited<E>) => F,\n  f6: (arg: Awaited<F>) => G,\n  f7: (arg: Awaited<G>) => H,\n  f8: (arg: Awaited<H>) => I,\n  f9: (arg: Awaited<I>) => J,\n): PipeReturn<[typeof f1, typeof f2, typeof f3, typeof f4, typeof f5, typeof f6, typeof f7, typeof f8, typeof f9], A>\n// 10 functions\nexport function pipe<A, B, C, D, E, F, G, H, I, J, K>(\n  arg: A,\n  f1: (arg: A) => B,\n  f2: (arg: Awaited<B>) => C,\n  f3: (arg: Awaited<C>) => D,\n  f4: (arg: Awaited<D>) => E,\n  f5: (arg: Awaited<E>) => F,\n  f6: (arg: Awaited<F>) => G,\n  f7: (arg: Awaited<G>) => H,\n  f8: (arg: Awaited<H>) => I,\n  f9: (arg: Awaited<I>) => J,\n  f10: (arg: Awaited<J>) => K,\n): PipeReturn<\n  [typeof f1, typeof f2, typeof f3, typeof f4, typeof f5, typeof f6, typeof f7, typeof f8, typeof f9, typeof f10],\n  A\n>\n// 11 functions\nexport function pipe<A, B, C, D, E, F, G, H, I, J, K, L>(\n  arg: A,\n  f1: (arg: A) => B,\n  f2: (arg: Awaited<B>) => C,\n  f3: (arg: Awaited<C>) => D,\n  f4: (arg: Awaited<D>) => E,\n  f5: (arg: Awaited<E>) => F,\n  f6: (arg: Awaited<F>) => G,\n  f7: (arg: Awaited<G>) => H,\n  f8: (arg: Awaited<H>) => I,\n  f9: (arg: Awaited<I>) => J,\n  f10: (arg: Awaited<J>) => K,\n  f11: (arg: Awaited<K>) => L,\n): PipeReturn<\n  [\n    typeof f1,\n    typeof f2,\n    typeof f3,\n    typeof f4,\n    typeof f5,\n    typeof f6,\n    typeof f7,\n    typeof f8,\n    typeof f9,\n    typeof f10,\n    typeof f11,\n  ],\n  A\n>\n// 12 functions\nexport function pipe<A, B, C, D, E, F, G, H, I, J, K, L, M>(\n  arg: A,\n  f1: (arg: A) => B,\n  f2: (arg: Awaited<B>) => C,\n  f3: (arg: Awaited<C>) => D,\n  f4: (arg: Awaited<D>) => E,\n  f5: (arg: Awaited<E>) => F,\n  f6: (arg: Awaited<F>) => G,\n  f7: (arg: Awaited<G>) => H,\n  f8: (arg: Awaited<H>) => I,\n  f9: (arg: Awaited<I>) => J,\n  f10: (arg: Awaited<J>) => K,\n  f11: (arg: Awaited<K>) => L,\n  f12: (arg: Awaited<L>) => M,\n): PipeReturn<\n  [\n    typeof f1,\n    typeof f2,\n    typeof f3,\n    typeof f4,\n    typeof f5,\n    typeof f6,\n    typeof f7,\n    typeof f8,\n    typeof f9,\n    typeof f10,\n    typeof f11,\n    typeof f12,\n  ],\n  A\n>\n// 13 functions\nexport function pipe<A, B, C, D, E, F, G, H, I, J, K, L, M, N>(\n  arg: A,\n  f1: (arg: A) => B,\n  f2: (arg: Awaited<B>) => C,\n  f3: (arg: Awaited<C>) => D,\n  f4: (arg: Awaited<D>) => E,\n  f5: (arg: Awaited<E>) => F,\n  f6: (arg: Awaited<F>) => G,\n  f7: (arg: Awaited<G>) => H,\n  f8: (arg: Awaited<H>) => I,\n  f9: (arg: Awaited<I>) => J,\n  f10: (arg: Awaited<J>) => K,\n  f11: (arg: Awaited<K>) => L,\n  f12: (arg: Awaited<L>) => M,\n  f13: (arg: Awaited<M>) => N,\n): PipeReturn<\n  [\n    typeof f1,\n    typeof f2,\n    typeof f3,\n    typeof f4,\n    typeof f5,\n    typeof f6,\n    typeof f7,\n    typeof f8,\n    typeof f9,\n    typeof f10,\n    typeof f11,\n    typeof f12,\n    typeof f13,\n  ],\n  A\n>\n// 14 functions\nexport function pipe<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O>(\n  arg: A,\n  f1: (arg: A) => B,\n  f2: (arg: Awaited<B>) => C,\n  f3: (arg: Awaited<C>) => D,\n  f4: (arg: Awaited<D>) => E,\n  f5: (arg: Awaited<E>) => F,\n  f6: (arg: Awaited<F>) => G,\n  f7: (arg: Awaited<G>) => H,\n  f8: (arg: Awaited<H>) => I,\n  f9: (arg: Awaited<I>) => J,\n  f10: (arg: Awaited<J>) => K,\n  f11: (arg: Awaited<K>) => L,\n  f12: (arg: Awaited<L>) => M,\n  f13: (arg: Awaited<M>) => N,\n  f14: (arg: Awaited<N>) => O,\n): PipeReturn<\n  [\n    typeof f1,\n    typeof f2,\n    typeof f3,\n    typeof f4,\n    typeof f5,\n    typeof f6,\n    typeof f7,\n    typeof f8,\n    typeof f9,\n    typeof f10,\n    typeof f11,\n    typeof f12,\n    typeof f13,\n    typeof f14,\n  ],\n  A\n>\n// 15 functions\nexport function pipe<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P>(\n  arg: A,\n  f1: (arg: A) => B,\n  f2: (arg: Awaited<B>) => C,\n  f3: (arg: Awaited<C>) => D,\n  f4: (arg: Awaited<D>) => E,\n  f5: (arg: Awaited<E>) => F,\n  f6: (arg: Awaited<F>) => G,\n  f7: (arg: Awaited<G>) => H,\n  f8: (arg: Awaited<H>) => I,\n  f9: (arg: Awaited<I>) => J,\n  f10: (arg: Awaited<J>) => K,\n  f11: (arg: Awaited<K>) => L,\n  f12: (arg: Awaited<L>) => M,\n  f13: (arg: Awaited<M>) => N,\n  f14: (arg: Awaited<N>) => O,\n  f15: (arg: Awaited<O>) => P,\n): PipeReturn<\n  [\n    typeof f1,\n    typeof f2,\n    typeof f3,\n    typeof f4,\n    typeof f5,\n    typeof f6,\n    typeof f7,\n    typeof f8,\n    typeof f9,\n    typeof f10,\n    typeof f11,\n    typeof f12,\n    typeof f13,\n    typeof f14,\n    typeof f15,\n  ],\n  A\n>\n// Implementation signature (fallback for 16+ functions)\n// oxlint-disable-next-line no-explicit-any\nexport function pipe<A, Fns extends [(arg: A) => any, ...λ[]]>(arg: A, ...fns: Fns): PipeReturn<Fns, A> {\n  // @ts-expect-error - we want to use the any type here\n  // oxlint-disable-next-line no-explicit-any, no-unsafe-return, no-unsafe-call, no-unsafe-type-assertion -- Required for pipe implementation\n  return (flow(...(fns as [λ, ...λ[]])) as any)(arg)\n}\n"],"mappings":"wCAoUA,SAAgB,EAA+C,EAAQ,GAAG,EAA8B,CAGtG,OAAQ,EAAK,GAAI,EAAoB,CAAS,EAAI"}
+{"version":3,"file":"functions-DmOZ7O4j.mjs","names":[],"sources":["../src/functions/pipe.ts"],"sourcesContent":["/**\n * Data-first function composition utilities.\n *\n * **Mental model**\n * - `pipe(value, fn1, fn2...)` applies functions left-to-right.\n * - Supports sync/async chains and preserves type inference across overloads.\n *\n * **Common tasks**\n * - Build readable transformation pipelines.\n * - Mix sync and async functions in the same chain.\n *\n * **Gotchas**\n * - The first argument is always the input value.\n * - For point-free composition, use `flow`.\n *\n * **Quickstart**\n *\n * @example\n * ```ts\n * import { pipe } from \"@nicolastoulemont/std\"\n *\n * const result = pipe(2, (n) => n + 1, (n) => n * 2)\n * ```\n *\n * @module\n */\nimport type { λ } from \"../shared/lambda.types\"\nimport { flow } from \"./flow\"\nimport type { PipeReturn } from \"./pipe.types\"\n\n/**\n * Like `flow` but takes an argument as its first parameter and invokes the pipe\n * with it.\n *\n * Note: unlike in `flow`, the first function of the pipe must take exactly one\n * argument.\n *\n * Type inference: This function provides automatic type inference for chains of\n * 1-15 functions. Each function's parameter type is automatically inferred from\n * the previous function's return type. For chains longer than 15 functions,\n * types must be explicitly specified.\n *\n * Async support: Functions can return Promises. The runtime automatically awaits\n * Promises before passing values to subsequent functions, and parameter types\n * use `Awaited<T>` to reflect this behavior. The final return type will be\n * Promise<T> if any function returns a Promise.\n *\n * @see {@link flow} for point-free function composition (returns a function)\n *\n * @example\n * ```ts\n * import { pipe } from \"@nicolastoulemont/std\"\n *\n * const result = pipe(2, (n) => n + 1, (n) => n * 3)\n * // => 9\n * ```\n */\n// 1 function\nexport function pipe<A, B>(arg: A, f1: (arg: A) => B): PipeReturn<[typeof f1], A>\n// 2 functions\nexport function pipe<A, B, C>(\n  arg: A,\n  f1: (arg: A) => B,\n  f2: (arg: Awaited<B>) => C,\n): PipeReturn<[typeof f1, typeof f2], A>\n// 3 functions\nexport function pipe<A, B, C, D>(\n  arg: A,\n  f1: (arg: A) => B,\n  f2: (arg: Awaited<B>) => C,\n  f3: (arg: Awaited<C>) => D,\n): PipeReturn<[typeof f1, typeof f2, typeof f3], A>\n// 4 functions\nexport function pipe<A, B, C, D, E>(\n  arg: A,\n  f1: (arg: A) => B,\n  f2: (arg: Awaited<B>) => C,\n  f3: (arg: Awaited<C>) => D,\n  f4: (arg: Awaited<D>) => E,\n): PipeReturn<[typeof f1, typeof f2, typeof f3, typeof f4], A>\n// 5 functions\nexport function pipe<A, B, C, D, E, F>(\n  arg: A,\n  f1: (arg: A) => B,\n  f2: (arg: Awaited<B>) => C,\n  f3: (arg: Awaited<C>) => D,\n  f4: (arg: Awaited<D>) => E,\n  f5: (arg: Awaited<E>) => F,\n): PipeReturn<[typeof f1, typeof f2, typeof f3, typeof f4, typeof f5], A>\n// 6 functions\nexport function pipe<A, B, C, D, E, F, G>(\n  arg: A,\n  f1: (arg: A) => B,\n  f2: (arg: Awaited<B>) => C,\n  f3: (arg: Awaited<C>) => D,\n  f4: (arg: Awaited<D>) => E,\n  f5: (arg: Awaited<E>) => F,\n  f6: (arg: Awaited<F>) => G,\n): PipeReturn<[typeof f1, typeof f2, typeof f3, typeof f4, typeof f5, typeof f6], A>\n// 7 functions\nexport function pipe<A, B, C, D, E, F, G, H>(\n  arg: A,\n  f1: (arg: A) => B,\n  f2: (arg: Awaited<B>) => C,\n  f3: (arg: Awaited<C>) => D,\n  f4: (arg: Awaited<D>) => E,\n  f5: (arg: Awaited<E>) => F,\n  f6: (arg: Awaited<F>) => G,\n  f7: (arg: Awaited<G>) => H,\n): PipeReturn<[typeof f1, typeof f2, typeof f3, typeof f4, typeof f5, typeof f6, typeof f7], A>\n// 8 functions\nexport function pipe<A, B, C, D, E, F, G, H, I>(\n  arg: A,\n  f1: (arg: A) => B,\n  f2: (arg: Awaited<B>) => C,\n  f3: (arg: Awaited<C>) => D,\n  f4: (arg: Awaited<D>) => E,\n  f5: (arg: Awaited<E>) => F,\n  f6: (arg: Awaited<F>) => G,\n  f7: (arg: Awaited<G>) => H,\n  f8: (arg: Awaited<H>) => I,\n): PipeReturn<[typeof f1, typeof f2, typeof f3, typeof f4, typeof f5, typeof f6, typeof f7, typeof f8], A>\n// 9 functions\nexport function pipe<A, B, C, D, E, F, G, H, I, J>(\n  arg: A,\n  f1: (arg: A) => B,\n  f2: (arg: Awaited<B>) => C,\n  f3: (arg: Awaited<C>) => D,\n  f4: (arg: Awaited<D>) => E,\n  f5: (arg: Awaited<E>) => F,\n  f6: (arg: Awaited<F>) => G,\n  f7: (arg: Awaited<G>) => H,\n  f8: (arg: Awaited<H>) => I,\n  f9: (arg: Awaited<I>) => J,\n): PipeReturn<[typeof f1, typeof f2, typeof f3, typeof f4, typeof f5, typeof f6, typeof f7, typeof f8, typeof f9], A>\n// 10 functions\nexport function pipe<A, B, C, D, E, F, G, H, I, J, K>(\n  arg: A,\n  f1: (arg: A) => B,\n  f2: (arg: Awaited<B>) => C,\n  f3: (arg: Awaited<C>) => D,\n  f4: (arg: Awaited<D>) => E,\n  f5: (arg: Awaited<E>) => F,\n  f6: (arg: Awaited<F>) => G,\n  f7: (arg: Awaited<G>) => H,\n  f8: (arg: Awaited<H>) => I,\n  f9: (arg: Awaited<I>) => J,\n  f10: (arg: Awaited<J>) => K,\n): PipeReturn<\n  [typeof f1, typeof f2, typeof f3, typeof f4, typeof f5, typeof f6, typeof f7, typeof f8, typeof f9, typeof f10],\n  A\n>\n// 11 functions\nexport function pipe<A, B, C, D, E, F, G, H, I, J, K, L>(\n  arg: A,\n  f1: (arg: A) => B,\n  f2: (arg: Awaited<B>) => C,\n  f3: (arg: Awaited<C>) => D,\n  f4: (arg: Awaited<D>) => E,\n  f5: (arg: Awaited<E>) => F,\n  f6: (arg: Awaited<F>) => G,\n  f7: (arg: Awaited<G>) => H,\n  f8: (arg: Awaited<H>) => I,\n  f9: (arg: Awaited<I>) => J,\n  f10: (arg: Awaited<J>) => K,\n  f11: (arg: Awaited<K>) => L,\n): PipeReturn<\n  [\n    typeof f1,\n    typeof f2,\n    typeof f3,\n    typeof f4,\n    typeof f5,\n    typeof f6,\n    typeof f7,\n    typeof f8,\n    typeof f9,\n    typeof f10,\n    typeof f11,\n  ],\n  A\n>\n// 12 functions\nexport function pipe<A, B, C, D, E, F, G, H, I, J, K, L, M>(\n  arg: A,\n  f1: (arg: A) => B,\n  f2: (arg: Awaited<B>) => C,\n  f3: (arg: Awaited<C>) => D,\n  f4: (arg: Awaited<D>) => E,\n  f5: (arg: Awaited<E>) => F,\n  f6: (arg: Awaited<F>) => G,\n  f7: (arg: Awaited<G>) => H,\n  f8: (arg: Awaited<H>) => I,\n  f9: (arg: Awaited<I>) => J,\n  f10: (arg: Awaited<J>) => K,\n  f11: (arg: Awaited<K>) => L,\n  f12: (arg: Awaited<L>) => M,\n): PipeReturn<\n  [\n    typeof f1,\n    typeof f2,\n    typeof f3,\n    typeof f4,\n    typeof f5,\n    typeof f6,\n    typeof f7,\n    typeof f8,\n    typeof f9,\n    typeof f10,\n    typeof f11,\n    typeof f12,\n  ],\n  A\n>\n// 13 functions\nexport function pipe<A, B, C, D, E, F, G, H, I, J, K, L, M, N>(\n  arg: A,\n  f1: (arg: A) => B,\n  f2: (arg: Awaited<B>) => C,\n  f3: (arg: Awaited<C>) => D,\n  f4: (arg: Awaited<D>) => E,\n  f5: (arg: Awaited<E>) => F,\n  f6: (arg: Awaited<F>) => G,\n  f7: (arg: Awaited<G>) => H,\n  f8: (arg: Awaited<H>) => I,\n  f9: (arg: Awaited<I>) => J,\n  f10: (arg: Awaited<J>) => K,\n  f11: (arg: Awaited<K>) => L,\n  f12: (arg: Awaited<L>) => M,\n  f13: (arg: Awaited<M>) => N,\n): PipeReturn<\n  [\n    typeof f1,\n    typeof f2,\n    typeof f3,\n    typeof f4,\n    typeof f5,\n    typeof f6,\n    typeof f7,\n    typeof f8,\n    typeof f9,\n    typeof f10,\n    typeof f11,\n    typeof f12,\n    typeof f13,\n  ],\n  A\n>\n// 14 functions\nexport function pipe<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O>(\n  arg: A,\n  f1: (arg: A) => B,\n  f2: (arg: Awaited<B>) => C,\n  f3: (arg: Awaited<C>) => D,\n  f4: (arg: Awaited<D>) => E,\n  f5: (arg: Awaited<E>) => F,\n  f6: (arg: Awaited<F>) => G,\n  f7: (arg: Awaited<G>) => H,\n  f8: (arg: Awaited<H>) => I,\n  f9: (arg: Awaited<I>) => J,\n  f10: (arg: Awaited<J>) => K,\n  f11: (arg: Awaited<K>) => L,\n  f12: (arg: Awaited<L>) => M,\n  f13: (arg: Awaited<M>) => N,\n  f14: (arg: Awaited<N>) => O,\n): PipeReturn<\n  [\n    typeof f1,\n    typeof f2,\n    typeof f3,\n    typeof f4,\n    typeof f5,\n    typeof f6,\n    typeof f7,\n    typeof f8,\n    typeof f9,\n    typeof f10,\n    typeof f11,\n    typeof f12,\n    typeof f13,\n    typeof f14,\n  ],\n  A\n>\n// 15 functions\nexport function pipe<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P>(\n  arg: A,\n  f1: (arg: A) => B,\n  f2: (arg: Awaited<B>) => C,\n  f3: (arg: Awaited<C>) => D,\n  f4: (arg: Awaited<D>) => E,\n  f5: (arg: Awaited<E>) => F,\n  f6: (arg: Awaited<F>) => G,\n  f7: (arg: Awaited<G>) => H,\n  f8: (arg: Awaited<H>) => I,\n  f9: (arg: Awaited<I>) => J,\n  f10: (arg: Awaited<J>) => K,\n  f11: (arg: Awaited<K>) => L,\n  f12: (arg: Awaited<L>) => M,\n  f13: (arg: Awaited<M>) => N,\n  f14: (arg: Awaited<N>) => O,\n  f15: (arg: Awaited<O>) => P,\n): PipeReturn<\n  [\n    typeof f1,\n    typeof f2,\n    typeof f3,\n    typeof f4,\n    typeof f5,\n    typeof f6,\n    typeof f7,\n    typeof f8,\n    typeof f9,\n    typeof f10,\n    typeof f11,\n    typeof f12,\n    typeof f13,\n    typeof f14,\n    typeof f15,\n  ],\n  A\n>\n// Implementation signature (fallback for 16+ functions)\n// oxlint-disable-next-line no-explicit-any\nexport function pipe<A, Fns extends [(arg: A) => any, ...λ[]]>(arg: A, ...fns: Fns): PipeReturn<Fns, A> {\n  // @ts-expect-error - we want to use the any type here\n  // oxlint-disable-next-line no-explicit-any, no-unsafe-return, no-unsafe-call, no-unsafe-type-assertion -- Required for pipe implementation\n  return (flow(...(fns as [λ, ...λ[]])) as any)(arg)\n}\n"],"mappings":"wCAoUA,SAAgB,EAA+C,EAAQ,GAAG,EAA8B,CAGtG,OAAQ,EAAK,GAAI,EAAoB,CAAS,EAAI"}

package/dist/fx/index.d.mts

@@ -1,2 +1,2 @@
-import { t as fx_d_exports } from "../index-BD-els5J.mjs";
+import { t as fx_d_exports } from "../index-CIEdspey.mjs";
 export { fx_d_exports as Fx };

package/dist/fx/index.mjs

@@ -1 +1 @@
-import{t as e}from"../fx-C_RTDEpv.mjs";export{e as Fx};
+import{t as e}from"../fx-DXBw4iYX.mjs";export{e as Fx};

package/dist/fx-DXBw4iYX.mjs

@@ -0,0 +1,2 @@
+import{t as e}from"./chunk-6rpU2rUb.mjs";import{n as t,t as n}from"./fx.types-Bg-Mmdm5.mjs";import{t as r}from"./dual-CZhzZslG.mjs";import{i,n as a,t as o}from"./result-C74pRN2x.mjs";import{t as s}from"./option.types-bFFSErJ-.mjs";import{t as c}from"./option-BlyP5LA2.mjs";import{b as l,d as u,f as d,n as f,s as p,u as m,v as h,y as g}from"./fx.runtime-B2_rL7h_.mjs";import{n as _,t as v}from"./trace-ByjppUes.mjs";import{i as y,n as b,r as x,t as S}from"./queue-CeEIUHcY.mjs";var C=class extends Error{_tag=`TypedFailure`;constructor(e){super(`TypedFailure`),this.error=e,this.name=`TypedFailure`}};const w=e=>e instanceof C,T=e=>typeof e==`object`&&!!e&&`_tag`in e&&e._tag===`Err`&&`error`in e,E=e=>e instanceof s?e:T(e)?e.error:e,D=e=>e!=null&&typeof e[Symbol.iterator]==`function`,O=e=>new x({reason:e.reason}),k=e=>e instanceof Error?e:Error(`Fx.forEach defect was not an Error`,{cause:e}),ee=()=>{throw Error(`Unreachable: Fx type marker should never execute at runtime`)},A=()=>ee,j=async(e,t,n)=>{if(e._tag===`AsyncFx`){let r=e[Symbol.asyncIterator](),i=await r.next();for(;i.done!==!0;){if(t.aborted)throw O(t);let e=i.value;if(l(e)!==void 0||p(e)){let a=await n(e,t);i=await r.next(a);continue}throw new C(E(e))}return i.value}let r=e[Symbol.iterator](),i=r.next();for(;i.done!==!0;){if(t.aborted)throw O(t);let e=i.value;if(l(e)!==void 0||p(e)){let a=await n(e,t);i=r.next(a);continue}throw new C(E(e))}return i.value},M=r(e=>D(e[0])&&typeof e[1]==`function`,(e,t,r)=>{let i=[...e],a=r?.discard===!0;return{_tag:`AsyncFx`,[n]:{_A:A(),_E:A(),_R:A()},async*[Symbol.asyncIterator](){if(i.length===0)return a?void 0:[];let e=y({concurrency:r?.concurrency??`unbounded`}),n=a?void 0:[],o=i.length,s,c,l=!1,u=[],d=new Set,f=()=>{for(let e of d)e();d.clear()},p=()=>new Promise(e=>{d.add(e)}),m=(e,t)=>t.aborted?Promise.reject(O(t)):new Promise((n,r)=>{let i={yielded:e,signal:t,resolve:e=>{t.removeEventListener(`abort`,a),n(e)},reject:e=>{t.removeEventListener(`abort`,a),r(e)}},a=()=>{let e=u.indexOf(i);e!==-1&&u.splice(e,1),r(O(t))};t.addEventListener(`abort`,a,{once:!0}),u.push(i),f()}),h=e=>{let t=u.splice(0);for(let n of t)n.reject(e)},g=t=>{l||(l=!0,e.shutdown({mode:`abort`,reason:t}).catch(()=>{}))},_=e=>{if(w(e)){s===void 0&&c===void 0&&(s=e.error,g(e.error));return}if(!((e instanceof S||e instanceof x||e instanceof b)&&(s!==void 0||c!==void 0))&&c===void 0&&s===void 0){let t=k(e);c=t,g(t)}},v=()=>{--o,f()};for(let[r,a]of i.entries())e.enqueue(async({signal:e})=>{let i=await j(t(a,r),e,m);n!==void 0&&(n[r]=i)}).catch(_).finally(v);for(;;){if(c!==void 0)throw h(c),Error(`Fx.forEach defect`,{cause:c});if(s!==void 0)throw h(new S({reason:s})),yield s,Error(`Unreachable: Fx runtime short-circuits on first failure`);let e=u.shift();if(e!==void 0){if(e.signal.aborted){e.reject(O(e.signal));continue}try{let t=yield e.yielded;e.resolve(t)}catch(t){e.reject(k(t))}continue}if(o===0)break;await p()}return a?void 0:n}}});var N=e({Exit:()=>g,FxTypeId:()=>n,err:()=>$,fn:()=>Y,forEach:()=>ae,forkChild:()=>Q,forkDetach:()=>ne,gen:()=>J,isServiceRequest:()=>t,match:()=>le,ok:()=>oe,option:()=>se,retry:()=>ie,run:()=>X,runFork:()=>Z,try:()=>ce,yieldNow:()=>re});function P(e){return e._tag===`AsyncFx`?m(e):d(e)}const F=e=>new Promise(t=>{setTimeout(t,e)}),I=async e=>{e<=0||await F(e)},L=e=>{typeof e.return==`function`&&e.return(void 0)},R=async e=>{typeof e.return==`function`&&await e.return(void 0)},z=(e,t)=>({_tag:`SyncFx`,[n]:{_A:()=>void 0,_E:()=>void 0,_R:()=>void 0},*[Symbol.iterator](){let n=0;attemptLoop:for(;;){let r=e[Symbol.iterator](),i=r.next();for(;i.done!==!0;){let e=i.value;if(l(e)!==void 0||p(e)){let t=yield e;i=r.next(t);continue}if(n+=1,n<=t.maxRetries){L(r);continue attemptLoop}yield e;return}return i.value}}}),B=(e,t)=>({_tag:`AsyncFx`,[n]:{_A:()=>void 0,_E:()=>void 0,_R:()=>void 0},async*[Symbol.asyncIterator](){let n=0;attemptLoop:for(;;){if(e._tag===`AsyncFx`){let r=e[Symbol.asyncIterator](),i=await r.next();for(;i.done!==!0;){let e=i.value;if(l(e)!==void 0||p(e)){let t=yield e;i=await r.next(t);continue}if(n+=1,n<=t.maxRetries){await I(t.delayForAttempt(n)),await R(r);continue attemptLoop}return yield e,void 0}return i.value}let r=e[Symbol.iterator](),i=r.next();for(;i.done!==!0;){let e=i.value;if(l(e)!==void 0||p(e)){let t=yield e;i=r.next(t);continue}if(n+=1,n<=t.maxRetries){await I(t.delayForAttempt(n)),await R(r);continue attemptLoop}return yield e,void 0}return i.value}}}),V=r(2,(e,t)=>e._tag===`AsyncFx`||!t._sync?B(e,t):z(e,t));function H(...e){let t=typeof e[0]==`function`?void 0:e[0],r=t===void 0?e[0]:e[1];if(r.length>0)return(...e)=>{let n=H(()=>r(...e)),i=typeof t==`object`?t.span:t;if(i===void 0)return n;let a=v(i,e);return _(a.name,n,a.options)};let i=r();if(Symbol.asyncIterator in i){let e={_tag:`AsyncFx`,[n]:{_A:()=>void 0,_E:()=>void 0,_R:()=>void 0},async*[Symbol.asyncIterator](){let e=r(),t=await e.next();for(;t.done!==!0;){let n=yield t.value;t=await e.next(n)}return t.value}},i=typeof t==`object`?t.span:t;if(i===void 0)return e;let a=v(i,[]);return _(a.name,e,a.options)}let a={_tag:`SyncFx`,[n]:{_A:()=>void 0,_E:()=>void 0,_R:()=>void 0},*[Symbol.iterator](){let e=r(),t=e.next();for(;t.done!==!0;){let n=yield t.value;t=e.next(n)}return t.value}},o=typeof t==`object`?t.span:t;if(o===void 0)return a;let s=v(o,[]);return _(s.name,a,s.options)}function U(...e){let t=typeof e[0]==`function`?void 0:e[0],n=t===void 0?e[0]:e[1],r=t===void 0?e[1]:e[2],i=H,a=t===void 0?i(n):i(t,n);return P(r?(a._tag,r(a)):a)}const W=i,G=o,te=a,K=c,q=r(2,(e,t)=>t[e._tag](e)),J=H,Y=U,X=P,Z=u,Q=e=>f(e,!1),ne=e=>f(e,!0),re=h,ie=V,ae=M,oe=W,$=G,se=K,ce=te,le=q;export{N as t};
+//# sourceMappingURL=fx-DXBw4iYX.mjs.map

package/dist/fx-DXBw4iYX.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"fx-DXBw4iYX.mjs","names":["gen","result","makeQueue","gen","result","fx","span","resolved","traceSpan","resultOk","resultErr","resultTry","optionFromNullable","runtimeRunFork","runtimeYieldNow"],"sources":["../src/fx/foreach.ts","../src/fx/fx.ts"],"sourcesContent":["import { NoSuchElementError } from \"../option/option.types\"\nimport { make as makeQueue, QueueAbortedError, QueueClosedError, QueueTaskAbortedError } from \"../queue/queue\"\nimport type { Concurrency } from \"../queue/queue.types\"\nimport { asServiceRequest } from \"../service/service-resolution\"\nimport { dual } from \"../shared/dual\"\nimport { isRuntimeInstruction } from \"./fx.runtime\"\nimport { FxTypeId } from \"./fx.types\"\nimport type { AsyncFx, FxError, FxRequirements, FxValue, FxYield, RunnableFx } from \"./fx.types\"\n\n/* oxlint-disable no-await-in-loop -- Fx.forEach coordinates child iterators and queue scheduling sequentially at specific yield points. */\n\ntype ForEachValue<Discard extends boolean, B> = Discard extends true ? void : Array<B>\n\ntype FxForEachOptions<Discard extends boolean = false> = {\n  readonly concurrency?: Concurrency\n  readonly discard?: Discard\n}\n\ntype ForEachFx<\n  F extends (a: never, i: number) => RunnableFx<unknown, unknown, unknown>,\n  Discard extends boolean,\n> = AsyncFx<ForEachValue<Discard, FxValue<ReturnType<F>>>, FxError<ReturnType<F>>, FxRequirements<ReturnType<F>>>\n\ntype FxForEach = {\n  <A, F extends (a: A, i: number) => RunnableFx<unknown, unknown, unknown>, const Discard extends boolean = false>(\n    self: Iterable<A>,\n    f: F,\n    options?: FxForEachOptions<Discard>,\n  ): ForEachFx<F, Discard>\n  <A, F extends (a: A, i: number) => RunnableFx<unknown, unknown, unknown>, const Discard extends boolean = false>(\n    f: F,\n    options?: FxForEachOptions<Discard>,\n  ): (self: Iterable<A>) => ForEachFx<F, Discard>\n}\n\ntype ServiceRequestEntry<E, R> = {\n  readonly yielded: FxYield<E, R>\n  readonly signal: AbortSignal\n  readonly resolve: (value: unknown) => void\n  readonly reject: (reason: Error) => void\n}\n\ntype ResultErrShape = {\n  readonly _tag: \"Err\"\n  readonly error: unknown\n}\n\nclass TypedFailure<E> extends Error {\n  readonly _tag = \"TypedFailure\"\n\n  constructor(readonly error: E) {\n    super(\"TypedFailure\")\n    this.name = \"TypedFailure\"\n  }\n}\n\nconst isTypedFailure = <E>(value: unknown): value is TypedFailure<E> => value instanceof TypedFailure\n\nconst isResultErr = (value: unknown): value is ResultErrShape =>\n  typeof value === \"object\" && value !== null && \"_tag\" in value && value._tag === \"Err\" && \"error\" in value\n\nconst toFailureValue = (yielded: unknown): unknown => {\n  if (yielded instanceof NoSuchElementError) {\n    return yielded\n  }\n\n  if (isResultErr(yielded)) {\n    return yielded.error\n  }\n\n  return yielded\n}\n\nconst isIterable = (value: unknown): value is Iterable<unknown> =>\n  value !== null &&\n  value !== undefined &&\n  typeof (value as { [Symbol.iterator]?: unknown })[Symbol.iterator] === \"function\"\n\nconst queueTaskAbortedError = (signal: AbortSignal): QueueTaskAbortedError =>\n  new QueueTaskAbortedError({ reason: signal.reason })\n\nconst toError = (reason: unknown): Error =>\n  reason instanceof Error ? reason : new Error(\"Fx.forEach defect was not an Error\", { cause: reason })\n\nconst unreachableType = (): never => {\n  throw new Error(\"Unreachable: Fx type marker should never execute at runtime\")\n}\n\nconst typeMarker = <A>(): (() => A) => unreachableType\n\nconst runMappedFx = async <B, E, R>(\n  fx: RunnableFx<B, E, R>,\n  signal: AbortSignal,\n  requestService: (yielded: FxYield<E, R>, signal: AbortSignal) => Promise<unknown>,\n): Promise<B> => {\n  if (fx._tag === \"AsyncFx\") {\n    const gen = fx[Symbol.asyncIterator]()\n    let result = await gen.next()\n\n    while (result.done !== true) {\n      if (signal.aborted) {\n        throw queueTaskAbortedError(signal)\n      }\n\n      const yielded = result.value\n      const serviceRequest = asServiceRequest(yielded)\n      if (serviceRequest !== undefined || isRuntimeInstruction(yielded)) {\n        const injected = await requestService(yielded, signal)\n        result = await gen.next(injected)\n        continue\n      }\n\n      // oxlint-disable-next-line typescript-eslint/no-unsafe-type-assertion -- failure channel values come from generic E at runtime.\n      throw new TypedFailure<E>(toFailureValue(yielded) as E)\n    }\n\n    return result.value\n  }\n\n  const gen = fx[Symbol.iterator]()\n  let result = gen.next()\n\n  while (result.done !== true) {\n    if (signal.aborted) {\n      throw queueTaskAbortedError(signal)\n    }\n\n    const yielded = result.value\n    const serviceRequest = asServiceRequest(yielded)\n    if (serviceRequest !== undefined || isRuntimeInstruction(yielded)) {\n      const injected = await requestService(yielded, signal)\n      result = gen.next(injected)\n      continue\n    }\n\n    // oxlint-disable-next-line typescript-eslint/no-unsafe-type-assertion -- failure channel values come from generic E at runtime.\n    throw new TypedFailure<E>(toFailureValue(yielded) as E)\n  }\n\n  return result.value\n}\n\nconst fxForEach = dual(\n  (args) => isIterable(args[0]) && typeof args[1] === \"function\",\n  <A, B, E, R>(\n    self: Iterable<A>,\n    f: (a: A, i: number) => RunnableFx<B, E, R>,\n    options?: FxForEachOptions<boolean>,\n  ): AsyncFx<Array<B> | void, E, R> => {\n    const items = [...self]\n    const discard = options?.discard === true\n\n    const program: AsyncFx<Array<B> | void, E, R> = {\n      _tag: \"AsyncFx\",\n      [FxTypeId]: {\n        _A: typeMarker<Array<B> | void>(),\n        _E: typeMarker<E>(),\n        _R: typeMarker<R>(),\n      },\n      async *[Symbol.asyncIterator](): AsyncGenerator<FxYield<E, R>, Array<B> | void, unknown> {\n        if (items.length === 0) {\n          return discard ? undefined : []\n        }\n\n        const queue = makeQueue({ concurrency: options?.concurrency ?? \"unbounded\" })\n        const results: Array<B> | undefined = discard ? undefined : []\n\n        let remaining = items.length\n        let firstFailure: E | undefined\n        let firstDefect: Error | undefined\n        let queueAborted = false\n\n        const serviceRequests: ServiceRequestEntry<E, R>[] = []\n        const eventWaiters = new Set<() => void>()\n\n        const notifyEvent = () => {\n          for (const resolve of eventWaiters) {\n            resolve()\n          }\n          eventWaiters.clear()\n        }\n\n        const waitForEvent = () =>\n          new Promise<void>((resolve) => {\n            eventWaiters.add(resolve)\n          })\n\n        const requestService = (yielded: FxYield<E, R>, signal: AbortSignal): Promise<unknown> => {\n          if (signal.aborted) {\n            return Promise.reject(queueTaskAbortedError(signal))\n          }\n\n          return new Promise<unknown>((resolve, reject) => {\n            const entry: ServiceRequestEntry<E, R> = {\n              yielded,\n              signal,\n              resolve: (value) => {\n                signal.removeEventListener(\"abort\", onAbort)\n                resolve(value)\n              },\n              reject: (reason) => {\n                signal.removeEventListener(\"abort\", onAbort)\n                reject(reason)\n              },\n            }\n\n            const onAbort = () => {\n              const index = serviceRequests.indexOf(entry)\n              if (index !== -1) {\n                serviceRequests.splice(index, 1)\n              }\n              reject(queueTaskAbortedError(signal))\n            }\n\n            signal.addEventListener(\"abort\", onAbort, { once: true })\n            serviceRequests.push(entry)\n            notifyEvent()\n          })\n        }\n\n        const rejectPendingServiceRequests = (reason: Error) => {\n          const pending = serviceRequests.splice(0)\n          for (const request of pending) {\n            request.reject(reason)\n          }\n        }\n\n        const abortQueue = (reason: unknown) => {\n          if (queueAborted) {\n            return\n          }\n\n          queueAborted = true\n          void queue.shutdown({ mode: \"abort\", reason }).catch(() => {\n            // no-op: fail-fast cleanup should never interrupt parent error handling\n          })\n        }\n\n        const onTaskFailure = (error: unknown) => {\n          if (isTypedFailure<E>(error)) {\n            if (firstFailure === undefined && firstDefect === undefined) {\n              firstFailure = error.error\n              abortQueue(error.error)\n            }\n            return\n          }\n\n          if (\n            (error instanceof QueueAbortedError ||\n              error instanceof QueueTaskAbortedError ||\n              error instanceof QueueClosedError) &&\n            (firstFailure !== undefined || firstDefect !== undefined)\n          ) {\n            return\n          }\n\n          if (firstDefect === undefined && firstFailure === undefined) {\n            const defect = toError(error)\n            firstDefect = defect\n            abortQueue(defect)\n          }\n        }\n\n        const onTaskSettled = () => {\n          remaining -= 1\n          notifyEvent()\n        }\n\n        for (const [index, item] of items.entries()) {\n          void queue\n            .enqueue(async ({ signal }) => {\n              const value = await runMappedFx(f(item, index), signal, requestService)\n              if (results !== undefined) {\n                results[index] = value\n              }\n            })\n            .catch(onTaskFailure)\n            .finally(onTaskSettled)\n        }\n\n        while (true) {\n          if (firstDefect !== undefined) {\n            rejectPendingServiceRequests(firstDefect)\n            throw new Error(\"Fx.forEach defect\", { cause: firstDefect })\n          }\n\n          if (firstFailure !== undefined) {\n            rejectPendingServiceRequests(new QueueAbortedError({ reason: firstFailure }))\n            yield firstFailure\n            throw new Error(\"Unreachable: Fx runtime short-circuits on first failure\")\n          }\n\n          const request = serviceRequests.shift()\n          if (request !== undefined) {\n            if (request.signal.aborted) {\n              request.reject(queueTaskAbortedError(request.signal))\n              continue\n            }\n\n            try {\n              const injected = yield request.yielded\n              request.resolve(injected)\n            } catch (error) {\n              request.reject(toError(error))\n            }\n            continue\n          }\n\n          if (remaining === 0) {\n            break\n          }\n\n          await waitForEvent()\n        }\n\n        return discard ? undefined : results\n      },\n    }\n\n    return program\n  },\n) as FxForEach\n\nexport { fxForEach as forEach }\n\n/* oxlint-enable no-await-in-loop */\n","/**\n * Lightweight effect runtime with typed success, error, and requirement channels.\n *\n * **Mental model**\n * - `Fx<A, E, R>` models computations that may fail and require services.\n * - Build with `Fx.gen`, run with `Fx.run`, and compose with `Layer`/`Provide`.\n *\n * **Common tasks**\n * - Create workflows with `Fx.gen`.\n * - Execute with `Fx.run` or `Fx.fn`.\n * - Retry with `Fx.retry` and match outcomes with `Fx.match`.\n *\n * **Gotchas**\n * - Dependencies (`R`) must be provided before execution.\n * - `Fx.run` returns `Exit`, not raw values.\n *\n * **Quickstart**\n *\n * @example\n * ```ts\n * import { Fx } from \"@nicolastoulemont/std\"\n *\n * const program = Fx.gen(function* () {\n *   const value = yield* Fx.ok(2)\n *   return value + 1\n * })\n * const exit = Fx.run(program)\n * // => { _tag: \"Ok\", value: 3 }\n * ```\n *\n * @module\n */\nimport { fromNullable as optionFromNullable } from \"../option/option\"\nimport { ok as resultOk, err as resultErr, fromTry as resultTry } from \"../result/result\"\nimport type { RetrySchedule, SyncRetrySchedule } from \"../schedule/schedule\"\nimport { asServiceRequest } from \"../service/service-resolution\"\nimport { dual } from \"../shared/dual\"\nimport { resolveFxSpanOptions, span as traceSpan } from \"../trace/trace\"\nimport type { FxGenOptions } from \"../trace/trace\"\nimport type { Exit as ExitType } from \"./exit\"\nimport { forEach as fxForEach } from \"./foreach\"\nimport {\n  forkFiber,\n  runFork as runtimeRunFork,\n  isRuntimeInstruction,\n  runSync,\n  runAsync,\n  yieldNow as runtimeYieldNow,\n} from \"./fx.runtime\"\nimport { FxTypeId } from \"./fx.types\"\nimport type { RunnableFx, SyncFx, AsyncFx, FxYield, Fx as FxProtocol, FxGenerator, AsyncFxGenerator } from \"./fx.types\"\nexport {\n  /**\n   * `Exit` utilities namespace for `Fx.run` outcomes.\n   *\n   * @example\n   * ```ts\n   * import { Fx } from \"@nicolastoulemont/std\"\n   *\n   * const exit = Fx.Exit.ok(1)\n   * // => { _tag: \"Ok\", value: 1 }\n   * ```\n   *\n   */\n  Exit,\n} from \"./exit\"\nexport {\n  /**\n   * Type guard for Fx service requests.\n   *\n   * @example\n   * ```ts\n   * import { Fx } from \"@nicolastoulemont/std\"\n   *\n   * const request = { _tag: \"ServiceRequest\", serviceKey: \"Logger\" } as Fx.ServiceRequest<unknown>\n   * const isRequest = Fx.isServiceRequest(request)\n   * // => true\n   * ```\n   *\n   */\n  isServiceRequest,\n} from \"./fx.types\"\nexport {\n  /**\n   * Runtime unique symbol identifying Fx values.\n   *\n   * @example\n   * ```ts\n   * import { Fx } from \"@nicolastoulemont/std\"\n   *\n   * const marker = { [Fx.FxTypeId]: true }\n   * // => Object.getOwnPropertySymbols(marker).includes(Fx.FxTypeId)\n   * ```\n   *\n   */\n  FxTypeId,\n} from \"./fx.types\"\nexport {\n  /**\n   * Re-exported core Fx protocol type.\n   *\n   * @example\n   * ```ts\n   * import { Fx } from \"@nicolastoulemont/std\"\n   *\n   * type Example = Fx.Fx<unknown, unknown, unknown>\n   * ```\n   *\n   */\n  type Fx,\n} from \"./fx.types\"\nexport {\n  /**\n   * Re-exported synchronous Fx type.\n   *\n   * @example\n   * ```ts\n   * import { Fx } from \"@nicolastoulemont/std\"\n   *\n   * type Example = Fx.SyncFx<unknown, unknown, unknown>\n   * ```\n   *\n   */\n  type SyncFx,\n} from \"./fx.types\"\nexport {\n  /**\n   * Re-exported asynchronous Fx type.\n   *\n   * @example\n   * ```ts\n   * import { Fx } from \"@nicolastoulemont/std\"\n   *\n   * type Example = Fx.AsyncFx<unknown, unknown, unknown>\n   * ```\n   *\n   */\n  type AsyncFx,\n} from \"./fx.types\"\nexport {\n  /**\n   * Re-exported runnable Fx union type.\n   *\n   * @example\n   * ```ts\n   * import { Fx } from \"@nicolastoulemont/std\"\n   *\n   * type Example = Fx.RunnableFx<unknown, unknown, unknown>\n   * ```\n   *\n   */\n  type RunnableFx,\n} from \"./fx.types\"\nexport {\n  /**\n   * Re-exported service-request protocol type.\n   *\n   * @example\n   * ```ts\n   * import { Fx } from \"@nicolastoulemont/std\"\n   *\n   * type Example = Fx.ServiceRequest<unknown>\n   * ```\n   *\n   */\n  type ServiceRequest,\n} from \"./fx.types\"\nexport {\n  /**\n   * Re-exported helper extracting Fx success type.\n   *\n   * @example\n   * ```ts\n   * import { Fx } from \"@nicolastoulemont/std\"\n   *\n   * type Example = Fx.FxValue<Fx.SyncFx<number>>\n   * ```\n   *\n   */\n  type FxValue,\n} from \"./fx.types\"\nexport {\n  /**\n   * Re-exported helper extracting Fx error type.\n   *\n   * @example\n   * ```ts\n   * import { Fx } from \"@nicolastoulemont/std\"\n   *\n   * type Example = Fx.FxError<Fx.SyncFx<number, string>>\n   * ```\n   *\n   */\n  type FxError,\n} from \"./fx.types\"\nexport {\n  /**\n   * Re-exported helper extracting Fx requirements type.\n   *\n   * @example\n   * ```ts\n   * import { Fx } from \"@nicolastoulemont/std\"\n   *\n   * type Example = Fx.FxRequirements<Fx.SyncFx<number, never, { readonly svc: unknown }>>\n   * ```\n   *\n   */\n  type FxRequirements,\n} from \"./fx.types\"\nexport {\n  /**\n   * Re-exported generator yield union for Fx internals.\n   *\n   * @example\n   * ```ts\n   * import { Fx } from \"@nicolastoulemont/std\"\n   *\n   * type Example = Fx.FxYield<unknown, unknown>\n   * ```\n   *\n   */\n  type FxYield,\n} from \"./fx.types\"\nexport {\n  /**\n   * Re-exported sync generator signature used by `Fx.gen`.\n   *\n   * @example\n   * ```ts\n   * import { Fx } from \"@nicolastoulemont/std\"\n   *\n   * type Example = Fx.FxGenerator<unknown, unknown, unknown>\n   * ```\n   *\n   */\n  type FxGenerator,\n} from \"./fx.types\"\nexport {\n  /**\n   * Re-exported async generator signature used by `Fx.gen`.\n   *\n   * @example\n   * ```ts\n   * import { Fx } from \"@nicolastoulemont/std\"\n   *\n   * type Example = Fx.AsyncFxGenerator<unknown, unknown, unknown>\n   * ```\n   *\n   */\n  type AsyncFxGenerator,\n} from \"./fx.types\"\nexport {\n  /**\n   * Re-exported sync Fx yieldable protocol type.\n   *\n   * @example\n   * ```ts\n   * import { Fx } from \"@nicolastoulemont/std\"\n   *\n   * type Example = Fx.FxYieldable<unknown, unknown, unknown>\n   * ```\n   *\n   */\n  type FxYieldable,\n} from \"./fx.types\"\nexport {\n  /**\n   * Re-exported async Fx yieldable protocol type.\n   *\n   * @example\n   * ```ts\n   * import { Fx } from \"@nicolastoulemont/std\"\n   *\n   * type Example = Fx.AsyncFxYieldable<unknown, unknown, unknown>\n   * ```\n   *\n   */\n  type AsyncFxYieldable,\n} from \"./fx.types\"\n\n/* oxlint-disable no-unsafe-type-assertion, no-unsafe-assignment, no-unsafe-call, no-unsafe-member-access, no-unsafe-return, no-unsafe-argument, no-unnecessary-type-assertion -- Fx runtime adapters intentionally traverse erased generator channels and rehydrate typed effects through controlled dynamic boundaries. */\n\n// ============================================================================\n// Fx.run - Execute computations\n// ============================================================================\n\n/**\n * Execute a sync Fx computation and return the Exit.\n * Catches unexpected thrown exceptions and wraps them as Defect.\n * Only available when R = never (all dependencies provided).\n *\n * @param fx - The sync computation to execute\n * @returns Exit<A, E>\n */\nfunction fxRun<A, E>(fx: SyncFx<A, E>): ExitType<A, E>\n\n/**\n * Execute an async Fx computation and return a Promise of the Exit.\n * Catches unexpected thrown exceptions and wraps them as Defect.\n * Only available when R = never (all dependencies provided).\n *\n * @param fx - The async computation to execute\n * @returns Promise<Exit<A, E>>\n */\nfunction fxRun<A, E>(fx: AsyncFx<A, E>): Promise<ExitType<A, E>>\n\n/**\n * Execute an Fx computation (union type).\n * Returns Exit for sync, Promise<Exit> for async.\n * Catches unexpected thrown exceptions and wraps them as Defect.\n */\nfunction fxRun<A, E>(fx: RunnableFx<A, E>): ExitType<A, E> | Promise<ExitType<A, E>>\n\n/**\n * Implementation of Fx.run.\n * Detects sync vs async and executes appropriately.\n */\nfunction fxRun<A, E>(fx: RunnableFx<A, E>): ExitType<A, E> | Promise<ExitType<A, E>> {\n  if (fx._tag === \"AsyncFx\") {\n    return runAsync(fx)\n  }\n  return runSync(fx)\n}\n\n// ============================================================================\n// Fx.retry - Retry failed computations\n// ============================================================================\n\nconst sleep = (ms: number): Promise<void> =>\n  new Promise((resolve) => {\n    setTimeout(resolve, ms)\n  })\n\nconst sleepIfNeeded = async (ms: number): Promise<void> => {\n  if (ms <= 0) {\n    return\n  }\n  await sleep(ms)\n}\n\nconst closeSyncAttempt = (gen: Generator<unknown, unknown, unknown>) => {\n  if (typeof gen.return === \"function\") {\n    gen.return(undefined)\n  }\n}\n\nconst closeAsyncAttempt = async (\n  gen: Generator<unknown, unknown, unknown> | AsyncGenerator<unknown, unknown, unknown>,\n) => {\n  if (typeof gen.return === \"function\") {\n    await gen.return(undefined)\n  }\n}\n\nconst makeSyncRetryFx = <A, E, R>(fx: SyncFx<A, E, R>, schedule: SyncRetrySchedule): SyncFx<A, E, R> => ({\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 R,\n  },\n  *[Symbol.iterator](): Generator<FxYield<E, R>, A, unknown> {\n    let retryAttempt = 0\n    attemptLoop: while (true) {\n      const gen = fx[Symbol.iterator]()\n      let result = gen.next()\n\n      while (result.done !== true) {\n        const yielded = result.value\n        const serviceRequest = asServiceRequest(yielded)\n        if (serviceRequest !== undefined || isRuntimeInstruction(yielded)) {\n          const injected = yield yielded as FxYield<E, R>\n          result = gen.next(injected)\n          continue\n        }\n\n        retryAttempt += 1\n        if (retryAttempt <= schedule.maxRetries) {\n          closeSyncAttempt(gen)\n          continue attemptLoop\n        }\n\n        // Forward the terminal typed failure to the outer runtime.\n        yield yielded as FxYield<E, R>\n        return undefined as never\n      }\n\n      return result.value\n    }\n  },\n})\n\n/* oxlint-disable no-await-in-loop -- retry execution is intentionally sequential across attempts and iterator steps. */\nconst makeAsyncRetryFx = <A, E, R>(fx: RunnableFx<A, E, R>, schedule: RetrySchedule): AsyncFx<A, E, R> => ({\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 R,\n  },\n  async *[Symbol.asyncIterator](): AsyncGenerator<FxYield<E, R>, A, unknown> {\n    let retryAttempt = 0\n\n    attemptLoop: while (true) {\n      if (fx._tag === \"AsyncFx\") {\n        const gen = fx[Symbol.asyncIterator]()\n        // Sequential async iterator protocol: each step depends on the previous one.\n        let result = await gen.next()\n\n        while (result.done !== true) {\n          const yielded = result.value\n          const serviceRequest = asServiceRequest(yielded)\n          if (serviceRequest !== undefined || isRuntimeInstruction(yielded)) {\n            const injected = yield yielded as FxYield<E, R>\n            // oxlint-disable-next-line no-await-in-loop\n            result = await gen.next(injected)\n            continue\n          }\n\n          retryAttempt += 1\n          if (retryAttempt <= schedule.maxRetries) {\n            const delayMs = schedule.delayForAttempt(retryAttempt)\n            await sleepIfNeeded(delayMs)\n            await closeAsyncAttempt(gen)\n            continue attemptLoop\n          }\n\n          // Forward the terminal typed failure to the outer runtime.\n          yield yielded as FxYield<E, R>\n          return undefined as never\n        }\n\n        return result.value\n      }\n\n      const gen = fx[Symbol.iterator]()\n      let result = gen.next()\n\n      while (result.done !== true) {\n        const yielded = result.value\n        const serviceRequest = asServiceRequest(yielded)\n        if (serviceRequest !== undefined || isRuntimeInstruction(yielded)) {\n          const injected = yield yielded as FxYield<E, R>\n          result = gen.next(injected)\n          continue\n        }\n\n        retryAttempt += 1\n        if (retryAttempt <= schedule.maxRetries) {\n          const delayMs = schedule.delayForAttempt(retryAttempt)\n          await sleepIfNeeded(delayMs)\n          await closeAsyncAttempt(gen)\n          continue attemptLoop\n        }\n\n        // Forward the terminal typed failure to the outer runtime.\n        yield yielded as FxYield<E, R>\n        return undefined as never\n      }\n\n      return result.value\n    }\n  },\n})\n/* oxlint-enable no-await-in-loop */\n\n/**\n * Retry a computation according to the given schedule.\n *\n * Retries only typed failures (Err channel). Defects are not retried.\n */\ntype RetryResult<Fx extends RunnableFx<unknown, unknown, unknown>, S extends RetrySchedule> =\n  Fx extends AsyncFx<infer A, infer E, infer R>\n    ? AsyncFx<A, E, R>\n    : S extends SyncRetrySchedule\n      ? Fx extends SyncFx<infer A, infer E, infer R>\n        ? SyncFx<A, E, R>\n        : never\n      : Fx extends SyncFx<infer A, infer E, infer R>\n        ? AsyncFx<A, E, R>\n        : never\n\nconst fxRetry: {\n  <Fx extends RunnableFx<unknown, unknown, unknown>, S extends RetrySchedule>(fx: Fx, schedule: S): RetryResult<Fx, S>\n  <S extends RetrySchedule>(\n    schedule: S,\n  ): <Fx extends RunnableFx<unknown, unknown, unknown>>(fx: Fx) => RetryResult<Fx, S>\n} = dual(\n  2,\n  <Fx extends RunnableFx<unknown, unknown, unknown>, S extends RetrySchedule>(\n    fx: Fx,\n    schedule: S,\n  ): RetryResult<Fx, S> => {\n    if (fx._tag === \"AsyncFx\" || !schedule._sync) {\n      return makeAsyncRetryFx(fx, schedule) as RetryResult<Fx, S>\n    }\n    return makeSyncRetryFx(fx as SyncFx<unknown, unknown, unknown>, schedule as SyncRetrySchedule) as RetryResult<Fx, S>\n  },\n)\n\n// ============================================================================\n// Fx.gen - Create composable computations\n// ============================================================================\n\ntype FxGenError<Yielded> = Yielded extends FxProtocol<unknown, infer E, unknown> ? E : Yielded\ntype FxGenRequirements<Yielded> = Yielded extends FxProtocol<unknown, unknown, infer R> ? R : never\n\n/**\n * Create a composable computation from a sync generator function.\n * Returns a SyncFx that can be stored, passed around, and executed later.\n *\n * @template Yielded - The type of values yielded by the generator\n * @template A - The success value type\n * @param generatorFn - A function that returns a sync generator\n * @returns SyncFx<A, FxGenError<Yielded>, FxGenRequirements<Yielded>>\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 exit = Fx.run(Provide.service(Port, 3000)(readPort))\n * // => { _tag: \"Ok\", value: 3000 }\n * ```\n */\nfunction fxGen<Yielded, A>(\n  generatorFn: () => Generator<Yielded, A, unknown>,\n): SyncFx<A, FxGenError<Yielded>, FxGenRequirements<Yielded>>\nfunction fxGen<Yielded, A>(\n  spanName: string,\n  generatorFn: () => Generator<Yielded, A, unknown>,\n): SyncFx<A, FxGenError<Yielded>, FxGenRequirements<Yielded>>\nfunction fxGen<Yielded, A>(\n  options: FxGenOptions,\n  generatorFn: () => Generator<Yielded, A, unknown>,\n): SyncFx<A, FxGenError<Yielded>, FxGenRequirements<Yielded>>\n\n/**\n * Create a composable computation from an async generator function.\n * Returns an AsyncFx that can be stored, passed around, and executed later.\n *\n * @template Yielded - The type of values yielded by the generator\n * @template A - The success value type\n * @param generatorFn - A function that returns an async generator\n * @returns AsyncFx<A, FxGenError<Yielded>, FxGenRequirements<Yielded>>\n *\n * @example\n * ```ts\n * import { Fx, Provide, Service } from \"@nicolastoulemont/std\"\n *\n * const Token = Service.tag<string>(\"Token\")\n * const readToken = Fx.gen(async function* () {\n *   const token = yield* Token\n *   const suffix = await Promise.resolve(\"-ok\")\n *   return `${token}${suffix}`\n * })\n * const exit = await Fx.run(Provide.service(Token, \"abc\")(readToken))\n * // => { _tag: \"Ok\", value: \"abc-ok\" }\n * ```\n */\nfunction fxGen<Yielded, A>(\n  generatorFn: () => AsyncGenerator<Yielded, A, unknown>,\n): AsyncFx<A, FxGenError<Yielded>, FxGenRequirements<Yielded>>\nfunction fxGen<Yielded, A>(\n  spanName: string,\n  generatorFn: () => AsyncGenerator<Yielded, A, unknown>,\n): AsyncFx<A, FxGenError<Yielded>, FxGenRequirements<Yielded>>\nfunction fxGen<Yielded, A>(\n  options: FxGenOptions,\n  generatorFn: () => AsyncGenerator<Yielded, A, unknown>,\n): AsyncFx<A, FxGenError<Yielded>, FxGenRequirements<Yielded>>\n\n/**\n * Create a composable computation from a sync generator function that takes parameters.\n * Returns a factory function that, when called with parameters, produces a SyncFx.\n *\n * @template P - The parameter types (must be non-empty)\n * @template Yielded - The type of values yielded by the generator\n * @template A - The success value type\n * @param generatorFn - A function that takes parameters and returns a sync generator\n * @returns A factory function that produces SyncFx<A, FxGenError<Yielded>, FxGenRequirements<Yielded>>\n *\n * @example\n * ```ts\n * import { Fx, Provide, Service } from \"@nicolastoulemont/std\"\n *\n * const Port = Service.tag<number>(\"Port\")\n * const describePort = Fx.gen(function* (label: string) {\n *   const port = yield* Port\n *   return `${label}:${port}`\n * })\n * const exit = Fx.run(Provide.service(Port, 3000)(describePort(\"port\")))\n * // => { _tag: \"Ok\", value: \"port:3000\" }\n * ```\n */\nfunction fxGen<P extends [unknown, ...unknown[]], Yielded, A>(\n  generatorFn: (...params: P) => Generator<Yielded, A, unknown>,\n): (...params: P) => SyncFx<A, FxGenError<Yielded>, FxGenRequirements<Yielded>>\nfunction fxGen<P extends [unknown, ...unknown[]], Yielded, A>(\n  spanName: string,\n  generatorFn: (...params: P) => Generator<Yielded, A, unknown>,\n): (...params: P) => SyncFx<A, FxGenError<Yielded>, FxGenRequirements<Yielded>>\nfunction fxGen<P extends [unknown, ...unknown[]], Yielded, A>(\n  options: FxGenOptions<P>,\n  generatorFn: (...params: P) => Generator<Yielded, A, unknown>,\n): (...params: P) => SyncFx<A, FxGenError<Yielded>, FxGenRequirements<Yielded>>\n\n/**\n * Create a composable computation from an async generator function that takes parameters.\n * Returns a factory function that, when called with parameters, produces an AsyncFx.\n *\n * @template P - The parameter types (must be non-empty)\n * @template Yielded - The type of values yielded by the generator\n * @template A - The success value type\n * @param generatorFn - A function that takes parameters and returns an async generator\n * @returns A factory function that produces AsyncFx<A, FxGenError<Yielded>, FxGenRequirements<Yielded>>\n *\n * @example\n * ```ts\n * import { Fx, Provide, Service } from \"@nicolastoulemont/std\"\n *\n * const Token = Service.tag<string>(\"Token\")\n * const describeToken = Fx.gen(async function* (prefix: string) {\n *   const token = yield* Token\n *   const suffix = await Promise.resolve(\"!\")\n *   return `${prefix}:${token}${suffix}`\n * })\n * const exit = await Fx.run(Provide.service(Token, \"abc\")(describeToken(\"token\")))\n * // => { _tag: \"Ok\", value: \"token:abc!\" }\n * ```\n */\nfunction fxGen<P extends [unknown, ...unknown[]], Yielded, A>(\n  generatorFn: (...params: P) => AsyncGenerator<Yielded, A, unknown>,\n): (...params: P) => AsyncFx<A, FxGenError<Yielded>, FxGenRequirements<Yielded>>\nfunction fxGen<P extends [unknown, ...unknown[]], Yielded, A>(\n  spanName: string,\n  generatorFn: (...params: P) => AsyncGenerator<Yielded, A, unknown>,\n): (...params: P) => AsyncFx<A, FxGenError<Yielded>, FxGenRequirements<Yielded>>\nfunction fxGen<P extends [unknown, ...unknown[]], Yielded, A>(\n  options: FxGenOptions<P>,\n  generatorFn: (...params: P) => AsyncGenerator<Yielded, A, unknown>,\n): (...params: P) => AsyncFx<A, FxGenError<Yielded>, FxGenRequirements<Yielded>>\n\n/**\n * Implementation of unified Fx.gen function.\n * Detects sync vs async generator and returns appropriate computation type.\n * For parameterized generators (length > 0), returns a factory function.\n */\n// oxlint-disable-next-line no-explicit-any\nfunction fxGen(...args: any[]): any {\n  const spanConfig = typeof args[0] === \"function\" ? undefined : (args[0] as string | FxGenOptions<readonly unknown[]>)\n  // oxlint-disable-next-line no-explicit-any\n  const generatorFn = (spanConfig === undefined ? args[0] : args[1]) as (...args: any[]) => any\n\n  if (generatorFn.length > 0) {\n    return (...params: unknown[]) => {\n      const fx = (fxGen as (...args: unknown[]) => RunnableFx<unknown, unknown, unknown>)(() => generatorFn(...params))\n      const span = typeof spanConfig === \"object\" ? spanConfig.span : spanConfig\n      if (span === undefined) {\n        return fx\n      }\n      const resolved = resolveFxSpanOptions(span, params)\n      return traceSpan(resolved.name, fx, resolved.options)\n    }\n  }\n\n  // Check if we're dealing with async generator\n  const testGen = generatorFn()\n  const isAsync = Symbol.asyncIterator in testGen\n\n  if (isAsync) {\n    const fx = {\n      _tag: \"AsyncFx\",\n      [FxTypeId]: {\n        _A: () => undefined,\n        _E: () => undefined,\n        _R: () => undefined,\n      },\n      // oxlint-disable-next-line no-explicit-any\n      async *[Symbol.asyncIterator](): AsyncGenerator<any, any, unknown> {\n        const gen = generatorFn()\n        let result = await gen.next()\n\n        while (result.done !== true) {\n          // Pass through yields (errors or services as Fx values)\n          const injected = yield result.value\n          // oxlint-disable-next-line no-await-in-loop\n          result = await gen.next(injected)\n        }\n\n        return result.value\n      },\n    } as AsyncFx<unknown, unknown, unknown>\n    const span = typeof spanConfig === \"object\" ? spanConfig.span : spanConfig\n    if (span === undefined) {\n      return fx\n    }\n    const resolved = resolveFxSpanOptions(span, [])\n    return traceSpan(resolved.name, fx, resolved.options)\n  }\n\n  // Sync generator\n  const fx = {\n    _tag: \"SyncFx\",\n    [FxTypeId]: {\n      _A: () => undefined,\n      _E: () => undefined,\n      _R: () => undefined,\n    },\n    // oxlint-disable-next-line no-explicit-any\n    *[Symbol.iterator](): Generator<any, any, unknown> {\n      const gen = generatorFn()\n      let result = gen.next()\n\n      while (result.done !== true) {\n        const injected = yield result.value\n        result = gen.next(injected)\n      }\n\n      return result.value\n    },\n  } as SyncFx<unknown, unknown, unknown>\n  const span = typeof spanConfig === \"object\" ? spanConfig.span : spanConfig\n  if (span === undefined) {\n    return fx\n  }\n  const resolved = resolveFxSpanOptions(span, [])\n  return traceSpan(resolved.name, fx, resolved.options)\n}\n\n// ============================================================================\n// Fx.fn - Execute computations immediately\n// ============================================================================\n\ntype FxRunResult<F extends RunnableFx<unknown, unknown, unknown>> =\n  F extends AsyncFx<infer A, infer E, unknown>\n    ? Promise<ExitType<A, E>>\n    : F extends SyncFx<infer A, infer E, unknown>\n      ? ExitType<A, E>\n      : never\n\n/**\n * Execute a sync computation immediately and return the Exit.\n * Catches unexpected thrown exceptions and wraps them as Defect.\n * For computations without service dependencies.\n *\n * @template A - The success value type\n * @template E - The error type\n * @param generatorFn - A function that returns a sync generator\n * @returns Exit<A, E>\n *\n * @example\n * ```ts\n * import { Fx } from \"@nicolastoulemont/std\"\n *\n * const exit = Fx.fn(function* () {\n *   const a = yield* Fx.ok(10)\n *   const b = yield* Fx.ok(20)\n *   return a + b\n * })\n * // => { _tag: \"Ok\", value: 30 }\n * ```\n */\nfunction fxFn<A, E>(generatorFn: () => FxGenerator<A, E, never>): ExitType<A, E>\nfunction fxFn<A, E>(spanName: string, generatorFn: () => FxGenerator<A, E, never>): ExitType<A, E>\nfunction fxFn<A, E>(options: FxGenOptions, generatorFn: () => FxGenerator<A, E, never>): ExitType<A, E>\n\n/**\n * Execute an async computation immediately and return a Promise of the Exit.\n * Catches unexpected thrown exceptions and wraps them as Defect.\n * For computations without service dependencies.\n *\n * @template A - The success value type\n * @template E - The error type\n * @param generatorFn - A function that returns an async generator\n * @returns Promise<Exit<A, E>>\n *\n * @example\n * ```ts\n * import { Fx } from \"@nicolastoulemont/std\"\n *\n * const exit = await Fx.fn(async function* () {\n *   const value = await Promise.resolve(2)\n *   return value + 1\n * })\n * // => { _tag: \"Ok\", value: 3 }\n * ```\n */\nfunction fxFn<A, E>(generatorFn: () => AsyncFxGenerator<A, E, never>): Promise<ExitType<A, E>>\nfunction fxFn<A, E>(spanName: string, generatorFn: () => AsyncFxGenerator<A, E, never>): Promise<ExitType<A, E>>\nfunction fxFn<A, E>(options: FxGenOptions, generatorFn: () => AsyncFxGenerator<A, E, never>): Promise<ExitType<A, E>>\n\n/**\n * Execute a sync computation with service dependencies immediately.\n * Catches unexpected thrown exceptions and wraps them as Defect.\n * The second argument is required when the computation has service requirements (R ≠ never).\n *\n * @template A - The success value type\n * @template E - The error type from the computation\n * @template R - The required services type\n * @param generatorFn - A function that returns a sync generator with service requirements\n * @param provider - A function that provides the services (e.g., Provide.layer(AppLayer))\n * @returns Exit result from running the provided Fx (sync or async depending on provider output)\n *\n * @example\n * ```ts\n * import { Fx, Provide, Service } from \"@nicolastoulemont/std\"\n *\n * const Port = Service.tag<number>(\"Port\")\n *\n * const exit = Fx.fn(function* () {\n *   const port = yield* Port\n *   return port + 1\n * }, Provide.service(Port, 3000))\n * // => { _tag: \"Ok\", value: 3001 }\n * ```\n */\nfunction fxFn<A, E, R, ProvidedFx extends RunnableFx<unknown, unknown, unknown>>(\n  generatorFn: () => FxGenerator<A, E, R>,\n  provider: (fx: SyncFx<A, E, R>) => ProvidedFx,\n): FxRunResult<ProvidedFx>\nfunction fxFn<A, E, R, ProvidedFx extends RunnableFx<unknown, unknown, unknown>>(\n  spanName: string,\n  generatorFn: () => FxGenerator<A, E, R>,\n  provider: (fx: SyncFx<A, E, R>) => ProvidedFx,\n): FxRunResult<ProvidedFx>\nfunction fxFn<A, E, R, ProvidedFx extends RunnableFx<unknown, unknown, unknown>>(\n  options: FxGenOptions,\n  generatorFn: () => FxGenerator<A, E, R>,\n  provider: (fx: SyncFx<A, E, R>) => ProvidedFx,\n): FxRunResult<ProvidedFx>\n\n/**\n * Execute an async computation with service dependencies immediately.\n * Catches unexpected thrown exceptions and wraps them as Defect.\n * The second argument is required when the computation has service requirements (R ≠ never).\n *\n * @template A - The success value type\n * @template E - The error type from the computation\n * @template R - The required services type\n * @param generatorFn - A function that returns an async generator with service requirements\n * @param provider - A function that provides the services (e.g., Provide.layer(AppLayer))\n * @returns Exit result from running the provided Fx (sync or async depending on provider output)\n *\n * @example\n * ```ts\n * import { Fx, Provide, Service } from \"@nicolastoulemont/std\"\n *\n * const Token = Service.tag<string>(\"Token\")\n *\n * const exit = await Fx.fn(async function* () {\n *   const token = yield* Token\n *   const suffix = await Promise.resolve(\"!\")\n *   return `${token}${suffix}`\n * }, Provide.service(Token, \"abc\"))\n * // => { _tag: \"Ok\", value: \"abc!\" }\n * ```\n */\nfunction fxFn<A, E, R, ProvidedFx extends RunnableFx<unknown, unknown, unknown>>(\n  generatorFn: () => AsyncFxGenerator<A, E, R>,\n  provider: (fx: AsyncFx<A, E, R>) => ProvidedFx,\n): FxRunResult<ProvidedFx>\nfunction fxFn<A, E, R, ProvidedFx extends RunnableFx<unknown, unknown, unknown>>(\n  spanName: string,\n  generatorFn: () => AsyncFxGenerator<A, E, R>,\n  provider: (fx: AsyncFx<A, E, R>) => ProvidedFx,\n): FxRunResult<ProvidedFx>\nfunction fxFn<A, E, R, ProvidedFx extends RunnableFx<unknown, unknown, unknown>>(\n  options: FxGenOptions,\n  generatorFn: () => AsyncFxGenerator<A, E, R>,\n  provider: (fx: AsyncFx<A, E, R>) => ProvidedFx,\n): FxRunResult<ProvidedFx>\n\n/**\n * Implementation of Fx.fn.\n * Reuses fxGen() for Fx creation and fxRun() for execution to ensure consistent behavior.\n */\nfunction fxFn<A, E, E2, R>(\n  ...args:\n    | [\n        generatorFn: () => FxGenerator<A, E, R> | AsyncFxGenerator<A, E, R>,\n        provider?: ((fx: SyncFx<A, E, R>) => RunnableFx<A, E | E2>) | ((fx: AsyncFx<A, E, R>) => RunnableFx<A, E | E2>),\n      ]\n    | [\n        spanConfig: string | FxGenOptions,\n        generatorFn: () => FxGenerator<A, E, R> | AsyncFxGenerator<A, E, R>,\n        provider?: ((fx: SyncFx<A, E, R>) => RunnableFx<A, E | E2>) | ((fx: AsyncFx<A, E, R>) => RunnableFx<A, E | E2>),\n      ]\n): ExitType<A, E | E2> | Promise<ExitType<A, E | E2>> {\n  const spanConfig = typeof args[0] === \"function\" ? undefined : args[0]\n  const generatorFn = (spanConfig === undefined ? args[0] : args[1]) as () =>\n    | FxGenerator<A, E, R>\n    | AsyncFxGenerator<A, E, R>\n  const provider = (spanConfig === undefined ? args[1] : args[2]) as\n    | ((fx: SyncFx<A, E, R>) => RunnableFx<A, E | E2>)\n    | ((fx: AsyncFx<A, E, R>) => RunnableFx<A, E | E2>)\n    | undefined\n\n  // Create the Fx using fxGen (single source of truth for Fx creation)\n  // Type cast needed because fxGen infers E/R from yielded Fx values,\n  // while fxFn receives E/R as explicit type parameters\n  const createFx = fxGen as (...args: unknown[]) => RunnableFx<A, E, R>\n  const fx = spanConfig === undefined ? createFx(generatorFn) : createFx(spanConfig, generatorFn)\n\n  if (provider) {\n    // Apply provider and run\n    const provided =\n      fx._tag === \"AsyncFx\"\n        ? (provider as (fx: AsyncFx<A, E, R>) => RunnableFx<A, E | E2>)(fx)\n        : (provider as (fx: SyncFx<A, E, R>) => RunnableFx<A, E | E2>)(fx)\n    return fxRun(provided as RunnableFx<A, E | E2>) as ExitType<A, E | E2> | Promise<ExitType<A, E | E2>>\n  }\n\n  // No provider - run directly (R must be never at the type level)\n  return fxRun(fx as RunnableFx<A, E | E2>) as ExitType<A, E | E2> | Promise<ExitType<A, E | E2>>\n}\n\n// ============================================================================\n// Fx.ok / Fx.err / Fx.option - Convenience aliases\n// ============================================================================\n\n/**\n * Convenience alias for Result.ok.\n * Creates a successful Result that can be yielded in an Fx computation.\n *\n * @param value - The success value\n * @returns Result<T, never>\n *\n * @example\n * ```ts\n * const workflow = Fx.gen(function* () {\n *   const value = yield* Fx.ok(42)\n *   return value * 2\n * })\n * ```\n */\nconst fxOk = resultOk\n\n/**\n * Convenience alias for Result.err.\n * Creates an error Result that can be yielded in an Fx computation.\n *\n * @param error - The error value\n * @returns Result<never, E>\n *\n * @example\n * ```ts\n * const workflow = Fx.gen(function* () {\n *   const config = yield* Config\n *\n *   if (!config.dbUrl) {\n *     return yield* Fx.err(new ValidationError({ field: \"dbUrl\" }))\n *   }\n *\n *   return config.dbUrl\n * })\n * ```\n */\nconst fxErr = resultErr\n\n/**\n * Convenience alias for Result.try.\n * Creates a Result that can be yielded in an Fx computation.\n *\n * @param fn - A function that returns a value or throws an error\n * @returns Result<T, E>\n *\n * @example\n * ```ts\n * const result = Fx.try(() => {\n *   return 42\n * })\n *\n * const workflow = Fx.gen(function* () {\n *   const result = yield* Fx.try(() => {\n *     return 42\n *   })\n *   return result\n * })\n * ```\n */\nconst fxTry = resultTry\n\n/**\n * Convenience alias for Option.fromNullable.\n * Converts nullable values into an Option that can be yielded in an Fx computation.\n *\n * @param value - A possibly nullish value\n * @returns Option<NonNullable<T>>\n *\n * @example\n * ```ts\n * const workflow = Fx.gen(function* () {\n *   const apiKey = yield* Fx.option(request.headers[\"x-api-key\"])\n *   return apiKey\n * })\n * ```\n */\nconst fxOption = optionFromNullable\n\n// ============================================================================\n// Fx.match - Universal pattern matching\n// ============================================================================\n\n/**\n * Handler functions for matching on a tagged union by `_tag` discriminator.\n * Each handler receives the narrowed variant corresponding to its tag key.\n *\n * @example\n * ```ts\n * import { Fx } from \"@nicolastoulemont/std\"\n *\n * type Example = typeof Fx\n * ```\n */\nexport type TaggedMatch<T extends { readonly _tag: string }, R> = {\n  readonly [K in Exclude<T[\"_tag\"], \"Interrupted\">]: (variant: Extract<T, { readonly _tag: K }>) => R\n} & {\n  readonly Interrupted?: (variant: Extract<T, { readonly _tag: \"Interrupted\" }>) => R\n}\n\n/**\n * Generic pattern matcher for any `_tag`-based discriminated union.\n *\n * Works with Exit, tagged errors, or any type with a `readonly _tag` discriminator.\n * Each handler receives the full narrowed variant object for its tag.\n *\n * Supports both data-first and data-last (pipe) calling styles.\n *\n * @example\n * ```ts\n * // Match on Exit\n * Fx.match(exit, {\n *   Ok: (ok) => ok.value,\n *   Err: (err) =>\n *     Fx.match(err.error, {\n *       DatabaseError: (e) => e.message,\n *       NotFoundError: (e) => e.resourceId,\n *     }),\n *   Defect: (d) => String(d.defect),\n * })\n *\n * // Data-last with pipe\n * pipe(exit, Fx.match({\n *   Ok: (ok) => ok.value,\n *   Err: (err) => \"error\",\n *   Defect: (d) => \"defect\",\n * }))\n * ```\n */\nconst fxMatch: {\n  <T extends { readonly _tag: string }, R>(value: T, handlers: TaggedMatch<T, R>): R\n  <T extends { readonly _tag: string }, R>(handlers: TaggedMatch<T, R>): (value: T) => R\n} = dual(\n  2,\n  // oxlint-disable-next-line no-explicit-any\n  (value: any, handlers: any): any => handlers[value._tag](value),\n)\n\n// ============================================================================\n// Exports\n// ============================================================================\n\n/**\n * Build typed computations from generator functions.\n *\n * @example\n * ```ts\n * import { Fx } from \"@nicolastoulemont/std\"\n *\n * const program = Fx.gen(function* () {\n *   const value = yield* Fx.ok(2)\n *   return value + 1\n * })\n * const exit = Fx.run(program)\n * // => { _tag: \"Ok\", value: 3 }\n * ```\n */\nexport const gen = fxGen\n\n/**\n * Run a generator function immediately and return its `Exit`.\n *\n * @example\n * ```ts\n * import { Fx } from \"@nicolastoulemont/std\"\n *\n * const exit = Fx.fn(function* () {\n *   return yield* Fx.ok(2)\n * })\n * // => { _tag: \"Ok\", value: 2 }\n * ```\n */\nexport const fn = fxFn\n\n/**\n * Execute an existing `Fx` value and produce an `Exit`.\n *\n * @example\n * ```ts\n * import { Fx } from \"@nicolastoulemont/std\"\n *\n * const exit = Fx.run(Fx.gen(function* () {\n *   return 1\n * }))\n * // => { _tag: \"Ok\", value: 1 }\n * ```\n */\nexport const run = fxRun\n\n/**\n * Start an Fx on a new root fiber and return its handle immediately.\n *\n * @example\n * ```ts\n * const fiber = Fx.runFork(Fx.gen(async function* () {\n *   yield* Fx.yieldNow()\n *   return 1\n * }))\n * const exit = await fiber.await()\n * // => { _tag: \"Ok\", value: 1 }\n * ```\n */\nexport const runFork = runtimeRunFork\n\n/**\n * Fork a child fiber owned by the current fiber.\n *\n * @example\n * ```ts\n * const child = yield* Fx.forkChild(Fx.gen(async function* () {\n *   yield* Fx.yieldNow()\n *   return 1\n * }))\n * // => Fiber.Fiber<number, never>\n * ```\n */\nexport const forkChild = <A, E, R>(fx: RunnableFx<A, E, R>) => forkFiber(fx, false)\n\n/**\n * Fork a detached fiber that snapshots the current runtime state.\n *\n * @example\n * ```ts\n * const fiber = yield* Fx.forkDetach(Fx.gen(async function* () {\n *   yield* Fx.yieldNow()\n *   return 1\n * }))\n * // => Fiber.Fiber<number, never>\n * ```\n */\nexport const forkDetach = <A, E, R>(fx: RunnableFx<A, E, R>) => forkFiber(fx, true)\n\n/**\n * Cooperatively yield to the runtime and observe pending interruption.\n *\n * @example\n * ```ts\n * yield* Fx.yieldNow()\n * // => AsyncFx<void>\n * ```\n */\nexport const yieldNow = runtimeYieldNow\n\n/**\n * Retry failed computations according to a schedule.\n *\n * @example\n * ```ts\n * import { Fx } from \"@nicolastoulemont/std\"\n *\n * import { Schedule } from \"@nicolastoulemont/std\"\n *\n * const retried = Fx.retry(\n *   Fx.gen(function* () {\n *     return yield* Fx.err(\"boom\")\n *   }),\n *   Schedule.recurs(2),\n * )\n * const exit = Fx.run(retried)\n * // => { _tag: \"Err\", error: \"boom\" }\n * ```\n */\nexport const retry = fxRetry\n\n/**\n * Run an effectful function for each item in a collection.\n *\n * @example\n * ```ts\n * import { Fx } from \"@nicolastoulemont/std\"\n *\n * const fx = Fx.forEach([1, 2, 3], (n) => Fx.gen(function* () {\n *   return n * 2\n * }))\n * // => AsyncFx<readonly number[], ...>\n * ```\n */\nexport const forEach = fxForEach\n\n/**\n * Alias for `Result.ok` in `Fx` namespace.\n *\n * @example\n * ```ts\n * import { Fx } from \"@nicolastoulemont/std\"\n *\n * const value = Fx.ok(42)\n * // => { _tag: \"Ok\", value: 42 }\n * ```\n */\nexport const ok = fxOk\n\n/**\n * Alias for `Result.err` in `Fx` namespace.\n *\n * @example\n * ```ts\n * import { Fx } from \"@nicolastoulemont/std\"\n *\n * const value = Fx.err(\"boom\")\n * // => { _tag: \"Err\", error: \"boom\" }\n * ```\n */\nexport const err = fxErr\n\n/**\n * Alias for `Option.fromNullable` in `Fx` namespace.\n *\n * @example\n * ```ts\n * import { Fx } from \"@nicolastoulemont/std\"\n *\n * const value = Fx.option(\"token\")\n * // => { _tag: \"Some\", value: \"token\" }\n * ```\n */\nexport const option = fxOption\n\nconst try_ = fxTry\n\nexport {\n  /**\n   * Alias for `Result.fromTry` in `Fx` namespace.\n   *\n   * @example\n   * ```ts\n   * import { Fx } from \"@nicolastoulemont/std\"\n   *\n   * const parsed = Fx.try(() => Number.parseInt(\"42\", 10))\n   * // => { _tag: \"Ok\", value: 42 }\n   * ```\n   *\n   */\n  try_ as try,\n}\n\n/**\n * Pattern matching helper for tagged unions.\n *\n * @example\n * ```ts\n * import { Fx } from \"@nicolastoulemont/std\"\n *\n * const value = Fx.match({ _tag: \"Ok\", value: 2 } as const, {\n *   Ok: (ok) => ok.value + 1,\n * })\n * // => 3\n * ```\n */\nexport const match = fxMatch\n\n/* oxlint-enable no-unsafe-type-assertion, no-unsafe-assignment, no-unsafe-call, no-unsafe-member-access, no-unsafe-return, no-unsafe-argument, no-unnecessary-type-assertion */\n"],"mappings":"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"}

package/dist/fx.runtime-B2_rL7h_.mjs

@@ -0,0 +1,2 @@
+import{t as e}from"./fx.types-Bg-Mmdm5.mjs";import{t}from"./dual-CZhzZslG.mjs";import{i as n,n as r}from"./context-7oKePrBY.mjs";import{t as i}from"./option.types-bFFSErJ-.mjs";function a(e){return typeof e==`object`&&!!e&&`_tag`in e&&e._tag===`Service`&&`key`in e&&typeof e.key==`string`}function o(e){return a(e)?e:void 0}function s(e,t){let n=o(t);if(n!==void 0)return e._services.get(n.key)}const c=e=>({_tag:`Ok`,value:e}),l=e=>({_tag:`Err`,error:e}),u=e=>({_tag:`Defect`,defect:e}),d=e=>({_tag:`Interrupted`,fiberId:e}),f={ok:c,err:l,defect:u,interrupted:d,isOk:e=>e._tag===`Ok`,isErr:e=>e._tag===`Err`,isDefect:e=>e._tag===`Defect`,isInterrupted:e=>e._tag===`Interrupted`,match:t(2,(e,t)=>{switch(e._tag){case`Ok`:return t.Ok(e.value);case`Err`:return t.Err(e.error);case`Defect`:return t.Defect(e.defect);case`Interrupted`:if(t.Interrupted!==void 0)return t.Interrupted(e.fiberId);throw Error(`Fiber ${e.fiberId} interrupted.`)}}),getOrThrow:e=>{switch(e._tag){case`Ok`:return e.value;case`Err`:throw e.error;case`Defect`:throw e.defect;case`Interrupted`:throw Error(`Fiber ${e.fiberId} interrupted.`)}}},p=e=>typeof e==`object`&&!!e&&`_tag`in e&&e._tag===`Err`&&`error`in e,m=e=>typeof e==`object`&&!!e&&`_tag`in e&&(e._tag===`RunWithRuntimeState`||e._tag===`GetRuntimeState`||e._tag===`UpdateRuntimeState`||e._tag===`ForkFiber`||e._tag===`AwaitFiber`||e._tag===`JoinFiber`||e._tag===`InterruptFiber`||e._tag===`FiberStatus`||e._tag===`YieldNow`||e._tag===`InterruptibleAsync`),h=()=>({services:r(),scope:void 0,fiberId:void 0,fiber:void 0,loggers:[],logFields:{},logSpans:[],tracer:void 0,currentSpan:void 0,currentLocalSpan:void 0,spanAttributes:{},spanLinks:[]});let g=0;const _=()=>(g+=1,g),v=e=>new Promise(t=>{setTimeout(t,e)}),y=()=>{},b=e=>({...e,loggers:[...e.loggers],logFields:{...e.logFields},logSpans:[...e.logSpans],currentLocalSpan:void 0,spanAttributes:{...e.spanAttributes},spanLinks:[...e.spanLinks]});var x=class{id;children=new Set;interruptors=new Set;promise;exit;interrupted=!1;constructor(e,t){this.id=_(),this.promise=this.run(e,t)}status(){return this.exit===void 0?this.interrupted?`Interrupted`:`Running`:this.exit._tag===`Interrupted`?`Interrupted`:`Done`}await(){return this.promise}async interrupt(){this.interrupted=!0;for(let e of this.interruptors)try{e()}catch{}return await Promise.all([...this.children].map(e=>e.interrupt())),this.promise}addInterruptor(e){return this.interruptors.add(e),()=>{this.interruptors.delete(e)}}isInterrupted(){return this.interrupted}async interruptChildren(){this.children.size!==0&&(await Promise.all([...this.children].map(e=>e.interrupt())),this.children.clear())}async run(e,t){await Promise.resolve();let n={...b(t),fiberId:this.id,fiber:this},r=e._tag===`AsyncFx`?await Y(e,n):K(e,n);await this.interruptChildren();let i=this.interrupted&&r.exit._tag===`Ok`?d(this.id):r.exit;return this.exit=i,i}};const S=(e,t)=>new x(e,t),C=e=>e.fiber?.isInterrupted()===!0,w=e=>({exit:d(e.fiberId??0),state:e}),T=e=>t=>({...t,services:n(t.services,e)}),E=e=>t=>({...t,tracer:e});function D(e,t){return O(e,t)}function O(t,n,r,i){let a={_tag:`RunWithRuntimeState`,fx:t,update:n,...r===void 0?{}:{onExit:r},...i===void 0?{}:{restore:i}};return t._tag===`AsyncFx`?{_tag:`AsyncFx`,[e]:{_A:()=>void 0,_E:()=>void 0,_R:()=>void 0},async*[Symbol.asyncIterator](){return yield a}}:{_tag:`SyncFx`,[e]:{_A:()=>void 0,_E:()=>void 0,_R:()=>void 0},*[Symbol.iterator](){return yield a}}}const k=(e,t)=>O(e,t,void 0,(e,t)=>({...t,services:e.services,scope:e.scope})),A=()=>({_tag:`SyncFx`,[e]:{_A:()=>void 0,_E:()=>void 0,_R:()=>void 0},*[Symbol.iterator](){return yield{_tag:`GetRuntimeState`}}}),j=t=>({_tag:`SyncFx`,[e]:{_A:()=>void 0,_E:()=>void 0,_R:()=>void 0},*[Symbol.iterator](){yield{_tag:`UpdateRuntimeState`,update:t}}}),M=t=>({_tag:`AsyncFx`,[e]:{_A:()=>void 0,_E:()=>void 0,_R:()=>void 0},async*[Symbol.asyncIterator](){return yield t}}),N=t=>({_tag:`SyncFx`,[e]:{_A:()=>void 0,_E:()=>void 0,_R:()=>void 0},*[Symbol.iterator](){return yield t}}),P=(e,t)=>M({_tag:`ForkFiber`,fx:e,detached:t}),F=e=>M({_tag:`AwaitFiber`,fiber:e}),I=e=>M({_tag:`JoinFiber`,fiber:e}),L=e=>M({_tag:`InterruptFiber`,fiber:e}),R=e=>N({_tag:`FiberStatus`,fiber:e}),z=()=>M({_tag:`YieldNow`}),B=(e,t)=>M({_tag:`InterruptibleAsync`,start:e,interrupt:t}),V=e=>e instanceof i?e:p(e)?e.error:e,H=e=>Error(`Service "${e}" not provided. Use Provide.layer() to inject services.`),U=(e,t)=>{if(C(t))return w(t);if(e._tag===`GetRuntimeState`)return{exit:c(t),state:t};if(e._tag===`UpdateRuntimeState`)return{exit:c(void 0),state:e.update(t)};if(e._tag===`FiberStatus`)return{exit:c(e.fiber.status()),state:t};if(e._tag===`ForkFiber`||e._tag===`AwaitFiber`||e._tag===`JoinFiber`||e._tag===`InterruptFiber`||e._tag===`YieldNow`||e._tag===`InterruptibleAsync`)return{exit:u(Error(`Cannot execute ${e._tag} from sync runtime.`)),state:t};if(e.fx._tag===`AsyncFx`)return{exit:u(Error(`Cannot execute AsyncFx from sync runtime instruction.`)),state:t};let n=K(e.fx,e.update(t));return e.onExit?.(n.exit,n.state),{exit:n.exit,state:e.restore?.(t,n.state)??t}},W=async(e,t)=>{if(C(t))return w(t);if(e._tag===`GetRuntimeState`)return{exit:c(t),state:t};if(e._tag===`UpdateRuntimeState`)return{exit:c(void 0),state:e.update(t)};if(e._tag===`ForkFiber`){let n=S(e.fx,t);return e.detached||t.fiber?.children.add(n),{exit:c(n),state:t}}if(e._tag===`AwaitFiber`)return{exit:c(await e.fiber.await()),state:t};if(e._tag===`JoinFiber`){let n=await e.fiber.await();return n._tag===`Ok`?{exit:c(n.value),state:t}:n._tag===`Err`?{exit:l(n.error),state:t}:n._tag===`Interrupted`?{exit:d(n.fiberId),state:t}:{exit:u(n.defect),state:t}}if(e._tag===`InterruptFiber`)return{exit:c(await e.fiber.interrupt()),state:t};if(e._tag===`FiberStatus`)return{exit:c(e.fiber.status()),state:t};if(e._tag===`YieldNow`)return await v(0),C(t)?w(t):{exit:c(void 0),state:t};if(e._tag===`InterruptibleAsync`){let n=t.fiber;if(n===void 0)try{let n=await e.start(t);return{exit:n._tag===`Ok`?c(n.value):l(n.error),state:t}}catch(e){return{exit:u(e),state:t}}let r=y,i=!1,a=new Promise(t=>{r=n.addInterruptor(()=>{if(!i){i=!0;try{e.interrupt()}catch{}t(`Interrupted`)}})}),o=Promise.resolve().then(()=>e.start(t)).then(e=>({_tag:`Result`,result:e})).catch(e=>({_tag:`Defect`,cause:e}));try{let e=await Promise.race([o,a]);return e===`Interrupted`||C(t)?w(t):e._tag===`Defect`?{exit:u(e.cause),state:t}:{exit:e.result._tag===`Ok`?c(e.result.value):l(e.result.error),state:t}}finally{r()}}let n=e.fx._tag===`AsyncFx`?await Y(e.fx,e.update(t)):K(e.fx,e.update(t));return e.onExit?.(n.exit,n.state),{exit:n.exit,state:e.restore?.(t,n.state)??t}};function G(e){return K(e,h()).exit}function K(e,t){let n=t;try{let t=e[Symbol.iterator](),r=t.next();for(;r.done!==!0;){if(C(n))return w(n);let e=r.value;if(m(e)){let i=U(e,n);if(n=i.state,i.exit._tag===`Ok`){r=t.next(i.exit.value);continue}return i}let i=o(e);if(i!==void 0){let a=s(n.services,e);if(a===void 0)return{exit:u(H(i.key)),state:n};r=t.next(a);continue}return{exit:l(V(e)),state:n}}return{exit:c(r.value),state:n}}catch(e){return{exit:u(e),state:n}}}async function q(e){return J(e).await()}function J(e){return S(e,h())}async function Y(e,t){let n=t;try{let t=e[Symbol.asyncIterator](),r=await t.next();for(;r.done!==!0;){if(C(n))return w(n);let e=r.value;if(m(e)){let i=await W(e,n);if(n=i.state,i.exit._tag===`Ok`){r=await t.next(i.exit.value);continue}return i}let i=o(e);if(i!==void 0){let a=s(n.services,e);if(a===void 0)return{exit:u(H(i.key)),state:n};r=await t.next(a);continue}return{exit:l(V(e)),state:n}}return{exit:c(r.value),state:n}}catch(e){return{exit:u(e),state:n}}}export{k as _,L as a,o as b,I as c,J as d,G as f,O as g,D as h,A as i,T as l,j as m,P as n,B as o,E as p,R as r,m as s,F as t,q as u,z as v,s as x,f as y};
+//# sourceMappingURL=fx.runtime-B2_rL7h_.mjs.map

package/dist/fx.runtime-B2_rL7h_.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"fx.runtime-B2_rL7h_.mjs","names":["Context.empty","exitInterrupted","Context.merge","exitOk","exitDefect","exitErr","interrupted"],"sources":["../src/service/service-resolution.ts","../src/fx/exit.ts","../src/fx/fx.runtime.ts"],"sourcesContent":["import type { Context } from \"../context/context\"\n\ntype ServiceRequest = {\n  _tag: \"Service\"\n  key: string\n}\n\n/**\n * Narrow an unknown yielded value to a service request.\n */\nfunction isServiceRequest(value: unknown): value is ServiceRequest {\n  return (\n    typeof value === \"object\" &&\n    value !== null &&\n    \"_tag\" in value &&\n    value._tag === \"Service\" &&\n    \"key\" in value &&\n    typeof value.key === \"string\"\n  )\n}\n\nexport function asServiceRequest(value: unknown) {\n  return isServiceRequest(value) ? value : undefined\n}\n\n/**\n * Resolve a yielded service request from a context.\n */\nexport function resolveService<R>(ctx: Context<R>, value: unknown) {\n  const request = asServiceRequest(value)\n  if (request === undefined) return undefined\n  return ctx._services.get(request.key)\n}\n","import { dual } from \"../shared/dual\"\nimport type { Err, Ok } from \"../shared/type-utils.types\"\n\n// ============================================================================\n// Exit Types - Flat 3-variant discriminated union\n// ============================================================================\n\n/**\n * Represents an unexpected thrown exception (defect) caught during Fx execution.\n */\ntype Defect = {\n  readonly _tag: \"Defect\"\n  readonly defect: unknown\n}\n\n/**\n * Represents cooperative fiber interruption.\n */\ntype Interrupted = {\n  readonly _tag: \"Interrupted\"\n  readonly fiberId: number\n}\n\n/**\n * Exit represents the outcome of an Fx computation.\n * A flat discriminated union that cleanly separates:\n * - `Ok<A>`: successful result with value of type A\n * - `Err<E>`: typed failure with error of type E\n * - `Defect`: unexpected thrown exception (defect)\n * - `Interrupted`: cooperative fiber interruption\n *\n * @example\n * ```ts\n * const exit = Fx.run(computation)\n * switch (exit._tag) {\n *   case \"Ok\":      exit.value    // A\n *   case \"Err\":     exit.error    // E (clean!)\n *   case \"Defect\":  exit.defect   // unknown\n * }\n * ```\n */\nexport type Exit<A, E> = Ok<A> | Err<E> | Defect | Interrupted\n\n// ============================================================================\n// Constructors\n// ============================================================================\n\n/**\n * Create a successful Exit.\n */\nexport const ok = <A>(value: A): Ok<A> => ({ _tag: \"Ok\", value })\n\n/**\n * Create a typed failure Exit.\n */\nexport const err = <E>(error: E): Err<E> => ({ _tag: \"Err\", error })\n\n/**\n * Create a defect Exit from an unexpected thrown value.\n */\nexport const defect = (thrown: unknown): Defect => ({ _tag: \"Defect\", defect: thrown })\n\n/**\n * Create an interrupted Exit.\n */\nexport const interrupted = (fiberId: number): Interrupted => ({ _tag: \"Interrupted\", fiberId })\n\n// ============================================================================\n// Guards\n// ============================================================================\n\n/**\n * Check if an Exit is a successful result.\n */\nconst isOk = <A, E>(exit: Exit<A, E>): exit is Ok<A> => exit._tag === \"Ok\"\n\n/**\n * Check if an Exit is a typed failure.\n */\nconst isErr = <A, E>(exit: Exit<A, E>): exit is Err<E> => exit._tag === \"Err\"\n\n/**\n * Check if an Exit is an unexpected defect.\n */\nconst isDefect = <A, E>(exit: Exit<A, E>): exit is Defect => exit._tag === \"Defect\"\n\n/**\n * Check if an Exit is an interruption.\n */\nconst isInterrupted = <A, E>(exit: Exit<A, E>): exit is Interrupted => exit._tag === \"Interrupted\"\n\n// ============================================================================\n// Match\n// ============================================================================\n\n/**\n * Handler functions for Exit.match.\n */\ntype ExitMatch<A, E, R> = {\n  readonly Ok: (value: A) => R\n  readonly Err: (error: E) => R\n  readonly Defect: (defect: unknown) => R\n  readonly Interrupted?: (fiberId: number) => R\n}\n\n/**\n * Pattern match on an Exit value.\n *\n * @example\n * ```ts\n * // Data-first\n * Exit.match(exit, {\n *   Ok: (value) => `Success: ${value}`,\n *   Err: (error) => `Error: ${error}`,\n *   Defect: (defect) => `Defect: ${defect}`,\n * })\n *\n * // Data-last (pipe)\n * pipe(exit, Exit.match({\n *   Ok: (value) => `Success: ${value}`,\n *   Err: (error) => `Error: ${error}`,\n *   Defect: (defect) => `Defect: ${defect}`,\n * }))\n * ```\n */\nconst match: {\n  <A, E, R>(exit: Exit<A, E>, handlers: ExitMatch<A, E, R>): R\n  <A, E, R>(handlers: ExitMatch<A, E, R>): (exit: Exit<A, E>) => R\n} = dual(2, <A, E, R>(exit: Exit<A, E>, handlers: ExitMatch<A, E, R>): R => {\n  switch (exit._tag) {\n    case \"Ok\":\n      return handlers.Ok(exit.value)\n    case \"Err\":\n      return handlers.Err(exit.error)\n    case \"Defect\":\n      return handlers.Defect(exit.defect)\n    case \"Interrupted\":\n      if (handlers.Interrupted !== undefined) {\n        return handlers.Interrupted(exit.fiberId)\n      }\n      throw new Error(`Fiber ${exit.fiberId} interrupted.`)\n  }\n})\n\n// ============================================================================\n// Utility\n// ============================================================================\n\n/**\n * Extract the value from an Ok exit, or throw.\n * Useful for tests and scripts where you expect success.\n *\n * @throws The error for Err exits, or the defect for Defect exits\n */\nconst getOrThrow = <A, E>(exit: Exit<A, E>): A => {\n  switch (exit._tag) {\n    case \"Ok\":\n      return exit.value\n    case \"Err\":\n      // oxlint-disable-next-line only-throw-error -- E is intentionally generic and may be a non-Error domain value.\n      throw exit.error\n    case \"Defect\":\n      throw exit.defect\n    case \"Interrupted\":\n      throw new Error(`Fiber ${exit.fiberId} interrupted.`)\n  }\n}\n\n// ============================================================================\n// Namespace\n// ============================================================================\n\n/**\n * Exit namespace containing all Exit utilities.\n */\nexport const Exit = {\n  ok,\n  err,\n  defect,\n  interrupted,\n  isOk,\n  isErr,\n  isDefect,\n  isInterrupted,\n  match,\n  getOrThrow,\n} as const\n","import * as Context from \"../context/context\"\nimport type { Context as ContextType } from \"../context/context\"\nimport { NoSuchElementError } from \"../option/option.types\"\nimport type { Result as ResultType } from \"../result/result.types\"\nimport { asServiceRequest, resolveService } from \"../service/service-resolution\"\nimport { ok as exitOk, err as exitErr, defect as exitDefect, interrupted as exitInterrupted } from \"./exit\"\nimport type { Exit } from \"./exit\"\nimport { FxTypeId } from \"./fx.types\"\nimport type { AsyncFx, FxYield, RunnableFx, SyncFx } from \"./fx.types\"\n\n/* oxlint-disable no-await-in-loop, typescript-eslint/no-unsafe-type-assertion, typescript-eslint/require-await -- The runtime driver crosses erased generator boundaries and must rehydrate typed success/error/runtime instruction channels. */\n\ntype LogSpan = {\n  readonly label: string\n  readonly startedAt: number\n}\n\nexport type RuntimeState = {\n  readonly services: ContextType<unknown>\n  readonly scope: unknown\n  readonly fiberId: number | undefined\n  readonly fiber: InternalFiber<unknown, unknown> | undefined\n  readonly loggers: ReadonlyArray<unknown>\n  readonly logFields: Record<string, unknown>\n  readonly logSpans: ReadonlyArray<LogSpan>\n  readonly tracer: unknown\n  readonly currentSpan: unknown\n  readonly currentLocalSpan: unknown\n  readonly spanAttributes: Record<string, unknown>\n  readonly spanLinks: ReadonlyArray<unknown>\n}\n\ntype RuntimeResult<A, E> = {\n  readonly exit: Exit<A, E>\n  readonly state: RuntimeState\n}\n\nexport type FiberStatus = \"Running\" | \"Done\" | \"Interrupted\"\n\nexport type RuntimeFiber<A, E> = {\n  readonly id: number\n  await(): Promise<Exit<A, E>>\n  interrupt(): Promise<Exit<A, E>>\n  status(): FiberStatus\n}\n\ntype RunWithRuntimeStateInstruction<A, E> = {\n  readonly _tag: \"RunWithRuntimeState\"\n  readonly fx: RunnableFx<A, E, unknown>\n  readonly update: (state: RuntimeState) => RuntimeState\n  readonly onExit?: (exit: Exit<A, E>, state: RuntimeState) => void\n  readonly restore?: (parent: RuntimeState, nested: RuntimeState) => RuntimeState\n}\n\ntype GetRuntimeStateInstruction = {\n  readonly _tag: \"GetRuntimeState\"\n}\n\ntype UpdateRuntimeStateInstruction = {\n  readonly _tag: \"UpdateRuntimeState\"\n  readonly update: (state: RuntimeState) => RuntimeState\n}\n\ntype ForkFiberInstruction<A, E> = {\n  readonly _tag: \"ForkFiber\"\n  readonly fx: RunnableFx<A, E, unknown>\n  readonly detached: boolean\n}\n\ntype AwaitFiberInstruction<A, E> = {\n  readonly _tag: \"AwaitFiber\"\n  readonly fiber: RuntimeFiber<A, E>\n}\n\ntype JoinFiberInstruction<A, E> = {\n  readonly _tag: \"JoinFiber\"\n  readonly fiber: RuntimeFiber<A, E>\n}\n\ntype InterruptFiberInstruction<A, E> = {\n  readonly _tag: \"InterruptFiber\"\n  readonly fiber: RuntimeFiber<A, E>\n}\n\ntype FiberStatusInstruction = {\n  readonly _tag: \"FiberStatus\"\n  readonly fiber: RuntimeFiber<unknown, unknown>\n}\n\ntype YieldNowInstruction = {\n  readonly _tag: \"YieldNow\"\n}\n\ntype InterruptibleAsyncInstruction<A, E> = {\n  readonly _tag: \"InterruptibleAsync\"\n  readonly start: (state: RuntimeState) => Promise<ResultType<A, E>>\n  readonly interrupt: () => void\n}\n\ntype RuntimeInstruction<A = unknown, E = unknown> =\n  | RunWithRuntimeStateInstruction<A, E>\n  | GetRuntimeStateInstruction\n  | UpdateRuntimeStateInstruction\n  | ForkFiberInstruction<A, E>\n  | AwaitFiberInstruction<A, E>\n  | JoinFiberInstruction<A, E>\n  | InterruptFiberInstruction<A, E>\n  | FiberStatusInstruction\n  | YieldNowInstruction\n  | InterruptibleAsyncInstruction<A, E>\n\nconst isResultErr = (value: unknown): value is { readonly _tag: \"Err\"; readonly error: unknown } =>\n  typeof value === \"object\" && value !== null && \"_tag\" in value && value._tag === \"Err\" && \"error\" in value\n\nexport const isRuntimeInstruction = (value: unknown): value is RuntimeInstruction =>\n  typeof value === \"object\" &&\n  value !== null &&\n  \"_tag\" in value &&\n  (value._tag === \"RunWithRuntimeState\" ||\n    value._tag === \"GetRuntimeState\" ||\n    value._tag === \"UpdateRuntimeState\" ||\n    value._tag === \"ForkFiber\" ||\n    value._tag === \"AwaitFiber\" ||\n    value._tag === \"JoinFiber\" ||\n    value._tag === \"InterruptFiber\" ||\n    value._tag === \"FiberStatus\" ||\n    value._tag === \"YieldNow\" ||\n    value._tag === \"InterruptibleAsync\")\n\nconst makeDefaultRuntimeState = (): RuntimeState => ({\n  services: Context.empty(),\n  scope: undefined,\n  fiberId: undefined,\n  fiber: undefined,\n  loggers: [],\n  logFields: {},\n  logSpans: [],\n  tracer: undefined,\n  currentSpan: undefined,\n  currentLocalSpan: undefined,\n  spanAttributes: {},\n  spanLinks: [],\n})\n\nlet nextFiberId = 0\n\nconst nextRuntimeFiberId = (): number => {\n  nextFiberId += 1\n  return nextFiberId\n}\n\nconst sleep = (ms: number): Promise<void> =>\n  new Promise((resolve) => {\n    setTimeout(resolve, ms)\n  })\n\nconst noop = (): void => {}\n\nconst copyRuntimeState = (state: RuntimeState): RuntimeState => ({\n  ...state,\n  loggers: [...state.loggers],\n  logFields: { ...state.logFields },\n  logSpans: [...state.logSpans],\n  currentLocalSpan: undefined,\n  spanAttributes: { ...state.spanAttributes },\n  spanLinks: [...state.spanLinks],\n})\n\nclass InternalFiber<A, E> implements RuntimeFiber<A, E> {\n  readonly id: number\n  readonly children = new Set<InternalFiber<unknown, unknown>>()\n  private readonly interruptors = new Set<() => void>()\n  private readonly promise: Promise<Exit<A, E>>\n  private exit: Exit<A, E> | undefined\n  private interrupted = false\n\n  constructor(fx: RunnableFx<A, E, unknown>, inheritedState: RuntimeState) {\n    this.id = nextRuntimeFiberId()\n    this.promise = this.run(fx, inheritedState)\n  }\n\n  status(): FiberStatus {\n    if (this.exit !== undefined) {\n      return this.exit._tag === \"Interrupted\" ? \"Interrupted\" : \"Done\"\n    }\n    return this.interrupted ? \"Interrupted\" : \"Running\"\n  }\n\n  await(): Promise<Exit<A, E>> {\n    return this.promise\n  }\n\n  async interrupt(): Promise<Exit<A, E>> {\n    this.interrupted = true\n    for (const interruptor of this.interruptors) {\n      try {\n        interruptor()\n      } catch {\n        // Interruption is best-effort; one failing hook must not block shutdown.\n      }\n    }\n    await Promise.all([...this.children].map((child) => child.interrupt()))\n    return this.promise\n  }\n\n  addInterruptor(interruptor: () => void): () => void {\n    this.interruptors.add(interruptor)\n    return () => {\n      this.interruptors.delete(interruptor)\n    }\n  }\n\n  isInterrupted(): boolean {\n    return this.interrupted\n  }\n\n  private async interruptChildren(): Promise<void> {\n    if (this.children.size === 0) {\n      return\n    }\n\n    await Promise.all([...this.children].map((child) => child.interrupt()))\n    this.children.clear()\n  }\n\n  private async run(fx: RunnableFx<A, E, unknown>, inheritedState: RuntimeState): Promise<Exit<A, E>> {\n    await Promise.resolve()\n\n    const state: RuntimeState = {\n      ...copyRuntimeState(inheritedState),\n      fiberId: this.id,\n      fiber: this as InternalFiber<unknown, unknown>,\n    }\n\n    const result = fx._tag === \"AsyncFx\" ? await runAsyncWithState(fx, state) : runSyncWithState(fx, state)\n    await this.interruptChildren()\n    const exit = this.interrupted && result.exit._tag === \"Ok\" ? exitInterrupted(this.id) : result.exit\n    this.exit = exit\n    return exit\n  }\n}\n\nconst runForkWithState = <A, E>(fx: RunnableFx<A, E, unknown>, state: RuntimeState): InternalFiber<A, E> =>\n  new InternalFiber(fx, state)\n\nconst shouldInterrupt = (state: RuntimeState): boolean => state.fiber?.isInterrupted() === true\n\nconst currentInterruptedExit = <A, E>(state: RuntimeState): RuntimeResult<A, E> => ({\n  exit: exitInterrupted(state.fiberId ?? 0),\n  state,\n})\n\nexport const mergeRuntimeServices =\n  <R>(ctx: ContextType<R>) =>\n  (state: RuntimeState): RuntimeState => ({\n    ...state,\n    services: Context.merge(state.services, ctx),\n  })\n\nexport const setRuntimeTracer =\n  (tracer: unknown) =>\n  (state: RuntimeState): RuntimeState => ({\n    ...state,\n    tracer,\n  })\n\nexport function withRuntimeState<A, E, R>(\n  fx: SyncFx<A, E, R>,\n  update: (state: RuntimeState) => RuntimeState,\n): SyncFx<A, E>\nexport function withRuntimeState<A, E, R>(\n  fx: AsyncFx<A, E, R>,\n  update: (state: RuntimeState) => RuntimeState,\n): AsyncFx<A, E>\nexport function withRuntimeState<A, E, R>(\n  fx: RunnableFx<A, E, R>,\n  update: (state: RuntimeState) => RuntimeState,\n): RunnableFx<A, E>\nexport function withRuntimeState<A, E, R>(\n  fx: RunnableFx<A, E, R>,\n  update: (state: RuntimeState) => RuntimeState,\n): RunnableFx<A, E> {\n  return withRuntimeStateAndExit(fx, update)\n}\n\nexport function withRuntimeStateAndExit<A, E, R>(\n  fx: SyncFx<A, E, R>,\n  update: (state: RuntimeState) => RuntimeState,\n  onExit?: (exit: Exit<A, E>, state: RuntimeState) => void,\n  restore?: (parent: RuntimeState, nested: RuntimeState) => RuntimeState,\n): SyncFx<A, E>\nexport function withRuntimeStateAndExit<A, E, R>(\n  fx: AsyncFx<A, E, R>,\n  update: (state: RuntimeState) => RuntimeState,\n  onExit?: (exit: Exit<A, E>, state: RuntimeState) => void,\n  restore?: (parent: RuntimeState, nested: RuntimeState) => RuntimeState,\n): AsyncFx<A, E>\nexport function withRuntimeStateAndExit<A, E, R>(\n  fx: RunnableFx<A, E, R>,\n  update: (state: RuntimeState) => RuntimeState,\n  onExit?: (exit: Exit<A, E>, state: RuntimeState) => void,\n  restore?: (parent: RuntimeState, nested: RuntimeState) => RuntimeState,\n): RunnableFx<A, E>\nexport function withRuntimeStateAndExit<A, E, R>(\n  fx: RunnableFx<A, E, R>,\n  update: (state: RuntimeState) => RuntimeState,\n  onExit?: (exit: Exit<A, E>, state: RuntimeState) => void,\n  restore?: (parent: RuntimeState, nested: RuntimeState) => RuntimeState,\n): RunnableFx<A, E> {\n  const instruction: RunWithRuntimeStateInstruction<A, E> = {\n    _tag: \"RunWithRuntimeState\",\n    fx: fx as RunnableFx<A, E, unknown>,\n    update,\n    ...(onExit === undefined ? {} : { onExit }),\n    ...(restore === undefined ? {} : { restore }),\n  }\n\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        return (yield instruction as unknown as FxYield<E, never>) as A\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      return (yield instruction as unknown as FxYield<E, never>) as A\n    },\n  } as SyncFx<A, E>\n}\n\nexport const withRuntimeStateCommit = <A, E, R>(\n  fx: RunnableFx<A, E, R>,\n  update: (state: RuntimeState) => RuntimeState,\n): RunnableFx<A, E> =>\n  withRuntimeStateAndExit(fx, update, undefined, (parent, nested) => ({\n    ...nested,\n    services: parent.services,\n    scope: parent.scope,\n  }))\n\nexport const getRuntimeState = (): SyncFx<RuntimeState> => ({\n  _tag: \"SyncFx\",\n  [FxTypeId]: {\n    _A: () => undefined as unknown as RuntimeState,\n    _E: () => undefined as never,\n    _R: () => undefined as never,\n  },\n  *[Symbol.iterator](): Generator<FxYield<never, never>, RuntimeState, unknown> {\n    return (yield { _tag: \"GetRuntimeState\" } as unknown as FxYield<never, never>) as RuntimeState\n  },\n})\n\nexport const updateRuntimeState = (update: (state: RuntimeState) => RuntimeState): SyncFx<void> => ({\n  _tag: \"SyncFx\",\n  [FxTypeId]: {\n    _A: () => undefined,\n    _E: () => undefined as never,\n    _R: () => undefined as never,\n  },\n  *[Symbol.iterator](): Generator<FxYield<never, never>, void, unknown> {\n    yield { _tag: \"UpdateRuntimeState\", update } as unknown as FxYield<never, never>\n  },\n})\n\nconst makeAsyncRuntimeInstructionFx = <A, E>(instruction: RuntimeInstruction): AsyncFx<A, E> => ({\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    return (yield instruction as unknown as FxYield<E, never>) as A\n  },\n})\n\nconst makeSyncRuntimeInstructionFx = <A, E>(instruction: RuntimeInstruction): SyncFx<A, E> => ({\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    return (yield instruction as unknown as FxYield<E, never>) as A\n  },\n})\n\nexport const forkFiber = <A, E, R>(fx: RunnableFx<A, E, R>, detached: boolean): AsyncFx<RuntimeFiber<A, E>> =>\n  makeAsyncRuntimeInstructionFx<RuntimeFiber<A, E>, never>({\n    _tag: \"ForkFiber\",\n    fx: fx as RunnableFx<A, E, unknown>,\n    detached,\n  })\n\nexport const awaitFiber = <A, E>(fiber: RuntimeFiber<A, E>): AsyncFx<Exit<A, E>> =>\n  makeAsyncRuntimeInstructionFx<Exit<A, E>, never>({\n    _tag: \"AwaitFiber\",\n    fiber,\n  })\n\nexport const joinFiber = <A, E>(fiber: RuntimeFiber<A, E>): AsyncFx<A, E> =>\n  makeAsyncRuntimeInstructionFx<A, E>({\n    _tag: \"JoinFiber\",\n    fiber,\n  })\n\nexport const interruptFiber = <A, E>(fiber: RuntimeFiber<A, E>): AsyncFx<Exit<A, E>> =>\n  makeAsyncRuntimeInstructionFx<Exit<A, E>, never>({\n    _tag: \"InterruptFiber\",\n    fiber,\n  })\n\nexport const getFiberStatus = (fiber: RuntimeFiber<unknown, unknown>): SyncFx<FiberStatus> =>\n  makeSyncRuntimeInstructionFx<FiberStatus, never>({\n    _tag: \"FiberStatus\",\n    fiber,\n  })\n\nexport const yieldNow = (): AsyncFx<void> =>\n  makeAsyncRuntimeInstructionFx<void, never>({\n    _tag: \"YieldNow\",\n  })\n\nexport const interruptibleAsync = <A, E>(\n  start: (state: RuntimeState) => Promise<ResultType<A, E>>,\n  interrupt: () => void,\n): AsyncFx<A, E> =>\n  makeAsyncRuntimeInstructionFx<A, E>({\n    _tag: \"InterruptibleAsync\",\n    start,\n    interrupt,\n  })\n\nconst toTypedFailure = <E>(yielded: unknown): E => {\n  if (yielded instanceof NoSuchElementError) {\n    return yielded as E\n  }\n\n  if (isResultErr(yielded)) {\n    return yielded.error as E\n  }\n\n  return yielded as E\n}\n\nconst missingServiceDefect = (key: string): Error =>\n  new Error(`Service \"${key}\" not provided. Use Provide.layer() to inject services.`)\n\nconst runRuntimeInstructionSync = <A, E>(\n  instruction: RuntimeInstruction<A, E>,\n  state: RuntimeState,\n): RuntimeResult<A, E> => {\n  if (shouldInterrupt(state)) {\n    return currentInterruptedExit(state)\n  }\n\n  if (instruction._tag === \"GetRuntimeState\") {\n    return {\n      exit: exitOk(state as A),\n      state,\n    }\n  }\n\n  if (instruction._tag === \"UpdateRuntimeState\") {\n    return {\n      exit: exitOk(undefined as A),\n      state: instruction.update(state),\n    }\n  }\n\n  if (instruction._tag === \"FiberStatus\") {\n    return {\n      exit: exitOk(instruction.fiber.status() as A),\n      state,\n    }\n  }\n\n  if (\n    instruction._tag === \"ForkFiber\" ||\n    instruction._tag === \"AwaitFiber\" ||\n    instruction._tag === \"JoinFiber\" ||\n    instruction._tag === \"InterruptFiber\" ||\n    instruction._tag === \"YieldNow\" ||\n    instruction._tag === \"InterruptibleAsync\"\n  ) {\n    return {\n      exit: exitDefect(new Error(`Cannot execute ${instruction._tag} from sync runtime.`)),\n      state,\n    }\n  }\n\n  if (instruction.fx._tag === \"AsyncFx\") {\n    return {\n      exit: exitDefect(new Error(\"Cannot execute AsyncFx from sync runtime instruction.\")),\n      state,\n    }\n  }\n\n  const nested = runSyncWithState(instruction.fx, instruction.update(state))\n  instruction.onExit?.(nested.exit, nested.state)\n  return {\n    exit: nested.exit,\n    state: instruction.restore?.(state, nested.state) ?? state,\n  }\n}\n\nconst runRuntimeInstructionAsync = async <A, E>(\n  instruction: RuntimeInstruction<A, E>,\n  state: RuntimeState,\n): Promise<RuntimeResult<A, E>> => {\n  if (shouldInterrupt(state)) {\n    return currentInterruptedExit(state)\n  }\n\n  if (instruction._tag === \"GetRuntimeState\") {\n    return {\n      exit: exitOk(state as A),\n      state,\n    }\n  }\n\n  if (instruction._tag === \"UpdateRuntimeState\") {\n    return {\n      exit: exitOk(undefined as A),\n      state: instruction.update(state),\n    }\n  }\n\n  if (instruction._tag === \"ForkFiber\") {\n    const child = runForkWithState(instruction.fx, state)\n    if (!instruction.detached) {\n      state.fiber?.children.add(child as InternalFiber<unknown, unknown>)\n    }\n    return {\n      exit: exitOk(child as A),\n      state,\n    }\n  }\n\n  if (instruction._tag === \"AwaitFiber\") {\n    const exit = await instruction.fiber.await()\n    return {\n      exit: exitOk(exit as A),\n      state,\n    }\n  }\n\n  if (instruction._tag === \"JoinFiber\") {\n    const exit = await instruction.fiber.await()\n    if (exit._tag === \"Ok\") {\n      return {\n        exit: exitOk(exit.value),\n        state,\n      }\n    }\n    if (exit._tag === \"Err\") {\n      return {\n        exit: exitErr(exit.error),\n        state,\n      }\n    }\n    if (exit._tag === \"Interrupted\") {\n      return {\n        exit: exitInterrupted(exit.fiberId),\n        state,\n      }\n    }\n    return {\n      exit: exitDefect(exit.defect),\n      state,\n    }\n  }\n\n  if (instruction._tag === \"InterruptFiber\") {\n    const exit = await instruction.fiber.interrupt()\n    return {\n      exit: exitOk(exit as A),\n      state,\n    }\n  }\n\n  if (instruction._tag === \"FiberStatus\") {\n    return {\n      exit: exitOk(instruction.fiber.status() as A),\n      state,\n    }\n  }\n\n  if (instruction._tag === \"YieldNow\") {\n    await sleep(0)\n    if (shouldInterrupt(state)) {\n      return currentInterruptedExit(state)\n    }\n    return {\n      exit: exitOk(undefined as A),\n      state,\n    }\n  }\n\n  if (instruction._tag === \"InterruptibleAsync\") {\n    const fiber = state.fiber\n    if (fiber === undefined) {\n      try {\n        const result = await instruction.start(state)\n        return {\n          exit: result._tag === \"Ok\" ? exitOk(result.value) : exitErr(result.error),\n          state,\n        }\n      } catch (cause) {\n        return {\n          exit: exitDefect(cause),\n          state,\n        }\n      }\n    }\n\n    let unregister = noop\n    let interrupted = false\n\n    const interruptedPromise = new Promise<\"Interrupted\">((resolve) => {\n      unregister = fiber.addInterruptor(() => {\n        if (interrupted) return\n        interrupted = true\n        try {\n          instruction.interrupt()\n        } catch {\n          // Interruption hooks are best-effort and cannot fail the fiber.\n        }\n        resolve(\"Interrupted\")\n      })\n    })\n\n    const resultPromise = Promise.resolve()\n      .then(() => instruction.start(state))\n      .then((result) => ({ _tag: \"Result\" as const, result }))\n      .catch((cause: unknown) => ({ _tag: \"Defect\" as const, cause }))\n\n    try {\n      const winner = await Promise.race([resultPromise, interruptedPromise])\n\n      if (winner === \"Interrupted\" || shouldInterrupt(state)) {\n        return currentInterruptedExit(state)\n      }\n\n      if (winner._tag === \"Defect\") {\n        return {\n          exit: exitDefect(winner.cause),\n          state,\n        }\n      }\n\n      return {\n        exit: winner.result._tag === \"Ok\" ? exitOk(winner.result.value) : exitErr(winner.result.error),\n        state,\n      }\n    } finally {\n      unregister()\n    }\n  }\n\n  const nested =\n    instruction.fx._tag === \"AsyncFx\"\n      ? await runAsyncWithState(instruction.fx, instruction.update(state))\n      : runSyncWithState(instruction.fx, instruction.update(state))\n\n  instruction.onExit?.(nested.exit, nested.state)\n  return {\n    exit: nested.exit,\n    state: instruction.restore?.(state, nested.state) ?? state,\n  }\n}\n\nexport function runSync<A, E>(fx: SyncFx<A, E>): Exit<A, E> {\n  return runSyncWithState(fx, makeDefaultRuntimeState()).exit\n}\n\nfunction runSyncWithState<A, E>(fx: SyncFx<A, E, unknown>, state: RuntimeState): RuntimeResult<A, E> {\n  let currentState = state\n\n  try {\n    const gen = fx[Symbol.iterator]()\n    let result = gen.next()\n\n    while (result.done !== true) {\n      if (shouldInterrupt(currentState)) {\n        return currentInterruptedExit(currentState)\n      }\n\n      const yielded = result.value as unknown\n\n      if (isRuntimeInstruction(yielded)) {\n        const nested = runRuntimeInstructionSync(yielded as RuntimeInstruction<unknown, E>, currentState)\n        currentState = nested.state\n        if (nested.exit._tag === \"Ok\") {\n          result = gen.next(nested.exit.value)\n          continue\n        }\n        return nested as RuntimeResult<A, E>\n      }\n\n      const serviceRequest = asServiceRequest(yielded)\n      if (serviceRequest !== undefined) {\n        const service = resolveService(currentState.services, yielded)\n        if (service === undefined) {\n          return {\n            exit: exitDefect(missingServiceDefect(serviceRequest.key)),\n            state: currentState,\n          }\n        }\n        result = gen.next(service)\n        continue\n      }\n\n      return {\n        exit: exitErr(toTypedFailure<E>(yielded)),\n        state: currentState,\n      }\n    }\n\n    return {\n      exit: exitOk(result.value),\n      state: currentState,\n    }\n  } catch (thrown) {\n    return {\n      exit: exitDefect(thrown),\n      state: currentState,\n    }\n  }\n}\n\nexport async function runAsync<A, E>(fx: AsyncFx<A, E>): Promise<Exit<A, E>> {\n  return runFork(fx).await()\n}\n\nexport function runFork<A, E>(fx: RunnableFx<A, E>): RuntimeFiber<A, E> {\n  return runForkWithState(fx, makeDefaultRuntimeState())\n}\n\nasync function runAsyncWithState<A, E>(fx: AsyncFx<A, E, unknown>, state: RuntimeState): Promise<RuntimeResult<A, E>> {\n  let currentState = state\n\n  try {\n    const gen = fx[Symbol.asyncIterator]()\n    let result = await gen.next()\n\n    while (result.done !== true) {\n      if (shouldInterrupt(currentState)) {\n        return currentInterruptedExit(currentState)\n      }\n\n      const yielded = result.value as unknown\n\n      if (isRuntimeInstruction(yielded)) {\n        const nested = await runRuntimeInstructionAsync(yielded as RuntimeInstruction<unknown, E>, currentState)\n        currentState = nested.state\n        if (nested.exit._tag === \"Ok\") {\n          result = await gen.next(nested.exit.value)\n          continue\n        }\n        return nested as RuntimeResult<A, E>\n      }\n\n      const serviceRequest = asServiceRequest(yielded)\n      if (serviceRequest !== undefined) {\n        const service = resolveService(currentState.services, yielded)\n        if (service === undefined) {\n          return {\n            exit: exitDefect(missingServiceDefect(serviceRequest.key)),\n            state: currentState,\n          }\n        }\n        result = await gen.next(service)\n        continue\n      }\n\n      return {\n        exit: exitErr(toTypedFailure<E>(yielded)),\n        state: currentState,\n      }\n    }\n\n    return {\n      exit: exitOk(result.value),\n      state: currentState,\n    }\n  } catch (thrown) {\n    return {\n      exit: exitDefect(thrown),\n      state: currentState,\n    }\n  }\n}\n"],"mappings":"iLAUA,SAAS,EAAiB,EAAyC,CACjE,OACE,OAAO,GAAU,YACjB,GACA,SAAU,GACV,EAAM,OAAS,WACf,QAAS,GACT,OAAO,EAAM,KAAQ,SAIzB,SAAgB,EAAiB,EAAgB,CAC/C,OAAO,EAAiB,EAAM,CAAG,EAAQ,IAAA,GAM3C,SAAgB,EAAkB,EAAiB,EAAgB,CACjE,IAAM,EAAU,EAAiB,EAAM,CACnC,OAAY,IAAA,GAChB,OAAO,EAAI,UAAU,IAAI,EAAQ,IAAI,CCmBvC,MAAa,EAAS,IAAqB,CAAE,KAAM,KAAM,QAAO,EAKnD,EAAU,IAAsB,CAAE,KAAM,MAAO,QAAO,EAKtD,EAAU,IAA6B,CAAE,KAAM,SAAU,OAAQ,EAAQ,EAKzE,EAAe,IAAkC,CAAE,KAAM,cAAe,UAAS,EA8GjF,EAAO,CAClB,KACA,MACA,SACA,cACA,KA1GkB,GAAoC,EAAK,OAAS,KA2GpE,MAtGmB,GAAqC,EAAK,OAAS,MAuGtE,SAlGsB,GAAqC,EAAK,OAAS,SAmGzE,cA9F2B,GAA0C,EAAK,OAAS,cA+FnF,MAxDE,EAAK,GAAa,EAAkB,IAAoC,CAC1E,OAAQ,EAAK,KAAb,CACE,IAAK,KACH,OAAO,EAAS,GAAG,EAAK,MAAM,CAChC,IAAK,MACH,OAAO,EAAS,IAAI,EAAK,MAAM,CACjC,IAAK,SACH,OAAO,EAAS,OAAO,EAAK,OAAO,CACrC,IAAK,cACH,GAAI,EAAS,cAAgB,IAAA,GAC3B,OAAO,EAAS,YAAY,EAAK,QAAQ,CAE3C,MAAU,MAAM,SAAS,EAAK,QAAQ,eAAe,GAEzD,CA2CA,WA/BwB,GAAwB,CAChD,OAAQ,EAAK,KAAb,CACE,IAAK,KACH,OAAO,EAAK,MACd,IAAK,MAEH,MAAM,EAAK,MACb,IAAK,SACH,MAAM,EAAK,OACb,IAAK,cACH,MAAU,MAAM,SAAS,EAAK,QAAQ,eAAe,GAsB1D,CC3EK,EAAe,GACnB,OAAO,GAAU,YAAY,GAAkB,SAAU,GAAS,EAAM,OAAS,OAAS,UAAW,EAE1F,EAAwB,GACnC,OAAO,GAAU,YACjB,GACA,SAAU,IACT,EAAM,OAAS,uBACd,EAAM,OAAS,mBACf,EAAM,OAAS,sBACf,EAAM,OAAS,aACf,EAAM,OAAS,cACf,EAAM,OAAS,aACf,EAAM,OAAS,kBACf,EAAM,OAAS,eACf,EAAM,OAAS,YACf,EAAM,OAAS,sBAEb,OAA+C,CACnD,SAAUA,GAAe,CACzB,MAAO,IAAA,GACP,QAAS,IAAA,GACT,MAAO,IAAA,GACP,QAAS,EAAE,CACX,UAAW,EAAE,CACb,SAAU,EAAE,CACZ,OAAQ,IAAA,GACR,YAAa,IAAA,GACb,iBAAkB,IAAA,GAClB,eAAgB,EAAE,CAClB,UAAW,EAAE,CACd,EAED,IAAI,EAAc,EAElB,MAAM,OACJ,GAAe,EACR,GAGH,EAAS,GACb,IAAI,QAAS,GAAY,CACvB,WAAW,EAAS,EAAG,EACvB,CAEE,MAAmB,GAEnB,EAAoB,IAAuC,CAC/D,GAAG,EACH,QAAS,CAAC,GAAG,EAAM,QAAQ,CAC3B,UAAW,CAAE,GAAG,EAAM,UAAW,CACjC,SAAU,CAAC,GAAG,EAAM,SAAS,CAC7B,iBAAkB,IAAA,GAClB,eAAgB,CAAE,GAAG,EAAM,eAAgB,CAC3C,UAAW,CAAC,GAAG,EAAM,UAAU,CAChC,EAED,IAAM,EAAN,KAAwD,CACtD,GACA,SAAoB,IAAI,IACxB,aAAgC,IAAI,IACpC,QACA,KACA,YAAsB,GAEtB,YAAY,EAA+B,EAA8B,CACvE,KAAK,GAAK,GAAoB,CAC9B,KAAK,QAAU,KAAK,IAAI,EAAI,EAAe,CAG7C,QAAsB,CAIpB,OAHI,KAAK,OAAS,IAAA,GAGX,KAAK,YAAc,cAAgB,UAFjC,KAAK,KAAK,OAAS,cAAgB,cAAgB,OAK9D,OAA6B,CAC3B,OAAO,KAAK,QAGd,MAAM,WAAiC,CACrC,KAAK,YAAc,GACnB,IAAK,IAAM,KAAe,KAAK,aAC7B,GAAI,CACF,GAAa,MACP,EAKV,OADA,MAAM,QAAQ,IAAI,CAAC,GAAG,KAAK,SAAS,CAAC,IAAK,GAAU,EAAM,WAAW,CAAC,CAAC,CAChE,KAAK,QAGd,eAAe,EAAqC,CAElD,OADA,KAAK,aAAa,IAAI,EAAY,KACrB,CACX,KAAK,aAAa,OAAO,EAAY,EAIzC,eAAyB,CACvB,OAAO,KAAK,YAGd,MAAc,mBAAmC,CAC3C,KAAK,SAAS,OAAS,IAI3B,MAAM,QAAQ,IAAI,CAAC,GAAG,KAAK,SAAS,CAAC,IAAK,GAAU,EAAM,WAAW,CAAC,CAAC,CACvE,KAAK,SAAS,OAAO,EAGvB,MAAc,IAAI,EAA+B,EAAmD,CAClG,MAAM,QAAQ,SAAS,CAEvB,IAAM,EAAsB,CAC1B,GAAG,EAAiB,EAAe,CACnC,QAAS,KAAK,GACd,MAAO,KACR,CAEK,EAAS,EAAG,OAAS,UAAY,MAAM,EAAkB,EAAI,EAAM,CAAG,EAAiB,EAAI,EAAM,CACvG,MAAM,KAAK,mBAAmB,CAC9B,IAAM,EAAO,KAAK,aAAe,EAAO,KAAK,OAAS,KAAOC,EAAgB,KAAK,GAAG,CAAG,EAAO,KAE/F,MADA,MAAK,KAAO,EACL,IAIX,MAAM,GAA0B,EAA+B,IAC7D,IAAI,EAAc,EAAI,EAAM,CAExB,EAAmB,GAAiC,EAAM,OAAO,eAAe,GAAK,GAErF,EAAgC,IAA8C,CAClF,KAAMA,EAAgB,EAAM,SAAW,EAAE,CACzC,QACD,EAEY,EACP,GACH,IAAuC,CACtC,GAAG,EACH,SAAUC,EAAc,EAAM,SAAU,EAAI,CAC7C,EAEU,EACV,GACA,IAAuC,CACtC,GAAG,EACH,SACD,EAcH,SAAgB,EACd,EACA,EACkB,CAClB,OAAO,EAAwB,EAAI,EAAO,CAqB5C,SAAgB,EACd,EACA,EACA,EACA,EACkB,CAClB,IAAM,EAAoD,CACxD,KAAM,sBACF,KACJ,SACA,GAAI,IAAW,IAAA,GAAY,EAAE,CAAG,CAAE,SAAQ,CAC1C,GAAI,IAAY,IAAA,GAAY,EAAE,CAAG,CAAE,UAAS,CAC7C,CAgBD,OAdI,EAAG,OAAS,UACP,CACL,KAAM,WACL,GAAW,CACV,OAAU,IAAA,GACV,OAAU,IAAA,GACV,OAAU,IAAA,GACX,CACD,OAAQ,OAAO,gBAAgE,CAC7E,OAAQ,MAAM,GAEjB,CAGI,CACL,KAAM,UACL,GAAW,CACV,OAAU,IAAA,GACV,OAAU,IAAA,GACV,OAAU,IAAA,GACX,CACD,EAAE,OAAO,WAAsD,CAC7D,OAAQ,MAAM,GAEjB,CAGH,MAAa,GACX,EACA,IAEA,EAAwB,EAAI,EAAQ,IAAA,IAAY,EAAQ,KAAY,CAClE,GAAG,EACH,SAAU,EAAO,SACjB,MAAO,EAAO,MACf,EAAE,CAEQ,OAA+C,CAC1D,KAAM,UACL,GAAW,CACV,OAAU,IAAA,GACV,OAAU,IAAA,GACV,OAAU,IAAA,GACX,CACD,EAAE,OAAO,WAAqE,CAC5E,OAAQ,KAAM,CAAE,KAAM,kBAAmB,EAE5C,EAEY,EAAsB,IAAiE,CAClG,KAAM,UACL,GAAW,CACV,OAAU,IAAA,GACV,OAAU,IAAA,GACV,OAAU,IAAA,GACX,CACD,EAAE,OAAO,WAA6D,CACpE,KAAM,CAAE,KAAM,qBAAsB,SAAQ,EAE/C,EAEK,EAAuC,IAAoD,CAC/F,KAAM,WACL,GAAW,CACV,OAAU,IAAA,GACV,OAAU,IAAA,GACV,OAAU,IAAA,GACX,CACD,OAAQ,OAAO,gBAAgE,CAC7E,OAAQ,MAAM,GAEjB,EAEK,EAAsC,IAAmD,CAC7F,KAAM,UACL,GAAW,CACV,OAAU,IAAA,GACV,OAAU,IAAA,GACV,OAAU,IAAA,GACX,CACD,EAAE,OAAO,WAAsD,CAC7D,OAAQ,MAAM,GAEjB,EAEY,GAAsB,EAAyB,IAC1D,EAAyD,CACvD,KAAM,YACF,KACJ,WACD,CAAC,CAES,EAAoB,GAC/B,EAAiD,CAC/C,KAAM,aACN,QACD,CAAC,CAES,EAAmB,GAC9B,EAAoC,CAClC,KAAM,YACN,QACD,CAAC,CAES,EAAwB,GACnC,EAAiD,CAC/C,KAAM,iBACN,QACD,CAAC,CAES,EAAkB,GAC7B,EAAiD,CAC/C,KAAM,cACN,QACD,CAAC,CAES,MACX,EAA2C,CACzC,KAAM,WACP,CAAC,CAES,GACX,EACA,IAEA,EAAoC,CAClC,KAAM,qBACN,QACA,YACD,CAAC,CAEE,EAAqB,GACrB,aAAmB,EACd,EAGL,EAAY,EAAQ,CACf,EAAQ,MAGV,EAGH,EAAwB,GACxB,MAAM,YAAY,EAAI,yDAAyD,CAE/E,GACJ,EACA,IACwB,CACxB,GAAI,EAAgB,EAAM,CACxB,OAAO,EAAuB,EAAM,CAGtC,GAAI,EAAY,OAAS,kBACvB,MAAO,CACL,KAAMC,EAAO,EAAW,CACxB,QACD,CAGH,GAAI,EAAY,OAAS,qBACvB,MAAO,CACL,KAAMA,EAAO,IAAA,GAAe,CAC5B,MAAO,EAAY,OAAO,EAAM,CACjC,CAGH,GAAI,EAAY,OAAS,cACvB,MAAO,CACL,KAAMA,EAAO,EAAY,MAAM,QAAQ,CAAM,CAC7C,QACD,CAGH,GACE,EAAY,OAAS,aACrB,EAAY,OAAS,cACrB,EAAY,OAAS,aACrB,EAAY,OAAS,kBACrB,EAAY,OAAS,YACrB,EAAY,OAAS,qBAErB,MAAO,CACL,KAAMC,EAAe,MAAM,kBAAkB,EAAY,KAAK,qBAAqB,CAAC,CACpF,QACD,CAGH,GAAI,EAAY,GAAG,OAAS,UAC1B,MAAO,CACL,KAAMA,EAAe,MAAM,wDAAwD,CAAC,CACpF,QACD,CAGH,IAAM,EAAS,EAAiB,EAAY,GAAI,EAAY,OAAO,EAAM,CAAC,CAE1E,OADA,EAAY,SAAS,EAAO,KAAM,EAAO,MAAM,CACxC,CACL,KAAM,EAAO,KACb,MAAO,EAAY,UAAU,EAAO,EAAO,MAAM,EAAI,EACtD,EAGG,EAA6B,MACjC,EACA,IACiC,CACjC,GAAI,EAAgB,EAAM,CACxB,OAAO,EAAuB,EAAM,CAGtC,GAAI,EAAY,OAAS,kBACvB,MAAO,CACL,KAAMD,EAAO,EAAW,CACxB,QACD,CAGH,GAAI,EAAY,OAAS,qBACvB,MAAO,CACL,KAAMA,EAAO,IAAA,GAAe,CAC5B,MAAO,EAAY,OAAO,EAAM,CACjC,CAGH,GAAI,EAAY,OAAS,YAAa,CACpC,IAAM,EAAQ,EAAiB,EAAY,GAAI,EAAM,CAIrD,OAHK,EAAY,UACf,EAAM,OAAO,SAAS,IAAI,EAAyC,CAE9D,CACL,KAAMA,EAAO,EAAW,CACxB,QACD,CAGH,GAAI,EAAY,OAAS,aAEvB,MAAO,CACL,KAAMA,EAFK,MAAM,EAAY,MAAM,OAAO,CAEnB,CACvB,QACD,CAGH,GAAI,EAAY,OAAS,YAAa,CACpC,IAAM,EAAO,MAAM,EAAY,MAAM,OAAO,CAmB5C,OAlBI,EAAK,OAAS,KACT,CACL,KAAMA,EAAO,EAAK,MAAM,CACxB,QACD,CAEC,EAAK,OAAS,MACT,CACL,KAAME,EAAQ,EAAK,MAAM,CACzB,QACD,CAEC,EAAK,OAAS,cACT,CACL,KAAMJ,EAAgB,EAAK,QAAQ,CACnC,QACD,CAEI,CACL,KAAMG,EAAW,EAAK,OAAO,CAC7B,QACD,CAGH,GAAI,EAAY,OAAS,iBAEvB,MAAO,CACL,KAAMD,EAFK,MAAM,EAAY,MAAM,WAAW,CAEvB,CACvB,QACD,CAGH,GAAI,EAAY,OAAS,cACvB,MAAO,CACL,KAAMA,EAAO,EAAY,MAAM,QAAQ,CAAM,CAC7C,QACD,CAGH,GAAI,EAAY,OAAS,WAKvB,OAJA,MAAM,EAAM,EAAE,CACV,EAAgB,EAAM,CACjB,EAAuB,EAAM,CAE/B,CACL,KAAMA,EAAO,IAAA,GAAe,CAC5B,QACD,CAGH,GAAI,EAAY,OAAS,qBAAsB,CAC7C,IAAM,EAAQ,EAAM,MACpB,GAAI,IAAU,IAAA,GACZ,GAAI,CACF,IAAM,EAAS,MAAM,EAAY,MAAM,EAAM,CAC7C,MAAO,CACL,KAAM,EAAO,OAAS,KAAOA,EAAO,EAAO,MAAM,CAAGE,EAAQ,EAAO,MAAM,CACzE,QACD,OACM,EAAO,CACd,MAAO,CACL,KAAMD,EAAW,EAAM,CACvB,QACD,CAIL,IAAI,EAAa,EACbE,EAAc,GAEZ,EAAqB,IAAI,QAAwB,GAAY,CACjE,EAAa,EAAM,mBAAqB,CAClCA,MACJ,GAAc,GACd,GAAI,CACF,EAAY,WAAW,MACjB,EAGR,EAAQ,cAAc,GACtB,EACF,CAEI,EAAgB,QAAQ,SAAS,CACpC,SAAW,EAAY,MAAM,EAAM,CAAC,CACpC,KAAM,IAAY,CAAE,KAAM,SAAmB,SAAQ,EAAE,CACvD,MAAO,IAAoB,CAAE,KAAM,SAAmB,QAAO,EAAE,CAElE,GAAI,CACF,IAAM,EAAS,MAAM,QAAQ,KAAK,CAAC,EAAe,EAAmB,CAAC,CAatE,OAXI,IAAW,eAAiB,EAAgB,EAAM,CAC7C,EAAuB,EAAM,CAGlC,EAAO,OAAS,SACX,CACL,KAAMF,EAAW,EAAO,MAAM,CAC9B,QACD,CAGI,CACL,KAAM,EAAO,OAAO,OAAS,KAAOD,EAAO,EAAO,OAAO,MAAM,CAAGE,EAAQ,EAAO,OAAO,MAAM,CAC9F,QACD,QACO,CACR,GAAY,EAIhB,IAAM,EACJ,EAAY,GAAG,OAAS,UACpB,MAAM,EAAkB,EAAY,GAAI,EAAY,OAAO,EAAM,CAAC,CAClE,EAAiB,EAAY,GAAI,EAAY,OAAO,EAAM,CAAC,CAGjE,OADA,EAAY,SAAS,EAAO,KAAM,EAAO,MAAM,CACxC,CACL,KAAM,EAAO,KACb,MAAO,EAAY,UAAU,EAAO,EAAO,MAAM,EAAI,EACtD,EAGH,SAAgB,EAAc,EAA8B,CAC1D,OAAO,EAAiB,EAAI,GAAyB,CAAC,CAAC,KAGzD,SAAS,EAAuB,EAA2B,EAA0C,CACnG,IAAI,EAAe,EAEnB,GAAI,CACF,IAAM,EAAM,EAAG,OAAO,WAAW,CAC7B,EAAS,EAAI,MAAM,CAEvB,KAAO,EAAO,OAAS,IAAM,CAC3B,GAAI,EAAgB,EAAa,CAC/B,OAAO,EAAuB,EAAa,CAG7C,IAAM,EAAU,EAAO,MAEvB,GAAI,EAAqB,EAAQ,CAAE,CACjC,IAAM,EAAS,EAA0B,EAA2C,EAAa,CAEjG,GADA,EAAe,EAAO,MAClB,EAAO,KAAK,OAAS,KAAM,CAC7B,EAAS,EAAI,KAAK,EAAO,KAAK,MAAM,CACpC,SAEF,OAAO,EAGT,IAAM,EAAiB,EAAiB,EAAQ,CAChD,GAAI,IAAmB,IAAA,GAAW,CAChC,IAAM,EAAU,EAAe,EAAa,SAAU,EAAQ,CAC9D,GAAI,IAAY,IAAA,GACd,MAAO,CACL,KAAMD,EAAW,EAAqB,EAAe,IAAI,CAAC,CAC1D,MAAO,EACR,CAEH,EAAS,EAAI,KAAK,EAAQ,CAC1B,SAGF,MAAO,CACL,KAAMC,EAAQ,EAAkB,EAAQ,CAAC,CACzC,MAAO,EACR,CAGH,MAAO,CACL,KAAMF,EAAO,EAAO,MAAM,CAC1B,MAAO,EACR,OACM,EAAQ,CACf,MAAO,CACL,KAAMC,EAAW,EAAO,CACxB,MAAO,EACR,EAIL,eAAsB,EAAe,EAAwC,CAC3E,OAAO,EAAQ,EAAG,CAAC,OAAO,CAG5B,SAAgB,EAAc,EAA0C,CACtE,OAAO,EAAiB,EAAI,GAAyB,CAAC,CAGxD,eAAe,EAAwB,EAA4B,EAAmD,CACpH,IAAI,EAAe,EAEnB,GAAI,CACF,IAAM,EAAM,EAAG,OAAO,gBAAgB,CAClC,EAAS,MAAM,EAAI,MAAM,CAE7B,KAAO,EAAO,OAAS,IAAM,CAC3B,GAAI,EAAgB,EAAa,CAC/B,OAAO,EAAuB,EAAa,CAG7C,IAAM,EAAU,EAAO,MAEvB,GAAI,EAAqB,EAAQ,CAAE,CACjC,IAAM,EAAS,MAAM,EAA2B,EAA2C,EAAa,CAExG,GADA,EAAe,EAAO,MAClB,EAAO,KAAK,OAAS,KAAM,CAC7B,EAAS,MAAM,EAAI,KAAK,EAAO,KAAK,MAAM,CAC1C,SAEF,OAAO,EAGT,IAAM,EAAiB,EAAiB,EAAQ,CAChD,GAAI,IAAmB,IAAA,GAAW,CAChC,IAAM,EAAU,EAAe,EAAa,SAAU,EAAQ,CAC9D,GAAI,IAAY,IAAA,GACd,MAAO,CACL,KAAMA,EAAW,EAAqB,EAAe,IAAI,CAAC,CAC1D,MAAO,EACR,CAEH,EAAS,MAAM,EAAI,KAAK,EAAQ,CAChC,SAGF,MAAO,CACL,KAAMC,EAAQ,EAAkB,EAAQ,CAAC,CACzC,MAAO,EACR,CAGH,MAAO,CACL,KAAMF,EAAO,EAAO,MAAM,CAC1B,MAAO,EACR,OACM,EAAQ,CACf,MAAO,CACL,KAAMC,EAAW,EAAO,CACxB,MAAO,EACR"}

package/dist/fx.runtime-q661ckFI.d.mts

@@ -0,0 +1,16 @@
+import { f as RunnableFx } from "./fx.types-CpFKa-Jj.mjs";
+import { t as Exit } from "./exit-D5zZVlCn.mjs";
+
+//#region src/fx/fx.runtime.d.ts
+
+type FiberStatus = "Running" | "Done" | "Interrupted";
+type RuntimeFiber<A, E> = {
+  readonly id: number;
+  await(): Promise<Exit<A, E>>;
+  interrupt(): Promise<Exit<A, E>>;
+  status(): FiberStatus;
+};
+declare function runFork<A, E>(fx: RunnableFx<A, E>): RuntimeFiber<A, E>;
+//#endregion
+export { RuntimeFiber as n, runFork as r, FiberStatus as t };
+//# sourceMappingURL=fx.runtime-q661ckFI.d.mts.map

package/dist/fx.runtime-q661ckFI.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"fx.runtime-q661ckFI.d.mts","names":[],"sources":["../src/fx/fx.runtime.ts"],"sourcesContent":[],"mappings":";;;;;AA8uBqD,KAzsBzC,WAAA,GAysByC,SAAA,GAAA,MAAA,GAAA,aAAA;AAAY,KAvsBrD,YAusBqD,CAAA,CAAA,EAAA,CAAA,CAAA,GAAA;;WArsBtD,QAAQ,KAAK,GAAG;eACZ,QAAQ,KAAK,GAAG;YACnB;;iBAmsBI,kBAAkB,WAAW,GAAG,KAAK,aAAa,GAAG"}

package/dist/{fx.types-DyQVgTS8.mjs → fx.types-Bg-Mmdm5.mjs}

@@ -1,2 +1,2 @@
 const e=Symbol.for(`@repo/std/fx/FxTypeId`),t=e=>typeof e==`object`&&!!e&&`_tag`in e&&e._tag===`ServiceRequest`;export{t as n,e as t};
-//# sourceMappingURL=fx.types-DyQVgTS8.mjs.map
+//# sourceMappingURL=fx.types-Bg-Mmdm5.mjs.map

package/dist/{fx.types-DyQVgTS8.mjs.map → fx.types-Bg-Mmdm5.mjs.map}

@@ -1 +1 @@
-{"version":3,"file":"fx.types-DyQVgTS8.mjs","names":[],"sources":["../src/fx/fx.types.ts"],"sourcesContent":["// ============================================================================\n// Service Request\n// ============================================================================\n\n/**\n * Unique symbol for Fx type identification.\n */\nexport const FxTypeId: unique symbol = Symbol.for(\"@repo/std/fx/FxTypeId\")\nexport type FxTypeId = typeof FxTypeId\n\n/**\n * Fx<A, E, R> is the base protocol for all effect types.\n * Explicitly carries type parameters for proper inference in generators.\n *\n * @template A - Success value type\n * @template E - Error type\n * @template R - Requirements type (services needed)\n */\nexport type Fx<out A, out E = never, out R = never> = {\n  readonly [FxTypeId]: {\n    readonly _A: () => A\n    readonly _E: () => E\n    readonly _R: () => R\n  }\n}\n\n/**\n * ServiceRequest is yielded when accessing a service via yield*.\n * The runtime intercepts these and injects the service from context.\n * Implements Fx protocol with A=S, E=never, R=S (requires service S to produce S).\n */\nexport type ServiceRequest<S> = Fx<S, never, S> & {\n  readonly _tag: \"ServiceRequest\"\n  /** Phantom type for service identification */\n  readonly _service: S\n  readonly serviceKey: string\n}\n\n/**\n * Check if a value is a ServiceRequest.\n */\nexport const isServiceRequest = (value: unknown): value is ServiceRequest<unknown> =>\n  typeof value === \"object\" && value !== null && \"_tag\" in value && value._tag === \"ServiceRequest\"\n\n/**\n * Extract the success type from an Fx.\n */\nexport type FxValue<T> = T extends Fx<infer A, unknown, unknown> ? A : never\n\n/**\n * Extract the error type from an Fx.\n */\nexport type FxError<T> = T extends Fx<unknown, infer E, unknown> ? E : never\n\n/**\n * Extract the requirements type from an Fx.\n */\nexport type FxRequirements<T> = T extends Fx<unknown, unknown, infer R> ? R : never\n\n// ============================================================================\n// Core Fx Types\n// ============================================================================\n\n/**\n * The type yielded by Fx generators at runtime.\n *\n * This union represents what flows through generator yield points:\n * - E: Error values that propagate through the computation\n * - ServiceClass<R>: Service requests that get intercepted and resolved from context\n *\n * Used for generator type annotations in Fx.gen(), Provide.layer(), and Layer implementations.\n */\nexport type FxYield<E, R> = E | ServiceClass<R>\n\n/**\n * ServiceClass type imported for FxYield.\n * This is a structural type that matches service classes.\n */\ntype ServiceClass<S> = Fx<S, never, S> & { _tag: \"Service\"; key: string }\n\n/**\n * SyncFx<A, E, R> represents a synchronous computation that:\n * - Produces a value of type A on success\n * - May fail with an error of type E\n * - Requires services of type R to run\n *\n * Use Fx.run() to execute when R = never (all dependencies provided).\n */\nexport type SyncFx<A, E = never, R = never> = Fx<A, E, R> & {\n  readonly _tag: \"SyncFx\"\n\n  /**\n   * Iterator for yield* support in gen computations.\n   * Yields error Results or ServiceClasses for service injection.\n   */\n  [Symbol.iterator](): Generator<FxYield<E, R>, A, unknown>\n}\n\n/**\n * AsyncFx<A, E, R> represents an asynchronous computation that:\n * - Produces a value of type A on success\n * - May fail with an error of type E\n * - Requires services of type R to run\n *\n * Use Fx.run() to execute when R = never (all dependencies provided).\n */\nexport type AsyncFx<A, E = never, R = never> = Fx<A, E, R> & {\n  readonly _tag: \"AsyncFx\"\n\n  /**\n   * Async iterator for yield* support in async gen computations.\n   * Yields error Results or ServiceClasses for service injection.\n   */\n  [Symbol.asyncIterator](): AsyncGenerator<FxYield<E, R>, A, unknown>\n}\n\n/**\n * RunnableFx<A, E, R> is a union of executable Fx types (sync or async).\n * Use this for functions that execute effects like Fx.run().\n */\nexport type RunnableFx<A, E = never, R = never> = SyncFx<A, E, R> | AsyncFx<A, E, R>\n\n// ============================================================================\n// Generator Types for Fx\n// ============================================================================\n\n/**\n * Sync generator type for Fx.gen.\n * Yields error Results or ServiceClasses, returns value of type A.\n */\nexport type FxGenerator<A, E, R> = Generator<FxYield<E, R>, A, unknown>\n\n/**\n * Async generator type for Fx.gen.\n * Yields error Results or ServiceClasses, returns value of type A.\n */\nexport type AsyncFxGenerator<A, E, R> = AsyncGenerator<FxYield<E, R>, A, unknown>\n\n// ============================================================================\n// Yieldable Types (for compatibility with existing gen module)\n// ============================================================================\n\n/**\n * FxYieldable extends the existing Yieldable protocol to support Fx values.\n */\nexport type FxYieldable<A, E = never, R = never> = Fx<A, E, R> & {\n  [Symbol.iterator](): Generator<FxYield<E, R>, A, unknown>\n}\n\n/**\n * AsyncFxYieldable for async computations with Fx values.\n */\nexport type AsyncFxYieldable<A, E = never, R = never> = Fx<A, E, R> & {\n  [Symbol.asyncIterator](): AsyncGenerator<FxYield<E, R>, A, unknown>\n}\n"],"mappings":"AAOA,MAAa,EAA0B,OAAO,IAAI,wBAAwB,CAkC7D,EAAoB,GAC/B,OAAO,GAAU,YAAY,GAAkB,SAAU,GAAS,EAAM,OAAS"}
+{"version":3,"file":"fx.types-Bg-Mmdm5.mjs","names":[],"sources":["../src/fx/fx.types.ts"],"sourcesContent":["// ============================================================================\n// Service Request\n// ============================================================================\n\n/**\n * Unique symbol for Fx type identification.\n */\nexport const FxTypeId: unique symbol = Symbol.for(\"@repo/std/fx/FxTypeId\")\nexport type FxTypeId = typeof FxTypeId\n\n/**\n * Fx<A, E, R> is the base protocol for all effect types.\n * Explicitly carries type parameters for proper inference in generators.\n *\n * @template A - Success value type\n * @template E - Error type\n * @template R - Requirements type (services needed)\n */\nexport type Fx<out A, out E = never, out R = never> = {\n  readonly [FxTypeId]: {\n    readonly _A: () => A\n    readonly _E: () => E\n    readonly _R: () => R\n  }\n}\n\n/**\n * ServiceRequest is yielded when accessing a service via yield*.\n * The runtime intercepts these and injects the service from context.\n * Implements Fx protocol with A=S, E=never, R=S (requires service S to produce S).\n */\nexport type ServiceRequest<S> = Fx<S, never, S> & {\n  readonly _tag: \"ServiceRequest\"\n  /** Phantom type for service identification */\n  readonly _service: S\n  readonly serviceKey: string\n}\n\n/**\n * Check if a value is a ServiceRequest.\n */\nexport const isServiceRequest = (value: unknown): value is ServiceRequest<unknown> =>\n  typeof value === \"object\" && value !== null && \"_tag\" in value && value._tag === \"ServiceRequest\"\n\n/**\n * Extract the success type from an Fx.\n */\nexport type FxValue<T> = T extends Fx<infer A, unknown, unknown> ? A : never\n\n/**\n * Extract the error type from an Fx.\n */\nexport type FxError<T> = T extends Fx<unknown, infer E, unknown> ? E : never\n\n/**\n * Extract the requirements type from an Fx.\n */\nexport type FxRequirements<T> = T extends Fx<unknown, unknown, infer R> ? R : never\n\n// ============================================================================\n// Core Fx Types\n// ============================================================================\n\n/**\n * The type yielded by Fx generators at runtime.\n *\n * This union represents what flows through generator yield points:\n * - E: Error values that propagate through the computation\n * - ServiceClass<R>: Service requests that get intercepted and resolved from context\n *\n * Used for generator type annotations in Fx.gen(), Provide.layer(), and Layer implementations.\n */\nexport type FxYield<E, R> = E | ServiceClass<R>\n\n/**\n * ServiceClass type imported for FxYield.\n * This is a structural type that matches service classes.\n */\ntype ServiceClass<S> = Fx<S, never, S> & { _tag: \"Service\"; key: string }\n\n/**\n * SyncFx<A, E, R> represents a synchronous computation that:\n * - Produces a value of type A on success\n * - May fail with an error of type E\n * - Requires services of type R to run\n *\n * Use Fx.run() to execute when R = never (all dependencies provided).\n */\nexport type SyncFx<A, E = never, R = never> = Fx<A, E, R> & {\n  readonly _tag: \"SyncFx\"\n\n  /**\n   * Iterator for yield* support in gen computations.\n   * Yields error Results or ServiceClasses for service injection.\n   */\n  [Symbol.iterator](): Generator<FxYield<E, R>, A, unknown>\n}\n\n/**\n * AsyncFx<A, E, R> represents an asynchronous computation that:\n * - Produces a value of type A on success\n * - May fail with an error of type E\n * - Requires services of type R to run\n *\n * Use Fx.run() to execute when R = never (all dependencies provided).\n */\nexport type AsyncFx<A, E = never, R = never> = Fx<A, E, R> & {\n  readonly _tag: \"AsyncFx\"\n\n  /**\n   * Async iterator for yield* support in async gen computations.\n   * Yields error Results or ServiceClasses for service injection.\n   */\n  [Symbol.asyncIterator](): AsyncGenerator<FxYield<E, R>, A, unknown>\n}\n\n/**\n * RunnableFx<A, E, R> is a union of executable Fx types (sync or async).\n * Use this for functions that execute effects like Fx.run().\n */\nexport type RunnableFx<A, E = never, R = never> = SyncFx<A, E, R> | AsyncFx<A, E, R>\n\n// ============================================================================\n// Generator Types for Fx\n// ============================================================================\n\n/**\n * Sync generator type for Fx.gen.\n * Yields error Results or ServiceClasses, returns value of type A.\n */\nexport type FxGenerator<A, E, R> = Generator<FxYield<E, R>, A, unknown>\n\n/**\n * Async generator type for Fx.gen.\n * Yields error Results or ServiceClasses, returns value of type A.\n */\nexport type AsyncFxGenerator<A, E, R> = AsyncGenerator<FxYield<E, R>, A, unknown>\n\n// ============================================================================\n// Yieldable Types (for compatibility with existing gen module)\n// ============================================================================\n\n/**\n * FxYieldable extends the existing Yieldable protocol to support Fx values.\n */\nexport type FxYieldable<A, E = never, R = never> = Fx<A, E, R> & {\n  [Symbol.iterator](): Generator<FxYield<E, R>, A, unknown>\n}\n\n/**\n * AsyncFxYieldable for async computations with Fx values.\n */\nexport type AsyncFxYieldable<A, E = never, R = never> = Fx<A, E, R> & {\n  [Symbol.asyncIterator](): AsyncGenerator<FxYield<E, R>, A, unknown>\n}\n"],"mappings":"AAOA,MAAa,EAA0B,OAAO,IAAI,wBAAwB,CAkC7D,EAAoB,GAC/B,OAAO,GAAU,YAAY,GAAkB,SAAU,GAAS,EAAM,OAAS"}

package/dist/{fx.types-BdN1EWxr.d.mts → fx.types-CpFKa-Jj.d.mts}

@@ -125,4 +125,4 @@ type AsyncFxYieldable<A, E = never, R = never> = Fx<A, E, R> & {
 };
 //#endregion
 export { FxError as a, FxTypeId as c, FxYieldable as d, RunnableFx as f, isServiceRequest as h, Fx as i, FxValue as l, SyncFx as m, AsyncFxGenerator as n, FxGenerator as o, ServiceRequest as p, AsyncFxYieldable as r, FxRequirements as s, AsyncFx as t, FxYield as u };
-//# sourceMappingURL=fx.types-BdN1EWxr.d.mts.map
+//# sourceMappingURL=fx.types-CpFKa-Jj.d.mts.map

package/dist/{fx.types-BdN1EWxr.d.mts.map → fx.types-CpFKa-Jj.d.mts.map}

@@ -1 +1 @@
-{"version":3,"file":"fx.types-BdN1EWxr.d.mts","names":[],"sources":["../src/fx/fx.types.ts"],"sourcesContent":[],"mappings":"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"}
+{"version":3,"file":"fx.types-CpFKa-Jj.d.mts","names":[],"sources":["../src/fx/fx.types.ts"],"sourcesContent":[],"mappings":";;AAOA;AACA;AAUY,cAXC,QAWC,EAAA,OAAA,MAAA;AAES,KAZX,QAAA,GAYW,OAZO,QAYP;;;;;AAWvB;;;;AAGqB,KAhBT,EAgBS,CAAA,KAAA,EAAA,QAAA,KAAA,EAAA,QAAA,KAAA,CAAA,GAAA;EAAC,UAfV,QAAA,CAeU,EAAA;IAOT,SAAA,EAAA,EAAA,GACsF,GAtB5E,CAsB4E;IAKvF,SAAO,EAAA,EAAA,GAAA,GA1BI,CA0BE;IAKb,SAAO,EAAA,EAAA,GAAA,GA9BI,CA8BE;EAKb,CAAA;AAeZ,CAAA;;;;;AAA+C;AAMrB,KA/Cd,cA+Cc,CAAA,CAAA,CAAA,GA/CM,EA+CN,CA/CS,CA+CT,EAAA,KAAA,EA/CmB,CA+CnB,CAAA,GAAA;EAAU,SAAA,IAAA,EAAA,gBAAA;EAAb;EAAE,SAAA,QAAA,EA5CJ,CA4CI;EAUb,SAAM,UAAA,EAAA,MAAA;CAA+B;;;;AAOR,cAtD5B,gBAsD4B,EAAA,CAAA,KAAA,EAAA,OAAA,EAAA,GAAA,KAAA,IAtDkB,cAsDlB,CAAA,OAAA,CAAA;;;;AAAlB,KAhDX,OAgDW,CAAA,CAAA,CAAA,GAhDE,CAgDF,SAhDY,EAgDZ,CAAA,KAAA,EAAA,EAAA,OAAA,EAAA,OAAA,CAAA,GAAA,CAAA,GAAA,KAAA;;AAWvB;;AAAqD,KAtDzC,OAsDyC,CAAA,CAAA,CAAA,GAtD5B,CAsD4B,SAtDlB,EAsDkB,CAAA,OAAA,EAAA,KAAA,EAAA,EAAA,OAAA,CAAA,GAAA,CAAA,GAAA,KAAA;;;;AAOC,KAxD1C,cAwD0C,CAAA,CAAA,CAAA,GAxDtB,CAwDsB,SAxDZ,EAwDY,CAAA,OAAA,EAAA,OAAA,EAAA,KAAA,EAAA,CAAA,GAAA,CAAA,GAAA,KAAA;;;;;AAOtD;;;;;AAA4E,KAhDhE,OAgDgE,CAAA,CAAA,EAAA,CAAA,CAAA,GAhDhD,CAgDgD,GAhD5C,YAgD4C,CAhD/B,CAgD+B,CAAA;;;;;AAU5E,KApDK,YAoDO,CAAW,CAAA,CAAA,GApDA,EAoDA,CApDG,CAoDH,EAAA,KAAA,EApDa,CAoDb,CAAA,GAAA;EAA8B,IAAA,EAAA,SAAA;EAAG,GAAA,EAAA,MAAA;CAAX;;;;AAM7C;;;;;AAAwC,KAhD5B,MAgD4B,CAAA,CAAA,EAAA,IAAA,KAAA,EAAA,IAAA,KAAA,CAAA,GAhDM,EAgDN,CAhDS,CAgDT,EAhDY,CAgDZ,EAhDe,CAgDf,CAAA,GAAA;EAAc,SAAA,IAAA,EAAA,QAAA;EAS1C;;;;EAAuC,CAAA,MAAA,CAAA,QAAA,GAAA,EAlD5B,SAkD4B,CAlDlB,OAkDkB,CAlDV,CAkDU,EAlDP,CAkDO,CAAA,EAlDH,CAkDG,EAAA,OAAA,CAAA;CACV;;;;;;AAMzC;;;AAAiE,KA9CrD,OA8CqD,CAAA,CAAA,EAAA,IAAA,KAAA,EAAA,IAAA,KAAA,CAAA,GA9ClB,EA8CkB,CA9Cf,CA8Ce,EA9CZ,CA8CY,EA9CT,CA8CS,CAAA,GAAA;EAAT,SAAA,IAAA,EAAA,SAAA;EACL;;;;EAAvB,CAAA,MAAA,CAAA,aAAA,GAAA,EAxCA,cAwCA,CAxCe,OAwCf,CAxCuB,CAwCvB,EAxC0B,CAwC1B,CAAA,EAxC8B,CAwC9B,EAAA,OAAA,CAAA;CAAc;;;;;KAjC9B,sCAAsC,OAAO,GAAG,GAAG,KAAK,QAAQ,GAAG,GAAG;;;;;KAUtE,uBAAuB,UAAU,QAAQ,GAAG,IAAI;;;;;KAMhD,4BAA4B,eAAe,QAAQ,GAAG,IAAI;;;;KAS1D,uCAAuC,GAAG,GAAG,GAAG;uBACrC,UAAU,QAAQ,GAAG,IAAI;;;;;KAMpC,4CAA4C,GAAG,GAAG,GAAG;4BACrC,eAAe,QAAQ,GAAG,IAAI"}

package/dist/{index-DfAqfnY0.d.mts → index-BJiD1-T_.d.mts}

@@ -1,6 +1,6 @@
-import { n as Branded } from "./brand.types-B3NDX1vo.mjs";
-import { n as TaggedErrorFactory } from "./index-D6pjHqlK.mjs";
-import { t as Result } from "./index-CIvNgjsx.mjs";
+import { n as Branded } from "./brand.types-Cqkibdlt.mjs";
+import { n as TaggedErrorFactory } from "./index-lYxaV6H7.mjs";
+import { t as Result } from "./index-hrn4s4Vn.mjs";
 
 //#region src/duration/duration.d.ts
 declare namespace duration_d_exports {
@@ -93,4 +93,4 @@ declare const parse: (input: string) => Result<Duration, DurationParseError>;
 declare const from: (input: Input) => Result<Duration, InputError>;
 //#endregion
 export { InputError as n, duration_d_exports as r, Input as t };
-//# sourceMappingURL=index-DfAqfnY0.d.mts.map
+//# sourceMappingURL=index-BJiD1-T_.d.mts.map

package/dist/{index-DfAqfnY0.d.mts.map → index-BJiD1-T_.d.mts.map}

@@ -1 +1 @@
-{"version":3,"file":"index-DfAqfnY0.d.mts","names":[],"sources":["../src/duration/duration.ts"],"sourcesContent":[],"mappings":";;;;;;;;;;;KA4BY,QAAA,GAAW;;;;KAKX,IAAA;;;;KAiBA,WAAA,gBAA2B;;;;KAK3B,KAAA,GAAQ,oBAAoB;cAAW,yBAAA;;;;cAKtC,kBAAA,SAA2B;;;AAhCxC,CAAA,CAAA,CAAA;AAsBA,cAaK,8BAbsC,EAatC,kBAbsC,CAAA,2BAAA,CAAA;AAK3C;AAAmD;AAKnD;AAGK,cAKQ,yBAAA,SAAkC,8BAL1C,CAAA;EAKQ,KAAA,EAAA,MAAA;EAGR,OAAA,EAAA,MAAA;AAKL,CAAA,CAAA,CAAA;cALK,8BAQK,EARL,kBAQK,CAAA,2BAAA,CAAA;;;;AAME,cATC,yBAAA,SAAkC,8BASJ,CAAA;EAK/B,KAAA,EAbH,KAaG;EAAa,OAAA,EAAA,MAAA;EAA4B,KAAA,CAAA,EAX3C,kBAW2C,GAXtB,yBAWsB;CAAqB,CAAA,CAAA;AAwB1E;AAKA;AAKA;AAKa,KA5CD,UAAA,GAAa,kBA4CkD;AAK3E;AAKA;AAKA;AAiCa,KAvFD,UAAA,GAAa,yBAkHxB,GAlHoD,kBAkHpD,GAlHyE,yBAkHzE;;;;AA3BkD,cA/DtC,MA+DsC,EAAA,CAAA,KAAA,EAAA,MAAA,EAAA,GA/DZ,QA+DY;AAgCnD;;;AAA4D,cA1F/C,OA0F+C,EAAA,CAAA,KAAA,EAAA,MAAA,EAAA,GA1FpB,QA0FoB;;;;cArF/C,4BAA2B;;;;cAK3B,0BAAyB;;;;cAKzB,yBAAwB;;;;cAKxB,0BAAyB;;;;cAKzB,qBAAsB;;;;cAiCtB,0BAAyB,OAAc,UAAU;;;;cAgCjD,cAAe,UAAQ,OAAc,UAAU"}
+{"version":3,"file":"index-BJiD1-T_.d.mts","names":[],"sources":["../src/duration/duration.ts"],"sourcesContent":[],"mappings":";;;;;;;;;;;KA4BY,QAAA,GAAW;;;;KAKX,IAAA;;;;KAiBA,WAAA,gBAA2B;;;;KAK3B,KAAA,GAAQ,oBAAoB;cAAW,yBAAA;;;;cAKtC,kBAAA,SAA2B;;;AAhCxC,CAAA,CAAA,CAAA;AAsBA,cAaK,8BAbsC,EAatC,kBAbsC,CAAA,2BAAA,CAAA;AAK3C;AAAmD;AAKnD;AAGK,cAKQ,yBAAA,SAAkC,8BAL1C,CAAA;EAKQ,KAAA,EAAA,MAAA;EAGR,OAAA,EAAA,MAAA;AAKL,CAAA,CAAA,CAAA;cALK,8BAQK,EARL,kBAQK,CAAA,2BAAA,CAAA;;;;AAME,cATC,yBAAA,SAAkC,8BASJ,CAAA;EAK/B,KAAA,EAbH,KAaG;EAAa,OAAA,EAAA,MAAA;EAA4B,KAAA,CAAA,EAX3C,kBAW2C,GAXtB,yBAWsB;CAAqB,CAAA,CAAA;AAwB1E;AAKA;AAKA;AAKa,KA5CD,UAAA,GAAa,kBA4CkD;AAK3E;AAKA;AAKA;AAiCa,KAvFD,UAAA,GAAa,yBAkHxB,GAlHoD,kBAkHpD,GAlHyE,yBAkHzE;;;;AA3BkD,cA/DtC,MA+DsC,EAAA,CAAA,KAAA,EAAA,MAAA,EAAA,GA/DZ,QA+DY;AAgCnD;;;AAA4D,cA1F/C,OA0F+C,EAAA,CAAA,KAAA,EAAA,MAAA,EAAA,GA1FpB,QA0FoB;;;;cArF/C,4BAA2B;;;;cAK3B,0BAAyB;;;;cAKzB,yBAAwB;;;;cAKxB,0BAAyB;;;;cAKzB,qBAAsB;;;;cAiCtB,0BAAyB,OAAc,UAAU;;;;cAgCjD,cAAe,UAAQ,OAAc,UAAU"}