@nicia-ai/typegraph 0.44.0 → 0.46.0

package/dist/{chunk-HOIFFY4M.js → chunk-5763DULU.js}

@@ -1,15 +1,14 @@
-import { createPostgresOperationStrategy, createCachedTableExistence, createContributionMaterializer, gateFulltextMethods, lockPostgresTrustedImportTables, assertTrustedImportDatabaseEmpty, suspendPostgresSecondaryIndexes, createPostgresTrustedImportSession, restoreSecondaryIndexes, analyzeImportedTables, createCommonOperationBackend, vectorSlotFromParams, buildLiveNodeCandidates, mapVectorWriteError, mapHybridSearchRow, mapContributionMaterializationRow, POSTGRES_CONTRIBUTION_MAT_TIMESTAMPS, buildContributionInsertValues, buildContributionOnConflictSet, tableExistsFromRow, assertAdoptedDialect, buildKindRemovalInsertValues, POSTGRES_KIND_REMOVAL_TIMESTAMPS, buildKindRemovalOnConflictSet, mapKindRemovalRow, buildMaterializationInsertValues, POSTGRES_INDEX_MAT_TIMESTAMPS, buildMaterializationOnConflictSet, mapMaterializationRow, vectorSlotFromDropIndexParams, vectorSlotFromCreateIndexParams, FIND_EDGES_ENDPOINT_FIXED_PARAM_COUNT, EMBEDDING_UPSERT_PARAM_COUNT, gateFulltext, getOrCreateLru, commitSchemaVersionIfKindsEmpty, assertActiveSchemaVersion } from './chunk-SQRD2CYF.js';
-import { pgvectorStrategy, assertPgvectorEfSearch } from './chunk-EFELJVLA.js';
-import { createNodeRowMapper, POSTGRES_ROW_MAPPER_CONFIG, createEdgeRowMapper, createUniqueRowMapper, createSchemaVersionRowMapper, nowIso, coerceNumericScore } from './chunk-PHXITZE4.js';
-import { tables, generatePgCreateTableSQL, generatePostgresDDL } from './chunk-7G32LIQM.js';
-import { toDrizzleSql, compileQueryWithDialect } from './chunk-GWEDD3DH.js';
-import { chunk } from './chunk-35S6P5ZU.js';
-import { POSTGRES_MAX_BIND_PARAMETERS, normalizeGraphAnalyticsCapabilities, createBackendOverlay, INTERNAL_TEMPORARY_WRITES, POSTGRES_CAPABILITIES } from './chunk-FMMIX6N4.js';
-import { isMissingTableError, isInsufficientResourcesError } from './chunk-B75XRV3O.js';
-import { tsvectorStrategy, assertVectorSearchLimit, buildFulltextCapabilities, buildVectorCapabilities } from './chunk-K3BUWSFR.js';
-import { sql, isSqlFragment, shouldForceCustomPlan, annIndexScanTypes } from './chunk-6DCB664D.js';
-import { requireDefined } from './chunk-QMQLUA66.js';
-import { ConfigurationError, CompilerInvariantError, TransactionClosedError } from './chunk-4MB3AQAQ.js';
+import { contributionRebuildSupported, createPostgresOperationStrategy, createCachedTableExistence, createContributionMaterializer, gateFulltextMethods, lockPostgresTrustedImportTables, assertTrustedImportDatabaseEmpty, suspendPostgresSecondaryIndexes, createPostgresTrustedImportSession, restoreSecondaryIndexes, analyzeImportedTables, createCommonOperationBackend, vectorSlotFromParams, buildLiveNodeCandidates, mapVectorWriteError, mapHybridSearchRow, mapContributionMaterializationRow, POSTGRES_CONTRIBUTION_MAT_TIMESTAMPS, buildContributionInsertValues, buildContributionOnConflictSet, tableExistsFromRow, assertAdoptedDialect, commitSchemaVersionIfKindsEmpty, buildKindRemovalInsertValues, POSTGRES_KIND_REMOVAL_TIMESTAMPS, buildKindRemovalOnConflictSet, mapKindRemovalRow, buildMaterializationInsertValues, POSTGRES_INDEX_MAT_TIMESTAMPS, buildMaterializationOnConflictSet, mapMaterializationRow, vectorSlotFromDropIndexParams, vectorSlotFromCreateIndexParams, assertActiveSchemaVersion, FIND_EDGES_ENDPOINT_FIXED_PARAM_COUNT, EMBEDDING_UPSERT_PARAM_COUNT, gateFulltext, getOrCreateLru } from './chunk-7VQXLT5O.js';
+import { pgvectorStrategy, assertPgvectorEfSearch } from './chunk-VGTJPTIC.js';
+import { createNodeRowMapper, POSTGRES_ROW_MAPPER_CONFIG, createEdgeRowMapper, createUniqueRowMapper, createSchemaVersionRowMapper, nowIso, coerceNumericScore } from './chunk-NMWDXFPH.js';
+import { tables, generatePostgresDDL, generatePgCreateTableSQL, createPostgresTables, postgresContributions } from './chunk-5UVRGXD3.js';
+import { toDrizzleSql, compileQueryWithDialect } from './chunk-UV3SN74I.js';
+import { isPostgresConcurrentDdlRaceError, chunk, isMissingTableError, isInsufficientResourcesError } from './chunk-JZUR7ZWE.js';
+import { POSTGRES_MAX_BIND_PARAMETERS, normalizeGraphAnalyticsCapabilities, createBackendOverlay, markSerializedTransactionResource, INTERNAL_TEMPORARY_WRITES, POSTGRES_CAPABILITIES } from './chunk-AKLS3BYZ.js';
+import { tsvectorStrategy, assertVectorSearchLimit, buildFulltextCapabilities, buildVectorCapabilities, resolveEfSearchOverride, vectorSearchFrontierTuning } from './chunk-YDFDBE6D.js';
+import { sql, isSqlFragment, shouldForceCustomPlan, annIndexScanTypes } from './chunk-PQBQG7IM.js';
+import { ConfigurationError, StaleVersionError, CompilerInvariantError, TransactionClosedError } from './chunk-J3WZ3FA2.js';
+import { requireDefined } from './chunk-DYATYRY4.js';
 import { getTableName, sql as sql$1, eq, and, isNull, inArray } from 'drizzle-orm';
 import { PgTransaction } from 'drizzle-orm/pg-core';
 
@@ -28,8 +27,12 @@ function isPgliteClient(candidate) {
   return typeof candidate === "object" && hasFunctionProperty(candidate, "query") && hasFunctionProperty(candidate, "dumpDataDir");
 }
 var PGLITE_MAX_BIND_PARAMETERS = 32767;
+function getPgliteClient(db) {
+  const client = db.$client;
+  return isPgliteClient(client) ? client : void 0;
+}
 function isPgliteDatabase(db) {
-  return isPgliteClient(db.$client);
+  return getPgliteClient(db) !== void 0;
 }
 function transactionSession(carrier) {
   return carrier.session ?? carrier._?.session;
@@ -291,6 +294,7 @@ var GET_EDGES_FIXED_PARAM_COUNT = 1;
 var FULLTEXT_UPSERT_PARAM_COUNT = 6;
 var FULLTEXT_DELETE_FIXED_PARAM_COUNT = 2;
 var CHECK_UNIQUE_BATCH_FIXED_PARAM_COUNT = 3;
+var UNIQUE_DELETE_FIXED_PARAM_COUNT = 2;
 var UNIQUE_INSERT_PARAM_COUNT = 6;
 function computePostgresBatchChunkSizes(maxBindParameters) {
   return {
@@ -330,12 +334,22 @@ function computePostgresBatchChunkSizes(maxBindParameters) {
       1,
       Math.floor(maxBindParameters / NODE_INSERT_PARAM_COUNT)
     ),
+    uniqueDeleteChunkSize: Math.max(
+      1,
+      maxBindParameters - UNIQUE_DELETE_FIXED_PARAM_COUNT
+    ),
     uniqueInsertBatchSize: Math.max(
       1,
       Math.floor(maxBindParameters / UNIQUE_INSERT_PARAM_COUNT)
     )
   };
 }
+var IDENTITY_TABLE_LOGICAL_NAMES = /* @__PURE__ */ new Set([
+  "identityAssertions",
+  "recordedIdentityAssertions",
+  "identityClosure",
+  "identitySeparation"
+]);
 var toNodeRow = createNodeRowMapper(POSTGRES_ROW_MAPPER_CONFIG);
 var toEdgeRow = createEdgeRowMapper(POSTGRES_ROW_MAPPER_CONFIG);
 var toUniqueRow = createUniqueRowMapper(POSTGRES_ROW_MAPPER_CONFIG);
@@ -350,6 +364,7 @@ function buildPostgresCapabilities(fulltextStrategy, vectorStrategy) {
   };
 }
 function createPostgresBackend(db, options = {}) {
+  const serializedClient = getSerializedPostgresClient(db);
   const tables2 = options.tables ?? tables;
   const fulltextStrategy = options.fulltext ?? tsvectorStrategy;
   const vectorStrategy = options.vector === false ? void 0 : options.vector ?? pgvectorStrategy;
@@ -372,12 +387,24 @@ function createPostgresBackend(db, options = {}) {
       PGLITE_MAX_BIND_PARAMETERS
     )
   } : {};
-  const capabilities = normalizeGraphAnalyticsCapabilities({
+  const declaredCapabilities = normalizeGraphAnalyticsCapabilities({
     ...baseCapabilities,
     ...httpOnlyOverrides,
     ...options.capabilities,
     ...driverBindParameterOverrides
   });
+  const capabilities = {
+    ...declaredCapabilities,
+    contributions: {
+      supported: true,
+      probe: true,
+      rebuild: contributionRebuildSupported(
+        fulltextStrategy,
+        tables2.fulltextTableName,
+        declaredCapabilities.transactions
+      )
+    }
+  };
   const adapterOptions = {
     ...options.prepareStatements === void 0 ? {} : { prepareStatements: options.prepareStatements },
     ...options.preparedStatementCacheMax === void 0 ? {} : { preparedStatementCacheMax: options.preparedStatementCacheMax },
@@ -391,6 +418,10 @@ function createPostgresBackend(db, options = {}) {
     recordedEdges: getTableName(tables2.recordedEdges),
     recordedClock: getTableName(tables2.recordedClock),
     revisionOrigins: getTableName(tables2.revisionOrigins),
+    identityAssertions: getTableName(tables2.identityAssertions),
+    recordedIdentityAssertions: getTableName(tables2.recordedIdentityAssertions),
+    identityClosure: getTableName(tables2.identityClosure),
+    identitySeparation: getTableName(tables2.identitySeparation),
     fulltext: tables2.fulltextTableName,
     uniques: getTableName(tables2.uniques)
   };
@@ -405,16 +436,20 @@ function createPostgresBackend(db, options = {}) {
       "postgres"
     )
   );
-  const recordedAnalyzeTables = [
+  const guardedAnalyzeTables = [
     tableNames.recordedNodes,
     tableNames.recordedEdges,
-    tableNames.recordedClock
+    tableNames.recordedClock,
+    tableNames.recordedIdentityAssertions,
+    tableNames.identityAssertions,
+    tableNames.identityClosure,
+    tableNames.identitySeparation
   ];
   const operationStrategy = createPostgresOperationStrategy(
     tables2,
     fulltextStrategy
   );
-  const recordedTableExists = createCachedTableExistence(
+  const guardedTableExists = createCachedTableExistence(
     async (tableName) => {
       const rows = await executionAdapter.execute(
         operationStrategy.buildTableExists(tableName)
@@ -424,8 +459,31 @@ function createPostgresBackend(db, options = {}) {
     { cacheExisting: false }
   );
   const matTable = tables2.contributionMaterializations;
+  async function executeConcurrentCreateDdl(ddl) {
+    const statement = sql$1.raw(ddl);
+    try {
+      await db.execute(statement);
+    } catch (error) {
+      if (!isPostgresConcurrentDdlRaceError(error)) throw error;
+      await db.execute(statement);
+    }
+  }
+  async function ensureTableWithConcurrentCreateRetry(table) {
+    await executeConcurrentCreateDdl(generatePgCreateTableSQL(table));
+  }
   async function ensureContributionMaterializationsTableImpl() {
-    await db.execute(sql$1.raw(generatePgCreateTableSQL(matTable)));
+    await ensureTableWithConcurrentCreateRetry(matTable);
+  }
+  function identityContributionsFor(identityTableNames) {
+    const identityTables = createPostgresTables({
+      identityAssertions: identityTableNames.identityAssertions,
+      recordedIdentityAssertions: identityTableNames.recordedIdentityAssertions,
+      identityClosure: identityTableNames.identityClosure,
+      identitySeparation: identityTableNames.identitySeparation
+    });
+    return postgresContributions(identityTables, fulltextStrategy).filter(
+      (contribution) => IDENTITY_TABLE_LOGICAL_NAMES.has(contribution.logicalName)
+    );
   }
   async function getContributionMaterializationRow(identity) {
     const rows = await db.select().from(matTable).where(
@@ -492,14 +550,25 @@ function createPostgresBackend(db, options = {}) {
     fulltextStrategy,
     fulltextTableName: tables2.fulltextTableName,
     vectorStrategy,
+    // Contribution DDL is `CREATE ... IF NOT EXISTS` reached from every
+    // booting replica, so it carries the same concurrent-create retry the
+    // other create sites use. Without it the loser's 23505 is recorded as
+    // `lastError` on the marker row and reported as a failed materialization,
+    // when the table it wanted is in fact present.
     execDdl: async (statement) => {
-      await db.execute(sql$1.raw(statement));
+      await executeConcurrentCreateDdl(statement);
     },
     ensureMarkerTable: ensureContributionMaterializationsTableImpl,
     getMarkers: getContributionMaterializationRows,
     recordMarker: recordContributionMaterializationRow,
     deleteMarker: deleteContributionMaterializationRow,
-    tableExists: contributionTableExists
+    tableExists: contributionTableExists,
+    // Withheld rather than wired-and-throwing when the driver cannot hold
+    // a session: the rebuild must refuse with its own typed error naming
+    // the absent fence, matching `capabilities.contributions.rebuild`.
+    ...capabilities.transactions ? {
+      schemaWriteTransaction: (graphId, fn) => runSchemaWriteTransaction(graphId, (target) => fn(target))
+    } : {}
   });
   const operations = createPostgresOperationBackend({
     db,
@@ -619,12 +688,32 @@ function createPostgresBackend(db, options = {}) {
     async bootstrapTables() {
       const statements = generatePostgresDDL(tables2, fulltextStrategy);
       for (const statement of statements) {
-        await db.execute(sql$1.raw(statement));
+        await executeConcurrentCreateDdl(statement);
       }
     },
     async ensureRevisionOriginsTable() {
-      await db.execute(
-        sql$1.raw(generatePgCreateTableSQL(tables2.revisionOrigins))
+      await ensureTableWithConcurrentCreateRetry(tables2.revisionOrigins);
+    },
+    async ensureIdentityTables(identityTableNames, options2) {
+      const identityContributions = identityContributionsFor(identityTableNames);
+      const missing = [];
+      for (const contribution of identityContributions) {
+        if (!await contributionTableExists(contribution.tableName)) {
+          missing.push(contribution.logicalName);
+        }
+      }
+      if (missing.length === 0 || options2.provisionMissing) {
+        for (const contribution of identityContributions) {
+          for (const ddl of contribution.createDdl) {
+            await executeConcurrentCreateDdl(ddl);
+          }
+        }
+      }
+      return missing;
+    },
+    identityTableDdl(identityTableNames) {
+      return identityContributionsFor(identityTableNames).flatMap(
+        (contribution) => [...contribution.createDdl]
       );
     },
     // Every fulltext-touching method asserts the durable marker instead
@@ -640,19 +729,13 @@ function createPostgresBackend(db, options = {}) {
       await db.execute(sql$1.raw(ddl));
     },
     async ensureIndexMaterializationsTable() {
-      await db.execute(
-        sql$1.raw(generatePgCreateTableSQL(tables2.indexMaterializations))
-      );
+      await ensureTableWithConcurrentCreateRetry(tables2.indexMaterializations);
       const tableName = getTableName(tables2.indexMaterializations);
-      await db.execute(
-        sql$1.raw(
-          `ALTER TABLE "${tableName}" ADD COLUMN IF NOT EXISTS "building_since" timestamptz;`
-        )
+      await executeConcurrentCreateDdl(
+        `ALTER TABLE "${tableName}" ADD COLUMN IF NOT EXISTS "building_since" timestamptz;`
       );
-      await db.execute(
-        sql$1.raw(
-          `ALTER TABLE "${tableName}" ADD COLUMN IF NOT EXISTS "claim_token" text;`
-        )
+      await executeConcurrentCreateDdl(
+        `ALTER TABLE "${tableName}" ADD COLUMN IF NOT EXISTS "claim_token" text;`
       );
     },
     async claimIndexMaterialization(params) {
@@ -728,7 +811,7 @@ function createPostgresBackend(db, options = {}) {
       await contributionMaterializer.assertInitialized(graphId);
     },
     async ensureKindRemovalsTable() {
-      await db.execute(sql$1.raw(generatePgCreateTableSQL(tables2.kindRemovals)));
+      await ensureTableWithConcurrentCreateRetry(tables2.kindRemovals);
     },
     async getPendingKindRemovals(graphId) {
       const t = tables2.kindRemovals;
@@ -757,9 +840,7 @@ function createPostgresBackend(db, options = {}) {
       });
     },
     async ensureReconciliationMarkersTable() {
-      await db.execute(
-        sql$1.raw(generatePgCreateTableSQL(tables2.reconciliationMarkers))
-      );
+      await ensureTableWithConcurrentCreateRetry(tables2.reconciliationMarkers);
     },
     async ensureRuntimeContributions(graphId) {
       await contributionMaterializer.ensureRuntimeContributions(graphId);
@@ -775,6 +856,19 @@ function createPostgresBackend(db, options = {}) {
     async verifyContributions(graphId, vectorSlots) {
       return contributionMaterializer.verifyContributions(graphId, vectorSlots);
     },
+    async repairContributions(graphId, vectorSlots) {
+      return contributionMaterializer.repairContributions(graphId, vectorSlots);
+    },
+    async probeContributions(graphId, vectorSlots) {
+      return contributionMaterializer.probeContributions(graphId, vectorSlots);
+    },
+    async rebuildContribution(graphId, scope, repopulate) {
+      return contributionMaterializer.rebuildContribution(
+        graphId,
+        scope,
+        repopulate
+      );
+    },
     // Vector counterparts of the runtime-contribution methods. Present
     // only when a vector strategy is wired (omitted under `vector: false`,
     // mirroring the embedding/search methods), so a no-vector backend
@@ -813,13 +907,13 @@ function createPostgresBackend(db, options = {}) {
         await db.execute(statement);
       }
       const tablePresence = await Promise.all(
-        recordedAnalyzeTables.map(async (tableName) => ({
+        guardedAnalyzeTables.map(async (tableName) => ({
           tableName,
-          exists: await recordedTableExists(tableName)
+          exists: await guardedTableExists(tableName)
         }))
       );
-      const presentRecordedTables = tablePresence.filter((entry) => entry.exists).map((entry) => entry.tableName);
-      for (const tableName of presentRecordedTables) {
+      const presentGuardedTables = tablePresence.filter((entry) => entry.exists).map((entry) => entry.tableName);
+      for (const tableName of presentGuardedTables) {
         await db.execute(
           toDrizzleSql(
             sql`ANALYZE (SKIP_LOCKED) ${sql.identifier(tableName)}`,
@@ -840,6 +934,12 @@ function createPostgresBackend(db, options = {}) {
         (target) => commitSchemaVersionIfKindsEmpty(target, params, probes)
       );
     },
+    async commitSchemaVersionWithPreflight(params, preflight) {
+      return runSchemaWriteTransaction(params.graphId, async (target) => {
+        await preflight(target);
+        return target.commitSchemaVersion(params);
+      });
+    },
     async setActiveVersion(params) {
       await runSchemaWriteTransaction(
         params.graphId,
@@ -898,8 +998,42 @@ function createPostgresBackend(db, options = {}) {
     async close() {
     }
   };
+  if (serializedClient !== void 0) {
+    markSerializedTransactionResource(backend, serializedClient);
+  }
   return backend;
 }
+function getSerializedPostgresClient(db) {
+  const pgliteClient = getPgliteClient(db);
+  if (pgliteClient !== void 0) return pgliteClient;
+  const client = db.$client;
+  if (typeof client === "function") {
+    return isSingleConnectionCallablePgClient(client) ? client : void 0;
+  }
+  if (typeof client !== "object" || client === null) return void 0;
+  const candidate = client;
+  if (!hasFunctionProperty(candidate, "query")) return void 0;
+  if (isSingleConnectionPgPool(candidate)) return client;
+  return isBarePgClient(candidate) ? client : void 0;
+}
+function isSingleConnectionPgPool(candidate) {
+  const options = candidate["options"];
+  if (typeof options !== "object" || options === null) return false;
+  return options["max"] === 1;
+}
+function isSingleConnectionCallablePgClient(client) {
+  if (client === void 0 || client === null) return false;
+  const options = client["options"];
+  if (!isPostgresJsClient(client)) return false;
+  if (typeof options !== "object" || options === null) return false;
+  return options["max"] === 1;
+}
+function isBarePgClient(candidate) {
+  if (candidate["options"] !== void 0 || candidate["totalCount"] !== void 0 || candidate["idleCount"] !== void 0 || candidate["waitingCount"] !== void 0) {
+    return false;
+  }
+  return hasFunctionProperty(candidate, "connect") && hasFunctionProperty(candidate, "end") && hasFunctionProperty(candidate, "escapeIdentifier");
+}
 function createIterativeScanProbe() {
   let probe;
   let warned = false;
@@ -958,31 +1092,24 @@ function createPostgresOperationBackend(options) {
   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();
-      }
+    const efSearchParameter = resolveEfSearchOverride({
+      efSearch: params.efSearch,
+      indexType: params.indexType,
+      tuning: vectorSearchFrontierTuning(vectorStrategy),
+      transactions: capabilities.transactions,
+      dialect: "PostgreSQL",
+      engine: vectorStrategy?.name ?? "this backend"
+    });
+    if (efSearchParameter !== void 0) {
+      overrides.push({
+        name: efSearchParameter,
+        value: String(params.efSearch)
+      });
     }
     if (params.indexType === "hnsw" && capabilities.transactions && await pgvectorIterativeScanSupported()) {
       overrides.push({ name: "hnsw.iterative_scan", value: "strict_order" });
@@ -1052,6 +1179,7 @@ function createPostgresOperationBackend(options) {
       execRun
     },
     nowIso,
+    maxBindParameters: capabilities.maxBindParameters ?? POSTGRES_MAX_BIND_PARAMETERS,
     operationStrategy,
     rowMappers: {
       toEdgeRow,
@@ -1130,6 +1258,21 @@ function createPostgresOperationBackend(options) {
         await execRun(statement);
       }
     },
+    async deleteEmbeddingBatch(params) {
+      if (params.nodeIds.length === 0) return;
+      const slot = vectorSlotFromParams(params);
+      await contributionMaterializer.assertVectorSlot(slot);
+      for (const nodeIds of chunk(
+        [...new Set(params.nodeIds)],
+        batchConfig.embeddingUpsertBatchSize
+      )) {
+        const statements = vectorStrategy.buildDeleteBatch(slot, {
+          ...params,
+          nodeIds
+        });
+        for (const statement of statements) await execRun(statement);
+      }
+    },
     async vectorSearch(params) {
       assertVectorSearchLimit(params.limit);
       assertPgvectorEfSearch(params.efSearch);
@@ -1218,10 +1361,36 @@ function createPostgresOperationBackend(options) {
       }
     } : {}
   };
+  async function lockActiveSchemaVersion(graphId) {
+    const active = await execGet(sql$1`
+      SELECT ${schemaVersionsTable.version} AS version
+      FROM ${schemaVersionsTable}
+      WHERE ${schemaVersionsTable.graphId} = ${graphId}
+        AND ${schemaVersionsTable.isActive} = TRUE
+      FOR SHARE
+    `);
+    return active?.version;
+  }
   const operationBackend = {
     ...commonBackend,
     ...executeRawMethod,
     ...vectorEmbeddingMethods,
+    /**
+     * Transaction-scoped contribution marker stamp. Present so the
+     * destructive rebuild can commit its marker with the DDL that
+     * produced it; without it the stamp would land outside the
+     * transaction and could survive a rolled-back drop.
+     *
+     * States the row outright rather than reusing the top-level upsert,
+     * whose `materialized_at` COALESCE preserves an earlier success so a
+     * failed re-attempt cannot erase it. A completed rebuild replaced the
+     * storage, so the recorded timestamp must be the rebuild's.
+     */
+    async recordContributionMaterialization(params) {
+      await execRun(
+        operationStrategy.buildInsertContributionMaterialization(params)
+      );
+    },
     async deleteSchemaVectorSlotContribution(slot) {
       if (vectorStrategy === void 0) return;
       for (const contribution of vectorStrategy.ownedTables(slot)) {
@@ -1251,18 +1420,21 @@ function createPostgresOperationBackend(options) {
           }
         );
       }
-      const active = await execGet(sql$1`
-        SELECT ${schemaVersionsTable.version} AS version
-        FROM ${schemaVersionsTable}
-        WHERE ${schemaVersionsTable.graphId} = ${params.graphId}
-          AND ${schemaVersionsTable.isActive} = TRUE
-        FOR SHARE
-      `);
-      assertActiveSchemaVersion(
-        params.graphId,
-        params.expectedVersion,
-        active?.version ?? 0
-      );
+      const locked = await lockActiveSchemaVersion(params.graphId);
+      if (locked !== void 0) {
+        assertActiveSchemaVersion(
+          params.graphId,
+          params.expectedVersion,
+          locked
+        );
+        return;
+      }
+      const settled = await commonBackend.getActiveSchema(params.graphId);
+      throw new StaleVersionError({
+        graphId: params.graphId,
+        expected: params.expectedVersion,
+        actual: settled?.version ?? 0
+      });
     },
     // === Vector Index Operations ===
     async createVectorIndex(params) {
@@ -1413,5 +1585,5 @@ function createTransactionBackend(options) {
 }
 
 export { createPostgresBackend };
-//# sourceMappingURL=chunk-HOIFFY4M.js.map
-//# sourceMappingURL=chunk-HOIFFY4M.js.map
+//# sourceMappingURL=chunk-5763DULU.js.map
+//# sourceMappingURL=chunk-5763DULU.js.map