@chipmobilesdk/rn-local-db 0.3.0 → 0.5.0

package/lib/commonjs/platform/fs.js

@@ -0,0 +1,59 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.fileSystem = fileSystem;
+exports.removeIfPresent = removeIfPresent;
+exports.setFileSystem = setFileSystem;
+var _rnCore = require("@chipmobilesdk/rn-core");
+var _errors = require("../contract/errors.js");
+var _errors2 = require("../diagnostics/errors.js");
+/**
+ * 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.
+ */
+
+/**
+ * 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.
+ */
+
+/** Loaded on first use (rn-core's lazy peer); a missing peer is `STORAGE_ACCESS`. */
+const fs = (0, _rnCore.lazyPeer)('@dr.pogodin/react-native-fs', () => {
+  // Inside `try`, so Metro bundles an app that leaves this optional peer out.
+  try {
+    return require('@dr.pogodin/react-native-fs');
+  } catch (cause) {
+    throw cause;
+  }
+});
+
+/** Swap the peer. Tests and the demo app's in-memory mode only; `null` restores it. */
+function setFileSystem(module) {
+  fs.override(module ?? undefined);
+}
+function fileSystem() {
+  return fs.require((_peer, cause) => new _errors2.StorageError(_errors.DiagnosticCodes.STORAGE_ACCESS, {
+    message: 'filesystem peer is not installed',
+    cause
+  }));
+}
+
+/** Remove a path, treating "already gone" as success (FR-062). */
+async function removeIfPresent(path) {
+  try {
+    await fileSystem().unlink(path);
+    return true;
+  } catch {
+    return false;
+  }
+}
+//# sourceMappingURL=fs.js.map

package/lib/commonjs/platform/fs.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["_rnCore","require","_errors","_errors2","fs","lazyPeer","cause","setFileSystem","module","override","undefined","fileSystem","_peer","StorageError","DiagnosticCodes","STORAGE_ACCESS","message","removeIfPresent","path","unlink"],"sourceRoot":"../../../src","sources":["platform/fs.ts"],"mappings":";;;;;;;;AAUA,IAAAA,OAAA,GAAAC,OAAA;AAEA,IAAAC,OAAA,GAAAD,OAAA;AACA,IAAAE,QAAA,GAAAF,OAAA;AAbA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAoBA;AACA;AACA;AACA;AACA;AACA;;AAiBA;AACA,MAAMG,EAAE,GAAG,IAAAC,gBAAQ,EAAC,6BAA6B,EAAE,MAAM;EACxD;EACA,IAAI;IACH,OAAOJ,OAAO,CAAC,6BAA6B,CAAC;EAC9C,CAAC,CAAC,OAAOK,KAAK,EAAE;IACf,MAAMA,KAAK;EACZ;AACD,CAAC,CAAC;;AAEF;AACO,SAASC,aAAaA,CAACC,MAAyB,EAAQ;EAC9DJ,EAAE,CAACK,QAAQ,CAACD,MAAM,IAAIE,SAAS,CAAC;AACjC;AAEO,SAASC,UAAUA,CAAA,EAAe;EACxC,OAAOP,EAAE,CAACH,OAAO,CAChB,CAACW,KAAK,EAAEN,KAAK,KACZ,IAAIO,qBAAY,CAACC,uBAAe,CAACC,cAAc,EAAE;IAChDC,OAAO,EAAE,kCAAkC;IAC3CV;EACD,CAAC,CACH,CAAC;AACF;;AAEA;AACO,eAAeW,eAAeA,CAACC,IAAY,EAAoB;EACrE,IAAI;IACH,MAAMP,UAAU,CAAC,CAAC,CAACQ,MAAM,CAACD,IAAI,CAAC;IAC/B,OAAO,IAAI;EACZ,CAAC,CAAC,MAAM;IACP,OAAO,KAAK;EACb;AACD","ignoreList":[]}

package/lib/commonjs/platform/location.js

@@ -0,0 +1,129 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.SCOPES_DIR = exports.MANAGED_ROOT_NAME = exports.DATA_FILE = exports.CATALOG_FILE = exports.ARTIFACTS_DIR = void 0;
+exports.assertValidAttachmentId = assertValidAttachmentId;
+exports.assertWithinManagedArea = assertWithinManagedArea;
+exports.createLayout = createLayout;
+exports.layoutFor = layoutFor;
+exports.normalizePath = normalizePath;
+var _errors = require("../contract/errors.js");
+var _errors2 = require("../diagnostics/errors.js");
+var _fs = require("./fs.js");
+/**
+ * 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.
+ */
+
+const MANAGED_ROOT_NAME = exports.MANAGED_ROOT_NAME = 'chipmobilesdk-localdb';
+const CATALOG_FILE = exports.CATALOG_FILE = 'catalog.db';
+const SCOPES_DIR = exports.SCOPES_DIR = 'scopes';
+const DATA_FILE = exports.DATA_FILE = 'data.db';
+const ARTIFACTS_DIR = exports.ARTIFACTS_DIR = 'artifacts';
+
+/** Normalize separators and collapse redundant segments. No `..` survives. */
+function normalizePath(path) {
+  const unified = path.replace(/\\/g, '/');
+  const segments = [];
+  for (const segment of unified.split('/')) {
+    if (segment === '' || segment === '.') {
+      continue;
+    }
+    if (segment === '..') {
+      segments.pop();
+      continue;
+    }
+    segments.push(segment);
+  }
+  const prefix = unified.startsWith('/') ? '/' : '';
+  return prefix + segments.join('/');
+}
+const SCOPE_KEY = /^[0-9a-f]{64}$/;
+const ARTIFACT_ID = /^[A-Za-z0-9._-]{1,128}$/;
+// `.` and `..` are made entirely of permitted characters and are the two that
+// matter: `artifacts/..` resolves to the scope directory itself, still inside
+// the managed root, so the boundary guard would wave it through and a cascade
+// would unlink the whole scope. A leading dot is refused with them, since no
+// attachment id needs one and hidden files are the package's own.
+const DOT_PREFIXED = /^\./;
+
+/**
+ * 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).
+ */
+function assertValidAttachmentId(attachmentId) {
+  if (!ARTIFACT_ID.test(attachmentId) || DOT_PREFIXED.test(attachmentId)) {
+    (0, _errors2.raise)(_errors.DiagnosticCodes.ATTACHMENT_OUT_OF_BOUNDS, {
+      message: 'attachment id is not a valid path segment'
+    });
+  }
+}
+function createLayout(documentDirectory, databaseName) {
+  const root = normalizePath(`${documentDirectory}/${MANAGED_ROOT_NAME}/${databaseName}`);
+  const scopePath = scopeKey => {
+    // The scope key is our own SHA-256 output. Validating its shape here
+    // means a caller cannot smuggle a traversal through it even if some
+    // future path reaches this function with unvalidated input.
+    if (!SCOPE_KEY.test(scopeKey)) {
+      (0, _errors2.raise)(_errors.DiagnosticCodes.ATTACHMENT_OUT_OF_BOUNDS, {
+        message: 'scope key is not a valid digest'
+      });
+    }
+    return `${root}/${SCOPES_DIR}/${scopeKey}`;
+  };
+  return {
+    root,
+    catalogPath: `${root}/${CATALOG_FILE}`,
+    scopePath,
+    scopeDataPath: scopeKey => `${scopePath(scopeKey)}/${DATA_FILE}`,
+    scopeArtifactsPath: scopeKey => `${scopePath(scopeKey)}/${ARTIFACTS_DIR}`,
+    artifactPath: (scopeKey, attachmentId) => {
+      assertValidAttachmentId(attachmentId);
+      return `${scopePath(scopeKey)}/${ARTIFACTS_DIR}/${attachmentId}`;
+    }
+  };
+}
+
+/**
+ * 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.
+ */
+function layoutFor(databaseName) {
+  return createLayout((0, _fs.fileSystem)().DocumentDirectoryPath, databaseName);
+}
+
+/**
+ * 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).
+ */
+function assertWithinManagedArea(layout, candidate) {
+  const normalized = normalizePath(candidate);
+  const root = normalizePath(layout.root);
+  if (normalized !== root && !normalized.startsWith(`${root}/`)) {
+    (0, _errors2.raise)(_errors.DiagnosticCodes.ATTACHMENT_OUT_OF_BOUNDS, {
+      // The offending path is NOT reported: it may contain a scope
+      // component or a user-chosen filename.
+      message: 'path resolves outside the managed storage area'
+    });
+  }
+  return normalized;
+}
+//# sourceMappingURL=location.js.map

package/lib/commonjs/platform/location.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["_errors","require","_errors2","_fs","MANAGED_ROOT_NAME","exports","CATALOG_FILE","SCOPES_DIR","DATA_FILE","ARTIFACTS_DIR","normalizePath","path","unified","replace","segments","segment","split","pop","push","prefix","startsWith","join","SCOPE_KEY","ARTIFACT_ID","DOT_PREFIXED","assertValidAttachmentId","attachmentId","test","raise","DiagnosticCodes","ATTACHMENT_OUT_OF_BOUNDS","message","createLayout","documentDirectory","databaseName","root","scopePath","scopeKey","catalogPath","scopeDataPath","scopeArtifactsPath","artifactPath","layoutFor","fileSystem","DocumentDirectoryPath","assertWithinManagedArea","layout","candidate","normalized"],"sourceRoot":"../../../src","sources":["platform/location.ts"],"mappings":"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","ignoreList":[]}

package/lib/commonjs/query/budgets.js

@@ -0,0 +1,95 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.assertArtifactWithinBudget = assertArtifactWithinBudget;
+exports.assertBatchWithinBudget = assertBatchWithinBudget;
+exports.assertRecordWithinBudget = assertRecordWithinBudget;
+exports.serializedSize = serializedSize;
+exports.utf8Length = utf8Length;
+var _config = require("../contract/config.js");
+var _errors = require("../contract/errors.js");
+var _errors2 = require("../diagnostics/errors.js");
+/**
+ * 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.
+ */
+
+/**
+ * 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.
+ */
+function utf8Length(value) {
+  let bytes = 0;
+  for (let index = 0; index < value.length; index += 1) {
+    const unit = value.charCodeAt(index);
+    if (unit < 0x80) {
+      bytes += 1;
+    } else if (unit < 0x800) {
+      bytes += 2;
+    } else if (unit >= 0xd800 && unit <= 0xdbff && index + 1 < value.length) {
+      // A surrogate pair is one four-byte code point.
+      bytes += 4;
+      index += 1;
+    } else {
+      bytes += 3;
+    }
+  }
+  return bytes;
+}
+
+/** UTF-8 byte length of the serialized payload — what actually hits disk. */
+function serializedSize(data) {
+  return utf8Length(JSON.stringify(data ?? {}));
+}
+
+/**
+ * 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.
+ */
+function assertRecordWithinBudget(collection, data) {
+  const payload = JSON.stringify(data ?? {});
+  const size = utf8Length(payload);
+  if (size > _config.Budgets.MAX_RECORD_BYTES) {
+    // Truncating would be silent data loss; failing opaquely would leave
+    // the consumer guessing. The size and the limit are both safe to
+    // report — neither can carry a field value.
+    (0, _errors2.raise)(_errors.DiagnosticCodes.RECORD_TOO_LARGE, {
+      message: 'record exceeds the per-record size budget',
+      detail: {
+        collection,
+        sizeBytes: size,
+        limitBytes: _config.Budgets.MAX_RECORD_BYTES
+      }
+    });
+  }
+  return payload;
+}
+function assertBatchWithinBudget(count) {
+  if (count > _config.Budgets.MAX_BATCH_OPERATIONS) {
+    (0, _errors2.raise)(_errors.DiagnosticCodes.BATCH_TOO_LARGE, {
+      message: 'batch exceeds the operation budget',
+      detail: {
+        count,
+        limit: _config.Budgets.MAX_BATCH_OPERATIONS
+      }
+    });
+  }
+}
+function assertArtifactWithinBudget(id, size) {
+  if (size > _config.Budgets.MAX_ARTIFACT_BYTES) {
+    (0, _errors2.raise)(_errors.DiagnosticCodes.ATTACHMENT_WRITE_FAILED, {
+      message: 'artifact exceeds the size budget',
+      detail: {
+        attachmentId: id,
+        sizeBytes: size,
+        limitBytes: _config.Budgets.MAX_ARTIFACT_BYTES
+      }
+    });
+  }
+}
+//# sourceMappingURL=budgets.js.map

package/lib/commonjs/query/budgets.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["_config","require","_errors","_errors2","utf8Length","value","bytes","index","length","unit","charCodeAt","serializedSize","data","JSON","stringify","assertRecordWithinBudget","collection","payload","size","Budgets","MAX_RECORD_BYTES","raise","DiagnosticCodes","RECORD_TOO_LARGE","message","detail","sizeBytes","limitBytes","assertBatchWithinBudget","count","MAX_BATCH_OPERATIONS","BATCH_TOO_LARGE","limit","assertArtifactWithinBudget","id","MAX_ARTIFACT_BYTES","ATTACHMENT_WRITE_FAILED","attachmentId"],"sourceRoot":"../../../src","sources":["query/budgets.ts"],"mappings":";;;;;;;;;;AAQA,IAAAA,OAAA,GAAAC,OAAA;AACA,IAAAC,OAAA,GAAAD,OAAA;AAEA,IAAAE,QAAA,GAAAF,OAAA;AAXA;AACA;AACA;AACA;AACA;AACA;AACA;;AAOA;AACA;AACA;AACA;AACO,SAASG,UAAUA,CAACC,KAAa,EAAU;EACjD,IAAIC,KAAK,GAAG,CAAC;EACb,KAAK,IAAIC,KAAK,GAAG,CAAC,EAAEA,KAAK,GAAGF,KAAK,CAACG,MAAM,EAAED,KAAK,IAAI,CAAC,EAAE;IACrD,MAAME,IAAI,GAAGJ,KAAK,CAACK,UAAU,CAACH,KAAK,CAAC;IACpC,IAAIE,IAAI,GAAG,IAAI,EAAE;MAChBH,KAAK,IAAI,CAAC;IACX,CAAC,MAAM,IAAIG,IAAI,GAAG,KAAK,EAAE;MACxBH,KAAK,IAAI,CAAC;IACX,CAAC,MAAM,IAAIG,IAAI,IAAI,MAAM,IAAIA,IAAI,IAAI,MAAM,IAAIF,KAAK,GAAG,CAAC,GAAGF,KAAK,CAACG,MAAM,EAAE;MACxE;MACAF,KAAK,IAAI,CAAC;MACVC,KAAK,IAAI,CAAC;IACX,CAAC,MAAM;MACND,KAAK,IAAI,CAAC;IACX;EACD;EACA,OAAOA,KAAK;AACb;;AAEA;AACO,SAASK,cAAcA,CAACC,IAAwB,EAAU;EAChE,OAAOR,UAAU,CAACS,IAAI,CAACC,SAAS,CAACF,IAAI,IAAI,CAAC,CAAC,CAAC,CAAC;AAC9C;;AAEA;AACA;AACA;AACA;AACO,SAASG,wBAAwBA,CAACC,UAAkB,EAAEJ,IAAwB,EAAU;EAC9F,MAAMK,OAAO,GAAGJ,IAAI,CAACC,SAAS,CAACF,IAAI,IAAI,CAAC,CAAC,CAAC;EAC1C,MAAMM,IAAI,GAAGd,UAAU,CAACa,OAAO,CAAC;EAChC,IAAIC,IAAI,GAAGC,eAAO,CAACC,gBAAgB,EAAE;IACpC;IACA;IACA;IACA,IAAAC,cAAK,EAACC,uBAAe,CAACC,gBAAgB,EAAE;MACvCC,OAAO,EAAE,2CAA2C;MACpDC,MAAM,EAAE;QAAET,UAAU;QAAEU,SAAS,EAAER,IAAI;QAAES,UAAU,EAAER,eAAO,CAACC;MAAiB;IAC7E,CAAC,CAAC;EACH;EACA,OAAOH,OAAO;AACf;AAEO,SAASW,uBAAuBA,CAACC,KAAa,EAAQ;EAC5D,IAAIA,KAAK,GAAGV,eAAO,CAACW,oBAAoB,EAAE;IACzC,IAAAT,cAAK,EAACC,uBAAe,CAACS,eAAe,EAAE;MACtCP,OAAO,EAAE,oCAAoC;MAC7CC,MAAM,EAAE;QAAEI,KAAK;QAAEG,KAAK,EAAEb,eAAO,CAACW;MAAqB;IACtD,CAAC,CAAC;EACH;AACD;AAEO,SAASG,0BAA0BA,CAACC,EAAU,EAAEhB,IAAY,EAAQ;EAC1E,IAAIA,IAAI,GAAGC,eAAO,CAACgB,kBAAkB,EAAE;IACtC,IAAAd,cAAK,EAACC,uBAAe,CAACc,uBAAuB,EAAE;MAC9CZ,OAAO,EAAE,kCAAkC;MAC3CC,MAAM,EAAE;QACPY,YAAY,EAAEH,EAAE;QAChBR,SAAS,EAAER,IAAI;QACfS,UAAU,EAAER,eAAO,CAACgB;MACrB;IACD,CAAC,CAAC;EACH;AACD","ignoreList":[]}

package/lib/commonjs/query/compare.js

@@ -0,0 +1,97 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.asFilterValue = asFilterValue;
+exports.byteOrder = byteOrder;
+exports.compareValues = compareValues;
+exports.lookupField = lookupField;
+/**
+ * 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).
+ */
+
+/**
+ * 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.
+ */
+
+function lookupField(data, field) {
+  if (!Object.prototype.hasOwnProperty.call(data, field)) {
+    return {
+      present: false
+    };
+  }
+  const value = data[field];
+  if (value === null) {
+    return {
+      present: true,
+      value: null
+    };
+  }
+  return {
+    present: true,
+    value: value
+  };
+}
+
+/**
+ * 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.
+ */
+function compareValues(a, b) {
+  if (a === null && b === null) {
+    return 0;
+  }
+  if (a === null) {
+    return -1;
+  }
+  if (b === null) {
+    return 1;
+  }
+  if (typeof a === 'boolean' || typeof b === 'boolean') {
+    return Number(a) - Number(b);
+  }
+  if (typeof a === 'number' && typeof b === 'number') {
+    if (Number.isNaN(a) || Number.isNaN(b)) {
+      return Number.isNaN(a) && Number.isNaN(b) ? 0 : Number.isNaN(a) ? -1 : 1;
+    }
+    return a < b ? -1 : a > b ? 1 : 0;
+  }
+  const sa = String(a);
+  const sb = String(b);
+  // Byte-order rather than locale collation: a locale-aware comparison would
+  // make the stored order depend on device settings, so the same data would
+  // page differently on two phones.
+  return sa < sb ? -1 : sa > sb ? 1 : 0;
+}
+
+/** Only primitives can be compared; a nested object is never a filter target. */
+function asFilterValue(value) {
+  if (value === null || typeof value === 'string' || typeof value === 'number' || typeof value === 'boolean') {
+    return value;
+  }
+  return 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.
+ */
+function byteOrder(a, b) {
+  if (a < b) {
+    return -1;
+  }
+  return a > b ? 1 : 0;
+}
+//# sourceMappingURL=compare.js.map

package/lib/commonjs/query/compare.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["lookupField","data","field","Object","prototype","hasOwnProperty","call","present","value","compareValues","a","b","Number","isNaN","sa","String","sb","asFilterValue","undefined","byteOrder"],"sourceRoot":"../../../src","sources":["query/compare.ts"],"mappings":";;;;;;;;;AAAA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAKA;AACA;AACA;AACA;;AAMO,SAASA,WAAWA,CAACC,IAAwB,EAAEC,KAAa,EAAe;EACjF,IAAI,CAACC,MAAM,CAACC,SAAS,CAACC,cAAc,CAACC,IAAI,CAACL,IAAI,EAAEC,KAAK,CAAC,EAAE;IACvD,OAAO;MAAEK,OAAO,EAAE;IAAM,CAAC;EAC1B;EACA,MAAMC,KAAK,GAAGP,IAAI,CAACC,KAAK,CAAC;EACzB,IAAIM,KAAK,KAAK,IAAI,EAAE;IACnB,OAAO;MAAED,OAAO,EAAE,IAAI;MAAEC,KAAK,EAAE;IAAK,CAAC;EACtC;EACA,OAAO;IAAED,OAAO,EAAE,IAAI;IAAEC,KAAK,EAAEA;EAAsC,CAAC;AACvE;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACO,SAASC,aAAaA,CAACC,CAAc,EAAEC,CAAc,EAAU;EACrE,IAAID,CAAC,KAAK,IAAI,IAAIC,CAAC,KAAK,IAAI,EAAE;IAC7B,OAAO,CAAC;EACT;EACA,IAAID,CAAC,KAAK,IAAI,EAAE;IACf,OAAO,CAAC,CAAC;EACV;EACA,IAAIC,CAAC,KAAK,IAAI,EAAE;IACf,OAAO,CAAC;EACT;EACA,IAAI,OAAOD,CAAC,KAAK,SAAS,IAAI,OAAOC,CAAC,KAAK,SAAS,EAAE;IACrD,OAAOC,MAAM,CAACF,CAAC,CAAC,GAAGE,MAAM,CAACD,CAAC,CAAC;EAC7B;EACA,IAAI,OAAOD,CAAC,KAAK,QAAQ,IAAI,OAAOC,CAAC,KAAK,QAAQ,EAAE;IACnD,IAAIC,MAAM,CAACC,KAAK,CAACH,CAAC,CAAC,IAAIE,MAAM,CAACC,KAAK,CAACF,CAAC,CAAC,EAAE;MACvC,OAAOC,MAAM,CAACC,KAAK,CAACH,CAAC,CAAC,IAAIE,MAAM,CAACC,KAAK,CAACF,CAAC,CAAC,GAAG,CAAC,GAAGC,MAAM,CAACC,KAAK,CAACH,CAAC,CAAC,GAAG,CAAC,CAAC,GAAG,CAAC;IACzE;IACA,OAAOA,CAAC,GAAGC,CAAC,GAAG,CAAC,CAAC,GAAGD,CAAC,GAAGC,CAAC,GAAG,CAAC,GAAG,CAAC;EAClC;EACA,MAAMG,EAAE,GAAGC,MAAM,CAACL,CAAC,CAAC;EACpB,MAAMM,EAAE,GAAGD,MAAM,CAACJ,CAAC,CAAC;EACpB;EACA;EACA;EACA,OAAOG,EAAE,GAAGE,EAAE,GAAG,CAAC,CAAC,GAAGF,EAAE,GAAGE,EAAE,GAAG,CAAC,GAAG,CAAC;AACtC;;AAEA;AACO,SAASC,aAAaA,CAACT,KAAoB,EAA2B;EAC5E,IACCA,KAAK,KAAK,IAAI,IACd,OAAOA,KAAK,KAAK,QAAQ,IACzB,OAAOA,KAAK,KAAK,QAAQ,IACzB,OAAOA,KAAK,KAAK,SAAS,EACzB;IACD,OAAOA,KAAK;EACb;EACA,OAAOU,SAAS;AACjB;;AAEA;AACA;AACA;AACA;AACA;AACA;AACO,SAASC,SAASA,CAACT,CAAS,EAAEC,CAAS,EAAU;EACvD,IAAID,CAAC,GAAGC,CAAC,EAAE;IACV,OAAO,CAAC,CAAC;EACV;EACA,OAAOD,CAAC,GAAGC,CAAC,GAAG,CAAC,GAAG,CAAC;AACrB","ignoreList":[]}

package/lib/commonjs/query/cursor.js

@@ -0,0 +1,97 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.decodeCursor = decodeCursor;
+exports.encodeCursor = encodeCursor;
+exports.isAfterCursor = isAfterCursor;
+var _errors = require("../contract/errors.js");
+var _errors2 = require("../diagnostics/errors.js");
+var _compare = require("./compare.js");
+var _sort = require("./sort.js");
+var _bytes = require("../platform/bytes.js");
+/**
+ * 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.
+ */
+
+function shapeOf(sort) {
+  return sort.map(key => `${key.field}:${key.direction === 'desc' ? 'd' : 'a'}`).join(',');
+}
+function toBase64(value) {
+  if (_bytes.host.btoa) {
+    return _bytes.host.btoa(unescape(encodeURIComponent(value)));
+  }
+  return (0, _bytes.bytesToBase64)((0, _bytes.utf8Bytes)(value));
+}
+function fromBase64(value) {
+  if (_bytes.host.atob) {
+    return decodeURIComponent(escape(_bytes.host.atob(value)));
+  }
+  return (0, _bytes.utf8String)((0, _bytes.base64ToBytes)(value));
+}
+function encodeCursor(record, sort) {
+  const payload = {
+    k: shapeOf(sort),
+    v: sort.map(key => (0, _sort.sortValueOf)(record, key.field) ?? null)
+  };
+  return toBase64(JSON.stringify(payload));
+}
+function decodeCursor(cursor, sort) {
+  let payload;
+  try {
+    payload = JSON.parse(fromBase64(cursor));
+  } catch {
+    (0, _errors2.raise)(_errors.DiagnosticCodes.CURSOR_INVALID, {
+      message: 'cursor is not decodable'
+    });
+  }
+  if (!payload || typeof payload.k !== 'string' || !Array.isArray(payload.v)) {
+    (0, _errors2.raise)(_errors.DiagnosticCodes.CURSOR_INVALID, {
+      message: 'cursor payload is malformed'
+    });
+  }
+  // A cursor from a differently sorted query would produce a silently wrong
+  // page rather than an error, so the shape is part of the cursor.
+  if (payload.k !== shapeOf(sort)) {
+    (0, _errors2.raise)(_errors.DiagnosticCodes.CURSOR_INVALID, {
+      message: 'cursor does not match this query shape'
+    });
+  }
+  if (payload.v.length !== sort.length) {
+    (0, _errors2.raise)(_errors.DiagnosticCodes.CURSOR_INVALID, {
+      message: 'cursor arity does not match sort'
+    });
+  }
+  return payload.v;
+}
+
+/**
+ * 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.
+ */
+function isAfterCursor(record, sort, anchor) {
+  for (let i = 0; i < sort.length; i += 1) {
+    const key = sort[i];
+    const direction = key.direction === 'desc' ? -1 : 1;
+    const value = (0, _sort.sortValueOf)(record, key.field) ?? null;
+    const result = (0, _compare.compareValues)(value, anchor[i] ?? null) * direction;
+    if (result > 0) {
+      return true;
+    }
+    if (result < 0) {
+      return false;
+    }
+  }
+  // Equal on every key including id — this is the anchor row itself.
+  return false;
+}
+//# sourceMappingURL=cursor.js.map

package/lib/commonjs/query/cursor.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["_errors","require","_errors2","_compare","_sort","_bytes","shapeOf","sort","map","key","field","direction","join","toBase64","value","host","btoa","unescape","encodeURIComponent","bytesToBase64","utf8Bytes","fromBase64","atob","decodeURIComponent","escape","utf8String","base64ToBytes","encodeCursor","record","payload","k","v","sortValueOf","JSON","stringify","decodeCursor","cursor","parse","raise","DiagnosticCodes","CURSOR_INVALID","message","Array","isArray","length","isAfterCursor","anchor","i","result","compareValues"],"sourceRoot":"../../../src","sources":["query/cursor.ts"],"mappings":"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","ignoreList":[]}

package/lib/commonjs/query/filter.js

@@ -0,0 +1,82 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.evaluateFilter = evaluateFilter;
+var _compare = require("./compare.js");
+/**
+ * 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.
+ */
+
+function equals(a, b) {
+  return (0, _compare.compareValues)(a, b) === 0 && a === null === (b === null);
+}
+function evaluateFilter(data, node) {
+  switch (node.op) {
+    case 'and':
+      return node.nodes.every(child => evaluateFilter(data, child));
+    case 'or':
+      return node.nodes.some(child => evaluateFilter(data, child));
+    case 'not':
+      return !evaluateFilter(data, node.node);
+    default:
+      break;
+  }
+  const lookup = (0, _compare.lookupField)(data, node.field);
+
+  // `exists` is the only operator that answers a question about presence,
+  // which is what keeps "absent" distinguishable from "null" (FR-019).
+  if (node.op === 'exists') {
+    return lookup.present === node.value;
+  }
+  if (!lookup.present) {
+    // An absent field satisfies nothing else — not even `ne` or `isNull`.
+    // SQL agrees: a comparison against a missing column yields NULL, which
+    // is not true.
+    return false;
+  }
+  const value = (0, _compare.asFilterValue)(lookup.value);
+  if (value === undefined) {
+    // A nested object or array is not comparable. Matching it would be a
+    // guess, so it simply does not satisfy a comparison.
+    return false;
+  }
+  switch (node.op) {
+    case 'isNull':
+      return value === null;
+    case 'isNotNull':
+      return value !== null;
+    case 'eq':
+      return equals(value, node.value);
+    case 'ne':
+      return !equals(value, node.value);
+    case 'lt':
+      return value !== null && node.value !== null && (0, _compare.compareValues)(value, node.value) < 0;
+    case 'lte':
+      return value !== null && node.value !== null && (0, _compare.compareValues)(value, node.value) <= 0;
+    case 'gt':
+      return value !== null && node.value !== null && (0, _compare.compareValues)(value, node.value) > 0;
+    case 'gte':
+      return value !== null && node.value !== null && (0, _compare.compareValues)(value, node.value) >= 0;
+    case 'in':
+      return node.value.some(candidate => equals(value, candidate));
+    case 'nin':
+      return !node.value.some(candidate => equals(value, candidate));
+    case 'between':
+      {
+        const [low, high] = node.value;
+        if (value === null || low === null || high === null) {
+          return false;
+        }
+        return (0, _compare.compareValues)(value, low) >= 0 && (0, _compare.compareValues)(value, high) <= 0;
+      }
+    default:
+      return false;
+  }
+}
+//# sourceMappingURL=filter.js.map

package/lib/commonjs/query/filter.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["_compare","require","equals","a","b","compareValues","evaluateFilter","data","node","op","nodes","every","child","some","lookup","lookupField","field","present","value","asFilterValue","undefined","candidate","low","high"],"sourceRoot":"../../../src","sources":["query/filter.ts"],"mappings":"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","ignoreList":[]}

package/lib/commonjs/query/paginate.js

@@ -0,0 +1,48 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.DEFAULT_PAGE_SIZE = void 0;
+exports.applyCursor = applyCursor;
+exports.buildPage = buildPage;
+exports.fetchLimitFor = fetchLimitFor;
+exports.resolvePageSize = resolvePageSize;
+var _config = require("../contract/config.js");
+var _cursor = require("./cursor.js");
+/**
+ * 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.
+ */
+
+const DEFAULT_PAGE_SIZE = exports.DEFAULT_PAGE_SIZE = 50;
+function resolvePageSize(page) {
+  return page?.size ?? DEFAULT_PAGE_SIZE;
+}
+
+/** Fetch one extra row to answer `hasMore` without a second count query. */
+function fetchLimitFor(size) {
+  return Math.min(size, _config.Budgets.MAX_PAGE_SIZE) + 1;
+}
+function applyCursor(records, sort, cursor) {
+  if (!cursor) {
+    return records;
+  }
+  const anchor = (0, _cursor.decodeCursor)(cursor, sort);
+  return records.filter(record => (0, _cursor.isAfterCursor)(record, sort, anchor));
+}
+function buildPage(records, sort, size) {
+  const hasMore = records.length > size;
+  const page = hasMore ? records.slice(0, size) : records;
+  const last = page[page.length - 1];
+  return {
+    records: page,
+    // No cursor on the final page: handing one back invites a consumer to
+    // keep paging past the end and treat an empty page as an error.
+    cursor: hasMore && last ? (0, _cursor.encodeCursor)(last, sort) : undefined,
+    hasMore
+  };
+}
+//# sourceMappingURL=paginate.js.map

package/lib/commonjs/query/paginate.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["_config","require","_cursor","DEFAULT_PAGE_SIZE","exports","resolvePageSize","page","size","fetchLimitFor","Math","min","Budgets","MAX_PAGE_SIZE","applyCursor","records","sort","cursor","anchor","decodeCursor","filter","record","isAfterCursor","buildPage","hasMore","length","slice","last","encodeCursor","undefined"],"sourceRoot":"../../../src","sources":["query/paginate.ts"],"mappings":";;;;;;;;;;AAOA,IAAAA,OAAA,GAAAC,OAAA;AAGA,IAAAC,OAAA,GAAAD,OAAA;AAVA;AACA;AACA;AACA;AACA;AACA;;AAOO,MAAME,iBAAiB,GAAAC,OAAA,CAAAD,iBAAA,GAAG,EAAE;AAE5B,SAASE,eAAeA,CAACC,IAA6B,EAAU;EACtE,OAAOA,IAAI,EAAEC,IAAI,IAAIJ,iBAAiB;AACvC;;AAEA;AACO,SAASK,aAAaA,CAACD,IAAY,EAAU;EACnD,OAAOE,IAAI,CAACC,GAAG,CAACH,IAAI,EAAEI,eAAO,CAACC,aAAa,CAAC,GAAG,CAAC;AACjD;AAEO,SAASC,WAAWA,CAC1BC,OAAY,EACZC,IAAe,EACfC,MAA0B,EACpB;EACN,IAAI,CAACA,MAAM,EAAE;IACZ,OAAOF,OAAO;EACf;EACA,MAAMG,MAAM,GAAG,IAAAC,oBAAY,EAACF,MAAM,EAAED,IAAI,CAAC;EACzC,OAAOD,OAAO,CAACK,MAAM,CAACC,MAAM,IAAI,IAAAC,qBAAa,EAACD,MAAM,EAAEL,IAAI,EAAEE,MAAM,CAAC,CAAC;AACrE;AAEO,SAASK,SAASA,CACxBR,OAA0B,EAC1BC,IAAe,EACfR,IAAY,EACI;EAChB,MAAMgB,OAAO,GAAGT,OAAO,CAACU,MAAM,GAAGjB,IAAI;EACrC,MAAMD,IAAI,GAAGiB,OAAO,GAAGT,OAAO,CAACW,KAAK,CAAC,CAAC,EAAElB,IAAI,CAAC,GAAGO,OAAO;EACvD,MAAMY,IAAI,GAAGpB,IAAI,CAACA,IAAI,CAACkB,MAAM,GAAG,CAAC,CAAC;EAClC,OAAO;IACNV,OAAO,EAAER,IAAI;IACb;IACA;IACAU,MAAM,EAAEO,OAAO,IAAIG,IAAI,GAAG,IAAAC,oBAAY,EAACD,IAAI,EAAEX,IAAI,CAAC,GAAGa,SAAS;IAC9DL;EACD,CAAC;AACF","ignoreList":[]}