effectweb 0.3.0 → 0.3.1

package/dist/keyed-tasks.js

@@ -0,0 +1,97 @@
+import { Cause, Effect, Exit } from 'effect';
+import { commandSlot, program } from './program.js';
+import { defaultUiRuntime } from './runtime.js';
+import { reportError, reportSafely } from './errors.js';
+import { protectSnapshot } from './snapshot.js';
+/** Per-entity serialization. Inputs are captured now; run reads services when work starts. */
+export function keyedTasks(owner, definition, ...provided) {
+    const runtime = provided[0] ?? defaultUiRuntime;
+    const entries = new Map();
+    let disposed = false;
+    const slot = commandSlot(definition.name);
+    const makeSource = () => program({
+        initial: null,
+        update: (model, message) => 'command' in message ? { model, commands: [message.command] } : { model, cancel: [slot] },
+    });
+    // Each key owns a program, including its interrupted fibers, so drain never waits on other keys.
+    const get = (key) => {
+        let entry = entries.get(key);
+        if (!entry) {
+            entry = { source: makeSource(), version: 0, retiring: false };
+            entries.set(key, entry);
+        }
+        return entry;
+    };
+    const dispose = () => {
+        disposed = true;
+        for (const entry of entries.values())
+            entry.source.dispose();
+    };
+    const close = async () => {
+        dispose();
+        await Promise.all([...entries.values()].map((entry) => entry.source.close()));
+        entries.clear();
+    };
+    owner.own({ dispose, close });
+    return {
+        submit(key, input) {
+            if (disposed || owner.disposed)
+                return { outcome: Promise.resolve(Object.freeze({ _tag: 'Cancelled' })) };
+            const captured = protectSnapshot(input);
+            const entry = get(key);
+            entry.version++;
+            let settle;
+            const outcome = new Promise((resolve) => {
+                settle = (result) => resolve(protectSnapshot(result));
+            });
+            outcome
+                .then(async () => {
+                if (entry.retiring)
+                    return;
+                entry.retiring = true;
+                let version;
+                do {
+                    version = entry.version;
+                    await entry.source.awaitStopped();
+                } while (version !== entry.version);
+                if (entries.get(key) === entry) {
+                    entries.delete(key);
+                    entry.source.dispose();
+                }
+            })
+                .catch((error) => reportSafely(reportError, error));
+            const action = Effect.uninterruptibleMask((restore) => restore(Effect.suspend(() => definition.run(key, captured)).pipe(Effect.map((value) => protectSnapshot(value)))).pipe(Effect.exit, Effect.flatMap((exit) => Effect.sync(() => settle(Exit.isSuccess(exit)
+                ? { _tag: 'Success', value: exit.value }
+                : Cause.hasInterruptsOnly(exit.cause)
+                    ? { _tag: 'Cancelled' }
+                    : { _tag: 'Failure', cause: exit.cause })))));
+            entry.source.send({
+                command: {
+                    slot,
+                    policy: definition.policy,
+                    action: runtime.provide(action),
+                    onDiscard: (_tag) => settle({ _tag }),
+                },
+            });
+            return { outcome };
+        },
+        cancel(key) {
+            const entry = entries.get(key);
+            if (entry) {
+                entry.version++;
+                entry.source.send({ cancel: true });
+            }
+        },
+        async drain(...selected) {
+            const pending = selected.length
+                ? [entries.get(selected[0])].filter((entry) => !!entry)
+                : [...entries.values()];
+            await Promise.all(pending.map(async (entry) => {
+                await entry.source.awaitIdle();
+                await entry.source.awaitStopped();
+            }));
+        },
+        close,
+        dispose,
+    };
+}

package/dist/lazy.js

@@ -25,7 +25,15 @@ export function lazyView(load, ...provided) {
         scope.cleanups.push(interrupt);
         if (scope.disposed)
             return;
-        fiber = Effect.runFork(runtime.provide(Effect.suspend(load)));
+        const finished = scope.settlement.begin();
+        try {
+            fiber = Effect.runFork(runtime.provide(Effect.suspend(load)));
+            fiber.addObserver(finished);
+        }
+        catch (error) {
+            finished();
+            throw error;
+        }
         if (scope.disposed) {
             interrupt();
             return;

package/dist/mount.d.ts

@@ -17,6 +17,8 @@ export declare function domMount<T extends Element, R = never>(start: (element:
 /** A stable DOM lifecycle with fresh immutable inputs, for focus, measurements and native events. */
 export declare function domBinding<T extends Element, A, R = never>(data: A | Snapshot<A>, acquire: (element: T, input: () => Snapshot<A>) => Work<R>, ...provided: [R] extends [never] ? [runtime?: UiRuntime<R>] : [runtime: UiRuntime<R>]): DomMount<T>;
 export declare function startMount<T extends Element>(element: T, mount: DomMount<T>, report?: ReportError): {
+    closed: Promise<void>;
+    close(): Promise<void>;
     update(next: DomMount<T>): boolean;
-    dispose(): void;
+    dispose: () => void;
 };

package/dist/mount.js

@@ -31,11 +31,39 @@ export function startMount(element, mount, report = reportError) {
     const work = mount.acquire(element, () => data);
     const fiber = Effect.isEffect(work) ? Effect.runFork(work) : undefined;
     let disposed = false;
+    let finish;
+    const closed = new Promise((resolve) => {
+        finish = resolve;
+    });
     fiber?.addObserver((exit) => {
         if (exit._tag === 'Failure' && !disposed)
             reportSafely(report, exit.cause);
+        finish();
     });
+    const dispose = () => {
+        if (disposed)
+            return;
+        disposed = true;
+        if (fiber)
+            Effect.runFork(Fiber.interrupt(fiber));
+        else {
+            try {
+                if (typeof work === 'function')
+                    work();
+                else if ('dispose' in work)
+                    work.dispose();
+            }
+            finally {
+                finish();
+            }
+        }
+    };
     return {
+        closed,
+        close() {
+            dispose();
+            return closed;
+        },
         update(next) {
             if (next.identity !== mount.identity)
                 return false;
@@ -44,16 +72,6 @@ export function startMount(element, mount, report = reportError) {
                 work.update?.();
             return true;
         },
-        dispose() {
-            if (disposed)
-                return;
-            disposed = true;
-            if (fiber)
-                Effect.runFork(Fiber.interrupt(fiber));
-            else if (typeof work === 'function')
-                work();
-            else if ('dispose' in work)
-                work.dispose();
-        },
+        dispose,
     };
 }

package/dist/owner.d.ts

@@ -24,7 +24,9 @@ export interface ModelOwner<Model extends object, R = never> extends DisposableO
     readonly run: (slot: CommandSlot, effect: Effect.Effect<unknown, unknown, R>, policy: TaskPolicy) => void;
     readonly cancel: (slot: CommandSlot) => void;
     readonly isRunning: (slot: CommandSlot) => boolean;
-    readonly awaitIdle: () => Promise<void>;
+    readonly awaitIdle: (slot?: CommandSlot) => Promise<void>;
+    /** Interrupt and join work before closing owned dependencies in reverse order. */
+    readonly close: () => Promise<void>;
     readonly dispose: () => void;
 }
 type Options = {

package/dist/owner.js

@@ -7,6 +7,7 @@ export function modelOwner(initial, options = {}) {
     let disposed = false;
     let staged;
     const cleanups = [];
+    let closing;
     const source = program({
         initial,
         ...options,
@@ -56,10 +57,44 @@ export function modelOwner(initial, options = {}) {
             return;
         disposed = true;
         source.dispose();
-        runAll(cleanups.splice(0).reverse(), options.onDefect ?? reportError);
+        runAll(cleanups
+            .splice(0)
+            .reverse()
+            .map((resource) => () => resource.dispose()), options.onDefect ?? reportError);
+    };
+    const close = () => {
+        if (closing)
+            return closing;
+        disposed = true;
+        const resources = cleanups.splice(0).reverse();
+        let finish;
+        let fail;
+        closing = new Promise((resolve, reject) => {
+            finish = resolve;
+            fail = reject;
+        });
+        const closeResources = async () => {
+            await source.close();
+            const errors = [];
+            for (const resource of resources) {
+                try {
+                    if (resource.close)
+                        await resource.close();
+                    else
+                        resource.dispose();
+                }
+                catch (error) {
+                    errors.push(error);
+                }
+            }
+            if (errors.length)
+                throw new AggregateError(errors, 'Owner cleanup failed.');
+        };
+        closeResources().then(finish, fail);
+        return closing;
     };
     return {
-        source: { model: source.model, send: source.send, subscribe: source.subscribe, dispose },
+        source: { model: source.model, send: source.send, subscribe: source.subscribe, dispose, close },
         read,
         patch,
         fields: (...keys) => {
@@ -114,11 +149,12 @@ export function modelOwner(initial, options = {}) {
         get disposed() {
             return disposed;
         },
+        close,
         own(resource) {
             if (disposed)
                 resource.dispose();
             else
-                cleanups.push(() => resource.dispose());
+                cleanups.push(resource);
             return resource;
         },
         dispose,

package/dist/pages.d.ts

@@ -3,10 +3,11 @@ import { Cause } from 'effect';
 import * as AsyncResult from 'effect/unstable/reactivity/AsyncResult';
 import type { UiLoad, UiPage } from './load.js';
 import { type Transition, type RunningProgram } from './program.js';
-export interface PagesModel<Props, A, Cursor> {
+import { type UiRuntime } from './runtime.js';
+export interface PagesModel<Props, A, Cursor, E = unknown> {
     readonly props: Props;
     readonly key: string | undefined;
-    readonly result: AsyncResult.AsyncResult<UiPage<A, Cursor>, unknown>;
+    readonly result: AsyncResult.AsyncResult<UiPage<A, Cursor>, E>;
     readonly append: boolean;
 }
 export type PagesRequest = {
@@ -17,34 +18,34 @@ export type PagesRequest = {
     type: 'Refresh';
 };
 /** Low-level reducer protocol, including completions for explicit program composition. */
-export type PagesMessage<A, Cursor> = PagesRequest | {
+export type PagesMessage<A, Cursor, E = unknown> = PagesRequest | {
     type: 'Loaded';
     page: UiPage<A, Cursor>;
     append: boolean;
 } | {
     type: 'Failed';
-    cause: Cause.Cause<unknown>;
+    cause: Cause.Cause<E>;
 };
 /** An owned pagination source with immutable input updates. */
-export interface PagesProgram<Props, A, Cursor> extends RunningProgram<PagesModel<Props, A, Cursor>, PagesRequest> {
+export interface PagesProgram<Props, A, Cursor, E = unknown> extends RunningProgram<PagesModel<Props, A, Cursor, E>, PagesRequest> {
     readonly receive: (props: Props | Snapshot<Props>) => void;
 }
 /** Reusable pagination transitions, or an independently owned source through create. */
-export interface Pagination<Props, A, Cursor> {
-    readonly init: (props: Props | Snapshot<Props>) => PagesModel<Props, A, Cursor> | Snapshot<PagesModel<Props, A, Cursor>>;
-    readonly receive: (model: PagesModel<Props, A, Cursor> | Snapshot<PagesModel<Props, A, Cursor>>, props: Props | Snapshot<Props>, options?: {
+export interface Pagination<Props, A, Cursor, E = unknown> {
+    readonly init: (props: Props | Snapshot<Props>) => PagesModel<Props, A, Cursor, E> | Snapshot<PagesModel<Props, A, Cursor, E>>;
+    readonly receive: (model: PagesModel<Props, A, Cursor, E> | Snapshot<PagesModel<Props, A, Cursor, E>>, props: Props | Snapshot<Props>, options?: {
         refresh?: boolean;
-    }) => Transition<PagesModel<Props, A, Cursor>, PagesMessage<A, Cursor>>;
-    readonly update: (model: PagesModel<Props, A, Cursor> | Snapshot<PagesModel<Props, A, Cursor>>, message: PagesMessage<A, Cursor>) => Transition<PagesModel<Props, A, Cursor>, PagesMessage<A, Cursor>>;
-    readonly create: (props: Props | Snapshot<Props>) => PagesProgram<Props, A, Cursor>;
+    }) => Transition<PagesModel<Props, A, Cursor, E>, PagesMessage<A, Cursor, E>>;
+    readonly update: (model: PagesModel<Props, A, Cursor, E> | Snapshot<PagesModel<Props, A, Cursor, E>>, message: PagesMessage<A, Cursor, E>) => Transition<PagesModel<Props, A, Cursor, E>, PagesMessage<A, Cursor, E>>;
+    readonly create: (props: Props | Snapshot<Props>) => PagesProgram<Props, A, Cursor, E>;
 }
 /**
  * Pagination owns the `page` command slot. Key changes clear results and replace the request;
  * same-key refreshes keep the last success, and retries repeat the failed cursor.
  * Feed request inputs through receive; pass { refresh: true } for explicit same-key submissions.
  */
-export declare function pages<Props, A, Cursor>(definition: {
+export declare function pages<Props, A, Cursor, E = unknown, R = never>(definition: {
     key: (props: Snapshot<Props>) => string | undefined;
-    load: (props: Snapshot<Props>, cursor: Snapshot<Cursor> | undefined) => UiLoad<UiPage<A, Cursor>>;
+    load: (props: Snapshot<Props>, cursor: Snapshot<Cursor> | undefined) => UiLoad<UiPage<A, Cursor>, E, R>;
     itemKey: (item: Snapshot<A>) => string;
-}): Pagination<Props, A, Cursor>;
+}, ...provided: [R] extends [never] ? [runtime?: UiRuntime<R>] : [runtime: UiRuntime<R>]): Pagination<Props, A, Cursor, E>;

package/dist/pages.js

@@ -3,14 +3,16 @@ import { shareData } from './sharing.js';
 import { Cause, Option } from 'effect';
 import * as AsyncResult from 'effect/unstable/reactivity/AsyncResult';
 import { effectCommand, program, } from './program.js';
+import { defaultUiRuntime } from './runtime.js';
 import { available } from './resource.js';
-const commandPage = commandSlot('page');
 /**
  * Pagination owns the `page` command slot. Key changes clear results and replace the request;
  * same-key refreshes keep the last success, and retries repeat the failed cursor.
  * Feed request inputs through receive; pass { refresh: true } for explicit same-key submissions.
  */
-export function pages(definition) {
+export function pages(definition, ...provided) {
+    const runtime = provided[0] ?? defaultUiRuntime;
+    const commandPage = commandSlot('page');
     const request = (model, append) => {
         const previous = available(model.result);
         if (append && (model.result.waiting || !previous || previous.next === undefined))
@@ -21,11 +23,11 @@ export function pages(definition) {
         return {
             model: { ...model, append, result: AsyncResult.waiting(model.result) },
             commands: [
-                effectCommand(commandPage, () => definition.load(model.props, cursor), {
+                runtime.command(effectCommand(commandPage, () => definition.load(model.props, cursor), {
                     policy: 'replace',
                     onSuccess: (page) => ({ type: 'Loaded', page, append }),
                     onFailure: (cause) => ({ type: 'Failed', cause }),
-                }),
+                })),
             ],
         };
     };

package/dist/program.d.ts

@@ -13,6 +13,8 @@ export declare const commandSlot: (name: string) => CommandSlot;
 export type Command<Message, R = never> = {
     readonly slot: CommandSlot;
     readonly policy: TaskPolicy;
+    /** Notification for work that never started. */
+    readonly onDiscard?: (reason: 'Cancelled' | 'Superseded' | 'Dropped') => void;
 } & ({
     readonly effect: Effect.Effect<Message, never, R>;
     readonly stream?: never;
@@ -40,13 +42,21 @@ export interface Transition<Model, Message, R = never> {
     readonly commands?: readonly Command<Message, R>[];
     readonly cancel?: readonly CommandSlot[];
 }
+export declare function mapTransition<Model, Message, Parent, ParentMessage, R = never>(transition: Transition<Model, Message, R>, maps: {
+    readonly model: (model: Snapshot<Model>) => Parent | Snapshot<Parent>;
+    readonly message: (message: Message) => ParentMessage;
+}): Transition<Parent, ParentMessage, R>;
 export interface Program<Model, Message> {
     readonly model: () => Snapshot<Model>;
     readonly send: Send<Message>;
     readonly subscribe: (listener: (model: Snapshot<Model>) => void) => () => void;
     readonly dispose: () => void;
+    readonly close?: () => Promise<void>;
 }
 export interface RunningProgram<Model, Message> extends Program<Model, Message> {
+    /** Wait for interrupted work and its finalizers as well as admitted work. */
+    readonly awaitStopped: () => Promise<void>;
+    readonly close: () => Promise<void>;
     readonly activeSlots: () => readonly CommandSlot[];
     readonly awaitIdle: (slot?: CommandSlot) => Promise<void>;
 }

package/dist/program.js

@@ -23,6 +23,15 @@ export function mapCommand(command, map) {
         ? { ...command, stream: command.stream.pipe(Stream.map(map)) }
         : { ...command, effect: command.effect.pipe(Effect.map(map)) };
 }
+export function mapTransition(transition, maps) {
+    return {
+        model: maps.model(transition.model),
+        ...(transition.cancel ? { cancel: transition.cancel } : {}),
+        ...(transition.commands
+            ? { commands: transition.commands.map((command) => mapCommand(command, maps.message)) }
+            : {}),
+    };
+}
 export function program(options) {
     const id = nextProgramId();
     const trace = (kind, slot, message) => hasProgramObservers() &&
@@ -40,6 +49,7 @@ export function program(options) {
         });
     const waiters = new Set();
     const notify = () => {
+        notifyStopped();
         for (const waiter of waiters) {
             if (disposed ||
                 (!draining && (waiter.slot ? !running.has(waiter.slot) : running.size === 0))) {
@@ -53,11 +63,33 @@ export function program(options) {
     let current = protectSnapshot(options.initial);
     const listeners = new Set();
     const running = new Map();
+    const live = new Set();
+    const stopped = new Set();
+    const notifyStopped = () => {
+        if (live.size || running.size || draining)
+            return;
+        for (const done of stopped)
+            done();
+        stopped.clear();
+    };
+    const awaitStopped = () => live.size === 0 && running.size === 0 && !draining
+        ? Promise.resolve()
+        : new Promise((done) => stopped.add(done));
     let disposed = false;
     let draining = false;
     const queue = [];
     const deferred = [];
-    const cancel = (slot) => {
+    const discard = (command, reason) => {
+        if (command.onDiscard) {
+            try {
+                command.onDiscard(reason);
+            }
+            catch (error) {
+                reportSafely(options.onDefect ?? reportError, error);
+            }
+        }
+    };
+    const cancel = (slot, reason = 'Cancelled') => {
         // A synchronous Effect can enqueue completion behind a reset/replacement message.
         // Its fiber is already done, but cancellation still owns that unpublished completion.
         for (let index = queue.length - 1; index >= 0; index--)
@@ -67,10 +99,15 @@ export function program(options) {
         running.delete(slot);
         if (previous) {
             trace('cancel', slot);
-            previous.pending.length = 0;
-            for (const task of previous.active)
+            const pending = previous.pending.splice(0);
+            for (const command of pending)
+                discard(command, reason);
+            for (const task of previous.active) {
                 if (task.fiber)
                     Effect.runFork(Fiber.interrupt(task.fiber));
+                else if (task.command && !live.has(task))
+                    discard(task.command, reason);
+            }
             previous.active.clear();
         }
     };
@@ -104,13 +141,12 @@ export function program(options) {
             : command.action
                 ? command.action.pipe(Effect.as(Option.none()))
                 : command.effect.pipe(Effect.map(Option.some));
+        live.add(task);
         const fiber = Effect.runFork(effect);
         task.fiber = fiber;
-        if (!valid()) {
-            Effect.runFork(Fiber.interrupt(fiber));
-            return;
-        }
         fiber.addObserver((exit) => {
+            live.delete(task);
+            notifyStopped();
             if (!valid())
                 return;
             group.active.delete(task);
@@ -133,6 +169,8 @@ export function program(options) {
             }
             notify();
         });
+        if (!valid())
+            Effect.runFork(Fiber.interrupt(fiber));
     };
     const advance = (slot, group) => {
         if (disposed || running.get(slot) !== group || group.active.size)
@@ -140,7 +178,7 @@ export function program(options) {
         const next = group.pending.shift();
         if (!next)
             return;
-        const task = {};
+        const task = { command: next };
         group.active.add(task);
         launch(next, group, task);
     };
@@ -181,15 +219,18 @@ export function program(options) {
                         break;
                     const policy = command.policy;
                     let group = running.get(command.slot);
-                    if (policy === 'drop' && group)
+                    if (policy === 'drop' && group) {
+                        discard(command, 'Dropped');
                         continue;
+                    }
                     if (policy === 'replace') {
-                        cancel(command.slot);
+                        cancel(command.slot, 'Superseded');
                         group = undefined;
                     }
                     if (group && (policy === 'queue' || policy === 'latest-queued')) {
                         if (policy === 'latest-queued')
-                            group.pending.length = 0;
+                            for (const pending of group.pending.splice(0))
+                                discard(pending, 'Superseded');
                         group.pending.push(command);
                         continue;
                     }
@@ -197,7 +238,7 @@ export function program(options) {
                         group = { active: new Set(), pending: [] };
                         running.set(command.slot, group);
                     }
-                    const task = {};
+                    const task = { command };
                     group.active.add(task);
                     const admitted = group;
                     starts.push(() => launch(command, admitted, task));
@@ -221,7 +262,24 @@ export function program(options) {
         }
     };
     const send = (message) => enqueue(message);
+    const dispose = () => {
+        if (disposed)
+            return;
+        disposed = true;
+        queue.length = 0;
+        deferred.length = 0;
+        for (const slot of running.keys())
+            cancel(slot);
+        listeners.clear();
+        trace('dispose');
+        notify();
+    };
     return {
+        awaitStopped,
+        close: () => {
+            dispose();
+            return awaitStopped();
+        },
         model: () => current,
         activeSlots: () => [...running.keys()],
         awaitIdle: (slot) => disposed || (!draining && (slot ? !running.has(slot) : running.size === 0))
@@ -246,17 +304,6 @@ export function program(options) {
                 listeners.delete(receive);
             };
         },
-        dispose() {
-            if (disposed)
-                return;
-            disposed = true;
-            queue.length = 0;
-            deferred.length = 0;
-            for (const slot of running.keys())
-                cancel(slot);
-            listeners.clear();
-            trace('dispose');
-            notify();
-        },
+        dispose,
     };
 }

package/dist/query-internals.d.ts

@@ -1,9 +1,11 @@
 import type { Effect } from 'effect';
 import type { Snapshot } from './snapshot.js';
-import type { Query } from './query.js';
+import type { Query, QueryGroup } from './query.js';
 export interface QueryDefinition<Args, A, E, R> {
     readonly name: string;
-    readonly load: (args: Snapshot<Args>) => Effect.Effect<A, E, R>;
+    readonly load: (args: Snapshot<Args>, previous?: Snapshot<A>) => Effect.Effect<A, E, R>;
+    readonly groups?: readonly QueryGroup[];
+    readonly unused?: 'retain' | 'cancel';
     readonly staleTime: number;
     readonly share?: (previous: Snapshot<A>, next: A | Snapshot<A>) => A | Snapshot<A>;
 }

package/dist/query.d.ts

@@ -27,4 +27,10 @@ export declare function query<Args, A, E = never, R = never>(definition: Definit
 export declare function query<A, E = never, R = never>(definition: Definition<true, A, E, R> & {
     readonly load: () => Effect.Effect<A, E, R>;
 }): Query<true, A, E, R>;
+declare const groupType: unique symbol;
+export type QueryGroup = symbol & {
+    readonly [groupType]: true;
+};
+/** Invalidation identity; equal diagnostic names do not share membership. */
+export declare const queryGroup: (name: string) => QueryGroup;
 export {};

package/dist/query.js

@@ -60,6 +60,12 @@ export function query(definition) {
     if (Number.isNaN(staleTime) || staleTime < 0)
         throw new RangeError('Query staleTime must be nonnegative.');
     const result = Object.freeze({ name: definition.name });
-    registerQuery(result, Object.freeze({ ...definition, staleTime }));
+    registerQuery(result, Object.freeze({
+        ...definition,
+        ...(definition.groups ? { groups: Object.freeze([...definition.groups]) } : {}),
+        staleTime,
+    }));
     return result;
 }
+/** Invalidation identity; equal diagnostic names do not share membership. */
+export const queryGroup = (name) => Symbol(name);

package/dist/session.js

@@ -38,7 +38,10 @@ export function queryResource(context, definition) {
     let revision = 0;
     const initial = AsyncResult.initial();
     const listeners = new Set();
-    const read = () => atom && !disposed && generation === internal.registry.get(internal.generation)
+    const read = () => atom &&
+        !disposed &&
+        !internal.disposed() &&
+        generation === internal.registry.get(internal.generation)
         ? internal.registry.get(atom)
         : initial;
     let published;
@@ -102,7 +105,7 @@ export function queryResource(context, definition) {
     });
     return {
         select(args) {
-            if (disposed)
+            if (disposed || internal.disposed())
                 return;
             const nextGeneration = internal.registry.get(internal.generation);
             const nextKey = args === undefined ? undefined : encodeQueryKey(args);
@@ -118,7 +121,12 @@ export function queryResource(context, definition) {
             atom = nextAtom;
             if (nextAtom) {
                 // Subscription setup itself can execute a synchronous Effect and reenter selection.
-                const release = internal.registry.subscribe(nextAtom, notify);
+                const releaseUse = internal.retain(nextAtom);
+                const unsubscribe = internal.registry.subscribe(nextAtom, notify);
+                const release = () => {
+                    unsubscribe();
+                    releaseUse();
+                };
                 if (disposed || selected !== revision) {
                     release();
                     return;
@@ -139,9 +147,10 @@ export function queryResource(context, definition) {
         refresh: () => {
             if (atom &&
                 !disposed &&
+                !internal.disposed() &&
                 generation === internal.registry.get(internal.generation) &&
                 !internal.registry.get(atom).waiting)
-                internal.registry.refresh(atom);
+                internal.refresh(atom);
         },
         dispose: () => {
             if (disposed)

package/dist/settlement.d.ts

@@ -0,0 +1,7 @@
+/** Internal completion accounting, including reentrant acquisition before a fiber is available. */
+export declare class Settlement {
+    private pending;
+    private waiters;
+    begin(): () => void;
+    wait(): Promise<void>;
+}