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

package/dist/chunk-3OPY6MK2.js

@@ -1,404 +0,0 @@
-import {
-  DecryptionError,
-  InvalidKeyError,
-  TamperedError
-} from "./chunk-S7VFUQM2.js";
-
-// src/kernel/enclave/crypto.ts
-var PBKDF2_ITERATIONS = 6e5;
-var SALT_BYTES = 32;
-var IV_BYTES = 12;
-var KEY_BITS = 256;
-var subtle = globalThis.crypto.subtle;
-async function deriveKey(passphrase, salt) {
-  const keyMaterial = await subtle.importKey(
-    "raw",
-    new TextEncoder().encode(passphrase),
-    "PBKDF2",
-    false,
-    ["deriveKey"]
-  );
-  return subtle.deriveKey(
-    {
-      name: "PBKDF2",
-      salt,
-      iterations: PBKDF2_ITERATIONS,
-      hash: "SHA-256"
-    },
-    keyMaterial,
-    { name: "AES-KW", length: KEY_BITS },
-    false,
-    ["wrapKey", "unwrapKey"]
-  );
-}
-async function derivePassphraseKey(passphrase, salt, params) {
-  const keyMaterial = await subtle.importKey(
-    "raw",
-    new TextEncoder().encode(passphrase),
-    "PBKDF2",
-    false,
-    ["deriveKey"]
-  );
-  return params.keyUsage === "aes-gcm" ? subtle.deriveKey(
-    {
-      name: "PBKDF2",
-      salt,
-      iterations: params.iterations,
-      hash: "SHA-256"
-    },
-    keyMaterial,
-    { name: "AES-GCM", length: KEY_BITS },
-    false,
-    ["encrypt", "decrypt"]
-  ) : subtle.deriveKey(
-    {
-      name: "PBKDF2",
-      salt,
-      iterations: params.iterations,
-      hash: "SHA-256"
-    },
-    keyMaterial,
-    { name: "AES-KW", length: KEY_BITS },
-    false,
-    ["wrapKey", "unwrapKey"]
-  );
-}
-async function generateDEK() {
-  return subtle.generateKey(
-    { name: "AES-GCM", length: KEY_BITS },
-    true,
-    // extractable — needed for AES-KW wrapping
-    ["encrypt", "decrypt"]
-  );
-}
-async function wrapKey(dek, kek) {
-  const wrapped = await subtle.wrapKey("raw", dek, kek, "AES-KW");
-  return bufferToBase64(wrapped);
-}
-async function unwrapKey(wrappedBase64, kek) {
-  try {
-    return await subtle.unwrapKey(
-      "raw",
-      base64ToBuffer(wrappedBase64),
-      kek,
-      "AES-KW",
-      { name: "AES-GCM", length: KEY_BITS },
-      true,
-      ["encrypt", "decrypt"]
-    );
-  } catch {
-    throw new InvalidKeyError();
-  }
-}
-async function asKwKey(dek) {
-  const rawDek = await subtle.exportKey("raw", dek);
-  const hkdfKey = await subtle.importKey("raw", rawDek, "HKDF", false, ["deriveBits"]);
-  const salt = new TextEncoder().encode("noydb-cek-wrap");
-  const info = new TextEncoder().encode("v1");
-  const bits = await subtle.deriveBits(
-    { name: "HKDF", hash: "SHA-256", salt, info },
-    hkdfKey,
-    KEY_BITS
-  );
-  return subtle.importKey("raw", bits, "AES-KW", false, ["wrapKey", "unwrapKey"]);
-}
-async function wrapCek(cek, dek) {
-  const kw = await asKwKey(dek);
-  const wrapped = await subtle.wrapKey("raw", cek, kw, "AES-KW");
-  return bufferToBase64(wrapped);
-}
-async function unwrapCek(wrappedBase64, dek) {
-  const kw = await asKwKey(dek);
-  try {
-    return await subtle.unwrapKey(
-      "raw",
-      base64ToBuffer(wrappedBase64),
-      kw,
-      "AES-KW",
-      { name: "AES-GCM", length: KEY_BITS },
-      true,
-      ["encrypt", "decrypt"]
-    );
-  } catch {
-    throw new InvalidKeyError();
-  }
-}
-async function importCek(rawKey) {
-  return subtle.importKey("raw", rawKey, { name: "AES-GCM", length: KEY_BITS }, false, ["decrypt"]);
-}
-async function encrypt(plaintext, dek) {
-  const iv = generateIV();
-  const encoded = new TextEncoder().encode(plaintext);
-  const ciphertext = await subtle.encrypt(
-    { name: "AES-GCM", iv },
-    dek,
-    encoded
-  );
-  return {
-    iv: bufferToBase64(iv),
-    data: bufferToBase64(ciphertext)
-  };
-}
-async function decrypt(ivBase64, dataBase64, dek) {
-  const iv = base64ToBuffer(ivBase64);
-  const ciphertext = base64ToBuffer(dataBase64);
-  try {
-    const plaintext = await subtle.decrypt(
-      { name: "AES-GCM", iv },
-      dek,
-      ciphertext
-    );
-    return new TextDecoder().decode(plaintext);
-  } catch (err) {
-    if (err instanceof Error && err.name === "OperationError") {
-      throw new TamperedError();
-    }
-    throw new DecryptionError(
-      err instanceof Error ? err.message : "Decryption failed"
-    );
-  }
-}
-async function encryptBytes(data, dek) {
-  const iv = generateIV();
-  const ciphertext = await subtle.encrypt(
-    { name: "AES-GCM", iv },
-    dek,
-    data
-  );
-  return {
-    iv: bufferToBase64(iv),
-    data: bufferToBase64(ciphertext)
-  };
-}
-async function decryptBytes(ivBase64, dataBase64, dek) {
-  const iv = base64ToBuffer(ivBase64);
-  const ciphertext = base64ToBuffer(dataBase64);
-  try {
-    const plaintext = await subtle.decrypt(
-      { name: "AES-GCM", iv },
-      dek,
-      ciphertext
-    );
-    return new Uint8Array(plaintext);
-  } catch (err) {
-    if (err instanceof Error && err.name === "OperationError") {
-      throw new TamperedError();
-    }
-    throw new DecryptionError(
-      err instanceof Error ? err.message : "Decryption failed"
-    );
-  }
-}
-async function sha256Hex(data) {
-  const hash = await subtle.digest("SHA-256", data);
-  return Array.from(new Uint8Array(hash)).map((b) => b.toString(16).padStart(2, "0")).join("");
-}
-async function hmacSha256Hex(key, data) {
-  const rawKey = await subtle.exportKey("raw", key);
-  const hmacKey = await subtle.importKey(
-    "raw",
-    rawKey,
-    { name: "HMAC", hash: "SHA-256" },
-    false,
-    ["sign"]
-  );
-  const sig = await subtle.sign("HMAC", hmacKey, data);
-  return Array.from(new Uint8Array(sig)).map((b) => b.toString(16).padStart(2, "0")).join("");
-}
-async function encryptBytesWithAAD(data, dek, aad) {
-  const iv = generateIV();
-  const ciphertext = await subtle.encrypt(
-    {
-      name: "AES-GCM",
-      iv,
-      additionalData: aad
-    },
-    dek,
-    data
-  );
-  return {
-    iv: bufferToBase64(iv),
-    data: bufferToBase64(ciphertext)
-  };
-}
-async function decryptBytesWithAAD(ivBase64, dataBase64, dek, aad) {
-  const iv = base64ToBuffer(ivBase64);
-  const ciphertext = base64ToBuffer(dataBase64);
-  try {
-    const plaintext = await subtle.decrypt(
-      {
-        name: "AES-GCM",
-        iv,
-        additionalData: aad
-      },
-      dek,
-      ciphertext
-    );
-    return new Uint8Array(plaintext);
-  } catch (err) {
-    if (err instanceof Error && err.name === "OperationError") {
-      throw new TamperedError();
-    }
-    throw new DecryptionError(
-      err instanceof Error ? err.message : "Decryption failed"
-    );
-  }
-}
-async function derivePresenceKey(dek, collectionName) {
-  const rawDek = await subtle.exportKey("raw", dek);
-  const hkdfKey = await subtle.importKey(
-    "raw",
-    rawDek,
-    "HKDF",
-    false,
-    ["deriveBits"]
-  );
-  const salt = new TextEncoder().encode("noydb-presence");
-  const info = new TextEncoder().encode(collectionName);
-  const bits = await subtle.deriveBits(
-    { name: "HKDF", hash: "SHA-256", salt, info },
-    hkdfKey,
-    KEY_BITS
-  );
-  return subtle.importKey(
-    "raw",
-    bits,
-    { name: "AES-GCM", length: KEY_BITS },
-    false,
-    ["encrypt", "decrypt"]
-  );
-}
-async function deriveSealedFieldKey(dek, collectionName, field) {
-  const rawDek = await subtle.exportKey("raw", dek);
-  const hkdfKey = await subtle.importKey("raw", rawDek, "HKDF", false, ["deriveBits"]);
-  const salt = new TextEncoder().encode("noydb-sealed");
-  const info = new TextEncoder().encode(JSON.stringify(["noydb-sealed", collectionName, field]));
-  const bits = await subtle.deriveBits(
-    { name: "HKDF", hash: "SHA-256", salt, info },
-    hkdfKey,
-    KEY_BITS
-  );
-  return subtle.importKey(
-    "raw",
-    bits,
-    { name: "AES-GCM", length: KEY_BITS },
-    false,
-    ["encrypt", "decrypt"]
-  );
-}
-async function deriveSealedFieldKeyFromCek(cek, collectionName, field) {
-  const rawCek = await subtle.exportKey("raw", cek);
-  const hkdfKey = await subtle.importKey("raw", rawCek, "HKDF", false, ["deriveBits"]);
-  const salt = new TextEncoder().encode("noydb-sealed-cek");
-  const info = new TextEncoder().encode(JSON.stringify(["noydb-sealed-cek", collectionName, field]));
-  const bits = await subtle.deriveBits(
-    { name: "HKDF", hash: "SHA-256", salt, info },
-    hkdfKey,
-    KEY_BITS
-  );
-  return subtle.importKey(
-    "raw",
-    bits,
-    { name: "AES-GCM", length: KEY_BITS },
-    false,
-    ["encrypt", "decrypt"]
-  );
-}
-async function deriveDeterministicKey(dek) {
-  const rawDek = await subtle.exportKey("raw", dek);
-  const hkdfKey = await subtle.importKey("raw", rawDek, "HKDF", false, ["deriveBits"]);
-  const salt = new TextEncoder().encode("noydb-det");
-  const info = new TextEncoder().encode(JSON.stringify(["noydb-det"]));
-  const bits = await subtle.deriveBits(
-    { name: "HKDF", hash: "SHA-256", salt, info },
-    hkdfKey,
-    KEY_BITS
-  );
-  return subtle.importKey(
-    "raw",
-    bits,
-    { name: "AES-GCM", length: KEY_BITS },
-    true,
-    ["encrypt", "decrypt"]
-  );
-}
-async function deriveDeterministicIV(dek, context, plaintext) {
-  const rawDek = await subtle.exportKey("raw", dek);
-  const hkdfKey = await subtle.importKey("raw", rawDek, "HKDF", false, ["deriveBits"]);
-  const salt = new TextEncoder().encode("noydb-deterministic-v1");
-  const info = new TextEncoder().encode(`${context}\0${plaintext}`);
-  const bits = await subtle.deriveBits(
-    { name: "HKDF", hash: "SHA-256", salt, info },
-    hkdfKey,
-    IV_BYTES * 8
-  );
-  return new Uint8Array(bits);
-}
-async function encryptDeterministic(plaintext, dek, context) {
-  const iv = await deriveDeterministicIV(dek, context, plaintext);
-  const encoded = new TextEncoder().encode(plaintext);
-  const ciphertext = await subtle.encrypt(
-    { name: "AES-GCM", iv },
-    dek,
-    encoded
-  );
-  return {
-    iv: bufferToBase64(iv),
-    data: bufferToBase64(ciphertext)
-  };
-}
-async function decryptDeterministic(ivBase64, dataBase64, dek) {
-  return decrypt(ivBase64, dataBase64, dek);
-}
-function generateIV() {
-  return globalThis.crypto.getRandomValues(new Uint8Array(IV_BYTES));
-}
-function generateSalt() {
-  return globalThis.crypto.getRandomValues(new Uint8Array(SALT_BYTES));
-}
-function bufferToBase64(buffer) {
-  const bytes = buffer instanceof Uint8Array ? buffer : new Uint8Array(buffer);
-  let binary = "";
-  for (let i = 0; i < bytes.length; i++) {
-    binary += String.fromCharCode(bytes[i]);
-  }
-  return btoa(binary);
-}
-function base64ToBuffer(base64) {
-  const binary = atob(base64);
-  const bytes = new Uint8Array(binary.length);
-  for (let i = 0; i < binary.length; i++) {
-    bytes[i] = binary.charCodeAt(i);
-  }
-  return bytes;
-}
-
-export {
-  deriveKey,
-  derivePassphraseKey,
-  generateDEK,
-  wrapKey,
-  unwrapKey,
-  wrapCek,
-  unwrapCek,
-  importCek,
-  encrypt,
-  decrypt,
-  encryptBytes,
-  decryptBytes,
-  sha256Hex,
-  hmacSha256Hex,
-  encryptBytesWithAAD,
-  decryptBytesWithAAD,
-  derivePresenceKey,
-  deriveSealedFieldKey,
-  deriveSealedFieldKeyFromCek,
-  deriveDeterministicKey,
-  encryptDeterministic,
-  decryptDeterministic,
-  generateIV,
-  generateSalt,
-  bufferToBase64,
-  base64ToBuffer
-};
-//# sourceMappingURL=chunk-3OPY6MK2.js.map

package/dist/chunk-3QSIU3UT.js

@@ -1,291 +0,0 @@
-import {
-  sha256Hex
-} from "./chunk-3OPY6MK2.js";
-import {
-  MaterializedViewSourceUnknownError
-} from "./chunk-S7VFUQM2.js";
-
-// src/with-formula/materialized-views/dependency-analyzer.ts
-function analyzeDependencies(query) {
-  const deps = /* @__PURE__ */ new Set();
-  const plan = query._plan();
-  const ctx = query._joinContext();
-  if (ctx?.leftCollection) {
-    deps.add(ctx.leftCollection);
-  }
-  for (const leg of plan.joins) {
-    deps.add(leg.target);
-  }
-  for (const clause of plan.clauses) {
-    if (clause.type === "crossJoin") {
-      deps.add(clause.target);
-    }
-  }
-  walkClausesForJoins(plan, deps, ctx);
-  return deps;
-}
-function walkClausesForJoins(plan, deps, ctx) {
-  void ctx;
-  for (const clause of plan.clauses) {
-    if (clause.type === "group") {
-    }
-  }
-}
-function summarizeQueryPlan(query) {
-  const plan = query._plan();
-  const ctx = query._joinContext();
-  return JSON.stringify({
-    root: ctx?.leftCollection ?? null,
-    clauses: plan.clauses.map((c) => {
-      if (c.type === "crossJoin") {
-        return {
-          type: "crossJoin",
-          target: c.target,
-          as: c.as,
-          // Inline on: callback: use sentinel — drift detection disabled for this MV
-          onPredicateName: c.onPredicateName ?? (c.on ? "[inline]" : null),
-          maxRows: c.maxRows ?? null
-        };
-      }
-      return c;
-    }),
-    orderBy: plan.orderBy,
-    limit: plan.limit ?? null,
-    offset: plan.offset,
-    joins: plan.joins.map((j) => ({ field: j.field, as: j.as, target: j.target, mode: j.mode }))
-  });
-}
-function summarizeUnionPlan(spec) {
-  const arms = (spec.unionSources ?? []).map((s) => {
-    const joins = s.join?.length ? `[${s.join.map((j) => `${j.field}\u2192${j.as}`).join(";")}]` : "";
-    return `${s.collection}${joins}`;
-  }).join(",");
-  const groupBy = Array.isArray(spec.groupBy) ? [...spec.groupBy].sort().join(",") : typeof spec.groupBy === "string" ? spec.groupBy : "";
-  const aggKeys = spec.aggregate ? Object.keys(spec.aggregate).sort().join(",") : "";
-  const moneyKeys = spec.moneyFields ? Object.keys(spec.moneyFields).sort().join(",") : "";
-  return `union(${arms})|groupBy(${groupBy})|aggregate(${aggKeys})|money(${moneyKeys})`;
-}
-
-// src/with-formula/materialized-views/query-hash.ts
-async function computeQueryHash(mvName, dependencies, queryPlanSummary) {
-  const canonical = JSON.stringify({
-    mvName,
-    dependencies: [...dependencies].sort(),
-    queryPlanSummary
-  });
-  const bytes = new TextEncoder().encode(canonical);
-  return sha256Hex(bytes);
-}
-function canonicalizeQueryPlan(plan) {
-  return JSON.stringify(plan, (_key, value) => {
-    if (value && typeof value === "object" && !Array.isArray(value)) {
-      const sorted = {};
-      for (const k of Object.keys(value).sort()) {
-        sorted[k] = value[k];
-      }
-      return sorted;
-    }
-    return value;
-  });
-}
-
-// src/with-formula/materialized-views/registry.ts
-var WHOLE_RECORD = "*";
-var MaterializedViewRegistry = class {
-  /** Keyed by `spec.name`. */
-  _byName = /* @__PURE__ */ new Map();
-  /** Keyed by dependency source-collection → MVs that depend on it. */
-  _bySource = /* @__PURE__ */ new Map();
-  /**
-   * Register an MV. Invokes `spec.query()` once at registration time to
-   * read the plan + join context; the resulting `Query<T>` is discarded
-   * after dependency extraction. `vault.collection(...)` must therefore
-   * be functional by the time this runs — typically wired from
-   * `Vault._initMaterializedViews` after collection bootstrap.
-   *
-   * Throws `MaterializedViewSourceUnknownError` if the analyzer
-   * surfaces a dependency the vault doesn't know about (when a
-   * `knownCollections` checker is supplied).
-   */
-  async register(spec, db, options) {
-    const dbForQuery = spec.predicates ? wrapDbWithPredicates(db, spec.predicates) : db;
-    let dependencies;
-    let queryPlanSummary;
-    let qAny = null;
-    let isQuery = false;
-    if (spec.unionSources) {
-      dependencies = new Set(spec.unionSources.map((s) => s.collection));
-      if (spec.sources) for (const s of spec.sources) dependencies.add(s);
-      queryPlanSummary = summarizeUnionPlan(spec);
-    } else {
-      const q = spec.query(dbForQuery);
-      qAny = q;
-      isQuery = typeof qAny._plan === "function";
-      if (isQuery) {
-        dependencies = analyzeDependencies(qAny);
-        queryPlanSummary = summarizeQueryPlan(qAny);
-        const predicateRefs = extractPredicateRefs(qAny._plan());
-        if (predicateRefs.length > 0) {
-          queryPlanSummary = JSON.stringify({ plan: queryPlanSummary, predicates: predicateRefs });
-        }
-        if (spec.sources) for (const s of spec.sources) dependencies.add(s);
-      } else {
-        if (!spec.sources || spec.sources.length === 0) {
-          throw new Error(
-            `withMaterializedView "${spec.name}": query() returned an aggregate (Aggregation or GroupedAggregation) but no \`sources\` field is declared. The dependency analyzer cannot walk through groupBy().aggregate() back to the source \u2014 declare sources: [...] explicitly.`
-          );
-        }
-        dependencies = new Set(spec.sources);
-        queryPlanSummary = JSON.stringify({ aggregate: true, sources: [...spec.sources].sort() });
-      }
-    }
-    if (options?.knownCollections) {
-      for (const dep of dependencies) {
-        if (!options.knownCollections(dep)) {
-          throw new MaterializedViewSourceUnknownError(spec.name, dep);
-        }
-      }
-    }
-    const outputCollection = spec.output?.collection ?? spec.name;
-    const queryHash = await computeQueryHash(spec.name, dependencies, queryPlanSummary);
-    const partitionClauses = [];
-    const partitionField = spec.output?.partition?.field;
-    if (partitionField !== void 0 && isQuery) {
-      const plan = qAny._plan();
-      for (const clause of plan.clauses) {
-        if (isFieldClauseOnField(clause, partitionField)) partitionClauses.push(clause);
-      }
-    }
-    const grain = spec.unionSources || isQuery ? "record" : "aggregate";
-    const reg = { spec, outputCollection, dependencies, queryHash, partitionClauses, grain };
-    this._byName.set(spec.name, reg);
-    for (const dep of dependencies) {
-      const arr = this._bySource.get(dep);
-      if (arr) arr.push(reg);
-      else this._bySource.set(dep, [reg]);
-    }
-  }
-  /** All MVs that depend on `source`, in registration order. */
-  mvsForSource(source) {
-    return this._bySource.get(source) ?? [];
-  }
-  /** Single MV by name, or `undefined`. */
-  byName(name) {
-    return this._byName.get(name);
-  }
-  /** Iterate over every registered MV. */
-  all() {
-    return [...this._byName.values()];
-  }
-  /**
-   * Graph edges for #638 Task 2: one `'mv'` edge per registered MV — target
-   * = the output collection (a `WHOLE_RECORD` artifact node), sources =
-   * every dependency (also `WHOLE_RECORD` nodes). Same-collection edges
-   * (`dep === outputCollection`) are skipped IFF the MV declares an
-   * `output.partition` discriminator AND the query has a where-clause that
-   * provably excludes the partition value (`partitionDisjoint`) — the SAME
-   * condition the old local DFS used. Grain comes from the registration-time
-   * `RegisteredMV.grain`.
-   */
-  edges() {
-    const out = [];
-    for (const reg of this._byName.values()) {
-      const sources = [];
-      for (const dep of reg.dependencies) {
-        if (dep === reg.outputCollection && partitionDisjoint(reg)) continue;
-        sources.push({ collection: dep, field: WHOLE_RECORD });
-      }
-      if (sources.length === 0) continue;
-      out.push({ target: { collection: reg.outputCollection, field: WHOLE_RECORD }, sources, kind: "mv", grain: reg.grain });
-    }
-    return out;
-  }
-  /**
-   * Cycle detection, delegated to `ViaGraph.assertAcyclic()` (#638 Task 2 —
-   * retires the local DFS). `graph` is the caller's shared per-vault graph,
-   * ALREADY carrying this registry's `edges()` AND `DerivationRegistry`'s
-   * (registered by the caller — see `Vault._initMaterializedViews`, which
-   * runs after `_initDerivations`, so a pure-derivation cycle already threw
-   * `DerivationCycleError` there; any cycle surfacing here necessarily
-   * touches an MV edge). Throws `MaterializedViewCycleError` — SAME class as
-   * before.
-   */
-  validate(graph) {
-    graph.assertAcyclic();
-  }
-};
-function isFieldClauseOnField(clause, field) {
-  return clause.type === "field" && clause.field === field;
-}
-function wrapDbWithPredicates(db, predicates) {
-  const map = /* @__PURE__ */ new Map();
-  for (const [name, decl] of Object.entries(predicates)) {
-    map.set(name, {
-      hash: decl.hash,
-      fn: decl.fn
-    });
-  }
-  return {
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any
-    collection(name) {
-      const c = db.collection(name);
-      return new Proxy(c, {
-        get(target, prop, receiver) {
-          if (prop === "query") {
-            return (...args) => {
-              const q = target.query(...args);
-              if (q && typeof q._withPredicates === "function") {
-                return q._withPredicates(map);
-              }
-              return q;
-            };
-          }
-          return Reflect.get(target, prop, receiver);
-        }
-      });
-    }
-  };
-}
-function extractPredicateRefs(plan) {
-  const refs = [];
-  const walk = (clauses) => {
-    for (const c of clauses) {
-      if (c.type === "wherePredicate") {
-        refs.push({ name: c.name, predicateHash: c.predicateHash, ctxHash: c.ctxHash });
-      } else if (c.type === "group") {
-        walk(c.clauses);
-      }
-    }
-  };
-  walk(plan.clauses);
-  refs.sort((a, b) => {
-    if (a.name !== b.name) return a.name < b.name ? -1 : 1;
-    if (a.predicateHash !== b.predicateHash) return a.predicateHash < b.predicateHash ? -1 : 1;
-    return a.ctxHash < b.ctxHash ? -1 : a.ctxHash > b.ctxHash ? 1 : 0;
-  });
-  return refs;
-}
-function partitionDisjoint(reg) {
-  const partition = reg.spec.output?.partition;
-  if (partition === void 0) return false;
-  const value = partition.value;
-  for (const c of reg.partitionClauses) {
-    if (c.op === "==" && c.value !== value) return true;
-    if (c.op === "!=" && c.value === value) return true;
-    if (c.op === "in" && Array.isArray(c.value)) {
-      const list = c.value;
-      if (!list.includes(value)) return true;
-    }
-  }
-  return false;
-}
-
-export {
-  analyzeDependencies,
-  summarizeQueryPlan,
-  computeQueryHash,
-  canonicalizeQueryPlan,
-  MaterializedViewRegistry,
-  wrapDbWithPredicates
-};
-//# sourceMappingURL=chunk-3QSIU3UT.js.map