@nicolastoulemont/std 0.6.0 → 0.7.0

package/dist/index-a4MEBZZ1.d.mts

@@ -1,850 +0,0 @@
-import { a as FxError, f as RunnableFx, i as Fx$1, m as SyncFx, n as AsyncFxGenerator, o as FxGenerator, s as FxRequirements, t as AsyncFx } from "./fx.types-B34asVRX.mjs";
-import { a as ResultFromTry, b as Err, j as Ok, t as Result } from "./result.types-HHDzgSTV.mjs";
-import { r as Option } from "./option.types-ClJiBTdg.mjs";
-import { O as Either } from "./index-CklRfom5.mjs";
-
-//#region src/shared/unify.types.d.ts
-
-/**
- * Unify Option unions: Option<A> | Option<B> => Option<A | B>
- */
-type UnifyOption<T> = [T] extends [Option<infer A>] ? Option<A> : never;
-/**
- * Unify Result unions: Result<A, E1> | Result<B, E2> => Result<A | B, E1 | E2>
- */
-type UnifyResult<T> = [T] extends [Result<infer A, infer E>] ? Result<A, E> : never;
-/**
- * Unify Either unions: Either<L1, R1> | Either<L2, R2> => Either<L1 | L2, R1 | R2>
- */
-type UnifyEither<T> = [T] extends [Either<infer L, infer R>] ? Either<L, R> : never;
-/**
- * Unify Fx unions: Fx<A1, E1, R1> | Fx<A2, E2, R2> => Fx<A1 | A2, E1 | E2, R1 | R2>
- */
-type UnifyFx<T> = [T] extends [Fx$1<infer A, infer E, infer R>] ? Fx$1<A, E, R> : never;
-/**
- * Master Unify dispatcher - detects the container type and applies appropriate unification
- */
-type Unify<T> = [T] extends [Option<unknown>] ? UnifyOption<T> : [T] extends [Result<unknown, unknown>] ? UnifyResult<T> : [T] extends [Either<unknown, unknown>] ? UnifyEither<T> : [T] extends [Fx$1<unknown, unknown, unknown>] ? UnifyFx<T> : T;
-//#endregion
-//#region src/fx/exit.d.ts
-/**
- * Represents an unexpected thrown exception (defect) caught during Fx execution.
- */
-type Defect = {
-  readonly _tag: "Defect";
-  readonly defect: unknown;
-};
-/**
- * Exit represents the outcome of an Fx computation.
- * A flat 3-variant discriminated union that cleanly separates:
- * - `Ok<A>`: successful result with value of type A
- * - `Err<E>`: typed failure with error of type E
- * - `Defect`: unexpected thrown exception (defect)
- *
- * @example
- * ```ts
- * const exit = Fx.run(computation)
- * switch (exit._tag) {
- *   case "Ok":      exit.value    // A
- *   case "Err":     exit.error    // E (clean!)
- *   case "Defect":  exit.defect   // unknown
- * }
- * ```
- */
-type Exit<A$1, E$1> = Ok<A$1> | Err<E$1> | Defect;
-/**
- * Handler functions for Exit.match.
- */
-type ExitMatch<A$1, E$1, R$1> = {
-  readonly Ok: (value: A$1) => R$1;
-  readonly Err: (error: E$1) => R$1;
-  readonly Defect: (defect: unknown) => R$1;
-};
-/**
- * Exit namespace containing all Exit utilities.
- */
-declare const Exit: {
-  readonly ok: <A$1>(value: A$1) => Ok<A$1>;
-  readonly err: <E$1>(error: E$1) => Err<E$1>;
-  readonly defect: (thrown: unknown) => Defect;
-  readonly isOk: <A$1, E$1>(exit: Exit<A$1, E$1>) => exit is Ok<A$1>;
-  readonly isErr: <A$1, E$1>(exit: Exit<A$1, E$1>) => exit is Err<E$1>;
-  readonly isDefect: <A$1, E$1>(exit: Exit<A$1, E$1>) => exit is Defect;
-  readonly match: {
-    <A$1, E$1, R$1>(exit: Exit<A$1, E$1>, handlers: ExitMatch<A$1, E$1, R$1>): R$1;
-    <A$1, E$1, R$1>(handlers: ExitMatch<A$1, E$1, R$1>): (exit: Exit<A$1, E$1>) => R$1;
-  };
-  readonly getOrThrow: <A$1, E$1>(exit: Exit<A$1, E$1>) => A$1;
-};
-//#endregion
-//#region src/fx/fx.d.ts
-/**
- * Execute a sync Fx computation and return the Exit.
- * Catches unexpected thrown exceptions and wraps them as Defect.
- * Only available when R = never (all dependencies provided).
- *
- * @param fx - The sync computation to execute
- * @returns Exit<A, E>
- */
-declare function fxRun<A$1, E$1>(fx: SyncFx<A$1, E$1>): Exit<A$1, E$1>;
-/**
- * Execute an async Fx computation and return a Promise of the Exit.
- * Catches unexpected thrown exceptions and wraps them as Defect.
- * Only available when R = never (all dependencies provided).
- *
- * @param fx - The async computation to execute
- * @returns Promise<Exit<A, E>>
- */
-declare function fxRun<A$1, E$1>(fx: AsyncFx<A$1, E$1>): Promise<Exit<A$1, E$1>>;
-/**
- * Execute an Fx computation (union type).
- * Returns Exit for sync, Promise<Exit> for async.
- * Catches unexpected thrown exceptions and wraps them as Defect.
- */
-declare function fxRun<A$1, E$1>(fx: RunnableFx<A$1, E$1>): Exit<A$1, E$1> | Promise<Exit<A$1, E$1>>;
-/**
- * Internal helper to run a sync Fx computation.
- * Wraps execution in try-catch to capture unexpected thrown exceptions as Defect.
- */
-
-/**
- * Create a composable computation from a sync generator function.
- * Returns a SyncFx that can be stored, passed around, and executed later.
- *
- * @template Yielded - The type of values yielded by the generator (must implement Fx protocol)
- * @template A - The success value type
- * @param generatorFn - A function that returns a sync generator
- * @returns SyncFx<A, FxError<Yielded>, FxRequirements<Yielded>>
- *
- * @example
- * ```ts
- * const getUser = (id: string) => Fx.gen(function* () {
- *   const db = yield* Database
- *   const logger = yield* Logger
- *
- *   logger.info(`Fetching user ${id}`)
- *   return yield* db.query<User>(`SELECT * FROM users WHERE id = '${id}'`)
- * })
- * // Type: SyncFx<User[], DatabaseError, Database | Logger>
- *
- * // Execute later with dependencies provided
- * const exit = pipe(getUser("123"), provide(AppLayer)).run()
- * ```
- */
-declare function fxGen<Yielded extends Fx$1<unknown, unknown, unknown>, A$1>(generatorFn: () => Generator<Yielded, A$1, unknown>): SyncFx<A$1, FxError<Yielded>, FxRequirements<Yielded>>;
-/**
- * Create a composable computation from an async generator function.
- * Returns an AsyncFx that can be stored, passed around, and executed later.
- *
- * @template Yielded - The type of values yielded by the generator (must implement Fx protocol)
- * @template A - The success value type
- * @param generatorFn - A function that returns an async generator
- * @returns AsyncFx<A, FxError<Yielded>, FxRequirements<Yielded>>
- *
- * @example
- * ```ts
- * const fetchData = (url: string) => Fx.gen(async function* () {
- *   const logger = yield* Logger
- *
- *   logger.info(`Fetching ${url}`)
- *   const response = await fetch(url)
- *   return yield* Result.try(async () => await response.json())
- * })
- * // Type: AsyncFx<unknown, Error, Logger>
- * ```
- */
-declare function fxGen<Yielded extends Fx$1<unknown, unknown, unknown>, A$1>(generatorFn: () => AsyncGenerator<Yielded, A$1, unknown>): AsyncFx<A$1, FxError<Yielded>, FxRequirements<Yielded>>;
-/**
- * Create a composable computation from a sync generator function that takes parameters.
- * Returns a factory function that, when called with parameters, produces a SyncFx.
- *
- * @template P - The parameter types (must be non-empty)
- * @template Yielded - The type of values yielded by the generator (must implement Fx protocol)
- * @template A - The success value type
- * @param generatorFn - A function that takes parameters and returns a sync generator
- * @returns A factory function that produces SyncFx<A, FxError<Yielded>, FxRequirements<Yielded>>
- *
- * @example
- * ```ts
- * const getUser = Fx.gen(function* ({userId}: {userId: string}) {
- *   const db = yield* Database
- *   return yield* db.query(`SELECT * FROM users WHERE id = '${userId}'`)
- * })
- * // Type: (params: {userId: string}) => SyncFx<...>
- *
- * const exit = Fx.run(pipe(getUser({userId: "123"}), provide(DbLayer)))
- * ```
- */
-declare function fxGen<P extends [unknown, ...unknown[]], Yielded extends Fx$1<unknown, unknown, unknown>, A$1>(generatorFn: (...params: P) => Generator<Yielded, A$1, unknown>): (...params: P) => SyncFx<A$1, FxError<Yielded>, FxRequirements<Yielded>>;
-/**
- * Create a composable computation from an async generator function that takes parameters.
- * Returns a factory function that, when called with parameters, produces an AsyncFx.
- *
- * @template P - The parameter types (must be non-empty)
- * @template Yielded - The type of values yielded by the generator (must implement Fx protocol)
- * @template A - The success value type
- * @param generatorFn - A function that takes parameters and returns an async generator
- * @returns A factory function that produces AsyncFx<A, FxError<Yielded>, FxRequirements<Yielded>>
- *
- * @example
- * ```ts
- * const fetchUser = Fx.gen(async function* ({url}: {url: string}) {
- *   const response = await fetch(url)
- *   return yield* Result.try(async () => await response.json())
- * })
- * // Type: (params: {url: string}) => AsyncFx<...>
- * ```
- */
-declare function fxGen<P extends [unknown, ...unknown[]], Yielded extends Fx$1<unknown, unknown, unknown>, A$1>(generatorFn: (...params: P) => AsyncGenerator<Yielded, A$1, unknown>): (...params: P) => AsyncFx<A$1, FxError<Yielded>, FxRequirements<Yielded>>;
-/**
- * Execute a sync computation immediately and return the Exit.
- * Catches unexpected thrown exceptions and wraps them as Defect.
- * For computations without service dependencies.
- *
- * @template A - The success value type
- * @template E - The error type
- * @param generatorFn - A function that returns a sync generator
- * @returns Exit<A, E>
- *
- * @example
- * ```ts
- * const exit = Fx.fn(function* () {
- *   const a = yield* Result.ok(10)
- *   const b = yield* Result.ok(20)
- *   return a + b
- * })
- * // Type: Exit<number, never>
- * // exit = { _tag: "Ok", value: 30 }
- * ```
- */
-declare function fxFn<A$1, E$1>(generatorFn: () => FxGenerator<A$1, E$1, never>): Exit<A$1, E$1>;
-/**
- * Execute an async computation immediately and return a Promise of the Exit.
- * Catches unexpected thrown exceptions and wraps them as Defect.
- * For computations without service dependencies.
- *
- * @template A - The success value type
- * @template E - The error type
- * @param generatorFn - A function that returns an async generator
- * @returns Promise<Exit<A, E>>
- *
- * @example
- * ```ts
- * const exit = await Fx.fn(async function* () {
- *   const response = await fetch("/api/users")
- *   const data = yield* Result.try(async () => await response.json())
- *   return data
- * })
- * // Type: Promise<Exit<unknown, Error>>
- * ```
- */
-declare function fxFn<A$1, E$1>(generatorFn: () => AsyncFxGenerator<A$1, E$1, never>): Promise<Exit<A$1, E$1>>;
-/**
- * Execute a sync computation with service dependencies immediately.
- * Catches unexpected thrown exceptions and wraps them as Defect.
- * The second argument is required when the computation has service requirements (R ≠ never).
- *
- * @template A - The success value type
- * @template E - The error type from the computation
- * @template E2 - The error type from the provider (layer)
- * @template R - The required services type
- * @param generatorFn - A function that returns a sync generator with service requirements
- * @param provider - A function that provides the services (e.g., provide(AppLayer))
- * @returns Exit<A, E | E2>
- *
- * @example
- * ```ts
- * const exit = Fx.fn(function* () {
- *   const config = yield* Config
- *   const logger = yield* Logger
- *   logger.info(`DB URL: ${config.dbUrl}`)
- *   return config.dbUrl
- * }, provide(AppLayer))
- * // Type: Exit<string, never>
- * ```
- */
-declare function fxFn<A$1, E$1, E2, R$1>(generatorFn: () => FxGenerator<A$1, E$1, R$1>, provider: (fx: RunnableFx<A$1, E$1, R$1>) => RunnableFx<A$1, E$1 | E2>): Exit<A$1, E$1 | E2>;
-/**
- * Execute an async computation with service dependencies immediately.
- * Catches unexpected thrown exceptions and wraps them as Defect.
- * The second argument is required when the computation has service requirements (R ≠ never).
- *
- * @template A - The success value type
- * @template E - The error type from the computation
- * @template E2 - The error type from the provider (layer)
- * @template R - The required services type
- * @param generatorFn - A function that returns an async generator with service requirements
- * @param provider - A function that provides the services (e.g., provide(AppLayer))
- * @returns Promise<Exit<A, E | E2>>
- *
- * @example
- * ```ts
- * const exit = await Fx.fn(async function* () {
- *   const config = yield* Config
- *   await doAsyncWork()
- *   return config.dbUrl
- * }, provide(AppLayer))
- * // Type: Promise<Exit<string, never>>
- * ```
- */
-declare function fxFn<A$1, E$1, E2, R$1>(generatorFn: () => AsyncFxGenerator<A$1, E$1, R$1>, provider: (fx: RunnableFx<A$1, E$1, R$1>) => RunnableFx<A$1, E$1 | E2>): Promise<Exit<A$1, E$1 | E2>>;
-/**
- * Handler functions for matching on a tagged union by `_tag` discriminator.
- * Each handler receives the narrowed variant corresponding to its tag key.
- */
-type TaggedMatch<T extends {
-  readonly _tag: string;
-}, R$1> = { readonly [K in T["_tag"]]: (variant: Extract<T, {
-  readonly _tag: K;
-}>) => R$1 };
-/**
- * Generic pattern matcher for any `_tag`-based discriminated union.
- *
- * Works with Exit, tagged errors, or any type with a `readonly _tag` discriminator.
- * Each handler receives the full narrowed variant object for its tag.
- *
- * Supports both data-first and data-last (pipe) calling styles.
- *
- * @example
- * ```ts
- * // Match on Exit
- * Fx.match(exit, {
- *   Ok: (ok) => ok.value,
- *   Err: (err) =>
- *     Fx.match(err.error, {
- *       DatabaseError: (e) => e.message,
- *       NotFoundError: (e) => e.resourceId,
- *     }),
- *   Defect: (d) => String(d.defect),
- * })
- *
- * // Data-last with pipe
- * pipe(exit, Fx.match({
- *   Ok: (ok) => ok.value,
- *   Err: (err) => "error",
- *   Defect: (d) => "defect",
- * }))
- * ```
- */
-declare const fxMatch: {
-  <T extends {
-    readonly _tag: string;
-  }, R$1>(value: T, handlers: TaggedMatch<T, R$1>): R$1;
-  <T extends {
-    readonly _tag: string;
-  }, R$1>(handlers: TaggedMatch<T, R$1>): (value: T) => R$1;
-};
-declare const gen: typeof fxGen;
-declare const fn: typeof fxFn;
-declare const run: typeof fxRun;
-declare const ok: <T>(value: T) => Result<T, never>;
-declare const err: <E$1>(error: E$1) => Result<never, E$1>;
-/**
- * Fx namespace containing utilities for creating and running effectful computations.
- *
- * Fx provides a minimal API inspired by Effect.ts:
- * - `Fx.gen()` - Create composable computations with service dependencies
- * - `Fx.fn()` - Execute computations immediately
- * - `Fx.run()` - Execute a computation (when all dependencies are provided)
- * - `Fx.ok()` - Create successful results (alias for Result.ok)
- * - `Fx.err()` - Create error results (alias for Result.err)
- * - `Fx.try()` - Wrap throwing operations (alias for Result.try)
- * - `Fx.option()` - Convert nullish values to Option (alias for Option.fromNullable)
- *
- * @example
- * ```ts
- * import { Fx, Service, Layer, provide, pipe, Exit } from "@nicolastoulemont/std"
- *
- * // Define services
- * class Config extends Service<Config>()("Config") {
- *   readonly dbUrl!: string
- * }
- *
- * class Logger extends Service<Logger>()("Logger") {
- *   readonly info!: (msg: string) => void
- * }
- *
- * // Create layers
- * const ConfigLive = Layer.ok(Config, { dbUrl: "postgres://..." })
- * const LoggerLive = Layer.fx(Logger)(
- *   Fx.gen(function* () {
- *     const config = yield* Config
- *     return { info: (msg) => console.log(`[${config.dbUrl}] ${msg}`) }
- *   })
- * )
- *
- * // Create workflow
- * const myWorkflow = Fx.gen(function* () {
- *   const logger = yield* Logger
- *   logger.info("Hello from Fx!")
- *   return "done"
- * })
- *
- * // Compose and run
- * const AppLayer = pipe(ConfigLive, Layer.provide(LoggerLive))
- * const exit = Fx.run(pipe(myWorkflow, provide(AppLayer)))
- * // exit._tag === "Ok" | "Err" | "Defect"
- * ```
- */
-declare const Fx: {
-  readonly gen: typeof fxGen;
-  readonly fn: typeof fxFn;
-  readonly run: typeof fxRun;
-  readonly ok: <T>(value: T) => Result<T, never>;
-  readonly err: <E$1>(error: E$1) => Result<never, E$1>;
-  readonly match: {
-    <T extends {
-      readonly _tag: string;
-    }, R$1>(value: T, handlers: TaggedMatch<T, R$1>): R$1;
-    <T extends {
-      readonly _tag: string;
-    }, R$1>(handlers: TaggedMatch<T, R$1>): (value: T) => R$1;
-  };
-  readonly try: ResultFromTry;
-  readonly option: <T>(value: T) => Option<NonNullable<T>>;
-};
-//#endregion
-//#region src/fx/service.d.ts
-/**
- * The interface returned by Service()().
- * Acts as both a type tag and a runtime lookup key.
- * Implements Fx protocol with E = never (no errors) and R = Self (requires itself).
- * When yielded, yields itself (as Fx) for proper type inference.
- */
-type ServiceClass<Self, Key extends string = string> = Fx$1<Self, never, Self> & {
-  readonly _tag: "Service";
-  readonly key: Key;
-  readonly _Self: Self;
-  /**
-   * Yielding the service class in a gen computation
-   * returns the service instance from context.
-   * Yields the ServiceClass itself (which implements Fx) for type inference.
-   */
-  [Symbol.iterator](): Generator<ServiceClass<Self, Key>, Self, unknown>;
-};
-/**
- * Extract the service type from a ServiceClass.
- */
-type ServiceOf<T> = T extends ServiceClass<infer S> ? S : never;
-/**
- * Extract the key from a ServiceClass.
- */
-type ServiceKey<T> = T extends ServiceClass<unknown, infer K> ? K : never;
-/**
- * Define a service with a unique key.
- * The returned class acts as both a type and a runtime tag for lookup.
- *
- * Usage follows a double-invocation pattern:
- * - First call provides the Self type parameter
- * - Second call provides the unique key
- *
- * @example
- * ```ts
- * class Config extends Service<Config>()("Config") {
- *   readonly dbUrl!: string
- *   readonly logLevel!: "debug" | "info" | "error"
- * }
- *
- * class Logger extends Service<Logger>()("Logger") {
- *   readonly info!: (msg: string) => void
- *   readonly error!: (msg: string) => void
- * }
- *
- * // Use in Fx.gen:
- * const workflow = Fx.gen(function* () {
- *   const config = yield* Config
- *   const logger = yield* Logger
- *   logger.info(`DB URL: ${config.dbUrl}`)
- * })
- * ```
- */
-declare function Service<Self>(): <Key extends string>(key: Key) => ServiceClass<Self, Key> & (new () => Self);
-/**
- * Create a service tag without class syntax.
- * Useful for simple services that don't need class inheritance.
- *
- * @example
- * ```ts
- * interface ConfigService {
- *   readonly dbUrl: string
- *   readonly logLevel: "debug" | "info" | "error"
- * }
- *
- * const Config = serviceTag<ConfigService>("Config")
- *
- * // Use in Fx.gen:
- * const workflow = Fx.gen(function* () {
- *   const config = yield* Config
- *   console.log(config.dbUrl)
- * })
- * ```
- */
-declare function serviceTag<S>(key: string): ServiceClass<S>;
-/**
- * Check if a value is a ServiceClass.
- */
-declare const isServiceClass: (value: unknown) => value is ServiceClass<unknown>;
-//#endregion
-//#region src/fx/context.d.ts
-/**
- * Context<Services> is an immutable map storing service implementations.
- * The Services type parameter tracks which services are available.
- */
-type Context<Services = never> = {
-  readonly _tag: "Context";
-  readonly _services: ReadonlyMap<string, unknown>;
-  readonly _Services: Services;
-};
-/**
- * Get a service from a context.
- * Throws if the service is not found.
- *
- * @param service - The service class (tag)
- * @returns The service implementation
- * @throws Error if service not found
- *
- * @example
- * ```ts
- * const config = Context.get(ctx, Config)
- * ```
- */
-declare function get<S>(ctx: Context<S>, service: ServiceClass<S>): S;
-declare function get<S>(service: ServiceClass<S>): (ctx: Context<S>) => S;
-/**
- * Context namespace containing utilities for managing service contexts.
- *
- * A Context is an immutable map of services that can be provided to Fx computations.
- * Services are identified by their unique keys.
- *
- * @example
- * ```ts
- * import { Context, Service } from "@nicolastoulemont/std"
- *
- * class Config extends Service<Config>()("Config") {
- *   readonly dbUrl!: string
- * }
- *
- * class Logger extends Service<Logger>()("Logger") {
- *   readonly info!: (msg: string) => void
- * }
- *
- * // Create a context with services
- * const ctx = pipe(
- *   Context.empty(),
- *   Context.add(Config, { dbUrl: "postgres://..." }),
- *   Context.add(Logger, { info: console.log }),
- * )
- *
- * // Or use make and merge
- * const configCtx = Context.make(Config, { dbUrl: "postgres://..." })
- * const loggerCtx = Context.make(Logger, { info: console.log })
- * const fullCtx = Context.merge(configCtx, loggerCtx)
- * ```
- */
-declare const Context: {
-  readonly empty: () => Context;
-  readonly make: <S>(service: ServiceClass<S>, impl: S) => Context<S>;
-  readonly add: <S>(service: ServiceClass<S>, impl: S) => <Existing>(ctx: Context<Existing>) => Context<Existing | S>;
-  readonly merge: <A$1, B>(a: Context<A$1>, b: Context<B>) => Context<A$1 | B>;
-  readonly get: typeof get;
-  readonly unsafeGet: (ctx: Context<unknown>, key: string) => unknown;
-  readonly has: <S>(ctx: Context<unknown>, service: ServiceClass<S>) => boolean;
-  readonly keys: (ctx: Context<unknown>) => string[];
-  readonly size: (ctx: Context<unknown>) => number;
-  readonly isContext: (value: unknown) => value is Context<unknown>;
-};
-//#endregion
-//#region src/fx/scope.d.ts
-/**
- * Scope manages resource lifecycles with finalizers.
- * Finalizers run in LIFO (Last In, First Out) order when the scope closes.
- *
- * @example
- * ```ts
- * const DatabaseLive = Layer.scoped(Database)(
- *   Fx.gen(function* () {
- *     const scope = yield* Scope
- *
- *     const connection = createConnection()
- *
- *     // Register cleanup - runs when scope closes
- *     yield* scope.addFinalizer(() =>
- *       Fx.gen(function* () {
- *         connection.close()
- *       })
- *     )
- *
- *     return { query: (sql) => connection.query(sql) }
- *   })
- * )
- * ```
- */
-type ScopeService = {
-  /**
-   * Add a finalizer to be run when the scope closes.
-   * Finalizers are run in LIFO order.
-   *
-   * @param finalizer - A function that returns an Fx to run on cleanup
-   * @returns An Fx that completes when the finalizer is registered
-   */
-  addFinalizer(finalizer: () => SyncFx<void> | AsyncFx<void>): SyncFx<void>;
-  /**
-   * Close the scope, running all finalizers in LIFO order.
-   *
-   * @param exit - The exit status of the computation
-   * @returns An Fx that completes when all finalizers have run
-   */
-  close(exit: Result<unknown, unknown>): SyncFx<void> | AsyncFx<void>;
-  /**
-   * Fork a child scope.
-   * The child scope will be closed when the parent scope closes.
-   *
-   * @returns A new child scope
-   */
-  fork(): ScopeService;
-};
-declare const ScopeTag_base: Fx$1<ScopeService, never, ScopeService> & {
-  readonly _tag: "Service";
-  readonly key: "@std/Scope";
-  readonly _Self: ScopeService;
-  [Symbol.iterator](): Generator<ServiceClass<ScopeService, "@std/Scope">, ScopeService, unknown>;
-} & (new () => ScopeService);
-declare class ScopeTag extends ScopeTag_base {}
-/**
- * Create a new Scope instance.
- * This is the concrete implementation of the ScopeService interface.
- */
-declare function createScope(): ScopeService;
-/**
- * Type utility to exclude Scope from requirements.
- * Used by Layer.scoped to auto-provide Scope.
- */
-type ExcludeScope<R$1> = Exclude<R$1, ScopeService>;
-//#endregion
-//#region src/fx/memo-map.d.ts
-/**
- * MemoMap caches built layers so each layer is only built once.
- * Multiple dependents share the same service instance.
- *
- * This implements the "service singleton" pattern where a service
- * is instantiated once and shared across all consumers.
- *
- * @example
- * ```ts
- * // Database is built once, shared by DocumentService and TeamService
- * const AppLayer = Layer.merge(
- *   ConfigLive,
- *   LoggerLive,
- *   DatabaseLive,       // Built once
- *   DocumentServiceLive, // Uses shared Database
- *   TeamServiceLive,     // Uses same Database instance
- * )
- * ```
- */
-declare class MemoMap {
-  private cache;
-  /**
-   * Get a cached context or build the layer if not cached.
-   *
-   * @param layer - The layer to get or build
-   * @param scope - The scope for resource management
-   * @param deps - Context containing the layer's dependencies
-   * @returns A RunnableFx producing the layer's context
-   */
-  getOrBuild<ROut, E$1, RIn>(layer: Layer$1<ROut, E$1, RIn>, scope: ScopeService, deps: Context<RIn>): RunnableFx<Context<ROut>, E$1>;
-  /**
-   * Clear the cache.
-   * Useful for testing.
-   */
-  clear(): void;
-  /**
-   * Get the number of cached layers.
-   */
-  get size(): number;
-}
-/**
- * Create a new MemoMap instance.
- */
-declare const createMemoMap: () => MemoMap;
-//#endregion
-//#region src/fx/layer.types.d.ts
-/**
- * Layer<ROut, E, RIn, Sync> describes how to build services:
- * - ROut: Services this layer provides
- * - E: Errors that can occur during construction
- * - RIn: Services this layer requires to build
- * - Sync: Whether the layer builds synchronously (true = sync, false = async)
- */
-type Layer$1<ROut, E$1 = never, RIn = never, Sync extends boolean = boolean> = {
-  readonly _tag: "Layer";
-  /** Phantom type for output services */
-  readonly _ROut: ROut;
-  /** Phantom type for errors */
-  readonly _E: E$1;
-  /** Phantom type for input requirements */
-  readonly _RIn: RIn;
-  /** Phantom type for sync tracking */
-  readonly _Sync: Sync;
-  /**
-   * Build the layer given its dependencies.
-   * Returns a RunnableFx that produces a Context with the provided services.
-   *
-   * @param memoMap - Cache for layer memoization
-   * @param scope - Scope for resource management
-   * @returns A RunnableFx that produces the context
-   */
-  build(memoMap: MemoMap, scope: ScopeService): Sync extends true ? SyncFx<Context<ROut>, E$1, RIn> : RunnableFx<Context<ROut>, E$1, RIn>;
-};
-/**
- * Extract the output services type from a Layer.
- */
-type LayerROut<T> = T extends Layer$1<infer ROut, unknown, unknown> ? ROut : never;
-/**
- * Extract the error type from a Layer.
- */
-type LayerError<T> = T extends Layer$1<unknown, infer E, unknown> ? E : never;
-/**
- * Extract the input requirements type from a Layer.
- */
-type LayerRIn<T> = T extends Layer$1<unknown, unknown, infer RIn> ? RIn : never;
-/**
- * Merge all ROut types from an array of layers into a union.
- */
-type MergeROut<L$1 extends readonly Layer$1<unknown, unknown, unknown>[]> = L$1[number] extends Layer$1<infer ROut, unknown, unknown> ? ROut : never;
-/**
- * Merge all error types from an array of layers into a union.
- */
-type MergeError<L$1 extends readonly Layer$1<unknown, unknown, unknown>[]> = L$1[number] extends Layer$1<unknown, infer E, unknown> ? E : never;
-/**
- * Get all requirements from an array of layers that are NOT provided by any layer in the array.
- * This computes the "unprovided" or "external" dependencies.
- */
-type UnprovidedDeps<L$1 extends readonly Layer$1<unknown, unknown, unknown>[]> = Exclude<MergeRIn<L$1>, MergeROut<L$1>>;
-/**
- * Merge all RIn types from an array of layers into a union.
- */
-type MergeRIn<L$1 extends readonly Layer$1<unknown, unknown, unknown>[]> = L$1[number] extends Layer$1<unknown, unknown, infer RIn> ? RIn : never;
-/**
- * Check if all layers in an array are sync.
- * Returns true only if all layers have Sync=true.
- */
-type AllSync<L$1 extends readonly Layer$1<unknown, unknown, unknown>[]> = L$1 extends readonly [] ? true : L$1 extends readonly [Layer$1<unknown, unknown, unknown, infer S>, ...infer Rest] ? S extends true ? Rest extends readonly Layer$1<unknown, unknown, unknown>[] ? AllSync<Rest> : false : false : false;
-//#endregion
-//#region src/fx/layer.d.ts
-/**
- * Create a layer from an Fx computation (can have dependencies).
- * The Sync type parameter is inferred from the input fx:
- * - SyncFx input → Layer with Sync=true
- * - AsyncFx input → Layer with Sync=false
- */
-declare function layerFx<S>(service: ServiceClass<S>): {
-  <E$1, R$1>(fx: SyncFx<S, E$1, R$1>): Layer$1<S, E$1, R$1, true>;
-  <E$1, R$1>(fx: AsyncFx<S, E$1, R$1>): Layer$1<S, E$1, R$1, false>;
-  <E$1, R$1>(fx: RunnableFx<S, E$1, R$1>): Layer$1<S, E$1, R$1>;
-};
-/**
- * Create a scoped layer (with resource cleanup).
- * The Sync type parameter is inferred from the input fx.
- */
-declare function layerScoped<S>(service: ServiceClass<S>): {
-  <E$1, R$1>(fx: SyncFx<S, E$1, R$1 | ScopeService>): Layer$1<S, E$1, ExcludeScope<R$1>, true>;
-  <E$1, R$1>(fx: AsyncFx<S, E$1, R$1 | ScopeService>): Layer$1<S, E$1, ExcludeScope<R$1>, false>;
-  <E$1, R$1>(fx: RunnableFx<S, E$1, R$1 | ScopeService>): Layer$1<S, E$1, ExcludeScope<R$1>>;
-};
-/**
- * Provide dependencies to a layer and merge outputs.
- * Sync is preserved only if both the deps layer and the consuming layer are sync.
- */
-declare function layerProvide<DepsROut, DepsE, DepsRIn, DepsSync extends boolean>(deps: Layer$1<DepsROut, DepsE, DepsRIn, DepsSync>): {
-  <ROut, E$1, RIn extends DepsROut, LayerSync extends boolean>(layer: Layer$1<ROut, E$1, RIn, LayerSync>): Layer$1<ROut | DepsROut, E$1 | DepsE, DepsRIn, LayerSync extends true ? DepsSync : false>;
-};
-/**
- * Merge multiple layers with automatic dependency resolution.
- * The merged layer is sync only if ALL input layers are sync.
- */
-declare function layerMerge<L$1 extends Layer$1<unknown, unknown, unknown>[]>(...layers: L$1): Layer$1<MergeROut<L$1>, MergeError<L$1>, UnprovidedDeps<L$1>, AllSync<L$1>>;
-declare const Layer: {
-  readonly ok: <S>(service: ServiceClass<S>, impl: S) => Layer$1<S, never, never, true>;
-  readonly err: <E$1>(error: E$1) => Layer$1<never, E$1, never, true>;
-  readonly fx: typeof layerFx;
-  readonly scoped: typeof layerScoped;
-  readonly provide: typeof layerProvide;
-  readonly merge: typeof layerMerge;
-};
-//#endregion
-//#region src/fx/provide.d.ts
-/**
- * Extract the value type from an Fx.
- */
-type FxValueType<F> = F extends RunnableFx<infer A, unknown, unknown> ? A : never;
-/**
- * Extract the error type from an Fx.
- */
-type FxErrorType<F> = F extends RunnableFx<unknown, infer E, unknown> ? E : never;
-/**
- * Type for the result of provide based on layer sync and fx type.
- * Uses infer to extract A and E from the actual Fx type.
- * - Sync layer + SyncFx → SyncFx
- * - Sync layer + AsyncFx → AsyncFx
- * - Async layer + any fx → AsyncFx
- * - Unknown sync layer + any fx → RunnableFx (fallback)
- */
-type ProvideResult<E2, LayerSync extends boolean, Fx$2 extends RunnableFx<unknown, unknown, unknown>> = LayerSync extends true ? Fx$2["_tag"] extends "SyncFx" ? SyncFx<FxValueType<Fx$2>, FxErrorType<Fx$2> | E2> : AsyncFx<FxValueType<Fx$2>, FxErrorType<Fx$2> | E2> : LayerSync extends false ? AsyncFx<FxValueType<Fx$2>, FxErrorType<Fx$2> | E2> : RunnableFx<FxValueType<Fx$2>, FxErrorType<Fx$2> | E2>;
-/**
- * Provide a layer to an Fx computation, resolving all service requirements.
- * Creates a new scope for resource management.
- *
- * Type preservation:
- * - Sync layer + SyncFx → SyncFx
- * - Sync layer + AsyncFx → AsyncFx
- * - Async layer + any fx → AsyncFx
- * - Unknown sync layer + any fx → RunnableFx (fallback)
- *
- * @param layer - The layer providing services (must have no external requirements)
- * @returns A function that takes an Fx and returns an Fx with dependencies resolved
- *
- * @example
- * ```ts
- * const result = Fx.run(pipe(
- *   updateDocumentWorkflow(userId, docId, data),
- *   provide(AppLayer)
- * ))
- * ```
- */
-declare function provide<ROut, E2, LayerSync extends boolean>(layer: Layer$1<ROut, E2, never, LayerSync>): <Fx$2 extends RunnableFx<unknown, unknown, ROut>>(fx: Fx$2) => ProvideResult<E2, LayerSync, Fx$2>;
-/**
- * Provide a context directly to an Fx computation.
- *
- * @param ctx - The context containing services
- * @returns A function that takes an Fx and returns an Fx with dependencies resolved
- *
- * @example
- * ```ts
- * const ctx = Context.make(Config, configImpl)
- * const result = Fx.run(pipe(
- *   myWorkflow,
- *   provideContext(ctx)
- * ))
- * ```
- */
-declare const provideContext: <R$1>(ctx: Context<R$1>) => <A$1, E$1>(fx: RunnableFx<A$1, E$1, R$1>) => RunnableFx<A$1, E$1>;
-/**
- * Provide a single service to an Fx computation.
- *
- * @param service - The service class (tag)
- * @param impl - The service implementation
- * @returns A function that takes an Fx and returns an Fx with the service provided
- *
- * @example
- * ```ts
- * const result = Fx.run(pipe(
- *   myWorkflow,
- *   provideService(Config, configImpl),
- *   provideService(Logger, loggerImpl),
- * ))
- * ```
- */
-declare const provideService: <S>(service: ServiceClass<S>, impl: S) => <A$1, E$1, R$1>(fx: RunnableFx<A$1, E$1, R$1 | S>) => RunnableFx<A$1, E$1, Exclude<R$1, S>>;
-//#endregion
-export { gen as A, isServiceClass as C, err as D, TaggedMatch as E, Unify as F, UnifyEither as I, UnifyFx as L, run as M, Defect as N, fn as O, Exit as P, UnifyOption as R, ServiceOf as S, Fx as T, createScope as _, Layer$1 as a, ServiceClass as b, LayerROut as c, UnprovidedDeps as d, MemoMap as f, ScopeTag as g, ScopeService as h, Layer as i, ok as j, fxMatch as k, MergeError as l, ExcludeScope as m, provideContext as n, LayerError as o, createMemoMap as p, provideService as r, LayerRIn as s, provide as t, MergeROut as u, Context as v, serviceTag as w, ServiceKey as x, Service as y, UnifyResult as z };
-//# sourceMappingURL=index-a4MEBZZ1.d.mts.map