@noy-db/hub 0.3.0-pre.10 → 0.3.0-pre.11

package/dist/chunk-67TNU77I.js

@@ -0,0 +1,36 @@
+import {
+  LookupHandle
+} from "./chunk-ELNBMFOS.js";
+
+// src/via/lookup/active.ts
+function withLookup() {
+  return {
+    buildLookupHandle(opts) {
+      return new LookupHandle(
+        opts.adapter,
+        opts.compartmentName,
+        opts.dimensionName,
+        opts.keyring,
+        opts.reservedEnvelopes,
+        opts.encrypted,
+        opts.ledger,
+        opts.options,
+        opts.findAndUpdateReferences,
+        opts.emitter,
+        opts.buildDeleteMarker,
+        // #647 fix wave 1
+        opts.onDirty,
+        // #650 Task 4
+        opts.onRecordMutated,
+        // #650 Task 4
+        opts.checkReferencesOnDelete
+        // #650 Task 5
+      );
+    }
+  };
+}
+
+export {
+  withLookup
+};
+//# sourceMappingURL=chunk-67TNU77I.js.map

package/dist/chunk-6QILBDZU.js

@@ -0,0 +1,205 @@
+import {
+  derivePassphraseKey
+} from "./chunk-HUS3J5WM.js";
+import {
+  NOYDB_FORMAT_VERSION
+} from "./chunk-CKZW6P5V.js";
+
+// src/with-party/team/wrapped-deks.ts
+var PBKDF2_ITERATIONS = 6e5;
+var SALT_BYTES = 32;
+var IV_BYTES = 12;
+var subtle = globalThis.crypto.subtle;
+async function mintWrappedDeksBlob(deks, credential) {
+  const salt = crypto.getRandomValues(new Uint8Array(SALT_BYTES));
+  const iv = crypto.getRandomValues(new Uint8Array(IV_BYTES));
+  const wrappingKey = await deriveWrappingKey(credential, salt);
+  const exported = {};
+  for (const [coll, dek] of deks) {
+    const raw = await subtle.exportKey("raw", dek);
+    exported[coll] = bytesToBase64(new Uint8Array(raw));
+  }
+  const plaintext = new TextEncoder().encode(JSON.stringify({ deks: exported }));
+  const ciphertext = await subtle.encrypt(
+    { name: "AES-GCM", iv },
+    wrappingKey,
+    plaintext
+  );
+  return {
+    salt: bytesToBase64(salt),
+    iv: bytesToBase64(iv),
+    wrappedDeks: bytesToBase64(new Uint8Array(ciphertext))
+  };
+}
+async function unwrapDeksFromBlob(blob, credential) {
+  const wrappingKey = await deriveWrappingKey(credential, base64ToBytes(blob.salt));
+  const plaintext = await subtle.decrypt(
+    { name: "AES-GCM", iv: base64ToBytes(blob.iv) },
+    wrappingKey,
+    base64ToBytes(blob.wrappedDeks)
+  );
+  const parsed = JSON.parse(new TextDecoder().decode(plaintext));
+  const deks = /* @__PURE__ */ new Map();
+  for (const [coll, b64] of Object.entries(parsed.deks)) {
+    const raw = base64ToBytes(b64);
+    const key = await subtle.importKey(
+      "raw",
+      raw,
+      { name: "AES-GCM", length: 256 },
+      true,
+      ["encrypt", "decrypt"]
+    );
+    deks.set(coll, key);
+  }
+  return deks;
+}
+async function deriveWrappingKey(credential, salt) {
+  return derivePassphraseKey(credential, salt, { iterations: PBKDF2_ITERATIONS, keyUsage: "aes-gcm" });
+}
+function bytesToBase64(b) {
+  let s = "";
+  for (const x of b) s += String.fromCharCode(x);
+  return btoa(s);
+}
+function base64ToBytes(b64) {
+  const s = atob(b64);
+  const out = new Uint8Array(s.length);
+  for (let i = 0; i < s.length; i++) out[i] = s.charCodeAt(i);
+  return out;
+}
+
+// src/with-party/team/recovery.ts
+var PAPER_DOC_ID = "recovery-paper";
+async function loadPaperRecoveryEntries(store, vault) {
+  const env = await store.get(vault, "_meta", PAPER_DOC_ID);
+  if (!env) return [];
+  try {
+    const doc = JSON.parse(env._data);
+    if (doc.profile !== "paper" || !Array.isArray(doc.entries)) return [];
+    return doc.entries;
+  } catch {
+    return [];
+  }
+}
+async function savePaperRecoveryEntries(store, vault, entries) {
+  const doc = {
+    _noydb_recovery: 1,
+    profile: "paper",
+    entries
+  };
+  const envelope = {
+    _noydb: NOYDB_FORMAT_VERSION,
+    _v: 1,
+    _ts: (/* @__PURE__ */ new Date()).toISOString(),
+    _iv: "",
+    _data: JSON.stringify(doc)
+  };
+  await store.put(vault, "_meta", PAPER_DOC_ID, envelope);
+}
+async function burnPaperRecoveryEntry(store, vault, codeId) {
+  const entries = await loadPaperRecoveryEntries(store, vault);
+  const remaining = entries.filter((e) => e.codeId !== codeId);
+  await savePaperRecoveryEntries(store, vault, remaining);
+}
+async function hasRecoveryEnrolled(store, vault) {
+  const paper = await loadPaperRecoveryEntries(store, vault);
+  if (paper.length > 0) return true;
+  const shamir = await loadShamirRecoveryEntries(store, vault);
+  return shamir.length > 0;
+}
+async function hasStrongRecoveryEnrolled(store, vault) {
+  const shamir = await loadShamirRecoveryEntries(store, vault);
+  return shamir.length > 0;
+}
+var SHAMIR_DOC_ID = "recovery-shamir";
+async function loadShamirRecoveryEntries(store, vault) {
+  const env = await store.get(vault, "_meta", SHAMIR_DOC_ID);
+  if (!env) return [];
+  try {
+    const doc = JSON.parse(env._data);
+    if (doc.profile !== "shamir" || !Array.isArray(doc.entries)) return [];
+    return doc.entries;
+  } catch {
+    return [];
+  }
+}
+async function saveShamirRecoveryEntries(store, vault, entries) {
+  const doc = {
+    _noydb_recovery: 1,
+    profile: "shamir",
+    entries
+  };
+  const envelope = {
+    _noydb: NOYDB_FORMAT_VERSION,
+    _v: 1,
+    _ts: (/* @__PURE__ */ new Date()).toISOString(),
+    _iv: "",
+    _data: JSON.stringify(doc)
+  };
+  await store.put(vault, "_meta", SHAMIR_DOC_ID, envelope);
+}
+async function mintShamirRecoveryEntry(provider, deks, entryId, k, n, label) {
+  const recoverySecret = crypto.getRandomValues(new Uint8Array(32));
+  try {
+    const credential = bytesToBase642(recoverySecret);
+    const blob = await mintWrappedDeksBlob(deks, credential);
+    const shareStrings = provider.splitToShares(recoverySecret, k, n);
+    const entry = {
+      ...blob,
+      entryId,
+      k,
+      n,
+      enrolledAt: (/* @__PURE__ */ new Date()).toISOString(),
+      ...label !== void 0 && { label }
+    };
+    return { entry, shareStrings };
+  } finally {
+    recoverySecret.fill(0);
+  }
+}
+async function unwrapDeksFromShamirEntry(provider, entry, shareStrings) {
+  if (shareStrings.length < entry.k) {
+    throw new Error(
+      `Insufficient shares: this Shamir entry needs ${entry.k} of ${entry.n}, but ${shareStrings.length} were provided.`
+    );
+  }
+  const secret = provider.combineShares(shareStrings);
+  try {
+    return await unwrapDeksFromBlob(entry, bytesToBase642(secret));
+  } finally {
+    secret.fill(0);
+  }
+}
+function bytesToBase642(b) {
+  let s = "";
+  for (const x of b) s += String.fromCharCode(x);
+  return btoa(s);
+}
+async function mintPaperRecoveryEntry(deks, code, codeId) {
+  const blob = await mintWrappedDeksBlob(deks, code);
+  return {
+    ...blob,
+    codeId,
+    enrolledAt: (/* @__PURE__ */ new Date()).toISOString()
+  };
+}
+async function unwrapDeksFromPaperEntry(entry, code) {
+  return unwrapDeksFromBlob(entry, code);
+}
+
+export {
+  mintWrappedDeksBlob,
+  unwrapDeksFromBlob,
+  loadPaperRecoveryEntries,
+  savePaperRecoveryEntries,
+  burnPaperRecoveryEntry,
+  hasRecoveryEnrolled,
+  hasStrongRecoveryEnrolled,
+  loadShamirRecoveryEntries,
+  saveShamirRecoveryEntries,
+  mintShamirRecoveryEntry,
+  unwrapDeksFromShamirEntry,
+  mintPaperRecoveryEntry,
+  unwrapDeksFromPaperEntry
+};
+//# sourceMappingURL=chunk-6QILBDZU.js.map

package/dist/chunk-7E67FJ33.js

@@ -0,0 +1,155 @@
+import {
+  ConflictError,
+  PodVersionConflictError
+} from "./chunk-FH542DDY.js";
+
+// src/with-pod/pod-store.ts
+var BUNDLE_STORE_VERSION = 1;
+var MAX_CONFLICT_RETRIES = 3;
+function wrapPodStore(bundle, options) {
+  const autoFlush = options?.autoFlush !== false;
+  const snapshots = /* @__PURE__ */ new Map();
+  const versions = /* @__PURE__ */ new Map();
+  const loaded = /* @__PURE__ */ new Set();
+  let batchDepth = 0;
+  async function load(vault) {
+    if (loaded.has(vault)) return snapshots.get(vault);
+    const result = await bundle.readBundle(vault);
+    if (result) {
+      const text = new TextDecoder().decode(result.bytes);
+      const format = JSON.parse(text);
+      snapshots.set(vault, format.data);
+      versions.set(vault, result.version);
+    } else {
+      snapshots.set(vault, {});
+      versions.set(vault, null);
+    }
+    loaded.add(vault);
+    return snapshots.get(vault);
+  }
+  async function flush(vault) {
+    const snapshot = snapshots.get(vault) ?? {};
+    const format = {
+      _noydb_bundle_store: BUNDLE_STORE_VERSION,
+      vault,
+      ts: (/* @__PURE__ */ new Date()).toISOString(),
+      data: snapshot
+    };
+    const bytes = new TextEncoder().encode(JSON.stringify(format));
+    const expectedVersion = versions.get(vault) ?? null;
+    for (let attempt = 0; attempt < MAX_CONFLICT_RETRIES; attempt++) {
+      try {
+        const { version: newVersion } = await bundle.writeBundle(vault, bytes, expectedVersion);
+        versions.set(vault, newVersion);
+        return;
+      } catch (err) {
+        if (err instanceof PodVersionConflictError && attempt < MAX_CONFLICT_RETRIES - 1) {
+          const remote = await bundle.readBundle(vault);
+          if (remote) {
+            const remoteText = new TextDecoder().decode(remote.bytes);
+            const remoteFormat = JSON.parse(remoteText);
+            const localSnap = snapshots.get(vault) ?? {};
+            const mergedSnap = mergeSnapshots(remoteFormat.data, localSnap);
+            snapshots.set(vault, mergedSnap);
+            versions.set(vault, remote.version);
+          }
+          continue;
+        }
+        throw err;
+      }
+    }
+  }
+  async function maybeFlush(vault) {
+    if (autoFlush && batchDepth === 0) {
+      await flush(vault);
+    }
+  }
+  const store = {
+    name: bundle.name ?? "bundle",
+    async flush(vaultId) {
+      await flush(vaultId);
+    },
+    async batch(vaultId, fn) {
+      await load(vaultId);
+      batchDepth++;
+      try {
+        await fn();
+      } finally {
+        batchDepth--;
+      }
+      await flush(vaultId);
+    },
+    async get(vault, collection, id) {
+      const snap = await load(vault);
+      return snap[collection]?.[id] ?? null;
+    },
+    async put(vault, collection, id, envelope, expectedVersion) {
+      const snap = await load(vault);
+      if (expectedVersion !== void 0) {
+        const current = snap[collection]?.[id];
+        const currentVersion = current?._v ?? 0;
+        if (currentVersion !== expectedVersion) {
+          throw new ConflictError(
+            currentVersion,
+            `Expected version ${expectedVersion} but found ${currentVersion} on ${collection}/${id}`
+          );
+        }
+      }
+      snap[collection] ??= {};
+      snap[collection][id] = envelope;
+      await maybeFlush(vault);
+    },
+    async delete(vault, collection, id) {
+      const snap = await load(vault);
+      if (snap[collection]) {
+        delete snap[collection][id];
+        await maybeFlush(vault);
+      }
+    },
+    async list(vault, collection) {
+      const snap = await load(vault);
+      return Object.keys(snap[collection] ?? {});
+    },
+    async loadAll(vault) {
+      return await load(vault);
+    },
+    async saveAll(vault, data) {
+      snapshots.set(vault, data);
+      loaded.add(vault);
+      await flush(vault);
+    }
+  };
+  return store;
+}
+function mergeSnapshots(remote, local) {
+  const merged = {};
+  for (const [coll, records] of Object.entries(remote)) {
+    merged[coll] = { ...records };
+  }
+  for (const [coll, records] of Object.entries(local)) {
+    if (!merged[coll]) {
+      merged[coll] = { ...records };
+      continue;
+    }
+    for (const [id, envelope] of Object.entries(records)) {
+      const existing = merged[coll][id];
+      if (!existing || envelope._ts >= existing._ts) {
+        merged[coll][id] = envelope;
+      }
+    }
+  }
+  return merged;
+}
+function createPodStore(factory) {
+  return factory;
+}
+var wrapBundleStore = wrapPodStore;
+var createBundleStore = createPodStore;
+
+export {
+  wrapPodStore,
+  createPodStore,
+  wrapBundleStore,
+  createBundleStore
+};
+//# sourceMappingURL=chunk-7E67FJ33.js.map

package/dist/chunk-7ITPJFGC.js

@@ -0,0 +1,50 @@
+import {
+  SatelliteConfigError
+} from "./chunk-FH542DDY.js";
+
+// src/with-shape/satellites/validate.ts
+function validateSatelliteDeclaration(input) {
+  if (input.baseIsSatellite) {
+    throw new SatelliteConfigError(
+      `R-S3: "${input.satellite}" declares satelliteOf "${input.satelliteOf}", which is itself a satellite \u2014 no satellite-of-satellite chains.`
+    );
+  }
+  if (input.crdtMode) {
+    throw new SatelliteConfigError(
+      `R-S8: crdtMode is refused on either member of a satellite pair in v1 (revert cannot compensate a merge).`
+    );
+  }
+  if (!input.fields || input.fields.length === 0) {
+    throw new SatelliteConfigError(`R-S5: satellite "${input.satellite}" must declare a non-empty fields list.`);
+  }
+  if (input.fields.includes("id")) {
+    throw new SatelliteConfigError(`R-S5: fields must not contain the shared key "id".`);
+  }
+  if (input.joined !== void 0 && (input.joined === input.satellite || input.joined === input.satelliteOf)) {
+    throw new SatelliteConfigError(`R-S5: joined name "${input.joined}" collides with a pair member.`);
+  }
+  if (input.joinedCollidesWithCollection) {
+    throw new SatelliteConfigError(`R-S5: joined name "${input.joined}" collides with an already-declared collection.`);
+  }
+  return Object.freeze({
+    base: input.satelliteOf,
+    satellite: input.satellite,
+    fields: Object.freeze([...input.fields]),
+    joined: input.joined
+  });
+}
+function hashFields(fields) {
+  const s = [...fields].sort().join("");
+  let h = 2166136261;
+  for (let i = 0; i < s.length; i++) {
+    h ^= s.charCodeAt(i);
+    h = Math.imul(h, 16777619) >>> 0;
+  }
+  return h.toString(16);
+}
+
+export {
+  validateSatelliteDeclaration,
+  hashFields
+};
+//# sourceMappingURL=chunk-7ITPJFGC.js.map

package/dist/chunk-7NS43EXZ.js

@@ -0,0 +1,117 @@
+import {
+  buildAccessibleBundle,
+  resolveAccessibleCollections
+} from "./chunk-BCYQA5BK.js";
+import {
+  sha256Hex
+} from "./chunk-HUS3J5WM.js";
+import {
+  NOYDB_FORMAT_VERSION
+} from "./chunk-CKZW6P5V.js";
+import {
+  ReadOnlyError
+} from "./chunk-FH542DDY.js";
+
+// src/with-audit/portability/withdraw-accessible.ts
+var FROZEN_SNAPSHOTS_COLLECTION = "_frozen_snapshots";
+var ENC = new TextEncoder();
+function randomId() {
+  const b = globalThis.crypto.getRandomValues(new Uint8Array(12));
+  return Array.from(b, (x) => x.toString(16).padStart(2, "0")).join("");
+}
+async function freezeSnapshotOnly(vault, collections, opts) {
+  const { name: vaultName, adapter } = vault._introspectState();
+  const closure = [];
+  for (const c of collections) {
+    for (const id of await adapter.list(vaultName, c)) closure.push({ collection: c, id });
+  }
+  const withdrawalId = opts.withdrawalId ?? `wd-${randomId()}`;
+  const snap = {};
+  for (const { collection, id } of closure) {
+    const env = await adapter.get(vaultName, collection, id);
+    if (env) (snap[collection] ??= {})[id] = env;
+  }
+  const frozenAt = (/* @__PURE__ */ new Date()).toISOString();
+  const body = JSON.stringify({ withdrawalId, frozenAt, by: opts.actorUserId, collections: snap });
+  const sha = await sha256Hex(ENC.encode(body));
+  await adapter.put(
+    vaultName,
+    FROZEN_SNAPSHOTS_COLLECTION,
+    withdrawalId,
+    { _noydb: NOYDB_FORMAT_VERSION, _v: 1, _ts: frozenAt, _iv: "", _data: body, _by: opts.actorUserId },
+    0
+  );
+  await vault._getLedgerOrNull()?.append({
+    op: "lifecycle",
+    collection: "",
+    id: "",
+    version: 0,
+    actor: opts.actorUserId,
+    payloadHash: "",
+    reason: `withdrawal-frozen-snapshot:${withdrawalId}:${sha}`
+  });
+  return { withdrawalId, sha256: sha, recordCount: closure.length, frozenAt };
+}
+async function freezeAndDeleteClosure(vault, collections, opts) {
+  const snapshot = opts.disposition === "freeze" ? await freezeSnapshotOnly(vault, collections, {
+    actorUserId: opts.actorUserId,
+    ...opts.withdrawalId ? { withdrawalId: opts.withdrawalId } : {}
+  }) : void 0;
+  const { name: vaultName, adapter } = vault._introspectState();
+  for (const c of collections) {
+    for (const id of await adapter.list(vaultName, c)) {
+      await vault.collection(c).delete(id);
+    }
+  }
+  return snapshot;
+}
+async function withdrawAccessibleData(vault, opts) {
+  const { keyring } = vault._introspectState();
+  const disposition = opts.disposition ?? "delete";
+  if (keyring.role === "owner" || keyring.role === "admin") {
+    throw new ReadOnlyError(
+      "unilateralWithdrawal is the scoped self-service path; an owner/admin should use extractPartition"
+    );
+  }
+  if (keyring.role === "custodian") {
+    throw new ReadOnlyError(
+      "a custodian cannot destructively withdraw/sever; use vault.custody.liberate for an audited ownership claim"
+    );
+  }
+  if (keyring.role === "client" || keyring.role === "viewer") {
+    throw new ReadOnlyError(
+      "read-only role cannot self-serve a destructive withdrawal \u2014 use requestWithdrawal (two-party)"
+    );
+  }
+  const collections = resolveAccessibleCollections(keyring, opts.scope, true);
+  if (!collections || collections.length === 0) {
+    throw new ReadOnlyError(
+      "unilateralWithdrawal requires rw access on the withdrawn collections \u2014 use requestWithdrawal for read-only scope"
+    );
+  }
+  const bundle = await buildAccessibleBundle(vault, collections, opts.reKey);
+  const snapshot = await freezeAndDeleteClosure(vault, collections, {
+    disposition,
+    actorUserId: keyring.userId,
+    ...opts.withdrawalId ? { withdrawalId: opts.withdrawalId } : {}
+  });
+  await vault._getLedgerOrNull()?.append({
+    op: "lifecycle",
+    collection: "",
+    id: "",
+    version: 0,
+    actor: keyring.userId,
+    payloadHash: "",
+    reason: `user-unilateral-withdrawal:${keyring.userId}:${disposition}:${opts.legalBasis}`
+  });
+  return snapshot ? { bundle, snapshot } : { bundle };
+}
+
+export {
+  FROZEN_SNAPSHOTS_COLLECTION,
+  randomId,
+  freezeSnapshotOnly,
+  freezeAndDeleteClosure,
+  withdrawAccessibleData
+};
+//# sourceMappingURL=chunk-7NS43EXZ.js.map