@chipmobilesdk/rn-local-db 0.4.0 → 0.5.0

package/lib/module/sqlite/batch.js

@@ -0,0 +1,214 @@
+"use strict";
+
+/**
+ * Batch writes: many operations, one atomic unit, one outcome (FR-028).
+ *
+ * Every statement is resolved before any of them runs. That ordering is the
+ * point: a conflict or a missing record is reported with the database still
+ * untouched, so "the batch failed" and "the batch was partly applied" are
+ * never the same event. The statements then go to the engine's own
+ * `executeBatch`, which wraps them in a single transaction — the batch is
+ * atomic because SQLite makes it atomic, not because this file is careful.
+ *
+ * Resolution keeps an overlay of what earlier operations in the same batch
+ * did, so `insert` followed by `update` on the same id resolves against the
+ * batch's own effect rather than against the database as it was before it.
+ */
+
+import { DiagnosticCodes } from "../contract/errors.js";
+import { raise } from "../diagnostics/errors.js";
+import { assertBatchWithinBudget, assertRecordWithinBudget } from "../query/budgets.js";
+import { collectionTable, hasSoftDelete } from "../schema/declare.js";
+import { insertStatement, updateStatement } from "./statements.js";
+function quoted(schema) {
+  return `"${collectionTable(schema.name)}"`;
+}
+
+/**
+ * Where a record stands, as this batch has left it so far. Three states, not
+ * two: a soft-deleted row is invisible to reads but still holds its primary
+ * key, so an insert over it conflicts and an upsert over it restores it — the
+ * same rules the collection API applies. Treating it as absent made a batch
+ * upsert issue an INSERT and fail the whole batch on the primary key.
+ */
+
+function conflict(schema, id) {
+  raise(DiagnosticCodes.RECORD_CONFLICT, {
+    message: 'record already exists',
+    detail: {
+      collection: schema.name,
+      recordId: id
+    }
+  });
+}
+function missing(schema, id) {
+  raise(DiagnosticCodes.RECORD_NOT_FOUND, {
+    message: 'record not found',
+    detail: {
+      collection: schema.name,
+      recordId: id
+    }
+  });
+}
+async function resolveInsert(resolver, operation) {
+  const {
+    schema,
+    now
+  } = resolver;
+  const payload = assertRecordWithinBudget(schema.name, operation.record.data);
+  if ((await resolver.state(operation.record.id)) !== 'absent') {
+    conflict(schema, operation.record.id);
+  }
+  resolver.stage(operation.record.id, 'live');
+  return {
+    command: insertStatement(schema, operation.record.id, operation.record.data, now, payload),
+    outcome: {
+      operation: 'created',
+      id: operation.record.id
+    }
+  };
+}
+async function resolveUpdate(resolver, operation) {
+  const {
+    schema,
+    now
+  } = resolver;
+  const payload = assertRecordWithinBudget(schema.name, operation.data);
+  if ((await resolver.state(operation.id)) !== 'live') {
+    missing(schema, operation.id);
+  }
+  return {
+    command: updateStatement(schema, operation.id, operation.data, now, payload, {
+      restore: false
+    }),
+    outcome: {
+      operation: 'updated',
+      id: operation.id
+    }
+  };
+}
+async function resolveUpsert(resolver, operation) {
+  const {
+    schema,
+    now
+  } = resolver;
+  const payload = assertRecordWithinBudget(schema.name, operation.record.data);
+  const present = (await resolver.state(operation.record.id)) !== 'absent';
+  resolver.stage(operation.record.id, 'live');
+  return {
+    command: present ? updateStatement(schema, operation.record.id, operation.record.data, now, payload, {
+      restore: true
+    }) : insertStatement(schema, operation.record.id, operation.record.data, now, payload),
+    outcome: {
+      operation: present ? 'updated' : 'created',
+      id: operation.record.id
+    }
+  };
+}
+async function resolveDelete(resolver, operation) {
+  const {
+    schema
+  } = resolver;
+  if ((await resolver.state(operation.id)) !== 'live') {
+    missing(schema, operation.id);
+  }
+  resolver.stage(operation.id, 'absent');
+  return {
+    command: [`DELETE FROM ${quoted(schema)} WHERE id = ?`, [operation.id]],
+    outcome: {
+      operation: 'deleted',
+      id: operation.id
+    }
+  };
+}
+async function resolveSoftDelete(resolver, operation) {
+  const {
+    schema,
+    now
+  } = resolver;
+  if (!hasSoftDelete(schema)) {
+    raise(DiagnosticCodes.CONFIG_INVALID, {
+      message: 'collection does not declare soft delete',
+      detail: {
+        collection: schema.name
+      }
+    });
+  }
+  if ((await resolver.state(operation.id)) !== 'live') {
+    missing(schema, operation.id);
+  }
+  resolver.stage(operation.id, 'softDeleted');
+  return {
+    command: [`UPDATE ${quoted(schema)} SET deleted_at = ? WHERE id = ?`, [now, operation.id]],
+    outcome: {
+      operation: 'deleted',
+      id: operation.id
+    }
+  };
+}
+function resolveOperation(resolver, operation) {
+  switch (operation.type) {
+    case 'insert':
+      return resolveInsert(resolver, operation);
+    case 'update':
+      return resolveUpdate(resolver, operation);
+    case 'upsert':
+      return resolveUpsert(resolver, operation);
+    case 'delete':
+      return resolveDelete(resolver, operation);
+    case 'softDelete':
+      return resolveSoftDelete(resolver, operation);
+    default:
+      raise(DiagnosticCodes.CONFIG_INVALID, {
+        message: 'unsupported batch operation'
+      });
+  }
+}
+export async function runBatch(context, operations) {
+  assertBatchWithinBudget(operations.length);
+  const commands = [];
+  const outcomes = [];
+  const overlay = new Map();
+
+  // What the batch will touch, read once per collection (LDB-08). A batch of a
+  // thousand operations used to make a thousand SELECTs before its one write.
+  // The ids travel as one JSON parameter, so no variable limit applies.
+  const known = new Map();
+  const idsByCollection = new Map();
+  for (const operation of operations) {
+    const id = 'record' in operation ? operation.record.id : operation.id;
+    const ids = idsByCollection.get(operation.collection) ?? new Set();
+    ids.add(id);
+    idsByCollection.set(operation.collection, ids);
+  }
+  for (const [collection, ids] of idsByCollection) {
+    const schema = context.schemaFor(collection);
+    const result = await context.connection.execute(`SELECT id, deleted_at FROM ${quoted(schema)} WHERE id IN (SELECT value FROM json_each(?))`, [JSON.stringify([...ids])]);
+    for (const row of result.rows) {
+      known.set(`${schema.name}:${String(row.id)}`, row.deleted_at === null || row.deleted_at === undefined ? 'live' : 'softDeleted');
+    }
+  }
+  for (const operation of operations) {
+    const schema = context.schemaFor(operation.collection);
+    const resolver = {
+      schema,
+      now: context.now(),
+      async state(id) {
+        const key = `${schema.name}:${id}`;
+        return overlay.get(key) ?? known.get(key) ?? 'absent';
+      },
+      stage(id, state) {
+        overlay.set(`${schema.name}:${id}`, state);
+      }
+    };
+    const resolved = await resolveOperation(resolver, operation);
+    commands.push(resolved.command);
+    outcomes.push(resolved.outcome);
+  }
+  await context.connection.executeBatch(commands);
+  return {
+    applied: outcomes.length,
+    outcomes
+  };
+}
+//# sourceMappingURL=batch.js.map

package/lib/module/sqlite/batch.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["DiagnosticCodes","raise","assertBatchWithinBudget","assertRecordWithinBudget","collectionTable","hasSoftDelete","insertStatement","updateStatement","quoted","schema","name","conflict","id","RECORD_CONFLICT","message","detail","collection","recordId","missing","RECORD_NOT_FOUND","resolveInsert","resolver","operation","now","payload","record","data","state","stage","command","outcome","resolveUpdate","restore","resolveUpsert","present","resolveDelete","resolveSoftDelete","CONFIG_INVALID","resolveOperation","type","runBatch","context","operations","length","commands","outcomes","overlay","Map","known","idsByCollection","ids","get","Set","add","set","schemaFor","result","connection","execute","JSON","stringify","row","rows","String","deleted_at","undefined","key","resolved","push","executeBatch","applied"],"sourceRoot":"../../../src","sources":["sqlite/batch.ts"],"mappings":"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","ignoreList":[]}

package/lib/module/sqlite/catalog.js

@@ -0,0 +1,72 @@
+"use strict";
+
+/**
+ * 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 { num, text } from "./values.js";
+const CREATE_SCOPES = `CREATE TABLE IF NOT EXISTS scopes (
+  scope_key      TEXT PRIMARY KEY,
+  created_at     INTEGER NOT NULL,
+  deletion_state TEXT NOT NULL,
+  backup_posture TEXT NOT NULL,
+  encrypted      INTEGER NOT NULL
+)`;
+export async function ensureCatalog(connection) {
+  await connection.execute(CREATE_SCOPES);
+}
+export async function readEntry(connection, scopeKey) {
+  const result = await connection.execute('SELECT scope_key, created_at, deletion_state, backup_posture, encrypted FROM scopes WHERE scope_key = ?', [scopeKey]);
+  const row = result.rows[0];
+  if (!row) {
+    return null;
+  }
+  return {
+    scopeKey: text(row.scope_key),
+    createdAt: num(row.created_at),
+    deletionState: text(row.deletion_state),
+    backupPosture: text(row.backup_posture),
+    encrypted: num(row.encrypted) === 1
+  };
+}
+export async function listEntries(connection) {
+  const result = await connection.execute('SELECT scope_key, created_at, deletion_state, backup_posture, encrypted FROM scopes');
+  return result.rows.map(row => ({
+    scopeKey: text(row.scope_key),
+    createdAt: num(row.created_at),
+    deletionState: text(row.deletion_state),
+    backupPosture: text(row.backup_posture),
+    encrypted: num(row.encrypted) === 1
+  }));
+}
+export async function registerScope(connection, entry) {
+  await connection.execute(`INSERT INTO scopes (scope_key, created_at, deletion_state, backup_posture, encrypted)
+		 VALUES (?, ?, ?, ?, ?)
+		 ON CONFLICT(scope_key) DO UPDATE SET
+		   deletion_state = excluded.deletion_state,
+		   backup_posture = excluded.backup_posture,
+		   encrypted = excluded.encrypted`, [entry.scopeKey, entry.createdAt, entry.deletionState, entry.backupPosture, entry.encrypted ? 1 : 0]);
+}
+export async function markDeleting(connection, scopeKey) {
+  await connection.execute('UPDATE scopes SET deletion_state = ? WHERE scope_key = ?', ['deleting', scopeKey]);
+}
+
+/** Cleared last, on purpose. See the note at the top of this file. */
+export async function clearScope(connection, scopeKey) {
+  await connection.execute('DELETE FROM scopes WHERE scope_key = ?', [scopeKey]);
+}
+//# sourceMappingURL=catalog.js.map

package/lib/module/sqlite/catalog.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["num","text","CREATE_SCOPES","ensureCatalog","connection","execute","readEntry","scopeKey","result","row","rows","scope_key","createdAt","created_at","deletionState","deletion_state","backupPosture","backup_posture","encrypted","listEntries","map","registerScope","entry","markDeleting","clearScope"],"sourceRoot":"../../../src","sources":["sqlite/catalog.ts"],"mappings":";;AAAA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAIA,SAASA,GAAG,EAAEC,IAAI,QAAQ,aAAU;AAUpC,MAAMC,aAAa,GAAG;AACtB;AACA;AACA;AACA;AACA;AACA,EAAE;AAEF,OAAO,eAAeC,aAAaA,CAACC,UAAsB,EAAiB;EAC1E,MAAMA,UAAU,CAACC,OAAO,CAACH,aAAa,CAAC;AACxC;AAEA,OAAO,eAAeI,SAASA,CAC9BF,UAAsB,EACtBG,QAAgB,EACe;EAC/B,MAAMC,MAAM,GAAG,MAAMJ,UAAU,CAACC,OAAO,CACtC,yGAAyG,EACzG,CAACE,QAAQ,CACV,CAAC;EACD,MAAME,GAAG,GAAGD,MAAM,CAACE,IAAI,CAAC,CAAC,CAAC;EAC1B,IAAI,CAACD,GAAG,EAAE;IACT,OAAO,IAAI;EACZ;EACA,OAAO;IACNF,QAAQ,EAAEN,IAAI,CAACQ,GAAG,CAACE,SAAS,CAAC;IAC7BC,SAAS,EAAEZ,GAAG,CAACS,GAAG,CAACI,UAAU,CAAC;IAC9BC,aAAa,EAAEb,IAAI,CAACQ,GAAG,CAACM,cAAc,CAAuB;IAC7DC,aAAa,EAAEf,IAAI,CAACQ,GAAG,CAACQ,cAAc,CAA4B;IAClEC,SAAS,EAAElB,GAAG,CAACS,GAAG,CAACS,SAAS,CAAC,KAAK;EACnC,CAAC;AACF;AAEA,OAAO,eAAeC,WAAWA,CAACf,UAAsB,EAA2B;EAClF,MAAMI,MAAM,GAAG,MAAMJ,UAAU,CAACC,OAAO,CACtC,qFACD,CAAC;EACD,OAAOG,MAAM,CAACE,IAAI,CAACU,GAAG,CAACX,GAAG,KAAK;IAC9BF,QAAQ,EAAEN,IAAI,CAACQ,GAAG,CAACE,SAAS,CAAC;IAC7BC,SAAS,EAAEZ,GAAG,CAACS,GAAG,CAACI,UAAU,CAAC;IAC9BC,aAAa,EAAEb,IAAI,CAACQ,GAAG,CAACM,cAAc,CAAuB;IAC7DC,aAAa,EAAEf,IAAI,CAACQ,GAAG,CAACQ,cAAc,CAA4B;IAClEC,SAAS,EAAElB,GAAG,CAACS,GAAG,CAACS,SAAS,CAAC,KAAK;EACnC,CAAC,CAAC,CAAC;AACJ;AAEA,OAAO,eAAeG,aAAaA,CAACjB,UAAsB,EAAEkB,KAAmB,EAAiB;EAC/F,MAAMlB,UAAU,CAACC,OAAO,CACvB;AACF;AACA;AACA;AACA;AACA,oCAAoC,EAClC,CACCiB,KAAK,CAACf,QAAQ,EACde,KAAK,CAACV,SAAS,EACfU,KAAK,CAACR,aAAa,EACnBQ,KAAK,CAACN,aAAa,EACnBM,KAAK,CAACJ,SAAS,GAAG,CAAC,GAAG,CAAC,CAEzB,CAAC;AACF;AAEA,OAAO,eAAeK,YAAYA,CAACnB,UAAsB,EAAEG,QAAgB,EAAiB;EAC3F,MAAMH,UAAU,CAACC,OAAO,CAAC,0DAA0D,EAAE,CACpF,UAAU,EACVE,QAAQ,CACR,CAAC;AACH;;AAEA;AACA,OAAO,eAAeiB,UAAUA,CAACpB,UAAsB,EAAEG,QAAgB,EAAiB;EACzF,MAAMH,UAAU,CAACC,OAAO,CAAC,wCAAwC,EAAE,CAACE,QAAQ,CAAC,CAAC;AAC/E","ignoreList":[]}

package/lib/module/sqlite/connection.js

@@ -0,0 +1,206 @@
+"use strict";
+
+/**
+ * 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 { DiagnosticCodes } from "../contract/errors.js";
+import { raise } from "../diagnostics/errors.js";
+import { raiseNative } from "../diagnostics/map-native.js";
+import { fileSystem } from "../platform/fs.js";
+import { createTransactionQueue } from "./transaction-queue.js";
+import { engine } from "./native.js";
+
+/**
+ * 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.
+ */
+
+function splitPath(path) {
+  const index = path.lastIndexOf('/');
+  return index === -1 ? {
+    location: '',
+    name: path
+  } : {
+    location: path.slice(0, index),
+    name: path.slice(index + 1)
+  };
+}
+export async function openConnection(options) {
+  const {
+    location,
+    name
+  } = splitPath(options.path);
+  const encrypted = options.encryptionKey !== undefined;
+  try {
+    await fileSystem().mkdir(location);
+  } catch (error) {
+    raiseNative(error, {
+      operation: 'open'
+    });
+  }
+  let database;
+  try {
+    database = engine().open({
+      name,
+      location,
+      // Passing the key only when encryption is on keeps an unencrypted
+      // database from being opened as an encrypted one with an empty key,
+      // which SQLCipher accepts and which would produce a file neither
+      // posture can reopen.
+      ...(encrypted ? {
+        encryptionKey: options.encryptionKey
+      } : {})
+    });
+  } catch (error) {
+    raiseNative(error, {
+      operation: 'open',
+      encrypted
+    });
+  }
+  let closed = false;
+  let active = null;
+  const queue = createTransactionQueue();
+  const assertOpen = () => {
+    if (closed) {
+      raise(DiagnosticCodes.CLOSED_HANDLE, {
+        message: 'connection is closed'
+      });
+    }
+  };
+  const classify = sql => /^\s*select|^\s*pragma|^\s*explain/i.test(sql) ? 'read' : 'write';
+  const connection = {
+    path: options.path,
+    encrypted,
+    execute(sql, params = []) {
+      assertOpen();
+      // Never into an in-flight transaction: queued behind it instead. See
+      // the note at the top of this file.
+      return queue.run(async () => {
+        try {
+          return await database.execute(sql, params);
+        } catch (error) {
+          raiseNative(error, {
+            operation: classify(sql),
+            encrypted
+          });
+        }
+      });
+    },
+    async transaction(fn) {
+      assertOpen();
+      if (active) {
+        // Nested transactions would need savepoints and would let a
+        // partial rollback look like a full one. Refused rather than
+        // queued: a body that opened a second transaction would otherwise
+        // wait on itself forever.
+        raise(DiagnosticCodes.TRANSACTION_STATE, {
+          message: 'a transaction is already in flight on this connection'
+        });
+      }
+      return queue.runTransaction(async () => {
+        try {
+          return await database.transaction(async tx => {
+            active = tx;
+            let settled = false;
+            try {
+              return await fn({
+                execute: (sql, params = []) => {
+                  if (settled) {
+                    // After an explicit rollback the body is still running
+                    // inside the engine's callback. Its remaining statements
+                    // are refused, not run in autocommit (LDB-V1).
+                    raise(DiagnosticCodes.TRANSACTION_STATE, {
+                      message: 'transaction already rolled back'
+                    });
+                  }
+                  return tx.execute(sql, params);
+                },
+                rollback: async () => {
+                  await tx.rollback();
+                  settled = true;
+                }
+              });
+            } finally {
+              active = null;
+            }
+          });
+        } catch (error) {
+          raiseNative(error, {
+            operation: 'transaction',
+            encrypted
+          });
+        }
+      });
+    },
+    executeBatch(commands) {
+      assertOpen();
+      return queue.run(async () => {
+        try {
+          await database.executeBatch(commands);
+        } catch (error) {
+          raiseNative(error, {
+            operation: 'write',
+            encrypted
+          });
+        }
+      });
+    },
+    async close() {
+      if (closed) {
+        return;
+      }
+      closed = true;
+      try {
+        await database.close();
+      } catch {
+        // A close that fails leaves nothing for a caller to do, and
+        // reporting it would turn an orderly sign-out into an error.
+      }
+    }
+  };
+
+  // Write-ahead logging so a reader is not blocked by the writer — FR-045's
+  // "reads proceed while a write is in flight" is this pragma plus op-sqlite's
+  // single-writer serialization, not a lock this package maintains.
+  await connection.execute('PRAGMA journal_mode = WAL');
+  await connection.execute('PRAGMA foreign_keys = ON');
+  // Durability over speed: a half-written record after a crash is exactly
+  // what FR-039 promises never happens.
+  await connection.execute('PRAGMA synchronous = FULL');
+  return 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 async function assertReadable(connection) {
+  await connection.execute('SELECT count(*) AS n FROM sqlite_master');
+}
+//# sourceMappingURL=connection.js.map

package/lib/module/sqlite/connection.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["DiagnosticCodes","raise","raiseNative","fileSystem","createTransactionQueue","engine","splitPath","path","index","lastIndexOf","location","name","slice","openConnection","options","encrypted","encryptionKey","undefined","mkdir","error","operation","database","open","closed","active","queue","assertOpen","CLOSED_HANDLE","message","classify","sql","test","connection","execute","params","run","transaction","fn","TRANSACTION_STATE","runTransaction","tx","settled","rollback","executeBatch","commands","close","assertReadable"],"sourceRoot":"../../../src","sources":["sqlite/connection.ts"],"mappings":"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","ignoreList":[]}

package/lib/module/sqlite/index-coverage.js

@@ -0,0 +1,38 @@
+"use strict";
+
+/**
+ * "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 { collectionTable } from "../schema/declare.js";
+import { buildFilter, buildOrderBy } from "./sql-builder.js";
+import { declaredIndexName } from "./row-codec.js";
+const SCAN = /\bSCAN\b/i;
+const USING_INDEX = /USING\s+(COVERING\s+)?INDEX\s+"?([A-Za-z0-9_]+)"?/i;
+export async function explainQuery(executor, schema, query, sort) {
+  const filter = buildFilter(query?.filter);
+  const table = collectionTable(schema.name);
+  const sql = `EXPLAIN QUERY PLAN SELECT id FROM "${table}" WHERE ${filter.sql} ORDER BY ${buildOrderBy(sort)}`;
+  const result = await executor.execute(sql, filter.params);
+  const detail = result.rows.map(row => String(row.detail ?? row.DETAIL ?? '')).filter(Boolean).join('; ');
+  const match = USING_INDEX.exec(detail);
+  return {
+    collection: schema.name,
+    usesIndex: match !== null,
+    // Reported under the name the app declared, not the collection-scoped
+    // name it has in the file.
+    indexName: match?.[2] === undefined ? undefined : declaredIndexName(schema, match[2]),
+    detail: detail || (SCAN.test(detail) ? 'full table scan' : 'the engine returned no plan for this query')
+  };
+}
+//# sourceMappingURL=index-coverage.js.map

package/lib/module/sqlite/index-coverage.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["collectionTable","buildFilter","buildOrderBy","declaredIndexName","SCAN","USING_INDEX","explainQuery","executor","schema","query","sort","filter","table","name","sql","result","execute","params","detail","rows","map","row","String","DETAIL","Boolean","join","match","exec","collection","usesIndex","indexName","undefined","test"],"sourceRoot":"../../../src","sources":["sqlite/index-coverage.ts"],"mappings":";;AAAA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAIA,SAASA,eAAe,QAAQ,sBAAmB;AAEnD,SAASC,WAAW,EAAEC,YAAY,QAAQ,kBAAe;AACzD,SAASC,iBAAiB,QAAQ,gBAAa;AAE/C,MAAMC,IAAI,GAAG,WAAW;AACxB,MAAMC,WAAW,GAAG,oDAAoD;AAExE,OAAO,eAAeC,YAAYA,CACjCC,QAAkB,EAClBC,MAAwB,EACxBC,KAAwB,EACxBC,IAAe,EACgB;EAC/B,MAAMC,MAAM,GAAGV,WAAW,CAACQ,KAAK,EAAEE,MAAM,CAAC;EACzC,MAAMC,KAAK,GAAGZ,eAAe,CAACQ,MAAM,CAACK,IAAI,CAAC;EAC1C,MAAMC,GAAG,GAAG,sCAAsCF,KAAK,WAAWD,MAAM,CAACG,GAAG,aAAaZ,YAAY,CACpGQ,IACD,CAAC,EAAE;EAEH,MAAMK,MAAM,GAAG,MAAMR,QAAQ,CAACS,OAAO,CAACF,GAAG,EAAEH,MAAM,CAACM,MAAM,CAAC;EACzD,MAAMC,MAAM,GAAGH,MAAM,CAACI,IAAI,CACxBC,GAAG,CAACC,GAAG,IAAIC,MAAM,CAACD,GAAG,CAACH,MAAM,IAAIG,GAAG,CAACE,MAAM,IAAI,EAAE,CAAC,CAAC,CAClDZ,MAAM,CAACa,OAAO,CAAC,CACfC,IAAI,CAAC,IAAI,CAAC;EAEZ,MAAMC,KAAK,GAAGrB,WAAW,CAACsB,IAAI,CAACT,MAAM,CAAC;EACtC,OAAO;IACNU,UAAU,EAAEpB,MAAM,CAACK,IAAI;IACvBgB,SAAS,EAAEH,KAAK,KAAK,IAAI;IACzB;IACA;IACAI,SAAS,EAAEJ,KAAK,GAAG,CAAC,CAAC,KAAKK,SAAS,GAAGA,SAAS,GAAG5B,iBAAiB,CAACK,MAAM,EAAEkB,KAAK,CAAC,CAAC,CAAC,CAAC;IACrFR,MAAM,EACLA,MAAM,KACLd,IAAI,CAAC4B,IAAI,CAACd,MAAM,CAAC,GAAG,iBAAiB,GAAG,4CAA4C;EACvF,CAAC;AACF","ignoreList":[]}

package/lib/module/sqlite/native.js

@@ -0,0 +1,48 @@
+"use strict";
+
+/**
+ * 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.
+ */
+
+import { lazyPeer } from '@chipmobilesdk/rn-core';
+import { DiagnosticCodes } from "../contract/errors.js";
+import { StorageError } from "../diagnostics/errors.js";
+/** Loaded on first use (rn-core's lazy peer); a missing peer is `OPEN_FAILED`. */
+const sqlite = lazyPeer('@op-engineering/op-sqlite', () => {
+  // Inside `try`, so Metro bundles an app that leaves this optional peer out.
+  try {
+    return require('@op-engineering/op-sqlite');
+  } catch (cause) {
+    throw cause;
+  }
+});
+
+/** Swap the engine. Tests only; `null` goes back to the real one. */
+export function setEngine(next) {
+  sqlite.override(next ?? undefined);
+}
+export function engine() {
+  return sqlite.require((_peer, cause) => new StorageError(DiagnosticCodes.OPEN_FAILED, {
+    message: 'storage engine peer is not installed',
+    cause
+  }));
+}
+
+/**
+ * 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 function isEncryptionAvailable() {
+  const current = engine();
+  return typeof current.isSQLCipher === 'function' ? current.isSQLCipher() === true : false;
+}
+//# sourceMappingURL=native.js.map

package/lib/module/sqlite/native.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["lazyPeer","DiagnosticCodes","StorageError","sqlite","require","cause","setEngine","next","override","undefined","engine","_peer","OPEN_FAILED","message","isEncryptionAvailable","current","isSQLCipher"],"sourceRoot":"../../../src","sources":["sqlite/native.ts"],"mappings":";;AAAA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA,SAASA,QAAQ,QAAQ,wBAAwB;AAEjD,SAASC,eAAe,QAAQ,uBAAoB;AACpD,SAASC,YAAY,QAAQ,0BAAuB;AAmCpD;AACA,MAAMC,MAAM,GAAGH,QAAQ,CAAC,2BAA2B,EAAE,MAAM;EAC1D;EACA,IAAI;IACH,OAAOI,OAAO,CAAC,2BAA2B,CAAC;EAC5C,CAAC,CAAC,OAAOC,KAAK,EAAE;IACf,MAAMA,KAAK;EACZ;AACD,CAAC,CAAC;;AAEF;AACA,OAAO,SAASC,SAASA,CAACC,IAAmB,EAAQ;EACpDJ,MAAM,CAACK,QAAQ,CAACD,IAAI,IAAIE,SAAS,CAAC;AACnC;AAEA,OAAO,SAASC,MAAMA,CAAA,EAAW;EAChC,OAAOP,MAAM,CAACC,OAAO,CACpB,CAACO,KAAK,EAAEN,KAAK,KACZ,IAAIH,YAAY,CAACD,eAAe,CAACW,WAAW,EAAE;IAC7CC,OAAO,EAAE,sCAAsC;IAC/CR;EACD,CAAC,CACH,CAAC;AACF;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,OAAO,SAASS,qBAAqBA,CAAA,EAAY;EAChD,MAAMC,OAAO,GAAGL,MAAM,CAAC,CAAC;EACxB,OAAO,OAAOK,OAAO,CAACC,WAAW,KAAK,UAAU,GAAGD,OAAO,CAACC,WAAW,CAAC,CAAC,KAAK,IAAI,GAAG,KAAK;AAC1F","ignoreList":[]}