@chipmobilesdk/rn-local-db 0.3.0 → 0.5.0

package/lib/typescript/module/platform/backup-android-verify.d.ts

@@ -0,0 +1,30 @@
+/**
+ * Android backup posture: verified and reported, never enforced.
+ *
+ * Android decides backup participation from `android:dataExtractionRules` in
+ * the app's manifest. That is build-time and app-owned, and this package
+ * authors no native code, so it cannot contribute an entry and cannot change
+ * the answer at runtime (research.md R5).
+ *
+ * What it can do is check the one thing that silently breaks the documented
+ * fix: the rule the README tells an app to ship addresses the `file` domain,
+ * which is the app's `files/` directory. If the managed root did not land
+ * under that directory, the app can ship the XML exactly as documented and
+ * still have an unprotected database. That mismatch is detectable here, and
+ * an app learning it from this report is the whole point of FR-111 — the
+ * alternative is learning it from an incident.
+ */
+import type { EffectivePosture } from '../contract/backup.js';
+import { type StorageLayout } from './location.js';
+export declare function isAndroid(): boolean;
+/** The `path` an app's exclusion rule must name for the root it actually got. */
+export declare function coveragePathFor(layout: StorageLayout): string | null;
+export declare function androidPosture(layout: StorageLayout, includeInPlatformBackup: boolean): EffectivePosture;
+/**
+ * The posture the handle reports (FR-111).
+ *
+ * Split by platform rather than smoothed over, because a consumer writing a
+ * privacy disclosure needs to know which of the two answers it is holding.
+ */
+export declare function effectivePostureFor(layout: StorageLayout, includeInPlatformBackup: boolean, iosPostureFor: (include: boolean) => EffectivePosture): EffectivePosture;
+//# sourceMappingURL=backup-android-verify.d.ts.map

package/lib/typescript/module/platform/backup-android-verify.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"backup-android-verify.d.ts","sourceRoot":"","sources":["../../../../src/platform/backup-android-verify.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;GAeG;AAIH,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,uBAAoB,CAAC;AAC3D,OAAO,EAAoC,KAAK,aAAa,EAAE,MAAM,eAAY,CAAC;AAElF,wBAAgB,SAAS,IAAI,OAAO,CAEnC;AAED,iFAAiF;AACjF,wBAAgB,eAAe,CAAC,MAAM,EAAE,aAAa,GAAG,MAAM,GAAG,IAAI,CAQpE;AAED,wBAAgB,cAAc,CAC7B,MAAM,EAAE,aAAa,EACrB,uBAAuB,EAAE,OAAO,GAC9B,gBAAgB,CA8BlB;AAED;;;;;GAKG;AACH,wBAAgB,mBAAmB,CAClC,MAAM,EAAE,aAAa,EACrB,uBAAuB,EAAE,OAAO,EAChC,aAAa,EAAE,CAAC,OAAO,EAAE,OAAO,KAAK,gBAAgB,GACnD,gBAAgB,CAKlB"}

package/lib/typescript/module/platform/backup-ios.d.ts

@@ -0,0 +1,26 @@
+/**
+ * iOS backup exclusion.
+ *
+ * `NSURLIsExcludedFromBackupKey` is set on the managed root at creation, and
+ * the attribute is inherited by everything beneath it — so one call covers
+ * the catalog, every scope database, and every artifact, including ones
+ * created years later. Setting it per file would leave a window in which a
+ * freshly written artifact is backed up before the attribute lands.
+ *
+ * This is the half of FR-109 the package can actually enforce. Android is
+ * manifest-owned; see backup-android-verify.ts and research.md R5.
+ */
+import type { EffectivePosture } from '../contract/backup.js';
+import type { StorageLayout } from './location.js';
+export declare function isIos(): boolean;
+/**
+ * Create the managed root with the exclusion attribute already on it.
+ *
+ * Idempotent: `mkdir` on an existing directory re-applies the attribute,
+ * which matters because an app that flips the posture between launches must
+ * get the new one without a reinstall.
+ */
+export declare function ensureManagedRoot(layout: StorageLayout, includeInPlatformBackup: boolean): Promise<void>;
+/** What the package can state about iOS, where it enforces rather than reports. */
+export declare function iosPosture(includeInPlatformBackup: boolean): EffectivePosture;
+//# sourceMappingURL=backup-ios.d.ts.map

package/lib/typescript/module/platform/backup-ios.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"backup-ios.d.ts","sourceRoot":"","sources":["../../../../src/platform/backup-ios.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AAIH,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,uBAAoB,CAAC;AAE3D,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,eAAY,CAAC;AAEhD,wBAAgB,KAAK,IAAI,OAAO,CAE/B;AAED;;;;;;GAMG;AACH,wBAAsB,iBAAiB,CACtC,MAAM,EAAE,aAAa,EACrB,uBAAuB,EAAE,OAAO,GAC9B,OAAO,CAAC,IAAI,CAAC,CAKf;AAED,mFAAmF;AACnF,wBAAgB,UAAU,CAAC,uBAAuB,EAAE,OAAO,GAAG,gBAAgB,CAO7E"}

package/lib/typescript/module/platform/bytes.d.ts

@@ -0,0 +1,36 @@
+/**
+ * Byte handling without Node's `Buffer`.
+ *
+ * Hermes has no global `Buffer`, and `react-native-quick-crypto` installs one
+ * only when the app calls its `install()` — which nothing in this package or its
+ * documentation asked for. Until 0.2.0 attachment writes and reads used the
+ * global anyway, so on a device every attachment operation threw. Everything
+ * here is plain `Uint8Array` and a self-contained base64 codec, identical on
+ * Hermes and in Node.
+ */
+/**
+ * Codecs Hermes and Node provide but React Native's type declarations omit.
+ * Read through this view so the package type-checks without DOM or Node types.
+ */
+interface HostCodecs {
+    atob?: (data: string) => string;
+    btoa?: (data: string) => string;
+    TextEncoder?: new () => {
+        encode(input: string): Uint8Array;
+    };
+    TextDecoder?: new () => {
+        decode(input: Uint8Array): string;
+    };
+}
+export declare const host: HostCodecs;
+export declare function base64ToBytes(base64: string): Uint8Array;
+export declare function bytesToBase64(bytes: Uint8Array): string;
+/** UTF-8 encoding. `TextEncoder` is in Hermes and Node; the loop is the fallback. */
+export declare function utf8Bytes(value: string): Uint8Array;
+/** UTF-8 decoding, the inverse of `utf8Bytes`. */
+export declare function utf8String(bytes: Uint8Array): string;
+export declare function concatBytes(parts: readonly Uint8Array[]): Uint8Array;
+/** The ASCII text of `length` bytes from `start`, for magic numbers. */
+export declare function asciiAt(bytes: Uint8Array, start: number, length: number): string;
+export {};
+//# sourceMappingURL=bytes.d.ts.map

package/lib/typescript/module/platform/bytes.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"bytes.d.ts","sourceRoot":"","sources":["../../../../src/platform/bytes.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AAcH;;;GAGG;AACH,UAAU,UAAU;IACnB,IAAI,CAAC,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,MAAM,CAAC;IAChC,IAAI,CAAC,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,MAAM,CAAC;IAChC,WAAW,CAAC,EAAE,UAAU;QAAE,MAAM,CAAC,KAAK,EAAE,MAAM,GAAG,UAAU,CAAA;KAAE,CAAC;IAC9D,WAAW,CAAC,EAAE,UAAU;QAAE,MAAM,CAAC,KAAK,EAAE,UAAU,GAAG,MAAM,CAAA;KAAE,CAAC;CAC9D;AAED,eAAO,MAAM,IAAI,EAA4B,UAAU,CAAC;AAOxD,wBAAgB,aAAa,CAAC,MAAM,EAAE,MAAM,GAAG,UAAU,CAkCxD;AAED,wBAAgB,aAAa,CAAC,KAAK,EAAE,UAAU,GAAG,MAAM,CAgCvD;AAED,qFAAqF;AACrF,wBAAgB,SAAS,CAAC,KAAK,EAAE,MAAM,GAAG,UAAU,CAUnD;AAED,kDAAkD;AAClD,wBAAgB,UAAU,CAAC,KAAK,EAAE,UAAU,GAAG,MAAM,CASpD;AAID,wBAAgB,WAAW,CAAC,KAAK,EAAE,SAAS,UAAU,EAAE,GAAG,UAAU,CASpE;AAED,wEAAwE;AACxE,wBAAgB,OAAO,CAAC,KAAK,EAAE,UAAU,EAAE,KAAK,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,GAAG,MAAM,CAMhF"}

package/lib/typescript/module/platform/fs.d.ts

@@ -0,0 +1,47 @@
+/**
+ * The filesystem peer, behind one lazy accessor.
+ *
+ * Required lazily for the same reason the engine is: a consuming app that
+ * only ever runs the in-memory adapter in tests must not have to install a
+ * native module to import this package. Confining the require to `platform/`
+ * also keeps the native surface four directories wide, which is the layering
+ * rule the ESLint config enforces.
+ */
+export type FileStat = {
+    path: string;
+    size: number;
+    mtime: number;
+    isFile(): boolean;
+    isDirectory(): boolean;
+};
+export type MkdirOptions = {
+    /** iOS only. Set at creation so nothing beneath it is ever backed up. */
+    NSURLIsExcludedFromBackupKey?: boolean;
+};
+/**
+ * Only what the package actually uses. The peer's upload and download
+ * helpers are deliberately absent from this type: the package must never
+ * make a network request (FR-084, SC-016), and a surface that cannot express
+ * one is a stronger guarantee than a rule that says not to.
+ */
+export type FileSystem = {
+    DocumentDirectoryPath: string;
+    mkdir(path: string, options?: MkdirOptions): Promise<void>;
+    writeFile(path: string, contents: string, encoding?: string): Promise<void>;
+    appendFile(path: string, contents: string, encoding?: string): Promise<void>;
+    readFile(path: string, encoding?: string): Promise<string>;
+    /** Chunked read at an offset — what FR-107a's flat memory bound rests on. */
+    read(path: string, length: number, position: number, encoding?: string): Promise<string>;
+    /** One native call, no bytes through JS: how an unencrypted file becomes an artifact. */
+    copyFile(from: string, into: string): Promise<void>;
+    stat(path: string): Promise<FileStat>;
+    readdir(path: string): Promise<string[]>;
+    unlink(path: string): Promise<void>;
+    exists(path: string): Promise<boolean>;
+};
+/** Swap the peer. Tests and the demo app's in-memory mode only; `null` restores it. */
+export declare function setFileSystem(module: FileSystem | null): void;
+export declare function fileSystem(): FileSystem;
+/** Remove a path, treating "already gone" as success (FR-062). */
+export declare function removeIfPresent(path: string): Promise<boolean>;
+//# sourceMappingURL=fs.d.ts.map

package/lib/typescript/module/platform/fs.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"fs.d.ts","sourceRoot":"","sources":["../../../../src/platform/fs.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAOH,MAAM,MAAM,QAAQ,GAAG;IACtB,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,EAAE,MAAM,CAAC;IACb,KAAK,EAAE,MAAM,CAAC;IACd,MAAM,IAAI,OAAO,CAAC;IAClB,WAAW,IAAI,OAAO,CAAC;CACvB,CAAC;AAEF,MAAM,MAAM,YAAY,GAAG;IAC1B,yEAAyE;IACzE,4BAA4B,CAAC,EAAE,OAAO,CAAC;CACvC,CAAC;AAEF;;;;;GAKG;AACH,MAAM,MAAM,UAAU,GAAG;IACxB,qBAAqB,EAAE,MAAM,CAAC;IAC9B,KAAK,CAAC,IAAI,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,YAAY,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;IAC3D,SAAS,CAAC,IAAI,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,EAAE,QAAQ,CAAC,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;IAC5E,UAAU,CAAC,IAAI,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,EAAE,QAAQ,CAAC,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;IAC7E,QAAQ,CAAC,IAAI,EAAE,MAAM,EAAE,QAAQ,CAAC,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC,CAAC;IAC3D,6EAA6E;IAC7E,IAAI,CAAC,IAAI,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,EAAE,QAAQ,CAAC,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC,CAAC;IACzF,yFAAyF;IACzF,QAAQ,CAAC,IAAI,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;IACpD,IAAI,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,QAAQ,CAAC,CAAC;IACtC,OAAO,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,EAAE,CAAC,CAAC;IACzC,MAAM,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;IACpC,MAAM,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,OAAO,CAAC,CAAC;CACvC,CAAC;AAYF,uFAAuF;AACvF,wBAAgB,aAAa,CAAC,MAAM,EAAE,UAAU,GAAG,IAAI,GAAG,IAAI,CAE7D;AAED,wBAAgB,UAAU,IAAI,UAAU,CAQvC;AAED,kEAAkE;AAClE,wBAAsB,eAAe,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,OAAO,CAAC,CAOpE"}

package/lib/typescript/module/platform/location.d.ts

@@ -0,0 +1,53 @@
+/**
+ * The managed storage area, and the single guard every filesystem call routes
+ * through.
+ *
+ * POL-011(b) flags media-and-files as a risk because this package deletes
+ * files from disk on cascade. The mitigation is that there is exactly one
+ * function that turns a caller's intent into a path, and it refuses anything
+ * outside the root. One choke point is what makes SC-013a's filesystem
+ * tracing pass reliably rather than usually.
+ */
+export declare const MANAGED_ROOT_NAME = "chipmobilesdk-localdb";
+export declare const CATALOG_FILE = "catalog.db";
+export declare const SCOPES_DIR = "scopes";
+export declare const DATA_FILE = "data.db";
+export declare const ARTIFACTS_DIR = "artifacts";
+/** Normalize separators and collapse redundant segments. No `..` survives. */
+export declare function normalizePath(path: string): string;
+export type StorageLayout = {
+    /** Absolute path to the managed root for one logical database. */
+    root: string;
+    catalogPath: string;
+    scopePath(scopeKey: string): string;
+    scopeDataPath(scopeKey: string): string;
+    scopeArtifactsPath(scopeKey: string): string;
+    artifactPath(scopeKey: string, attachmentId: string): string;
+};
+/**
+ * An attachment id must be a safe single path segment.
+ *
+ * Shared by both adapters rather than left to the one that touches a
+ * filesystem. The in-memory adapter has no paths to escape, but a consumer
+ * whose tests accept `../../etc/passwd` and whose device build refuses it has
+ * a test suite that stops predicting the device — which is the one thing the
+ * adapter exists to avoid (FR-096).
+ */
+export declare function assertValidAttachmentId(attachmentId: string): void;
+export declare function createLayout(documentDirectory: string, databaseName: string): StorageLayout;
+/**
+ * The layout for one logical database, rooted at the app's private documents
+ * directory.
+ *
+ * Resolved lazily through the filesystem peer rather than captured at module
+ * load, so importing this package does not require the peer to be installed —
+ * a consumer running only the in-memory adapter never reaches this function.
+ */
+export declare function layoutFor(databaseName: string): StorageLayout;
+/**
+ * The guard. Every read, write, and delete passes through this, and anything
+ * resolving outside the managed root is refused before it reaches the
+ * filesystem (FR-073, FR-073f).
+ */
+export declare function assertWithinManagedArea(layout: StorageLayout, candidate: string): string;
+//# sourceMappingURL=location.d.ts.map

package/lib/typescript/module/platform/location.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"location.d.ts","sourceRoot":"","sources":["../../../../src/platform/location.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AAMH,eAAO,MAAM,iBAAiB,0BAA0B,CAAC;AACzD,eAAO,MAAM,YAAY,eAAe,CAAC;AACzC,eAAO,MAAM,UAAU,WAAW,CAAC;AACnC,eAAO,MAAM,SAAS,YAAY,CAAC;AACnC,eAAO,MAAM,aAAa,cAAc,CAAC;AAEzC,8EAA8E;AAC9E,wBAAgB,aAAa,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,CAelD;AAED,MAAM,MAAM,aAAa,GAAG;IAC3B,kEAAkE;IAClE,IAAI,EAAE,MAAM,CAAC;IACb,WAAW,EAAE,MAAM,CAAC;IACpB,SAAS,CAAC,QAAQ,EAAE,MAAM,GAAG,MAAM,CAAC;IACpC,aAAa,CAAC,QAAQ,EAAE,MAAM,GAAG,MAAM,CAAC;IACxC,kBAAkB,CAAC,QAAQ,EAAE,MAAM,GAAG,MAAM,CAAC;IAC7C,YAAY,CAAC,QAAQ,EAAE,MAAM,EAAE,YAAY,EAAE,MAAM,GAAG,MAAM,CAAC;CAC7D,CAAC;AAWF;;;;;;;;GAQG;AACH,wBAAgB,uBAAuB,CAAC,YAAY,EAAE,MAAM,GAAG,IAAI,CAMlE;AAED,wBAAgB,YAAY,CAAC,iBAAiB,EAAE,MAAM,EAAE,YAAY,EAAE,MAAM,GAAG,aAAa,CA0B3F;AAED;;;;;;;GAOG;AACH,wBAAgB,SAAS,CAAC,YAAY,EAAE,MAAM,GAAG,aAAa,CAE7D;AAED;;;;GAIG;AACH,wBAAgB,uBAAuB,CAAC,MAAM,EAAE,aAAa,EAAE,SAAS,EAAE,MAAM,GAAG,MAAM,CAWxF"}

package/lib/typescript/module/query/budgets.d.ts

@@ -0,0 +1,23 @@
+/**
+ * Budget enforcement.
+ *
+ * Per-record size, page size, and batch size are HARD limits reported through
+ * typed errors (FR-088a). The rest are soft: exceeding them must not crash,
+ * hang, or drop data silently, and the degraded behavior is documented.
+ */
+import type { StorableRecordData } from '../contract/record.js';
+/**
+ * UTF-8 length of a string, counted rather than encoded: measuring a 256 KB
+ * record used to allocate a 256 KB byte array just to read its length.
+ */
+export declare function utf8Length(value: string): number;
+/** UTF-8 byte length of the serialized payload — what actually hits disk. */
+export declare function serializedSize(data: StorableRecordData): number;
+/**
+ * Checks the size budget and returns the serialized payload, so the write that
+ * follows stores this string instead of serializing the record a second time.
+ */
+export declare function assertRecordWithinBudget(collection: string, data: StorableRecordData): string;
+export declare function assertBatchWithinBudget(count: number): void;
+export declare function assertArtifactWithinBudget(id: string, size: number): void;
+//# sourceMappingURL=budgets.d.ts.map

package/lib/typescript/module/query/budgets.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"budgets.d.ts","sourceRoot":"","sources":["../../../../src/query/budgets.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAIH,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,uBAAoB,CAAC;AAG7D;;;GAGG;AACH,wBAAgB,UAAU,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,CAiBhD;AAED,6EAA6E;AAC7E,wBAAgB,cAAc,CAAC,IAAI,EAAE,kBAAkB,GAAG,MAAM,CAE/D;AAED;;;GAGG;AACH,wBAAgB,wBAAwB,CAAC,UAAU,EAAE,MAAM,EAAE,IAAI,EAAE,kBAAkB,GAAG,MAAM,CAa7F;AAED,wBAAgB,uBAAuB,CAAC,KAAK,EAAE,MAAM,GAAG,IAAI,CAO3D;AAED,wBAAgB,0BAA0B,CAAC,EAAE,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,GAAG,IAAI,CAWzE"}

package/lib/typescript/module/query/compare.d.ts

@@ -0,0 +1,42 @@
+/**
+ * Comparison and field access semantics.
+ *
+ * Defined once here, used by the in-memory adapter directly and by the SQL
+ * builder for validation and cursor construction. Two implementations of
+ * these rules would drift, and the drift would show up as a conformance
+ * divergence that hides a real bug (research.md R8).
+ */
+import type { FilterValue } from '../contract/query.js';
+import type { StorableRecordData, StorableValue } from '../contract/record.js';
+/**
+ * A field is one of three things, and the difference is the whole point of
+ * FR-019: present with a value, present and null, or absent.
+ */
+export type FieldLookup = {
+    present: true;
+    value: Exclude<StorableValue, null>;
+} | {
+    present: true;
+    value: null;
+} | {
+    present: false;
+};
+export declare function lookupField(data: StorableRecordData, field: string): FieldLookup;
+/**
+ * Ordering for values of the same declared type.
+ *
+ * Null sorts before every non-null value, matching SQLite's default so the
+ * two adapters agree without the SQL builder emitting NULLS FIRST/LAST
+ * clauses that older SQLite versions do not support.
+ */
+export declare function compareValues(a: FilterValue, b: FilterValue): number;
+/** Only primitives can be compared; a nested object is never a filter target. */
+export declare function asFilterValue(value: StorableValue): FilterValue | undefined;
+/**
+ * Byte order, not locale collation.
+ *
+ * A locale-aware sort would make the reported order depend on device
+ * settings, so two phones holding identical data would report it differently.
+ */
+export declare function byteOrder(a: string, b: string): number;
+//# sourceMappingURL=compare.d.ts.map

package/lib/typescript/module/query/compare.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"compare.d.ts","sourceRoot":"","sources":["../../../../src/query/compare.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAEH,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,sBAAmB,CAAC;AACrD,OAAO,KAAK,EAAE,kBAAkB,EAAE,aAAa,EAAE,MAAM,uBAAoB,CAAC;AAE5E;;;GAGG;AACH,MAAM,MAAM,WAAW,GACpB;IAAE,OAAO,EAAE,IAAI,CAAC;IAAC,KAAK,EAAE,OAAO,CAAC,aAAa,EAAE,IAAI,CAAC,CAAA;CAAE,GACtD;IAAE,OAAO,EAAE,IAAI,CAAC;IAAC,KAAK,EAAE,IAAI,CAAA;CAAE,GAC9B;IAAE,OAAO,EAAE,KAAK,CAAA;CAAE,CAAC;AAEtB,wBAAgB,WAAW,CAAC,IAAI,EAAE,kBAAkB,EAAE,KAAK,EAAE,MAAM,GAAG,WAAW,CAShF;AAED;;;;;;GAMG;AACH,wBAAgB,aAAa,CAAC,CAAC,EAAE,WAAW,EAAE,CAAC,EAAE,WAAW,GAAG,MAAM,CAyBpE;AAED,iFAAiF;AACjF,wBAAgB,aAAa,CAAC,KAAK,EAAE,aAAa,GAAG,WAAW,GAAG,SAAS,CAU3E;AAED;;;;;GAKG;AACH,wBAAgB,SAAS,CAAC,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,GAAG,MAAM,CAKtD"}

package/lib/typescript/module/query/cursor.d.ts

@@ -0,0 +1,27 @@
+/**
+ * Keyset pagination cursors.
+ *
+ * Keyset rather than OFFSET for two reasons, both of which SC-007 measures:
+ * OFFSET degrades linearly at the 100,000-record budget because the engine
+ * still walks the skipped rows, and it shifts pages under concurrent writes
+ * so a record can be skipped or returned twice. A cursor anchored to the last
+ * row's sort values has neither problem.
+ */
+import type { FilterValue, SortKey } from '../contract/query.js';
+import type { StoredRecord } from '../contract/record.js';
+export type CursorPayload = {
+    /** Sort key fields and directions, so a cursor cannot be reused across shapes. */
+    k: string;
+    /** The last row's values, in sort-key order. */
+    v: FilterValue[];
+};
+export declare function encodeCursor(record: StoredRecord, sort: SortKey[]): string;
+export declare function decodeCursor(cursor: string, sort: SortKey[]): FilterValue[];
+/**
+ * Is this record strictly after the cursor position, under the sort order?
+ *
+ * Lexicographic across the sort keys: equal on the first key means the second
+ * decides, and so on down to the id tiebreaker that guarantees a total order.
+ */
+export declare function isAfterCursor(record: StoredRecord, sort: SortKey[], anchor: FilterValue[]): boolean;
+//# sourceMappingURL=cursor.d.ts.map

package/lib/typescript/module/query/cursor.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"cursor.d.ts","sourceRoot":"","sources":["../../../../src/query/cursor.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAGH,OAAO,KAAK,EAAE,WAAW,EAAE,OAAO,EAAE,MAAM,sBAAmB,CAAC;AAC9D,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,uBAAoB,CAAC;AAMvD,MAAM,MAAM,aAAa,GAAG;IAC3B,kFAAkF;IAClF,CAAC,EAAE,MAAM,CAAC;IACV,gDAAgD;IAChD,CAAC,EAAE,WAAW,EAAE,CAAC;CACjB,CAAC;AAoBF,wBAAgB,YAAY,CAAC,MAAM,EAAE,YAAY,EAAE,IAAI,EAAE,OAAO,EAAE,GAAG,MAAM,CAM1E;AAED,wBAAgB,YAAY,CAAC,MAAM,EAAE,MAAM,EAAE,IAAI,EAAE,OAAO,EAAE,GAAG,WAAW,EAAE,CAqB3E;AAED;;;;;GAKG;AACH,wBAAgB,aAAa,CAC5B,MAAM,EAAE,YAAY,EACpB,IAAI,EAAE,OAAO,EAAE,EACf,MAAM,EAAE,WAAW,EAAE,GACnB,OAAO,CAeT"}

package/lib/typescript/module/query/filter.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Filter evaluation over a plain record.
+ *
+ * The in-memory adapter runs this directly. The SQLite adapter translates the
+ * same validated tree to SQL. Both must agree, which is why the semantics
+ * live here rather than in either of them.
+ */
+import type { FilterNode } from '../contract/query.js';
+import type { StorableRecordData } from '../contract/record.js';
+export declare function evaluateFilter(data: StorableRecordData, node: FilterNode): boolean;
+//# sourceMappingURL=filter.d.ts.map

package/lib/typescript/module/query/filter.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"filter.d.ts","sourceRoot":"","sources":["../../../../src/query/filter.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH,OAAO,KAAK,EAAE,UAAU,EAAe,MAAM,sBAAmB,CAAC;AACjE,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,uBAAoB,CAAC;AAO7D,wBAAgB,cAAc,CAAC,IAAI,EAAE,kBAAkB,EAAE,IAAI,EAAE,UAAU,GAAG,OAAO,CAiElF"}

package/lib/typescript/module/query/paginate.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Page assembly over already-filtered, already-sorted records.
+ *
+ * Shared so the in-memory adapter and the SQLite adapter produce identical
+ * pages, including the `hasMore` signal and when a cursor is emitted.
+ */
+import type { PageRequest, ResultPage, SortKey } from '../contract/query.js';
+import type { StorableRecordData, StoredRecord } from '../contract/record.js';
+export declare const DEFAULT_PAGE_SIZE = 50;
+export declare function resolvePageSize(page: PageRequest | undefined): number;
+/** Fetch one extra row to answer `hasMore` without a second count query. */
+export declare function fetchLimitFor(size: number): number;
+export declare function applyCursor<T extends StoredRecord>(records: T[], sort: SortKey[], cursor: string | undefined): T[];
+export declare function buildPage<T extends StorableRecordData>(records: StoredRecord<T>[], sort: SortKey[], size: number): ResultPage<T>;
+//# sourceMappingURL=paginate.d.ts.map

package/lib/typescript/module/query/paginate.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"paginate.d.ts","sourceRoot":"","sources":["../../../../src/query/paginate.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAGH,OAAO,KAAK,EAAE,WAAW,EAAE,UAAU,EAAE,OAAO,EAAE,MAAM,sBAAmB,CAAC;AAC1E,OAAO,KAAK,EAAE,kBAAkB,EAAE,YAAY,EAAE,MAAM,uBAAoB,CAAC;AAG3E,eAAO,MAAM,iBAAiB,KAAK,CAAC;AAEpC,wBAAgB,eAAe,CAAC,IAAI,EAAE,WAAW,GAAG,SAAS,GAAG,MAAM,CAErE;AAED,4EAA4E;AAC5E,wBAAgB,aAAa,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,CAElD;AAED,wBAAgB,WAAW,CAAC,CAAC,SAAS,YAAY,EACjD,OAAO,EAAE,CAAC,EAAE,EACZ,IAAI,EAAE,OAAO,EAAE,EACf,MAAM,EAAE,MAAM,GAAG,SAAS,GACxB,CAAC,EAAE,CAML;AAED,wBAAgB,SAAS,CAAC,CAAC,SAAS,kBAAkB,EACrD,OAAO,EAAE,YAAY,CAAC,CAAC,CAAC,EAAE,EAC1B,IAAI,EAAE,OAAO,EAAE,EACf,IAAI,EAAE,MAAM,GACV,UAAU,CAAC,CAAC,CAAC,CAWf"}

package/lib/typescript/module/query/sort.d.ts

@@ -0,0 +1,19 @@
+/**
+ * Sort ordering.
+ *
+ * The record id is always appended as the final sort key (FR-031). Without a
+ * tiebreaker, records with equal sort values come back in whatever order the
+ * engine happens to produce, which makes keyset pagination lose or repeat
+ * rows — the exact failure SC-007 forbids.
+ */
+import type { SortKey } from '../contract/query.js';
+import type { StoredRecord } from '../contract/record.js';
+import { asFilterValue } from './compare.js';
+export declare const ID_SORT_KEY: SortKey;
+/** Append `id ASC` unless the caller already sorted by it. */
+export declare function withStableTiebreaker(sort: SortKey[] | undefined): SortKey[];
+/** Sort values come from the record id or from a declared field. */
+export declare function sortValueOf(record: StoredRecord, field: string): ReturnType<typeof asFilterValue>;
+export declare function compareRecords(a: StoredRecord, b: StoredRecord, sort: SortKey[]): number;
+export declare function sortRecords<T extends StoredRecord>(records: T[], sort: SortKey[]): T[];
+//# sourceMappingURL=sort.d.ts.map

package/lib/typescript/module/query/sort.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sort.d.ts","sourceRoot":"","sources":["../../../../src/query/sort.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAEH,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,sBAAmB,CAAC;AACjD,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,uBAAoB,CAAC;AACvD,OAAO,EAAE,aAAa,EAA8B,MAAM,cAAW,CAAC;AAEtE,eAAO,MAAM,WAAW,EAAE,OAA2C,CAAC;AAEtE,8DAA8D;AAC9D,wBAAgB,oBAAoB,CAAC,IAAI,EAAE,OAAO,EAAE,GAAG,SAAS,GAAG,OAAO,EAAE,CAM3E;AAED,oEAAoE;AACpE,wBAAgB,WAAW,CAAC,MAAM,EAAE,YAAY,EAAE,KAAK,EAAE,MAAM,GAAG,UAAU,CAAC,OAAO,aAAa,CAAC,CAWjG;AAED,wBAAgB,cAAc,CAAC,CAAC,EAAE,YAAY,EAAE,CAAC,EAAE,YAAY,EAAE,IAAI,EAAE,OAAO,EAAE,GAAG,MAAM,CAYxF;AAED,wBAAgB,WAAW,CAAC,CAAC,SAAS,YAAY,EAAE,OAAO,EAAE,CAAC,EAAE,EAAE,IAAI,EAAE,OAAO,EAAE,GAAG,CAAC,EAAE,CAEtF"}

package/lib/typescript/module/query/validate.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Query validation, run before any SQL is built.
+ *
+ * Two things fall out of validating first: FR-034 is satisfied, and no
+ * consumer-supplied string ever reaches SQL construction — field names are
+ * resolved through the schema to a known column, and values bind as
+ * parameters. Injection stops being a thing to remember.
+ */
+import type { FilterNode, Query, SortKey } from '../contract/query.js';
+import type { CollectionSchema } from '../contract/schema.js';
+export declare function validateFilter(collection: CollectionSchema, node: FilterNode): void;
+export declare function validateSort(collection: CollectionSchema, sort: SortKey[]): void;
+export declare function validatePageSize(size: number): void;
+export declare function validateQuery(collection: CollectionSchema, query: Query | undefined): void;
+//# sourceMappingURL=validate.d.ts.map

package/lib/typescript/module/query/validate.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"validate.d.ts","sourceRoot":"","sources":["../../../../src/query/validate.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAIH,OAAO,KAAK,EAAE,UAAU,EAAe,KAAK,EAAE,OAAO,EAAE,MAAM,sBAAmB,CAAC;AACjF,OAAO,KAAK,EAAE,gBAAgB,EAAa,MAAM,uBAAoB,CAAC;AA0CtE,wBAAgB,cAAc,CAAC,UAAU,EAAE,gBAAgB,EAAE,IAAI,EAAE,UAAU,GAAG,IAAI,CA8EnF;AAED,wBAAgB,YAAY,CAAC,UAAU,EAAE,gBAAgB,EAAE,IAAI,EAAE,OAAO,EAAE,GAAG,IAAI,CAYhF;AAED,wBAAgB,gBAAgB,CAAC,IAAI,EAAE,MAAM,GAAG,IAAI,CAOnD;AAED,wBAAgB,aAAa,CAAC,UAAU,EAAE,gBAAgB,EAAE,KAAK,EAAE,KAAK,GAAG,SAAS,GAAG,IAAI,CAa1F"}

package/lib/typescript/module/schema/declare.d.ts

@@ -0,0 +1,20 @@
+/**
+ * Schema lookup helpers shared by both adapters.
+ *
+ * Declaring a field makes it queryable — it does not restrict what a record
+ * may contain. `isQueryable` is the single answer to "may a filter or sort
+ * reference this?", so both adapters reject the same field names (FR-034).
+ */
+import type { CollectionSchema, FieldDeclaration } from '../contract/schema.js';
+export type SchemaIndex = ReadonlyMap<string, CollectionSchema>;
+export declare function indexSchemas(collections: CollectionSchema[]): SchemaIndex;
+export declare function fieldOf(collection: CollectionSchema, name: string): FieldDeclaration | undefined;
+export declare function isQueryable(collection: CollectionSchema, name: string): boolean;
+export declare function hasSoftDelete(collection: CollectionSchema): boolean;
+export declare function hasTimestamps(collection: CollectionSchema): boolean;
+/** Column name for a projected queryable field. Prefixed to avoid colliding
+ * with the reserved columns (`id`, `payload`, `created_at`, ...). */
+export declare function projectedColumn(field: string): string;
+/** Table name for a collection, prefixed for the same reason. */
+export declare function collectionTable(name: string): string;
+//# sourceMappingURL=declare.d.ts.map

package/lib/typescript/module/schema/declare.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"declare.d.ts","sourceRoot":"","sources":["../../../../src/schema/declare.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH,OAAO,KAAK,EAAE,gBAAgB,EAAE,gBAAgB,EAAE,MAAM,uBAAoB,CAAC;AAE7E,MAAM,MAAM,WAAW,GAAG,WAAW,CAAC,MAAM,EAAE,gBAAgB,CAAC,CAAC;AAEhE,wBAAgB,YAAY,CAAC,WAAW,EAAE,gBAAgB,EAAE,GAAG,WAAW,CAEzE;AAED,wBAAgB,OAAO,CAAC,UAAU,EAAE,gBAAgB,EAAE,IAAI,EAAE,MAAM,GAAG,gBAAgB,GAAG,SAAS,CAEhG;AAED,wBAAgB,WAAW,CAAC,UAAU,EAAE,gBAAgB,EAAE,IAAI,EAAE,MAAM,GAAG,OAAO,CAE/E;AAED,wBAAgB,aAAa,CAAC,UAAU,EAAE,gBAAgB,GAAG,OAAO,CAEnE;AAED,wBAAgB,aAAa,CAAC,UAAU,EAAE,gBAAgB,GAAG,OAAO,CAEnE;AAED;qEACqE;AACrE,wBAAgB,eAAe,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,CAErD;AAED,iEAAiE;AACjE,wBAAgB,eAAe,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,CAEpD"}

package/lib/typescript/module/schema/validate-config.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Configuration validation.
+ *
+ * Runs to completion before any write and before any migration executes
+ * (FR-006, FR-053). Order matters: scope first, then collections, then the
+ * migration chain — so a consumer fixes the outermost problem first rather
+ * than chasing a downstream symptom.
+ */
+import { type DatabaseConfig } from '../contract/config.js';
+export declare function validateConfig(config: DatabaseConfig): void;
+//# sourceMappingURL=validate-config.d.ts.map

package/lib/typescript/module/schema/validate-config.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"validate-config.d.ts","sourceRoot":"","sources":["../../../../src/schema/validate-config.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAEH,OAAO,EAAW,KAAK,cAAc,EAAE,MAAM,uBAAoB,CAAC;AAiElE,wBAAgB,cAAc,CAAC,MAAM,EAAE,cAAc,GAAG,IAAI,CAiC3D"}

package/lib/typescript/module/scope/hash.d.ts

@@ -0,0 +1,24 @@
+/**
+ * Scope key derivation.
+ *
+ * The directory a scope lives in is named by the SHA-256 digest of its
+ * canonical descriptor, never by the components themselves. FR-014 requires
+ * scope components be treated as sensitive, and a directory named after an
+ * email address puts that address in plaintext on disk — visible even when
+ * the database itself is encrypted, and carried into any crash report that
+ * includes a file path.
+ *
+ * Hashing also removes filesystem charset and length limits from the problem,
+ * which is what lets validation reject rather than sanitize (research.md R2).
+ *
+ * Implemented in pure TypeScript rather than over a native crypto peer so the
+ * scope layer stays importable from anywhere in the package, including the
+ * in-memory adapter running under Jest.
+ *
+ * Verified against Node's own SHA-256 in scope-resolution.test.ts — a wrong
+ * digest would silently merge or split scopes, so it is checked against a
+ * reference implementation rather than against a snapshot of this one.
+ */
+export declare function utf8ByteLength(input: string): number;
+export declare function sha256Hex(input: string): string;
+//# sourceMappingURL=hash.d.ts.map

package/lib/typescript/module/scope/hash.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"hash.d.ts","sourceRoot":"","sources":["../../../../src/scope/hash.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;GAoBG;AAgDH,wBAAgB,cAAc,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,CAEpD;AAED,wBAAgB,SAAS,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,CA0D/C"}

package/lib/typescript/module/scope/normalize.d.ts

@@ -0,0 +1,46 @@
+/**
+ * Scope descriptor normalization.
+ *
+ * The package normalizes and validates; it never repairs. A component it
+ * cannot represent safely is an error (FR-013), because silently sanitizing
+ * one is how two different descriptors end up sharing a directory — which
+ * would be a cross-scope leak dressed up as a convenience.
+ */
+import type { ScopeDescriptor, ScopeKind } from '../contract/scope.js';
+/**
+ * Separates components in the canonical form.
+ *
+ * NUL rather than a printable character: a component containing the separator
+ * could forge another descriptor's canonical string, and every printable
+ * candidate occurs in legitimate identity data. Tenant names contain spaces,
+ * identifiers contain colons and slashes, emails contain "@" and ".". NUL
+ * occurs in none of them, so reserving it costs consumers nothing.
+ */
+export declare const COMPONENT_SEPARATOR = "\0";
+/**
+ * Control characters are rejected wholesale rather than only the separator.
+ * They have no place in an identity component, and they would be trouble in a
+ * log line or a diagnostic even where they could not forge a canonical
+ * string.
+ */
+export declare const CONTROL_CHARACTER: RegExp;
+export declare const MAX_COMPONENT_BYTES = 512;
+/** Fixed order, so the canonical form is stable across callers. */
+export declare const COMPONENT_ORDER: readonly ["kind", "id", "tenant", "app", "environment", "namespace"];
+export declare const SCOPE_KINDS: readonly ScopeKind[];
+/**
+ * NFC, trimmed, case preserved.
+ *
+ * Case is preserved deliberately: the package does not know whether a
+ * consumer's identity system is case-sensitive, and folding case would merge
+ * two scopes the app considers distinct.
+ */
+export declare function normalizeComponent(value: string): string;
+export type NormalizedScope = {
+    kind: ScopeKind;
+    components: Record<string, string>;
+    canonical: string;
+};
+/** Normalize without validating. Callers must validate first. */
+export declare function normalizeDescriptor(descriptor: ScopeDescriptor): NormalizedScope;
+//# sourceMappingURL=normalize.d.ts.map

package/lib/typescript/module/scope/normalize.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"normalize.d.ts","sourceRoot":"","sources":["../../../../src/scope/normalize.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAEH,OAAO,KAAK,EAAE,eAAe,EAAE,SAAS,EAAE,MAAM,sBAAmB,CAAC;AAEpE;;;;;;;;GAQG;AACH,eAAO,MAAM,mBAAmB,OAAW,CAAC;AAE5C;;;;;GAKG;AAEH,eAAO,MAAM,iBAAiB,QAA0B,CAAC;AAEzD,eAAO,MAAM,mBAAmB,MAAM,CAAC;AAEvC,mEAAmE;AACnE,eAAO,MAAM,eAAe,sEAAuE,CAAC;AAEpG,eAAO,MAAM,WAAW,EAAE,SAAS,SAAS,EAM3C,CAAC;AAEF;;;;;;GAMG;AACH,wBAAgB,kBAAkB,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,CAExD;AAED,MAAM,MAAM,eAAe,GAAG;IAC7B,IAAI,EAAE,SAAS,CAAC;IAChB,UAAU,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IACnC,SAAS,EAAE,MAAM,CAAC;CAClB,CAAC;AAEF,iEAAiE;AACjE,wBAAgB,mBAAmB,CAAC,UAAU,EAAE,eAAe,GAAG,eAAe,CAoBhF"}

package/lib/typescript/module/scope/validate.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Scope validation and resolution.
+ *
+ * Validate, never repair (FR-013). The package never invents, derives, or
+ * defaults an identity of its own (FR-008).
+ */
+import type { ResolvedScope, ScopeDescriptor } from '../contract/scope.js';
+export declare function validateDescriptor(descriptor: ScopeDescriptor | undefined | null): void;
+/**
+ * Deterministic: identical descriptors always resolve to the same scope, and
+ * descriptors differing in any component always resolve to different ones
+ * (FR-010).
+ */
+export declare function resolveScope(descriptor: ScopeDescriptor): ResolvedScope;
+//# sourceMappingURL=validate.d.ts.map

package/lib/typescript/module/scope/validate.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"validate.d.ts","sourceRoot":"","sources":["../../../../src/scope/validate.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAGH,OAAO,KAAK,EAAE,aAAa,EAAE,eAAe,EAAE,MAAM,sBAAmB,CAAC;AAqCxE,wBAAgB,kBAAkB,CAAC,UAAU,EAAE,eAAe,GAAG,SAAS,GAAG,IAAI,GAAG,IAAI,CAuBvF;AAED;;;;GAIG;AACH,wBAAgB,YAAY,CAAC,UAAU,EAAE,eAAe,GAAG,aAAa,CAOvE"}

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

@@ -0,0 +1,16 @@
+/**
+ * The on-device adapter.
+ *
+ * Deliberately a seam rather than an implementation. Everything it composes
+ * lives in `adapter/`, `migration/`, `artifacts/`, and this directory, so the
+ * in-memory adapter can be held to the same contract by the same conformance
+ * suite (FR-092) without either one being the "real" version the other
+ * approximates.
+ *
+ * Reached only through the lazy require in `adapter/index.ts`, so a consumer
+ * that runs the in-memory adapter in tests never loads the native peers.
+ */
+import type { StorageAdapter } from '../contract/adapter.js';
+import { type OpenOptions } from '../adapter/lifecycle.js';
+export declare function createSqliteAdapter(options?: OpenOptions): StorageAdapter;
+//# sourceMappingURL=adapter.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"adapter.d.ts","sourceRoot":"","sources":["../../../../src/sqlite/adapter.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AAEH,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,wBAAqB,CAAC;AAE1D,OAAO,EAAsB,KAAK,WAAW,EAAE,MAAM,yBAAsB,CAAC;AAE5E,wBAAgB,mBAAmB,CAAC,OAAO,GAAE,WAAgB,GAAG,cAAc,CAQ7E"}

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

@@ -0,0 +1,25 @@
+/**
+ * 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 type { CollectionSchema } from '../contract/schema.js';
+import type { BatchOperation, BatchOutcome } from '../contract/transaction.js';
+import type { Connection } from './connection.js';
+export type BatchContext = {
+    connection: Connection;
+    /** Raises CONFIG_INVALID for a collection the schema never declared. */
+    schemaFor(name: string): CollectionSchema;
+    now(): number;
+};
+export declare function runBatch(context: BatchContext, operations: BatchOperation[]): Promise<BatchOutcome>;
+//# sourceMappingURL=batch.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"batch.d.ts","sourceRoot":"","sources":["../../../../src/sqlite/batch.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;GAaG;AAIH,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,uBAAoB,CAAC;AAC3D,OAAO,KAAK,EAAE,cAAc,EAAE,YAAY,EAAE,MAAM,4BAAyB,CAAC;AAI5E,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,iBAAc,CAAC;AAG/C,MAAM,MAAM,YAAY,GAAG;IAC1B,UAAU,EAAE,UAAU,CAAC;IACvB,wEAAwE;IACxE,SAAS,CAAC,IAAI,EAAE,MAAM,GAAG,gBAAgB,CAAC;IAC1C,GAAG,IAAI,MAAM,CAAC;CACd,CAAC;AAgJF,wBAAsB,QAAQ,CAC7B,OAAO,EAAE,YAAY,EACrB,UAAU,EAAE,cAAc,EAAE,GAC1B,OAAO,CAAC,YAAY,CAAC,CAqDvB"}