@chipmobilesdk/rn-local-db 0.3.0 → 0.5.0

package/lib/typescript/commonjs/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';
+export { memoryConformanceHooks, resetMemoryAdapter, seedRecords } from './memory-adapter/reset';
+export { clearFaults, injectFault, type FaultPoint, type FaultSpec } from './faults';
+/** Makes `openDatabase` and the deletion functions use the given adapter; `null` restores the device one. */
+export { setStorageAdapter } from '../adapter';
+export { runConformanceSuite, type ConformanceContext, type ConformanceHooks, type ConformanceOptions, type ConformanceSection, } from './conformance';
+//# sourceMappingURL=index.d.ts.map

package/lib/typescript/commonjs/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,kBAAkB,CAAC;AAClF,OAAO,EAAE,sBAAsB,EAAE,kBAAkB,EAAE,WAAW,EAAE,MAAM,wBAAwB,CAAC;AACjG,OAAO,EAAE,WAAW,EAAE,WAAW,EAAE,KAAK,UAAU,EAAE,KAAK,SAAS,EAAE,MAAM,UAAU,CAAC;AACrF,6GAA6G;AAC7G,OAAO,EAAE,iBAAiB,EAAE,MAAM,YAAY,CAAC;AAC/C,OAAO,EACN,mBAAmB,EACnB,KAAK,kBAAkB,EACvB,KAAK,gBAAgB,EACrB,KAAK,kBAAkB,EACvB,KAAK,kBAAkB,GACvB,MAAM,eAAe,CAAC"}

package/lib/typescript/commonjs/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';
+import type { MemoryScopeStore } from './store';
+import type { MemoryAdapterOptions } from './index';
+/** 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

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

@@ -0,0 +1 @@
+{"version":3,"file":"attachments.d.ts","sourceRoot":"","sources":["../../../../../src/testing/memory-adapter/attachments.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AACH,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,wBAAwB,CAAC;AAe1D,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,SAAS,CAAC;AAChD,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,SAAS,CAAC;AAEpD,iFAAiF;AACjF,MAAM,WAAW,QAAQ;IACxB,GAAG,CAAC,EAAE,EAAE,MAAM,GAAG,IAAI,CAAC;CACtB;AAED,MAAM,WAAW,oBAAoB;IACpC,KAAK,EAAE,gBAAgB,CAAC;IACxB,OAAO,EAAE,oBAAoB,CAAC;IAC9B,GAAG,EAAE,MAAM,MAAM,CAAC;IAClB,UAAU,EAAE,MAAM,IAAI,CAAC;CACvB;AAED,wBAAgB,uBAAuB,CAAC,IAAI,EAAE,oBAAoB,IAGzD,WAAW,QAAQ,KAAG,WAAW,CAwGzC"}

package/lib/typescript/commonjs/testing/memory-adapter/collection.d.ts

@@ -0,0 +1,19 @@
+/**
+ * Collection operations over the in-memory store.
+ *
+ * Every semantic decision — filtering, sorting, paging — is delegated to
+ * `query/`, the module the SQLite adapter also validates through. Anything
+ * decided here instead would be a place the two adapters could drift.
+ */
+import type { StorableRecordData } from '../../contract/record';
+import type { CollectionSchema } from '../../contract/schema';
+import type { CollectionOps } from '../../contract/transaction';
+import { type MemoryScopeStore } from './store';
+export type CollectionContext = {
+    store: MemoryScopeStore;
+    schema: CollectionSchema;
+    now: () => number;
+    assertOpen: () => void;
+};
+export declare function createMemoryCollection<T extends StorableRecordData>(context: CollectionContext): CollectionOps<T>;
+//# sourceMappingURL=collection.d.ts.map

package/lib/typescript/commonjs/testing/memory-adapter/collection.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"collection.d.ts","sourceRoot":"","sources":["../../../../../src/testing/memory-adapter/collection.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAIH,OAAO,KAAK,EAEX,kBAAkB,EAGlB,MAAM,uBAAuB,CAAC;AAC/B,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,uBAAuB,CAAC;AAC9D,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,4BAA4B,CAAC;AAShE,OAAO,EAAgD,KAAK,gBAAgB,EAAE,MAAM,SAAS,CAAC;AAE9F,MAAM,MAAM,iBAAiB,GAAG;IAC/B,KAAK,EAAE,gBAAgB,CAAC;IACxB,MAAM,EAAE,gBAAgB,CAAC;IACzB,GAAG,EAAE,MAAM,MAAM,CAAC;IAClB,UAAU,EAAE,MAAM,IAAI,CAAC;CACvB,CAAC;AASF,wBAAgB,sBAAsB,CAAC,CAAC,SAAS,kBAAkB,EAClE,OAAO,EAAE,iBAAiB,GACxB,aAAa,CAAC,CAAC,CAAC,CAyKlB"}

package/lib/typescript/commonjs/testing/memory-adapter/index.d.ts

@@ -0,0 +1,22 @@
+/**
+ * The in-memory adapter.
+ *
+ * Not a convenience: op-sqlite is native and unreachable from Jest, so this
+ * is the only way the package's own guarantees are testable in CI
+ * (research.md R8). Documented divergences are listed in the package README.
+ */
+import type { StorageAdapter } from '../../contract/adapter';
+export type MemoryAdapterOptions = {
+    /** Fixed clock, so timestamp assertions are deterministic. */
+    now?: () => number;
+    /**
+     * What a `sourcePath` attachment reads, as base64. There is no filesystem
+     * behind this adapter, so a test that writes attachments by path supplies
+     * the bytes here; without it such a write is refused with `STORAGE_ACCESS`.
+     */
+    readSourceFile?: (path: string) => Promise<string> | string;
+};
+export declare function createMemoryAdapter(options?: MemoryAdapterOptions): StorageAdapter;
+export { Budgets } from '../../contract/config';
+export { activeFaults } from '../faults';
+//# sourceMappingURL=index.d.ts.map

package/lib/typescript/commonjs/testing/memory-adapter/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/testing/memory-adapter/index.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAoBH,OAAO,KAAK,EAAkB,cAAc,EAAE,MAAM,wBAAwB,CAAC;AAoB7E,MAAM,MAAM,oBAAoB,GAAG;IAClC,8DAA8D;IAC9D,GAAG,CAAC,EAAE,MAAM,MAAM,CAAC;IACnB;;;;OAIG;IACH,cAAc,CAAC,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,OAAO,CAAC,MAAM,CAAC,GAAG,MAAM,CAAC;CAC5D,CAAC;AA0BF,wBAAgB,mBAAmB,CAAC,OAAO,GAAE,oBAAyB,GAAG,cAAc,CAwUtF;AAED,OAAO,EAAE,OAAO,EAAE,MAAM,uBAAuB,CAAC;AAChD,OAAO,EAAE,YAAY,EAAE,MAAM,WAAW,CAAC"}

package/lib/typescript/commonjs/testing/memory-adapter/migrations.d.ts

@@ -0,0 +1,11 @@
+/**
+ * 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 type { DatabaseConfig } from '../../contract/config';
+import type { MemoryScopeStore } from './store';
+export declare function runMigrations(store: MemoryScopeStore, config: DatabaseConfig, now: () => number): Promise<void>;
+//# sourceMappingURL=migrations.d.ts.map

package/lib/typescript/commonjs/testing/memory-adapter/migrations.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"migrations.d.ts","sourceRoot":"","sources":["../../../../../src/testing/memory-adapter/migrations.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,uBAAuB,CAAC;AAK5D,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,SAAS,CAAC;AAEhD,wBAAsB,aAAa,CAClC,KAAK,EAAE,gBAAgB,EACvB,MAAM,EAAE,cAAc,EACtB,GAAG,EAAE,MAAM,MAAM,GACf,OAAO,CAAC,IAAI,CAAC,CA0Ef"}

package/lib/typescript/commonjs/testing/memory-adapter/reset.d.ts

@@ -0,0 +1,23 @@
+/**
+ * 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 type { StorageAdapter } from '../../contract/adapter';
+import type { DatabaseConfig } from '../../contract/config';
+import type { RecordInput, StorableRecordData } from '../../contract/record';
+/**
+ * The conformance suite's "reach past the package" hooks, implemented for the
+ * in-memory store. On device the equivalent unlinks the file directly.
+ */
+export declare const memoryConformanceHooks: {
+    removeArtifactBehindTheScenes(scopeKey: string, attachmentId: string): Promise<void>;
+    removeReferenceBehindTheScenes(scopeKey: string, attachmentId: string): Promise<void>;
+};
+/** Return every in-memory database to a known-empty state (FR-093). */
+export declare function resetMemoryAdapter(_adapter?: StorageAdapter): Promise<void>;
+export declare function seedRecords<T extends StorableRecordData>(adapter: StorageAdapter, config: DatabaseConfig, collection: string, records: RecordInput<T>[]): Promise<void>;
+//# sourceMappingURL=reset.d.ts.map

package/lib/typescript/commonjs/testing/memory-adapter/reset.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"reset.d.ts","sourceRoot":"","sources":["../../../../../src/testing/memory-adapter/reset.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAEH,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,wBAAwB,CAAC;AAC7D,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,uBAAuB,CAAC;AAC5D,OAAO,KAAK,EAAE,WAAW,EAAE,kBAAkB,EAAE,MAAM,uBAAuB,CAAC;AAI7E;;;GAGG;AACH,eAAO,MAAM,sBAAsB;4CACY,MAAM,gBAAgB,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;6CAG3C,MAAM,gBAAgB,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;CAG3F,CAAC;AAEF,uEAAuE;AACvE,wBAAsB,kBAAkB,CAAC,QAAQ,CAAC,EAAE,cAAc,GAAG,OAAO,CAAC,IAAI,CAAC,CAGjF;AAED,wBAAsB,WAAW,CAAC,CAAC,SAAS,kBAAkB,EAC7D,OAAO,EAAE,cAAc,EACvB,MAAM,EAAE,cAAc,EACtB,UAAU,EAAE,MAAM,EAClB,OAAO,EAAE,WAAW,CAAC,CAAC,CAAC,EAAE,GACvB,OAAO,CAAC,IAAI,CAAC,CAUf"}

package/lib/typescript/commonjs/testing/memory-adapter/store.d.ts

@@ -0,0 +1,54 @@
+/**
+ * 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).
+ */
+import type { AttachmentReference } from '../../contract/attachment';
+import type { MigrationLedgerEntry } from '../../contract/migration';
+import type { StorableRecordData, StoredRecord } from '../../contract/record';
+import type { ScopeDeletionState } from '../../contract/scope';
+export type MemoryRow = {
+    id: string;
+    /** Serialized on write, parsed on read — the same payload-as-truth rule
+     * the SQLite adapter follows, so a mutation after write cannot leak in. */
+    payload: string;
+    createdAt?: number | undefined;
+    updatedAt?: number | undefined;
+    deletedAt?: number | null | undefined;
+};
+export type MemoryScopeStore = {
+    scopeKey: string;
+    schemaVersion: number;
+    ledger: Map<number, MigrationLedgerEntry>;
+    collections: Map<string, Map<string, MemoryRow>>;
+    attachments: Map<string, AttachmentReference>;
+    artifacts: Map<string, string>;
+    deletionState: ScopeDeletionState;
+    encrypted: boolean;
+    backupIncluded: boolean;
+};
+export type MemoryDatabase = {
+    name: string;
+    scopes: Map<string, MemoryScopeStore>;
+};
+export declare function databaseFor(name: string): MemoryDatabase;
+export declare function scopeStoreFor(name: string, scopeKey: string): MemoryScopeStore;
+export declare function existingScopeStore(name: string, scopeKey: string): MemoryScopeStore | undefined;
+export declare function dropScope(name: string, scopeKey: string): void;
+export declare function dropDatabase(name: string): void;
+/** Between tests (FR-093). */
+export declare function resetAllMemoryStores(): void;
+export declare function collectionMap(store: MemoryScopeStore, collection: string): Map<string, MemoryRow>;
+/**
+ * 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 declare function encodePayload(data: StorableRecordData): string;
+export declare function decodePayload<T extends StorableRecordData>(payload: string): T;
+export declare function toStoredRecord<T extends StorableRecordData>(row: MemoryRow): StoredRecord<T>;
+//# sourceMappingURL=store.d.ts.map

package/lib/typescript/commonjs/testing/memory-adapter/store.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"store.d.ts","sourceRoot":"","sources":["../../../../../src/testing/memory-adapter/store.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,2BAA2B,CAAC;AACrE,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,0BAA0B,CAAC;AACrE,OAAO,KAAK,EAAE,kBAAkB,EAAE,YAAY,EAAE,MAAM,uBAAuB,CAAC;AAC9E,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,sBAAsB,CAAC;AAE/D,MAAM,MAAM,SAAS,GAAG;IACvB,EAAE,EAAE,MAAM,CAAC;IACX;+EAC2E;IAC3E,OAAO,EAAE,MAAM,CAAC;IAChB,SAAS,CAAC,EAAE,MAAM,GAAG,SAAS,CAAC;IAC/B,SAAS,CAAC,EAAE,MAAM,GAAG,SAAS,CAAC;IAC/B,SAAS,CAAC,EAAE,MAAM,GAAG,IAAI,GAAG,SAAS,CAAC;CACtC,CAAC;AAEF,MAAM,MAAM,gBAAgB,GAAG;IAC9B,QAAQ,EAAE,MAAM,CAAC;IACjB,aAAa,EAAE,MAAM,CAAC;IACtB,MAAM,EAAE,GAAG,CAAC,MAAM,EAAE,oBAAoB,CAAC,CAAC;IAC1C,WAAW,EAAE,GAAG,CAAC,MAAM,EAAE,GAAG,CAAC,MAAM,EAAE,SAAS,CAAC,CAAC,CAAC;IACjD,WAAW,EAAE,GAAG,CAAC,MAAM,EAAE,mBAAmB,CAAC,CAAC;IAC9C,SAAS,EAAE,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IAC/B,aAAa,EAAE,kBAAkB,CAAC;IAClC,SAAS,EAAE,OAAO,CAAC;IACnB,cAAc,EAAE,OAAO,CAAC;CACxB,CAAC;AAEF,MAAM,MAAM,cAAc,GAAG;IAC5B,IAAI,EAAE,MAAM,CAAC;IACb,MAAM,EAAE,GAAG,CAAC,MAAM,EAAE,gBAAgB,CAAC,CAAC;CACtC,CAAC;AAIF,wBAAgB,WAAW,CAAC,IAAI,EAAE,MAAM,GAAG,cAAc,CAOxD;AAED,wBAAgB,aAAa,CAAC,IAAI,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,GAAG,gBAAgB,CAkB9E;AAED,wBAAgB,kBAAkB,CAAC,IAAI,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,GAAG,gBAAgB,GAAG,SAAS,CAE/F;AAED,wBAAgB,SAAS,CAAC,IAAI,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,GAAG,IAAI,CAE9D;AAED,wBAAgB,YAAY,CAAC,IAAI,EAAE,MAAM,GAAG,IAAI,CAE/C;AAED,8BAA8B;AAC9B,wBAAgB,oBAAoB,IAAI,IAAI,CAE3C;AAED,wBAAgB,aAAa,CAAC,KAAK,EAAE,gBAAgB,EAAE,UAAU,EAAE,MAAM,GAAG,GAAG,CAAC,MAAM,EAAE,SAAS,CAAC,CAOjG;AAED;;;;;;GAMG;AACH,wBAAgB,aAAa,CAAC,IAAI,EAAE,kBAAkB,GAAG,MAAM,CAE9D;AAED,wBAAgB,aAAa,CAAC,CAAC,SAAS,kBAAkB,EAAE,OAAO,EAAE,MAAM,GAAG,CAAC,CAE9E;AAED,wBAAgB,cAAc,CAAC,CAAC,SAAS,kBAAkB,EAAE,GAAG,EAAE,SAAS,GAAG,YAAY,CAAC,CAAC,CAAC,CAe5F"}

package/lib/typescript/module/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.js';
+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/module/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,qBAAkB,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/module/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.js';
+import type { CollectionSchema } from '../contract/schema.js';
+import type { CollectionOps } from '../contract/transaction.js';
+import type { Executor } from '../sqlite/connection.js';
+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/module/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,uBAAoB,CAAC;AAC5B,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,uBAAoB,CAAC;AAC3D,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,4BAAyB,CAAC;AAQ7D,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,yBAAsB,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/module/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.js';
+import type { DatabaseTargetConfig, ScopeTargetConfig } from '../contract/config.js';
+import type { ResolvedScope } from '../contract/scope.js';
+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/module/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,2BAAwB,CAAC;AAC9D,OAAO,KAAK,EAAE,oBAAoB,EAAE,iBAAiB,EAAE,MAAM,uBAAoB,CAAC;AAClF,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,sBAAmB,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/module/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.js';
+import type { EffectivePosture } from '../contract/backup.js';
+import type { DatabaseConfig } from '../contract/config.js';
+import type { CollectionSchema } from '../contract/schema.js';
+import type { ResolvedScope } from '../contract/scope.js';
+import type { KeyHandle } from '../crypto/key-provider.js';
+import type { StorageLayout } from '../platform/location.js';
+import type { Connection } from '../sqlite/connection.js';
+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/module/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,wBAAqB,CAAC;AAQvE,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,uBAAoB,CAAC;AAC3D,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,uBAAoB,CAAC;AAIzD,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,uBAAoB,CAAC;AAC3D,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,sBAAmB,CAAC;AAkBvD,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,2BAAwB,CAAC;AAIxD,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,yBAAsB,CAAC;AAG1D,OAAO,KAAK,EAAE,UAAU,EAAY,MAAM,yBAAsB,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/module/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.js';
+import type { DatabaseConfig, DatabaseTargetConfig, ScopeTargetConfig } from '../contract/config.js';
+import type { DeletionOutcome } from '../contract/attachment.js';
+/**
+ * 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/module/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,wBAAqB,CAAC;AAC1E,OAAO,KAAK,EAAE,cAAc,EAAE,oBAAoB,EAAE,iBAAiB,EAAE,MAAM,uBAAoB,CAAC;AAClG,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,2BAAwB,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/module/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.js';
+import type { DatabaseConfig } from '../contract/config.js';
+export type OpenOptions = {
+    now?: () => number;
+};
+export declare function openSqliteDatabase(config: DatabaseConfig, options?: OpenOptions): Promise<DatabaseHandle>;
+//# sourceMappingURL=lifecycle.d.ts.map

package/lib/typescript/module/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,wBAAqB,CAAC;AAC1D,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,uBAAoB,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/module/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.js';
+import type { Connection } from '../sqlite/connection.js';
+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/module/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,uBAAoB,CAAC;AAGzD,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,yBAAsB,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/module/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.js';
+import type { CollectionOps, Transaction } from '../contract/transaction.js';
+import type { Attachments } from '../contract/adapter.js';
+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/module/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,uBAAoB,CAAC;AAC7D,OAAO,KAAK,EAAE,aAAa,EAAE,WAAW,EAAE,MAAM,4BAAyB,CAAC;AAC1E,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,wBAAqB,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/module/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.js';
+import type { Executor } from '../sqlite/connection.js';
+import { type ArtifactContext } from './store.js';
+export declare function artifactAvailability(context: ArtifactContext, executor: Executor, id: string): Promise<AttachmentAvailability>;
+//# sourceMappingURL=availability.d.ts.map

package/lib/typescript/module/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,2BAAwB,CAAC;AAIrE,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,yBAAsB,CAAC;AAErD,OAAO,EAAiB,KAAK,eAAe,EAAE,MAAM,YAAS,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/module/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.js';
+import type { Executor } from '../sqlite/connection.js';
+import { type ArtifactContext, type DeferredUnlinks } from './store.js';
+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/module/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,2BAAwB,CAAC;AAE/E,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,yBAAsB,CAAC;AAErD,OAAO,EAGN,KAAK,eAAe,EACpB,KAAK,eAAe,EACpB,MAAM,YAAS,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/module/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.js';
+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/module/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,yBAAsB,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"}

package/lib/typescript/module/artifacts/reconcile.d.ts

@@ -0,0 +1,23 @@
+/**
+ * Reconciliation: the two ways the database and the disk can disagree.
+ *
+ * An **orphaned artifact** is a file with no reference — left by a rolled-back
+ * transaction, or by a crash between the write and the insert. A **dangling
+ * reference** is the reverse: a row pointing at a file the operating system
+ * reclaimed, or the user deleted through a file manager.
+ *
+ * App-triggered only (FR-073d). A background sweep would run during a user's
+ * session without their knowledge, delete files it believes are orphans, and
+ * have no way to distinguish "orphan" from "written by a transaction that has
+ * not committed yet". Handing the trigger to the app makes that an explicit
+ * decision at a moment the app knows is quiet.
+ */
+import type { ReconciliationReport } from '../contract/attachment.js';
+import type { Executor } from '../sqlite/connection.js';
+import { type ArtifactContext } from './store.js';
+export type ReconcileOptions = {
+    /** Off by default: deleting a user's file is never an implied yes. */
+    removeOrphans?: boolean;
+};
+export declare function reconcileArtifacts(context: ArtifactContext, executor: Executor, options?: ReconcileOptions): Promise<ReconciliationReport>;
+//# sourceMappingURL=reconcile.d.ts.map

package/lib/typescript/module/artifacts/reconcile.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"reconcile.d.ts","sourceRoot":"","sources":["../../../../src/artifacts/reconcile.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;GAaG;AAEH,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,2BAAwB,CAAC;AAGnE,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,yBAAsB,CAAC;AAErD,OAAO,EAAkB,KAAK,eAAe,EAAE,MAAM,YAAS,CAAC;AAE/D,MAAM,MAAM,gBAAgB,GAAG;IAC9B,sEAAsE;IACtE,aAAa,CAAC,EAAE,OAAO,CAAC;CACxB,CAAC;AAYF,wBAAsB,kBAAkB,CACvC,OAAO,EAAE,eAAe,EACxB,QAAQ,EAAE,QAAQ,EAClB,OAAO,GAAE,gBAAqB,GAC5B,OAAO,CAAC,oBAAoB,CAAC,CAqB/B"}