@typed/fx 2.0.0-beta.0 → 2.0.0-beta.10

package/dist/RefSubject/RefRecord.d.ts

@@ -10,21 +10,54 @@ import type * as Fx from "../Fx/index.js";
 import * as RefSubject from "./RefSubject.js";
 /**
  * A RefRecord is a RefSubject specialized over a Record.
- * @since 1.18.0
- * @category models
+ * @remarks
+ * ## Why
+ *
+ * Defines record state with the same current-read, pushed-update, and synchronized-write contract
+ * as RefSubject.
+ *
+ * ## Ownership and lifetime
+ *
+ * RefRecord is a contract and performs no acquisition. Implementations retain the errors,
+ * services, interruption, and Scope requirements expressed by its members.
+ *
+ * @since 1.18.0
+ * @category State models
  */
 export interface RefRecord<in out K extends string, in out V, in out E = never, out R = never> extends RefSubject.RefSubject<Record.ReadonlyRecord<K, V>, E, R> {
 }
 /**
  * Creates a new `RefRecord` from a Record, `Effect`, or `Fx`.
- * @since 1.18.0
- * @category constructors
- */
-export declare function make<K extends string, V, E, R>(initial: Record.ReadonlyRecord<K, V> | Effect.Effect<Record.ReadonlyRecord<K, V>, E, R> | Fx.Fx<Record.ReadonlyRecord<K, V>, E, R>): Effect.Effect<RefRecord<K, V, E>, never, R | Scope.Scope>;
+ * @remarks
+ * ## Why
+ *
+ * Creates record state with equality suited to that Effect data type, so unchanged values do not
+ * produce redundant pushed updates.
+ *
+ * ## Ownership and lifetime
+ *
+ * The creation Effect requires Scope. It owns initializer acquisition, live source subscriptions,
+ * and cleanup; source failures and services stay on reads and pushes.
+ *
+ * @since 1.18.0
+ * @category Constructors
+ */
+export declare function make<K extends string, V, E = never, R = never>(initial: Record.ReadonlyRecord<K, V> | Effect.Effect<Record.ReadonlyRecord<K, V>, E, R> | Fx.Fx<Record.ReadonlyRecord<K, V>, E, R>): Effect.Effect<RefRecord<K, V, E>, never, R | Scope.Scope>;
 /**
  * Set a key-value pair in the Record.
- * @since 1.18.0
- * @category combinators
+ * @remarks
+ * ## Why
+ *
+ * Keeps set atomic with respect to competing RefSubject writes instead of splitting the read and
+ * replacement into separate effects.
+ *
+ * ## Ownership and lifetime
+ *
+ * Running set performs one serialized record transition and resolves with its committed value. It
+ * acquires no resource; failures and services remain those of the source ref.
+ *
+ * @since 1.18.0
+ * @category State updates
  */
 export declare const set: {
     <K extends string, V>(key: K, value: V): <E, R>(ref: RefRecord<K, V, E, R>) => Effect.Effect<Record.ReadonlyRecord<K, V>, E, R>;
@@ -32,8 +65,19 @@ export declare const set: {
 };
 /**
  * Remove a key from the Record.
- * @since 1.18.0
- * @category combinators
+ * @remarks
+ * ## Why
+ *
+ * Applies remove to the committed record value and publishes only the result, preserving its
+ * element order and equality rules.
+ *
+ * ## Ownership and lifetime
+ *
+ * Running remove performs one serialized record transition and resolves with its committed value.
+ * It acquires no resource; failures and services remain those of the source ref.
+ *
+ * @since 1.18.0
+ * @category State updates
  */
 export declare const remove: {
     <K extends string>(key: K): <V, E, R>(ref: RefRecord<K, V, E, R>) => Effect.Effect<Record.ReadonlyRecord<K, V>, E, R>;
@@ -41,8 +85,19 @@ export declare const remove: {
 };
 /**
  * Modify the value at a key if it exists.
- * @since 1.18.0
- * @category combinators
+ * @remarks
+ * ## Why
+ *
+ * Keeps modify atomic with respect to competing RefSubject writes instead of splitting the read
+ * and replacement into separate effects.
+ *
+ * ## Ownership and lifetime
+ *
+ * Running modify performs one serialized record transition and resolves with its committed value.
+ * It acquires no resource; failures and services remain those of the source ref.
+ *
+ * @since 1.18.0
+ * @category State updates
  */
 export declare const modify: {
     <K extends string, V>(key: K, f: (v: V) => V): <E, R>(ref: RefRecord<K, V, E, R>) => Effect.Effect<Record.ReadonlyRecord<K, V>, E, R>;
@@ -50,8 +105,19 @@ export declare const modify: {
 };
 /**
  * Replace the value at a key if it exists.
- * @since 1.18.0
- * @category combinators
+ * @remarks
+ * ## Why
+ *
+ * Keeps replace atomic with respect to competing RefSubject writes instead of splitting the read
+ * and replacement into separate effects.
+ *
+ * ## Ownership and lifetime
+ *
+ * Running replace performs one serialized record transition and resolves with its committed value.
+ * It acquires no resource; failures and services remain those of the source ref.
+ *
+ * @since 1.18.0
+ * @category State updates
  */
 export declare const replace: {
     <K extends string, V>(key: K, value: V): <E, R>(ref: RefRecord<K, V, E, R>) => Effect.Effect<Record.ReadonlyRecord<K, V>, E, R>;
@@ -59,14 +125,36 @@ export declare const replace: {
 };
 /**
  * Clear all entries from the Record.
- * @since 1.18.0
- * @category combinators
+ * @remarks
+ * ## Why
+ *
+ * Applies clear to the committed record value and publishes only the result, preserving its
+ * element order and equality rules.
+ *
+ * ## Ownership and lifetime
+ *
+ * Running clear performs one serialized record transition and resolves with its committed value.
+ * It acquires no resource; failures and services remain those of the source ref.
+ *
+ * @since 1.18.0
+ * @category State updates
  */
 export declare const clear: <K extends string, V, E, R>(ref: RefRecord<K, V, E, R>) => Effect.Effect<Record.ReadonlyRecord<K, V>, E, R>;
 /**
  * Union with another record.
- * @since 1.18.0
- * @category combinators
+ * @remarks
+ * ## Why
+ *
+ * Combines bulk record changes in one committed value, giving subscribers one coherent update
+ * rather than a partially applied sequence.
+ *
+ * ## Ownership and lifetime
+ *
+ * Running union performs one serialized record transition and resolves with its committed value.
+ * It acquires no resource; failures and services remain those of the source ref.
+ *
+ * @since 1.18.0
+ * @category State updates
  */
 export declare const union: {
     <K extends string, V>(that: Record.ReadonlyRecord<K, V>, combine?: (selfValue: V, thatValue: V) => V): <E, R>(ref: RefRecord<K, V, E, R>) => Effect.Effect<Record.ReadonlyRecord<K, V>, E, R>;
@@ -74,8 +162,19 @@ export declare const union: {
 };
 /**
  * Intersection with another record.
- * @since 1.18.0
- * @category combinators
+ * @remarks
+ * ## Why
+ *
+ * Intersection with another record. The operation remains attached to the RefSubject's versioned
+ * state boundary.
+ *
+ * ## Ownership and lifetime
+ *
+ * Running intersection performs one serialized record transition and resolves with its committed
+ * value. It acquires no resource; failures and services remain those of the source ref.
+ *
+ * @since 1.18.0
+ * @category State updates
  */
 export declare const intersection: {
     <K extends string, V>(that: Record.ReadonlyRecord<K, V>, combine?: (selfValue: V, thatValue: V) => V): <E, R>(ref: RefRecord<K, V, E, R>) => Effect.Effect<Record.ReadonlyRecord<K, V>, E, R>;
@@ -83,8 +182,19 @@ export declare const intersection: {
 };
 /**
  * Difference with another record.
- * @since 1.18.0
- * @category combinators
+ * @remarks
+ * ## Why
+ *
+ * Difference with another record. The operation remains attached to the RefSubject's versioned
+ * state boundary.
+ *
+ * ## Ownership and lifetime
+ *
+ * Running difference performs one serialized record transition and resolves with its committed
+ * value. It acquires no resource; failures and services remain those of the source ref.
+ *
+ * @since 1.18.0
+ * @category State updates
  */
 export declare const difference: {
     <K extends string, V>(that: Record.ReadonlyRecord<K, V>): <E, R>(ref: RefRecord<K, V, E, R>) => Effect.Effect<Record.ReadonlyRecord<K, V>, E, R>;
@@ -92,8 +202,18 @@ export declare const difference: {
 };
 /**
  * Filter entries in place.
- * @since 1.18.0
- * @category combinators
+ * @remarks
+ * ## Why
+ *
+ * Applies filter to the committed Record through `RefSubject.update` and publishes one coherent
+ * replacement; this is a mutation, not a read-only Computed projection.
+ *
+ * ## Ownership and lifetime
+ *
+ * The Effect starts when run, participates in the source ref's serialized update boundary, and
+ * acquires no resource. It returns the committed Record and retains the ref's E and R channels.
+ * @since 1.18.0
+ * @category State updates
  */
 export declare const filter: {
     <K extends string, V>(predicate: (value: V, key: K) => boolean): <E, R>(ref: RefRecord<K, V, E, R>) => Effect.Effect<Record.ReadonlyRecord<K, V>, E, R>;
@@ -101,8 +221,18 @@ export declare const filter: {
 };
 /**
  * Map values in place (endomorphic).
- * @since 1.18.0
- * @category combinators
+ * @remarks
+ * ## Why
+ *
+ * Applies map to the committed Record through `RefSubject.update` and publishes one coherent
+ * replacement; this is a mutation, not a read-only Computed projection.
+ *
+ * ## Ownership and lifetime
+ *
+ * The Effect starts when run, participates in the source ref's serialized update boundary, and
+ * acquires no resource. It returns the committed Record and retains the ref's E and R channels.
+ * @since 1.18.0
+ * @category State updates
  */
 export declare const map: {
     <K extends string, V>(f: (value: V, key: K) => V): <E, R>(ref: RefRecord<K, V, E, R>) => Effect.Effect<Record.ReadonlyRecord<K, V>, E, R>;
@@ -110,26 +240,70 @@ export declare const map: {
 };
 /**
  * Get the current size of the Record.
- * @since 1.18.0
- * @category computed
+ * @remarks
+ * ## Why
+ *
+ * Makes size a live projection of the record; consumers can sample it now or observe it without
+ * copying the source state.
+ *
+ * ## Ownership and lifetime
+ *
+ * The size view retains no independent state. An Effect read samples the source once; Fx
+ * observation follows later pushes and its observing Scope owns subscription cleanup.
+ *
+ * @since 1.18.0
+ * @category Derived queries
  */
 export declare const size: <K extends string, V, E, R>(ref: RefRecord<K, V, E, R>) => RefSubject.Computed<number, E, R>;
 /**
  * Check if the Record is empty.
- * @since 1.18.0
- * @category computed
+ * @remarks
+ * ## Why
+ *
+ * Makes is empty a live projection of the record; consumers can sample it now or observe it
+ * without copying the source state.
+ *
+ * ## Ownership and lifetime
+ *
+ * The is empty view retains no independent state. An Effect read samples the source once; Fx
+ * observation follows later pushes and its observing Scope owns subscription cleanup.
+ *
+ * @since 1.18.0
+ * @category State predicates
  */
 export declare const isEmpty: <K extends string, V, E, R>(ref: RefRecord<K, V, E, R>) => RefSubject.Computed<boolean, E, R>;
 /**
  * Check if the Record is non-empty.
- * @since 1.18.0
- * @category computed
+ * @remarks
+ * ## Why
+ *
+ * Makes is non empty a live projection of the record; consumers can sample it now or observe it
+ * without copying the source state.
+ *
+ * ## Ownership and lifetime
+ *
+ * The is non empty view retains no independent state. An Effect read samples the source once; Fx
+ * observation follows later pushes and its observing Scope owns subscription cleanup.
+ *
+ * @since 1.18.0
+ * @category State predicates
  */
 export declare const isNonEmpty: <K extends string, V, E, R>(ref: RefRecord<K, V, E, R>) => RefSubject.Computed<boolean, E, R>;
 /**
  * Check if a key exists in the Record.
- * @since 1.18.0
- * @category computed
+ * @remarks
+ * ## Why
+ *
+ * Makes has a live projection of the record; consumers can sample it now or observe it without
+ * copying the source state.
+ *
+ * ## Ownership and lifetime
+ *
+ * The has view retains no independent state. An Effect read samples the source once; Fx
+ * observation follows later pushes and its observing Scope owns subscription cleanup.
+ *
+ * @since 1.18.0
+ * @category State predicates
  */
 export declare const has: {
     <K extends string>(key: K): <V, E, R>(ref: RefRecord<K, V, E, R>) => RefSubject.Computed<boolean, E, R>;
@@ -137,26 +311,70 @@ export declare const has: {
 };
 /**
  * Get all keys from the Record.
- * @since 1.18.0
- * @category computed
+ * @remarks
+ * ## Why
+ *
+ * Projects record state with keys for both current reads and future pushes, avoiding a second
+ * mutable cache of the derived value.
+ *
+ * ## Ownership and lifetime
+ *
+ * The keys view retains no independent state. An Effect read samples the source once; Fx
+ * observation follows later pushes and its observing Scope owns subscription cleanup.
+ *
+ * @since 1.18.0
+ * @category Derived queries
  */
 export declare const keys: <K extends string, V, E, R>(ref: RefRecord<K, V, E, R>) => RefSubject.Computed<Array<K>, E, R>;
 /**
  * Get all values from the Record.
- * @since 1.18.0
- * @category computed
+ * @remarks
+ * ## Why
+ *
+ * Projects record state with values for both current reads and future pushes, avoiding a second
+ * mutable cache of the derived value.
+ *
+ * ## Ownership and lifetime
+ *
+ * The values view retains no independent state. An Effect read samples the source once; Fx
+ * observation follows later pushes and its observing Scope owns subscription cleanup.
+ *
+ * @since 1.18.0
+ * @category Derived queries
  */
 export declare const values: <K extends string, V, E, R>(ref: RefRecord<K, V, E, R>) => RefSubject.Computed<Array<V>, E, R>;
 /**
  * Get all entries from the Record.
- * @since 1.18.0
- * @category computed
+ * @remarks
+ * ## Why
+ *
+ * Projects record state with entries for both current reads and future pushes, avoiding a second
+ * mutable cache of the derived value.
+ *
+ * ## Ownership and lifetime
+ *
+ * The entries view retains no independent state. An Effect read samples the source once; Fx
+ * observation follows later pushes and its observing Scope owns subscription cleanup.
+ *
+ * @since 1.18.0
+ * @category Derived queries
  */
 export declare const entries: <K extends string, V, E, R>(ref: RefRecord<K, V, E, R>) => RefSubject.Computed<Array<[K, V]>, E, R>;
 /**
  * Map values to a different type.
- * @since 1.18.0
- * @category computed
+ * @remarks
+ * ## Why
+ *
+ * Projects record state with map values for both current reads and future pushes, avoiding a
+ * second mutable cache of the derived value.
+ *
+ * ## Ownership and lifetime
+ *
+ * The map values view retains no independent state. An Effect read samples the source once; Fx
+ * observation follows later pushes and its observing Scope owns subscription cleanup.
+ *
+ * @since 1.18.0
+ * @category Derived queries
  */
 export declare const mapValues: {
     <K extends string, V, B>(f: (value: V, key: K) => B): <E, R>(ref: RefRecord<K, V, E, R>) => RefSubject.Computed<Record.ReadonlyRecord<K, B>, E, R>;
@@ -164,8 +382,19 @@ export declare const mapValues: {
 };
 /**
  * Map keys to different keys.
- * @since 1.18.0
- * @category computed
+ * @remarks
+ * ## Why
+ *
+ * Projects record state with map keys for both current reads and future pushes, avoiding a second
+ * mutable cache of the derived value.
+ *
+ * ## Ownership and lifetime
+ *
+ * The map keys view retains no independent state. An Effect read samples the source once; Fx
+ * observation follows later pushes and its observing Scope owns subscription cleanup.
+ *
+ * @since 1.18.0
+ * @category Derived queries
  */
 export declare const mapKeys: {
     <K extends string, K2 extends string>(f: (key: K) => K2): <V, E, R>(ref: RefRecord<K, V, E, R>) => RefSubject.Computed<Record.ReadonlyRecord<K2, V>, E, R>;
@@ -173,8 +402,19 @@ export declare const mapKeys: {
 };
 /**
  * Map entries to new key-value pairs.
- * @since 1.18.0
- * @category computed
+ * @remarks
+ * ## Why
+ *
+ * Projects record state with map entries for both current reads and future pushes, avoiding a
+ * second mutable cache of the derived value.
+ *
+ * ## Ownership and lifetime
+ *
+ * The map entries view retains no independent state. An Effect read samples the source once; Fx
+ * observation follows later pushes and its observing Scope owns subscription cleanup.
+ *
+ * @since 1.18.0
+ * @category Derived queries
  */
 export declare const mapEntries: {
     <K extends string, V, K2 extends string, B>(f: (value: V, key: K) => [K2, B]): <E, R>(ref: RefRecord<K, V, E, R>) => RefSubject.Computed<Record.ReadonlyRecord<K2, B>, E, R>;
@@ -182,8 +422,19 @@ export declare const mapEntries: {
 };
 /**
  * Filter entries creating a Computed value.
- * @since 1.18.0
- * @category computed
+ * @remarks
+ * ## Why
+ *
+ * Projects record state with filter values for both current reads and future pushes, avoiding a
+ * second mutable cache of the derived value.
+ *
+ * ## Ownership and lifetime
+ *
+ * The filter values view retains no independent state. An Effect read samples the source once; Fx
+ * observation follows later pushes and its observing Scope owns subscription cleanup.
+ *
+ * @since 1.18.0
+ * @category Derived queries
  */
 export declare const filterValues: {
     <K extends string, V>(predicate: (value: V, key: K) => boolean): <E, R>(ref: RefRecord<K, V, E, R>) => RefSubject.Computed<Record.ReadonlyRecord<K, V>, E, R>;
@@ -191,8 +442,19 @@ export declare const filterValues: {
 };
 /**
  * Filter and map values.
- * @since 1.18.0
- * @category computed
+ * @remarks
+ * ## Why
+ *
+ * Projects record state with filter map values for both current reads and future pushes, avoiding
+ * a second mutable cache of the derived value.
+ *
+ * ## Ownership and lifetime
+ *
+ * The filter map values view retains no independent state. An Effect read samples the source once;
+ * Fx observation follows later pushes and its observing Scope owns subscription cleanup.
+ *
+ * @since 1.18.0
+ * @category Derived queries
  */
 export declare const filterMapValues: {
     <K extends string, V, B>(f: (value: V, key: K) => Option.Option<B>): <E, R>(ref: RefRecord<K, V, E, R>) => RefSubject.Computed<Record.ReadonlyRecord<K, B>, E, R>;
@@ -200,8 +462,18 @@ export declare const filterMapValues: {
 };
 /**
  * Partition entries.
- * @since 1.18.0
- * @category computed
+ * @remarks
+ * ## Why
+ *
+ * Partition entries. The operation remains attached to the RefSubject's versioned state boundary.
+ *
+ * ## Ownership and lifetime
+ *
+ * The partition view retains no independent state. An Effect read samples the source once; Fx
+ * observation follows later pushes and its observing Scope owns subscription cleanup.
+ *
+ * @since 1.18.0
+ * @category Derived queries
  */
 export declare const partition: {
     <K extends string, V>(predicate: (value: V, key: K) => boolean): <E, R>(ref: RefRecord<K, V, E, R>) => RefSubject.Computed<[Record.ReadonlyRecord<K, V>, Record.ReadonlyRecord<K, V>], E, R>;
@@ -209,8 +481,19 @@ export declare const partition: {
 };
 /**
  * Check if any entry satisfies a predicate.
- * @since 1.18.0
- * @category computed
+ * @remarks
+ * ## Why
+ *
+ * Makes some a live projection of the record; consumers can sample it now or observe it without
+ * copying the source state.
+ *
+ * ## Ownership and lifetime
+ *
+ * The some view retains no independent state. An Effect read samples the source once; Fx
+ * observation follows later pushes and its observing Scope owns subscription cleanup.
+ *
+ * @since 1.18.0
+ * @category State predicates
  */
 export declare const some: {
     <K extends string, V>(predicate: (value: V, key: K) => boolean): <E, R>(ref: RefRecord<K, V, E, R>) => RefSubject.Computed<boolean, E, R>;
@@ -218,8 +501,19 @@ export declare const some: {
 };
 /**
  * Check if all entries satisfy a predicate.
- * @since 1.18.0
- * @category computed
+ * @remarks
+ * ## Why
+ *
+ * Makes every a live projection of the record; consumers can sample it now or observe it without
+ * copying the source state.
+ *
+ * ## Ownership and lifetime
+ *
+ * The every view retains no independent state. An Effect read samples the source once; Fx
+ * observation follows later pushes and its observing Scope owns subscription cleanup.
+ *
+ * @since 1.18.0
+ * @category State predicates
  */
 export declare const every: {
     <K extends string, V>(predicate: (value: V, key: K) => boolean): <E, R>(ref: RefRecord<K, V, E, R>) => RefSubject.Computed<boolean, E, R>;
@@ -227,8 +521,19 @@ export declare const every: {
 };
 /**
  * Reduce the entries to a single value.
- * @since 1.18.0
- * @category computed
+ * @remarks
+ * ## Why
+ *
+ * Makes reduce a live projection of the record; consumers can sample it now or observe it without
+ * copying the source state.
+ *
+ * ## Ownership and lifetime
+ *
+ * The reduce view retains no independent state. An Effect read samples the source once; Fx
+ * observation follows later pushes and its observing Scope owns subscription cleanup.
+ *
+ * @since 1.18.0
+ * @category Derived queries
  */
 export declare const reduce: {
     <K extends string, V, B>(b: B, f: (b: B, value: V, key: K) => B): <E, R>(ref: RefRecord<K, V, E, R>) => RefSubject.Computed<B, E, R>;
@@ -236,8 +541,19 @@ export declare const reduce: {
 };
 /**
  * Get the value at a key as a Filtered.
- * @since 1.18.0
- * @category filtered
+ * @remarks
+ * ## Why
+ *
+ * Models the possibly absent result of get as Filtered state, so absence stays explicit while
+ * later source versions can make a value available.
+ *
+ * ## Ownership and lifetime
+ *
+ * The get view retains no independent value. Its Effect read fails with NoSuchElement
+ * while absent; the observing Scope owns and finalizes its Fx subscription.
+ *
+ * @since 1.18.0
+ * @category Optional queries
  */
 export declare const get: {
     <K extends string>(key: K): <V, E, R>(ref: RefRecord<K, V, E, R>) => RefSubject.Filtered<V, E, R>;
@@ -245,8 +561,19 @@ export declare const get: {
 };
 /**
  * Find the first entry satisfying a predicate.
- * @since 1.18.0
- * @category filtered
+ * @remarks
+ * ## Why
+ *
+ * Models the possibly absent result of find first as Filtered state, so absence stays explicit
+ * while later source versions can make a value available.
+ *
+ * ## Ownership and lifetime
+ *
+ * The find first view retains no independent value. Its Effect read fails with NoSuchElement
+ * while absent; the observing Scope owns and finalizes its Fx subscription.
+ *
+ * @since 1.18.0
+ * @category Optional queries
  */
 export declare const findFirst: {
     <K extends string, V>(predicate: (value: V, key: K) => boolean): <E, R>(ref: RefRecord<K, V, E, R>) => RefSubject.Filtered<[K, V], E, R>;
@@ -254,8 +581,19 @@ export declare const findFirst: {
 };
 /**
  * Pop a value at a key as a Filtered.
- * @since 1.18.0
- * @category filtered
+ * @remarks
+ * ## Why
+ *
+ * Models the possibly absent result of pop as Filtered state, so absence stays explicit while
+ * later source versions can make a value available.
+ *
+ * ## Ownership and lifetime
+ *
+ * The pop view retains no independent value. Its Effect read fails with NoSuchElement
+ * while absent; the observing Scope owns and finalizes its Fx subscription.
+ *
+ * @since 1.18.0
+ * @category Optional queries
  */
 export declare const pop: {
     <K extends string>(key: K): <V, E, R>(ref: RefRecord<K, V, E, R>) => RefSubject.Filtered<[V, Record.ReadonlyRecord<K, V>], E, R>;