shelving 1.188.4 → 1.188.6

package/api/store/EndpointStore.d.ts

@@ -6,5 +6,5 @@ export declare class EndpointStore<P, R> extends PayloadFetchStore<P, R> {
     readonly provider: APIProvider<P, R>;
     readonly endpoint: Endpoint<P, R>;
     constructor(endpoint: Endpoint<P, R>, payload: P, provider: APIProvider<P, R>);
-    protected _fetch(): Promise<R>;
+    protected _fetch(signal: AbortSignal): Promise<R>;
 }

package/api/store/EndpointStore.js

@@ -10,7 +10,7 @@ export class EndpointStore extends PayloadFetchStore {
         this.provider = provider;
     }
     // Override to fetch the value using the provider and endpoint.
-    _fetch() {
-        return this.provider.call(this.endpoint, this.payload.value, { signal: this.signal });
+    _fetch(signal) {
+        return this.provider.call(this.endpoint, this.payload.value, { signal });
     }
 }

package/db/store/ItemStore.d.ts

@@ -16,5 +16,5 @@ export declare class ItemStore<I extends Identifier, T extends Data> extends Fet
     get item(): Item<I, T>;
     set item(data: T | Item<I, T>);
     constructor(collection: Collection<string, I, T>, id: I, provider: DBProvider<I>, memory?: MemoryDBProvider<I>);
-    _fetch(): Promise<OptionalItem<I, T>>;
+    _fetch(_signal: AbortSignal): Promise<OptionalItem<I, T>>;
 }

package/db/store/ItemStore.js

@@ -38,7 +38,7 @@ export class ItemStore extends FetchStore {
         this.id = id;
     }
     // Override to get the item from the provider.
-    _fetch() {
+    _fetch(_signal) {
         return this.provider.getItem(this.collection, this.id);
     }
 }

package/db/store/QueryStore.d.ts

@@ -23,7 +23,7 @@ export declare class QueryStore<I extends Identifier, T extends Data> extends Fe
     /** Get the last item in this store. */
     get last(): Item<I, T>;
     constructor(collection: Collection<string, I, T>, query: Query<Item<I, T>>, provider: DBProvider<I>, memory?: MemoryDBProvider<I>);
-    _fetch(): Promise<Items<I, T>>;
+    _fetch(_signal: AbortSignal): Promise<Items<I, T>>;
     /**
      * Load more items after the last once.
      * - Promise that needs to be handled.

package/db/store/QueryStore.js

@@ -62,7 +62,7 @@ export class QueryStore extends FetchStore {
         this.query = query;
     }
     // Override to fetch the result from the database provider.
-    _fetch() {
+    _fetch(_signal) {
         return this.provider.getQuery(this.collection, this.query);
     }
     /**

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "shelving",
-	"version": "1.188.4",
+	"version": "1.188.6",
 	"author": "Dave Houlbrooke <dave@shax.com>",
 	"repository": {
 		"type": "git",
@@ -9,13 +9,13 @@
 	"main": "./index.js",
 	"module": "./index.js",
 	"devDependencies": {
-		"@biomejs/biome": "^2.4.12",
+		"@biomejs/biome": "^2.4.13",
 		"@google-cloud/firestore": "^8.5.0",
-		"@types/bun": "^1.3.12",
+		"@types/bun": "^1.3.13",
 		"@types/react": "^19.2.14",
 		"@types/react-dom": "^19.2.3",
-		"@typescript/native-preview": "^7.0.0-dev.20260418.1",
-		"firebase": "^12.12.0",
+		"@typescript/native-preview": "^7.0.0-dev.20260425.1",
+		"firebase": "^12.12.1",
 		"react": "^19.2.5",
 		"react-dom": "^19.2.5",
 		"typescript": "^5.9.3"

package/store/FetchStore.d.ts

@@ -2,53 +2,62 @@ import { NONE } from "../util/constants.js";
 import { BooleanStore } from "./BooleanStore.js";
 import { Store } from "./Store.js";
 /** Callback for a callback fetch store. */
-export type FetchCallback<T> = () => T | PromiseLike<T>;
+export type FetchCallback<T> = (signal: AbortSignal) => T | PromiseLike<T>;
 /**
  * Store that fetches its values from a remote source.
  *
  * @param value The initial value for the store, or `NONE` if it does not have one yet.
- * @param callback An optional callback that, if set, will be called when the `fetch()` method is invoked to fetch the next value.
+ * @param callback An optional callback that, if set, will be called when the `refresh()` method is invoked to fetch the next value.
  */
 export declare class FetchStore<T> extends Store<T> {
     /**
      * Store that indicates the busy state of this store.
-     * - Can be listened to for e.g. loading spinners etc.
+     * - `true` while a refresh is in-flight, `false` otherwise.
+     * - Can be subscribed to for e.g. loading spinners.
      */
     readonly busy: BooleanStore;
     get loading(): boolean;
     get value(): T;
-    set value(value: T | typeof NONE);
+    set value(value: T | typeof NONE | PromiseLike<T | typeof NONE>);
     constructor(value: T | typeof NONE, callback?: FetchCallback<T>);
     /**
-     * Fetch the result for this endpoint now.
-     * - Triggered automatically when someone reads `value` or `loading`
-     * - Multiple requests to `fetch()` while one is inflight will return the same promise.
+     * Fetch the result for this store now.
+     * - Triggered automatically when someone reads `value` or `loading`.
+     * - Concurrent calls while a fetch is in-flight return the same promise (deduplication).
+     * - Never throws — errors are stored as `reason`.
      *
-     * @returns {Promise} that resolves when the fetch is done.
-     * @returns {void} if this store returned a synchronous value.
-     * @throws {never} Never throws so safe to call unhandled.
+     * @returns `true` if the fetch completed and the value was applied, `false` if aborted or superseded.
+     * @returns Synchronous `boolean` if the callback returned a synchronous value.
      */
-    refresh(): Promise<void> | void;
-    /** An in-flight refresh, so we don't de-duplicate these. */
+    refresh(): Promise<boolean> | boolean;
     private _inflight;
-    await(value: PromiseLike<T>): Promise<void>;
-    private _awaits;
-    /** Call the callback with the current payload. */
-    protected _fetch(): T | PromiseLike<T>;
+    private _refresh;
+    /**
+     * Current `AbortSignal` for this store's in-flight fetch.
+     * - Created lazily; a new signal is issued each time `refresh()` starts a new fetch or `abort()` is called.
+     */
+    get signal(): AbortSignal;
+    private _controller;
+    /**
+     * Call the fetch callback to get the next value.
+     * @param signal `AbortSignal` for the current fetch — passed through to the callback so it can cancel HTTP requests etc.
+     */
+    protected _fetch(signal: AbortSignal): T | PromiseLike<T>;
     private _callback;
-    /** Invalidate this endpoint, so a new fetch is triggered next time `this.value` is called. */
+    /**
+     * Invalidate this store so a new fetch is triggered on the next read of `loading` or `value`.
+     * - Also aborts any current in-flight fetch.
+     */
     invalidate(): void;
     private _invalidation;
-    /** Re-fetch the result now if the current value is older than `maxAge` millisecond or has been invalidated. */
+    /** Re-fetch now if the current value is older than `maxAge` milliseconds or has been invalidated. */
     refreshStale(maxAge: number): Promise<void>;
     /**
-     * Create or get an `AbortSignal` that can be used to cancel an in-flight fetch for this store.
-     * - implementation code or subclasses can use this signal when fetching to cancel the most recent request
-     * - The signal will be reset whenever a fetch completes or a new fetch starts.
+     * Abort any current in-flight fetch and pending async operation.
+     * - Aborts the current `AbortSignal` and clears the controller (a new signal will be created on the next read or fetch).
+     * - Clears the in-flight promise and resets busy state.
+     * - Any pending `await()` result will be silently discarded.
      */
-    get signal(): AbortSignal;
-    private _controller;
-    /** Abort the current signal now. */
     abort(): void;
     [Symbol.asyncDispose](): Promise<void>;
 }

package/store/FetchStore.js

@@ -8,126 +8,125 @@ import { Store } from "./Store.js";
  * Store that fetches its values from a remote source.
  *
  * @param value The initial value for the store, or `NONE` if it does not have one yet.
- * @param callback An optional callback that, if set, will be called when the `fetch()` method is invoked to fetch the next value.
+ * @param callback An optional callback that, if set, will be called when the `refresh()` method is invoked to fetch the next value.
  */
 export class FetchStore extends Store {
     /**
      * Store that indicates the busy state of this store.
-     * - Can be listened to for e.g. loading spinners etc.
+     * - `true` while a refresh is in-flight, `false` otherwise.
+     * - Can be subscribed to for e.g. loading spinners.
      */
     busy;
     // Override to possibly trigger a fetch when `this.loading` is read.
-    // This is because when we check `store.loading` in a component we are signalling intent that we wish to use that value.
+    // Reading `loading` signals intent to use the value, so we start a fetch if needed.
     get loading() {
         const loading = super.loading;
         if (loading || this._invalidation)
             void this.refresh();
         return loading;
     }
-    // Override to possibly trigger a fetch if `this.value` is still in a loading state or is invalid.
-    // This is because when we check `store.loading` in a component we are signalling intent that we wish to use that value.
+    // Override to possibly trigger a fetch if `this.value` is still loading.
+    // Reading `value` signals intent to use the value, so we start a fetch if needed.
     get value() {
         if (super.loading)
             void this.refresh();
         return super.value;
     }
     set value(value) {
-        super.value = value;
-        // Setting a value resets in the invalid state.
+        super.value = value; // calls Store.set value() which calls this.abort() then _applyValue()
+        // Setting a value resets the invalid state.
         this._invalidation = 0;
     }
-    // Override to save callback.
     constructor(value, callback) {
         super(value);
-        this.busy = new BooleanStore(value !== NONE);
+        this.busy = new BooleanStore(value === NONE);
         this._callback = callback;
     }
     /**
-     * Fetch the result for this endpoint now.
-     * - Triggered automatically when someone reads `value` or `loading`
-     * - Multiple requests to `fetch()` while one is inflight will return the same promise.
+     * Fetch the result for this store now.
+     * - Triggered automatically when someone reads `value` or `loading`.
+     * - Concurrent calls while a fetch is in-flight return the same promise (deduplication).
+     * - Never throws — errors are stored as `reason`.
      *
-     * @returns {Promise} that resolves when the fetch is done.
-     * @returns {void} if this store returned a synchronous value.
-     * @throws {never} Never throws so safe to call unhandled.
+     * @returns `true` if the fetch completed and the value was applied, `false` if aborted or superseded.
+     * @returns Synchronous `boolean` if the callback returned a synchronous value.
      */
     refresh() {
         if (this._inflight)
             return this._inflight;
+        // Cancel any existing controller and create a fresh one for this fetch.
+        this._controller?.abort(ABORTED);
+        this._controller = new AbortController();
         try {
-            const value = this._fetch();
+            const value = this._fetch(this._controller.signal);
             if (isAsync(value))
-                return (this._inflight = this.await(value));
+                return (this._inflight = this._refresh(value));
             this.value = value;
+            return true;
         }
         catch (thrown) {
             this.reason = thrown;
+            return false;
         }
     }
-    /** An in-flight refresh, so we don't de-duplicate these. */
     _inflight = undefined;
-    // Override to start/stop `this.busy` when awaiting values, and handle aborts correctly.
-    async await(value) {
+    async _refresh(asyncValue) {
         this.busy.value = true;
-        this._awaits.add(value);
         try {
-            // Capture the invalidation number before the change.
-            const invalidation = this._invalidation;
-            // Use super.value to set the value directly without resetting the invalidation number.
-            super.value = await value;
-            // If this store was not invalidated while awaiting the value (i.e. invalidation number did not change) then reset the invalidation number.
-            if (invalidation === this._invalidation)
+            const refreshed = await this.await(asyncValue);
+            if (refreshed)
                 this._invalidation = 0;
-        }
-        catch (thrown) {
-            // If the throw was not an on-purpose abort, save it as the reason.
-            if (thrown !== ABORTED)
-                this.reason = thrown;
+            return refreshed;
         }
         finally {
-            this._awaits.delete(value);
-            if (!this._awaits.size) {
-                this.busy.value = false;
-                this._inflight = undefined; // Clear any inflight refresh if this was the last await.
-            }
-            this._controller = undefined;
+            this.busy.value = false;
+            this._inflight = undefined;
         }
     }
-    _awaits = new Set(); // Used to only set `busy` when we have no awaited values left.
-    /** Call the callback with the current payload. */
-    _fetch() {
+    /**
+     * Current `AbortSignal` for this store's in-flight fetch.
+     * - Created lazily; a new signal is issued each time `refresh()` starts a new fetch or `abort()` is called.
+     */
+    get signal() {
+        return (this._controller ||= new AbortController()).signal;
+    }
+    _controller;
+    /**
+     * Call the fetch callback to get the next value.
+     * @param signal `AbortSignal` for the current fetch — passed through to the callback so it can cancel HTTP requests etc.
+     */
+    _fetch(signal) {
         if (!this._callback)
             throw new RequiredError("FetchStore has no callback() function", { store: this, caller: this.refresh });
-        return this._callback();
+        return this._callback(signal);
     }
     _callback;
-    /** Invalidate this endpoint, so a new fetch is triggered next time `this.value` is called. */
+    /**
+     * Invalidate this store so a new fetch is triggered on the next read of `loading` or `value`.
+     * - Also aborts any current in-flight fetch.
+     */
     invalidate() {
         this.abort();
         this._invalidation++;
     }
-    _invalidation = 0; // Used to track the "invalidation number" which increments on each invalidation and
-    /** Re-fetch the result now if the current value is older than `maxAge` millisecond or has been invalidated. */
+    _invalidation = 0;
+    /** Re-fetch now if the current value is older than `maxAge` milliseconds or has been invalidated. */
     async refreshStale(maxAge) {
         if (this._invalidation || this.age > maxAge)
             await this.refresh();
     }
     /**
-     * Create or get an `AbortSignal` that can be used to cancel an in-flight fetch for this store.
-     * - implementation code or subclasses can use this signal when fetching to cancel the most recent request
-     * - The signal will be reset whenever a fetch completes or a new fetch starts.
+     * Abort any current in-flight fetch and pending async operation.
+     * - Aborts the current `AbortSignal` and clears the controller (a new signal will be created on the next read or fetch).
+     * - Clears the in-flight promise and resets busy state.
+     * - Any pending `await()` result will be silently discarded.
      */
-    get signal() {
-        return (this._controller ||= new AbortController()).signal;
-    }
-    _controller;
-    /** Abort the current signal now. */
     abort() {
-        const controller = this._controller;
-        if (controller) {
-            controller.abort(ABORTED);
-            this._controller = undefined;
-        }
+        this._controller?.abort(ABORTED);
+        this._controller = undefined;
+        this._inflight = undefined;
+        this.busy.value = false;
+        super.abort(); // clears _pendingValue
     }
     // Implement `AsyncDisposable`.
     async [Symbol.asyncDispose]() {

package/store/PayloadFetchStore.js

@@ -33,8 +33,7 @@ export class PayloadFetchStore extends FetchStore {
  */
 async function _iterate(store) {
     for await (const _payload of store.payload.next) {
-        store.abort(); // Abort any in-flight request that used the old payload.
-        store.invalidate(); // Mark stale so the next read (or the refresh below) fetches fresh data.
-        void store.refresh(); // Eagerly start a fresh fetch if no other fetch is already in-flight.
+        store.invalidate(); // Abort any in-flight fetch and mark stale.
+        void store.refresh(); // Eagerly start a fresh fetch with the new payload.
     }
 }

package/store/Store.d.ts

@@ -10,9 +10,9 @@ export type AnyStore = Store<any>;
  * - Stores also send their most-recent value to any new subscribers immediately when a new subscriber is added.
  * - Stores can also be in a loading store where they do not have a current value.
  *
- * @param initial The initial value for the store, a `Promise` that resolves to the initial value, a source `Subscribable` to subscribe to, or another `Store` instance to take the initial value from and subscribe to.
- * - To set the store to be loading, use the `NONE` constant or a `Promise` value.
- * - To set the store to an explicit value, use that value or another `Store` instance with a value.
+ * @param initial The initial value for this store, a `Promise` that resolves to the initial value, a source `Subscribable` to subscribe to, or another `Store` instance to take the initial value from and subscribe to.
+ * - To set this store to be loading, use the `NONE` constant or a `Promise` value.
+ * - To set this store to an explicit value, use that value or another `Store` instance with a value.
  */
 export declare class Store<T> implements AsyncIterable<T, void, void>, AsyncDisposable {
     /** Deferred sequence this store uses to issue values as they change. */
@@ -24,13 +24,18 @@ export declare class Store<T> implements AsyncIterable<T, void, void>, AsyncDisp
      */
     get loading(): boolean;
     /**
-     * Current value of the store.
+     * Get the current value of this store.
      *
-     * @throws {Promise} that resolves when this store receives its next value or error).
-     * @throws {unknown} if the store currently has an error.
+     * @throws {Promise} if this store currently has no value (resolves when this store receives its next value or error).
+     * @throws {unknown} if this store currently has an error.
      */
     get value(): T;
-    set value(value: T | typeof NONE);
+    /**
+     * Set the value of this store .
+     * - Silently discards any pending `await()` calls.
+     * - Awaits any async values.
+     */
+    set value(value: T | typeof NONE | PromiseLike<T | typeof NONE>);
     private _value;
     /**
      * Time (in milliseconds) this store was last updated with a new value.
@@ -58,22 +63,46 @@ export declare class Store<T> implements AsyncIterable<T, void, void>, AsyncDisp
     private _starter;
     /** Store is initiated with an initial store. */
     constructor(value: T | typeof NONE);
-    /** Set the value of the store as values are pulled from a sequence. */
+    /** Set the value of this store as values are pulled from a sequence. */
     through(sequence: AsyncIterable<T>): AsyncIterable<T>;
     /**
-     * Safely call a callback and save its output value in this `Store`, optionally passing an input value.
-     * @param callback The callback function to call that should return a value to set on this store.
+     * Call a callback that returns a new value (possibly async) for this store.
+     * - Errors are stored as `reason`; never throws.
+     *
+     * @returns `true` if the value was applied, `false` if an error occurred or the result was superseded.
+     */
+    call<A extends Arguments = []>(callback: (...args: A) => T | PromiseLike<T>, ...args: A): Promise<boolean> | boolean;
+    /**
+     * Reduce the current value using a reducer callback that receives the current value.
+     *
+     * @param reducer The callback function to call that should return a value to set on this store.
+     * 		@param value The current value of this store.
+     * 		@param args Any additional input values for the reducer.
+     * 		@returns New value for this store (possibly async).
      * @oaram args Any arguments to pass to the callback.
+     *
+     * @throws {Promise} if this store currently has no value (resolves when this store receives its next value or error).
+     * @throws {unknown} if this store currently has an error reason set.
      */
-    call<A extends Arguments = []>(callback: (...args: A) => T | PromiseLike<T>, ...args: A): void;
+    reduce<A extends Arguments = []>(reducer: (value: T, ...args: A) => T | PromiseLike<T>, ...args: A): Promise<boolean> | boolean;
     /**
      * Await an async value and save it to this store.
-     * - If it rejects, save the rejection `reason` to this store.
+     * - Saves the resolved value.
+     * - If it rejects saves the rejection as `reason`.
+     * - Silently discarded if a newer value is set.
+     * - Silently discarded if `await()` is called again.
+     * - Silently discarded if `abort()` is called.
      *
-     * @returns Promise that resolves when the value has been saved (either resolves to the value or `undefined` if the value threw).
-     * @throws {never} Never throws so safe to call unhandled..
+     * @returns `true` if the value was applied, `false` if superseded, aborted, or errored.
+     * @throws {never} Never throws — safe to call without handling the return value.
+     */
+    await(asyncValue: PromiseLike<T | typeof NONE>): Promise<boolean>;
+    private _pendingValue;
+    /**
+     * Abort any current pending `await()` call.
+     * - The pending call's result will be silently discarded and its error will not be stored.
      */
-    await(value: PromiseLike<T>): Promise<void>;
+    abort(): void;
     [Symbol.asyncIterator](): AsyncIterator<T, void, void>;
     private _iterating;
     /** Compare two values for this store and return whether they are equal. */

package/store/Store.js

@@ -10,9 +10,9 @@ import { getStarter } from "../util/start.js";
  * - Stores also send their most-recent value to any new subscribers immediately when a new subscriber is added.
  * - Stores can also be in a loading store where they do not have a current value.
  *
- * @param initial The initial value for the store, a `Promise` that resolves to the initial value, a source `Subscribable` to subscribe to, or another `Store` instance to take the initial value from and subscribe to.
- * - To set the store to be loading, use the `NONE` constant or a `Promise` value.
- * - To set the store to an explicit value, use that value or another `Store` instance with a value.
+ * @param initial The initial value for this store, a `Promise` that resolves to the initial value, a source `Subscribable` to subscribe to, or another `Store` instance to take the initial value from and subscribe to.
+ * - To set this store to be loading, use the `NONE` constant or a `Promise` value.
+ * - To set this store to an explicit value, use that value or another `Store` instance with a value.
  */
 export class Store {
     /** Deferred sequence this store uses to issue values as they change. */
@@ -26,10 +26,10 @@ export class Store {
         return this._value === NONE && this._reason === undefined;
     }
     /**
-     * Current value of the store.
+     * Get the current value of this store.
      *
-     * @throws {Promise} that resolves when this store receives its next value or error).
-     * @throws {unknown} if the store currently has an error.
+     * @throws {Promise} if this store currently has no value (resolves when this store receives its next value or error).
+     * @throws {unknown} if this store currently has an error.
      */
     get value() {
         if (this._reason !== undefined)
@@ -38,17 +38,28 @@ export class Store {
             throw this.next;
         return this._value;
     }
+    /**
+     * Set the value of this store .
+     * - Silently discards any pending `await()` calls.
+     * - Awaits any async values.
+     */
     set value(value) {
-        this._reason = undefined;
-        if (value === NONE) {
-            this._time = undefined;
-            this._value = value;
-            this.next.cancel();
+        if (isAsync(value)) {
+            void this.await(value);
         }
-        else if (this._value === NONE || !this.isEqual(value, this._value)) {
-            this._time = Date.now();
-            this._value = value;
-            this.next.resolve(value);
+        else {
+            this.abort();
+            this._reason = undefined;
+            if (value === NONE) {
+                this._time = undefined;
+                this._value = value;
+                this.next.cancel();
+            }
+            else if (this._value === NONE || !this.isEqual(value, this._value)) {
+                this._time = Date.now();
+                this._value = value;
+                this.next.resolve(value);
+            }
         }
     }
     _value;
@@ -75,10 +86,10 @@ export class Store {
         return this._reason;
     }
     set reason(reason) {
+        this.abort();
         this._reason = reason;
-        if (reason !== undefined) {
+        if (reason !== undefined)
             this.next.reject(reason);
-        }
     }
     _reason = undefined;
     /**
@@ -99,7 +110,7 @@ export class Store {
         this._value = value;
         this._time = value === NONE ? -Infinity : Date.now();
     }
-    /** Set the value of the store as values are pulled from a sequence. */
+    /** Set the value of this store as values are pulled from a sequence. */
     async *through(sequence) {
         for await (const value of sequence) {
             this.value = value;
@@ -107,39 +118,80 @@ export class Store {
         }
     }
     /**
-     * Safely call a callback and save its output value in this `Store`, optionally passing an input value.
-     * @param callback The callback function to call that should return a value to set on this store.
-     * @oaram args Any arguments to pass to the callback.
+     * Call a callback that returns a new value (possibly async) for this store.
+     * - Errors are stored as `reason`; never throws.
+     *
+     * @returns `true` if the value was applied, `false` if an error occurred or the result was superseded.
      */
     call(callback, ...args) {
         try {
             const value = callback(...args);
             if (isAsync(value))
-                void this.await(value);
-            else
-                this.value = value;
+                return this.await(value);
+            this.value = value;
+            return true;
         }
         catch (thrown) {
             this.reason = thrown;
+            return false;
         }
     }
+    /**
+     * Reduce the current value using a reducer callback that receives the current value.
+     *
+     * @param reducer The callback function to call that should return a value to set on this store.
+     * 		@param value The current value of this store.
+     * 		@param args Any additional input values for the reducer.
+     * 		@returns New value for this store (possibly async).
+     * @oaram args Any arguments to pass to the callback.
+     *
+     * @throws {Promise} if this store currently has no value (resolves when this store receives its next value or error).
+     * @throws {unknown} if this store currently has an error reason set.
+     */
+    reduce(reducer, ...args) {
+        return this.call(reducer, this.value, ...args);
+    }
     /**
      * Await an async value and save it to this store.
-     * - If it rejects, save the rejection `reason` to this store.
+     * - Saves the resolved value.
+     * - If it rejects saves the rejection as `reason`.
+     * - Silently discarded if a newer value is set.
+     * - Silently discarded if `await()` is called again.
+     * - Silently discarded if `abort()` is called.
      *
-     * @returns Promise that resolves when the value has been saved (either resolves to the value or `undefined` if the value threw).
-     * @throws {never} Never throws so safe to call unhandled..
+     * @returns `true` if the value was applied, `false` if superseded, aborted, or errored.
+     * @throws {never} Never throws — safe to call without handling the return value.
      */
-    async await(value) {
+    async await(asyncValue) {
+        // Keep track of the value that is being awaited.
+        // If `_pendingValue` changes while waiting for `asyncValue` to resolve, another call to `await()` has `set value`, `set reason`, or `abort()` has invalidated this one.
+        // If that happens we silently discard the resolved value/reason of this await call.
+        this._pendingValue = asyncValue;
         try {
-            this.value = await value;
+            const value = await asyncValue;
+            if (this._pendingValue === asyncValue) {
+                this.value = value;
+                return true;
+            }
+            return false;
         }
         catch (reason) {
-            this.reason = reason;
+            if (this._pendingValue === asyncValue) {
+                this.reason = reason;
+            }
+            return false;
         }
     }
+    _pendingValue = undefined;
+    /**
+     * Abort any current pending `await()` call.
+     * - The pending call's result will be silently discarded and its error will not be stored.
+     */
+    abort() {
+        this._pendingValue = undefined;
+    }
     // Implement `AsyncIterator`
-    // Issues the current value of the store first, then any subsequent values that are issued.
+    // Issues the current value of this store first, then any subsequent values that are issued.
     async *[Symbol.asyncIterator]() {
         await Promise.resolve(); // Introduce a slight delay, i.e. don't immediately yield `this.value` in case it is changed synchronously.
         this._starter?.start(this);