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

package/dist/chunk-G4JYND6L.js

@@ -1,42 +0,0 @@
-import {
-  NOYDB_FORMAT_VERSION
-} from "./chunk-YN5IAHN6.js";
-
-// src/with-party/policy/storage.ts
-var META_COLLECTION = "_meta";
-var POLICY_RECORD_ID = "policy";
-async function loadVaultPolicy(store, vault) {
-  const envelope = await store.get(vault, META_COLLECTION, POLICY_RECORD_ID);
-  if (!envelope) return void 0;
-  try {
-    const parsed = JSON.parse(envelope._data);
-    if (!isVaultPolicy(parsed)) return void 0;
-    return parsed;
-  } catch {
-    return void 0;
-  }
-}
-async function saveVaultPolicy(store, vault, policy) {
-  const envelope = {
-    _noydb: NOYDB_FORMAT_VERSION,
-    _v: 1,
-    _ts: (/* @__PURE__ */ new Date()).toISOString(),
-    _iv: "",
-    _data: JSON.stringify(policy)
-  };
-  await store.put(vault, META_COLLECTION, POLICY_RECORD_ID, envelope);
-}
-function isVaultPolicy(x) {
-  if (x === null || typeof x !== "object") return false;
-  if (!("gates" in x)) return false;
-  const gates = x.gates;
-  return gates !== null && typeof gates === "object";
-}
-
-export {
-  META_COLLECTION,
-  POLICY_RECORD_ID,
-  loadVaultPolicy,
-  saveVaultPolicy
-};
-//# sourceMappingURL=chunk-G4JYND6L.js.map

package/dist/chunk-G6XV4H65.js

@@ -1,59 +0,0 @@
-import {
-  ATTESTATIONS_COLLECTION,
-  loadOrCreateSigner
-} from "./chunk-PLS64NCS.js";
-import {
-  generateULID
-} from "./chunk-ZJADGNYF.js";
-import {
-  encrypt
-} from "./chunk-3OPY6MK2.js";
-import {
-  NOYDB_FORMAT_VERSION
-} from "./chunk-YN5IAHN6.js";
-import {
-  AttestationError
-} from "./chunk-S7VFUQM2.js";
-
-// src/with-audit/attestation/issue.ts
-import {
-  computeFieldHashes,
-  signPayloadCore,
-  encodeQr,
-  bytesToB64url
-} from "@noy-db/attestation";
-async function issueAttestationCore(ctx, args) {
-  if (ctx.role !== "owner") {
-    throw new AttestationError(`issueAttestation requires the 'owner' role; caller is '${ctx.role}'. Issuing a signed attestation is the firm's identity operation.`);
-  }
-  const src = await ctx.readRecord(args.collection, args.id);
-  if (!src) throw new AttestationError(`issueAttestation: source record '${args.collection}/${args.id}' not found.`);
-  const dek = await ctx.getDEK();
-  const signer = await loadOrCreateSigner(ctx.store, ctx.vault, () => Promise.resolve(dek));
-  const saltB64 = bytesToB64url(crypto.getRandomValues(new Uint8Array(16)));
-  let fieldHashes;
-  try {
-    fieldHashes = await computeFieldHashes(saltB64, args.fieldSchema, src.record);
-  } catch (e) {
-    throw new AttestationError(`issueAttestation: ${e.message}`);
-  }
-  const docId = generateULID();
-  const sig = await signPayloadCore({ v: 1, docId, salt: saltB64, keyId: signer.keyId, fieldHashes }, signer.privateKeyPkcs8B64);
-  const payload = { v: 1, docId, salt: saltB64, alg: "ed25519", keyId: signer.keyId, fieldHashes, sig };
-  const index = {
-    docId,
-    issuedAt: (/* @__PURE__ */ new Date()).toISOString(),
-    keyId: signer.keyId,
-    fieldPaths: args.fieldSchema.fields.map((f) => f.path),
-    sourceRefs: [{ collection: args.collection, id: args.id, version: src.version }]
-  };
-  const { iv, data } = await encrypt(JSON.stringify(index), dek);
-  const env = { _noydb: NOYDB_FORMAT_VERSION, _v: 1, _ts: index.issuedAt, _iv: iv, _data: data };
-  await ctx.store.put(ctx.vault, ATTESTATIONS_COLLECTION, docId, env);
-  return { docId, qr: encodeQr(payload), payload, keyId: signer.keyId, publicKeyB64: signer.publicKeyB64 };
-}
-
-export {
-  issueAttestationCore
-};
-//# sourceMappingURL=chunk-G6XV4H65.js.map

package/dist/chunk-GNMXXTMN.js

@@ -1,85 +0,0 @@
-import {
-  ATTESTATIONS_COLLECTION,
-  REVOKED_RECORD_ID,
-  loadOrCreateSigner
-} from "./chunk-PLS64NCS.js";
-import {
-  openEnvelopeJson
-} from "./chunk-MCHVVJIA.js";
-import {
-  encrypt
-} from "./chunk-3OPY6MK2.js";
-import {
-  NOYDB_FORMAT_VERSION
-} from "./chunk-YN5IAHN6.js";
-import {
-  AttestationError,
-  ConflictError
-} from "./chunk-S7VFUQM2.js";
-
-// src/with-audit/attestation/revoke.ts
-import { signRevocationList } from "@noy-db/attestation";
-function requireOwner(ctx, op) {
-  if (ctx.role !== "owner") {
-    throw new AttestationError(`${op} requires the 'owner' role; caller is '${ctx.role}'. Revocation is the firm's identity operation.`);
-  }
-}
-async function readSet(store, vault, dek) {
-  const env = await store.get(vault, ATTESTATIONS_COLLECTION, REVOKED_RECORD_ID);
-  if (!env) return { docIds: /* @__PURE__ */ new Set(), version: void 0 };
-  const set = JSON.parse(await openEnvelopeJson(env, dek));
-  return { docIds: new Set(set.docIds), version: env._v };
-}
-async function mutateSet(ctx, mutate) {
-  const dek = await ctx.getDEK();
-  for (let attempt = 0; attempt < 2; attempt++) {
-    const { docIds, version } = await readSet(ctx.store, ctx.vault, dek);
-    mutate(docIds);
-    const payload = { docIds: [...docIds].sort(), updatedAt: (/* @__PURE__ */ new Date()).toISOString() };
-    const { iv, data } = await encrypt(JSON.stringify(payload), dek);
-    const expectedVersion = version ?? 0;
-    const env = {
-      _noydb: NOYDB_FORMAT_VERSION,
-      _v: expectedVersion + 1,
-      _ts: payload.updatedAt,
-      _iv: iv,
-      _data: data
-    };
-    try {
-      await ctx.store.put(ctx.vault, ATTESTATIONS_COLLECTION, REVOKED_RECORD_ID, env, expectedVersion);
-      return;
-    } catch (e) {
-      if (e instanceof ConflictError && attempt === 0) continue;
-      throw e;
-    }
-  }
-}
-async function revokeDocCore(ctx, docId) {
-  requireOwner(ctx, "revokeAttestation");
-  const issued = await ctx.store.get(ctx.vault, ATTESTATIONS_COLLECTION, docId);
-  if (!issued) throw new AttestationError(`revokeAttestation: attestation '${docId}' not found (was it issued by this vault?).`);
-  await mutateSet(ctx, (ids) => ids.add(docId));
-}
-async function unrevokeDocCore(ctx, docId) {
-  requireOwner(ctx, "unrevokeAttestation");
-  await mutateSet(ctx, (ids) => ids.delete(docId));
-}
-async function getRevokedDocIdsCore(ctx) {
-  const dek = await ctx.getDEK();
-  const { docIds } = await readSet(ctx.store, ctx.vault, dek);
-  return [...docIds].sort();
-}
-async function publishRevocationListCore(ctx) {
-  requireOwner(ctx, "publishRevocationList");
-  const docIds = await getRevokedDocIdsCore(ctx);
-  const signer = await loadOrCreateSigner(ctx.store, ctx.vault, () => ctx.getDEK());
-  return signRevocationList(docIds, (/* @__PURE__ */ new Date()).toISOString(), signer.keyId, signer.privateKeyPkcs8B64);
-}
-
-export {
-  revokeDocCore,
-  unrevokeDocCore,
-  getRevokedDocIdsCore,
-  publishRevocationListCore
-};
-//# sourceMappingURL=chunk-GNMXXTMN.js.map

package/dist/chunk-HPWKV3YB.js

@@ -1,21 +0,0 @@
-import {
-  SealedRecordNotEnabledError
-} from "./chunk-S7VFUQM2.js";
-
-// src/with-audit/sealed-record/strategy.ts
-var NO_SEALED_RECORD = {
-  async sealRecordToHost() {
-    throw new SealedRecordNotEnabledError();
-  },
-  async revokeSealedRecord() {
-    throw new SealedRecordNotEnabledError();
-  },
-  async rotateRecordCek() {
-    throw new SealedRecordNotEnabledError();
-  }
-};
-
-export {
-  NO_SEALED_RECORD
-};
-//# sourceMappingURL=chunk-HPWKV3YB.js.map

package/dist/chunk-HY3AUMFI.js

@@ -1,41 +0,0 @@
-import {
-  NoydbError
-} from "./chunk-S7VFUQM2.js";
-
-// src/with-shape/links/names.ts
-var LINK_COLLECTION_PREFIX = "_links_";
-function linkCollectionName(name) {
-  return `${LINK_COLLECTION_PREFIX}${name}`;
-}
-function isLinkCollectionName(name) {
-  return name.startsWith(LINK_COLLECTION_PREFIX);
-}
-function linkRowKey(aId, bId) {
-  return `${encodeURIComponent(aId)}|${encodeURIComponent(bId)}`;
-}
-var LinkIntegrityError = class extends NoydbError {
-  link;
-  endpoint;
-  id;
-  count;
-  constructor(link, endpoint, id, count) {
-    super(
-      "LINK_INTEGRITY",
-      `Cannot delete "${endpoint}"/"${id}": ${count} link(s) in "${link}" still reference it (onDelete: 'strict').`
-    );
-    this.name = "LinkIntegrityError";
-    this.link = link;
-    this.endpoint = endpoint;
-    this.id = id;
-    this.count = count;
-  }
-};
-
-export {
-  LINK_COLLECTION_PREFIX,
-  linkCollectionName,
-  isLinkCollectionName,
-  linkRowKey,
-  LinkIntegrityError
-};
-//# sourceMappingURL=chunk-HY3AUMFI.js.map

package/dist/chunk-HYR4WZZ3.js

@@ -1,69 +0,0 @@
-import {
-  VDIG_ITERATIONS,
-  normalizeForVerify,
-  pbkdf2VerifyDigest
-} from "./chunk-LP7BEXCT.js";
-import {
-  bufferToBase64
-} from "./chunk-3OPY6MK2.js";
-
-// src/kernel/enclave/classify/bidx.ts
-var subtle = globalThis.crypto.subtle;
-var CLASSIFY_INDEX_KEY_DOMAIN = "noydb-classify-index-v1";
-var CLASSIFY_INDEX_SALT_DOMAIN = "noydb-classify-index-salt-v1";
-var COST_BYTE_V1 = 1;
-var CURRENT_COST_BYTE = COST_BYTE_V1;
-function iterationsForCostByte(b) {
-  if (b === COST_BYTE_V1) return VDIG_ITERATIONS;
-  return null;
-}
-async function deriveClassifyIndexKey(dek, collection, field) {
-  const rawDek = await subtle.exportKey("raw", dek);
-  const hkdfKey = await subtle.importKey("raw", rawDek, "HKDF", false, ["deriveBits"]);
-  const salt = new TextEncoder().encode(CLASSIFY_INDEX_KEY_DOMAIN);
-  const info = new TextEncoder().encode(JSON.stringify([CLASSIFY_INDEX_KEY_DOMAIN, collection, field]));
-  const bits = await subtle.deriveBits({ name: "HKDF", hash: "SHA-256", salt, info }, hkdfKey, 256);
-  return subtle.importKey("raw", bits, { name: "HMAC", hash: "SHA-256" }, false, ["sign"]);
-}
-async function deriveClassifyIndexSalt(dek, collection, field) {
-  const rawDek = await subtle.exportKey("raw", dek);
-  const hkdfKey = await subtle.importKey("raw", rawDek, "HKDF", false, ["deriveBits"]);
-  const salt = new TextEncoder().encode(CLASSIFY_INDEX_SALT_DOMAIN);
-  const info = new TextEncoder().encode(JSON.stringify([CLASSIFY_INDEX_SALT_DOMAIN, collection, field]));
-  const bits = await subtle.deriveBits({ name: "HKDF", hash: "SHA-256", salt, info }, hkdfKey, 256);
-  return new Uint8Array(bits);
-}
-async function mintAt(normalized, dek, collection, field, costByte) {
-  const iterations = iterationsForCostByte(costByte);
-  if (iterations == null) {
-    throw new Error(`bidx: unknown cost byte 0x${costByte.toString(16)}`);
-  }
-  const saltCf = await deriveClassifyIndexSalt(dek, collection, field);
-  const inner = await pbkdf2VerifyDigest(normalized, saltCf, iterations);
-  const kIdx = await deriveClassifyIndexKey(dek, collection, field);
-  const mac = await subtle.sign("HMAC", kIdx, inner);
-  const tag = new Uint8Array(1 + 32);
-  tag[0] = costByte;
-  tag.set(new Uint8Array(mac), 1);
-  return bufferToBase64(tag);
-}
-async function mintBidxTag(normalized, dek, collection, field) {
-  return mintAt(normalized, dek, collection, field, CURRENT_COST_BYTE);
-}
-
-// src/kernel/enclave/classify/find.ts
-async function computeBidxTarget(candidate, normalize, dek, collection, field, costByte) {
-  const resolvedCostByte = costByte ?? CURRENT_COST_BYTE;
-  const iters = iterationsForCostByte(resolvedCostByte);
-  if (iters === null) return null;
-  const normalized = normalizeForVerify(normalize, candidate);
-  return mintAt(normalized, dek, collection, field, resolvedCostByte);
-}
-
-export {
-  deriveClassifyIndexKey,
-  deriveClassifyIndexSalt,
-  mintBidxTag,
-  computeBidxTarget
-};
-//# sourceMappingURL=chunk-HYR4WZZ3.js.map

package/dist/chunk-ICXIFFYZ.js

@@ -1,355 +0,0 @@
-import {
-  generateULID
-} from "./chunk-ZJADGNYF.js";
-import {
-  AmendmentForbiddenError,
-  ConflictError,
-  InvariantError,
-  ValidationError
-} from "./chunk-S7VFUQM2.js";
-
-// src/with-commit/tx/transaction.ts
-var TxContext = class {
-  /** Stable id for this transaction; shared by all writes it performs. */
-  txId = generateULID();
-  /** @internal */
-  _ops = [];
-  /**
-   * @internal — write log built up in Phase 2. Each entry records the
-   * envelope captured BEFORE the write so a mid-batch failure can
-   * restore prior state via `revertExecuted`. Side-effect writes (e.g.
-   * recursive derivation outputs fired inside `Collection.put`) are
-   * appended here in execution order so they roll back alongside the
-   * main staged ops.
-   */
-  _executed = [];
-  /** @internal */
-  _db;
-  /**
-   * @internal — true when this TxContext was opened in amendment
-   * mode. Toggles the lazy-`beginAmendment` + role-check path on first
-   * `tx.vault(name)` and unlocks the post-Phase-2 invariant + audit run.
-   */
-  _amendment;
-  /** @internal — vaults that have already had `beginAmendment` called. */
-  _amendmentVaults = /* @__PURE__ */ new Map();
-  /** @internal */
-  constructor(db, amendment = false) {
-    this._db = db;
-    this._amendment = amendment;
-  }
-  /** Scope subsequent `collection()` calls to the named vault. */
-  vault(name) {
-    const v = this._db.vault(name);
-    if (this._amendment && !this._amendmentVaults.has(name)) {
-      const role = v.role;
-      if (role !== "admin" && role !== "owner" && role !== "custodian") {
-        throw new AmendmentForbiddenError(v.userId, role);
-      }
-      const reg = v._getGuardRegistry();
-      if (reg === null) {
-        throw new ValidationError(
-          `Vault "${name}": amendment mode requires at least one guardStrategy registered via createNoydb({ guardStrategies }). Open the vault with guardStrategies before calling db.transaction({ amendment: true }).`
-        );
-      }
-      reg.beginAmendment();
-      this._amendmentVaults.set(name, v);
-    }
-    return new TxVault(this, v);
-  }
-};
-var TxVault = class {
-  /** @internal */
-  _ctx;
-  /** @internal */
-  _vault;
-  /** @internal */
-  constructor(ctx, vault) {
-    this._ctx = ctx;
-    this._vault = vault;
-  }
-  /** Scope subsequent op calls to the named collection. */
-  collection(name) {
-    const c = this._vault.collection(name);
-    return new TxCollection(this._ctx, this._vault, c, name);
-  }
-};
-var TxCollection = class {
-  /** @internal */
-  _ctx;
-  /** @internal */
-  _vault;
-  /** @internal */
-  _coll;
-  /** @internal */
-  _name;
-  /** @internal */
-  constructor(ctx, vault, coll, name) {
-    this._ctx = ctx;
-    this._vault = vault;
-    this._coll = coll;
-    this._name = name;
-  }
-  /**
-   * Read the current committed value, or the most-recently-staged
-   * value from the same transaction if one exists.
-   */
-  async get(id) {
-    for (let i = this._ctx._ops.length - 1; i >= 0; i--) {
-      const op = this._ctx._ops[i];
-      if (op.vaultName === this._vault.name && op.collectionName === this._name && op.id === id) {
-        if (op.type === "delete") return null;
-        return op.record;
-      }
-    }
-    return this._coll.get(id);
-  }
-  /**
-   * Stage a put. Does not write until the transaction body returns.
-   * Supply `{ expectedVersion }` to enforce optimistic concurrency
-   * during the commit pre-flight.
-   */
-  put(id, record, options) {
-    const op = {
-      type: "put",
-      vaultName: this._vault.name,
-      collectionName: this._name,
-      id,
-      record
-    };
-    if (options?.expectedVersion !== void 0) op.expectedVersion = options.expectedVersion;
-    if (options?.reason !== void 0) op.reason = options.reason;
-    this._ctx._ops.push(op);
-  }
-  /**
-   * Stage a delete. Does not write until the transaction body returns.
-   * Supply `{ expectedVersion }` to enforce optimistic concurrency
-   * during the commit pre-flight.
-   */
-  delete(id, options) {
-    const op = {
-      type: "delete",
-      vaultName: this._vault.name,
-      collectionName: this._name,
-      id
-    };
-    if (options?.expectedVersion !== void 0) op.expectedVersion = options.expectedVersion;
-    this._ctx._ops.push(op);
-  }
-};
-async function runTransaction(db, fn, options, txInvariants) {
-  if (options?.amendment) {
-    if (typeof options.reason !== "string" || options.reason.trim().length === 0) {
-      throw new ValidationError(
-        "db.transaction({ amendment: true }) requires a non-empty `reason` string."
-      );
-    }
-  }
-  const ctx = new TxContext(db, options?.amendment === true);
-  const bodyResult = await fn(ctx);
-  if (ctx._ops.length === 0) {
-    if (ctx._amendment) {
-      for (const v of ctx._amendmentVaults.values()) {
-        const reg = v._getGuardRegistry();
-        if (reg !== null) {
-          reg.consumeChanges();
-          reg.consumeMeta();
-        }
-      }
-    }
-    return bodyResult;
-  }
-  const priorEnvelopes = /* @__PURE__ */ new Map();
-  const store = db._store;
-  const invariants = txInvariants ?? [];
-  const watchedScopes = new Set(invariants.map((i) => i.scope));
-  const plainBefore = /* @__PURE__ */ new Map();
-  for (const op of ctx._ops) {
-    const key = keyOf(op);
-    if (!priorEnvelopes.has(key)) {
-      const env = await store.get(op.vaultName, op.collectionName, op.id);
-      priorEnvelopes.set(key, env);
-    }
-    if (watchedScopes.has(op.collectionName) && !plainBefore.has(key)) {
-      const prior = await db.vault(op.vaultName).collection(op.collectionName).get(op.id);
-      plainBefore.set(key, prior ?? null);
-    }
-    if (op.expectedVersion !== void 0) {
-      const env = priorEnvelopes.get(key) ?? null;
-      const actual = env?._v ?? 0;
-      if (actual !== op.expectedVersion) {
-        throw new ConflictError(
-          actual,
-          `Transaction pre-flight: ${op.vaultName}/${op.collectionName}/${op.id} expected v${op.expectedVersion}, found v${actual}`
-        );
-      }
-    }
-  }
-  db._setActiveTxContext(ctx);
-  try {
-    try {
-      for (const op of ctx._ops) {
-        const coll = db.vault(op.vaultName).collection(op.collectionName);
-        const key = keyOf(op);
-        const prior = priorEnvelopes.get(key) ?? null;
-        ctx._executed.push({ op, priorEnvelope: prior });
-        if (op.type === "put") {
-          await coll.put(op.id, op.record, op.reason !== void 0 ? { reason: op.reason } : void 0);
-        } else {
-          await coll.delete(op.id);
-        }
-      }
-    } catch (err) {
-      await revertExecuted(ctx._executed, store, db);
-      if (ctx._amendment) {
-        for (const v of ctx._amendmentVaults.values()) {
-          const reg = v._getGuardRegistry();
-          if (reg !== null) {
-            reg.consumeChanges();
-            reg.consumeMeta();
-          }
-        }
-      }
-      throw err;
-    }
-  } finally {
-    db._clearActiveTxContext(ctx);
-  }
-  if (ctx._amendment) {
-    const { GuardExecutor } = await import("./executor-ZHTJJICG.js");
-    try {
-      for (const [vaultName, v] of ctx._amendmentVaults) {
-        const registry = v._getGuardRegistry();
-        if (registry === null) continue;
-        const changesByCollection = registry.consumeChanges();
-        const meta = registry.consumeMeta();
-        if (changesByCollection.size === 0) continue;
-        const readOnlyVault = v._getReadOnlyFacade();
-        if (readOnlyVault === null) continue;
-        const invariantsPassed = [];
-        for (const [collection, changes] of changesByCollection) {
-          const guards = registry.guardsFor(collection).filter((g) => g.amendment !== void 0);
-          for (const guard of guards) {
-            await GuardExecutor.runInvariant(guard, changes, {
-              existing: null,
-              vault: readOnlyVault,
-              userId: v.userId,
-              role: v.role
-            });
-          }
-          if (guards.length > 0) invariantsPassed.push(collection);
-        }
-        const ledger = v._getLedgerOrNull();
-        if (ledger) {
-          const role = v.role;
-          const amendment = {
-            reason: options.reason,
-            role,
-            changes: meta,
-            invariantsPassed
-          };
-          await ledger.append({
-            op: "amendment",
-            collection: "",
-            id: "",
-            version: 0,
-            actor: v.userId,
-            // No payload to hash — the per-record entries already
-            // captured `payloadHash` at their own append time. We use
-            // a sha256 of the canonical reason string so the field is
-            // populated with something deterministic and non-empty.
-            payloadHash: "",
-            amendment
-          });
-        }
-        void vaultName;
-      }
-    } catch (err) {
-      await revertExecuted(ctx._executed, store, db);
-      throw err instanceof InvariantError ? err : new InvariantError(
-        err instanceof Error ? err.message : `invariant violated: ${String(err)}`
-      );
-    }
-  }
-  if (invariants.length > 0) {
-    const lastOp = /* @__PURE__ */ new Map();
-    const order = [];
-    for (const op of ctx._ops) {
-      const key = keyOf(op);
-      if (!lastOp.has(key)) order.push(key);
-      lastOp.set(key, op);
-    }
-    const changesByScope = /* @__PURE__ */ new Map();
-    const scopeVault = /* @__PURE__ */ new Map();
-    for (const key of order) {
-      const op = lastOp.get(key);
-      if (!watchedScopes.has(op.collectionName)) continue;
-      const before = plainBefore.get(key) ?? null;
-      const after = op.type === "delete" ? null : op.record ?? null;
-      const change = { before, after };
-      const arr = changesByScope.get(op.collectionName);
-      if (arr) arr.push(change);
-      else changesByScope.set(op.collectionName, [change]);
-      scopeVault.set(op.collectionName, op.vaultName);
-    }
-    try {
-      for (const inv of invariants) {
-        const changes = changesByScope.get(inv.scope);
-        if (changes === void 0 || changes.length === 0) continue;
-        const vaultName = scopeVault.get(inv.scope);
-        const v = db.vault(vaultName);
-        const facade = v._getReadOnlyFacade() ?? {
-          collection(name) {
-            const c = v.collection(name);
-            return {
-              get: (id) => c.get(id),
-              list: () => c.list(),
-              query: () => c.query()
-            };
-          }
-        };
-        const ctxForInv = {
-          existing: null,
-          vault: facade,
-          userId: v.userId,
-          role: v.role
-        };
-        await inv.check(changes, ctxForInv);
-      }
-    } catch (err) {
-      await revertExecuted(ctx._executed, store, db);
-      throw err instanceof InvariantError ? err : new InvariantError(
-        err instanceof Error ? err.message : `invariant violated: ${String(err)}`
-      );
-    }
-  }
-  return bodyResult;
-}
-async function revertExecuted(executed, store, db) {
-  for (const { op, priorEnvelope } of executed.slice().reverse()) {
-    try {
-      if (priorEnvelope) {
-        await store.put(op.vaultName, op.collectionName, op.id, priorEnvelope);
-      } else {
-        await store.delete(op.vaultName, op.collectionName, op.id);
-      }
-      if (db) {
-        const coll = db.vault(op.vaultName).collection(op.collectionName);
-        await coll._invalidateCacheEntry(op.id);
-      }
-    } catch {
-    }
-  }
-}
-function keyOf(op) {
-  return `${op.vaultName}\0${op.collectionName}\0${op.id}`;
-}
-
-export {
-  TxContext,
-  TxVault,
-  TxCollection,
-  runTransaction,
-  revertExecuted
-};
-//# sourceMappingURL=chunk-ICXIFFYZ.js.map