@sixb/sqlite 0.1.14 → 0.1.16

package/dist/index.js

@@ -4357,6 +4357,319 @@ CREATE INDEX idx_auth_group_memberships_group
   ON auth_group_memberships(project_id, group_id);
 `;
 
+// src/migrations/051-projection-run-supersession.sql
+var _051_projection_run_supersession_default = `-- Projection runs gain the terminal status \`superseded\`, and a running run may carry the failure
+-- of its last attempt in \`error\` while the queue retries it. SQLite cannot alter a CHECK
+-- constraint, so the table is rebuilt.
+CREATE TABLE projection_runs_v2 (
+  project_id TEXT NOT NULL,
+  id TEXT NOT NULL,
+  execution_id TEXT NOT NULL,
+  projection_id TEXT NOT NULL,
+  projection_kind TEXT NOT NULL CHECK (projection_kind IN ('object', 'link', 'telemetry')),
+  materialization_protocol TEXT NOT NULL CHECK (
+    materialization_protocol IN ('replacement', 'telemetry')
+  ),
+  dataset_id TEXT NOT NULL,
+  dataset_version_id TEXT NOT NULL,
+  dataset_version_created_at TEXT NOT NULL,
+  ontology_revision TEXT NOT NULL,
+  projection_revision TEXT NOT NULL,
+  ownership_hash TEXT NOT NULL,
+  object_type_id TEXT,
+  source_object_type_id TEXT,
+  target_object_type_id TEXT,
+  status TEXT NOT NULL CHECK (
+    status IN ('queued', 'running', 'succeeded', 'failed', 'cancelled', 'superseded')
+  ),
+  queued_at TEXT NOT NULL,
+  started_at TEXT,
+  finished_at TEXT,
+  attempt INTEGER NOT NULL CHECK (attempt >= 0),
+  execution_token TEXT,
+  fixed_batch_size INTEGER CHECK (fixed_batch_size > 0),
+  next_batch_ordinal INTEGER CHECK (next_batch_ordinal >= 0),
+  next_row_offset INTEGER CHECK (next_row_offset >= 0),
+  input_exhausted INTEGER CHECK (input_exhausted IN (0, 1)),
+  missing_target_object_type_id TEXT,
+  missing_target_object_id TEXT,
+  missing_target_batch_ordinal INTEGER CHECK (
+    missing_target_batch_ordinal IS NULL OR missing_target_batch_ordinal >= 0
+  ),
+  missing_target_first_seen_at TEXT,
+  source_rows_read INTEGER NOT NULL DEFAULT 0 CHECK (source_rows_read >= 0),
+  source_rows_skipped INTEGER NOT NULL DEFAULT 0 CHECK (source_rows_skipped >= 0),
+  source_changes_read INTEGER CHECK (source_changes_read IS NULL OR source_changes_read >= 0),
+  error TEXT CHECK (error IS NULL OR json_valid(error)),
+  PRIMARY KEY (project_id, id),
+  UNIQUE (project_id, execution_id),
+  FOREIGN KEY (project_id, execution_id) REFERENCES executions (project_id, id) ON DELETE RESTRICT,
+  CHECK (source_rows_skipped <= source_rows_read),
+  CHECK ((status = 'running') = (execution_token IS NOT NULL)),
+  CHECK (
+    (status = 'queued' AND attempt = 0 AND started_at IS NULL AND finished_at IS NULL
+      AND error IS NULL)
+    OR (status = 'running' AND attempt >= 1 AND started_at IS NOT NULL AND finished_at IS NULL)
+    OR (
+      status IN ('succeeded', 'failed', 'cancelled', 'superseded')
+      AND finished_at IS NOT NULL
+      AND (
+        (json_extract(error, '$.code') = 'queue.enqueue_failed'
+          AND status = 'failed' AND attempt = 0 AND started_at IS NULL)
+        OR (COALESCE(json_extract(error, '$.code'), '') != 'queue.enqueue_failed'
+          AND attempt >= 1 AND started_at IS NOT NULL)
+      )
+    )
+  ),
+  CHECK (status != 'succeeded' OR error IS NULL),
+  -- A run is superseded instead of materialized, so it carries no failure, and only replacement
+  -- runs can be: telemetry appends readings rather than replace a source.
+  CHECK (status != 'superseded' OR (error IS NULL AND materialization_protocol = 'replacement')),
+  CHECK ((projection_kind = 'telemetry') = (materialization_protocol = 'telemetry')),
+  CHECK (
+    (projection_kind = 'link' AND object_type_id IS NULL
+      AND source_object_type_id IS NOT NULL AND target_object_type_id IS NOT NULL)
+    OR (projection_kind IN ('object', 'telemetry') AND object_type_id IS NOT NULL
+      AND source_object_type_id IS NULL AND target_object_type_id IS NULL)
+  ),
+  CHECK (
+    (materialization_protocol = 'replacement' AND fixed_batch_size IS NULL
+      AND next_batch_ordinal IS NULL AND next_row_offset IS NULL AND input_exhausted IS NULL)
+    OR (materialization_protocol = 'telemetry' AND fixed_batch_size IS NOT NULL
+      AND next_batch_ordinal IS NOT NULL AND next_row_offset IS NOT NULL
+      AND input_exhausted IS NOT NULL)
+  ),
+  CHECK (
+    (missing_target_object_type_id IS NULL AND missing_target_object_id IS NULL
+      AND missing_target_batch_ordinal IS NULL AND missing_target_first_seen_at IS NULL)
+    OR (projection_kind = 'telemetry' AND missing_target_object_type_id = object_type_id
+      AND missing_target_object_id IS NOT NULL
+      AND missing_target_batch_ordinal = next_batch_ordinal
+      AND missing_target_first_seen_at IS NOT NULL)
+  ),
+  CHECK (projection_kind != 'telemetry' OR status != 'succeeded' OR input_exhausted = 1)
+);
+
+INSERT INTO projection_runs_v2 (
+  project_id, id, execution_id, projection_id, projection_kind, materialization_protocol,
+  dataset_id, dataset_version_id, dataset_version_created_at, ontology_revision,
+  projection_revision, ownership_hash, object_type_id, source_object_type_id,
+  target_object_type_id, status, queued_at, started_at, finished_at, attempt, execution_token,
+  fixed_batch_size, next_batch_ordinal, next_row_offset, input_exhausted,
+  missing_target_object_type_id, missing_target_object_id, missing_target_batch_ordinal,
+  missing_target_first_seen_at, source_rows_read, source_rows_skipped, source_changes_read, error
+)
+SELECT
+  project_id, id, execution_id, projection_id, projection_kind, materialization_protocol,
+  dataset_id, dataset_version_id, dataset_version_created_at, ontology_revision,
+  projection_revision, ownership_hash, object_type_id, source_object_type_id,
+  target_object_type_id, status, queued_at, started_at, finished_at, attempt, execution_token,
+  fixed_batch_size, next_batch_ordinal, next_row_offset, input_exhausted,
+  missing_target_object_type_id, missing_target_object_id, missing_target_batch_ordinal,
+  missing_target_first_seen_at, source_rows_read, source_rows_skipped, source_changes_read, error
+FROM projection_runs;
+
+DROP TABLE projection_runs;
+ALTER TABLE projection_runs_v2 RENAME TO projection_runs;
+
+CREATE INDEX idx_projection_runs_project_started
+  ON projection_runs(project_id, COALESCE(started_at, queued_at) DESC);
+CREATE INDEX idx_projection_runs_project_projection_started
+  ON projection_runs(project_id, projection_id, COALESCE(started_at, queued_at) DESC);
+CREATE INDEX idx_projection_runs_project_dataset_started
+  ON projection_runs(project_id, dataset_id, COALESCE(started_at, queued_at) DESC);
+CREATE INDEX idx_projection_runs_project_version_started
+  ON projection_runs(project_id, dataset_version_id, COALESCE(started_at, queued_at) DESC);
+CREATE INDEX idx_projection_runs_project_status_started
+  ON projection_runs(project_id, status, COALESCE(started_at, queued_at) DESC);
+CREATE INDEX idx_projection_runs_project_object_type_started
+  ON projection_runs(project_id, object_type_id, COALESCE(started_at, queued_at) DESC);
+`;
+
+// src/migrations/052-compact-source-storage.sql
+var _052_compact_source_storage_default = `-- Source versions get a compact surrogate key; roots and rows stop repeating the text triple.
+-- SQLite cannot add a key column to a table, so the three source tables are rebuilt. Index
+-- names are schema-wide: the old ones are dropped first to free them.
+DROP INDEX idx_ontology_sources_active;
+DROP INDEX idx_ontology_sources_run_candidate;
+DROP INDEX idx_ontology_sources_cleanup;
+DROP INDEX idx_ontology_sources_run;
+DROP INDEX idx_ontology_source_roots_active;
+DROP INDEX idx_ontology_source_roots_lookup;
+DROP INDEX idx_ontology_source_roots_cleanup;
+DROP INDEX idx_ontology_source_rows_root;
+DROP INDEX idx_ontology_source_rows_staging_ordinal;
+DROP INDEX idx_ontology_source_rows_entity_sort;
+DROP INDEX idx_ontology_source_rows_object;
+DROP INDEX idx_ontology_source_rows_link_source;
+DROP INDEX idx_ontology_source_rows_link_target;
+ALTER TABLE ontology_source_rows RENAME TO legacy_ontology_source_rows;
+ALTER TABLE ontology_source_roots RENAME TO legacy_ontology_source_roots;
+ALTER TABLE ontology_sources RENAME TO legacy_ontology_sources;
+
+CREATE TABLE ontology_sources (
+  version_id INTEGER PRIMARY KEY,
+  project_id TEXT NOT NULL,
+  source_id TEXT NOT NULL,
+  materialization_id TEXT NOT NULL,
+  projection_run_id TEXT NOT NULL,
+  projection_kind TEXT NOT NULL CHECK (projection_kind IN ('object', 'link')),
+  protocol TEXT NOT NULL CHECK (protocol = 'replacement'),
+  status TEXT NOT NULL CHECK (
+    status IN ('staging', 'ready', 'active', 'superseded', 'abandoned')
+  ),
+  execution_token TEXT,
+  dataset_id TEXT NOT NULL,
+  dataset_version_id TEXT NOT NULL,
+  dataset_version_created_at TEXT NOT NULL,
+  projection_revision TEXT NOT NULL,
+  ownership_hash TEXT NOT NULL,
+  ontology_revision TEXT NOT NULL,
+  root_count INTEGER CHECK (root_count IS NULL OR root_count >= 0),
+  assertion_count INTEGER CHECK (assertion_count IS NULL OR assertion_count >= 0),
+  created_at TEXT NOT NULL,
+  ready_at TEXT,
+  activated_at TEXT,
+  terminal_at TEXT,
+  last_commit_id TEXT,
+  updated_at TEXT NOT NULL,
+  base_materialization_id TEXT,
+  base_commit_id TEXT,
+  UNIQUE (project_id, source_id, materialization_id),
+  CHECK ((base_materialization_id IS NULL) = (base_commit_id IS NULL)),
+  CHECK ((root_count IS NULL) = (assertion_count IS NULL)),
+  CHECK ((root_count IS NULL) = (ready_at IS NULL)),
+  CHECK ((status IN ('staging', 'ready')) = (execution_token IS NOT NULL)),
+  CHECK (
+    (status = 'staging' AND ready_at IS NULL)
+    OR (status IN ('ready', 'active', 'superseded') AND ready_at IS NOT NULL)
+    OR status = 'abandoned'
+  ),
+  CHECK ((status IN ('active', 'superseded')) = (activated_at IS NOT NULL)),
+  CHECK ((status IN ('active', 'superseded')) = (last_commit_id IS NOT NULL)),
+  CHECK ((status IN ('superseded', 'abandoned')) = (terminal_at IS NOT NULL)),
+  CHECK (ready_at IS NULL OR created_at <= ready_at),
+  CHECK (activated_at IS NULL OR (ready_at IS NOT NULL AND ready_at <= activated_at)),
+  CHECK (terminal_at IS NULL OR created_at <= terminal_at),
+  CHECK (terminal_at IS NULL OR ready_at IS NULL OR ready_at <= terminal_at),
+  CHECK (terminal_at IS NULL OR activated_at IS NULL OR activated_at <= terminal_at),
+  CHECK (created_at <= updated_at)
+);
+INSERT INTO ontology_sources (
+  project_id, source_id, materialization_id, projection_run_id, projection_kind, protocol,
+  status, execution_token, 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,
+  base_materialization_id, base_commit_id
+)
+SELECT project_id, source_id, materialization_id, projection_run_id, projection_kind, protocol,
+  status, execution_token, 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,
+  base_materialization_id, base_commit_id
+FROM legacy_ontology_sources
+ORDER BY rowid;
+CREATE UNIQUE INDEX idx_ontology_sources_active
+  ON ontology_sources(project_id, source_id)
+  WHERE status = 'active';
+CREATE UNIQUE INDEX idx_ontology_sources_run_candidate
+  ON ontology_sources(project_id, projection_run_id)
+  WHERE status IN ('staging', 'ready');
+CREATE INDEX idx_ontology_sources_cleanup
+  ON ontology_sources(project_id, status, terminal_at, source_id, materialization_id);
+CREATE INDEX idx_ontology_sources_run
+  ON ontology_sources(project_id, projection_run_id);
+
+-- A root is live while its version is published (active or superseded), it is not retired and
+-- it is not a deletion. Activation therefore writes only the roots it replaces, never its own.
+-- \`root_key\` is the canonical key; SQLite's default BINARY collation orders it by its UTF-8 bytes.
+CREATE TABLE ontology_source_roots (
+  id INTEGER PRIMARY KEY,
+  version_id INTEGER NOT NULL REFERENCES ontology_sources (version_id) ON DELETE RESTRICT,
+  project_id TEXT NOT NULL,
+  root_key TEXT NOT NULL,
+  staging_ordinal INTEGER NOT NULL CHECK (staging_ordinal >= 0),
+  deleted INTEGER NOT NULL DEFAULT 0 CHECK (deleted IN (0, 1)),
+  retired_at TEXT,
+  CONSTRAINT ontology_source_roots_key UNIQUE (version_id, root_key),
+  CONSTRAINT ontology_source_roots_ordinal UNIQUE (version_id, staging_ordinal)
+);
+CREATE INDEX idx_ontology_source_roots_live
+  ON ontology_source_roots (project_id, root_key) WHERE retired_at IS NULL AND deleted = 0;
+CREATE INDEX idx_ontology_source_roots_retired
+  ON ontology_source_roots (project_id, retired_at) WHERE retired_at IS NOT NULL;
+
+-- A row's identity lives in its typed columns; \`payload\` is the assertion without kind and ref.
+CREATE TABLE ontology_source_rows (
+  root_id INTEGER NOT NULL REFERENCES ontology_source_roots (id) ON DELETE RESTRICT,
+  entity_kind TEXT NOT NULL CHECK (entity_kind IN ('object', 'link')),
+  object_type_id TEXT,
+  primary_id TEXT,
+  source_type_id TEXT,
+  source_primary_id TEXT,
+  link_id TEXT,
+  target_type_id TEXT,
+  target_primary_id TEXT,
+  payload TEXT CHECK (json_valid(payload)),
+  CHECK (
+    (
+      entity_kind = 'object'
+      AND object_type_id IS NOT NULL AND primary_id IS NOT NULL
+      AND source_type_id IS NULL AND source_primary_id IS NULL AND link_id IS NULL
+      AND target_type_id IS NULL AND target_primary_id IS NULL
+    )
+    OR
+    (
+      entity_kind = 'link'
+      AND object_type_id IS NULL AND primary_id IS NULL
+      AND source_type_id IS NOT NULL AND source_primary_id IS NOT NULL AND link_id IS NOT NULL
+      AND target_type_id IS NOT NULL AND target_primary_id IS NOT NULL
+    )
+  )
+);
+CREATE INDEX idx_ontology_source_rows_root ON ontology_source_rows (root_id);
+CREATE INDEX idx_ontology_source_rows_link_source
+  ON ontology_source_rows (source_type_id, source_primary_id, link_id)
+  WHERE entity_kind = 'link';
+CREATE INDEX idx_ontology_source_rows_link_target
+  ON ontology_source_rows (target_type_id, target_primary_id)
+  WHERE entity_kind = 'link';
+
+-- A published root that was not active is retired, so liveness stays exactly what it was.
+INSERT INTO ontology_source_roots (
+  version_id, project_id, root_key, staging_ordinal, deleted, retired_at
+)
+SELECT versions.version_id, roots.project_id, roots.root_key, roots.staging_ordinal,
+  roots.deleted,
+  CASE
+    WHEN roots.active = 1 THEN NULL
+    WHEN roots.retired_at IS NOT NULL THEN roots.retired_at
+    WHEN versions.status IN ('active', 'superseded') THEN versions.updated_at
+  END
+FROM legacy_ontology_source_roots AS roots
+JOIN ontology_sources AS versions USING (project_id, source_id, materialization_id)
+ORDER BY versions.version_id, roots.staging_ordinal;
+
+INSERT INTO ontology_source_rows (
+  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 roots.id, rows.entity_kind, rows.object_type_id, rows.primary_id,
+  rows.source_type_id, rows.source_primary_id, rows.link_id, rows.target_type_id,
+  rows.target_primary_id, NULLIF(json_remove(rows.assertion, '$.kind', '$.ref'), '{}')
+FROM legacy_ontology_source_rows AS rows
+JOIN ontology_sources AS versions USING (project_id, source_id, materialization_id)
+JOIN ontology_source_roots AS roots
+  ON roots.version_id = versions.version_id AND roots.root_key = rows.root_key
+ORDER BY roots.id;
+
+DROP TABLE legacy_ontology_source_rows;
+DROP TABLE legacy_ontology_source_roots;
+DROP TABLE legacy_ontology_sources;
+-- No ANALYZE: nothing refreshes SQLite statistics afterwards, and on a fresh install they would
+-- describe empty tables forever and steer the planner to partial indexes over primary keys.
+`;
+
 // src/migrations/037-execution-requester-groups.sql
 var _037_execution_requester_groups_default = `ALTER TABLE executions ADD COLUMN requester_group_ids TEXT NOT NULL DEFAULT '[]';
 
@@ -4561,7 +4874,16 @@ var sqliteStorageMigrations = defineMigrations({
     sqliteSql("047-ontology-commit-attribution", _047_ontology_commit_attribution_default),
     sqliteSql("048-file-upload-sessions", _048_file_upload_sessions_default),
     sqliteSql("049-native-sessions", _049_native_sessions_default),
-    sqliteSql("050-directory-group-memberships", _050_directory_group_memberships_default)
+    sqliteSql("050-directory-group-memberships", _050_directory_group_memberships_default),
+    sqliteSql("051-projection-run-supersession", _051_projection_run_supersession_default),
+    sqliteStep("052-compact-source-storage", (db) => {
+      const before = sourceStorageCounts(db);
+      db.run(_052_compact_source_storage_default);
+      const after = sourceStorageCounts(db);
+      if (after.versions !== before.versions || after.roots !== before.roots || after.rows !== before.rows) {
+        throw new Error("[SixbSqliteStorage] Source versions, roots or rows were lost while compacting source storage.");
+      }
+    }, { checksum: checksum(_052_compact_source_storage_default) })
   ]
 });
 function sqliteStoragePath(basePath) {
@@ -4676,6 +4998,11 @@ function rowToMigrationRecord(row) {
     finishedAt: migration.finished_at ?? undefined
   };
 }
+function sourceStorageCounts(db) {
+  return db.query(`SELECT (SELECT count(*) FROM ontology_sources) AS versions,
+      (SELECT count(*) FROM ontology_source_roots) AS roots,
+      (SELECT count(*) FROM ontology_source_rows) AS rows`).get();
+}
 function checksum(value) {
   return createHash("sha256").update(value).digest("hex");
 }
@@ -10240,7 +10567,7 @@ var PAGE_TOKEN_PREFIX = "keyset:";
 var DEFAULT_EXPANSION_FANOUT = 1000;
 function compileObjectQuery(projectId, query, options = {}) {
   if (hasVectorProfile(query) && !isVectorProfileQuery(query)) {
-    throw new ObjectQueryExecutionError("unsupported_vector_composition", "Vector search supports one profile with filters before ranking and limit/project after.");
+    throw new ObjectQueryExecutionError("unsupported_vector_composition", "Vector search supports one profile with filters, traversals or sets before ranking and limit/project after.");
   }
   const source = options.source ?? DEFAULT_OBJECT_QUERY_SOURCE;
   const ctx = { probeLimit: options.includeTotal === false, source };
@@ -10313,9 +10640,29 @@ function compileVector(projectId, query, ctx) {
     { kind: "column", column: "_vector_score", direction: "desc" },
     ...identityOrderFields().map((field) => ({ ...field, binary: true }))
   ]);
-  const sql = `SELECT * FROM (SELECT input.*, max(-1, min(1, 1 - vec_distance_cosine(vectors.embedding, ?))) AS _vector_score
-    ${candidates}) AS ranked ORDER BY ${order.sql} LIMIT ?`;
-  const args = [encodeSqliteVector(values), ...candidateArgs, query.k];
+  const rankedOrder = compileOrder(order.fields, "ranked");
+  const sql = `SELECT stored.project_id, stored.object_type_id, stored.primary_id,
+    stored.properties, stored.properties AS _cursor_properties,
+    stored.created_at, stored.updated_at, stored.version, stored.last_commit_id,
+    ranked._vector_candidate_count, ranked._vector_score
+    FROM (
+    WITH _sixb_vector_candidates AS MATERIALIZED (
+      SELECT input.project_id, input.object_type_id, input.primary_id,
+        vectors.embedding AS _vector_embedding ${candidates} LIMIT ?
+    ), _sixb_vector_budget AS (
+      SELECT COUNT(*) AS _vector_candidate_count FROM _sixb_vector_candidates
+    )
+    SELECT input.project_id, input.object_type_id, input.primary_id, budget._vector_candidate_count,
+      CASE WHEN budget._vector_candidate_count <= ?
+        THEN max(-1, min(1, 1 - vec_distance_cosine(input._vector_embedding, ?)))
+      END AS _vector_score
+    FROM _sixb_vector_candidates AS input CROSS JOIN _sixb_vector_budget AS budget
+    ORDER BY ${order.sql} LIMIT ?
+  ) AS ranked CROSS JOIN ${ctx.source.objectsTable} AS stored
+    ON stored.project_id = ranked.project_id AND stored.object_type_id = ranked.object_type_id
+      AND stored.primary_id = ranked.primary_id
+  ORDER BY ${rankedOrder.sql}`;
+  const args = [...candidateArgs, limit + 1, limit, encodeSqliteVector(values), query.k];
   return {
     sql,
     args,
@@ -10325,7 +10672,9 @@ function compileVector(projectId, query, ctx) {
     vectorProbe: {
       sql: `SELECT COUNT(*) AS total FROM (SELECT 1 ${candidates} LIMIT ?) AS candidates`,
       args: [...candidateArgs, limit + 1],
-      limit
+      limit,
+      rowLimit: query.k,
+      totalLimit: query.k
     },
     hasMore: () => false,
     trimRows: identityRows,
@@ -10484,7 +10833,11 @@ function compileLimit(projectId, inputQuery, rawLimit, ctx) {
       FROM (${input.sql}) AS input
     `,
     totalArgs: input.args,
-    vectorProbe: input.vectorProbe,
+    vectorProbe: input.vectorProbe ? {
+      ...input.vectorProbe,
+      rowLimit: Math.min(input.vectorProbe.rowLimit, rowLimit),
+      totalLimit: input.vectorProbe.rowLimit
+    } : undefined,
     order: input.order,
     hasMore: (rowCount, total) => total === undefined ? ctx.probeLimit && rowCount > limit : limit < total,
     trimRows: ctx.probeLimit ? (rows) => rows.slice(0, limit) : identityRows,
@@ -10761,7 +11114,7 @@ function compileProject(projectId, inputQuery, properties, ctx) {
         input.created_at,
         input.updated_at,
         input.version,
-        input.last_commit_id${input.vectorProbe ? ", input._vector_score" : ""}
+        input.last_commit_id${input.vectorProbe ? ", input._vector_score, input._vector_candidate_count" : ""}
       FROM (${input.sql}) AS input
       ORDER BY ${inputOrder.sql}
     `,
@@ -11305,19 +11658,20 @@ class SqliteObjectReader {
     ensureSqliteVectorSearch(this.db);
     const probe = compiled.vectorProbe;
     const row = this.db.query(probe.sql).get(...probe.args);
-    if (Number(row?.total ?? 0) > probe.limit) {
-      throw new ObjectQueryExecutionError3("vector_work_limit_exceeded", `Exact vector search supports at most ${probe.limit} eligible vectors at this dimension. Narrow the query filters.`);
-    }
+    assertVectorCandidateCount(row?.total, probe.limit);
   }
   queryObjects(params) {
-    this.assertVectorSearch(params);
     const source = this.source;
     const compiled = compileObjectQuery(params.projectId, params.query, {
       includeTotal: params.includeTotal,
       source
     });
-    const total = params.includeTotal === false ? undefined : readTotal(this.db, compiled);
+    if (compiled.vectorProbe)
+      ensureSqliteVectorSearch(this.db);
+    const ordinaryTotal = params.includeTotal === false || compiled.vectorProbe ? undefined : readTotal(this.db, compiled);
     const rawRows = this.db.query(compiled.sql).all(...compiled.args);
+    const vectorTotal = this.vectorResultTotal(compiled, rawRows);
+    const total = params.includeTotal === false ? undefined : vectorTotal ?? ordinaryTotal;
     const rows = compiled.trimRows(rawRows);
     const hasMore = total === undefined && compiled.hasMoreProbe ? compiled.hasMoreProbe.hasMore(this.db.query(compiled.hasMoreProbe.sql).all(...compiled.hasMoreProbe.args).length) : compiled.hasMore(rawRows.length, total);
     return {
@@ -11327,6 +11681,17 @@ class SqliteObjectReader {
       ...total === undefined ? {} : { total }
     };
   }
+  vectorResultTotal(compiled, rows) {
+    const probe = compiled.vectorProbe;
+    if (!probe)
+      return;
+    let count = rows[0]?._vector_candidate_count;
+    if (rows.length === 0) {
+      count = probe.rowLimit === 0 ? this.db.query(probe.sql).get(...probe.args)?.total : 0;
+    }
+    assertVectorCandidateCount(count, probe.limit);
+    return Math.min(count, probe.totalLimit);
+  }
   countObjects(params) {
     this.assertVectorSearch(params);
     const source = this.source;
@@ -11640,6 +12005,14 @@ function sqliteFacetValue(valueType, value) {
   }
   return value;
 }
+function assertVectorCandidateCount(count, limit) {
+  if (typeof count !== "number" || !Number.isSafeInteger(count) || count < 0) {
+    throw new ObjectQueryExecutionError3("invalid_vector_candidate_count", "Storage did not return a valid vector candidate count.");
+  }
+  if (count > limit) {
+    throw new ObjectQueryExecutionError3("vector_work_limit_exceeded", `Exact vector search supports at most ${limit} eligible vectors at this dimension. Narrow the query filters.`);
+  }
+}
 function existsProbeQuery(query) {
   return { kind: "limit", limit: 1, input: stripOuterRowShape(query) };
 }
@@ -11731,7 +12104,7 @@ function compileSelectedReadScopeCte(scopeJson, projectId) {
       _sixb_scope_root_facts(project_id, root_id, node_id, object_type_id, primary_id) AS (
         SELECT anchor.project_id, root.root_id, root.node_id, root.object_type_id, root.primary_id
         FROM _sixb_scope_roots AS root
-        JOIN objects AS anchor
+        CROSS JOIN objects AS anchor
           ON anchor.project_id = ?
          AND anchor.object_type_id = root.object_type_id
          AND anchor.primary_id = root.primary_id
@@ -11813,7 +12186,7 @@ function compileSelectedReadScopeCte(scopeJson, projectId) {
         GROUP BY reachable.project_id, reachable.object_type_id, reachable.primary_id
       ),
       _sixb_scope_objects AS (
-        SELECT stored.project_id, stored.object_type_id, stored.primary_id,
+        SELECT grants.project_id, grants.object_type_id, grants.primary_id,
           COALESCE((
             SELECT json_group_object(property.key, ${sqliteJsonEachValue("property")})
             FROM json_each(stored.properties) AS property
@@ -11903,12 +12276,12 @@ function compileSelectedReadScopeCte(scopeJson, projectId) {
       ),
       _sixb_scope_links AS (
         SELECT
-          stored.project_id,
-          stored.source_type_id,
-          stored.source_id,
-          stored.link_id,
-          stored.target_type_id,
-          stored.target_id,
+          visible.project_id,
+          visible.source_type_id,
+          visible.source_id,
+          visible.link_id,
+          visible.target_type_id,
+          visible.target_id,
           CASE
             WHEN stored.properties IS NULL THEN NULL
             ELSE NULLIF(
@@ -12204,6 +12577,10 @@ function assertReconciliationPageLimit(limit) {
 // src/ontology-storage/shared.ts
 import { parseSixbFailure as parseSixbFailure2 } from "@sixb/core/internal/errors";
 import { MaterializationConflictError } from "@sixb/core/internal/materialization";
+import {
+  sourceAssertionFromColumns,
+  sourceEntityFromKey
+} from "@sixb/core/internal/ontology-storage-provider";
 import { ONTOLOGY_OUTBOX_FAILURE_CODES } from "@sixb/core/storage";
 import {
   assertNonblank,
@@ -12256,8 +12633,8 @@ function sourceRecord(row) {
 }
 function sourceAssertion(row) {
   return {
-    root: parseJson2(row.root),
-    assertion: parseJson2(row.assertion),
+    root: sourceEntityFromKey(row.root_key),
+    assertion: sourceAssertionFromColumns(row, row.payload === null ? null : parseJson2(row.payload)),
     stagingOrdinal: row.staging_ordinal
   };
 }
@@ -12475,29 +12852,68 @@ import {
   MaterializationValidationError,
   projectionEntityKey
 } from "@sixb/core/internal/materialization";
-import { sourceStageRoots, utf8SortKey } from "@sixb/core/internal/ontology-storage-provider";
-function replacementSourceRows(input) {
-  const roots = input.incremental ? `ontology_source_roots AS changed
-    CROSS JOIN ontology_source_roots AS roots ON 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 = 1` : "ontology_source_roots AS roots";
-  const selected = input.incremental ? "changed" : "roots";
+import {
+  sourceEntityColumns,
+  sourceStageRoots
+} from "@sixb/core/internal/ontology-storage-provider";
+var PUBLISHED = "('active', 'superseded')";
+var SOURCE_ASSERTION_COLUMNS = `versions.source_id, versions.materialization_id,
+  roots.root_key, roots.staging_ordinal, rows.entity_kind, rows.object_type_id, rows.primary_id,
+  rows.source_type_id, rows.source_primary_id, rows.link_id, rows.target_type_id,
+  rows.target_primary_id, rows.payload`;
+var LIVE_SOURCE_ROWS_JOIN = `
+  CROSS JOIN ontology_source_roots AS roots ON roots.id = rows.root_id
+    AND roots.project_id = ? AND roots.retired_at IS NULL AND roots.deleted = 0
+  CROSS JOIN ontology_sources AS versions ON versions.version_id = roots.version_id
+    AND versions.status IN ${PUBLISHED}`;
+var ENTITY_MATCH = `rows.entity_kind = requested.entity_kind
+  AND rows.object_type_id IS requested.object_type_id
+  AND rows.primary_id IS requested.primary_id
+  AND rows.source_type_id IS requested.source_type_id
+  AND rows.source_primary_id IS requested.source_primary_id
+  AND rows.link_id IS requested.link_id
+  AND rows.target_type_id IS requested.target_type_id
+  AND rows.target_primary_id IS requested.target_primary_id`;
+var REQUESTED_ENTITY = `json_extract(value, '$.entityKind') AS entity_kind,
+  json_extract(value, '$.objectTypeId') AS object_type_id,
+  json_extract(value, '$.primaryId') AS primary_id,
+  json_extract(value, '$.sourceTypeId') AS source_type_id,
+  json_extract(value, '$.sourcePrimaryId') AS source_primary_id,
+  json_extract(value, '$.linkId') AS link_id,
+  json_extract(value, '$.targetTypeId') AS target_type_id,
+  json_extract(value, '$.targetPrimaryId') AS target_primary_id`;
+function requestedEntity(ref) {
+  const key = projectionEntityKey(ref);
   return {
-    sql: `SELECT * FROM ontology_source_rows WHERE project_id = ? AND source_id = ? AND materialization_id = ?
+    entityKind: ref.kind,
+    ...sourceEntityColumns(ref),
+    rootKeys: ref.kind === "object" ? [key] : [key, projectionEntityKey({ kind: "object", ref: ref.ref.source })]
+  };
+}
+function sourceVersionId(db, input) {
+  const version = db.query(`SELECT version_id FROM ontology_sources
+      WHERE project_id = ? AND source_id = ? AND materialization_id = ?`).get(input.projectId, input.sourceId, input.materializationId);
+  return version?.version_id ?? null;
+}
+function replacementSourceRows(db, input) {
+  const version = sourceVersionId(db, input);
+  const live = `live.retired_at IS NULL AND live.deleted = 0
+    AND versions.source_id = ? AND versions.status IN ${PUBLISHED}`;
+  const replaced = input.incremental ? `SELECT live.id FROM ontology_source_roots AS changed
+      CROSS JOIN ontology_source_roots AS live
+        ON live.project_id = ? AND live.root_key = changed.root_key
+      CROSS JOIN ontology_sources AS versions ON versions.version_id = live.version_id
+      WHERE changed.version_id = ? AND ${live}` : `SELECT live.id FROM ontology_sources AS versions
+      CROSS JOIN ontology_source_roots AS live ON live.version_id = versions.version_id
+      WHERE versions.project_id = ? AND ${live}`;
+  return {
+    sql: `SELECT rows.* FROM ontology_source_roots AS roots
+      CROSS JOIN ontology_source_rows AS rows ON rows.root_id = roots.id
+      WHERE roots.version_id = ?
       UNION ALL
-      SELECT rows.* FROM ${roots}
-      CROSS 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 ${selected}.project_id = ? AND ${selected}.source_id = ?
-        AND ${input.incremental ? "changed.materialization_id = ?" : "roots.active = 1"}`,
-    values: [
-      input.projectId,
-      input.sourceId,
-      input.materializationId,
-      input.projectId,
-      input.sourceId,
-      ...input.incremental ? [input.materializationId] : []
-    ]
+      SELECT rows.* FROM (${replaced}) AS roots
+      CROSS JOIN ontology_source_rows AS rows ON rows.root_id = roots.id`,
+    values: [version, input.projectId, ...input.incremental ? [version] : [], input.sourceId]
   };
 }
 function stageSourceRoots(db, manifest, input) {
@@ -12506,15 +12922,15 @@ function stageSourceRoots(db, manifest, input) {
     throw new MaterializationValidationError("Root deletions require a source delta base.");
   }
   const existing = db.query(`SELECT staging_ordinal, deleted FROM ontology_source_roots
-    WHERE project_id = ? AND source_id = ? AND materialization_id = ? AND root_sort_key = ?`);
+    WHERE version_id = ? AND root_key = ?`);
   const insert = db.query(`INSERT INTO ontology_source_roots (
-    project_id, source_id, materialization_id, root_sort_key, root_kind, root_key, root, staging_ordinal, deleted
-  ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?) ON CONFLICT DO NOTHING RETURNING root_sort_key`);
+    version_id, project_id, root_key, staging_ordinal, deleted
+  ) VALUES (?, ?, ?, ?, ?) ON CONFLICT DO NOTHING RETURNING id`);
   for (const root of roots) {
-    const inserted = insert.get(input.projectId, input.source.projectionId, input.materializationId, root.sortKey, root.root.kind, root.rootKey, canonicalJson(root.root), root.stagingOrdinal, Number(root.deleted));
+    const inserted = insert.get(manifest.version_id, input.projectId, root.rootKey, root.stagingOrdinal, Number(root.deleted));
     if (inserted)
       continue;
-    const previous = existing.get(input.projectId, input.source.projectionId, input.materializationId, root.sortKey);
+    const previous = existing.get(manifest.version_id, root.rootKey);
     if (!previous || previous.staging_ordinal !== root.stagingOrdinal || Boolean(previous.deleted) !== root.deleted) {
       throw new MaterializationValidationError("Source materialization repeats root or stream ordinal with different content.");
     }
@@ -12525,72 +12941,61 @@ function activateSourceRoots(db, projectId, candidate, activation) {
     throw new MaterializationConflictError2("projection-fence", "Source delta base changed before activation.");
   if (candidate.base_materialization_id !== null && candidate.root_count === 0)
     return;
-  const scope = [projectId, activation.source.projectionId, activation.materializationId];
-  db.query(`UPDATE ontology_source_roots AS roots SET active = 0, retired_at = ?
-    WHERE project_id = ? AND source_id = ? AND active = 1
-      ${candidate.base_materialization_id === null ? "" : `AND root_sort_key IN (
-        SELECT root_sort_key FROM ontology_source_roots
-        WHERE project_id = ? AND source_id = ? AND materialization_id = ?)`}`).run(activation.updatedAt, projectId, activation.source.projectionId, ...candidate.base_materialization_id === null ? [] : [...scope]);
-  db.query(`UPDATE ontology_source_roots SET active = CASE WHEN deleted = 1 THEN 0 ELSE 1 END,
-      retired_at = CASE WHEN deleted = 1 THEN ? ELSE NULL END
-    WHERE project_id = ? AND source_id = ? AND materialization_id = ?`).run(activation.updatedAt, ...scope);
+  const delta = candidate.base_materialization_id !== null;
+  db.query(`UPDATE ontology_source_roots SET retired_at = ?
+    WHERE retired_at IS NULL AND deleted = 0
+      AND version_id IN (SELECT version_id FROM ontology_sources
+        WHERE project_id = ? AND source_id = ? AND status IN ${PUBLISHED})
+      ${delta ? `AND project_id = ? AND root_key IN (
+        SELECT root_key FROM ontology_source_roots WHERE version_id = ?)` : ""}`).run(activation.updatedAt, projectId, activation.source.projectionId, ...delta ? [projectId, candidate.version_id] : []);
+  db.query(`UPDATE ontology_source_roots SET retired_at = ?
+    WHERE version_id = ? AND deleted = 1`).run(activation.updatedAt, candidate.version_id);
 }
 function assertSourceRootCoverage(db, manifest) {
   const invalid = db.query(`SELECT 1 FROM ontology_source_roots AS roots
-    WHERE project_id = ? AND source_id = ? AND materialization_id = ?
+    WHERE roots.version_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`).get(manifest.project_id, manifest.source_id, manifest.materialization_id);
+        SELECT 1 FROM ontology_source_rows AS rows WHERE rows.root_id = roots.id
+      ) LIMIT 1`).get(manifest.version_id);
   if (invalid)
     throw new MaterializationValidationError("Source roots must have complete assertions or an explicit deletion, never both.");
 }
 function activeSourceRows(db, 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) => ({ rootSortKey, entitySortKey }));
+  const requested = refs.flatMap((ref) => {
+    const { rootKeys, ...entity } = requestedEntity(ref);
+    return rootKeys.map((rootKey) => ({ ...entity, rootKey }));
   });
   return db.query(`WITH requested AS (
-    SELECT DISTINCT json_extract(value, '$.rootSortKey') AS root_sort_key,
-      json_extract(value, '$.entitySortKey') AS entity_sort_key FROM json_each(?)
-  ) SELECT rows.* FROM requested
+    SELECT DISTINCT json_extract(value, '$.rootKey') AS root_key, ${REQUESTED_ENTITY}
+    FROM json_each(?)
+  ) SELECT ${SOURCE_ASSERTION_COLUMNS} FROM requested
     CROSS JOIN ontology_source_roots AS roots ON roots.project_id = ?
-      AND roots.active = 1 AND roots.root_sort_key = requested.root_sort_key
-    CROSS 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`).all(canonicalJson(keys), projectId);
+      AND roots.root_key = requested.root_key AND roots.retired_at IS NULL AND roots.deleted = 0
+    CROSS JOIN ontology_sources AS versions ON versions.version_id = roots.version_id
+      AND versions.status IN ${PUBLISHED}
+    CROSS JOIN ontology_source_rows AS rows ON rows.root_id = roots.id AND ${ENTITY_MATCH}`).all(canonicalJson(requested), projectId);
 }
 function replacementAssertionRows(db, input) {
-  const keys = input.refs.map((ref) => ({
-    entityKind: ref.kind,
-    entityKey: projectionEntityKey(ref),
-    rootKeys: ref.kind === "object" ? [utf8SortKey(projectionEntityKey(ref))] : [
-      utf8SortKey(projectionEntityKey(ref)),
-      utf8SortKey(projectionEntityKey({ kind: "object", ref: ref.ref.source }))
-    ]
-  }));
+  const version = sourceVersionId(db, input);
   const previous = !input.includePrevious ? "" : `UNION ALL
-    SELECT rows.* FROM requested_entities AS requested
-    CROSS JOIN ontology_source_roots AS roots ON roots.project_id = ? AND roots.source_id = ?
-      AND roots.active = 1 AND roots.root_sort_key IN (SELECT value FROM json_each(requested.root_keys))
-    CROSS 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
-      AND rows.entity_kind = requested.entity_kind AND rows.entity_key = requested.entity_key
+    SELECT ${SOURCE_ASSERTION_COLUMNS} FROM requested_entities AS requested
+    CROSS JOIN ontology_source_roots AS roots ON roots.project_id = ?
+      AND roots.root_key IN (SELECT value FROM json_each(requested.root_keys))
+      AND roots.retired_at IS NULL AND roots.deleted = 0
+    CROSS JOIN ontology_sources AS versions ON versions.version_id = roots.version_id
+      AND versions.source_id = ? AND versions.status IN ${PUBLISHED}
+    CROSS JOIN ontology_source_rows AS rows ON rows.root_id = roots.id AND ${ENTITY_MATCH}
     ${!input.incremental ? "" : `WHERE 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 = ? AND changed.root_sort_key = roots.root_sort_key)`}`;
+      WHERE changed.version_id = ? AND changed.root_key = roots.root_key)`}`;
   return db.query(`WITH requested_entities AS (
-    SELECT DISTINCT json_extract(value, '$.entityKind') AS entity_kind,
-      json_extract(value, '$.entityKey') AS entity_key, json_extract(value, '$.rootKeys') AS root_keys FROM json_each(?)
-  ) SELECT rows.* FROM requested_entities AS requested
-    CROSS JOIN ontology_source_rows AS rows ON rows.project_id = ? AND rows.source_id = ?
-      AND rows.materialization_id = ? AND rows.entity_kind = requested.entity_kind AND rows.entity_key = requested.entity_key
-    ${previous}`).all(canonicalJson(keys), input.projectId, input.sourceId, input.materializationId, ...input.includePrevious ? [input.projectId, input.sourceId, ...input.incremental ? [input.materializationId] : []] : []);
+    SELECT DISTINCT ${REQUESTED_ENTITY}, json_extract(value, '$.rootKeys') AS root_keys
+    FROM json_each(?)
+  ) SELECT ${SOURCE_ASSERTION_COLUMNS} FROM requested_entities AS requested
+    CROSS JOIN ontology_source_roots AS roots ON roots.version_id = ?
+      AND roots.root_key IN (SELECT value FROM json_each(requested.root_keys))
+    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 AND ${ENTITY_MATCH}
+    ${previous}`).all(canonicalJson(input.refs.map(requestedEntity)), version, ...input.includePrevious ? [input.projectId, input.sourceId, ...input.incremental ? [version] : []] : []);
 }
 
 // src/ontology-storage/materialization-state.ts
@@ -12803,19 +13208,13 @@ class SqliteMaterializationStateReader {
              json_extract(value, '$.linkId') AS link_id
            FROM json_each(?)
          )
-         SELECT rows.* FROM requested
+         SELECT ${SOURCE_ASSERTION_COLUMNS} FROM requested
          CROSS JOIN ontology_source_rows AS rows
-           ON rows.project_id = ?
-          AND rows.entity_kind = 'link'
+           ON rows.entity_kind = 'link'
           AND rows.source_type_id = requested.source_type_id
           AND rows.source_primary_id = requested.source_primary_id
           AND rows.link_id = requested.link_id
-         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 sources.active = 1`).all(requestedJson, this.projectId);
+         ${LIVE_SOURCE_ROWS_JOIN}`).all(requestedJson, this.projectId);
     const slotOverrideRows = this.db.query(`WITH requested AS (
            SELECT DISTINCT
              json_extract(value, '$.sourceTypeId') AS source_type_id,
@@ -12904,12 +13303,8 @@ class SqliteMaterializationStateReader {
               SELECT rows.source_type_id, rows.source_primary_id, rows.link_id,
                 rows.target_type_id, rows.target_primary_id
               FROM ontology_source_rows AS rows
-              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 = ? AND rows.entity_kind = 'link' AND sources.active = 1
+              ${LIVE_SOURCE_ROWS_JOIN}
+              WHERE rows.entity_kind = 'link'
             ), selected AS (
               SELECT DISTINCT links.*,
                 ${linkSortExpression("links")} AS sort_key
@@ -13020,7 +13415,7 @@ class SqliteMaterializationStateReader {
     this.prepareReplacementLinks(input);
   }
   prepareReplacementObjects(input) {
-    const rows = replacementSourceRows({
+    const rows = replacementSourceRows(this.db, {
       projectId: this.projectId,
       sourceId: input.sourceId,
       materializationId: input.candidateMaterializationId,
@@ -13031,14 +13426,14 @@ class SqliteMaterializationStateReader {
             session_id, entity_kind, identity_key, sort_key, diff_required
           )
           SELECT ?, 'object', json_array(object_type_id, primary_id),
-            MIN(entity_sort_key), 1
+            ${objectSortExpression()}, 1
           FROM (${rows.sql}) AS rows
           WHERE entity_kind = 'object'
           GROUP BY object_type_id, primary_id
         `).run(input.sessionId, ...rows.values);
   }
   prepareReplacementLinks(input) {
-    const rows = replacementSourceRows({
+    const rows = replacementSourceRows(this.db, {
       projectId: this.projectId,
       sourceId: input.sourceId,
       materializationId: input.candidateMaterializationId,
@@ -13095,31 +13490,21 @@ class SqliteMaterializationStateReader {
             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_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 = ? AND rows.entity_kind = 'link'
-              AND sources.active = 1
+            FROM incident_objects
+            CROSS JOIN ontology_source_rows AS rows
+              ON rows.entity_kind = 'link'
+             AND rows.source_type_id = incident_objects.object_type_id
+             AND rows.source_primary_id = incident_objects.primary_id
+            ${LIVE_SOURCE_ROWS_JOIN}
             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_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 = ? AND rows.entity_kind = 'link'
-              AND sources.active = 1
+            FROM incident_objects
+            CROSS JOIN ontology_source_rows AS rows
+              ON rows.entity_kind = 'link'
+             AND rows.target_type_id = incident_objects.object_type_id
+             AND rows.target_primary_id = incident_objects.primary_id
+            ${LIVE_SOURCE_ROWS_JOIN}
           ), diff_links AS (
             SELECT * FROM replacement_links
             UNION SELECT * FROM incident_links
@@ -13269,9 +13654,7 @@ function storedSource(row) {
   return {
     source: { projectionId: row.source_id },
     materializationId: row.materialization_id,
-    root: parseJson2(row.root),
-    assertion: parseJson2(row.assertion),
-    stagingOrdinal: row.staging_ordinal
+    ...sourceAssertion(row)
   };
 }
 function effectiveObjectSnapshot(row) {
@@ -13319,6 +13702,10 @@ function storedPoint(row) {
     lastCommitId: row.last_commit_id
   };
 }
+function objectSortExpression(alias) {
+  const prefix = alias ? `${alias}.` : "";
+  return `LOWER(HEX(CAST(json_array(${prefix}object_type_id, ${prefix}primary_id) AS BLOB)))`;
+}
 function linkSortExpression(alias) {
   const prefix = alias ? `${alias}.` : "";
   return `LOWER(HEX(CAST(json_array(${prefix}source_type_id, ${prefix}source_id, ${prefix}link_id, ${prefix}target_type_id, ${prefix}target_id) AS BLOB)))`;
@@ -14499,51 +14886,80 @@ import {
   sourceEntityColumns as entityColumns,
   isExactStagingManifest,
   reconcileSourceStageRows,
+  sourceAssertionPayload,
   sourceConflict,
   sourceMaterializationIdentity,
   sourceStageRow,
-  sourceStageRows,
-  utf8SortKey as utf8SortKey2
+  sourceStageRows
 } from "@sixb/core/internal/ontology-storage-provider";
 
 // src/ontology-storage/source-cleanup.ts
+function purgeAbandonedSourceVersions(db, input) {
+  let remaining = input.limit;
+  let rowsDeleted = 0;
+  let materializationsDeleted = 0;
+  const nextCandidate = db.query(`
+    SELECT version_id FROM ontology_sources
+    WHERE project_id = ? AND status = 'abandoned'
+    ORDER BY terminal_at, source_id, materialization_id LIMIT 1
+  `);
+  const deleteRows = db.query(`DELETE FROM ontology_source_rows WHERE rowid IN (
+    SELECT rows.rowid FROM ontology_source_roots AS roots
+    CROSS JOIN ontology_source_rows AS rows ON rows.root_id = roots.id
+    WHERE roots.version_id = ? LIMIT ?)`);
+  const deleteRoots = db.query(`DELETE FROM ontology_source_roots WHERE id IN (
+    SELECT id FROM ontology_source_roots WHERE version_id = ? LIMIT ?)`);
+  const deleteManifest = db.query("DELETE FROM ontology_sources WHERE version_id = ? AND status = 'abandoned'");
+  while (remaining > 0) {
+    const candidate = nextCandidate.get(input.projectId);
+    if (!candidate)
+      break;
+    const rows = deleteRows.run(candidate.version_id, remaining).changes;
+    rowsDeleted += rows;
+    remaining -= rows;
+    if (remaining === 0)
+      break;
+    const roots = deleteRoots.run(candidate.version_id, remaining).changes;
+    rowsDeleted += roots;
+    remaining -= roots;
+    if (remaining === 0)
+      break;
+    const manifest = deleteManifest.run(candidate.version_id).changes;
+    if (manifest === 0)
+      break;
+    materializationsDeleted += manifest;
+    remaining -= manifest;
+  }
+  return { rowsDeleted, materializationsDeleted };
+}
 function cleanupSourceVersions(db, input) {
   let remaining = input.limit;
+  const retired = `roots.project_id = ? AND roots.retired_at < ? AND versions.status = 'superseded'`;
   let rowsDeleted = db.query(`DELETE FROM ontology_source_rows WHERE rowid IN (
     SELECT rows.rowid FROM ontology_source_roots AS roots
-    JOIN ontology_sources AS sources USING (project_id, source_id, materialization_id)
-    CROSS 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 = ? AND roots.active = 0 AND roots.retired_at < ?
-      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
+    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
+    WHERE ${retired}
+    ORDER BY roots.retired_at, roots.id
     LIMIT ?
   )`).run(input.projectId, input.terminalBefore, remaining).changes;
   remaining -= rowsDeleted;
   if (remaining > 0) {
-    const removed = db.query(`DELETE FROM ontology_source_roots WHERE rowid IN (
-      SELECT roots.rowid FROM ontology_source_roots AS roots
-      JOIN ontology_sources AS sources USING (project_id, source_id, materialization_id)
-      WHERE roots.project_id = ? AND roots.active = 0 AND roots.retired_at < ?
-        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 ?
+    const removed = db.query(`DELETE FROM ontology_source_roots WHERE id IN (
+      SELECT roots.id FROM ontology_source_roots AS roots
+      JOIN ontology_sources AS versions ON versions.version_id = roots.version_id
+      WHERE ${retired}
+        AND NOT EXISTS (SELECT 1 FROM ontology_source_rows AS rows WHERE rows.root_id = roots.id)
+      ORDER BY roots.retired_at, roots.id LIMIT ?
     )`).run(input.projectId, input.terminalBefore, remaining).changes;
     rowsDeleted += removed;
     remaining -= removed;
   }
-  const materializationsDeleted = remaining === 0 ? 0 : db.query(`DELETE FROM ontology_sources WHERE rowid IN (
-    SELECT sources.rowid FROM ontology_sources AS sources
-    WHERE project_id = ? AND status IN ('superseded', 'abandoned') AND terminal_at < ?
+  const materializationsDeleted = remaining === 0 ? 0 : db.query(`DELETE FROM ontology_sources WHERE version_id IN (
+    SELECT versions.version_id FROM ontology_sources AS versions
+    WHERE project_id = ? AND status = 'superseded' AND terminal_at < ?
       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)
+        WHERE roots.version_id = versions.version_id)
     ORDER BY terminal_at, source_id, materialization_id LIMIT ?
   )`).run(input.projectId, input.terminalBefore, remaining).changes;
   return { rowsDeleted, materializationsDeleted };
@@ -14575,7 +14991,7 @@ class SqliteOntologySourceStorage {
             LIMIT 1
           `).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.`);
+        throw sourceConflict(`Projection run '${input.execution.projectionRunId}' already has a nonterminal source materialization; adopt it before beginning another.`);
       }
       this.db.query(`
             INSERT INTO ontology_sources (
@@ -14601,10 +15017,10 @@ class SqliteOntologySourceStorage {
         throw sourceConflict(`Source materialization '${input.materializationId}' is '${manifest.status}' and cannot accept rows.`);
       }
       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();
@@ -14654,13 +15070,40 @@ class SqliteOntologySourceStorage {
       return row ? sourceRecord(row) : null;
     });
   }
+  async adopt(input) {
+    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;
+      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) {
     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;
     });
   }
   async cleanupTerminal(input) {
@@ -14671,6 +15114,13 @@ class SqliteOntologySourceStorage {
       return cleanupSourceVersions(this.db, input);
     });
   }
+  async purgeAbandoned(input) {
+    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) {
     return this.runRootOperation(() => {
       assertNonblank(input.projectId, "Terminal source summary project id");
@@ -14696,19 +15146,20 @@ class SqliteOntologySourceStorage {
     assertSourceCandidateOwner(sourceRecord(manifest), input.execution);
     return this.transitionToAbandoned(manifest, input.abandonedAt);
   }
-  abandonForReclaim(input) {
+  findRunCandidate(input) {
     const candidates = this.db.query(`
           SELECT * FROM ontology_sources
           WHERE project_id = ? AND source_id = ? AND projection_run_id = ?
             AND status IN ('staging', 'ready')
         `).all(input.projectId, input.source.projectionId, input.execution.projectionRunId);
-    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;
+  }
+  lastStagedOrdinal(manifest) {
+    const last = this.db.query("SELECT MAX(staging_ordinal) AS ordinal FROM ontology_source_roots WHERE version_id = ?").get(manifest.version_id);
+    return last?.ordinal ?? 0;
   }
   transitionToAbandoned(manifest, abandonedAt) {
     if (abandonedAt < manifest.created_at || manifest.ready_at !== null && abandonedAt < manifest.ready_at) {
@@ -14723,84 +15174,95 @@ class SqliteOntologySourceStorage {
     if (changed !== 1) {
       throw sourceConflict(`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);
     return sourceRecord(this.requireManifest(manifest.project_id, manifest.source_id, manifest.materialization_id));
   }
   assertReadyState(manifest, rootCount, assertionCount) {
     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 = ?
-        `).get(manifest.project_id, manifest.source_id, manifest.materialization_id, manifest.project_id, manifest.source_id, manifest.materialization_id);
+          WHERE version_id = ?1
+        `).get(manifest.version_id);
     if (counts.assertions !== assertionCount || counts.roots !== rootCount || counts.ordinals !== rootCount || rootCount > 0 && (counts.min_ordinal !== 0 || counts.max_ordinal !== rootCount - 1)) {
       throw new MaterializationValidationError4("Source ready counts do not match the staged roots and assertions.");
     }
     assertSourceRootCoverage(this.db, manifest);
     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 MaterializationValidationError4(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.");
     }
   }
-  findStageRows(input, rows) {
+  findStageRows(manifest, rows) {
     if (rows.length === 0)
       return [];
-    const rootSortKeys = [...new Set(rows.map((row) => utf8SortKey2(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) => utf8SortKey2(row.entityKey)))];
     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(?))
-            )
-        `).all(input.projectId, input.source.projectionId, input.materializationId, JSON.stringify(rootSortKeys), JSON.stringify(ordinals), JSON.stringify(entitySortKeys));
+          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(manifest.version_id, JSON.stringify(rootKeys), JSON.stringify(ordinals));
     return existing.map((row) => sourceStageRow(sourceAssertion(row)));
   }
-  insertStageRows(input, rows) {
+  insertStageRows(manifest, rows) {
     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: utf8SortKey2(entityKey),
-        rootKind: row.root.kind,
         rootKey,
-        rootSortKey: utf8SortKey2(rootKey),
-        stagingOrdinal: row.stagingOrdinal,
-        root: row.root,
-        assertion: row.assertion,
+        entityKind: row.assertion.kind,
         objectTypeId: entity.objectTypeId,
         primaryId: entity.primaryId,
         sourceTypeId: entity.sourceTypeId,
@@ -14808,45 +15270,27 @@ class SqliteOntologySourceStorage {
         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.query(`
+    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
-        `).run(canonicalJson(payload), input.projectId, input.source.projectionId, input.materializationId);
+          CROSS JOIN ontology_source_roots AS roots
+            ON roots.version_id = ? AND roots.root_key = json_extract(value, '$.rootKey')
+        `).run(canonicalJson(payload), manifest.version_id).changes;
+    if (inserted !== rows.length) {
+      throw sourceConflict("Staged source rows do not all belong to a staged root.");
+    }
   }
   assertExecution(input, identity) {
     assertProjectionExecution(this.db, {
@@ -15113,6 +15557,8 @@ function queryLatestRunsByOwnerId(input) {
     return [];
   }
   const placeholders = ownerIds.map(() => "?").join(", ");
+  const statusFilter = input.excludedStatus === undefined ? "" : " AND status <> ?";
+  const statusArgs = input.excludedStatus === undefined ? [] : [input.excludedStatus];
   const orderColumn = input.tableName === "sync_runs" || input.tableName === "pipeline_runs" || input.tableName === "projection_runs" ? "COALESCE(started_at, queued_at)" : "started_at";
   const rows = input.db.query(`
         SELECT *
@@ -15124,10 +15570,10 @@ function queryLatestRunsByOwnerId(input) {
               ORDER BY ${orderColumn} DESC, id DESC
             ) AS sixb_latest_rank
           FROM ${input.tableName}
-          WHERE project_id = ? AND ${input.ownerColumn} IN (${placeholders})
+          WHERE project_id = ? AND ${input.ownerColumn} IN (${placeholders})${statusFilter}
         )
         WHERE sixb_latest_rank = 1
-      `).all(input.projectId, ...ownerIds);
+      `).all(input.projectId, ...ownerIds, ...statusArgs);
   const latestByOwnerId = new Map(rows.map((row) => [input.ownerIdFor(row), row]));
   return ownerIds.flatMap((ownerId) => {
     const row = latestByOwnerId.get(ownerId);
@@ -15473,12 +15919,14 @@ import {
   failProjectionRunEnqueue,
   immutableDatasetVersionConflict,
   mergeProjectionRunProgress,
+  parseProjectionAttemptFailure,
   planProjectionRunFinish,
   planProjectionRunReclaim,
   projectionRunNotFound,
   publicProjectionRunRecord,
   requireTelemetryProjectionRun,
   restoreProjectionRun,
+  SUPERSEDING_PROJECTION_RUN_STATUSES,
   staleProjectionRunExecution
 } from "@sixb/core/internal/projection-run-storage-provider";
 import { PROJECTION_RUN_FAILURE_CODES, ProjectionRunError } from "@sixb/core/storage";
@@ -15560,7 +16008,7 @@ class SqliteProjectionRunStorage {
       const result = this.db.query(`
             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)
@@ -15604,6 +16052,20 @@ class SqliteProjectionRunStorage {
       return rowToProjectionRunRecord(this.requireRow(input.projectId, input.id));
     });
   }
+  async recordAttemptFailure(input) {
+    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(serializeSixbFailure4(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) {
     return runImmediateTransaction(this.db, () => {
       const existingRow = this.requireMaterializationExecution(input);
@@ -15741,6 +16203,21 @@ class SqliteProjectionRunStorage {
     const runs = rows.map(rowToProjectionRunRecord);
     return { runs, hasMore: offset + runs.length < totalRow.count, total: totalRow.count };
   }
+  async findSupersedingRun(input) {
+    const run = this.requireRow(input.projectId, input.id);
+    if (run.materialization_protocol !== "replacement")
+      return null;
+    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);
+    return newer ? rowToProjectionRunRecord(newer) : null;
+  }
   async listLatestByProjectionIds(input) {
     const rows = queryLatestRunsByOwnerId({
       db: this.db,
@@ -15748,7 +16225,8 @@ class SqliteProjectionRunStorage {
       ownerColumn: "projection_id",
       ownerIds: input.projectionIds,
       projectId: input.projectId,
-      ownerIdFor: (row) => row.projection_id
+      ownerIdFor: (row) => row.projection_id,
+      excludedStatus: "superseded"
     });
     return { runs: rows.map(rowToProjectionRunRecord) };
   }
@@ -17945,4 +18423,4 @@ export {
   migrateSqliteStorage
 };
 
-//# debugId=9F25188860B63C3464756E2164756E21
+//# debugId=A2CEAFAB428734DF64756E2164756E21