@chipmobilesdk/rn-local-db 0.4.0 → 0.5.0

package/lib/module/testing/memory-adapter/migrations.js

@@ -0,0 +1,122 @@
+"use strict";
+
+/**
+ * Migration execution for the in-memory adapter.
+ *
+ * Mirrors the on-device rules exactly, because migration behaviour is the
+ * thing consumers most need to test without a device: ordered, at most once
+ * per scope, atomic per step, and loud on failure (FR-047 to FR-057).
+ */
+
+import { DiagnosticCodes } from "../../contract/errors.js";
+import { raise } from "../../diagnostics/errors.js";
+import { throwIfFaulted } from "../faults.js";
+export async function runMigrations(store, config, now) {
+  const migrations = [...(config.migrations ?? [])].sort((a, b) => a.version - b.version);
+  if (store.schemaVersion > config.schemaVersion) {
+    // Opening anyway would mean a newer database read by older code, which
+    // silently drops whatever the newer schema added.
+    raise(DiagnosticCodes.SCHEMA_DOWNGRADE, {
+      message: 'recorded schema version is newer than the declared one',
+      detail: {
+        recordedVersion: store.schemaVersion,
+        version: config.schemaVersion
+      }
+    });
+  }
+  for (const migration of migrations) {
+    if (migration.version <= store.schemaVersion) {
+      continue;
+    }
+    const snapshot = new Map([...store.collections].map(([name, rows]) => [name, new Map(rows)]));
+    try {
+      throwIfFaulted('migration');
+      // A migration gets collection access but no handle-level surface:
+      // it must not open another scope or start a nested transaction.
+      const context = {
+        collection: name => {
+          if (!store.collections.has(name)) {
+            store.collections.set(name, new Map());
+          }
+          return migrationCollection(store, name);
+        },
+        abort: async () => {
+          throw new Error('migration aborted');
+        },
+        execute: async () => {
+          // The memory adapter has no SQL. Documented divergence.
+        }
+      };
+      await migration.migrate(context);
+      store.schemaVersion = migration.version;
+      store.ledger.set(migration.version, {
+        version: migration.version,
+        attemptedAt: now(),
+        outcome: 'applied'
+      });
+    } catch (error) {
+      // Leave the recorded version untouched so the next open retries
+      // from the same place rather than skipping ahead (FR-051).
+      store.collections = snapshot;
+      store.ledger.set(migration.version, {
+        version: migration.version,
+        attemptedAt: now(),
+        outcome: 'failed',
+        failureCode: error.code ?? DiagnosticCodes.MIGRATION_FAILED
+      });
+      raise(DiagnosticCodes.MIGRATION_FAILED, {
+        message: 'migration failed',
+        migration: {
+          recordedVersion: store.schemaVersion,
+          failingVersion: migration.version,
+          outcome: 'failed'
+        },
+        cause: error
+      });
+    }
+  }
+  if (migrations.length === 0) {
+    store.schemaVersion = config.schemaVersion;
+  }
+}
+function migrationCollection(store, name) {
+  const rows = store.collections.get(name);
+  return {
+    async insert(record) {
+      rows.set(record.id, {
+        id: record.id,
+        payload: JSON.stringify(record.data)
+      });
+      return {
+        operation: 'created',
+        id: record.id
+      };
+    },
+    async upsert(record) {
+      const existed = rows.has(record.id);
+      rows.set(record.id, {
+        id: record.id,
+        payload: JSON.stringify(record.data)
+      });
+      return {
+        operation: existed ? 'updated' : 'created',
+        id: record.id
+      };
+    },
+    async delete(id) {
+      rows.delete(id);
+      return {
+        operation: 'deleted',
+        id
+      };
+    },
+    async find(id) {
+      const row = rows.get(id);
+      return row ? {
+        id: row.id,
+        data: JSON.parse(row.payload)
+      } : null;
+    }
+  };
+}
+//# sourceMappingURL=migrations.js.map

package/lib/module/testing/memory-adapter/migrations.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["DiagnosticCodes","raise","throwIfFaulted","runMigrations","store","config","now","migrations","sort","a","b","version","schemaVersion","SCHEMA_DOWNGRADE","message","detail","recordedVersion","migration","snapshot","Map","collections","map","name","rows","context","collection","has","set","migrationCollection","abort","Error","execute","migrate","ledger","attemptedAt","outcome","error","failureCode","code","MIGRATION_FAILED","failingVersion","cause","length","get","insert","record","id","payload","JSON","stringify","data","operation","upsert","existed","delete","find","row","parse"],"sourceRoot":"../../../../src","sources":["testing/memory-adapter/migrations.ts"],"mappings":"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","ignoreList":[]}

package/lib/module/testing/memory-adapter/reset.js

@@ -0,0 +1,44 @@
+"use strict";
+
+/**
+ * Test lifecycle helpers.
+ *
+ * `seedRecords` deliberately goes through the same write operations
+ * production code uses (FR-094). Seeding by poking the store directly would
+ * skip budget checks and timestamp handling, so tests would pass against data
+ * the package would have refused to store.
+ */
+
+import { clearFaults } from "../faults.js";
+import { existingScopeStore, resetAllMemoryStores } from "./store.js";
+
+/**
+ * The conformance suite's "reach past the package" hooks, implemented for the
+ * in-memory store. On device the equivalent unlinks the file directly.
+ */
+export const memoryConformanceHooks = {
+  async removeArtifactBehindTheScenes(scopeKey, attachmentId) {
+    existingScopeStore('conformance', scopeKey)?.artifacts.delete(attachmentId);
+  },
+  async removeReferenceBehindTheScenes(scopeKey, attachmentId) {
+    existingScopeStore('conformance', scopeKey)?.attachments.delete(attachmentId);
+  }
+};
+
+/** Return every in-memory database to a known-empty state (FR-093). */
+export async function resetMemoryAdapter(_adapter) {
+  resetAllMemoryStores();
+  clearFaults();
+}
+export async function seedRecords(adapter, config, collection, records) {
+  const handle = await adapter.open(config);
+  try {
+    const ops = handle.collection(collection);
+    for (const record of records) {
+      await ops.upsert(record);
+    }
+  } finally {
+    await handle.close();
+  }
+}
+//# sourceMappingURL=reset.js.map

package/lib/module/testing/memory-adapter/reset.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["clearFaults","existingScopeStore","resetAllMemoryStores","memoryConformanceHooks","removeArtifactBehindTheScenes","scopeKey","attachmentId","artifacts","delete","removeReferenceBehindTheScenes","attachments","resetMemoryAdapter","_adapter","seedRecords","adapter","config","collection","records","handle","open","ops","record","upsert","close"],"sourceRoot":"../../../../src","sources":["testing/memory-adapter/reset.ts"],"mappings":";;AAAA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAKA,SAASA,WAAW,QAAQ,cAAW;AACvC,SAASC,kBAAkB,EAAEC,oBAAoB,QAAQ,YAAS;;AAElE;AACA;AACA;AACA;AACA,OAAO,MAAMC,sBAAsB,GAAG;EACrC,MAAMC,6BAA6BA,CAACC,QAAgB,EAAEC,YAAoB,EAAiB;IAC1FL,kBAAkB,CAAC,aAAa,EAAEI,QAAQ,CAAC,EAAEE,SAAS,CAACC,MAAM,CAACF,YAAY,CAAC;EAC5E,CAAC;EACD,MAAMG,8BAA8BA,CAACJ,QAAgB,EAAEC,YAAoB,EAAiB;IAC3FL,kBAAkB,CAAC,aAAa,EAAEI,QAAQ,CAAC,EAAEK,WAAW,CAACF,MAAM,CAACF,YAAY,CAAC;EAC9E;AACD,CAAC;;AAED;AACA,OAAO,eAAeK,kBAAkBA,CAACC,QAAyB,EAAiB;EAClFV,oBAAoB,CAAC,CAAC;EACtBF,WAAW,CAAC,CAAC;AACd;AAEA,OAAO,eAAea,WAAWA,CAChCC,OAAuB,EACvBC,MAAsB,EACtBC,UAAkB,EAClBC,OAAyB,EACT;EAChB,MAAMC,MAAM,GAAG,MAAMJ,OAAO,CAACK,IAAI,CAACJ,MAAM,CAAC;EACzC,IAAI;IACH,MAAMK,GAAG,GAAGF,MAAM,CAACF,UAAU,CAAIA,UAAU,CAAC;IAC5C,KAAK,MAAMK,MAAM,IAAIJ,OAAO,EAAE;MAC7B,MAAMG,GAAG,CAACE,MAAM,CAACD,MAAM,CAAC;IACzB;EACD,CAAC,SAAS;IACT,MAAMH,MAAM,CAACK,KAAK,CAAC,CAAC;EACrB;AACD","ignoreList":[]}

package/lib/module/testing/memory-adapter/store.js

@@ -0,0 +1,94 @@
+"use strict";
+
+/**
+ * The in-memory store behind the test adapter.
+ *
+ * Scope isolation is structural here for the same reason it is on device: one
+ * store per scope, held in a registry keyed by scope digest. A handle holds a
+ * reference to its own store and has no way to reach another (FR-011).
+ */
+
+const databases = new Map();
+export function databaseFor(name) {
+  let database = databases.get(name);
+  if (!database) {
+    database = {
+      name,
+      scopes: new Map()
+    };
+    databases.set(name, database);
+  }
+  return database;
+}
+export function scopeStoreFor(name, scopeKey) {
+  const database = databaseFor(name);
+  let store = database.scopes.get(scopeKey);
+  if (!store) {
+    store = {
+      scopeKey,
+      schemaVersion: 0,
+      ledger: new Map(),
+      collections: new Map(),
+      attachments: new Map(),
+      artifacts: new Map(),
+      deletionState: 'active',
+      encrypted: false,
+      backupIncluded: false
+    };
+    database.scopes.set(scopeKey, store);
+  }
+  return store;
+}
+export function existingScopeStore(name, scopeKey) {
+  return databases.get(name)?.scopes.get(scopeKey);
+}
+export function dropScope(name, scopeKey) {
+  databases.get(name)?.scopes.delete(scopeKey);
+}
+export function dropDatabase(name) {
+  databases.delete(name);
+}
+
+/** Between tests (FR-093). */
+export function resetAllMemoryStores() {
+  databases.clear();
+}
+export function collectionMap(store, collection) {
+  let rows = store.collections.get(collection);
+  if (!rows) {
+    rows = new Map();
+    store.collections.set(collection, rows);
+  }
+  return rows;
+}
+
+/**
+ * Deep copy through serialization on the way in and out.
+ *
+ * The same discipline as the SQLite adapter's payload column: a consumer that
+ * mutates the object it handed us must not change what is stored (FR-022),
+ * and what we hand back must not be a live reference into the store.
+ */
+export function encodePayload(data) {
+  return JSON.stringify(data ?? {});
+}
+export function decodePayload(payload) {
+  return JSON.parse(payload);
+}
+export function toStoredRecord(row) {
+  const record = {
+    id: row.id,
+    data: decodePayload(row.payload)
+  };
+  if (row.createdAt !== undefined) {
+    record.createdAt = row.createdAt;
+  }
+  if (row.updatedAt !== undefined) {
+    record.updatedAt = row.updatedAt;
+  }
+  if (row.deletedAt !== undefined) {
+    record.deletedAt = row.deletedAt;
+  }
+  return record;
+}
+//# sourceMappingURL=store.js.map

package/lib/module/testing/memory-adapter/store.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["databases","Map","databaseFor","name","database","get","scopes","set","scopeStoreFor","scopeKey","store","schemaVersion","ledger","collections","attachments","artifacts","deletionState","encrypted","backupIncluded","existingScopeStore","dropScope","delete","dropDatabase","resetAllMemoryStores","clear","collectionMap","collection","rows","encodePayload","data","JSON","stringify","decodePayload","payload","parse","toStoredRecord","row","record","id","createdAt","undefined","updatedAt","deletedAt"],"sourceRoot":"../../../../src","sources":["testing/memory-adapter/store.ts"],"mappings":"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","ignoreList":[]}

package/lib/typescript/commonjs/adapter/budgets.d.ts

@@ -0,0 +1,19 @@
+/**
+ * Where the FR-088 budgets are actually enforced.
+ *
+ * The checks live in `query/budgets.ts` so both adapters share them; this
+ * module is the adapter-layer entry point, and exists so there is one place
+ * to answer "which budgets are hard?" — per-record size, batch size, page
+ * size, and artifact size, each with a typed error (FR-088a).
+ *
+ * The rest are soft by design. Exceeding 100,000 records in a collection is
+ * slow, not an error, and refusing the 100,001st write would destroy data an
+ * app already holds. Degraded behavior is documented in the README instead.
+ */
+import { assertArtifactWithinBudget, assertBatchWithinBudget, assertRecordWithinBudget, serializedSize } from '../query/budgets';
+export { assertArtifactWithinBudget, assertBatchWithinBudget, assertRecordWithinBudget, serializedSize, };
+export declare function acquireHandleSlot(): void;
+export declare function releaseHandleSlot(): void;
+/** Between tests. */
+export declare function resetHandleSlots(): void;
+//# sourceMappingURL=budgets.d.ts.map

package/lib/typescript/commonjs/adapter/budgets.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"budgets.d.ts","sourceRoot":"","sources":["../../../../src/adapter/budgets.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AAKH,OAAO,EACN,0BAA0B,EAC1B,uBAAuB,EACvB,wBAAwB,EACxB,cAAc,EACd,MAAM,kBAAkB,CAAC;AAE1B,OAAO,EACN,0BAA0B,EAC1B,uBAAuB,EACvB,wBAAwB,EACxB,cAAc,GACd,CAAC;AAYF,wBAAgB,iBAAiB,IAAI,IAAI,CAQxC;AAED,wBAAgB,iBAAiB,IAAI,IAAI,CAExC;AAED,qBAAqB;AACrB,wBAAgB,gBAAgB,IAAI,IAAI,CAEvC"}

package/lib/typescript/commonjs/adapter/collection.d.ts

@@ -0,0 +1,25 @@
+/**
+ * Collection operations against a SQLite executor.
+ *
+ * The executor is either the connection or the transaction in flight on it,
+ * which is what gives read-your-own-writes for free (FR-043): a read inside a
+ * transaction runs on the same handle that made the writes, so it sees them,
+ * and a reader outside does not.
+ *
+ * Every semantic decision that could differ between the two adapters —
+ * which operators mean what, how nulls sort, what a cursor points at — is
+ * delegated to `query/`. This file decides only how to say it in SQL.
+ */
+import type { StorableRecordData } from '../contract/record';
+import type { CollectionSchema } from '../contract/schema';
+import type { CollectionOps } from '../contract/transaction';
+import type { Executor } from '../sqlite/connection';
+export type SqlCollectionContext = {
+    /** Resolved per call, so a transaction can swap in its own executor. */
+    executor(): Executor;
+    schema: CollectionSchema;
+    now(): number;
+    assertUsable(): void;
+};
+export declare function createSqlCollection<T extends StorableRecordData>(context: SqlCollectionContext): CollectionOps<T>;
+//# sourceMappingURL=collection.d.ts.map

package/lib/typescript/commonjs/adapter/collection.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"collection.d.ts","sourceRoot":"","sources":["../../../../src/adapter/collection.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AAIH,OAAO,KAAK,EAEX,kBAAkB,EAGlB,MAAM,oBAAoB,CAAC;AAC5B,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,oBAAoB,CAAC;AAC3D,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,yBAAyB,CAAC;AAQ7D,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,sBAAsB,CAAC;AAOrD,MAAM,MAAM,oBAAoB,GAAG;IAClC,wEAAwE;IACxE,QAAQ,IAAI,QAAQ,CAAC;IACrB,MAAM,EAAE,gBAAgB,CAAC;IACzB,GAAG,IAAI,MAAM,CAAC;IACd,YAAY,IAAI,IAAI,CAAC;CACrB,CAAC;AAWF,wBAAgB,mBAAmB,CAAC,CAAC,SAAS,kBAAkB,EAC/D,OAAO,EAAE,oBAAoB,GAC3B,aAAa,CAAC,CAAC,CAAC,CA0NlB"}

package/lib/typescript/commonjs/adapter/deletion.d.ts

@@ -0,0 +1,48 @@
+/**
+ * Deletion, and the ordering that makes an interrupted one visible.
+ *
+ * These are module-level functions rather than handle methods because they
+ * must work whether or not a handle is open on the target (FR-059) — a
+ * sign-out that already closed the handle still has to be able to delete, and
+ * an app recovering from a crash has no handle to call a method on.
+ *
+ * The order is: **mark `deleting` first, clear the catalog row last**
+ * (FR-061, FR-063). A crash at any point in between leaves the flag set, so
+ * the next open reports a scope mid-deletion rather than presenting it as
+ * complete. Clearing the row first would be the natural way to write this and
+ * would produce exactly the failure FR-063 exists to prevent: an
+ * interruption that looks like a success, leaving a user's data on disk after
+ * they asked for it to be gone.
+ *
+ * Nothing here ever runs on its own. No expiry, no sweep, no deletion on
+ * close or on app upgrade (FR-058) — the package deletes when asked, where
+ * asked, and not otherwise.
+ */
+import type { DeletionOutcome } from '../contract/attachment';
+import type { DatabaseTargetConfig, ScopeTargetConfig } from '../contract/config';
+import type { ResolvedScope } from '../contract/scope';
+export declare function markScopeInvalidated(name: string, scopeKey: string): void;
+export declare function clearScopeInvalidation(name: string, scopeKey: string): void;
+export declare function isScopeInvalidated(name: string, scopeKey: string): boolean;
+export declare function clearAllInvalidations(): void;
+/** Returns the function that takes the handle out of the registry again. */
+export declare function registerOpenHandle(name: string, scopeKey: string, revoke: () => Promise<void>): () => void;
+/** Deleting a scope that holds nothing is success, not an error (FR-062). */
+export declare function emptyOutcome(scope?: ResolvedScope): DeletionOutcome;
+/**
+ * Remove one scope's data. Every collection in that scope, and nothing
+ * outside it (FR-059, SC-012).
+ */
+export declare function deleteScopeData(config: ScopeTargetConfig): Promise<DeletionOutcome>;
+/**
+ * Discard one scope and leave it ready for a clean first-run migration
+ * (FR-057a).
+ *
+ * Destructive, separately named, and never reachable from `openDatabase`. An
+ * automatic fallback here would turn a bad migration shipped to production
+ * into silent data loss for every user who launched the app.
+ */
+export declare function resetScope(config: ScopeTargetConfig): Promise<DeletionOutcome>;
+/** Remove the whole database directory: catalog, every scope, every artifact. */
+export declare function deleteDatabase(config: DatabaseTargetConfig): Promise<DeletionOutcome>;
+//# sourceMappingURL=deletion.d.ts.map

package/lib/typescript/commonjs/adapter/deletion.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"deletion.d.ts","sourceRoot":"","sources":["../../../../src/adapter/deletion.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;GAmBG;AAEH,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,wBAAwB,CAAC;AAC9D,OAAO,KAAK,EAAE,oBAAoB,EAAE,iBAAiB,EAAE,MAAM,oBAAoB,CAAC;AAClF,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,mBAAmB,CAAC;AAyBvD,wBAAgB,oBAAoB,CAAC,IAAI,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,GAAG,IAAI,CAEzE;AAED,wBAAgB,sBAAsB,CAAC,IAAI,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,GAAG,IAAI,CAE3E;AAED,wBAAgB,kBAAkB,CAAC,IAAI,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,GAAG,OAAO,CAE1E;AAED,wBAAgB,qBAAqB,IAAI,IAAI,CAG5C;AAWD,4EAA4E;AAC5E,wBAAgB,kBAAkB,CACjC,IAAI,EAAE,MAAM,EACZ,QAAQ,EAAE,MAAM,EAChB,MAAM,EAAE,MAAM,OAAO,CAAC,IAAI,CAAC,GACzB,MAAM,IAAI,CAWZ;AAmBD,6EAA6E;AAC7E,wBAAgB,YAAY,CAAC,KAAK,CAAC,EAAE,aAAa,GAAG,eAAe,CAQnE;AAmID;;;GAGG;AACH,wBAAgB,eAAe,CAAC,MAAM,EAAE,iBAAiB,GAAG,OAAO,CAAC,eAAe,CAAC,CAEnF;AAED;;;;;;;GAOG;AACH,wBAAgB,UAAU,CAAC,MAAM,EAAE,iBAAiB,GAAG,OAAO,CAAC,eAAe,CAAC,CAE9E;AAED,iFAAiF;AACjF,wBAAsB,cAAc,CAAC,MAAM,EAAE,oBAAoB,GAAG,OAAO,CAAC,eAAe,CAAC,CA6B3F"}

package/lib/typescript/commonjs/adapter/handle.d.ts

@@ -0,0 +1,30 @@
+/**
+ * The handle an open returns: collections, transactions, batches and
+ * attachments over one connection, bound to one scope.
+ *
+ * Scope is bound here and nowhere else. The handle carries its scope key and
+ * no operation on it accepts a scope argument, so there is no `switchScope`
+ * to misuse and no read that could address another scope (FR-008a, FR-015).
+ */
+import type { DatabaseHandle } from '../contract/adapter';
+import type { EffectivePosture } from '../contract/backup';
+import type { DatabaseConfig } from '../contract/config';
+import type { CollectionSchema } from '../contract/schema';
+import type { ResolvedScope } from '../contract/scope';
+import type { KeyHandle } from '../crypto/key-provider';
+import type { StorageLayout } from '../platform/location';
+import type { Connection } from '../sqlite/connection';
+export declare function schemaFor(schemas: ReadonlyMap<string, CollectionSchema>, name: string): CollectionSchema;
+export type HandleContext = {
+    config: DatabaseConfig;
+    connection: Connection;
+    key: KeyHandle | null;
+    layout: StorageLayout;
+    now(): number;
+    schemaVersion: number;
+    schemas: ReadonlyMap<string, CollectionSchema>;
+    scope: ResolvedScope;
+    posture: EffectivePosture;
+};
+export declare function buildHandle(context: HandleContext): DatabaseHandle;
+//# sourceMappingURL=handle.d.ts.map

package/lib/typescript/commonjs/adapter/handle.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"handle.d.ts","sourceRoot":"","sources":["../../../../src/adapter/handle.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAEH,OAAO,KAAK,EAAe,cAAc,EAAE,MAAM,qBAAqB,CAAC;AAQvE,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,oBAAoB,CAAC;AAC3D,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,oBAAoB,CAAC;AAIzD,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,oBAAoB,CAAC;AAC3D,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,mBAAmB,CAAC;AAkBvD,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,wBAAwB,CAAC;AAIxD,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,sBAAsB,CAAC;AAG1D,OAAO,KAAK,EAAE,UAAU,EAAY,MAAM,sBAAsB,CAAC;AAQjE,wBAAgB,SAAS,CACxB,OAAO,EAAE,WAAW,CAAC,MAAM,EAAE,gBAAgB,CAAC,EAC9C,IAAI,EAAE,MAAM,GACV,gBAAgB,CASlB;AAED,MAAM,MAAM,aAAa,GAAG;IAC3B,MAAM,EAAE,cAAc,CAAC;IACvB,UAAU,EAAE,UAAU,CAAC;IACvB,GAAG,EAAE,SAAS,GAAG,IAAI,CAAC;IACtB,MAAM,EAAE,aAAa,CAAC;IACtB,GAAG,IAAI,MAAM,CAAC;IACd,aAAa,EAAE,MAAM,CAAC;IACtB,OAAO,EAAE,WAAW,CAAC,MAAM,EAAE,gBAAgB,CAAC,CAAC;IAC/C,KAAK,EAAE,aAAa,CAAC;IACrB,OAAO,EAAE,gBAAgB,CAAC;CAC1B,CAAC;AAEF,wBAAgB,WAAW,CAAC,OAAO,EAAE,aAAa,GAAG,cAAc,CAoOlE"}

package/lib/typescript/commonjs/adapter/index.d.ts

@@ -0,0 +1,30 @@
+/**
+ * The public lifecycle functions.
+ *
+ * Scope deletion and reset are module-level rather than handle methods: they
+ * must work whether or not a handle is open on the target (FR-059), and
+ * `resetScope` in particular must never be reachable as a fallback from
+ * `openDatabase` (FR-057a).
+ *
+ * The active adapter is resolved lazily so a consuming app that only ever
+ * uses the in-memory adapter in tests never loads the native peers.
+ */
+import type { DatabaseHandle, StorageAdapter } from '../contract/adapter';
+import type { DatabaseConfig, DatabaseTargetConfig, ScopeTargetConfig } from '../contract/config';
+import type { DeletionOutcome } from '../contract/attachment';
+/**
+ * Swap the adapter. Intended for tests and for the demo app's in-memory
+ * mode; production code never calls this.
+ */
+export declare function setStorageAdapter(adapter: StorageAdapter | null): void;
+export declare function openDatabase(config: DatabaseConfig): Promise<DatabaseHandle>;
+export declare function deleteScopeData(config: ScopeTargetConfig): Promise<DeletionOutcome>;
+export declare function deleteDatabase(config: DatabaseTargetConfig): Promise<DeletionOutcome>;
+/**
+ * Destructive. Discards one scope's data and leaves it ready for a clean
+ * first-run migration. Named apart from `deleteScopeData` deliberately: one
+ * is a lifecycle operation, the other is an admission that a database is
+ * broken.
+ */
+export declare function resetScope(config: ScopeTargetConfig): Promise<DeletionOutcome>;
+//# sourceMappingURL=index.d.ts.map

package/lib/typescript/commonjs/adapter/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/adapter/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AAEH,OAAO,KAAK,EAAE,cAAc,EAAE,cAAc,EAAE,MAAM,qBAAqB,CAAC;AAC1E,OAAO,KAAK,EAAE,cAAc,EAAE,oBAAoB,EAAE,iBAAiB,EAAE,MAAM,oBAAoB,CAAC;AAClG,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,wBAAwB,CAAC;AAK9D;;;GAGG;AACH,wBAAgB,iBAAiB,CAAC,OAAO,EAAE,cAAc,GAAG,IAAI,GAAG,IAAI,CAEtE;AAkBD,wBAAgB,YAAY,CAAC,MAAM,EAAE,cAAc,GAAG,OAAO,CAAC,cAAc,CAAC,CAE5E;AAED,wBAAgB,eAAe,CAAC,MAAM,EAAE,iBAAiB,GAAG,OAAO,CAAC,eAAe,CAAC,CAEnF;AAED,wBAAgB,cAAc,CAAC,MAAM,EAAE,oBAAoB,GAAG,OAAO,CAAC,eAAe,CAAC,CAErF;AAED;;;;;GAKG;AACH,wBAAgB,UAAU,CAAC,MAAM,EAAE,iBAAiB,GAAG,OAAO,CAAC,eAAe,CAAC,CAE9E"}

package/lib/typescript/commonjs/adapter/lifecycle.d.ts

@@ -0,0 +1,25 @@
+/**
+ * Opening and closing a database.
+ *
+ * The order of operations here is the design, not an implementation detail:
+ *
+ * 1. **Validate everything first.** Configuration, scope, and the migration
+ *    chain are checked before a file is touched, so a developer error is
+ *    reported against an untouched database (FR-006, FR-053).
+ * 2. **Consult the catalog before opening the scope file.** A posture
+ *    mismatch is detectable there; discovering it from SQLCipher's "file is
+ *    not a database" would report corruption for what is actually an app
+ *    configuration change (FR-101).
+ * 3. **Migrate before returning.** Nothing observes a half-migrated schema,
+ *    because there is no handle to observe it with until the chain completes
+ *    (FR-055). A failure returns no handle at all (FR-050).
+ *
+ * The handle itself is built in `handle.ts`.
+ */
+import type { DatabaseHandle } from '../contract/adapter';
+import type { DatabaseConfig } from '../contract/config';
+export type OpenOptions = {
+    now?: () => number;
+};
+export declare function openSqliteDatabase(config: DatabaseConfig, options?: OpenOptions): Promise<DatabaseHandle>;
+//# sourceMappingURL=lifecycle.d.ts.map

package/lib/typescript/commonjs/adapter/lifecycle.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"lifecycle.d.ts","sourceRoot":"","sources":["../../../../src/adapter/lifecycle.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;GAiBG;AAEH,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,qBAAqB,CAAC;AAC1D,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,oBAAoB,CAAC;AAsBzD,MAAM,MAAM,WAAW,GAAG;IACzB,GAAG,CAAC,EAAE,MAAM,MAAM,CAAC;CACnB,CAAC;AAkDF,wBAAsB,kBAAkB,CACvC,MAAM,EAAE,cAAc,EACtB,OAAO,GAAE,WAAgB,GACvB,OAAO,CAAC,cAAc,CAAC,CA2FzB"}

package/lib/typescript/commonjs/adapter/schema-sync.d.ts

@@ -0,0 +1,19 @@
+/**
+ * Bringing the physical tables in line with the declared schema, and skipping
+ * that work when nothing changed (LDB-07, LDB-11).
+ *
+ * Until 0.4.0 every open ran the whole set — CREATE TABLE, PRAGMA table_info,
+ * CREATE INDEX per index, for every collection — some sixty native round-trips
+ * for ten collections, on the startup path. The applied schema is now recorded
+ * in `_meta`; an open whose declaration matches it runs no DDL at all.
+ */
+import type { DatabaseConfig } from '../contract/config';
+import type { Connection } from '../sqlite/connection';
+export interface SchemaSync {
+    /** True when the stored schema already matched, so `_meta` exists and no DDL ran. */
+    readonly unchanged: boolean;
+    /** Records the declaration as applied. Call once the open has succeeded. */
+    record(): Promise<void>;
+}
+export declare function syncSchema(connection: Connection, config: DatabaseConfig): Promise<SchemaSync>;
+//# sourceMappingURL=schema-sync.d.ts.map

package/lib/typescript/commonjs/adapter/schema-sync.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"schema-sync.d.ts","sourceRoot":"","sources":["../../../../src/adapter/schema-sync.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AACH,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,oBAAoB,CAAC;AAGzD,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,sBAAsB,CAAC;AAgHvD,MAAM,WAAW,UAAU;IAC1B,qFAAqF;IACrF,QAAQ,CAAC,SAAS,EAAE,OAAO,CAAC;IAC5B,4EAA4E;IAC5E,MAAM,IAAI,OAAO,CAAC,IAAI,CAAC,CAAC;CACxB;AAED,wBAAsB,UAAU,CAC/B,UAAU,EAAE,UAAU,EACtB,MAAM,EAAE,cAAc,GACpB,OAAO,CAAC,UAAU,CAAC,CAoBrB"}

package/lib/typescript/commonjs/adapter/transaction.d.ts

@@ -0,0 +1,32 @@
+/**
+ * The `Transaction` a consumer actually holds.
+ *
+ * Two rules live here rather than in either adapter, so both are held to the
+ * same standard:
+ *
+ * **Read-your-own-writes** (FR-043). Every collection reached through `tx`
+ * runs against the transaction's executor, so a read inside sees the writes
+ * made inside. A collection reached through the handle during a transaction
+ * would not, and handing one out would be a quiet correctness trap.
+ *
+ * **Terminal state is terminal** (FR-044). After a commit or an abort, using
+ * the transaction raises rather than silently writing outside it — the
+ * failure mode where a caller's cleanup code lands in the database after the
+ * rollback it was supposed to be part of.
+ */
+import type { StorableRecordData } from '../contract/record';
+import type { CollectionOps, Transaction } from '../contract/transaction';
+import type { Attachments } from '../contract/adapter';
+export type TransactionHost = {
+    collection<T extends StorableRecordData>(name: string): CollectionOps<T>;
+    attachments(): Attachments;
+    rollback(): Promise<void>;
+};
+export type ManagedTransaction = {
+    transaction: Transaction;
+    /** True once the body committed or aborted. */
+    isSettled(): boolean;
+    settle(): void;
+};
+export declare function createTransaction(host: TransactionHost): ManagedTransaction;
+//# sourceMappingURL=transaction.d.ts.map

package/lib/typescript/commonjs/adapter/transaction.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"transaction.d.ts","sourceRoot":"","sources":["../../../../src/adapter/transaction.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;GAeG;AAGH,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,oBAAoB,CAAC;AAC7D,OAAO,KAAK,EAAE,aAAa,EAAE,WAAW,EAAE,MAAM,yBAAyB,CAAC;AAC1E,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,qBAAqB,CAAC;AAGvD,MAAM,MAAM,eAAe,GAAG;IAC7B,UAAU,CAAC,CAAC,SAAS,kBAAkB,EAAE,IAAI,EAAE,MAAM,GAAG,aAAa,CAAC,CAAC,CAAC,CAAC;IACzE,WAAW,IAAI,WAAW,CAAC;IAC3B,QAAQ,IAAI,OAAO,CAAC,IAAI,CAAC,CAAC;CAC1B,CAAC;AAEF,MAAM,MAAM,kBAAkB,GAAG;IAChC,WAAW,EAAE,WAAW,CAAC;IACzB,+CAA+C;IAC/C,SAAS,IAAI,OAAO,CAAC;IACrB,MAAM,IAAI,IAAI,CAAC;CACf,CAAC;AAEF,wBAAgB,iBAAiB,CAAC,IAAI,EAAE,eAAe,GAAG,kBAAkB,CAkC3E"}

package/lib/typescript/commonjs/artifacts/availability.d.ts

@@ -0,0 +1,19 @@
+/**
+ * "Is this artifact still there?", answered without opening it.
+ *
+ * `stat()` and, for an encrypted artifact, the 22-byte header. Never a
+ * content byte and never a decryption (FR-073e, FR-107b). An availability
+ * check that decrypted would make a gallery screen showing fifty thumbnails
+ * decrypt fifty artifacts to answer a question none of them asked, and would
+ * put key material in play for an operation that does not need it.
+ *
+ * The four states are deliberately four rather than two. `missing` is data
+ * that is gone; `undecryptable` is data that exists under a key that does not
+ * open it, which is often recoverable and always a different conversation to
+ * have with the user (FR-107c).
+ */
+import type { AttachmentAvailability } from '../contract/attachment';
+import type { Executor } from '../sqlite/connection';
+import { type ArtifactContext } from './store';
+export declare function artifactAvailability(context: ArtifactContext, executor: Executor, id: string): Promise<AttachmentAvailability>;
+//# sourceMappingURL=availability.d.ts.map

package/lib/typescript/commonjs/artifacts/availability.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"availability.d.ts","sourceRoot":"","sources":["../../../../src/artifacts/availability.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;GAaG;AAEH,OAAO,KAAK,EAAE,sBAAsB,EAAE,MAAM,wBAAwB,CAAC;AAIrE,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,sBAAsB,CAAC;AAErD,OAAO,EAAiB,KAAK,eAAe,EAAE,MAAM,SAAS,CAAC;AAE9D,wBAAsB,oBAAoB,CACzC,OAAO,EAAE,eAAe,EACxB,QAAQ,EAAE,QAAQ,EAClB,EAAE,EAAE,MAAM,GACR,OAAO,CAAC,sBAAsB,CAAC,CAuCjC"}

package/lib/typescript/commonjs/artifacts/cascade.d.ts

@@ -0,0 +1,26 @@
+/**
+ * Cascading artifact removal.
+ *
+ * The package deletes the files, because the Q2 clarification made it the
+ * owner of them (FR-073c). That is the single riskiest thing this package
+ * does — POL-011(b)'s media-and-files row exists for it — so two rules hold
+ * without exception: every path goes through the boundary guard in
+ * `paths.ts`, and the outcome reports what was removed **and what could not
+ * be**, never a bare success (FR-071).
+ *
+ * A failed removal is reported rather than retried or swallowed. A file the
+ * package could not delete is still on disk holding the user's data, and an
+ * app that told them "deleted" would have said something untrue.
+ */
+import type { AttachmentOwner, DeletionOutcome } from '../contract/attachment';
+import type { Executor } from '../sqlite/connection';
+import { type ArtifactContext, type DeferredUnlinks } from './store';
+export type { DeferredUnlinks };
+/** Unlinks one artifact file. True when the file is gone afterwards, whoever removed it. */
+export declare function unlinkArtifact(path: string): Promise<boolean>;
+/**
+ * Everything belonging to one record, for the FR-070 cascade. Inside a
+ * transaction pass `deferred`: the files are removed only once it commits.
+ */
+export declare function cascadeForOwner(context: ArtifactContext, executor: Executor, owner: AttachmentOwner, deferred?: DeferredUnlinks): Promise<DeletionOutcome>;
+//# sourceMappingURL=cascade.d.ts.map

package/lib/typescript/commonjs/artifacts/cascade.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"cascade.d.ts","sourceRoot":"","sources":["../../../../src/artifacts/cascade.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;GAaG;AAEH,OAAO,KAAK,EAAE,eAAe,EAAE,eAAe,EAAE,MAAM,wBAAwB,CAAC;AAE/E,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,sBAAsB,CAAC;AAErD,OAAO,EAGN,KAAK,eAAe,EACpB,KAAK,eAAe,EACpB,MAAM,SAAS,CAAC;AAEjB,YAAY,EAAE,eAAe,EAAE,CAAC;AAEhC,4FAA4F;AAC5F,wBAAsB,cAAc,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,OAAO,CAAC,CAYnE;AAyCD;;;GAGG;AACH,wBAAsB,eAAe,CACpC,OAAO,EAAE,eAAe,EACxB,QAAQ,EAAE,QAAQ,EAClB,KAAK,EAAE,eAAe,EACtB,QAAQ,CAAC,EAAE,eAAe,GACxB,OAAO,CAAC,eAAe,CAAC,CAQ1B"}

package/lib/typescript/commonjs/artifacts/paths.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Every artifact path, resolved through one guard.
+ *
+ * POL-011(b) flags media-and-files as a risk precisely because this package
+ * deletes files from disk on cascade. The mitigation is structural rather
+ * than procedural: no code in `artifacts/` builds a path by string
+ * concatenation, and the one function that turns an attachment id into a path
+ * refuses anything escaping the managed root (FR-073, FR-073f).
+ *
+ * That is what makes SC-013a's filesystem tracing pass reliably rather than
+ * usually — there is no second path to audit.
+ */
+import { type StorageLayout } from '../platform/location';
+export declare function artifactsDirectory(layout: StorageLayout, scopeKey: string): string;
+export declare function artifactPath(layout: StorageLayout, scopeKey: string, attachmentId: string): string;
+//# sourceMappingURL=paths.d.ts.map

package/lib/typescript/commonjs/artifacts/paths.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"paths.d.ts","sourceRoot":"","sources":["../../../../src/artifacts/paths.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AAEH,OAAO,EAA2B,KAAK,aAAa,EAAE,MAAM,sBAAsB,CAAC;AAEnF,wBAAgB,kBAAkB,CAAC,MAAM,EAAE,aAAa,EAAE,QAAQ,EAAE,MAAM,GAAG,MAAM,CAElF;AAED,wBAAgB,YAAY,CAC3B,MAAM,EAAE,aAAa,EACrB,QAAQ,EAAE,MAAM,EAChB,YAAY,EAAE,MAAM,GAClB,MAAM,CAKR"}