@sixb/sqlite 0.1.13 → 0.1.15

package/src/ontology-storage/sources.ts

@@ -10,15 +10,18 @@ import {
   isExactStagingManifest,
   reconcileSourceStageRows,
   type SourceStageRow,
+  sourceAssertionPayload,
   sourceConflict,
   sourceMaterializationIdentity,
   sourceStageRow,
   sourceStageRows,
-  utf8SortKey,
 } from "@sixb/core/internal/ontology-storage-provider"
 import type {
+  AbandonRunSourceMaterializationInput,
   AbandonSourceMaterializationCandidateInput,
   AbandonSourceMaterializationInput,
+  AdoptedSourceMaterialization,
+  AdoptSourceMaterializationInput,
   AssertSourceMaterializationExecutionInput,
   BeginSourceMaterializationInput,
   CleanupTerminalSourceMaterializationsInput,
@@ -27,7 +30,7 @@ import type {
   MarkSourceMaterializationReadyInput,
   OntologySourceRecord,
   OntologySourceStorage,
-  ReclaimSourceMaterializationInput,
+  PurgeAbandonedSourceMaterializationsInput,
   StageSourceRowsInput,
   StageSourceRowsResult,
   SummarizeTerminalSourceMaterializationsInput,
@@ -47,8 +50,12 @@ import {
   sourceAssertion,
   sourceRecord,
 } from "./shared"
-import { cleanupSourceVersions } from "./source-cleanup"
-import { assertSourceRootCoverage, stageSourceRoots } from "./source-roots"
+import { cleanupSourceVersions, purgeAbandonedSourceVersions } from "./source-cleanup"
+import {
+  assertSourceRootCoverage,
+  SOURCE_ASSERTION_COLUMNS,
+  stageSourceRoots,
+} from "./source-roots"
 
 export class SqliteOntologySourceStorage implements OntologySourceStorage {
   constructor(
@@ -87,7 +94,7 @@ export class SqliteOntologySourceStorage implements OntologySourceStorage {
         .get(input.projectId, input.execution.projectionRunId)
       if (candidate) {
         throw sourceConflict(
-          `Projection run '${input.execution.projectionRunId}' already has a nonterminal source materialization; reclaim it before beginning another.`
+          `Projection run '${input.execution.projectionRunId}' already has a nonterminal source materialization; adopt it before beginning another.`
         )
       }
 
@@ -146,10 +153,10 @@ export class SqliteOntologySourceStorage implements OntologySourceStorage {
       }
 
       const rows = sourceStageRows(manifest.projection_kind, input.rows)
-      const existing = this.findStageRows(input, rows)
+      const existing = this.findStageRows(manifest, rows)
       const { pending, unchanged } = reconcileSourceStageRows(rows, existing)
       stageSourceRoots(this.db, manifest, input)
-      this.insertStageRows(input, pending)
+      this.insertStageRows(manifest, pending)
       return { inserted: pending.length, unchanged }
     })
     await yieldSqliteEventLoop()
@@ -233,17 +240,59 @@ export class SqliteOntologySourceStorage implements OntologySourceStorage {
     })
   }
 
+  async adopt(
+    input: AdoptSourceMaterializationInput
+  ): Promise<AdoptedSourceMaterialization | null> {
+    return this.runRootOperation(() => {
+      assertProjectAndSource(input)
+      assertExecutionIdentity(input.execution.projectionRunId, input.execution.executionToken)
+      assertTimestamp(input.adoptedAt, "Source adoptedAt", true)
+      this.assertExecution(input)
+      const candidate = this.findRunCandidate(input)
+      if (!candidate) return null
+      // Workers' clocks differ; adoption never moves the record back in time.
+      const changed = this.db
+        .query(
+          `
+            UPDATE ontology_sources SET execution_token = ?, updated_at = MAX(updated_at, ?)
+            WHERE project_id = ? AND source_id = ? AND materialization_id = ?
+              AND status IN ('staging', 'ready')
+          `
+        )
+        .run(
+          input.execution.executionToken,
+          input.adoptedAt,
+          candidate.project_id,
+          candidate.source_id,
+          candidate.materialization_id
+        ).changes
+      if (changed !== 1) {
+        throw sourceConflict(`Source materialization '${candidate.materialization_id}' changed.`)
+      }
+      const adopted = this.requireManifest(
+        candidate.project_id,
+        candidate.source_id,
+        candidate.materialization_id
+      )
+      return {
+        record: sourceRecord(adopted),
+        resumeStagingOrdinal:
+          adopted.status === "ready" ? Number(adopted.root_count) : this.lastStagedOrdinal(adopted),
+      }
+    })
+  }
+
   async abandon(input: AbandonSourceMaterializationCandidateInput): Promise<OntologySourceRecord>
-  async abandon(input: ReclaimSourceMaterializationInput): Promise<OntologySourceRecord | null>
+  async abandon(input: AbandonRunSourceMaterializationInput): Promise<OntologySourceRecord | null>
   async abandon(input: AbandonSourceMaterializationInput): Promise<OntologySourceRecord | null> {
     return this.runRootOperation(() => {
       assertProjectAndSource(input)
       assertExecutionIdentity(input.execution.projectionRunId, input.execution.executionToken)
       assertTimestamp(input.abandonedAt, "Source abandonedAt", true)
       this.assertExecution(input)
-      return input.kind === "candidate"
-        ? this.abandonCandidate(input)
-        : this.abandonForReclaim(input)
+      if (input.kind === "candidate") return this.abandonCandidate(input)
+      const candidate = this.findRunCandidate(input)
+      return candidate ? this.transitionToAbandoned(candidate, input.abandonedAt) : null
     })
   }
 
@@ -258,6 +307,16 @@ export class SqliteOntologySourceStorage implements OntologySourceStorage {
     })
   }
 
+  async purgeAbandoned(
+    input: PurgeAbandonedSourceMaterializationsInput
+  ): Promise<CleanupTerminalSourceMaterializationsResult> {
+    return this.runRootOperation(() => {
+      assertNonblank(input.projectId, "Abandoned source purge project id")
+      assertPositiveInteger(input.limit, "Abandoned source purge limit")
+      return purgeAbandonedSourceVersions(this.db, input)
+    })
+  }
+
   async summarizeTerminal(
     input: SummarizeTerminalSourceMaterializationsInput
   ): Promise<TerminalSourceMaterializationSummary> {
@@ -305,7 +364,12 @@ export class SqliteOntologySourceStorage implements OntologySourceStorage {
     return this.transitionToAbandoned(manifest, input.abandonedAt)
   }
 
-  private abandonForReclaim(input: ReclaimSourceMaterializationInput): OntologySourceRecord | null {
+  /** The run's one staging or ready candidate, whichever execution staged it. */
+  private findRunCandidate(input: {
+    readonly projectId: string
+    readonly source: { readonly projectionId: string }
+    readonly execution: { readonly projectionRunId: string }
+  }): SqliteOntologySourceRow | null {
     const candidates = this.db
       .query(
         `
@@ -319,19 +383,23 @@ export class SqliteOntologySourceStorage implements OntologySourceStorage {
         input.source.projectionId,
         input.execution.projectionRunId
       ) as SqliteOntologySourceRow[]
-    if (
-      candidates.some((candidate) => candidate.execution_token === input.execution.executionToken)
-    ) {
-      throw sourceConflict(
-        `Projection run '${input.execution.projectionRunId}' already has a source materialization owned by the current execution.`
-      )
-    }
     if (candidates.length > 1) {
       throw sourceConflict(
         `Projection run '${input.execution.projectionRunId}' has multiple nonterminal source materializations.`
       )
     }
-    return candidates[0] ? this.transitionToAbandoned(candidates[0], input.abandonedAt) : null
+    return candidates[0] ?? null
+  }
+
+  private lastStagedOrdinal(manifest: SqliteOntologySourceRow): number {
+    const last = this.db
+      .query(
+        "SELECT MAX(staging_ordinal) AS ordinal FROM ontology_source_roots WHERE version_id = ?"
+      )
+      .get(manifest.version_id) as {
+      readonly ordinal: number | null
+    } | null
+    return last?.ordinal ?? 0
   }
 
   private transitionToAbandoned(
@@ -367,10 +435,7 @@ export class SqliteOntologySourceStorage implements OntologySourceStorage {
         `Source materialization '${manifest.materialization_id}' cannot transition to 'abandoned'.`
       )
     }
-    this.db
-      .query(`UPDATE ontology_source_roots SET retired_at = ?
-      WHERE project_id = ? AND source_id = ? AND materialization_id = ? AND active = 0`)
-      .run(abandonedAt, manifest.project_id, manifest.source_id, manifest.materialization_id)
+    // Its roots were never live and stay unpublished; purging removes them with the version.
     return sourceRecord(
       this.requireManifest(manifest.project_id, manifest.source_id, manifest.materialization_id)
     )
@@ -384,22 +449,16 @@ export class SqliteOntologySourceStorage implements OntologySourceStorage {
     const counts = this.db
       .query(
         `
-          SELECT (SELECT COUNT(*) FROM ontology_source_rows
-            WHERE project_id = ? AND source_id = ? AND materialization_id = ?) AS assertions, COUNT(*) AS roots,
-            COUNT(DISTINCT staging_ordinal) AS ordinals,
+          SELECT (SELECT COUNT(*) FROM ontology_source_roots AS roots
+              JOIN ontology_source_rows AS rows ON rows.root_id = roots.id
+              WHERE roots.version_id = ?1) 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_roots
-          WHERE project_id = ? AND source_id = ? AND materialization_id = ?
+          WHERE version_id = ?1
         `
       )
-      .get(
-        manifest.project_id,
-        manifest.source_id,
-        manifest.materialization_id,
-        manifest.project_id,
-        manifest.source_id,
-        manifest.materialization_id
-      ) as {
+      .get(manifest.version_id) as {
       assertions: number
       roots: number
       ordinals: number
@@ -417,36 +476,52 @@ export class SqliteOntologySourceStorage implements OntologySourceStorage {
       )
     }
     assertSourceRootCoverage(this.db, manifest)
+    // Roots store only their canonical key; compare its parts with each row's typed identity.
     const invalid = this.db
       .query(
         manifest.projection_kind === "link"
           ? `
-              SELECT root_key
-              FROM ontology_source_rows
-              WHERE project_id = ? AND source_id = ? AND materialization_id = ?
-              GROUP BY root_key
-              HAVING COUNT(*) <> 1 OR MIN(root_kind) <> 'link' OR MIN(entity_kind) <> 'link'
-                OR MIN(root_key) <> MIN(entity_key)
+              SELECT roots.root_key
+              FROM ontology_source_roots AS roots
+              JOIN ontology_source_rows AS rows ON rows.root_id = roots.id
+              WHERE roots.version_id = ?
+              GROUP BY roots.id
+              HAVING COUNT(*) <> 1
+                OR MAX(json_extract(roots.root_key, '$[0]') <> 'link')
+                OR MAX(rows.entity_kind <> 'link')
+                OR MAX(rows.source_type_id <> json_extract(roots.root_key, '$[1]')
+                  OR rows.source_primary_id <> json_extract(roots.root_key, '$[2]')
+                  OR rows.link_id <> json_extract(roots.root_key, '$[3]')
+                  OR rows.target_type_id <> json_extract(roots.root_key, '$[4]')
+                  OR rows.target_primary_id <> json_extract(roots.root_key, '$[5]'))
               LIMIT 1
             `
           : `
-              SELECT root_key
-              FROM ontology_source_rows
-              WHERE project_id = ? AND source_id = ? AND materialization_id = ?
-              GROUP BY root_key
-              HAVING MIN(root_kind) <> 'object'
-                OR SUM(CASE WHEN entity_kind = 'object' AND entity_key = root_key THEN 1 ELSE 0 END) <> 1
-                OR SUM(CASE
-                  WHEN entity_kind = 'object' AND entity_key <> root_key THEN 1
-                  WHEN entity_kind = 'link' AND (
-                    source_type_id <> root_object_type_id OR source_primary_id <> root_primary_id
-                  ) THEN 1
-                  ELSE 0
-                END) <> 0
+              SELECT roots.root_key
+              FROM ontology_source_roots AS roots
+              JOIN ontology_source_rows AS rows ON rows.root_id = roots.id
+              WHERE roots.version_id = ?
+              GROUP BY roots.id
+              HAVING MAX(json_extract(roots.root_key, '$[0]') <> 'object')
+                OR SUM(rows.entity_kind = 'object'
+                  AND rows.object_type_id = json_extract(roots.root_key, '$[1]')
+                  AND rows.primary_id = json_extract(roots.root_key, '$[2]')) <> 1
+                OR SUM(
+                  (rows.entity_kind = 'object' AND (
+                    rows.object_type_id <> json_extract(roots.root_key, '$[1]')
+                    OR rows.primary_id <> json_extract(roots.root_key, '$[2]')))
+                  OR (rows.entity_kind = 'link' AND (
+                    rows.source_type_id <> json_extract(roots.root_key, '$[1]')
+                    OR rows.source_primary_id <> json_extract(roots.root_key, '$[2]')))
+                ) <> 0
+                OR SUM(rows.entity_kind = 'link') <> COUNT(DISTINCT CASE
+                  WHEN rows.entity_kind = 'link'
+                  THEN json_array(rows.link_id, rows.target_type_id, rows.target_primary_id)
+                END)
               LIMIT 1
             `
       )
-      .get(manifest.project_id, manifest.source_id, manifest.materialization_id)
+      .get(manifest.version_id)
     if (invalid) {
       throw new MaterializationValidationError(
         manifest.projection_kind === "link"
@@ -456,52 +531,51 @@ export class SqliteOntologySourceStorage implements OntologySourceStorage {
     }
   }
 
+  /** Already staged assertions sharing a root or an ordinal with `rows`. */
   private findStageRows(
-    input: StageSourceRowsInput,
+    manifest: SqliteOntologySourceRow,
     rows: readonly SourceStageRow[]
   ): readonly SourceStageRow[] {
     if (rows.length === 0) return []
-    const rootSortKeys = [...new Set(rows.map((row) => utf8SortKey(row.rootKey)))]
+    const rootKeys = [...new Set(rows.map((row) => row.rootKey))]
     const ordinals = [...new Set(rows.map((row) => row.row.stagingOrdinal))]
-    const entitySortKeys = [...new Set(rows.map((row) => utf8SortKey(row.entityKey)))]
+    // Two keyed lookups: an OR over both columns scans every root of the version per batch.
     const existing = this.db
       .query(
         `
-          SELECT * FROM ontology_source_rows
-          WHERE project_id = ? AND source_id = ? AND materialization_id = ?
-            AND (
-              root_sort_key IN (SELECT CAST(value AS TEXT) FROM json_each(?))
-              OR staging_ordinal IN (SELECT CAST(value AS INTEGER) FROM json_each(?))
-              OR entity_sort_key IN (SELECT CAST(value AS TEXT) FROM json_each(?))
-            )
+          WITH selected AS (
+            SELECT roots.id FROM json_each(?2) AS requested
+            CROSS JOIN ontology_source_roots AS roots
+              ON roots.version_id = ?1 AND roots.root_key = CAST(requested.value AS TEXT)
+            UNION
+            SELECT roots.id FROM json_each(?3) AS requested
+            CROSS JOIN ontology_source_roots AS roots
+              ON roots.version_id = ?1 AND roots.staging_ordinal = CAST(requested.value AS INTEGER)
+          )
+          SELECT ${SOURCE_ASSERTION_COLUMNS} FROM selected
+          CROSS JOIN ontology_source_roots AS roots ON roots.id = selected.id
+          CROSS JOIN ontology_sources AS versions ON versions.version_id = roots.version_id
+          CROSS JOIN ontology_source_rows AS rows ON rows.root_id = roots.id
         `
       )
       .all(
-        input.projectId,
-        input.source.projectionId,
-        input.materializationId,
-        JSON.stringify(rootSortKeys),
-        JSON.stringify(ordinals),
-        JSON.stringify(entitySortKeys)
+        manifest.version_id,
+        JSON.stringify(rootKeys),
+        JSON.stringify(ordinals)
       ) as SqliteOntologySourceAssertionRow[]
     return existing.map((row) => sourceStageRow(sourceAssertion(row)))
   }
 
-  private insertStageRows(input: StageSourceRowsInput, rows: readonly SourceStageRow[]): void {
+  private insertStageRows(
+    manifest: SqliteOntologySourceRow,
+    rows: readonly SourceStageRow[]
+  ): void {
     if (rows.length === 0) return
-    const payload = rows.map(({ entityKey, rootKey, row }) => {
+    const payload = rows.map(({ rootKey, row }) => {
       const entity = entityColumns(row.assertion)
-      const root = entityColumns(row.root)
       return {
-        entityKind: row.assertion.kind,
-        entityKey,
-        entitySortKey: utf8SortKey(entityKey),
-        rootKind: row.root.kind,
         rootKey,
-        rootSortKey: utf8SortKey(rootKey),
-        stagingOrdinal: row.stagingOrdinal,
-        root: row.root,
-        assertion: row.assertion,
+        entityKind: row.assertion.kind,
         objectTypeId: entity.objectTypeId,
         primaryId: entity.primaryId,
         sourceTypeId: entity.sourceTypeId,
@@ -509,54 +583,31 @@ export class SqliteOntologySourceStorage implements OntologySourceStorage {
         linkId: entity.linkId,
         targetTypeId: entity.targetTypeId,
         targetPrimaryId: entity.targetPrimaryId,
-        rootObjectTypeId: root.objectTypeId,
-        rootPrimaryId: root.primaryId,
-        rootSourceTypeId: root.sourceTypeId,
-        rootSourcePrimaryId: root.sourcePrimaryId,
-        rootLinkId: root.linkId,
-        rootTargetTypeId: root.targetTypeId,
-        rootTargetPrimaryId: root.targetPrimaryId,
+        payload: sourceAssertionPayload(row.assertion),
       }
     })
-    this.db
+    const inserted = this.db
       .query(
         `
           WITH staged(value) AS (SELECT value FROM json_each(?))
           INSERT INTO ontology_source_rows (
-            project_id, source_id, materialization_id,
-            entity_kind, entity_key, entity_sort_key,
-            root_kind, root_key, root_sort_key, staging_ordinal,
-            root, assertion,
-            object_type_id, primary_id,
-            source_type_id, source_primary_id, link_id, target_type_id, target_primary_id,
-            root_object_type_id, root_primary_id,
-            root_source_type_id, root_source_primary_id, root_link_id,
-            root_target_type_id, root_target_primary_id
+            root_id, entity_kind, object_type_id, primary_id,
+            source_type_id, source_primary_id, link_id, target_type_id, target_primary_id, payload
           )
-          SELECT
-            ?, ?, ?,
-            json_extract(value, '$.entityKind'), json_extract(value, '$.entityKey'),
-            json_extract(value, '$.entitySortKey'),
-            json_extract(value, '$.rootKind'), json_extract(value, '$.rootKey'),
-            json_extract(value, '$.rootSortKey'), json_extract(value, '$.stagingOrdinal'),
-            json(json_extract(value, '$.root')), json(json_extract(value, '$.assertion')),
+          SELECT roots.id, json_extract(value, '$.entityKind'),
             json_extract(value, '$.objectTypeId'), json_extract(value, '$.primaryId'),
             json_extract(value, '$.sourceTypeId'), json_extract(value, '$.sourcePrimaryId'),
             json_extract(value, '$.linkId'), json_extract(value, '$.targetTypeId'),
-            json_extract(value, '$.targetPrimaryId'),
-            json_extract(value, '$.rootObjectTypeId'), json_extract(value, '$.rootPrimaryId'),
-            json_extract(value, '$.rootSourceTypeId'),
-            json_extract(value, '$.rootSourcePrimaryId'), json_extract(value, '$.rootLinkId'),
-            json_extract(value, '$.rootTargetTypeId'), json_extract(value, '$.rootTargetPrimaryId')
+            json_extract(value, '$.targetPrimaryId'), json_extract(value, '$.payload')
           FROM staged
+          CROSS JOIN ontology_source_roots AS roots
+            ON roots.version_id = ? AND roots.root_key = json_extract(value, '$.rootKey')
         `
       )
-      .run(
-        canonicalJson(payload),
-        input.projectId,
-        input.source.projectionId,
-        input.materializationId
-      )
+      .run(canonicalJson(payload), manifest.version_id).changes
+    if (inserted !== rows.length) {
+      throw sourceConflict("Staged source rows do not all belong to a staged root.")
+    }
   }
 
   private assertExecution(

package/src/projection-run-storage.ts

@@ -19,6 +19,7 @@ import {
   immutableDatasetVersionConflict,
   mergeProjectionRunProgress,
   type PersistedProjectionRunRecord,
+  parseProjectionAttemptFailure,
   planProjectionRunFinish,
   planProjectionRunReclaim,
   projectionRunNotFound,
@@ -26,12 +27,14 @@ import {
   requireTelemetryProjectionRun,
   restoreProjectionRun,
   type StoredProjectionRunRecord,
+  SUPERSEDING_PROJECTION_RUN_STATUSES,
   staleProjectionRunExecution,
 } from "@sixb/core/internal/projection-run-storage-provider"
 import type {
   AdvanceProjectionTelemetryCheckpointInput,
   ExecutionStorage,
   FailProjectionRunEnqueueInput,
+  FindSupersedingProjectionRunInput,
   FinishProjectionRunInput,
   ListLatestProjectionRunsInput,
   ListLatestProjectionRunsResult,
@@ -45,6 +48,7 @@ import type {
   ProjectionRunStatus,
   ProjectionRunStorage,
   QueueProjectionRunInput,
+  RecordProjectionAttemptFailureInput,
   RecordProjectionMissingTargetInput,
   StartOrReclaimProjectionRunInput,
   TelemetryProjectionRunRecord,
@@ -177,7 +181,7 @@ export class SqliteProjectionRunStorage implements ProjectionRunStorage {
           `
             UPDATE projection_runs
             SET status = 'running', started_at = COALESCE(started_at, ?), finished_at = NULL,
-              attempt = ?, execution_token = ?, error = NULL
+              attempt = ?, execution_token = ?
             WHERE project_id = ? AND id = ?
               AND (
                 (status = 'queued' AND execution_token IS NULL)
@@ -243,6 +247,31 @@ export class SqliteProjectionRunStorage implements ProjectionRunStorage {
     })
   }
 
+  async recordAttemptFailure(
+    input: RecordProjectionAttemptFailureInput
+  ): Promise<ProjectionRunRecord> {
+    return runImmediateTransaction(this.db, () => {
+      const existingRow = this.requireMaterializationExecution(input)
+      const error = parseProjectionAttemptFailure(restoreProjectionRunRow(existingRow), input.error)
+      const result = this.db
+        .query(
+          `
+          UPDATE projection_runs
+          SET error = ?
+          WHERE project_id = ? AND id = ? AND status = 'running' AND execution_token = ?
+        `
+        )
+        .run(
+          serializeSixbFailure(error, PROJECTION_RUN_FAILURE_CODES),
+          input.projectId,
+          input.id,
+          input.executionToken
+        )
+      if (result.changes !== 1) throw staleProjectionRunExecution(input.id)
+      return rowToProjectionRunRecord(this.requireRow(input.projectId, input.id))
+    })
+  }
+
   async finish(input: FinishProjectionRunInput): Promise<ProjectionRunRecord> {
     return runImmediateTransaction(this.db, () => {
       const existingRow = this.requireMaterializationExecution(input)
@@ -447,6 +476,34 @@ export class SqliteProjectionRunStorage implements ProjectionRunStorage {
     return { runs, hasMore: offset + runs.length < totalRow.count, total: totalRow.count }
   }
 
+  async findSupersedingRun(
+    input: FindSupersedingProjectionRunInput
+  ): Promise<ProjectionRunRecord | null> {
+    const run = this.requireRow(input.projectId, input.id)
+    if (run.materialization_protocol !== "replacement") return null
+    // SQLite compares TEXT with the binary collation, under which canonical UTC ISO timestamps
+    // order chronologically.
+    const statuses = SUPERSEDING_PROJECTION_RUN_STATUSES
+    const newer = this.db
+      .query(
+        `
+          SELECT * FROM projection_runs
+          WHERE project_id = ? AND projection_id = ? AND materialization_protocol = 'replacement'
+            AND status IN (${statuses.map(() => "?").join(", ")})
+            AND dataset_version_created_at > ?
+          ORDER BY dataset_version_created_at DESC, id DESC
+          LIMIT 1
+        `
+      )
+      .get(
+        input.projectId,
+        run.projection_id,
+        ...statuses,
+        run.dataset_version_created_at
+      ) as DatabaseRow | null
+    return newer ? rowToProjectionRunRecord(newer) : null
+  }
+
   async listLatestByProjectionIds(
     input: ListLatestProjectionRunsInput
   ): Promise<ListLatestProjectionRunsResult> {
@@ -457,6 +514,7 @@ export class SqliteProjectionRunStorage implements ProjectionRunStorage {
       ownerIds: input.projectionIds,
       projectId: input.projectId,
       ownerIdFor: (row) => row.projection_id,
+      excludedStatus: "superseded",
     })
     return { runs: rows.map(rowToProjectionRunRecord) }
   }