@systemfsoftware/effect-atom 2.0.0 → 3.0.0

package/CHANGELOG.md

@@ -1,5 +1,17 @@
 # @systemfsoftware/effect-atom
 
+## 3.0.0
+
+### Major Changes
+
+- Published types no longer include names tagged `@internal`. If you imported one of those names from the package, switch to a public export or stop using it.
+
+### Patch Changes
+
+- The peer requirements for `effect` and for the Effect test-runner integration now accept any compatible `4.0.0-rc` release, instead of demanding one exact release candidate.
+
+  Installing alongside a newer release candidate no longer reports an unmet peer dependency or resolves a second copy of `effect` into the dependency tree.
+
 ## 2.0.0
 
 ### Major Changes

package/dist/{Atom-DVWTGeoV.mjs → Atom-BdJCLuRj.mjs}

@@ -1,6 +1,6 @@
 import { t as __exportAll } from "./rolldown-runtime-D7D4PA-g.mjs";
-import { a as getResult$1, d as toStream$1, f as toStreamResult$1, m as batch$1, t as AtomRegistry, u as mount$1 } from "./Registry-BE4aKSZk.mjs";
-import { D as value, F as isResult, I as success, N as failure, O as waiting, P as initial, T as toExit, b as map$1, c as failureWithPrevious, d as fromExitWithPrevious, h as isInitial, k as waitingFrom, m as isFailure, p as getOrThrow, s as failWithPrevious, v as isSuccess, w as replacePrevious } from "./Result-rlUvoHzK.mjs";
+import { a as batch$1, d as mount$1, f as toStream$1, o as getResult$1, p as toStreamResult$1, t as AtomRegistry } from "./Registry-Bwb4SHbP.mjs";
+import { D as value, F as isResult, I as success, N as failure, O as waiting, P as initial, T as toExit, b as map$1, c as failureWithPrevious, d as fromExitWithPrevious, h as isInitial, k as waitingFrom, m as isFailure, p as getOrThrow, s as failWithPrevious, v as isSuccess, w as replacePrevious } from "./Result-CBWUo7aQ.mjs";
 import * as Arr from "effect/Array";
 import * as Cause from "effect/Cause";
 import * as Channel from "effect/Channel";
@@ -25,8 +25,7 @@ import { NodeInspectSymbol } from "effect/Inspectable";
 import { pipeArguments } from "effect/Pipeable";
 import { hasProperty } from "effect/Predicate";
 import * as Result from "effect/Result";
-//#region src/internal/Core.ts
-/** @internal */
+//#region src/AtomCore.ts
 const PipeInspectableProto = { pipe() {
 	return pipeArguments(this, arguments);
 } };
@@ -68,9 +67,7 @@ const setIdleTTL = dual(2, (self, durationInput) => {
 	Reflect.setPrototypeOf(copy, Reflect.getPrototypeOf(self));
 	return copy;
 });
-/** @internal */
 const removeTtl = setIdleTTL(0);
-/** @internal */
 const AtomProto = {
 	[TypeId]: TypeId,
 	equals: Object.is,
@@ -87,7 +84,6 @@ const AtomProto = {
 		};
 	}
 };
-/** @internal */
 const WritableProto = {
 	...AtomProto,
 	[WritableTypeId]: WritableTypeId

package/dist/{Atom-BgqgP-Qc.d.ts → Atom-Ciqh8CR3.d.ts}

@@ -1,4 +1,4 @@
-import { L as Result } from "./Result-BHH-qTvm.js";
+import { L as Result } from "./Result-pXS4ZOef.js";
 import * as Arr from "effect/Array";
 import * as Cause from "effect/Cause";
 import * as Context from "effect/Context";
@@ -7,18 +7,18 @@ import * as Effect from "effect/Effect";
 import { LazyArg } from "effect/Function";
 import * as Layer from "effect/Layer";
 import * as Option from "effect/Option";
-import { Scheduler } from "effect/Scheduler";
+import { Scheduler, SchedulerDispatcher } from "effect/Scheduler";
 import * as Schema from "effect/Schema";
 import * as Scope from "effect/Scope";
 import * as Stream from "effect/Stream";
 import * as SubscriptionRef from "effect/SubscriptionRef";
 import * as KeyValueStore from "effect/unstable/persistence/KeyValueStore";
 import * as Reactivity from "effect/unstable/reactivity/Reactivity";
-import { Inspectable } from "effect/Inspectable";
+import { Inspectable, NodeInspectSymbol } from "effect/Inspectable";
 import { Pipeable } from "effect/Pipeable";
 import { ReadonlyRecord } from "effect/Record";
 import { NoInfer } from "effect/Types";
-//#region src/internal/Core.d.ts
+//#region src/AtomCore.d.ts
 /**
  * Type-level identifier used to recognize `Atom` values.
  *
@@ -106,8 +106,65 @@ declare const transform: {
     readonly initialValueTarget?: Atom<B> | undefined;
   }): [R] extends [Writable<infer _, infer RW>] ? Writable<B, RW> : Atom<B>;
 };
+//#endregion
+//#region src/AtomNode.d.ts
+declare const NodeState: {
+  readonly uninitialized: number;
+  readonly stale: number;
+  readonly valid: number;
+  readonly removed: 0;
+};
+type NodeState = number;
+declare class NodeImpl<A> {
+  constructor(registry: RegistryImpl, atom: Atom<A>);
+  readonly registry: RegistryImpl;
+  readonly atom: Atom<A>;
+  state: NodeState;
+  lifetime: Lifetime<A> | undefined;
+  writeContext: WriteContextImpl<A>;
+  preserveInitialValueOnBuild: boolean;
+  parents: Set<NodeImpl<unknown>>;
+  previousParents: Set<NodeImpl<unknown>> | undefined;
+  children: Set<NodeImpl<unknown>>;
+  listeners: Set<() => void>;
+  skipInvalidation: boolean;
+  building: boolean;
+  invalidatedDuringBuild: boolean;
+  currentState(): 'uninitialized' | 'stale' | 'valid' | 'removed';
+  get canBeRemoved(): boolean;
+  _value: A;
+  value(): A;
+  valueOption(): Option.Option<A>;
+  setInitialValue(value: A): void;
+  setValue(value: A): void;
+  addParent(parent: NodeImpl<unknown>): void;
+  removeChild(child: NodeImpl<unknown>): void;
+  invalidate(): void;
+  invalidateChildren(): void;
+  notify(): void;
+  disposeLifetime(): void;
+  remove(): void;
+  subscribe(listener: () => void): () => void;
+}
+interface Lifetime<A> extends AtomContext {
+  isFn: boolean;
+  readonly registry: RegistryImpl;
+  readonly node: NodeImpl<A>;
+  finalizers: (() => void)[] | undefined;
+  disposed: boolean;
+  readonly dispose: () => void;
+}
+declare class WriteContextImpl<A> implements WriteContext<A> {
+  constructor(registry: RegistryImpl, node: NodeImpl<A>);
+  readonly registry: RegistryImpl;
+  readonly node: NodeImpl<A>;
+  get<A>(atom: Atom<A>): A;
+  set<R, W>(atom: Writable<R, W>, value: W): void;
+  setSelf(value: A): void;
+  refreshSelf(): void;
+}
 declare namespace Registry_d_exports {
-  export { AtomRegistry, Node, Registry, TypeId, getResult$1 as getResult, isAtomRegistry, layer, layerOptions, make$1 as make, mount$1 as mount, toStream$1 as toStream, toStreamResult$1 as toStreamResult };
+  export { AtomRegistry, Node, Registry, RegistryImpl, TypeId, batch$1 as batch, getResult$1 as getResult, isAtomRegistry, layer, layerOptions, make$1 as make, mount$1 as mount, toStream$1 as toStream, toStreamResult$1 as toStreamResult };
 }
 /**
  * The literal type used to identify `AtomRegistry` services and values.
@@ -324,6 +381,55 @@ declare const mount$1: {
   <A>(atom: Atom<A>): (self: Registry) => Effect.Effect<void, never, Scope.Scope>;
   <A>(self: Registry, atom: Atom<A>): Effect.Effect<void, never, Scope.Scope>;
 };
+/**
+ * Concrete registry used by the package implementation.
+ */
+declare class RegistryImpl implements Registry {
+  #private;
+  readonly [TypeId]: TypeId;
+  readonly timeoutResolution: number;
+  readonly defaultIdleTTL: number | undefined;
+  readonly scheduler: Scheduler;
+  readonly schedulerAsync: Scheduler;
+  readonly dispatcher: SchedulerDispatcher;
+  readonly now: () => number;
+  readonly scheduleTimer: (f: () => void, delayMillis: number) => () => void;
+  onNodeAdded?: ((node: Node<unknown>) => void) | undefined;
+  onNodeRemoved?: ((node: Node<unknown>) => void) | undefined;
+  constructor(initialValues?: Iterable<readonly [Atom<unknown>, unknown]>, scheduleTask?: (cb: () => void) => () => void, timeoutResolution?: number, defaultIdleTTL?: number, now?: () => number, scheduleTimer?: (f: () => void, delayMillis: number) => () => void);
+  setInitialValue<A>(atom: Atom<A>, value: A): void;
+  readonly nodes: Map<string | Atom<unknown>, NodeImpl<unknown>>;
+  readonly preloadedSerializable: Map<string, unknown>;
+  readonly timeoutBuckets: Map<number, readonly [nodes: Set<NodeImpl<unknown>>, cancel: () => void]>;
+  readonly nodeTimeoutBucket: Map<NodeImpl<unknown>, number>;
+  disposed: boolean;
+  getNodes(): Map<string | Atom<unknown>, NodeImpl<unknown>>;
+  get<A>(atom: Atom<A>): A;
+  getRaw<A>(atom: Atom<A>): Option.Option<A>;
+  set<R, W>(atom: Writable<R, W>, value: W): void;
+  setSerializable(key: string, encoded: unknown): void;
+  private applySerializableValue;
+  modify<R, W, A>(atom: Writable<R, W>, f: (_: R) => [returnValue: A, nextValue: W]): A;
+  update<R, W>(atom: Writable<R, W>, f: (_: R) => W): void;
+  refresh: <A>(atom: Atom<A>) => void;
+  subscribe<A>(atom: Atom<A>, f: (_: A) => void, options?: {
+    readonly immediate?: boolean;
+  }): () => void;
+  mount<A>(atom: Atom<A>): () => void;
+  atomHasTtl(atom: Atom<unknown>): boolean;
+  ensureNode<A>(atom: Atom<A>): NodeImpl<A>;
+  createNode<A>(atom: Atom<A>): NodeImpl<A>;
+  invalidateAtom: <A>(atom: Atom<A>) => void;
+  scheduleAtomRemoval(atom: Atom<unknown>): void;
+  scheduleNodeRemoval(node: NodeImpl<unknown>): void;
+  removeNode(node: NodeImpl<unknown>): void;
+  setNodeTimeout(node: NodeImpl<unknown>): void;
+  removeNodeTimeout(node: NodeImpl<unknown>): void;
+  sweepBucket(bucket: number): void;
+  reset(): void;
+  dispose(): void;
+}
+declare function batch$1(f: () => void): void;
 //#endregion
 //#region src/Browser.d.ts
 /**
@@ -1284,4 +1390,4 @@ declare const serializable: {
   }): R & Serializable<S>;
 };
 //#endregion
-export { toStreamResult as $, get as A, isAtom as At, modify as B, autoDispose as C, layerOptions as Ct, family as D, toStreamResult$1 as Dt, debounce as E, toStream$1 as Et, kvs as F, writable as Ft, refresh as G, optimistic as H, make as I, set as J, runtime as K, makeRead as L, initialValue as M, readable as Mt, isSerializable as N, setIdleTTL as Nt, fn as O, TypeId$1 as Ot, keepAlive as P, transform as Pt, toStream as Q, map as R, WriteContext as S, layer as St, context as T, mount$1 as Tt, optimisticFn as U, mount as V, pull as W, subscriptionRef as X, setLazy as Y, swr as Z, SharedRuntimeFactory as _, Registry as _t, Atom_d_exports as a, withRefresh as at, WithoutSerializable as b, getResult$1 as bt, Interrupt as c, getServerValue as ct, RegistryRuntimeFactory as d, makeRefreshOnSignal as dt, update as et, Reset as f, refreshOnWindowFocus as ft, SerializableTypeId as g, Node as gt, SerializableJson as h, AtomRegistry as ht, AtomRuntime as i, withReactivity as it, getResult as j, isWritable as jt, fnSync as k, WritableTypeId as kt, PullResult as l, withServerValue as lt, Serializable as m, windowFocusSignal as mt, AtomContext as n, withFallback as nt, Failure as o, ServerValue as ot, RuntimeFactory as p, searchParam as pt, serializable as q, AtomResultFn as r, withLabel as rt, FnContext as s, ServerValueTypeId as st, Atom as t, withEquality as tt, PullSuccess as u, withServerValueInitial as ut, Success as v, Registry_d_exports as vt, batch as w, make$1 as wt, Writable as x, isAtomRegistry as xt, Type as y, TypeId as yt, mapResult as z };
+export { toStreamResult as $, get as A, TypeId$1 as At, modify as B, autoDispose as C, isAtomRegistry as Ct, family as D, mount$1 as Dt, debounce as E, make$1 as Et, kvs as F, setIdleTTL as Ft, refresh as G, optimistic as H, make as I, transform as It, set as J, runtime as K, makeRead as L, writable as Lt, initialValue as M, isAtom as Mt, isSerializable as N, isWritable as Nt, fn as O, toStream$1 as Ot, keepAlive as P, readable as Pt, toStream as Q, map as R, WriteContext as S, getResult$1 as St, context as T, layerOptions as Tt, optimisticFn as U, mount as V, pull as W, subscriptionRef as X, setLazy as Y, swr as Z, SharedRuntimeFactory as _, Registry as _t, Atom_d_exports as a, withRefresh as at, WithoutSerializable as b, TypeId as bt, Interrupt as c, getServerValue as ct, RegistryRuntimeFactory as d, makeRefreshOnSignal as dt, update as et, Reset as f, refreshOnWindowFocus as ft, SerializableTypeId as g, Node as gt, SerializableJson as h, AtomRegistry as ht, AtomRuntime as i, withReactivity as it, getResult as j, WritableTypeId as jt, fnSync as k, toStreamResult$1 as kt, PullResult as l, withServerValue as lt, Serializable as m, windowFocusSignal as mt, AtomContext as n, withFallback as nt, Failure as o, ServerValue as ot, RuntimeFactory as p, searchParam as pt, serializable as q, AtomResultFn as r, withLabel as rt, FnContext as s, ServerValueTypeId as st, Atom as t, withEquality as tt, PullSuccess as u, withServerValueInitial as ut, Success as v, RegistryImpl as vt, batch as w, layer as wt, Writable as x, batch$1 as xt, Type as y, Registry_d_exports as yt, mapResult as z };

package/dist/Atom.d.ts

@@ -1,2 +1,2 @@
-import { $ as toStreamResult, A as get, At as isAtom, B as modify, C as autoDispose, D as family, E as debounce, F as kvs, Ft as writable, G as refresh, H as optimistic, I as make, J as set, K as runtime, L as makeRead, M as initialValue, Mt as readable, N as isSerializable, Nt as setIdleTTL, O as fn, Ot as TypeId, P as keepAlive, Pt as transform, Q as toStream, R as map, S as WriteContext, T as context, U as optimisticFn, V as mount, W as pull, X as subscriptionRef, Y as setLazy, Z as swr, _ as SharedRuntimeFactory, at as withRefresh, b as WithoutSerializable, c as Interrupt, ct as getServerValue, d as RegistryRuntimeFactory, dt as makeRefreshOnSignal, et as update, f as Reset, ft as refreshOnWindowFocus, g as SerializableTypeId, h as SerializableJson, i as AtomRuntime, it as withReactivity, j as getResult, jt as isWritable, k as fnSync, kt as WritableTypeId, l as PullResult, lt as withServerValue, m as Serializable, mt as windowFocusSignal, n as AtomContext, nt as withFallback, o as Failure, ot as ServerValue, p as RuntimeFactory, pt as searchParam, q as serializable, r as AtomResultFn, rt as withLabel, s as FnContext, st as ServerValueTypeId, t as Atom, tt as withEquality, u as PullSuccess, ut as withServerValueInitial, v as Success, w as batch, x as Writable, y as Type, z as mapResult } from "./Atom-BgqgP-Qc.js";
+import { $ as toStreamResult, A as get, At as TypeId, B as modify, C as autoDispose, D as family, E as debounce, F as kvs, Ft as setIdleTTL, G as refresh, H as optimistic, I as make, It as transform, J as set, K as runtime, L as makeRead, Lt as writable, M as initialValue, Mt as isAtom, N as isSerializable, Nt as isWritable, O as fn, P as keepAlive, Pt as readable, Q as toStream, R as map, S as WriteContext, T as context, U as optimisticFn, V as mount, W as pull, X as subscriptionRef, Y as setLazy, Z as swr, _ as SharedRuntimeFactory, at as withRefresh, b as WithoutSerializable, c as Interrupt, ct as getServerValue, d as RegistryRuntimeFactory, dt as makeRefreshOnSignal, et as update, f as Reset, ft as refreshOnWindowFocus, g as SerializableTypeId, h as SerializableJson, i as AtomRuntime, it as withReactivity, j as getResult, jt as WritableTypeId, k as fnSync, l as PullResult, lt as withServerValue, m as Serializable, mt as windowFocusSignal, n as AtomContext, nt as withFallback, o as Failure, ot as ServerValue, p as RuntimeFactory, pt as searchParam, q as serializable, r as AtomResultFn, rt as withLabel, s as FnContext, st as ServerValueTypeId, t as Atom, tt as withEquality, u as PullSuccess, ut as withServerValueInitial, v as Success, w as batch, x as Writable, y as Type, z as mapResult } from "./Atom-Ciqh8CR3.js";
 export { Atom, AtomContext, AtomResultFn, AtomRuntime, Failure, FnContext, Interrupt, PullResult, PullSuccess, RegistryRuntimeFactory, Reset, RuntimeFactory, Serializable, SerializableJson, SerializableTypeId, type ServerValue, ServerValueTypeId, SharedRuntimeFactory, Success, Type, TypeId, WithoutSerializable, Writable, WritableTypeId, WriteContext, autoDispose, batch, context, debounce, family, fn, fnSync, get, getResult, getServerValue, initialValue, isAtom, isSerializable, isWritable, keepAlive, kvs, make, makeRead, makeRefreshOnSignal, map, mapResult, modify, mount, optimistic, optimisticFn, pull, readable, refresh, refreshOnWindowFocus, runtime, searchParam, serializable, set, setIdleTTL, setLazy, subscriptionRef, swr, toStream, toStreamResult, transform, update, windowFocusSignal, withEquality, withFallback, withLabel, withReactivity, withRefresh, withServerValue, withServerValueInitial, writable };

package/dist/Atom.mjs

@@ -1,2 +1,2 @@
-import { $ as isWritable, A as set, B as withReactivity, C as mount, D as refresh, E as pull, F as toStreamResult, G as withServerValueInitial, H as ServerValueTypeId, I as update, J as searchParam, K as makeRefreshOnSignal, L as withEquality, M as subscriptionRef, N as swr, O as runtime, P as toStream, Q as isAtom, R as withFallback, S as modify, T as optimisticFn, U as getServerValue, V as withRefresh, W as withServerValue, X as TypeId, Y as windowFocusSignal, Z as WritableTypeId, _ as kvs, a as autoDispose, b as map, c as debounce, d as fnSync, et as readable, f as get, g as keepAlive, h as isSerializable, i as SerializableTypeId, j as setLazy, k as serializable, l as family, m as initialValue, n as Interrupt, nt as transform, o as batch, p as getResult, q as refreshOnWindowFocus, r as Reset, rt as writable, s as context, tt as setIdleTTL, u as fn, v as make, w as optimistic, x as mapResult, y as makeRead, z as withLabel } from "./Atom-DVWTGeoV.mjs";
+import { $ as isWritable, A as set, B as withReactivity, C as mount, D as refresh, E as pull, F as toStreamResult, G as withServerValueInitial, H as ServerValueTypeId, I as update, J as searchParam, K as makeRefreshOnSignal, L as withEquality, M as subscriptionRef, N as swr, O as runtime, P as toStream, Q as isAtom, R as withFallback, S as modify, T as optimisticFn, U as getServerValue, V as withRefresh, W as withServerValue, X as TypeId, Y as windowFocusSignal, Z as WritableTypeId, _ as kvs, a as autoDispose, b as map, c as debounce, d as fnSync, et as readable, f as get, g as keepAlive, h as isSerializable, i as SerializableTypeId, j as setLazy, k as serializable, l as family, m as initialValue, n as Interrupt, nt as transform, o as batch, p as getResult, q as refreshOnWindowFocus, r as Reset, rt as writable, s as context, tt as setIdleTTL, u as fn, v as make, w as optimistic, x as mapResult, y as makeRead, z as withLabel } from "./Atom-BdJCLuRj.mjs";
 export { Interrupt, Reset, SerializableTypeId, ServerValueTypeId, TypeId, WritableTypeId, autoDispose, batch, context, debounce, family, fn, fnSync, get, getResult, getServerValue, initialValue, isAtom, isSerializable, isWritable, keepAlive, kvs, make, makeRead, makeRefreshOnSignal, map, mapResult, modify, mount, optimistic, optimisticFn, pull, readable, refresh, refreshOnWindowFocus, runtime, searchParam, serializable, set, setIdleTTL, setLazy, subscriptionRef, swr, toStream, toStreamResult, transform, update, windowFocusSignal, withEquality, withFallback, withLabel, withReactivity, withRefresh, withServerValue, withServerValueInitial, writable };

package/dist/AtomHttpApi.d.ts

@@ -1,5 +1,5 @@
-import { i as AtomRuntime, n as AtomContext, p as RuntimeFactory, r as AtomResultFn, t as Atom } from "./Atom-BgqgP-Qc.js";
-import { L as Result } from "./Result-BHH-qTvm.js";
+import { i as AtomRuntime, n as AtomContext, p as RuntimeFactory, r as AtomResultFn, t as Atom } from "./Atom-Ciqh8CR3.js";
+import { L as Result } from "./Result-pXS4ZOef.js";
 import * as Context from "effect/Context";
 import * as Duration from "effect/Duration";
 import * as Effect from "effect/Effect";

package/dist/AtomHttpApi.mjs

@@ -1,6 +1,6 @@
 import { t as __exportAll } from "./rolldown-runtime-D7D4PA-g.mjs";
-import { O as runtime, g as keepAlive, k as serializable, l as family, tt as setIdleTTL } from "./Atom-DVWTGeoV.mjs";
-import { j as schemaCodec } from "./Result-rlUvoHzK.mjs";
+import { O as runtime, g as keepAlive, k as serializable, l as family, tt as setIdleTTL } from "./Atom-BdJCLuRj.mjs";
+import { j as schemaCodec } from "./Result-CBWUo7aQ.mjs";
 import * as Context from "effect/Context";
 import * as Duration from "effect/Duration";
 import * as Effect from "effect/Effect";

package/dist/AtomRpc.d.ts

@@ -1,5 +1,5 @@
-import { i as AtomRuntime, l as PullResult, n as AtomContext, p as RuntimeFactory, r as AtomResultFn, t as Atom, x as Writable } from "./Atom-BgqgP-Qc.js";
-import { L as Result } from "./Result-BHH-qTvm.js";
+import { i as AtomRuntime, l as PullResult, n as AtomContext, p as RuntimeFactory, r as AtomResultFn, t as Atom, x as Writable } from "./Atom-Ciqh8CR3.js";
+import { L as Result } from "./Result-pXS4ZOef.js";
 import * as Context from "effect/Context";
 import * as Duration from "effect/Duration";
 import * as Effect from "effect/Effect";

package/dist/AtomRpc.mjs

@@ -1,6 +1,6 @@
 import { t as __exportAll } from "./rolldown-runtime-D7D4PA-g.mjs";
-import { O as runtime, g as keepAlive, k as serializable, l as family, tt as setIdleTTL } from "./Atom-DVWTGeoV.mjs";
-import { j as schemaCodec } from "./Result-rlUvoHzK.mjs";
+import { O as runtime, g as keepAlive, k as serializable, l as family, tt as setIdleTTL } from "./Atom-BdJCLuRj.mjs";
+import { j as schemaCodec } from "./Result-CBWUo7aQ.mjs";
 import * as Context from "effect/Context";
 import * as Duration from "effect/Duration";
 import * as Effect from "effect/Effect";

package/dist/Hydration.d.ts

@@ -1,4 +1,4 @@
-import { _t as Registry } from "./Atom-BgqgP-Qc.js";
+import { _t as Registry } from "./Atom-Ciqh8CR3.js";
 import * as Fiber from "effect/Fiber";
 declare namespace Hydration_d_exports {
   export { DehydratedAtom, DehydratedAtomValue, dehydrate, hydrate };

package/dist/Hydration.mjs

@@ -1,6 +1,6 @@
 import { t as __exportAll } from "./rolldown-runtime-D7D4PA-g.mjs";
-import { h as isSerializable, i as SerializableTypeId } from "./Atom-DVWTGeoV.mjs";
-import { F as isResult, h as isInitial } from "./Result-rlUvoHzK.mjs";
+import { h as isSerializable, i as SerializableTypeId } from "./Atom-BdJCLuRj.mjs";
+import { F as isResult, h as isInitial } from "./Result-CBWUo7aQ.mjs";
 import * as Effect from "effect/Effect";
 import * as Clock from "effect/Clock";
 import * as Deferred from "effect/Deferred";

package/dist/{Registry-BE4aKSZk.mjs → Registry-Bwb4SHbP.mjs}

@@ -1,5 +1,5 @@
 import { t as __exportAll } from "./rolldown-runtime-D7D4PA-g.mjs";
-import { F as isResult, T as toExit, _ as isNotInitial, h as isInitial, m as isFailure, v as isSuccess } from "./Result-rlUvoHzK.mjs";
+import { F as isResult, T as toExit, _ as isNotInitial, h as isInitial, m as isFailure, v as isSuccess } from "./Result-CBWUo7aQ.mjs";
 import * as Context from "effect/Context";
 import * as Effect from "effect/Effect";
 import * as Exit from "effect/Exit";
@@ -13,26 +13,8 @@ import * as Stream from "effect/Stream";
 import { hasProperty } from "effect/Predicate";
 import * as Queue from "effect/Queue";
 import * as Match from "effect/Match";
-//#region src/internal/HostTimer.ts
-/**
-* Host clock and timer primitives for the atom registry.
-*
-* This module is the named host boundary for wall-clock reads and delayed
-* scheduling. It deliberately imports nothing from `effect`: the registry
-* itself is a fiber-free store, and consumers who need deterministic idle
-* eviction pass their own `now` / `scheduleTimer` to `Registry.make` /
-* `Registry.layerOptions`. The defaults here are the plain platform
-* implementations.
-*
-* @since 4.0.0
-*/
-const hostNow = () => Date.now();
-const hostScheduleTimer = (f, delayMillis) => {
-	const id = setTimeout(f, delayMillis);
-	return () => clearTimeout(id);
-};
-//#endregion
 //#region src/internal/NodeLifetime.ts
+/** @internal */
 const decideNodeFate = (input) => {
 	if (input.keepAlive || input.listenerCount > 0 || input.childCount > 0 || !input.isLive || input.isWaiting) return { _tag: "Alive" };
 	if (input.idleTTL === 0) return { _tag: "RemoveNow" };
@@ -43,7 +25,7 @@ const decideNodeFate = (input) => {
 	};
 };
 //#endregion
-//#region src/internal/Node.ts
+//#region src/AtomNode.ts
 const notifyListener = (listener) => {
 	listener();
 };
@@ -58,7 +40,6 @@ const NodeState = {
 	valid: NodeFlags.alive | NodeFlags.initialized,
 	removed: 0
 };
-/** @internal */
 var NodeImpl = class {
 	constructor(registry, atom) {
 		this.registry = registry;
@@ -385,21 +366,18 @@ var WriteContextImpl = class {
 		return this.node.invalidate();
 	}
 };
-/** @internal */
 const BatchPhase = {
 	disabled: 0,
 	collect: 1,
 	commit: 2
 };
-/** @internal */
 const batchState = {
 	phase: BatchPhase.disabled,
 	depth: 0,
 	stale: [],
 	notify: /* @__PURE__ */ new Set()
 };
-/** @internal */
-function batch(f) {
+function runInternalBatch(f) {
 	batchState.phase = BatchPhase.collect;
 	batchState.depth++;
 	try {
@@ -429,6 +407,27 @@ function batchRebuildNode(node) {
 	if (node.state !== NodeState.valid) node.value();
 }
 //#endregion
+//#region src/internal/HostTimer.ts
+/**
+* Host clock and timer primitives for the atom registry.
+*
+* This module is the named host boundary for wall-clock reads and delayed
+* scheduling. It deliberately imports nothing from `effect`: the registry
+* itself is a fiber-free store, and consumers who need deterministic idle
+* eviction pass their own `now` / `scheduleTimer` to `Registry.make` /
+* `Registry.layerOptions`. The defaults here are the plain platform
+* implementations.
+*
+* @since 4.0.0
+*/
+/** @internal */
+const hostNow = () => Date.now();
+/** @internal */
+const hostScheduleTimer = (f, delayMillis) => {
+	const id = setTimeout(f, delayMillis);
+	return () => clearTimeout(id);
+};
+//#endregion
 //#region src/Registry.ts
 /**
 * Stores and runs atoms for one reactive runtime.
@@ -443,11 +442,9 @@ function batchRebuildNode(node) {
 */
 var Registry_exports = /* @__PURE__ */ __exportAll({
 	AtomRegistry: () => AtomRegistry,
-	BatchPhase: () => BatchPhase,
 	RegistryImpl: () => RegistryImpl,
 	TypeId: () => TypeId,
 	batch: () => batch,
-	batchState: () => batchState,
 	getResult: () => getResult,
 	isAtomRegistry: () => isAtomRegistry,
 	layer: () => layer,
@@ -599,7 +596,7 @@ const atomKey = (atom) => isSerializableAtom(atom) ? atom[SerializableTypeId].ke
 */
 const isNodeImplFor = (atom, node) => atomKey(node.atom) === atomKey(atom);
 /**
-* @internal
+* Concrete registry used by the package implementation.
 */
 var RegistryImpl = class {
 	[TypeId];
@@ -819,5 +816,8 @@ var RegistryImpl = class {
 		this.reset();
 	}
 };
+function batch(f) {
+	runInternalBatch(f);
+}
 //#endregion
-export { getResult as a, layerOptions as c, toStream as d, toStreamResult as f, batchState as h, TypeId as i, make as l, batch as m, RegistryImpl as n, isAtomRegistry as o, BatchPhase as p, Registry_exports as r, layer as s, AtomRegistry as t, mount as u };
+export { batch as a, layer as c, mount as d, toStream as f, TypeId as i, layerOptions as l, RegistryImpl as n, getResult as o, toStreamResult as p, Registry_exports as r, isAtomRegistry as s, AtomRegistry as t, make as u };

package/dist/Registry.d.ts

@@ -1,2 +1,2 @@
-import { Ct as layerOptions, Dt as toStreamResult, Et as toStream, St as layer, Tt as mount, _t as Registry, bt as getResult, gt as Node, ht as AtomRegistry, wt as make, xt as isAtomRegistry, yt as TypeId } from "./Atom-BgqgP-Qc.js";
-export { AtomRegistry, Node, Registry, TypeId, getResult, isAtomRegistry, layer, layerOptions, make, mount, toStream, toStreamResult };
+import { Ct as isAtomRegistry, Dt as mount, Et as make, Ot as toStream, St as getResult, Tt as layerOptions, _t as Registry, bt as TypeId, gt as Node, ht as AtomRegistry, kt as toStreamResult, vt as RegistryImpl, wt as layer, xt as batch } from "./Atom-Ciqh8CR3.js";
+export { AtomRegistry, Node, Registry, RegistryImpl, TypeId, batch, getResult, isAtomRegistry, layer, layerOptions, make, mount, toStream, toStreamResult };

package/dist/Registry.mjs

@@ -1,2 +1,2 @@
-import { a as getResult, c as layerOptions, d as toStream, f as toStreamResult, h as batchState, i as TypeId, l as make, m as batch, n as RegistryImpl, o as isAtomRegistry, p as BatchPhase, s as layer, t as AtomRegistry, u as mount } from "./Registry-BE4aKSZk.mjs";
-export { AtomRegistry, BatchPhase, RegistryImpl, TypeId, batch, batchState, getResult, isAtomRegistry, layer, layerOptions, make, mount, toStream, toStreamResult };
+import { a as batch, c as layer, d as mount, f as toStream, i as TypeId, l as layerOptions, n as RegistryImpl, o as getResult, p as toStreamResult, s as isAtomRegistry, t as AtomRegistry, u as make } from "./Registry-Bwb4SHbP.mjs";
+export { AtomRegistry, RegistryImpl, TypeId, batch, getResult, isAtomRegistry, layer, layerOptions, make, mount, toStream, toStreamResult };

package/dist/{Result-rlUvoHzK.mjs → Result-CBWUo7aQ.mjs}

@@ -15,7 +15,7 @@ import * as Hash from "effect/Hash";
 import * as SchemaIssue from "effect/SchemaIssue";
 import * as SchemaParser from "effect/SchemaParser";
 import * as SchemaTransformation from "effect/SchemaTransformation";
-//#region src/internal/ResultValues.ts
+//#region src/ResultValues.ts
 const now = () => Effect.runSync(Clock.currentTimeMillis);
 /**
 * Runtime identifier attached to `Result` values and used by `isResult`.
@@ -53,6 +53,9 @@ const ResultProto = {
 		return Match.value(this).pipe(Match.tag("Initial", () => tagHash), Match.tag("Success", (s) => Hash.combine(tagHash)(Hash.hash(s.value))), Match.tag("Failure", (f) => Hash.combine(tagHash)(Hash.hash(f.cause))), Match.exhaustive);
 	}
 };
+const InitialTag = { _tag: "Initial" };
+const SuccessTag = { _tag: "Success" };
+const FailureTag = { _tag: "Failure" };
 /**
 * Returns `true` when a value is an `Result`.
 *
@@ -69,7 +72,7 @@ const isResult = (u) => hasProperty(u, TypeId);
 const initial = (waiting = false) => {
 	return {
 		...ResultProto,
-		_tag: "Initial",
+		...InitialTag,
 		waiting
 	};
 };
@@ -83,7 +86,7 @@ const initial = (waiting = false) => {
 const success = (value, options) => {
 	return {
 		...ResultProto,
-		_tag: "Success",
+		...SuccessTag,
 		value,
 		waiting: options?.waiting ?? false,
 		timestamp: options?.timestamp ?? now()
@@ -99,14 +102,14 @@ const success = (value, options) => {
 const failure = (cause, options) => {
 	return {
 		...ResultProto,
-		_tag: "Failure",
+		...FailureTag,
 		cause,
 		...options?.previousSuccess === void 0 ? { previousSuccess: Option.none() } : { previousSuccess: options.previousSuccess },
 		waiting: options?.waiting ?? false
 	};
 };
 //#endregion
-//#region src/internal/ResultSchema.ts
+//#region src/ResultSchema.ts
 /**
 * Creates a schema for `Result` values using optional schemas for success values and failure errors.
 *
@@ -197,8 +200,6 @@ const Schema = (options) => {
 };
 /**
 * A codec for `Result` values built from the given success and error schemas.
-*
-* @internal
 */
 const schemaCodec = (success, error) => Schema({
 	success,

package/dist/{Result-BHH-qTvm.d.ts → Result-pXS4ZOef.d.ts}

@@ -6,7 +6,7 @@ import * as Schema_ from "effect/Schema";
 import { Pipeable } from "effect/Pipeable";
 import { Predicate, Refinement } from "effect/Predicate";
 import * as Types from "effect/Types";
-//#region src/internal/ResultValues.d.ts
+//#region src/ResultValues.d.ts
 /**
  * Type-level identifier used to recognize `Result` values.
  *
@@ -66,15 +66,21 @@ declare namespace Result {
  * @since 4.0.0
  */
 type Result<A, E = never> = Initial<A, E> | Success<A, E> | Failure<A, E>;
+declare const InitialTag: {
+  readonly _tag: 'Initial';
+};
+type InitialTag = typeof InitialTag;
 /**
  * Initial `Result` state before a success value or failure cause is available.
  *
  * @category models
  * @since 4.0.0
  */
-interface Initial<A, E = never> extends Result.Proto<A, E> {
-  readonly _tag: 'Initial';
-}
+interface Initial<A, E = never> extends Result.Proto<A, E>, InitialTag {}
+declare const SuccessTag: {
+  readonly _tag: 'Success';
+};
+type SuccessTag = typeof SuccessTag;
 /**
  * Successful `Result` containing the current value, its timestamp, and the
  * shared waiting flag.
@@ -82,11 +88,14 @@ interface Initial<A, E = never> extends Result.Proto<A, E> {
  * @category models
  * @since 4.0.0
  */
-interface Success<A, E = never> extends Result.Proto<A, E> {
-  readonly _tag: 'Success';
+interface Success<A, E = never> extends Result.Proto<A, E>, SuccessTag {
   readonly value: A;
   readonly timestamp: number;
 }
+declare const FailureTag: {
+  readonly _tag: 'Failure';
+};
+type FailureTag = typeof FailureTag;
 /**
  * Failed `Result` containing a failure cause and the latest previous success
  * when one is available.
@@ -94,8 +103,7 @@ interface Success<A, E = never> extends Result.Proto<A, E> {
  * @category models
  * @since 4.0.0
  */
-interface Failure<A, E = never> extends Result.Proto<A, E> {
-  readonly _tag: 'Failure';
+interface Failure<A, E = never> extends Result.Proto<A, E>, FailureTag {
   readonly cause: Cause.Cause<E>;
   readonly previousSuccess: Option.Option<Success<A, E>>;
 }
@@ -136,7 +144,7 @@ declare const failure: <A, E = never>(cause: Cause.Cause<E>, options?: {
   readonly waiting?: boolean | undefined;
 }) => Failure<A, E>;
 //#endregion
-//#region src/internal/ResultSchema.d.ts
+//#region src/ResultSchema.d.ts
 /**
  * Schema interface for `Result` values, retaining the schemas used for
  * success values and failure errors.

package/dist/Result.d.ts

@@ -1,2 +1,2 @@
-import { A as touch, B as failure, C as isWaiting, D as matchWithWaiting, E as matchWithError, F as Failure, H as isResult, I as Initial, L as Result, M as waiting, N as waitingFrom, O as replacePrevious, P as Schema, R as Success, S as isSuccess, T as match, U as success, V as initial, _ as getOrThrow, a as With, b as isInterrupted, c as cause, d as failWithPrevious, f as failureWithPrevious, g as getOrElse, h as fromExitWithPrevious, j as value, k as toExit, l as error, m as fromExit, n as Defect, o as all, p as flatMap, r as Interrupt, s as builder, t as Builder, u as fail, v as isFailure, w as map, x as isNotInitial, y as isInitial, z as TypeId } from "./Result-BHH-qTvm.js";
+import { A as touch, B as failure, C as isWaiting, D as matchWithWaiting, E as matchWithError, F as Failure, H as isResult, I as Initial, L as Result, M as waiting, N as waitingFrom, O as replacePrevious, P as Schema, R as Success, S as isSuccess, T as match, U as success, V as initial, _ as getOrThrow, a as With, b as isInterrupted, c as cause, d as failWithPrevious, f as failureWithPrevious, g as getOrElse, h as fromExitWithPrevious, j as value, k as toExit, l as error, m as fromExit, n as Defect, o as all, p as flatMap, r as Interrupt, s as builder, t as Builder, u as fail, v as isFailure, w as map, x as isNotInitial, y as isInitial, z as TypeId } from "./Result-pXS4ZOef.js";
 export { Builder, Defect, type Failure, type Initial, Interrupt, type Result, Schema, type Success, TypeId, With, all, builder, cause, error, fail, failWithPrevious, failure, failureWithPrevious, flatMap, fromExit, fromExitWithPrevious, getOrElse, getOrThrow, initial, isResult as isAsyncResult, isResult, isFailure, isInitial, isInterrupted, isNotInitial, isSuccess, isWaiting, map, match, matchWithError, matchWithWaiting, replacePrevious, success, toExit, touch, value, waiting, waitingFrom };

package/dist/Result.mjs

@@ -1,2 +1,2 @@
-import { A as Schema, C as matchWithWaiting, D as value, E as touch, F as isResult, I as success, M as TypeId, N as failure, O as waiting, P as initial, S as matchWithError, T as toExit, _ as isNotInitial, a as error, b as map, c as failureWithPrevious, d as fromExitWithPrevious, f as getOrElse, g as isInterrupted, h as isInitial, i as cause, k as waitingFrom, l as flatMap, m as isFailure, n as all, o as fail, p as getOrThrow, r as builder, s as failWithPrevious, u as fromExit, v as isSuccess, w as replacePrevious, x as match, y as isWaiting } from "./Result-rlUvoHzK.mjs";
+import { A as Schema, C as matchWithWaiting, D as value, E as touch, F as isResult, I as success, M as TypeId, N as failure, O as waiting, P as initial, S as matchWithError, T as toExit, _ as isNotInitial, a as error, b as map, c as failureWithPrevious, d as fromExitWithPrevious, f as getOrElse, g as isInterrupted, h as isInitial, i as cause, k as waitingFrom, l as flatMap, m as isFailure, n as all, o as fail, p as getOrThrow, r as builder, s as failWithPrevious, u as fromExit, v as isSuccess, w as replacePrevious, x as match, y as isWaiting } from "./Result-CBWUo7aQ.mjs";
 export { Schema, TypeId, all, builder, cause, error, fail, failWithPrevious, failure, failureWithPrevious, flatMap, fromExit, fromExitWithPrevious, getOrElse, getOrThrow, initial, isResult as isAsyncResult, isResult, isFailure, isInitial, isInterrupted, isNotInitial, isSuccess, isWaiting, map, match, matchWithError, matchWithWaiting, replacePrevious, success, toExit, touch, value, waiting, waitingFrom };

package/dist/index.d.ts

@@ -1,5 +1,5 @@
-import { a as Atom_d_exports, vt as Registry_d_exports } from "./Atom-BgqgP-Qc.js";
-import { i as Result_d_exports } from "./Result-BHH-qTvm.js";
+import { a as Atom_d_exports, yt as Registry_d_exports } from "./Atom-Ciqh8CR3.js";
+import { i as Result_d_exports } from "./Result-pXS4ZOef.js";
 import { t as AtomHttpApi_d_exports } from "./AtomHttpApi.js";
 import { t as AtomRef_d_exports } from "./AtomRef.js";
 import { t as AtomRpc_d_exports } from "./AtomRpc.js";

package/dist/index.mjs

@@ -1,6 +1,6 @@
-import { t as Atom_exports } from "./Atom-DVWTGeoV.mjs";
-import { r as Registry_exports } from "./Registry-BE4aKSZk.mjs";
-import { t as Result_exports } from "./Result-rlUvoHzK.mjs";
+import { t as Atom_exports } from "./Atom-BdJCLuRj.mjs";
+import { r as Registry_exports } from "./Registry-Bwb4SHbP.mjs";
+import { t as Result_exports } from "./Result-CBWUo7aQ.mjs";
 import { t as AtomHttpApi_exports } from "./AtomHttpApi.mjs";
 import { t as AtomRef_exports } from "./AtomRef.mjs";
 import { t as AtomRpc_exports } from "./AtomRpc.mjs";

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@systemfsoftware/effect-atom",
   "license": "Apache-2.0",
-  "version": "2.0.0",
+  "version": "3.0.0",
   "author": "Ryan Lee <drdgvhbh@gmail.com>",
   "repository": {
     "type": "git",
@@ -58,23 +58,23 @@
     "dist"
   ],
   "peerDependencies": {
-    "effect": "4.0.0-rc.108"
+    "effect": "^4.0.0-rc.111"
   },
   "devDependencies": {
-    "@effect/vitest": "4.0.0-rc.108",
+    "@effect/vitest": "4.0.0-rc.111",
     "@systemfsoftware/arethetypeswrong-cli": "^1.1.1",
     "@types/node": "^24",
-    "effect": "4.0.0-rc.108",
+    "effect": "4.0.0-rc.111",
     "oxlint": "^1.77.0",
     "rimraf": "^6.1.3",
     "tsdown": "^0.22.14",
     "type-fest": "^5.8.0",
     "typescript": "^7",
     "vitest": "^4.1.10",
-    "@systemfsoftware/effect-gherkin-spec": "^2.0.0",
+    "@systemfsoftware/effect-gherkin-spec": "^2.0.1",
     "@systemfsoftware/oxlint-config": "^0.1.0",
-    "@systemfsoftware/tsconfig": "^1.3.3",
-    "@systemfsoftware/vitest-config": "^0.1.0"
+    "@systemfsoftware/vitest-config": "^0.1.0",
+    "@systemfsoftware/tsconfig": "^1.3.3"
   },
   "publishConfig": {
     "provenance": true