@sixb/pg 0.1.9 → 0.1.10

package/dist/index.js

@@ -3448,7 +3448,7 @@ class PgConnectorConnectionPersistence {
         ) VALUES (
           ${record.projectId}, ${record.connectorId}, ${record.id}, ${record.slot},
           ${record.initiatedByExecutionId}, ${record.stateHash},
-          ${jsonParameter(this.sql, record.codeVerifier)}, ${record.redirectUri},
+          ${record.codeVerifier === undefined ? null : jsonParameter(this.sql, record.codeVerifier)}, ${record.redirectUri},
           ${record.connectionRunId ?? null}, ${record.returnTo ?? null},
           ${record.callbackBindingHash ?? null}, ${record.reauthorizationId ?? null},
           ${record.reauthorizationRevision ?? null},
@@ -3741,7 +3741,7 @@ function authorizationAttemptFromRow(row) {
     slot: row.slot,
     initiatedByExecutionId: row.initiated_by_execution_id,
     stateHash: row.state_hash,
-    codeVerifier: row.code_verifier,
+    ...row.code_verifier === null ? {} : { codeVerifier: row.code_verifier },
     redirectUri: row.redirect_uri,
     ...row.connection_run_id === null ? {} : { connectionRunId: row.connection_run_id },
     ...row.return_to === null ? {} : { returnTo: row.return_to },
@@ -7081,6 +7081,55 @@ ALTER TABLE executions
     ON DELETE RESTRICT;
 `;
 
+// src/migrations/039-projection-source-roots.sql
+var _039_projection_source_roots_default = `ALTER TABLE ontology_sources ADD COLUMN base_materialization_id TEXT;
+ALTER TABLE ontology_sources ADD COLUMN base_commit_id TEXT;
+ALTER TABLE ontology_sources ADD CHECK ((base_materialization_id IS NULL) = (base_commit_id IS NULL));
+
+-- A root selects one complete set of assertions. Unchanged roots keep their original version;
+-- activation only retires/replaces affected references, under the source commit fence.
+CREATE TABLE ontology_source_roots (
+  project_id TEXT NOT NULL,
+  source_id TEXT NOT NULL,
+  materialization_id TEXT NOT NULL,
+  root_sort_key TEXT NOT NULL,
+  root_kind TEXT NOT NULL CHECK (root_kind IN ('object', 'link')),
+  root_key JSONB NOT NULL,
+  root JSONB NOT NULL,
+  staging_ordinal BIGINT NOT NULL CHECK (staging_ordinal >= 0),
+  deleted BOOLEAN NOT NULL DEFAULT FALSE,
+  active BOOLEAN NOT NULL DEFAULT FALSE,
+  retired_at TIMESTAMPTZ,
+  PRIMARY KEY (project_id, source_id, materialization_id, root_sort_key),
+  UNIQUE (project_id, source_id, materialization_id, staging_ordinal),
+  FOREIGN KEY (project_id, source_id, materialization_id)
+    REFERENCES ontology_sources(project_id, source_id, materialization_id) ON DELETE RESTRICT,
+  CHECK (NOT active OR (NOT deleted AND retired_at IS NULL))
+);
+CREATE UNIQUE INDEX idx_ontology_source_roots_active
+  ON ontology_source_roots (project_id, source_id, root_sort_key) WHERE active;
+CREATE INDEX idx_ontology_source_roots_lookup
+  ON ontology_source_roots (project_id, root_sort_key, source_id) WHERE active;
+CREATE INDEX idx_ontology_source_roots_cleanup
+  ON ontology_source_roots (project_id, retired_at, source_id, materialization_id, root_sort_key)
+  WHERE NOT active AND retired_at IS NOT NULL;
+
+INSERT INTO ontology_source_roots (
+  project_id, source_id, materialization_id, root_sort_key, root_kind, root_key, root,
+  staging_ordinal, active, retired_at
+)
+SELECT DISTINCT rows.project_id, rows.source_id, rows.materialization_id,
+  rows.root_sort_key, rows.root_kind, rows.root_key, rows.root, rows.staging_ordinal,
+  sources.status = 'active', sources.terminal_at
+FROM ontology_source_rows AS rows
+JOIN ontology_sources AS sources USING (project_id, source_id, materialization_id);
+
+ANALYZE ontology_source_roots;
+
+ALTER TABLE projection_runs ADD COLUMN source_changes_read BIGINT
+  CHECK (source_changes_read IS NULL OR source_changes_read >= 0);
+`;
+
 // src/migrations/037-execution-requester-groups.sql
 var _037_execution_requester_groups_default = `ALTER TABLE executions ADD COLUMN requester_group_ids JSONB NOT NULL DEFAULT '[]'::jsonb;
 
@@ -7105,6 +7154,20 @@ ALTER TABLE workflow_runs DROP COLUMN requester_group_ids;
 ALTER TABLE agent_runs DROP COLUMN requester_group_ids;
 `;
 
+// src/migrations/038-outbox-publication-order.sql
+var _038_outbox_publication_order_default = `-- Preserve the claim order without sorting every pending event for each batch.
+-- Keep the availability index for selective delayed/leased workloads.
+CREATE INDEX idx_ontology_outbox_publication_order
+  ON ontology_outbox (project_id, created_at, commit_id, commit_ordinal)
+  WHERE published_at IS NULL;
+`;
+
+// src/migrations/040-connector-optional-pkce.sql
+var _040_connector_optional_pkce_default = `-- Existing attempts retain their encrypted S256 verifier. NULL denotes disabled PKCE.
+ALTER TABLE connector_authorization_attempts
+  ALTER COLUMN code_verifier DROP NOT NULL;
+`;
+
 // src/migrations.ts
 var POSTGRES_STORAGE_ADAPTER_ID = "SixbPostgresStorage";
 function pgSql(id, sqlText) {
@@ -7316,7 +7379,10 @@ var postgresStorageMigrations = defineMigrations({
     pgSql("034-device-authorizations", _034_device_authorizations_default),
     pgSql("035-share-grants", _035_share_grants_default),
     pgSql("036-share-sessions", _036_share_sessions_default),
-    pgSql("037-execution-requester-groups", _037_execution_requester_groups_default)
+    pgSql("037-execution-requester-groups", _037_execution_requester_groups_default),
+    pgSql("038-outbox-publication-order", _038_outbox_publication_order_default),
+    pgSql("039-projection-source-roots", _039_projection_source_roots_default),
+    pgSql("040-connector-optional-pkce", _040_connector_optional_pkce_default)
   ]
 });
 
@@ -9515,6 +9581,12 @@ function sourceRecord(row) {
     projectionRevision: row.projection_revision,
     ownershipHash: row.ownership_hash,
     ontologyRevision: row.ontology_revision,
+    ...row.base_materialization_id === null ? {} : {
+      base: {
+        materializationId: row.base_materialization_id,
+        lastCommitId: row.base_commit_id
+      }
+    },
     rootCount: row.root_count === null ? null : databaseSafeInteger(row.root_count, "Source root count"),
     assertionCount: row.assertion_count === null ? null : databaseSafeInteger(row.assertion_count, "Source assertion count"),
     createdAt: toIsoString2(row.created_at),
@@ -9683,7 +9755,7 @@ import {
   linkRefKey as linkRefKey3,
   linkRefSortKey,
   linkScopeSortKey as linkScopeSortKey2,
-  MaterializationConflictError as MaterializationConflictError5,
+  MaterializationConflictError as MaterializationConflictError6,
   objectRefKey as objectRefKey3,
   objectRefSortKey,
   telemetryPointKey as telemetryPointKey3,
@@ -9702,7 +9774,7 @@ import {
 } from "@sixb/core/internal/ontology-storage-provider";
 
 // src/ontology-storage/materialization-session.ts
-import { MaterializationConflictError as MaterializationConflictError3 } from "@sixb/core/internal/materialization";
+import { MaterializationConflictError as MaterializationConflictError4 } from "@sixb/core/internal/materialization";
 import {
   correlateMaterializationChunk,
   duplicateMaterializationWork as duplicateWork,
@@ -9716,9 +9788,9 @@ import {
 import {
   linkRefKey,
   linkScopeSortKey,
-  MaterializationConflictError as MaterializationConflictError2,
+  MaterializationConflictError as MaterializationConflictError3,
   objectRefKey,
-  projectionEntityKey,
+  projectionEntityKey as projectionEntityKey2,
   telemetryPointKey,
   telemetryPointSortKey
 } from "@sixb/core/internal/materialization";
@@ -9728,6 +9800,178 @@ import {
   linkSlotOverrideValue,
   startScopeAccumulator
 } from "@sixb/core/internal/ontology-storage-provider";
+
+// src/ontology-storage/source-roots.ts
+import {
+  MaterializationConflictError as MaterializationConflictError2,
+  MaterializationValidationError,
+  projectionEntityKey
+} from "@sixb/core/internal/materialization";
+import { sourceStageRoots, utf8SortKey } from "@sixb/core/internal/ontology-storage-provider";
+function replacementSourceRows(sql, input) {
+  const roots = input.incremental ? sql`
+    SELECT roots.* FROM ontology_source_roots AS changed
+    CROSS JOIN LATERAL (
+      SELECT roots.* FROM ontology_source_roots AS roots
+      WHERE roots.project_id = changed.project_id AND roots.source_id = changed.source_id
+        AND roots.root_sort_key = changed.root_sort_key AND roots.active OFFSET 0
+    ) AS roots
+    WHERE changed.project_id = ${input.projectId} AND changed.source_id = ${input.sourceId}
+      AND changed.materialization_id = ${input.materializationId}
+  ` : sql`SELECT * FROM ontology_source_roots WHERE project_id = ${input.projectId} AND source_id = ${input.sourceId} AND active`;
+  return sql`
+    SELECT * FROM ontology_source_rows WHERE project_id = ${input.projectId}
+      AND source_id = ${input.sourceId} AND materialization_id = ${input.materializationId}
+    UNION ALL
+    SELECT rows.* FROM (${roots}) AS roots
+    CROSS JOIN LATERAL (
+      SELECT rows.* FROM ontology_source_rows AS rows WHERE rows.project_id = roots.project_id
+        AND rows.source_id = roots.source_id AND rows.materialization_id = roots.materialization_id
+        AND rows.root_sort_key = roots.root_sort_key OFFSET 0
+    ) AS rows
+  `;
+}
+async function stageSourceRoots(sql, manifest, input) {
+  const roots = sourceStageRoots(manifest.projection_kind, input);
+  if (roots.length === 0)
+    return;
+  if (!manifest.base_materialization_id && roots.some((root) => root.deleted)) {
+    throw new MaterializationValidationError("Root deletions require a source delta base.");
+  }
+  const values = jsonParameter2(sql, roots.map((root) => ({
+    root_sort_key: root.sortKey,
+    root_kind: root.root.kind,
+    root_key: JSON.parse(root.rootKey),
+    root: root.root,
+    staging_ordinal: root.stagingOrdinal,
+    deleted: root.deleted
+  })));
+  const inserted = await sql`
+    INSERT INTO ontology_source_roots (
+      project_id, source_id, materialization_id, root_sort_key, root_kind, root_key, root, staging_ordinal, deleted
+    ) SELECT ${input.projectId}, ${input.source.projectionId}, ${input.materializationId},
+      root_sort_key, root_kind, root_key, root, staging_ordinal, deleted
+    FROM jsonb_to_recordset(${values}) AS input(
+      root_sort_key TEXT, root_kind TEXT, root_key JSONB, root JSONB, staging_ordinal BIGINT, deleted BOOLEAN)
+    ON CONFLICT DO NOTHING RETURNING root_sort_key
+  `;
+  if (inserted.length === roots.length)
+    return;
+  const insertedKeys = new Set(inserted.map((row) => row.root_sort_key));
+  const skipped = roots.filter((root) => !insertedKeys.has(root.sortKey));
+  const stored = await sql`
+    SELECT root_sort_key, staging_ordinal, deleted FROM ontology_source_roots
+    WHERE project_id = ${input.projectId} AND source_id = ${input.source.projectionId}
+      AND materialization_id = ${input.materializationId}
+      AND root_sort_key = ANY(${sql.array(skipped.map((root) => root.sortKey))}::text[])
+  `;
+  const existing = new Map(stored.map((root) => [root.root_sort_key, root]));
+  if (skipped.some((root) => {
+    const previous = existing.get(root.sortKey);
+    return !previous || Number(previous.staging_ordinal) !== root.stagingOrdinal || previous.deleted !== root.deleted;
+  }))
+    throw new MaterializationValidationError("Source materialization repeats root or stream ordinal with different content.");
+}
+async function activateSourceRoots(sql, projectId, candidate, activation) {
+  if (candidate.base_materialization_id !== null && (candidate.base_materialization_id !== activation.expected.activeMaterializationId || candidate.base_commit_id !== activation.expected.lastCommitId))
+    throw new MaterializationConflictError2("projection-fence", "Source delta base changed before activation.");
+  if (candidate.base_materialization_id !== null && Number(candidate.root_count) === 0)
+    return;
+  const affected = candidate.base_materialization_id === null ? sql`` : sql`AND root_sort_key IN (
+    SELECT root_sort_key FROM ontology_source_roots
+    WHERE project_id = ${projectId} AND source_id = ${activation.source.projectionId}
+      AND materialization_id = ${activation.materializationId}
+  )`;
+  await sql`
+    UPDATE ontology_source_roots AS roots SET active = FALSE, retired_at = ${activation.updatedAt}
+    WHERE project_id = ${projectId} AND source_id = ${activation.source.projectionId} AND active
+    ${affected}
+  `;
+  await sql`
+    UPDATE ontology_source_roots SET active = NOT deleted,
+      retired_at = CASE WHEN deleted THEN ${activation.updatedAt}::timestamptz ELSE NULL END
+    WHERE project_id = ${projectId} AND source_id = ${activation.source.projectionId}
+      AND materialization_id = ${activation.materializationId}
+  `;
+}
+async function assertSourceRootCoverage(sql, manifest) {
+  const [invalid] = await sql`
+    SELECT 1 FROM ontology_source_roots AS roots
+    WHERE project_id = ${manifest.project_id} AND source_id = ${manifest.source_id}
+      AND materialization_id = ${manifest.materialization_id}
+      AND roots.deleted = EXISTS (
+        SELECT 1 FROM ontology_source_rows AS rows
+        WHERE rows.project_id = roots.project_id AND rows.source_id = roots.source_id
+          AND rows.materialization_id = roots.materialization_id AND rows.root_sort_key = roots.root_sort_key
+      ) LIMIT 1
+  `;
+  if (invalid)
+    throw new MaterializationValidationError("Source roots must have complete assertions or an explicit deletion, never both.");
+}
+function activeSourceRows(sql, projectId, refs) {
+  const keys = refs.flatMap((entity) => {
+    const entitySortKey = utf8SortKey(projectionEntityKey(entity));
+    const roots = entity.kind === "object" ? [entitySortKey] : [
+      entitySortKey,
+      utf8SortKey(projectionEntityKey({ kind: "object", ref: entity.ref.source }))
+    ];
+    return roots.map((rootSortKey) => ({
+      root_sort_key: rootSortKey,
+      entity_sort_key: entitySortKey
+    }));
+  });
+  return sql`
+    SELECT rows.* FROM jsonb_to_recordset(${jsonParameter2(sql, keys)}) AS requested(root_sort_key TEXT, entity_sort_key TEXT)
+    JOIN ontology_source_roots AS roots ON roots.project_id = ${projectId}
+      AND roots.active AND roots.root_sort_key = requested.root_sort_key
+    JOIN ontology_source_rows AS rows ON rows.project_id = roots.project_id AND rows.source_id = roots.source_id
+      AND rows.materialization_id = roots.materialization_id AND rows.entity_sort_key = requested.entity_sort_key
+      AND rows.root_sort_key = roots.root_sort_key
+  `;
+}
+function replacementAssertionRows(sql, input) {
+  const keys = input.refs.map((ref) => ({
+    entity_kind: ref.kind,
+    entity_key: JSON.parse(projectionEntityKey(ref)),
+    root_keys: ref.kind === "object" ? [utf8SortKey(projectionEntityKey(ref))] : [
+      utf8SortKey(projectionEntityKey(ref)),
+      utf8SortKey(projectionEntityKey({ kind: "object", ref: ref.ref.source }))
+    ]
+  }));
+  const previous = !input.includePrevious ? sql`` : sql`UNION ALL
+    SELECT rows.* FROM (
+      SELECT roots.* FROM ontology_source_roots AS roots
+    WHERE roots.project_id = ${input.projectId} AND roots.source_id = ${input.sourceId}
+      AND roots.active AND roots.root_sort_key = ANY(requested.root_keys)
+      ${!input.incremental ? sql`` : sql`AND EXISTS (SELECT 1 FROM ontology_source_roots AS changed
+        WHERE changed.project_id = roots.project_id AND changed.source_id = roots.source_id
+          AND changed.materialization_id = ${input.materializationId} AND changed.root_sort_key = roots.root_sort_key)`}
+
+      OFFSET 0
+    ) AS roots
+    CROSS JOIN LATERAL (
+      SELECT rows.* FROM ontology_source_rows AS rows
+      WHERE rows.project_id = roots.project_id AND rows.source_id = roots.source_id
+        AND rows.materialization_id = roots.materialization_id AND rows.root_sort_key = roots.root_sort_key
+        AND rows.entity_kind = requested.entity_kind AND rows.entity_key = requested.entity_key
+      OFFSET 0
+    ) AS rows
+  `;
+  return sql`
+    SELECT selected.* FROM jsonb_to_recordset(${jsonParameter2(sql, keys)})
+      AS requested(entity_kind TEXT, entity_key JSONB, root_keys TEXT[])
+    CROSS JOIN LATERAL (
+      SELECT rows.* FROM ontology_source_rows AS rows
+      WHERE rows.project_id = ${input.projectId} AND rows.source_id = ${input.sourceId}
+        AND rows.materialization_id = ${input.materializationId}
+        AND rows.entity_kind = requested.entity_kind AND rows.entity_key = requested.entity_key
+      ${previous}
+      OFFSET 0
+    ) AS selected
+  `;
+}
+
+// src/ontology-storage/materialization-state.ts
 var PG_MATERIALIZATION_WORK_TABLE = "ontology_materialization_work";
 var PG_REPLACEMENT_WORK_TABLE = "ontology_replacement_work";
 
@@ -9760,22 +10004,7 @@ class PgMaterializationStateReader {
         JOIN requested USING (object_type_id, primary_id)
         WHERE objects.project_id = ${this.projectId}
       `,
-      this.sql`
-        WITH requested AS (
-          SELECT DISTINCT * FROM jsonb_to_recordset(${requestedParameter})
-            AS requested_values(object_type_id TEXT, primary_id TEXT)
-        )
-        SELECT rows.*
-        FROM ontology_source_rows AS rows
-        JOIN requested USING (object_type_id, primary_id)
-        JOIN ontology_sources AS sources
-          ON sources.project_id = rows.project_id
-         AND sources.source_id = rows.source_id
-         AND sources.materialization_id = rows.materialization_id
-        WHERE rows.project_id = ${this.projectId}
-          AND rows.entity_kind = 'object'
-          AND sources.status = 'active'
-      `,
+      activeSourceRows(this.sql, this.projectId, refs.map((ref) => ({ kind: "object", ref }))),
       this.sql`
         WITH requested AS (
           SELECT DISTINCT * FROM jsonb_to_recordset(${requestedParameter})
@@ -9816,7 +10045,7 @@ class PgMaterializationStateReader {
       const effectiveRow = effective.get(key);
       return {
         ref: structuredClone(ref),
-        source: sourceObject(sources.get(projectionEntityKey({ kind: "object", ref }))),
+        source: sourceObject(sources.get(projectionEntityKey2({ kind: "object", ref }))),
         override: overrides.get(key) ?? null,
         effective: effectiveRow ? effectiveObjectSnapshot(effectiveRow) : null,
         latestTelemetry: telemetry.get(key) ?? []
@@ -9852,26 +10081,7 @@ class PgMaterializationStateReader {
         JOIN requested USING (source_type_id, source_id, link_id, target_type_id, target_id)
         WHERE links.project_id = ${this.projectId}
       `,
-      this.sql`
-        WITH requested AS (
-          SELECT DISTINCT * FROM jsonb_to_recordset(${requestedParameter}) AS requested_values(
-            source_type_id TEXT, source_primary_id TEXT, link_id TEXT,
-            target_type_id TEXT, target_primary_id TEXT
-          )
-        )
-        SELECT rows.*
-        FROM ontology_source_rows AS rows
-        JOIN requested USING (
-          source_type_id, source_primary_id, link_id, target_type_id, target_primary_id
-        )
-        JOIN ontology_sources AS sources
-          ON sources.project_id = rows.project_id
-         AND sources.source_id = rows.source_id
-         AND sources.materialization_id = rows.materialization_id
-        WHERE rows.project_id = ${this.projectId}
-          AND rows.entity_kind = 'link'
-          AND sources.status = 'active'
-      `,
+      activeSourceRows(this.sql, this.projectId, refs.map((ref) => ({ kind: "link", ref }))),
       this.sql`
         WITH requested AS (
           SELECT DISTINCT * FROM jsonb_to_recordset(${requestedParameter}) AS requested_values(
@@ -9910,7 +10120,7 @@ class PgMaterializationStateReader {
       const effectiveRow = effective.get(key);
       return {
         ref: structuredClone(ref),
-        source: sourceLink(sources.get(projectionEntityKey({ kind: "link", ref }))),
+        source: sourceLink(sources.get(projectionEntityKey2({ kind: "link", ref }))),
         override: overrides.get(key) ?? null,
         slotOverride: slotOverrides.get(linkScopeSortKey(ref.source, ref.linkId)) ?? null,
         effective: effectiveRow ? effectiveLinkSnapshot(effectiveRow) : null
@@ -9979,13 +10189,14 @@ class PgMaterializationStateReader {
           ON requested.source_type_id = rows.source_type_id
          AND requested.source_id = rows.source_primary_id
          AND requested.link_id = rows.link_id
-        JOIN ontology_sources AS sources
+        JOIN ontology_source_roots AS sources
           ON sources.project_id = rows.project_id
          AND sources.source_id = rows.source_id
          AND sources.materialization_id = rows.materialization_id
+         AND sources.root_sort_key = rows.root_sort_key
         WHERE rows.project_id = ${this.projectId}
           AND rows.entity_kind = 'link'
-          AND sources.status = 'active'
+          AND sources.active
       `,
       this.sql`
         WITH requested AS (
@@ -10058,7 +10269,7 @@ class PgMaterializationStateReader {
       for (const row of rows) {
         const accumulator = accumulators.get(row.scope_sort_key);
         if (!accumulator) {
-          throw new MaterializationConflictError2("effective-state", `Unexpected link scope '${row.scope_sort_key}' returned by storage.`);
+          throw new MaterializationConflictError3("effective-state", `Unexpected link scope '${row.scope_sort_key}' returned by storage.`);
         }
         const snapshot = effectiveLinkSnapshot(row);
         appendScopeSnapshot(accumulator, snapshot);
@@ -10127,30 +10338,32 @@ class PgMaterializationStateReader {
           SELECT rows.source_type_id, rows.source_primary_id AS source_id,
             rows.link_id, rows.target_type_id, rows.target_primary_id AS target_id
           FROM ontology_source_rows AS rows
-          JOIN ontology_sources AS sources
+          JOIN ontology_source_roots AS sources
             ON sources.project_id = rows.project_id
            AND sources.source_id = rows.source_id
            AND sources.materialization_id = rows.materialization_id
+         AND sources.root_sort_key = rows.root_sort_key
           JOIN requested
             ON requested.object_type_id = rows.source_type_id
            AND requested.primary_id = rows.source_primary_id
           WHERE rows.project_id = ${this.projectId}
             AND rows.entity_kind = 'link'
-            AND sources.status = 'active'
+            AND sources.active
           UNION
           SELECT rows.source_type_id, rows.source_primary_id AS source_id,
             rows.link_id, rows.target_type_id, rows.target_primary_id AS target_id
           FROM ontology_source_rows AS rows
-          JOIN ontology_sources AS sources
+          JOIN ontology_source_roots AS sources
             ON sources.project_id = rows.project_id
            AND sources.source_id = rows.source_id
            AND sources.materialization_id = rows.materialization_id
+         AND sources.root_sort_key = rows.root_sort_key
           JOIN requested
             ON requested.object_type_id = rows.target_type_id
            AND requested.primary_id = rows.target_primary_id
           WHERE rows.project_id = ${this.projectId}
             AND rows.entity_kind = 'link'
-            AND sources.status = 'active'
+            AND sources.active
         ), selected AS (
           SELECT DISTINCT links.*,
             ${this.sql.unsafe(linkSortExpression("links"))} AS sort_key
@@ -10169,13 +10382,15 @@ class PgMaterializationStateReader {
   }
   async* replacementIdentities(input) {
     await this.prepareReplacementIdentities(input);
+    await this.sql`ANALYZE ${this.sql(PG_REPLACEMENT_WORK_TABLE)}`;
     let cursor = null;
     while (true) {
+      const after = cursor === null ? this.sql`` : this.sql`AND sort_key > ${cursor}`;
       const rows = await this.sql`
         SELECT entity_kind, identity_key, sort_key, diff_required
         FROM ${this.sql(PG_REPLACEMENT_WORK_TABLE)}
         WHERE session_id = ${input.sessionId} AND entity_kind = ${input.kind}
-          AND (${cursor}::text IS NULL OR sort_key > ${cursor})
+          ${after}
         ORDER BY sort_key
         LIMIT ${input.pageRows}
       `;
@@ -10190,19 +10405,19 @@ class PgMaterializationStateReader {
     const candidates = await this.replacementSources(sourceId, [candidateMaterializationId], refs.map((ref) => ({ kind: "object", ref })));
     return base.map((state) => ({
       ref: state.ref,
-      candidateSource: sourceObject(candidates.byMaterialization.get(candidateMaterializationId)?.get(projectionEntityKey({ kind: "object", ref: state.ref }))),
+      candidateSource: sourceObject(candidates.byMaterialization.get(candidateMaterializationId)?.get(projectionEntityKey2({ kind: "object", ref: state.ref }))),
       override: state.override,
       effective: state.effective,
       latestTelemetry: state.latestTelemetry
     }));
   }
-  async replacementLinkStates(sourceId, candidateMaterializationId, materializationIds, identities) {
+  async replacementLinkStates(sourceId, candidateMaterializationId, materializationIds, identities, incremental = false) {
     const refs = identities.map((identity) => identity.ref);
     const base = await this.linkStates(refs);
-    const replacements = await this.replacementSources(sourceId, materializationIds, refs.map((ref) => ({ kind: "link", ref })));
+    const replacements = await this.replacementSources(sourceId, materializationIds, refs.map((ref) => ({ kind: "link", ref })), incremental);
     const candidate = replacements.byMaterialization.get(candidateMaterializationId);
     return base.map((state, index) => {
-      const key = projectionEntityKey({ kind: "link", ref: state.ref });
+      const key = projectionEntityKey2({ kind: "link", ref: state.ref });
       return {
         ref: state.ref,
         candidateSource: replacements.owned.has(key) ? sourceLink(candidate?.get(key)) : state.source,
@@ -10269,33 +10484,23 @@ class PgMaterializationStateReader {
     `;
     return new Map(rows.map((row) => [linkRefKey(linkRefFromColumns(row)), row.last_commit_id]));
   }
-  async replacementSources(sourceId, materializationIds, refs) {
+  async replacementSources(sourceId, materializationIds, refs, incremental = false) {
     if (materializationIds.length === 0 || refs.length === 0) {
       return { owned: new Set, byMaterialization: new Map };
     }
-    const keys = refs.map((ref) => ({
-      entity_kind: ref.kind,
-      entity_key: JSON.parse(projectionEntityKey(ref))
-    }));
-    const rows = await this.sql`
-      WITH requested AS (
-        SELECT *
-        FROM jsonb_to_recordset(${jsonParameter2(this.sql, keys)})
-          AS requested_values(entity_kind TEXT, entity_key JSONB)
-      )
-      SELECT rows.* FROM ontology_source_rows AS rows
-      JOIN requested USING (entity_kind, entity_key)
-      WHERE rows.project_id = ${this.projectId}
-        AND rows.source_id = ${sourceId}
-        AND rows.materialization_id = ANY(
-          ${this.sql.array([...new Set(materializationIds)])}::text[]
-        )
-    `;
+    const rows = await replacementAssertionRows(this.sql, {
+      projectId: this.projectId,
+      sourceId,
+      materializationId: materializationIds[0],
+      incremental,
+      includePrevious: materializationIds.length > 1,
+      refs
+    });
     const owned = new Set;
     const byMaterialization = new Map;
     for (const row of rows) {
       const source = storedSource(row);
-      const key = projectionEntityKey(source.assertion);
+      const key = projectionEntityKey2(source.assertion);
       owned.add(key);
       const materialization = byMaterialization.get(row.materialization_id) ?? new Map;
       materialization.set(key, source);
@@ -10311,20 +10516,19 @@ class PgMaterializationStateReader {
     await this.prepareReplacementLinks(input);
   }
   async prepareReplacementObjects(input) {
-    const materializationIds = [
-      input.candidateMaterializationId,
-      ...input.previousMaterializationId ? [input.previousMaterializationId] : []
-    ];
+    const rows = replacementSourceRows(this.sql, {
+      projectId: this.projectId,
+      sourceId: input.sourceId,
+      materializationId: input.candidateMaterializationId,
+      incremental: input.incremental ?? false
+    });
     await this.sql`
       WITH selected AS (
         SELECT DISTINCT object_type_id, primary_id,
           ${this.sql.unsafe(objectKeyExpression("rows"))} AS identity_key,
           ${this.sql.unsafe(objectSortExpression("rows"))} AS sort_key
-        FROM ontology_source_rows AS rows
-        WHERE project_id = ${this.projectId}
-          AND source_id = ${input.sourceId}
-          AND entity_kind = 'object'
-          AND materialization_id = ANY(${this.sql.array(materializationIds)}::text[])
+        FROM (${rows}) AS rows
+        WHERE entity_kind = 'object'
       )
       INSERT INTO ${this.sql(PG_REPLACEMENT_WORK_TABLE)} (
         session_id, entity_kind, identity_key, sort_key, diff_required
@@ -10337,10 +10541,13 @@ class PgMaterializationStateReader {
     `;
   }
   async prepareReplacementLinks(input) {
-    const materializationIds = [
-      input.candidateMaterializationId,
-      ...input.previousMaterializationId ? [input.previousMaterializationId] : []
-    ];
+    await this.sql`ANALYZE ${this.sql(PG_MATERIALIZATION_WORK_TABLE)}`;
+    const rows = replacementSourceRows(this.sql, {
+      projectId: this.projectId,
+      sourceId: input.sourceId,
+      materializationId: input.candidateMaterializationId,
+      incremental: input.incremental ?? false
+    });
     await this.sql`
       WITH incident_objects AS (
         SELECT DISTINCT payload->'ref'->>'objectTypeId' AS object_type_id,
@@ -10350,11 +10557,8 @@ class PgMaterializationStateReader {
       ), replacement_links AS (
         SELECT source_type_id, source_primary_id AS source_id, link_id,
           target_type_id, target_primary_id AS target_id
-        FROM ontology_source_rows
-        WHERE project_id = ${this.projectId}
-          AND source_id = ${input.sourceId}
-          AND entity_kind = 'link'
-          AND materialization_id = ANY(${this.sql.array(materializationIds)}::text[])
+        FROM (${rows}) AS rows
+        WHERE entity_kind = 'link'
       ), incident_links AS (
         SELECT links.source_type_id, links.source_id, links.link_id,
           links.target_type_id, links.target_id
@@ -10393,30 +10597,32 @@ class PgMaterializationStateReader {
         SELECT rows.source_type_id, rows.source_primary_id AS source_id,
           rows.link_id, rows.target_type_id, rows.target_primary_id AS target_id
         FROM ontology_source_rows AS rows
-        JOIN ontology_sources AS sources
+        JOIN ontology_source_roots AS sources
           ON sources.project_id = rows.project_id
          AND sources.source_id = rows.source_id
          AND sources.materialization_id = rows.materialization_id
+         AND sources.root_sort_key = rows.root_sort_key
         JOIN incident_objects
           ON incident_objects.object_type_id = rows.source_type_id
          AND incident_objects.primary_id = rows.source_primary_id
         WHERE rows.project_id = ${this.projectId}
           AND rows.entity_kind = 'link'
-          AND sources.status = 'active'
+          AND sources.active
         UNION
         SELECT rows.source_type_id, rows.source_primary_id AS source_id,
           rows.link_id, rows.target_type_id, rows.target_primary_id AS target_id
         FROM ontology_source_rows AS rows
-        JOIN ontology_sources AS sources
+        JOIN ontology_source_roots AS sources
           ON sources.project_id = rows.project_id
          AND sources.source_id = rows.source_id
          AND sources.materialization_id = rows.materialization_id
+         AND sources.root_sort_key = rows.root_sort_key
         JOIN incident_objects
           ON incident_objects.object_type_id = rows.target_type_id
          AND incident_objects.primary_id = rows.target_primary_id
         WHERE rows.project_id = ${this.projectId}
           AND rows.entity_kind = 'link'
-          AND sources.status = 'active'
+          AND sources.active
       ), diff_links AS (
         SELECT * FROM replacement_links
         UNION SELECT * FROM incident_links
@@ -10484,9 +10690,9 @@ function activeSourceMap(rows) {
   const result = new Map;
   for (const row of rows) {
     const source = storedSource(row);
-    const key = projectionEntityKey(source.assertion);
+    const key = projectionEntityKey2(source.assertion);
     if (result.has(key)) {
-      throw new MaterializationConflictError2("source-materialization", `Multiple active sources assert ${key}.`);
+      throw new MaterializationConflictError3("source-materialization", `Multiple active sources assert ${key}.`);
     }
     result.set(key, source);
   }
@@ -10501,7 +10707,7 @@ function activeScopeSourceMap(rows) {
     const ref = source.assertion.ref;
     const key = linkScopeSortKey(ref.source, ref.linkId);
     if (result.has(key)) {
-      throw new MaterializationConflictError2("source-materialization", `Multiple active sources assert cardinality-one link slot ${key}.`);
+      throw new MaterializationConflictError3("source-materialization", `Multiple active sources assert cardinality-one link slot ${key}.`);
     }
     result.set(key, source);
   }
@@ -10565,7 +10771,7 @@ function storedSource(row) {
 }
 function effectiveObjectSnapshot(row) {
   if (!row.last_commit_id) {
-    throw new MaterializationConflictError2("effective-state", `Effective object ${row.object_type_id}:${row.primary_id} lacks materializer provenance.`);
+    throw new MaterializationConflictError3("effective-state", `Effective object ${row.object_type_id}:${row.primary_id} lacks materializer provenance.`);
   }
   return {
     ref: objectRefFromColumns(row),
@@ -10578,7 +10784,7 @@ function effectiveObjectSnapshot(row) {
 }
 function effectiveLinkSnapshot(row) {
   if (!row.last_commit_id) {
-    throw new MaterializationConflictError2("effective-state", `Effective link ${linkRefKey(linkRefFromColumns(row))} lacks materializer provenance.`);
+    throw new MaterializationConflictError3("effective-state", `Effective link ${linkRefKey(linkRefFromColumns(row))} lacks materializer provenance.`);
   }
   return {
     ref: linkRefFromColumns(row),
@@ -10593,7 +10799,7 @@ function effectiveLinkSnapshot(row) {
 function storedPoint(row) {
   const at = toIsoString2(row.at);
   if (!row.last_commit_id) {
-    throw new MaterializationConflictError2("timeseries-point", `Telemetry point ${telemetryPointSortKey({
+    throw new MaterializationConflictError3("timeseries-point", `Telemetry point ${telemetryPointSortKey({
       object: { objectTypeId: row.object_type_id, primaryId: row.object_id },
       propertyId: row.property_id
     }, at)} lacks materializer provenance.`);
@@ -10652,6 +10858,9 @@ function jsonTupleExpression(parts) {
 
 // src/ontology-storage/materialization-session.ts
 class PgMaterializationSessionState extends ProviderMaterializationSessionState {
+  stagedWorkCount = 0;
+  changedObjects = 0;
+  changedLinks = 0;
   appliedPlanCursor = null;
   appliedEventCursor = null;
 }
@@ -10668,7 +10877,7 @@ class PgMaterializationSessions {
   }
   async create(header) {
     if (!this.context?.active) {
-      throw new MaterializationConflictError3("effective-state", "Materialization sessions require an active storage transaction.");
+      throw new MaterializationConflictError4("effective-state", "Materialization sessions require an active storage transaction.");
     }
     await this.ensureTables();
     const session = new PgMaterializationSessionState(structuredClone(header), this.context.id);
@@ -10680,7 +10889,7 @@ class PgMaterializationSessions {
   require(session) {
     const value = this.sessions.get(session.providerToken);
     if (!value || !value.active || !this.context?.active || value.transactionId !== this.context.id) {
-      throw new MaterializationConflictError3("effective-state", "Materialization session is inactive.");
+      throw new MaterializationConflictError4("effective-state", "Materialization session is inactive.");
     }
     return value;
   }
@@ -10738,14 +10947,18 @@ class PgMaterializationSessions {
       }
       throw error;
     }
+    session.stagedWorkCount += records.length;
   }
   async* stream(input) {
     const session = this.require(input.session);
     const stream = session.workStreams[input.order];
     if (stream.started) {
-      throw new MaterializationConflictError3("effective-state", `Materialization ${input.order} work may only be streamed once per session.`);
+      throw new MaterializationConflictError4("effective-state", `Materialization ${input.order} work may only be streamed once per session.`);
     }
     stream.started = true;
+    if (!session.workSealed && session.stagedWorkCount >= 1e4) {
+      await this.sql`ANALYZE ${this.sql(PG_MATERIALIZATION_WORK_TABLE)}`;
+    }
     session.workSealed = true;
     let cursor = null;
     while (true) {
@@ -10766,10 +10979,13 @@ class PgMaterializationSessions {
       return [];
     const keys = refs.map((ref) => `object-existence:${JSON.stringify([ref.objectTypeId, ref.primaryId])}`);
     const rows = await this.sql`
-      SELECT unique_key, payload FROM ${this.sql(PG_MATERIALIZATION_WORK_TABLE)}
-      WHERE session_id = ${session.id}
-        AND unique_key = ANY(${this.sql.array(keys)}::text[])
-        AND kind = 'object-existence'
+      SELECT work.unique_key, work.payload
+      FROM unnest(${this.sql.array(keys)}::text[]) AS requested(unique_key)
+      CROSS JOIN LATERAL (
+        SELECT unique_key, payload FROM ${this.sql(PG_MATERIALIZATION_WORK_TABLE)}
+        WHERE session_id = ${session.id} AND unique_key = requested.unique_key
+        OFFSET 0
+      ) AS work
     `;
     const found = new Map(rows.map((row) => [row.unique_key, row.payload]));
     return keys.flatMap((key) => {
@@ -10777,6 +10993,9 @@ class PgMaterializationSessions {
       if (!payload)
         return [];
       const record = structuredClone(payload);
+      if (record.kind !== "object-existence") {
+        invalidCorrelation("Object existence work has an invalid kind.");
+      }
       return [{ ref: record.ref, exists: record.exists }];
     });
   }
@@ -10931,7 +11150,7 @@ function workCursor(row) {
 // src/ontology-storage/materialization-writer.ts
 import {
   linkRefKey as linkRefKey2,
-  MaterializationConflictError as MaterializationConflictError4,
+  MaterializationConflictError as MaterializationConflictError5,
   objectRefKey as objectRefKey2,
   telemetryPointKey as telemetryPointKey2
 } from "@sixb/core/internal/materialization";
@@ -11447,7 +11666,7 @@ function effectiveLinkConflict(item) {
   return effectiveConflict(`Expected link ${linkIdentityKey(item)} changed.`);
 }
 function pointConflict(item) {
-  return new MaterializationConflictError4("timeseries-point", `Telemetry point ${telemetryPointKey2({
+  return new MaterializationConflictError5("timeseries-point", `Telemetry point ${telemetryPointKey2({
     object: { objectTypeId: item.objectTypeId, primaryId: item.objectId },
     propertyId: item.propertyId
   }, item.at)} changed.`);
@@ -11482,14 +11701,14 @@ class PgOntologyMaterializationStorage {
       const linkScopeRevisions = await reader.linkScopeRevisions(input.expected.linkScopes);
       for (const [index, expected] of input.expected.linkScopes.entries()) {
         if (linkScopeRevisions[index]?.fingerprint !== expected.fingerprint) {
-          throw new MaterializationConflictError5("effective-state", `Expected link scope changed for ${expected.source.objectTypeId}:${expected.source.primaryId}.${expected.linkId}.`);
+          throw new MaterializationConflictError6("effective-state", `Expected link scope changed for ${expected.source.objectTypeId}:${expected.source.primaryId}.${expected.linkId}.`);
         }
       }
       const points = await reader.exactPoints(input.expected.points, true);
       const pointRevisions = new Map(points.map((point) => [telemetryPointKey3(point.series, point.at), point.lastCommitId]));
       for (const expected of input.expected.points) {
         if ((pointRevisions.get(telemetryPointKey3(expected.series, expected.at)) ?? null) !== expected.lastCommitId) {
-          throw new MaterializationConflictError5("timeseries-point", `Telemetry point ${telemetryPointKey3(expected.series, expected.at)} changed.`);
+          throw new MaterializationConflictError6("timeseries-point", `Telemetry point ${telemetryPointKey3(expected.series, expected.at)} changed.`);
         }
       }
       return session.publicSession();
@@ -11548,10 +11767,10 @@ class PgOntologyMaterializationStorage {
     const reader = new PgMaterializationStateReader(this.sql, session.header.commit.projectId);
     if (input.entityKind === "object") {
       if (replacement.projectionKind !== "object") {
-        throw new MaterializationConflictError5("source-materialization", "Link projection replacement cannot stream object state.");
+        throw new MaterializationConflictError6("source-materialization", "Link projection replacement cannot stream object state.");
       }
       if (replacement.objectStreamStarted) {
-        throw new MaterializationConflictError5("effective-state", "Replacement object state may only be streamed once per session.");
+        throw new MaterializationConflictError6("effective-state", "Replacement object state may only be streamed once per session.");
       }
       replacement.objectStreamStarted = true;
       for await (const identities of reader.replacementIdentities({
@@ -11559,6 +11778,7 @@ class PgOntologyMaterializationStorage {
         sourceId: replacement.sourceId,
         candidateMaterializationId: replacement.candidateMaterializationId,
         previousMaterializationId: replacement.previousMaterializationId,
+        incremental: replacement.incremental,
         kind: "object",
         pageRows: input.pageRows
       })) {
@@ -11577,10 +11797,10 @@ class PgOntologyMaterializationStorage {
       return;
     }
     if (replacement.projectionKind === "object" && !replacement.objectStreamCompleted) {
-      throw new MaterializationConflictError5("effective-state", "Object projection replacement must fully stream object state before link state.");
+      throw new MaterializationConflictError6("effective-state", "Object projection replacement must fully stream object state before link state.");
     }
     if (replacement.linkStreamStarted) {
-      throw new MaterializationConflictError5("effective-state", "Replacement link state may only be streamed once per session.");
+      throw new MaterializationConflictError6("effective-state", "Replacement link state may only be streamed once per session.");
     }
     replacement.linkStreamStarted = true;
     const materializationIds = [
@@ -11592,6 +11812,7 @@ class PgOntologyMaterializationStorage {
       sourceId: replacement.sourceId,
       candidateMaterializationId: replacement.candidateMaterializationId,
       previousMaterializationId: replacement.previousMaterializationId,
+      incremental: replacement.incremental,
       kind: "link",
       pageRows: input.pageRows
     })) {
@@ -11602,7 +11823,7 @@ class PgOntologyMaterializationStorage {
         }
         return identity;
       });
-      const links = await reader.replacementLinkStates(replacement.sourceId, replacement.candidateMaterializationId, materializationIds, linkIdentities);
+      const links = await reader.replacementLinkStates(replacement.sourceId, replacement.candidateMaterializationId, materializationIds, linkIdentities, replacement.incremental);
       yield { objects: [], links };
     }
     this.sessions.require(input.session);
@@ -11625,6 +11846,8 @@ class PgOntologyMaterializationStorage {
     assertPlanChunkCorrelations(input.chunk, commit);
     const progress = await this.sessions.prepareChunkSequence(session, input.chunk);
     await this.writer.apply(commit.projectId, commit.id, input.chunk);
+    session.changedObjects += input.chunk.effective.objectUpserts.length + input.chunk.effective.objectDeletes.length;
+    session.changedLinks += input.chunk.effective.linkUpserts.length + input.chunk.effective.linkDeletes.length;
     this.sessions.commitChunkSequence(session, progress);
   }
   async finalize(input) {
@@ -11634,6 +11857,10 @@ class PgOntologyMaterializationStorage {
     for (const activation of input.finalization.sourceActivations) {
       await this.activateSource(session, activation);
     }
+    if (session.changedObjects >= 1000)
+      await this.sql`ANALYZE objects`;
+    if (session.changedLinks >= 1000)
+      await this.sql`ANALYZE links`;
     const record = await this.insertCommit(session.header, input);
     await this.sessions.release(session);
     return { commit: record };
@@ -11644,14 +11871,14 @@ class PgOntologyMaterializationStorage {
   async requireReplacement(session, input) {
     if (session.replacement) {
       if (session.replacement.sourceId !== input.source.projectionId || session.replacement.candidateMaterializationId !== input.candidateMaterializationId) {
-        throw new MaterializationConflictError5("source-materialization", "Materialization session already owns another replacement union.");
+        throw new MaterializationConflictError6("source-materialization", "Materialization session already owns another replacement union.");
       }
       return session.replacement;
     }
     const projectId = session.header.commit.projectId;
     const candidate = await this.getSource(projectId, input.source.projectionId, input.candidateMaterializationId, true);
     if (!candidate || candidate.status !== "ready" || candidate.execution_token === null) {
-      throw new MaterializationConflictError5("source-materialization", `Candidate source materialization '${input.candidateMaterializationId}' is missing or is not ready.`);
+      throw new MaterializationConflictError6("source-materialization", `Candidate source materialization '${input.candidateMaterializationId}' is missing or is not ready.`);
     }
     await assertProjectionExecution(this.sql, {
       projectId,
@@ -11661,12 +11888,13 @@ class PgOntologyMaterializationStorage {
     });
     const previous = await this.getActiveSource(projectId, input.source.projectionId, true);
     if (candidate.protocol !== "replacement" || previous && (previous.protocol !== candidate.protocol || previous.projection_kind !== candidate.projection_kind)) {
-      throw new MaterializationConflictError5("source-materialization", "Source replacement kind or protocol does not match its active materialization.");
+      throw new MaterializationConflictError6("source-materialization", "Source replacement kind or protocol does not match its active materialization.");
     }
     session.replacement = {
       sourceId: input.source.projectionId,
       candidateMaterializationId: input.candidateMaterializationId,
       previousMaterializationId: previous?.materialization_id ?? null,
+      incremental: candidate.base_materialization_id !== null,
       projectionKind: candidate.projection_kind,
       objectStreamStarted: false,
       objectStreamCompleted: false,
@@ -11686,7 +11914,7 @@ class PgOntologyMaterializationStorage {
       FOR UPDATE
     `;
     if (duplicateIdentity) {
-      throw new MaterializationConflictError5("idempotency", duplicateIdentity.id === header.commit.id ? `Ontology commit '${header.commit.id}' already exists.` : "Ontology idempotency key already exists.");
+      throw new MaterializationConflictError6("idempotency", duplicateIdentity.id === header.commit.id ? `Ontology commit '${header.commit.id}' already exists.` : "Ontology idempotency key already exists.");
     }
     const origin = originColumns(header.commit.origin);
     if (origin.runId === null)
@@ -11709,7 +11937,7 @@ class PgOntologyMaterializationStorage {
             FOR UPDATE
           `;
     if (duplicateOrigin) {
-      throw new MaterializationConflictError5("run-correlation", "Ontology commit origin already has an authoritative commit.");
+      throw new MaterializationConflictError6("run-correlation", "Ontology commit origin already has an authoritative commit.");
     }
   }
   async assertSources(expectedSources, projectId) {
@@ -11731,29 +11959,29 @@ class PgOntologyMaterializationStorage {
   }
   assertSourceRow(expected, active) {
     if ((active?.materialization_id ?? null) !== expected.activeMaterializationId || (active?.last_commit_id ?? null) !== expected.lastCommitId) {
-      throw new MaterializationConflictError5("projection-fence", `Source '${expected.source.projectionId}' changed.`);
+      throw new MaterializationConflictError6("projection-fence", `Source '${expected.source.projectionId}' changed.`);
     }
   }
   assertObject(row, expected) {
     if (!expected.exists) {
       if (row) {
-        throw new MaterializationConflictError5("effective-state", `Expected object ${objectRefKey3(expected.ref)} to be absent.`);
+        throw new MaterializationConflictError6("effective-state", `Expected object ${objectRefKey3(expected.ref)} to be absent.`);
       }
       return;
     }
     if (!row || row.version !== expected.version || row.lastCommitId !== expected.lastCommitId) {
-      throw new MaterializationConflictError5("effective-state", `Expected object ${objectRefKey3(expected.ref)} changed.`);
+      throw new MaterializationConflictError6("effective-state", `Expected object ${objectRefKey3(expected.ref)} changed.`);
     }
   }
   assertLink(lastCommitId, expected) {
     if (!expected.exists) {
       if (lastCommitId !== undefined) {
-        throw new MaterializationConflictError5("effective-state", `Expected link ${linkRefKey3(expected.ref)} to be absent.`);
+        throw new MaterializationConflictError6("effective-state", `Expected link ${linkRefKey3(expected.ref)} to be absent.`);
       }
       return;
     }
     if (lastCommitId === undefined || lastCommitId !== expected.lastCommitId) {
-      throw new MaterializationConflictError5("effective-state", `Expected link ${linkRefKey3(expected.ref)} changed.`);
+      throw new MaterializationConflictError6("effective-state", `Expected link ${linkRefKey3(expected.ref)} changed.`);
     }
   }
   async assertFinalization(session, input) {
@@ -11762,7 +11990,8 @@ class PgOntologyMaterializationStorage {
     assertMaterializationFinalizationCorrelation(session, input);
     const laneCounts = await this.sessions.laneCounts(session);
     assertMaterializationLaneCompletion(session, laneCounts);
-    await this.assertFinalCardinality(session);
+    if (laneCounts.cardinality > 0)
+      await this.assertFinalCardinality(session);
     const eventCount = laneCounts.event;
     const [outbox] = await this.sql`
       SELECT COUNT(*) AS count, MIN(commit_ordinal) AS minimum,
@@ -11795,17 +12024,18 @@ class PgOntologyMaterializationStorage {
     }
   }
   async assertFinalCardinality(session) {
-    const [violation] = await this.sql`
-      WITH work AS (
-        SELECT payload->>'scopeSortKey' AS scope_sort_key,
-          payload->>'linkSortKey' AS link_sort_key,
+    const table = `ontology_cardinality_${session.id.replaceAll("-", "")}`;
+    await this.sql.unsafe(`CREATE TEMP TABLE ${table} ON COMMIT DROP AS
+        SELECT sort_one AS scope_sort_key, sort_two AS link_sort_key,
           (payload->>'occupied')::boolean AS occupied,
           payload->'ref'->'source'->>'objectTypeId' AS source_type_id,
           payload->'ref'->'source'->>'primaryId' AS source_id,
           payload->'ref'->>'linkId' AS link_id
-        FROM ${this.sql(PG_MATERIALIZATION_WORK_TABLE)}
-        WHERE session_id = ${session.id} AND kind = 'cardinality'
-          AND payload->>'view' = 'effective'
+        FROM ${PG_MATERIALIZATION_WORK_TABLE}
+        WHERE session_id = $1 AND lane = 'cardinality' AND major_order = 0`, [session.id]);
+    await this.sql.unsafe(`ANALYZE ${table}`);
+    const [violation] = await this.sql.unsafe(`WITH work AS (
+        SELECT * FROM ${table}
       ), duplicate AS (
         SELECT scope_sort_key FROM work WHERE occupied
         GROUP BY scope_sort_key HAVING COUNT(*) > 1
@@ -11815,10 +12045,10 @@ class PgOntologyMaterializationStorage {
         SELECT scope_sort_key, link_sort_key FROM work WHERE occupied
       ), actual AS (
         SELECT scopes.scope_sort_key,
-          ${this.sql.unsafe(linkSortExpression("links"))} AS link_sort_key
+          ${linkSortExpression("links")} AS link_sort_key
         FROM scopes
         JOIN links USING (source_type_id, source_id, link_id)
-        WHERE links.project_id = ${session.header.commit.projectId}
+        WHERE links.project_id = $1
       ), differences AS (
         (SELECT * FROM expected EXCEPT SELECT * FROM actual)
         UNION ALL
@@ -11827,8 +12057,8 @@ class PgOntologyMaterializationStorage {
       SELECT 'duplicate'::text AS reason FROM duplicate
       UNION ALL
       SELECT 'mismatch'::text AS reason FROM differences
-      LIMIT 1
-    `;
+      LIMIT 1`, [session.header.commit.projectId]);
+    await this.sql.unsafe(`DROP TABLE ${table}`);
     if (violation?.reason === "duplicate") {
       invalidCorrelation2("Materialization cardinality work violates cardinality-one.");
     }
@@ -11924,7 +12154,7 @@ class PgOntologyMaterializationStorage {
     assertSourceActivationCorrelation(session, activation);
     const candidate = await this.getSource(commit.projectId, activation.source.projectionId, activation.materializationId, true);
     if (!candidate || candidate.status !== "ready" || candidate.execution_token === null) {
-      throw new MaterializationConflictError5("source-materialization", "Source activation candidate is missing or is not ready.");
+      throw new MaterializationConflictError6("source-materialization", "Source activation candidate is missing or is not ready.");
     }
     await assertProjectionExecution(this.sql, {
       projectId: commit.projectId,
@@ -11937,6 +12167,7 @@ class PgOntologyMaterializationStorage {
     }
     const previous = await this.getActiveSource(commit.projectId, activation.source.projectionId, true);
     this.assertSourceRow(activation.expected, previous);
+    await activateSourceRoots(this.sql, commit.projectId, candidate, activation);
     if (previous) {
       assertPinnedDatasetWatermark({
         datasetId: previous.dataset_id,
@@ -11958,7 +12189,7 @@ class PgOntologyMaterializationStorage {
         RETURNING materialization_id
       `;
       if (superseded.length !== 1) {
-        throw new MaterializationConflictError5("projection-fence", `Source '${activation.source.projectionId}' changed.`);
+        throw new MaterializationConflictError6("projection-fence", `Source '${activation.source.projectionId}' changed.`);
       }
     }
     let activated;
@@ -11977,12 +12208,12 @@ class PgOntologyMaterializationStorage {
       `;
     } catch (error) {
       if (isUniqueViolation(error)) {
-        throw new MaterializationConflictError5("projection-fence", `Source '${activation.source.projectionId}' changed.`);
+        throw new MaterializationConflictError6("projection-fence", `Source '${activation.source.projectionId}' changed.`);
       }
       throw error;
     }
     if (activated.length !== 1) {
-      throw new MaterializationConflictError5("source-materialization", "Source activation candidate changed.");
+      throw new MaterializationConflictError6("source-materialization", "Source activation candidate changed.");
     }
   }
   async insertCommit(header, input) {
@@ -12009,7 +12240,7 @@ class PgOntologyMaterializationStorage {
     `;
     if (!rows[0]) {
       await this.assertCommitAbsent(header);
-      throw new MaterializationConflictError5("idempotency", "Ontology commit identity already exists.");
+      throw new MaterializationConflictError6("idempotency", "Ontology commit identity already exists.");
     }
     return commitRecord(rows[0]);
   }
@@ -12057,8 +12288,8 @@ function databaseCount(value) {
 // src/ontology-storage/outbox.ts
 import { serializeSixbFailure as serializeSixbFailure2 } from "@sixb/core/internal/errors";
 import {
-  MaterializationConflictError as MaterializationConflictError6,
-  MaterializationValidationError
+  MaterializationConflictError as MaterializationConflictError7,
+  MaterializationValidationError as MaterializationValidationError2
 } from "@sixb/core/internal/materialization";
 import { ONTOLOGY_OUTBOX_FAILURE_CODES as ONTOLOGY_OUTBOX_FAILURE_CODES2 } from "@sixb/core/storage";
 class PgOntologyOutboxStorage {
@@ -12074,7 +12305,7 @@ class PgOntologyOutboxStorage {
       const leaseExpiry = assertTimestamp(input.leaseExpiresAt, "Ontology outbox lease expiry");
       assertNonblank(input.leaseId, "Ontology outbox lease id");
       if (leaseExpiry <= now) {
-        throw new MaterializationValidationError("Ontology outbox lease expiry must be later than the claim time.");
+        throw new MaterializationValidationError2("Ontology outbox lease expiry must be later than the claim time.");
       }
       const rows = await sql`
         WITH candidates AS (
@@ -12104,7 +12335,7 @@ class PgOntologyOutboxStorage {
       return rows.map((row) => {
         const record = outboxRecord(row);
         if (record.leaseId === null || record.leaseExpiresAt === null) {
-          throw new MaterializationConflictError6("outbox-lease", "Ontology outbox claim returned an unpaired lease.");
+          throw new MaterializationConflictError7("outbox-lease", "Ontology outbox claim returned an unpaired lease.");
         }
         return { ...record, leaseId: record.leaseId, leaseExpiresAt: record.leaseExpiresAt };
       });
@@ -12225,7 +12456,7 @@ function validateLeaseIds(ids) {
   for (const id of ids) {
     assertNonblank(id, "Ontology outbox event id");
     if (seen.has(id)) {
-      throw new MaterializationValidationError(`Ontology outbox lease batch repeats event '${id}'.`);
+      throw new MaterializationValidationError2(`Ontology outbox lease batch repeats event '${id}'.`);
     }
     seen.add(id);
   }
@@ -12236,11 +12467,11 @@ function assertLeaseInput(input) {
   assertNonblank(input.leaseId, "Ontology outbox lease id");
 }
 function leaseConflict() {
-  return new MaterializationConflictError6("outbox-lease", "Ontology outbox lease does not match.");
+  return new MaterializationConflictError7("outbox-lease", "Ontology outbox lease does not match.");
 }
 
 // src/ontology-storage/sources.ts
-import { MaterializationValidationError as MaterializationValidationError2 } from "@sixb/core/internal/materialization";
+import { MaterializationValidationError as MaterializationValidationError3 } from "@sixb/core/internal/materialization";
 import {
   assertSourceBeginInput as assertBeginInput,
   assertSourceExecutionIdentity as assertExecutionIdentity,
@@ -12254,8 +12485,61 @@ import {
   sourceMaterializationIdentity,
   sourceStageRow,
   sourceStageRows,
-  utf8SortKey
+  utf8SortKey as utf8SortKey2
 } from "@sixb/core/internal/ontology-storage-provider";
+
+// src/ontology-storage/source-cleanup.ts
+async function cleanupSourceVersions(sql, input) {
+  let remaining = input.limit;
+  const removedRows = await sql`
+    WITH selected AS (
+      SELECT rows.ctid FROM ontology_source_roots AS roots
+      JOIN ontology_sources AS sources USING (project_id, source_id, materialization_id)
+      JOIN ontology_source_rows AS rows
+        ON rows.project_id = roots.project_id AND rows.source_id = roots.source_id
+        AND rows.materialization_id = roots.materialization_id AND rows.root_sort_key = roots.root_sort_key
+      WHERE roots.project_id = ${input.projectId} AND NOT roots.active AND roots.retired_at < ${input.terminalBefore}
+        AND sources.status IN ('superseded', 'abandoned')
+      ORDER BY roots.retired_at, roots.source_id, roots.materialization_id, roots.root_sort_key, rows.entity_sort_key
+      LIMIT ${remaining} FOR UPDATE OF rows SKIP LOCKED
+    ) DELETE FROM ontology_source_rows AS rows USING selected WHERE rows.ctid = selected.ctid RETURNING 1
+  `;
+  let rowsDeleted = removedRows.length;
+  remaining -= rowsDeleted;
+  if (remaining > 0) {
+    const removed = await sql`
+      WITH selected AS (
+        SELECT roots.ctid FROM ontology_source_roots AS roots
+        JOIN ontology_sources AS sources USING (project_id, source_id, materialization_id)
+        WHERE roots.project_id = ${input.projectId} AND NOT roots.active AND roots.retired_at < ${input.terminalBefore}
+          AND sources.status IN ('superseded', 'abandoned')
+          AND NOT EXISTS (SELECT 1 FROM ontology_source_rows AS rows
+            WHERE rows.project_id = roots.project_id AND rows.source_id = roots.source_id
+              AND rows.materialization_id = roots.materialization_id AND rows.root_sort_key = roots.root_sort_key)
+        ORDER BY roots.retired_at, roots.source_id, roots.materialization_id, roots.root_sort_key
+        LIMIT ${remaining} FOR UPDATE OF roots SKIP LOCKED
+      ) DELETE FROM ontology_source_roots AS roots USING selected WHERE roots.ctid = selected.ctid RETURNING 1
+    `;
+    rowsDeleted += removed.length;
+    remaining -= removed.length;
+  }
+  const removedManifests = remaining === 0 ? [] : await sql`
+    WITH selected AS (
+      SELECT sources.ctid FROM ontology_sources AS sources
+      WHERE project_id = ${input.projectId} AND status IN ('superseded', 'abandoned') AND terminal_at < ${input.terminalBefore}
+        AND NOT EXISTS (SELECT 1 FROM ontology_source_roots AS roots
+          WHERE roots.project_id = sources.project_id AND roots.source_id = sources.source_id
+            AND roots.materialization_id = sources.materialization_id)
+        AND NOT EXISTS (SELECT 1 FROM ontology_source_rows AS rows
+          WHERE rows.project_id = sources.project_id AND rows.source_id = sources.source_id
+            AND rows.materialization_id = sources.materialization_id)
+      ORDER BY terminal_at, source_id, materialization_id LIMIT ${remaining} FOR UPDATE SKIP LOCKED
+    ) DELETE FROM ontology_sources AS sources USING selected WHERE sources.ctid = selected.ctid RETURNING 1
+  `;
+  return { rowsDeleted, materializationsDeleted: removedManifests.length };
+}
+
+// src/ontology-storage/sources.ts
 class PgOntologySourceStorage {
   runRootOperation;
   constructor(runRootOperation) {
@@ -12286,14 +12570,15 @@ class PgOntologySourceStorage {
           dataset_id, dataset_version_id, dataset_version_created_at,
           projection_revision, ownership_hash, ontology_revision,
           root_count, assertion_count, created_at, ready_at, activated_at,
-          terminal_at, last_commit_id, updated_at
+          terminal_at, last_commit_id, updated_at, base_materialization_id, base_commit_id
         ) VALUES (
           ${input.projectId}, ${input.source.projectionId}, ${input.materializationId},
           ${input.execution.projectionRunId}, ${input.projectionKind}, 'replacement',
           'staging', ${input.execution.executionToken}, ${input.datasetVersion.datasetId},
           ${input.datasetVersion.versionId}, ${input.datasetVersion.createdAt},
           ${input.projectionRevision}, ${input.ownershipHash}, ${input.ontologyRevision},
-          NULL, NULL, ${input.createdAt}, NULL, NULL, NULL, NULL, ${input.createdAt}
+          NULL, NULL, ${input.createdAt}, NULL, NULL, NULL, NULL, ${input.createdAt},
+          ${input.base?.materializationId ?? null}, ${input.base?.lastCommitId ?? null}
         )
         ON CONFLICT DO NOTHING
         RETURNING *
@@ -12322,6 +12607,7 @@ class PgOntologySourceStorage {
       const rows = sourceStageRows(manifest.projection_kind, input.rows);
       const existing = await this.findStageRows(sql, input, rows);
       const { pending, unchanged } = reconcileSourceStageRows(rows, existing);
+      await stageSourceRoots(sql, manifest, input);
       await this.insertStageRows(sql, input, pending);
       return { inserted: pending.length, unchanged };
     });
@@ -12345,7 +12631,10 @@ class PgOntologySourceStorage {
         throw sourceConflict(`Source materialization '${input.materializationId}' cannot transition from '${manifest.status}' to 'ready'.`);
       }
       if (input.readyAt < toIsoString2(manifest.created_at)) {
-        throw new MaterializationValidationError2("Source readyAt cannot precede source createdAt.");
+        throw new MaterializationValidationError3("Source readyAt cannot precede source createdAt.");
+      }
+      if (input.assertionCount >= 1000 || input.rootCount >= 1000) {
+        await sql`ANALYZE ontology_source_rows, ontology_source_roots`;
       }
       await this.assertReadyState(sql, manifest, input.rootCount, input.assertionCount);
       const rows = await sql`
@@ -12392,61 +12681,7 @@ class PgOntologySourceStorage {
       assertNonblank(input.projectId, "Terminal source cleanup project id");
       assertTimestamp(input.terminalBefore, "Terminal source cleanup cutoff", true);
       assertPositiveInteger(input.limit, "Terminal source cleanup limit");
-      const manifests = await sql`
-        SELECT * FROM ontology_sources
-        WHERE project_id = ${input.projectId}
-          AND status IN ('superseded', 'abandoned')
-          AND terminal_at < ${input.terminalBefore}
-        ORDER BY terminal_at, source_id, materialization_id
-        LIMIT ${input.limit}
-        FOR UPDATE SKIP LOCKED
-      `;
-      let remaining = input.limit;
-      let rowsDeleted = 0;
-      let materializationsDeleted = 0;
-      for (const manifest of manifests) {
-        if (remaining === 0)
-          break;
-        const deletedRows = await sql`
-          WITH selected AS (
-            SELECT rows.ctid
-            FROM ontology_source_rows AS rows
-            WHERE rows.project_id = ${manifest.project_id}
-              AND rows.source_id = ${manifest.source_id}
-              AND rows.materialization_id = ${manifest.materialization_id}
-            ORDER BY rows.entity_sort_key
-            LIMIT ${remaining}
-            FOR UPDATE SKIP LOCKED
-          )
-          DELETE FROM ontology_source_rows AS rows
-          USING selected
-          WHERE rows.ctid = selected.ctid
-          RETURNING rows.entity_sort_key
-        `;
-        rowsDeleted += deletedRows.length;
-        remaining -= deletedRows.length;
-        if (remaining === 0)
-          break;
-        const removed = await sql`
-          DELETE FROM ontology_sources AS sources
-          WHERE sources.project_id = ${manifest.project_id}
-            AND sources.source_id = ${manifest.source_id}
-            AND sources.materialization_id = ${manifest.materialization_id}
-            AND sources.status IN ('superseded', 'abandoned')
-            AND sources.terminal_at = ${manifest.terminal_at}
-            AND sources.terminal_at < ${input.terminalBefore}
-            AND NOT EXISTS (
-              SELECT 1 FROM ontology_source_rows AS rows
-              WHERE rows.project_id = sources.project_id
-                AND rows.source_id = sources.source_id
-                AND rows.materialization_id = sources.materialization_id
-            )
-          RETURNING sources.materialization_id
-        `;
-        materializationsDeleted += removed.length;
-        remaining -= removed.length;
-      }
-      return { rowsDeleted, materializationsDeleted };
+      return cleanupSourceVersions(sql, input);
     });
   }
   async summarizeTerminal(input) {
@@ -12494,7 +12729,7 @@ class PgOntologySourceStorage {
   }
   async transitionToAbandoned(sql, manifest, abandonedAt) {
     if (abandonedAt < toIsoString2(manifest.created_at) || manifest.ready_at !== null && abandonedAt < toIsoString2(manifest.ready_at)) {
-      throw new MaterializationValidationError2("Source abandonedAt cannot precede source creation or readiness.");
+      throw new MaterializationValidationError3("Source abandonedAt cannot precede source creation or readiness.");
     }
     const rows = await sql`
       UPDATE ontology_sources
@@ -12509,14 +12744,19 @@ class PgOntologySourceStorage {
     if (!rows[0]) {
       throw sourceConflict(`Source materialization '${manifest.materialization_id}' cannot transition to 'abandoned'.`);
     }
+    await sql`UPDATE ontology_source_roots SET retired_at = ${abandonedAt}
+      WHERE project_id = ${manifest.project_id} AND source_id = ${manifest.source_id}
+        AND materialization_id = ${manifest.materialization_id} AND NOT active`;
     return sourceRecord(rows[0]);
   }
   async assertReadyState(sql, manifest, rootCount, assertionCount) {
     const [counts] = await sql`
-      SELECT COUNT(*) AS assertions, COUNT(DISTINCT root_key) AS roots,
+      SELECT (SELECT COUNT(*) FROM ontology_source_rows
+        WHERE project_id = ${manifest.project_id} AND source_id = ${manifest.source_id}
+          AND materialization_id = ${manifest.materialization_id}) AS assertions, COUNT(*) AS roots,
         COUNT(DISTINCT staging_ordinal) AS ordinals,
         MIN(staging_ordinal) AS min_ordinal, MAX(staging_ordinal) AS max_ordinal
-      FROM ontology_source_rows
+      FROM ontology_source_roots
       WHERE project_id = ${manifest.project_id}
         AND source_id = ${manifest.source_id}
         AND materialization_id = ${manifest.materialization_id}
@@ -12527,8 +12767,9 @@ class PgOntologySourceStorage {
     const minimum = counts?.min_ordinal === null ? null : Number(counts?.min_ordinal);
     const maximum = counts?.max_ordinal === null ? null : Number(counts?.max_ordinal);
     if (assertions !== assertionCount || roots !== rootCount || ordinals !== rootCount || rootCount > 0 && (minimum !== 0 || maximum !== rootCount - 1)) {
-      throw new MaterializationValidationError2("Source ready counts do not match the staged roots and assertions.");
+      throw new MaterializationValidationError3("Source ready counts do not match the staged roots and assertions.");
     }
+    await assertSourceRootCoverage(sql, manifest);
     const [invalid] = manifest.projection_kind === "link" ? await sql`
             SELECT root_key
             FROM ontology_source_rows
@@ -12562,15 +12803,15 @@ class PgOntologySourceStorage {
             LIMIT 1
           `;
     if (invalid) {
-      throw new MaterializationValidationError2(manifest.projection_kind === "link" ? "Link projection roots must contain exactly their matching link assertion." : "Object projection roots must contain exactly their matching object assertion plus links sourced from that root.");
+      throw new MaterializationValidationError3(manifest.projection_kind === "link" ? "Link projection roots must contain exactly their matching link assertion." : "Object projection roots must contain exactly their matching object assertion plus links sourced from that root.");
     }
   }
   async findStageRows(sql, input, rows) {
     if (rows.length === 0)
       return [];
-    const rootSortKeys = [...new Set(rows.map((row) => utf8SortKey(row.rootKey)))];
+    const rootSortKeys = [...new Set(rows.map((row) => utf8SortKey2(row.rootKey)))];
     const ordinals = [...new Set(rows.map((row) => row.row.stagingOrdinal))];
-    const entitySortKeys = [...new Set(rows.map((row) => utf8SortKey(row.entityKey)))];
+    const entitySortKeys = [...new Set(rows.map((row) => utf8SortKey2(row.entityKey)))];
     const existing = await sql`
       SELECT * FROM ontology_source_rows
       WHERE project_id = ${input.projectId}
@@ -12593,10 +12834,10 @@ class PgOntologySourceStorage {
       return {
         entityKind: row.assertion.kind,
         entityKey: JSON.parse(entityKey),
-        entitySortKey: utf8SortKey(entityKey),
+        entitySortKey: utf8SortKey2(entityKey),
         rootKind: row.root.kind,
         rootKey: JSON.parse(rootKey),
-        rootSortKey: utf8SortKey(rootKey),
+        rootSortKey: utf8SortKey2(rootKey),
         stagingOrdinal: row.stagingOrdinal,
         root: row.root,
         assertion: row.assertion,
@@ -15256,7 +15497,7 @@ class PgProjectionRunStorage {
             input_exhausted = ${input.fixedBatchSize === undefined ? null : false},
             missing_target_object_type_id = ${null}, missing_target_object_id = ${null},
             missing_target_batch_ordinal = ${null}, missing_target_first_seen_at = ${null},
-            source_rows_read = ${0}, source_rows_skipped = ${0}, error = ${null}
+            source_rows_read = ${0}, source_rows_skipped = ${0}, source_changes_read = ${null}, error = ${null}
           WHERE project_id = ${input.projectId} AND id = ${input.id}
             AND status = ${"failed"} AND error->>'code' = ${"queue.enqueue_failed"}
           RETURNING *
@@ -15367,7 +15608,8 @@ class PgProjectionRunStorage {
         UPDATE projection_runs
         SET
           source_rows_read = ${progress.sourceRowsRead},
-          source_rows_skipped = ${progress.sourceRowsSkipped}
+          source_rows_skipped = ${progress.sourceRowsSkipped},
+          source_changes_read = ${progress.sourceChangesRead ?? null}
         WHERE project_id = ${input.projectId}
           AND id = ${input.id}
           AND status = ${"running"}
@@ -15392,6 +15634,7 @@ class PgProjectionRunStorage {
           execution_token = ${null},
           source_rows_read = ${plan.progress.sourceRowsRead},
           source_rows_skipped = ${plan.progress.sourceRowsSkipped},
+          source_changes_read = ${plan.progress.sourceChangesRead ?? null},
           input_exhausted = ${plan.inputExhausted ?? existingRow.input_exhausted},
           error = ${plan.error === undefined ? null : serializeSixbFailure4(plan.error, PROJECTION_RUN_FAILURE_CODES)}::text::jsonb
         WHERE project_id = ${input.projectId}
@@ -15634,7 +15877,8 @@ function restoreProjectionRunRow(row) {
     missingTargetFirstSeenAt: row.missing_target_first_seen_at ? new Date(row.missing_target_first_seen_at) : undefined,
     progress: {
       sourceRowsRead: databaseSafeInteger2(row.source_rows_read, "sourceRowsRead"),
-      sourceRowsSkipped: databaseSafeInteger2(row.source_rows_skipped, "sourceRowsSkipped")
+      sourceRowsSkipped: databaseSafeInteger2(row.source_rows_skipped, "sourceRowsSkipped"),
+      ...row.source_changes_read == null ? {} : { sourceChangesRead: databaseSafeInteger2(row.source_changes_read, "sourceChangesRead") }
     },
     error: row.error ?? undefined
   };
@@ -17866,4 +18110,4 @@ export {
   migratePostgresStorage
 };
 
-//# debugId=E76835E14E96BFEC64756E2164756E21
+//# debugId=672C519862E8368164756E2164756E21