effect-atom-svelte 0.3.0 → 0.4.0

package/dist/Hooks.svelte.d.ts

@@ -4,8 +4,10 @@
  * @since 0.1.0
  */
 import { Exit } from "effect";
+import type { Schema } from "effect";
 import { AsyncResult, Atom } from "effect/reactivity";
 import type { AtomRef } from "effect/reactivity";
+import type * as Form from "./Form.ts";
 /**
  * An atom, or a getter so the hook follows the atom when reactive state picks a different one.
  *
@@ -400,3 +402,55 @@ export declare function useAtomSuspense<A, E>(input: AtomInput<Atom.Atom<AsyncRe
 export declare function useAtomSuspense<A, E>(input: AtomInput<Atom.Atom<AsyncResult.AsyncResult<A, E>>>, options?: SuspenseOptions & {
     readonly includeFailure?: boolean | undefined;
 }): AtomValue<Promise<A | AsyncResult.Success<A, E> | AsyncResult.Failure<A, E>>>;
+/**
+ * Creates an instance of a form from `Form.make` in a component. Its state lives in the
+ * component's registry and is released when the component is destroyed; a submit in flight keeps
+ * it, and keeps its atom running, until the submit settles, so a save finishes after a dialog
+ * closes. Share an instance by passing it down, or create it in the parent whose lifetime it
+ * should have, such as a wizard around its steps.
+ *
+ * Pass `id` from `$props.id()`: field ids are built from it, and must match between the server and
+ * the browser. On the server the form renders from `initialValues` and doesn't validate, so there
+ * is nothing to hydrate. A getter for `initialValues` is followed: when it changes, a clean form
+ * takes the new values and a dirty one keeps its edits.
+ *
+ * **Example** (A login form)
+ *
+ * ```svelte
+ * <script lang="ts">
+ *   import { useForm } from "effect-atom-svelte";
+ *   import { Login, loginAtom } from "./forms.ts";
+ *
+ *   const id = $props.id();
+ *   const form = useForm(Login, {
+ *     id,
+ *     initialValues: { email: "", password: "" },
+ *     submit: { atom: loginAtom },
+ *     mapError: (error) =>
+ *       error._tag === "WrongPassword"
+ *         ? { form: "Wrong email or password" }
+ *         : undefined,
+ *   });
+ *   const email = form.field("email");
+ * </script>
+ *
+ * <form {...form.attrs}>
+ *   <label for={email.id}>Email</label>
+ *   <input {...email.attrs} bind:value={email.value} />
+ *   {#if email.error}
+ *     <p id={email.errorId}>{email.error}</p>
+ *   {/if}
+ *   {#if form.rootError}
+ *     <p role="alert">{form.rootError}</p>
+ *   {/if}
+ *   <button disabled={form.submitting}>Log in</button>
+ * </form>
+ * ```
+ *
+ * @see {@link https://atom.jarrednorris.dev/forms | Forms}
+ * @stability unstable
+ * @since 0.4.0
+ * @category hooks
+ */
+export declare function useForm<F extends Form.Form<Schema.Top>, A, E, W, Args = undefined>(form: F, options: Form.InstanceOptions<Form.Encoded<F>, Form.Decoded<F>, A, E, W, Args>): Form.Instance<Form.Encoded<F>, Form.Decoded<F>, A, E, Args>;
+export declare function useForm<F extends Form.Form<Schema.Top>>(form: F, options: Form.ValidateOnlyOptions<Form.Encoded<F>>): Form.Instance<Form.Encoded<F>, Form.Decoded<F>, Form.Decoded<F>, never, void>;

package/dist/Hooks.svelte.js

@@ -8,17 +8,18 @@ import { AsyncResult, Atom, AtomRegistry } from "effect/reactivity";
 import { BROWSER, DEV } from "esm-env";
 import { getAbortSignal, hydratable, untrack } from "svelte";
 import { createSubscriber } from "svelte/reactivity";
+import { awaitWrite } from "./internal/awaitWrite.js";
 import { queuedByBoundary } from "./internal/boundaries.js";
 import { onDispose } from "./internal/disposal.js";
+import { engineOf, initialGetter } from "./internal/form/engineOf.js";
 import { decodeSeed, encodeSeed, isWaiting, noSeed, revalidatesOnHydrate, } from "./internal/hydration.js";
 import { onRenderEnd } from "./internal/renderEnd.js";
 import { reportReads } from "./internal/scope.svelte.js";
 import { onTeardown } from "./internal/teardown.svelte.js";
 import { troubleshooting } from "./internal/troubleshooting.js";
 import { getRegistry } from "./RegistryContext.js";
-const toGetter = (input) => typeof input === "function" && !Atom.isAtom(input)
-    ? input
-    : () => input;
+const isGetter = (input) => typeof input === "function" && !Atom.isAtom(input);
+const toGetter = (input) => isGetter(input) ? input : () => input;
 // The registry notifies subscribers synchronously while it computes an atom, and Svelte throws
 // state_unsafe_mutation if state changes while a template or $derived is evaluating. Reads are
 // counted, and a notification raised during one is delivered on a microtask instead. Outside a
@@ -33,7 +34,9 @@ const afterReads = (update) => {
         update();
     }
 };
-const notifyAfterReads = (update) => () => afterReads(update);
+const notifyAfterReads = (update) => () => {
+    afterReads(update);
+};
 const duringRead = (f) => {
     activeReads += 1;
     try {
@@ -51,6 +54,7 @@ class AtomCell {
         this.#read = read;
         this.#write = write;
     }
+    // oxlint-disable-next-line typescript/related-getter-setter-pairs -- implements AtomState, whose read and write types differ
     get current() {
         return this.#read();
     }
@@ -77,11 +81,13 @@ const notStarted = (result) => result._tag === "Initial" && !result.waiting;
  * computes the atom, as its real read is often browser-only.
  */
 const hasServerValue = (atom) => Atom.ServerValueTypeId in atom;
-// SAFETY: ensureNode and scheduleNodeRemoval are on the registry implementation, not the interface
-// (Effect 4.0.0); @effect/atom-react uses ensureNode the same way. Of the node's parts,
+/** The atom's node, created if the registry has none yet. */
+const nodeOf = (registry, atom) => 
+// SAFETY: ensureNode returns the implementation's node (Effect 4.0.5), which has
 // preserveInitialValueOnBuild, _value, setValue and failed (set while a first build has thrown)
-// are on its implementation too; the rest, currentState included, are on Effect's Node interface.
-const internals = (registry) => registry;
+// beside the Node interface; @effect/atom-react calls its setValue the same way.
+// oxlint-disable-next-line typescript/no-unsafe-type-assertion -- those members are on the implementation only, which Effect doesn't export
+registry.ensureNode(atom);
 /** The atom that holds a value given to `atom`: a wrapper such as `withRefresh` passes it on. */
 const initialValueTarget = (atom) => {
     let target = atom;
@@ -97,7 +103,9 @@ const initialValueTarget = (atom) => {
  * set, so holds sharing one would all end with the first to let go.
  */
 const holdNode = (registry, node) => {
-    const unsubscribe = node.subscribe(() => undefined);
+    const unsubscribe = node.subscribe(() => {
+        // Only there to hold the node.
+    });
     return () => {
         unsubscribe();
         if (node.canBeRemoved) {
@@ -119,7 +127,7 @@ const holdNode = (registry, node) => {
 const dropInitialValueMark = (registry, atom) => {
     let current = atom;
     while (current) {
-        const node = internals(registry).ensureNode(current);
+        const node = nodeOf(registry, current);
         if (node.currentState() === "valid") {
             node.preserveInitialValueOnBuild = false;
         }
@@ -141,7 +149,7 @@ const initialNodeOnServer = (registry, atom) => {
     if (BROWSER) {
         return undefined;
     }
-    const node = internals(registry).ensureNode(initialValueTarget(atom));
+    const node = nodeOf(registry, initialValueTarget(atom));
     return node.preserveInitialValueOnBuild ? node : undefined;
 };
 /** Whether, on the server, an atom renders a value from `useAtomInitialValues`. */
@@ -149,7 +157,7 @@ const initialOnServer = (registry, atom) => initialNodeOnServer(registry, atom)
 /** Keeps an atom for the server render: a node with an initial value is held, not mounted. */
 const serverMount = (registry, atom) => {
     const node = initialNodeOnServer(registry, atom);
-    return node ? holdNode(internals(registry), node) : registry.mount(atom);
+    return node ? holdNode(registry, node) : registry.mount(atom);
 };
 /** Reads an atom without building it on the server while it renders an initial value. */
 const serverGet = (registry, atom) => {
@@ -183,31 +191,6 @@ const awaitSettled = (registry, atom, options, signal) => {
         return Effect.sync(cancel);
     }), { signal });
 };
-/**
- * A promise-mode setter's wait: as `awaitResult` with `suspendOnWaiting`, but a change to a result
- * from before the call, which is what `Atom.Reset` from another setter leaves (an idle `Initial`,
- * or an `Atom.fn`'s `initialValue`), ends it as interrupted. The reset interrupts the call, so
- * otherwise the wait would hang until the next call, or settle with the initial value.
- */
-const awaitWrite = (registry, atom, start, signal) => Effect.runPromiseExit(Effect.callback((resume) => {
-    const first = registry.get(atom);
-    if (first._tag !== "Initial" && !first.waiting) {
-        resume(AsyncResult.toExit(first));
-        return;
-    }
-    const cancel = registry.subscribe(atom, (result) => {
-        if (result.waiting) {
-            return;
-        }
-        cancel();
-        const reset = result._tag === "Initial" ||
-            (result._tag === "Success" && result.timestamp < start);
-        resume(reset
-            ? Exit.interrupt()
-            : AsyncResult.toExit(result));
-    });
-    return Effect.sync(cancel);
-}), { signal });
 // On the server, per registry, how many renders' seeds carry each key, until those renders end.
 const seededKeys = new WeakMap();
 /** Whether a render using the registry sends the key's result to the browser with a seed. */
@@ -419,7 +402,7 @@ const subscribedReader = (registry, getAtom, plainRead) => {
             // After mount, only a first build is dropped: a stale node rebuilt here, as after a failed
             // rebuild, announces a change other reads of this reader have not seen. A node whose first
             // build failed is still uninitialized, but the page has shown that failure, so it counts too.
-            const node = internals(registry).ensureNode(current);
+            const node = nodeOf(registry, current);
             if (node.currentState() === "uninitialized" && !node.failed) {
                 reading = current;
             }
@@ -461,7 +444,9 @@ export function useAtomValue(input, f) {
 export const useAtom = (input) => {
     const registry = getRegistry();
     const getAtom = toGetter(input);
-    return new AtomCell(subscribedReader(registry, getAtom, "useAtom"), (value) => registry.set(getAtom(), value));
+    return new AtomCell(subscribedReader(registry, getAtom, "useAtom"), (value) => {
+        registry.set(getAtom(), value);
+    });
 };
 /** useAtomMount, telling an inspector scope why the atom is held: `useAtomSet` holds it to write. */
 const mountWhileAlive = (input, kind) => {
@@ -505,9 +490,14 @@ export function useAtomSet(input, options) {
     if (mode === "value") {
         return (value) => {
             const atom = getAtom();
-            registry.set(atom, typeof value === "function"
-                ? value(registry.get(atom))
-                : value);
+            if (typeof value !== "function") {
+                registry.set(atom, value);
+                return;
+            }
+            // SAFETY: the overloads type a function value as an update from the current value.
+            // oxlint-disable-next-line typescript/no-unsafe-type-assertion -- a typeof check can't recover the function's signature
+            const updateFrom = value;
+            registry.set(atom, updateFrom(registry.get(atom)));
         };
     }
     return async (value, writeOptions) => {
@@ -516,21 +506,26 @@ export function useAtomSet(input, options) {
             // never end.
             throw new TypeError(`useAtomSet's ${mode} mode cannot wait for Atom.Reset; reset with a value mode setter`);
         }
+        // SAFETY: the overloads offer the promise modes only for an atom that holds an AsyncResult.
+        // oxlint-disable-next-line typescript/no-unsafe-type-assertion -- the implementation signature can't carry the overloads' atom type
         const atom = getAtom();
         // An already aborted signal settles as interrupted without writing, as fetch does (JND-25). It
         // skips the wait too: Effect checks the signal only after a first run, which would return a
         // result the atom already holds from an earlier call.
         let exit;
-        if (writeOptions?.signal?.aborted) {
+        if (writeOptions?.signal?.aborted === true) {
             exit = Exit.interrupt();
         }
         else {
+            // oxlint-disable-next-line effecttsgo/global-date -- compared with an AsyncResult's timestamp, which Effect takes from Date.now
             const start = Date.now();
             registry.set(atom, value);
             // A provider disposing of its registry ends the call without a last result, so the wait ends
             // there too, as interrupted.
             const controller = new AbortController();
-            const abort = () => controller.abort();
+            const abort = () => {
+                controller.abort();
+            };
             writeOptions?.signal?.addEventListener("abort", abort, { once: true });
             const cancel = onDispose(registry, abort);
             try {
@@ -565,7 +560,9 @@ export const useAtomRefresh = (input) => {
     const registry = getRegistry();
     const getAtom = toGetter(input);
     useAtomMount(getAtom);
-    return () => registry.refresh(getAtom());
+    return () => {
+        registry.refresh(getAtom());
+    };
 };
 /**
  * Delivers each value to `f` as afterReads would, but in order and only while subscribed. Once a
@@ -575,12 +572,13 @@ export const useAtomRefresh = (input) => {
 const orderedDelivery = (f) => {
     let live = true;
     let flushing = false;
+    // Boxed, so an empty queue is told apart from a queued undefined.
     const queue = [];
     // Stopping empties the queue, which ends a flush in progress.
     const flush = () => {
         try {
-            while (queue.length > 0) {
-                f(queue.shift());
+            for (let next = queue.shift(); next; next = queue.shift()) {
+                f(next.value);
             }
         }
         finally {
@@ -596,7 +594,7 @@ const orderedDelivery = (f) => {
             return;
         }
         if (flushing || activeReads > 0) {
-            queue.push(value);
+            queue.push({ value });
             if (!flushing) {
                 flushing = true;
                 queueMicrotask(flush);
@@ -668,7 +666,7 @@ export const useAtomSubscribe = (input, f, options) => {
  * atom's next read; this sets it on the node now, which is valid, so nothing reads it again.
  */
 const setNodeValue = (registry, atom, value) => {
-    internals(registry).ensureNode(atom).setValue(value);
+    nodeOf(registry, atom).setValue(value);
     dropInitialValueMark(registry, atom);
 };
 // The nodes given a value by useAtomInitialValues. A node belongs to one registry, and a node the
@@ -711,7 +709,7 @@ const serverHolders = new WeakMap();
  * @category hooks
  */
 export const useAtomInitialValues = (initialValues) => {
-    const registry = internals(getRegistry());
+    const registry = getRegistry();
     const releases = [];
     // Registered before the loop: an entry that throws midway leaves the earlier ones held otherwise.
     onTeardown(() => {
@@ -741,11 +739,12 @@ export const useAtomInitialValues = (initialValues) => {
         releases.push(holdNode(registry, node));
     }
 };
+const isWritableRef = (ref) => "set" in ref;
 /** Writes a ref that has `set`; a read-only ref, as from `map`, throws as `useAtomValue` would. */
 const writeRef = (getRef) => (value) => {
     const ref = getRef();
-    if (!("set" in ref)) {
-        readOnly();
+    if (!isWritableRef(ref)) {
+        return readOnly();
     }
     ref.set(value);
 };
@@ -836,7 +835,7 @@ const settledSeeds = new WeakSet();
  * within a render, and a per-registry record would outlive the request when the caller owns the
  * registry, so later requests would skip embedding their seed (JND-17).
  */
-const seedOnServer = (registry, atom, key, encode, suspendOnWaiting) => {
+const seedOnServer = (registry, atom, key, encode, suspendOnWaiting = false) => {
     // Mounted until the render ends, so the settled node is what the render reads.
     const release = serverMount(registry, atom);
     // A render ends before its seeds settle only when it fails, as when a later reader throws during
@@ -855,7 +854,7 @@ const seedOnServer = (registry, atom, key, encode, suspendOnWaiting) => {
     const claim = {};
     const encoded = hydratable(key, () => {
         claim.own = (async () => {
-            await undefined;
+            await Promise.resolve();
             if (ended) {
                 return noSeed;
             }
@@ -866,7 +865,7 @@ const seedOnServer = (registry, atom, key, encode, suspendOnWaiting) => {
             // waits, so with suspendOnWaiting the seed is the settled result the render shows, not one the
             // browser would run again because it was still waiting.
             if (!initialOnServer(registry, atom) && !notStarted(registry.get(atom))) {
-                let settled = suspendOnWaiting === true;
+                let settled = suspendOnWaiting;
                 await awaitResult(registry, atom, { suspendOnWaiting: settled });
                 // A later reader of the key may want the settled result once this one's wait has begun.
                 if (!settled && claim.first && settledSeeds.has(claim.first)) {
@@ -882,7 +881,7 @@ const seedOnServer = (registry, atom, key, encode, suspendOnWaiting) => {
         return claim.own;
     });
     claim.first = encoded;
-    if (suspendOnWaiting === true) {
+    if (suspendOnWaiting) {
         settledSeeds.add(encoded);
     }
     const claimed = serverSeeds.get(encoded);
@@ -905,7 +904,10 @@ const claimedKeys = new WeakMap();
 // The store is not public API, so a Svelte that changes its shape or drops it turns the warning off
 // rather than throwing.
 const serverValues = () => {
-    const store = globalThis.__svelte?.h;
+    const svelte = Object.getOwnPropertyDescriptor(globalThis, "__svelte")?.value;
+    const store = typeof svelte === "object" && svelte !== null && "h" in svelte
+        ? svelte.h
+        : undefined;
     return store instanceof Map ? store : undefined;
 };
 const warnIfSent = async (key, sent) => {
@@ -957,7 +959,9 @@ const claimServerValue = (key, missed) => {
  * serialization key. The atom is fetched again once seeded if any component using the key then
  * asked to revalidate.
  */
-const seedFromServer = (registry, getAtom, revalidateOption, suspendOnWaiting) => {
+const seedFromServer = (registry, getAtom, 
+// oxlint-disable-next-line sonarjs/bool-param-default -- undefined is "the hook gave no option", so the provider's default applies
+revalidateOption, suspendOnWaiting = false) => {
     const atom = getAtom();
     // The server never computes an atom with a server value, so it has no value to pass on, and the
     // browser must not ask for one: hydratable throws for a key the server didn't write (JND-58).
@@ -1158,9 +1162,9 @@ const isPending = (current, options) => current._tag === "Initial" ||
 /** What the promise resolves with, or the error it rejects with, for a result that is not pending. */
 const fromSettled = (current, options) => {
     if (current._tag === "Success") {
-        return options.includeFailure ? current : current.value;
+        return options.includeFailure === true ? current : current.value;
     }
-    if (current._tag === "Failure" && !options.includeFailure) {
+    if (current._tag === "Failure" && options.includeFailure !== true) {
         throw Cause.squash(current.cause);
     }
     return current;
@@ -1178,6 +1182,7 @@ const fromServerValue = (current, options) => {
         return Promise.resolve(fromSettled(current, options));
     }
     catch (error) {
+        // oxlint-disable-next-line typescript/prefer-promise-reject-errors -- rejects with the atom's squashed error, as awaiting the atom would, whatever its type
         return Promise.reject(error);
     }
 };
@@ -1276,7 +1281,9 @@ const sharedWait = (start, onAbandoned) => {
             }
             held.add(signal);
             holders += 1;
-            const listener = () => release(signal.reason);
+            const listener = () => {
+                release(signal.reason);
+            };
             signal.addEventListener("abort", listener, { once: true });
             listeners.push([signal, listener]);
         },
@@ -1394,9 +1401,10 @@ export function useAtomSuspense(input, options = {}) {
             // settles, as nothing could let go of it. Handled here, so a read nobody awaits isn't reported
             // as unhandled.
             const last = lastWaits.get(getAtom());
-            if (last?.settled()) {
+            if (last?.settled() === true) {
                 return last.promise;
             }
+            // oxlint-disable-next-line typescript/prefer-promise-reject-errors -- rejects with the reader's abort reason, such as Svelte's STALE_REACTION, which Svelte recognises
             const gone = Promise.reject(holder.reason);
             void (async () => {
                 try {
@@ -1422,7 +1430,7 @@ export function useAtomSuspense(input, options = {}) {
                     // reading would compute the atom for nobody.
                     const live = [...readers].filter((reader) => !reader.aborted);
                     if (live.length === 0) {
-                        return undefined;
+                        return;
                     }
                     // A read outside any reaction can't say when it is done, so it doesn't hold the atom: held
                     // by the component's lifetime, the atom would stay mounted after the getter moves on.
@@ -1437,7 +1445,7 @@ export function useAtomSuspense(input, options = {}) {
                     for (const reader of live) {
                         waited = settle(atom, current, reader);
                     }
-                    return waited;
+                    return await waited;
                 })();
                 pending = { promise, readers };
                 afterSeed.set(atom, pending);
@@ -1453,3 +1461,29 @@ export function useAtomSuspense(input, options = {}) {
         return promise;
     }, readOnly);
 }
+export function useForm(form, options) {
+    const registry = getRegistry();
+    const initial = options.initialValues;
+    const getInitial = initialGetter(initial);
+    const engine = engineOf(form, {
+        ...options,
+        initialValues: getInitial ? getInitial() : initial,
+        registry,
+        validates: BROWSER,
+    });
+    const state = useAtomValue(engine.stateAtom);
+    const values = useAtomValue(engine.valuesAtom);
+    engine.setReaders(() => state.current, () => values.current);
+    if (getInitial && BROWSER) {
+        $effect.pre(() => {
+            const next = getInitial();
+            untrack(() => {
+                engine.setInitial(next);
+            });
+        });
+    }
+    onTeardown(() => {
+        engine.dispose();
+    });
+    return engine.root;
+}

package/dist/HydrationBoundary.svelte

@@ -56,11 +56,10 @@
   const { children, state }: Props = $props();
   const registry = getRegistry();
 
-  // SAFETY: preloadedSerializable is on the registry implementation, not the interface (Effect
-  // 4.0.0). It holds the encoded values Hydration.hydrate queued, until a lookup of the key takes one.
-  const { preloadedSerializable: preloaded } = registry as unknown as {
-    readonly preloadedSerializable?: Map<string, unknown>;
-  };
+  // The encoded values Hydration.hydrate queued, until a lookup of the key takes one. Public since
+  // Effect 4.0.2; typed as possibly missing for a registry that isn't Effect's own.
+  const preloaded: Map<string, unknown> | undefined =
+    registry.preloadedSerializable;
   // The values this boundary queued, by key, so it can drop the ones nobody took.
   const queued = new Map<string, unknown>();
   // Whether the boundary has ended, as at the end of the server render or once the browser destroys

package/dist/Inspector.js

@@ -86,10 +86,10 @@ const install = (registry) => {
                 // finalizer that interrupts the fiber.
                 // A wrapper that passes on another atom's result (debounce, makeRefreshOnSignal) holds a
                 // value that atom made, and has no fiber of its own. A runtime's fiber isn't interrupted.
-                if (AsyncResult.isAsyncResult(value) &&
+                const ownWait = AsyncResult.isAsyncResult(value) &&
                     value.waiting &&
-                    (origins.get(value) ?? node) === node &&
-                    !isRuntime(node.atom)) {
+                    (origins.get(value) ?? node) === node;
+                if (ownWait && !isRuntime(node.atom)) {
                     emit({ _tag: "Interrupted", node, time: performance.now() });
                 }
                 emit({ _tag: "Finalized", finalizers, node, time: performance.now() });
@@ -145,8 +145,11 @@ const install = (registry) => {
         });
         complete &&= instrumented;
     };
-    const patchable = registry;
-    const { modify, onNodeAdded, onNodeRemoved, refresh, set, update } = patchable;
+    const { onNodeAdded, onNodeRemoved } = registry;
+    const modify = registry.modify.bind(registry);
+    const refresh = registry.refresh.bind(registry);
+    const set = registry.set.bind(registry);
+    const update = registry.update.bind(registry);
     const writes = (f) => {
         writing += 1;
         try {
@@ -156,33 +159,45 @@ const install = (registry) => {
             writing -= 1;
         }
     };
-    patchable.set = (atom, value) => writes(() => set.call(registry, atom, value));
-    patchable.update = (atom, f) => writes(() => update.call(registry, atom, f));
-    patchable.modify = (atom, f) => writes(() => modify.call(registry, atom, f));
-    // An atom with its own refresh (a wrapper such as withRefresh) calls the registry's refresh for
-    // the atoms it wraps, through this replacement, so each of those is marked too.
-    patchable.refresh = (atom) => {
-        const node = registry.getNodes().get(nodeKey(atom));
-        if (node !== undefined) {
-            record(node).refreshed = true;
-        }
-        try {
-            refresh.call(registry, atom);
-        }
-        finally {
-            // Still valid: the refresh didn't reach it (what it wraps computed an equal value), or it
-            // computed already. Either way the mark isn't the cause of a later computation.
-            if (node?.currentState() === "valid") {
-                record(node).refreshed = false;
+    const patched = {
+        modify: (atom, f) => writes(() => modify(atom, f)),
+        // An atom with its own refresh (a wrapper such as withRefresh) calls the registry's refresh for
+        // the atoms it wraps, through this replacement, so each of those is marked too.
+        refresh: (atom) => {
+            const node = registry.getNodes().get(nodeKey(atom));
+            if (node !== undefined) {
+                record(node).refreshed = true;
             }
-        }
+            try {
+                refresh(atom);
+            }
+            finally {
+                // Still valid: the refresh didn't reach it (what it wraps computed an equal value), or it
+                // computed already. Either way the mark isn't the cause of a later computation.
+                if (node?.currentState() === "valid") {
+                    record(node).refreshed = false;
+                }
+            }
+        },
+        set: (atom, value) => {
+            writes(() => {
+                set(atom, value);
+            });
+        },
+        update: (atom, f) => {
+            writes(() => {
+                update(atom, f);
+            });
+        },
     };
-    patchable.onNodeAdded = (node) => {
+    // Readonly in the interface: replaced on this registry only, as its nodes are.
+    Object.assign(registry, patched);
+    registry.onNodeAdded = (node) => {
         onNodeAdded?.(node);
         instrument(node);
         emit({ _tag: "NodeAdded", node, time: performance.now() });
     };
-    patchable.onNodeRemoved = (node) => {
+    registry.onNodeRemoved = (node) => {
         onNodeRemoved?.(node);
         // An idle node is announced before it is removed; its teardown is reported first.
         if (node.currentState() !== "removed" && records.has(node)) {
@@ -207,7 +222,7 @@ const install = (registry) => {
         idleTTL: (atom) => {
             // An idle TTL of 0 is none: the registry removes the atom as soon as nothing reads it.
             if (atom.keepAlive || atom.idleTTL === 0) {
-                return undefined;
+                return;
             }
             return atom.idleTTL ?? defaultIdleTTL(registry);
         },
@@ -284,7 +299,9 @@ const emptySnapshot = { edges: [], nodes: [], readers: [] };
 /** The scope on the server: always empty. */
 const inertScope = {
     snapshot: () => emptySnapshot,
-    subscribe: () => () => undefined,
+    subscribe: () => () => {
+        // Nothing to unsubscribe from.
+    },
 };
 const stateOf = (node) => {
     // A valid node's value is read without computing anything.
@@ -342,9 +359,7 @@ class Scope {
         if (this.#listeners.size === 0) {
             return this.#walk();
         }
-        if (this.#members === undefined) {
-            this.#members = this.#walk();
-        }
+        this.#members ??= this.#walk();
         return this.#members;
     }
     /** Works out the scope's nodes from the graph as it is now, without keeping them. */
@@ -445,7 +460,9 @@ class Scope {
         if (this.#listeners.size === 0 || this.#following.has(registry)) {
             return;
         }
-        this.#following.set(registry, inspect(registry).subscribe((event) => this.#receive(event)));
+        this.#following.set(registry, inspect(registry).subscribe((event) => {
+            this.#receive(event);
+        }));
     }
     #receive(event) {
         // Events arrive in the middle of the registry's work, while a computation is still changing

package/dist/RegistryContext.js

@@ -91,7 +91,9 @@ export const provideRegistry = (options = {}) => {
     }
     // Not onDestroy: in the browser it never runs for a component destroyed while its script awaits.
     if (!provided) {
-        onTeardownAfterChildren(() => disposeRegistry(registry));
+        onTeardownAfterChildren(() => {
+            disposeRegistry(registry);
+        });
     }
     if (DEV && BROWSER) {
         // For developer tools to find (effect-atom-svelte/inspector).