shelving 1.188.5 → 1.189.0

package/api/endpoint/util.js

@@ -1,6 +1,6 @@
 import { MethodNotAllowedError, NotFoundError } from "../../error/RequestError.js";
 import { ValueError } from "../../error/ValueError.js";
-import { getDictionary } from "../../util/dictionary.js";
+import { requireDictionary } from "../../util/dictionary.js";
 import { getResponse, isRequestMethod, parseRequestBody } from "../../util/http.js";
 import { isPlainObject } from "../../util/object.js";
 import { requireURL } from "../../util/url.js";
@@ -19,7 +19,7 @@ export function handleEndpoints(base, handlers, request, context, caller = handl
         const pathParams = handler.endpoint.match(method, targetPath, caller);
         if (!pathParams)
             continue;
-        const params = searchParams.size ? { ...getDictionary(searchParams), ...pathParams } : pathParams;
+        const params = searchParams.size ? { ...requireDictionary(searchParams), ...pathParams } : pathParams;
         return _handleEndpoint(handler, params, request, context, handleEndpoints);
     }
     throw new NotFoundError("No matching endpoint", { received: targetPath, caller });

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.5",
+	"version": "1.189.0",
 	"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/ArrayStore.d.ts

@@ -1,9 +1,11 @@
-import type { ImmutableArray } from "../util/array.js";
+import type { ImmutableArray, PossibleArray } from "../util/array.js";
 import type { NONE } from "../util/constants.js";
+import type { AnyCaller } from "../util/function.js";
 import { Store } from "./Store.js";
 /** Store an array. */
-export declare class ArrayStore<T> extends Store<ImmutableArray<T>> implements Iterable<T> {
+export declare class ArrayStore<T> extends Store<PossibleArray<T>, ImmutableArray<T>> implements Iterable<T> {
     constructor(value?: ImmutableArray<T> | typeof NONE);
+    convert(value: PossibleArray<T>, caller?: AnyCaller): ImmutableArray<T>;
     /** Get the first item in this store or `null` if this query has no items. */
     get optionalFirst(): T | undefined;
     /** Get the last item in this store or `null` if this query has no items. */

package/store/ArrayStore.js

@@ -1,10 +1,14 @@
-import { getFirst, getLast, omitArrayItems, requireFirst, requireLast, toggleArrayItems, withArrayItems } from "../util/array.js";
+import { getFirst, getLast, omitArrayItems, requireArray, requireFirst, requireLast, toggleArrayItems, withArrayItems, } from "../util/array.js";
 import { Store } from "./Store.js";
 /** Store an array. */
 export class ArrayStore extends Store {
     constructor(value = []) {
         super(value);
     }
+    // Implement to automatically convert `PossibleArray`
+    convert(value, caller = this.convert) {
+        return requireArray(value, undefined, undefined, caller);
+    }
     /** Get the first item in this store or `null` if this query has no items. */
     get optionalFirst() {
         return getFirst(this.value);

package/store/BooleanStore.d.ts

@@ -1,8 +1,7 @@
-import type { NONE } from "../util/constants.js";
 import { Store } from "./Store.js";
 /** Store a boolean. */
-export declare class BooleanStore extends Store<boolean> {
-    constructor(value?: boolean | typeof NONE);
+export declare class BooleanStore extends Store<unknown, boolean> {
+    convert(value: unknown): boolean;
     /** Toggle the current boolean value. */
     toggle(): void;
     isEqual(a: boolean, b: boolean): boolean;

package/store/BooleanStore.js

@@ -1,8 +1,9 @@
 import { Store } from "./Store.js";
 /** Store a boolean. */
 export class BooleanStore extends Store {
-    constructor(value = false) {
-        super(value);
+    // Override to automatically convert to boolean.
+    convert(value) {
+        return !!value;
     }
     /** Toggle the current boolean value. */
     toggle() {

package/store/DataStore.d.ts

@@ -3,7 +3,7 @@ import type { AnyCaller } from "../util/function.js";
 import type { Updates } from "../util/update.js";
 import { Store } from "./Store.js";
 /** Store a data object. */
-export declare class DataStore<T extends Data> extends Store<T> {
+export declare class DataStore<T extends Data> extends Store<T, T> {
     /** Get the data of this store. */
     get data(): T;
     /** Set the data of this store. */
@@ -14,9 +14,10 @@ export declare class DataStore<T extends Data> extends Store<T> {
     get<K extends DataKey<T>>(name: K): T[K];
     /** Update a single named prop in this data. */
     set<K extends DataKey<T>>(name: K, value: T[K]): void;
+    convert(value: T): T;
 }
 /** Store an optional data object. */
-export declare class OptionalDataStore<T extends Data> extends Store<T | undefined> {
+export declare class OptionalDataStore<T extends Data> extends Store<T | undefined, T | undefined> {
     /** Get current data value of this store (or throw `Promise` that resolves to the next required value). */
     get data(): T;
     /** Set the data of this store. */
@@ -33,4 +34,5 @@ export declare class OptionalDataStore<T extends Data> extends Store<T | undefin
     set<K extends DataKey<T>>(name: K, value: T[K]): void;
     /** Set the data to `undefined`. */
     delete(): void;
+    convert(value: T): T;
 }

package/store/DataStore.js

@@ -25,6 +25,10 @@ export class DataStore extends Store {
     set(name, value) {
         this.value = withProp(this.data, name, value);
     }
+    // Implement to passthrough.
+    convert(value) {
+        return value;
+    }
 }
 /** Store an optional data object. */
 export class OptionalDataStore extends Store {
@@ -63,4 +67,8 @@ export class OptionalDataStore extends Store {
     delete() {
         this.value = undefined;
     }
+    // Implement to passthrough.
+    convert(value) {
+        return value;
+    }
 }

package/store/DictionaryStore.d.ts

@@ -1,9 +1,10 @@
-import type { DictionaryItem, ImmutableDictionary } from "../util/dictionary.js";
+import type { DictionaryItem, ImmutableDictionary, PossibleDictionary } from "../util/dictionary.js";
 import type { Updates } from "../util/update.js";
 import { Store } from "./Store.js";
 /** Store a dictionary object. */
-export declare class DictionaryStore<T> extends Store<ImmutableDictionary<T>> implements Iterable<DictionaryItem<T>> {
-    constructor(value?: ImmutableDictionary<T>);
+export declare class DictionaryStore<T> extends Store<PossibleDictionary<T>, ImmutableDictionary<T>> implements Iterable<DictionaryItem<T>> {
+    constructor(value?: PossibleDictionary<T>);
+    convert(possible: PossibleDictionary<T>): ImmutableDictionary<T>;
     /** Get the length of the current value of this store. */
     get count(): number;
     /** Set a named entry in this object with a different value. */

package/store/DictionaryStore.js

@@ -1,11 +1,16 @@
-import { getDictionaryItems, omitDictionaryItems } from "../util/dictionary.js";
+import { EMPTY_DICTIONARY, getDictionaryItems, omitDictionaryItems, requireDictionary } from "../util/dictionary.js";
 import { omitProps, withProp } from "../util/object.js";
 import { updateData } from "../util/update.js";
 import { Store } from "./Store.js";
 /** Store a dictionary object. */
 export class DictionaryStore extends Store {
-    constructor(value = {}) {
-        super(value);
+    // Override to set default value to empty dictionary.
+    constructor(value = EMPTY_DICTIONARY) {
+        super(requireDictionary(value));
+    }
+    // Override to convert a possible dictionary to a dictionary on set.
+    convert(possible) {
+        return requireDictionary(possible);
     }
     /** Get the length of the current value of this store. */
     get count() {

package/store/FetchStore.d.ts

@@ -2,53 +2,63 @@ 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> {
+export declare class FetchStore<T> extends Store<T | typeof NONE, 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>);
+    convert(value: T | typeof NONE): T | typeof NONE;
     /**
-     * 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

@@ -1,6 +1,6 @@
 import { RequiredError } from "../error/RequiredError.js";
 import { isAsync } from "../util/async.js";
-import { ABORTED, NONE } from "../util/constants.js";
+import { ABORT, NONE } from "../util/constants.js";
 import { awaitDispose } from "../util/dispose.js";
 import { BooleanStore } from "./BooleanStore.js";
 import { Store } from "./Store.js";
@@ -8,126 +8,129 @@ 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._callback = callback;
     }
+    // Implement to allow `NONE`
+    convert(value) {
+        return value;
+    }
     /**
-     * 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(ABORT);
+        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(ABORT);
+        this._controller = undefined;
+        this._inflight = undefined;
+        this.busy.value = false;
+        super.abort(); // clears _pendingValue
     }
     // Implement `AsyncDisposable`.
     async [Symbol.asyncDispose]() {

package/store/LoadingStore.d.ts

@@ -0,0 +1,10 @@
+import { NONE } from "../util/constants.js";
+import { Store } from "./Store.js";
+/**
+ * Store that is explicitly allows a "loading" state when it has no value (which is also the default value).
+ * - Note: All stores have know how to interpret `NONE` — this subclass simply _allows_ that through its types.
+ */
+export declare class LoadingStore<T> extends Store<T, T | typeof NONE> {
+    constructor(value?: T | typeof NONE);
+    convert(value: T | typeof NONE): T | typeof NONE;
+}

package/store/LoadingStore.js

@@ -0,0 +1,16 @@
+import { NONE } from "../util/constants.js";
+import { Store } from "./Store.js";
+/**
+ * Store that is explicitly allows a "loading" state when it has no value (which is also the default value).
+ * - Note: All stores have know how to interpret `NONE` — this subclass simply _allows_ that through its types.
+ */
+export class LoadingStore extends Store {
+    // Override to default to `NONE`
+    constructor(value = NONE) {
+        super(value);
+    }
+    // Implement to allow `NONE`
+    convert(value) {
+        return value;
+    }
+}

package/store/PathStore.d.ts

@@ -1,10 +1,11 @@
-import type { AbsolutePath } from "../util/path.js";
+import type { AnyCaller } from "../util/function.js";
+import type { AbsolutePath, PossiblePath } from "../util/path.js";
 import { Store } from "./Store.js";
 /** Store an absolute path, e.g. `/a/b/c` */
-export declare class PathStore extends Store<AbsolutePath> {
-    constructor(path?: string);
-    get value(): AbsolutePath;
-    set value(path: string);
+export declare class PathStore extends Store<PossiblePath, AbsolutePath> {
+    readonly base: AbsolutePath;
+    constructor(path?: string, base?: AbsolutePath);
+    convert(possible: PossiblePath, caller: AnyCaller): AbsolutePath;
     /** Based on the current store path, is a path active? */
     isActive(path: AbsolutePath): boolean;
     /** Based on the current store path, is a path proud (i.e. a child of the current store path)? */

package/store/PathStore.js

@@ -2,15 +2,15 @@ import { isPathActive, isPathProud, requirePath } from "../util/path.js";
 import { Store } from "./Store.js";
 /** Store an absolute path, e.g. `/a/b/c` */
 export class PathStore extends Store {
-    constructor(path = ".") {
-        super(requirePath(path));
+    base;
+    // Override to set default path to `.` and base to `/`
+    constructor(path = ".", base = "/") {
+        super(requirePath(path, base, PathStore));
+        this.base = base;
     }
-    // Override to clean the path on set.
-    get value() {
-        return super.value;
-    }
-    set value(path) {
-        super.value = requirePath(path, super.value);
+    // Implement to convert a possible path to an absolute path (relative to `this.base`).
+    convert(possible, caller) {
+        return requirePath(possible, this.base, caller);
     }
     /** Based on the current store path, is a path active? */
     isActive(path) {

package/store/PayloadFetchStore.d.ts

@@ -1,6 +1,6 @@
 import type { NONE } from "../util/constants.js";
 import { FetchStore } from "./FetchStore.js";
-import { Store } from "./Store.js";
+import { ValueStore } from "./ValueStore.js";
 export type PayloadFetchCallback<P, R> = (payload: P) => R | PromiseLike<R>;
 /**
  * Store that fetches its values from a remote source by sending a payload to them.
@@ -14,7 +14,7 @@ export declare class PayloadFetchStore<P, R> extends FetchStore<R> {
      * Store keeping the current payload to send to the fetch on send.
      * - New payloads can be set using `this.payload.value`
      */
-    readonly payload: Store<P>;
+    readonly payload: ValueStore<P>;
     constructor(payload: P, value: R | typeof NONE, callback?: PayloadFetchCallback<P, R>);
     [Symbol.asyncDispose](): Promise<void>;
 }