@camstack/system 1.2.390 → 1.2.392

package/dist/builtins/sqlite-storage/filter-compiler.d.ts

@@ -1,126 +1,126 @@
 /**
- * One filter compiler for both the read and the bulk-mutation paths.
- *
- * It exists because those two paths must NOT behave the same way, and until
- * now the only compiler lived inline in `query` — where being forgiving is
- * correct. Reusing it verbatim for `deleteWhere` would have shipped two
- * data-loss shapes:
- *
- *  - **A dropped predicate.** A field that is not a column of a structured
- *    table is skipped, so `{ deviceId: 615, kind: 'motion' }` can compile to
- *    `WHERE "deviceId" = ?` — on a SELECT that returns extra rows, on a DELETE
- *    it removes rows the caller meant to keep.
- *  - **No predicate at all.** An empty filter compiles to an empty WHERE,
- *    which on a DELETE is the entire collection.
- *
- * `select` mode keeps the historical behaviour, because every existing caller
- * was written against it. `mutate` mode refuses both, before any SQL exists.
- * Emptying a collection is a legitimate thing to want, and it should be a
- * differently-named operation rather than a filter that happens to be empty.
- * `measure` mode sits between them — see {@link FilterMode}.
- *
- * ── NULL is a value the language can name ────────────────────────────────
- *
- * A `null` on the right-hand side of `where` / `whereNot` compiles to `IS NULL`
- * / `IS NOT NULL`, and binds no parameter. It used to compile to `= ?` / `!= ?`
- * with a NULL parameter, and SQL three-valued logic makes both of those NULL
- * for every row: the filter matched NOTHING and the caller got a `0` that
- * looked like an answer. `pipelineAnalytics.countUnstampedEventMedia` — the
- * gate that decides whether 152 GB of event media may be repointed onto
- * another disk — asks exactly "how many rows have no `locationId`", and `0` is
- * the one value that opens it. `whereNot: { field: null }` was the same defect
- * mirrored: `(expr IS NULL OR expr != NULL)` is TRUE for a NULL row and NULL
- * for every other, so it selected precisely the rows it was asked to exclude.
- *
- * Nothing could ever have MEANT `= NULL`; there is no caller to preserve.
- */
+* One filter compiler for both the read and the bulk-mutation paths.
+*
+* It exists because those two paths must NOT behave the same way, and until
+* now the only compiler lived inline in `query` — where being forgiving is
+* correct. Reusing it verbatim for `deleteWhere` would have shipped two
+* data-loss shapes:
+*
+*  - **A dropped predicate.** A field that is not a column of a structured
+*    table is skipped, so `{ deviceId: 615, kind: 'motion' }` can compile to
+*    `WHERE "deviceId" = ?` — on a SELECT that returns extra rows, on a DELETE
+*    it removes rows the caller meant to keep.
+*  - **No predicate at all.** An empty filter compiles to an empty WHERE,
+*    which on a DELETE is the entire collection.
+*
+* `select` mode keeps the historical behaviour, because every existing caller
+* was written against it. `mutate` mode refuses both, before any SQL exists.
+* Emptying a collection is a legitimate thing to want, and it should be a
+* differently-named operation rather than a filter that happens to be empty.
+* `measure` mode sits between them — see {@link FilterMode}.
+*
+* ── NULL is a value the language can name ────────────────────────────────
+*
+* A `null` on the right-hand side of `where` / `whereNot` compiles to `IS NULL`
+* / `IS NOT NULL`, and binds no parameter. It used to compile to `= ?` / `!= ?`
+* with a NULL parameter, and SQL three-valued logic makes both of those NULL
+* for every row: the filter matched NOTHING and the caller got a `0` that
+* looked like an answer. `pipelineAnalytics.countUnstampedEventMedia` — the
+* gate that decides whether 152 GB of event media may be repointed onto
+* another disk — asks exactly "how many rows have no `locationId`", and `0` is
+* the one value that opens it. `whereNot: { field: null }` was the same defect
+* mirrored: `(expr IS NULL OR expr != NULL)` is TRUE for a NULL row and NULL
+* for every other, so it selected precisely the rows it was asked to exclude.
+*
+* Nothing could ever have MEANT `= NULL`; there is no caller to preserve.
+*/
 /** The part of a declared collection this compiler needs. */
 export interface CollectionShape {
-    readonly primaryKey: string;
-    readonly columns: ReadonlySet<string>;
-    /**
-     * The single JSON blob column for a KV-shaped collection (fields inside it
-     * are reachable via `json_extract`), or `null` for a structured table whose
-     * fields are real columns.
-     */
-    readonly kvBlobColumn: string | null;
+	readonly primaryKey: string;
+	readonly columns: ReadonlySet<string>;
+	/**
+	* The single JSON blob column for a KV-shaped collection (fields inside it
+	* are reachable via `json_extract`), or `null` for a structured table whose
+	* fields are real columns.
+	*/
+	readonly kvBlobColumn: string | null;
 }
 /**
- * How forgiving this compilation is allowed to be.
- *
- * - `select` — a predicate naming a field the collection cannot express is
- *   SKIPPED. The caller receives the rows and can see for itself that the
- *   filter did not bite; the cost is extra rows, not a wrong belief.
- * - `measure` — the same predicate is REFUSED. A count, an aggregate or a
- *   histogram hands back a NUMBER: the whole collection and the intended
- *   subset are the same shape, and the caller has no way to tell which one it
- *   was given. An empty filter is still fine — `COUNT(*)` over everything is a
- *   legitimate question, unlike `DELETE` over everything. This closes the
- *   asymmetry `aggregate` already applied to its FIELDS ("a dropped aggregate
- *   returns a number that is wrong and looks exactly like a real one") but not
- *   to its predicate.
- * - `mutate` — refuses that AND an empty filter, which on a bulk write is the
- *   entire collection.
- */
-export type FilterMode = 'select' | 'measure' | 'mutate';
+* How forgiving this compilation is allowed to be.
+*
+* - `select` — a predicate naming a field the collection cannot express is
+*   SKIPPED. The caller receives the rows and can see for itself that the
+*   filter did not bite; the cost is extra rows, not a wrong belief.
+* - `measure` — the same predicate is REFUSED. A count, an aggregate or a
+*   histogram hands back a NUMBER: the whole collection and the intended
+*   subset are the same shape, and the caller has no way to tell which one it
+*   was given. An empty filter is still fine — `COUNT(*)` over everything is a
+*   legitimate question, unlike `DELETE` over everything. This closes the
+*   asymmetry `aggregate` already applied to its FIELDS ("a dropped aggregate
+*   returns a number that is wrong and looks exactly like a real one") but not
+*   to its predicate.
+* - `mutate` — refuses that AND an empty filter, which on a bulk write is the
+*   entire collection.
+*/
+export type FilterMode = "select" | "measure" | "mutate";
 /** Marshals a JS value to what the driver should bind. */
 export type SerializeValue = (value: unknown) => unknown;
 export interface QueryFilterInput {
-    /** Equality. A `null` value means `IS NULL` — see the file docblock. */
-    readonly where?: Readonly<Record<string, unknown>>;
-    readonly whereIn?: Readonly<Record<string, readonly unknown[]>>;
-    readonly whereBetween?: Readonly<Record<string, readonly [unknown, unknown]>>;
-    /**
-     * NULL-safe exclusion, compiled as `(expr IS NULL OR expr != ?)`. SQL `!=`
-     * alone drops NULL rows, and on a nullable column those are precisely the
-     * rows a "not this kind" filter must keep (they predate the column).
-     *
-     * A `null` VALUE means `IS NOT NULL` instead: "everything except the rows
-     * that carry no value" is the only reading of `whereNot: { f: null }` that
-     * is not a contradiction.
-     */
-    readonly whereNot?: Readonly<Record<string, unknown>>;
-    /**
-     * NULL-safe exclusion of a SET, compiled as
-     * `(expr IS NULL OR expr NOT IN (…))` — `whereNot` for more than one value.
-     * See `QueryFilter.whereNotIn` for why it is a separate operator and not a
-     * `whereNot` that happens to take an array.
-     *
-     * An EMPTY list is no predicate at all, not "matches nothing" — the same
-     * reading `whereJsonArrayAny` gives it.
-     */
-    readonly whereNotIn?: Readonly<Record<string, readonly unknown[]>>;
-    /**
-     * JSON-array membership, compiled as
-     * `(expr IS NULL OR NOT json_valid(expr) OR EXISTS (SELECT 1 FROM
-     * json_each(expr) WHERE value IN (…)))`.
-     *
-     * A SUPERSET prefilter on purpose — see `QueryFilter.whereJsonArrayAny`. An
-     * unreadable column keeps its row rather than losing it, so this can narrow
-     * a read without ever changing an answer.
-     */
-    readonly whereJsonArrayAny?: Readonly<Record<string, readonly unknown[]>>;
+	/** Equality. A `null` value means `IS NULL` — see the file docblock. */
+	readonly where?: Readonly<Record<string, unknown>>;
+	readonly whereIn?: Readonly<Record<string, readonly unknown[]>>;
+	readonly whereBetween?: Readonly<Record<string, readonly [unknown, unknown]>>;
+	/**
+	* NULL-safe exclusion, compiled as `(expr IS NULL OR expr != ?)`. SQL `!=`
+	* alone drops NULL rows, and on a nullable column those are precisely the
+	* rows a "not this kind" filter must keep (they predate the column).
+	*
+	* A `null` VALUE means `IS NOT NULL` instead: "everything except the rows
+	* that carry no value" is the only reading of `whereNot: { f: null }` that
+	* is not a contradiction.
+	*/
+	readonly whereNot?: Readonly<Record<string, unknown>>;
+	/**
+	* NULL-safe exclusion of a SET, compiled as
+	* `(expr IS NULL OR expr NOT IN (…))` — `whereNot` for more than one value.
+	* See `QueryFilter.whereNotIn` for why it is a separate operator and not a
+	* `whereNot` that happens to take an array.
+	*
+	* An EMPTY list is no predicate at all, not "matches nothing" — the same
+	* reading `whereJsonArrayAny` gives it.
+	*/
+	readonly whereNotIn?: Readonly<Record<string, readonly unknown[]>>;
+	/**
+	* JSON-array membership, compiled as
+	* `(expr IS NULL OR NOT json_valid(expr) OR EXISTS (SELECT 1 FROM
+	* json_each(expr) WHERE value IN (…)))`.
+	*
+	* A SUPERSET prefilter on purpose — see `QueryFilter.whereJsonArrayAny`. An
+	* unreadable column keeps its row rather than losing it, so this can narrow
+	* a read without ever changing an answer.
+	*/
+	readonly whereJsonArrayAny?: Readonly<Record<string, readonly unknown[]>>;
 }
 /**
- * The predicate-only filter a bulk mutation accepts — no ordering, no limit.
- * Structurally the mutation half of {@link QueryFilterInput}.
- */
+* The predicate-only filter a bulk mutation accepts — no ordering, no limit.
+* Structurally the mutation half of {@link QueryFilterInput}.
+*/
 export type MutationFilterInput = QueryFilterInput;
 export interface CompiledFilter {
-    /** Either `''` or a leading-space ` WHERE …` clause, ready to concatenate. */
-    readonly whereSql: string;
-    readonly params: readonly unknown[];
+	/** Either `''` or a leading-space ` WHERE …` clause, ready to concatenate. */
+	readonly whereSql: string;
+	readonly params: readonly unknown[];
 }
 /** Thrown by `measure` and `mutate` mode. Distinct type so a caller can map it
- *  to a 400. */
+*  to a 400. */
 export declare class UnsafeFilterError extends Error {
-    constructor(message: string);
+	constructor(message: string);
 }
 /**
- * SQL expression for `field` on this collection, or `null` when it cannot be
- * expressed: a real column → `"field"`; a KV blob field → `json_extract`;
- * anything else on a structured table → unresolvable. Exported because
- * `histogram` needs the same resolution for its bucketed column.
- */
+* SQL expression for `field` on this collection, or `null` when it cannot be
+* expressed: a real column → `"field"`; a KV blob field → `json_extract`;
+* anything else on a structured table → unresolvable. Exported because
+* `histogram` needs the same resolution for its bucketed column.
+*/
 export declare function fieldExprFor(field: string, shape: CollectionShape): string | null;
 export declare function compileFilter(filter: QueryFilterInput | undefined, shape: CollectionShape, mode: FilterMode, serialize: SerializeValue): CompiledFilter;

package/dist/builtins/sqlite-storage/index.d.ts

@@ -1,12 +1,12 @@
-export { ConfigStore } from './config-store.js';
-export type { DeviceRow } from './device-store.js';
-export { DeviceStore } from './device-store.js';
-export { FilesystemStorageAddon, FilesystemStorageAddon as default, } from './filesystem-storage.addon.js';
-export { FilesystemStorageProvider } from './filesystem-storage-provider.js';
-export type { SqliteOpLabel, SqliteOpSample, SqliteOpStat } from './query-profiler.js';
-export { SQLITE_ENGINE_STORM_WALL_SHARE, SQLITE_PROFILE_REPORT_FLOOR_MS, SQLITE_PROFILE_REPORT_INTERVAL_MS, SQLITE_PROFILE_TOP_N, SQLITE_SLOW_CALL_MS, sqliteEngineStorm, SqliteOpProfiler, } from './query-profiler.js';
-export { SQLITE_JOURNAL_SIZE_LIMIT_BYTES, SQLITE_MMAP_CEILING_BYTES, SQLITE_MMAP_FLOOR_BYTES, SQLITE_PAGE_CACHE_CEILING_KIB, SQLITE_PAGE_CACHE_FLOOR_KIB, sqliteMmapSizeFor, sqlitePageCacheKibFor, } from './sqlite-pragmas.js';
-export { SqliteSettingsAddon } from './sqlite-settings.addon.js';
-export { SqliteSettingsBackend } from './sqlite-settings-backend.js';
-export type { WalMaintenanceOptions, WalMaintenanceOutcome } from './wal-maintenance.js';
-export { WAL_CHECKPOINT_BUSY_TIMEOUT_MS, WAL_HIGH_WATER_BYTES, WAL_IDLE_QUIET_MS, WAL_MAINTENANCE_INTERVAL_MS, WalMaintenance, } from './wal-maintenance.js';
+export { ConfigStore } from "./config-store.js";
+export type { DeviceRow } from "./device-store.js";
+export { DeviceStore } from "./device-store.js";
+export { FilesystemStorageAddon, FilesystemStorageAddon as default } from "./filesystem-storage.addon.js";
+export { FilesystemStorageProvider } from "./filesystem-storage-provider.js";
+export type { SqliteOpLabel, SqliteOpSample, SqliteOpStat } from "./query-profiler.js";
+export { SQLITE_ENGINE_STORM_WALL_SHARE, SQLITE_PROFILE_REPORT_FLOOR_MS, SQLITE_PROFILE_REPORT_INTERVAL_MS, SQLITE_PROFILE_TOP_N, SQLITE_SLOW_CALL_MS, sqliteEngineStorm, SqliteOpProfiler } from "./query-profiler.js";
+export { SQLITE_JOURNAL_SIZE_LIMIT_BYTES, SQLITE_MMAP_CEILING_BYTES, SQLITE_MMAP_FLOOR_BYTES, SQLITE_PAGE_CACHE_CEILING_KIB, SQLITE_PAGE_CACHE_FLOOR_KIB, sqliteMmapSizeFor, sqlitePageCacheKibFor } from "./sqlite-pragmas.js";
+export { SqliteSettingsAddon } from "./sqlite-settings.addon.js";
+export { SqliteSettingsBackend } from "./sqlite-settings-backend.js";
+export type { WalMaintenanceOptions, WalMaintenanceOutcome } from "./wal-maintenance.js";
+export { WAL_CHECKPOINT_BUSY_TIMEOUT_MS, WAL_HIGH_WATER_BYTES, WAL_IDLE_QUIET_MS, WAL_MAINTENANCE_INTERVAL_MS, WalMaintenance } from "./wal-maintenance.js";

package/dist/builtins/sqlite-storage/integration-registry.d.ts

@@ -1,40 +1,40 @@
-import { CreateIntegrationInput, IIntegrationRegistry, Integration, ISettingsStoreProvider } from '@camstack/types';
+import type { CreateIntegrationInput, IIntegrationRegistry, Integration, ISettingsStoreProvider } from "@camstack/types";
 /**
- * The persisted INTEGRATIONS — one row per provider instance an operator (or a
- * declaring addon) added, plus that instance's settings.
- *
- * It had a device half once: `devices` + `device_settings_kv`, `dev_NNNN` ids,
- * `createDevice` / `listCameras` / `setDeviceSetting`. It was removed on
- * 2026-08-19 with both tables ([D183](../../../../../docs/decisions/adr-0183-code-that-is-deleted-takes-its-tables-with-it.md)):
- * measured on the reference hub it held 0 rows against 974 live devices, no
- * production caller ever reached it, and its id-space could not be reconciled
- * with the numeric ids every track, rule and binding in the system uses. The
- * fleet is `device-manager:devices`. Do not add a device method here — the
- * device authority is the device-manager, and a second one that agrees with
- * nothing is how this half came to exist.
- */
+* The persisted INTEGRATIONS — one row per provider instance an operator (or a
+* declaring addon) added, plus that instance's settings.
+*
+* It had a device half once: `devices` + `device_settings_kv`, `dev_NNNN` ids,
+* `createDevice` / `listCameras` / `setDeviceSetting`. It was removed on
+* 2026-08-19 with both tables ([D183](../../../../../docs/decisions/adr-0183-code-that-is-deleted-takes-its-tables-with-it.md)):
+* measured on the reference hub it held 0 rows against 974 live devices, no
+* production caller ever reached it, and its id-space could not be reconciled
+* with the numeric ids every track, rule and binding in the system uses. The
+* fleet is `device-manager:devices`. Do not add a device method here — the
+* device authority is the device-manager, and a second one that agrees with
+* nothing is how this half came to exist.
+*/
 export declare class IntegrationRegistry implements IIntegrationRegistry {
-    private readonly store;
-    constructor(backend: ISettingsStoreProvider);
-    initialize(): Promise<void>;
-    createIntegration(input: CreateIntegrationInput): Promise<Integration>;
-    getIntegration(id: string): Promise<Integration | null>;
-    getIntegrationByAddonId(addonId: string): Promise<Integration | null>;
-    listIntegrations(): Promise<readonly Integration[]>;
-    updateIntegration(id: string, updates: Partial<Pick<Integration, 'name' | 'enabled' | 'info'>>): Promise<Integration | null>;
-    /**
-     * A FIXED integration exists because an addon declares it, not because an
-     * operator added it — the Notification Center's alarm panel is the first.
-     * There is no add or delete flow for one, and this is where that is true
-     * rather than merely hidden: a UI that only omits the button still leaves the
-     * mutation one API call away.
-     */
-    static isFixed(integration: {
-        readonly info: Readonly<Record<string, unknown>> | null;
-    }): boolean;
-    deleteIntegration(id: string): Promise<boolean>;
-    getIntegrationSettings(integrationId: string): Promise<Record<string, unknown>>;
-    setIntegrationSetting(integrationId: string, key: string, value: unknown): Promise<void>;
-    setIntegrationSettings(integrationId: string, settings: Record<string, unknown>): Promise<void>;
-    private mapIntegration;
+	private readonly store;
+	constructor(backend: ISettingsStoreProvider);
+	initialize(): Promise<void>;
+	createIntegration(input: CreateIntegrationInput): Promise<Integration>;
+	getIntegration(id: string): Promise<Integration | null>;
+	getIntegrationByAddonId(addonId: string): Promise<Integration | null>;
+	listIntegrations(): Promise<readonly Integration[]>;
+	updateIntegration(id: string, updates: Partial<Pick<Integration, "name" | "enabled" | "info">>): Promise<Integration | null>;
+	/**
+	* A FIXED integration exists because an addon declares it, not because an
+	* operator added it — the Notification Center's alarm panel is the first.
+	* There is no add or delete flow for one, and this is where that is true
+	* rather than merely hidden: a UI that only omits the button still leaves the
+	* mutation one API call away.
+	*/
+	static isFixed(integration: {
+		readonly info: Readonly<Record<string, unknown>> | null;
+	}): boolean;
+	deleteIntegration(id: string): Promise<boolean>;
+	getIntegrationSettings(integrationId: string): Promise<Record<string, unknown>>;
+	setIntegrationSetting(integrationId: string, key: string, value: unknown): Promise<void>;
+	setIntegrationSettings(integrationId: string, settings: Record<string, unknown>): Promise<void>;
+	private mapIntegration;
 }

package/dist/builtins/sqlite-storage/path-guard.d.ts

@@ -3,9 +3,9 @@ export declare function isWithinAllowedRoots(candidate: string, allowedRoots: re
 /** Throws unless `candidate` is within an allowed root. WRITES only. */
 export declare function assertWithinAllowedRoots(candidate: string, allowedRoots: readonly string[]): void;
 /**
- * Throws unless `candidate` is a browsable path. Read-only discovery is
- * deliberately unconfined — the only requirement is an absolute path, so a
- * relative one can never be resolved against whatever the runner's cwd
- * happens to be.
- */
+* Throws unless `candidate` is a browsable path. Read-only discovery is
+* deliberately unconfined — the only requirement is an absolute path, so a
+* relative one can never be resolved against whatever the runner's cwd
+* happens to be.
+*/
 export declare function assertBrowsablePath(candidate: string): void;

package/dist/builtins/sqlite-storage/prefix-range.d.ts

@@ -1,50 +1,50 @@
 /**
- * Turn a key PREFIX into a half-open range SQLite can answer from the index.
- *
- * **The measurement.** The two canonical KV tables (`addon-settings`,
- * `addon-device-settings`) are keyed `"<scope>.<key>"` and every scoped read
- * and write selects by prefix. That was written as `WHERE id LIKE ? || '%'`,
- * and SQLite cannot use an index for it: `LIKE` is case-insensitive for ASCII
- * by default, so the LIKE optimisation requires an index with `COLLATE
- * NOCASE`, which the implicit PRIMARY KEY index is not. `EXPLAIN QUERY PLAN`
- * says so in one word:
- *
- *     LIKE   =>  SCAN addon-device-settings
- *     RANGE  =>  SEARCH addon-device-settings USING INDEX … (id>? AND id<?)
- *
- * Every `writeDeviceRuntimeState` therefore scanned the whole table before
- * inserting, on the main thread, synchronously — 15.6% of hub-main's CPU in
- * the 2026-08-07 V8 profile sat in this transaction. Measured on a 2 240-row
- * table (far smaller than the live one, and the gap widens linearly with rows):
- *
- *     write  (1 DELETE + 14 UPSERT, one txn)   0.253 ms → 0.143 ms   1.8x
- *     read   (getAllScoped)                    0.207 ms → 0.011 ms  19.4x
- *
- * **It is also more CORRECT, which was not the goal.** `LIKE` treats `_` and
- * `%` in the PATTERN as wildcards, and the pattern here is built from an addon
- * id and a device id. `clearAddonDevice('a_b', …)` deleted `axb`'s rows too,
- * and `LIKE`'s ASCII case-folding meant `Recorder:615.` matched
- * `recorder:615.`. A byte range matches exactly the keys that start with the
- * prefix and nothing else.
- *
- * **Why it can refuse.** SQLite's BINARY collation compares UTF-8 BYTES; JS
- * compares UTF-16 code units. The two orders agree for ASCII and can disagree
- * above it. Rather than encode a subtle equivalence nobody will re-derive, a
- * non-ASCII prefix returns `null` and the caller keeps the existing `LIKE` —
- * slower, but identical to what shipped. Every prefix in this codebase is an
- * addon id, a device id and separators, so the fast path is the only one that
- * runs in practice; the fallback exists so a future key shape cannot silently
- * lose rows.
- */
+* Turn a key PREFIX into a half-open range SQLite can answer from the index.
+*
+* **The measurement.** The two canonical KV tables (`addon-settings`,
+* `addon-device-settings`) are keyed `"<scope>.<key>"` and every scoped read
+* and write selects by prefix. That was written as `WHERE id LIKE ? || '%'`,
+* and SQLite cannot use an index for it: `LIKE` is case-insensitive for ASCII
+* by default, so the LIKE optimisation requires an index with `COLLATE
+* NOCASE`, which the implicit PRIMARY KEY index is not. `EXPLAIN QUERY PLAN`
+* says so in one word:
+*
+*     LIKE   =>  SCAN addon-device-settings
+*     RANGE  =>  SEARCH addon-device-settings USING INDEX … (id>? AND id<?)
+*
+* Every `writeDeviceRuntimeState` therefore scanned the whole table before
+* inserting, on the main thread, synchronously — 15.6% of hub-main's CPU in
+* the 2026-08-07 V8 profile sat in this transaction. Measured on a 2 240-row
+* table (far smaller than the live one, and the gap widens linearly with rows):
+*
+*     write  (1 DELETE + 14 UPSERT, one txn)   0.253 ms → 0.143 ms   1.8x
+*     read   (getAllScoped)                    0.207 ms → 0.011 ms  19.4x
+*
+* **It is also more CORRECT, which was not the goal.** `LIKE` treats `_` and
+* `%` in the PATTERN as wildcards, and the pattern here is built from an addon
+* id and a device id. `clearAddonDevice('a_b', …)` deleted `axb`'s rows too,
+* and `LIKE`'s ASCII case-folding meant `Recorder:615.` matched
+* `recorder:615.`. A byte range matches exactly the keys that start with the
+* prefix and nothing else.
+*
+* **Why it can refuse.** SQLite's BINARY collation compares UTF-8 BYTES; JS
+* compares UTF-16 code units. The two orders agree for ASCII and can disagree
+* above it. Rather than encode a subtle equivalence nobody will re-derive, a
+* non-ASCII prefix returns `null` and the caller keeps the existing `LIKE` —
+* slower, but identical to what shipped. Every prefix in this codebase is an
+* addon id, a device id and separators, so the fast path is the only one that
+* runs in practice; the fallback exists so a future key shape cannot silently
+* lose rows.
+*/
 /** Half-open key range `[lo, hi)` covering exactly the keys starting with a prefix. */
 export interface PrefixRange {
-    readonly lo: string;
-    /** EXCLUSIVE upper bound: the prefix with its last byte incremented. */
-    readonly hi: string;
+	readonly lo: string;
+	/** EXCLUSIVE upper bound: the prefix with its last byte incremented. */
+	readonly hi: string;
 }
 /**
- * @returns the range for `prefix`, or `null` when the caller must fall back to
- *   a `LIKE` scan (empty prefix — which is the whole table and has no upper
- *   bound — or any byte outside ASCII).
- */
+* @returns the range for `prefix`, or `null` when the caller must fall back to
+*   a `LIKE` scan (empty prefix — which is the whole table and has no upper
+*   bound — or any byte outside ASCII).
+*/
 export declare function prefixRange(prefix: string): PrefixRange | null;