@chipmobilesdk/rn-local-db 0.3.0 → 0.5.0

package/lib/commonjs/diagnostics/dev-log.js

@@ -0,0 +1,127 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.instrument = instrument;
+exports.isLogging = isLogging;
+exports.logDiagnostic = logDiagnostic;
+exports.setDiagnosticLogger = setDiagnosticLogger;
+var _rnCore = require("@chipmobilesdk/rn-core");
+/**
+ * Development-only diagnostics.
+ *
+ * Operation names, durations, and counts are safe to report. Record payloads,
+ * field values, and query parameters are not — in any build, including this
+ * one (FR-080, FR-081). There is deliberately no path here that accepts a
+ * payload, so a future caller cannot pass one by accident.
+ */
+
+let logger = null;
+
+/** Passing null removes the logger. */
+function setDiagnosticLogger(next) {
+  logger = next;
+}
+function isDevelopmentBuild() {
+  // __DEV__ is a React Native global; the typeof guard keeps this usable
+  // under plain Node when the package is exercised from Jest.
+  if (typeof __DEV__ !== 'undefined') return __DEV__ === true;
+  const {
+    process
+  } = globalThis;
+  return process?.env?.NODE_ENV !== 'production';
+}
+
+/**
+ * A failed operation also reaches the app's SDK sinks (`installSdkSink` from
+ * rn-core, CORE-08), in any build: its code, the operation and the collection,
+ * which are identifiers this package defines. Successes stay with the
+ * development logger.
+ */
+const channel = (0, _rnCore.createDiagnosticChannel)('rn-local-db');
+function logDiagnostic(event) {
+  if (event.outcome !== undefined) {
+    channel.emit(event.outcome, 'warn', {
+      operation: event.operation,
+      ...(event.collection === undefined ? {} : {
+        collection: event.collection
+      }),
+      ...(event.adapter === undefined ? {} : {
+        adapter: event.adapter
+      })
+    });
+  }
+  if (!logger || !isDevelopmentBuild()) {
+    return;
+  }
+  logger(event);
+}
+function isLogging() {
+  return logger !== null && isDevelopmentBuild();
+}
+
+/**
+ * Wrap a collection so every operation reports its name, duration, and result
+ * count — and nothing else.
+ *
+ * Wrapping once here rather than instrumenting each operation in the adapters
+ * is what keeps the guarantee checkable: there is one place that decides what
+ * a log line may contain, and it has no access to a payload to leak even if a
+ * future change wanted one. The wrapper is applied only when a logger is
+ * installed and the build is a development build, so a production bundle pays
+ * nothing and emits nothing (FR-081).
+ */
+function instrument(collection, adapter, operations) {
+  // Unwrapped unless someone is listening: production pays nothing by default.
+  if (!isLogging() && !(0, _rnCore.hasSdkSinks)()) {
+    return operations;
+  }
+  const wrapped = {};
+  for (const [name, operation] of Object.entries(operations)) {
+    if (typeof operation !== 'function') {
+      wrapped[name] = operation;
+      continue;
+    }
+    wrapped[name] = async (...args) => {
+      const started = Date.now();
+      try {
+        const result = await operation(...args);
+        logDiagnostic({
+          operation: `${collection}.${name}`,
+          durationMs: Date.now() - started,
+          collection,
+          adapter,
+          ...(countOf(result) === undefined ? {} : {
+            count: countOf(result)
+          })
+        });
+        return result;
+      } catch (error) {
+        // The code, never the message: a failure log is exactly where a
+        // payload-bearing native message would otherwise end up.
+        logDiagnostic({
+          operation: `${collection}.${name}`,
+          durationMs: Date.now() - started,
+          collection,
+          adapter,
+          outcome: error.code ?? 'failed'
+        });
+        throw error;
+      }
+    };
+  }
+  return wrapped;
+}
+
+/** How many records an operation produced, when that is a meaningful answer. */
+function countOf(result) {
+  if (typeof result === 'number') {
+    return result;
+  }
+  if (result && typeof result === 'object' && Array.isArray(result.records)) {
+    return result.records.length;
+  }
+  return undefined;
+}
+//# sourceMappingURL=dev-log.js.map

package/lib/commonjs/diagnostics/dev-log.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["_rnCore","require","logger","setDiagnosticLogger","next","isDevelopmentBuild","__DEV__","process","globalThis","env","NODE_ENV","channel","createDiagnosticChannel","logDiagnostic","event","outcome","undefined","emit","operation","collection","adapter","isLogging","instrument","operations","hasSdkSinks","wrapped","name","Object","entries","args","started","Date","now","result","durationMs","countOf","count","error","code","Array","isArray","records","length"],"sourceRoot":"../../../src","sources":["diagnostics/dev-log.ts"],"mappings":"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","ignoreList":[]}

package/lib/commonjs/diagnostics/errors.js

@@ -0,0 +1,57 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+Object.defineProperty(exports, "DiagnosticCodes", {
+  enumerable: true,
+  get: function () {
+    return _errors.DiagnosticCodes;
+  }
+});
+exports.StorageError = void 0;
+exports.isCode = isCode;
+exports.isStorageError = isStorageError;
+exports.raise = raise;
+var _rnCore = require("@chipmobilesdk/rn-core");
+var _errors = require("../contract/errors.js");
+var _redact = require("./redact.js");
+/**
+ * The single error type the package raises.
+ *
+ * Everything is redacted on the way in (see redact.ts), so there is no path
+ * by which a field value, query parameter, scope component, or key reaches an
+ * error object at all.
+ */
+
+/** The package's error; an `SdkError` (`@chipmobilesdk/rn-core`) with `pkg: 'rn-local-db'`. */
+class StorageError extends _rnCore.SdkError {
+  constructor(code, init = {}) {
+    // Call sites pass only authored literals (authored-messages.test.ts).
+    const message = init.message ? (0, _redact.sanitizeAuthoredMessage)(init.message) : code;
+    // `cause` is deliberately NOT kept: the native error it came from may
+    // quote the offending value. Only its redacted identifier survives.
+    super('rn-local-db', code, {
+      message,
+      retryable: _errors.RETRYABLE_CODES.has(code),
+      redactedCause: (0, _redact.redactCause)(init.cause)
+    });
+    this.name = 'StorageError';
+    this.detail = (0, _redact.redactDetail)(init.detail);
+    // Version numbers and an outcome enum — no payload can hide in these.
+    this.migration = init.migration;
+  }
+}
+exports.StorageError = StorageError;
+function isStorageError(value) {
+  return value instanceof StorageError;
+}
+
+/** So no consumer ever has to parse a message string (FR-082). */
+function isCode(value, code) {
+  return isStorageError(value) && value.code === code;
+}
+function raise(code, init) {
+  throw new StorageError(code, init);
+}
+//# sourceMappingURL=errors.js.map

package/lib/commonjs/diagnostics/errors.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["_rnCore","require","_errors","_redact","StorageError","SdkError","constructor","code","init","message","sanitizeAuthoredMessage","retryable","RETRYABLE_CODES","has","redactedCause","redactCause","cause","name","detail","redactDetail","migration","exports","isStorageError","value","isCode","raise"],"sourceRoot":"../../../src","sources":["diagnostics/errors.ts"],"mappings":";;;;;;;;;;;;;;;AAQA,IAAAA,OAAA,GAAAC,OAAA;AAEA,IAAAC,OAAA,GAAAD,OAAA;AAEA,IAAAE,OAAA,GAAAF,OAAA;AAZA;AACA;AACA;AACA;AACA;AACA;AACA;;AAoBA;AACO,MAAMG,YAAY,SAASC,gBAAQ,CAAiB;EAI1DC,WAAWA,CAACC,IAAoB,EAAEC,IAAsB,GAAG,CAAC,CAAC,EAAE;IAC9D;IACA,MAAMC,OAAO,GAAGD,IAAI,CAACC,OAAO,GAAG,IAAAC,+BAAuB,EAACF,IAAI,CAACC,OAAO,CAAC,GAAGF,IAAI;IAC3E;IACA;IACA,KAAK,CAAC,aAAa,EAAEA,IAAI,EAAE;MAC1BE,OAAO;MACPE,SAAS,EAAEC,uBAAe,CAACC,GAAG,CAACN,IAAI,CAAC;MACpCO,aAAa,EAAE,IAAAC,mBAAW,EAACP,IAAI,CAACQ,KAAK;IACtC,CAAC,CAAC;IACF,IAAI,CAACC,IAAI,GAAG,cAAc;IAC1B,IAAI,CAACC,MAAM,GAAG,IAAAC,oBAAY,EAACX,IAAI,CAACU,MAAM,CAAC;IACvC;IACA,IAAI,CAACE,SAAS,GAAGZ,IAAI,CAACY,SAAS;EAChC;AACD;AAACC,OAAA,CAAAjB,YAAA,GAAAA,YAAA;AAEM,SAASkB,cAAcA,CAACC,KAAc,EAAyB;EACrE,OAAOA,KAAK,YAAYnB,YAAY;AACrC;;AAEA;AACO,SAASoB,MAAMA,CAACD,KAAc,EAAEhB,IAAoB,EAAW;EACrE,OAAOe,cAAc,CAACC,KAAK,CAAC,IAAIA,KAAK,CAAChB,IAAI,KAAKA,IAAI;AACpD;AAEO,SAASkB,KAAKA,CAAClB,IAAoB,EAAEC,IAAuB,EAAS;EAC3E,MAAM,IAAIJ,YAAY,CAACG,IAAI,EAAEC,IAAI,CAAC;AACnC","ignoreList":[]}

package/lib/commonjs/diagnostics/faults.js

@@ -0,0 +1,54 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.activeFaults = activeFaults;
+exports.clearFaults = clearFaults;
+exports.injectFault = injectFault;
+exports.throwIfFaulted = throwIfFaulted;
+var _errors = require("./errors.js");
+/**
+ * The fault registry.
+ *
+ * It lives here rather than under `testing/` because FR-095 wants every
+ * documented failure reachable from a real app running the real adapter — the
+ * demo's fault-injection panel exercises the on-device path, not a simulation
+ * of it. So the check has to exist in production code.
+ *
+ * What does *not* exist in production code is a way to inject: `injectFault`
+ * and `clearFaults` are exported only from the `./testing` entrypoint. With
+ * nothing injected this is one lookup in an empty map, which is the price of
+ * being able to prove a recovery path works before a user finds it broken.
+ */
+
+const faults = new Map();
+function injectFault(spec) {
+  faults.set(spec.at, {
+    code: spec.code,
+    remaining: spec.times ?? Number.POSITIVE_INFINITY
+  });
+}
+function clearFaults() {
+  faults.clear();
+}
+function activeFaults() {
+  return [...faults.keys()];
+}
+function throwIfFaulted(point) {
+  if (faults.size === 0) {
+    return;
+  }
+  const fault = faults.get(point);
+  if (!fault || fault.remaining <= 0) {
+    return;
+  }
+  fault.remaining -= 1;
+  if (fault.remaining <= 0) {
+    faults.delete(point);
+  }
+  throw new _errors.StorageError(fault.code, {
+    message: `injected fault at ${point}`
+  });
+}
+//# sourceMappingURL=faults.js.map

package/lib/commonjs/diagnostics/faults.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["_errors","require","faults","Map","injectFault","spec","set","at","code","remaining","times","Number","POSITIVE_INFINITY","clearFaults","clear","activeFaults","keys","throwIfFaulted","point","size","fault","get","delete","StorageError","message"],"sourceRoot":"../../../src","sources":["diagnostics/faults.ts"],"mappings":";;;;;;;;;AAeA,IAAAA,OAAA,GAAAC,OAAA;AAfA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAeA,MAAMC,MAAM,GAAG,IAAIC,GAAG,CAA0D,CAAC;AAE1E,SAASC,WAAWA,CAACC,IAAe,EAAQ;EAClDH,MAAM,CAACI,GAAG,CAACD,IAAI,CAACE,EAAE,EAAE;IACnBC,IAAI,EAAEH,IAAI,CAACG,IAAI;IACfC,SAAS,EAAEJ,IAAI,CAACK,KAAK,IAAIC,MAAM,CAACC;EACjC,CAAC,CAAC;AACH;AAEO,SAASC,WAAWA,CAAA,EAAS;EACnCX,MAAM,CAACY,KAAK,CAAC,CAAC;AACf;AAEO,SAASC,YAAYA,CAAA,EAAiB;EAC5C,OAAO,CAAC,GAAGb,MAAM,CAACc,IAAI,CAAC,CAAC,CAAC;AAC1B;AAEO,SAASC,cAAcA,CAACC,KAAiB,EAAQ;EACvD,IAAIhB,MAAM,CAACiB,IAAI,KAAK,CAAC,EAAE;IACtB;EACD;EACA,MAAMC,KAAK,GAAGlB,MAAM,CAACmB,GAAG,CAACH,KAAK,CAAC;EAC/B,IAAI,CAACE,KAAK,IAAIA,KAAK,CAACX,SAAS,IAAI,CAAC,EAAE;IACnC;EACD;EACAW,KAAK,CAACX,SAAS,IAAI,CAAC;EACpB,IAAIW,KAAK,CAACX,SAAS,IAAI,CAAC,EAAE;IACzBP,MAAM,CAACoB,MAAM,CAACJ,KAAK,CAAC;EACrB;EACA,MAAM,IAAIK,oBAAY,CAACH,KAAK,CAACZ,IAAI,EAAE;IAAEgB,OAAO,EAAE,qBAAqBN,KAAK;EAAG,CAAC,CAAC;AAC9E","ignoreList":[]}

package/lib/commonjs/diagnostics/map-native.js

@@ -0,0 +1,98 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.mapNativeError = mapNativeError;
+exports.raiseNative = raiseNative;
+var _errors = require("../contract/errors.js");
+var _errors2 = require("./errors.js");
+/**
+ * Native error to diagnostic code.
+ *
+ * The three failures FR-076 insists stay apart — a full disk, a filesystem
+ * the app cannot reach, and a corrupt database — arrive from SQLite and from
+ * the filesystem peer as ordinary errors with a string on them. Collapsing
+ * them into one write failure would be the easy thing and the wrong one: an
+ * app frees space for the first, retries after unlock for the second, and has
+ * to offer a reset for the third.
+ *
+ * Only the code is derived here. The message never travels — it is redacted
+ * at construction by `StorageError` (FR-079).
+ */
+
+function textOf(error) {
+  if (error instanceof Error) {
+    return `${error.message} ${error.code ?? ''}`;
+  }
+  if (typeof error === 'string') {
+    return error;
+  }
+  return '';
+}
+const DISK_FULL = /SQLITE_FULL|database or disk is full|ENOSPC|no space left/i;
+const NOT_A_DATABASE = /SQLITE_NOTADB|file is not a database|encrypted or is not a database/i;
+const CORRUPT = /SQLITE_CORRUPT|database disk image is malformed|malformed database/i;
+const CONFLICT = /UNIQUE constraint failed|PRIMARY KEY must be unique|SQLITE_CONSTRAINT_PRIMARYKEY/i;
+const ACCESS = /SQLITE_CANTOPEN|SQLITE_READONLY|SQLITE_PERM|SQLITE_AUTH|EACCES|EPERM|EROFS|ENOENT|EISDIR/i;
+const BUSY = /SQLITE_BUSY|SQLITE_LOCKED|database is locked/i;
+function mapNativeError(error, context) {
+  const text = textOf(error);
+  if (DISK_FULL.test(text)) {
+    return _errors.DiagnosticCodes.DISK_FULL;
+  }
+  if (NOT_A_DATABASE.test(text)) {
+    // A wrong key and a corrupt file are indistinguishable from the engine's
+    // answer alone. Reporting corruption for a wrong key would push an app
+    // towards destroying recoverable data, so the encrypted case wins.
+    return context.encrypted ? _errors.DiagnosticCodes.KEY_INVALID : _errors.DiagnosticCodes.CORRUPTION;
+  }
+  if (CORRUPT.test(text)) {
+    return _errors.DiagnosticCodes.CORRUPTION;
+  }
+  if (CONFLICT.test(text)) {
+    return _errors.DiagnosticCodes.RECORD_CONFLICT;
+  }
+  if (ACCESS.test(text)) {
+    return _errors.DiagnosticCodes.STORAGE_ACCESS;
+  }
+  if (BUSY.test(text)) {
+    // Retryable, and distinct from a permanent write failure.
+    return context.operation === 'transaction' ? _errors.DiagnosticCodes.TRANSACTION_FAILED : _errors.DiagnosticCodes.WRITE_FAILED;
+  }
+  switch (context.operation) {
+    case 'open':
+      return _errors.DiagnosticCodes.OPEN_FAILED;
+    case 'read':
+      return _errors.DiagnosticCodes.STORAGE_ACCESS;
+    case 'transaction':
+      return _errors.DiagnosticCodes.TRANSACTION_FAILED;
+    case 'attachment':
+      return _errors.DiagnosticCodes.ATTACHMENT_WRITE_FAILED;
+    case 'delete':
+    case 'write':
+    default:
+      return _errors.DiagnosticCodes.WRITE_FAILED;
+  }
+}
+
+/**
+ * Re-raise a native failure as a typed one, preserving an error the package
+ * already classified rather than reclassifying it as a generic write failure.
+ */
+function raiseNative(error, context) {
+  if ((0, _errors2.isStorageError)(error)) {
+    throw error;
+  }
+  (0, _errors2.raise)(mapNativeError(error, context), {
+    // The native message is deliberately not the error's message. It goes
+    // through `cause`, which redacts it — passing it here as well would be
+    // two chances to leak the same string for no extra information.
+    message: `native ${context.operation} failed`,
+    detail: {
+      operation: context.operation
+    },
+    cause: error
+  });
+}
+//# sourceMappingURL=map-native.js.map

package/lib/commonjs/diagnostics/map-native.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["_errors","require","_errors2","textOf","error","Error","message","code","DISK_FULL","NOT_A_DATABASE","CORRUPT","CONFLICT","ACCESS","BUSY","mapNativeError","context","text","test","DiagnosticCodes","encrypted","KEY_INVALID","CORRUPTION","RECORD_CONFLICT","STORAGE_ACCESS","operation","TRANSACTION_FAILED","WRITE_FAILED","OPEN_FAILED","ATTACHMENT_WRITE_FAILED","raiseNative","isStorageError","raise","detail","cause"],"sourceRoot":"../../../src","sources":["diagnostics/map-native.ts"],"mappings":";;;;;;;AAcA,IAAAA,OAAA,GAAAC,OAAA;AACA,IAAAC,QAAA,GAAAD,OAAA;AAfA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAgBA,SAASE,MAAMA,CAACC,KAAc,EAAU;EACvC,IAAIA,KAAK,YAAYC,KAAK,EAAE;IAC3B,OAAO,GAAGD,KAAK,CAACE,OAAO,IAAKF,KAAK,CAAuBG,IAAI,IAAI,EAAE,EAAE;EACrE;EACA,IAAI,OAAOH,KAAK,KAAK,QAAQ,EAAE;IAC9B,OAAOA,KAAK;EACb;EACA,OAAO,EAAE;AACV;AAEA,MAAMI,SAAS,GAAG,4DAA4D;AAC9E,MAAMC,cAAc,GAAG,sEAAsE;AAC7F,MAAMC,OAAO,GAAG,qEAAqE;AACrF,MAAMC,QAAQ,GACb,mFAAmF;AACpF,MAAMC,MAAM,GACX,2FAA2F;AAC5F,MAAMC,IAAI,GAAG,+CAA+C;AAErD,SAASC,cAAcA,CAACV,KAAc,EAAEW,OAAsB,EAAkB;EACtF,MAAMC,IAAI,GAAGb,MAAM,CAACC,KAAK,CAAC;EAE1B,IAAII,SAAS,CAACS,IAAI,CAACD,IAAI,CAAC,EAAE;IACzB,OAAOE,uBAAe,CAACV,SAAS;EACjC;EACA,IAAIC,cAAc,CAACQ,IAAI,CAACD,IAAI,CAAC,EAAE;IAC9B;IACA;IACA;IACA,OAAOD,OAAO,CAACI,SAAS,GAAGD,uBAAe,CAACE,WAAW,GAAGF,uBAAe,CAACG,UAAU;EACpF;EACA,IAAIX,OAAO,CAACO,IAAI,CAACD,IAAI,CAAC,EAAE;IACvB,OAAOE,uBAAe,CAACG,UAAU;EAClC;EACA,IAAIV,QAAQ,CAACM,IAAI,CAACD,IAAI,CAAC,EAAE;IACxB,OAAOE,uBAAe,CAACI,eAAe;EACvC;EACA,IAAIV,MAAM,CAACK,IAAI,CAACD,IAAI,CAAC,EAAE;IACtB,OAAOE,uBAAe,CAACK,cAAc;EACtC;EACA,IAAIV,IAAI,CAACI,IAAI,CAACD,IAAI,CAAC,EAAE;IACpB;IACA,OAAOD,OAAO,CAACS,SAAS,KAAK,aAAa,GACvCN,uBAAe,CAACO,kBAAkB,GAClCP,uBAAe,CAACQ,YAAY;EAChC;EAEA,QAAQX,OAAO,CAACS,SAAS;IACxB,KAAK,MAAM;MACV,OAAON,uBAAe,CAACS,WAAW;IACnC,KAAK,MAAM;MACV,OAAOT,uBAAe,CAACK,cAAc;IACtC,KAAK,aAAa;MACjB,OAAOL,uBAAe,CAACO,kBAAkB;IAC1C,KAAK,YAAY;MAChB,OAAOP,uBAAe,CAACU,uBAAuB;IAC/C,KAAK,QAAQ;IACb,KAAK,OAAO;IACZ;MACC,OAAOV,uBAAe,CAACQ,YAAY;EACrC;AACD;;AAEA;AACA;AACA;AACA;AACO,SAASG,WAAWA,CAACzB,KAAc,EAAEW,OAAsB,EAAS;EAC1E,IAAI,IAAAe,uBAAc,EAAC1B,KAAK,CAAC,EAAE;IAC1B,MAAMA,KAAK;EACZ;EACA,IAAA2B,cAAK,EAACjB,cAAc,CAACV,KAAK,EAAEW,OAAO,CAAC,EAAE;IACrC;IACA;IACA;IACAT,OAAO,EAAE,UAAUS,OAAO,CAACS,SAAS,SAAS;IAC7CQ,MAAM,EAAE;MAAER,SAAS,EAAET,OAAO,CAACS;IAAU,CAAC;IACxCS,KAAK,EAAE7B;EACR,CAAC,CAAC;AACH","ignoreList":[]}

package/lib/commonjs/diagnostics/redact.js

@@ -0,0 +1,110 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.SAFE_DETAIL_KEYS = void 0;
+exports.redactCause = redactCause;
+exports.redactDetail = redactDetail;
+exports.redactForeignText = redactForeignText;
+exports.sanitizeAuthoredMessage = sanitizeAuthoredMessage;
+exports.sanitizeIdentifier = sanitizeIdentifier;
+var _rnCore = require("@chipmobilesdk/rn-core");
+/**
+ * Redaction, applied at construction rather than at logging time.
+ *
+ * The distinction matters: an error object that never held a payload cannot
+ * leak one through a consumer's crash reporter, which is where these leaks
+ * actually happen in practice. Redacting on the way out of a logger would
+ * still leave the values sitting on the object for anything else to pick up
+ * (FR-079, FR-099).
+ */
+
+/**
+ * The allowlist IS the mechanism. Every key here has been reviewed as
+ * incapable of carrying user data: identifiers the app already knows, sizes,
+ * counts, and version numbers.
+ *
+ * A denylist was tried and removed. It rejected `recordId` because the name
+ * contains "record", which is the failure mode denylists always have — they
+ * guess from names. A closed allowlist cannot guess, and adding to it is a
+ * deliberate act with a reviewer attached.
+ */
+const SAFE_DETAIL_KEYS = exports.SAFE_DETAIL_KEYS = new Set(['code', 'collection', 'recordId', 'attachmentId', 'scopeKey', 'version', 'recordedVersion', 'failingVersion', 'outcome', 'operation', 'adapter', 'platform', 'sizeBytes', 'limitBytes', 'count', 'limit']);
+
+/**
+ * Reduce foreign text to an identifier, or to nothing.
+ *
+ * "Foreign" means text this package did not author: a SQLite message, a
+ * filesystem error, an `Error` a consumer's own migration threw. Any of them
+ * can contain anything — SQLite quotes bound parameters back, and a migration
+ * that fails on a constraint routinely names the value that violated it.
+ *
+ * An earlier version of this tried to keep the readable part: the text before
+ * the first colon, if it "looked like a class of failure". That heuristic
+ * fails on the case that matters. `Patient reported chest pain` looks exactly
+ * like a class of failure — short, no punctuation, no digits — and is a
+ * medical record. There is no shape test that separates prose describing a
+ * failure from prose describing a person, so there is no version of the
+ * heuristic worth keeping.
+ *
+ * What survives is a leading `SQLITE_*` / `ENOENT`-style identifier, which is
+ * a closed vocabulary of engine and libc constants and cannot be a value.
+ * Everything else becomes `[redacted]`. A developer who needs more can
+ * reproduce with the development logger; a crash report cannot.
+ */
+function redactForeignText(text) {
+  return (0, _rnCore.leadingIdentifier)(text);
+}
+const MAX_AUTHORED_MESSAGE = 160;
+
+/**
+ * A message this package wrote itself.
+ *
+ * Every `raise()` call site passes a string literal, and the handful that
+ * interpolate do so with a value from a closed set — an operator name, a
+ * fault point, a sanitized identifier. `authored-messages.test.ts` enforces
+ * that mechanically against the source, so this is a checked property rather
+ * than a convention someone has to remember.
+ *
+ * So no filtering happens here: filtering a message the package wrote would
+ * destroy the only readable part of the error for no gain. Foreign text never
+ * reaches this function — it goes through `redactForeignText` above.
+ */
+function sanitizeAuthoredMessage(message) {
+  return message.split('\n')[0].trim().slice(0, MAX_AUTHORED_MESSAGE);
+}
+
+/**
+ * Reduce a consumer-supplied identifier to a bounded, punctuation-free token.
+ *
+ * A field name is worth naming — FR-034 exists so a typo is distinguishable
+ * from a deliberate choice, and "which field?" is the whole answer. But the
+ * name arrives from the consumer, so it is capped and stripped rather than
+ * trusted verbatim.
+ */
+function sanitizeIdentifier(identifier) {
+  const cleaned = identifier.replace(/\W/g, '').slice(0, 64);
+  return cleaned.length > 0 ? cleaned : _rnCore.REDACTED;
+}
+
+/** Keep only keys on the allowlist, and only primitive values. */
+function redactDetail(detail) {
+  const safe = (0, _rnCore.pickAllowed)(detail, SAFE_DETAIL_KEYS);
+  return safe && Object.keys(safe).length > 0 ? safe : undefined;
+}
+
+/** Reduce an unknown thrown value to a message-shaped string, redacted. */
+function redactCause(cause) {
+  if (cause === undefined || cause === null) {
+    return undefined;
+  }
+  if (cause instanceof Error) {
+    return redactForeignText(cause.message);
+  }
+  if (typeof cause === 'string') {
+    return redactForeignText(cause);
+  }
+  return _rnCore.REDACTED;
+}
+//# sourceMappingURL=redact.js.map

package/lib/commonjs/diagnostics/redact.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["_rnCore","require","SAFE_DETAIL_KEYS","exports","Set","redactForeignText","text","leadingIdentifier","MAX_AUTHORED_MESSAGE","sanitizeAuthoredMessage","message","split","trim","slice","sanitizeIdentifier","identifier","cleaned","replace","length","REDACTED","redactDetail","detail","safe","pickAllowed","Object","keys","undefined","redactCause","cause","Error"],"sourceRoot":"../../../src","sources":["diagnostics/redact.ts"],"mappings":";;;;;;;;;;;AAUA,IAAAA,OAAA,GAAAC,OAAA;AAVA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAIA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACO,MAAMC,gBAAgB,GAAAC,OAAA,CAAAD,gBAAA,GAAG,IAAIE,GAAG,CAAC,CACvC,MAAM,EACN,YAAY,EACZ,UAAU,EACV,cAAc,EACd,UAAU,EACV,SAAS,EACT,iBAAiB,EACjB,gBAAgB,EAChB,SAAS,EACT,WAAW,EACX,SAAS,EACT,UAAU,EACV,WAAW,EACX,YAAY,EACZ,OAAO,EACP,OAAO,CACP,CAAC;;AAEF;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACO,SAASC,iBAAiBA,CAACC,IAAY,EAAU;EACvD,OAAO,IAAAC,yBAAiB,EAACD,IAAI,CAAC;AAC/B;AAEA,MAAME,oBAAoB,GAAG,GAAG;;AAEhC;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACO,SAASC,uBAAuBA,CAACC,OAAe,EAAU;EAChE,OAAOA,OAAO,CAACC,KAAK,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC,CAAEC,IAAI,CAAC,CAAC,CAACC,KAAK,CAAC,CAAC,EAAEL,oBAAoB,CAAC;AACrE;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACO,SAASM,kBAAkBA,CAACC,UAAkB,EAAU;EAC9D,MAAMC,OAAO,GAAGD,UAAU,CAACE,OAAO,CAAC,KAAK,EAAE,EAAE,CAAC,CAACJ,KAAK,CAAC,CAAC,EAAE,EAAE,CAAC;EAC1D,OAAOG,OAAO,CAACE,MAAM,GAAG,CAAC,GAAGF,OAAO,GAAGG,gBAAQ;AAC/C;;AAEA;AACO,SAASC,YAAYA,CAC3BC,MAA2C,EACa;EACxD,MAAMC,IAAI,GAAG,IAAAC,mBAAW,EAACF,MAAM,EAAEnB,gBAAgB,CAAC;EAClD,OAAOoB,IAAI,IAAIE,MAAM,CAACC,IAAI,CAACH,IAAI,CAAC,CAACJ,MAAM,GAAG,CAAC,GAAGI,IAAI,GAAGI,SAAS;AAC/D;;AAEA;AACO,SAASC,WAAWA,CAACC,KAAc,EAAsB;EAC/D,IAAIA,KAAK,KAAKF,SAAS,IAAIE,KAAK,KAAK,IAAI,EAAE;IAC1C,OAAOF,SAAS;EACjB;EACA,IAAIE,KAAK,YAAYC,KAAK,EAAE;IAC3B,OAAOxB,iBAAiB,CAACuB,KAAK,CAAClB,OAAO,CAAC;EACxC;EACA,IAAI,OAAOkB,KAAK,KAAK,QAAQ,EAAE;IAC9B,OAAOvB,iBAAiB,CAACuB,KAAK,CAAC;EAChC;EACA,OAAOT,gBAAQ;AAChB","ignoreList":[]}

package/lib/commonjs/index.js

@@ -0,0 +1,70 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+Object.defineProperty(exports, "Budgets", {
+  enumerable: true,
+  get: function () {
+    return _config.Budgets;
+  }
+});
+Object.defineProperty(exports, "DiagnosticCodes", {
+  enumerable: true,
+  get: function () {
+    return _errors.DiagnosticCodes;
+  }
+});
+Object.defineProperty(exports, "StorageError", {
+  enumerable: true,
+  get: function () {
+    return _errors.StorageError;
+  }
+});
+Object.defineProperty(exports, "deleteDatabase", {
+  enumerable: true,
+  get: function () {
+    return _index.deleteDatabase;
+  }
+});
+Object.defineProperty(exports, "deleteScopeData", {
+  enumerable: true,
+  get: function () {
+    return _index.deleteScopeData;
+  }
+});
+Object.defineProperty(exports, "isCode", {
+  enumerable: true,
+  get: function () {
+    return _errors.isCode;
+  }
+});
+Object.defineProperty(exports, "isStorageError", {
+  enumerable: true,
+  get: function () {
+    return _errors.isStorageError;
+  }
+});
+Object.defineProperty(exports, "openDatabase", {
+  enumerable: true,
+  get: function () {
+    return _index.openDatabase;
+  }
+});
+Object.defineProperty(exports, "resetScope", {
+  enumerable: true,
+  get: function () {
+    return _index.resetScope;
+  }
+});
+Object.defineProperty(exports, "setDiagnosticLogger", {
+  enumerable: true,
+  get: function () {
+    return _devLog.setDiagnosticLogger;
+  }
+});
+var _index = require("./adapter/index.js");
+var _errors = require("./diagnostics/errors.js");
+var _devLog = require("./diagnostics/dev-log.js");
+var _config = require("./contract/config.js");
+//# sourceMappingURL=index.js.map

package/lib/commonjs/index.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["_index","require","_errors","_devLog","_config"],"sourceRoot":"../../src","sources":["index.ts"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAeA,IAAAA,MAAA,GAAAC,OAAA;AAGA,IAAAC,OAAA,GAAAD,OAAA;AACA,IAAAE,OAAA,GAAAF,OAAA;AAGA,IAAAG,OAAA,GAAAH,OAAA","ignoreList":[]}