@sixb/pg 0.1.8 → 0.1.10

package/dist/index.js

@@ -2,6 +2,10 @@
 // src/index.ts
 import { AsyncLocalStorage } from "async_hooks";
 import { ProviderMaterializationTransactionLifecycle } from "@sixb/core/internal/ontology-storage-provider";
+import {
+  createTransactionStorageProxy,
+  throwNestedStorageTransaction
+} from "@sixb/core/internal/storage";
 import {
   createAgentOperationScope,
   createAuthOperationScope,
@@ -12,9 +16,7 @@ import {
   createWorkflowRunOperationScope
 } from "@sixb/core/internal/storage-operation-scope";
 import {
-  createTransactionStorageProxy,
-  StorageTransactionError,
-  throwNestedStorageTransaction
+  StorageTransactionError
 } from "@sixb/core/storage";
 
 // src/agents/checkpoints.ts
@@ -147,7 +149,6 @@ function rowToRunRecord(row) {
     id: row.id,
     projectId: row.project_id,
     executionId: row.execution_id,
-    requesterGroupIds: typeof row.requester_group_ids === "string" ? JSON.parse(row.requester_group_ids) : row.requester_group_ids,
     status: row.status,
     modelId: row.model_id ?? undefined,
     finishReason: coerceAgentRunFinishReason(row.finish_reason),
@@ -580,7 +581,6 @@ import {
   assertSubagentRunResult,
   subagentRunMatchesCreateInput
 } from "@sixb/core/internal/agent-run-storage-provider";
-import { normalizeRequesterGroupIds } from "@sixb/core/internal/auth";
 import { serializeSixbFailure } from "@sixb/core/internal/errors";
 import {
   AGENT_RUN_FAILURE_CODES as AGENT_RUN_FAILURE_CODES2,
@@ -683,7 +683,6 @@ class PgAgentRunStore {
             thread_id,
             trigger_message_id,
             spec,
-            requester_group_ids,
             status,
             attempt,
             created_at
@@ -695,7 +694,6 @@ class PgAgentRunStore {
             ${input.threadId},
             ${input.triggerMessageId},
             ${JSON.stringify(input.spec)}::text::jsonb,
-            ${JSON.stringify(normalizeRequesterGroupIds(input.requesterGroupIds))}::text::jsonb,
             ${"queued"},
             ${0},
             ${createdAt}
@@ -756,7 +754,6 @@ class PgAgentRunStore {
         if (parent.execution_token !== input.parentExecutionToken) {
           throw new AgentStorageError3("execution_lost", `[SixbPg] Parent Agent run '${parent.id}' is no longer owned by this execution.`);
         }
-        const parentRecord = rowToRunRecord(parent);
         const [countRow] = await tx`
           SELECT COUNT(*)::bigint AS count FROM agent_runs
           WHERE project_id = ${input.projectId}
@@ -770,12 +767,11 @@ class PgAgentRunStore {
         const [row] = await tx`
           INSERT INTO agent_runs (
             project_id, id, execution_id, kind, parent_run_id, spawn_key, spec,
-            requester_group_ids, status, attempt, created_at
+            status, attempt, created_at
           ) VALUES (
             ${input.projectId}, ${input.id}, ${input.executionId}, ${"subagent"},
             ${input.parentRunId}, ${input.spawnKey},
             ${JSON.stringify(input.spec)}::text::jsonb,
-            ${JSON.stringify(parentRecord.requesterGroupIds)}::text::jsonb,
             ${"queued"}, ${0}, ${input.createdAt ?? new Date}
           )
           RETURNING *
@@ -1871,13 +1867,13 @@ class PgAuthAccessTokenStore {
   }
   async assertSubjectExists(projectId, subjectType, subjectId) {
     if (subjectType === "user") {
-      const [row2] = await this.sql`
+      const [row] = await this.sql`
         SELECT *
         FROM auth_users
         WHERE project_id = ${projectId}
           AND id = ${subjectId}
       `;
-      if (row2)
+      if (row)
         return;
       throw new AuthStorageError2("missing_user", `[Sixb] User '${subjectId}' not found for project '${projectId}'.`);
     }
@@ -3452,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},
@@ -3745,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 },
@@ -7085,6 +7081,93 @@ 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;
+
+-- Keep historical admission snapshots; never reconstruct them from current memberships.
+WITH RECURSIVE attribution(project_id, id, groups) AS (
+  SELECT e.project_id, e.id, COALESCE(w.requester_group_ids, a.requester_group_ids, '[]'::jsonb)
+  FROM executions e
+  LEFT JOIN workflow_runs w ON w.project_id = e.project_id AND w.execution_id = e.id
+  LEFT JOIN agent_runs a ON a.project_id = e.project_id AND a.execution_id = e.id
+  WHERE e.parent_execution_id IS NULL
+  UNION ALL
+  SELECT e.project_id, e.id, COALESCE(w.requester_group_ids, a.requester_group_ids, p.groups)
+  FROM executions e
+  JOIN attribution p ON p.project_id = e.project_id AND p.id = e.parent_execution_id
+  LEFT JOIN workflow_runs w ON w.project_id = e.project_id AND w.execution_id = e.id
+  LEFT JOIN agent_runs a ON a.project_id = e.project_id AND a.execution_id = e.id
+)
+UPDATE executions e SET requester_group_ids = a.groups
+FROM attribution a WHERE a.project_id = e.project_id AND a.id = e.id;
+
+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) {
@@ -7295,7 +7378,11 @@ var postgresStorageMigrations = defineMigrations({
     pgSql("033-retire-agent-definitions", _033_retire_agent_definitions_default),
     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("036-share-sessions", _036_share_sessions_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)
   ]
 });
 
@@ -7744,18 +7831,18 @@ function compileExpansionOrder(expansion, target, neighborType, neighborId) {
 }
 function compileSet(projectId, op, inputs, ctx) {
   if (inputs.length === 0) {
-    const order2 = compileOrder(identityOrderFields());
+    const order = compileOrder(identityOrderFields());
     return {
       sql: `
         SELECT *, properties AS _cursor_properties
         FROM ${ctx.source.objectsTable}
         WHERE 1 = 0
-        ORDER BY ${order2.sql}
+        ORDER BY ${order.sql}
       `,
-      args: order2.args,
+      args: order.args,
       totalSql: "SELECT 0::bigint AS total",
       totalArgs: [],
-      order: order2,
+      order,
       hasMore: () => false,
       trimRows: identityRows,
       nextPageToken: () => {
@@ -9428,7 +9515,7 @@ function valuesJoin(sql, select, columns, tuples, where, whereParams) {
   const colWidth = columns.length;
   const base = whereParams.length;
   const valuePlaceholders = tuples.map((_, i) => {
-    const cols = columns.map((_2, j) => `$${base + i * colWidth + j + 1}`);
+    const cols = columns.map((_, j) => `$${base + i * colWidth + j + 1}`);
     return `(${cols.join(",")})`;
   }).join(",");
   const onClause = columns.map((c) => {
@@ -9494,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),
@@ -9662,7 +9755,7 @@ import {
   linkRefKey as linkRefKey3,
   linkRefSortKey,
   linkScopeSortKey as linkScopeSortKey2,
-  MaterializationConflictError as MaterializationConflictError5,
+  MaterializationConflictError as MaterializationConflictError6,
   objectRefKey as objectRefKey3,
   objectRefSortKey,
   telemetryPointKey as telemetryPointKey3,
@@ -9681,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,
@@ -9695,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";
@@ -9707,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";
 
@@ -9739,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})
@@ -9795,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) ?? []
@@ -9831,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(
@@ -9889,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
@@ -9958,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 (
@@ -10037,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);
@@ -10106,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
@@ -10148,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}
       `;
@@ -10169,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,
@@ -10248,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);
@@ -10290,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
@@ -10316,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,
@@ -10329,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
@@ -10372,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
@@ -10463,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);
   }
@@ -10480,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);
   }
@@ -10544,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),
@@ -10557,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),
@@ -10572,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.`);
@@ -10631,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;
 }
@@ -10647,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);
@@ -10659,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;
   }
@@ -10717,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) {
@@ -10745,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) => {
@@ -10756,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 }];
     });
   }
@@ -10910,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";
@@ -11426,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.`);
@@ -11461,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();
@@ -11527,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({
@@ -11538,6 +11778,7 @@ class PgOntologyMaterializationStorage {
         sourceId: replacement.sourceId,
         candidateMaterializationId: replacement.candidateMaterializationId,
         previousMaterializationId: replacement.previousMaterializationId,
+        incremental: replacement.incremental,
         kind: "object",
         pageRows: input.pageRows
       })) {
@@ -11556,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 = [
@@ -11571,6 +11812,7 @@ class PgOntologyMaterializationStorage {
       sourceId: replacement.sourceId,
       candidateMaterializationId: replacement.candidateMaterializationId,
       previousMaterializationId: replacement.previousMaterializationId,
+      incremental: replacement.incremental,
       kind: "link",
       pageRows: input.pageRows
     })) {
@@ -11581,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);
@@ -11604,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) {
@@ -11613,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 };
@@ -11623,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,
@@ -11640,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,
@@ -11665,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)
@@ -11688,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) {
@@ -11710,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) {
@@ -11741,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,
@@ -11774,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
@@ -11794,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
@@ -11806,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.");
     }
@@ -11903,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,
@@ -11916,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,
@@ -11937,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;
@@ -11956,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) {
@@ -11988,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]);
   }
@@ -12036,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 {
@@ -12053,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 (
@@ -12083,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 };
       });
@@ -12204,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);
   }
@@ -12215,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,
@@ -12233,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) {
@@ -12265,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 *
@@ -12301,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 };
     });
@@ -12324,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`
@@ -12371,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) {
@@ -12473,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
@@ -12488,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}
@@ -12506,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
@@ -12541,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}
@@ -12572,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,
@@ -12697,12 +12959,11 @@ import {
 } from "@sixb/core/internal/action-run-storage";
 import { assertActionRunExecution } from "@sixb/core/internal/action-run-storage-provider";
 import {
-  ActionRunError,
   actionRunPhaseRecordsEqual,
   canRequeueActionRunAfterEnqueueFailure,
-  finishActionRunPhase,
-  isTerminalActionRun
-} from "@sixb/core/storage";
+  finishActionRunPhase
+} from "@sixb/core/internal/storage";
+import { ActionRunError, isTerminalActionRun } from "@sixb/core/storage";
 class PgActionRunStorage {
   sql;
   executions;
@@ -12960,8 +13221,8 @@ class PgActionRunStorage {
       params.push(input.actionId);
     }
     if (input.actionIds) {
-      const placeholders2 = input.actionIds.map(() => `$${index++}`);
-      whereClauses.push(`action_id IN (${placeholders2.join(", ")})`);
+      const placeholders = input.actionIds.map(() => `$${index++}`);
+      whereClauses.push(`action_id IN (${placeholders.join(", ")})`);
       params.push(...input.actionIds);
     }
     if (input.objectTypeIds) {
@@ -12970,8 +13231,8 @@ class PgActionRunStorage {
         params.push("object");
       } else {
         const subjectKindIndex = index++;
-        const placeholders2 = input.objectTypeIds.map(() => `$${index++}`);
-        whereClauses.push(`(subject_kind <> $${subjectKindIndex} OR object_type_id IN (${placeholders2.join(", ")}))`);
+        const placeholders = input.objectTypeIds.map(() => `$${index++}`);
+        whereClauses.push(`(subject_kind <> $${subjectKindIndex} OR object_type_id IN (${placeholders.join(", ")}))`);
         params.push("object", ...input.objectTypeIds);
       }
     }
@@ -12998,8 +13259,8 @@ class PgActionRunStorage {
       }
     }
     if (input.statuses) {
-      const placeholders2 = input.statuses.map(() => `$${index++}`);
-      whereClauses.push(`status IN (${placeholders2.join(", ")})`);
+      const placeholders = input.statuses.map(() => `$${index++}`);
+      whereClauses.push(`status IN (${placeholders.join(", ")})`);
       params.push(...input.statuses);
     }
     if (input.startedAfter) {
@@ -13157,6 +13418,7 @@ import {
   aiModelCallCostDetails,
   aiModelCallCostMatchesUsage,
   buildAiAccountingOverviewFromFragments,
+  directModelCallAttribution,
   normalizeAiAccountingQuery,
   normalizeAiModelCallAccountingQuery as normalizeAiModelCallAccountingQuery2,
   normalizeAiModelCallCostRecord,
@@ -13201,6 +13463,7 @@ WITH filtered AS (
   SELECT COALESCE(root_agent.execution_id, usage.execution_id) AS root_execution_id,
     usage.execution_id, usage.provider_id, usage.requested_model_id, usage.occurred_at,
     usage.total_tokens,
+    execution.executor_kind, execution.executor_id, execution.authority_primitive_id AS primitive_id,
     COALESCE(cost.status, 'unvalued') AS valuation_status,
     cost.currency AS amount_currency, cost.amount_nanos,
     root_agent.id AS root_agent_run_id,
@@ -13213,6 +13476,7 @@ WITH filtered AS (
     workflow_node.workflow_id AS workflow_id,
     workflow_node.workflow_run_id AS workflow_run_id
   FROM ai_model_call_usage AS usage
+  JOIN executions AS execution ON execution.project_id = usage.project_id AND execution.id = usage.execution_id
   LEFT JOIN agent_runs AS direct_agent
     ON direct_agent.project_id = usage.project_id AND direct_agent.execution_id = usage.execution_id
   LEFT JOIN agent_runs AS root_agent
@@ -13250,6 +13514,7 @@ SELECT filtered.root_execution_id, execution_id, provider_id, requested_model_id
   CAST(SUM((amount_nanos / 1000000) % 1000000) AS TEXT) AS amount_middle,
   CAST(SUM(amount_nanos % 1000000) AS TEXT) AS amount_low,
   MAX(root_agent_run_id) AS root_agent_run_id,
+  MAX(executor_kind) AS executor_kind, MAX(executor_id) AS executor_id, MAX(primitive_id) AS primitive_id,
   MAX(root_thread_id) AS root_thread_id,
   MAX(direct_kind) AS direct_kind,
   MAX(direct_run_id) AS direct_run_id,
@@ -13264,12 +13529,11 @@ GROUP BY filtered.root_execution_id, execution_id, provider_id, requested_model_
 `;
 
 // src/pg-ai-usage-storage.ts
+import { assertAiUsageExecutionId, normalizeAiModelCallRecord } from "@sixb/core/internal/storage";
 import { isModelReasoning, normalizeModelProviderIds } from "@sixb/core/models";
 import {
   AiUsageStorageError,
-  aggregateAiModelCallUsage,
-  assertAiUsageExecutionId,
-  normalizeAiModelCallRecord
+  aggregateAiModelCallUsage
 } from "@sixb/core/storage";
 class PgAiUsageStorage {
   sql;
@@ -13581,11 +13845,14 @@ class PgAiCostStorage {
             ELSE NULL
           END AS attribution_agent_kind,
           workflow_node.node_id AS attribution_agent_step_id,
-          workflow_node.workflow_id AS attribution_workflow_id,
+          COALESCE(workflow_node.workflow_id,
+            CASE WHEN execution.executor_kind = 'workflow' THEN execution.authority_primitive_id END
+          ) AS attribution_workflow_id,
           cost.status AS cost_status,
           cost.currency AS cost_currency,
           cost.amount_nanos AS cost_amount_nanos
         FROM ai_model_call_usage AS usage
+        JOIN executions AS execution ON execution.project_id = usage.project_id AND execution.id = usage.execution_id
         LEFT JOIN agent_runs AS direct_agent
           ON direct_agent.project_id = usage.project_id
           AND direct_agent.execution_id = usage.execution_id
@@ -13712,6 +13979,7 @@ class PgAiCostStorage {
         workflow_agent.node_run_id AS attribution_node_run_id,
         workflow_node.workflow_id AS attribution_workflow_id,
         workflow_node.workflow_run_id AS attribution_workflow_run_id,
+        execution.executor_kind, execution.executor_id, execution.authority_primitive_id AS primitive_id,
         COALESCE((
           SELECT jsonb_agg(groups.group_id ORDER BY groups.group_id)
           FROM ai_model_call_usage_groups AS groups
@@ -13726,6 +13994,7 @@ class PgAiCostStorage {
         cost.details AS cost_details,
         cost.rated_at AS cost_rated_at
       FROM ai_model_call_usage AS usage
+      JOIN executions AS execution ON execution.project_id = usage.project_id AND execution.id = usage.execution_id
       LEFT JOIN agent_runs AS direct_agent
         ON direct_agent.project_id = usage.project_id
         AND direct_agent.execution_id = usage.execution_id
@@ -13814,7 +14083,7 @@ function meterFragment(presentCallCount, total) {
 function accountingItemFromRow(row) {
   const usage = usageFromRow2(row, parseStringArray(row.requester_group_ids));
   const cost = row.cost_status === null ? undefined : costFromJoinedRow(row);
-  const attribution = row.attribution_kind === null ? undefined : row.attribution_kind === "agent" ? {
+  const attribution = row.attribution_kind === null ? directModelCallAttribution(row.executor_kind, row.executor_id, row.primitive_id) : row.attribution_kind === "agent" ? {
     kind: "agent",
     agentRunId: required2(row.attribution_agent_run_id),
     threadId: required2(row.attribution_thread_id)
@@ -14649,8 +14918,7 @@ function createPgClient(options) {
 import {
   executionRecordFromStorageRow,
   executionRecordToStorageRow,
-  normalizeExecutionRecord,
-  validateExecutionRecordReferences
+  prepareExecutionRecord
 } from "@sixb/core/internal/execution-storage";
 import { ExecutionStorageError } from "@sixb/core/storage";
 class PgExecutionStorage {
@@ -14663,8 +14931,7 @@ class PgExecutionStorage {
     this.shareSessions = shareSessions;
   }
   async create(input) {
-    const record = normalizeExecutionRecord(input);
-    await validateExecutionRecordReferences(record, {
+    const record = await prepareExecutionRecord(input, {
       auth: this.auth,
       getExecution: (params) => this.getById(params),
       getShareSession: (params) => this.shareSessions.getById(params)
@@ -14681,6 +14948,7 @@ class PgExecutionStorage {
           source_id,
           requested_by_user_id,
           requested_by_service_account_id,
+          requester_group_ids,
           correlation_id,
           parent_execution_id,
           authority_kind,
@@ -14704,6 +14972,7 @@ class PgExecutionStorage {
           ${row.sourceId},
           ${row.requestedByUserId},
           ${row.requestedByServiceAccountId},
+          ${JSON.stringify(row.requesterGroupIds)}::text::jsonb,
           ${row.correlationId},
           ${row.parentExecutionId},
           ${row.authorityKind},
@@ -14751,6 +15020,7 @@ function toStorageRow(row) {
     sourceId: row.source_id,
     requestedByUserId: row.requested_by_user_id,
     requestedByServiceAccountId: row.requested_by_service_account_id,
+    requesterGroupIds: row.requester_group_ids,
     correlationId: row.correlation_id,
     parentExecutionId: row.parent_execution_id,
     authorityKind: row.authority_kind,
@@ -14771,11 +15041,8 @@ function toStorageRow(row) {
 // src/pg-pipeline-run-storage.ts
 import { parseSixbFailure as parseSixbFailure3, serializeSixbFailure as serializeSixbFailure3 } from "@sixb/core/internal/errors";
 import { assertPipelineRunExecution } from "@sixb/core/internal/pipeline-run-storage-provider";
-import {
-  canRequeuePipelineRunAfterEnqueueFailure,
-  PIPELINE_RUN_FAILURE_CODES,
-  PipelineRunError
-} from "@sixb/core/storage";
+import { canRequeuePipelineRunAfterEnqueueFailure } from "@sixb/core/internal/storage";
+import { PIPELINE_RUN_FAILURE_CODES, PipelineRunError } from "@sixb/core/storage";
 
 // src/latest-run-query.ts
 async function queryLatestRunsByOwnerId(input) {
@@ -14783,12 +15050,12 @@ async function queryLatestRunsByOwnerId(input) {
   if (ownerIds.length === 0) {
     return [];
   }
-  const placeholders2 = ownerIds.map((_, index) => `$${index + 2}`).join(", ");
+  const placeholders = ownerIds.map((_, index) => `$${index + 2}`).join(", ");
   const orderColumn = input.tableName === "sync_runs" || input.tableName === "pipeline_runs" || input.tableName === "projection_runs" ? "COALESCE(started_at, queued_at)" : "started_at";
   const rows = await input.sql.unsafe(`
       SELECT DISTINCT ON (${input.ownerColumn}) ${input.selectList ?? "*"}
       FROM ${input.tableName}
-      WHERE project_id = $1 AND ${input.ownerColumn} IN (${placeholders2})
+      WHERE project_id = $1 AND ${input.ownerColumn} IN (${placeholders})
       ORDER BY ${input.ownerColumn}, ${orderColumn} DESC, id DESC
     `, [input.projectId, ...ownerIds]);
   const latestByOwnerId = new Map(rows.map((row) => [input.ownerIdFor(row), row]));
@@ -15031,8 +15298,8 @@ class PgPipelineRunStorage {
       params.push(input.pipelineId);
     }
     if (input.pipelineIds) {
-      const placeholders2 = input.pipelineIds.map(() => `$${index++}`).join(", ");
-      whereClauses.push(`pipeline_id IN (${placeholders2})`);
+      const placeholders = input.pipelineIds.map(() => `$${index++}`).join(", ");
+      whereClauses.push(`pipeline_id IN (${placeholders})`);
       params.push(...input.pipelineIds);
     }
     index = appendRunListFilters(whereClauses, params, index, input, "COALESCE(started_at, queued_at)");
@@ -15230,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 *
@@ -15341,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"}
@@ -15366,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}
@@ -15467,16 +15736,16 @@ class PgProjectionRunStorage {
       if (input.objectTypeIds.length === 0) {
         return { runs: [], hasMore: false, total: 0 };
       }
-      const placeholders2 = input.objectTypeIds.map(() => `$${index++}`);
-      const list = placeholders2.join(", ");
+      const placeholders = input.objectTypeIds.map(() => `$${index++}`);
+      const list = placeholders.join(", ");
       const sourceList = input.objectTypeIds.map(() => `$${index++}`).join(", ");
       const targetList = input.objectTypeIds.map(() => `$${index++}`).join(", ");
       whereClauses.push(`(object_type_id IN (${list})` + ` OR (source_object_type_id IN (${sourceList})` + ` AND target_object_type_id IN (${targetList})))`);
       params.push(...input.objectTypeIds, ...input.objectTypeIds, ...input.objectTypeIds);
     }
     if (input.statuses) {
-      const placeholders2 = input.statuses.map(() => `$${index++}`);
-      whereClauses.push(`status IN (${placeholders2.join(", ")})`);
+      const placeholders = input.statuses.map(() => `$${index++}`);
+      whereClauses.push(`status IN (${placeholders.join(", ")})`);
       params.push(...input.statuses);
     }
     if (input.startedAfter) {
@@ -15608,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
   };
@@ -15694,8 +15964,8 @@ class PgRulesStorage {
       params.push(input.objectTypeId);
     }
     if (input.objectTypeIds) {
-      const placeholders2 = input.objectTypeIds.map(() => `$${index++}`);
-      whereClauses.push(`object_type_id IN (${placeholders2.join(", ")})`);
+      const placeholders = input.objectTypeIds.map(() => `$${index++}`);
+      whereClauses.push(`object_type_id IN (${placeholders.join(", ")})`);
       params.push(...input.objectTypeIds);
     }
     if (input.primaryId) {
@@ -15871,12 +16141,9 @@ function toIsoString3(value) {
 
 // src/pg-sync-run-storage.ts
 import { parseSixbFailure as parseSixbFailure4, serializeSixbFailure as serializeSixbFailure5 } from "@sixb/core/internal/errors";
+import { canRequeueSyncRunAfterEnqueueFailure } from "@sixb/core/internal/storage";
 import { assertSyncRunExecution } from "@sixb/core/internal/sync-run-storage-provider";
-import {
-  canRequeueSyncRunAfterEnqueueFailure,
-  SYNC_RUN_FAILURE_CODES,
-  SyncRunError
-} from "@sixb/core/storage";
+import { SYNC_RUN_FAILURE_CODES, SyncRunError } from "@sixb/core/storage";
 class PgSyncRunStorage {
   sql;
   executions;
@@ -16036,8 +16303,8 @@ class PgSyncRunStorage {
       params.push(input.syncId);
     }
     if (input.syncIds) {
-      const placeholders2 = input.syncIds.map(() => `$${index++}`);
-      whereClauses.push(`sync_id IN (${placeholders2.join(", ")})`);
+      const placeholders = input.syncIds.map(() => `$${index++}`);
+      whereClauses.push(`sync_id IN (${placeholders.join(", ")})`);
       params.push(...input.syncIds);
     }
     if (input.datasetId) {
@@ -16139,14 +16406,14 @@ class PgTimeseriesStorage {
     const params = [];
     let nextIndex = 1;
     const values = input.series.map((series, seriesIndex) => {
-      const placeholders2 = [
+      const placeholders = [
         `$${nextIndex++}`,
         `$${nextIndex++}`,
         `$${nextIndex++}`,
         `$${nextIndex++}`
       ];
       params.push(seriesIndex, series.objectTypeId, series.objectId, series.propertyId);
-      return `(${placeholders2.join(", ")})`;
+      return `(${placeholders.join(", ")})`;
     }).join(", ");
     const projectIdPlaceholder = `$${nextIndex++}`;
     params.push(input.projectId);
@@ -16498,8 +16765,8 @@ class PgWorkflowInterventionStorage {
     const params = [input.projectId];
     let index = 2;
     if (input.statuses) {
-      const placeholders2 = input.statuses.map(() => `$${index++}`);
-      whereClauses.push(`status IN (${placeholders2.join(", ")})`);
+      const placeholders = input.statuses.map(() => `$${index++}`);
+      whereClauses.push(`status IN (${placeholders.join(", ")})`);
       params.push(...input.statuses);
     }
     if (input.workflowId) {
@@ -16507,8 +16774,8 @@ class PgWorkflowInterventionStorage {
       params.push(input.workflowId);
     }
     if (input.workflowIds) {
-      const placeholders2 = input.workflowIds.map(() => `$${index++}`);
-      whereClauses.push(`workflow_id IN (${placeholders2.join(", ")})`);
+      const placeholders = input.workflowIds.map(() => `$${index++}`);
+      whereClauses.push(`workflow_id IN (${placeholders.join(", ")})`);
       params.push(...input.workflowIds);
     }
     if (input.workflowRunId) {
@@ -16622,7 +16889,6 @@ function assertNonNegativeInteger(value, fieldName) {
 }
 
 // src/pg-workflow-run-storage.ts
-import { normalizeRequesterGroupIds as normalizeRequesterGroupIds2 } from "@sixb/core/internal/auth";
 import { parseSixbFailure as parseSixbFailure6, serializeSixbFailure as serializeSixbFailure7 } from "@sixb/core/internal/errors";
 import {
   assertWorkflowAgentNodeRunExecution,
@@ -16664,7 +16930,6 @@ class PgWorkflowRunStorage {
           input,
           queued_at,
           started_at,
-          requester_group_ids,
           attempt
         ) VALUES (
           ${input.projectId},
@@ -16675,7 +16940,6 @@ class PgWorkflowRunStorage {
           ${serializeRecord2(input.input)}::text::jsonb,
           ${queuedAt},
           ${queuedAt},
-          ${JSON.stringify(normalizeRequesterGroupIds2(input.requesterGroupIds))}::text::jsonb,
           ${0}
         )
         RETURNING *
@@ -16861,8 +17125,8 @@ class PgWorkflowRunStorage {
       params.push(input.workflowId);
     }
     if (input.workflowIds) {
-      const placeholders2 = input.workflowIds.map(() => `$${index++}`);
-      whereClauses.push(`workflow_id IN (${placeholders2.join(", ")})`);
+      const placeholders = input.workflowIds.map(() => `$${index++}`);
+      whereClauses.push(`workflow_id IN (${placeholders.join(", ")})`);
       params.push(...input.workflowIds);
     }
     index = appendRunListFilters(whereClauses, params, index, input);
@@ -17268,7 +17532,6 @@ function rowToWorkflowRunRecord(row) {
     startedAt: new Date(row.started_at),
     finishedAt: row.finished_at ? new Date(row.finished_at) : undefined,
     error: row.error === null ? undefined : parseSixbFailure6(row.error, WORKFLOW_RUN_FAILURE_CODES),
-    requesterGroupIds: parseJson(row.requester_group_ids),
     attempt: Number(row.attempt),
     ...row.execution_token && row.execution_queue_lease_expires_at ? {
       execution: {
@@ -17843,8 +18106,8 @@ function resolveTimeoutMillis(value, label) {
   return Math.trunc(value);
 }
 export {
-  migratePostgresStorage,
-  PostgresStorage
+  PostgresStorage,
+  migratePostgresStorage
 };
 
-//# debugId=66A7E573B9EBA9B464756E2164756E21
+//# debugId=672C519862E8368164756E2164756E21