shelving 1.271.4 → 1.273.0

package/cloudflare/CloudflareKVProvider.d.ts

@@ -16,9 +16,9 @@ import type { KVNamespace } from "./types.js";
  * - ID generation: `addItem()` generates a UUID v4 identifier automatically.
  *
  * ### Not supported
- * - **Realtime subscriptions:** `getItemSequence()` and `getQuerySequence()` throw `UnimplementedError`.
+ * - **Realtime subscriptions:** `getItemSequence()` and `getQuerySequence()` throw `UnsupportedError`.
  *   KV has no change feed or push notification mechanism.
- * - **Updates:** `updateItem()` and `updateQuery()` throw `UnimplementedError`.
+ * - **Updates:** `updateItem()` and `updateQuery()` throw `UnsupportedError`.
  * - **Collection queries:** `getQuery()`, `setQuery()`, `deleteQuery()`, and `countQuery()` are not supported.
  *   KV does not expose efficient filtering, sorting, or collection scans, so this provider avoids the old "read everything and filter in memory" behavior.
  *
@@ -33,22 +33,22 @@ export declare class CloudflareKVProvider<I extends string = string, T extends D
     private readonly _kv;
     constructor(kv: KVNamespace);
     getItem<II extends I, TT extends T>({ name }: Collection<string, II, TT>, id: II): Promise<OptionalItem<II, TT>>;
-    /** Not supported — KV has no change feed, so this throws `UnimplementedError`. */
+    /** Not supported — KV has no change feed, so this throws `UnsupportedError`. */
     getItemSequence<II extends I, TT extends T>(_collection: Collection<string, II, TT>, _id: II): OptionalItemSequence<II, TT>;
     /** Generates a UUID v4 identifier for the new item. */
     addItem<II extends I, TT extends T>({ name }: Collection<string, II, TT>, data: TT): Promise<II>;
     setItem<II extends I, TT extends T>({ name }: Collection<string, II, TT>, id: II, data: TT): Promise<void>;
-    /** Not supported — KV cannot apply partial updates, so this throws `UnimplementedError`. */
+    /** Not supported — KV cannot apply partial updates, so this throws `UnsupportedError`. */
     updateItem<II extends I, TT extends T>(_collection: Collection<string, II, TT>, _id: II, _updates: Updates<Item<II, TT>>): Promise<void>;
     deleteItem<II extends I, TT extends T>({ name }: Collection<string, II, TT>, id: II): Promise<void>;
-    /** Not supported — KV cannot filter, sort, or scan collections, so this throws `UnimplementedError`. */
+    /** Not supported — KV cannot filter, sort, or scan collections, so this throws `UnsupportedError`. */
     getQuery<II extends I, TT extends T>(_collection: Collection<string, II, TT>, _query?: Query<Item<II, TT>>): Promise<Items<II, TT>>;
-    /** Not supported — KV has no change feed, so this throws `UnimplementedError`. */
+    /** Not supported — KV has no change feed, so this throws `UnsupportedError`. */
     getQuerySequence<II extends I, TT extends T>(_collection: Collection<string, II, TT>, _query?: Query<Item<II, TT>>): ItemsSequence<II, TT>;
-    /** Not supported — KV cannot run collection queries, so this throws `UnimplementedError`. */
+    /** Not supported — KV cannot run collection queries, so this throws `UnsupportedError`. */
     setQuery<II extends I, TT extends T>(_collection: Collection<string, II, TT>, _query: Query<Item<II, TT>>, _data: TT): Promise<void>;
-    /** Not supported — KV supports neither updates nor collection queries, so this throws `UnimplementedError`. */
+    /** Not supported — KV supports neither updates nor collection queries, so this throws `UnsupportedError`. */
     updateQuery<II extends I, TT extends T>(_collection: Collection<string, II, TT>, _query: Query<Item<II, TT>>, _updates: Updates<TT>): Promise<void>;
-    /** Not supported — KV cannot run collection queries, so this throws `UnimplementedError`. */
+    /** Not supported — KV cannot run collection queries, so this throws `UnsupportedError`. */
     deleteQuery<II extends I, TT extends T>(_collection: Collection<string, II, TT>, _query: Query<Item<II, TT>>): Promise<void>;
 }

package/cloudflare/CloudflareKVProvider.js

@@ -1,5 +1,5 @@
 import { DBProvider } from "../db/provider/DBProvider.js";
-import { UnimplementedError } from "../error/UnimplementedError.js";
+import { UnsupportedError } from "../error/UnsupportedError.js";
 import { getItem } from "../util/item.js";
 import { randomUUID } from "../util/uuid.js";
 /**
@@ -13,9 +13,9 @@ import { randomUUID } from "../util/uuid.js";
  * - ID generation: `addItem()` generates a UUID v4 identifier automatically.
  *
  * ### Not supported
- * - **Realtime subscriptions:** `getItemSequence()` and `getQuerySequence()` throw `UnimplementedError`.
+ * - **Realtime subscriptions:** `getItemSequence()` and `getQuerySequence()` throw `UnsupportedError`.
  *   KV has no change feed or push notification mechanism.
- * - **Updates:** `updateItem()` and `updateQuery()` throw `UnimplementedError`.
+ * - **Updates:** `updateItem()` and `updateQuery()` throw `UnsupportedError`.
  * - **Collection queries:** `getQuery()`, `setQuery()`, `deleteQuery()`, and `countQuery()` are not supported.
  *   KV does not expose efficient filtering, sorting, or collection scans, so this provider avoids the old "read everything and filter in memory" behavior.
  *
@@ -37,9 +37,9 @@ export class CloudflareKVProvider extends DBProvider {
         if (data)
             return getItem(id, data);
     }
-    /** Not supported — KV has no change feed, so this throws `UnimplementedError`. */
+    /** Not supported — KV has no change feed, so this throws `UnsupportedError`. */
     getItemSequence(_collection, _id) {
-        throw new UnimplementedError("CloudflareKVProvider does not support realtime subscriptions");
+        throw new UnsupportedError("CloudflareKVProvider does not support realtime subscriptions");
     }
     /** Generates a UUID v4 identifier for the new item. */
     async addItem({ name }, data) {
@@ -50,32 +50,32 @@ export class CloudflareKVProvider extends DBProvider {
     async setItem({ name }, id, data) {
         await this._kv.put(_getKey(name, id), JSON.stringify(data));
     }
-    /** Not supported — KV cannot apply partial updates, so this throws `UnimplementedError`. */
+    /** Not supported — KV cannot apply partial updates, so this throws `UnsupportedError`. */
     async updateItem(_collection, _id, _updates) {
-        throw new UnimplementedError("CloudflareKVProvider does not support updates to items");
+        throw new UnsupportedError("CloudflareKVProvider does not support updates to items");
     }
     async deleteItem({ name }, id) {
         await this._kv.delete(_getKey(name, id));
     }
-    /** Not supported — KV cannot filter, sort, or scan collections, so this throws `UnimplementedError`. */
+    /** Not supported — KV cannot filter, sort, or scan collections, so this throws `UnsupportedError`. */
     async getQuery(_collection, _query) {
-        throw new UnimplementedError("CloudflareKVProvider does not support querying items");
+        throw new UnsupportedError("CloudflareKVProvider does not support querying items");
     }
-    /** Not supported — KV has no change feed, so this throws `UnimplementedError`. */
+    /** Not supported — KV has no change feed, so this throws `UnsupportedError`. */
     getQuerySequence(_collection, _query) {
-        throw new UnimplementedError("CloudflareKVProvider does not support realtime subscriptions");
+        throw new UnsupportedError("CloudflareKVProvider does not support realtime subscriptions");
     }
-    /** Not supported — KV cannot run collection queries, so this throws `UnimplementedError`. */
+    /** Not supported — KV cannot run collection queries, so this throws `UnsupportedError`. */
     async setQuery(_collection, _query, _data) {
-        throw new UnimplementedError("CloudflareKVProvider does not support querying items");
+        throw new UnsupportedError("CloudflareKVProvider does not support querying items");
     }
-    /** Not supported — KV supports neither updates nor collection queries, so this throws `UnimplementedError`. */
+    /** Not supported — KV supports neither updates nor collection queries, so this throws `UnsupportedError`. */
     async updateQuery(_collection, _query, _updates) {
-        throw new UnimplementedError("CloudflareKVProvider does not support updates to items");
+        throw new UnsupportedError("CloudflareKVProvider does not support updates to items");
     }
-    /** Not supported — KV cannot run collection queries, so this throws `UnimplementedError`. */
+    /** Not supported — KV cannot run collection queries, so this throws `UnsupportedError`. */
     async deleteQuery(_collection, _query) {
-        throw new UnimplementedError("CloudflareKVProvider does not support querying items");
+        throw new UnsupportedError("CloudflareKVProvider does not support querying items");
     }
 }
 function _getKey(collection, id) {

package/db/cache/DBCache.d.ts

@@ -3,7 +3,7 @@ import type { Identifier, Item } from "../../util/item.js";
 import type { Query } from "../../util/query.js";
 import type { Collection } from "../collection/Collection.js";
 import type { DBProvider } from "../provider/DBProvider.js";
-import type { MemoryDBProvider } from "../provider/MemoryDBProvider.js";
+import { MemoryDBProvider } from "../provider/MemoryDBProvider.js";
 import type { ItemStore } from "../store/ItemStore.js";
 import type { QueryStore } from "../store/QueryStore.js";
 import { CollectionCache } from "./CollectionCache.js";

package/db/cache/DBCache.js

@@ -2,6 +2,7 @@ import { awaitDispose } from "../../util/dispose.js";
 import { setMapItem } from "../../util/map.js";
 import { getSource } from "../../util/source.js";
 import { CacheDBProvider } from "../provider/CacheDBProvider.js";
+import { MemoryDBProvider } from "../provider/MemoryDBProvider.js";
 import { CollectionCache } from "./CollectionCache.js";
 /**
  * Cache of `CollectionCache` objects for multiple collections.
@@ -28,8 +29,8 @@ export class DBCache {
     memory;
     constructor(provider) {
         this.provider = provider;
-        // If the provider chain contains a `CacheDBProvider`, reuse its memory so we can seed stores synchronously.
-        this.memory = getSource(CacheDBProvider, provider)?.memory;
+        // If the provider is itself in-memory (e.g. `MemoryDBProvider` or `StorageDBProvider`), or the chain contains a `CacheDBProvider`, reuse its memory so we can seed stores synchronously.
+        this.memory = provider instanceof MemoryDBProvider ? provider : getSource(CacheDBProvider, provider)?.memory;
     }
     _get(collection) {
         return this._collections.get(collection);

package/db/index.d.ts

@@ -14,6 +14,7 @@ export * from "./provider/MockDBProvider.js";
 export * from "./provider/PostgreSQLProvider.js";
 export * from "./provider/SQLiteProvider.js";
 export * from "./provider/SQLProvider.js";
+export * from "./provider/StorageDBProvider.js";
 export * from "./provider/ThroughDBProvider.js";
 export * from "./provider/ValidationDBProvider.js";
 export * from "./store/ItemStore.js";

package/db/index.js

@@ -14,6 +14,7 @@ export * from "./provider/MockDBProvider.js";
 export * from "./provider/PostgreSQLProvider.js";
 export * from "./provider/SQLiteProvider.js";
 export * from "./provider/SQLProvider.js";
+export * from "./provider/StorageDBProvider.js";
 export * from "./provider/ThroughDBProvider.js";
 export * from "./provider/ValidationDBProvider.js";
 export * from "./store/ItemStore.js";

package/db/migrate/DBMigrator.d.ts

@@ -18,7 +18,7 @@ export declare abstract class DBMigrator<T extends DBProvider = DBProvider> {
      * Bring the provider's storage into line with the given collection schemas.
      *
      * @param collections The collections whose schemas the storage should match.
-     * @throws `UnimplementedError` if a schema feature can't be represented by the backend.
+     * @throws `UnsupportedError` if a schema feature can't be represented by the backend.
      * @example await migrator.migrate(users, posts)
      * @see https://shelving.cc/db/DBMigrator/migrate
      */

package/db/migrate/SQLMigrator.js

@@ -1,4 +1,4 @@
-import { UnimplementedError } from "../../error/UnimplementedError.js";
+import { UnsupportedError } from "../../error/UnsupportedError.js";
 import { ArraySchema } from "../../schema/ArraySchema.js";
 import { BooleanSchema } from "../../schema/BooleanSchema.js";
 import { ChoiceSchema } from "../../schema/ChoiceSchema.js";
@@ -97,12 +97,12 @@ export class SQLMigrator extends DBMigrator {
     }
     getAddColumnQuery(tableName, column) {
         if (column.name === "id")
-            throw new UnimplementedError(`Cannot add primary key column to existing table "${tableName}"`);
+            throw new UnsupportedError(`Cannot add primary key column to existing table "${tableName}"`);
         return `ALTER TABLE ${this.quoteIdentifier(tableName)} ADD COLUMN ${this.getTableColumnDefinition(column)};`;
     }
     getDropColumnQuery(tableName, columnName) {
         if (columnName === "id")
-            throw new UnimplementedError(`Cannot drop primary key column from existing table "${tableName}"`);
+            throw new UnsupportedError(`Cannot drop primary key column from existing table "${tableName}"`);
         return `ALTER TABLE ${this.quoteIdentifier(tableName)} DROP COLUMN ${this.quoteIdentifier(columnName)};`;
     }
     getTableMigrations(collection, table) {
@@ -129,7 +129,7 @@ export class SQLMigrator extends DBMigrator {
         const schema = _getColumnSchema(collection, key);
         const definition = this.definition(schema);
         if (!definition)
-            throw new UnimplementedError(`Cannot generate SQL column for "${key}"`, { received: schema });
+            throw new UnsupportedError(`Cannot generate SQL column for "${key}"`, { received: schema });
         return { name: column, statement: this.getGeneratedColumnDefinition(column, path, definition) };
     }
     isSameColumn(from, to) {
@@ -180,10 +180,10 @@ function _getColumnSchema(collection, key) {
     for (const part of key.split(".")) {
         const current = _unwrapSchema(schema);
         if (!(current instanceof DataSchema))
-            throw new UnimplementedError(`Cannot resolve schema path "${key}"`);
+            throw new UnsupportedError(`Cannot resolve schema path "${key}"`);
         const next = current.props[part];
         if (!next)
-            throw new UnimplementedError(`Cannot resolve schema path "${key}"`);
+            throw new UnsupportedError(`Cannot resolve schema path "${key}"`);
         schema = next;
     }
     return schema;

package/db/migrate/SQLiteMigrator.js

@@ -1,4 +1,4 @@
-import { UnimplementedError } from "../../error/UnimplementedError.js";
+import { UnsupportedError } from "../../error/UnsupportedError.js";
 import { ChoiceSchema } from "../../schema/ChoiceSchema.js";
 import { DateSchema } from "../../schema/DateSchema.js";
 import { NumberSchema } from "../../schema/NumberSchema.js";
@@ -47,7 +47,7 @@ export class SQLiteMigrator extends SQLMigrator {
         if (id instanceof NumberSchema) {
             if (id.step === 1)
                 return "INTEGER PRIMARY KEY";
-            throw new UnimplementedError("SQLiteMigrator only supports string and integer identifiers", { received: id });
+            throw new UnsupportedError("SQLiteMigrator only supports string and integer identifiers", { received: id });
         }
         if (id instanceof ChoiceSchema || id instanceof DateSchema)
             return "TEXT PRIMARY KEY";
@@ -62,7 +62,7 @@ export class SQLiteMigrator extends SQLMigrator {
     }
     getAlterColumnQueries(tableName, from, to) {
         if (from.name === "id" || from.name === "data") {
-            throw new UnimplementedError(`Cannot alter SQLite column "${from.name}" in existing table "${tableName}"`);
+            throw new UnsupportedError(`Cannot alter SQLite column "${from.name}" in existing table "${tableName}"`);
         }
         return super.getAlterColumnQueries(tableName, from, to);
     }

package/db/provider/MemoryDBProvider.d.ts

@@ -16,7 +16,9 @@ import { DBProvider } from "./DBProvider.js";
  */
 export declare class MemoryDBProvider<I extends Identifier = Identifier, T extends Data = Data> extends DBProvider<I, T> {
     /** List of tables in `{ name: MemoryTable }` format. */
-    private _tables;
+    protected _tables: {
+        [K in string]?: MemoryTable<I, T>;
+    };
     /**
      * Get (or lazily create) the `MemoryTable` backing a collection.
      *
@@ -25,6 +27,15 @@ export declare class MemoryDBProvider<I extends Identifier = Identifier, T exten
      * @see https://shelving.cc/db/MemoryDBProvider/getTable
      */
     getTable<II extends I, TT extends T>(collection: Collection<string, II, TT>): MemoryTable<II, TT>;
+    /**
+     * Create a new `MemoryTable` for a collection (without registering it — use `getTable()` for that).
+     * - Override point for subclasses that back collections with a specialised table, e.g. `StorageDBProvider`.
+     *
+     * @param collection Collection to create a table for.
+     * @example provider.createTable(users) // MemoryTable
+     * @see https://shelving.cc/db/MemoryDBProvider/createTable
+     */
+    createTable<II extends I, TT extends T>(collection: Collection<string, II, TT>): MemoryTable<II, TT>;
     getItem<II extends I, TT extends T>(collection: Collection<string, II, TT>, id: II): Promise<OptionalItem<II, TT>>;
     getItemSequence<II extends I, TT extends T>(collection: Collection<string, II, TT>, id: II): OptionalItemSequence<II, TT>;
     addItem<II extends I, TT extends T>(collection: Collection<string, II, TT>, data: TT): Promise<II>;
@@ -46,6 +57,7 @@ export declare class MemoryDBProvider<I extends Identifier = Identifier, T exten
      * @see https://shelving.cc/db/MemoryDBProvider/setItems
      */
     setItems<II extends I, TT extends T>(collection: Collection<string, II, TT>, items: Items<II, TT>): void;
+    [Symbol.asyncDispose](): Promise<void>;
 }
 /**
  * In-memory table holding the items of a single collection for a `MemoryDBProvider`.
@@ -59,7 +71,7 @@ export declare class MemoryDBProvider<I extends Identifier = Identifier, T exten
  *
  * @see https://shelving.cc/db/MemoryTable
  */
-export declare class MemoryTable<I extends Identifier, T extends Data> {
+export declare class MemoryTable<I extends Identifier, T extends Data> implements AsyncDisposable {
     /** Actual data in this table. */
     protected readonly _data: Map<I, Item<I, T>>;
     /**
@@ -203,4 +215,5 @@ export declare class MemoryTable<I extends Identifier, T extends Data> {
     deleteQuery(query: Query<Item<I, T>>): void;
     setItems(items: Items<I, T>): void;
     setItemsSequence(sequence: AsyncIterable<Items<I, T>>): AsyncIterable<Items<I, T>>;
+    [Symbol.asyncDispose](): Promise<void>;
 }

package/db/provider/MemoryDBProvider.js

@@ -1,6 +1,7 @@
 import { StringSchema } from "../../schema/StringSchema.js";
 import { DeferredSequence } from "../../sequence/DeferredSequence.js";
 import { requireArray } from "../../util/array.js";
+import { awaitDispose } from "../../util/dispose.js";
 import { isArrayEqual } from "../../util/equal.js";
 import { getItem } from "../../util/item.js";
 import { countItems } from "../../util/iterate.js";
@@ -28,7 +29,18 @@ export class MemoryDBProvider extends DBProvider {
      * @see https://shelving.cc/db/MemoryDBProvider/getTable
      */
     getTable(collection) {
-        return (this._tables[collection.name] ||= new MemoryTable(collection));
+        return (this._tables[collection.name] ||= this.createTable(collection));
+    }
+    /**
+     * Create a new `MemoryTable` for a collection (without registering it — use `getTable()` for that).
+     * - Override point for subclasses that back collections with a specialised table, e.g. `StorageDBProvider`.
+     *
+     * @param collection Collection to create a table for.
+     * @example provider.createTable(users) // MemoryTable
+     * @see https://shelving.cc/db/MemoryDBProvider/createTable
+     */
+    createTable(collection) {
+        return new MemoryTable(collection);
     }
     async getItem(collection, id) {
         return this.getTable(collection).getItem(id);
@@ -77,6 +89,11 @@ export class MemoryDBProvider extends DBProvider {
     setItems(collection, items) {
         this.getTable(collection).setItems(items);
     }
+    // Implement `AsyncDisposable`
+    async [Symbol.asyncDispose]() {
+        await awaitDispose(...Object.values(this._tables), // Dispose all tables.
+        super[Symbol.asyncDispose]());
+    }
 }
 /**
  * In-memory table holding the items of a single collection for a `MemoryDBProvider`.
@@ -214,11 +231,7 @@ export class MemoryTable {
         const oldItem = this._data.get(id);
         if (!oldItem)
             return;
-        const nextItem = updateData(oldItem, updates);
-        if (this._data.get(id) !== nextItem) {
-            this._data.set(id, nextItem);
-            this.next.resolve();
-        }
+        this.setItem(id, updateData(oldItem, updates));
     }
     /**
      * Delete an item by its id.
@@ -287,16 +300,8 @@ export class MemoryTable {
      * @see https://shelving.cc/db/MemoryTable/setQuery
      */
     setQuery(query, data) {
-        let changed = false;
-        for (const { id } of queryWritableItems(this._data.values(), query)) {
-            const item = getItem(id, data);
-            if (this._data.get(id) !== item) {
-                this._data.set(id, item);
-                changed = true;
-            }
-        }
-        if (changed)
-            this.next.resolve();
+        for (const { id } of queryWritableItems(this._data.values(), query))
+            this.setItem(id, data);
     }
     /**
      * Apply partial updates to every item matching a query.
@@ -307,41 +312,16 @@ export class MemoryTable {
      * @see https://shelving.cc/db/MemoryTable/updateQuery
      */
     updateQuery(query, updates) {
-        let changed = false;
-        for (const { id } of queryWritableItems(this._data.values(), query)) {
-            const oldItem = this._data.get(id);
-            if (!oldItem)
-                continue;
-            const nextItem = updateData(oldItem, updates);
-            if (this._data.get(id) !== nextItem) {
-                this._data.set(id, nextItem);
-                changed = true;
-            }
-        }
-        if (changed)
-            this.next.resolve();
+        for (const { id } of queryWritableItems(this._data.values(), query))
+            this.updateItem(id, updates);
     }
     deleteQuery(query) {
-        let changed = false;
-        for (const { id } of queryWritableItems(this._data.values(), query)) {
-            if (this._data.has(id)) {
-                this._data.delete(id);
-                changed = true;
-            }
-        }
-        if (changed)
-            this.next.resolve();
+        for (const { id } of queryWritableItems(this._data.values(), query))
+            this.deleteItem(id);
     }
     setItems(items) {
-        let changed = false;
-        for (const item of items) {
-            if (this._data.get(item.id) !== item) {
-                this._data.set(item.id, item);
-                changed = true;
-            }
-        }
-        if (changed)
-            this.next.resolve();
+        for (const item of items)
+            this.setItem(item.id, item);
     }
     async *setItemsSequence(sequence) {
         for await (const items of sequence) {
@@ -349,4 +329,10 @@ export class MemoryTable {
             yield items;
         }
     }
+    // Implement `AsyncDisposable`
+    async [Symbol.asyncDispose]() {
+        await awaitDispose(
+        // Empty by default.
+        );
+    }
 }

package/db/provider/SQLProvider.d.ts

@@ -19,7 +19,7 @@ export interface SQLFragment {
  *
  * - Subclasses implement `exec()` to run a query against a concrete database (e.g. SQLite, PostgreSQL).
  * - The `sql*` helpers build composable `SQLFragment` objects so dialect differences can be overridden.
- * - Realtime subscriptions are unsupported and throw `UnimplementedError`.
+ * - Realtime subscriptions are unsupported and throw `UnsupportedError`.
  *
  * @see https://shelving.cc/db/SQLProvider
  */
@@ -34,7 +34,7 @@ export declare abstract class SQLProvider<I extends Identifier = Identifier, T e
      */
     abstract exec<X extends Data>(strings: TemplateStringsArray, ...values: ImmutableArray<unknown>): Promise<ImmutableArray<X>>;
     getItem<II extends I, TT extends T>(collection: Collection<string, II, TT>, id: II): Promise<OptionalItem<II, TT>>;
-    /** Unsupported by SQL providers — always throws `UnimplementedError`. */
+    /** Unsupported by SQL providers — always throws `UnsupportedError`. */
     getItemSequence<II extends I, TT extends T>(_collection: Collection<string, II, TT>, _id: II): OptionalItemSequence<II, TT>;
     /** Insert via `INSERT ... RETURNING`; throws `RequiredError` if no id comes back. */
     addItem<II extends I, TT extends T>(collection: Collection<string, II, TT>, data: TT): Promise<II>;
@@ -43,7 +43,7 @@ export declare abstract class SQLProvider<I extends Identifier = Identifier, T e
     deleteItem<II extends I, TT extends T>(collection: Collection<string, II, TT>, id: II): Promise<void>;
     countQuery<II extends I, TT extends T>(collection: Collection<string, II, TT>, query?: Query<Item<II, TT>>): Promise<number>;
     getQuery<II extends I, TT extends T>(collection: Collection<string, II, TT>, query?: Query<Item<II, TT>>): Promise<Items<II, TT>>;
-    /** Unsupported by SQL providers — always throws `UnimplementedError`. */
+    /** Unsupported by SQL providers — always throws `UnsupportedError`. */
     getQuerySequence<II extends I, TT extends T>(_collection: Collection<string, II, TT>, _query?: Query<Item<II, TT>>): ItemsSequence<II, TT>;
     setQuery<II extends I, TT extends T>(collection: Collection<string, II, TT>, query: Query<Item<II, TT>>, data: TT): Promise<void>;
     updateQuery<II extends I, TT extends T>(collection: Collection<string, II, TT>, query: Query<Item<II, TT>>, updates: Updates<TT>): Promise<void>;
@@ -70,7 +70,7 @@ export declare abstract class SQLProvider<I extends Identifier = Identifier, T e
      * - Base implementation only supports flat (single-segment) keys; subclasses override for nested JSON paths.
      *
      * @param key The key segments identifying the column (and any nested path).
-     * @throws `UnimplementedError` if the key is nested (multi-segment).
+     * @throws `UnsupportedError` if the key is nested (multi-segment).
      * @example this.sqlExtract(["name"]); // "name"
      * @see https://shelving.cc/db/SQLProvider/sqlExtract
      */
@@ -105,11 +105,11 @@ export declare abstract class SQLProvider<I extends Identifier = Identifier, T e
     /**
      * Define an SQL fragment for a single update action.
      * - Handles flat `set` and `sum` only (single-segment key).
-     * - Nested keys (multi-segment) and `with`/`omit` actions throw `UnimplementedError`.
+     * - Nested keys (multi-segment) and `with`/`omit` actions throw `UnsupportedError`.
      * - Subclasses should override to support nested keys and array mutation actions.
      *
      * @param update The update action (`action`, `key`, `value`) to convert.
-     * @throws `UnimplementedError` if the key is nested or the action is unsupported.
+     * @throws `UnsupportedError` if the key is nested or the action is unsupported.
      * @example this.sqlUpdate({ action: "set", key: ["a"], value: 1 }); // "a" = 1
      * @see https://shelving.cc/db/SQLProvider/sqlUpdate
      */
@@ -144,7 +144,7 @@ export declare abstract class SQLProvider<I extends Identifier = Identifier, T e
      * Define an SQL fragment for a single filter clause on a column, e.g. `x = 1` or `x IN (1, 2)`.
      *
      * @param filter The filter (`key`, `operator`, `value`) to translate.
-     * @throws `UnimplementedError` if the operator is unsupported.
+     * @throws `UnsupportedError` if the operator is unsupported.
      * @example this.sqlFilter({ key: ["x"], operator: "is", value: 1 }); // "x" = 1
      * @see https://shelving.cc/db/SQLProvider/sqlFilter
      */
@@ -152,10 +152,10 @@ export declare abstract class SQLProvider<I extends Identifier = Identifier, T e
     /**
      * Define an SQL fragment for an `ORDER BY` clause, e.g. ` ORDER BY "a" ASC, "b" DESC`.
      * - Returns an empty fragment when the query has no orders.
-     * - Nested keys (multi-segment) throw `UnimplementedError`.
+     * - Nested keys (multi-segment) throw `UnsupportedError`.
      *
      * @param query The query whose orders become the `ORDER BY` clause.
-     * @throws `UnimplementedError` if an order key is nested (multi-segment).
+     * @throws `UnsupportedError` if an order key is nested (multi-segment).
      * @example this.sqlOrder(query); // ORDER BY "a" ASC
      * @see https://shelving.cc/db/SQLProvider/sqlOrder
      */

package/db/provider/SQLProvider.js

@@ -1,5 +1,5 @@
 import { RequiredError } from "../../error/RequiredError.js";
-import { UnimplementedError } from "../../error/UnimplementedError.js";
+import { UnsupportedError } from "../../error/UnsupportedError.js";
 import { getQueryFilters, getQueryLimit, getQueryOrders } from "../../util/query.js";
 import { getUpdates } from "../../util/update.js";
 import { DBProvider } from "./DBProvider.js";
@@ -8,7 +8,7 @@ import { DBProvider } from "./DBProvider.js";
  *
  * - Subclasses implement `exec()` to run a query against a concrete database (e.g. SQLite, PostgreSQL).
  * - The `sql*` helpers build composable `SQLFragment` objects so dialect differences can be overridden.
- * - Realtime subscriptions are unsupported and throw `UnimplementedError`.
+ * - Realtime subscriptions are unsupported and throw `UnsupportedError`.
  *
  * @see https://shelving.cc/db/SQLProvider
  */
@@ -21,9 +21,9 @@ export class SQLProvider extends DBProvider {
 		`;
         return rows[0];
     }
-    /** Unsupported by SQL providers — always throws `UnimplementedError`. */
+    /** Unsupported by SQL providers — always throws `UnsupportedError`. */
     getItemSequence(_collection, _id) {
-        throw new UnimplementedError(`SQLProvider does not support realtime subscriptions`);
+        throw new UnsupportedError(`SQLProvider does not support realtime subscriptions`);
     }
     /** Insert via `INSERT ... RETURNING`; throws `RequiredError` if no id comes back. */
     async addItem(collection, data) {
@@ -65,9 +65,9 @@ export class SQLProvider extends DBProvider {
 			${query ? this.sqlClauses(query) : this.sql ``}
 		`;
     }
-    /** Unsupported by SQL providers — always throws `UnimplementedError`. */
+    /** Unsupported by SQL providers — always throws `UnsupportedError`. */
     getQuerySequence(_collection, _query) {
-        throw new UnimplementedError(`SQLProvider does not support realtime subscriptions`);
+        throw new UnsupportedError(`SQLProvider does not support realtime subscriptions`);
     }
     async setQuery(collection, query, data) {
         await this.exec `UPDATE ${this.sqlIdentifier(collection.name)} SET ${this.sqlSetters(data)}${this.sqlClauses(query)}`;
@@ -104,13 +104,13 @@ export class SQLProvider extends DBProvider {
      * - Base implementation only supports flat (single-segment) keys; subclasses override for nested JSON paths.
      *
      * @param key The key segments identifying the column (and any nested path).
-     * @throws `UnimplementedError` if the key is nested (multi-segment).
+     * @throws `UnsupportedError` if the key is nested (multi-segment).
      * @example this.sqlExtract(["name"]); // "name"
      * @see https://shelving.cc/db/SQLProvider/sqlExtract
      */
     sqlExtract(key) {
         if (key.length > 1)
-            throw new UnimplementedError("SQLProvider does not support nested filter keys");
+            throw new UnsupportedError("SQLProvider does not support nested filter keys");
         return this.sqlIdentifier(key[0]);
     }
     /**
@@ -151,23 +151,23 @@ export class SQLProvider extends DBProvider {
     /**
      * Define an SQL fragment for a single update action.
      * - Handles flat `set` and `sum` only (single-segment key).
-     * - Nested keys (multi-segment) and `with`/`omit` actions throw `UnimplementedError`.
+     * - Nested keys (multi-segment) and `with`/`omit` actions throw `UnsupportedError`.
      * - Subclasses should override to support nested keys and array mutation actions.
      *
      * @param update The update action (`action`, `key`, `value`) to convert.
-     * @throws `UnimplementedError` if the key is nested or the action is unsupported.
+     * @throws `UnsupportedError` if the key is nested or the action is unsupported.
      * @example this.sqlUpdate({ action: "set", key: ["a"], value: 1 }); // "a" = 1
      * @see https://shelving.cc/db/SQLProvider/sqlUpdate
      */
     sqlUpdate({ action, key, value }) {
         if (key.length > 1)
-            throw new UnimplementedError("SQLProvider does not support nested update keys");
+            throw new UnsupportedError("SQLProvider does not support nested update keys");
         const column = this.sqlIdentifier(key[0]);
         if (action === "set")
             return this.sql `${column} = ${value}`;
         if (action === "sum")
             return this.sql `${column} = ${column} + ${value}`;
-        throw new UnimplementedError(`SQLProvider does not support "${action}" updates`);
+        throw new UnsupportedError(`SQLProvider does not support "${action}" updates`);
     }
     /**
      * Define an SQL fragment for `VALUES` syntax, e.g. `("a", "b") VALUES (1, 2)`.
@@ -211,7 +211,7 @@ export class SQLProvider extends DBProvider {
      * Define an SQL fragment for a single filter clause on a column, e.g. `x = 1` or `x IN (1, 2)`.
      *
      * @param filter The filter (`key`, `operator`, `value`) to translate.
-     * @throws `UnimplementedError` if the operator is unsupported.
+     * @throws `UnsupportedError` if the operator is unsupported.
      * @example this.sqlFilter({ key: ["x"], operator: "is", value: 1 }); // "x" = 1
      * @see https://shelving.cc/db/SQLProvider/sqlFilter
      */
@@ -239,15 +239,15 @@ export class SQLProvider extends DBProvider {
             return this.sql `${path} > ${value}`;
         if (operator === "gte")
             return this.sql `${path} >= ${value}`;
-        throw new UnimplementedError(`SQLProvider does not support "${operator}" filters`);
+        throw new UnsupportedError(`SQLProvider does not support "${operator}" filters`);
     }
     /**
      * Define an SQL fragment for an `ORDER BY` clause, e.g. ` ORDER BY "a" ASC, "b" DESC`.
      * - Returns an empty fragment when the query has no orders.
-     * - Nested keys (multi-segment) throw `UnimplementedError`.
+     * - Nested keys (multi-segment) throw `UnsupportedError`.
      *
      * @param query The query whose orders become the `ORDER BY` clause.
-     * @throws `UnimplementedError` if an order key is nested (multi-segment).
+     * @throws `UnsupportedError` if an order key is nested (multi-segment).
      * @example this.sqlOrder(query); // ORDER BY "a" ASC
      * @see https://shelving.cc/db/SQLProvider/sqlOrder
      */

package/db/provider/StorageDBProvider.d.ts

@@ -0,0 +1,79 @@
+import type { Data } from "../../util/data.js";
+import type { Identifier, Item } from "../../util/item.js";
+import type { Collection } from "../collection/Collection.js";
+import { MemoryDBProvider, MemoryTable } from "./MemoryDBProvider.js";
+/**
+ * In-memory database provider that persists every collection to a `Storage` — `localStorage`, `sessionStorage`, or anything else with the same interface.
+ *
+ * - Extends `MemoryDBProvider`, so all reads, queries, and realtime sequences are served synchronously from memory, and it can seed `ItemStore` / `QueryStore` and act as the cache inside `CacheDBProvider`. The only difference is that collections are backed by `StorageTable` instead of `MemoryTable`.
+ * - The storage is a required argument (there is no default), so server code that constructs this provider must reference `localStorage` / `sessionStorage` itself — surfacing the mistake at the callsite instead of deep inside this class.
+ * - Treat the persisted data as best-effort: quota is shared across the origin (typically ~5MB) and users can clear it at any time. Data read back from storage is unvalidated — wrap this provider in `ValidationDBProvider` if it may have been written by an older version of your app.
+ * - If the storage is unusable (writes blocked by browser settings, or private browsing with zero quota), the provider degrades to memory-only operation — check the `persistent` flag to warn users their changes won't be saved.
+ *
+ * @example
+ *  const provider = new StorageDBProvider(localStorage);
+ *  if (!provider.persistent) console.warn("Changes won't be saved on this device.");
+ *  const id = await provider.addItem(users, { name: "Dave" });
+ *
+ * @see https://shelving.cc/db/StorageDBProvider
+ */
+export declare class StorageDBProvider<I extends Identifier = Identifier, T extends Data = Data> extends MemoryDBProvider<I, T> {
+    /**
+     * Prefix for every storage key written by this provider.
+     *
+     * @see https://shelving.cc/db/StorageDBProvider/prefix
+     */
+    readonly prefix: string;
+    /**
+     * Whether this provider is actually persisting to storage.
+     * - `false` when storage exists but is unusable (e.g. blocked by browser settings, or private browsing with zero quota) — the provider still works, but data only lives in memory and is lost when the page closes.
+     *
+     * @see https://shelving.cc/db/StorageDBProvider/persistent
+     */
+    readonly persistent: boolean;
+    /** Storage being persisted to, or `undefined` when operating memory-only. */
+    private readonly _storage;
+    /**
+     * @param storage `Storage` instance to persist to, e.g. `localStorage` or `sessionStorage` (required so environments without one, e.g. the server, fail at the callsite).
+     * @param prefix Prefix for every storage key written by this provider, so it can share an origin's storage with other code (defaults to `"shelving:"`).
+     */
+    constructor(storage: Storage, prefix?: string);
+    /** Back collections with a `StorageTable`, or a plain `MemoryTable` when operating memory-only. */
+    createTable<II extends I, TT extends T>(collection: Collection<string, II, TT>): MemoryTable<II, TT>;
+}
+/**
+ * `MemoryTable` that persists its items to a `Storage` instance — self-contained, so it can also be used independently of `StorageDBProvider`.
+ *
+ * - Hydrates itself from storage on construction, then persists each write *before* applying it to memory, so a failed write (e.g. `QuotaExceededError` when the origin's quota is full) throws and leaves memory and storage consistent.
+ * - Items are stored as JSON under keys formatted as `{prefix}{collection}:{id}`, so values must be JSON-serializable. The id in the key is authoritative — an `id` stored inside the JSON is overridden.
+ * - Listens for `storage` events, so changes made in other tabs/windows update memory and notify realtime sequences. Dispose the table (or its provider) to remove the listener.
+ *
+ * @see https://shelving.cc/db/StorageTable
+ */
+export declare class StorageTable<I extends Identifier, T extends Data> extends MemoryTable<I, T> {
+    /** Prefix for every storage key belonging to this table, e.g. `"shelving:users:"`. */
+    private readonly _prefix;
+    /** Storage this table persists to. */
+    private readonly _storage;
+    /** Attached `storage` event listener (so it can be detached on dispose), or `undefined` if none was attached. */
+    private readonly _listener;
+    constructor(collection: Collection<string, I, T>, storage: Storage, prefix?: string);
+    /** Load every persisted item of this table's collection into memory (directly, skipping the persist-back in `setItem()`). */
+    private _hydrate;
+    /** Storage key for an item of this table. */
+    private _key;
+    /** Identifier encoded in a storage key of this table. */
+    private _decodeKey;
+    /** Parse a stored JSON value into an item with the given id, or `undefined` if it's malformed. */
+    private _parse;
+    /**
+     * Apply a `storage` event (a change made in another tab/window) to this table.
+     * - Reuses `setItem()` / `deleteItem()` — re-persisting the value already in storage is a no-op, and same-tab writes don't fire `storage` events, so this can't loop.
+     */
+    private _syncStorage;
+    /** Persist to storage first — a failure (e.g. `QuotaExceededError`) throws before memory changes, keeping the two consistent. */
+    setItem(id: I, data: Item<I, T> | T): void;
+    /** Remove from storage first, keeping storage and memory consistent. */
+    deleteItem(id: I): void;
+    [Symbol.asyncDispose](): Promise<void>;
+}

package/db/provider/StorageDBProvider.js

@@ -0,0 +1,163 @@
+import { UnsupportedError } from "../../error/UnsupportedError.js";
+import { StringSchema } from "../../schema/StringSchema.js";
+import { isData } from "../../util/data.js";
+import { awaitDispose } from "../../util/dispose.js";
+import { getItem } from "../../util/item.js";
+import { MemoryDBProvider, MemoryTable } from "./MemoryDBProvider.js";
+/**
+ * In-memory database provider that persists every collection to a `Storage` — `localStorage`, `sessionStorage`, or anything else with the same interface.
+ *
+ * - Extends `MemoryDBProvider`, so all reads, queries, and realtime sequences are served synchronously from memory, and it can seed `ItemStore` / `QueryStore` and act as the cache inside `CacheDBProvider`. The only difference is that collections are backed by `StorageTable` instead of `MemoryTable`.
+ * - The storage is a required argument (there is no default), so server code that constructs this provider must reference `localStorage` / `sessionStorage` itself — surfacing the mistake at the callsite instead of deep inside this class.
+ * - Treat the persisted data as best-effort: quota is shared across the origin (typically ~5MB) and users can clear it at any time. Data read back from storage is unvalidated — wrap this provider in `ValidationDBProvider` if it may have been written by an older version of your app.
+ * - If the storage is unusable (writes blocked by browser settings, or private browsing with zero quota), the provider degrades to memory-only operation — check the `persistent` flag to warn users their changes won't be saved.
+ *
+ * @example
+ *  const provider = new StorageDBProvider(localStorage);
+ *  if (!provider.persistent) console.warn("Changes won't be saved on this device.");
+ *  const id = await provider.addItem(users, { name: "Dave" });
+ *
+ * @see https://shelving.cc/db/StorageDBProvider
+ */
+export class StorageDBProvider extends MemoryDBProvider {
+    /**
+     * Prefix for every storage key written by this provider.
+     *
+     * @see https://shelving.cc/db/StorageDBProvider/prefix
+     */
+    prefix;
+    /**
+     * Whether this provider is actually persisting to storage.
+     * - `false` when storage exists but is unusable (e.g. blocked by browser settings, or private browsing with zero quota) — the provider still works, but data only lives in memory and is lost when the page closes.
+     *
+     * @see https://shelving.cc/db/StorageDBProvider/persistent
+     */
+    persistent;
+    /** Storage being persisted to, or `undefined` when operating memory-only. */
+    _storage;
+    /**
+     * @param storage `Storage` instance to persist to, e.g. `localStorage` or `sessionStorage` (required so environments without one, e.g. the server, fail at the callsite).
+     * @param prefix Prefix for every storage key written by this provider, so it can share an origin's storage with other code (defaults to `"shelving:"`).
+     */
+    constructor(storage, prefix = "shelving:") {
+        super();
+        this.prefix = prefix;
+        if (!storage)
+            throw new UnsupportedError("StorageDBProvider requires a Storage, e.g. localStorage or sessionStorage", {
+                caller: StorageDBProvider,
+            });
+        // Probe with a write+remove: private browsing can expose a `Storage` whose every write throws.
+        try {
+            const probe = `${prefix}?`;
+            storage.setItem(probe, "?");
+            storage.removeItem(probe);
+            this.persistent = true;
+            this._storage = storage;
+        }
+        catch {
+            // Unusable storage — degrade to memory-only.
+            this.persistent = false;
+            this._storage = undefined;
+        }
+    }
+    /** Back collections with a `StorageTable`, or a plain `MemoryTable` when operating memory-only. */
+    createTable(collection) {
+        return this._storage ? new StorageTable(collection, this._storage, this.prefix) : super.createTable(collection);
+    }
+}
+/**
+ * `MemoryTable` that persists its items to a `Storage` instance — self-contained, so it can also be used independently of `StorageDBProvider`.
+ *
+ * - Hydrates itself from storage on construction, then persists each write *before* applying it to memory, so a failed write (e.g. `QuotaExceededError` when the origin's quota is full) throws and leaves memory and storage consistent.
+ * - Items are stored as JSON under keys formatted as `{prefix}{collection}:{id}`, so values must be JSON-serializable. The id in the key is authoritative — an `id` stored inside the JSON is overridden.
+ * - Listens for `storage` events, so changes made in other tabs/windows update memory and notify realtime sequences. Dispose the table (or its provider) to remove the listener.
+ *
+ * @see https://shelving.cc/db/StorageTable
+ */
+export class StorageTable extends MemoryTable {
+    /** Prefix for every storage key belonging to this table, e.g. `"shelving:users:"`. */
+    _prefix;
+    /** Storage this table persists to. */
+    _storage;
+    /** Attached `storage` event listener (so it can be detached on dispose), or `undefined` if none was attached. */
+    _listener;
+    constructor(collection, storage, prefix = "shelving:") {
+        super(collection);
+        this._storage = storage;
+        this._prefix = `${prefix}${collection.name}:`;
+        this._hydrate();
+        // Changes made in other tabs/windows arrive as `storage` events on the global scope.
+        if (typeof globalThis.addEventListener === "function") {
+            this._listener = event => this._syncStorage(event);
+            globalThis.addEventListener("storage", this._listener);
+        }
+    }
+    /** Load every persisted item of this table's collection into memory (directly, skipping the persist-back in `setItem()`). */
+    _hydrate() {
+        for (let i = 0; i < this._storage.length; i++) {
+            const key = this._storage.key(i);
+            if (key?.startsWith(this._prefix)) {
+                const id = this._decodeKey(key);
+                const item = this._parse(id, this._storage.getItem(key));
+                if (item)
+                    this._data.set(id, item);
+            }
+        }
+    }
+    /** Storage key for an item of this table. */
+    _key(id) {
+        return `${this._prefix}${id}`;
+    }
+    /** Identifier encoded in a storage key of this table. */
+    _decodeKey(key) {
+        const raw = key.slice(this._prefix.length);
+        return (this.collection.id instanceof StringSchema ? raw : Number(raw)); // `as I` needed: TypeScript can't narrow I from the schema check.
+    }
+    /** Parse a stored JSON value into an item with the given id, or `undefined` if it's malformed. */
+    _parse(id, value) {
+        if (value) {
+            try {
+                const data = JSON.parse(value);
+                if (isData(data))
+                    return getItem(id, data); // `as T` needed: stored values are unvalidated — wrap the provider in `ValidationDBProvider` to validate them.
+            }
+            catch {
+                // Malformed values are skipped, not deleted — they may belong to other code sharing the prefix.
+            }
+        }
+    }
+    /**
+     * Apply a `storage` event (a change made in another tab/window) to this table.
+     * - Reuses `setItem()` / `deleteItem()` — re-persisting the value already in storage is a no-op, and same-tab writes don't fire `storage` events, so this can't loop.
+     */
+    _syncStorage({ storageArea, key, newValue }) {
+        if (storageArea !== this._storage)
+            return;
+        if (key === null) {
+            this.deleteQuery({}); // A `null` key means the other tab called `storage.clear()`.
+        }
+        else if (key.startsWith(this._prefix)) {
+            const id = this._decodeKey(key);
+            const item = newValue !== null ? this._parse(id, newValue) : undefined;
+            item ? this.setItem(id, item) : this.deleteItem(id);
+        }
+    }
+    /** Persist to storage first — a failure (e.g. `QuotaExceededError`) throws before memory changes, keeping the two consistent. */
+    setItem(id, data) {
+        const item = getItem(id, data);
+        if (this._data.get(id) !== item)
+            this._storage.setItem(this._key(id), JSON.stringify(item));
+        super.setItem(id, item);
+    }
+    /** Remove from storage first, keeping storage and memory consistent. */
+    deleteItem(id) {
+        if (this._data.has(id))
+            this._storage.removeItem(this._key(id));
+        super.deleteItem(id);
+    }
+    // Implement `AsyncDisposable`
+    async [Symbol.asyncDispose]() {
+        await awaitDispose(() => this._listener && globalThis.removeEventListener("storage", this._listener), // Stop listening for `storage` events.
+        super[Symbol.asyncDispose]());
+    }
+}

package/error/{UnimplementedError.d.ts → UnsupportedError.d.ts}

@@ -1,12 +1,12 @@
 import { type BaseError, type BaseErrorOptions } from "./BaseError.js";
 /**
- * Error thrown when functionality is called but is not implemented by an interface.
+ * Error thrown when functionality is called but is not supported — by a backend, an environment, or an implementation.
  *
- * @see https://shelving.cc/error/UnimplementedError
+ * @see https://shelving.cc/error/UnsupportedError
  */
-export declare class UnimplementedError extends Error implements BaseError {
+export declare class UnsupportedError extends Error implements BaseError {
     /** Provide additional named contextual data that is relevant to the `Error` instance. */
     readonly [key: string]: unknown;
-    /** @param message Optional human-readable description of the missing implementation. */
+    /** @param message Optional human-readable description of the unsupported functionality. */
     constructor(message?: string, options?: BaseErrorOptions);
 }

package/error/UnsupportedError.js

@@ -0,0 +1,14 @@
+import { setBaseErrorOptions } from "./BaseError.js";
+/**
+ * Error thrown when functionality is called but is not supported — by a backend, an environment, or an implementation.
+ *
+ * @see https://shelving.cc/error/UnsupportedError
+ */
+export class UnsupportedError extends Error {
+    /** @param message Optional human-readable description of the unsupported functionality. */
+    constructor(message, options = {}) {
+        super(message, options);
+        setBaseErrorOptions(UnsupportedError, this, options);
+    }
+}
+UnsupportedError.prototype.name = "UnsupportedError";

package/error/index.d.ts

@@ -5,5 +5,5 @@ export * from "./RequestError.js";
 export * from "./RequiredError.js";
 export * from "./ResponseError.js";
 export * from "./UnexpectedError.js";
-export * from "./UnimplementedError.js";
+export * from "./UnsupportedError.js";
 export * from "./ValueError.js";

package/error/index.js

@@ -5,5 +5,5 @@ export * from "./RequestError.js";
 export * from "./RequiredError.js";
 export * from "./ResponseError.js";
 export * from "./UnexpectedError.js";
-export * from "./UnimplementedError.js";
+export * from "./UnsupportedError.js";
 export * from "./ValueError.js";

package/firestore/lite/FirestoreLiteProvider.d.ts

@@ -10,7 +10,7 @@ import type { Updates } from "../../util/update.js";
  *
  * - Works with the Firebase JS SDK via `firebase/firestore/lite`, which keeps bundle size small.
  * - Does not support offline mode.
- * - Does not support realtime subscriptions: `getItemSequence()` and `getQuerySequence()` throw `UnimplementedError`.
+ * - Does not support realtime subscriptions: `getItemSequence()` and `getQuerySequence()` throw `UnsupportedError`.
  *
  * @see https://shelving.cc/firestore/lite/FirestoreLiteProvider
  */
@@ -24,7 +24,7 @@ export declare class FirestoreLiteProvider<I extends string = string, T extends
     /** Get a Firestore QueryReference for a given query. */
     private _query;
     getItem<II extends I, TT extends T>(c: Collection<string, II, TT>, id: II): Promise<OptionalItem<II, TT>>;
-    /** Not supported — the Firebase Lite SDK has no realtime listeners, so this throws `UnimplementedError`. */
+    /** Not supported — the Firebase Lite SDK has no realtime listeners, so this throws `UnsupportedError`. */
     getItemSequence<II extends I, TT extends T>(_c: Collection<string, II, TT>, _id: II): OptionalItemSequence<II, TT>;
     addItem<II extends I, TT extends T>(c: Collection<string, II, TT>, data: TT): Promise<II>;
     setItem<II extends I, TT extends T>(c: Collection<string, II, TT>, id: II, data: TT): Promise<void>;
@@ -32,7 +32,7 @@ export declare class FirestoreLiteProvider<I extends string = string, T extends
     deleteItem<II extends I, TT extends T>(c: Collection<string, II, TT>, id: II): Promise<void>;
     countQuery<II extends I, TT extends T>(c: Collection<string, II, TT>, q?: Query<Item<II, TT>>): Promise<number>;
     getQuery<II extends I, TT extends T>(c: Collection<string, II, TT>, q?: Query<Item<II, TT>>): Promise<Items<II, TT>>;
-    /** Not supported — the Firebase Lite SDK has no realtime listeners, so this throws `UnimplementedError`. */
+    /** Not supported — the Firebase Lite SDK has no realtime listeners, so this throws `UnsupportedError`. */
     getQuerySequence<II extends I, TT extends T>(_c: Collection<string, II, TT>, _q?: Query<Item<II, TT>>): ItemsSequence<II, TT>;
     setQuery<II extends I, TT extends T>(c: Collection<string, II, TT>, q: Query<Item<II, TT>>, data: TT): Promise<void>;
     updateQuery<II extends I, TT extends T>(c: Collection<string, II, TT>, q: Query<Item<II, TT>>, updates: Updates<TT>): Promise<void>;

package/firestore/lite/FirestoreLiteProvider.js

@@ -1,6 +1,6 @@
 import { addDoc, arrayRemove, arrayUnion, collection, deleteDoc, doc, documentId, getCount, getDoc, getDocs, increment, limit, orderBy, query, setDoc, updateDoc, where, } from "firebase/firestore/lite";
 import { DBProvider } from "../../db/provider/DBProvider.js";
-import { UnimplementedError } from "../../error/UnimplementedError.js";
+import { UnsupportedError } from "../../error/UnsupportedError.js";
 import { joinDataPath } from "../../util/data.js";
 import { getItem } from "../../util/item.js";
 import { getObject } from "../../util/object.js";
@@ -66,7 +66,7 @@ function _getFieldValue({ key, action, value }) {
  *
  * - Works with the Firebase JS SDK via `firebase/firestore/lite`, which keeps bundle size small.
  * - Does not support offline mode.
- * - Does not support realtime subscriptions: `getItemSequence()` and `getQuerySequence()` throw `UnimplementedError`.
+ * - Does not support realtime subscriptions: `getItemSequence()` and `getQuerySequence()` throw `UnsupportedError`.
  *
  * @see https://shelving.cc/firestore/lite/FirestoreLiteProvider
  */
@@ -92,9 +92,9 @@ export class FirestoreLiteProvider extends DBProvider {
         const snapshot = await getDoc(this._doc(c, id));
         return _getOptionalItem(snapshot);
     }
-    /** Not supported — the Firebase Lite SDK has no realtime listeners, so this throws `UnimplementedError`. */
+    /** Not supported — the Firebase Lite SDK has no realtime listeners, so this throws `UnsupportedError`. */
     getItemSequence(_c, _id) {
-        throw new UnimplementedError("FirestoreLiteProvider does not support realtime subscriptions");
+        throw new UnsupportedError("FirestoreLiteProvider does not support realtime subscriptions");
     }
     async addItem(c, data) {
         const reference = await addDoc(this._collection(c), data);
@@ -116,9 +116,9 @@ export class FirestoreLiteProvider extends DBProvider {
     async getQuery(c, q) {
         return _getItems(await getDocs(this._query(c, q)));
     }
-    /** Not supported — the Firebase Lite SDK has no realtime listeners, so this throws `UnimplementedError`. */
+    /** Not supported — the Firebase Lite SDK has no realtime listeners, so this throws `UnsupportedError`. */
     getQuerySequence(_c, _q) {
-        throw new UnimplementedError("FirestoreLiteProvider does not support realtime subscriptions");
+        throw new UnsupportedError("FirestoreLiteProvider does not support realtime subscriptions");
     }
     async setQuery(c, q, data) {
         const snapshot = await getDocs(this._query(c, q));

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "shelving",
-	"version": "1.271.4",
+	"version": "1.273.0",
 	"author": "Dave Houlbrooke <dave@shax.com>",
 	"repository": {
 		"type": "git",

package/error/UnimplementedError.js

@@ -1,14 +0,0 @@
-import { setBaseErrorOptions } from "./BaseError.js";
-/**
- * Error thrown when functionality is called but is not implemented by an interface.
- *
- * @see https://shelving.cc/error/UnimplementedError
- */
-export class UnimplementedError extends Error {
-    /** @param message Optional human-readable description of the missing implementation. */
-    constructor(message, options = {}) {
-        super(message, options);
-        setBaseErrorOptions(UnimplementedError, this, options);
-    }
-}
-UnimplementedError.prototype.name = "UnimplementedError";