@nicia-ai/typegraph 0.49.0 → 0.51.0

package/dist/chunk-3QNZ5SAJ.cjs

@@ -1,3502 +0,0 @@
-'use strict';
-
-var chunkFA2AFWLP_cjs = require('./chunk-FA2AFWLP.cjs');
-var chunkHDL2ARHX_cjs = require('./chunk-HDL2ARHX.cjs');
-var chunkWODMN3Q2_cjs = require('./chunk-WODMN3Q2.cjs');
-var chunkPWLJ77UV_cjs = require('./chunk-PWLJ77UV.cjs');
-var chunkSIT26LAZ_cjs = require('./chunk-SIT26LAZ.cjs');
-var chunkTQHGE7UC_cjs = require('./chunk-TQHGE7UC.cjs');
-var chunkZY4GXIVN_cjs = require('./chunk-ZY4GXIVN.cjs');
-var chunkL3LQNR34_cjs = require('./chunk-L3LQNR34.cjs');
-var chunkEDN4Y4ZG_cjs = require('./chunk-EDN4Y4ZG.cjs');
-var chunkMRDBBHIZ_cjs = require('./chunk-MRDBBHIZ.cjs');
-var chunkN66HCGCY_cjs = require('./chunk-N66HCGCY.cjs');
-var drizzleOrm = require('drizzle-orm');
-
-// src/backend/edge-endpoint-sets.ts
-var FIND_EDGES_ENDPOINT_FIXED_PARAM_COUNT = 6;
-var FIND_EDGES_HETEROGENEOUS_FIXED_PARAM_COUNT = 4;
-function assertLimitPerEndpoint(operation, graphId, limitPerEndpoint, kind) {
-  if (limitPerEndpoint === void 0 || Number.isInteger(limitPerEndpoint) && limitPerEndpoint > 0) {
-    return;
-  }
-  throw new chunkMRDBBHIZ_cjs.ConfigurationError(
-    `${operation} \`limitPerEndpoint\` must be a positive integer, received ${String(limitPerEndpoint)}.`,
-    {
-      code: "EDGE_ENDPOINT_SET_INVALID",
-      graphId,
-      ...kind === void 0 ? {} : { kind }
-    },
-    {
-      suggestion: "Pass a positive integer to cap each endpoint's rows, or omit it for an unbounded read."
-    }
-  );
-}
-function resolveEdgeEndpointIds(params) {
-  assertLimitPerEndpoint(
-    "findEdgesByEndpointSet",
-    params.graphId,
-    params.limitPerEndpoint,
-    params.kind
-  );
-  return [...new Set(params.endpointIds)];
-}
-function endpointKey(endpoint) {
-  return `${endpoint.kind}\0${endpoint.id}`;
-}
-function resolveHeterogeneousEdgeRead(params, maxBindParameters) {
-  assertLimitPerEndpoint(
-    "findEdgesByHeterogeneousEndpointSet",
-    params.graphId,
-    params.limitPerEndpoint
-  );
-  const edgeKinds = [...new Set(params.edgeKinds)];
-  const endpoints = [
-    ...new Map(
-      params.endpoints.map((endpoint) => [endpointKey(endpoint), endpoint])
-    ).values()
-  ];
-  if (edgeKinds.length === 0 || endpoints.length === 0) {
-    return { edgeKinds, endpoints, endpointChunkSize: 1 };
-  }
-  const endpointBindBudget = maxBindParameters - FIND_EDGES_HETEROGENEOUS_FIXED_PARAM_COUNT - edgeKinds.length;
-  const endpointChunkSize = Math.floor(endpointBindBudget / 2);
-  if (endpointChunkSize >= 1) {
-    return { edgeKinds, endpoints, endpointChunkSize };
-  }
-  throw new chunkMRDBBHIZ_cjs.ConfigurationError(
-    "findEdgesByHeterogeneousEndpointSet cannot fit one endpoint and the selected edge kinds within the backend bind-parameter budget.",
-    {
-      code: "EDGE_HETEROGENEOUS_READ_BIND_BUDGET_EXCEEDED",
-      graphId: params.graphId,
-      edgeKindCount: edgeKinds.length,
-      maxBindParameters
-    },
-    {
-      suggestion: "Select fewer edge kinds in one call or use a backend with a larger bind-parameter budget."
-    }
-  );
-}
-
-// src/backend/live-node-candidates.ts
-function buildLiveNodeCandidates(nodesTableName, graphId, nodeKind, now) {
-  const nodes = chunkEDN4Y4ZG_cjs.sql.identifier(nodesTableName);
-  return chunkEDN4Y4ZG_cjs.sql`
-    SELECT "id" AS node_id
-    FROM ${nodes}
-    WHERE "graph_id" = ${graphId}
-      AND "kind" = ${nodeKind}
-      AND "deleted_at" IS NULL
-      AND ("valid_from" IS NULL OR "valid_from" <= ${now})
-      AND ("valid_to" IS NULL OR "valid_to" > ${now})
-  `;
-}
-
-// src/backend/drizzle/vector-runtime.ts
-var VECTOR_SLOT_PLACEHOLDER_DIMENSIONS = 1;
-var EMBEDDING_UPSERT_PARAM_COUNT = 5;
-function vectorSlotFromParams(params) {
-  return {
-    graphId: params.graphId,
-    nodeKind: params.nodeKind,
-    fieldPath: params.fieldPath,
-    dimensions: params.dimensions,
-    metric: params.metric,
-    indexType: params.indexType
-  };
-}
-function vectorSlotFromCreateIndexParams(params) {
-  return {
-    ...vectorSlotFromParams(params),
-    ...params.indexParams === void 0 ? {} : { indexParams: params.indexParams }
-  };
-}
-function vectorSlotFromDropIndexParams(params) {
-  return {
-    graphId: params.graphId,
-    nodeKind: params.nodeKind,
-    fieldPath: params.fieldPath,
-    dimensions: VECTOR_SLOT_PLACEHOLDER_DIMENSIONS,
-    metric: "cosine",
-    indexType: "hnsw"
-  };
-}
-function mapVectorWriteError(error, params) {
-  const mismatch = chunkSIT26LAZ_cjs.parseDimensionMismatch(error);
-  if (mismatch === void 0) return error;
-  const attempted = mismatch.actual ?? "a different number of";
-  return new chunkMRDBBHIZ_cjs.EmbeddingDimensionChangedError(
-    `Embedding "${params.nodeKind}.${params.fieldPath}" was written with ${attempted} dimensions, but its per-field storage expects ${mismatch.expected}. The field's embedding dimension changed; existing vectors must be recreated and re-embedded.`,
-    {
-      kind: params.nodeKind,
-      fieldPath: params.fieldPath,
-      storedDimensions: mismatch.expected,
-      ...mismatch.actual === void 0 ? {} : { declaredDimensions: mismatch.actual }
-    },
-    { cause: error }
-  );
-}
-var SQLITE_CONTRIBUTION_MAT_TIMESTAMPS = {
-  decode: (value) => typeof value === "string" ? value : void 0,
-  encode: (value) => value
-};
-var POSTGRES_CONTRIBUTION_MAT_TIMESTAMPS = {
-  decode: chunkFA2AFWLP_cjs.formatPostgresTimestamp,
-  encode: (value) => new Date(value)
-};
-function mapContributionMaterializationRow(row, decode) {
-  const lastAttemptedAt = decode(row.lastAttemptedAt);
-  if (lastAttemptedAt === void 0) {
-    throw new Error(
-      `contribution materialization row missing required last_attempted_at: ${row.graphId}/${row.logicalName}`
-    );
-  }
-  return {
-    graphId: row.graphId,
-    logicalName: row.logicalName,
-    owner: row.owner,
-    tableName: row.tableName,
-    signature: row.signature,
-    materializedAt: decode(row.materializedAt),
-    lastAttemptedAt,
-    lastError: row.lastError ?? void 0
-  };
-}
-function buildContributionInsertValues(params, encode) {
-  return {
-    graphId: params.graphId,
-    logicalName: params.logicalName,
-    owner: params.owner,
-    tableName: params.tableName,
-    signature: params.signature,
-    materializedAt: params.materializedAt === void 0 ? void 0 : encode(params.materializedAt),
-    lastAttemptedAt: encode(params.attemptedAt),
-    lastError: params.error
-  };
-}
-function buildContributionOnConflictSet(materializedAtColumn, paramsMaterializedAt) {
-  const materializedAtSet = paramsMaterializedAt === void 0 ? drizzleOrm.sql`COALESCE(excluded.${drizzleOrm.sql.identifier("materialized_at")}, ${materializedAtColumn})` : drizzleOrm.sql`excluded.${drizzleOrm.sql.identifier("materialized_at")}`;
-  return {
-    signature: drizzleOrm.sql`excluded.${drizzleOrm.sql.identifier("signature")}`,
-    materializedAt: materializedAtSet,
-    lastAttemptedAt: drizzleOrm.sql`excluded.${drizzleOrm.sql.identifier("last_attempted_at")}`,
-    lastError: drizzleOrm.sql`excluded.${drizzleOrm.sql.identifier("last_error")}`
-  };
-}
-function contributionSignatureInput(dialect, identity, createDdl) {
-  const hashable = {
-    dialect,
-    owner: identity.owner,
-    logicalName: identity.logicalName,
-    tableName: identity.tableName,
-    createDdl
-  };
-  return JSON.stringify(hashable, chunkPWLJ77UV_cjs.sortedReplacer);
-}
-function evaluateContributionState(row, signature) {
-  if (row === void 0) return "missing";
-  if (row.lastError !== void 0) return "failed";
-  if (row.signature !== signature) return "stale";
-  if (row.materializedAt === void 0) return "missing";
-  return "initialized";
-}
-function diagnoseContribution(row, signature, tableExists) {
-  if (!tableExists) {
-    if (row === void 0) return void 0;
-    if (row.materializedAt !== void 0) return "orphaned-marker";
-    return row.lastError === void 0 ? void 0 : "failed-materialization";
-  }
-  if (row?.materializedAt !== void 0 && row.signature !== signature) {
-    return "stale";
-  }
-  const state = evaluateContributionState(row, signature);
-  switch (state) {
-    case "initialized": {
-      return void 0;
-    }
-    case "stale": {
-      return "stale";
-    }
-    case "missing":
-    case "failed": {
-      return "missing-marker";
-    }
-    default: {
-      return state;
-    }
-  }
-}
-var PROBE_PROJECTION_ORDER = [
-  "fulltext",
-  "vector"
-];
-var PROBE_DETAIL_PHRASE = {
-  "orphaned-marker": "storage is missing",
-  "missing-marker": "storage is not attested by a durable marker",
-  "failed-materialization": "provisioning failed and produced no storage",
-  stale: "storage exists at a different shape than the current declaration"
-};
-function describeProbeDiagnostic(diagnostic) {
-  const subject = diagnostic.kind === void 0 || diagnostic.fieldPath === void 0 ? `table "${diagnostic.physicalName}"` : `${diagnostic.kind}.${diagnostic.fieldPath}`;
-  return `${subject}: ${PROBE_DETAIL_PHRASE[diagnostic.state]} (${diagnostic.state})`;
-}
-function identityOf(graphId, contribution) {
-  return {
-    graphId,
-    logicalName: contribution.logicalName,
-    owner: contribution.owner,
-    tableName: contribution.tableName
-  };
-}
-function missingTableErrorNames(error, tableName) {
-  const quotedTableName2 = `"${tableName.replaceAll('"', '""')}"`;
-  for (const link of chunkSIT26LAZ_cjs.errorChain(error)) {
-    const message = errorMessage(link);
-    if (typeof message !== "string") continue;
-    const sqliteMatch = /\bno such table:\s*([^\s;:]+)/i.exec(message);
-    const sqliteName = unquoteSqliteIdentifier(sqliteMatch?.[1]);
-    if (sqliteName === tableName) return true;
-    const namesPostgresTable = message.includes(`relation ${quotedTableName2} does not exist`) || message.includes(`table ${quotedTableName2} does not exist`);
-    if (namesPostgresTable) return true;
-  }
-  return false;
-}
-function errorMessage(error) {
-  if (typeof error === "string") return error;
-  if (error instanceof Error) return error.message;
-  if (typeof error !== "object" || error === null || !("message" in error)) {
-    return void 0;
-  }
-  return typeof error.message === "string" ? error.message : void 0;
-}
-function unquoteSqliteIdentifier(identifier) {
-  if (identifier === void 0) return void 0;
-  const first = identifier.at(0);
-  const last = identifier.at(-1);
-  const isQuoted = first === '"' && last === '"' || first === "'" && last === "'" || first === "`" && last === "`" || first === "[" && last === "]";
-  return isQuoted ? identifier.slice(1, -1) : identifier;
-}
-async function executeGatedFulltext(graphId, assert, refuseUnavailable, execute) {
-  await assert(graphId);
-  try {
-    return await execute();
-  } catch (error) {
-    return refuseUnavailable(graphId, error);
-  }
-}
-function gateFulltextMethods(source, assert, refuseUnavailable) {
-  const gated = {};
-  if (source.upsertFulltext) {
-    const raw = source.upsertFulltext;
-    gated.upsertFulltext = async (params) => {
-      await executeGatedFulltext(
-        params.graphId,
-        assert,
-        refuseUnavailable,
-        () => raw(params)
-      );
-    };
-  }
-  if (source.deleteFulltext) {
-    const raw = source.deleteFulltext;
-    gated.deleteFulltext = async (params) => {
-      await executeGatedFulltext(
-        params.graphId,
-        assert,
-        refuseUnavailable,
-        () => raw(params)
-      );
-    };
-  }
-  if (source.upsertFulltextBatch) {
-    const raw = source.upsertFulltextBatch;
-    gated.upsertFulltextBatch = async (params) => {
-      if (params.rows.length === 0) return;
-      await executeGatedFulltext(
-        params.graphId,
-        assert,
-        refuseUnavailable,
-        () => raw(params)
-      );
-    };
-  }
-  if (source.deleteFulltextBatch) {
-    const raw = source.deleteFulltextBatch;
-    gated.deleteFulltextBatch = async (params) => {
-      if (params.nodeIds.length === 0) return;
-      await executeGatedFulltext(
-        params.graphId,
-        assert,
-        refuseUnavailable,
-        () => raw(params)
-      );
-    };
-  }
-  if (source.fulltextSearch) {
-    const raw = source.fulltextSearch;
-    gated.fulltextSearch = async (params) => {
-      return executeGatedFulltext(
-        params.graphId,
-        assert,
-        refuseUnavailable,
-        () => raw(params)
-      );
-    };
-  }
-  const rawHardDelete = source.hardDeleteNode;
-  gated.hardDeleteNode = async (params) => {
-    await executeGatedFulltext(
-      params.graphId,
-      assert,
-      refuseUnavailable,
-      () => rawHardDelete(params)
-    );
-  };
-  return gated;
-}
-function gateFulltext(tx, assert, refuseUnavailable) {
-  return chunkSIT26LAZ_cjs.deriveBackend(
-    tx,
-    gateFulltextMethods(tx, assert, refuseUnavailable)
-  );
-}
-function contributionRebuildSupported(fulltextStrategy, fulltextTableName, transactional) {
-  return transactional && chunkHDL2ARHX_cjs.runtimeStrategyContributions(fulltextStrategy, fulltextTableName).every(
-    (contribution) => contribution.dropDdl !== void 0
-  );
-}
-var CONTRIBUTION_DDL_LOCK_KEY = "typegraph:contribution-ddl";
-var FOREIGN_GRAPH_REPORT_LIMIT = 5;
-var CONTRIBUTION_KEY_SEPARATOR = String.fromCodePoint(0);
-function contributionKey(graphId, contribution) {
-  return [
-    graphId,
-    contribution.owner,
-    contribution.logicalName,
-    contribution.tableName
-  ].join(CONTRIBUTION_KEY_SEPARATOR);
-}
-function createContributionMaterializer(deps) {
-  const { dialect, fulltextStrategy, fulltextTableName } = deps;
-  const initializedSignatures = /* @__PURE__ */ new Map();
-  const uncacheableKeys = /* @__PURE__ */ new Set();
-  const computedSignatures = /* @__PURE__ */ new Map();
-  async function resolveContributionSignature(key, contribution) {
-    const cached = computedSignatures.get(key);
-    const cachedCreateDdl = cached?.createDdl;
-    const cachedSignature = cached?.signature;
-    if (cachedCreateDdl?.length === contribution.createDdl.length && cachedSignature !== void 0 && contribution.createDdl.every(
-      (statement, index) => cachedCreateDdl[index] === statement
-    )) {
-      return cachedSignature;
-    }
-    const input = contributionSignatureInput(
-      dialect,
-      contribution,
-      contribution.createDdl
-    );
-    const entry = {
-      createDdl: [...contribution.createDdl],
-      signature: chunkZY4GXIVN_cjs.sha256Hex(input, 16)
-    };
-    computedSignatures.set(key, entry);
-    try {
-      return await entry.signature;
-    } catch (error) {
-      if (computedSignatures.get(key) === entry) {
-        computedSignatures.delete(key);
-      }
-      throw error;
-    }
-  }
-  function runtimeContributions() {
-    return chunkHDL2ARHX_cjs.runtimeStrategyContributions(fulltextStrategy, fulltextTableName);
-  }
-  function cacheInitializedSignature(key, signature) {
-    if (!uncacheableKeys.has(key)) {
-      initializedSignatures.set(key, signature);
-    }
-  }
-  async function materializeOne(graphId, contribution, signature, existing, options) {
-    const force = options?.force === true;
-    const identity = identityOf(graphId, contribution);
-    if (!force && evaluateContributionState(existing, signature) === "initialized") {
-      return "materialized";
-    }
-    const priorSuccess = existing?.materializedAt !== void 0;
-    if (!force && priorSuccess && existing.signature !== signature) {
-      if (options?.onDrift === "skip") {
-        console.warn(
-          `[typegraph] contribution "${contribution.logicalName}" (table "${contribution.tableName}") is provisioned at a different shape than the current declaration \u2014 left untouched. Writes to it will fail until store.reembedVectorField(kind, fieldPath) recreates the storage at the new shape.`
-        );
-        return "drift-skipped";
-      }
-      const error = new Error(
-        `Contribution "${contribution.logicalName}" (owner "${contribution.owner}", table "${contribution.tableName}") was already materialized with a different signature. The recorded physical shape is stale relative to the current strategy/DDL \u2014 migrate or drop the table and retry, or restore the original strategy.`
-      );
-      await deps.recordMarker({
-        ...identity,
-        signature: existing.signature,
-        attemptedAt: chunkFA2AFWLP_cjs.nowIso(),
-        materializedAt: void 0,
-        error: error.message
-      });
-      throw error;
-    }
-    const attemptedAt = chunkFA2AFWLP_cjs.nowIso();
-    try {
-      for (const statement of contribution.createDdl) {
-        await deps.execDdl(statement);
-      }
-    } catch (error) {
-      await deps.recordMarker({
-        ...identity,
-        signature,
-        attemptedAt,
-        materializedAt: void 0,
-        error: error instanceof Error ? error.message : String(error)
-      });
-      throw error;
-    }
-    await deps.recordMarker({
-      ...identity,
-      signature,
-      attemptedAt,
-      materializedAt: attemptedAt,
-      error: void 0
-    });
-    return "materialized";
-  }
-  function indexMarkerRows(graphId, rows) {
-    return new Map(
-      rows.map((row) => [contributionKey(graphId, row), row])
-    );
-  }
-  async function readMarkerRows(graphId) {
-    try {
-      return {
-        kind: "rows",
-        rows: indexMarkerRows(graphId, await deps.getMarkers(graphId))
-      };
-    } catch (error) {
-      if (!chunkSIT26LAZ_cjs.isMissingTableError(error)) throw error;
-      return { kind: "missing-table", error };
-    }
-  }
-  async function ensureContributions(graphId, contributions, options) {
-    const force = options?.force === true;
-    const bypassCache = options?.bypassCache === true;
-    const entries = await Promise.all(
-      contributions.map(async (contribution) => {
-        const key = contributionKey(graphId, contribution);
-        return {
-          contribution,
-          key,
-          signature: await resolveContributionSignature(key, contribution)
-        };
-      })
-    );
-    if (bypassCache) {
-      for (const entry of entries) {
-        uncacheableKeys.add(entry.key);
-        initializedSignatures.delete(entry.key);
-      }
-    }
-    const pending = force || bypassCache ? entries : entries.filter(
-      (entry) => uncacheableKeys.has(entry.key) || initializedSignatures.get(entry.key) !== entry.signature
-    );
-    if (pending.length === 0) return;
-    const initialRead = force ? void 0 : await readMarkerRows(graphId);
-    if (!force && initialRead?.kind === "rows" && pending.every(
-      (entry) => evaluateContributionState(
-        initialRead.rows.get(entry.key),
-        entry.signature
-      ) === "initialized"
-    )) {
-      for (const entry of pending) {
-        cacheInitializedSignature(entry.key, entry.signature);
-      }
-      return;
-    }
-    await deps.ensureMarkerTable();
-    const existingRows = indexMarkerRows(
-      graphId,
-      await deps.getMarkers(graphId)
-    );
-    for (const entry of pending) {
-      const outcome = await materializeOne(
-        graphId,
-        entry.contribution,
-        entry.signature,
-        existingRows.get(entry.key),
-        {
-          force,
-          ...options?.onDrift === void 0 ? {} : { onDrift: options.onDrift }
-        }
-      );
-      if (outcome === "materialized") {
-        cacheInitializedSignature(entry.key, entry.signature);
-      }
-    }
-  }
-  async function assertContributions(graphId, contributions) {
-    const entries = await Promise.all(
-      contributions.map(async (contribution) => {
-        const key = contributionKey(graphId, contribution);
-        return {
-          contribution,
-          key,
-          signature: await resolveContributionSignature(key, contribution)
-        };
-      })
-    );
-    const pending = entries.filter(
-      (entry) => uncacheableKeys.has(entry.key) || initializedSignatures.get(entry.key) !== entry.signature
-    );
-    if (pending.length === 0) return;
-    const read = await readMarkerRows(graphId);
-    if (read.kind === "missing-table") {
-      const first = pending[0];
-      if (first === void 0) return;
-      throw new chunkMRDBBHIZ_cjs.StoreNotInitializedError(graphId, "missing", {
-        cause: read.error,
-        details: { logicalName: first.contribution.logicalName }
-      });
-    }
-    for (const entry of pending) {
-      const { contribution, key, signature } = entry;
-      const state = evaluateContributionState(read.rows.get(key), signature);
-      if (state !== "initialized") {
-        throw new chunkMRDBBHIZ_cjs.StoreNotInitializedError(graphId, state, {
-          details: { logicalName: contribution.logicalName }
-        });
-      }
-      cacheInitializedSignature(key, signature);
-    }
-  }
-  async function ensureRuntimeContributions(graphId) {
-    await ensureContributions(graphId, runtimeContributions());
-  }
-  async function assertInitialized(graphId) {
-    await assertContributions(graphId, runtimeContributions());
-  }
-  async function refuseUnavailableFulltext(graphId, error) {
-    await Promise.resolve();
-    if (!chunkSIT26LAZ_cjs.isMissingTableError(error)) throw error;
-    const missingContribution = runtimeContributions().find(
-      (contribution) => contribution.logicalName === "fulltext" && missingTableErrorNames(error, contribution.tableName)
-    );
-    if (missingContribution !== void 0) {
-      throw new chunkMRDBBHIZ_cjs.ContributionUnavailableError(
-        graphId,
-        missingContribution.tableName,
-        { cause: error }
-      );
-    }
-    throw error;
-  }
-  async function ensureVectorSlot(slot, options) {
-    await ensureVectorSlots([slot], options);
-  }
-  async function assertVectorSlot(slot) {
-    await assertVectorSlots([slot]);
-  }
-  function groupVectorContributions(slots) {
-    const grouped = /* @__PURE__ */ new Map();
-    if (deps.vectorStrategy === void 0) return grouped;
-    for (const slot of slots) {
-      grouped.set(slot.graphId, [
-        ...grouped.get(slot.graphId) ?? [],
-        ...deps.vectorStrategy.ownedTables(slot)
-      ]);
-    }
-    return grouped;
-  }
-  async function ensureVectorSlots(slots, options) {
-    for (const [graphId, contributions] of groupVectorContributions(slots)) {
-      await ensureContributions(graphId, contributions, options);
-    }
-  }
-  async function assertVectorSlots(slots) {
-    for (const [graphId, contributions] of groupVectorContributions(slots)) {
-      await assertContributions(graphId, contributions);
-    }
-  }
-  function verificationTargetsByGraph(graphId, vectorSlots) {
-    const targets = /* @__PURE__ */ new Map();
-    function addTarget(id, target) {
-      const existing = targets.get(id);
-      if (existing === void 0) targets.set(id, [target]);
-      else existing.push(target);
-    }
-    for (const contribution of runtimeContributions()) {
-      addTarget(graphId, { contribution, projection: "fulltext" });
-    }
-    const { vectorStrategy } = deps;
-    if (vectorStrategy !== void 0) {
-      for (const slot of vectorSlots) {
-        for (const contribution of vectorStrategy.ownedTables(slot)) {
-          addTarget(slot.graphId, {
-            contribution,
-            projection: "vector",
-            kind: slot.nodeKind,
-            fieldPath: slot.fieldPath
-          });
-        }
-      }
-    }
-    return targets;
-  }
-  async function diagnoseTargets(targetsByGraph) {
-    const probes = /* @__PURE__ */ new Map();
-    function tableExists(tableName) {
-      const pending = probes.get(tableName);
-      if (pending !== void 0) return pending;
-      const probe = deps.tableExists(tableName);
-      probes.set(tableName, probe);
-      return probe;
-    }
-    const diagnosed = [];
-    for (const [id, targets] of targetsByGraph) {
-      const read = await readMarkerRows(id);
-      const rows = read.kind === "rows" ? read.rows : /* @__PURE__ */ new Map();
-      for (const { contribution, projection, kind, fieldPath } of targets) {
-        const key = contributionKey(id, contribution);
-        const row = rows.get(key);
-        const state = diagnoseContribution(
-          row,
-          await resolveContributionSignature(key, contribution),
-          await tableExists(contribution.tableName)
-        );
-        if (state === void 0) continue;
-        diagnosed.push({
-          graphId: id,
-          contribution,
-          projection,
-          diagnostic: {
-            owner: contribution.owner,
-            logicalName: contribution.logicalName,
-            physicalName: contribution.tableName,
-            ...kind === void 0 ? {} : { kind },
-            ...fieldPath === void 0 ? {} : { fieldPath },
-            state,
-            // The recorded reason, carried through verbatim. `state` folds
-            // several marker verdicts together because they share a repair;
-            // this is what keeps the fold from also discarding the one thing
-            // the catalog can never tell the operator.
-            ...row?.lastError === void 0 ? {} : { lastError: row.lastError }
-          }
-        });
-      }
-    }
-    return diagnosed;
-  }
-  async function diagnoseContributions(graphId, vectorSlots) {
-    return diagnoseTargets(verificationTargetsByGraph(graphId, vectorSlots));
-  }
-  async function verifyContributions(graphId, vectorSlots) {
-    const diagnosed = await diagnoseContributions(graphId, vectorSlots);
-    return diagnosed.map((entry) => entry.diagnostic);
-  }
-  async function probeContributions(graphId, vectorSlots) {
-    const targetsByGraph = verificationTargetsByGraph(graphId, vectorSlots);
-    const declared = /* @__PURE__ */ new Set();
-    for (const targets of targetsByGraph.values()) {
-      for (const target of targets) declared.add(target.projection);
-    }
-    const diagnosed = await diagnoseTargets(targetsByGraph);
-    const entries = [];
-    for (const projection of PROBE_PROJECTION_ORDER) {
-      if (!declared.has(projection)) continue;
-      const problems = diagnosed.filter(
-        (entry) => entry.projection === projection
-      );
-      if (problems.length === 0) {
-        entries.push({ contribution: projection, state: "ready" });
-        continue;
-      }
-      entries.push({
-        contribution: projection,
-        state: "degraded",
-        detail: problems.map((entry) => describeProbeDiagnostic(entry.diagnostic)).join("; ")
-      });
-    }
-    return entries;
-  }
-  async function repairContributions(graphId, vectorSlots) {
-    const diagnosed = await diagnoseContributions(graphId, vectorSlots);
-    const results = [];
-    for (const {
-      graphId: targetGraphId,
-      contribution,
-      diagnostic
-    } of diagnosed) {
-      if (diagnostic.state === "stale" || diagnostic.state === "orphaned-marker") {
-        results.push({ diagnostic, status: "requires-rebuild" });
-        continue;
-      }
-      try {
-        await ensureContributions(targetGraphId, [contribution], {
-          bypassCache: true
-        });
-        results.push({ diagnostic, status: "repaired" });
-      } catch (error) {
-        results.push({
-          diagnostic,
-          status: "failed",
-          error: error instanceof Error ? error.message : String(error)
-        });
-      }
-    }
-    return {
-      results,
-      remaining: await verifyContributions(graphId, vectorSlots)
-    };
-  }
-  async function lockContributionDdl(tx) {
-    if (dialect !== "postgres") return;
-    await tx.execute(
-      chunkEDN4Y4ZG_cjs.asCompiledRowsSql(
-        chunkEDN4Y4ZG_cjs.sql`SELECT pg_advisory_xact_lock(hashtext(${CONTRIBUTION_DDL_LOCK_KEY}), 0)`
-      )
-    );
-  }
-  async function lockSharedFulltextTable(tx, tableName) {
-    if (dialect !== "postgres") return;
-    await tx.executeStatement(
-      chunkEDN4Y4ZG_cjs.asCompiledStatementSql(
-        chunkEDN4Y4ZG_cjs.sql`LOCK TABLE ${chunkEDN4Y4ZG_cjs.sql.identifier(tableName)} IN ACCESS EXCLUSIVE MODE`
-      )
-    );
-  }
-  async function readForeignGraphIds(tx, tableName, graphId) {
-    const rows = await tx.execute(
-      chunkEDN4Y4ZG_cjs.asCompiledRowsSql(
-        chunkL3LQNR34_cjs.buildForeignFulltextGraphProbe(
-          tableName,
-          graphId,
-          FOREIGN_GRAPH_REPORT_LIMIT
-        )
-      )
-    );
-    return rows.map((row) => String(row.graph_id));
-  }
-  async function rebuildContribution(graphId, scope, repopulate) {
-    if (scope === "vector") {
-      throw new chunkMRDBBHIZ_cjs.ContributionRebuildUnsupportedError(
-        "vector-source-unavailable",
-        { graphId, contribution: scope }
-      );
-    }
-    const contributions = runtimeContributions();
-    const withoutTeardown = contributions.find(
-      (contribution) => contribution.dropDdl === void 0
-    );
-    if (withoutTeardown !== void 0) {
-      throw new chunkMRDBBHIZ_cjs.ContributionRebuildUnsupportedError("no-drop-ddl", {
-        graphId,
-        contribution: scope,
-        owner: withoutTeardown.owner,
-        logicalName: withoutTeardown.logicalName,
-        physicalName: withoutTeardown.tableName
-      });
-    }
-    const fence = deps.schemaWriteTransaction;
-    if (fence === void 0) {
-      throw new chunkMRDBBHIZ_cjs.ContributionRebuildUnsupportedError("no-schema-fence", {
-        graphId,
-        contribution: scope,
-        backend: dialect
-      });
-    }
-    const stamps = await Promise.all(
-      contributions.map(async (contribution) => {
-        const key = contributionKey(graphId, contribution);
-        return {
-          contribution,
-          key,
-          signature: await resolveContributionSignature(key, contribution)
-        };
-      })
-    );
-    await deps.ensureMarkerTable();
-    const markers = indexMarkerRows(graphId, await deps.getMarkers(graphId));
-    const sharedTable = deps.fulltextTableName;
-    const sharedTableExisted = await deps.tableExists(sharedTable);
-    const rebuilt = await fence(graphId, async (tx) => {
-      const record = tx.recordContributionMaterialization;
-      if (record === void 0) {
-        throw new chunkMRDBBHIZ_cjs.ConfigurationError(
-          "rebuildContribution requires a transaction-scoped backend that can write contribution markers; without it the drop, recreate, and stamp could not commit together.",
-          {
-            backend: dialect,
-            capability: "contributions",
-            operation: "rebuild"
-          }
-        );
-      }
-      await lockContributionDdl(tx);
-      const unlockedForeignGraphIds = sharedTableExisted ? await readForeignGraphIds(tx, sharedTable, graphId) : [];
-      const mayRecreate = sharedTableExisted && unlockedForeignGraphIds.length === 0;
-      if (mayRecreate) await lockSharedFulltextTable(tx, sharedTable);
-      const foreignGraphIds = mayRecreate ? await readForeignGraphIds(tx, sharedTable, graphId) : unlockedForeignGraphIds;
-      const recreateStorage = mayRecreate && foreignGraphIds.length === 0;
-      if (!recreateStorage) {
-        const staleStamp = stamps.find(
-          ({ key, signature }) => diagnoseContribution(
-            markers.get(key),
-            signature,
-            sharedTableExisted
-          ) === "stale"
-        );
-        if (staleStamp !== void 0) {
-          throw new chunkMRDBBHIZ_cjs.ContributionRebuildUnsupportedError(
-            "shared-storage-in-use",
-            {
-              graphId,
-              contribution: scope,
-              owner: staleStamp.contribution.owner,
-              logicalName: staleStamp.contribution.logicalName,
-              physicalName: staleStamp.contribution.tableName,
-              otherGraphIds: foreignGraphIds
-            }
-          );
-        }
-      }
-      for (const { contribution } of stamps) {
-        if (recreateStorage) {
-          for (const statement of contribution.dropDdl ?? []) {
-            await tx.executeSchemaDdl(statement);
-          }
-        }
-        for (const statement of contribution.createDdl) {
-          await tx.executeSchemaDdl(statement);
-        }
-      }
-      if (!recreateStorage) {
-        await tx.executeStatement(
-          chunkEDN4Y4ZG_cjs.asCompiledStatementSql(
-            chunkL3LQNR34_cjs.buildFulltextGraphDelete(sharedTable, graphId)
-          )
-        );
-      }
-      const stats = await repopulate(tx);
-      const now = chunkFA2AFWLP_cjs.nowIso();
-      for (const { contribution, signature } of stamps) {
-        await record({
-          ...identityOf(graphId, contribution),
-          signature,
-          attemptedAt: now,
-          materializedAt: now,
-          error: void 0
-        });
-      }
-      return {
-        rebuilt: stamps.map(({ contribution }) => contribution.tableName),
-        processed: stats.processed,
-        repopulated: stats.repopulated,
-        skipped: stats.skipped
-      };
-    });
-    for (const { key, signature } of stamps) {
-      cacheInitializedSignature(key, signature);
-    }
-    return rebuilt;
-  }
-  function evictVectorSlot(slot) {
-    if (deps.vectorStrategy === void 0) return;
-    for (const contribution of deps.vectorStrategy.ownedTables(slot)) {
-      const key = contributionKey(slot.graphId, contribution);
-      uncacheableKeys.add(key);
-      initializedSignatures.delete(key);
-      computedSignatures.delete(key);
-    }
-  }
-  async function dropVectorSlot(slot) {
-    if (deps.vectorStrategy === void 0) return;
-    try {
-      for (const contribution of deps.vectorStrategy.ownedTables(slot)) {
-        await deps.deleteMarker(identityOf(slot.graphId, contribution));
-      }
-    } finally {
-      evictVectorSlot(slot);
-    }
-  }
-  return {
-    ensureRuntimeContributions,
-    assertInitialized,
-    refuseUnavailableFulltext,
-    ensureVectorSlot,
-    ensureVectorSlots,
-    assertVectorSlot,
-    assertVectorSlots,
-    dropVectorSlot,
-    evictVectorSlot,
-    verifyContributions,
-    repairContributions,
-    probeContributions,
-    rebuildContribution
-  };
-}
-var SQLITE_INDEX_MAT_TIMESTAMPS = {
-  decode: (value) => typeof value === "string" ? value : void 0,
-  encode: (value) => value
-};
-var POSTGRES_INDEX_MAT_TIMESTAMPS = {
-  decode: chunkFA2AFWLP_cjs.formatPostgresTimestamp,
-  encode: (value) => new Date(value)
-};
-function mapMaterializationRow(row, decode) {
-  const lastAttemptedAt = decode(row.lastAttemptedAt);
-  if (lastAttemptedAt === void 0) {
-    throw new Error(
-      `materialization row missing required last_attempted_at: ${row.indexName}`
-    );
-  }
-  return {
-    indexName: row.indexName,
-    graphId: row.graphId,
-    entity: row.entity,
-    kind: row.kind,
-    signature: row.signature,
-    schemaVersion: row.schemaVersion,
-    materializedAt: decode(row.materializedAt),
-    lastAttemptedAt,
-    lastError: row.lastError ?? void 0
-  };
-}
-function buildMaterializationInsertValues(params, encode) {
-  return {
-    indexName: params.indexName,
-    graphId: params.graphId,
-    entity: params.entity,
-    kind: params.kind,
-    signature: params.signature,
-    schemaVersion: params.schemaVersion,
-    materializedAt: params.materializedAt === void 0 ? void 0 : encode(params.materializedAt),
-    lastAttemptedAt: encode(params.attemptedAt),
-    lastError: params.error
-  };
-}
-function buildMaterializationOnConflictSet(paramsMaterializedAt) {
-  if (paramsMaterializedAt === void 0) {
-    return {
-      lastAttemptedAt: drizzleOrm.sql`excluded.${drizzleOrm.sql.identifier("last_attempted_at")}`,
-      lastError: drizzleOrm.sql`excluded.${drizzleOrm.sql.identifier("last_error")}`
-    };
-  }
-  return {
-    graphId: drizzleOrm.sql`excluded.${drizzleOrm.sql.identifier("graph_id")}`,
-    entity: drizzleOrm.sql`excluded.${drizzleOrm.sql.identifier("entity")}`,
-    kind: drizzleOrm.sql`excluded.${drizzleOrm.sql.identifier("kind")}`,
-    signature: drizzleOrm.sql`excluded.${drizzleOrm.sql.identifier("signature")}`,
-    schemaVersion: drizzleOrm.sql`excluded.${drizzleOrm.sql.identifier("schema_version")}`,
-    materializedAt: drizzleOrm.sql`excluded.${drizzleOrm.sql.identifier("materialized_at")}`,
-    lastAttemptedAt: drizzleOrm.sql`excluded.${drizzleOrm.sql.identifier("last_attempted_at")}`,
-    lastError: drizzleOrm.sql`excluded.${drizzleOrm.sql.identifier("last_error")}`
-  };
-}
-var SQLITE_KIND_REMOVAL_TIMESTAMPS = {
-  decode: (value) => typeof value === "string" ? value : void 0,
-  encode: (value) => value
-};
-var POSTGRES_KIND_REMOVAL_TIMESTAMPS = {
-  decode: chunkFA2AFWLP_cjs.formatPostgresTimestamp,
-  encode: (value) => new Date(value)
-};
-function mapKindRemovalRow(row, decode) {
-  const lastAttemptedAt = decode(row.lastAttemptedAt);
-  if (lastAttemptedAt === void 0) {
-    throw new Error(
-      `kind removal row missing required last_attempted_at: ${row.kindName}`
-    );
-  }
-  return {
-    graphId: row.graphId,
-    kindName: row.kindName,
-    entity: row.entity,
-    schemaVersion: row.schemaVersion,
-    removedAt: decode(row.removedAt),
-    lastAttemptedAt,
-    lastError: row.lastError ?? void 0
-  };
-}
-function buildKindRemovalInsertValues(params, encode) {
-  return {
-    graphId: params.graphId,
-    kindName: params.kindName,
-    entity: params.entity,
-    schemaVersion: params.schemaVersion,
-    removedAt: params.removedAt === void 0 ? void 0 : encode(params.removedAt),
-    lastAttemptedAt: encode(params.attemptedAt),
-    lastError: params.error
-  };
-}
-function buildKindRemovalOnConflictSet(removedAtColumn, paramsRemovedAt) {
-  const removedAtSet = paramsRemovedAt === void 0 ? drizzleOrm.sql`COALESCE(excluded.${drizzleOrm.sql.identifier("removed_at")}, ${removedAtColumn})` : drizzleOrm.sql`excluded.${drizzleOrm.sql.identifier("removed_at")}`;
-  return {
-    entity: drizzleOrm.sql`excluded.${drizzleOrm.sql.identifier("entity")}`,
-    schemaVersion: drizzleOrm.sql`excluded.${drizzleOrm.sql.identifier("schema_version")}`,
-    removedAt: removedAtSet,
-    lastAttemptedAt: drizzleOrm.sql`excluded.${drizzleOrm.sql.identifier("last_attempted_at")}`,
-    lastError: drizzleOrm.sql`excluded.${drizzleOrm.sql.identifier("last_error")}`
-  };
-}
-function primaryKeyConstraintNames(relation, keyColumns) {
-  return [`${relation}_pkey`, `${relation}_${keyColumns.join("_")}_pk`];
-}
-function nodePrimaryKeyConstraint(nodes) {
-  const relation = drizzleOrm.getTableName(nodes);
-  return {
-    table: relation,
-    constraintNames: primaryKeyConstraintNames(relation, [
-      nodes.graphId.name,
-      nodes.kind.name,
-      nodes.id.name
-    ])
-  };
-}
-function edgePrimaryKeyConstraint(edges) {
-  const relation = drizzleOrm.getTableName(edges);
-  return {
-    table: relation,
-    constraintNames: primaryKeyConstraintNames(relation, [
-      edges.graphId.name,
-      edges.id.name
-    ])
-  };
-}
-function sqlNull(value) {
-  return value ?? drizzleOrm.sql.raw("NULL");
-}
-function expectedValidFromPredicate(column, expected) {
-  if (expected === void 0) return drizzleOrm.sql.empty();
-  if (expected === null) return drizzleOrm.sql` AND ${column} IS NULL`;
-  return drizzleOrm.sql` AND ${column} = ${expected}`;
-}
-function quotedColumn(column) {
-  return drizzleOrm.sql.raw(`"${column.name.replaceAll('"', '""')}"`);
-}
-function quotedTableName(tableName) {
-  return drizzleOrm.sql.raw(`"${tableName.replaceAll('"', '""')}"`);
-}
-var CODE_POINT_ORDER_BUILDERS = {
-  postgres: (value) => drizzleOrm.sql`${value} COLLATE "C"`,
-  sqlite: (value) => value
-};
-function codePointOrderKey(column, dialect) {
-  return CODE_POINT_ORDER_BUILDERS[dialect](column);
-}
-function liveNodeIdsSubquery(nodes, graphId, nodeKind, nowIso2) {
-  return drizzleOrm.sql`SELECT ${nodes.id} AS node_id FROM ${nodes} WHERE ${nodes.graphId} = ${graphId} AND ${nodes.kind} = ${nodeKind} AND ${nodes.deletedAt} IS NULL AND (${nodes.validFrom} IS NULL OR ${nodes.validFrom} <= ${nowIso2}) AND (${nodes.validTo} IS NULL OR ${nodes.validTo} > ${nowIso2})`;
-}
-function nodeColumnList(nodes) {
-  return drizzleOrm.sql.raw(
-    `"${nodes.graphId.name}", "${nodes.kind.name}", "${nodes.id.name}", "${nodes.props.name}", "${nodes.version.name}", "${nodes.validFrom.name}", "${nodes.validTo.name}", "${nodes.createdAt.name}", "${nodes.updatedAt.name}"`
-  );
-}
-function edgeColumnList(edges) {
-  return drizzleOrm.sql.raw(
-    `"${edges.graphId.name}", "${edges.id.name}", "${edges.kind.name}", "${edges.fromKind.name}", "${edges.fromId.name}", "${edges.toKind.name}", "${edges.toId.name}", "${edges.props.name}", "${edges.validFrom.name}", "${edges.validTo.name}", "${edges.createdAt.name}", "${edges.updatedAt.name}"`
-  );
-}
-
-// src/backend/drizzle/operations/hybrid.ts
-function nodeIdOrderKey(dialect) {
-  return codePointOrderKey(drizzleOrm.sql.raw("node_id"), dialect);
-}
-function hybridCandidatesRef() {
-  return drizzleOrm.sql`SELECT node_id FROM tg_hybrid_cand`;
-}
-function buildHybridSearchStatement(input) {
-  const { nodes } = input;
-  const nodeIdOrder = nodeIdOrderKey(input.dialect);
-  const vectorOrder = input.vectorScoreDescending ? drizzleOrm.sql`score DESC, ${nodeIdOrder} ASC` : drizzleOrm.sql`score ASC, ${nodeIdOrder} ASC`;
-  const columnPairs = [
-    [nodes.graphId, "graph_id"],
-    [nodes.kind, "kind"],
-    [nodes.id, "id"],
-    [nodes.props, "props"],
-    [nodes.version, "version"],
-    [nodes.validFrom, "valid_from"],
-    [nodes.validTo, "valid_to"],
-    [nodes.createdAt, "created_at"],
-    [nodes.updatedAt, "updated_at"],
-    [nodes.deletedAt, "deleted_at"]
-  ];
-  const nodeColumns = drizzleOrm.sql.raw(
-    columnPairs.map(
-      ([column, alias]) => `tg_hybrid_node."${column.name.replaceAll('"', '""')}" AS ${alias}`
-    ).join(", ")
-  );
-  return drizzleOrm.sql`
-    WITH tg_hybrid_cand AS (
-      SELECT node_id FROM (${input.candidatesSql}) AS tg_hybrid_cand_src
-    ),
-    tg_hybrid_vec AS (
-      SELECT node_id, score,
-             ROW_NUMBER() OVER (ORDER BY ${vectorOrder}) AS ord
-      FROM (${input.vectorSql}) AS tg_hybrid_vec_src
-    ),
-    tg_hybrid_fts AS (
-      SELECT node_id, score, snippet,
-             ROW_NUMBER() OVER (ORDER BY score DESC, ${nodeIdOrder} ASC) AS ord
-      FROM (${input.fulltextSql}) AS tg_hybrid_fts_src
-    ),
-    tg_hybrid_pairs AS (
-      SELECT node_id, ord AS vector_rank, score AS vector_score,
-             NULL AS fulltext_rank, NULL AS fulltext_score, NULL AS snippet
-      FROM tg_hybrid_vec
-      UNION ALL
-      SELECT node_id, NULL, NULL, ord, score, snippet
-      FROM tg_hybrid_fts
-    ),
-    tg_hybrid_fused AS MATERIALIZED (
-      SELECT node_id,
-        SUM(
-          COALESCE((${input.vectorWeight} * 1.0) / (${input.fusionK} + vector_rank), 0)
-          + COALESCE((${input.fulltextWeight} * 1.0) / (${input.fusionK} + fulltext_rank), 0)
-        ) AS fused_score,
-        MAX(vector_rank) AS vector_rank,
-        MAX(vector_score) AS vector_score,
-        MAX(fulltext_rank) AS fulltext_rank,
-        MAX(fulltext_score) AS fulltext_score,
-        MAX(snippet) AS snippet
-      FROM tg_hybrid_pairs
-      GROUP BY node_id
-    )
-    SELECT
-      tg_hybrid_fused.node_id AS node_id,
-      tg_hybrid_fused.fused_score AS fused_score,
-      tg_hybrid_fused.vector_rank AS vector_rank,
-      tg_hybrid_fused.vector_score AS vector_score,
-      tg_hybrid_fused.fulltext_rank AS fulltext_rank,
-      tg_hybrid_fused.fulltext_score AS fulltext_score,
-      tg_hybrid_fused.snippet AS snippet,
-      ${nodeColumns}
-    FROM tg_hybrid_fused
-    JOIN ${nodes} AS tg_hybrid_node
-      ON ${qualified(nodes, "graphId")} = ${input.graphId}
-     AND ${qualified(nodes, "kind")} = ${input.nodeKind}
-     AND ${qualified(nodes, "id")} = tg_hybrid_fused.node_id
-     AND ${qualified(nodes, "deletedAt")} IS NULL
-    ORDER BY fused_score DESC, ${nodeIdOrder} ASC
-    LIMIT ${input.limit} OFFSET ${input.offset}
-  `;
-}
-function qualified(nodes, member) {
-  return drizzleOrm.sql`tg_hybrid_node.${quotedColumn(nodes[member])}`;
-}
-function present(value) {
-  return value !== null && value !== void 0;
-}
-function mapHybridSearchRow(row, toNodeRow) {
-  return {
-    node: toNodeRow(row),
-    fusedScore: chunkFA2AFWLP_cjs.coerceNumericScore(row["fused_score"]),
-    ...present(row["vector_rank"]) ? { vectorRank: Number(row["vector_rank"]) } : {},
-    ...present(row["vector_score"]) ? { vectorScore: chunkFA2AFWLP_cjs.coerceNumericScore(row["vector_score"]) } : {},
-    ...present(row["fulltext_rank"]) ? { fulltextRank: Number(row["fulltext_rank"]) } : {},
-    ...present(row["fulltext_score"]) ? {
-      fulltextScore: chunkFA2AFWLP_cjs.coerceNumericScore(
-        row["fulltext_score"]
-      )
-    } : {},
-    ...present(row["snippet"]) ? { snippet: String(row["snippet"]) } : {}
-  };
-}
-function buildClearGraph(tables, graphId) {
-  return [
-    // The fulltext table is shared by every graph in the database, so its
-    // graph-scoped delete is owned by one builder the destructive
-    // contribution rebuild calls too — see `buildFulltextGraphDelete`.
-    { query: chunkL3LQNR34_cjs.buildFulltextGraphDelete(tables.fulltextTableName, graphId) },
-    {
-      query: drizzleOrm.sql`DELETE FROM ${tables.recordedIdentityAssertions} WHERE ${tables.recordedIdentityAssertions.graphId} = ${graphId}`,
-      ignoreMissingTable: true,
-      requiredTableName: drizzleOrm.getTableName(tables.recordedIdentityAssertions)
-    },
-    {
-      query: drizzleOrm.sql`DELETE FROM ${tables.recordedEdges} WHERE ${tables.recordedEdges.graphId} = ${graphId}`,
-      ignoreMissingTable: true,
-      requiredTableName: drizzleOrm.getTableName(tables.recordedEdges)
-    },
-    {
-      query: drizzleOrm.sql`DELETE FROM ${tables.recordedNodes} WHERE ${tables.recordedNodes.graphId} = ${graphId}`,
-      ignoreMissingTable: true,
-      requiredTableName: drizzleOrm.getTableName(tables.recordedNodes)
-    },
-    {
-      query: drizzleOrm.sql`DELETE FROM ${tables.recordedClock} WHERE ${tables.recordedClock.graphId} = ${graphId}`,
-      ignoreMissingTable: true,
-      requiredTableName: drizzleOrm.getTableName(tables.recordedClock)
-    },
-    {
-      query: drizzleOrm.sql`DELETE FROM ${tables.identitySeparation} WHERE ${tables.identitySeparation.graphId} = ${graphId}`,
-      ignoreMissingTable: true,
-      requiredTableName: drizzleOrm.getTableName(tables.identitySeparation)
-    },
-    {
-      query: drizzleOrm.sql`DELETE FROM ${tables.identityClosure} WHERE ${tables.identityClosure.graphId} = ${graphId}`,
-      ignoreMissingTable: true,
-      requiredTableName: drizzleOrm.getTableName(tables.identityClosure)
-    },
-    {
-      query: drizzleOrm.sql`DELETE FROM ${tables.identityAssertions} WHERE ${tables.identityAssertions.graphId} = ${graphId}`,
-      ignoreMissingTable: true,
-      requiredTableName: drizzleOrm.getTableName(tables.identityAssertions)
-    },
-    {
-      query: drizzleOrm.sql`DELETE FROM ${tables.uniques} WHERE ${tables.uniques.graphId} = ${graphId}`
-    },
-    {
-      query: drizzleOrm.sql`DELETE FROM ${tables.edges} WHERE ${tables.edges.graphId} = ${graphId}`
-    },
-    {
-      query: drizzleOrm.sql`DELETE FROM ${tables.nodes} WHERE ${tables.nodes.graphId} = ${graphId}`
-    },
-    {
-      query: drizzleOrm.sql`DELETE FROM ${tables.indexMaterializations} WHERE ${tables.indexMaterializations.graphId} = ${graphId}`
-    },
-    {
-      query: drizzleOrm.sql`DELETE FROM ${tables.kindRemovals} WHERE ${tables.kindRemovals.graphId} = ${graphId}`
-    },
-    {
-      query: drizzleOrm.sql`DELETE FROM ${tables.reconciliationMarkers} WHERE ${tables.reconciliationMarkers.graphId} = ${graphId}`
-    },
-    {
-      query: drizzleOrm.sql`DELETE FROM ${tables.schemaVersions} WHERE ${tables.schemaVersions.graphId} = ${graphId}`
-    }
-  ];
-}
-function buildTemporalConditions(table, params) {
-  const conditions = [];
-  const mode = params.temporalMode;
-  if (mode === "includeTombstones") return conditions;
-  if (params.excludeDeleted !== false) {
-    conditions.push(drizzleOrm.sql`${table.deletedAt} IS NULL`);
-  }
-  if (mode === "current" || mode === "asOf") {
-    if (params.asOf === void 0) {
-      throw new Error(`asOf timestamp is required for temporal mode "${mode}"`);
-    }
-    conditions.push(
-      drizzleOrm.sql`(${table.validFrom} IS NULL OR ${table.validFrom} <= ${params.asOf})`,
-      drizzleOrm.sql`(${table.validTo} IS NULL OR ${table.validTo} > ${params.asOf})`
-    );
-  }
-  return conditions;
-}
-function buildFindNodesByKind(tables, params) {
-  const { nodes } = tables;
-  const conditions = [
-    drizzleOrm.sql`${nodes.graphId} = ${params.graphId}`,
-    drizzleOrm.sql`${nodes.kind} = ${params.kind}`,
-    ...buildTemporalConditions(nodes, params)
-  ];
-  if (params.orderBy === "id" && params.after !== void 0) {
-    conditions.push(drizzleOrm.sql`${nodes.id} > ${params.after}`);
-  }
-  const whereClause = drizzleOrm.sql.join(conditions, drizzleOrm.sql` AND `);
-  const orderByClause = params.orderBy === "id" ? drizzleOrm.sql`${nodes.id} ASC` : drizzleOrm.sql`${nodes.createdAt} DESC, ${nodes.id} DESC`;
-  if (params.limit !== void 0 && params.offset !== void 0) {
-    return drizzleOrm.sql`
-      SELECT * FROM ${nodes}
-      WHERE ${whereClause}
-      ORDER BY ${orderByClause}
-      LIMIT ${params.limit} OFFSET ${params.offset}
-    `;
-  }
-  if (params.limit !== void 0) {
-    return drizzleOrm.sql`
-      SELECT * FROM ${nodes}
-      WHERE ${whereClause}
-      ORDER BY ${orderByClause}
-      LIMIT ${params.limit}
-    `;
-  }
-  return drizzleOrm.sql`
-    SELECT * FROM ${nodes}
-    WHERE ${whereClause}
-    ORDER BY ${orderByClause}
-  `;
-}
-function buildCountNodesByKind(tables, params) {
-  const { nodes } = tables;
-  const conditions = [
-    drizzleOrm.sql`${nodes.graphId} = ${params.graphId}`,
-    drizzleOrm.sql`${nodes.kind} = ${params.kind}`,
-    ...buildTemporalConditions(nodes, params)
-  ];
-  const whereClause = drizzleOrm.sql.join(conditions, drizzleOrm.sql` AND `);
-  return drizzleOrm.sql`
-    SELECT COUNT(*) as count FROM ${nodes}
-    WHERE ${whereClause}
-  `;
-}
-function buildIdSetCondition(column, ids) {
-  return drizzleOrm.sql`${column} IN (${drizzleOrm.sql.join(
-    ids.map((id) => drizzleOrm.sql`${id}`),
-    drizzleOrm.sql`, `
-  )})`;
-}
-function buildEdgeOrdering(tables, orderBy) {
-  const { edges } = tables;
-  return orderBy === "id" ? { qualified: drizzleOrm.sql`${edges.id} ASC`, bare: drizzleOrm.sql.raw(`"id" ASC`) } : {
-    qualified: drizzleOrm.sql`${edges.createdAt} DESC, ${edges.id} DESC`,
-    bare: drizzleOrm.sql.raw(`"created_at" DESC, "id" DESC`)
-  };
-}
-function buildFindEdgesByKind(tables, params) {
-  const { edges } = tables;
-  const conditions = [
-    drizzleOrm.sql`${edges.graphId} = ${params.graphId}`,
-    drizzleOrm.sql`${edges.kind} = ${params.kind}`,
-    ...buildTemporalConditions(edges, params)
-  ];
-  if (params.fromKind !== void 0) {
-    conditions.push(drizzleOrm.sql`${edges.fromKind} = ${params.fromKind}`);
-  }
-  if (params.fromId !== void 0) {
-    conditions.push(drizzleOrm.sql`${edges.fromId} = ${params.fromId}`);
-  }
-  if (params.toKind !== void 0) {
-    conditions.push(drizzleOrm.sql`${edges.toKind} = ${params.toKind}`);
-  }
-  if (params.toId !== void 0) {
-    conditions.push(drizzleOrm.sql`${edges.toId} = ${params.toId}`);
-  }
-  if (params.orderBy === "id" && params.after !== void 0) {
-    conditions.push(drizzleOrm.sql`${edges.id} > ${params.after}`);
-  }
-  const whereClause = drizzleOrm.sql.join(conditions, drizzleOrm.sql` AND `);
-  const { qualified: orderByClause } = buildEdgeOrdering(
-    tables,
-    params.orderBy
-  );
-  if (params.limit !== void 0 && params.offset !== void 0) {
-    return drizzleOrm.sql`
-      SELECT * FROM ${edges}
-      WHERE ${whereClause}
-      ORDER BY ${orderByClause}
-      LIMIT ${params.limit} OFFSET ${params.offset}
-    `;
-  }
-  if (params.limit !== void 0) {
-    return drizzleOrm.sql`
-      SELECT * FROM ${edges}
-      WHERE ${whereClause}
-      ORDER BY ${orderByClause}
-      LIMIT ${params.limit}
-    `;
-  }
-  return drizzleOrm.sql`
-    SELECT * FROM ${edges}
-    WHERE ${whereClause}
-    ORDER BY ${orderByClause}
-  `;
-}
-function buildFindEdgesByEndpointSet(tables, params, endpointIds) {
-  const { edges } = tables;
-  const fromSide = params.side === "from";
-  const kindColumn = fromSide ? edges.fromKind : edges.toKind;
-  const idColumn = fromSide ? edges.fromId : edges.toId;
-  const whereClause = drizzleOrm.sql.join(
-    [
-      drizzleOrm.sql`${edges.graphId} = ${params.graphId}`,
-      drizzleOrm.sql`${edges.kind} = ${params.kind}`,
-      ...buildTemporalConditions(edges, params),
-      drizzleOrm.sql`${kindColumn} = ${params.endpointKind}`,
-      buildIdSetCondition(idColumn, endpointIds)
-    ],
-    drizzleOrm.sql` AND `
-  );
-  const { qualified: orderByClause, bare: derivedOrderByClause } = buildEdgeOrdering(tables, void 0);
-  if (params.limitPerEndpoint === void 0) {
-    return drizzleOrm.sql`
-      SELECT * FROM ${edges}
-      WHERE ${whereClause}
-      ORDER BY ${orderByClause}
-    `;
-  }
-  const ranked = drizzleOrm.sql`
-    SELECT *, ROW_NUMBER() OVER (
-      PARTITION BY ${idColumn} ORDER BY ${orderByClause}
-    ) AS endpoint_rank
-    FROM ${edges}
-    WHERE ${whereClause}
-  `;
-  return drizzleOrm.sql`
-    SELECT * FROM (${ranked}) AS ranked_edges
-    WHERE endpoint_rank <= ${params.limitPerEndpoint}
-    ORDER BY ${derivedOrderByClause}
-  `;
-}
-function buildFindEdgesByHeterogeneousEndpointSet(tables, params, endpoints, edgeKinds) {
-  const { edges } = tables;
-  const fromSide = params.side === "from";
-  const kindColumn = fromSide ? edges.fromKind : edges.toKind;
-  const idColumn = fromSide ? edges.fromId : edges.toId;
-  const requestedKind = drizzleOrm.sql.raw(`requested_endpoints."endpoint_kind"`);
-  const requestedId = drizzleOrm.sql.raw(`requested_endpoints."endpoint_id"`);
-  const requestedRows = drizzleOrm.sql.join(
-    endpoints.map((endpoint) => drizzleOrm.sql`(${endpoint.kind}, ${endpoint.id})`),
-    drizzleOrm.sql`, `
-  );
-  const whereClause = drizzleOrm.sql.join(
-    [
-      drizzleOrm.sql`${edges.graphId} = ${params.graphId}`,
-      buildIdSetCondition(edges.kind, edgeKinds),
-      ...buildTemporalConditions(edges, params)
-    ],
-    drizzleOrm.sql` AND `
-  );
-  const joinClause = drizzleOrm.sql`
-    FROM ${edges}
-    INNER JOIN requested_endpoints
-      ON ${kindColumn} = ${requestedKind}
-     AND ${idColumn} = ${requestedId}
-    WHERE ${whereClause}
-  `;
-  const { qualified: orderByClause, bare: derivedOrderByClause } = buildEdgeOrdering(tables, void 0);
-  if (params.limitPerEndpoint === void 0) {
-    return drizzleOrm.sql`
-      WITH requested_endpoints(endpoint_kind, endpoint_id) AS (
-        VALUES ${requestedRows}
-      )
-      SELECT ${edges}.*
-      ${joinClause}
-      ORDER BY ${orderByClause}
-    `;
-  }
-  const ranked = drizzleOrm.sql`
-    SELECT ${edges}.*, ROW_NUMBER() OVER (
-      PARTITION BY ${kindColumn}, ${idColumn} ORDER BY ${orderByClause}
-    ) AS endpoint_rank
-    ${joinClause}
-  `;
-  return drizzleOrm.sql`
-    WITH requested_endpoints(endpoint_kind, endpoint_id) AS (
-      VALUES ${requestedRows}
-    )
-    SELECT * FROM (${ranked}) AS ranked_edges
-    WHERE endpoint_rank <= ${params.limitPerEndpoint}
-    ORDER BY ${derivedOrderByClause}
-  `;
-}
-function buildCountEdgesByKind(tables, params) {
-  const { edges } = tables;
-  const conditions = [
-    drizzleOrm.sql`${edges.graphId} = ${params.graphId}`,
-    drizzleOrm.sql`${edges.kind} = ${params.kind}`,
-    ...buildTemporalConditions(edges, params)
-  ];
-  if (params.fromKind !== void 0) {
-    conditions.push(drizzleOrm.sql`${edges.fromKind} = ${params.fromKind}`);
-  }
-  if (params.fromId !== void 0) {
-    conditions.push(drizzleOrm.sql`${edges.fromId} = ${params.fromId}`);
-  }
-  if (params.toKind !== void 0) {
-    conditions.push(drizzleOrm.sql`${edges.toKind} = ${params.toKind}`);
-  }
-  if (params.toId !== void 0) {
-    conditions.push(drizzleOrm.sql`${edges.toId} = ${params.toId}`);
-  }
-  const whereClause = drizzleOrm.sql.join(conditions, drizzleOrm.sql` AND `);
-  return drizzleOrm.sql`
-    SELECT COUNT(*) as count FROM ${edges}
-    WHERE ${whereClause}
-  `;
-}
-function buildInsertEdge(tables, params, timestamp) {
-  const { edges } = tables;
-  const propsJson = JSON.stringify(params.props);
-  const columns = edgeColumnList(edges);
-  return drizzleOrm.sql`
-    INSERT INTO ${edges} (${columns})
-    VALUES (
-      ${params.graphId}, ${params.id}, ${params.kind},
-      ${params.fromKind}, ${params.fromId}, ${params.toKind}, ${params.toId},
-      ${propsJson}, ${sqlNull(chunkTQHGE7UC_cjs.resolveStampedValidityLowerBound(params.validFrom, params.validTo, timestamp))}, ${sqlNull(params.validTo)},
-      ${timestamp}, ${timestamp}
-    )
-    RETURNING *
-  `;
-}
-function buildInsertEdgeNoReturn(tables, params, timestamp) {
-  const { edges } = tables;
-  const propsJson = JSON.stringify(params.props);
-  const columns = edgeColumnList(edges);
-  return drizzleOrm.sql`
-    INSERT INTO ${edges} (${columns})
-    VALUES (
-      ${params.graphId}, ${params.id}, ${params.kind},
-      ${params.fromKind}, ${params.fromId}, ${params.toKind}, ${params.toId},
-      ${propsJson}, ${sqlNull(chunkTQHGE7UC_cjs.resolveStampedValidityLowerBound(params.validFrom, params.validTo, timestamp))}, ${sqlNull(params.validTo)},
-      ${timestamp}, ${timestamp}
-    )
-  `;
-}
-function buildInsertEdgesBatch(tables, params, timestamp) {
-  const { edges } = tables;
-  const columns = edgeColumnList(edges);
-  const values = params.map((edgeParams) => {
-    const propsJson = JSON.stringify(edgeParams.props);
-    return drizzleOrm.sql`(${edgeParams.graphId}, ${edgeParams.id}, ${edgeParams.kind}, ${edgeParams.fromKind}, ${edgeParams.fromId}, ${edgeParams.toKind}, ${edgeParams.toId}, ${propsJson}, ${sqlNull(chunkTQHGE7UC_cjs.resolveStampedValidityLowerBound(edgeParams.validFrom, edgeParams.validTo, timestamp))}, ${sqlNull(edgeParams.validTo)}, ${timestamp}, ${timestamp})`;
-  });
-  return drizzleOrm.sql`
-    INSERT INTO ${edges} (${columns})
-    VALUES ${drizzleOrm.sql.join(values, drizzleOrm.sql`, `)}
-  `;
-}
-function buildInsertEdgesBatchReturning(tables, params, timestamp) {
-  const { edges } = tables;
-  const columns = edgeColumnList(edges);
-  const values = params.map((edgeParams) => {
-    const propsJson = JSON.stringify(edgeParams.props);
-    return drizzleOrm.sql`(${edgeParams.graphId}, ${edgeParams.id}, ${edgeParams.kind}, ${edgeParams.fromKind}, ${edgeParams.fromId}, ${edgeParams.toKind}, ${edgeParams.toId}, ${propsJson}, ${sqlNull(chunkTQHGE7UC_cjs.resolveStampedValidityLowerBound(edgeParams.validFrom, edgeParams.validTo, timestamp))}, ${sqlNull(edgeParams.validTo)}, ${timestamp}, ${timestamp})`;
-  });
-  return drizzleOrm.sql`
-    INSERT INTO ${edges} (${columns})
-    VALUES ${drizzleOrm.sql.join(values, drizzleOrm.sql`, `)}
-    RETURNING *
-  `;
-}
-function buildGetEdge(tables, graphId, id) {
-  const { edges } = tables;
-  return drizzleOrm.sql`
-    SELECT * FROM ${edges}
-    WHERE ${edges.graphId} = ${graphId}
-      AND ${edges.id} = ${id}
-  `;
-}
-function buildGetEdges(tables, graphId, ids) {
-  const { edges } = tables;
-  return drizzleOrm.sql`
-    SELECT * FROM ${edges}
-    WHERE ${edges.graphId} = ${graphId}
-      AND ${edges.id} IN (${drizzleOrm.sql.join(
-    ids.map((id) => drizzleOrm.sql`${id}`),
-    drizzleOrm.sql`, `
-  )})
-  `;
-}
-function expectedIdentityPredicate(tables, expected) {
-  const { edges } = tables;
-  const parts = [
-    expected.kind === void 0 ? void 0 : drizzleOrm.sql` AND ${edges.kind} = ${expected.kind}`,
-    expected.fromKind === void 0 ? void 0 : drizzleOrm.sql` AND ${edges.fromKind} = ${expected.fromKind}`,
-    expected.fromId === void 0 ? void 0 : drizzleOrm.sql` AND ${edges.fromId} = ${expected.fromId}`,
-    expected.toKind === void 0 ? void 0 : drizzleOrm.sql` AND ${edges.toKind} = ${expected.toKind}`,
-    expected.toId === void 0 ? void 0 : drizzleOrm.sql` AND ${edges.toId} = ${expected.toId}`
-  ].filter((part) => part !== void 0);
-  return parts.length === 0 ? drizzleOrm.sql.empty() : drizzleOrm.sql.join(parts, drizzleOrm.sql``);
-}
-function buildUpdateEdge(tables, params, timestamp) {
-  const { edges } = tables;
-  const propsJson = JSON.stringify(params.props);
-  const setParts = [
-    drizzleOrm.sql`${quotedColumn(edges.props)} = ${propsJson}`,
-    drizzleOrm.sql`${quotedColumn(edges.updatedAt)} = ${timestamp}`
-  ];
-  if (params.clearDeleted && params.validFrom !== void 0) {
-    setParts.push(
-      drizzleOrm.sql`${quotedColumn(edges.validFrom)} = ${sqlNull(chunkTQHGE7UC_cjs.resolveStatedValidityLowerBound(params.validFrom))}`,
-      drizzleOrm.sql`${quotedColumn(edges.validTo)} = ${sqlNull(params.validTo)}`
-    );
-  } else if (params.clearValidTo === true) {
-    setParts.push(drizzleOrm.sql`${quotedColumn(edges.validTo)} = NULL`);
-  } else if (params.validTo !== void 0) {
-    setParts.push(drizzleOrm.sql`${quotedColumn(edges.validTo)} = ${params.validTo}`);
-  }
-  if (params.clearDeleted) {
-    setParts.push(drizzleOrm.sql`${quotedColumn(edges.deletedAt)} = NULL`);
-  }
-  const setClause = drizzleOrm.sql.join(setParts, drizzleOrm.sql`, `);
-  const expectedIdentity = expectedIdentityPredicate(tables, params);
-  const expectedValidFrom = expectedValidFromPredicate(
-    edges.validFrom,
-    params.expectedValidFrom
-  );
-  const expectedValidTo = expectedValidFromPredicate(
-    edges.validTo,
-    params.expectedValidTo
-  );
-  if (params.clearDeleted) {
-    return drizzleOrm.sql`
-      UPDATE ${edges}
-      SET ${setClause}
-      WHERE ${edges.graphId} = ${params.graphId}
-        AND ${edges.id} = ${params.id}${expectedIdentity}${expectedValidFrom}${expectedValidTo}
-      RETURNING *
-    `;
-  }
-  return drizzleOrm.sql`
-    UPDATE ${edges}
-    SET ${setClause}
-    WHERE ${edges.graphId} = ${params.graphId}
-      AND ${edges.id} = ${params.id}${expectedIdentity}${expectedValidFrom}${expectedValidTo}
-      AND ${edges.deletedAt} IS NULL
-    RETURNING *
-  `;
-}
-function buildDeleteEdge(tables, params, timestamp) {
-  const { edges } = tables;
-  return drizzleOrm.sql`
-    UPDATE ${edges}
-    SET ${quotedColumn(edges.deletedAt)} = ${timestamp}
-    WHERE ${edges.graphId} = ${params.graphId}
-      AND ${edges.id} = ${params.id}${expectedIdentityPredicate(tables, params.kind === void 0 ? {} : { kind: params.kind })}
-      AND ${edges.deletedAt} IS NULL
-  `;
-}
-function buildDeleteEdgesBatch(tables, params, timestamp) {
-  const { edges } = tables;
-  return drizzleOrm.sql`
-    UPDATE ${edges}
-    SET ${quotedColumn(edges.deletedAt)} = ${timestamp}
-    WHERE ${edges.graphId} = ${params.graphId}
-      AND ${edges.id} IN (${drizzleOrm.sql.join(
-    params.ids.map((id) => drizzleOrm.sql`${id}`),
-    drizzleOrm.sql`, `
-  )})
-      AND ${edges.deletedAt} IS NULL
-  `;
-}
-function buildHardDeleteEdgesBatch(tables, params) {
-  const { edges } = tables;
-  return drizzleOrm.sql`
-    DELETE FROM ${edges}
-    WHERE ${edges.graphId} = ${params.graphId}
-      AND ${edges.id} IN (${drizzleOrm.sql.join(
-    params.ids.map((id) => drizzleOrm.sql`${id}`),
-    drizzleOrm.sql`, `
-  )})
-  `;
-}
-function buildHardDeleteEdge(tables, params) {
-  const { edges } = tables;
-  return drizzleOrm.sql`
-    DELETE FROM ${edges}
-    WHERE ${edges.graphId} = ${params.graphId}
-      AND ${edges.id} = ${params.id}${expectedIdentityPredicate(tables, params.kind === void 0 ? {} : { kind: params.kind })}
-  `;
-}
-function buildHardDeleteEdgesByNode(tables, graphId, nodeKind, nodeId) {
-  const { edges } = tables;
-  return drizzleOrm.sql`
-    DELETE FROM ${edges}
-    WHERE ${edges.graphId} = ${graphId}
-      AND (
-        (${edges.fromKind} = ${nodeKind} AND ${edges.fromId} = ${nodeId})
-        OR (${edges.toKind} = ${nodeKind} AND ${edges.toId} = ${nodeId})
-      )
-  `;
-}
-function buildCountEdgesFrom(tables, params) {
-  const { edges } = tables;
-  if (params.activeOnly) {
-    return drizzleOrm.sql`
-      SELECT COUNT(*) as count FROM ${edges}
-      WHERE ${edges.graphId} = ${params.graphId}
-        AND ${edges.kind} = ${params.edgeKind}
-        AND ${edges.fromKind} = ${params.fromKind}
-        AND ${edges.fromId} = ${params.fromId}
-        AND ${edges.deletedAt} IS NULL
-        AND ${edges.validTo} IS NULL
-    `;
-  }
-  return drizzleOrm.sql`
-    SELECT COUNT(*) as count FROM ${edges}
-    WHERE ${edges.graphId} = ${params.graphId}
-      AND ${edges.kind} = ${params.edgeKind}
-      AND ${edges.fromKind} = ${params.fromKind}
-      AND ${edges.fromId} = ${params.fromId}
-      AND ${edges.deletedAt} IS NULL
-  `;
-}
-function buildEdgeExistsBetween(tables, params) {
-  const { edges } = tables;
-  return drizzleOrm.sql`
-    SELECT 1 FROM ${edges}
-    WHERE ${edges.graphId} = ${params.graphId}
-      AND ${edges.kind} = ${params.edgeKind}
-      AND ${edges.fromKind} = ${params.fromKind}
-      AND ${edges.fromId} = ${params.fromId}
-      AND ${edges.toKind} = ${params.toKind}
-      AND ${edges.toId} = ${params.toId}
-      AND ${edges.deletedAt} IS NULL
-    LIMIT 1
-  `;
-}
-function buildFindEdgesConnectedTo(tables, params) {
-  const { edges } = tables;
-  return drizzleOrm.sql`
-    SELECT * FROM ${edges}
-    WHERE ${edges.graphId} = ${params.graphId}
-      AND ${edges.deletedAt} IS NULL
-      AND ${edges.fromKind} = ${params.nodeKind}
-      AND ${edges.fromId} = ${params.nodeId}
-    UNION ALL
-    SELECT * FROM ${edges}
-    WHERE ${edges.graphId} = ${params.graphId}
-      AND ${edges.deletedAt} IS NULL
-      AND ${edges.toKind} = ${params.nodeKind}
-      AND ${edges.toId} = ${params.nodeId}
-      AND NOT (
-        ${edges.fromKind} = ${params.nodeKind}
-        AND ${edges.fromId} = ${params.nodeId}
-      )
-  `;
-}
-function resolveMode(mode) {
-  return mode ?? "websearch";
-}
-function buildFulltextSearch(tableName, params, strategy, dialect, candidates) {
-  assertValidSearchParams(params);
-  const mode = resolveMode(params.mode);
-  const table = quotedTableName(tableName);
-  const matchCondition = chunkWODMN3Q2_cjs.toDrizzleSql(
-    strategy.matchCondition(tableName, params.query, mode, params.language),
-    dialect
-  );
-  const rankExpression = chunkWODMN3Q2_cjs.toDrizzleSql(
-    strategy.rankExpression(tableName, params.query, mode, params.language),
-    dialect
-  );
-  const conditions = [
-    matchCondition,
-    drizzleOrm.sql`"graph_id" = ${params.graphId}`,
-    drizzleOrm.sql`"node_kind" = ${params.nodeKind}`
-  ];
-  if (params.minScore !== void 0) {
-    conditions.push(drizzleOrm.sql`${rankExpression} >= ${params.minScore}`);
-  }
-  if (candidates !== void 0) {
-    const candidateSql = chunkEDN4Y4ZG_cjs.isSqlFragment(candidates) ? chunkWODMN3Q2_cjs.toDrizzleSql(candidates, dialect) : candidates;
-    conditions.push(drizzleOrm.sql`"node_id" IN (${candidateSql})`);
-  }
-  const snippetExpr = params.includeSnippets === true && strategy.supportsSnippets ? chunkWODMN3Q2_cjs.toDrizzleSql(
-    strategy.snippetExpression(
-      tableName,
-      params.query,
-      mode,
-      params.language
-    ),
-    dialect
-  ) : drizzleOrm.sql`NULL`;
-  const pageClause = params.offset === void 0 || params.offset === 0 ? drizzleOrm.sql`LIMIT ${params.limit}` : drizzleOrm.sql`LIMIT ${params.limit} OFFSET ${params.offset}`;
-  return drizzleOrm.sql`
-    SELECT
-      "node_id" AS node_id,
-      ${rankExpression} AS score,
-      ${snippetExpr} AS snippet
-    FROM ${table}
-    WHERE ${drizzleOrm.sql.join(conditions, drizzleOrm.sql` AND `)}
-    ORDER BY ${rankExpression} DESC, ${codePointOrderKey(drizzleOrm.sql.raw('"node_id"'), dialect)} ASC
-    ${pageClause}
-  `;
-}
-function assertValidSearchParams(params) {
-  if (!Number.isInteger(params.limit) || params.limit <= 0) {
-    throw new Error(`limit must be a positive integer, got: ${params.limit}`);
-  }
-  if (params.minScore !== void 0 && !Number.isFinite(params.minScore)) {
-    throw new TypeError(
-      `minScore must be a finite number, got: ${params.minScore}`
-    );
-  }
-}
-function buildInsertNode(tables, params, timestamp) {
-  const { nodes } = tables;
-  const propsJson = JSON.stringify(params.props);
-  const columns = nodeColumnList(nodes);
-  return drizzleOrm.sql`
-    INSERT INTO ${nodes} (${columns})
-    VALUES (
-      ${params.graphId}, ${params.kind}, ${params.id}, ${propsJson},
-      1, ${sqlNull(chunkTQHGE7UC_cjs.resolveStampedValidityLowerBound(params.validFrom, params.validTo, timestamp))}, ${sqlNull(params.validTo)},
-      ${timestamp}, ${timestamp}
-    )
-    RETURNING *
-  `;
-}
-function buildInsertNodeNoReturn(tables, params, timestamp) {
-  const { nodes } = tables;
-  const propsJson = JSON.stringify(params.props);
-  const columns = nodeColumnList(nodes);
-  return drizzleOrm.sql`
-    INSERT INTO ${nodes} (${columns})
-    VALUES (
-      ${params.graphId}, ${params.kind}, ${params.id}, ${propsJson},
-      1, ${sqlNull(chunkTQHGE7UC_cjs.resolveStampedValidityLowerBound(params.validFrom, params.validTo, timestamp))}, ${sqlNull(params.validTo)},
-      ${timestamp}, ${timestamp}
-    )
-  `;
-}
-function buildInsertNodesBatch(tables, params, timestamp) {
-  const { nodes } = tables;
-  const columns = nodeColumnList(nodes);
-  const values = params.map((nodeParams) => {
-    const propsJson = JSON.stringify(nodeParams.props);
-    return drizzleOrm.sql`(${nodeParams.graphId}, ${nodeParams.kind}, ${nodeParams.id}, ${propsJson}, 1, ${sqlNull(chunkTQHGE7UC_cjs.resolveStampedValidityLowerBound(nodeParams.validFrom, nodeParams.validTo, timestamp))}, ${sqlNull(nodeParams.validTo)}, ${timestamp}, ${timestamp})`;
-  });
-  return drizzleOrm.sql`
-    INSERT INTO ${nodes} (${columns})
-    VALUES ${drizzleOrm.sql.join(values, drizzleOrm.sql`, `)}
-  `;
-}
-function buildInsertNodesBatchReturning(tables, params, timestamp) {
-  const { nodes } = tables;
-  const columns = nodeColumnList(nodes);
-  const values = params.map((nodeParams) => {
-    const propsJson = JSON.stringify(nodeParams.props);
-    return drizzleOrm.sql`(${nodeParams.graphId}, ${nodeParams.kind}, ${nodeParams.id}, ${propsJson}, 1, ${sqlNull(chunkTQHGE7UC_cjs.resolveStampedValidityLowerBound(nodeParams.validFrom, nodeParams.validTo, timestamp))}, ${sqlNull(nodeParams.validTo)}, ${timestamp}, ${timestamp})`;
-  });
-  return drizzleOrm.sql`
-    INSERT INTO ${nodes} (${columns})
-    VALUES ${drizzleOrm.sql.join(values, drizzleOrm.sql`, `)}
-    RETURNING *
-  `;
-}
-function buildGetNode(tables, graphId, kind, id) {
-  const { nodes } = tables;
-  return drizzleOrm.sql`
-    SELECT * FROM ${nodes}
-    WHERE ${nodes.graphId} = ${graphId}
-      AND ${nodes.kind} = ${kind}
-      AND ${nodes.id} = ${id}
-  `;
-}
-function buildGetNodes(tables, graphId, kind, ids) {
-  const { nodes } = tables;
-  return drizzleOrm.sql`
-    SELECT * FROM ${nodes}
-    WHERE ${nodes.graphId} = ${graphId}
-      AND ${nodes.kind} = ${kind}
-      AND ${nodes.id} IN (${drizzleOrm.sql.join(
-    ids.map((id) => drizzleOrm.sql`${id}`),
-    drizzleOrm.sql`, `
-  )})
-  `;
-}
-function buildUpdateNode(tables, params, timestamp) {
-  const { nodes } = tables;
-  const propsJson = JSON.stringify(params.props);
-  const setParts = [
-    drizzleOrm.sql`${quotedColumn(nodes.props)} = ${propsJson}`,
-    drizzleOrm.sql`${quotedColumn(nodes.updatedAt)} = ${timestamp}`
-  ];
-  if (params.incrementVersion) {
-    setParts.push(
-      drizzleOrm.sql`${quotedColumn(nodes.version)} = ${quotedColumn(nodes.version)} + 1`
-    );
-  }
-  if (params.clearDeleted) {
-    setParts.push(
-      drizzleOrm.sql`${quotedColumn(nodes.validFrom)} = ${sqlNull(chunkTQHGE7UC_cjs.resolveStampedValidityLowerBound(params.validFrom, params.validTo, timestamp))}`,
-      drizzleOrm.sql`${quotedColumn(nodes.validTo)} = ${sqlNull(params.validTo)}`
-    );
-  } else if (params.clearValidTo === true) {
-    setParts.push(drizzleOrm.sql`${quotedColumn(nodes.validTo)} = NULL`);
-  } else if (params.validTo !== void 0) {
-    setParts.push(drizzleOrm.sql`${quotedColumn(nodes.validTo)} = ${params.validTo}`);
-  }
-  if (params.clearDeleted) {
-    setParts.push(drizzleOrm.sql`${quotedColumn(nodes.deletedAt)} = NULL`);
-  }
-  const setClause = drizzleOrm.sql.join(setParts, drizzleOrm.sql`, `);
-  const expectedValidFrom = expectedValidFromPredicate(
-    nodes.validFrom,
-    params.expectedValidFrom
-  );
-  if (params.clearDeleted) {
-    return drizzleOrm.sql`
-      UPDATE ${nodes}
-      SET ${setClause}
-      WHERE ${nodes.graphId} = ${params.graphId}
-        AND ${nodes.kind} = ${params.kind}
-        AND ${nodes.id} = ${params.id}${expectedValidFrom}
-        AND ${nodes.deletedAt} IS NOT NULL
-      RETURNING *
-    `;
-  }
-  return drizzleOrm.sql`
-    UPDATE ${nodes}
-    SET ${setClause}
-    WHERE ${nodes.graphId} = ${params.graphId}
-      AND ${nodes.kind} = ${params.kind}
-      AND ${nodes.id} = ${params.id}${expectedValidFrom}
-      AND ${nodes.deletedAt} IS NULL
-    RETURNING *
-  `;
-}
-function buildUpdateNodeSet(tables, dialect, params, timestamp) {
-  const { nodes } = tables;
-  const adapter = chunkL3LQNR34_cjs.getDialect(dialect);
-  const patchedProps = chunkWODMN3Q2_cjs.toDrizzleSql(
-    adapter.jsonSetProperties(
-      chunkEDN4Y4ZG_cjs.sql.identifier(nodes.props.name),
-      params.patch,
-      params.unsetProperties ?? []
-    ),
-    dialect
-  );
-  const candidateIds = chunkWODMN3Q2_cjs.toDrizzleSql(params.candidateIds, dialect);
-  const candidateIdColumn = chunkWODMN3Q2_cjs.toDrizzleSql(
-    chunkEDN4Y4ZG_cjs.sql.identifier(params.candidateIdColumn),
-    dialect
-  );
-  return drizzleOrm.sql`
-    UPDATE ${nodes}
-    SET ${quotedColumn(nodes.props)} = ${patchedProps},
-        ${quotedColumn(nodes.updatedAt)} = ${timestamp},
-        ${quotedColumn(nodes.version)} = ${quotedColumn(nodes.version)} + 1
-    WHERE ${nodes.graphId} = ${params.graphId}
-      AND ${nodes.kind} = ${params.kind}
-      AND ${nodes.deletedAt} IS NULL
-      AND ${nodes.id} IN (
-        SELECT ${candidateIdColumn}
-        FROM (${candidateIds}) AS tg_set_candidates
-      )
-    RETURNING *
-  `;
-}
-function buildDeleteNode(tables, params, timestamp) {
-  const { nodes } = tables;
-  return drizzleOrm.sql`
-    UPDATE ${nodes}
-    SET ${quotedColumn(nodes.deletedAt)} = ${timestamp}
-    WHERE ${nodes.graphId} = ${params.graphId}
-      AND ${nodes.kind} = ${params.kind}
-      AND ${nodes.id} = ${params.id}
-      AND ${nodes.deletedAt} IS NULL
-  `;
-}
-function buildHardDeleteNode(tables, params) {
-  const { nodes } = tables;
-  return drizzleOrm.sql`
-    DELETE FROM ${nodes}
-    WHERE ${nodes.graphId} = ${params.graphId}
-      AND ${nodes.kind} = ${params.kind}
-      AND ${nodes.id} = ${params.id}
-  `;
-}
-function createSchemaDialectStrategy(dialect) {
-  const literals = {
-    postgres: { false: "FALSE", true: "TRUE" },
-    sqlite: { false: "0", true: "1" }
-  };
-  const dialectLiterals = literals[dialect];
-  const trueLiteral = drizzleOrm.sql.raw(dialectLiterals.true);
-  const falseLiteral = drizzleOrm.sql.raw(dialectLiterals.false);
-  return {
-    booleanLiteral(value) {
-      return value ? trueLiteral : falseLiteral;
-    }
-  };
-}
-var SCHEMA_DIALECT_STRATEGIES = {
-  postgres: createSchemaDialectStrategy("postgres"),
-  sqlite: createSchemaDialectStrategy("sqlite")
-};
-function buildInsertSchema(tables, params, timestamp, dialect = "sqlite") {
-  const { schemaVersions } = tables;
-  const strategy = SCHEMA_DIALECT_STRATEGIES[dialect];
-  const schemaDocumentJson = JSON.stringify(params.schemaDoc);
-  const isActiveValue = strategy.booleanLiteral(params.isActive);
-  const columns = drizzleOrm.sql.raw(
-    `"${schemaVersions.graphId.name}", "${schemaVersions.version.name}", "${schemaVersions.schemaHash.name}", "${schemaVersions.schemaDoc.name}", "${schemaVersions.createdAt.name}", "${schemaVersions.isActive.name}"`
-  );
-  return drizzleOrm.sql`
-    INSERT INTO ${schemaVersions} (${columns})
-    VALUES (
-      ${params.graphId}, ${params.version},
-      ${params.schemaHash}, ${schemaDocumentJson},
-      ${timestamp}, ${isActiveValue}
-    )
-    RETURNING *
-  `;
-}
-function buildGetActiveSchema(tables, graphId, dialect = "sqlite") {
-  const { schemaVersions } = tables;
-  const strategy = SCHEMA_DIALECT_STRATEGIES[dialect];
-  return drizzleOrm.sql`
-    SELECT * FROM ${schemaVersions}
-    WHERE ${schemaVersions.graphId} = ${graphId}
-      AND ${schemaVersions.isActive} = ${strategy.booleanLiteral(true)}
-  `;
-}
-function buildGetSchemaVersion(tables, graphId, version) {
-  const { schemaVersions } = tables;
-  return drizzleOrm.sql`
-    SELECT * FROM ${schemaVersions}
-    WHERE ${schemaVersions.graphId} = ${graphId}
-      AND ${schemaVersions.version} = ${version}
-  `;
-}
-function buildSetActiveSchema(tables, graphId, version, dialect = "sqlite") {
-  const { schemaVersions } = tables;
-  const strategy = SCHEMA_DIALECT_STRATEGIES[dialect];
-  const deactivateAll = drizzleOrm.sql`
-    UPDATE ${schemaVersions}
-    SET ${quotedColumn(schemaVersions.isActive)} = ${strategy.booleanLiteral(false)}
-    WHERE ${schemaVersions.graphId} = ${graphId}
-  `;
-  const activateVersion = drizzleOrm.sql`
-    UPDATE ${schemaVersions}
-    SET ${quotedColumn(schemaVersions.isActive)} = ${strategy.booleanLiteral(true)}
-    WHERE ${schemaVersions.graphId} = ${graphId}
-      AND ${schemaVersions.version} = ${version}
-  `;
-  return { deactivateAll, activateVersion };
-}
-function buildInsertUniqueSqlite(tables, params) {
-  const { uniques } = tables;
-  const columns = drizzleOrm.sql.raw(
-    `"${uniques.graphId.name}", "${uniques.nodeKind.name}", "${uniques.constraintName.name}", "${uniques.key.name}", "${uniques.nodeId.name}", "${uniques.concreteKind.name}", "${uniques.deletedAt.name}"`
-  );
-  const conflictColumns = drizzleOrm.sql.raw(
-    `"${uniques.graphId.name}", "${uniques.nodeKind.name}", "${uniques.constraintName.name}", "${uniques.key.name}"`
-  );
-  return drizzleOrm.sql`
-    INSERT INTO ${uniques} (${columns})
-    VALUES (
-      ${params.graphId}, ${params.nodeKind}, ${params.constraintName},
-      ${params.key}, ${params.nodeId}, ${params.concreteKind}, ${drizzleOrm.sql.raw("NULL")}
-    )
-    ON CONFLICT (${conflictColumns})
-    DO UPDATE SET
-      ${quotedColumn(uniques.nodeId)} = CASE
-        WHEN ${quotedColumn(uniques.nodeId)} = ${params.nodeId} THEN ${params.nodeId}
-        WHEN ${quotedColumn(uniques.deletedAt)} IS NOT NULL THEN ${params.nodeId}
-        ELSE ${quotedColumn(uniques.nodeId)}
-      END,
-      ${quotedColumn(uniques.concreteKind)} = CASE
-        WHEN ${quotedColumn(uniques.nodeId)} = ${params.nodeId} THEN ${params.concreteKind}
-        WHEN ${quotedColumn(uniques.deletedAt)} IS NOT NULL THEN ${params.concreteKind}
-        ELSE ${quotedColumn(uniques.concreteKind)}
-      END,
-      ${quotedColumn(uniques.deletedAt)} = CASE
-        WHEN ${quotedColumn(uniques.nodeId)} = ${params.nodeId} THEN NULL
-        WHEN ${quotedColumn(uniques.deletedAt)} IS NOT NULL THEN NULL
-        ELSE ${quotedColumn(uniques.deletedAt)}
-      END
-    RETURNING ${quotedColumn(uniques.nodeId)} as node_id
-  `;
-}
-function buildInsertUniquePostgres(tables, params) {
-  const { uniques } = tables;
-  const columns = drizzleOrm.sql.raw(
-    `"${uniques.graphId.name}", "${uniques.nodeKind.name}", "${uniques.constraintName.name}", "${uniques.key.name}", "${uniques.nodeId.name}", "${uniques.concreteKind.name}", "${uniques.deletedAt.name}"`
-  );
-  const conflictColumns = drizzleOrm.sql.raw(
-    `"${uniques.graphId.name}", "${uniques.nodeKind.name}", "${uniques.constraintName.name}", "${uniques.key.name}"`
-  );
-  const tableName = drizzleOrm.getTableName(uniques);
-  const existingColumn = (column) => drizzleOrm.sql.raw(`"${tableName}"."${column.name}"`);
-  return drizzleOrm.sql`
-    INSERT INTO ${uniques} (${columns})
-    VALUES (
-      ${params.graphId}, ${params.nodeKind}, ${params.constraintName},
-      ${params.key}, ${params.nodeId}, ${params.concreteKind}, ${drizzleOrm.sql.raw("NULL")}
-    )
-    ON CONFLICT (${conflictColumns})
-    DO UPDATE SET
-      ${quotedColumn(uniques.nodeId)} = CASE
-        WHEN ${existingColumn(uniques.nodeId)} = ${params.nodeId} THEN ${params.nodeId}
-        WHEN ${existingColumn(uniques.deletedAt)} IS NOT NULL THEN ${params.nodeId}
-        ELSE ${existingColumn(uniques.nodeId)}
-      END,
-      ${quotedColumn(uniques.concreteKind)} = CASE
-        WHEN ${existingColumn(uniques.nodeId)} = ${params.nodeId} THEN ${params.concreteKind}
-        WHEN ${existingColumn(uniques.deletedAt)} IS NOT NULL THEN ${params.concreteKind}
-        ELSE ${existingColumn(uniques.concreteKind)}
-      END,
-      ${quotedColumn(uniques.deletedAt)} = CASE
-        WHEN ${existingColumn(uniques.nodeId)} = ${params.nodeId} THEN NULL
-        WHEN ${existingColumn(uniques.deletedAt)} IS NOT NULL THEN NULL
-        ELSE ${existingColumn(uniques.deletedAt)}
-      END
-    RETURNING ${quotedColumn(uniques.nodeId)} as node_id
-  `;
-}
-var UNIQUE_INSERT_BUILDERS = {
-  postgres: buildInsertUniquePostgres,
-  sqlite: buildInsertUniqueSqlite
-};
-function buildInsertUnique(tables, dialect, params) {
-  const builder = UNIQUE_INSERT_BUILDERS[dialect];
-  return builder(tables, params);
-}
-function buildInsertUniqueBatch(tables, dialect, entries) {
-  const { uniques } = tables;
-  const columns = drizzleOrm.sql.raw(
-    `"${uniques.graphId.name}", "${uniques.nodeKind.name}", "${uniques.constraintName.name}", "${uniques.key.name}", "${uniques.nodeId.name}", "${uniques.concreteKind.name}", "${uniques.deletedAt.name}"`
-  );
-  const conflictColumns = drizzleOrm.sql.raw(
-    `"${uniques.graphId.name}", "${uniques.nodeKind.name}", "${uniques.constraintName.name}", "${uniques.key.name}"`
-  );
-  const tableName = drizzleOrm.getTableName(uniques);
-  const existingColumn = (column) => {
-    switch (dialect) {
-      case "postgres": {
-        return drizzleOrm.sql.raw(`"${tableName}"."${column.name}"`);
-      }
-      case "sqlite": {
-        return drizzleOrm.sql.raw(`"${column.name}"`);
-      }
-      default: {
-        return dialect;
-      }
-    }
-  };
-  const excludedColumn = (column) => drizzleOrm.sql.raw(`excluded."${column.name}"`);
-  const valueRows = drizzleOrm.sql.join(
-    entries.map(
-      (params) => drizzleOrm.sql`(${params.graphId}, ${params.nodeKind}, ${params.constraintName}, ${params.key}, ${params.nodeId}, ${params.concreteKind}, ${drizzleOrm.sql.raw("NULL")})`
-    ),
-    drizzleOrm.sql`, `
-  );
-  return drizzleOrm.sql`
-    INSERT INTO ${uniques} (${columns})
-    VALUES ${valueRows}
-    ON CONFLICT (${conflictColumns})
-    DO UPDATE SET
-      ${quotedColumn(uniques.nodeId)} = CASE
-        WHEN ${existingColumn(uniques.nodeId)} = ${excludedColumn(uniques.nodeId)} THEN ${excludedColumn(uniques.nodeId)}
-        WHEN ${existingColumn(uniques.deletedAt)} IS NOT NULL THEN ${excludedColumn(uniques.nodeId)}
-        ELSE ${existingColumn(uniques.nodeId)}
-      END,
-      ${quotedColumn(uniques.concreteKind)} = CASE
-        WHEN ${existingColumn(uniques.nodeId)} = ${excludedColumn(uniques.nodeId)} THEN ${excludedColumn(uniques.concreteKind)}
-        WHEN ${existingColumn(uniques.deletedAt)} IS NOT NULL THEN ${excludedColumn(uniques.concreteKind)}
-        ELSE ${existingColumn(uniques.concreteKind)}
-      END,
-      ${quotedColumn(uniques.deletedAt)} = CASE
-        WHEN ${existingColumn(uniques.nodeId)} = ${excludedColumn(uniques.nodeId)} THEN NULL
-        WHEN ${existingColumn(uniques.deletedAt)} IS NOT NULL THEN NULL
-        ELSE ${existingColumn(uniques.deletedAt)}
-      END
-    RETURNING
-      ${quotedColumn(uniques.nodeKind)} as node_kind,
-      ${quotedColumn(uniques.constraintName)} as constraint_name,
-      ${quotedColumn(uniques.key)} as key,
-      ${quotedColumn(uniques.nodeId)} as node_id
-  `;
-}
-function buildDeleteUnique(tables, params, timestamp) {
-  const { uniques } = tables;
-  return drizzleOrm.sql`
-    UPDATE ${uniques}
-    SET ${quotedColumn(uniques.deletedAt)} = ${timestamp}
-    WHERE ${uniques.graphId} = ${params.graphId}
-      AND ${uniques.nodeKind} = ${params.nodeKind}
-      AND ${uniques.constraintName} = ${params.constraintName}
-      AND ${uniques.key} = ${params.key}
-      AND ${uniques.deletedAt} IS NULL
-  `;
-}
-function buildHardDeleteUniquesByNode(tables, graphId, concreteKind, nodeId) {
-  return buildHardDeleteUniquesByNodeIds(tables, {
-    graphId,
-    concreteKind,
-    nodeIds: [nodeId]
-  });
-}
-function buildHardDeleteUniquesByNodeIds(tables, params) {
-  const { uniques } = tables;
-  return drizzleOrm.sql`
-    DELETE FROM ${uniques}
-    WHERE ${uniques.graphId} = ${params.graphId}
-      AND ${uniques.concreteKind} = ${params.concreteKind}
-      AND ${uniques.nodeId} IN (${drizzleOrm.sql.join(
-    params.nodeIds.map((nodeId) => drizzleOrm.sql`${nodeId}`),
-    drizzleOrm.sql`, `
-  )})
-  `;
-}
-function buildCheckUnique(tables, params) {
-  const { uniques } = tables;
-  if (params.includeDeleted) {
-    return drizzleOrm.sql`
-      SELECT * FROM ${uniques}
-      WHERE ${uniques.graphId} = ${params.graphId}
-        AND ${uniques.nodeKind} = ${params.nodeKind}
-        AND ${uniques.constraintName} = ${params.constraintName}
-        AND ${uniques.key} = ${params.key}
-    `;
-  }
-  return drizzleOrm.sql`
-    SELECT * FROM ${uniques}
-    WHERE ${uniques.graphId} = ${params.graphId}
-      AND ${uniques.nodeKind} = ${params.nodeKind}
-      AND ${uniques.constraintName} = ${params.constraintName}
-      AND ${uniques.key} = ${params.key}
-      AND ${uniques.deletedAt} IS NULL
-  `;
-}
-function buildCheckUniqueBatch(tables, params) {
-  const { uniques } = tables;
-  const keyPlaceholders = drizzleOrm.sql.join(
-    params.keys.map((key) => drizzleOrm.sql`${key}`),
-    drizzleOrm.sql`, `
-  );
-  if (params.includeDeleted) {
-    return drizzleOrm.sql`
-      SELECT * FROM ${uniques}
-      WHERE ${uniques.graphId} = ${params.graphId}
-        AND ${uniques.nodeKind} = ${params.nodeKind}
-        AND ${uniques.constraintName} = ${params.constraintName}
-        AND ${uniques.key} IN (${keyPlaceholders})
-    `;
-  }
-  return drizzleOrm.sql`
-    SELECT * FROM ${uniques}
-    WHERE ${uniques.graphId} = ${params.graphId}
-      AND ${uniques.nodeKind} = ${params.nodeKind}
-      AND ${uniques.constraintName} = ${params.constraintName}
-      AND ${uniques.key} IN (${keyPlaceholders})
-      AND ${uniques.deletedAt} IS NULL
-  `;
-}
-
-// src/backend/drizzle/operations/strategy.ts
-function nullableText(value) {
-  return value === void 0 ? drizzleOrm.sql`NULL` : drizzleOrm.sql`${value}`;
-}
-function bindTableOperationBuilders(tables, builders) {
-  const boundEntries = Object.entries(builders).map(([name, builder]) => {
-    function boundBuilder(...args) {
-      return builder(tables, ...args);
-    }
-    return [name, boundBuilder];
-  });
-  return Object.fromEntries(
-    boundEntries
-  );
-}
-var COMMON_TABLE_OPERATION_BUILDERS = {
-  buildInsertNode,
-  buildInsertNodeNoReturn,
-  buildInsertNodesBatch,
-  buildInsertNodesBatchReturning,
-  buildGetNode,
-  buildGetNodes,
-  buildUpdateNode,
-  buildDeleteNode,
-  buildHardDeleteNode,
-  buildInsertEdge,
-  buildInsertEdgeNoReturn,
-  buildInsertEdgesBatch,
-  buildInsertEdgesBatchReturning,
-  buildGetEdge,
-  buildGetEdges,
-  buildUpdateEdge,
-  buildDeleteEdge,
-  buildDeleteEdgesBatch,
-  buildHardDeleteEdge,
-  buildHardDeleteEdgesBatch,
-  buildHardDeleteEdgesByNode,
-  buildCountEdgesFrom,
-  buildEdgeExistsBetween,
-  buildFindEdgesConnectedTo,
-  buildFindNodesByKind,
-  buildCountNodesByKind,
-  buildFindEdgesByKind,
-  buildFindEdgesByEndpointSet,
-  buildFindEdgesByHeterogeneousEndpointSet,
-  buildCountEdgesByKind,
-  buildDeleteUnique,
-  buildHardDeleteUniquesByNode,
-  buildHardDeleteUniquesByNodeIds,
-  buildCheckUnique,
-  buildCheckUniqueBatch,
-  buildGetSchemaVersion
-};
-function createCommonOperationStrategy(tables, dialect, fulltextStrategy) {
-  const tableOperations = bindTableOperationBuilders(
-    tables,
-    COMMON_TABLE_OPERATION_BUILDERS
-  );
-  const fulltextTable = tables.fulltextTableName;
-  const contributionMaterializations = tables.contributionMaterializations;
-  const fulltextBuilders = {
-    buildUpsertFulltext: (params, timestamp) => fulltextStrategy.buildUpsert(fulltextTable, params, timestamp).map((statement) => chunkWODMN3Q2_cjs.toDrizzleSql(statement, dialect)),
-    buildDeleteFulltext: (params) => fulltextStrategy.buildDelete(fulltextTable, params).map((statement) => chunkWODMN3Q2_cjs.toDrizzleSql(statement, dialect)),
-    buildDeleteFulltextByNode: (graphId, nodeKind, nodeId) => fulltextStrategy.buildDelete(fulltextTable, {
-      graphId,
-      nodeKind,
-      nodeId
-    }).map((statement) => chunkWODMN3Q2_cjs.toDrizzleSql(statement, dialect)),
-    buildUpsertFulltextBatch: (params, timestamp) => fulltextStrategy.buildBatchUpsert(fulltextTable, params, timestamp).map((statement) => chunkWODMN3Q2_cjs.toDrizzleSql(statement, dialect)),
-    buildDeleteFulltextBatch: (params) => fulltextStrategy.buildBatchDelete(fulltextTable, params).map((statement) => chunkWODMN3Q2_cjs.toDrizzleSql(statement, dialect)),
-    buildFulltextSearch: (params) => buildFulltextSearch(
-      fulltextTable,
-      params,
-      fulltextStrategy,
-      dialect,
-      // Store-compiled candidates (predicates + subclass + currency)
-      // take precedence; the live-node default covers direct backend use.
-      params.candidates ?? liveNodeIdsSubquery(
-        tables.nodes,
-        params.graphId,
-        params.nodeKind,
-        chunkFA2AFWLP_cjs.nowIso()
-      )
-    ),
-    buildHybridSearch: (params, vectorSql, vectorScoreDescending) => {
-      const candidates = params.candidates ?? liveNodeIdsSubquery(
-        tables.nodes,
-        params.graphId,
-        params.nodeKind,
-        chunkFA2AFWLP_cjs.nowIso()
-      );
-      const fulltextSql = buildFulltextSearch(
-        fulltextTable,
-        {
-          graphId: params.graphId,
-          nodeKind: params.nodeKind,
-          query: params.fulltext.query,
-          limit: params.fulltext.k,
-          ...params.fulltext.mode === void 0 ? {} : { mode: params.fulltext.mode },
-          ...params.fulltext.language === void 0 ? {} : { language: params.fulltext.language },
-          ...params.fulltext.minScore === void 0 ? {} : { minScore: params.fulltext.minScore },
-          ...params.fulltext.includeSnippets === void 0 ? {} : { includeSnippets: params.fulltext.includeSnippets }
-        },
-        fulltextStrategy,
-        dialect,
-        // Reference, not copy: the statement evaluates the shared
-        // tg_hybrid_cand CTE once for both legs.
-        hybridCandidatesRef()
-      );
-      return buildHybridSearchStatement({
-        candidatesSql: chunkEDN4Y4ZG_cjs.isSqlFragment(candidates) ? chunkWODMN3Q2_cjs.toDrizzleSql(candidates, dialect) : candidates,
-        vectorSql,
-        vectorScoreDescending,
-        fulltextSql,
-        nodes: tables.nodes,
-        dialect,
-        graphId: params.graphId,
-        nodeKind: params.nodeKind,
-        fusionK: params.fusion.k,
-        vectorWeight: params.fusion.vectorWeight,
-        fulltextWeight: params.fusion.fulltextWeight,
-        limit: params.limit,
-        offset: params.offset ?? 0
-      });
-    }
-  };
-  function buildInsertContributionMaterialization(params) {
-    return drizzleOrm.sql`
-      INSERT INTO ${contributionMaterializations}
-        (graph_id, logical_name, owner, table_name, signature,
-         materialized_at, last_attempted_at, last_error)
-      VALUES (
-        ${params.graphId}, ${params.logicalName}, ${params.owner},
-        ${params.tableName}, ${params.signature},
-        ${nullableText(params.materializedAt)}, ${params.attemptedAt},
-        ${nullableText(params.error)}
-      )
-      ON CONFLICT (graph_id, logical_name, owner, table_name) DO UPDATE SET
-        signature = excluded.signature,
-        materialized_at = excluded.materialized_at,
-        last_attempted_at = excluded.last_attempted_at,
-        last_error = excluded.last_error
-    `;
-  }
-  function buildDeleteContributionMaterialization(identity) {
-    return drizzleOrm.sql`
-      DELETE FROM ${contributionMaterializations}
-      WHERE graph_id = ${identity.graphId}
-        AND logical_name = ${identity.logicalName}
-        AND owner = ${identity.owner}
-        AND table_name = ${identity.tableName}
-    `;
-  }
-  return {
-    ...tableOperations,
-    ...fulltextBuilders,
-    primaryKeyConstraints: {
-      nodes: nodePrimaryKeyConstraint(tables.nodes),
-      edges: edgePrimaryKeyConstraint(tables.edges)
-    },
-    buildUpdateNodeSet(params, timestamp) {
-      return buildUpdateNodeSet(tables, dialect, params, timestamp);
-    },
-    buildDeleteContributionMaterialization,
-    buildInsertContributionMaterialization,
-    buildInsertUnique(params) {
-      return buildInsertUnique(tables, dialect, params);
-    },
-    buildInsertUniqueBatch(entries) {
-      return buildInsertUniqueBatch(tables, dialect, entries);
-    },
-    buildGetActiveSchema(graphId) {
-      return buildGetActiveSchema(tables, graphId, dialect);
-    },
-    buildInsertSchema(params, timestamp) {
-      return buildInsertSchema(tables, params, timestamp, dialect);
-    },
-    buildSetActiveSchema(graphId, version) {
-      return buildSetActiveSchema(tables, graphId, version, dialect);
-    },
-    buildTableExists(tableName) {
-      switch (dialect) {
-        case "postgres": {
-          return drizzleOrm.sql`
-            SELECT c.relname AS table_name
-            FROM pg_catalog.pg_class AS c
-            WHERE c.relname = ${tableName}
-              AND c.relkind IN ('r', 'p', 'v', 'm', 'f')
-              AND pg_catalog.pg_table_is_visible(c.oid)
-            LIMIT 1
-          `;
-        }
-        case "sqlite": {
-          return drizzleOrm.sql`SELECT name AS table_name FROM sqlite_master WHERE type IN ('table', 'view') AND name = ${tableName}`;
-        }
-        default: {
-          return dialect;
-        }
-      }
-    },
-    buildClearGraph(graphId) {
-      return buildClearGraph(tables, graphId);
-    }
-  };
-}
-function tableExistsFromRow(row) {
-  if (row === void 0) return false;
-  return Object.values(row).some((value) => chunkN66HCGCY_cjs.isPresent(value));
-}
-function createCachedTableExistence(probe, options) {
-  const cacheExisting = options?.cacheExisting !== false;
-  const cacheMissing = options?.cacheMissing === true;
-  const confirmedExisting = /* @__PURE__ */ new Set();
-  const confirmedMissing = /* @__PURE__ */ new Set();
-  return async function tableExists(tableName) {
-    if (confirmedExisting.has(tableName)) return true;
-    if (confirmedMissing.has(tableName)) return false;
-    const exists = tableExistsFromRow(await probe(tableName));
-    if (exists && cacheExisting) {
-      confirmedExisting.add(tableName);
-    }
-    if (!exists && cacheMissing) {
-      confirmedMissing.add(tableName);
-    }
-    return exists;
-  };
-}
-function createSqliteOperationStrategy(tables, fulltextStrategy) {
-  return createCommonOperationStrategy(tables, "sqlite", fulltextStrategy);
-}
-function createPostgresOperationStrategy(tables, fulltextStrategy) {
-  return createCommonOperationStrategy(tables, "postgres", fulltextStrategy);
-}
-var DRIZZLE_DIALECT_LABELS = {
-  postgres: "Postgres",
-  sqlite: "SQLite"
-};
-function assertAdoptedDialect(externalTx, brand, backend) {
-  if (drizzleOrm.is(externalTx, brand)) return;
-  const label = DRIZZLE_DIALECT_LABELS[backend];
-  throw new chunkMRDBBHIZ_cjs.ConfigurationError(
-    `adoptTransaction received a handle that is not a ${label} Drizzle transaction. Pass the \`tx\` from a ${label} \`db.transaction(...)\` opened on this backend's connection.`,
-    { backend, capability: "adoptTransaction" }
-  );
-}
-async function withDuplicateKeyClassification(run, context) {
-  try {
-    return await run();
-  } catch (error) {
-    if (!chunkSIT26LAZ_cjs.isDuplicatePrimaryKeyError(error, context.relation)) throw error;
-    throw new chunkMRDBBHIZ_cjs.DatabaseOperationError(
-      `Insert ${context.entity} failed: a row with this identity already exists`,
-      {
-        operation: "insert",
-        entity: context.entity,
-        reason: "duplicate_key",
-        attempted: context.attempted
-      },
-      { cause: error }
-    );
-  }
-}
-function attemptedInserts(params) {
-  return params.map((item) => ({ kind: item.kind, id: item.id }));
-}
-function verifyExpectedActiveVersion(graphId, expected, actualActiveVersion) {
-  const expectedVersion = expected.kind === "active" ? expected.version : 0;
-  assertActiveSchemaVersion(graphId, expectedVersion, actualActiveVersion);
-}
-function assertActiveSchemaVersion(graphId, expectedVersion, actualActiveVersion) {
-  if (actualActiveVersion !== expectedVersion) {
-    throw new chunkMRDBBHIZ_cjs.StaleVersionError({
-      graphId,
-      expected: expectedVersion,
-      actual: actualActiveVersion
-    });
-  }
-}
-async function commitSchemaVersionIfKindsEmpty(backend, params, probes) {
-  const [existing, active] = await Promise.all([
-    backend.getSchemaVersion(params.graphId, params.version),
-    backend.getActiveSchema(params.graphId)
-  ]);
-  if (existing !== void 0 && (existing.is_active || existing.schema_hash !== params.schemaHash)) {
-    return {
-      status: "committed",
-      row: await backend.commitSchemaVersion(params)
-    };
-  }
-  verifyExpectedActiveVersion(
-    params.graphId,
-    params.expected,
-    active?.version ?? 0
-  );
-  const populated = [];
-  for (const probe of probes) {
-    const count = probe.entity === "node" ? await backend.countNodesByKind({
-      graphId: params.graphId,
-      kind: probe.kind
-    }) : await backend.countEdgesByKind({
-      graphId: params.graphId,
-      kind: probe.kind
-    });
-    if (count > 0) populated.push({ ...probe, count });
-  }
-  if (populated.length > 0) {
-    return { status: "populated", kinds: populated };
-  }
-  return {
-    status: "committed",
-    row: await backend.commitSchemaVersion(params)
-  };
-}
-function createCommonOperationBackend(options) {
-  const {
-    batchConfig,
-    execution,
-    maxBindParameters,
-    operationStrategy,
-    rowMappers
-  } = options;
-  const nowIso2 = options.nowIso ?? chunkFA2AFWLP_cjs.nowIso;
-  const tableExists = createCachedTableExistence(
-    (tableName) => execution.execGet(
-      operationStrategy.buildTableExists(tableName)
-    ),
-    options.tableExistenceCache
-  );
-  async function runIgnorableClearStatement(statement) {
-    if (statement.ignoreMissingTable === true && statement.requiredTableName !== void 0 && !await tableExists(statement.requiredTableName)) {
-      return;
-    }
-    await execution.execRun(statement.query);
-  }
-  async function readActiveVersion(graphId) {
-    const row = await execution.execGet(
-      operationStrategy.buildGetActiveSchema(graphId)
-    );
-    return row === void 0 ? 0 : rowMappers.toSchemaVersionRow(row).version;
-  }
-  return {
-    tableExists,
-    async executeSchemaDdl(ddl) {
-      await execution.execRun(chunkEDN4Y4ZG_cjs.asCompiledStatementSql(chunkEDN4Y4ZG_cjs.sql.raw(ddl)));
-    },
-    async executeStatement(query) {
-      await execution.execRun(query);
-    },
-    async executeTemporaryStatement(query) {
-      await execution.execRun(query);
-    },
-    async insertNode(params) {
-      const timestamp = nowIso2();
-      const query = operationStrategy.buildInsertNode(params, timestamp);
-      const row = await withDuplicateKeyClassification(
-        () => execution.execGet(query),
-        {
-          entity: "node",
-          relation: operationStrategy.primaryKeyConstraints.nodes,
-          attempted: attemptedInserts([params])
-        }
-      );
-      if (!row)
-        throw new chunkMRDBBHIZ_cjs.DatabaseOperationError(
-          "Insert node failed: no row returned",
-          {
-            operation: "insert",
-            entity: "node",
-            reason: "no_row_returned"
-          }
-        );
-      return rowMappers.toNodeRow(row);
-    },
-    async insertNodeNoReturn(params) {
-      const timestamp = nowIso2();
-      const query = operationStrategy.buildInsertNodeNoReturn(
-        params,
-        timestamp
-      );
-      await withDuplicateKeyClassification(() => execution.execRun(query), {
-        entity: "node",
-        relation: operationStrategy.primaryKeyConstraints.nodes,
-        attempted: attemptedInserts([params])
-      });
-    },
-    async insertNodesBatch(params) {
-      if (params.length === 0) {
-        return;
-      }
-      const timestamp = nowIso2();
-      for (const chunk2 of chunkSIT26LAZ_cjs.chunk(params, batchConfig.nodeInsertBatchSize)) {
-        const query = operationStrategy.buildInsertNodesBatch(chunk2, timestamp);
-        await withDuplicateKeyClassification(() => execution.execRun(query), {
-          entity: "node",
-          relation: operationStrategy.primaryKeyConstraints.nodes,
-          attempted: attemptedInserts(chunk2)
-        });
-      }
-    },
-    async insertNodesBatchReturning(params) {
-      if (params.length === 0) {
-        return [];
-      }
-      const timestamp = nowIso2();
-      const allRows = [];
-      for (const chunk2 of chunkSIT26LAZ_cjs.chunk(params, batchConfig.nodeInsertBatchSize)) {
-        const query = operationStrategy.buildInsertNodesBatchReturning(
-          chunk2,
-          timestamp
-        );
-        const rows = await withDuplicateKeyClassification(
-          () => execution.execAll(query),
-          {
-            entity: "node",
-            relation: operationStrategy.primaryKeyConstraints.nodes,
-            attempted: attemptedInserts(chunk2)
-          }
-        );
-        allRows.push(...rows.map((row) => rowMappers.toNodeRow(row)));
-      }
-      return allRows;
-    },
-    async getNode(graphId, kind, id) {
-      const query = operationStrategy.buildGetNode(graphId, kind, id);
-      const row = await execution.execGet(query);
-      return row ? rowMappers.toNodeRow(row) : void 0;
-    },
-    async getNodes(graphId, kind, ids) {
-      if (ids.length === 0) return [];
-      const allRows = [];
-      for (const chunk2 of chunkSIT26LAZ_cjs.chunk(ids, batchConfig.getNodesChunkSize)) {
-        const query = operationStrategy.buildGetNodes(graphId, kind, chunk2);
-        const rows = await execution.execAll(query);
-        allRows.push(...rows.map((row) => rowMappers.toNodeRow(row)));
-      }
-      return allRows;
-    },
-    async updateNode(params) {
-      const timestamp = nowIso2();
-      const query = operationStrategy.buildUpdateNode(params, timestamp);
-      const row = await execution.execGet(query);
-      if (!row)
-        throw new chunkMRDBBHIZ_cjs.DatabaseOperationError(
-          "Update node failed: no row returned",
-          {
-            operation: "update",
-            entity: "node",
-            reason: "no_row_returned"
-          }
-        );
-      return rowMappers.toNodeRow(row);
-    },
-    async updateNodeSet(params) {
-      if (Object.keys(params.patch).length === 0 && (params.unsetProperties?.length ?? 0) === 0) {
-        throw new chunkMRDBBHIZ_cjs.ConfigurationError(
-          "Set-based node update requires at least one property",
-          { operation: "updateNodeSet", kind: params.kind }
-        );
-      }
-      if (params.candidateIdColumn.length === 0) {
-        throw new chunkMRDBBHIZ_cjs.ConfigurationError(
-          "Set-based node update requires a candidate id column",
-          { operation: "updateNodeSet", kind: params.kind }
-        );
-      }
-      const timestamp = nowIso2();
-      const query = operationStrategy.buildUpdateNodeSet(params, timestamp);
-      const rows = await execution.execAll(query);
-      const updatedRows = rows.map((row) => rowMappers.toNodeRow(row));
-      return { affectedCount: updatedRows.length, rows: updatedRows };
-    },
-    async deleteNode(params) {
-      const timestamp = nowIso2();
-      const query = operationStrategy.buildDeleteNode(params, timestamp);
-      await execution.execRun(query);
-    },
-    // IMPORTANT: This cascade is not atomic. Callers must ensure this runs
-    // within a transaction to prevent partial deletion on intermediate failure.
-    //
-    // Embeddings are NOT cleaned up here: they live in per-`(nodeKind,
-    // fieldPath)` strategy-owned tables addressable only with the slot
-    // context the graph-agnostic backend lacks. The store's hard-delete
-    // path (`executeNodeHardDelete`) drives `deleteNodeEmbeddings`, which
-    // resolves each embedding field and routes a per-field
-    // `backend.deleteEmbedding` through the active vector strategy.
-    async hardDeleteNode(params) {
-      const deleteUniquesQuery = operationStrategy.buildHardDeleteUniquesByNode(
-        params.graphId,
-        params.kind,
-        params.id
-      );
-      await execution.execRun(deleteUniquesQuery);
-      const deleteFulltextStatements = operationStrategy.buildDeleteFulltextByNode(
-        params.graphId,
-        params.kind,
-        params.id
-      );
-      for (const stmt of deleteFulltextStatements) {
-        await execution.execRun(stmt);
-      }
-      const deleteEdgesQuery = operationStrategy.buildHardDeleteEdgesByNode(
-        params.graphId,
-        params.kind,
-        params.id
-      );
-      await execution.execRun(deleteEdgesQuery);
-      const query = operationStrategy.buildHardDeleteNode(params);
-      await execution.execRun(query);
-    },
-    async insertEdge(params) {
-      const timestamp = nowIso2();
-      const query = operationStrategy.buildInsertEdge(params, timestamp);
-      const row = await withDuplicateKeyClassification(
-        () => execution.execGet(query),
-        {
-          entity: "edge",
-          relation: operationStrategy.primaryKeyConstraints.edges,
-          attempted: attemptedInserts([params])
-        }
-      );
-      if (!row)
-        throw new chunkMRDBBHIZ_cjs.DatabaseOperationError(
-          "Insert edge failed: no row returned",
-          {
-            operation: "insert",
-            entity: "edge",
-            reason: "no_row_returned"
-          }
-        );
-      return rowMappers.toEdgeRow(row);
-    },
-    async insertEdgeNoReturn(params) {
-      const timestamp = nowIso2();
-      const query = operationStrategy.buildInsertEdgeNoReturn(
-        params,
-        timestamp
-      );
-      await withDuplicateKeyClassification(() => execution.execRun(query), {
-        entity: "edge",
-        relation: operationStrategy.primaryKeyConstraints.edges,
-        attempted: attemptedInserts([params])
-      });
-    },
-    async insertEdgesBatch(params) {
-      if (params.length === 0) {
-        return;
-      }
-      const timestamp = nowIso2();
-      for (const chunk2 of chunkSIT26LAZ_cjs.chunk(params, batchConfig.edgeInsertBatchSize)) {
-        const query = operationStrategy.buildInsertEdgesBatch(chunk2, timestamp);
-        await withDuplicateKeyClassification(() => execution.execRun(query), {
-          entity: "edge",
-          relation: operationStrategy.primaryKeyConstraints.edges,
-          attempted: attemptedInserts(chunk2)
-        });
-      }
-    },
-    async insertEdgesBatchReturning(params) {
-      if (params.length === 0) {
-        return [];
-      }
-      const timestamp = nowIso2();
-      const allRows = [];
-      for (const chunk2 of chunkSIT26LAZ_cjs.chunk(params, batchConfig.edgeInsertBatchSize)) {
-        const query = operationStrategy.buildInsertEdgesBatchReturning(
-          chunk2,
-          timestamp
-        );
-        const rows = await withDuplicateKeyClassification(
-          () => execution.execAll(query),
-          {
-            entity: "edge",
-            relation: operationStrategy.primaryKeyConstraints.edges,
-            attempted: attemptedInserts(chunk2)
-          }
-        );
-        allRows.push(...rows.map((row) => rowMappers.toEdgeRow(row)));
-      }
-      return allRows;
-    },
-    async getEdge(graphId, id) {
-      const query = operationStrategy.buildGetEdge(graphId, id);
-      const row = await execution.execGet(query);
-      return row ? rowMappers.toEdgeRow(row) : void 0;
-    },
-    async getEdges(graphId, ids) {
-      if (ids.length === 0) return [];
-      const allRows = [];
-      for (const chunk2 of chunkSIT26LAZ_cjs.chunk(ids, batchConfig.getEdgesChunkSize)) {
-        const query = operationStrategy.buildGetEdges(graphId, chunk2);
-        const rows = await execution.execAll(query);
-        allRows.push(...rows.map((row) => rowMappers.toEdgeRow(row)));
-      }
-      return allRows;
-    },
-    async updateEdge(params) {
-      const timestamp = nowIso2();
-      const query = operationStrategy.buildUpdateEdge(params, timestamp);
-      const row = await execution.execGet(query);
-      if (!row)
-        throw new chunkMRDBBHIZ_cjs.DatabaseOperationError(
-          "Update edge failed: no row returned",
-          {
-            operation: "update",
-            entity: "edge",
-            reason: "no_row_returned"
-          }
-        );
-      return rowMappers.toEdgeRow(row);
-    },
-    async deleteEdge(params) {
-      const timestamp = nowIso2();
-      const query = operationStrategy.buildDeleteEdge(params, timestamp);
-      await execution.execRun(query);
-    },
-    async hardDeleteEdge(params) {
-      const query = operationStrategy.buildHardDeleteEdge(params);
-      await execution.execRun(query);
-    },
-    async deleteEdgesBatch(params) {
-      if (params.ids.length === 0) return;
-      const timestamp = nowIso2();
-      const softDeleteChunkSize = Math.max(
-        1,
-        batchConfig.getEdgesChunkSize - 1
-      );
-      for (const chunk2 of chunkSIT26LAZ_cjs.chunk(params.ids, softDeleteChunkSize)) {
-        const query = operationStrategy.buildDeleteEdgesBatch(
-          { graphId: params.graphId, ids: chunk2 },
-          timestamp
-        );
-        await execution.execRun(query);
-      }
-    },
-    async hardDeleteEdgesBatch(params) {
-      if (params.ids.length === 0) return;
-      for (const chunk2 of chunkSIT26LAZ_cjs.chunk(
-        params.ids,
-        batchConfig.getEdgesChunkSize
-      )) {
-        const query = operationStrategy.buildHardDeleteEdgesBatch({
-          graphId: params.graphId,
-          ids: chunk2
-        });
-        await execution.execRun(query);
-      }
-    },
-    async countEdgesFrom(params) {
-      const query = operationStrategy.buildCountEdgesFrom(params);
-      const row = await execution.execGet(query);
-      return Number(row?.count ?? 0);
-    },
-    async edgeExistsBetween(params) {
-      const query = operationStrategy.buildEdgeExistsBetween(params);
-      const row = await execution.execGet(query);
-      return row !== void 0;
-    },
-    async findEdgesConnectedTo(params) {
-      const query = operationStrategy.buildFindEdgesConnectedTo(params);
-      const rows = await execution.execAll(query);
-      return rows.map((row) => rowMappers.toEdgeRow(row));
-    },
-    async findNodesByKind(params) {
-      const query = operationStrategy.buildFindNodesByKind(params);
-      const rows = await execution.execAll(query);
-      return rows.map((row) => rowMappers.toNodeRow(row));
-    },
-    async countNodesByKind(params) {
-      const query = operationStrategy.buildCountNodesByKind(params);
-      const row = await execution.execGet(query);
-      return Number(row?.count ?? 0);
-    },
-    async findEdgesByKind(params) {
-      const query = operationStrategy.buildFindEdgesByKind(params);
-      const rows = await execution.execAll(query);
-      return rows.map((row) => rowMappers.toEdgeRow(row));
-    },
-    async findEdgesByEndpointSet(params) {
-      const ids = resolveEdgeEndpointIds(params);
-      const edgeRows = [];
-      for (const idChunk of chunkSIT26LAZ_cjs.chunk(
-        ids,
-        batchConfig.findEdgesEndpointChunkSize
-      )) {
-        const query = operationStrategy.buildFindEdgesByEndpointSet(
-          params,
-          idChunk
-        );
-        const rows = await execution.execAll(query);
-        for (const row of rows) edgeRows.push(rowMappers.toEdgeRow(row));
-      }
-      return edgeRows;
-    },
-    async findEdgesByHeterogeneousEndpointSet(params) {
-      const { edgeKinds, endpoints, endpointChunkSize } = resolveHeterogeneousEdgeRead(params, maxBindParameters);
-      if (edgeKinds.length === 0 || endpoints.length === 0) return [];
-      const edgeRows = [];
-      for (const endpointChunk of chunkSIT26LAZ_cjs.chunk(endpoints, endpointChunkSize)) {
-        const query = operationStrategy.buildFindEdgesByHeterogeneousEndpointSet(
-          params,
-          endpointChunk,
-          edgeKinds
-        );
-        const rows = await execution.execAll(query);
-        for (const row of rows) edgeRows.push(rowMappers.toEdgeRow(row));
-      }
-      return edgeRows;
-    },
-    async countEdgesByKind(params) {
-      const query = operationStrategy.buildCountEdgesByKind(params);
-      const row = await execution.execGet(query);
-      return Number(row?.count ?? 0);
-    },
-    async insertUnique(params) {
-      const query = operationStrategy.buildInsertUnique(params);
-      const result = await execution.execGet(query);
-      if (result && result.node_id !== params.nodeId) {
-        throw new chunkMRDBBHIZ_cjs.UniquenessError({
-          constraintName: params.constraintName,
-          kind: params.nodeKind,
-          existingId: result.node_id,
-          newId: params.nodeId,
-          fields: []
-        });
-      }
-    },
-    async insertUniqueBatch(entries) {
-      if (entries.length === 0) return;
-      const targetKey = (entry) => `${entry.nodeKind}\0${entry.constraintName}\0${entry.key}`;
-      const byTarget = /* @__PURE__ */ new Map();
-      for (const entry of entries) {
-        const existing = byTarget.get(targetKey(entry));
-        if (existing === void 0) {
-          byTarget.set(targetKey(entry), entry);
-          continue;
-        }
-        if (existing.nodeId !== entry.nodeId) {
-          throw new chunkMRDBBHIZ_cjs.UniquenessError({
-            constraintName: entry.constraintName,
-            kind: entry.nodeKind,
-            existingId: existing.nodeId,
-            newId: entry.nodeId,
-            fields: []
-          });
-        }
-      }
-      const deduped = [...byTarget.values()];
-      for (const chunk2 of chunkSIT26LAZ_cjs.chunk(
-        deduped,
-        batchConfig.uniqueInsertBatchSize
-      )) {
-        const query = operationStrategy.buildInsertUniqueBatch(chunk2);
-        const rows = await execution.execAll(query);
-        const ownerByTarget = new Map(
-          rows.map((row) => [
-            `${row.node_kind}\0${row.constraint_name}\0${row.key}`,
-            row.node_id
-          ])
-        );
-        for (const entry of chunk2) {
-          const owner = ownerByTarget.get(targetKey(entry));
-          if (owner !== void 0 && owner !== entry.nodeId) {
-            throw new chunkMRDBBHIZ_cjs.UniquenessError({
-              constraintName: entry.constraintName,
-              kind: entry.nodeKind,
-              existingId: owner,
-              newId: entry.nodeId,
-              fields: []
-            });
-          }
-        }
-      }
-    },
-    async deleteUnique(params) {
-      const timestamp = nowIso2();
-      const query = operationStrategy.buildDeleteUnique(params, timestamp);
-      await execution.execRun(query);
-    },
-    async hardDeleteUniquesByNodeIds(params) {
-      const nodeIds = [...new Set(params.nodeIds)];
-      for (const chunk2 of chunkSIT26LAZ_cjs.chunk(
-        nodeIds,
-        batchConfig.uniqueDeleteChunkSize
-      )) {
-        const query = operationStrategy.buildHardDeleteUniquesByNodeIds({
-          ...params,
-          nodeIds: chunk2
-        });
-        await execution.execRun(query);
-      }
-    },
-    async checkUnique(params) {
-      const query = operationStrategy.buildCheckUnique(params);
-      const row = await execution.execGet(query);
-      return row ? rowMappers.toUniqueRow(row) : void 0;
-    },
-    async checkUniqueBatch(params) {
-      if (params.keys.length === 0) return [];
-      const allRows = [];
-      for (const chunk2 of chunkSIT26LAZ_cjs.chunk(
-        params.keys,
-        batchConfig.checkUniqueBatchChunkSize
-      )) {
-        const query = operationStrategy.buildCheckUniqueBatch({
-          ...params,
-          keys: chunk2
-        });
-        const rows = await execution.execAll(query);
-        allRows.push(...rows.map((row) => rowMappers.toUniqueRow(row)));
-      }
-      return allRows;
-    },
-    async getActiveSchema(graphId) {
-      const query = operationStrategy.buildGetActiveSchema(graphId);
-      const row = await execution.execGet(query);
-      return row ? rowMappers.toSchemaVersionRow(row) : void 0;
-    },
-    async getSchemaVersion(graphId, version) {
-      const query = operationStrategy.buildGetSchemaVersion(graphId, version);
-      const row = await execution.execGet(query);
-      return row ? rowMappers.toSchemaVersionRow(row) : void 0;
-    },
-    async commitSchemaVersion(params) {
-      const existingRaw = await execution.execGet(
-        operationStrategy.buildGetSchemaVersion(params.graphId, params.version)
-      );
-      const actualActiveVersion = await readActiveVersion(params.graphId);
-      if (existingRaw !== void 0) {
-        const existing = rowMappers.toSchemaVersionRow(existingRaw);
-        if (existing.schema_hash !== params.schemaHash) {
-          throw new chunkMRDBBHIZ_cjs.SchemaContentConflictError({
-            graphId: params.graphId,
-            version: params.version,
-            existingHash: existing.schema_hash,
-            incomingHash: params.schemaHash
-          });
-        }
-        if (existing.is_active) {
-          return existing;
-        }
-        verifyExpectedActiveVersion(
-          params.graphId,
-          params.expected,
-          actualActiveVersion
-        );
-        const reactivate = operationStrategy.buildSetActiveSchema(
-          params.graphId,
-          params.version
-        );
-        await execution.execRun(reactivate.deactivateAll);
-        await execution.execRun(reactivate.activateVersion);
-        return { ...existing, is_active: true };
-      }
-      verifyExpectedActiveVersion(
-        params.graphId,
-        params.expected,
-        actualActiveVersion
-      );
-      if (params.expected.kind === "active") {
-        const flip = operationStrategy.buildSetActiveSchema(
-          params.graphId,
-          params.version
-        );
-        await execution.execRun(flip.deactivateAll);
-      }
-      const timestamp = nowIso2();
-      const insertQuery = operationStrategy.buildInsertSchema(
-        {
-          graphId: params.graphId,
-          version: params.version,
-          schemaHash: params.schemaHash,
-          schemaDoc: params.schemaDoc,
-          isActive: true
-        },
-        timestamp
-      );
-      const insertedRaw = await execution.execGet(insertQuery);
-      if (!insertedRaw) {
-        throw new chunkMRDBBHIZ_cjs.DatabaseOperationError(
-          "Insert schema failed: no row returned",
-          { operation: "insert", entity: "schema" }
-        );
-      }
-      return rowMappers.toSchemaVersionRow(insertedRaw);
-    },
-    async setActiveVersion(params) {
-      const actualActiveVersion = await readActiveVersion(params.graphId);
-      verifyExpectedActiveVersion(
-        params.graphId,
-        params.expected,
-        actualActiveVersion
-      );
-      const targetRaw = await execution.execGet(
-        operationStrategy.buildGetSchemaVersion(params.graphId, params.version)
-      );
-      if (!targetRaw) {
-        throw new chunkMRDBBHIZ_cjs.MigrationError(
-          `Cannot activate version ${params.version}: version does not exist for graph "${params.graphId}".`,
-          {
-            graphId: params.graphId,
-            fromVersion: actualActiveVersion,
-            toVersion: params.version,
-            reason: "version-not-found"
-          }
-        );
-      }
-      const queries = operationStrategy.buildSetActiveSchema(
-        params.graphId,
-        params.version
-      );
-      await execution.execRun(queries.deactivateAll);
-      await execution.execRun(queries.activateVersion);
-    },
-    async clearGraph(graphId) {
-      const statements = operationStrategy.buildClearGraph(graphId);
-      for (const statement of statements) {
-        await runIgnorableClearStatement(statement);
-      }
-    }
-  };
-}
-
-// src/backend/drizzle/trusted-import.ts
-var DATABASE_NULL = null;
-function quoteSqlIdentifier(identifier) {
-  return `"${identifier.replaceAll('"', '""')}"`;
-}
-function requireRawExecution(backend) {
-  if (backend.executeRaw === void 0) {
-    throw new chunkMRDBBHIZ_cjs.TrustedImportError(
-      "This backend cannot execute the raw statements required by trusted import.",
-      "backend_unsupported"
-    );
-  }
-  return backend.executeRaw;
-}
-function requireStatementExecution(backend) {
-  if (backend.executeStatement === void 0) {
-    throw new chunkMRDBBHIZ_cjs.TrustedImportError(
-      "This backend cannot execute the index lifecycle required by trusted import.",
-      "backend_unsupported"
-    );
-  }
-  return backend.executeStatement;
-}
-function rowIndicatesExistingData(row) {
-  if (typeof row !== "object" || row === null) return false;
-  const value = row["has_rows"];
-  return value === true || value === 1 || value === "1";
-}
-async function assertTrustedImportDatabaseEmpty(backend, tableNames) {
-  const executeRaw = requireRawExecution(backend);
-  const rows = await executeRaw(
-    `SELECT (
-       EXISTS (SELECT 1 FROM ${quoteSqlIdentifier(tableNames.nodes)} LIMIT 1)
-       OR EXISTS (SELECT 1 FROM ${quoteSqlIdentifier(tableNames.edges)} LIMIT 1)
-     ) AS has_rows`,
-    []
-  );
-  if (!rowIndicatesExistingData(rows[0])) return;
-  throw new chunkMRDBBHIZ_cjs.TrustedImportError(
-    "Trusted import requires globally empty TypeGraph node and edge tables.",
-    "database_not_empty",
-    { tables: [tableNames.nodes, tableNames.edges] },
-    {
-      suggestion: "Run trusted import only against a fresh, dedicated database. Use importGraph or the collection bulk APIs to add data to an existing database."
-    }
-  );
-}
-async function lockPostgresTrustedImportTables(backend, tableNames) {
-  const executeStatement = requireStatementExecution(backend);
-  await executeStatement(
-    chunkEDN4Y4ZG_cjs.asCompiledStatementSql(
-      chunkEDN4Y4ZG_cjs.sql.raw(
-        `LOCK TABLE ${quoteSqlIdentifier(tableNames.nodes)}, ${quoteSqlIdentifier(tableNames.edges)} IN ACCESS EXCLUSIVE MODE`
-      )
-    )
-  );
-}
-async function suspendSqliteSecondaryIndexes(backend, tableNames) {
-  const executeRaw = requireRawExecution(backend);
-  const executeStatement = requireStatementExecution(backend);
-  const definitions = await executeRaw(
-    `SELECT name AS index_name, sql AS index_definition
-       FROM sqlite_schema
-      WHERE type = 'index'
-        AND tbl_name IN (?, ?)
-        AND sql IS NOT NULL
-      ORDER BY name`,
-    [tableNames.nodes, tableNames.edges]
-  );
-  for (const definition of definitions) {
-    await executeStatement(
-      chunkEDN4Y4ZG_cjs.asCompiledStatementSql(
-        chunkEDN4Y4ZG_cjs.sql.raw(`DROP INDEX ${quoteSqlIdentifier(definition.index_name)}`)
-      )
-    );
-  }
-  return definitions;
-}
-async function suspendPostgresSecondaryIndexes(backend, tableNames) {
-  const executeRaw = requireRawExecution(backend);
-  const executeStatement = requireStatementExecution(backend);
-  const definitions = await executeRaw(
-    `SELECT index_class.relname AS index_name,
-            pg_get_indexdef(index_class.oid) AS index_definition
-       FROM pg_class AS table_class
-       JOIN pg_namespace AS namespace
-         ON namespace.oid = table_class.relnamespace
-       JOIN pg_index AS index_metadata
-         ON index_metadata.indrelid = table_class.oid
-       JOIN pg_class AS index_class
-         ON index_class.oid = index_metadata.indexrelid
-       LEFT JOIN pg_constraint AS table_constraint
-         ON table_constraint.conindid = index_class.oid
-      WHERE namespace.nspname = current_schema()
-        AND table_class.relname IN ($1, $2)
-        AND table_constraint.oid IS NULL
-        AND NOT index_metadata.indisprimary
-      ORDER BY index_class.relname`,
-    [tableNames.nodes, tableNames.edges]
-  );
-  for (const definition of definitions) {
-    await executeStatement(
-      chunkEDN4Y4ZG_cjs.asCompiledStatementSql(
-        chunkEDN4Y4ZG_cjs.sql.raw(`DROP INDEX ${quoteSqlIdentifier(definition.index_name)}`)
-      )
-    );
-  }
-  return definitions;
-}
-async function restoreSecondaryIndexes(backend, definitions) {
-  const executeStatement = requireStatementExecution(backend);
-  for (const definition of definitions) {
-    await executeStatement(
-      chunkEDN4Y4ZG_cjs.asCompiledStatementSql(chunkEDN4Y4ZG_cjs.sql.raw(definition.index_definition))
-    );
-  }
-}
-async function analyzeImportedTables(backend, tableNames) {
-  const executeStatement = requireStatementExecution(backend);
-  await executeStatement(
-    chunkEDN4Y4ZG_cjs.asCompiledStatementSql(
-      chunkEDN4Y4ZG_cjs.sql.raw(`ANALYZE ${quoteSqlIdentifier(tableNames.nodes)}`)
-    )
-  );
-  await executeStatement(
-    chunkEDN4Y4ZG_cjs.asCompiledStatementSql(
-      chunkEDN4Y4ZG_cjs.sql.raw(`ANALYZE ${quoteSqlIdentifier(tableNames.edges)}`)
-    )
-  );
-}
-function postgresArray(values) {
-  return `{${values.map(
-    (value) => value === DATABASE_NULL ? "NULL" : `"${value.replaceAll("\\", "\\\\").replaceAll('"', String.raw`\"`)}"`
-  ).join(",")}}`;
-}
-function createSqliteTrustedImportSession(executionAdapter, tableNames) {
-  const executePreparedRunBatch = executionAdapter.executePreparedRunBatch;
-  if (executePreparedRunBatch === void 0) {
-    throw new chunkMRDBBHIZ_cjs.TrustedImportError(
-      "Trusted import requires a synchronous SQLite driver with prepared statement support.",
-      "backend_unsupported"
-    );
-  }
-  const nodeSql = `INSERT INTO ${quoteSqlIdentifier(tableNames.nodes)}
-    (graph_id, kind, id, props, version, valid_from, valid_to, created_at, updated_at)
-    VALUES (?, ?, ?, ?, 1, ?, ?, ?, ?)`;
-  const edgeSql = `INSERT INTO ${quoteSqlIdentifier(tableNames.edges)}
-    (graph_id, id, kind, from_kind, from_id, to_kind, to_id, props, valid_from, valid_to, created_at, updated_at)
-    VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`;
-  return {
-    async insertNodes(params) {
-      if (params.length === 0) return;
-      const timestamp = (/* @__PURE__ */ new Date()).toISOString();
-      await executePreparedRunBatch(
-        nodeSql,
-        params.map((item) => [
-          item.graphId,
-          item.kind,
-          item.id,
-          JSON.stringify(item.props),
-          chunkTQHGE7UC_cjs.resolveStampedValidityLowerBound(item.validFrom, item.validTo, timestamp) ?? DATABASE_NULL,
-          item.validTo ?? DATABASE_NULL,
-          timestamp,
-          timestamp
-        ])
-      );
-    },
-    async insertEdges(params) {
-      if (params.length === 0) return;
-      const timestamp = (/* @__PURE__ */ new Date()).toISOString();
-      await executePreparedRunBatch(
-        edgeSql,
-        params.map((item) => [
-          item.graphId,
-          item.id,
-          item.kind,
-          item.fromKind,
-          item.fromId,
-          item.toKind,
-          item.toId,
-          JSON.stringify(item.props),
-          chunkTQHGE7UC_cjs.resolveStampedValidityLowerBound(item.validFrom, item.validTo, timestamp) ?? DATABASE_NULL,
-          item.validTo ?? DATABASE_NULL,
-          timestamp,
-          timestamp
-        ])
-      );
-    }
-  };
-}
-function createPostgresTrustedImportSession(backend, tableNames) {
-  const executeRaw = requireRawExecution(backend);
-  const nodeSql = `INSERT INTO ${quoteSqlIdentifier(tableNames.nodes)}
-    (graph_id, kind, id, props, version, valid_from, valid_to, created_at, updated_at)
-    SELECT graph_id, kind, id, props::jsonb, 1, valid_from, valid_to, created_at, created_at
-      FROM UNNEST(
-        $1::text[], $2::text[], $3::text[], $4::text[],
-        $5::timestamptz[], $6::timestamptz[], $7::timestamptz[]
-      ) AS imported(graph_id, kind, id, props, valid_from, valid_to, created_at)`;
-  const edgeSql = `INSERT INTO ${quoteSqlIdentifier(tableNames.edges)}
-    (graph_id, id, kind, from_kind, from_id, to_kind, to_id, props, valid_from, valid_to, created_at, updated_at)
-    SELECT graph_id, id, kind, from_kind, from_id, to_kind, to_id, props::jsonb,
-           valid_from, valid_to, created_at, created_at
-      FROM UNNEST(
-        $1::text[], $2::text[], $3::text[], $4::text[], $5::text[],
-        $6::text[], $7::text[], $8::text[], $9::timestamptz[],
-        $10::timestamptz[], $11::timestamptz[]
-      ) AS imported(
-        graph_id, id, kind, from_kind, from_id, to_kind, to_id, props,
-        valid_from, valid_to, created_at
-      )`;
-  return {
-    async insertNodes(params) {
-      if (params.length === 0) return;
-      const timestamp = (/* @__PURE__ */ new Date()).toISOString();
-      await executeRaw(nodeSql, [
-        postgresArray(params.map((item) => item.graphId)),
-        postgresArray(params.map((item) => item.kind)),
-        postgresArray(params.map((item) => item.id)),
-        postgresArray(params.map((item) => JSON.stringify(item.props))),
-        postgresArray(
-          params.map(
-            (item) => chunkTQHGE7UC_cjs.resolveStampedValidityLowerBound(item.validFrom, item.validTo, timestamp) ?? DATABASE_NULL
-          )
-        ),
-        postgresArray(params.map((item) => item.validTo ?? DATABASE_NULL)),
-        postgresArray(params.map(() => timestamp))
-      ]);
-    },
-    async insertEdges(params) {
-      if (params.length === 0) return;
-      const timestamp = (/* @__PURE__ */ new Date()).toISOString();
-      await executeRaw(edgeSql, [
-        postgresArray(params.map((item) => item.graphId)),
-        postgresArray(params.map((item) => item.id)),
-        postgresArray(params.map((item) => item.kind)),
-        postgresArray(params.map((item) => item.fromKind)),
-        postgresArray(params.map((item) => item.fromId)),
-        postgresArray(params.map((item) => item.toKind)),
-        postgresArray(params.map((item) => item.toId)),
-        postgresArray(params.map((item) => JSON.stringify(item.props))),
-        postgresArray(
-          params.map(
-            (item) => chunkTQHGE7UC_cjs.resolveStampedValidityLowerBound(item.validFrom, item.validTo, timestamp) ?? DATABASE_NULL
-          )
-        ),
-        postgresArray(params.map((item) => item.validTo ?? DATABASE_NULL)),
-        postgresArray(params.map(() => timestamp))
-      ]);
-    }
-  };
-}
-
-// src/backend/drizzle/execution/lru.ts
-function getOrCreateLru(cache, key, cacheMax, create) {
-  const cached = cache.get(key);
-  if (cached !== void 0) {
-    cache.delete(key);
-    cache.set(key, cached);
-    return cached;
-  }
-  const value = create();
-  cache.set(key, value);
-  if (cache.size > cacheMax) {
-    const oldest = cache.keys().next().value;
-    if (oldest !== void 0) cache.delete(oldest);
-  }
-  return value;
-}
-
-exports.EMBEDDING_UPSERT_PARAM_COUNT = EMBEDDING_UPSERT_PARAM_COUNT;
-exports.FIND_EDGES_ENDPOINT_FIXED_PARAM_COUNT = FIND_EDGES_ENDPOINT_FIXED_PARAM_COUNT;
-exports.POSTGRES_CONTRIBUTION_MAT_TIMESTAMPS = POSTGRES_CONTRIBUTION_MAT_TIMESTAMPS;
-exports.POSTGRES_INDEX_MAT_TIMESTAMPS = POSTGRES_INDEX_MAT_TIMESTAMPS;
-exports.POSTGRES_KIND_REMOVAL_TIMESTAMPS = POSTGRES_KIND_REMOVAL_TIMESTAMPS;
-exports.SQLITE_CONTRIBUTION_MAT_TIMESTAMPS = SQLITE_CONTRIBUTION_MAT_TIMESTAMPS;
-exports.SQLITE_INDEX_MAT_TIMESTAMPS = SQLITE_INDEX_MAT_TIMESTAMPS;
-exports.SQLITE_KIND_REMOVAL_TIMESTAMPS = SQLITE_KIND_REMOVAL_TIMESTAMPS;
-exports.analyzeImportedTables = analyzeImportedTables;
-exports.assertActiveSchemaVersion = assertActiveSchemaVersion;
-exports.assertAdoptedDialect = assertAdoptedDialect;
-exports.assertTrustedImportDatabaseEmpty = assertTrustedImportDatabaseEmpty;
-exports.buildContributionInsertValues = buildContributionInsertValues;
-exports.buildContributionOnConflictSet = buildContributionOnConflictSet;
-exports.buildKindRemovalInsertValues = buildKindRemovalInsertValues;
-exports.buildKindRemovalOnConflictSet = buildKindRemovalOnConflictSet;
-exports.buildLiveNodeCandidates = buildLiveNodeCandidates;
-exports.buildMaterializationInsertValues = buildMaterializationInsertValues;
-exports.buildMaterializationOnConflictSet = buildMaterializationOnConflictSet;
-exports.commitSchemaVersionIfKindsEmpty = commitSchemaVersionIfKindsEmpty;
-exports.contributionRebuildSupported = contributionRebuildSupported;
-exports.createCachedTableExistence = createCachedTableExistence;
-exports.createCommonOperationBackend = createCommonOperationBackend;
-exports.createContributionMaterializer = createContributionMaterializer;
-exports.createPostgresOperationStrategy = createPostgresOperationStrategy;
-exports.createPostgresTrustedImportSession = createPostgresTrustedImportSession;
-exports.createSqliteOperationStrategy = createSqliteOperationStrategy;
-exports.createSqliteTrustedImportSession = createSqliteTrustedImportSession;
-exports.gateFulltext = gateFulltext;
-exports.gateFulltextMethods = gateFulltextMethods;
-exports.getOrCreateLru = getOrCreateLru;
-exports.lockPostgresTrustedImportTables = lockPostgresTrustedImportTables;
-exports.mapContributionMaterializationRow = mapContributionMaterializationRow;
-exports.mapHybridSearchRow = mapHybridSearchRow;
-exports.mapKindRemovalRow = mapKindRemovalRow;
-exports.mapMaterializationRow = mapMaterializationRow;
-exports.mapVectorWriteError = mapVectorWriteError;
-exports.restoreSecondaryIndexes = restoreSecondaryIndexes;
-exports.suspendPostgresSecondaryIndexes = suspendPostgresSecondaryIndexes;
-exports.suspendSqliteSecondaryIndexes = suspendSqliteSecondaryIndexes;
-exports.tableExistsFromRow = tableExistsFromRow;
-exports.vectorSlotFromCreateIndexParams = vectorSlotFromCreateIndexParams;
-exports.vectorSlotFromDropIndexParams = vectorSlotFromDropIndexParams;
-exports.vectorSlotFromParams = vectorSlotFromParams;
-//# sourceMappingURL=chunk-3QNZ5SAJ.cjs.map
-//# sourceMappingURL=chunk-3QNZ5SAJ.cjs.map