@chipmobilesdk/rn-local-db 0.3.0 → 0.5.0

package/lib/typescript/module/sqlite/catalog.d.ts

@@ -0,0 +1,34 @@
+/**
+ * The catalog: one registry per logical database, listing the scopes that
+ * exist.
+ *
+ * This is the only structure that spans scopes, so it is deliberately the
+ * smallest thing that answers the questions the package must answer without
+ * opening every scope file. It holds a digest, timestamps, and two posture
+ * flags — **no raw scope components** (FR-014), so a device with full disk
+ * access cannot mine it for identities or tenant names even though the
+ * catalog itself is never encrypted.
+ *
+ * The `deleting` flag is the load-bearing part. It is written before a scope
+ * deletion begins and cleared last, so a crash at any point leaves the
+ * interruption visible on the next open. Clearing it first would make an
+ * interrupted deletion look complete — the exact failure FR-063 exists to
+ * prevent.
+ */
+import type { ScopeDeletionState } from '../contract/scope.js';
+import type { Connection } from './connection.js';
+export type CatalogEntry = {
+    scopeKey: string;
+    createdAt: number;
+    deletionState: ScopeDeletionState;
+    backupPosture: 'excluded' | 'included';
+    encrypted: boolean;
+};
+export declare function ensureCatalog(connection: Connection): Promise<void>;
+export declare function readEntry(connection: Connection, scopeKey: string): Promise<CatalogEntry | null>;
+export declare function listEntries(connection: Connection): Promise<CatalogEntry[]>;
+export declare function registerScope(connection: Connection, entry: CatalogEntry): Promise<void>;
+export declare function markDeleting(connection: Connection, scopeKey: string): Promise<void>;
+/** Cleared last, on purpose. See the note at the top of this file. */
+export declare function clearScope(connection: Connection, scopeKey: string): Promise<void>;
+//# sourceMappingURL=catalog.d.ts.map

package/lib/typescript/module/sqlite/catalog.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"catalog.d.ts","sourceRoot":"","sources":["../../../../src/sqlite/catalog.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;GAgBG;AAEH,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,sBAAmB,CAAC;AAC5D,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,iBAAc,CAAC;AAG/C,MAAM,MAAM,YAAY,GAAG;IAC1B,QAAQ,EAAE,MAAM,CAAC;IACjB,SAAS,EAAE,MAAM,CAAC;IAClB,aAAa,EAAE,kBAAkB,CAAC;IAClC,aAAa,EAAE,UAAU,GAAG,UAAU,CAAC;IACvC,SAAS,EAAE,OAAO,CAAC;CACnB,CAAC;AAUF,wBAAsB,aAAa,CAAC,UAAU,EAAE,UAAU,GAAG,OAAO,CAAC,IAAI,CAAC,CAEzE;AAED,wBAAsB,SAAS,CAC9B,UAAU,EAAE,UAAU,EACtB,QAAQ,EAAE,MAAM,GACd,OAAO,CAAC,YAAY,GAAG,IAAI,CAAC,CAgB9B;AAED,wBAAsB,WAAW,CAAC,UAAU,EAAE,UAAU,GAAG,OAAO,CAAC,YAAY,EAAE,CAAC,CAWjF;AAED,wBAAsB,aAAa,CAAC,UAAU,EAAE,UAAU,EAAE,KAAK,EAAE,YAAY,GAAG,OAAO,CAAC,IAAI,CAAC,CAgB9F;AAED,wBAAsB,YAAY,CAAC,UAAU,EAAE,UAAU,EAAE,QAAQ,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAK1F;AAED,sEAAsE;AACtE,wBAAsB,UAAU,CAAC,UAAU,EAAE,UAAU,EAAE,QAAQ,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAExF"}

package/lib/typescript/module/sqlite/connection.d.ts

@@ -0,0 +1,58 @@
+/**
+ * One connection per database file.
+ *
+ * Two things about this file carry design weight:
+ *
+ * **Scope isolation is the file boundary.** A connection is opened against
+ * one scope's `data.db`, whose directory is named by the scope digest and
+ * never by the components (FR-014). No SQL this package could generate — and
+ * none a future bug could generate — reaches another scope's rows, because
+ * they are in a file this connection never opened (research.md R2).
+ *
+ * **A transaction owns the connection while it runs, and only its own
+ * executor reaches it.** Every operation queues on the connection, and a
+ * transaction holds the queue until it settles. Work issued through the
+ * connection meanwhile — a background sync, a second screen — waits and then
+ * runs on its own, rather than joining the transaction and vanishing with its
+ * rollback. Until 0.2.0 `execute` routed into whatever transaction was in
+ * flight, which is how an unrelated write was lost. Work meant to be part of
+ * the transaction goes through the executor the transaction hands out
+ * (`tx.collection`, `tx.attachments`).
+ */
+import { type ExecuteResult, type SqlValue } from './native.js';
+export type Executor = {
+    execute(sql: string, params?: SqlValue[]): Promise<ExecuteResult>;
+};
+/**
+ * The executor a transaction body runs against, plus the one control it
+ * needs. `rollback` is handed to the body rather than returned from
+ * `transaction`, so an explicit abort cannot outlive the transaction it
+ * belongs to.
+ */
+export type TransactionExecutor = Executor & {
+    rollback(): Promise<void>;
+};
+export type Connection = Executor & {
+    readonly path: string;
+    readonly encrypted: boolean;
+    transaction<R>(fn: (tx: TransactionExecutor) => Promise<R>): Promise<R>;
+    executeBatch(commands: [string, SqlValue[]?][]): Promise<void>;
+    close(): Promise<void>;
+};
+export type OpenConnectionOptions = {
+    /** Absolute path to the database file, already inside the managed area. */
+    path: string;
+    encryptionKey?: string;
+};
+export declare function openConnection(options: OpenConnectionOptions): Promise<Connection>;
+/**
+ * Confirm a freshly opened database is readable.
+ *
+ * Deliberately not `PRAGMA integrity_check`: that walks the whole file and
+ * would put open time far past the 150-millisecond budget on a large scope.
+ * One trivial read is enough to surface the failures that matter at open —
+ * a wrong key, a truncated file, a malformed header — because all three fail
+ * it, and the error mapping keeps them distinguishable (FR-076, FR-078).
+ */
+export declare function assertReadable(connection: Connection): Promise<void>;
+//# sourceMappingURL=connection.d.ts.map

package/lib/typescript/module/sqlite/connection.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"connection.d.ts","sourceRoot":"","sources":["../../../../src/sqlite/connection.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;GAoBG;AAOH,OAAO,EAEN,KAAK,aAAa,EAGlB,KAAK,QAAQ,EACb,MAAM,aAAU,CAAC;AAElB,MAAM,MAAM,QAAQ,GAAG;IACtB,OAAO,CAAC,GAAG,EAAE,MAAM,EAAE,MAAM,CAAC,EAAE,QAAQ,EAAE,GAAG,OAAO,CAAC,aAAa,CAAC,CAAC;CAClE,CAAC;AAEF;;;;;GAKG;AACH,MAAM,MAAM,mBAAmB,GAAG,QAAQ,GAAG;IAC5C,QAAQ,IAAI,OAAO,CAAC,IAAI,CAAC,CAAC;CAC1B,CAAC;AAEF,MAAM,MAAM,UAAU,GAAG,QAAQ,GAAG;IACnC,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,SAAS,EAAE,OAAO,CAAC;IAC5B,WAAW,CAAC,CAAC,EAAE,EAAE,EAAE,CAAC,EAAE,EAAE,mBAAmB,KAAK,OAAO,CAAC,CAAC,CAAC,GAAG,OAAO,CAAC,CAAC,CAAC,CAAC;IACxE,YAAY,CAAC,QAAQ,EAAE,CAAC,MAAM,EAAE,QAAQ,EAAE,CAAC,CAAC,EAAE,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;IAC/D,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC,CAAC;CACvB,CAAC;AAEF,MAAM,MAAM,qBAAqB,GAAG;IACnC,2EAA2E;IAC3E,IAAI,EAAE,MAAM,CAAC;IACb,aAAa,CAAC,EAAE,MAAM,CAAC;CACvB,CAAC;AASF,wBAAsB,cAAc,CAAC,OAAO,EAAE,qBAAqB,GAAG,OAAO,CAAC,UAAU,CAAC,CAsIxF;AAED;;;;;;;;GAQG;AACH,wBAAsB,cAAc,CAAC,UAAU,EAAE,UAAU,GAAG,OAAO,CAAC,IAAI,CAAC,CAE1E"}

package/lib/typescript/module/sqlite/index-coverage.d.ts

@@ -0,0 +1,18 @@
+/**
+ * "Is this query covered by an index?", answered by the engine rather than by
+ * inspection of the declarations (FR-037).
+ *
+ * Reading the schema would answer what the developer intended; `EXPLAIN QUERY
+ * PLAN` answers what SQLite will actually do, and the two diverge exactly
+ * where it matters — a filter on an indexed field that the planner declines
+ * because of a type mismatch or a leading wildcard still reports as "indexed"
+ * if you only read declarations.
+ *
+ * Exposed as a development-mode diagnostic. It runs an extra statement, so an
+ * app calling it on every list would pay for it.
+ */
+import type { IndexCoverageReport, Query, SortKey } from '../contract/query.js';
+import type { CollectionSchema } from '../contract/schema.js';
+import type { Executor } from './connection.js';
+export declare function explainQuery(executor: Executor, schema: CollectionSchema, query: Query | undefined, sort: SortKey[]): Promise<IndexCoverageReport>;
+//# sourceMappingURL=index-coverage.d.ts.map

package/lib/typescript/module/sqlite/index-coverage.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index-coverage.d.ts","sourceRoot":"","sources":["../../../../src/sqlite/index-coverage.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AAEH,OAAO,KAAK,EAAE,mBAAmB,EAAE,KAAK,EAAE,OAAO,EAAE,MAAM,sBAAmB,CAAC;AAC7E,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,uBAAoB,CAAC;AAE3D,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,iBAAc,CAAC;AAO7C,wBAAsB,YAAY,CACjC,QAAQ,EAAE,QAAQ,EAClB,MAAM,EAAE,gBAAgB,EACxB,KAAK,EAAE,KAAK,GAAG,SAAS,EACxB,IAAI,EAAE,OAAO,EAAE,GACb,OAAO,CAAC,mBAAmB,CAAC,CAwB9B"}

package/lib/typescript/module/sqlite/native.d.ts

@@ -0,0 +1,48 @@
+/**
+ * The storage engine peer, behind one lazy accessor.
+ *
+ * Every native call the package makes to SQLite passes through this type.
+ * Note what is missing: `executeSync`. op-sqlite ships it, and using it would
+ * put a database read on the interface thread — the one thing PERF-001's
+ * 16-millisecond rule cannot survive (research.md R9). A surface that cannot
+ * express the synchronous call is a stronger guarantee than a review comment.
+ */
+export type SqlValue = string | number | boolean | null | undefined;
+export type ExecuteResult = {
+    rows: Record<string, unknown>[];
+    rowsAffected: number;
+};
+export type NativeTransaction = {
+    execute(sql: string, params?: SqlValue[]): Promise<ExecuteResult>;
+    commit(): Promise<void>;
+    rollback(): Promise<void>;
+};
+export type NativeDatabase = {
+    execute(sql: string, params?: SqlValue[]): Promise<ExecuteResult>;
+    executeBatch(commands: [string, SqlValue[]?][]): Promise<ExecuteResult>;
+    transaction<T>(fn: (tx: NativeTransaction) => Promise<T>): Promise<T>;
+    close(): Promise<void>;
+    delete(): Promise<void>;
+};
+export type OpenOptions = {
+    name: string;
+    location?: string;
+    /** SQLCipher only. Never logged, never persisted, never returned (FR-098). */
+    encryptionKey?: string;
+};
+export type Engine = {
+    open(options: OpenOptions): NativeDatabase;
+    isSQLCipher?: () => boolean;
+};
+/** Swap the engine. Tests only; `null` goes back to the real one. */
+export declare function setEngine(next: Engine | null): void;
+export declare function engine(): Engine;
+/**
+ * Whether SQLCipher is compiled into this build.
+ *
+ * A build flag in the consuming app, not a separate peer (research.md R1a).
+ * An app that enables encryption without it must fail loudly rather than
+ * write plaintext to a file it believes is encrypted.
+ */
+export declare function isEncryptionAvailable(): boolean;
+//# sourceMappingURL=native.d.ts.map

package/lib/typescript/module/sqlite/native.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"native.d.ts","sourceRoot":"","sources":["../../../../src/sqlite/native.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAOH,MAAM,MAAM,QAAQ,GAAG,MAAM,GAAG,MAAM,GAAG,OAAO,GAAG,IAAI,GAAG,SAAS,CAAC;AAEpE,MAAM,MAAM,aAAa,GAAG;IAC3B,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAAE,CAAC;IAChC,YAAY,EAAE,MAAM,CAAC;CACrB,CAAC;AAEF,MAAM,MAAM,iBAAiB,GAAG;IAC/B,OAAO,CAAC,GAAG,EAAE,MAAM,EAAE,MAAM,CAAC,EAAE,QAAQ,EAAE,GAAG,OAAO,CAAC,aAAa,CAAC,CAAC;IAClE,MAAM,IAAI,OAAO,CAAC,IAAI,CAAC,CAAC;IACxB,QAAQ,IAAI,OAAO,CAAC,IAAI,CAAC,CAAC;CAC1B,CAAC;AAEF,MAAM,MAAM,cAAc,GAAG;IAC5B,OAAO,CAAC,GAAG,EAAE,MAAM,EAAE,MAAM,CAAC,EAAE,QAAQ,EAAE,GAAG,OAAO,CAAC,aAAa,CAAC,CAAC;IAClE,YAAY,CAAC,QAAQ,EAAE,CAAC,MAAM,EAAE,QAAQ,EAAE,CAAC,CAAC,EAAE,GAAG,OAAO,CAAC,aAAa,CAAC,CAAC;IACxE,WAAW,CAAC,CAAC,EAAE,EAAE,EAAE,CAAC,EAAE,EAAE,iBAAiB,KAAK,OAAO,CAAC,CAAC,CAAC,GAAG,OAAO,CAAC,CAAC,CAAC,CAAC;IACtE,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC,CAAC;IACvB,MAAM,IAAI,OAAO,CAAC,IAAI,CAAC,CAAC;CACxB,CAAC;AAEF,MAAM,MAAM,WAAW,GAAG;IACzB,IAAI,EAAE,MAAM,CAAC;IACb,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,8EAA8E;IAC9E,aAAa,CAAC,EAAE,MAAM,CAAC;CACvB,CAAC;AAEF,MAAM,MAAM,MAAM,GAAG;IACpB,IAAI,CAAC,OAAO,EAAE,WAAW,GAAG,cAAc,CAAC;IAC3C,WAAW,CAAC,EAAE,MAAM,OAAO,CAAC;CAC5B,CAAC;AAYF,qEAAqE;AACrE,wBAAgB,SAAS,CAAC,IAAI,EAAE,MAAM,GAAG,IAAI,GAAG,IAAI,CAEnD;AAED,wBAAgB,MAAM,IAAI,MAAM,CAQ/B;AAED;;;;;;GAMG;AACH,wBAAgB,qBAAqB,IAAI,OAAO,CAG/C"}

package/lib/typescript/module/sqlite/row-codec.d.ts

@@ -0,0 +1,69 @@
+/**
+ * Table shape, and the payload-as-truth rule.
+ *
+ * Every read reconstructs the record from `payload` alone. The projected
+ * `f_*` columns are written on every write and consulted only by `WHERE` and
+ * `ORDER BY` — never by a read path (research.md R6).
+ *
+ * That single rule is what makes two requirements structural rather than
+ * carefully maintained. FR-018's byte fidelity holds because nothing else is
+ * consulted to rebuild a record, and FR-019's explicit-null versus
+ * absent-field distinction holds because a NULL projected column cannot be
+ * ambiguous if no read ever looks at it.
+ */
+import type { StorableRecordData, StoredRecord } from '../contract/record.js';
+import type { CollectionSchema, FieldDeclaration } from '../contract/schema.js';
+import type { SqlValue } from './native.js';
+export declare const RESERVED_COLUMNS: string[];
+export declare function createTableSql(schema: CollectionSchema): string;
+export declare function addColumnSql(schema: CollectionSchema, field: FieldDeclaration): string;
+/**
+ * The name an index has in the database file.
+ *
+ * Index names are database-wide in SQLite, but declared per collection. Until
+ * 0.2.0 the declared name was used as is, so a second collection declaring an
+ * index of the same name hit `IF NOT EXISTS` and silently got no index — a
+ * UNIQUE constraint included. The double underscore keeps a declared name from
+ * colliding with the package's own `<table>_live` index.
+ */
+export declare function physicalIndexName(schema: CollectionSchema, declaredName: string): string;
+/** The declared name back from a physical one, for reporting to the app. */
+export declare function declaredIndexName(schema: CollectionSchema, physicalName: string): string;
+export declare function createIndexSql(schema: CollectionSchema): string[];
+/**
+ * Project a declared field for the WHERE and ORDER BY columns.
+ *
+ * Anything that is not a comparable primitive projects to NULL. A nested
+ * object has no defensible ordering, and inventing one would make a filter
+ * silently match records a consumer never meant to select.
+ */
+export declare function projectValue(data: StorableRecordData, field: FieldDeclaration): SqlValue;
+export declare function projectedValues(schema: CollectionSchema, data: StorableRecordData): SqlValue[];
+export declare function projectedColumnNames(schema: CollectionSchema): string[];
+/** Serialize on the way in, so a caller mutating its object cannot change
+ * what is stored (FR-022). */
+export declare function encodePayload(data: StorableRecordData): string;
+export type CollectionRow = {
+    id: string;
+    payload: string;
+    created_at?: number | null;
+    updated_at?: number | null;
+    deleted_at?: number | null;
+};
+/**
+ * Rebuild a record from the payload column and nothing else.
+ *
+ * The timestamp and soft-delete fields are surfaced only when the collection
+ * declared them, so a consumer cannot come to depend on a field the schema
+ * never promised.
+ */
+export declare function decodeRow<T extends StorableRecordData>(schema: CollectionSchema, row: Record<string, unknown>): StoredRecord<T>;
+export type WriteColumns = {
+    columns: string[];
+    values: SqlValue[];
+};
+export declare function insertColumns(schema: CollectionSchema, id: string, data: StorableRecordData, now: number, 
+/** The payload already serialized by the budget check, to avoid a second pass. */
+payload?: string): WriteColumns;
+export declare function updateAssignments(schema: CollectionSchema, data: StorableRecordData, now: number, payload?: string): WriteColumns;
+//# sourceMappingURL=row-codec.d.ts.map

package/lib/typescript/module/sqlite/row-codec.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"row-codec.d.ts","sourceRoot":"","sources":["../../../../src/sqlite/row-codec.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AAEH,OAAO,KAAK,EAAE,kBAAkB,EAAE,YAAY,EAAE,MAAM,uBAAoB,CAAC;AAC3E,OAAO,KAAK,EAAE,gBAAgB,EAAE,gBAAgB,EAAE,MAAM,uBAAoB,CAAC;AAE7E,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,aAAU,CAAC;AAGzC,eAAO,MAAM,gBAAgB,UAA8D,CAAC;AAgB5F,wBAAgB,cAAc,CAAC,MAAM,EAAE,gBAAgB,GAAG,MAAM,CAU/D;AAED,wBAAgB,YAAY,CAAC,MAAM,EAAE,gBAAgB,EAAE,KAAK,EAAE,gBAAgB,GAAG,MAAM,CAItF;AAED;;;;;;;;GAQG;AACH,wBAAgB,iBAAiB,CAAC,MAAM,EAAE,gBAAgB,EAAE,YAAY,EAAE,MAAM,GAAG,MAAM,CAExF;AAED,4EAA4E;AAC5E,wBAAgB,iBAAiB,CAAC,MAAM,EAAE,gBAAgB,EAAE,YAAY,EAAE,MAAM,GAAG,MAAM,CAGxF;AAED,wBAAgB,cAAc,CAAC,MAAM,EAAE,gBAAgB,GAAG,MAAM,EAAE,CAejE;AAED;;;;;;GAMG;AACH,wBAAgB,YAAY,CAAC,IAAI,EAAE,kBAAkB,EAAE,KAAK,EAAE,gBAAgB,GAAG,QAAQ,CAkBxF;AAED,wBAAgB,eAAe,CAAC,MAAM,EAAE,gBAAgB,EAAE,IAAI,EAAE,kBAAkB,GAAG,QAAQ,EAAE,CAE9F;AAED,wBAAgB,oBAAoB,CAAC,MAAM,EAAE,gBAAgB,GAAG,MAAM,EAAE,CAEvE;AAED;8BAC8B;AAC9B,wBAAgB,aAAa,CAAC,IAAI,EAAE,kBAAkB,GAAG,MAAM,CAE9D;AAED,MAAM,MAAM,aAAa,GAAG;IAC3B,EAAE,EAAE,MAAM,CAAC;IACX,OAAO,EAAE,MAAM,CAAC;IAChB,UAAU,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;IAC3B,UAAU,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;IAC3B,UAAU,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;CAC3B,CAAC;AAEF;;;;;;GAMG;AACH,wBAAgB,SAAS,CAAC,CAAC,SAAS,kBAAkB,EACrD,MAAM,EAAE,gBAAgB,EACxB,GAAG,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAC1B,YAAY,CAAC,CAAC,CAAC,CAiBjB;AAED,MAAM,MAAM,YAAY,GAAG;IAC1B,OAAO,EAAE,MAAM,EAAE,CAAC;IAClB,MAAM,EAAE,QAAQ,EAAE,CAAC;CACnB,CAAC;AAEF,wBAAgB,aAAa,CAC5B,MAAM,EAAE,gBAAgB,EACxB,EAAE,EAAE,MAAM,EACV,IAAI,EAAE,kBAAkB,EACxB,GAAG,EAAE,MAAM;AACX,kFAAkF;AAClF,OAAO,GAAE,MAA4B,GACnC,YAAY,CAkBd;AAED,wBAAgB,iBAAiB,CAChC,MAAM,EAAE,gBAAgB,EACxB,IAAI,EAAE,kBAAkB,EACxB,GAAG,EAAE,MAAM,EACX,OAAO,GAAE,MAA4B,GACnC,YAAY,CAcd"}

package/lib/typescript/module/sqlite/sql-builder.d.ts

@@ -0,0 +1,34 @@
+/**
+ * Filter tree to parameterized SQL.
+ *
+ * Nothing a consumer supplies is ever concatenated into a statement. Field
+ * names are resolved through the schema first — validation has already run
+ * and rejected anything undeclared (FR-034) — so the only identifiers that
+ * reach SQL are ones this package generated from a declaration it checked.
+ * Values bind as parameters, without exception. Injection stops being a thing
+ * to remember and becomes a thing the shape of the code prevents.
+ *
+ * The other half of this file is keyset pagination. `OFFSET` was rejected for
+ * two measured reasons (research.md R6): it degrades linearly at the 100,000
+ * record budget because the engine still walks the skipped rows, and it
+ * shifts pages under concurrent writes so a record can be skipped or returned
+ * twice — the exact failure SC-007 forbids.
+ */
+import type { FilterNode, FilterValue, SortKey } from '../contract/query.js';
+import type { SqlValue } from './native.js';
+export type SqlFragment = {
+    sql: string;
+    params: SqlValue[];
+};
+export declare function buildFilter(node: FilterNode | undefined): SqlFragment;
+export declare function buildOrderBy(sort: SortKey[]): string;
+/**
+ * The keyset predicate: everything strictly after the cursor position.
+ *
+ * Lexicographic across the sort keys — equal on the first means the second
+ * decides, down to the `id` tiebreaker that guarantees a total order. NULL is
+ * treated as smaller than every value, matching both SQLite's default
+ * ordering and `compareValues`, so the two adapters page identically.
+ */
+export declare function buildKeysetPredicate(sort: SortKey[], anchor: FilterValue[]): SqlFragment;
+//# sourceMappingURL=sql-builder.d.ts.map

package/lib/typescript/module/sqlite/sql-builder.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sql-builder.d.ts","sourceRoot":"","sources":["../../../../src/sqlite/sql-builder.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;GAeG;AAEH,OAAO,KAAK,EAAE,UAAU,EAAE,WAAW,EAAE,OAAO,EAAE,MAAM,sBAAmB,CAAC;AAE1E,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,aAAU,CAAC;AAEzC,MAAM,MAAM,WAAW,GAAG;IACzB,GAAG,EAAE,MAAM,CAAC;IACZ,MAAM,EAAE,QAAQ,EAAE,CAAC;CACnB,CAAC;AAuIF,wBAAgB,WAAW,CAAC,IAAI,EAAE,UAAU,GAAG,SAAS,GAAG,WAAW,CAsBrE;AAED,wBAAgB,YAAY,CAAC,IAAI,EAAE,OAAO,EAAE,GAAG,MAAM,CAIpD;AAED;;;;;;;GAOG;AACH,wBAAgB,oBAAoB,CAAC,IAAI,EAAE,OAAO,EAAE,EAAE,MAAM,EAAE,WAAW,EAAE,GAAG,WAAW,CA8CxF"}

package/lib/typescript/module/sqlite/statements.d.ts

@@ -0,0 +1,26 @@
+/**
+ * The write statements, built in one place (LDB-12).
+ *
+ * The collection API and the batch each used to assemble their own INSERT and
+ * UPDATE text. Two copies of the same rule is how a batch upsert came to treat
+ * a soft-deleted row differently from a collection upsert.
+ */
+import type { CollectionSchema } from '../contract/schema.js';
+import type { SqlValue } from './native.js';
+import { insertColumns } from './row-codec.js';
+export type Statement = [sql: string, params: SqlValue[]];
+type RecordData = Parameters<typeof insertColumns>[2];
+/**
+ * `ignore` leaves a row that already holds the id untouched and reports zero
+ * rows affected, so a conflict is detected without a SELECT beforehand.
+ */
+export declare function insertStatement(schema: CollectionSchema, id: string, data: RecordData, now: number, payload: string, onConflict?: 'fail' | 'ignore'): Statement;
+export type UpdateOptions = {
+    /** Clear `deleted_at`: an upsert over a soft-deleted record brings it back. */
+    restore?: boolean;
+    /** Match only a record that is not soft-deleted. */
+    liveOnly?: boolean;
+};
+export declare function updateStatement(schema: CollectionSchema, id: string, data: RecordData, now: number, payload: string, options?: UpdateOptions): Statement;
+export {};
+//# sourceMappingURL=statements.d.ts.map

package/lib/typescript/module/sqlite/statements.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"statements.d.ts","sourceRoot":"","sources":["../../../../src/sqlite/statements.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AACH,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,uBAAoB,CAAC;AAE3D,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,aAAU,CAAC;AACzC,OAAO,EAAE,aAAa,EAAqB,MAAM,gBAAa,CAAC;AAE/D,MAAM,MAAM,SAAS,GAAG,CAAC,GAAG,EAAE,MAAM,EAAE,MAAM,EAAE,QAAQ,EAAE,CAAC,CAAC;AAE1D,KAAK,UAAU,GAAG,UAAU,CAAC,OAAO,aAAa,CAAC,CAAC,CAAC,CAAC,CAAC;AAiBtD;;;GAGG;AACH,wBAAgB,eAAe,CAC9B,MAAM,EAAE,gBAAgB,EACxB,EAAE,EAAE,MAAM,EACV,IAAI,EAAE,UAAU,EAChB,GAAG,EAAE,MAAM,EACX,OAAO,EAAE,MAAM,EACf,UAAU,GAAE,MAAM,GAAG,QAAiB,GACpC,SAAS,CAIX;AAED,MAAM,MAAM,aAAa,GAAG;IAC3B,+EAA+E;IAC/E,OAAO,CAAC,EAAE,OAAO,CAAC;IAClB,oDAAoD;IACpD,QAAQ,CAAC,EAAE,OAAO,CAAC;CACnB,CAAC;AAEF,wBAAgB,eAAe,CAC9B,MAAM,EAAE,gBAAgB,EACxB,EAAE,EAAE,MAAM,EACV,IAAI,EAAE,UAAU,EAChB,GAAG,EAAE,MAAM,EACX,OAAO,EAAE,MAAM,EACf,OAAO,GAAE,aAAkB,GACzB,SAAS,CAWX"}

package/lib/typescript/module/sqlite/transaction-queue.d.ts

@@ -0,0 +1,31 @@
+/**
+ * The per-handle queue that keeps a transaction to itself.
+ *
+ * A transaction holds the queue until it settles; work arriving meanwhile
+ * through the handle waits its turn and then runs on its own, instead of
+ * joining the transaction and vanishing with its rollback (LDB-01). Shared by
+ * the SQLite connection and the memory adapter so both isolate the same way.
+ *
+ * Pure: no engine, no React, so the memory adapter can use it without loading
+ * native code.
+ */
+/**
+ * How long work through the handle waits behind a transaction before it is
+ * refused.
+ *
+ * Not a performance budget: it exists for the one wait that never ends. A
+ * transaction body that awaits the handle's own `collection()` or
+ * `attachments()` is waiting on work queued behind itself. Until 0.2.0 that
+ * work ran inside the transaction; now it is refused after this long with a
+ * message naming `tx.collection()` / `tx.attachments()`, and the transaction
+ * rolls back, rather than both waiting forever.
+ */
+export declare const TRANSACTION_WAIT_LIMIT_MS = 10000;
+export type TransactionQueue = {
+    /** Ordinary work. Bounded by `TRANSACTION_WAIT_LIMIT_MS` when it queues behind a transaction. */
+    run<T>(work: () => Promise<T>): Promise<T>;
+    /** A transaction: holds the queue for as long as `work` runs. */
+    runTransaction<T>(work: () => Promise<T>): Promise<T>;
+};
+export declare function createTransactionQueue(waitLimitMs?: number): TransactionQueue;
+//# sourceMappingURL=transaction-queue.d.ts.map

package/lib/typescript/module/sqlite/transaction-queue.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"transaction-queue.d.ts","sourceRoot":"","sources":["../../../../src/sqlite/transaction-queue.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AAKH;;;;;;;;;;GAUG;AACH,eAAO,MAAM,yBAAyB,QAAS,CAAC;AAEhD,MAAM,MAAM,gBAAgB,GAAG;IAC9B,iGAAiG;IACjG,GAAG,CAAC,CAAC,EAAE,IAAI,EAAE,MAAM,OAAO,CAAC,CAAC,CAAC,GAAG,OAAO,CAAC,CAAC,CAAC,CAAC;IAC3C,iEAAiE;IACjE,cAAc,CAAC,CAAC,EAAE,IAAI,EAAE,MAAM,OAAO,CAAC,CAAC,CAAC,GAAG,OAAO,CAAC,CAAC,CAAC,CAAC;CACtD,CAAC;AAEF,wBAAgB,sBAAsB,CACrC,WAAW,GAAE,MAAkC,GAC7C,gBAAgB,CAiDlB"}

package/lib/typescript/module/sqlite/transactions.d.ts

@@ -0,0 +1,26 @@
+/**
+ * The transaction primitive.
+ *
+ * A transaction never spans two scopes, and not because a check forbids it:
+ * a transaction runs on one connection, a connection is opened against one
+ * scope's file, and the public surface offers no way to reach a second one
+ * from inside. FR-038 is a type error rather than a runtime one (research.md
+ * R2).
+ *
+ * Rollback fidelity is SQLite's, not this package's. A failure at any step
+ * unwinds through the engine's own `ROLLBACK`, which is the only way SC-006's
+ * "identical to its pre-transaction state, every time" survives a process
+ * kill halfway through.
+ */
+import type { Connection, TransactionExecutor } from './connection.js';
+/**
+ * Run `body` inside one transaction on one scope.
+ *
+ * Deliberately thin. The interesting behavior — read-your-own-writes,
+ * terminal-state rejection, what a settled transaction does when used again —
+ * belongs to `adapter/transaction.ts`, where both adapters can be held to the
+ * same rules.
+ */
+export declare function runInTransaction<R>(connection: Connection, body: (tx: TransactionExecutor) => Promise<R>): Promise<R>;
+export type { TransactionExecutor };
+//# sourceMappingURL=transactions.d.ts.map

package/lib/typescript/module/sqlite/transactions.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"transactions.d.ts","sourceRoot":"","sources":["../../../../src/sqlite/transactions.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;GAaG;AAEH,OAAO,KAAK,EAAE,UAAU,EAAE,mBAAmB,EAAE,MAAM,iBAAc,CAAC;AAEpE;;;;;;;GAOG;AACH,wBAAgB,gBAAgB,CAAC,CAAC,EACjC,UAAU,EAAE,UAAU,EACtB,IAAI,EAAE,CAAC,EAAE,EAAE,mBAAmB,KAAK,OAAO,CAAC,CAAC,CAAC,GAC3C,OAAO,CAAC,CAAC,CAAC,CAEZ;AAED,YAAY,EAAE,mBAAmB,EAAE,CAAC"}

package/lib/typescript/module/sqlite/values.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Reading values back out of a result row.
+ *
+ * The engine hands back `unknown` per column, and every read site would
+ * otherwise repeat the same `String(...)` / `Number(...)` coercion with a
+ * slightly different null check. One place to do it means one place where the
+ * "NULL means absent, not empty string" rule is decided.
+ */
+export declare function text(value: unknown): string;
+export declare function num(value: unknown): number;
+export declare function maybeText(value: unknown): string | null;
+export declare function maybeNum(value: unknown): number | null;
+//# sourceMappingURL=values.d.ts.map

package/lib/typescript/module/sqlite/values.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"values.d.ts","sourceRoot":"","sources":["../../../../src/sqlite/values.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAEH,wBAAgB,IAAI,CAAC,KAAK,EAAE,OAAO,GAAG,MAAM,CAE3C;AAED,wBAAgB,GAAG,CAAC,KAAK,EAAE,OAAO,GAAG,MAAM,CAE1C;AAED,wBAAgB,SAAS,CAAC,KAAK,EAAE,OAAO,GAAG,MAAM,GAAG,IAAI,CAEvD;AAED,wBAAgB,QAAQ,CAAC,KAAK,EAAE,OAAO,GAAG,MAAM,GAAG,IAAI,CAEtD"}

package/lib/typescript/module/testing/conformance/attachments.d.ts

@@ -0,0 +1,4 @@
+import type { ConformanceContext } from './index.js';
+/** US7: artifacts the package owns, and the reconciliation that keeps them honest. */
+export declare function registerAttachmentConformance(context: ConformanceContext): void;
+//# sourceMappingURL=attachments.d.ts.map

package/lib/typescript/module/testing/conformance/attachments.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"attachments.d.ts","sourceRoot":"","sources":["../../../../../src/testing/conformance/attachments.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,YAAS,CAAC;AAElD,sFAAsF;AACtF,wBAAgB,6BAA6B,CAAC,OAAO,EAAE,kBAAkB,GAAG,IAAI,CAoI/E"}

package/lib/typescript/module/testing/conformance/encryption.d.ts

@@ -0,0 +1,4 @@
+import type { ConformanceContext } from './index.js';
+/** US10: opt-in encryption, and failures that stay apart from each other. */
+export declare function registerEncryptionConformance(context: ConformanceContext): void;
+//# sourceMappingURL=encryption.d.ts.map

package/lib/typescript/module/testing/conformance/encryption.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"encryption.d.ts","sourceRoot":"","sources":["../../../../../src/testing/conformance/encryption.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,YAAS,CAAC;AAElD,6EAA6E;AAC7E,wBAAgB,6BAA6B,CAAC,OAAO,EAAE,kBAAkB,GAAG,IAAI,CA+I/E"}

package/lib/typescript/module/testing/conformance/index.d.ts

@@ -0,0 +1,58 @@
+/**
+ * The conformance suite: the executable definition of what the package
+ * guarantees (FR-092).
+ *
+ * Exported rather than kept internal so a consuming team can run it against
+ * their own adapter if one ever exists, and so both of ours are held to
+ * exactly the same standard rather than to two similar-looking test files.
+ */
+import type { StorageAdapter } from '../../contract/adapter.js';
+import type { DatabaseConfig, ScopeTargetConfig } from '../../contract/config.js';
+import type { EncryptionConfig } from '../../contract/encryption.js';
+import type { ScopeDescriptor } from '../../contract/scope.js';
+export type ConformanceContext = {
+    adapter: StorageAdapter;
+    /** A fresh config for the given scope, using the standard test schema. */
+    configFor(scope: ScopeDescriptor, overrides?: Partial<DatabaseConfig>): DatabaseConfig;
+    /**
+     * How an app names a scope for deletion.
+     *
+     * Carries the encryption config when the run is encrypted, because that is
+     * how a real consumer calls it: `ScopeTargetConfig.encryption` exists so
+     * deletion can report what it removed rather than guessing at it.
+     */
+    scopeTargetFor(scope: ScopeDescriptor): ScopeTargetConfig;
+    reset(): Promise<void>;
+    /**
+     * Reach past the package and delete an artifact the way the operating
+     * system does when it reclaims storage. Each adapter supplies its own,
+     * because the suite cannot simulate this through the public API without
+     * asking the package to break its own guarantee.
+     */
+    removeArtifactBehindTheScenes(scopeKey: string, attachmentId: string): Promise<void>;
+    /** The other direction: a reference whose artifact survives. */
+    removeReferenceBehindTheScenes(scopeKey: string, attachmentId: string): Promise<void>;
+};
+export type ConformanceHooks = Pick<ConformanceContext, 'removeArtifactBehindTheScenes' | 'removeReferenceBehindTheScenes'>;
+export type ConformanceOptions = {
+    /** Sections the adapter knowingly cannot satisfy, with a documented reason. */
+    skip?: ConformanceSection[];
+    /**
+     * Run every section against an encrypted database (FR-105).
+     *
+     * The suite is the contract, so the contract has to hold in both postures
+     * — an encrypted database that quietly behaved differently would be a
+     * second implementation nobody tested.
+     */
+    encryption?: EncryptionConfig | undefined;
+};
+export type ConformanceSection = 'records' | 'scopes' | 'queries' | 'transactions' | 'migrations' | 'lifecycle' | 'attachments' | 'encryption';
+export declare const TEST_COLLECTIONS: DatabaseConfig['collections'];
+export declare function makeConformanceContext(adapter: StorageAdapter, reset: () => Promise<void>, hooks: ConformanceHooks, defaults?: Partial<DatabaseConfig>): ConformanceContext;
+/**
+ * Registers the whole suite against one adapter. Both adapters call this with
+ * the same arguments; any difference in outcome is a divergence that must be
+ * documented under FR-096 or fixed.
+ */
+export declare function runConformanceSuite(factory: () => StorageAdapter, reset: () => Promise<void>, hooks: ConformanceHooks, options?: ConformanceOptions): void;
+//# sourceMappingURL=index.d.ts.map

package/lib/typescript/module/testing/conformance/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/testing/conformance/index.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAEH,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,2BAAwB,CAAC;AAC7D,OAAO,KAAK,EAAE,cAAc,EAAE,iBAAiB,EAAE,MAAM,0BAAuB,CAAC;AAC/E,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,8BAA2B,CAAC;AAClE,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,yBAAsB,CAAC;AAU5D,MAAM,MAAM,kBAAkB,GAAG;IAChC,OAAO,EAAE,cAAc,CAAC;IACxB,0EAA0E;IAC1E,SAAS,CAAC,KAAK,EAAE,eAAe,EAAE,SAAS,CAAC,EAAE,OAAO,CAAC,cAAc,CAAC,GAAG,cAAc,CAAC;IACvF;;;;;;OAMG;IACH,cAAc,CAAC,KAAK,EAAE,eAAe,GAAG,iBAAiB,CAAC;IAC1D,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC,CAAC;IACvB;;;;;OAKG;IACH,6BAA6B,CAAC,QAAQ,EAAE,MAAM,EAAE,YAAY,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;IACrF,gEAAgE;IAChE,8BAA8B,CAAC,QAAQ,EAAE,MAAM,EAAE,YAAY,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;CACtF,CAAC;AAEF,MAAM,MAAM,gBAAgB,GAAG,IAAI,CAClC,kBAAkB,EAClB,+BAA+B,GAAG,gCAAgC,CAClE,CAAC;AAEF,MAAM,MAAM,kBAAkB,GAAG;IAChC,+EAA+E;IAC/E,IAAI,CAAC,EAAE,kBAAkB,EAAE,CAAC;IAC5B;;;;;;OAMG;IACH,UAAU,CAAC,EAAE,gBAAgB,GAAG,SAAS,CAAC;CAC1C,CAAC;AAEF,MAAM,MAAM,kBAAkB,GAC3B,SAAS,GACT,QAAQ,GACR,SAAS,GACT,cAAc,GACd,YAAY,GACZ,WAAW,GACX,aAAa,GACb,YAAY,CAAC;AAEhB,eAAO,MAAM,gBAAgB,EAAE,cAAc,CAAC,aAAa,CAiB1D,CAAC;AAEF,wBAAgB,sBAAsB,CACrC,OAAO,EAAE,cAAc,EACvB,KAAK,EAAE,MAAM,OAAO,CAAC,IAAI,CAAC,EAC1B,KAAK,EAAE,gBAAgB,EACvB,QAAQ,GAAE,OAAO,CAAC,cAAc,CAAM,GACpC,kBAAkB,CAwBpB;AAED;;;;GAIG;AACH,wBAAgB,mBAAmB,CAClC,OAAO,EAAE,MAAM,cAAc,EAC7B,KAAK,EAAE,MAAM,OAAO,CAAC,IAAI,CAAC,EAC1B,KAAK,EAAE,gBAAgB,EACvB,OAAO,GAAE,kBAAuB,GAC9B,IAAI,CA0BN"}

package/lib/typescript/module/testing/conformance/lifecycle.d.ts

@@ -0,0 +1,4 @@
+import type { ConformanceContext } from './index.js';
+/** US6: sign-out retains; deletion happens only when asked, and only where asked. */
+export declare function registerLifecycleConformance(context: ConformanceContext): void;
+//# sourceMappingURL=lifecycle.d.ts.map

package/lib/typescript/module/testing/conformance/lifecycle.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"lifecycle.d.ts","sourceRoot":"","sources":["../../../../../src/testing/conformance/lifecycle.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,YAAS,CAAC;AAElD,qFAAqF;AACrF,wBAAgB,4BAA4B,CAAC,OAAO,EAAE,kBAAkB,GAAG,IAAI,CA8F9E"}

package/lib/typescript/module/testing/conformance/migrations.d.ts

@@ -0,0 +1,4 @@
+import type { ConformanceContext } from './index.js';
+/** US5: ordered, once-only migrations that fail loudly. */
+export declare function registerMigrationConformance(context: ConformanceContext): void;
+//# sourceMappingURL=migrations.d.ts.map

package/lib/typescript/module/testing/conformance/migrations.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"migrations.d.ts","sourceRoot":"","sources":["../../../../../src/testing/conformance/migrations.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,YAAS,CAAC;AAElD,2DAA2D;AAC3D,wBAAgB,4BAA4B,CAAC,OAAO,EAAE,kBAAkB,GAAG,IAAI,CA0K9E"}

package/lib/typescript/module/testing/conformance/queries.d.ts

@@ -0,0 +1,4 @@
+import type { ConformanceContext } from './index.js';
+/** US3: filter, sort, page, count — and paging that loses nothing. */
+export declare function registerQueryConformance(context: ConformanceContext): void;
+//# sourceMappingURL=queries.d.ts.map

package/lib/typescript/module/testing/conformance/queries.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"queries.d.ts","sourceRoot":"","sources":["../../../../../src/testing/conformance/queries.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,YAAS,CAAC;AAElD,sEAAsE;AACtE,wBAAgB,wBAAwB,CAAC,OAAO,EAAE,kBAAkB,GAAG,IAAI,CAsM1E"}

package/lib/typescript/module/testing/conformance/records.d.ts

@@ -0,0 +1,4 @@
+import type { ConformanceContext } from './index.js';
+/** US1: durable CRUD, and the four value conditions staying distinguishable. */
+export declare function registerRecordConformance(context: ConformanceContext): void;
+//# sourceMappingURL=records.d.ts.map

package/lib/typescript/module/testing/conformance/records.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"records.d.ts","sourceRoot":"","sources":["../../../../../src/testing/conformance/records.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,YAAS,CAAC;AAElD,gFAAgF;AAChF,wBAAgB,yBAAyB,CAAC,OAAO,EAAE,kBAAkB,GAAG,IAAI,CAmK3E"}

package/lib/typescript/module/testing/conformance/scopes.d.ts

@@ -0,0 +1,4 @@
+import type { ConformanceContext } from './index.js';
+/** US2: scope isolation, proven with unfiltered reads and colliding ids. */
+export declare function registerScopeConformance(context: ConformanceContext): void;
+//# sourceMappingURL=scopes.d.ts.map

package/lib/typescript/module/testing/conformance/scopes.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"scopes.d.ts","sourceRoot":"","sources":["../../../../../src/testing/conformance/scopes.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,YAAS,CAAC;AAElD,4EAA4E;AAC5E,wBAAgB,wBAAwB,CAAC,OAAO,EAAE,kBAAkB,GAAG,IAAI,CAiF1E"}

package/lib/typescript/module/testing/conformance/transactions.d.ts

@@ -0,0 +1,4 @@
+import type { ConformanceContext } from './index.js';
+/** US4: all-or-nothing writes. */
+export declare function registerTransactionConformance(context: ConformanceContext): void;
+//# sourceMappingURL=transactions.d.ts.map

package/lib/typescript/module/testing/conformance/transactions.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"transactions.d.ts","sourceRoot":"","sources":["../../../../../src/testing/conformance/transactions.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,YAAS,CAAC;AAElD,kCAAkC;AAClC,wBAAgB,8BAA8B,CAAC,OAAO,EAAE,kBAAkB,GAAG,IAAI,CA+IhF"}

package/lib/typescript/module/testing/faults.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Fault injection, exposed only through the `./testing` entrypoint.
+ *
+ * Produces the same typed errors the on-device implementation produces, so a
+ * consumer can test its recovery paths without a device that is actually out
+ * of space or actually corrupt (FR-095). The registry itself lives in
+ * `diagnostics/faults.ts`, because the *checks* have to run in production code
+ * for the demo app's panel to exercise the real adapter — only the ability to
+ * arm one is kept behind this entrypoint.
+ */
+export { activeFaults, clearFaults, injectFault, throwIfFaulted, type FaultPoint, type FaultSpec, } from '../diagnostics/faults.js';
+export { DiagnosticCodes } from '../contract/errors.js';
+//# sourceMappingURL=faults.d.ts.map

package/lib/typescript/module/testing/faults.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"faults.d.ts","sourceRoot":"","sources":["../../../../src/testing/faults.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AAEH,OAAO,EACN,YAAY,EACZ,WAAW,EACX,WAAW,EACX,cAAc,EACd,KAAK,UAAU,EACf,KAAK,SAAS,GACd,MAAM,0BAAuB,CAAC;AAE/B,OAAO,EAAE,eAAe,EAAE,MAAM,uBAAoB,CAAC"}

package/lib/typescript/module/testing/index.d.ts

@@ -0,0 +1,13 @@
+/**
+ * `@chipmobilesdk/rn-local-db/testing`
+ *
+ * Test-only surface, kept behind its own entrypoint so the in-memory engine
+ * never reaches a consuming app's production bundle (research.md R10).
+ */
+export { createMemoryAdapter, type MemoryAdapterOptions } from './memory-adapter/index.js';
+export { memoryConformanceHooks, resetMemoryAdapter, seedRecords } from './memory-adapter/reset.js';
+export { clearFaults, injectFault, type FaultPoint, type FaultSpec } from './faults.js';
+/** Makes `openDatabase` and the deletion functions use the given adapter; `null` restores the device one. */
+export { setStorageAdapter } from '../adapter/index.js';
+export { runConformanceSuite, type ConformanceContext, type ConformanceHooks, type ConformanceOptions, type ConformanceSection, } from './conformance/index.js';
+//# sourceMappingURL=index.d.ts.map

package/lib/typescript/module/testing/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/testing/index.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,OAAO,EAAE,mBAAmB,EAAE,KAAK,oBAAoB,EAAE,MAAM,2BAAkB,CAAC;AAClF,OAAO,EAAE,sBAAsB,EAAE,kBAAkB,EAAE,WAAW,EAAE,MAAM,2BAAwB,CAAC;AACjG,OAAO,EAAE,WAAW,EAAE,WAAW,EAAE,KAAK,UAAU,EAAE,KAAK,SAAS,EAAE,MAAM,aAAU,CAAC;AACrF,6GAA6G;AAC7G,OAAO,EAAE,iBAAiB,EAAE,MAAM,qBAAY,CAAC;AAC/C,OAAO,EACN,mBAAmB,EACnB,KAAK,kBAAkB,EACvB,KAAK,gBAAgB,EACrB,KAAK,kBAAkB,EACvB,KAAK,kBAAkB,GACvB,MAAM,wBAAe,CAAC"}

package/lib/typescript/module/testing/memory-adapter/attachments.d.ts

@@ -0,0 +1,23 @@
+/**
+ * The in-memory adapter's attachments (FR-091).
+ *
+ * The same surface the SQLite adapter exposes, over the store's maps: written
+ * whole rather than chunked, no filesystem, and a `sourcePath` read through the
+ * `readSourceFile` option a test supplies. Divergences are documented in the
+ * package README.
+ */
+import type { Attachments } from '../../contract/adapter.js';
+import type { MemoryScopeStore } from './store.js';
+import type { MemoryAdapterOptions } from './index.js';
+/** What one artifact removal has to wait for: the transaction that caused it. */
+export interface Deferred {
+    add(id: string): void;
+}
+export interface MemoryAttachmentDeps {
+    store: MemoryScopeStore;
+    options: MemoryAdapterOptions;
+    now: () => number;
+    assertOpen: () => void;
+}
+export declare function createMemoryAttachments(deps: MemoryAttachmentDeps): (deferred?: Deferred) => Attachments;
+//# sourceMappingURL=attachments.d.ts.map