@nicolastoulemont/std 0.5.1 → 0.7.0

package/dist/index-Dm2dFysv.d.mts

@@ -0,0 +1,415 @@
+import { a as OptionFilter, c as OptionMatch, d as OptionUnwrapOr, f as OptionUnwrapOrElse, i as OptionAll, l as OptionOrElse, n as NoSuchElementError$1, o as OptionFlatMap, r as Option$1, s as OptionMap, t as FromTryReturn, u as OptionTap } from "./option.types-DlAb6Sr0.mjs";
+
+//#region src/option/option.d.ts
+declare namespace option_d_exports {
+  export { NoSuchElementError, Option, all, filter, flatMap, fromNullable, fromTry, isNone, isSome, map, match, none, orElse, some, tap, unwrapOr, unwrapOrElse };
+}
+/**
+ * Re-exported error type used when yielding `Option.none()` in `Fx.gen`.
+ *
+ * @example
+ * ```ts
+ * import { Option } from "@nicolastoulemont/std"
+ *
+ * const error = new Option.NoSuchElementError()
+ * // => error.name === "NoSuchElementError"
+ * ```
+ *
+ * @category Re-exports
+ */
+declare const NoSuchElementError: typeof NoSuchElementError$1;
+/**
+ * Re-exported `NoSuchElementError` instance type.
+ *
+ * @example
+ * ```ts
+ * import type { Option } from "@nicolastoulemont/std"
+ *
+ * type Example = Option.NoSuchElementError
+ * ```
+ *
+ * @category Re-exports
+ */
+type NoSuchElementError = InstanceType<typeof NoSuchElementError$1>;
+/**
+ * Re-exported `Option` type.
+ *
+ * @example
+ * ```ts
+ * import type { Option } from "@nicolastoulemont/std"
+ *
+ * type Example = Option.Option<unknown>
+ * ```
+ *
+ * @category Re-exports
+ */
+type Option<T> = Option$1<T>;
+/**
+ * Create an Option with a value.
+ *
+ * @param value - The value to wrap
+ * @returns An Option with `_tag: "Some"`
+ *
+ * @example
+ * ```ts
+ * import { Option } from "@nicolastoulemont/std"
+ *
+ * const value = Option.some(42)
+ * // => { _tag: "Some", value: 42 }
+ * ```
+ *
+ * @category Constructors
+ */
+declare const some: <T>(value: T) => Option$1<T>;
+/**
+ * Create an Option with no value.
+ *
+ * @returns An Option with `_tag: "None"`
+ *
+ * @example
+ * ```ts
+ * import { Option } from "@nicolastoulemont/std"
+ *
+ * const value = Option.none<number>()
+ * // => { _tag: "None" }
+ * ```
+ *
+ * @category Constructors
+ */
+declare const none: <T = never>() => Option$1<T>;
+/**
+ * Check if an Option has a value.
+ *
+ * @param option - The Option to check
+ * @returns true if the Option is some
+ *
+ * @example
+ * ```ts
+ * import { Option } from "@nicolastoulemont/std"
+ *
+ * const value = Option.isSome(Option.some(1))
+ * // => true
+ * ```
+ *
+ * @category Guards
+ */
+declare const isSome: <T>(option: Option$1<T>) => option is Extract<Option$1<T>, {
+  _tag: "Some";
+}>;
+/**
+ * isNone utility.
+ *
+ * @example
+ * ```ts
+ * import { Option } from "@nicolastoulemont/std"
+ *
+ * const value = Option.isNone(Option.none())
+ * // => true
+ * ```
+ *
+ * @category Guards
+ */
+declare const isNone: <T>(option: Option$1<T>) => option is Extract<Option$1<T>, {
+  _tag: "None";
+}>;
+/**
+ * Transform the value of an Option.
+ * If the Option is none, it passes through unchanged.
+ *
+ * Supports both data-first and data-last calling styles:
+ * - Data-first: `map(option, fn)`
+ * - Data-last: `pipe(option, map(fn))`
+ *
+ * Supports both sync and async functions:
+ * - Sync fn: returns Option<U>
+ * - Async fn: returns Promise<Option<U>>
+ *
+ * @param fn - Function to transform the value
+ * @returns A function that takes an Option and returns a new Option
+ *
+ * @example
+ * ```ts
+ * import { Option } from "@nicolastoulemont/std"
+ *
+ * const input = Option.some(2)
+ * const dataFirst = Option.map(input, (n) => n + 1)
+ * // => { _tag: "Some", value: 3 }
+ *
+ * const dataLast = Option.map((n: number) => n + 1)(input)
+ * // => { _tag: "Some", value: 3 }
+ * ```
+ *
+ * @category Mapping
+ */
+declare const map: OptionMap;
+/**
+ * Chain operations that return Options.
+ * If the Option is none, it passes through unchanged.
+ *
+ * Supports both data-first and data-last calling styles:
+ * - Data-first: `flatMap(option, fn)`
+ * - Data-last: `pipe(option, flatMap(fn))`
+ *
+ * Supports both sync and async functions:
+ * - Sync fn: returns Option<U>
+ * - Async fn: returns Promise<Option<U>>
+ *
+ * @param fn - Function that takes a value and returns an Option (or Promise<Option>)
+ * @returns A function that takes an Option and returns a new Option
+ *
+ * @example
+ * ```ts
+ * import { Option } from "@nicolastoulemont/std"
+ *
+ * const input = Option.some(2)
+ * const dataFirst = Option.flatMap(input, (n) => Option.some(n + 1))
+ * // => { _tag: "Some", value: 3 }
+ *
+ * const dataLast = Option.flatMap((n: number) => Option.some(n + 1))(input)
+ * // => { _tag: "Some", value: 3 }
+ * ```
+ *
+ * @category Sequencing
+ */
+declare const flatMap: OptionFlatMap;
+/**
+ * Perform a side effect on the value without modifying the Option.
+ * Useful for debugging, logging, or other side effects in a pipeline.
+ * If the Option is none, the function is not called.
+ *
+ * Supports both data-first and data-last calling styles:
+ * - Data-first: `tap(option, fn)`
+ * - Data-last: `pipe(option, tap(fn))`
+ *
+ * Supports both sync and async functions:
+ * - Sync fn: returns Option<T>
+ * - Async fn: returns Promise<Option<T>>
+ *
+ * @param fn - Function to call with the value (return value is ignored)
+ * @returns A function that takes an Option and returns the same Option
+ *
+ * @example
+ * ```ts
+ * import { Option } from "@nicolastoulemont/std"
+ *
+ * let seen = 0
+ * const input = Option.some(2)
+ * const dataFirst = Option.tap(input, (n) => {
+ *   seen = n
+ * })
+ * // => { _tag: "Some", value: 2 }
+ *
+ * const dataLast = Option.tap((n: number) => {
+ *   seen = n
+ * })(input)
+ * // => { _tag: "Some", value: 2 }
+ * ```
+ *
+ * @category Sequencing
+ */
+declare const tap: OptionTap;
+/**
+ * Recover from none by providing an alternative Option.
+ * If the Option is some, it passes through unchanged.
+ *
+ * Supports both data-first and data-last calling styles:
+ * - Data-first: `orElse(option, fn)`
+ * - Data-last: `pipe(option, orElse(fn))`
+ *
+ * Supports both sync and async functions:
+ * - Sync fn: returns Option<T | U>
+ * - Async fn: returns Promise<Option<T | U>>
+ *
+ * @param fn - Function that returns an alternative Option
+ * @returns A function that takes an Option and returns a new Option
+ *
+ * @example
+ * ```ts
+ * import { Option } from "@nicolastoulemont/std"
+ *
+ * const input = Option.none<number>()
+ * const dataFirst = Option.orElse(input, () => Option.some(0))
+ * // => { _tag: "Some", value: 0 }
+ *
+ * const dataLast = Option.orElse(() => Option.some(0))(input)
+ * // => { _tag: "Some", value: 0 }
+ * ```
+ *
+ * @category Combining
+ */
+declare const orElse: OptionOrElse;
+/**
+ * Filter an Option based on a predicate.
+ * If the predicate returns false, converts to none.
+ * If the Option is already none, it passes through unchanged.
+ *
+ * Supports both data-first and data-last calling styles:
+ * - Data-first: `filter(option, predicate)`
+ * - Data-last: `pipe(option, filter(predicate))`
+ *
+ * @param predicate - Function that returns true to keep the value
+ * @returns A function that takes an Option and returns a new Option
+ *
+ * @example
+ * ```ts
+ * import { Option } from "@nicolastoulemont/std"
+ *
+ * const input = Option.some(3)
+ * const dataFirst = Option.filter(input, (n) => n > 0)
+ * // => { _tag: "Some", value: 3 }
+ *
+ * const dataLast = Option.filter((n: number) => n > 0)(input)
+ * // => { _tag: "Some", value: 3 }
+ * ```
+ *
+ * @category Filtering
+ */
+declare const filter: OptionFilter;
+/**
+ * Combine multiple Options into a single Option.
+ * Supports both array and object inputs.
+ *
+ * - If all Options are some, returns some with all values
+ * - If any Option is none, returns none (short-circuits)
+ *
+ * For arrays of 1-6 elements, tuple types are inferred automatically.
+ * For longer arrays, use `as const` to preserve tuple structure.
+ *
+ * @example
+ * ```ts
+ * import { Option } from "@nicolastoulemont/std"
+ *
+ * const combined = Option.all([Option.some(1), Option.some(2)] as const)
+ * // => { _tag: "Some", value: [1, 2] }
+ * ```
+ *
+ * @category Combining
+ */
+declare const all: OptionAll;
+/**
+ * Get the value or a default value.
+ *
+ * Supports both data-first and data-last calling styles:
+ * - Data-first: `unwrapOr(option, defaultValue)`
+ * - Data-last: `pipe(option, unwrapOr(defaultValue))`
+ *
+ * Uses NoInfer to prevent type inference from the default value.
+ *
+ * @param defaultValue - Value to return if the Option is none
+ * @returns A function that takes an Option and returns the value or default
+ *
+ * @example
+ * ```ts
+ * import { Option } from "@nicolastoulemont/std"
+ *
+ * const input = Option.none<number>()
+ * const dataFirst = Option.unwrapOr(input, 0)
+ * // => 0
+ *
+ * const dataLast = Option.unwrapOr(0)(input)
+ * // => 0
+ * ```
+ *
+ * @category Getters
+ */
+declare const unwrapOr: OptionUnwrapOr;
+/**
+ * Get the value or compute a value.
+ *
+ * Supports both data-first and data-last calling styles:
+ * - Data-first: `unwrapOrElse(option, fn)`
+ * - Data-last: `pipe(option, unwrapOrElse(fn))`
+ *
+ * @param fn - Function to compute a value
+ * @returns A function that takes an Option and returns the value or computed value
+ *
+ * @example
+ * ```ts
+ * import { Option } from "@nicolastoulemont/std"
+ *
+ * const input = Option.none<number>()
+ * const dataFirst = Option.unwrapOrElse(input, () => 0)
+ * // => 0
+ *
+ * const dataLast = Option.unwrapOrElse(() => 0)(input)
+ * // => 0
+ * ```
+ *
+ * @category Getters
+ */
+declare const unwrapOrElse: OptionUnwrapOrElse;
+/**
+ * Pattern match on an Option, handling both some and none cases.
+ *
+ * Supports both data-first and data-last calling styles:
+ * - Data-first: `match(option, { Some: ..., None: ... })`
+ * - Data-last: `pipe(option, match({ Some: ..., None: ... }))`
+ *
+ * @param handlers - Object with `Some` and `None` handlers
+ * @returns A function that takes an Option and returns the handler result
+ *
+ * @example
+ * ```ts
+ * import { Option } from "@nicolastoulemont/std"
+ *
+ * const input = Option.some(2)
+ * const dataFirst = Option.match(input, {
+ *   Some: (value) => `some:${value}` ,
+ *   None: () => "none" ,
+ * })
+ * // => "some:2"
+ *
+ * const dataLast = Option.match({
+ *   Some: (value: number) => `some:${value}` ,
+ *   None: () => "none" ,
+ * })(input)
+ * // => "some:2"
+ * ```
+ *
+ * @category Pattern Matching
+ */
+declare const match: OptionMatch;
+/**
+ * fromNullable utility.
+ *
+ * @example
+ * ```ts
+ * import { Option } from "@nicolastoulemont/std"
+ *
+ * const value = Option.fromNullable("Ada")
+ * // => { _tag: "Some", value: "Ada" }
+ * ```
+ *
+ * @category Conversions
+ */
+declare const fromNullable: <T>(value: T) => Option$1<NonNullable<T>>;
+/**
+ * Wrap a function that might throw into an Option.
+ * Supports both sync and async functions with automatic type inference.
+ *
+ * - Sync fn: returns Option<T>
+ * - Async fn: returns Promise<Option<T>>
+ *
+ * **Note on `any` return types:** If your function returns `any` (e.g., `JSON.parse`),
+ * you should add an explicit return type annotation. This is because TypeScript's
+ * conditional types cannot determine if `any` is a Promise or not, resulting in a
+ * union type `Promise<Option<unknown>> | Option<any>` that won't work
+ * with Option utilities like `isSome` or `isNone`.
+ *
+ * @param fn - Function that might throw (sync or async)
+ * @returns An Option with the return value or none
+ *
+ * @example
+ * ```ts
+ * import { Option } from "@nicolastoulemont/std"
+ *
+ * const parsed = Option.fromTry(() => Number.parseInt("42", 10))
+ * // => { _tag: "Some", value: 42 }
+ * ```
+ *
+ * @category Conversions
+ */
+declare const fromTry: <T>(fn: () => T) => FromTryReturn<T>;
+//#endregion
+export { option_d_exports as t };
+//# sourceMappingURL=index-Dm2dFysv.d.mts.map

package/dist/index-Dm2dFysv.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index-Dm2dFysv.d.mts","names":[],"sources":["../src/option/option.ts"],"sourcesContent":[],"mappings":";;;;;;;;;;;;;;;;;;;cA4Da,2BAAkB;;;;;;;;AAA/B;AAcA;AAcA;AAwBA;;AAA8C,KAtClC,kBAAA,GAAqB,YAsCa,CAAA,OAtCO,oBAsCP,CAAA;;;AA8B9C;AAkCA;;;;;;;AAgBA;;AAAkC,KAxGtB,MAwGsB,CAAA,CAAA,CAAA,GAxGV,QAwGU,CAxGC,CAwGD,CAAA;;;;;AAqClC;AAwCA;AAwCA;AAwCA;AA8BA;AA8BA;AAkDA;AA6BA;AAmCA;AA2CA;;;AAAsD,cAtczC,IAscyC,EAAA,CAAA,CAAA,CAAA,CAAA,KAAA,EAtcvB,CAscuB,EAAA,GAtcnB,QAscmB,CAtcR,CAscQ,CAAA;;;AA6BtD;;;;;;;;;;;;;cArca,uBAAsB,SAAW;;;;;;;;;;;;;;;;;cAkCjC,oBAAqB,SAAW,iBAAe,QAAQ,SAAW;;;;;;;;;;;;;;;;cAgBlE,oBAAqB,SAAW,iBAAe,QAAQ,SAAW;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;cAqClE,KAAK;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;cAwCL,SAAS;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;cAwCT,KAAK;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;cAwCL,QAAQ;;;;;;;;;;;;;;;;;;;;;;;;;;;cA8BR,QAAQ;;;;;;;;;;;;;;;;;;;;;cA8BR,KAAK;;;;;;;;;;;;;;;;;;;;;;;;;;;cAkDL,UAAU;;;;;;;;;;;;;;;;;;;;;;;;;cA6BV,cAAc;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;cAmCd,OAAO;;;;;;;;;;;;;;cA2CP,yBAA0B,MAAI,SAAW,YAAY;;;;;;;;;;;;;;;;;;;;;;;;;;;cA6BrD,uBAAwB,MAAI,cAAc"}

package/dist/index.d.mts

@@ -1,16 +1,23 @@
-import { a as FxError, c as FxSuccess, h as SyncFx, i as Fx$1, m as ServiceRequest, s as FxRequirements, t as AsyncFx } from "./fx.types-DO-8yG4c.mjs";
-import { n as pipeMethod, t as Pipeable } from "./pipeable-KHu4D8ol.mjs";
-import { A as NoUnion, C as IsAny, D as Last, E as KeysOfType, F as Prettify, I as RequiredKeys, L as Tail, M as OmitByType, N as PartialKeys, O as Length, P as PickByType, R as UnionToIntersection, S as Init, T as IsUnknown, _ as DeepReadonly, g as DeepPrettify, h as DeepPartial, k as Merge, m as DeepMutable, n as Result$1, p as AsyncReturnType, v as DeepRequired, w as IsNever, x as Head, y as Equals } from "./result.types-fIbuBwVQ.mjs";
-import { a as record, d as Infer, f as InferInput, g as ValidationError, h as RecordObject, i as data, m as RecordDef, o as ADT, p as InferOutput } from "./index-DLlx9jiG.mjs";
-import { c as BrandKey, d as Unbrand, o as Brand$1, s as BrandError, t as Brand, u as Branded } from "./index-DjjJIDaA.mjs";
-import { a as ArrayValue, c as TaggedValue, i as tagged, l as TupleValue, n as tuple, o as StructValue, r as struct, s as TaggedConstructor, t as array } from "./index-DtAPrec7.mjs";
-import { i as Option$1, r as None } from "./option.types-Cluybn30.mjs";
-import { O as Either$1, t as Either } from "./index-Bs5TTFlK.mjs";
-import { a as ErrorData, c as TaggedErrorFactory, l as TaggedErrorInstance, n as TaggedError, o as ErrorTag, s as TaggedError$1, t as Err } from "./index-CDio8mJY.mjs";
-import { t as flow } from "./index-BahMvQpA.mjs";
-import { t as Option } from "./index-BQ5wVDSP.mjs";
-import { t as pipe } from "./index-IdejL485.mjs";
-import { E as TaggedMatch, F as Unify, I as UnifyEither, L as UnifyFx, N as Defect, P as Exit, R as UnifyOption, S as ServiceOf, T as Fx, a as Layer$1, b as ServiceClass, c as LayerROut, g as ScopeTag, h as ScopeService, i as Layer, n as provideContext, o as LayerError, r as provideService, s as LayerRIn, t as provide, v as Context, w as serviceTag, y as Service, z as UnifyResult } from "./index-UYodvXes.mjs";
-import { f as Predicate$1, p as Refinement, t as Predicate } from "./index-78LWwTds.mjs";
-import { t as Result } from "./index-BuLJRX1e.mjs";
-export { ADT, ArrayValue, AsyncFx, AsyncReturnType, Brand, BrandError, BrandKey, Brand$1 as BrandType, Branded, Context, Context as ContextType, DeepMutable, DeepPartial, DeepPrettify, DeepReadonly, DeepRequired, Either, Either$1 as EitherType, Equals, Err, ErrorData, ErrorTag, Exit, Exit as ExitType, Defect as ExitDefect, Fx, FxError, FxRequirements, FxSuccess, Fx$1 as FxType, Head, Infer, InferInput, InferOutput, Init, IsAny, IsNever, IsUnknown, KeysOfType, Last, Layer, LayerError, LayerRIn, LayerROut, Layer$1 as LayerType, Length, Merge, NoUnion, None, OmitByType, Option, Option$1 as OptionType, PartialKeys, PickByType, Pipeable, Predicate, Predicate$1 as PredicateType, Prettify, RecordDef, RecordObject, Refinement, RequiredKeys, Result, Result$1 as ResultType, ScopeTag as Scope, ScopeService, Service, ServiceClass, ServiceOf, ServiceRequest, StructValue, SyncFx, TaggedConstructor, TaggedError, TaggedErrorFactory, TaggedErrorInstance, TaggedError$1 as TaggedErrorType, TaggedMatch, TaggedValue, Tail, TupleValue, Unbrand, Unify, UnifyEither, UnifyFx, UnifyOption, UnifyResult, UnionToIntersection, ValidationError, array, data, flow, pipe, pipeMethod, provide, provideContext, provideService, record, serviceTag, struct, tagged, tuple };
+import { t as adt_d_exports } from "./index-DKS1g1oC.mjs";
+import { t as brand_d_exports } from "./index-DXbYlSnB.mjs";
+import { n as service_d_exports } from "./service-DrXU7KJG.mjs";
+import { n as context_d_exports } from "./context-r8ESJiFn.mjs";
+import "./context/index.mjs";
+import { t as data_d_exports } from "./index-DaTvFhZ8.mjs";
+import { t as either_d_exports } from "./index-DSsDFLGw.mjs";
+import { n as flow, t as pipe } from "./index-B_wWGszy.mjs";
+import { r as schedule_d_exports } from "./schedule-DlX2Dg69.mjs";
+import { t as fx_d_exports } from "./index-CugDqdx6.mjs";
+import { r as scope_d_exports } from "./scope-CZdp4wKX.mjs";
+import { t as layer_d_exports } from "./index-7Lv982Om.mjs";
+import { t as multithread_d_exports } from "./index-By6dNRc4.mjs";
+import { t as option_d_exports } from "./index-Dm2dFysv.mjs";
+import { t as order_d_exports } from "./index-CUZn-ohG.mjs";
+import { t as predicate_d_exports } from "./index-B_iY5tq0.mjs";
+import { t as provide_d_exports } from "./index-BiiE8NS7.mjs";
+import { t as queue_d_exports } from "./index-CCo85AdC.mjs";
+import { t as result_d_exports } from "./index-DEAWPlcI.mjs";
+import "./schedule/index.mjs";
+import "./scope/index.mjs";
+import "./service/index.mjs";
+export { adt_d_exports as Adt, brand_d_exports as Brand, context_d_exports as Context, data_d_exports as Data, either_d_exports as Either, fx_d_exports as Fx, layer_d_exports as Layer, multithread_d_exports as Multithread, option_d_exports as Option, order_d_exports as Order, predicate_d_exports as Predicate, provide_d_exports as Provide, queue_d_exports as Queue, result_d_exports as Result, schedule_d_exports as Schedule, scope_d_exports as Scope, service_d_exports as Service, flow, pipe };

package/dist/index.mjs

@@ -1 +1 @@
-import{t as e}from"./pipeable-rQvolRqh.mjs";import{t}from"./flow-CxKQ5yac.mjs";import{t as n}from"./result-B68pxC7l.mjs";import{n as r,r as i}from"./adt-DZmVJG4P.mjs";import{t as a}from"./brand-BUqMmkzC.mjs";import{i as o,n as s,r as c,t as l}from"./data-DzqKBCQg.mjs";import{t as u}from"./option-Qiv7Ls7L.mjs";import{t as d}from"./either-BDY9T5oz.mjs";import{n as f,t as p}from"./err-CYs4b1RV.mjs";import"./flow/index.mjs";import{t as m}from"./pipe-BROILDeC.mjs";import{t as h}from"./predicate-DvXnfmeJ.mjs";import{b as g,c as _,f as v,l as y,n as b,o as x,p as S,r as C,t as w,u as T}from"./fx-C4UuWCqP.mjs";export{a as Brand,y as Context,d as Either,p as Err,g as Exit,S as Fx,_ as Layer,u as Option,h as Predicate,n as Result,x as Scope,T as Service,f as TaggedError,l as array,r as data,t as flow,m as pipe,e as pipeMethod,w as provide,b as provideContext,C as provideService,i as record,v as serviceTag,c as struct,o as tagged,s as tuple};
+import{t as e}from"./adt-DajUZvJe.mjs";import{t}from"./flow-D8_tllWl.mjs";import{i as n}from"./result-BEzV0DYC.mjs";import{t as r}from"./brand-Bia3Vj6l.mjs";import{t as i}from"./context-CCHj1nab.mjs";import"./context/index.mjs";import{n as a}from"./data-CJxw6al9.mjs";import{r as o}from"./option-Qt1H-u7c.mjs";import{t as s}from"./either-6BwadiFj.mjs";import{t as c}from"./functions-BkevX2Dw.mjs";import{a as l}from"./queue-CG5izEBS.mjs";import{t as u}from"./fx-BzxLbf1Q.mjs";import{t as d}from"./layer-BttmtDrs.mjs";import{t as f}from"./multithread-xUUh4eLn.mjs";import{t as p}from"./order-D5c4QChk.mjs";import{t as m}from"./predicate-DUhhQqWY.mjs";import{n as h}from"./scope-qwL1VUh2.mjs";import{t as g}from"./provide-B_SqJpCd.mjs";import"./queue/index.mjs";import{t as _}from"./schedule-C6tjcJ1O.mjs";import"./scope/index.mjs";import{t as v}from"./service-3PYQTUdH.mjs";export{e as Adt,r as Brand,i as Context,a as Data,s as Either,u as Fx,d as Layer,f as Multithread,o as Option,p as Order,m as Predicate,g as Provide,l as Queue,n as Result,_ as Schedule,h as Scope,v as Service,t as flow,c as pipe};

package/dist/layer/index.d.mts

@@ -0,0 +1,2 @@
+import { t as layer_d_exports } from "../index-7Lv982Om.mjs";
+export { layer_d_exports as Layer };

package/dist/layer/index.mjs

@@ -0,0 +1 @@
+import{t as e}from"../layer-BttmtDrs.mjs";export{e as Layer};

package/dist/layer-BttmtDrs.mjs

@@ -0,0 +1,2 @@
+import{t as e}from"./chunk-C934ptG5.mjs";import{t}from"./fx.types-Bg-Mmdm5.mjs";import{i as n,n as r,r as i}from"./context-CCHj1nab.mjs";import{n as a,t as o}from"./service-resolution-C19smeaO.mjs";var s=e({err:()=>h,fx:()=>g,merge:()=>y,ok:()=>m,provide:()=>v,scoped:()=>_});const c=(e,n)=>({_tag:`Layer`,_ROut:void 0,_E:void 0,_RIn:void 0,_Sync:void 0,build:()=>({_tag:`SyncFx`,[t]:{_A:()=>void 0,_E:()=>void 0,_R:()=>void 0},*[Symbol.iterator](){return i(e,n)}})}),l=e=>({_tag:`Layer`,_ROut:void 0,_E:void 0,_RIn:void 0,_Sync:void 0,build:()=>({_tag:`SyncFx`,[t]:{_A:()=>void 0,_E:()=>e,_R:()=>void 0},*[Symbol.iterator](){throw yield e,Error(`Unreachable`)}})});function u(e){return n=>({_tag:`Layer`,_ROut:void 0,_E:void 0,_RIn:void 0,_Sync:void 0,build:()=>n._tag===`AsyncFx`?{_tag:`AsyncFx`,[t]:{_A:()=>void 0,_E:()=>void 0,_R:()=>void 0},async*[Symbol.asyncIterator](){let t=n[Symbol.asyncIterator](),r=await t.next();for(;r.done!==!0;){let e=yield r.value;r=await t.next(e)}return i(e,r.value)}}:{_tag:`SyncFx`,[t]:{_A:()=>void 0,_E:()=>void 0,_R:()=>void 0},*[Symbol.iterator](){let t=n[Symbol.iterator](),r=t.next();for(;r.done!==!0;){let e=yield r.value;r=t.next(e)}return i(e,r.value)}}})}function d(e){return n=>({_tag:`Layer`,_ROut:void 0,_E:void 0,_RIn:void 0,_Sync:void 0,build:(r,a)=>n._tag===`AsyncFx`?{_tag:`AsyncFx`,[t]:{_A:()=>void 0,_E:()=>void 0,_R:()=>void 0},async*[Symbol.asyncIterator](){let t=n[Symbol.asyncIterator](),r=await t.next();for(;r.done!==!0;){let e=r.value;if(o(e)?.key===`@std/Scope`)r=await t.next(a);else{let n=yield e;r=await t.next(n)}}return i(e,r.value)}}:{_tag:`SyncFx`,[t]:{_A:()=>void 0,_E:()=>void 0,_R:()=>void 0},*[Symbol.iterator](){let t=n[Symbol.iterator](),r=t.next();for(;r.done!==!0;){let e=r.value;if(o(e)?.key===`@std/Scope`)r=t.next(a);else{let n=yield e;r=t.next(n)}}return i(e,r.value)}}})}function f(e){return r=>({_tag:`Layer`,_ROut:void 0,_E:void 0,_RIn:void 0,_Sync:void 0,build:(i,o)=>{let s=e.build(i,o);return s._tag===`AsyncFx`?{_tag:`AsyncFx`,[t]:{_A:()=>void 0,_E:()=>void 0,_R:()=>void 0},async*[Symbol.asyncIterator](){let e=s[Symbol.asyncIterator](),t=await e.next();for(;t.done!==!0;){let n=yield t.value;t=await e.next(n)}let c=t.value,l=r.build(i,o);if(l._tag===`AsyncFx`){let e=l[Symbol.asyncIterator](),t=await e.next();for(;t.done!==!0;){let n=t.value,r=a(c,n);if(r!==void 0){t=await e.next(r);continue}let i=yield n;t=await e.next(i)}return n(c,t.value)}let u=l[Symbol.iterator](),d=u.next();for(;d.done!==!0;){let e=d.value,t=a(c,e);if(t!==void 0){d=u.next(t);continue}let n=yield e;d=u.next(n)}return n(c,d.value)}}:{_tag:`SyncFx`,[t]:{_A:()=>void 0,_E:()=>void 0,_R:()=>void 0},*[Symbol.iterator](){let e=s[Symbol.iterator](),t=e.next();for(;t.done!==!0;){let n=yield t.value;t=e.next(n)}let c=t.value,l=r.build(i,o);if(l._tag===`SyncFx`){let e=l[Symbol.iterator](),t=e.next();for(;t.done!==!0;){let n=t.value,r=a(c,n);if(r!==void 0){t=e.next(r);continue}let i=yield n;t=e.next(i)}return n(c,t.value)}throw Error(`Cannot use async layer in sync context`)}}}})}function p(...e){return{_tag:`Layer`,_ROut:void 0,_E:void 0,_RIn:void 0,_Sync:void 0,build:(i,o)=>e.some(e=>e.build(i,o)._tag===`AsyncFx`)?{_tag:`AsyncFx`,[t]:{_A:()=>void 0,_E:()=>void 0,_R:()=>void 0},async*[Symbol.asyncIterator](){let t=r();for(let r of e){let e=r.build(i,o);if(e._tag===`AsyncFx`){let r=e[Symbol.asyncIterator](),i=await r.next();for(;i.done!==!0;){let e=i.value,n=a(t,e);if(n!==void 0){i=await r.next(n);continue}let o=yield e;i=await r.next(o)}t=n(t,i.value)}else{let r=e[Symbol.iterator](),i=r.next();for(;i.done!==!0;){let e=i.value,n=a(t,e);if(n!==void 0){i=r.next(n);continue}let o=yield e;i=r.next(o)}t=n(t,i.value)}}return t}}:{_tag:`SyncFx`,[t]:{_A:()=>void 0,_E:()=>void 0,_R:()=>void 0},*[Symbol.iterator](){let t=r();for(let r of e){let e=r.build(i,o);if(e._tag!==`SyncFx`)throw Error(`Expected sync layer in sync context`);let s=e[Symbol.iterator](),c=s.next();for(;c.done!==!0;){let e=c.value,n=a(t,e);if(n!==void 0){c=s.next(n);continue}let r=yield e;c=s.next(r)}t=n(t,c.value)}return t}}}}const m=c,h=l,g=u,_=d,v=f,y=p;export{s as t};
+//# sourceMappingURL=layer-BttmtDrs.mjs.map

package/dist/layer-BttmtDrs.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"layer-BttmtDrs.mjs","names":["Context.make","fx","layerGen","layerResult","Context.merge","Context.empty"],"sources":["../src/layer/layer.ts"],"sourcesContent":["/**\n * Layer construction and composition for service dependency graphs.\n *\n * **Mental model**\n * - A `Layer` builds one or more services, potentially requiring other services.\n * - Compose layers and provide dependencies before running `Fx`.\n *\n * **Common tasks**\n * - Build from values with `Layer.ok`.\n * - Build from effects with `Layer.fx` or `Layer.scoped`.\n * - Compose with `Layer.provide` and `Layer.merge`.\n *\n * **Gotchas**\n * - Async layers force async execution paths.\n * - Scoped layers require scope finalization.\n *\n * **Quickstart**\n *\n * @example\n * ```ts\n * import { Layer } from \"@nicolastoulemont/std\"\n *\n * import { Service } from \"@nicolastoulemont/std\"\n * \n * const Port = Service.tag<number>(\"Port\")\n * const portLayer = Layer.ok(Port, 3000)\n * // => layer that provides Port\n * ```\n *\n * @module\n */\nimport * as Context from \"../context/context\"\nimport type { Context as ContextType } from \"../context/context\"\nimport { FxTypeId } from \"../fx/fx.types\"\nimport type { RunnableFx, SyncFx, AsyncFx, FxYield } from \"../fx/fx.types\"\nimport type { ScopeService, ExcludeScope } from \"../scope/scope\"\nimport type { ServiceClass } from \"../service/service\"\nimport { asServiceRequest, resolveService } from \"../service/service-resolution\"\nimport type { Layer as LayerType, MergeROut, MergeError, UnprovidedDeps, AllSync } from \"./layer.types\"\n\n/* oxlint-disable no-unsafe-type-assertion -- Layer composition carries erased generic channels and phantom type slots that require assertion-based reconstruction. */\n\n/**\n * Create a layer from a synchronous value (no dependencies).\n */\nconst layerOk = <S>(service: ServiceClass<S>, impl: S): LayerType<S, never, never, true> => ({\n  _tag: \"Layer\",\n  _ROut: undefined as unknown as S,\n  _E: undefined as never,\n  _RIn: undefined as never,\n  _Sync: undefined as unknown as true,\n  build: (): SyncFx<ContextType<S>> => ({\n    _tag: \"SyncFx\",\n    [FxTypeId]: {\n      _A: () => undefined as unknown as ContextType<S>,\n      _E: () => undefined as never,\n      _R: () => undefined as never,\n    },\n    // oxlint-disable-next-line require-yield\n    *[Symbol.iterator](): Generator<never, ContextType<S>, unknown> {\n      return Context.make(service, impl)\n    },\n  }),\n})\n\n/**\n * Create a layer that always fails with an error.\n */\nconst layerErr = <E>(error: E): LayerType<never, E, never, true> => ({\n  _tag: \"Layer\",\n  _ROut: undefined as never,\n  _E: undefined as unknown as E,\n  _RIn: undefined as never,\n  _Sync: undefined as unknown as true,\n  build: (): SyncFx<ContextType, E> => ({\n    _tag: \"SyncFx\",\n    [FxTypeId]: {\n      _A: () => undefined as never,\n      _E: () => error,\n      _R: () => undefined as never,\n    },\n    *[Symbol.iterator](): Generator<E, never, unknown> {\n      yield error\n      throw new Error(\"Unreachable\")\n    },\n  }),\n})\n\n/**\n * Create a layer from an Fx computation (can have dependencies).\n * The Sync type parameter is inferred from the input fx:\n * - SyncFx input → Layer with Sync=true\n * - AsyncFx input → Layer with Sync=false\n *\n * @example\n * ```ts\n * import { Layer } from \"@nicolastoulemont/std\"\n *\n * import { Fx, Service } from \"@nicolastoulemont/std\"\n * \n * const Port = Service.tag<number>(\"Port\")\n * const portLayer = Layer.fx(Port)(Fx.gen(function* () {\n *   return 3000\n * }))\n * // => effect-backed layer\n * ```\n *\n * @category Constructors\n */\nfunction layerFx<S>(service: ServiceClass<S>): {\n  <E, R>(fx: SyncFx<S, E, R>): LayerType<S, E, R, true>\n  <E, R>(fx: AsyncFx<S, E, R>): LayerType<S, E, R, false>\n  <E, R>(fx: RunnableFx<S, E, R>): LayerType<S, E, R>\n}\nfunction layerFx<S>(service: ServiceClass<S>) {\n  return <E, R>(fx: RunnableFx<S, E, R>): LayerType<S, E, R> => ({\n    _tag: \"Layer\",\n    _ROut: undefined as unknown as S,\n    _E: undefined as unknown as E,\n    _RIn: undefined as unknown as R,\n    _Sync: undefined as unknown as boolean,\n    build: (): RunnableFx<ContextType<S>, E, R> => {\n      if (fx._tag === \"AsyncFx\") {\n        return {\n          _tag: \"AsyncFx\",\n          [FxTypeId]: {\n            _A: () => undefined as unknown as ContextType<S>,\n            _E: () => undefined as unknown as E,\n            _R: () => undefined as unknown as R,\n          },\n          async *[Symbol.asyncIterator](): AsyncGenerator<FxYield<E, R>, ContextType<S>, unknown> {\n            const gen = fx[Symbol.asyncIterator]()\n            let result = await gen.next()\n            while (result.done !== true) {\n              const value = yield result.value\n              // oxlint-disable-next-line no-await-in-loop\n              result = await gen.next(value)\n            }\n            return Context.make(service, result.value)\n          },\n        } as AsyncFx<ContextType<S>, E, R>\n      }\n\n      return {\n        _tag: \"SyncFx\",\n        [FxTypeId]: {\n          _A: () => undefined as unknown as ContextType<S>,\n          _E: () => undefined as unknown as E,\n          _R: () => undefined as unknown as R,\n        },\n        *[Symbol.iterator](): Generator<FxYield<E, R>, ContextType<S>, unknown> {\n          const gen = fx[Symbol.iterator]()\n          let result = gen.next()\n          while (result.done !== true) {\n            const value = yield result.value\n            result = gen.next(value)\n          }\n          return Context.make(service, result.value)\n        },\n      } as SyncFx<ContextType<S>, E, R>\n    },\n  })\n}\n\n/**\n * Create a scoped layer (with resource cleanup).\n * The Sync type parameter is inferred from the input fx.\n *\n * @example\n * ```ts\n * import { Layer } from \"@nicolastoulemont/std\"\n *\n * import { Fx, Service } from \"@nicolastoulemont/std\"\n * \n * const Resource = Service.tag<{ close: () => void }>(\"Resource\")\n * const resourceLayer = Layer.scoped(Resource)(Fx.gen(function* () {\n *   return { close: () => undefined }\n * }) as never)\n * // => scoped layer with finalization support\n * ```\n *\n * @category Constructors\n */\nfunction layerScoped<S>(service: ServiceClass<S>): {\n  <E, R>(fx: SyncFx<S, E, R | ScopeService>): LayerType<S, E, ExcludeScope<R>, true>\n  <E, R>(fx: AsyncFx<S, E, R | ScopeService>): LayerType<S, E, ExcludeScope<R>, false>\n  <E, R>(fx: RunnableFx<S, E, R | ScopeService>): LayerType<S, E, ExcludeScope<R>>\n}\nfunction layerScoped<S>(service: ServiceClass<S>) {\n  return <E, R>(fx: RunnableFx<S, E, R | ScopeService>): LayerType<S, E, ExcludeScope<R>> => ({\n    _tag: \"Layer\",\n    _ROut: undefined as unknown as S,\n    _E: undefined as unknown as E,\n    _RIn: undefined as unknown as ExcludeScope<R>,\n    _Sync: undefined as unknown as boolean,\n    build: (_memoMap, scope): RunnableFx<ContextType<S>, E, ExcludeScope<R>> => {\n      if (fx._tag === \"AsyncFx\") {\n        return {\n          _tag: \"AsyncFx\",\n          [FxTypeId]: {\n            _A: () => undefined as unknown as ContextType<S>,\n            _E: () => undefined as unknown as E,\n            _R: () => undefined as unknown as ExcludeScope<R>,\n          },\n          async *[Symbol.asyncIterator](): AsyncGenerator<FxYield<E, ExcludeScope<R>>, ContextType<S>, unknown> {\n            const gen = fx[Symbol.asyncIterator]()\n            let result = await gen.next()\n            while (result.done !== true) {\n              const yielded = result.value\n              const serviceRequest = asServiceRequest(yielded)\n              if (serviceRequest?.key === \"@std/Scope\") {\n                // oxlint-disable-next-line no-await-in-loop\n                result = await gen.next(scope)\n              } else {\n                const value = yield yielded as FxYield<E, ExcludeScope<R>>\n                // oxlint-disable-next-line no-await-in-loop\n                result = await gen.next(value)\n              }\n            }\n            return Context.make(service, result.value)\n          },\n        } as AsyncFx<ContextType<S>, E, ExcludeScope<R>>\n      }\n\n      return {\n        _tag: \"SyncFx\",\n        [FxTypeId]: {\n          _A: () => undefined as unknown as ContextType<S>,\n          _E: () => undefined as unknown as E,\n          _R: () => undefined as unknown as ExcludeScope<R>,\n        },\n        *[Symbol.iterator](): Generator<FxYield<E, ExcludeScope<R>>, ContextType<S>, unknown> {\n          const gen = fx[Symbol.iterator]()\n          let result = gen.next()\n          while (result.done !== true) {\n            const yielded = result.value\n            const serviceRequest = asServiceRequest(yielded)\n            if (serviceRequest?.key === \"@std/Scope\") {\n              result = gen.next(scope)\n            } else {\n              const value = yield yielded as FxYield<E, ExcludeScope<R>>\n              result = gen.next(value)\n            }\n          }\n          return Context.make(service, result.value)\n        },\n      } as SyncFx<ContextType<S>, E, ExcludeScope<R>>\n    },\n  })\n}\n\n// ============================================================================\n// Layer Composition\n// ============================================================================\n\n/**\n * Provide dependencies to a layer and merge outputs.\n * Sync is preserved only if both the deps layer and the consuming layer are sync.\n *\n * @example\n * ```ts\n * import { Layer } from \"@nicolastoulemont/std\"\n *\n * import { Service } from \"@nicolastoulemont/std\"\n * \n * const Logger = Service.tag<{ log: (message: string) => void }>(\"Logger\")\n * const App = Service.tag<{ start: () => void }>(\"App\")\n * const loggerLayer = Layer.ok(Logger, { log: () => undefined })\n * const appLayer = Layer.ok(App, { start: () => undefined })\n * const provided = Layer.provide(loggerLayer)(appLayer)\n * // => composed layer\n * ```\n *\n * @category Sequencing\n */\nfunction layerProvide<DepsROut, DepsE, DepsRIn, DepsSync extends boolean>(\n  deps: LayerType<DepsROut, DepsE, DepsRIn, DepsSync>,\n): {\n  <ROut, E, RIn extends DepsROut, LayerSync extends boolean>(\n    layer: LayerType<ROut, E, RIn, LayerSync>,\n  ): LayerType<ROut | DepsROut, E | DepsE, DepsRIn, LayerSync extends true ? DepsSync : false>\n}\nfunction layerProvide<DepsROut, DepsE, DepsRIn>(deps: LayerType<DepsROut, DepsE, DepsRIn>) {\n  return <ROut, E, RIn extends DepsROut>(\n    layer: LayerType<ROut, E, RIn>,\n  ): LayerType<ROut | DepsROut, E | DepsE, DepsRIn> => ({\n    _tag: \"Layer\",\n    _ROut: undefined as unknown as ROut | DepsROut,\n    _E: undefined as unknown as E | DepsE,\n    _RIn: undefined as unknown as DepsRIn,\n    _Sync: undefined as unknown as boolean,\n    build: (memoMap, scope): RunnableFx<ContextType<ROut | DepsROut>, E | DepsE, DepsRIn> => {\n      const depsBuildFx = deps.build(memoMap, scope)\n\n      if (depsBuildFx._tag === \"AsyncFx\") {\n        return {\n          _tag: \"AsyncFx\",\n          [FxTypeId]: {\n            _A: () => undefined as unknown as ContextType<ROut | DepsROut>,\n            _E: () => undefined as unknown as E | DepsE,\n            _R: () => undefined as unknown as DepsRIn,\n          },\n          async *[Symbol.asyncIterator](): AsyncGenerator<\n            FxYield<E | DepsE, DepsRIn>,\n            ContextType<ROut | DepsROut>,\n            unknown\n          > {\n            const depsGen = depsBuildFx[Symbol.asyncIterator]()\n            let depsResult = await depsGen.next()\n            while (depsResult.done !== true) {\n              const value = yield depsResult.value\n              // oxlint-disable-next-line no-await-in-loop\n              depsResult = await depsGen.next(value)\n            }\n            const depsCtx = depsResult.value\n\n            const layerBuildFx = layer.build(memoMap, scope)\n            if (layerBuildFx._tag === \"AsyncFx\") {\n              const layerGen = layerBuildFx[Symbol.asyncIterator]()\n              let layerResult = await layerGen.next()\n              while (layerResult.done !== true) {\n                const yielded = layerResult.value\n                const service = resolveService(depsCtx, yielded)\n                if (service !== undefined) {\n                  // oxlint-disable-next-line no-await-in-loop\n                  layerResult = await layerGen.next(service)\n                  continue\n                }\n                const value = yield yielded as FxYield<E, DepsRIn>\n                // oxlint-disable-next-line no-await-in-loop\n                layerResult = await layerGen.next(value)\n              }\n              return Context.merge(depsCtx, layerResult.value)\n            }\n\n            const layerGen = layerBuildFx[Symbol.iterator]()\n            let layerResult = layerGen.next()\n            while (layerResult.done !== true) {\n              const yielded = layerResult.value\n              const service = resolveService(depsCtx, yielded)\n              if (service !== undefined) {\n                layerResult = layerGen.next(service)\n                continue\n              }\n              const value = yield yielded as FxYield<E, DepsRIn>\n              layerResult = layerGen.next(value)\n            }\n            return Context.merge(depsCtx, layerResult.value)\n          },\n        } as AsyncFx<ContextType<ROut | DepsROut>, E | DepsE, DepsRIn>\n      }\n\n      return {\n        _tag: \"SyncFx\",\n        [FxTypeId]: {\n          _A: () => undefined as unknown as ContextType<ROut | DepsROut>,\n          _E: () => undefined as unknown as E | DepsE,\n          _R: () => undefined as unknown as DepsRIn,\n        },\n        *[Symbol.iterator](): Generator<FxYield<E | DepsE, DepsRIn>, ContextType<ROut | DepsROut>, unknown> {\n          const depsGen = depsBuildFx[Symbol.iterator]()\n          let depsResult = depsGen.next()\n          while (depsResult.done !== true) {\n            const value = yield depsResult.value\n            depsResult = depsGen.next(value)\n          }\n          const depsCtx = depsResult.value\n\n          const layerBuildFx = layer.build(memoMap, scope)\n          if (layerBuildFx._tag === \"SyncFx\") {\n            const syncGen = layerBuildFx[Symbol.iterator]()\n            let layerResult = syncGen.next()\n            while (layerResult.done !== true) {\n              const yielded = layerResult.value\n              const service = resolveService(depsCtx, yielded)\n              if (service !== undefined) {\n                layerResult = syncGen.next(service)\n                continue\n              }\n              const value = yield yielded as FxYield<E, DepsRIn>\n              layerResult = syncGen.next(value)\n            }\n            return Context.merge(depsCtx, layerResult.value)\n          }\n          throw new Error(\"Cannot use async layer in sync context\")\n        },\n      } as SyncFx<ContextType<ROut | DepsROut>, E | DepsE, DepsRIn>\n    },\n  })\n}\n\n/**\n * Merge multiple layers with automatic dependency resolution.\n * The merged layer is sync only if ALL input layers are sync.\n *\n * @example\n * ```ts\n * import { Layer } from \"@nicolastoulemont/std\"\n *\n * import { Service } from \"@nicolastoulemont/std\"\n * \n * const Logger = Service.tag<{ log: (message: string) => void }>(\"Logger\")\n * const Clock = Service.tag<{ now: () => number }>(\"Clock\")\n * const merged = Layer.merge(\n *   Layer.ok(Logger, { log: () => undefined }),\n *   Layer.ok(Clock, { now: () => Date.now() }),\n * )\n * // => layer that provides Logger | Clock\n * ```\n *\n * @category Combining\n */\nfunction layerMerge<L extends LayerType<unknown, unknown, unknown>[]>(\n  ...layers: L\n): LayerType<MergeROut<L>, MergeError<L>, UnprovidedDeps<L>, AllSync<L>>\nfunction layerMerge<L extends LayerType<unknown, unknown, unknown>[]>(\n  ...layers: L\n): LayerType<MergeROut<L>, MergeError<L>, UnprovidedDeps<L>> {\n  return {\n    _tag: \"Layer\",\n    _ROut: undefined as unknown as MergeROut<L>,\n    _E: undefined as unknown as MergeError<L>,\n    _RIn: undefined as unknown as UnprovidedDeps<L>,\n    _Sync: undefined as unknown as boolean,\n    build: (memoMap, scope): RunnableFx<ContextType<MergeROut<L>>, MergeError<L>, UnprovidedDeps<L>> => {\n      const hasAsync = layers.some((l) => l.build(memoMap, scope)._tag === \"AsyncFx\")\n\n      if (hasAsync) {\n        return {\n          _tag: \"AsyncFx\",\n          [FxTypeId]: {\n            _A: () => undefined as unknown as ContextType<MergeROut<L>>,\n            _E: () => undefined as unknown as MergeError<L>,\n            _R: () => undefined as unknown as UnprovidedDeps<L>,\n          },\n          async *[Symbol.asyncIterator](): AsyncGenerator<\n            FxYield<MergeError<L>, UnprovidedDeps<L>>,\n            ContextType<MergeROut<L>>,\n            unknown\n          > {\n            let ctx = Context.empty() as ContextType<unknown>\n            for (const layer of layers) {\n              const buildFx = layer.build(memoMap, scope)\n              if (buildFx._tag === \"AsyncFx\") {\n                const gen = buildFx[Symbol.asyncIterator]()\n                // oxlint-disable-next-line no-await-in-loop\n                let result = await gen.next()\n                while (result.done !== true) {\n                  const yielded = result.value\n                  const service = resolveService(ctx, yielded)\n                  if (service !== undefined) {\n                    // oxlint-disable-next-line no-await-in-loop\n                    result = await gen.next(service)\n                    continue\n                  }\n                  const value = yield yielded as FxYield<MergeError<L>, UnprovidedDeps<L>>\n                  // oxlint-disable-next-line no-await-in-loop\n                  result = await gen.next(value)\n                }\n                ctx = Context.merge(ctx, result.value)\n              } else {\n                const gen = buildFx[Symbol.iterator]()\n                let result = gen.next()\n                while (result.done !== true) {\n                  const yielded = result.value\n                  const service = resolveService(ctx, yielded)\n                  if (service !== undefined) {\n                    result = gen.next(service)\n                    continue\n                  }\n                  const value = yield yielded as FxYield<MergeError<L>, UnprovidedDeps<L>>\n                  result = gen.next(value)\n                }\n                ctx = Context.merge(ctx, result.value)\n              }\n            }\n            return ctx as ContextType<MergeROut<L>>\n          },\n        } as AsyncFx<ContextType<MergeROut<L>>, MergeError<L>, UnprovidedDeps<L>>\n      }\n\n      return {\n        _tag: \"SyncFx\",\n        [FxTypeId]: {\n          _A: () => undefined as unknown as ContextType<MergeROut<L>>,\n          _E: () => undefined as unknown as MergeError<L>,\n          _R: () => undefined as unknown as UnprovidedDeps<L>,\n        },\n        *[Symbol.iterator](): Generator<FxYield<MergeError<L>, UnprovidedDeps<L>>, ContextType<MergeROut<L>>, unknown> {\n          let ctx = Context.empty() as ContextType<unknown>\n          for (const layer of layers) {\n            const buildFx = layer.build(memoMap, scope)\n            if (buildFx._tag !== \"SyncFx\") {\n              throw new Error(\"Expected sync layer in sync context\")\n            }\n            const gen = buildFx[Symbol.iterator]()\n            let result = gen.next()\n            while (result.done !== true) {\n              const yielded = result.value\n              const service = resolveService(ctx, yielded)\n              if (service !== undefined) {\n                result = gen.next(service)\n                continue\n              }\n              const value = yield yielded as FxYield<MergeError<L>, UnprovidedDeps<L>>\n              result = gen.next(value)\n            }\n            ctx = Context.merge(ctx, result.value)\n          }\n          return ctx as ContextType<MergeROut<L>>\n        },\n      } as SyncFx<ContextType<MergeROut<L>>, MergeError<L>, UnprovidedDeps<L>>\n    },\n  }\n}\n\n/**\n * Create a successful no-dependency layer from a plain service value.\n *\n * @example\n * ```ts\n * import { Layer } from \"@nicolastoulemont/std\"\n *\n * import { Service } from \"@nicolastoulemont/std\"\n * \n * const Port = Service.tag<number>(\"Port\")\n * const portLayer = Layer.ok(Port, 3000)\n * // => layer that provides Port\n * ```\n *\n * @category Constructors\n */\nexport const ok = layerOk\n\n/**\n * Create a layer that always fails with an error.\n *\n * @example\n * ```ts\n * import { Layer } from \"@nicolastoulemont/std\"\n *\n * const failingLayer = Layer.err(\"missing-config\")\n * // => layer that always fails with Err(\"missing-config\")\n * ```\n *\n * @category Constructors\n */\nexport const err = layerErr\n\n/**\n * Create a layer from an effectful service builder.\n *\n * @example\n * ```ts\n * import { Layer } from \"@nicolastoulemont/std\"\n *\n * import { Fx, Service } from \"@nicolastoulemont/std\"\n * \n * const Port = Service.tag<number>(\"Port\")\n * const portLayer = Layer.fx(Port)(Fx.gen(function* () {\n *   return 3000\n * }))\n * // => effect-backed layer\n * ```\n *\n * @category Constructors\n */\nexport const fx = layerFx\n\n/**\n * Create a scoped layer that registers resource finalizers.\n *\n * @example\n * ```ts\n * import { Layer } from \"@nicolastoulemont/std\"\n *\n * import { Fx, Service } from \"@nicolastoulemont/std\"\n * \n * const Resource = Service.tag<{ close: () => void }>(\"Resource\")\n * const resourceLayer = Layer.scoped(Resource)(Fx.gen(function* () {\n *   return { close: () => undefined }\n * }) as never)\n * // => scoped layer with finalization support\n * ```\n *\n * @category Constructors\n */\nexport const scoped = layerScoped\n\n/**\n * Provide one layer to another, satisfying dependencies.\n *\n * @example\n * ```ts\n * import { Layer } from \"@nicolastoulemont/std\"\n *\n * import { Service } from \"@nicolastoulemont/std\"\n * \n * const Logger = Service.tag<{ log: (message: string) => void }>(\"Logger\")\n * const App = Service.tag<{ start: () => void }>(\"App\")\n * const loggerLayer = Layer.ok(Logger, { log: () => undefined })\n * const appLayer = Layer.ok(App, { start: () => undefined })\n * const provided = Layer.provide(loggerLayer)(appLayer)\n * // => composed layer\n * ```\n *\n * @category Sequencing\n */\nexport const provide = layerProvide\n\n/**\n * Merge multiple layers into a single composite layer.\n *\n * @example\n * ```ts\n * import { Layer } from \"@nicolastoulemont/std\"\n *\n * import { Service } from \"@nicolastoulemont/std\"\n * \n * const Logger = Service.tag<{ log: (message: string) => void }>(\"Logger\")\n * const Clock = Service.tag<{ now: () => number }>(\"Clock\")\n * const merged = Layer.merge(\n *   Layer.ok(Logger, { log: () => undefined }),\n *   Layer.ok(Clock, { now: () => Date.now() }),\n * )\n * // => layer that provides Logger | Clock\n * ```\n *\n * @category Combining\n */\nexport const merge = layerMerge\n\n/* oxlint-enable no-unsafe-type-assertion */\n"],"mappings":"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"}

package/dist/layer.types-DgpCIsk_.d.mts

@@ -0,0 +1,100 @@
+import { f as RunnableFx, m as SyncFx } from "./fx.types-DeEWEltG.mjs";
+import { t as Context } from "./context-r8ESJiFn.mjs";
+import { n as ScopeService } from "./scope-CZdp4wKX.mjs";
+
+//#region src/provide/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, RIn>(layer: Layer<ROut, E, RIn>, scope: ScopeService, deps: Context<RIn>): RunnableFx<Context<ROut>, E>;
+  /**
+   * Clear the cache.
+   * Useful for testing.
+   */
+  clear(): void;
+  /**
+   * Get the number of cached layers.
+   */
+  get size(): number;
+}
+//#endregion
+//#region src/layer/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<ROut, E = 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;
+  /** 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, RIn> : RunnableFx<Context<ROut>, E, RIn>;
+};
+/**
+ * Merge all ROut types from an array of layers into a union.
+ */
+type MergeROut<L extends readonly Layer<unknown, unknown, unknown>[]> = L[number] extends Layer<infer ROut, unknown, unknown> ? ROut : never;
+/**
+ * Merge all error types from an array of layers into a union.
+ */
+type MergeError<L extends readonly Layer<unknown, unknown, unknown>[]> = L[number] extends Layer<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<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<unknown, unknown, unknown>[]> = L[number] extends Layer<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 extends readonly Layer<unknown, unknown, unknown>[]> = L extends readonly [] ? true : L extends readonly [Layer<unknown, unknown, unknown, infer S>, ...infer Rest] ? S extends true ? Rest extends readonly Layer<unknown, unknown, unknown>[] ? AllSync<Rest> : false : false : false;
+//#endregion
+export { UnprovidedDeps as a, MergeROut as i, Layer as n, MergeError as r, AllSync as t };
+//# sourceMappingURL=layer.types-DgpCIsk_.d.mts.map