@nicolastoulemont/std 0.7.2 → 0.8.0

package/dist/order-BXOBEKvB.mjs

@@ -0,0 +1,2 @@
+import{t as e}from"./chunk-oQKkju2G.mjs";import{t}from"./dual-fN6OUwN_.mjs";var n=e({alwaysEqual:()=>u,array:()=>v,between:()=>D,bigint:()=>c,boolean:()=>s,by:()=>f,clamp:()=>E,collator:()=>a,date:()=>l,greaterThan:()=>S,greaterThanOrEqual:()=>C,lessThan:()=>b,lessThanOrEqual:()=>x,make:()=>r,max:()=>T,merge:()=>g,min:()=>w,number:()=>o,reverse:()=>d,sort:()=>O,sortBy:()=>A,sortWith:()=>k,string:()=>i,struct:()=>y,tuple:()=>_});function r(e){return(t,n)=>t===n?0:e(t,n)}const i=r((e,t)=>e<t?-1:1);function a(e){return r((t,n)=>{let r=e.compare(t,n);return r<0?-1:r>0?1:0})}const o=r((e,t)=>Number.isNaN(e)&&Number.isNaN(t)?0:Number.isNaN(e)?-1:Number.isNaN(t)?1:e<t?-1:1),s=r((e,t)=>e<t?-1:1),c=r((e,t)=>e<t?-1:1),l=r((e,t)=>o(e.getTime(),t.getTime()));function u(){return r(()=>0)}function d(e){return r((t,n)=>e(n,t))}const f=t(2,(e,t)=>r((n,r)=>e(t(n),t(r)))),p=(e,t)=>r((n,r)=>{let i=e(n,r);return i===0?t(n,r):i}),m=e=>{let t=Array.from(e);return t.length===0?u():t.length===1?t[0]:r((e,n)=>{for(let r of t){let t=r(e,n);if(t!==0)return t}return 0})};function h(e,t){if(t!==void 0){if(typeof e!=`function`)throw TypeError(`Order.merge(self, that) requires two order functions`);return p(e,t)}return typeof e==`function`?t=>p(t,e):m(e)}const g=h;function _(e){return r((t,n)=>{for(let r=0;r<e.length;r++){let i=e[r],a=i(t[r],n[r]);if(a!==0)return a}return 0})}function v(e){return r((t,n)=>{let r=Math.min(t.length,n.length);for(let i=0;i<r;i++){let r=e(t[i],n[i]);if(r!==0)return r}return o(t.length,n.length)})}function y(e){let t=Object.keys(e);return r((n,r)=>{for(let i of t){let t=e[i](n[i],r[i]);if(t!==0)return t}return 0})}const b=e=>t(2,(t,n)=>e(t,n)===-1),x=e=>t(2,(t,n)=>e(t,n)!==1),S=e=>t(2,(t,n)=>e(t,n)===1),C=e=>t(2,(t,n)=>e(t,n)!==-1),w=e=>t(2,(t,n)=>t===n||e(t,n)<1?t:n),T=e=>t(2,(t,n)=>t===n||e(t,n)>-1?t:n),E=e=>t(2,(t,n)=>w(e)(n.maximum,T(e)(n.minimum,t))),D=e=>t(2,(t,n)=>!b(e)(t,n.minimum)&&!S(e)(t,n.maximum)),O=t(2,(e,t)=>{let n=Array.from(e);return n.sort((e,n)=>t(e,n)),n}),k=t(3,(e,t,n)=>{let r=Array.from(e,e=>[e,t(e)]);return r.sort(([,e],[,t])=>n(e,t)),r.map(([e])=>e)}),A=(...e)=>{if(e.length===0)return e=>Array.from(e);let t=g(e);return e=>O(e,t)};export{n as t};
+//# sourceMappingURL=order-BXOBEKvB.mjs.map

package/dist/order-BXOBEKvB.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"order-BXOBEKvB.mjs","names":["collator"],"sources":["../src/order/order.ts"],"sourcesContent":["/**\n * Ordering combinators and instances for deterministic sorting and comparisons.\n *\n * **Mental model**\n * - `Order<A>` compares two values and returns `-1 | 0 | 1`.\n * - Compose reusable comparators with `by`, `merge`, and `reverse`.\n *\n * **Common tasks**\n * - Use built-ins like `Order.number`, `Order.string`, `Order.date`.\n * - Build custom orders with `Order.make`, `Order.by`, `Order.struct`.\n * - Sort with `Order.sort`, `Order.sortWith`, `Order.sortBy`.\n *\n * **Gotchas**\n * - Orders should be total and stable for predictable sorting.\n * - `Order.merge` uses lexicographic tie-breaking.\n *\n * **Quickstart**\n *\n * @example\n * ```ts\n * import { Order } from \"@nicolastoulemont/std\"\n *\n * const byAge = Order.by(Order.number, (user: { age: number }) => user.age)\n * const sorted = Order.sort([{ age: 2 }, { age: 1 }], byAge)\n * ```\n *\n * @module\n */\nimport { dual } from \"../shared/dual\"\nimport type { Order as OrderType, OrderBounds, Ordering as OrderingType } from \"./order.types\"\n\n/**\n * Re-exported `Order` type.\n *\n * @example\n * ```ts\n * import type { Order } from \"@nicolastoulemont/std\"\n *\n * type Example = Order.Order<unknown>\n * ```\n */\nexport type Order<A> = OrderType<A>\n\n/**\n * Re-exported `Ordering` type.\n *\n * @example\n * ```ts\n * import type { Order } from \"@nicolastoulemont/std\"\n *\n * type Example = Order.Ordering\n * ```\n */\nexport type Ordering = OrderingType\n\n/**\n * Create an `Order` from a comparison function.\n *\n * The created order short-circuits identical references (`===`) to `0`.\n *\n * @param compare - Comparison function returning `-1 | 0 | 1`\n * @returns An order function\n *\n * @example\n * ```ts\n * import { Order } from \"@nicolastoulemont/std\"\n *\n * const byLength = Order.make<string>((self, that) =>\n *   self.length < that.length ? -1 : self.length > that.length ? 1 : 0,\n * )\n * const result = byLength(\"a\", \"bbb\")\n * // => -1\n * ```\n */\nexport function make<A>(compare: (self: A, that: A) => Ordering): OrderType<A> {\n  return (self, that) => (self === that ? 0 : compare(self, that))\n}\n\n/**\n * `Order` instance for strings (lexicographic, case-sensitive).\n *\n * Use `Order.collator` for locale-aware human-facing ordering.\n *\n * @example\n * ```ts\n * import { Order } from \"@nicolastoulemont/std\"\n *\n * const result = Order.string(\"a\", \"b\")\n * // => -1\n * ```\n */\nexport const string: OrderType<string> = make((self, that) => (self < that ? -1 : 1))\n\n/**\n * Create a locale-aware `Order` from an `Intl.Collator`.\n *\n * This is intended for human-facing sorting where locale rules matter.\n * Reuse a collator instance when sorting repeatedly.\n *\n * @param collator - Preconfigured collator controlling locale-sensitive ordering\n * @returns A string order normalized to `-1 | 0 | 1`\n *\n * @example\n * ```ts\n * import { Order } from \"@nicolastoulemont/std\"\n *\n * const collator = new Intl.Collator(\"en\", { numeric: true })\n * const result = Order.collator(collator)(\"2\", \"10\")\n * // => -1\n * ```\n */\nexport function collator(collator: Intl.Collator): OrderType<string> {\n  return make((self, that) => {\n    const result = collator.compare(self, that)\n    return result < 0 ? -1 : result > 0 ? 1 : 0\n  })\n}\n\n/**\n * `Order` instance for numbers.\n *\n * - `NaN` equals `NaN`\n * - `NaN` is less than any non-`NaN`\n * - `0` equals `-0`\n *\n * @example\n * ```ts\n * import { Order } from \"@nicolastoulemont/std\"\n *\n * const result = Order.number(1, 2)\n * // => -1\n * ```\n */\nexport const number: OrderType<number> = make((self, that) => {\n  if (Number.isNaN(self) && Number.isNaN(that)) return 0\n  if (Number.isNaN(self)) return -1\n  if (Number.isNaN(that)) return 1\n  return self < that ? -1 : 1\n})\n\n/**\n * `Order` instance for booleans where `false < true`.\n *\n * @example\n * ```ts\n * import { Order } from \"@nicolastoulemont/std\"\n *\n * const result = Order.boolean(false, true)\n * // => -1\n * ```\n */\nexport const boolean: OrderType<boolean> = make((self, that) => (self < that ? -1 : 1))\n\n/**\n * `Order` instance for bigints.\n *\n * @example\n * ```ts\n * import { Order } from \"@nicolastoulemont/std\"\n *\n * const result = Order.bigint(1n, 2n)\n * // => -1\n * ```\n */\nexport const bigint: OrderType<bigint> = make((self, that) => (self < that ? -1 : 1))\n\n/**\n * `Order` instance for dates based on `getTime()`.\n *\n * @example\n * ```ts\n * import { Order } from \"@nicolastoulemont/std\"\n *\n * const result = Order.date(new Date(\"2024-01-01\"), new Date(\"2024-01-02\"))\n * // => -1\n * ```\n */\nexport const date: OrderType<Date> = make((self, that) => number(self.getTime(), that.getTime()))\n\n/**\n * Create an order that treats all values as equal.\n *\n * @example\n * ```ts\n * import { Order } from \"@nicolastoulemont/std\"\n *\n * const compare = Order.alwaysEqual<number>()\n * const result = compare(1, 2)\n * // => 0\n * ```\n */\nexport function alwaysEqual<A>(): OrderType<A> {\n  return make(() => 0)\n}\n\n/**\n * Reverse an existing order.\n *\n * @example\n * ```ts\n * import { Order } from \"@nicolastoulemont/std\"\n *\n * const desc = Order.reverse(Order.number)\n * const result = desc(1, 2)\n * // => 1\n * ```\n */\nexport function reverse<A>(order: OrderType<A>): OrderType<A> {\n  return make((self, that) => order(that, self))\n}\n\n/**\n * Map inputs before comparison.\n *\n * Supports data-first and data-last styles:\n * - `by(order, project)`\n * - `pipe(order, by(project))`\n *\n * @example\n * ```ts\n * import { Order } from \"@nicolastoulemont/std\"\n *\n * type User = { age: number }\n * const dataFirst = Order.by(Order.number, (user: User) => user.age)\n * const compareFirst = dataFirst({ age: 1 }, { age: 2 })\n * // => -1\n *\n * const dataLast = Order.by((user: User) => user.age)(Order.number)\n * const compareLast = dataLast({ age: 1 }, { age: 2 })\n * // => -1\n * ```\n */\nexport const by: {\n  <B, A>(project: (value: B) => A): (order: OrderType<A>) => OrderType<B>\n  <A, B>(order: OrderType<A>, project: (value: B) => A): OrderType<B>\n} = dual(\n  2,\n  <A, B>(order: OrderType<A>, project: (value: B) => A): OrderType<B> =>\n    make((self, that) => order(project(self), project(that))),\n)\n\nconst mergeBinary = <A>(self: OrderType<A>, that: OrderType<A>): OrderType<A> =>\n  make((a, b) => {\n    const result = self(a, b)\n    if (result !== 0) return result\n    return that(a, b)\n  })\n\nconst mergeAll = <A>(orders: Iterable<OrderType<A>>): OrderType<A> => {\n  const all = Array.from(orders)\n  if (all.length === 0) return alwaysEqual()\n  if (all.length === 1) return all[0]!\n\n  return make((a, b) => {\n    for (const order of all) {\n      const result = order(a, b)\n      if (result !== 0) return result\n    }\n    return 0\n  })\n}\n\nfunction mergeOverload<A>(that: OrderType<A>): (self: OrderType<A>) => OrderType<A>\nfunction mergeOverload<A>(self: OrderType<A>, that: OrderType<A>): OrderType<A>\nfunction mergeOverload<A>(orders: Iterable<OrderType<A>>): OrderType<A>\nfunction mergeOverload<A>(\n  selfOrThatOrOrders: OrderType<A> | Iterable<OrderType<A>>,\n  that?: OrderType<A>,\n): ((self: OrderType<A>) => OrderType<A>) | OrderType<A> {\n  if (that !== undefined) {\n    if (typeof selfOrThatOrOrders !== \"function\") {\n      throw new TypeError(\"Order.merge(self, that) requires two order functions\")\n    }\n    return mergeBinary(selfOrThatOrOrders, that)\n  }\n\n  if (typeof selfOrThatOrOrders === \"function\") {\n    return (self: OrderType<A>) => mergeBinary(self, selfOrThatOrOrders)\n  }\n\n  return mergeAll(selfOrThatOrOrders)\n}\n\n/**\n * Merge orders lexicographically.\n *\n * Supports three forms:\n * - `merge(self, that)`\n * - `merge(that)(self)`\n * - `merge([order1, order2, ...])`\n *\n * @example\n * ```ts\n * import { Order } from \"@nicolastoulemont/std\"\n *\n * type User = { first: string; last: string }\n * const byLast = Order.by(Order.string, (user: User) => user.last)\n * const byFirst = Order.by(Order.string, (user: User) => user.first)\n * const compare = Order.merge([byLast, byFirst])({ first: \"Ada\", last: \"Lovelace\" }, { first: \"Alan\", last: \"Turing\" })\n * // => -1\n * ```\n */\nexport const merge: {\n  <A>(that: OrderType<A>): (self: OrderType<A>) => OrderType<A>\n  <A>(self: OrderType<A>, that: OrderType<A>): OrderType<A>\n  <A>(orders: Iterable<OrderType<A>>): OrderType<A>\n} = mergeOverload\n\n/**\n * Create an order for tuples, compared left-to-right.\n */\ntype TupleOrders<Elements extends ReadonlyArray<unknown>> = {\n  readonly [K in keyof Elements]: OrderType<Elements[K]>\n}\n\n/**\n * tuple utility.\n *\n * @example\n * ```ts\n * import { Order } from \"@nicolastoulemont/std\"\n *\n * const compare = Order.tuple([Order.string, Order.number] as const)([\"a\", 1], [\"a\", 2])\n * // => -1\n * ```\n */\nexport function tuple<const Elements extends ReadonlyArray<unknown>>(\n  orders: TupleOrders<Elements>,\n): OrderType<Elements> {\n  return make((self, that) => {\n    for (let i = 0; i < orders.length; i++) {\n      const order = orders[i]!\n      const result = order(self[i], that[i])\n      if (result !== 0) return result\n    }\n    return 0\n  })\n}\n\n/**\n * Create an order for arrays.\n *\n * Arrays are compared element-by-element, then by length when all compared\n * elements are equal.\n *\n * @example\n * ```ts\n * import { Order } from \"@nicolastoulemont/std\"\n *\n * const compare = Order.array(Order.number)([1, 2], [1, 3])\n * // => -1\n * ```\n */\nexport function array<A>(order: OrderType<A>): OrderType<readonly A[]> {\n  return make((self, that) => {\n    const minLength = Math.min(self.length, that.length)\n    for (let i = 0; i < minLength; i++) {\n      const result = order(self[i]!, that[i]!)\n      if (result !== 0) return result\n    }\n    return number(self.length, that.length)\n  })\n}\n\n/**\n * Create an order for objects by key order in `fields`.\n *\n * @example\n * ```ts\n * import { Order } from \"@nicolastoulemont/std\"\n *\n * const compare = Order.struct<{ id: number; name: string }>({\n *   id: Order.number,\n *   name: Order.string,\n * })({ id: 1, name: \"a\" }, { id: 1, name: \"b\" })\n * // => -1\n * ```\n */\nexport function struct<const R extends Record<string, unknown>>(fields: {\n  readonly [K in keyof R]: OrderType<R[K]>\n}): OrderType<R> {\n  const keys = Object.keys(fields) as Array<keyof R>\n\n  return make((self, that) => {\n    for (const key of keys) {\n      const result = fields[key](self[key], that[key])\n      if (result !== 0) return result\n    }\n    return 0\n  })\n}\n\n/**\n * Test strict less-than using an order.\n *\n * @example\n * ```ts\n * import { Order } from \"@nicolastoulemont/std\"\n *\n * const result = Order.lessThan(Order.number)(1, 2)\n * // => true\n * ```\n */\nexport const lessThan = <A>(\n  order: OrderType<A>,\n): {\n  (that: A): (self: A) => boolean\n  (self: A, that: A): boolean\n} => dual(2, (self: A, that: A) => order(self, that) === -1)\n\n/**\n * Test less-than-or-equal using an order.\n *\n * @example\n * ```ts\n * import { Order } from \"@nicolastoulemont/std\"\n *\n * const result = Order.lessThanOrEqual(Order.number)(2, 2)\n * // => true\n * ```\n */\nexport const lessThanOrEqual = <A>(\n  order: OrderType<A>,\n): {\n  (that: A): (self: A) => boolean\n  (self: A, that: A): boolean\n} => dual(2, (self: A, that: A) => order(self, that) !== 1)\n\n/**\n * Test strict greater-than using an order.\n *\n * @example\n * ```ts\n * import { Order } from \"@nicolastoulemont/std\"\n *\n * const result = Order.greaterThan(Order.number)(3, 2)\n * // => true\n * ```\n */\nexport const greaterThan = <A>(\n  order: OrderType<A>,\n): {\n  (that: A): (self: A) => boolean\n  (self: A, that: A): boolean\n} => dual(2, (self: A, that: A) => order(self, that) === 1)\n\n/**\n * Test greater-than-or-equal using an order.\n *\n * @example\n * ```ts\n * import { Order } from \"@nicolastoulemont/std\"\n *\n * const result = Order.greaterThanOrEqual(Order.number)(2, 2)\n * // => true\n * ```\n */\nexport const greaterThanOrEqual = <A>(\n  order: OrderType<A>,\n): {\n  (that: A): (self: A) => boolean\n  (self: A, that: A): boolean\n} => dual(2, (self: A, that: A) => order(self, that) !== -1)\n\n/**\n * Get the minimum of two values.\n *\n * If equal, returns the first argument.\n *\n * @example\n * ```ts\n * import { Order } from \"@nicolastoulemont/std\"\n *\n * const value = Order.min(Order.number)(3, 5)\n * // => 3\n * ```\n */\nexport const min = <A>(\n  order: OrderType<A>,\n): {\n  (that: A): (self: A) => A\n  (self: A, that: A): A\n} => dual(2, (self: A, that: A) => (self === that || order(self, that) < 1 ? self : that))\n\n/**\n * Get the maximum of two values.\n *\n * If equal, returns the first argument.\n *\n * @example\n * ```ts\n * import { Order } from \"@nicolastoulemont/std\"\n *\n * const value = Order.max(Order.number)(3, 5)\n * // => 5\n * ```\n */\nexport const max = <A>(\n  order: OrderType<A>,\n): {\n  (that: A): (self: A) => A\n  (self: A, that: A): A\n} => dual(2, (self: A, that: A) => (self === that || order(self, that) > -1 ? self : that))\n\n/**\n * Clamp a value to inclusive bounds.\n *\n * @example\n * ```ts\n * import { Order } from \"@nicolastoulemont/std\"\n *\n * const value = Order.clamp(Order.number)(7, { minimum: 0, maximum: 5 })\n * // => 5\n * ```\n */\nexport const clamp = <A>(\n  order: OrderType<A>,\n): {\n  (bounds: OrderBounds<A>): (self: A) => A\n  (self: A, bounds: OrderBounds<A>): A\n} => dual(2, (self: A, bounds: OrderBounds<A>): A => min(order)(bounds.maximum, max(order)(bounds.minimum, self)))\n\n/**\n * Check whether a value is within inclusive bounds.\n *\n * @example\n * ```ts\n * import { Order } from \"@nicolastoulemont/std\"\n *\n * const isBetween = Order.between(Order.number)(3, { minimum: 0, maximum: 5 })\n * // => true\n * ```\n */\nexport const between = <A>(\n  order: OrderType<A>,\n): {\n  (bounds: OrderBounds<A>): (self: A) => boolean\n  (self: A, bounds: OrderBounds<A>): boolean\n} =>\n  dual(\n    2,\n    (self: A, bounds: OrderBounds<A>): boolean =>\n      !lessThan(order)(self, bounds.minimum) && !greaterThan(order)(self, bounds.maximum),\n  )\n\n/**\n * Sort an iterable by an order, returning a new array.\n *\n * Supports data-first and data-last styles.\n *\n * @example\n * ```ts\n * import { Order } from \"@nicolastoulemont/std\"\n *\n * const values = [3, 1, 2]\n * const dataFirst = Order.sort(values, Order.number)\n * // => [1, 2, 3]\n *\n * const dataLast = Order.sort(Order.number)(values)\n * // => [1, 2, 3]\n * ```\n */\nexport const sort: {\n  <B>(order: OrderType<B>): <A extends B>(input: Iterable<A>) => A[]\n  <A extends B, B>(input: Iterable<A>, order: OrderType<B>): A[]\n} = dual(2, <A extends B, B>(input: Iterable<A>, order: OrderType<B>): A[] => {\n  const output = Array.from(input)\n  output.sort((self, that) => order(self, that))\n  return output\n})\n\n/**\n * Sort an iterable by a projected value.\n *\n * Supports data-first and data-last styles.\n *\n * @example\n * ```ts\n * import { Order } from \"@nicolastoulemont/std\"\n *\n * const users = [{ age: 2 }, { age: 1 }]\n * const dataFirst = Order.sortWith(users, (user) => user.age, Order.number)\n * // => [{ age: 1 }, { age: 2 }]\n *\n * const dataLast = Order.sortWith((user: { age: number }) => user.age, Order.number)(users)\n * // => [{ age: 1 }, { age: 2 }]\n * ```\n */\nexport const sortWith: {\n  <A, B>(project: (value: A) => B, order: OrderType<B>): (input: Iterable<A>) => A[]\n  <A, B>(input: Iterable<A>, project: (value: A) => B, order: OrderType<B>): A[]\n} = dual(3, <A, B>(input: Iterable<A>, project: (value: A) => B, order: OrderType<B>): A[] => {\n  const output = Array.from(input, (value) => [value, project(value)] as const)\n  output.sort(([, a], [, b]) => order(a, b))\n  return output.map(([value]) => value)\n})\n\n/**\n * Sort an iterable by multiple orders, in sequence.\n *\n * - first order has highest priority\n * - ties are broken by subsequent orders\n * - no orders returns a shallow copy preserving iteration order\n *\n * @example\n * ```ts\n * import { Order } from \"@nicolastoulemont/std\"\n *\n * const users = [{ age: 2, name: \"b\" }, { age: 1, name: \"a\" }]\n * const sorted = Order.sortBy(Order.by(Order.number, (user: { age: number; name: string }) => user.age))(users)\n * // => [{ age: 1, name: \"a\" }, { age: 2, name: \"b\" }]\n * ```\n */\nexport const sortBy = <A>(...orders: readonly OrderType<A>[]) => {\n  if (orders.length === 0) {\n    return (input: Iterable<A>): A[] => Array.from(input)\n  }\n\n  const merged = merge(orders)\n  return (input: Iterable<A>): A[] => sort(input, merged)\n}\n"],"mappings":"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"}

package/dist/{pipeable-rfqacPxZ.d.mts → pipeable-BIrevC0D.d.mts}

@@ -17,4 +17,4 @@ type Pipeable = {
 };
 //#endregion
 export { Pipeable as t };
-//# sourceMappingURL=pipeable-rfqacPxZ.d.mts.map
+//# sourceMappingURL=pipeable-BIrevC0D.d.mts.map

package/dist/{pipeable-rfqacPxZ.d.mts.map → pipeable-BIrevC0D.d.mts.map}

@@ -1 +1 @@
-{"version":3,"file":"pipeable-rfqacPxZ.d.mts","names":[],"sources":["../src/shared/pipeable.ts"],"sourcesContent":[],"mappings":"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"}
+{"version":3,"file":"pipeable-BIrevC0D.d.mts","names":[],"sources":["../src/shared/pipeable.ts"],"sourcesContent":[],"mappings":"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"}

package/dist/pipeable-Dp1_23zH.mjs

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

package/dist/{pipeable-COGyGMUV.mjs.map → pipeable-Dp1_23zH.mjs.map}

@@ -1 +1 @@
-{"version":3,"file":"pipeable-COGyGMUV.mjs","names":[],"sources":["../src/shared/pipeable.ts"],"sourcesContent":["import { flow } from \"../functions/flow\"\n\n/**\n * Pipeable interface for fluent method chaining.\n * Enables: value.pipe(fn1, fn2, fn3) as alternative to pipe(value, fn1, fn2, fn3)\n */\nexport type Pipeable = {\n  pipe<A>(this: A): A\n  pipe<A, B>(this: A, ab: (a: A) => B): B\n  pipe<A, B, C>(this: A, ab: (a: A) => B, bc: (b: B) => C): C\n  pipe<A, B, C, D>(this: A, ab: (a: A) => B, bc: (b: B) => C, cd: (c: C) => D): D\n  pipe<A, B, C, D, E>(this: A, ab: (a: A) => B, bc: (b: B) => C, cd: (c: C) => D, de: (d: D) => E): E\n  pipe<A, B, C, D, E, F>(\n    this: A,\n    ab: (a: A) => B,\n    bc: (b: B) => C,\n    cd: (c: C) => D,\n    de: (d: D) => E,\n    ef: (e: E) => F,\n  ): F\n  pipe<A, B, C, D, E, F, G>(\n    this: A,\n    ab: (a: A) => B,\n    bc: (b: B) => C,\n    cd: (c: C) => D,\n    de: (d: D) => E,\n    ef: (e: E) => F,\n    fg: (f: F) => G,\n  ): G\n  pipe<A, B, C, D, E, F, G, H>(\n    this: A,\n    ab: (a: A) => B,\n    bc: (b: B) => C,\n    cd: (c: C) => D,\n    de: (d: D) => E,\n    ef: (e: E) => F,\n    fg: (f: F) => G,\n    gh: (g: G) => H,\n  ): H\n  pipe<A, B, C, D, E, F, G, H, I>(\n    this: A,\n    ab: (a: A) => B,\n    bc: (b: B) => C,\n    cd: (c: C) => D,\n    de: (d: D) => E,\n    ef: (e: E) => F,\n    fg: (f: F) => G,\n    gh: (g: G) => H,\n    hi: (h: H) => I,\n  ): I\n  pipe<A, B, C, D, E, F, G, H, I, J>(\n    this: A,\n    ab: (a: A) => B,\n    bc: (b: B) => C,\n    cd: (c: C) => D,\n    de: (d: D) => E,\n    ef: (e: E) => F,\n    fg: (f: F) => G,\n    gh: (g: G) => H,\n    hi: (h: H) => I,\n    ij: (i: I) => J,\n  ): J\n}\n\ntype UnaryFn = (arg: unknown) => unknown\n\n/**\n * Create a pipe method implementation.\n * Returns a function that pipes the value through provided functions.\n * This is designed to be used as an object method, so it uses `this` binding.\n */\n// oxlint-disable no-explicit-any, no-this-in-exported-function\nexport function pipeMethod<A>(this: A, ...fns: UnaryFn[]): any {\n  if (fns.length === 0) return this\n  // oxlint-disable-next-line no-unsafe-return, no-unsafe-call, no-unsafe-type-assertion\n  return (flow as any)(...fns)(this)\n}\n// oxlint-enable no-explicit-any, no-this-in-exported-function\n"],"mappings":"wCAwEA,SAAgB,EAAuB,GAAG,EAAqB,CAG7D,OAFI,EAAI,SAAW,EAAU,KAErB,EAAa,GAAG,EAAI,CAAC,KAAK"}
+{"version":3,"file":"pipeable-Dp1_23zH.mjs","names":[],"sources":["../src/shared/pipeable.ts"],"sourcesContent":["import { flow } from \"../functions/flow\"\n\n/**\n * Pipeable interface for fluent method chaining.\n * Enables: value.pipe(fn1, fn2, fn3) as alternative to pipe(value, fn1, fn2, fn3)\n */\nexport type Pipeable = {\n  pipe<A>(this: A): A\n  pipe<A, B>(this: A, ab: (a: A) => B): B\n  pipe<A, B, C>(this: A, ab: (a: A) => B, bc: (b: B) => C): C\n  pipe<A, B, C, D>(this: A, ab: (a: A) => B, bc: (b: B) => C, cd: (c: C) => D): D\n  pipe<A, B, C, D, E>(this: A, ab: (a: A) => B, bc: (b: B) => C, cd: (c: C) => D, de: (d: D) => E): E\n  pipe<A, B, C, D, E, F>(\n    this: A,\n    ab: (a: A) => B,\n    bc: (b: B) => C,\n    cd: (c: C) => D,\n    de: (d: D) => E,\n    ef: (e: E) => F,\n  ): F\n  pipe<A, B, C, D, E, F, G>(\n    this: A,\n    ab: (a: A) => B,\n    bc: (b: B) => C,\n    cd: (c: C) => D,\n    de: (d: D) => E,\n    ef: (e: E) => F,\n    fg: (f: F) => G,\n  ): G\n  pipe<A, B, C, D, E, F, G, H>(\n    this: A,\n    ab: (a: A) => B,\n    bc: (b: B) => C,\n    cd: (c: C) => D,\n    de: (d: D) => E,\n    ef: (e: E) => F,\n    fg: (f: F) => G,\n    gh: (g: G) => H,\n  ): H\n  pipe<A, B, C, D, E, F, G, H, I>(\n    this: A,\n    ab: (a: A) => B,\n    bc: (b: B) => C,\n    cd: (c: C) => D,\n    de: (d: D) => E,\n    ef: (e: E) => F,\n    fg: (f: F) => G,\n    gh: (g: G) => H,\n    hi: (h: H) => I,\n  ): I\n  pipe<A, B, C, D, E, F, G, H, I, J>(\n    this: A,\n    ab: (a: A) => B,\n    bc: (b: B) => C,\n    cd: (c: C) => D,\n    de: (d: D) => E,\n    ef: (e: E) => F,\n    fg: (f: F) => G,\n    gh: (g: G) => H,\n    hi: (h: H) => I,\n    ij: (i: I) => J,\n  ): J\n}\n\ntype UnaryFn = (arg: unknown) => unknown\n\n/**\n * Create a pipe method implementation.\n * Returns a function that pipes the value through provided functions.\n * This is designed to be used as an object method, so it uses `this` binding.\n */\n// oxlint-disable no-explicit-any, no-this-in-exported-function\nexport function pipeable<A>(this: A, ...fns: UnaryFn[]): any {\n  if (fns.length === 0) return this\n  // oxlint-disable-next-line no-unsafe-return, no-unsafe-call, no-unsafe-type-assertion\n  return (flow as any)(...fns)(this)\n}\n// oxlint-enable no-explicit-any, no-this-in-exported-function\n"],"mappings":"wCAwEA,SAAgB,EAAqB,GAAG,EAAqB,CAG3D,OAFI,EAAI,SAAW,EAAU,KAErB,EAAa,GAAG,EAAI,CAAC,KAAK"}

package/dist/predicate/index.d.mts

@@ -1,2 +1,2 @@
-import { t as predicate_d_exports } from "../index-B_iY5tq0.mjs";
+import { t as predicate_d_exports } from "../index-CNTYbcY9.mjs";
 export { predicate_d_exports as Predicate };

package/dist/predicate/index.mjs

@@ -1 +1 @@
-import{t as e}from"../predicate-DUhhQqWY.mjs";export{e as Predicate};
+import{t as e}from"../predicate-D_1SsIi4.mjs";export{e as Predicate};

package/dist/{predicate-DUhhQqWY.mjs → predicate-D_1SsIi4.mjs}

@@ -1,2 +1,2 @@
-import{t as e}from"./chunk-C934ptG5.mjs";var t=e({all:()=>a,and:()=>r,andRefinement:()=>c,constant:()=>u,equals:()=>d,none:()=>s,not:()=>n,or:()=>i,orRefinement:()=>l,some:()=>o});const n=e=>t=>!e(t),r=(...e)=>t=>{for(let n of e)if(!n(t))return!1;return!0},i=(...e)=>t=>{for(let n of e)if(n(t))return!0;return!1},a=e=>t=>t.every(e),o=e=>t=>t.some(e),s=e=>t=>!t.some(e),c=(...e)=>t=>{for(let n of e)if(!n(t))return!1;return!0},l=(...e)=>t=>{for(let n of e)if(n(t))return!0;return!1},u=e=>()=>e,d=e=>t=>t===e;export{t};
-//# sourceMappingURL=predicate-DUhhQqWY.mjs.map
+import{t as e}from"./chunk-oQKkju2G.mjs";var t=e({all:()=>a,and:()=>r,andRefinement:()=>c,constant:()=>u,equals:()=>d,none:()=>s,not:()=>n,or:()=>i,orRefinement:()=>l,some:()=>o});const n=e=>t=>!e(t),r=(...e)=>t=>{for(let n of e)if(!n(t))return!1;return!0},i=(...e)=>t=>{for(let n of e)if(n(t))return!0;return!1},a=e=>t=>t.every(e),o=e=>t=>t.some(e),s=e=>t=>!t.some(e),c=(...e)=>t=>{for(let n of e)if(!n(t))return!1;return!0},l=(...e)=>t=>{for(let n of e)if(n(t))return!0;return!1},u=e=>()=>e,d=e=>t=>t===e;export{t};
+//# sourceMappingURL=predicate-D_1SsIi4.mjs.map

package/dist/predicate-D_1SsIi4.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"predicate-D_1SsIi4.mjs","names":[],"sources":["../src/predicate/predicate.ts"],"sourcesContent":["import type { Predicate as PredicateType, Refinement } from \"./predicate.types\"\n\n/**\n * Negate a predicate.\n * Returns true when the original predicate returns false, and vice versa.\n *\n * @template T - The type being tested\n * @param predicate - The predicate to negate\n * @returns A new predicate that returns the opposite boolean\n *\n * @example\n * ```ts\n * import { Predicate } from \"@nicolastoulemont/std\"\n *\n * const isOdd = Predicate.not((n: number) => n % 2 === 0)\n * const result = isOdd(3)\n * // => true\n * ```\n */\nexport const not = <T>(predicate: PredicateType<T>): PredicateType<T> => {\n  return (value: T): boolean => !predicate(value)\n}\n\n/**\n * Combine predicates with logical AND.\n * Returns true only when ALL predicates return true.\n * Short-circuits on first false (lazy evaluation).\n *\n * @template T - The type being tested\n * @param predicates - The predicates to combine\n * @returns A new predicate that returns true if all predicates pass\n *\n * @example\n * ```ts\n * import { Predicate } from \"@nicolastoulemont/std\"\n *\n * const isPositiveEven = Predicate.and<number>((n) => n > 0, (n) => n % 2 === 0)\n * const result = isPositiveEven(4)\n * // => true\n * ```\n */\nexport const and = <T>(...predicates: readonly PredicateType<T>[]): PredicateType<T> => {\n  return (value: T): boolean => {\n    for (const predicate of predicates) {\n      if (!predicate(value)) return false\n    }\n    return true\n  }\n}\n\n/**\n * Combine predicates with logical OR.\n * Returns true when ANY predicate returns true.\n * Short-circuits on first true (lazy evaluation).\n *\n * @template T - The type being tested\n * @param predicates - The predicates to combine\n * @returns A new predicate that returns true if any predicate passes\n *\n * @example\n * ```ts\n * import { Predicate } from \"@nicolastoulemont/std\"\n *\n * const isWeekend = Predicate.or<string>((day) => day === \"sat\", (day) => day === \"sun\")\n * const result = isWeekend(\"sun\")\n * // => true\n * ```\n */\nexport const or = <T>(...predicates: readonly PredicateType<T>[]): PredicateType<T> => {\n  return (value: T): boolean => {\n    for (const predicate of predicates) {\n      if (predicate(value)) return true\n    }\n    return false\n  }\n}\n\n/**\n * Create a predicate that tests if ALL elements in an array match.\n * Returns true for empty arrays (vacuous truth).\n *\n * @template T - The element type\n * @param predicate - The predicate to test each element\n * @returns A predicate that takes an array and returns true if all match\n *\n * @example\n * ```ts\n * import { Predicate } from \"@nicolastoulemont/std\"\n *\n * const allPositive = Predicate.all((n: number) => n > 0)\n * const result = allPositive([1, 2, 3])\n * // => true\n * ```\n */\nexport const all = <T>(predicate: PredicateType<T>): PredicateType<readonly T[]> => {\n  return (arr: readonly T[]): boolean => arr.every(predicate)\n}\n\n/**\n * Create a predicate that tests if ANY element in an array matches.\n * Returns false for empty arrays.\n *\n * @template T - The element type\n * @param predicate - The predicate to test each element\n * @returns A predicate that takes an array and returns true if any match\n *\n * @example\n * ```ts\n * import { Predicate } from \"@nicolastoulemont/std\"\n *\n * const someNegative = Predicate.some((n: number) => n < 0)\n * const result = someNegative([1, -1, 3])\n * // => true\n * ```\n */\nexport const some = <T>(predicate: PredicateType<T>): PredicateType<readonly T[]> => {\n  return (arr: readonly T[]): boolean => arr.some(predicate)\n}\n\n/**\n * Create a predicate that tests if NO elements in an array match.\n * Returns true for empty arrays (vacuous truth).\n * Equivalent to `not(some(predicate))`.\n *\n * @template T - The element type\n * @param predicate - The predicate that should NOT match any element\n * @returns A predicate that takes an array and returns true if none match\n *\n * @example\n * ```ts\n * import { Predicate } from \"@nicolastoulemont/std\"\n *\n * const noneZero = Predicate.none((n: number) => n === 0)\n * const result = noneZero([1, 2, 3])\n * // => true\n * ```\n */\nexport const none = <T>(predicate: PredicateType<T>): PredicateType<readonly T[]> => {\n  return (arr: readonly T[]): boolean => !arr.some(predicate)\n}\n\n/**\n * Combine refinements with logical AND, preserving type narrowing.\n * Use this instead of `and` when you need to preserve type guard behavior.\n *\n * @template T - The base type\n * @template U - The narrowed type (must extend T)\n * @param refinements - The refinements to combine\n * @returns A refinement that narrows to U if all refinements pass\n *\n * @example\n * ```ts\n * import { Predicate } from \"@nicolastoulemont/std\"\n *\n * const isString = (value: unknown): value is string => typeof value === \"string\"\n * const isNonEmpty = (value: unknown): value is string => typeof value === \"string\" && value.length > 0\n * const refine = Predicate.andRefinement(isString, isNonEmpty)\n * const result = refine(\"hello\")\n * // => true\n * ```\n */\nexport const andRefinement = <T, U extends T>(...refinements: readonly Refinement<T, U>[]): Refinement<T, U> => {\n  return (value: T): value is U => {\n    for (const refinement of refinements) {\n      if (!refinement(value)) return false\n    }\n    return true\n  }\n}\n\n/**\n * Combine refinements with logical OR, preserving type narrowing.\n * Use this instead of `or` when you need to preserve type guard behavior.\n *\n * @template T - The base type\n * @template U - The narrowed type (must extend T)\n * @param refinements - The refinements to combine\n * @returns A refinement that narrows to U if any refinement passes\n *\n * @example\n * ```ts\n * import { Predicate } from \"@nicolastoulemont/std\"\n *\n * const isGuest = (value: unknown): value is string => value === \"guest\"\n * const isAdmin = (value: unknown): value is string => value === \"admin\"\n * const refine = Predicate.orRefinement(isGuest, isAdmin)\n * const result = refine(\"admin\")\n * // => true\n * ```\n */\nexport const orRefinement = <T, U extends T>(...refinements: readonly Refinement<T, U>[]): Refinement<T, U> => {\n  return (value: T): value is U => {\n    for (const refinement of refinements) {\n      if (refinement(value)) return true\n    }\n    return false\n  }\n}\n\n/**\n * Create a predicate from a constant boolean value.\n * Useful for testing or as a placeholder.\n *\n * @template T - The type (can be anything)\n * @param value - The constant boolean to return\n * @returns A predicate that always returns the given value\n *\n * @example\n * ```ts\n * import { Predicate } from \"@nicolastoulemont/std\"\n *\n * const always = Predicate.constant<number>(true)\n * const result = always(123)\n * // => true\n * ```\n */\nexport const constant = <T>(value: boolean): PredicateType<T> => {\n  return (): boolean => value\n}\n\n/**\n * Create a predicate that checks strict equality.\n *\n * @template T - The type being compared\n * @param expected - The value to compare against\n * @returns A predicate that returns true if value === expected\n *\n * @example\n * ```ts\n * import { Predicate } from \"@nicolastoulemont/std\"\n *\n * const isReady = Predicate.equals(\"ready\")\n * const result = isReady(\"ready\")\n * // => true\n * ```\n */\nexport const equals = <T>(expected: T): PredicateType<T> => {\n  return (value: T): boolean => value === expected\n}\n"],"mappings":"oLAmBA,MAAa,EAAU,GACb,GAAsB,CAAC,EAAU,EAAM,CAqBpC,GAAU,GAAG,IAChB,GAAsB,CAC5B,IAAK,IAAM,KAAa,EACtB,GAAI,CAAC,EAAU,EAAM,CAAE,MAAO,GAEhC,MAAO,IAsBE,GAAS,GAAG,IACf,GAAsB,CAC5B,IAAK,IAAM,KAAa,EACtB,GAAI,EAAU,EAAM,CAAE,MAAO,GAE/B,MAAO,IAqBE,EAAU,GACb,GAA+B,EAAI,MAAM,EAAU,CAoBhD,EAAW,GACd,GAA+B,EAAI,KAAK,EAAU,CAqB/C,EAAW,GACd,GAA+B,CAAC,EAAI,KAAK,EAAU,CAuBhD,GAAiC,GAAG,IACvC,GAAyB,CAC/B,IAAK,IAAM,KAAc,EACvB,GAAI,CAAC,EAAW,EAAM,CAAE,MAAO,GAEjC,MAAO,IAwBE,GAAgC,GAAG,IACtC,GAAyB,CAC/B,IAAK,IAAM,KAAc,EACvB,GAAI,EAAW,EAAM,CAAE,MAAO,GAEhC,MAAO,IAqBE,EAAe,OACJ,EAmBX,EAAa,GAChB,GAAsB,IAAU"}

package/dist/provide/index.d.mts

@@ -1,2 +1,2 @@
-import { t as provide_d_exports } from "../index-BiiE8NS7.mjs";
+import { t as provide_d_exports } from "../index-crtzMG48.mjs";
 export { provide_d_exports as Provide };

package/dist/provide/index.mjs

@@ -1 +1 @@
-import{t as e}from"../provide-BmSM3Ruy.mjs";export{e as Provide};
+import{t as e}from"../provide--yZE8x-n.mjs";export{e as Provide};

package/dist/{provide-BmSM3Ruy.mjs → provide--yZE8x-n.mjs}

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

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

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

package/dist/queue/index.d.mts

@@ -1,2 +1,2 @@
-import { t as queue_d_exports } from "../index-Cq2IFito.mjs";
+import { t as queue_d_exports } from "../index-Ctqe1fD1.mjs";
 export { queue_d_exports as Queue };

package/dist/queue/index.mjs

@@ -1 +1 @@
-import{a as e}from"../queue-Sg6KJerl.mjs";export{e as Queue};
+import{a as e}from"../queue-apiEOlRD.mjs";export{e as Queue};

package/dist/{queue-Sg6KJerl.mjs → queue-apiEOlRD.mjs}

@@ -1,2 +1,2 @@
-import{t as e}from"./chunk-C934ptG5.mjs";import{t}from"./data-BLXO4XwS.mjs";var n=e({QueueAbortedError:()=>i,QueueClosedError:()=>r,QueueTaskAbortedError:()=>a,bounded:()=>h,is:()=>f,make:()=>m,unbounded:()=>g}),r=class extends t(`QueueClosedError`){},i=class extends t(`QueueAbortedError`){},a=class extends t(`QueueTaskAbortedError`){};const o=e=>{let t=e??`unbounded`;if(t===`unbounded`)return 1/0;if(!Number.isInteger(t)||t<=0)throw RangeError(`Queue concurrency must be a positive integer or "unbounded", received: ${String(t)}`);return t},s=e=>{if(e!==1/0&&(!Number.isInteger(e)||e<0))throw RangeError(`Queue maxSize must be an integer >= 0, received: ${String(e)}`)},c=e=>new a({reason:e.reason}),l=e=>new r({state:e}),u=e=>e instanceof Error?e:Error(`Queue rejection reason was not an Error`,{cause:e}),d=(e,t)=>{if(t===void 0)return e;if(t.aborted)return t;if(e.aborted)return e;let n=new AbortController,r=()=>{n.abort(e.reason),t.removeEventListener(`abort`,i)},i=()=>{n.abort(t.reason),e.removeEventListener(`abort`,r)};return e.addEventListener(`abort`,r,{once:!0}),t.addEventListener(`abort`,i,{once:!0}),n.signal.addEventListener(`abort`,()=>{e.removeEventListener(`abort`,r),t.removeEventListener(`abort`,i)},{once:!0}),n.signal},f=e=>typeof e==`object`&&!!e&&`_tag`in e&&e._tag===`Queue`,p=(e,t)=>{s(e);let n=o(t?.concurrency),r=`open`,a,f=t?.autoStart===!1,p=0,m=!1,h=[],g=[],_=new Set,v=new AbortController,y,b,x=()=>{if(!(p!==0||h.length>0)){for(let e of _)e();_.clear(),(r===`draining`||r===`aborted`)&&(r=`closed`,y?.(),y=void 0)}},S=e=>{if(g.length===0)return;let t=g.splice(0);for(let n of t)n.reject(e)},C=()=>{if(!(!Number.isFinite(e)||g.length===0))for(;g.length>0&&h.length<e&&r===`open`;){let e=g.shift();e!==void 0&&e.resolve()}},w=e=>{if(h.length===0)return;let t=new i({reason:e}),n=h.splice(0);for(let e of n)e.reject(t)},T=t=>!Number.isFinite(e)||h.length<e?Promise.resolve():new Promise((e,n)=>{let r={resolve:()=>{t!==void 0&&i!==void 0&&t.removeEventListener(`abort`,i),e()},reject:e=>{t!==void 0&&i!==void 0&&t.removeEventListener(`abort`,i),n(e)},signal:t},i=t===void 0?void 0:()=>{let e=g.indexOf(r);e!==-1&&g.splice(e,1),n(c(t))};if(t!==void 0&&t.aborted){n(c(t));return}t!==void 0&&i!==void 0&&t.addEventListener(`abort`,i,{once:!0}),g.push(r)}),E=()=>{(r===`draining`||r===`aborted`)&&p===0&&h.length===0&&x()},D=e=>{p+=1;let t=d(v.signal,e.signal),n;if(t.aborted)n=Promise.reject(c(t));else try{n=Promise.resolve(e.task({signal:t}))}catch(e){n=Promise.reject(u(e))}n.then(t=>{e.resolve(t)},t=>{e.reject(u(t))}).finally(()=>{--p,C(),O(),x()})},O=()=>{if(!m){m=!0;try{if(r===`aborted`){E();return}for(;!f&&p<n&&h.length>0;){let e=h.shift();if(e===void 0)break;C(),D(e)}E()}finally{m=!1}}},k=()=>l(a===void 0?r===`aborted`?`aborted`:r===`draining`?`draining`:r===`closed`?a??`draining`:`draining`:a);return{_tag:`Queue`,get pending(){return p},get size(){return h.length},get isPaused(){return f},get isShutdown(){return r!==`open`},enqueue(t,n){let i=n?.signal;if(i!==void 0&&i.aborted)return Promise.reject(c(i));if(r!==`open`)return Promise.reject(k());let a=()=>new Promise((e,n)=>{let r={task:t,resolve:e,reject:n,signal:i};h.push(r),O()});return!Number.isFinite(e)||h.length<e?a():T(i).then(()=>{if(i!==void 0&&i.aborted)throw c(i);if(r!==`open`)throw k();return a()})},pause(){f=!0},resume(){f&&(f=!1,O())},awaitIdle(){return p===0&&h.length===0?Promise.resolve():new Promise(e=>{_.add(e)})},shutdown(e){let t=e?.mode??`drain`;return b!==void 0&&(r===`draining`||r===`aborted`||r===`closed`)?(t===`abort`&&a!==`aborted`&&(a=`aborted`,r=`aborted`,v.abort(e?.reason),w(e?.reason),S(l(`aborted`)),E()),b):(b??=new Promise(e=>{y=e}),t===`abort`?(a=`aborted`,r=`aborted`,f=!1,v.abort(e?.reason),w(e?.reason),S(l(`aborted`))):(a=`draining`,r===`open`&&(r=`draining`),f=!1,S(l(`draining`))),O(),x(),b)}}},m=e=>p(1/0,e),h=(e,t)=>p(e,t),g=e=>p(1/0,e);export{n as a,m as i,r as n,a as r,i as t};
-//# sourceMappingURL=queue-Sg6KJerl.mjs.map
+import{t as e}from"./chunk-oQKkju2G.mjs";import{t}from"./data-BHYPdqWZ.mjs";var n=e({QueueAbortedError:()=>i,QueueClosedError:()=>r,QueueTaskAbortedError:()=>a,bounded:()=>h,is:()=>f,make:()=>m,unbounded:()=>g}),r=class extends t(`QueueClosedError`){},i=class extends t(`QueueAbortedError`){},a=class extends t(`QueueTaskAbortedError`){};const o=e=>{let t=e??`unbounded`;if(t===`unbounded`)return 1/0;if(!Number.isInteger(t)||t<=0)throw RangeError(`Queue concurrency must be a positive integer or "unbounded", received: ${String(t)}`);return t},s=e=>{if(e!==1/0&&(!Number.isInteger(e)||e<0))throw RangeError(`Queue maxSize must be an integer >= 0, received: ${String(e)}`)},c=e=>new a({reason:e.reason}),l=e=>new r({state:e}),u=e=>e instanceof Error?e:Error(`Queue rejection reason was not an Error`,{cause:e}),d=(e,t)=>{if(t===void 0)return e;if(t.aborted)return t;if(e.aborted)return e;let n=new AbortController,r=()=>{n.abort(e.reason),t.removeEventListener(`abort`,i)},i=()=>{n.abort(t.reason),e.removeEventListener(`abort`,r)};return e.addEventListener(`abort`,r,{once:!0}),t.addEventListener(`abort`,i,{once:!0}),n.signal.addEventListener(`abort`,()=>{e.removeEventListener(`abort`,r),t.removeEventListener(`abort`,i)},{once:!0}),n.signal},f=e=>typeof e==`object`&&!!e&&`_tag`in e&&e._tag===`Queue`,p=(e,t)=>{s(e);let n=o(t?.concurrency),r=`open`,a,f=t?.autoStart===!1,p=0,m=!1,h=[],g=[],_=new Set,v=new AbortController,y,b,x=()=>{if(!(p!==0||h.length>0)){for(let e of _)e();_.clear(),(r===`draining`||r===`aborted`)&&(r=`closed`,y?.(),y=void 0)}},S=e=>{if(g.length===0)return;let t=g.splice(0);for(let n of t)n.reject(e)},C=()=>{if(!(!Number.isFinite(e)||g.length===0))for(;g.length>0&&h.length<e&&r===`open`;){let e=g.shift();e!==void 0&&e.resolve()}},w=e=>{if(h.length===0)return;let t=new i({reason:e}),n=h.splice(0);for(let e of n)e.reject(t)},T=t=>!Number.isFinite(e)||h.length<e?Promise.resolve():new Promise((e,n)=>{let r={resolve:()=>{t!==void 0&&i!==void 0&&t.removeEventListener(`abort`,i),e()},reject:e=>{t!==void 0&&i!==void 0&&t.removeEventListener(`abort`,i),n(e)},signal:t},i=t===void 0?void 0:()=>{let e=g.indexOf(r);e!==-1&&g.splice(e,1),n(c(t))};if(t!==void 0&&t.aborted){n(c(t));return}t!==void 0&&i!==void 0&&t.addEventListener(`abort`,i,{once:!0}),g.push(r)}),E=()=>{(r===`draining`||r===`aborted`)&&p===0&&h.length===0&&x()},D=e=>{p+=1;let t=d(v.signal,e.signal),n;if(t.aborted)n=Promise.reject(c(t));else try{n=Promise.resolve(e.task({signal:t}))}catch(e){n=Promise.reject(u(e))}n.then(t=>{e.resolve(t)},t=>{e.reject(u(t))}).finally(()=>{--p,C(),O(),x()})},O=()=>{if(!m){m=!0;try{if(r===`aborted`){E();return}for(;!f&&p<n&&h.length>0;){let e=h.shift();if(e===void 0)break;C(),D(e)}E()}finally{m=!1}}},k=()=>l(a===void 0?r===`aborted`?`aborted`:r===`draining`?`draining`:r===`closed`?a??`draining`:`draining`:a);return{_tag:`Queue`,get pending(){return p},get size(){return h.length},get isPaused(){return f},get isShutdown(){return r!==`open`},enqueue(t,n){let i=n?.signal;if(i!==void 0&&i.aborted)return Promise.reject(c(i));if(r!==`open`)return Promise.reject(k());let a=()=>new Promise((e,n)=>{let r={task:t,resolve:e,reject:n,signal:i};h.push(r),O()});return!Number.isFinite(e)||h.length<e?a():T(i).then(()=>{if(i!==void 0&&i.aborted)throw c(i);if(r!==`open`)throw k();return a()})},pause(){f=!0},resume(){f&&(f=!1,O())},awaitIdle(){return p===0&&h.length===0?Promise.resolve():new Promise(e=>{_.add(e)})},shutdown(e){let t=e?.mode??`drain`;return b!==void 0&&(r===`draining`||r===`aborted`||r===`closed`)?(t===`abort`&&a!==`aborted`&&(a=`aborted`,r=`aborted`,v.abort(e?.reason),w(e?.reason),S(l(`aborted`)),E()),b):(b??=new Promise(e=>{y=e}),t===`abort`?(a=`aborted`,r=`aborted`,f=!1,v.abort(e?.reason),w(e?.reason),S(l(`aborted`))):(a=`draining`,r===`open`&&(r=`draining`),f=!1,S(l(`draining`))),O(),x(),b)}}},m=e=>p(1/0,e),h=(e,t)=>p(e,t),g=e=>p(1/0,e);export{n as a,m as i,r as n,a as r,i as t};
+//# sourceMappingURL=queue-apiEOlRD.mjs.map

package/dist/queue-apiEOlRD.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"queue-apiEOlRD.mjs","names":["Data.TaggedError","options"],"sources":["../src/queue/queue.ts"],"sourcesContent":["/**\n * Promise-based work queue with bounded/unbounded capacity and shutdown modes.\n *\n * **Mental model**\n * - A queue coordinates concurrent task execution with backpressure.\n * - Enqueue returns a promise for each task result.\n *\n * **Common tasks**\n * - Create queues via `Queue.make`, `Queue.bounded`, or `Queue.unbounded`.\n * - Pause/resume processing and await idle state.\n * - Shutdown with drain or abort semantics.\n *\n * **Gotchas**\n * - Bounded queues can block enqueue when capacity is reached.\n * - Aborted queues reject queued and future tasks.\n *\n * **Quickstart**\n *\n * @example\n * ```ts\n * import { Queue } from \"@nicolastoulemont/std\"\n *\n * const queue = Queue.make()\n * const pending = queue.pending\n * // => 0\n * ```\n *\n * @module\n */\nimport { Data } from \"../data\"\nimport type {\n  Concurrency,\n  Queue as QueueType,\n  QueueBoundedOptions,\n  QueueOptions,\n  QueueShutdownMode,\n  QueueShutdownOptions,\n  QueueTask,\n} from \"./queue.types\"\n\n/* oxlint-disable max-classes-per-file -- Queue exports dedicated error classes for precise instanceof checks at call sites. */\n/**\n * Error raised when enqueueing into a non-open queue.\n *\n * @example\n * ```ts\n * import { Queue } from \"@nicolastoulemont/std\"\n *\n * const error = new Queue.QueueClosedError({ state: \"draining\" })\n * // => { _tag: \"QueueClosedError\", state: \"draining\" }\n * ```\n */\nexport class QueueClosedError extends Data.TaggedError(\"QueueClosedError\")<{ state: \"draining\" | \"aborted\" }> {}\n/**\n * Error raised when queue processing is aborted.\n *\n * @example\n * ```ts\n * import { Queue } from \"@nicolastoulemont/std\"\n *\n * const error = new Queue.QueueAbortedError({ reason: \"manual\" })\n * // => { _tag: \"QueueAbortedError\", reason: \"manual\" }\n * ```\n */\nexport class QueueAbortedError extends Data.TaggedError(\"QueueAbortedError\")<{ reason?: unknown }> {}\n/**\n * Error raised when a specific task is aborted.\n *\n * @example\n * ```ts\n * import { Queue } from \"@nicolastoulemont/std\"\n *\n * const error = new Queue.QueueTaskAbortedError({ reason: \"signal\" })\n * // => { _tag: \"QueueTaskAbortedError\", reason: \"signal\" }\n * ```\n */\nexport class QueueTaskAbortedError extends Data.TaggedError(\"QueueTaskAbortedError\")<{ reason?: unknown }> {}\n\ntype QueueState = \"open\" | \"draining\" | \"aborted\" | \"closed\"\n\ntype TaskEntry<A> = {\n  readonly task: QueueTask<A>\n  resolve(value: A | PromiseLike<A>): void\n  reject(reason: unknown): void\n  readonly signal: AbortSignal | undefined\n}\n\ntype CapacityWaiter = {\n  resolve(): void\n  reject(reason: Error): void\n  readonly signal: AbortSignal | undefined\n}\n\nconst asConcurrencyLimit = (concurrency: Concurrency | undefined): number => {\n  const resolved = concurrency ?? \"unbounded\"\n  if (resolved === \"unbounded\") {\n    return Number.POSITIVE_INFINITY\n  }\n\n  if (!Number.isInteger(resolved) || resolved <= 0) {\n    throw new RangeError(`Queue concurrency must be a positive integer or \"unbounded\", received: ${String(resolved)}`)\n  }\n\n  return resolved\n}\n\nconst assertMaxSize = (maxSize: number) => {\n  if (maxSize === Number.POSITIVE_INFINITY) {\n    return\n  }\n\n  if (!Number.isInteger(maxSize) || maxSize < 0) {\n    throw new RangeError(`Queue maxSize must be an integer >= 0, received: ${String(maxSize)}`)\n  }\n}\n\nconst queueTaskAbortedError = (signal: AbortSignal): QueueTaskAbortedError =>\n  new QueueTaskAbortedError({ reason: signal.reason })\n\nconst queueClosedError = (state: \"draining\" | \"aborted\"): QueueClosedError => new QueueClosedError({ state })\n\nconst toError = (reason: unknown): Error =>\n  reason instanceof Error ? reason : new Error(\"Queue rejection reason was not an Error\", { cause: reason })\n\nconst composeSignals = (queueSignal: AbortSignal, taskSignal: AbortSignal | undefined): AbortSignal => {\n  if (taskSignal === undefined) {\n    return queueSignal\n  }\n\n  if (taskSignal.aborted) {\n    return taskSignal\n  }\n\n  if (queueSignal.aborted) {\n    return queueSignal\n  }\n\n  const composite = new AbortController()\n\n  const onQueueAbort = () => {\n    composite.abort(queueSignal.reason)\n    taskSignal.removeEventListener(\"abort\", onTaskAbort)\n  }\n\n  const onTaskAbort = () => {\n    composite.abort(taskSignal.reason)\n    queueSignal.removeEventListener(\"abort\", onQueueAbort)\n  }\n\n  queueSignal.addEventListener(\"abort\", onQueueAbort, { once: true })\n  taskSignal.addEventListener(\"abort\", onTaskAbort, { once: true })\n\n  composite.signal.addEventListener(\n    \"abort\",\n    () => {\n      queueSignal.removeEventListener(\"abort\", onQueueAbort)\n      taskSignal.removeEventListener(\"abort\", onTaskAbort)\n    },\n    { once: true },\n  )\n\n  return composite.signal\n}\n\n/**\n * Check if a value is a `Queue`.\n *\n * @example\n * ```ts\n * import { Queue } from \"@nicolastoulemont/std\"\n *\n * const queue = Queue.make()\n * const isQueue = Queue.is(queue)\n * // => true\n * ```\n */\nexport const is = (value: unknown): value is QueueType =>\n  typeof value === \"object\" && value !== null && \"_tag\" in value && value._tag === \"Queue\"\n\nconst createQueue = (maxSize: number, options?: QueueOptions): QueueType => {\n  assertMaxSize(maxSize)\n\n  const concurrencyLimit = asConcurrencyLimit(options?.concurrency)\n  let state: QueueState = \"open\"\n  let closeState: \"draining\" | \"aborted\" | undefined\n  let paused = options?.autoStart === false\n  let pending = 0\n  let draining = false\n\n  const queuedTasks: TaskEntry<unknown>[] = []\n  const capacityWaiters: CapacityWaiter[] = []\n  const idleWaiters = new Set<() => void>()\n\n  const queueAbortController = new AbortController()\n\n  let shutdownResolver: (() => void) | undefined\n  let shutdownPromise: Promise<void> | undefined\n\n  const resolveIdleIfNeeded = () => {\n    if (pending !== 0 || queuedTasks.length > 0) {\n      return\n    }\n\n    for (const resolve of idleWaiters) {\n      resolve()\n    }\n    idleWaiters.clear()\n\n    if (state === \"draining\" || state === \"aborted\") {\n      state = \"closed\"\n      shutdownResolver?.()\n      shutdownResolver = undefined\n    }\n  }\n\n  const rejectCapacityWaiters = (reason: Error) => {\n    if (capacityWaiters.length === 0) {\n      return\n    }\n\n    const waiters = capacityWaiters.splice(0)\n    for (const waiter of waiters) {\n      waiter.reject(reason)\n    }\n  }\n\n  const releaseCapacityWaiters = () => {\n    if (!Number.isFinite(maxSize) || capacityWaiters.length === 0) {\n      return\n    }\n\n    while (capacityWaiters.length > 0 && queuedTasks.length < maxSize && state === \"open\") {\n      const waiter = capacityWaiters.shift()\n      if (waiter !== undefined) {\n        waiter.resolve()\n      }\n    }\n  }\n\n  const applyAbortToQueuedTasks = (reason: unknown) => {\n    if (queuedTasks.length === 0) {\n      return\n    }\n\n    const error = new QueueAbortedError({ reason })\n    const tasks = queuedTasks.splice(0)\n    for (const entry of tasks) {\n      entry.reject(error)\n    }\n  }\n\n  const waitForCapacity = (signal: AbortSignal | undefined): Promise<void> => {\n    if (!Number.isFinite(maxSize)) {\n      return Promise.resolve()\n    }\n\n    if (queuedTasks.length < maxSize) {\n      return Promise.resolve()\n    }\n\n    return new Promise<void>((resolve, reject) => {\n      const waiter: CapacityWaiter = {\n        resolve: () => {\n          if (signal !== undefined && onAbort !== undefined) {\n            signal.removeEventListener(\"abort\", onAbort)\n          }\n          resolve()\n        },\n        reject: (error) => {\n          if (signal !== undefined && onAbort !== undefined) {\n            signal.removeEventListener(\"abort\", onAbort)\n          }\n          reject(error)\n        },\n        signal,\n      }\n\n      const onAbort =\n        signal === undefined\n          ? undefined\n          : () => {\n              const index = capacityWaiters.indexOf(waiter)\n              if (index !== -1) {\n                capacityWaiters.splice(index, 1)\n              }\n              reject(queueTaskAbortedError(signal))\n            }\n\n      if (signal !== undefined && signal.aborted) {\n        reject(queueTaskAbortedError(signal))\n        return\n      }\n\n      if (signal !== undefined && onAbort !== undefined) {\n        signal.addEventListener(\"abort\", onAbort, { once: true })\n      }\n\n      capacityWaiters.push(waiter)\n    })\n  }\n\n  const closeIfNeeded = () => {\n    if ((state === \"draining\" || state === \"aborted\") && pending === 0 && queuedTasks.length === 0) {\n      resolveIdleIfNeeded()\n    }\n  }\n\n  const runTask = <A>(entry: TaskEntry<A>) => {\n    pending += 1\n\n    const taskSignal = composeSignals(queueAbortController.signal, entry.signal)\n\n    let taskResult: Promise<A>\n    if (taskSignal.aborted) {\n      taskResult = Promise.reject(queueTaskAbortedError(taskSignal))\n    } else {\n      try {\n        taskResult = Promise.resolve(entry.task({ signal: taskSignal }))\n      } catch (error) {\n        taskResult = Promise.reject(toError(error))\n      }\n    }\n\n    void taskResult\n      .then(\n        (value) => {\n          entry.resolve(value)\n          return undefined\n        },\n        (error: unknown) => {\n          entry.reject(toError(error))\n          return undefined\n        },\n      )\n      .finally(() => {\n        pending -= 1\n        releaseCapacityWaiters()\n        drainQueue()\n        resolveIdleIfNeeded()\n      })\n  }\n\n  const drainQueue = () => {\n    if (draining) {\n      return\n    }\n\n    draining = true\n    try {\n      if (state === \"aborted\") {\n        closeIfNeeded()\n        return\n      }\n\n      while (!paused && pending < concurrencyLimit && queuedTasks.length > 0) {\n        const entry = queuedTasks.shift()\n        if (entry === undefined) {\n          break\n        }\n        releaseCapacityWaiters()\n        runTask(entry)\n      }\n\n      closeIfNeeded()\n    } finally {\n      draining = false\n    }\n  }\n\n  const enqueueErrorForState = (): QueueClosedError => {\n    if (closeState !== undefined) {\n      return queueClosedError(closeState)\n    }\n\n    if (state === \"aborted\") {\n      return queueClosedError(\"aborted\")\n    }\n\n    if (state === \"draining\") {\n      return queueClosedError(\"draining\")\n    }\n\n    if (state === \"closed\") {\n      return queueClosedError(closeState ?? \"draining\")\n    }\n\n    return queueClosedError(\"draining\")\n  }\n\n  const queue: QueueType = {\n    _tag: \"Queue\",\n\n    get pending(): number {\n      return pending\n    },\n\n    get size(): number {\n      return queuedTasks.length\n    },\n\n    get isPaused(): boolean {\n      return paused\n    },\n\n    get isShutdown(): boolean {\n      return state !== \"open\"\n    },\n\n    enqueue<A>(task: QueueTask<A>, options?: { readonly signal?: AbortSignal }): Promise<A> {\n      const signal = options?.signal\n\n      if (signal !== undefined && signal.aborted) {\n        return Promise.reject(queueTaskAbortedError(signal))\n      }\n\n      if (state !== \"open\") {\n        return Promise.reject(enqueueErrorForState())\n      }\n\n      const enqueueTask = () =>\n        new Promise<A>((resolve, reject) => {\n          const entry: TaskEntry<A> = {\n            task,\n            resolve,\n            reject,\n            signal,\n          }\n\n          queuedTasks.push(entry)\n          drainQueue()\n        })\n\n      if (!Number.isFinite(maxSize) || queuedTasks.length < maxSize) {\n        return enqueueTask()\n      }\n\n      return waitForCapacity(signal).then(() => {\n        if (signal !== undefined && signal.aborted) {\n          throw queueTaskAbortedError(signal)\n        }\n\n        if (state !== \"open\") {\n          throw enqueueErrorForState()\n        }\n\n        return enqueueTask()\n      })\n    },\n\n    pause(): void {\n      paused = true\n    },\n\n    resume(): void {\n      if (!paused) {\n        return\n      }\n\n      paused = false\n      drainQueue()\n    },\n\n    awaitIdle(): Promise<void> {\n      if (pending === 0 && queuedTasks.length === 0) {\n        return Promise.resolve()\n      }\n\n      return new Promise<void>((resolve) => {\n        idleWaiters.add(resolve)\n      })\n    },\n\n    shutdown(options?: QueueShutdownOptions): Promise<void> {\n      const mode: QueueShutdownMode = options?.mode ?? \"drain\"\n\n      if (shutdownPromise !== undefined && (state === \"draining\" || state === \"aborted\" || state === \"closed\")) {\n        if (mode === \"abort\" && closeState !== \"aborted\") {\n          closeState = \"aborted\"\n          state = \"aborted\"\n          queueAbortController.abort(options?.reason)\n          applyAbortToQueuedTasks(options?.reason)\n          rejectCapacityWaiters(queueClosedError(\"aborted\"))\n          closeIfNeeded()\n        }\n\n        return shutdownPromise\n      }\n\n      shutdownPromise =\n        shutdownPromise ??\n        new Promise<void>((resolve) => {\n          shutdownResolver = resolve\n        })\n\n      if (mode === \"abort\") {\n        closeState = \"aborted\"\n        state = \"aborted\"\n        paused = false\n        queueAbortController.abort(options?.reason)\n        applyAbortToQueuedTasks(options?.reason)\n        rejectCapacityWaiters(queueClosedError(\"aborted\"))\n      } else {\n        closeState = \"draining\"\n        if (state === \"open\") {\n          state = \"draining\"\n        }\n        paused = false\n        rejectCapacityWaiters(queueClosedError(\"draining\"))\n      }\n\n      drainQueue()\n      resolveIdleIfNeeded()\n\n      return shutdownPromise\n    },\n  }\n\n  return queue\n}\n\n/**\n * Create a queue with default unbounded capacity.\n *\n * @example\n * ```ts\n * import { Queue } from \"@nicolastoulemont/std\"\n *\n * const queue = Queue.make()\n * const pending = queue.pending\n * // => 0\n * ```\n */\nexport const make = (options?: QueueOptions): QueueType => createQueue(Number.POSITIVE_INFINITY, options)\n\n/**\n * Create a queue with bounded capacity.\n *\n * @example\n * ```ts\n * import { Queue } from \"@nicolastoulemont/std\"\n *\n * const queue = Queue.bounded(2)\n * const size = queue.size\n * // => 0\n * ```\n */\nexport const bounded = (maxSize: number, options?: QueueBoundedOptions): QueueType => createQueue(maxSize, options)\n\n/**\n * Create a queue with explicit unbounded capacity.\n *\n * @example\n * ```ts\n * import { Queue } from \"@nicolastoulemont/std\"\n *\n * const queue = Queue.unbounded()\n * const paused = queue.isPaused\n * // => false\n * ```\n */\nexport const unbounded = (options?: QueueOptions): QueueType => createQueue(Number.POSITIVE_INFINITY, options)\n\n/* oxlint-enable max-classes-per-file */\n"],"mappings":"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"}

package/dist/{queue.types-CD2LOu37.d.mts → queue.types-B-l5XYbU.d.mts}

@@ -33,4 +33,4 @@ type Queue = {
 };
 //#endregion
 export { QueueOptions as i, Queue as n, QueueBoundedOptions as r, Concurrency as t };
-//# sourceMappingURL=queue.types-CD2LOu37.d.mts.map
+//# sourceMappingURL=queue.types-B-l5XYbU.d.mts.map

package/dist/{queue.types-CD2LOu37.d.mts.map → queue.types-B-l5XYbU.d.mts.map}

@@ -1 +1 @@
-{"version":3,"file":"queue.types-CD2LOu37.d.mts","names":[],"sources":["../src/queue/queue.types.ts"],"sourcesContent":[],"mappings":";KAAY,WAAA;AAAZ,KAEK,gBAAA,GAFkB;EAElB,SAAA,MAAA,EACc,WADE;AAIrB,CAAA;AAAiC,KAArB,SAAqB,CAAA,CAAA,CAAA,GAAA,CAAA,GAAA,EAAA,gBAAA,EAAA,GAAqB,CAArB,GAAyB,OAAzB,CAAiC,CAAjC,CAAA;AAAqB,KAE1C,iBAAA,GAF0C,OAAA,GAAA,OAAA;AAAY,KAItD,YAAA,GAJsD;EAAR,SAAA,WAAA,CAAA,EAKjC,WALiC;EAAO,SAAA,SAAA,CAAA,EAAA,OAAA;AAEjE,CAAA;AAEY,KAKA,mBAAA,GAJa;EAIb,SAAA,WAAA,CAAA,EACa,WADM;EAKnB,SAAA,SAAA,CAAA,EAAA,OAAoB;AAKhC,CAAA;AAM6B,KAXjB,oBAAA,GAWiB;EAAV,SAAA,IAAA,CAAA,EAVD,iBAUC;EAA4C,SAAA,MAAA,CAAA,EAAA,OAAA;CAAwB;AAAR,KANnE,KAAA,GAMmE;EAGhE,SAAA,IAAA,EAAA,OAAA;EACM,SAAA,OAAA,EAAA,MAAA;EAAuB,SAAA,IAAA,EAAA,MAAA;EAAO,SAAA,QAAA,EAAA,OAAA;;mBAJhC,UAAU;sBAAkC;MAAgB,QAAQ;;;eAGxE;qBACM,uBAAuB"}
+{"version":3,"file":"queue.types-B-l5XYbU.d.mts","names":[],"sources":["../src/queue/queue.types.ts"],"sourcesContent":[],"mappings":";KAAY,WAAA;AAAZ,KAEK,gBAAA,GAFkB;EAElB,SAAA,MAAA,EACc,WADE;AAIrB,CAAA;AAAiC,KAArB,SAAqB,CAAA,CAAA,CAAA,GAAA,CAAA,GAAA,EAAA,gBAAA,EAAA,GAAqB,CAArB,GAAyB,OAAzB,CAAiC,CAAjC,CAAA;AAAqB,KAE1C,iBAAA,GAF0C,OAAA,GAAA,OAAA;AAAY,KAItD,YAAA,GAJsD;EAAR,SAAA,WAAA,CAAA,EAKjC,WALiC;EAAO,SAAA,SAAA,CAAA,EAAA,OAAA;AAEjE,CAAA;AAEY,KAKA,mBAAA,GAJa;EAIb,SAAA,WAAA,CAAA,EACa,WADM;EAKnB,SAAA,SAAA,CAAA,EAAA,OAAoB;AAKhC,CAAA;AAM6B,KAXjB,oBAAA,GAWiB;EAAV,SAAA,IAAA,CAAA,EAVD,iBAUC;EAA4C,SAAA,MAAA,CAAA,EAAA,OAAA;CAAwB;AAAR,KANnE,KAAA,GAMmE;EAGhE,SAAA,IAAA,EAAA,OAAA;EACM,SAAA,OAAA,EAAA,MAAA;EAAuB,SAAA,IAAA,EAAA,MAAA;EAAO,SAAA,QAAA,EAAA,OAAA;;mBAJhC,UAAU;sBAAkC;MAAgB,QAAQ;;;eAGxE;qBACM,uBAAuB"}

package/dist/result/index.d.mts

@@ -1,2 +1,2 @@
-import { t as result_d_exports } from "../index-DEAWPlcI.mjs";
+import { n as result_d_exports } from "../index-CIvNgjsx.mjs";
 export { result_d_exports as Result };

package/dist/result/index.mjs

@@ -1 +1 @@
-import{i as e}from"../result-BEzV0DYC.mjs";export{e as Result};
+import{a as e}from"../result-D3VY0qBG.mjs";export{e as Result};

package/dist/{result-BEzV0DYC.mjs → result-D3VY0qBG.mjs}

@@ -1,2 +1,2 @@
-import{t as e}from"./chunk-C934ptG5.mjs";import{t}from"./fx.types-Bg-Mmdm5.mjs";import{t as n}from"./dual-CZhzZslG.mjs";import{n as r}from"./flow-D8_tllWl.mjs";import{t as i}from"./pipeable-COGyGMUV.mjs";var a=e({all:()=>g,err:()=>s,filter:()=>h,flatMap:()=>f,fromTry:()=>b,isErr:()=>l,isOk:()=>c,map:()=>u,mapErr:()=>d,match:()=>y,ok:()=>o,orElse:()=>m,tap:()=>p,try:()=>x,unwrapOr:()=>_,unwrapOrElse:()=>v});const o=e=>({_tag:`Ok`,value:e,pipe:i,[t]:{_A:()=>e,_E:()=>void 0,_R:()=>void 0},*[Symbol.iterator](){return e}}),s=e=>{let n={_tag:`Err`,error:e,pipe:i,[t]:{_A:()=>void 0,_E:()=>e,_R:()=>void 0},*[Symbol.iterator](){throw yield n,Error(`Unreachable: Fx.gen should short-circuit on error`)}};return n},c=e=>e._tag===`Ok`,l=e=>e._tag===`Err`,u=n(2,(e,t)=>{if(e._tag===`Err`)return e;let n=t(e.value);return r(n)?Promise.resolve(n).then(o):o(n)}),d=n(2,(e,t)=>{if(e._tag===`Ok`)return e;let n=t(e.error);return r(n)?Promise.resolve(n).then(s):s(n)}),f=n(2,(e,t)=>e._tag===`Ok`?t(e.value):e),p=n(2,(e,t)=>{if(e._tag===`Err`)return e;let n=t(e.value);return r(n)?Promise.resolve(n).then(()=>e):e}),m=n(2,(e,t)=>e._tag===`Ok`?e:t(e.error)),h=n(3,(e,t,n)=>e._tag===`Err`||t(e.value)?e:s(n(e.value))),g=e=>{if(Array.isArray(e)){let t=[];for(let n of e){if(n._tag===`Err`)return n;t.push(n.value)}return o(t)}let t={};for(let[n,r]of Object.entries(e)){let e=r;if(e._tag===`Err`)return r;t[n]=e.value}return o(t)},_=n(2,(e,t)=>e._tag===`Ok`?e.value:t),v=n(2,(e,t)=>e._tag===`Ok`?e.value:t(e.error)),y=n(2,(e,t)=>e._tag===`Ok`?t.Ok(e.value):t.Err(e.error)),b=e=>{let t=typeof e==`function`?e:e.try,n=typeof e==`function`?e=>e instanceof Error?e:Error(String(e)):e.catch,i=typeof e==`function`?void 0:e.finally,a=!1;try{let e=t();if(r(e)){a=!0;let t=Promise.resolve(e).then(o).catch(e=>s(n(e)));return i?t.finally(i):t}return o(e)}catch(e){return s(n(e))}finally{i&&!a&&i()}},x=b;export{a as i,b as n,o as r,s as t};
-//# sourceMappingURL=result-BEzV0DYC.mjs.map
+import{t as e}from"./chunk-oQKkju2G.mjs";import{t}from"./fx.types-DyQVgTS8.mjs";import{t as n}from"./dual-fN6OUwN_.mjs";import{n as r}from"./flow-CNyLsPGb.mjs";import{t as i}from"./pipeable-Dp1_23zH.mjs";var a=e({all:()=>g,err:()=>s,filter:()=>h,flatMap:()=>f,fromTry:()=>b,isErr:()=>l,isOk:()=>c,map:()=>u,mapErr:()=>d,match:()=>y,ok:()=>o,orElse:()=>m,tap:()=>p,try:()=>x,unwrapOr:()=>_,unwrapOrElse:()=>v});const o=e=>({_tag:`Ok`,value:e,pipe:i,[t]:{_A:()=>e,_E:()=>void 0,_R:()=>void 0},*[Symbol.iterator](){return e}}),s=e=>{let n={_tag:`Err`,error:e,pipe:i,[t]:{_A:()=>void 0,_E:()=>e,_R:()=>void 0},*[Symbol.iterator](){throw yield n,Error(`Unreachable: Fx.gen should short-circuit on error`)}};return n},c=e=>e._tag===`Ok`,l=e=>e._tag===`Err`,u=n(2,(e,t)=>{if(e._tag===`Err`)return e;let n=t(e.value);return r(n)?Promise.resolve(n).then(o):o(n)}),d=n(2,(e,t)=>{if(e._tag===`Ok`)return e;let n=t(e.error);return r(n)?Promise.resolve(n).then(s):s(n)}),f=n(2,(e,t)=>e._tag===`Ok`?t(e.value):e),p=n(2,(e,t)=>{if(e._tag===`Err`)return e;let n=t(e.value);return r(n)?Promise.resolve(n).then(()=>e):e}),m=n(2,(e,t)=>e._tag===`Ok`?e:t(e.error)),h=n(3,(e,t,n)=>e._tag===`Err`||t(e.value)?e:s(n(e.value))),g=e=>{if(Array.isArray(e)){let t=[];for(let n of e){if(n._tag===`Err`)return n;t.push(n.value)}return o(t)}let t={};for(let[n,r]of Object.entries(e)){let e=r;if(e._tag===`Err`)return r;t[n]=e.value}return o(t)},_=n(2,(e,t)=>e._tag===`Ok`?e.value:t),v=n(2,(e,t)=>e._tag===`Ok`?e.value:t(e.error)),y=n(2,(e,t)=>e._tag===`Ok`?t.Ok(e.value):t.Err(e.error)),b=e=>{let t=typeof e==`function`?e:e.try,n=typeof e==`function`?e=>e instanceof Error?e:Error(String(e)):e.catch,i=typeof e==`function`?void 0:e.finally,a=!1;try{let e=t();if(r(e)){a=!0;let t=Promise.resolve(e).then(o).catch(e=>s(n(e)));return i?t.finally(i):t}return o(e)}catch(e){return s(n(e))}finally{i&&!a&&i()}},x=b;export{a,o as i,b as n,l as r,s as t};
+//# sourceMappingURL=result-D3VY0qBG.mjs.map

package/dist/result-D3VY0qBG.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"result-D3VY0qBG.mjs","names":["values"],"sources":["../src/result/result.ts"],"sourcesContent":["/**\n * Synchronous success/error primitives with typed channels (`Ok` / `Err`).\n *\n * **Mental model**\n * - `Result<A, E>` makes success and failure explicit.\n * - Use `flatMap` to sequence fallible operations without throwing.\n *\n * **Common tasks**\n * - Construct with `Result.ok`, `Result.err`, `Result.fromTry`.\n * - Transform with `Result.map`, `Result.mapErr`, `Result.flatMap`.\n * - Handle with `Result.match` or `Result.unwrapOr`.\n *\n * **Gotchas**\n * - `Result.err` short-circuits in `Fx.gen`.\n * - Keep domain errors in the `E` channel instead of throwing.\n *\n * **Quickstart**\n *\n * @example\n * ```ts\n * import { Result } from \"@nicolastoulemont/std\"\n *\n * const parsed = Result.fromTry(() => Number.parseInt(\"42\", 10))\n * const doubled = Result.map(parsed, (value) => value * 2)\n * ```\n *\n * @module\n */\nimport { FxTypeId } from \"../fx/fx.types\"\nimport { dual } from \"../shared/dual\"\nimport { isPromise } from \"../shared/is-promise\"\nimport { pipeable } from \"../shared/pipeable\"\nimport type {\n  FromTryOptions,\n  Result as ResultType,\n  ResultAll,\n  ResultFlatMap,\n  ResultFromTry,\n  ResultMap,\n  ResultMapErr,\n  ResultMatch,\n  ResultTap,\n  ResultOrElse,\n  ResultFilter,\n  ResultUnwrapOr,\n  ResultUnwrapOrElse,\n} from \"./result.types\"\n\n/**\n * Re-exported `Result` type.\n *\n * @example\n * ```ts\n * import type { Result } from \"@nicolastoulemont/std\"\n *\n * type Example = Result.Result<unknown, unknown>\n * ```\n */\nexport type Result<T, E> = ResultType<T, E>\n\n/* oxlint-disable no-unsafe-type-assertion -- Result constructors encode Fx phantom channels and iterator contracts via type-level markers. */\n\n// ============================================================================\n// Constructors\n// ============================================================================\n\n/**\n * Create a successful Result.\n *\n * @param value - The success value\n * @returns A Result with _tag: \"Ok\"\n *\n * @example\n * ```ts\n * import { Result } from \"@nicolastoulemont/std\"\n *\n * const value = Result.ok(42)\n * // => { _tag: \"Ok\", value: 42 }\n * ```\n */\nexport const ok = <T>(value: T): ResultType<T, never> => {\n  const result: ResultType<T, never> = {\n    _tag: \"Ok\",\n    value,\n    pipe: pipeable,\n    [FxTypeId]: {\n      _A: () => value,\n      _E: () => undefined as never,\n      _R: () => undefined as never,\n    },\n    // oxlint-disable-next-line require-yield\n    *[Symbol.iterator](): Generator<ResultType<T, never>, T, unknown> {\n      return value\n    },\n  }\n  return result\n}\n\n/**\n * Create an error Result.\n *\n * @param error - The error value\n * @returns A Result with _tag: \"Err\"\n *\n * @example\n * ```ts\n * import { Result } from \"@nicolastoulemont/std\"\n *\n * const value = Result.err(\"boom\")\n * // => { _tag: \"Err\", error: \"boom\" }\n * ```\n */\nexport const err = <E>(error: E): ResultType<never, E> => {\n  const result: ResultType<never, E> = {\n    _tag: \"Err\",\n    error,\n    pipe: pipeable,\n    [FxTypeId]: {\n      _A: () => undefined as never,\n      _E: () => error,\n      _R: () => undefined as never,\n    },\n    *[Symbol.iterator](): Generator<ResultType<never, E>, never, unknown> {\n      yield result\n      throw new Error(\"Unreachable: Fx.gen should short-circuit on error\")\n    },\n  }\n  return result\n}\n\n// ============================================================================\n// Type Guards\n// ============================================================================\n\n/**\n * Check if a Result is successful.\n *\n * @param result - The Result to check\n * @returns true if the Result is Ok\n *\n * @example\n * ```ts\n * import { Result } from \"@nicolastoulemont/std\"\n *\n * const isOk = Result.isOk(Result.ok(1))\n * // => true\n * ```\n */\nexport const isOk = <T, E>(result: ResultType<T, E>): result is Extract<ResultType<T, E>, { _tag: \"Ok\" }> =>\n  result._tag === \"Ok\"\n\n/**\n * Check if a Result is an error.\n *\n * @param result - The Result to check\n * @returns true if the Result is an error\n *\n * @example\n * ```ts\n * import { Result } from \"@nicolastoulemont/std\"\n *\n * const isErr = Result.isErr(Result.err(\"boom\"))\n * // => true\n * ```\n */\nexport const isErr = <T, E>(result: ResultType<T, E>): result is Extract<ResultType<T, E>, { _tag: \"Err\" }> =>\n  result._tag === \"Err\"\n\n// ============================================================================\n// Transformations (curried for pipe)\n// ============================================================================\n\n/**\n * Transform the success value of a Result.\n * If the Result is an error, it passes through unchanged.\n *\n * Supports both data-first and data-last calling styles:\n * - Data-first: `map(result, fn)`\n * - Data-last: `pipe(result, map(fn))`\n *\n * Supports both sync and async callbacks:\n * - Sync fn: returns U\n * - Async fn: returns Promise<U>\n *\n * @param fn - Function that transforms the success value\n * @returns The mapped Result in data-first form, or a function that maps a Result in data-last form\n *\n * @example\n * ```ts\n * import { Result } from \"@nicolastoulemont/std\"\n *\n * const input = Result.ok(2)\n * const dataFirst = Result.map(input, (n) => n + 1)\n * // => { _tag: \"Ok\", value: 3 }\n *\n * const dataLast = Result.map((n: number) => n + 1)(input)\n * // => { _tag: \"Ok\", value: 3 }\n * ```\n */\n/* oxlint-disable no-explicit-any, no-unsafe-return, no-unsafe-type-assertion -- Required for overloaded return types in curried functions */\nexport const map: ResultMap = dual(2, (result: ResultType<unknown, unknown>, fn: (value: unknown) => unknown) => {\n  if (result._tag === \"Err\") return result as any\n  const mapped = fn(result.value)\n  if (isPromise(mapped)) {\n    return Promise.resolve(mapped).then(ok) as any\n  }\n  return ok(mapped) as any\n})\n/* oxlint-enable no-explicit-any, no-unsafe-return, no-unsafe-type-assertion */\n\n/**\n * Transform the error value of a Result.\n * If the Result is successful, it passes through unchanged.\n *\n * Supports both data-first and data-last calling styles:\n * - Data-first: `mapErr(result, fn)`\n * - Data-last: `pipe(result, mapErr(fn))`\n *\n * Supports both sync and async callbacks:\n * - Sync fn: returns F\n * - Async fn: returns Promise<F>\n *\n * @param fn - Function that transforms the error value\n * @returns The mapped Result in data-first form, or a function that maps Result errors in data-last form\n *\n * @example\n * ```ts\n * import { Result } from \"@nicolastoulemont/std\"\n *\n * const input = Result.err(\"missing\")\n * const dataFirst = Result.mapErr(input, (msg) => msg.toUpperCase())\n * // => { _tag: \"Err\", error: \"MISSING\" }\n *\n * const dataLast = Result.mapErr((msg: string) => msg.toUpperCase())(input)\n * // => { _tag: \"Err\", error: \"MISSING\" }\n * ```\n */\n/* oxlint-disable no-explicit-any, no-unsafe-return, no-unsafe-type-assertion -- Required for overloaded return types in curried functions */\nexport const mapErr: ResultMapErr = dual(2, (result: ResultType<unknown, unknown>, fn: (error: unknown) => unknown) => {\n  if (result._tag === \"Ok\") return result as any\n  const mapped = fn(result.error)\n  if (isPromise(mapped)) {\n    return Promise.resolve(mapped).then(err) as any\n  }\n  return err(mapped) as any\n})\n/* oxlint-enable no-explicit-any, no-unsafe-return, no-unsafe-type-assertion */\n\n/**\n * Chain operations that return Results.\n * If the Result is an error, it passes through unchanged.\n *\n * Supports both data-first and data-last calling styles:\n * - Data-first: `flatMap(result, fn)`\n * - Data-last: `pipe(result, flatMap(fn))`\n *\n * Supports both sync and async functions:\n * - Sync fn: returns Result<U, E | E2>\n * - Async fn: returns Promise<Result<U, E | E2>>\n *\n * @param fn - Function that takes a value and returns a Result (or Promise<Result>)\n * @returns The resulting Result in data-first form, or a function that flatMaps a Result in data-last form\n *\n * @example\n * ```ts\n * import { Result } from \"@nicolastoulemont/std\"\n *\n * const input = Result.ok(2)\n * const dataFirst = Result.flatMap(input, (n) => Result.ok(n + 1))\n * // => { _tag: \"Ok\", value: 3 }\n *\n * const dataLast = Result.flatMap((n: number) => Result.ok(n + 1))(input)\n * // => { _tag: \"Ok\", value: 3 }\n * ```\n */\n// oxlint-disable-next-line no-explicit-any, no-unsafe-return, no-unsafe-type-assertion -- Required for overloaded return types\nexport const flatMap: ResultFlatMap = dual(2, (result: ResultType<unknown, unknown>, fn: (value: unknown) => unknown) =>\n  result._tag === \"Ok\" ? fn(result.value) : result,\n)\n\n/**\n * Perform a side effect on the success value without modifying the Result.\n * Useful for debugging, logging, or other side effects in a pipeline.\n * If the Result is an error, the function is not called.\n *\n * Supports both data-first and data-last calling styles:\n * - Data-first: `tap(result, fn)`\n * - Data-last: `pipe(result, tap(fn))`\n *\n * Supports both sync and async side effects:\n * - Sync fn: returns any value (ignored)\n * - Async fn: returns Promise<unknown>\n *\n * @param fn - Function to call with the success value (return value is ignored)\n * @returns The original Result in data-first form, or a function that taps a Result in data-last form\n *\n * @example\n * ```ts\n * import { Result } from \"@nicolastoulemont/std\"\n *\n * let seen = 0\n * const input = Result.ok(2)\n * const dataFirst = Result.tap(input, (n) => {\n *   seen = n\n * })\n * // => { _tag: \"Ok\", value: 2 }\n *\n * const dataLast = Result.tap((n: number) => {\n *   seen = n\n * })(input)\n * // => { _tag: \"Ok\", value: 2 }\n * ```\n */\n/* oxlint-disable no-explicit-any, no-unsafe-return, no-unsafe-type-assertion -- Required for overloaded return types in curried functions */\nexport const tap: ResultTap = dual(2, (result: ResultType<unknown, unknown>, fn: (value: unknown) => unknown) => {\n  if (result._tag === \"Err\") return result as any\n  const sideEffect = fn(result.value)\n  if (isPromise(sideEffect)) {\n    return Promise.resolve(sideEffect).then(() => result) as any\n  }\n  return result as any\n})\n/* oxlint-enable no-explicit-any, no-unsafe-return, no-unsafe-type-assertion */\n\n/**\n * Recover from an error by providing an alternative Result.\n * If the Result is successful, it passes through unchanged.\n *\n * Supports both data-first and data-last calling styles:\n * - Data-first: `orElse(result, fn)`\n * - Data-last: `pipe(result, orElse(fn))`\n *\n * Supports both sync and async fallback functions:\n * - Sync fn: returns Result<T | U, E2>\n * - Async fn: returns Promise<Result<T | U, E2>>\n *\n * @param fn - Function that takes the error and returns an alternative Result\n * @returns The original or fallback Result in data-first form, or a function that recovers from an error in data-last form\n *\n * @example\n * ```ts\n * import { Result } from \"@nicolastoulemont/std\"\n *\n * const input = Result.err(\"missing\") as Result.Result<number, string>\n * const dataFirst = Result.orElse(input, () => Result.ok(0))\n * // => { _tag: \"Ok\", value: 0 }\n *\n * const dataLast = Result.orElse(() => Result.ok(0))(input)\n * // => { _tag: \"Ok\", value: 0 }\n * ```\n */\n// oxlint-disable-next-line no-explicit-any, no-unsafe-return, no-unsafe-type-assertion -- Required for overloaded return types\nexport const orElse: ResultOrElse = dual(2, (result: ResultType<unknown, unknown>, fn: (error: unknown) => unknown) =>\n  result._tag === \"Ok\" ? result : fn(result.error),\n)\n\n/**\n * Filter a successful Result based on a predicate.\n * If the predicate returns false, converts the success to an error.\n * If the Result is already an error, it passes through unchanged.\n *\n * Supports both data-first and data-last calling styles:\n * - Data-first: `filter(result, predicate, onFail)`\n * - Data-last: `pipe(result, filter(predicate, onFail))`\n *\n * @param predicate - Function that returns true to keep the value\n * @param onFail - Function that creates the error when predicate fails\n * @returns The filtered Result in data-first form, or a function that filters a Result in data-last form\n *\n * @example\n * ```ts\n * import { Result } from \"@nicolastoulemont/std\"\n *\n * const input = Result.ok(3)\n * const dataFirst = Result.filter(input, (n) => n > 0, (n) => `${n} must be positive`)\n * // => { _tag: \"Ok\", value: 3 }\n *\n * const dataLast = Result.filter((n: number) => n > 0, (n) => `${n} must be positive`)(input)\n * // => { _tag: \"Ok\", value: 3 }\n * ```\n */\nexport const filter: ResultFilter = dual(\n  3,\n  (\n    result: ResultType<unknown, unknown>,\n    predicate: (value: unknown) => boolean,\n    onFail: (value: unknown) => unknown,\n  ) => {\n    if (result._tag === \"Err\") return result\n    return predicate(result.value) ? result : err(onFail(result.value))\n  },\n)\n\n// ============================================================================\n// Combinators\n// ============================================================================\n\n/**\n * Combine multiple Results into a single Result.\n * Supports both array and object inputs.\n *\n * - If all Results are ok, returns ok with all values\n * - If any Result is an error, returns the first error (short-circuits)\n *\n * For arrays of 1-6 elements, tuple types are inferred automatically.\n * For longer arrays, use `as const` to preserve tuple structure.\n *\n * @example\n * ```ts\n * import { Result } from \"@nicolastoulemont/std\"\n *\n * const combined = Result.all([Result.ok(1), Result.ok(2)] as const)\n * // => { _tag: \"Ok\", value: [1, 2] }\n * ```\n */\n/* oxlint-disable no-explicit-any, no-unsafe-return, no-unsafe-member-access, strict-boolean-expressions, no-unsafe-type-assertion, no-unsafe-argument -- Required for handling union types in overloaded function */\nexport const all: ResultAll = (results: any): any => {\n  if (Array.isArray(results)) {\n    const values: unknown[] = []\n    for (const result of results) {\n      if (result._tag === \"Err\") return result\n      values.push(result.value)\n    }\n    return ok(values)\n  }\n\n  const values: Record<string, unknown> = {}\n  for (const [key, result] of Object.entries(results)) {\n    const r = result as ResultType<unknown, unknown>\n    if (r._tag === \"Err\") return result\n    values[key] = r.value\n  }\n  return ok(values)\n}\n/* oxlint-enable no-explicit-any, no-unsafe-return, no-unsafe-member-access, strict-boolean-expressions, no-unsafe-type-assertion, no-unsafe-argument */\n\n// ============================================================================\n// Extraction\n// ============================================================================\n\n/**\n * Get the success value or a default value.\n *\n * Supports both data-first and data-last calling styles:\n * - Data-first: `unwrapOr(result, defaultValue)`\n * - Data-last: `pipe(result, unwrapOr(defaultValue))`\n *\n * Uses NoInfer to prevent type inference from the default value.\n *\n * @param defaultValue - Value to return if the Result is an error\n * @returns The unwrapped value in data-first form, or a function that unwraps a Result with a default in data-last form\n *\n * @example\n * ```ts\n * import { Result } from \"@nicolastoulemont/std\"\n *\n * const input = Result.err(\"missing\") as Result.Result<number, string>\n * const dataFirst = Result.unwrapOr(input, 0)\n * // => 0\n *\n * const dataLast = Result.unwrapOr(0)(input)\n * // => 0\n * ```\n */\nexport const unwrapOr: ResultUnwrapOr = dual(\n  2,\n  <T, E>(result: ResultType<T, E>, defaultValue: NoInfer<T>): T => (result._tag === \"Ok\" ? result.value : defaultValue),\n)\n\n/**\n * Get the success value or compute a value from the error.\n *\n * Supports both data-first and data-last calling styles:\n * - Data-first: `unwrapOrElse(result, fn)`\n * - Data-last: `pipe(result, unwrapOrElse(fn))`\n *\n * @param fn - Function to compute a value from the error\n * @returns The unwrapped value in data-first form, or a function that unwraps a Result lazily in data-last form\n *\n * @example\n * ```ts\n * import { Result } from \"@nicolastoulemont/std\"\n *\n * const input = Result.err(\"missing\") as Result.Result<number, string>\n * const dataFirst = Result.unwrapOrElse(input, () => 0)\n * // => 0\n *\n * const dataLast = Result.unwrapOrElse(() => 0)(input)\n * // => 0\n * ```\n */\nexport const unwrapOrElse: ResultUnwrapOrElse = dual(\n  2,\n  <T, E>(result: ResultType<T, E>, fn: (error: E) => T): T => (result._tag === \"Ok\" ? result.value : fn(result.error)),\n)\n\n/**\n * Pattern match on a Result, handling both success and error cases.\n *\n * Supports both data-first and data-last calling styles:\n * - Data-first: `match(result, { Ok: ..., Err: ... })`\n * - Data-last: `pipe(result, match({ Ok: ..., Err: ... }))`\n *\n * @param handlers - Object with `Ok` and `Err` handlers\n * @returns The handler result in data-first form, or a function that matches a Result in data-last form\n *\n * @example\n * ```ts\n * import { Result } from \"@nicolastoulemont/std\"\n *\n * const input = Result.ok(2) as Result.Result<number, string>\n * const dataFirst = Result.match(input, {\n *   Ok: (value) => `ok:${value}` ,\n *   Err: (error) => `err:${error}` ,\n * })\n * // => \"ok:2\"\n *\n * const dataLast = Result.match({\n *   Ok: (value: number) => `ok:${value}` ,\n *   Err: (error: string) => `err:${error}` ,\n * })(input)\n * // => \"ok:2\"\n * ```\n */\nexport const match: ResultMatch = dual(\n  2,\n  <T, E, U>(result: ResultType<T, E>, handlers: { Ok: (value: T) => U; Err: (error: E) => U }): U =>\n    result._tag === \"Ok\" ? handlers.Ok(result.value) : handlers.Err(result.error),\n)\n\n// ============================================================================\n// Error Boundary\n// ============================================================================\n\n/**\n * Wrap a function that might throw into a Result.\n * Supports both sync and async functions with automatic type inference.\n *\n * Can be called with a simple callback or an object with `try` and `catch`:\n * - Simple: `fromTry(() => riskyOp())` — errors are wrapped as `Error`\n * - Object: `fromTry({ try: () => riskyOp(), catch: (e) => mapError(e) })` — custom error mapping\n *\n * @param fnOrOptions - Function that might throw, or object with `try` and `catch`\n * @returns A Result with the return value or the caught/mapped error\n *\n * @example\n * ```ts\n * import { Result } from \"@nicolastoulemont/std\"\n *\n * const parsed = Result.fromTry(() => Number.parseInt(\"42\", 10))\n * // => { _tag: \"Ok\", value: 42 }\n * ```\n */\n/* oxlint-disable no-explicit-any, no-unsafe-type-assertion -- Required for overloaded return type */\nexport const fromTry: ResultFromTry = (fnOrOptions: (() => unknown) | FromTryOptions<unknown, unknown>): any => {\n  const fn = typeof fnOrOptions === \"function\" ? fnOrOptions : fnOrOptions.try\n  const catchFn =\n    typeof fnOrOptions === \"function\"\n      ? (e: unknown) => (e instanceof Error ? e : new Error(String(e)))\n      : fnOrOptions.catch\n  const finallyFn = typeof fnOrOptions === \"function\" ? undefined : fnOrOptions.finally\n\n  let isAsync = false\n  try {\n    const result = fn()\n    if (isPromise(result)) {\n      isAsync = true\n      const promise = Promise.resolve(result)\n        .then(ok)\n        .catch((e: unknown) => err(catchFn(e)))\n      return finallyFn ? promise.finally(finallyFn) : promise\n    }\n    return ok(result)\n  } catch (e) {\n    return err(catchFn(e))\n  } finally {\n    if (finallyFn && !isAsync) {\n      finallyFn()\n    }\n  }\n}\n/* oxlint-enable no-explicit-any, no-unsafe-type-assertion */\n\nconst try_ = fromTry\n\nexport {\n  /**\n   * Alias of {@link fromTry}.\n   *\n   * @example\n   * ```ts\n   * import { Result } from \"@nicolastoulemont/std\"\n   *\n   * const parsed = Result.try(() => JSON.parse(\"{\\\"ok\\\":true}\"))\n   * ```\n   *\n   */\n  try_ as try,\n}\n\n/* oxlint-enable no-unsafe-type-assertion */\n"],"mappings":"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"}

package/dist/{result.types-_xDAei3-.d.mts → result.types-BKzChyWY.d.mts}

@@ -1,5 +1,5 @@
-import { i as Fx } from "./fx.types-DeEWEltG.mjs";
-import { t as Pipeable } from "./pipeable-rfqacPxZ.mjs";
+import { i as Fx } from "./fx.types-BdN1EWxr.mjs";
+import { t as Pipeable } from "./pipeable-BIrevC0D.mjs";
 
 //#region src/shared/type-utils.types.d.ts
 
@@ -178,4 +178,4 @@ type ResultMatch = {
 };
 //#endregion
 export { ResultFromTry as a, ResultMatch as c, ResultUnwrapOr as d, ResultUnwrapOrElse as f, Prettify as h, ResultFlatMap as i, ResultOrElse as l, Ok as m, ResultAll as n, ResultMap as o, Err as p, ResultFilter as r, ResultMapErr as s, Result as t, ResultTap as u };
-//# sourceMappingURL=result.types-_xDAei3-.d.mts.map
+//# sourceMappingURL=result.types-BKzChyWY.d.mts.map

package/dist/{result.types-_xDAei3-.d.mts.map → result.types-BKzChyWY.d.mts.map}

@@ -1 +1 @@
-{"version":3,"file":"result.types-_xDAei3-.d.mts","names":[],"sources":["../src/shared/type-utils.types.ts","../src/result/result.types.ts"],"sourcesContent":[],"mappings":"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"}
+{"version":3,"file":"result.types-BKzChyWY.d.mts","names":[],"sources":["../src/shared/type-utils.types.ts","../src/result/result.types.ts"],"sourcesContent":[],"mappings":"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"}

package/dist/schedule/index.d.mts

@@ -1,2 +1,2 @@
-import { r as schedule_d_exports } from "../schedule-DlX2Dg69.mjs";
+import { r as schedule_d_exports } from "../schedule-B9K_2Z21.mjs";
 export { schedule_d_exports as Schedule };

package/dist/schedule/index.mjs

@@ -1 +1 @@
-import{t as e}from"../schedule-C6tjcJ1O.mjs";export{e as Schedule};
+import{t as e}from"../schedule-C6iN3oMt.mjs";export{e as Schedule};