@nicolastoulemont/std 0.7.1 → 0.8.0

package/dist/provide-C2cWOx2B.mjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"provide-C2cWOx2B.mjs","names":["layer","service","makeScope","layer","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 { Provide } from \"@nicolastoulemont/std\"\n *\n * import { Fx, Layer, 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 * // => Fx with Port dependency resolved\n * ```\n *\n * @category Utilities\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    // Determine if the layer or fx is async\n    const memoMap = new MemoMap()\n    const scope = makeScope()\n    const layerBuildFx = layer.build(memoMap, scope)\n\n    if (layerBuildFx._tag === \"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          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        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 { Provide } from \"@nicolastoulemont/std\"\n *\n * import { Context, Fx, 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 * // => Fx runnable without Port requirement\n * ```\n *\n * @category Utilities\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 { Provide } from \"@nicolastoulemont/std\"\n *\n * import { Fx, 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 * // => Fx runnable without Port requirement\n * ```\n *\n * @category Utilities\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-Sg6KJerl.mjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"queue-Sg6KJerl.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 *\n * @category Models\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 *\n * @category Models\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 *\n * @category Models\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 *\n * @category Guards\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 *\n * @category Constructors\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 *\n * @category Constructors\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 *\n * @category Constructors\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/result-BEzV0DYC.mjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"result-BEzV0DYC.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 { pipeMethod } 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 *\n * @category Re-exports\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 *\n * @category Constructors\n */\nexport const ok = <T>(value: T): ResultType<T, never> => {\n  const result: ResultType<T, never> = {\n    _tag: \"Ok\",\n    value,\n    pipe: pipeMethod,\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 *\n * @category Constructors\n */\nexport const err = <E>(error: E): ResultType<never, E> => {\n  const result: ResultType<never, E> = {\n    _tag: \"Err\",\n    error,\n    pipe: pipeMethod,\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 *\n * @category Guards\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 *\n * @category Guards\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 functions:\n * - Sync fn: returns Result<U, E>\n * - Async fn: returns Promise<Result<U, E>>\n *\n * @param fn - Function to transform the success value\n * @returns A function that takes a Result and returns a new Result\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 * @category Mapping\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 functions:\n * - Sync fn: returns Result<T, F>\n * - Async fn: returns Promise<Result<T, F>>\n *\n * @param fn - Function to transform the error value\n * @returns A function that takes a Result and returns a new Result\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 * @category Mapping\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 A function that takes a Result and returns a new Result\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 * @category Sequencing\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 functions:\n * - Sync fn: returns Result<T, E>\n * - Async fn: returns Promise<Result<T, E>>\n *\n * @param fn - Function to call with the success value (return value is ignored)\n * @returns A function that takes a Result and returns the same Result\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 * @category Sequencing\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 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 A function that takes a Result and returns a new Result\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 * @category Error Handling\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 A function that takes a Result and returns a new Result\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 *\n * @category Filtering\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 * @category Combining\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 A function that takes a Result and returns the value or default\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 *\n * @category Getters\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 A function that takes a Result and returns the value or computed value\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 *\n * @category Getters\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 A function that takes a Result and returns the handler result\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 *\n * @category Pattern Matching\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 * @category Constructors\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   * @category Constructors\n   */\n  try_ as try,\n}\n\n/* oxlint-enable no-unsafe-type-assertion */\n"],"mappings":"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"}

package/dist/schedule-C6tjcJ1O.mjs

@@ -1,2 +0,0 @@
-import{t as e}from"./chunk-C934ptG5.mjs";var t=e({exponential:()=>l,fixed:()=>c,recurs:()=>s});const n=e=>{if(!Number.isInteger(e)||e<0)throw RangeError(`Schedule retry count must be an integer >= 0, received: ${String(e)}`)},r=(e,t)=>{if(!Number.isFinite(t)||t<0)throw RangeError(`Schedule ${e} must be a finite number >= 0, received: ${String(t)}`)},i=(e,t)=>{if(!Number.isFinite(t)||t<=0)throw RangeError(`Schedule ${e} must be a finite number > 0, received: ${String(t)}`)},a=(e,t)=>({_tag:`RetrySchedule`,_sync:!0,maxRetries:e,delayForAttempt:t}),o=(e,t)=>({_tag:`RetrySchedule`,_sync:!1,maxRetries:e,delayForAttempt:t}),s=e=>(n(e),a(e,()=>0)),c=e=>(n(e.times),r(`delayMs`,e.delayMs),o(e.times,()=>e.delayMs)),l=e=>{n(e.times),r(`baseDelayMs`,e.baseDelayMs);let t=e.factor??2;return i(`factor`,t),e.maxDelayMs!==void 0&&r(`maxDelayMs`,e.maxDelayMs),o(e.times,n=>{let r=e.baseDelayMs*t**(n-1);return e.maxDelayMs===void 0?r:Math.min(r,e.maxDelayMs)})};export{t};
-//# sourceMappingURL=schedule-C6tjcJ1O.mjs.map

package/dist/schedule-C6tjcJ1O.mjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"schedule-C6tjcJ1O.mjs","names":[],"sources":["../src/schedule/schedule.ts"],"sourcesContent":["/**\n * Retry schedule constructors used by `Fx.retry`.\n *\n * **Mental model**\n * - A schedule defines retry count and per-attempt delay.\n * - Sync schedules have no async delay requirements.\n *\n * **Common tasks**\n * - Use `Schedule.recurs` for immediate retries.\n * - Use `Schedule.fixed` for constant-delay retries.\n * - Use `Schedule.exponential` for backoff.\n *\n * **Gotchas**\n * - `times` is the number of retries after the first attempt.\n * - Delay values must be finite and non-negative.\n *\n * **Quickstart**\n *\n * @example\n * ```ts\n * import { Schedule } from \"@nicolastoulemont/std\"\n *\n * const schedule = Schedule.recurs(2)\n * const delay = schedule.delayForAttempt(1)\n * // => 0\n * ```\n *\n * @module\n */\n/**\n * Retry schedule used by Fx.retry.\n *\n * A schedule defines:\n * - how many retries are allowed after the first attempt\n * - how long to wait before each retry attempt\n *\n * @example\n * ```ts\n * import { Schedule } from \"@nicolastoulemont/std\"\n *\n * type Example = typeof Schedule\n * ```\n *\n * @category Models\n */\nexport type RetrySchedule = SyncRetrySchedule | AsyncRetrySchedule\n\n/**\n * Schedule that never introduces async delays.\n *\n * @example\n * ```ts\n * import { Schedule } from \"@nicolastoulemont/std\"\n *\n * type Example = typeof Schedule\n * ```\n *\n * @category Models\n */\nexport type SyncRetrySchedule = {\n  readonly _tag: \"RetrySchedule\"\n  readonly _sync: true\n  readonly maxRetries: number\n  readonly delayForAttempt: (retryAttempt: number) => number\n}\n\n/**\n * Schedule that may delay retries, requiring async execution.\n *\n * @example\n * ```ts\n * import { Schedule } from \"@nicolastoulemont/std\"\n *\n * type Example = typeof Schedule\n * ```\n *\n * @category Models\n */\nexport type AsyncRetrySchedule = {\n  readonly _tag: \"RetrySchedule\"\n  readonly _sync: false\n  readonly maxRetries: number\n  readonly delayForAttempt: (retryAttempt: number) => number\n}\n\ntype FixedScheduleOptions = {\n  readonly times: number\n  readonly delayMs: number\n}\n\ntype ExponentialScheduleOptions = {\n  readonly times: number\n  readonly baseDelayMs: number\n  readonly factor?: number | undefined\n  readonly maxDelayMs?: number | undefined\n}\n\nconst validateRetryCount = (times: number) => {\n  if (!Number.isInteger(times) || times < 0) {\n    throw new RangeError(`Schedule retry count must be an integer >= 0, received: ${String(times)}`)\n  }\n}\n\nconst validateNonNegativeFinite = (name: string, value: number) => {\n  if (!Number.isFinite(value) || value < 0) {\n    throw new RangeError(`Schedule ${name} must be a finite number >= 0, received: ${String(value)}`)\n  }\n}\n\nconst validatePositiveFinite = (name: string, value: number) => {\n  if (!Number.isFinite(value) || value <= 0) {\n    throw new RangeError(`Schedule ${name} must be a finite number > 0, received: ${String(value)}`)\n  }\n}\n\nconst makeSyncSchedule = (\n  maxRetries: number,\n  delayForAttempt: (retryAttempt: number) => number,\n): SyncRetrySchedule => ({\n  _tag: \"RetrySchedule\",\n  _sync: true,\n  maxRetries,\n  delayForAttempt,\n})\n\nconst makeAsyncSchedule = (\n  maxRetries: number,\n  delayForAttempt: (retryAttempt: number) => number,\n): AsyncRetrySchedule => ({\n  _tag: \"RetrySchedule\",\n  _sync: false,\n  maxRetries,\n  delayForAttempt,\n})\n\n/**\n * Retry immediately up to `times` times.\n *\n * @example\n * ```ts\n * import { Schedule } from \"@nicolastoulemont/std\"\n *\n * const schedule = Schedule.recurs(2)\n * const delay = schedule.delayForAttempt(1)\n * // => 0\n * ```\n *\n * @category Constructors\n */\nexport const recurs = (times: number): SyncRetrySchedule => {\n  validateRetryCount(times)\n  return makeSyncSchedule(times, () => 0)\n}\n\n/**\n * Retry with a fixed delay between attempts.\n *\n * @example\n * ```ts\n * import { Schedule } from \"@nicolastoulemont/std\"\n *\n * const schedule = Schedule.fixed({ times: 2, delayMs: 100 })\n * const delay = schedule.delayForAttempt(2)\n * // => 100\n * ```\n *\n * @category Constructors\n */\nexport const fixed = (options: FixedScheduleOptions): AsyncRetrySchedule => {\n  validateRetryCount(options.times)\n  validateNonNegativeFinite(\"delayMs\", options.delayMs)\n\n  return makeAsyncSchedule(options.times, () => options.delayMs)\n}\n\n/**\n * Retry with exponential backoff:\n * `baseDelayMs * factor^(retryAttempt - 1)`, optionally capped by `maxDelayMs`.\n *\n * @example\n * ```ts\n * import { Schedule } from \"@nicolastoulemont/std\"\n *\n * const schedule = Schedule.exponential({ times: 3, baseDelayMs: 100 })\n * const delay = schedule.delayForAttempt(3)\n * // => 400\n * ```\n *\n * @category Constructors\n */\nexport const exponential = (options: ExponentialScheduleOptions): AsyncRetrySchedule => {\n  validateRetryCount(options.times)\n  validateNonNegativeFinite(\"baseDelayMs\", options.baseDelayMs)\n\n  const factor = options.factor ?? 2\n  validatePositiveFinite(\"factor\", factor)\n\n  if (options.maxDelayMs !== undefined) {\n    validateNonNegativeFinite(\"maxDelayMs\", options.maxDelayMs)\n  }\n\n  return makeAsyncSchedule(options.times, (retryAttempt) => {\n    const delay = options.baseDelayMs * Math.pow(factor, retryAttempt - 1)\n    return options.maxDelayMs === undefined ? delay : Math.min(delay, options.maxDelayMs)\n  })\n}\n"],"mappings":"+FAiGA,MAAM,EAAsB,GAAkB,CAC5C,GAAI,CAAC,OAAO,UAAU,EAAM,EAAI,EAAQ,EACtC,MAAU,WAAW,2DAA2D,OAAO,EAAM,GAAG,EAI9F,GAA6B,EAAc,IAAkB,CACjE,GAAI,CAAC,OAAO,SAAS,EAAM,EAAI,EAAQ,EACrC,MAAU,WAAW,YAAY,EAAK,2CAA2C,OAAO,EAAM,GAAG,EAI/F,GAA0B,EAAc,IAAkB,CAC9D,GAAI,CAAC,OAAO,SAAS,EAAM,EAAI,GAAS,EACtC,MAAU,WAAW,YAAY,EAAK,0CAA0C,OAAO,EAAM,GAAG,EAI9F,GACJ,EACA,KACuB,CACvB,KAAM,gBACN,MAAO,GACP,aACA,kBACD,EAEK,GACJ,EACA,KACwB,CACxB,KAAM,gBACN,MAAO,GACP,aACA,kBACD,EAgBY,EAAU,IACrB,EAAmB,EAAM,CAClB,EAAiB,MAAa,EAAE,EAiB5B,EAAS,IACpB,EAAmB,EAAQ,MAAM,CACjC,EAA0B,UAAW,EAAQ,QAAQ,CAE9C,EAAkB,EAAQ,UAAa,EAAQ,QAAQ,EAkBnD,EAAe,GAA4D,CACtF,EAAmB,EAAQ,MAAM,CACjC,EAA0B,cAAe,EAAQ,YAAY,CAE7D,IAAM,EAAS,EAAQ,QAAU,EAOjC,OANA,EAAuB,SAAU,EAAO,CAEpC,EAAQ,aAAe,IAAA,IACzB,EAA0B,aAAc,EAAQ,WAAW,CAGtD,EAAkB,EAAQ,MAAQ,GAAiB,CACxD,IAAM,EAAQ,EAAQ,YAAuB,IAAQ,EAAe,GACpE,OAAO,EAAQ,aAAe,IAAA,GAAY,EAAQ,KAAK,IAAI,EAAO,EAAQ,WAAW,EACrF"}

package/dist/schedule-DlX2Dg69.d.mts

@@ -1,144 +0,0 @@
-declare namespace schedule_d_exports {
-  export { AsyncRetrySchedule, RetrySchedule, SyncRetrySchedule, exponential, fixed, recurs };
-}
-/**
- * Retry schedule constructors used by `Fx.retry`.
- *
- * **Mental model**
- * - A schedule defines retry count and per-attempt delay.
- * - Sync schedules have no async delay requirements.
- *
- * **Common tasks**
- * - Use `Schedule.recurs` for immediate retries.
- * - Use `Schedule.fixed` for constant-delay retries.
- * - Use `Schedule.exponential` for backoff.
- *
- * **Gotchas**
- * - `times` is the number of retries after the first attempt.
- * - Delay values must be finite and non-negative.
- *
- * **Quickstart**
- *
- * @example
- * ```ts
- * import { Schedule } from "@nicolastoulemont/std"
- *
- * const schedule = Schedule.recurs(2)
- * const delay = schedule.delayForAttempt(1)
- * // => 0
- * ```
- *
- * @module
- */
-/**
- * Retry schedule used by Fx.retry.
- *
- * A schedule defines:
- * - how many retries are allowed after the first attempt
- * - how long to wait before each retry attempt
- *
- * @example
- * ```ts
- * import { Schedule } from "@nicolastoulemont/std"
- *
- * type Example = typeof Schedule
- * ```
- *
- * @category Models
- */
-type RetrySchedule = SyncRetrySchedule | AsyncRetrySchedule;
-/**
- * Schedule that never introduces async delays.
- *
- * @example
- * ```ts
- * import { Schedule } from "@nicolastoulemont/std"
- *
- * type Example = typeof Schedule
- * ```
- *
- * @category Models
- */
-type SyncRetrySchedule = {
-  readonly _tag: "RetrySchedule";
-  readonly _sync: true;
-  readonly maxRetries: number;
-  readonly delayForAttempt: (retryAttempt: number) => number;
-};
-/**
- * Schedule that may delay retries, requiring async execution.
- *
- * @example
- * ```ts
- * import { Schedule } from "@nicolastoulemont/std"
- *
- * type Example = typeof Schedule
- * ```
- *
- * @category Models
- */
-type AsyncRetrySchedule = {
-  readonly _tag: "RetrySchedule";
-  readonly _sync: false;
-  readonly maxRetries: number;
-  readonly delayForAttempt: (retryAttempt: number) => number;
-};
-type FixedScheduleOptions = {
-  readonly times: number;
-  readonly delayMs: number;
-};
-type ExponentialScheduleOptions = {
-  readonly times: number;
-  readonly baseDelayMs: number;
-  readonly factor?: number | undefined;
-  readonly maxDelayMs?: number | undefined;
-};
-/**
- * Retry immediately up to `times` times.
- *
- * @example
- * ```ts
- * import { Schedule } from "@nicolastoulemont/std"
- *
- * const schedule = Schedule.recurs(2)
- * const delay = schedule.delayForAttempt(1)
- * // => 0
- * ```
- *
- * @category Constructors
- */
-declare const recurs: (times: number) => SyncRetrySchedule;
-/**
- * Retry with a fixed delay between attempts.
- *
- * @example
- * ```ts
- * import { Schedule } from "@nicolastoulemont/std"
- *
- * const schedule = Schedule.fixed({ times: 2, delayMs: 100 })
- * const delay = schedule.delayForAttempt(2)
- * // => 100
- * ```
- *
- * @category Constructors
- */
-declare const fixed: (options: FixedScheduleOptions) => AsyncRetrySchedule;
-/**
- * Retry with exponential backoff:
- * `baseDelayMs * factor^(retryAttempt - 1)`, optionally capped by `maxDelayMs`.
- *
- * @example
- * ```ts
- * import { Schedule } from "@nicolastoulemont/std"
- *
- * const schedule = Schedule.exponential({ times: 3, baseDelayMs: 100 })
- * const delay = schedule.delayForAttempt(3)
- * // => 400
- * ```
- *
- * @category Constructors
- */
-declare const exponential: (options: ExponentialScheduleOptions) => AsyncRetrySchedule;
-//#endregion
-export { SyncRetrySchedule as n, schedule_d_exports as r, RetrySchedule as t };
-//# sourceMappingURL=schedule-DlX2Dg69.d.mts.map

package/dist/schedule-DlX2Dg69.d.mts.map

@@ -1 +0,0 @@
-{"version":3,"file":"schedule-DlX2Dg69.d.mts","names":[],"sources":["../src/schedule/schedule.ts"],"sourcesContent":[],"mappings":";;;;;;;;;;;;;;AA6CA;AAcA;AAmBA;AAKC;AAEwB;AAgEzB;AAmBA;AAsBA;;;;;;;;;;;;;;;;;;;;;;;;;;;KAjJY,aAAA,GAAgB,oBAAoB;;;;;;;;;;;;;KAcpC,iBAAA;;;;;;;;;;;;;;;;;;KAmBA,kBAAA;;;;;;KAOP,oBAAA;;;;KAKA,0BAAA;;;;;;;;;;;;;;;;;;;;cA2DQ,2BAA0B;;;;;;;;;;;;;;;cAmB1B,iBAAkB,yBAAuB;;;;;;;;;;;;;;;;cAsBzC,uBAAwB,+BAA6B"}

package/dist/scope-CZdp4wKX.d.mts.map

@@ -1 +0,0 @@
-{"version":3,"file":"scope-CZdp4wKX.d.mts","names":[],"sources":["../src/scope/scope.ts"],"sourcesContent":[],"mappings":";;;;;;;;;;;;;;;AAuDA;;;;;AAgByC,KAhB7B,YAAA,GAgB6B;EAAe;;;AA4BxD;AA8HA;;;EAA8B,YAAA,CAAA,SAAA,EAAA,GAAA,GAlKE,MAkKF,CAAA,IAAA,CAAA,GAlKiB,OAkKjB,CAAA,IAAA,CAAA,CAAA,EAlKiC,MAkKjC,CAAA,IAAA,CAAA;EAAO;;;;;;cA1JvB,2BAA2B,eAAe;;;;;;;UAQ9C;;;;;;;;;;;;;;;;;;;iBAoBM,IAAA,CAAA,GAAQ;;;;;;;;;;;;;;KA8HZ,kBAAkB,QAAQ,GAAG"}

package/dist/scope-D_kzd1nT.mjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"scope-D_kzd1nT.mjs","names":[],"sources":["../src/scope/scope.ts"],"sourcesContent":["/**\n * Scope lifecycle management for registering and running finalizers.\n *\n * **Mental model**\n * - A scope tracks cleanup actions and executes them in LIFO order.\n * - `Layer.scoped` and `Provide.layer` rely on scope semantics.\n *\n * **Common tasks**\n * - Create scopes with `Scope.make`.\n * - Register cleanup with `scope.addFinalizer`.\n * - Close scopes with `scope.close`.\n *\n * **Gotchas**\n * - Child scopes close before parent finalizers.\n * - Async finalizers force async scope close.\n *\n * **Quickstart**\n *\n * @example\n * ```ts\n * import { Scope } from \"@nicolastoulemont/std\"\n *\n * import { Result } from \"@nicolastoulemont/std\"\n *\n * const scope = Scope.make()\n * const closeFx = scope.close(Result.ok(undefined))\n * // => SyncFx<void> | AsyncFx<void>\n * ```\n *\n * @module\n */\nimport { runSync, runAsync } from \"../fx/fx.runtime\"\nimport { FxTypeId } from \"../fx/fx.types\"\nimport type { SyncFx, AsyncFx, FxYield } from \"../fx/fx.types\"\nimport type { Result } from \"../result/result.types\"\n\n/* oxlint-disable no-unsafe-type-assertion -- Scope encodes Fx phantom type slots and sync/async branch narrowing via assertions. */\n\n// ============================================================================\n// Scope Service\n// ============================================================================\n\n/**\n * Scope manages resource lifecycles with finalizers.\n * Finalizers run in LIFO (Last In, First Out) order when the scope closes.\n *\n * @example\n * ```ts\n * import { Scope } from \"@nicolastoulemont/std\"\n *\n * type Example = typeof Scope\n * ```\n *\n * @category Type-level\n */\nexport type ScopeService = {\n  /**\n   * Add a finalizer to be run when the scope closes.\n   * Finalizers are run in LIFO order.\n   *\n   * @param finalizer - A function that returns an Fx to run on cleanup\n   * @returns An Fx that completes when the finalizer is registered\n   */\n  addFinalizer(finalizer: () => SyncFx<void> | AsyncFx<void>): SyncFx<void>\n\n  /**\n   * Close the scope, running all finalizers in LIFO order.\n   *\n   * @param exit - The exit status of the computation\n   * @returns An Fx that completes when all finalizers have run\n   */\n  close(exit: Result<unknown, unknown>): SyncFx<void> | AsyncFx<void>\n\n  /**\n   * Fork a child scope.\n   * The child scope will be closed when the parent scope closes.\n   *\n   * @returns A new child scope\n   */\n  fork(): ScopeService\n}\n\n/**\n * Create a new Scope instance.\n * This is the concrete implementation of the ScopeService interface.\n *\n * @example\n * ```ts\n * import { Scope } from \"@nicolastoulemont/std\"\n *\n * import { Result } from \"@nicolastoulemont/std\"\n *\n * const scope = Scope.make()\n * const closeFx = scope.close(Result.ok(undefined))\n * // => SyncFx<void> | AsyncFx<void>\n * ```\n *\n * @category Constructors\n */\nexport function make(): ScopeService {\n  type Finalizer = () => SyncFx<void> | AsyncFx<void>\n  const finalizers: Finalizer[] = []\n  let closed = false\n  const children: ScopeService[] = []\n\n  const scope: ScopeService = {\n    addFinalizer(finalizer: Finalizer): SyncFx<void> {\n      return {\n        _tag: \"SyncFx\",\n        [FxTypeId]: {\n          _A: () => undefined as void,\n          _E: () => undefined as never,\n          _R: () => undefined as never,\n        },\n        // oxlint-disable-next-line require-yield\n        *[Symbol.iterator](): Generator<FxYield<never, never>, void, unknown> {\n          if (!closed) {\n            finalizers.push(finalizer)\n          }\n        },\n      } as SyncFx<void>\n    },\n\n    close(exit: Result<unknown, unknown>): SyncFx<void> | AsyncFx<void> {\n      // Check if any finalizer is async\n      const hasAsyncFinalizer = finalizers.some((f) => {\n        const fx = f()\n        return fx._tag === \"AsyncFx\"\n      })\n\n      if (hasAsyncFinalizer) {\n        return {\n          _tag: \"AsyncFx\",\n          [FxTypeId]: {\n            _A: () => undefined as void,\n            _E: () => undefined as never,\n            _R: () => undefined as never,\n          },\n          // oxlint-disable-next-line require-yield\n          async *[Symbol.asyncIterator](): AsyncGenerator<FxYield<never, never>, void, unknown> {\n            if (closed) return\n            closed = true\n\n            // Close children first\n            for (const child of [...children].toReversed()) {\n              const childClose = child.close(exit)\n              if (childClose._tag === \"AsyncFx\") {\n                // oxlint-disable-next-line no-await-in-loop\n                await runAsync(childClose)\n              } else {\n                runSync(childClose)\n              }\n            }\n\n            // Run finalizers in LIFO order\n            const reversed = [...finalizers].toReversed()\n            for (const finalizer of reversed) {\n              const fx = finalizer()\n              if (fx._tag === \"AsyncFx\") {\n                // oxlint-disable-next-line no-await-in-loop\n                await runAsync(fx)\n              } else {\n                runSync(fx)\n              }\n            }\n          },\n        } as AsyncFx<void>\n      }\n\n      // Sync version\n      return {\n        _tag: \"SyncFx\",\n        [FxTypeId]: {\n          _A: () => undefined as void,\n          _E: () => undefined as never,\n          _R: () => undefined as never,\n        },\n        // oxlint-disable-next-line require-yield\n        *[Symbol.iterator](): Generator<FxYield<never, never>, void, unknown> {\n          if (closed) return\n          closed = true\n\n          // Close children first\n          for (const child of [...children].toReversed()) {\n            const childClose = child.close(exit)\n            runSync(childClose as SyncFx<void>)\n          }\n\n          // Run finalizers in LIFO order\n          const reversed = [...finalizers].toReversed()\n          for (const finalizer of reversed) {\n            const fx = finalizer()\n            runSync(fx as SyncFx<void>)\n          }\n        },\n      } as SyncFx<void>\n    },\n\n    fork(): ScopeService {\n      const child = make()\n      children.push(child)\n      return child\n    },\n  }\n\n  return scope\n}\n\n// ============================================================================\n// Helper Types\n// ============================================================================\n\n/**\n * Type utility to exclude Scope from requirements.\n * Used by Layer.scoped to auto-provide Scope.\n *\n * @example\n * ```ts\n * import { Scope } from \"@nicolastoulemont/std\"\n *\n * type Example = typeof Scope\n * ```\n *\n * @category Type-level\n */\nexport type ExcludeScope<R> = Exclude<R, ScopeService>\n\n/* oxlint-enable no-unsafe-type-assertion */\n"],"mappings":"sJAmGA,SAAgB,GAAqB,CAEnC,IAAM,EAA0B,EAAE,CAC9B,EAAS,GACP,EAA2B,EAAE,CAsGnC,MApG4B,CAC1B,aAAa,EAAoC,CAC/C,MAAO,CACL,KAAM,UACL,GAAW,CACV,OAAU,IAAA,GACV,OAAU,IAAA,GACV,OAAU,IAAA,GACX,CAED,EAAE,OAAO,WAA6D,CAC/D,GACH,EAAW,KAAK,EAAU,EAG/B,EAGH,MAAM,EAA8D,CA+ClE,OA7C0B,EAAW,KAAM,GAC9B,GAAG,CACJ,OAAS,UACnB,CAGO,CACL,KAAM,WACL,GAAW,CACV,OAAU,IAAA,GACV,OAAU,IAAA,GACV,OAAU,IAAA,GACX,CAED,OAAQ,OAAO,gBAAuE,CACpF,GAAI,EAAQ,OACZ,EAAS,GAGT,IAAK,IAAM,IAAS,CAAC,GAAG,EAAS,CAAC,YAAY,CAAE,CAC9C,IAAM,EAAa,EAAM,MAAM,EAAK,CAChC,EAAW,OAAS,UAEtB,MAAM,EAAS,EAAW,CAE1B,EAAQ,EAAW,CAKvB,IAAM,EAAW,CAAC,GAAG,EAAW,CAAC,YAAY,CAC7C,IAAK,IAAM,KAAa,EAAU,CAChC,IAAM,EAAK,GAAW,CAClB,EAAG,OAAS,UAEd,MAAM,EAAS,EAAG,CAElB,EAAQ,EAAG,GAIlB,CAII,CACL,KAAM,UACL,GAAW,CACV,OAAU,IAAA,GACV,OAAU,IAAA,GACV,OAAU,IAAA,GACX,CAED,EAAE,OAAO,WAA6D,CACpE,GAAI,EAAQ,OACZ,EAAS,GAGT,IAAK,IAAM,IAAS,CAAC,GAAG,EAAS,CAAC,YAAY,CAE5C,EADmB,EAAM,MAAM,EAAK,CACD,CAIrC,IAAM,EAAW,CAAC,GAAG,EAAW,CAAC,YAAY,CAC7C,IAAK,IAAM,KAAa,EAEtB,EADW,GAAW,CACK,EAGhC,EAGH,MAAqB,CACnB,IAAM,EAAQ,GAAM,CAEpB,OADA,EAAS,KAAK,EAAM,CACb,GAEV"}

package/dist/service-3PYQTUdH.mjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"service-3PYQTUdH.mjs","names":["tag"],"sources":["../src/service/service.ts"],"sourcesContent":["/**\n * Service tag constructors for `Fx` dependency injection.\n *\n * **Mental model**\n * - A service tag is both a runtime lookup key and a typed requirement marker.\n * - `Service()` and `tag()` create values that can be yielded in `Fx.gen`.\n *\n * **Common tasks**\n * - Define class-based services with `Service`.\n * - Define interface-only tags with `tag`.\n *\n * **Gotchas**\n * - Service keys must be globally unique in a context.\n * - Yielding a service tag requires the service to be provided.\n *\n * **Quickstart**\n *\n * @example\n * ```ts\n * import { Service } from \"@nicolastoulemont/std\"\n *\n * const Logger = Service.Service<{ log: (message: string) => void }>()(\"Logger\")\n * // => service class with key \"Logger\"\n * ```\n *\n * @module\n */\nimport { FxTypeId } from \"../fx/fx.types\"\nimport type { Fx } from \"../fx/fx.types\"\n\n/* oxlint-disable no-unsafe-type-assertion -- Service tags carry phantom generic metadata at runtime and require explicit type assertions. */\n\n// ============================================================================\n// Service Class Types\n// ============================================================================\n\n/**\n * The interface returned by Service()().\n * Acts as both a type tag and a runtime lookup key.\n * Implements Fx protocol with E = never (no errors) and R = Self (requires itself).\n * When yielded, yields itself (as Fx) for proper type inference.\n *\n * @example\n * ```ts\n * import { Service } from \"@nicolastoulemont/std\"\n *\n * type Example = typeof Service\n * ```\n *\n * @category Models\n */\nexport type ServiceClass<Self, Key extends string = string> = Fx<Self, never, Self> & {\n  readonly _tag: \"Service\"\n  readonly key: Key\n  // Phantom type\n  readonly _Self: Self\n\n  /**\n   * Yielding the service class in a gen computation\n   * returns the service instance from context.\n   * Yields the ServiceClass itself (which implements Fx) for type inference.\n   */\n  [Symbol.iterator](): Generator<ServiceClass<Self, Key>, Self, unknown>\n}\n\n// ============================================================================\n// Service Factory\n// ============================================================================\n\n/**\n * Define a service with a unique key.\n * The returned class acts as both a type and a runtime tag for lookup.\n *\n * Usage follows a double-invocation pattern:\n * - First call provides the Self type parameter\n * - Second call provides the unique key\n *\n * @example\n * ```ts\n * import { Service } from \"@nicolastoulemont/std\"\n *\n * const Logger = Service.Service<string>()(\"Logger\")\n * // => service class with key \"Logger\"\n * ```\n *\n * @category Utilities\n */\nexport function Service<Self>(): <Key extends string>(key: Key) => ServiceClass<Self, Key> & (new () => Self) {\n  return <Key extends string>(key: Key): ServiceClass<Self, Key> & (new () => Self) => {\n    // Create the base class with proper prototype\n    // oxlint-disable-next-line typescript/no-extraneous-class\n    const ServiceBase = class {\n      static readonly _tag = \"Service\" as const\n      static readonly key: Key = key\n      static readonly _Self: Self = undefined as unknown as Self\n\n      static readonly [FxTypeId] = {\n        _A: () => undefined as unknown as Self,\n        _E: () => undefined as never,\n        _R: () => undefined as unknown as Self,\n      };\n\n      /**\n       * Yielding the class returns the class itself (for type inference).\n       * The runtime intercepts this and provides the actual service instance.\n       */\n      static *[Symbol.iterator](): Generator<typeof ServiceBase, Self, Self> {\n        // Yield the class itself - it implements Fx<Self, never, Self>\n        // The runtime will recognize ServiceClass and inject the service\n        const serviceInstance = yield ServiceBase\n        return serviceInstance\n      }\n    }\n\n    // Return with correct typing\n    return ServiceBase as unknown as ServiceClass<Self, Key> & (new () => Self)\n  }\n}\n\n/**\n * Create a service tag without class syntax.\n * Useful for simple services that don't need class inheritance.\n *\n * @example\n * ```ts\n * import { Service } from \"@nicolastoulemont/std\"\n *\n * const Logger = Service.tag<string>(\"Logger\")\n * // => plain service tag with key \"Logger\"\n * ```\n *\n * @category Utilities\n */\nexport function tag<S>(key: string): ServiceClass<S> {\n  const tag: ServiceClass<S> = {\n    _tag: \"Service\",\n    key,\n    _Self: undefined as unknown as S,\n    [FxTypeId]: {\n      _A: () => undefined as unknown as S,\n      _E: () => undefined as never,\n      _R: () => undefined as unknown as S,\n    },\n    *[Symbol.iterator](): Generator<ServiceClass<S>, S, S> {\n      // Yield the tag itself - it implements Fx<S, never, S>\n      // The runtime will recognize ServiceClass and inject the service\n      const serviceInstance = yield tag\n      return serviceInstance\n    },\n  }\n  return tag\n}\n\n/* oxlint-enable no-unsafe-type-assertion */\n"],"mappings":"mHAuFA,SAAgB,GAA8F,CAC5G,MAA4B,IAAyD,CAGnF,IAAM,EAAc,KAAM,CACxB,OAAgB,KAAO,UACvB,OAAgB,IAAW,EAC3B,OAAgB,MAAc,IAAA,GAE9B,OAAiB,GAAY,CAC3B,OAAU,IAAA,GACV,OAAU,IAAA,GACV,OAAU,IAAA,GACX,CAMD,QAAS,OAAO,WAAuD,CAIrE,OADwB,MAAM,IAMlC,OAAO,GAkBX,SAAgB,EAAO,EAA8B,CACnD,IAAMA,EAAuB,CAC3B,KAAM,UACN,MACA,MAAO,IAAA,IACN,GAAW,CACV,OAAU,IAAA,GACV,OAAU,IAAA,GACV,OAAU,IAAA,GACX,CACD,EAAE,OAAO,WAA8C,CAIrD,OADwB,MAAMA,GAGjC,CACD,OAAOA"}

package/dist/service-DrXU7KJG.d.mts.map

@@ -1 +0,0 @@
-{"version":3,"file":"service-DrXU7KJG.d.mts","names":[],"sources":["../src/service/service.ts"],"sourcesContent":[],"mappings":";;;;;;;;;;;;;;AAmDA;;;;;;;AAWoD,KAXxC,YAWwC,CAAA,IAAA,EAAA,YAAA,MAAA,GAAA,MAAA,CAAA,GAXU,EAWV,CAXa,IAWb,EAAA,KAAA,EAX0B,IAW1B,CAAA,GAAA;EAAnB,SAAA,IAAA,EAAA,SAAA;EAAyB,SAAA,GAAA,EAT1C,GAS0C;EAAnC,SAAA,KAAA,EAPL,IAOK;EAAS;AAyBhC;;;;EAAmE,CAAA,MAAA,CAAA,QAAA,GAAA,EAzB5C,SAyB4C,CAzBlC,YAyBkC,CAzBrB,IAyBqB,EAzBf,GAyBe,CAAA,EAzBT,IAyBS,EAAA,OAAA,CAAA;CAAqC;;AA8CxG;;;;;;;;;;;;;;;;;iBA9CgB,2CAA2C,QAAQ,aAAa,MAAM,kBAAkB;;;;;;;;;;;;;;;iBA8CxF,qBAAqB,aAAa"}