@systemfsoftware/effect-atom 1.0.0 → 3.0.0

package/CHANGELOG.md

@@ -1,5 +1,117 @@
 # @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
+
+- The `result` member is removed from the `DehydratedAtomValue` type returned by `dehydrate`.
+
+  - `DehydratedAtomValue.result` was a `Deferred` that completed when an initially-loading atom reached a real value. It never survived serialization, so it could not work across the process boundary the dehydrated state exists for; reading it after transport failed at runtime.
+  - The pending-update behaviour is unchanged: entries created with `encodeInitialAs: 'deferred'` still settle the target registry once `hydrate` applies them and the source atom resolves.
+  - Wait for all pending updates by joining the fiber that `hydrate` returns, as before.
+  - Code that read `entry.result` directly no longer compiles; drop that access — there is no replacement field.
+
+### Minor Changes
+
+- `Registry.make` and `Registry.layerOptions` accept `now` and `scheduleTimer`, so every time-dependent atom can be driven without waiting in real time.
+
+  - `now?: () => number` supplies the clock.
+  - `scheduleTimer?: (f: () => void, delayMillis: number) => () => void` arms a delayed callback and returns its canceller.
+
+  Both default to the platform's wall clock and timer, so existing callers are unaffected. One substitution now drives all three time-dependent behaviours together: idle-TTL eviction, `Atom.debounce`, and `Atom.swr` staleness. Previously each read the clock and armed timers itself, so testing any of them meant real elapsed time.
+
+  `Registry` exposes `now` and `scheduleTimer` as members, alongside `scheduler` and `schedulerAsync`.
+
+- Atoms built from a runtime keep the last good answer again, and four read paths that lost or overwrote a value are fixed.
+
+  - A stream-backed atom that emitted values and then completed reported an empty stream and failed with `NoSuchElementError`. It now settles with the value the stream emitted last.
+  - A failing refresh, retry or reload no longer clears the value already on screen. The previous success is carried across effect, stream, pull, `subscriptionRef` and `fn` atoms, so `Result.previousSuccess` is populated while waiting and after a failure, as documented.
+  - Reading a `subscriptionRef` atom whose runtime layer failed threw `Result.getOrThrow: no value found` instead of reporting the failure. It now reports the layer's failure like every other atom on that runtime.
+  - `Atom.kvs` without `mode: 'async'` wrote `defaultValue()` into the store on first read, overwriting a value the store had not finished loading. The fallback is now shown without writing, and the default is stored only once the store reports the key absent.
+
+  Surface changes:
+
+  - `AtomContext.self` takes the value type as a parameter: `get.self<MyResult>()` returns `Option<MyResult>` where it previously returned `Option<unknown>`.
+  - `AtomRuntime.subscriptionRef` declares `Cause.NoSuchElementError` in its error channel, which its implementation always could produce.
+  - The HTTP API client's `mutation` and `query` bound their `Group` and `Endpoint` type parameters to any group and any endpoint. Each is now bound to the group and endpoint its identifier arguments select, so a call that passed one of them explicitly and disagreed with the identifiers no longer compiles.
+  - `Result.builder` renders a typed value. `orElse` returns the accumulated value or the fallback, `orNull` and `render` add `null`, and `exhaustive` returns the value alone, where all four previously returned `unknown`. Code that relied on assigning a rendered result anywhere now needs the value's real type.
+  - `Atom.mapResult` reports the mapped value with the source atom's error type, where it previously reported a union that included an untyped result. Mapping a mapped atom now gives the second mapper the real value type instead of `unknown`; an annotation written against the old union needs updating.
+
+- Harden the v4 fork: Effect-native hydration, zero `as any` casts, browser-mode tests.
+
+  Breaking changes:
+
+  - `Hydration.DehydratedAtomValue.resultPromise?: Promise<unknown>` is now `result?: Deferred<unknown>` — the pending-value channel is Effect-native, and `hydrate` returns a `Fiber<void, never>` that completes once every pending result has been applied (join it for deterministic SSR flushes and tests).
+  - `Hydration.dehydrate`'s `encodeInitialAs: 'promise'` is now `'deferred'`, `dehydrate` returns `Array<DehydratedAtomValue>` directly, and `Hydration.toValues` is removed.
+  - `Registry.setSerializable` now applies to an already-materialized node as well as preloading absent ones.
+  - `ScopedAtom.Context` is typed `React.Context<A | undefined>` to match runtime.
+  - `useAtom`/`useAtomSet` `mode: 'promise'` and `mode: 'promiseExit'` are gone; the single `mode: 'effect'` returns a lazy `(value) => Effect<A, E>` instead of an eager `Promise`, so callers run the result with `Effect.runPromise`/`yield*` and no raw `Promise` remains on the public surface.
+
+  Additions:
+
+  - `Registry.setInitialValue(atom, value)` — typed initial-value seeding (also used by `useAtomInitialValues`).
+  - `Result.Schema` now carries a `toArbitrary` hook, so `Schema.toArbitrary` works for property tests; its generated space is the wire-representable subset (no `undefined` defects, which the JSON codec cannot carry).
+
+  Internal:
+
+  - Every `as any` / `as unknown as` cast removed from both packages' `src` (Registry, Result, Atom, AtomRef, AtomRpc, AtomHttpApi, Hooks, RegistryContext, ScopedAtom); oxlint `correctness` and `perf` categories now gate as errors.
+  - `atom-react` tests run in Vitest browser mode (playwright chromium) with `expect.element` assertions; jest-dom and jsdom are gone. Consumers running these tests need `playwright install chromium`.
+  - Fixed a zombie-notification defect: an item removed from an `AtomRef.collection` no longer notifies the collection when mutated.
+
+- Port both packages onto the effect v4 release candidate (`effect@4.0.0-rc.108`,
+  resolved from the `effect4` catalog). The `src/` is now the v4 reactivity API:
+  absorbed packages (`@effect/experimental`, `@effect/platform`, `@effect/rpc`)
+  are gone — their modules now live under `effect/unstable/*` and the core `effect`
+  barrel — and every removed/renamed v3 symbol is replaced (`Effect.async`→
+  `callback`, `Context.Tag`→`Context.Service`, `Runtime<R>`→`Runtime`, `Cause`
+  error renames, `Schema.decodeEither`→`decodeExit`, the `Mailbox`/`Subscribable`/
+  `GlobalValue`/`FiberId` modules). **Breaking:** the `effect` peer dependency is
+  now `4.0.0-rc.x`; consumers must move to effect v4.
+
+  Breaking changes:
+
+  - `Registry.isRegistry` is renamed `isAtomRegistry`.
+  - The read-context type `Atom.Context` is renamed `Atom.AtomContext`; `defaultMemoMap` and `KvsError` are removed.
+  - `Result.toExitAsEffect`, `Result.schemaFromSelf`, `Result.PartialEncoded`, and `Result.Encoded` are removed (use `Result.toExit` + `Effect.exit` and `Result.Schema`).
+  - `Atom.make(stream)`/`Atom.fn(stream)` widen the atom's error channel with `Cause.NoSuchElementError`.
+  - `Registry.make`/`Registry.layerOptions` and `RegistryProvider` take a changed `scheduleTask` option signature.
+  - `@systemfsoftware/effect-atom-react` no longer re-exports the atom package's namespaces (`Atom`, `Registry`, `Result`, `AtomRef`, `AtomHttpApi`, `AtomRpc`, `Hydration`, `ScopedAtom`) from its root — those modules are not browser-safe, and the react entry is browser-tested. Import them from `@systemfsoftware/effect-atom` directly.
+  - Runtime type markers `Atom.TypeId`/`WritableTypeId`/`AtomRef.TypeId` moved to `~effect/reactivity/*`; the wire `SerializableTypeId` (`~effect-atom/atom/Atom/Serializable`) is unchanged, so `Hydration` payload keys are stable.
+
+- cut over to effect v4 (4.0.0-rc.108): public surface derives from effect types; peers flip effect ^3→^4
+
+### Patch Changes
+
+- Array types are spelled one way. `Array<T>` and `ReadonlyArray<T>` in emitted
+  declarations become `T[]` and `readonly T[]`, which the type checker cannot tell
+  apart: no exported type changes, only how it is written.
+
+- A serialised successful result now requires its timestamp to be a finite number.
+  It previously accepted `NaN` and `Infinity`, so a corrupted timestamp could decode
+  without complaint and reach code that compares it.
+
+- New version is published through npm trusted publishing, so it carries a provenance attestation you can verify.
+
+- The `atom` packages publish their own author rather than crediting an upstream they are not downstream of, and `stryker-plugins` no longer pulls Node's ambient types into a package that has no runtime dependency on them.
+
+- Each of these packages now has a README, so its registry page says what the package is, how
+  to install it, and what to import or register — previously the page was blank. The lint
+  plugins show the configuration line that enables what they recommend.
+
+  `@systemfsoftware/stryker-js-mutation-report` also carries its licence text
+
 ## 1.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,14 +1,14 @@
 {
   "name": "@systemfsoftware/effect-atom",
   "license": "Apache-2.0",
-  "version": "1.0.0",
+  "version": "3.0.0",
   "author": "Ryan Lee <drdgvhbh@gmail.com>",
   "repository": {
     "type": "git",
     "url": "git+https://github.com/systemfsoftware/systemfsoftware.git",
-    "directory": "packages/effect-atom/atom"
+    "directory": "packages/core/effect/atom/atom"
   },
-  "homepage": "https://github.com/systemfsoftware/systemfsoftware/tree/main/packages/effect-atom/atom#readme",
+  "homepage": "https://github.com/systemfsoftware/systemfsoftware/tree/main/packages/core/effect/atom/atom#readme",
   "bugs": "https://github.com/systemfsoftware/systemfsoftware/issues",
   "description": "Reactive toolkit for Effect — forked under systemfsoftware from tim-smart/effect-atom.",
   "keywords": [
@@ -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": "^1.0.0",
+    "@systemfsoftware/effect-gherkin-spec": "^2.0.1",
     "@systemfsoftware/oxlint-config": "^0.1.0",
     "@systemfsoftware/vitest-config": "^0.1.0",
-    "@systemfsoftware/tsconfig": "^1.3.2"
+    "@systemfsoftware/tsconfig": "^1.3.3"
   },
   "publishConfig": {
     "provenance": true