@nicia-ai/typegraph 0.34.0 → 0.36.0

package/dist/chunk-ZAMFOJ5P.cjs

@@ -0,0 +1,1176 @@
+'use strict';
+
+var chunk456Z2U7Y_cjs = require('./chunk-456Z2U7Y.cjs');
+var chunkTCOCYN2P_cjs = require('./chunk-TCOCYN2P.cjs');
+var chunk5W4L6DLF_cjs = require('./chunk-5W4L6DLF.cjs');
+var chunkD7ZEOS56_cjs = require('./chunk-D7ZEOS56.cjs');
+var chunkEOLERH7Y_cjs = require('./chunk-EOLERH7Y.cjs');
+var chunkX4JBT642_cjs = require('./chunk-X4JBT642.cjs');
+var chunkRSSQKPSZ_cjs = require('./chunk-RSSQKPSZ.cjs');
+var chunkDIK74MXX_cjs = require('./chunk-DIK74MXX.cjs');
+var drizzleOrm = require('drizzle-orm');
+var pgCore = require('drizzle-orm/pg-core');
+
+// src/backend/drizzle/execution/postgres-execution.ts
+function hasFunctionProperty(value, property) {
+  if (value === void 0 || value === null) {
+    return false;
+  }
+  const candidate = value;
+  return typeof candidate[property] === "function";
+}
+function isPgNativeClient(candidate) {
+  return typeof candidate === "object" && hasFunctionProperty(candidate, "query");
+}
+function isPgliteClient(candidate) {
+  return typeof candidate === "object" && hasFunctionProperty(candidate, "query") && hasFunctionProperty(candidate, "dumpDataDir");
+}
+function isPostgresJsClient(candidate) {
+  return typeof candidate === "function" && hasFunctionProperty(candidate, "unsafe") && hasFunctionProperty(candidate, "begin");
+}
+function isNeonHttpClient(db) {
+  const candidate = db.$client;
+  return typeof candidate === "function" && hasFunctionProperty(candidate, "transaction") && !hasFunctionProperty(candidate, "begin");
+}
+var DEFAULT_POSTGRES_STATEMENT_CACHE_MAX = 256;
+var STATEMENT_NAME_CACHE = /* @__PURE__ */ new Map();
+var nextStatementId = 0;
+function statementNameFor(sqlText, cacheMax) {
+  return chunk456Z2U7Y_cjs.getOrCreateLru(STATEMENT_NAME_CACHE, sqlText, cacheMax, () => {
+    const name = `tg_${nextStatementId}`;
+    nextStatementId += 1;
+    return name;
+  });
+}
+function normalizeRow(row) {
+  if (row === null || typeof row !== "object") return row;
+  let mutated;
+  for (const key of Object.keys(row)) {
+    const value = row[key];
+    if (value instanceof Date) {
+      mutated ??= { ...row };
+      mutated[key] = value.toISOString();
+    }
+  }
+  return mutated ?? row;
+}
+function normalizeRows(rows) {
+  let mutated;
+  for (let index = 0; index < rows.length; index += 1) {
+    const original = rows[index];
+    const normalized = normalizeRow(original);
+    if (normalized !== original) {
+      mutated ??= [...rows];
+      mutated[index] = normalized;
+    }
+  }
+  return mutated ?? rows;
+}
+function wrapNodePgClient(client, cacheMax) {
+  return {
+    async query(sqlText, params) {
+      const result = await client.query({
+        name: statementNameFor(sqlText, cacheMax),
+        text: sqlText,
+        values: params
+      });
+      return { rows: normalizeRows(result.rows) };
+    },
+    async queryUnnamed(sqlText, params) {
+      const result = await client.query(sqlText, params);
+      return { rows: normalizeRows(result.rows) };
+    }
+  };
+}
+function wrapNodePgClientUnnamed(client) {
+  async function queryUnnamed(sqlText, params) {
+    const result = await client.query(sqlText, params);
+    return { rows: normalizeRows(result.rows) };
+  }
+  return {
+    query: queryUnnamed,
+    queryUnnamed
+  };
+}
+function adaptPostgresJsClient(sql2) {
+  async function query(sqlText, params) {
+    const rows = await sql2.unsafe(sqlText, params);
+    return { rows };
+  }
+  return {
+    query,
+    async queryUnnamed(sqlText, params) {
+      const rows = await sql2.unsafe(sqlText, params, { prepare: false });
+      return { rows };
+    }
+  };
+}
+function resolvePgClient(db, prepareStatements, cacheMax) {
+  if (isNeonHttpClient(db)) {
+    return void 0;
+  }
+  const client = db.$client;
+  if (isPgliteClient(client)) {
+    return wrapNodePgClientUnnamed(client);
+  }
+  if (isPgNativeClient(client)) {
+    return prepareStatements ? wrapNodePgClient(client, cacheMax) : wrapNodePgClientUnnamed(client);
+  }
+  if (isPostgresJsClient(client)) {
+    return adaptPostgresJsClient(client);
+  }
+  return void 0;
+}
+async function executeDrizzleQuery(db, query) {
+  const result = await db.execute(query);
+  if (Array.isArray(result)) {
+    return result;
+  }
+  return result.rows;
+}
+function createPgPreparedStatement(pgClient, sqlText) {
+  return {
+    async execute(params) {
+      const result = await pgClient.query(sqlText, params);
+      return result.rows;
+    }
+  };
+}
+function createPostgresExecutionAdapter(db, options = {}) {
+  const prepareStatements = options.prepareStatements ?? true;
+  const cacheMax = options.preparedStatementCacheMax ?? DEFAULT_POSTGRES_STATEMENT_CACHE_MAX;
+  const pgClient = resolvePgClient(db, prepareStatements, cacheMax);
+  function compile(query) {
+    return chunk456Z2U7Y_cjs.compileQueryWithDialect(db, query, "PostgreSQL");
+  }
+  if (pgClient === void 0) {
+    return {
+      compile,
+      async execute(query) {
+        return executeDrizzleQuery(db, query);
+      }
+    };
+  }
+  const pgQueryClient = pgClient;
+  async function executeCompiled(compiledQuery) {
+    const result = await pgQueryClient.query(
+      compiledQuery.sql,
+      compiledQuery.params
+    );
+    return result.rows;
+  }
+  return {
+    compile,
+    async execute(query) {
+      const compiled = compile(query);
+      if (chunkEOLERH7Y_cjs.shouldForceCustomPlan(query)) {
+        const result = await pgQueryClient.queryUnnamed(
+          compiled.sql,
+          compiled.params
+        );
+        return result.rows;
+      }
+      return executeCompiled(compiled);
+    },
+    executeCompiled,
+    prepare(sqlText) {
+      return createPgPreparedStatement(pgQueryClient, sqlText);
+    }
+  };
+}
+
+// src/backend/drizzle/execution/statement-queue.ts
+function ignoreOutcome() {
+}
+function createStatementQueue() {
+  let tail = Promise.resolve();
+  let closed = false;
+  return {
+    enqueue(task) {
+      if (closed) return Promise.reject(new chunkDIK74MXX_cjs.TransactionClosedError());
+      const result = tail.then(() => task());
+      tail = result.then(ignoreOutcome, ignoreOutcome);
+      return result;
+    },
+    async drainAndClose() {
+      closed = true;
+      await tail;
+    }
+  };
+}
+function createSerialExecutionAdapter(adapter) {
+  const { enqueue, drainAndClose } = createStatementQueue();
+  const { executeCompiled, prepare } = adapter;
+  return {
+    drainAndClose,
+    compile(query) {
+      return adapter.compile(query);
+    },
+    execute(query) {
+      return enqueue(() => adapter.execute(query));
+    },
+    runExclusive(critical) {
+      return enqueue(() => critical(adapter));
+    },
+    ...executeCompiled === void 0 ? {} : {
+      executeCompiled(compiledQuery) {
+        return enqueue(() => executeCompiled(compiledQuery));
+      }
+    },
+    ...prepare === void 0 ? {} : {
+      prepare(sqlText) {
+        const statement = prepare(sqlText);
+        return {
+          execute(params) {
+            return enqueue(() => statement.execute(params));
+          }
+        };
+      }
+    }
+  };
+}
+
+// src/backend/drizzle/postgres.ts
+var NODE_INSERT_PARAM_COUNT = 9;
+var EDGE_INSERT_PARAM_COUNT = 12;
+var POSTGRES_NODE_INSERT_BATCH_SIZE = Math.max(
+  1,
+  Math.floor(chunkX4JBT642_cjs.POSTGRES_MAX_BIND_PARAMETERS / NODE_INSERT_PARAM_COUNT)
+);
+var POSTGRES_EDGE_INSERT_BATCH_SIZE = Math.max(
+  1,
+  Math.floor(chunkX4JBT642_cjs.POSTGRES_MAX_BIND_PARAMETERS / EDGE_INSERT_PARAM_COUNT)
+);
+var POSTGRES_GET_NODES_ID_CHUNK_SIZE = Math.max(
+  1,
+  chunkX4JBT642_cjs.POSTGRES_MAX_BIND_PARAMETERS - 2
+);
+var POSTGRES_GET_EDGES_ID_CHUNK_SIZE = Math.max(
+  1,
+  chunkX4JBT642_cjs.POSTGRES_MAX_BIND_PARAMETERS - 1
+);
+var FULLTEXT_UPSERT_PARAM_COUNT = 6;
+var FULLTEXT_DELETE_FIXED_PARAM_COUNT = 2;
+var POSTGRES_FULLTEXT_UPSERT_BATCH_SIZE = Math.max(
+  1,
+  Math.floor(chunkX4JBT642_cjs.POSTGRES_MAX_BIND_PARAMETERS / FULLTEXT_UPSERT_PARAM_COUNT)
+);
+var POSTGRES_FULLTEXT_DELETE_CHUNK_SIZE = Math.max(
+  1,
+  chunkX4JBT642_cjs.POSTGRES_MAX_BIND_PARAMETERS - FULLTEXT_DELETE_FIXED_PARAM_COUNT
+);
+var CHECK_UNIQUE_BATCH_FIXED_PARAM_COUNT = 3;
+var POSTGRES_CHECK_UNIQUE_BATCH_CHUNK_SIZE = Math.max(
+  1,
+  chunkX4JBT642_cjs.POSTGRES_MAX_BIND_PARAMETERS - CHECK_UNIQUE_BATCH_FIXED_PARAM_COUNT
+);
+var UNIQUE_INSERT_PARAM_COUNT = 6;
+var POSTGRES_UNIQUE_INSERT_BATCH_SIZE = Math.max(
+  1,
+  Math.floor(chunkX4JBT642_cjs.POSTGRES_MAX_BIND_PARAMETERS / UNIQUE_INSERT_PARAM_COUNT)
+);
+var toNodeRow = chunk5W4L6DLF_cjs.createNodeRowMapper(chunk5W4L6DLF_cjs.POSTGRES_ROW_MAPPER_CONFIG);
+var toEdgeRow = chunk5W4L6DLF_cjs.createEdgeRowMapper(chunk5W4L6DLF_cjs.POSTGRES_ROW_MAPPER_CONFIG);
+var toUniqueRow = chunk5W4L6DLF_cjs.createUniqueRowMapper(chunk5W4L6DLF_cjs.POSTGRES_ROW_MAPPER_CONFIG);
+var toSchemaVersionRow = chunk5W4L6DLF_cjs.createSchemaVersionRowMapper(
+  chunk5W4L6DLF_cjs.POSTGRES_ROW_MAPPER_CONFIG
+);
+function buildPostgresCapabilities(fulltextStrategy, vectorStrategy) {
+  return {
+    ...chunkX4JBT642_cjs.POSTGRES_CAPABILITIES,
+    ...vectorStrategy === void 0 ? {} : { vector: chunkD7ZEOS56_cjs.buildVectorCapabilities(vectorStrategy) },
+    fulltext: chunkD7ZEOS56_cjs.buildFulltextCapabilities(fulltextStrategy)
+  };
+}
+function createPostgresBackend(db, options = {}) {
+  const tables2 = options.tables ?? chunk456Z2U7Y_cjs.tables;
+  const fulltextStrategy = options.fulltext ?? chunkD7ZEOS56_cjs.tsvectorStrategy;
+  const vectorStrategy = options.vector === false ? void 0 : options.vector ?? chunkTCOCYN2P_cjs.pgvectorStrategy;
+  const vectorSlotLatch = vectorStrategy === void 0 ? void 0 : chunk456Z2U7Y_cjs.createVectorSlotLatch();
+  const iterativeScanProbe = createIterativeScanProbe();
+  const baseCapabilities = buildPostgresCapabilities(
+    fulltextStrategy,
+    vectorStrategy
+  );
+  const httpOnlyOverrides = isNeonHttpClient(db) ? { transactions: false } : {};
+  const capabilities = {
+    ...baseCapabilities,
+    ...httpOnlyOverrides,
+    ...options.capabilities
+  };
+  const adapterOptions = {
+    ...options.prepareStatements === void 0 ? {} : { prepareStatements: options.prepareStatements },
+    ...options.preparedStatementCacheMax === void 0 ? {} : { preparedStatementCacheMax: options.preparedStatementCacheMax }
+  };
+  const executionAdapter = createPostgresExecutionAdapter(db, adapterOptions);
+  const tableNames = {
+    nodes: drizzleOrm.getTableName(tables2.nodes),
+    edges: drizzleOrm.getTableName(tables2.edges),
+    recordedNodes: drizzleOrm.getTableName(tables2.recordedNodes),
+    recordedEdges: drizzleOrm.getTableName(tables2.recordedEdges),
+    recordedClock: drizzleOrm.getTableName(tables2.recordedClock),
+    revisionOrigins: drizzleOrm.getTableName(tables2.revisionOrigins),
+    fulltext: tables2.fulltextTableName,
+    uniques: drizzleOrm.getTableName(tables2.uniques)
+  };
+  const coreAnalyzeStatements = [
+    tableNames.nodes,
+    tableNames.edges,
+    drizzleOrm.getTableName(tables2.uniques),
+    tableNames.fulltext
+  ].map((name) => drizzleOrm.sql`ANALYZE (SKIP_LOCKED) ${chunk5W4L6DLF_cjs.quoteIdentifier(name)}`);
+  const recordedAnalyzeTables = [
+    tableNames.recordedNodes,
+    tableNames.recordedEdges,
+    tableNames.recordedClock
+  ];
+  const operationStrategy = chunk456Z2U7Y_cjs.createPostgresOperationStrategy(
+    tables2,
+    fulltextStrategy
+  );
+  const operations = createPostgresOperationBackend({
+    db,
+    executionAdapter,
+    adapterOptions,
+    operationStrategy,
+    tableNames,
+    capabilities,
+    fulltextStrategy,
+    vectorStrategy,
+    vectorSlotLatch,
+    iterativeScanProbe
+  });
+  const recordedTableExists = chunk456Z2U7Y_cjs.createCachedTableExistence(
+    async (tableName) => {
+      const rows = await executionAdapter.execute(
+        operationStrategy.buildTableExists(tableName)
+      );
+      return rows[0];
+    },
+    { cacheExisting: false }
+  );
+  function runSchemaWriteTransaction(graphId, fn) {
+    if (!capabilities.transactions) {
+      throw new chunkDIK74MXX_cjs.ConfigurationError(
+        "commitSchemaVersion and setActiveVersion require atomic transactions, but this Postgres backend does not provide them. The drizzle-orm/neon-http driver communicates over HTTP and cannot hold a session across statements; use drizzle-orm/neon-serverless (websocket) for transactional writes.",
+        {
+          backend: "postgres",
+          capability: "transactions",
+          supportsTransactions: false
+        }
+      );
+    }
+    return db.transaction(async (tx) => {
+      await tx.execute(drizzleOrm.sql`SELECT pg_advisory_xact_lock(hashtext(${graphId}))`);
+      const { backend: txBackend, drainAndClose } = createTransactionBackend({
+        db: tx,
+        adapterOptions,
+        operationStrategy,
+        tableNames,
+        capabilities,
+        fulltextStrategy,
+        vectorStrategy,
+        iterativeScanProbe
+      });
+      try {
+        return await fn(txBackend);
+      } finally {
+        await drainAndClose();
+      }
+    });
+  }
+  const matTable = tables2.contributionMaterializations;
+  async function ensureContributionMaterializationsTableImpl() {
+    await db.execute(drizzleOrm.sql.raw(chunk456Z2U7Y_cjs.generatePgCreateTableSQL(matTable)));
+  }
+  async function getContributionMaterializationRow(identity) {
+    const rows = await db.select().from(matTable).where(
+      drizzleOrm.and(
+        drizzleOrm.eq(matTable.graphId, identity.graphId),
+        drizzleOrm.eq(matTable.logicalName, identity.logicalName),
+        drizzleOrm.eq(matTable.owner, identity.owner),
+        drizzleOrm.eq(matTable.tableName, identity.tableName)
+      )
+    );
+    const row = rows[0];
+    if (row === void 0) return void 0;
+    return chunk456Z2U7Y_cjs.mapContributionMaterializationRow(
+      row,
+      chunk456Z2U7Y_cjs.POSTGRES_CONTRIBUTION_MAT_TIMESTAMPS.decode
+    );
+  }
+  async function recordContributionMaterializationRow(params) {
+    await db.insert(matTable).values(
+      chunk456Z2U7Y_cjs.buildContributionInsertValues(
+        params,
+        chunk456Z2U7Y_cjs.POSTGRES_CONTRIBUTION_MAT_TIMESTAMPS.encode
+      )
+    ).onConflictDoUpdate({
+      target: [
+        matTable.graphId,
+        matTable.logicalName,
+        matTable.owner,
+        matTable.tableName
+      ],
+      set: chunk456Z2U7Y_cjs.buildContributionOnConflictSet(
+        matTable.materializedAt,
+        params.materializedAt
+      )
+    });
+  }
+  const contributionMaterializer = chunk456Z2U7Y_cjs.createContributionMaterializer({
+    dialect: "postgres",
+    fulltextStrategy,
+    fulltextTableName: tables2.fulltextTableName,
+    execDdl: async (statement) => {
+      await db.execute(drizzleOrm.sql.raw(statement));
+    },
+    ensureMarkerTable: ensureContributionMaterializationsTableImpl,
+    getMarker: getContributionMaterializationRow,
+    recordMarker: recordContributionMaterializationRow
+  });
+  function bindTransactionBackend(tx) {
+    const { backend: backend2, drainAndClose } = createTransactionBackend({
+      db: tx,
+      adapterOptions,
+      operationStrategy,
+      tableNames,
+      capabilities,
+      fulltextStrategy,
+      vectorStrategy,
+      iterativeScanProbe
+    });
+    return {
+      backend: chunk456Z2U7Y_cjs.gateFulltext(
+        backend2,
+        contributionMaterializer.assertInitialized
+      ),
+      drainAndClose
+    };
+  }
+  const backend = {
+    ...operations,
+    async bootstrapTables() {
+      const statements = chunk456Z2U7Y_cjs.generatePostgresDDL(tables2, fulltextStrategy);
+      for (const statement of statements) {
+        await db.execute(drizzleOrm.sql.raw(statement));
+      }
+    },
+    async ensureRevisionOriginsTable() {
+      await db.execute(
+        drizzleOrm.sql.raw(chunk456Z2U7Y_cjs.generatePgCreateTableSQL(tables2.revisionOrigins))
+      );
+    },
+    // Every fulltext-touching method asserts the durable marker instead
+    // of lazily emitting DDL. Steady state performs zero ensure; an
+    // uninitialized database throws `StoreNotInitializedError` loudly
+    // rather than self-healing on a read/write path (#135). Shared
+    // verbatim with the tx-scoped gate via `gateFulltextMethods`.
+    ...chunk456Z2U7Y_cjs.gateFulltextMethods(
+      operations,
+      contributionMaterializer.assertInitialized
+    ),
+    async executeDdl(ddl) {
+      await db.execute(drizzleOrm.sql.raw(ddl));
+    },
+    async ensureIndexMaterializationsTable() {
+      await db.execute(
+        drizzleOrm.sql.raw(chunk456Z2U7Y_cjs.generatePgCreateTableSQL(tables2.indexMaterializations))
+      );
+      const tableName = drizzleOrm.getTableName(tables2.indexMaterializations);
+      await db.execute(
+        drizzleOrm.sql.raw(
+          `ALTER TABLE "${tableName}" ADD COLUMN IF NOT EXISTS "building_since" timestamptz;`
+        )
+      );
+      await db.execute(
+        drizzleOrm.sql.raw(
+          `ALTER TABLE "${tableName}" ADD COLUMN IF NOT EXISTS "claim_token" text;`
+        )
+      );
+    },
+    async claimIndexMaterialization(params) {
+      const t = tables2.indexMaterializations;
+      const rows = await db.execute(drizzleOrm.sql`
+        INSERT INTO ${t} (
+          "index_name", "graph_id", "entity", "kind", "signature",
+          "schema_version", "last_attempted_at", "building_since",
+          "claim_token"
+        )
+        VALUES (
+          ${params.indexName}, ${params.graphId}, ${params.entity},
+          ${params.kind}, ${params.signature}, ${params.schemaVersion},
+          now(), now(), ${params.token}
+        )
+        ON CONFLICT ("index_name") DO UPDATE SET
+          "building_since" = now(),
+          "claim_token" = EXCLUDED."claim_token"
+        WHERE ${t}."building_since" IS NULL
+           OR ${t}."building_since" < now() - (${params.leaseMs} * interval '1 millisecond')
+        RETURNING "index_name"
+      `);
+      const result = rows;
+      const returned = Array.isArray(result) ? result : result.rows ?? [];
+      return returned.length > 0;
+    },
+    async releaseIndexMaterializationClaim(params) {
+      const t = tables2.indexMaterializations;
+      await db.execute(drizzleOrm.sql`
+        UPDATE ${t}
+        SET "building_since" = NULL, "claim_token" = NULL
+        WHERE "index_name" = ${params.indexName}
+          AND "claim_token" = ${params.token}
+      `);
+    },
+    async getIndexMaterialization(indexName) {
+      const t = tables2.indexMaterializations;
+      const rows = await db.select().from(t).where(drizzleOrm.eq(t.indexName, indexName));
+      const row = rows[0];
+      if (row === void 0) return void 0;
+      return chunk456Z2U7Y_cjs.mapMaterializationRow(row, chunk456Z2U7Y_cjs.POSTGRES_INDEX_MAT_TIMESTAMPS.decode);
+    },
+    async getIndexMaterializations(statusKeys) {
+      if (statusKeys.length === 0) return [];
+      const t = tables2.indexMaterializations;
+      const rows = await db.select().from(t).where(drizzleOrm.inArray(t.indexName, [...statusKeys]));
+      return rows.map(
+        (row) => chunk456Z2U7Y_cjs.mapMaterializationRow(row, chunk456Z2U7Y_cjs.POSTGRES_INDEX_MAT_TIMESTAMPS.decode)
+      );
+    },
+    async recordIndexMaterialization(params) {
+      const t = tables2.indexMaterializations;
+      await db.insert(t).values(
+        chunk456Z2U7Y_cjs.buildMaterializationInsertValues(
+          params,
+          chunk456Z2U7Y_cjs.POSTGRES_INDEX_MAT_TIMESTAMPS.encode
+        )
+      ).onConflictDoUpdate({
+        target: t.indexName,
+        set: chunk456Z2U7Y_cjs.buildMaterializationOnConflictSet(
+          t.materializedAt,
+          params.materializedAt
+        )
+      });
+    },
+    async ensureContributionMaterializationsTable() {
+      await ensureContributionMaterializationsTableImpl();
+    },
+    async getContributionMaterialization(identity) {
+      return getContributionMaterializationRow(identity);
+    },
+    async recordContributionMaterialization(params) {
+      await recordContributionMaterializationRow(params);
+    },
+    async assertRuntimeContributionsInitialized(graphId) {
+      await contributionMaterializer.assertInitialized(graphId);
+    },
+    async ensureKindRemovalsTable() {
+      await db.execute(drizzleOrm.sql.raw(chunk456Z2U7Y_cjs.generatePgCreateTableSQL(tables2.kindRemovals)));
+    },
+    async getPendingKindRemovals(graphId) {
+      const t = tables2.kindRemovals;
+      const rows = await db.select().from(t).where(drizzleOrm.and(drizzleOrm.eq(t.graphId, graphId), drizzleOrm.isNull(t.removedAt)));
+      return rows.map(
+        (row) => chunk456Z2U7Y_cjs.mapKindRemovalRow(row, chunk456Z2U7Y_cjs.POSTGRES_KIND_REMOVAL_TIMESTAMPS.decode)
+      );
+    },
+    async getAllKindRemovals(graphId) {
+      const t = tables2.kindRemovals;
+      const rows = await db.select().from(t).where(drizzleOrm.eq(t.graphId, graphId));
+      return rows.map(
+        (row) => chunk456Z2U7Y_cjs.mapKindRemovalRow(row, chunk456Z2U7Y_cjs.POSTGRES_KIND_REMOVAL_TIMESTAMPS.decode)
+      );
+    },
+    async recordKindRemoval(params) {
+      const t = tables2.kindRemovals;
+      await db.insert(t).values(
+        chunk456Z2U7Y_cjs.buildKindRemovalInsertValues(
+          params,
+          chunk456Z2U7Y_cjs.POSTGRES_KIND_REMOVAL_TIMESTAMPS.encode
+        )
+      ).onConflictDoUpdate({
+        target: [t.graphId, t.kindName, t.entity, t.schemaVersion],
+        set: chunk456Z2U7Y_cjs.buildKindRemovalOnConflictSet(t.removedAt, params.removedAt)
+      });
+    },
+    async ensureReconciliationMarkersTable() {
+      await db.execute(
+        drizzleOrm.sql.raw(chunk456Z2U7Y_cjs.generatePgCreateTableSQL(tables2.reconciliationMarkers))
+      );
+    },
+    async ensureRuntimeContributions(graphId) {
+      await contributionMaterializer.ensureRuntimeContributions(graphId);
+    },
+    /**
+     * Superseded by `ensureRuntimeContributions(graphId)` (#129).
+     * Retained as a thin back-compat wrapper for callers predating
+     * #129; #135 routed it through the durable-marker writer.
+     */
+    async ensureFulltextTable(graphId) {
+      await contributionMaterializer.ensureRuntimeContributions(graphId);
+    },
+    async getReconciliationMarker(graphId) {
+      const t = tables2.reconciliationMarkers;
+      const rows = await db.select().from(t).where(drizzleOrm.eq(t.graphId, graphId));
+      return rows[0]?.reconciledToVersion;
+    },
+    async setReconciliationMarker(graphId, version) {
+      const t = tables2.reconciliationMarkers;
+      await db.insert(t).values({ graphId, reconciledToVersion: version }).onConflictDoUpdate({
+        target: t.graphId,
+        set: { reconciledToVersion: version }
+      });
+    },
+    async refreshStatistics() {
+      for (const statement of coreAnalyzeStatements) {
+        await db.execute(statement);
+      }
+      const tablePresence = await Promise.all(
+        recordedAnalyzeTables.map(async (tableName) => ({
+          tableName,
+          exists: await recordedTableExists(tableName)
+        }))
+      );
+      const presentRecordedTables = tablePresence.filter((entry) => entry.exists).map((entry) => entry.tableName);
+      for (const tableName of presentRecordedTables) {
+        await db.execute(
+          drizzleOrm.sql`ANALYZE (SKIP_LOCKED) ${chunk5W4L6DLF_cjs.quoteIdentifier(tableName)}`
+        );
+      }
+    },
+    async commitSchemaVersion(params) {
+      return runSchemaWriteTransaction(
+        params.graphId,
+        (target) => target.commitSchemaVersion(params)
+      );
+    },
+    async setActiveVersion(params) {
+      await runSchemaWriteTransaction(
+        params.graphId,
+        (target) => target.setActiveVersion(params)
+      );
+    },
+    async transaction(fn, options2) {
+      const txConfig = options2?.isolationLevel ? {
+        isolationLevel: options2.isolationLevel.replace("_", " ")
+      } : void 0;
+      return db.transaction(async (tx) => {
+        const { backend: txBackend, drainAndClose } = bindTransactionBackend(tx);
+        try {
+          return await fn(txBackend, tx);
+        } finally {
+          await drainAndClose();
+        }
+      }, txConfig);
+    },
+    adoptTransaction(externalTx) {
+      if (!capabilities.transactions) {
+        throw new chunkDIK74MXX_cjs.ConfigurationError(
+          "Cross-store atomicity is unavailable on this Postgres backend: its driver does not support transactions (drizzle-orm/neon-http, Cloudflare D1). Adopting an external transaction here would let the caller's relational write commit with no way to roll back the graph write. Use a node-postgres or neon-serverless (Pool/WebSocket) connection for cross-store transactions.",
+          {
+            backend: "postgres",
+            capability: "transactions",
+            supportsTransactions: false
+          }
+        );
+      }
+      chunk456Z2U7Y_cjs.assertAdoptedDialect(externalTx, pgCore.PgDatabase, "postgres");
+      return bindTransactionBackend(externalTx).backend;
+    },
+    async close() {
+    }
+  };
+  return backend;
+}
+function createIterativeScanProbe() {
+  let probe;
+  let warned = false;
+  function warnUnavailable(version) {
+    if (warned) return;
+    warned = true;
+    if (typeof console === "undefined" || typeof console.warn !== "function") {
+      return;
+    }
+    console.warn(
+      `[typegraph] pgvector ${version} has no iterative scan (added in 0.8), so a filtered approximate vector search stays ef_search-bounded and can return fewer rows than \`limit\` while more matches exist. Upgrade pgvector to >= 0.8, or use an exact search (\`approximate: false\`) where a full page matters.`
+    );
+  }
+  return {
+    isSupported(execAll) {
+      probe ??= (async () => {
+        try {
+          const [row] = await execAll(
+            drizzleOrm.sql`SELECT extversion AS v FROM pg_extension WHERE extname = 'vector'`
+          );
+          if (typeof row?.v !== "string") return false;
+          const [major = 0, minor = 0] = row.v.split(".").map((part) => Number.parseInt(part, 10));
+          const supported = major > 0 || major === 0 && minor >= 8;
+          if (!supported) warnUnavailable(row.v);
+          return supported;
+        } catch {
+          return false;
+        }
+      })();
+      return probe;
+    }
+  };
+}
+function createPostgresOperationBackend(options) {
+  const {
+    db,
+    executionAdapter,
+    adapterOptions,
+    operationStrategy,
+    tableNames,
+    capabilities,
+    fulltextStrategy,
+    vectorStrategy,
+    vectorSlotLatch,
+    iterativeScanProbe
+  } = options;
+  async function execAll(query) {
+    return executionAdapter.execute(query);
+  }
+  async function execGet(query) {
+    const rows = await executionAdapter.execute(query);
+    return rows[0];
+  }
+  async function execRun(query) {
+    await executionAdapter.execute(query);
+  }
+  let efSearchUnsupportedWarned = false;
+  function warnEfSearchUnsupported() {
+    if (efSearchUnsupportedWarned) return;
+    efSearchUnsupportedWarned = true;
+    if (typeof console === "undefined" || typeof console.warn !== "function") {
+      return;
+    }
+    console.warn(
+      "[typegraph] efSearch (hnsw.ef_search override) was ignored: this Postgres backend has transactions disabled (e.g. drizzle-orm/neon-http), and SET LOCAL needs a transaction to scope the override. Use a transactional driver (node-postgres / neon-serverless / postgres-js) to apply efSearch."
+    );
+  }
+  function pgvectorIterativeScanSupported() {
+    return iterativeScanProbe.isSupported(execAll);
+  }
+  async function vectorSearchGucOverrides(params) {
+    const overrides = [];
+    if (params.efSearch !== void 0) {
+      if (capabilities.transactions) {
+        overrides.push({
+          name: "hnsw.ef_search",
+          value: String(params.efSearch)
+        });
+      } else {
+        warnEfSearchUnsupported();
+      }
+    }
+    if (params.indexType === "hnsw" && capabilities.transactions && await pgvectorIterativeScanSupported()) {
+      overrides.push({ name: "hnsw.iterative_scan", value: "strict_order" });
+    }
+    if (params.indexType === "ivfflat" && capabilities.transactions && await pgvectorIterativeScanSupported()) {
+      overrides.push({
+        name: "ivfflat.iterative_scan",
+        value: "relaxed_order"
+      });
+    }
+    return overrides;
+  }
+  async function runVectorSearchGucGroup(overrides, query) {
+    const runExclusive = executionAdapter.runExclusive;
+    if (runExclusive === void 0) {
+      throw new chunkDIK74MXX_cjs.CompilerInvariantError(
+        "A transaction-scoped Postgres backend must expose runExclusive; its execution adapter was not wrapped by createSerialExecutionAdapter."
+      );
+    }
+    return runExclusive(async (connection) => {
+      const snapshots = [];
+      for (const override of overrides) {
+        const [setting] = await connection.execute(
+          drizzleOrm.sql`SELECT current_setting(${override.name}) AS v`
+        );
+        if (setting !== void 0) {
+          snapshots.push({ name: override.name, value: setting.v });
+        }
+        await connection.execute(
+          drizzleOrm.sql`SELECT set_config(${override.name}, ${override.value}, true)`
+        );
+      }
+      const rows = await connection.execute(query);
+      for (const snapshot of snapshots) {
+        await connection.execute(
+          drizzleOrm.sql`SELECT set_config(${snapshot.name}, ${snapshot.value}, true)`
+        );
+      }
+      return rows;
+    });
+  }
+  async function runVectorSearch(overrides, query) {
+    if (overrides.length === 0) {
+      return execAll(query);
+    }
+    if (db instanceof pgCore.PgTransaction) {
+      return runVectorSearchGucGroup(overrides, query);
+    }
+    return db.transaction(async (tx) => {
+      const txAdapter = createPostgresExecutionAdapter(tx, adapterOptions);
+      for (const override of overrides) {
+        await txAdapter.execute(
+          drizzleOrm.sql`SELECT set_config(${override.name}, ${override.value}, true)`
+        );
+      }
+      return txAdapter.execute(query);
+    });
+  }
+  async function ensureVectorSlotStorage(slot) {
+    if (vectorStrategy === void 0 || vectorSlotLatch === void 0) return;
+    await vectorSlotLatch.ensure(vectorStrategy, slot, async (statement) => {
+      await execRun(drizzleOrm.sql.raw(statement));
+    });
+  }
+  const batchConfig = {
+    checkUniqueBatchChunkSize: POSTGRES_CHECK_UNIQUE_BATCH_CHUNK_SIZE,
+    edgeInsertBatchSize: POSTGRES_EDGE_INSERT_BATCH_SIZE,
+    // Unlike the static siblings, the embedding upsert honors a runtime
+    // `maxBindParameters` override so its chunk size tracks the connection's
+    // actual bind budget.
+    embeddingUpsertBatchSize: Math.max(
+      1,
+      Math.floor(
+        (capabilities.maxBindParameters ?? chunkX4JBT642_cjs.POSTGRES_MAX_BIND_PARAMETERS) / chunk456Z2U7Y_cjs.EMBEDDING_UPSERT_PARAM_COUNT
+      )
+    ),
+    getEdgesChunkSize: POSTGRES_GET_EDGES_ID_CHUNK_SIZE,
+    getNodesChunkSize: POSTGRES_GET_NODES_ID_CHUNK_SIZE,
+    nodeInsertBatchSize: POSTGRES_NODE_INSERT_BATCH_SIZE,
+    uniqueInsertBatchSize: POSTGRES_UNIQUE_INSERT_BATCH_SIZE
+  };
+  const commonBackend = chunk456Z2U7Y_cjs.createCommonOperationBackend({
+    batchConfig,
+    execution: {
+      execAll,
+      execGet,
+      execRun
+    },
+    nowIso: chunk5W4L6DLF_cjs.nowIso,
+    operationStrategy,
+    rowMappers: {
+      toEdgeRow,
+      toNodeRow,
+      toSchemaVersionRow,
+      toUniqueRow
+    },
+    tableExistenceCache: { cacheExisting: false }
+  });
+  const executeCompiled = executionAdapter.executeCompiled;
+  const executeRawMethod = executeCompiled === void 0 ? {} : {
+    async executeRaw(sqlText, params) {
+      return executeCompiled({ params, sql: sqlText });
+    }
+  };
+  const vectorEmbeddingMethods = vectorStrategy === void 0 ? {} : {
+    async upsertEmbedding(params) {
+      const slot = chunk456Z2U7Y_cjs.vectorSlotFromParams(params);
+      await ensureVectorSlotStorage(slot);
+      const statements = vectorStrategy.buildUpsert(slot, params, chunk5W4L6DLF_cjs.nowIso());
+      try {
+        for (const statement of statements) {
+          await execRun(statement);
+        }
+      } catch (error) {
+        throw chunk456Z2U7Y_cjs.mapVectorWriteError(error, params);
+      }
+    },
+    async upsertEmbeddingBatch(params) {
+      if (params.rows.length === 0) return;
+      const slot = chunk456Z2U7Y_cjs.vectorSlotFromParams(params);
+      await ensureVectorSlotStorage(slot);
+      const rowsById = new Map(
+        params.rows.map((row) => [row.nodeId, row])
+      );
+      const rows = [...rowsById.values()];
+      const timestamp = chunk5W4L6DLF_cjs.nowIso();
+      try {
+        for (const chunk2 of chunkX4JBT642_cjs.chunk(
+          rows,
+          batchConfig.embeddingUpsertBatchSize
+        )) {
+          const statements = vectorStrategy.buildUpsertBatch === void 0 ? chunk2.flatMap(
+            (row) => vectorStrategy.buildUpsert(
+              slot,
+              {
+                graphId: params.graphId,
+                nodeKind: params.nodeKind,
+                nodeId: row.nodeId,
+                fieldPath: params.fieldPath,
+                embedding: row.embedding,
+                dimensions: params.dimensions,
+                metric: params.metric,
+                indexType: params.indexType
+              },
+              timestamp
+            )
+          ) : vectorStrategy.buildUpsertBatch(
+            slot,
+            { ...params, rows: chunk2 },
+            timestamp
+          );
+          for (const statement of statements) {
+            await execRun(statement);
+          }
+        }
+      } catch (error) {
+        throw chunk456Z2U7Y_cjs.mapVectorWriteError(error, params);
+      }
+    },
+    async deleteEmbedding(params) {
+      const slot = chunk456Z2U7Y_cjs.vectorSlotFromParams(params);
+      await ensureVectorSlotStorage(slot);
+      const statements = vectorStrategy.buildDelete(slot, params);
+      for (const statement of statements) {
+        await execRun(statement);
+      }
+    },
+    async vectorSearch(params) {
+      chunkD7ZEOS56_cjs.assertVectorSearchLimit(params.limit);
+      chunkTCOCYN2P_cjs.assertPgvectorEfSearch(params.efSearch);
+      const slot = chunk456Z2U7Y_cjs.vectorSlotFromParams(params);
+      await ensureVectorSlotStorage(slot);
+      const query = vectorStrategy.buildSearch(
+        slot,
+        params,
+        // Store-compiled candidates (predicates + subclass + currency)
+        // take precedence; the live-node default covers direct backend use.
+        params.candidates ?? operationStrategy.buildLiveNodeIds(
+          params.graphId,
+          params.nodeKind
+        )
+      );
+      const gucOverrides = await vectorSearchGucOverrides(params);
+      let rows;
+      try {
+        rows = await runVectorSearch(gucOverrides, query);
+      } catch (error) {
+        throw chunk456Z2U7Y_cjs.mapVectorWriteError(error, params);
+      }
+      return rows.map((row) => ({
+        nodeId: row.node_id,
+        score: row.score
+      }));
+    },
+    // Single-statement hybrid needs ROW_NUMBER(); a capability
+    // profile that disables window functions keeps the store's
+    // multi-statement fallback by simply not exposing the member.
+    ...capabilities.windowFunctions ? {
+      async hybridSearch(params) {
+        chunkD7ZEOS56_cjs.assertVectorSearchLimit(params.limit);
+        chunkD7ZEOS56_cjs.assertVectorSearchLimit(params.vector.k);
+        chunkTCOCYN2P_cjs.assertPgvectorEfSearch(params.vector.efSearch);
+        const slot = chunk456Z2U7Y_cjs.vectorSlotFromParams({
+          graphId: params.graphId,
+          nodeKind: params.nodeKind,
+          fieldPath: params.vector.fieldPath,
+          dimensions: params.vector.dimensions,
+          metric: params.vector.metric,
+          indexType: params.vector.indexType
+        });
+        await ensureVectorSlotStorage(slot);
+        const candidates = params.candidates ?? operationStrategy.buildLiveNodeIds(
+          params.graphId,
+          params.nodeKind
+        );
+        const vectorParams = {
+          graphId: params.graphId,
+          nodeKind: params.nodeKind,
+          fieldPath: params.vector.fieldPath,
+          queryEmbedding: params.vector.queryEmbedding,
+          metric: params.vector.metric,
+          dimensions: params.vector.dimensions,
+          indexType: params.vector.indexType,
+          limit: params.vector.k,
+          ...params.vector.minScore === void 0 ? {} : { minScore: params.vector.minScore }
+        };
+        const vectorSql = vectorStrategy.buildSearch(
+          slot,
+          vectorParams,
+          chunk456Z2U7Y_cjs.hybridCandidatesRef()
+        );
+        const statement = operationStrategy.buildHybridSearch(
+          { ...params, candidates },
+          vectorSql,
+          params.vector.metric === "cosine"
+        );
+        const gucOverrides = await vectorSearchGucOverrides({
+          indexType: params.vector.indexType,
+          ...params.vector.efSearch === void 0 ? {} : { efSearch: params.vector.efSearch }
+        });
+        let raw;
+        try {
+          raw = await runVectorSearch(
+            gucOverrides,
+            statement
+          );
+        } catch (error) {
+          throw chunk456Z2U7Y_cjs.mapVectorWriteError(error, vectorParams);
+        }
+        return raw.map((row) => chunk456Z2U7Y_cjs.mapHybridSearchRow(row, toNodeRow));
+      }
+    } : {}
+  };
+  const operationBackend = {
+    ...commonBackend,
+    ...executeRawMethod,
+    ...vectorEmbeddingMethods,
+    capabilities,
+    fulltextStrategy,
+    ...vectorStrategy === void 0 ? {} : { vectorStrategy },
+    dialect: "postgres",
+    tableNames,
+    // === Vector Index Operations ===
+    async createVectorIndex(params) {
+      if (vectorStrategy === void 0) return;
+      const slot = chunk456Z2U7Y_cjs.vectorSlotFromCreateIndexParams(params);
+      await ensureVectorSlotStorage(slot);
+      const indexStatement = vectorStrategy.buildCreateIndex?.(slot, {
+        concurrent: params.concurrent === true
+      });
+      if (indexStatement !== void 0) {
+        try {
+          await execRun(indexStatement);
+        } catch (error) {
+          if (!chunkRSSQKPSZ_cjs.isInsufficientResourcesError(error)) throw error;
+          const dropStatement = vectorStrategy.buildDropIndex?.(slot);
+          if (dropStatement !== void 0) {
+            await execRun(dropStatement);
+          }
+          const table = chunk5W4L6DLF_cjs.quoteIdentifier(
+            vectorStrategy.tableName(
+              slot.graphId,
+              slot.nodeKind,
+              slot.fieldPath
+            )
+          );
+          await execRun(
+            drizzleOrm.sql`ALTER TABLE ${table} SET (parallel_workers = 0)`
+          );
+          try {
+            await execRun(indexStatement);
+          } finally {
+            await execRun(drizzleOrm.sql`ALTER TABLE ${table} RESET (parallel_workers)`);
+          }
+        }
+      }
+    },
+    // === Fulltext Operations ===
+    async upsertFulltext(params) {
+      const timestamp = chunk5W4L6DLF_cjs.nowIso();
+      const statements = operationStrategy.buildUpsertFulltext(
+        params,
+        timestamp
+      );
+      for (const stmt of statements) {
+        await execRun(stmt);
+      }
+    },
+    async deleteFulltext(params) {
+      const statements = operationStrategy.buildDeleteFulltext(params);
+      for (const stmt of statements) {
+        await execRun(stmt);
+      }
+    },
+    async upsertFulltextBatch(params) {
+      if (params.rows.length === 0) return;
+      const timestamp = chunk5W4L6DLF_cjs.nowIso();
+      for (const rows of chunkX4JBT642_cjs.chunk(
+        params.rows,
+        POSTGRES_FULLTEXT_UPSERT_BATCH_SIZE
+      )) {
+        const statements = operationStrategy.buildUpsertFulltextBatch(
+          { ...params, rows },
+          timestamp
+        );
+        for (const stmt of statements) {
+          await execRun(stmt);
+        }
+      }
+    },
+    async deleteFulltextBatch(params) {
+      if (params.nodeIds.length === 0) return;
+      for (const nodeIds of chunkX4JBT642_cjs.chunk(
+        params.nodeIds,
+        POSTGRES_FULLTEXT_DELETE_CHUNK_SIZE
+      )) {
+        const statements = operationStrategy.buildDeleteFulltextBatch({
+          ...params,
+          nodeIds
+        });
+        for (const stmt of statements) {
+          await execRun(stmt);
+        }
+      }
+    },
+    async fulltextSearch(params) {
+      const query = operationStrategy.buildFulltextSearch(params);
+      const rows = await execAll(query);
+      return rows.map((row, index) => ({
+        nodeId: row.node_id,
+        score: chunk5W4L6DLF_cjs.coerceNumericScore(row.score),
+        rank: index + 1,
+        ...row.snippet === null ? {} : { snippet: row.snippet }
+      }));
+    },
+    async dropVectorIndex(params) {
+      if (vectorStrategy === void 0) return;
+      const slot = chunk456Z2U7Y_cjs.vectorSlotFromDropIndexParams(params);
+      const dropStatement = vectorStrategy.buildDropIndex?.(slot);
+      if (dropStatement === void 0) return;
+      try {
+        await execRun(dropStatement);
+      } catch (error) {
+        if (!chunkRSSQKPSZ_cjs.isMissingTableError(error)) throw error;
+      }
+    },
+    // === Query Execution ===
+    async execute(query) {
+      const annTypes = chunkEOLERH7Y_cjs.annIndexScanTypes(query);
+      if (annTypes !== void 0 && vectorStrategy !== void 0) {
+        const overrides = [];
+        for (const indexType of annTypes) {
+          if (indexType !== "hnsw" && indexType !== "ivfflat") continue;
+          overrides.push(
+            ...await vectorSearchGucOverrides({ indexType })
+          );
+        }
+        return runVectorSearch(overrides, query);
+      }
+      return executionAdapter.execute(query);
+    },
+    compileSql(query) {
+      return executionAdapter.compile(query);
+    }
+  };
+  return operationBackend;
+}
+function createTransactionBackend(options) {
+  const txExecutionAdapter = createSerialExecutionAdapter(
+    createPostgresExecutionAdapter(options.db, options.adapterOptions)
+  );
+  const backend = createPostgresOperationBackend({
+    db: options.db,
+    executionAdapter: txExecutionAdapter,
+    adapterOptions: options.adapterOptions,
+    operationStrategy: options.operationStrategy,
+    tableNames: options.tableNames,
+    capabilities: options.capabilities,
+    fulltextStrategy: options.fulltextStrategy,
+    vectorStrategy: options.vectorStrategy,
+    vectorSlotLatch: options.vectorStrategy === void 0 ? void 0 : chunk456Z2U7Y_cjs.createVectorSlotLatch(),
+    // The probe is process-wide truth, so — unlike the slot latch — the outer
+    // instance's is reused rather than a fresh one per transaction.
+    iterativeScanProbe: options.iterativeScanProbe
+  });
+  return { backend, drainAndClose: txExecutionAdapter.drainAndClose };
+}
+
+exports.createPostgresBackend = createPostgresBackend;
+//# sourceMappingURL=chunk-ZAMFOJ5P.cjs.map
+//# sourceMappingURL=chunk-ZAMFOJ5P.cjs.map