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

package/dist/chunk-XREOISSI.js

@@ -1,40 +0,0 @@
-import {
-  NOYDB_FORMAT_VERSION
-} from "./chunk-YN5IAHN6.js";
-
-// src/with-shape/schema-update/fence.ts
-var FENCE_RECORD_ID = "schema-fence";
-var META_COLLECTION = "_meta";
-var DEFAULT_FENCE = { currentSchemaVersion: 0, fenceState: "normal" };
-async function loadFence(store, vault) {
-  const envelope = await store.get(vault, META_COLLECTION, FENCE_RECORD_ID);
-  if (!envelope) return DEFAULT_FENCE;
-  try {
-    const parsed = JSON.parse(envelope._data);
-    if (!isFenceDoc(parsed)) return DEFAULT_FENCE;
-    return parsed;
-  } catch {
-    return DEFAULT_FENCE;
-  }
-}
-async function saveFence(store, vault, fence) {
-  const envelope = {
-    _noydb: NOYDB_FORMAT_VERSION,
-    _v: 1,
-    _ts: (/* @__PURE__ */ new Date()).toISOString(),
-    _iv: "",
-    _data: JSON.stringify(fence)
-  };
-  await store.put(vault, META_COLLECTION, FENCE_RECORD_ID, envelope);
-}
-function isFenceDoc(x) {
-  if (x === null || typeof x !== "object") return false;
-  const o = x;
-  return typeof o["currentSchemaVersion"] === "number" && (o["fenceState"] === "normal" || o["fenceState"] === "draining" || o["fenceState"] === "migrating" || o["fenceState"] === "complete");
-}
-
-export {
-  loadFence,
-  saveFence
-};
-//# sourceMappingURL=chunk-XREOISSI.js.map

package/dist/chunk-XUBPSPKD.js

@@ -1,164 +0,0 @@
-import {
-  ViaGraph
-} from "./chunk-FUOE7UUV.js";
-import {
-  sha256Hex
-} from "./chunk-3OPY6MK2.js";
-import {
-  DerivationCycleError
-} from "./chunk-S7VFUQM2.js";
-
-// src/with-formula/derivations/strategy-hash.ts
-async function computeStrategyHash(source, outputKeys, derive, sources) {
-  const canonical = JSON.stringify({
-    source,
-    outputs: [...outputKeys].sort(),
-    derive: derive.toString(),
-    // Declared sibling sources — adding/removing a trigger
-    // collection invalidates cached derived records. Omitted when empty
-    // so strategies without siblings keep their existing hash.
-    ...sources?.length ? { sources: [...sources].sort() } : {}
-  });
-  const bytes = new TextEncoder().encode(canonical);
-  return sha256Hex(bytes);
-}
-
-// src/with-formula/derivations/registry.ts
-var WHOLE_RECORD = "*";
-function stripArtifactSuffix(displayId) {
-  const suffix = `.${WHOLE_RECORD}`;
-  return displayId.endsWith(suffix) ? displayId.slice(0, -suffix.length) : displayId;
-}
-var DerivationRegistry = class {
-  _bySource = /* @__PURE__ */ new Map();
-  _byOutput = /* @__PURE__ */ new Map();
-  // eslint-disable-next-line @typescript-eslint/no-explicit-any
-  async register(spec) {
-    const outputKeys = Object.keys(spec.outputs);
-    const strategyHash = await computeStrategyHash(spec.source, outputKeys, spec.derive, spec.sources);
-    const reg = { spec, strategyHash };
-    const fromSource = this._bySource.get(spec.source);
-    if (fromSource) fromSource.push(reg);
-    else this._bySource.set(spec.source, [reg]);
-    for (const extra of spec.sources ?? []) {
-      const fromExtra = this._bySource.get(extra);
-      if (fromExtra) fromExtra.push(reg);
-      else this._bySource.set(extra, [reg]);
-    }
-    for (const t of spec.triggerBy ?? []) {
-      const fromTrigger = this._bySource.get(t.collection);
-      if (fromTrigger) fromTrigger.push(reg);
-      else this._bySource.set(t.collection, [reg]);
-    }
-    if (spec.rollup) {
-      const fromRollup = this._bySource.get(spec.rollup.from);
-      if (fromRollup) fromRollup.push(reg);
-      else this._bySource.set(spec.rollup.from, [reg]);
-    }
-    for (const key of outputKeys) {
-      const output = spec.outputs[key];
-      if (!output) continue;
-      const outputCollection = output.collection;
-      const arr = this._byOutput.get(outputCollection);
-      if (arr) arr.push(reg);
-      else this._byOutput.set(outputCollection, [reg]);
-    }
-  }
-  strategiesForSource(source) {
-    return this._bySource.get(source) ?? [];
-  }
-  strategiesProducingOutput(collection) {
-    return this._byOutput.get(collection) ?? [];
-  }
-  /**
-   * All registered strategies as a flat, deduplicated array.
-   * Each strategy is indexed once per source (not once per output key),
-   * so iterating `_bySource.values()` naturally yields each strategy
-   * exactly once per source — deduplication is handled by flattening
-   * the per-source arrays and collecting into a Set by identity.
-   *
-   * Used by `dumpSchema()` / `describeDerivations()` in the introspection
-   * walker to populate the derivations map.
-   */
-  all() {
-    const seen = /* @__PURE__ */ new Set();
-    for (const strategies of this._bySource.values()) {
-      for (const s of strategies) seen.add(s);
-    }
-    return [...seen];
-  }
-  /**
-   * Graph edges for #638 Task 2: one `'derivation'`/`'record'` edge per
-   * (non-self-write) output key — target = the output collection (a
-   * `WHOLE_RECORD` artifact node), sources = every collection that can
-   * trigger this strategy (`source`, `sources[]`, `triggerBy[].collection`,
-   * and — for a rollup — `rollup.from`), mirroring EXACTLY the trigger keys
-   * `register()` indexes under `_bySource`. The self-write reverse-denorm
-   * output (`output.collection === source` with `denorm` declared) is
-   * skipped — the SAME condition the old local DFS used; it is not a cycle
-   * (see the comment `validate()` used to carry, now on this skip).
-   * Rollups ADDITIONALLY get a dedicated `'rollup'`/`'aggregate'` edge
-   * targeting the real `rollup.field` on the parent (`source`) — the
-   * self-write output above only covers the cycle-DFS skip, not
-   * dispatch/taint (Tasks 3/4/6), which need the real field.
-   */
-  edges() {
-    const out = [];
-    for (const reg of this.all()) {
-      const spec = reg.spec;
-      const triggerCollections = [
-        spec.source,
-        ...spec.sources ?? [],
-        ...(spec.triggerBy ?? []).map((t) => t.collection),
-        ...spec.rollup ? [spec.rollup.from] : []
-      ];
-      const sources = triggerCollections.map((c) => ({ collection: c, field: WHOLE_RECORD }));
-      for (const key of Object.keys(spec.outputs)) {
-        const output = spec.outputs[key];
-        if (!output) continue;
-        if (output.shape === "record" && output.collection === spec.source && output.denorm !== void 0) continue;
-        out.push({ target: { collection: output.collection, field: WHOLE_RECORD }, sources, kind: "derivation", grain: "record" });
-      }
-      if (spec.rollup) {
-        out.push({
-          target: { collection: spec.source, field: spec.rollup.field },
-          sources: [{ collection: spec.rollup.from, field: WHOLE_RECORD }],
-          kind: "rollup",
-          grain: "aggregate"
-        });
-      }
-    }
-    return out;
-  }
-  /**
-   * Cycle detection, delegated to `ViaGraph.assertAcyclic()` (#638 Task 2 —
-   * retires the local DFS). Call after all `register()` calls complete (i.e.
-   * at vault open). Throws `DerivationCycleError` on the first cycle found —
-   * SAME class/timing as before; the message/path is byte-identical to the
-   * pre-#638 shape for a pure record-shape derivation cycle (the
-   * `WHOLE_RECORD` artifact suffix is stripped back to a bare collection
-   * name before re-throwing).
-   *
-   * `graph` is the caller's shared per-vault graph, ALREADY carrying this
-   * registry's `edges()` (the caller registers them — see `Vault._initDerivations`)
-   * — omit it (e.g. this registry's own unit tests) to validate this
-   * registry's edges in isolation against a throwaway graph.
-   */
-  validate(graph) {
-    const g = graph ?? new ViaGraph();
-    if (!graph) {
-      for (const edge of this.edges()) g.registerDerived(edge.target, edge.sources, edge.kind, edge.grain);
-    }
-    try {
-      g.assertAcyclic();
-    } catch (e) {
-      if (e instanceof DerivationCycleError) throw new DerivationCycleError(e.path.map(stripArtifactSuffix));
-      throw e;
-    }
-  }
-};
-
-export {
-  DerivationRegistry
-};
-//# sourceMappingURL=chunk-XUBPSPKD.js.map

package/dist/chunk-Y3A5CB5G.js

@@ -1,247 +0,0 @@
-// src/via/classified/validators.ts
-function luhnCheck(pan) {
-  const digits = pan.replace(/[\s-]/g, "");
-  if (!/^\d{12,19}$/.test(digits)) return false;
-  let sum = 0;
-  for (let i = 0; i < digits.length; i++) {
-    let d = Number(digits[digits.length - 1 - i]);
-    if (i % 2 === 1) {
-      d *= 2;
-      if (d > 9) d -= 9;
-    }
-    sum += d;
-  }
-  return sum % 10 === 0;
-}
-
-// src/via/classified/presets.ts
-var digitsOf = (v) => String(v).replace(/\D/g, "");
-function panSpec() {
-  return {
-    _noydbClassified: true,
-    _viaBrand: "classified",
-    preset: "creditCard.pan",
-    storage: "recoverable",
-    sensitivity: "secret",
-    list: { kind: "mask", pattern: "\u2022\u2022\u2022\u2022 ${last4}" },
-    riders: { last4: (v) => digitsOf(v).slice(-4), bin: (v) => digitsOf(v).slice(0, 6) },
-    validate: (v) => typeof v === "string" && luhnCheck(v) ? null : "not a Luhn-valid card number"
-  };
-}
-function expirySpec() {
-  return {
-    _noydbClassified: true,
-    _viaBrand: "classified",
-    preset: "creditCard.expiry",
-    storage: "recoverable",
-    sensitivity: "pii",
-    list: { kind: "mask", pattern: "\u2022\u2022/\u2022\u2022" },
-    validate: (v) => typeof v === "string" && /^(0[1-9]|1[0-2])\/\d{2}$/.test(v) ? null : "expected MM/YY"
-  };
-}
-function cvcSpec() {
-  return {
-    _noydbClassified: true,
-    _viaBrand: "classified",
-    preset: "creditCard.cvc",
-    storage: "never",
-    sensitivity: "secret",
-    list: { kind: "omit" },
-    validate: (v) => typeof v === "string" && /^\d{3,4}$/.test(v) ? null : "expected 3-4 digits"
-  };
-}
-var classified = {
-  /** Composite card type. PAN sealed + last4/bin riders; CVC is storage:'never' (PCI-aware). */
-  creditCard(fields) {
-    const members = { [fields.pan]: panSpec() };
-    if (fields.expiry !== void 0) members[fields.expiry] = expirySpec();
-    if (fields.cvc !== void 0) members[fields.cvc] = cvcSpec();
-    return { _noydbClassifiedGroup: true, _viaBrand: "classified", preset: "creditCard", members };
-  },
-  birthDate() {
-    return {
-      _noydbClassified: true,
-      _viaBrand: "classified",
-      preset: "birthDate",
-      storage: "recoverable",
-      sensitivity: "pii",
-      list: { kind: "mask", pattern: "${yob}-\u2022\u2022-\u2022\u2022" },
-      riders: { yob: (v) => String(v).slice(0, 4) },
-      validate: (v) => {
-        if (typeof v !== "string" || !/^\d{4}-\d{2}-\d{2}$/.test(v)) return "expected ISO yyyy-mm-dd";
-        const parts = v.split("-").map(Number);
-        const year = parts[0], month = parts[1], day = parts[2];
-        if (month < 1 || month > 12) return "not a valid calendar date";
-        const daysInMonth = [31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31];
-        const isLeapYear = year % 4 === 0 && year % 100 !== 0 || year % 400 === 0;
-        const maxDay = month === 2 && isLeapYear ? 29 : daysInMonth[month - 1];
-        if (day < 1 || day > maxDay) return "not a valid calendar date";
-        return null;
-      }
-    };
-  },
-  email() {
-    return {
-      _noydbClassified: true,
-      _viaBrand: "classified",
-      preset: "email",
-      storage: "recoverable",
-      sensitivity: "pii",
-      list: { kind: "mask", pattern: "\u2022\u2022\u2022@${domain}" },
-      riders: { domain: (v) => String(v).split("@")[1] ?? "" },
-      validate: (v) => typeof v === "string" && v.includes("@") ? null : "expected an email address"
-    };
-  },
-  phone() {
-    return {
-      _noydbClassified: true,
-      _viaBrand: "classified",
-      preset: "phone",
-      storage: "recoverable",
-      sensitivity: "pii",
-      list: { kind: "mask", pattern: "\u2022\u2022\u2022\u2022\u2022${last2}" },
-      riders: { last2: (v) => digitsOf(v).slice(-2) },
-      validate: (v) => digitsOf(v).length >= 5 ? null : "expected at least 5 digits"
-    };
-  },
-  /** Digest-only password: verify-without-reveal; never listed, never revealed.
-   *  Enumeration math is on the caller for low-entropy values — see the
-   *  per-preset docs; the hub ships no rate limiter in this slice (spec §5).
-   *
-   *  @param opts.equatable — emit a store-visible `_bidx` equality tag (enables
-   *  `findByDigest`). Cost band you are accepting:
-   *
-   *  equal values produce equal store-visible tags: anyone with store access
-   *  learns which records share this secret and how many share each value —
-   *  never the value itself. A collection-DEK holder can additionally test
-   *  candidate values offline: the tag's inner digest is PBKDF2-SHA256 (600K),
-   *  which is GPU/ASIC-friendly — an offline attacker runs on the order of
-   *  10⁴–10⁸ guesses/second, so for low-entropy secrets (PINs, casefolded secret
-   *  answers) offline recovery of the equality partition is seconds-to-hours, not
-   *  years. `crypto.subtle` exposes no memory-hard KDF (no scrypt/argon2) and the
-   *  family's no-crypto-deps law forbids adding one, so PBKDF2-SHA256 is the
-   *  hardest primitive available; the iteration count raises the price but does
-   *  not make a low-entropy field safe. The real control for low-entropy fields
-   *  is the DOOR — do not enable `equatable` for them unless the partition being
-   *  learnable is acceptable — not the iteration count. Pre-forget backups retain
-   *  tags. */
-  password(opts = {}) {
-    const minLength = opts.minLength ?? 10;
-    const notLastN = opts.notLastN ?? 0;
-    if (!Number.isInteger(notLastN) || notLastN < 0 || notLastN > 8) {
-      throw new Error(`classified.password: notLastN must be an integer 0..8 (write cost is n \xD7 600K PBKDF2; ring blast radius is documented), got ${notLastN}`);
-    }
-    return {
-      _noydbClassified: true,
-      _viaBrand: "classified",
-      preset: "password",
-      storage: "digest-only",
-      sensitivity: "secret",
-      list: { kind: "omit" },
-      verifyNormalize: "password",
-      ...opts.rotateDays !== void 0 ? { rotateDays: opts.rotateDays } : {},
-      ...notLastN > 0 ? { notLastN } : {},
-      ...opts.equatable === true ? { equatable: true } : {},
-      validate: (v) => typeof v === "string" && v.normalize("NFC").length >= minLength ? null : `password must be at least ${minLength} characters`
-    };
-  },
-  /** Digest-only secret answer: normalized (casefold/trim/collapse), groupable
-   *  into k-of-n matchGroup challenges. Low-entropy by nature — document the
-   *  enumeration math to your users; add app-side rate limiting.
-   *
-   *  @param opts.equatable — emit a store-visible `_bidx` equality tag (enables
-   *  `findByDigest`). Cost band you are accepting:
-   *
-   *  equal values produce equal store-visible tags: anyone with store access
-   *  learns which records share this secret and how many share each value —
-   *  never the value itself. A collection-DEK holder can additionally test
-   *  candidate values offline: the tag's inner digest is PBKDF2-SHA256 (600K),
-   *  which is GPU/ASIC-friendly — an offline attacker runs on the order of
-   *  10⁴–10⁸ guesses/second, so for low-entropy secrets (PINs, casefolded secret
-   *  answers) offline recovery of the equality partition is seconds-to-hours, not
-   *  years. `crypto.subtle` exposes no memory-hard KDF (no scrypt/argon2) and the
-   *  family's no-crypto-deps law forbids adding one, so PBKDF2-SHA256 is the
-   *  hardest primitive available; the iteration count raises the price but does
-   *  not make a low-entropy field safe. The real control for low-entropy fields
-   *  is the DOOR — do not enable `equatable` for them unless the partition being
-   *  learnable is acceptable — not the iteration count. Pre-forget backups retain
-   *  tags. */
-  secretAnswer(opts = {}) {
-    return {
-      _noydbClassified: true,
-      _viaBrand: "classified",
-      preset: "secretAnswer",
-      storage: "digest-only",
-      sensitivity: "secret",
-      list: { kind: "omit" },
-      verifyNormalize: "secret-answer",
-      verifyGroupMember: true,
-      ...opts.equatable === true ? { equatable: true } : {},
-      validate: (v) => typeof v === "string" && v.normalize("NFC").toLowerCase().trim().replace(/\s+/g, " ").length > 0 ? null : "secret answer must be non-empty after normalization"
-    };
-  }
-};
-
-// src/via/classified/active.ts
-function policyOf(spec) {
-  return {
-    normalize: spec.verifyNormalize ?? "password",
-    notLastN: spec.notLastN ?? 0,
-    equatable: spec.equatable === true,
-    ...spec.rotateDays !== void 0 ? { rotateDays: spec.rotateDays } : {}
-  };
-}
-var engineCtx = (ctx) => ({
-  collection: ctx.collection,
-  getEnvelope: ctx.getEnvelope,
-  resolveCek: ctx.resolveCek,
-  getDEK: ctx.getDEK,
-  now: ctx.now
-});
-function withClassified() {
-  return {
-    async reveal(ctx, id, field) {
-      const { revealSealedField } = await import("./reveal-R3JLHMUF.js");
-      const value = await revealSealedField({
-        collection: ctx.collection,
-        encrypted: ctx.encrypted,
-        getEnvelope: ctx.getEnvelope,
-        resolveCek: ctx.resolveCek,
-        getDEK: ctx.getDEK
-      }, id, field);
-      await ctx.onAccess?.("reveal", id);
-      return value;
-    },
-    async verify(ctx, id, field, candidate) {
-      const { verifyDigestField } = await import("./verify-JPF2YR5E.js");
-      const verdict = await verifyDigestField(engineCtx(ctx), id, field, candidate, policyOf(ctx.spec));
-      await ctx.onAccess?.("verify", id);
-      return verdict;
-    },
-    async verifyText(ctx, id, field, candidate) {
-      const { verifyTextField } = await import("./verify-JPF2YR5E.js");
-      const verdict = await verifyTextField(engineCtx(ctx), id, field, candidate, ctx.spec.verifyNormalize ?? "password");
-      await ctx.onAccess?.("verify", id);
-      return verdict;
-    },
-    async matchGroup(ctx, id, answers, opts) {
-      const { matchGroupFields } = await import("./verify-JPF2YR5E.js");
-      const members = (ctx.groupMembers ?? []).map((m) => ({ field: m.field, policy: policyOf(m.spec) }));
-      const result = await matchGroupFields(engineCtx(ctx), id, answers, members, opts);
-      await ctx.onAccess?.("verify", id);
-      return result;
-    },
-    async computeTarget(ctx, field, candidate, costByte) {
-      const { computeBidxTarget } = await import("./find-BNGBJNKP.js");
-      const dek = await ctx.getDEK();
-      return computeBidxTarget(candidate, policyOf(ctx.spec).normalize, dek, ctx.collection, field, costByte);
-    }
-  };
-}
-
-export {
-  luhnCheck,
-  classified,
-  withClassified
-};
-//# sourceMappingURL=chunk-Y3A5CB5G.js.map

package/dist/chunk-YCXCR7VG.js

@@ -1,230 +0,0 @@
-import {
-  NOYDB_FORMAT_VERSION
-} from "./chunk-YN5IAHN6.js";
-
-// src/with-party/team/managed-passphrase.ts
-var MemorySealingKeyProvider = class {
-  id;
-  fingerprint;
-  keyBytes;
-  constructor(opts) {
-    this.id = opts.id;
-    const encoded = new TextEncoder().encode(opts.id);
-    let h = 0;
-    for (let i = 0; i < encoded.length; i++) {
-      h = h * 31 + encoded[i] >>> 0;
-    }
-    this.fingerprint = new Uint8Array([
-      h >>> 24 & 255,
-      h >>> 16 & 255,
-      h >>> 8 & 255,
-      h & 255
-    ]);
-    this.keyBytes = new Uint8Array(16);
-    for (let i = 0; i < 16; i++) {
-      this.keyBytes[i] = this.fingerprint[i % 4] ^ i * 17;
-    }
-  }
-  async seal(passphrase) {
-    const out = new Uint8Array(4 + passphrase.length);
-    out.set(this.fingerprint, 0);
-    for (let i = 0; i < passphrase.length; i++) {
-      out[4 + i] = passphrase[i] ^ this.keyBytes[i % 16];
-    }
-    return out;
-  }
-  async unseal(sealed) {
-    if (sealed.length < 4) {
-      throw new Error("MemorySealingKeyProvider: sealed input too short");
-    }
-    for (let i = 0; i < 4; i++) {
-      if (sealed[i] !== this.fingerprint[i]) {
-        throw new Error(
-          `MemorySealingKeyProvider("${this.id}"): provider-id mismatch on unseal (sealed bytes were produced by a different provider)`
-        );
-      }
-    }
-    const body = sealed.subarray(4);
-    const out = new Uint8Array(body.length);
-    for (let i = 0; i < body.length; i++) {
-      out[i] = body[i] ^ this.keyBytes[i % 16];
-    }
-    return out;
-  }
-};
-async function sealRsaOaepTlv(plaintext, publicKeyPem) {
-  const b64 = publicKeyPem.replace(/-----BEGIN PUBLIC KEY-----/, "").replace(/-----END PUBLIC KEY-----/, "").replace(/\s+/g, "");
-  const spki = base64ToBytes(b64);
-  const recipientPub = await crypto.subtle.importKey(
-    "spki",
-    spki,
-    { name: "RSA-OAEP", hash: "SHA-256" },
-    false,
-    ["encrypt"]
-  );
-  const cekBytes = crypto.getRandomValues(new Uint8Array(32));
-  const cek = await crypto.subtle.importKey("raw", cekBytes, "AES-GCM", false, ["encrypt"]);
-  const iv = crypto.getRandomValues(new Uint8Array(12));
-  const ct = new Uint8Array(await crypto.subtle.encrypt({ name: "AES-GCM", iv }, cek, plaintext));
-  const wrapped = new Uint8Array(await crypto.subtle.encrypt({ name: "RSA-OAEP" }, recipientPub, cekBytes));
-  cekBytes.fill(0);
-  if (wrapped.length !== 256) {
-    throw new Error(`sealRsaOaepTlv: expected 256-byte RSA-OAEP wrap, got ${wrapped.length}`);
-  }
-  const out = new Uint8Array(1 + 256 + 12 + ct.length);
-  out[0] = 1;
-  out.set(wrapped, 1);
-  out.set(iv, 1 + 256);
-  out.set(ct, 1 + 256 + 12);
-  return out;
-}
-function parseRsaOaepTlv(bytes) {
-  if (bytes.length < 1 + 256 + 12 + 16) {
-    throw new Error("parseRsaOaepTlv: sealed input too short");
-  }
-  if (bytes[0] !== 1) {
-    throw new Error(`parseRsaOaepTlv: unknown TLV version ${bytes[0]}`);
-  }
-  return {
-    wrapped: bytes.subarray(1, 1 + 256),
-    iv: bytes.subarray(1 + 256, 1 + 256 + 12),
-    ct: bytes.subarray(1 + 256 + 12)
-  };
-}
-async function aesGcmOpen(cekBytes, iv, ct) {
-  const cek = await crypto.subtle.importKey("raw", cekBytes, "AES-GCM", false, ["decrypt"]);
-  return new Uint8Array(await crypto.subtle.decrypt({ name: "AES-GCM", iv }, cek, ct));
-}
-var MemoryRecipientSealer = class {
-  id;
-  keypair;
-  constructor(opts) {
-    this.id = opts.id;
-    this.keypair = crypto.subtle.generateKey(
-      { name: "RSA-OAEP", modulusLength: 2048, publicExponent: new Uint8Array([1, 0, 1]), hash: "SHA-256" },
-      true,
-      ["encrypt", "decrypt"]
-    );
-  }
-  async publishRecipientHint() {
-    const { publicKey } = await this.keypair;
-    const spki = await crypto.subtle.exportKey("spki", publicKey);
-    const pem = "-----BEGIN PUBLIC KEY-----\n" + bytesToBase64(new Uint8Array(spki)).match(/.{1,64}/g).join("\n") + "\n-----END PUBLIC KEY-----\n";
-    return { v: 1, pid: this.id, alg: "rsa-oaep-sha256", material: { publicKeyPem: pem } };
-  }
-  async sealForRecipient(plaintext, hint) {
-    if (hint.v !== 1) {
-      throw new Error(`MemoryRecipientSealer.sealForRecipient: unsupported hint.v ${String(hint.v)} (expected 1)`);
-    }
-    if (hint.alg !== "rsa-oaep-sha256") {
-      throw new Error(`MemoryRecipientSealer.sealForRecipient: unsupported hint.alg '${String(hint.alg)}' (expected 'rsa-oaep-sha256')`);
-    }
-    const pem = hint.material["publicKeyPem"];
-    if (typeof pem !== "string") {
-      throw new Error("MemoryRecipientSealer.sealForRecipient: hint.material.publicKeyPem missing or not a string");
-    }
-    return sealRsaOaepTlv(plaintext, pem);
-  }
-  async seal(plaintext) {
-    const hint = await this.publishRecipientHint();
-    return this.sealForRecipient(plaintext, hint);
-  }
-  async unseal(bytes) {
-    const { wrapped, iv, ct } = parseRsaOaepTlv(bytes);
-    const { privateKey } = await this.keypair;
-    const cekBytes = new Uint8Array(await crypto.subtle.decrypt({ name: "RSA-OAEP" }, privateKey, wrapped));
-    const pt = await aesGcmOpen(cekBytes, iv, ct);
-    cekBytes.fill(0);
-    return pt;
-  }
-};
-var SEALED_PASSPHRASE_RECORD_ID = "sealed-passphrase";
-function bytesToBase64(bytes) {
-  let binary = "";
-  for (let i = 0; i < bytes.length; i++) binary += String.fromCharCode(bytes[i]);
-  return btoa(binary);
-}
-function base64ToBytes(b64) {
-  const binary = atob(b64);
-  const out = new Uint8Array(binary.length);
-  for (let i = 0; i < binary.length; i++) out[i] = binary.charCodeAt(i);
-  return out;
-}
-function parseSealedEnvelope(raw) {
-  if (typeof raw !== "object" || raw === null) return void 0;
-  const r = raw;
-  if (r._noydb_sealed !== 1) return void 0;
-  if (r.v === 1 && typeof r.pid === "string" && typeof r.payload === "string") {
-    return {
-      _noydb_sealed: 1,
-      providerId: r.pid,
-      sealed: base64ToBytes(r.payload)
-    };
-  }
-  if (typeof r.providerId === "string" && typeof r.sealed === "string") {
-    return {
-      _noydb_sealed: 1,
-      providerId: r.providerId,
-      sealed: base64ToBytes(r.sealed)
-    };
-  }
-  return void 0;
-}
-async function saveSealedPassphrase(store, vault, payload) {
-  const persisted = {
-    v: 1,
-    _noydb_sealed: 1,
-    pid: payload.providerId,
-    payload: bytesToBase64(payload.sealed)
-  };
-  const prior = await store.get(vault, "_meta", SEALED_PASSPHRASE_RECORD_ID);
-  const env = {
-    _noydb: NOYDB_FORMAT_VERSION,
-    _v: (prior?._v ?? 0) + 1,
-    _ts: (/* @__PURE__ */ new Date()).toISOString(),
-    // AES-GCM bypassed — the sealing layer is the security boundary.
-    _iv: "",
-    _data: JSON.stringify(persisted)
-  };
-  await store.put(vault, "_meta", SEALED_PASSPHRASE_RECORD_ID, env);
-}
-async function loadSealedPassphrase(store, vault) {
-  const envelope = await store.get(vault, "_meta", SEALED_PASSPHRASE_RECORD_ID);
-  if (!envelope) return void 0;
-  try {
-    return parseSealedEnvelope(JSON.parse(envelope._data));
-  } catch {
-    return void 0;
-  }
-}
-async function resolveManagedSecret(store, vault, provider) {
-  const existing = await loadSealedPassphrase(store, vault);
-  if (existing) {
-    if (existing.providerId !== provider.id) {
-      throw new Error(
-        `Managed-mode vault "${vault}" was sealed under provider id "${existing.providerId}" but the current SealingKeyProvider is "${provider.id}". Pass the same provider that originally enrolled the vault, or treat this as a fresh enrollment and clear \`_meta/sealed-passphrase\` first.`
-      );
-    }
-    const plaintext = await provider.unseal(existing.sealed);
-    return bytesToBase64(plaintext);
-  }
-  const random = new Uint8Array(32);
-  globalThis.crypto.getRandomValues(random);
-  const sealed = await provider.seal(random);
-  await saveSealedPassphrase(store, vault, { providerId: provider.id, sealed });
-  return bytesToBase64(random);
-}
-
-export {
-  MemorySealingKeyProvider,
-  sealRsaOaepTlv,
-  parseRsaOaepTlv,
-  aesGcmOpen,
-  MemoryRecipientSealer,
-  SEALED_PASSPHRASE_RECORD_ID,
-  parseSealedEnvelope,
-  saveSealedPassphrase,
-  loadSealedPassphrase,
-  resolveManagedSecret
-};
-//# sourceMappingURL=chunk-YCXCR7VG.js.map