@nicolastoulemont/std 0.2.0 → 0.3.0

package/dist/index.d.mts

@@ -13,6 +13,633 @@ import { t as pipe } from "./index-zC2zAtZY.mjs";
 import { n as Predicate$1, r as Refinement, t as Predicate } from "./index-DbfMra4p.mjs";
 import { n as all$2, t as Result } from "./index-BwVaI5d0.mjs";
 
+//#region src/fx/fx.types.d.ts
+/**
+ * ServiceRequest is yielded when accessing a service via yield*.
+ * The runtime intercepts these and injects the service from context.
+ */
+type ServiceRequest<S> = {
+  readonly _tag: "ServiceRequest";
+  /** Phantom type for service identification */
+  readonly _service: S;
+  readonly serviceKey: string;
+};
+/**
+ * Exit represents the outcome of a computation.
+ * Either success with a value or failure with an error.
+ */
+/**
+ * SyncFx<A, E, R> represents a synchronous computation that:
+ * - Produces a value of type A on success
+ * - May fail with an error of type E
+ * - Requires services of type R to run
+ *
+ * When R = never, .run() returns Result<A, E> directly.
+ */
+type SyncFx<A, E = never, R = never> = {
+  readonly _tag: "SyncFx";
+  /**
+   * Execute the computation synchronously.
+   * Only available when R = never (all dependencies provided).
+   */
+  run: () => Result$1<A, E>;
+  /**
+   * Iterator for yield* support in gen computations.
+   * Yields either errors or service requests.
+   */
+  [Symbol.iterator](): Generator<E | ServiceRequest<R>, A, unknown>;
+};
+/**
+ * AsyncFx<A, E, R> represents an asynchronous computation that:
+ * - Produces a value of type A on success
+ * - May fail with an error of type E
+ * - Requires services of type R to run
+ *
+ * When R = never, .run() returns Promise<Result<A, E>>.
+ */
+type AsyncFx<A, E = never, R = never> = {
+  readonly _tag: "AsyncFx";
+  /**
+   * Execute the computation asynchronously.
+   * Only available when R = never (all dependencies provided).
+   */
+  run: () => Promise<Result$1<A, E>>;
+  /**
+   * Async iterator for yield* support in async gen computations.
+   * Yields either errors or service requests.
+   */
+  [Symbol.asyncIterator](): AsyncGenerator<E | ServiceRequest<R>, A, unknown>;
+};
+/**
+ * Fx<A, E, R> is a union of sync and async computations.
+ * Use this as the general type for computations.
+ */
+type Fx$1<A, E = never, R = never> = SyncFx<A, E, R> | AsyncFx<A, E, R>;
+/**
+ * Extract the success type from an Fx.
+ */
+type FxSuccess<T> = T extends Fx$1<infer A, unknown, unknown> ? A : never;
+/**
+ * Extract the error type from an Fx.
+ */
+type FxError<T> = T extends Fx$1<unknown, infer E, unknown> ? E : never;
+/**
+ * Extract the requirements type from an Fx.
+ */
+type FxRequirements<T> = T extends Fx$1<unknown, unknown, infer R> ? R : never;
+/**
+ * Sync generator type for Fx.gen.
+ * Yields errors or service requests, returns value of type A.
+ */
+type FxGenerator<A, E, R> = Generator<E | ServiceRequest<R>, A, unknown>;
+/**
+ * Async generator type for Fx.gen.
+ * Yields errors or service requests, returns value of type A.
+ */
+type AsyncFxGenerator<A, E, R> = AsyncGenerator<E | ServiceRequest<R>, A, unknown>;
+//#endregion
+//#region src/fx/fx.d.ts
+/**
+ * Create a composable computation from a sync generator function.
+ * Returns a SyncFx that can be stored, passed around, and executed later.
+ *
+ * @template A - The success value type
+ * @template E - The error type
+ * @template R - The required services type
+ * @param generatorFn - A function that returns a sync generator
+ * @returns SyncFx<A, E, R>
+ *
+ * @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: Fx<User[], DatabaseError, Database | Logger>
+ *
+ * // Execute later with dependencies provided
+ * const result = pipe(getUser("123"), provide(AppLayer)).run()
+ * ```
+ */
+declare function fxGen<A, E, R>(generatorFn: () => FxGenerator<A, E, R>): SyncFx<A, E, R>;
+/**
+ * Create a composable computation from an async generator function.
+ * Returns an AsyncFx that can be stored, passed around, and executed later.
+ *
+ * @template A - The success value type
+ * @template E - The error type
+ * @template R - The required services type
+ * @param generatorFn - A function that returns an async generator
+ * @returns AsyncFx<A, E, R>
+ *
+ * @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.fromTry(async () => await response.json())
+ * })
+ * // Type: Fx<unknown, Error, Logger>
+ * ```
+ */
+declare function fxGen<A, E, R>(generatorFn: () => AsyncFxGenerator<A, E, R>): AsyncFx<A, E, R>;
+/**
+ * Execute a sync computation immediately and return the result.
+ * 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 Result<A, E>
+ *
+ * @example
+ * ```ts
+ * const result = Fx.fn(function* () {
+ *   const a = yield* Result.ok(10)
+ *   const b = yield* Result.ok(20)
+ *   return a + b
+ * })
+ * // Type: Result<number, never>
+ * // result = { ok: true, value: 30 }
+ * ```
+ */
+declare function fxFn<A, E>(generatorFn: () => FxGenerator<A, E, never>): Result$1<A, E>;
+/**
+ * Execute an async computation immediately and return a Promise of the result.
+ * 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<Result<A, E>>
+ *
+ * @example
+ * ```ts
+ * const result = await Fx.fn(async function* () {
+ *   const response = await fetch("/api/users")
+ *   const data = yield* Result.fromTry(async () => await response.json())
+ *   return data
+ * })
+ * // Type: Promise<Result<unknown, Error>>
+ * ```
+ */
+declare function fxFn<A, E>(generatorFn: () => AsyncFxGenerator<A, E, never>): Promise<Result$1<A, E>>;
+/**
+ * Execute a sync computation with service dependencies immediately.
+ * 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 Result<A, E | E2>
+ *
+ * @example
+ * ```ts
+ * const result = Fx.fn(function* () {
+ *   const config = yield* Config
+ *   const logger = yield* Logger
+ *   logger.info(`DB URL: ${config.dbUrl}`)
+ *   return config.dbUrl
+ * }, provide(AppLayer))
+ * // Type: Result<string, never>
+ * ```
+ */
+declare function fxFn<A, E, E2, R>(generatorFn: () => FxGenerator<A, E, R>, provider: (fx: Fx$1<A, E, R>) => Fx$1<A, E | E2, never>): Result$1<A, E | E2>;
+/**
+ * Execute an async computation with service dependencies immediately.
+ * 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<Result<A, E | E2>>
+ *
+ * @example
+ * ```ts
+ * const result = await Fx.fn(async function* () {
+ *   const config = yield* Config
+ *   await doAsyncWork()
+ *   return config.dbUrl
+ * }, provide(AppLayer))
+ * // Type: Promise<Result<string, never>>
+ * ```
+ */
+declare function fxFn<A, E, E2, R>(generatorFn: () => AsyncFxGenerator<A, E, R>, provider: (fx: Fx$1<A, E, R>) => Fx$1<A, E | E2, never>): Promise<Result$1<A, E | E2>>;
+/**
+ * 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.ok()` - Create successful results (alias for Result.ok)
+ * - `Fx.err()` - Create error results (alias for Result.err)
+ *
+ * @example
+ * ```ts
+ * import { Fx, Service, Layer, provide, pipe } from "@repo/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 result = pipe(myWorkflow, provide(AppLayer)).run()
+ * ```
+ */
+declare const Fx: {
+  readonly gen: typeof fxGen;
+  readonly fn: typeof fxFn;
+  readonly ok: <T>(value: T) => Result$1<T, never>;
+  readonly err: <E>(error: E) => Result$1<never, E>;
+};
+//#endregion
+//#region src/fx/service.d.ts
+/**
+ * The interface returned by Service()().
+ * Acts as both a type tag and a runtime lookup key.
+ */
+type ServiceClass<Self, Key extends string = string> = {
+  readonly _tag: "Service";
+  readonly key: Key;
+  readonly _Self: Self;
+  /**
+   * Yielding the service class in a gen computation
+   * returns the service instance from context.
+   */
+  [Symbol.iterator](): Generator<ServiceRequest<Self>, Self, unknown>;
+};
+/**
+ * Extract the service type from a ServiceClass.
+ */
+type ServiceOf<T> = T extends ServiceClass<infer S> ? S : 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>;
+//#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 "@repo/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, B>(a: Context<A>, b: Context<B>) => Context<A | 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, never> | AsyncFx<void, never>): SyncFx<void, never>;
+  /**
+   * 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$1<unknown, unknown>): SyncFx<void, never> | AsyncFx<void, never>;
+  /**
+   * 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: ServiceClass<ScopeService, "@std/Scope"> & (new () => ScopeService);
+declare class ScopeTag extends ScopeTag_base {}
+/**
+ * Type utility to exclude Scope from requirements.
+ * Used by Layer.scoped to auto-provide Scope.
+ */
+type ExcludeScope<R> = Exclude<R, 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 An Fx producing the layer's context
+   */
+  getOrBuild<ROut, E, RIn>(layer: Layer$1<ROut, E, RIn>, scope: ScopeService, deps: Context<RIn>): Fx$1<Context<ROut>, E>;
+  /**
+   * Clear the cache.
+   * Useful for testing.
+   */
+  clear(): void;
+  /**
+   * Get the number of cached layers.
+   */
+  get size(): number;
+}
+//#endregion
+//#region src/fx/layer.types.d.ts
+/**
+ * Layer<ROut, E, RIn> describes how to build services:
+ * - ROut: Services this layer provides
+ * - E: Errors that can occur during construction
+ * - RIn: Services this layer requires to build
+ */
+type Layer$1<ROut, E = never, RIn = never> = {
+  readonly _tag: "Layer";
+  /** Phantom type for output services */
+  readonly _ROut: ROut;
+  /** Phantom type for errors */
+  readonly _E: E;
+  /** Phantom type for input requirements */
+  readonly _RIn: RIn;
+  /**
+   * Build the layer given its dependencies.
+   * Returns an Fx that produces a Context with the provided services.
+   *
+   * @param memoMap - Cache for layer memoization
+   * @param scope - Scope for resource management
+   * @returns An Fx that produces the context
+   */
+  build(memoMap: MemoMap, scope: ScopeService): Fx$1<Context<ROut>, E, 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 extends readonly Layer$1<unknown, unknown, unknown>[]> = L[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 extends readonly Layer$1<unknown, unknown, unknown>[]> = L[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 extends readonly Layer$1<unknown, unknown, unknown>[]> = Exclude<MergeRIn<L>, MergeROut<L>>;
+/**
+ * Merge all RIn types from an array of layers into a union.
+ */
+type MergeRIn<L extends readonly Layer$1<unknown, unknown, unknown>[]> = L[number] extends Layer$1<unknown, unknown, infer RIn> ? RIn : never;
+//#endregion
+//#region src/fx/layer.d.ts
+declare const Layer: {
+  readonly ok: <S>(service: ServiceClass<S>, impl: S) => Layer$1<S, never>;
+  readonly err: <E>(error: E) => Layer$1<never, E>;
+  readonly fx: <S>(service: ServiceClass<S>) => <E, R>(fx: Fx$1<S, E, R>) => Layer$1<S, E, R>;
+  readonly scoped: <S>(service: ServiceClass<S>) => <E, R>(fx: Fx$1<S, E, R | ScopeService>) => Layer$1<S, E, ExcludeScope<R>>;
+  readonly provide: <DepsROut, DepsE, DepsRIn>(deps: Layer$1<DepsROut, DepsE, DepsRIn>) => <ROut, E, RIn extends DepsROut>(layer: Layer$1<ROut, E, RIn>) => Layer$1<ROut | DepsROut, E | DepsE, DepsRIn>;
+  readonly merge: <L extends Layer$1<unknown, unknown, unknown>[]>(...layers: L) => Layer$1<MergeROut<L>, MergeError<L>, UnprovidedDeps<L>>;
+};
+//#endregion
+//#region src/fx/provide.d.ts
+/**
+ * Provide a layer to an Fx computation, resolving all service requirements.
+ * Creates a new scope for resource management.
+ *
+ * @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 = pipe(
+ *   updateDocumentWorkflow(userId, docId, data),
+ *   provide(AppLayer)
+ * ).run()
+ * ```
+ */
+declare const provide: <ROut, E2>(layer: Layer$1<ROut, E2>) => <A, E, R extends ROut>(fx: Fx$1<A, E, R>) => Fx$1<A, E | E2, never>;
+/**
+ * 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 = pipe(
+ *   myWorkflow,
+ *   provideContext(ctx)
+ * ).run()
+ * ```
+ */
+declare const provideContext: <R>(ctx: Context<R>) => <A, E>(fx: Fx$1<A, E, R>) => Fx$1<A, E>;
+/**
+ * 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 = pipe(
+ *   myWorkflow,
+ *   provideService(Config, configImpl),
+ *   provideService(Logger, loggerImpl),
+ * ).run()
+ * ```
+ */
+declare const provideService: <S>(service: ServiceClass<S>, impl: S) => <A, E, R>(fx: Fx$1<A, E, R | S>) => Fx$1<A, E, Exclude<R, S>>;
+//#endregion
 //#region src/std.d.ts
 /**
  * Main Std namespace containing all utility functions and types.
@@ -94,9 +721,49 @@ declare const Std: {
   Brand: {
     readonly make: <B extends Branded<unknown, string>>(value: Unbrand<B>) => B;
     readonly unsafeMake: <B extends Branded<unknown, string>>(value: Unbrand<B>) => B;
-    readonly is: <T, K extends string>(validator: Validator<T>) => ((value: T) => value is Branded<T, K>);
+    readonly is: <T, K$1 extends string>(validator: Validator<T>) => ((value: T) => value is Branded<T, K$1>);
     readonly refine: <B extends Branded<unknown, string>>(validator: Validator<Unbrand<B>>, errorMessage?: string | ((value: Unbrand<B>) => string)) => ((value: Unbrand<B>) => Result$1<B, BrandError<Unbrand<B>>>);
   };
+  Fx: {
+    readonly gen: {
+      <A, E, R>(generatorFn: () => FxGenerator<A, E, R>): SyncFx<A, E, R>;
+      <A, E, R>(generatorFn: () => AsyncFxGenerator<A, E, R>): AsyncFx<A, E, R>;
+    };
+    readonly fn: {
+      <A, E>(generatorFn: () => FxGenerator<A, E, never>): Result$1<A, E>;
+      <A, E>(generatorFn: () => AsyncFxGenerator<A, E, never>): Promise<Result$1<A, E>>;
+      <A, E, E2, R>(generatorFn: () => FxGenerator<A, E, R>, provider: (fx: Fx$1<A, E, R>) => Fx$1<A, E | E2, never>): Result$1<A, E | E2>;
+      <A, E, E2, R>(generatorFn: () => AsyncFxGenerator<A, E, R>, provider: (fx: Fx$1<A, E, R>) => Fx$1<A, E | E2, never>): Promise<Result$1<A, E | E2>>;
+    };
+    readonly ok: <T>(value: T) => Result$1<T, never>;
+    readonly err: <E>(error: E) => Result$1<never, E>;
+  };
+  Service: typeof Service;
+  Layer: {
+    readonly ok: <S>(service: ServiceClass<S>, impl: S) => Layer$1<S, never>;
+    readonly err: <E>(error: E) => Layer$1<never, E>;
+    readonly fx: <S>(service: ServiceClass<S>) => <E, R>(fx: Fx$1<S, E, R>) => Layer$1<S, E, R>;
+    readonly scoped: <S>(service: ServiceClass<S>) => <E, R>(fx: Fx$1<S, E, R | ScopeService>) => Layer$1<S, E, ExcludeScope<R>>;
+    readonly provide: <DepsROut, DepsE, DepsRIn>(deps: Layer$1<DepsROut, DepsE, DepsRIn>) => <ROut, E, RIn extends DepsROut>(layer: Layer$1<ROut, E, RIn>) => Layer$1<ROut | DepsROut, E | DepsE, DepsRIn>;
+    readonly merge: <L extends Layer$1<unknown, unknown, unknown>[]>(...layers: L) => Layer$1<MergeROut<L>, MergeError<L>, UnprovidedDeps<L>>;
+  };
+  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, B>(a: Context<A>, b: Context<B>) => Context<A | B>;
+    readonly get: {
+      <S>(ctx: Context<S>, service: ServiceClass<S>): S;
+      <S>(service: ServiceClass<S>): (ctx: Context<S>) => S;
+    };
+    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>;
+  };
+  Scope: typeof ScopeTag;
+  provide: <ROut, E2>(layer: Layer$1<ROut, E2>) => <A, E, R extends ROut>(fx: Fx$1<A, E, R>) => Fx$1<A, E | E2, never>;
   ok: <T>(value: T) => Result$1<T, never>;
   err: <E>(error: E) => Result$1<never, E>;
   isOk: <T, E>(result: Result$1<T, E>) => result is Extract<Result$1<T, E>, {
@@ -131,5 +798,5 @@ declare const Std: {
   tuple: typeof tuple;
 };
 //#endregion
-export { type ADT, type ArrayValue, type AsyncComputation, type AsyncYieldable, Brand, type BrandError, type BrandKey, type Brand$1 as BrandType, type Branded, type Computation, Either, type Either$1 as EitherType, Err, type ErrorData, type ErrorTag, type Infer, type InferInput, type InferOutput, type None, Option, type Option$1 as OptionType, Predicate, type Predicate$1 as PredicateType, type RecordDef, type RecordObject, type Refinement, Result, type Result$1 as ResultType, Std, type StructValue, type SyncComputation, type TaggedConstructor, TaggedError, type TaggedErrorFactory, type TaggedErrorInstance, type TaggedError$1 as TaggedErrorType, type TaggedValue, type TupleValue, type Unbrand, type ValidationError, type Yieldable, array, data, ensure, ensureRefinement, flow, fn, gen, pipe, record, struct, tagged, tuple };
+export { type ADT, type ArrayValue, type AsyncComputation, type AsyncFx, type AsyncYieldable, Brand, type BrandError, type BrandKey, type Brand$1 as BrandType, type Branded, type Computation, Context, type Context as ContextType, Either, type Either$1 as EitherType, Err, type ErrorData, type ErrorTag, Fx, type FxError, type FxRequirements, type FxSuccess, type Fx$1 as FxType, type Infer, type InferInput, type InferOutput, Layer, type LayerError, type LayerRIn, type LayerROut, type Layer$1 as LayerType, type None, Option, type Option$1 as OptionType, Predicate, type Predicate$1 as PredicateType, type RecordDef, type RecordObject, type Refinement, Result, type Result$1 as ResultType, ScopeTag as Scope, type ScopeService, Service, type ServiceClass, type ServiceOf, type ServiceRequest, Std, type StructValue, type SyncComputation, type SyncFx, type TaggedConstructor, TaggedError, type TaggedErrorFactory, type TaggedErrorInstance, type TaggedError$1 as TaggedErrorType, type TaggedValue, type TupleValue, type Unbrand, type ValidationError, type Yieldable, array, data, ensure, ensureRefinement, flow, fn, gen, pipe, provide, provideContext, provideService, record, serviceTag, struct, tagged, tuple };
 //# sourceMappingURL=index.d.mts.map