@sixb/sqlite 0.1.9 → 0.1.10

package/dist/index.js

@@ -3932,6 +3932,53 @@ DROP TABLE executions;
 ALTER TABLE executions_v2 RENAME TO executions;
 `;
 
+// src/migrations/038-projection-source-roots.sql
+var _038_projection_source_roots_default = `ALTER TABLE ontology_sources ADD COLUMN base_materialization_id TEXT;
+ALTER TABLE ontology_sources ADD COLUMN base_commit_id TEXT
+  CHECK ((base_materialization_id IS NULL) = (base_commit_id IS NULL));
+
+CREATE TABLE ontology_source_roots (
+  project_id TEXT NOT NULL,
+  source_id TEXT NOT NULL,
+  materialization_id TEXT NOT NULL,
+  root_sort_key TEXT NOT NULL,
+  root_kind TEXT NOT NULL CHECK (root_kind IN ('object', 'link')),
+  root_key TEXT NOT NULL CHECK (json_valid(root_key)),
+  root TEXT NOT NULL CHECK (json_valid(root)),
+  staging_ordinal INTEGER NOT NULL CHECK (staging_ordinal >= 0),
+  deleted INTEGER NOT NULL DEFAULT 0 CHECK (deleted IN (0, 1)),
+  active INTEGER NOT NULL DEFAULT 0 CHECK (active IN (0, 1)),
+  retired_at TEXT,
+  PRIMARY KEY (project_id, source_id, materialization_id, root_sort_key),
+  UNIQUE (project_id, source_id, materialization_id, staging_ordinal),
+  FOREIGN KEY (project_id, source_id, materialization_id)
+    REFERENCES ontology_sources(project_id, source_id, materialization_id) ON DELETE RESTRICT,
+  CHECK (active = 0 OR (deleted = 0 AND retired_at IS NULL))
+);
+CREATE UNIQUE INDEX idx_ontology_source_roots_active
+  ON ontology_source_roots (project_id, source_id, root_sort_key) WHERE active = 1;
+CREATE INDEX idx_ontology_source_roots_lookup
+  ON ontology_source_roots (project_id, root_sort_key, source_id) WHERE active = 1;
+CREATE INDEX idx_ontology_source_roots_cleanup
+  ON ontology_source_roots (project_id, retired_at, source_id, materialization_id, root_sort_key)
+  WHERE active = 0 AND retired_at IS NOT NULL;
+
+INSERT INTO ontology_source_roots (
+  project_id, source_id, materialization_id, root_sort_key, root_kind, root_key, root,
+  staging_ordinal, active, retired_at
+)
+SELECT DISTINCT rows.project_id, rows.source_id, rows.materialization_id,
+  rows.root_sort_key, rows.root_kind, rows.root_key, rows.root, rows.staging_ordinal,
+  sources.status = 'active', sources.terminal_at
+FROM ontology_source_rows AS rows
+JOIN ontology_sources AS sources USING (project_id, source_id, materialization_id);
+
+ANALYZE ontology_source_roots;
+
+ALTER TABLE projection_runs ADD COLUMN source_changes_read INTEGER
+  CHECK (source_changes_read IS NULL OR source_changes_read >= 0);
+`;
+
 // src/migrations/037-execution-requester-groups.sql
 var _037_execution_requester_groups_default = `ALTER TABLE executions ADD COLUMN requester_group_ids TEXT NOT NULL DEFAULT '[]';
 
@@ -3959,6 +4006,61 @@ ALTER TABLE workflow_runs DROP COLUMN requester_group_ids;
 ALTER TABLE agent_runs DROP COLUMN requester_group_ids;
 `;
 
+// src/migrations/039-connector-optional-pkce.sql
+var _039_connector_optional_pkce_default = `-- Rebuild to remove NOT NULL while preserving existing attempts and their constraints.
+CREATE TABLE connector_authorization_attempts_optional_pkce (
+  project_id TEXT NOT NULL,
+  connector_id TEXT NOT NULL,
+  id TEXT NOT NULL,
+  slot TEXT NOT NULL,
+  initiated_by_execution_id TEXT NOT NULL,
+  state_hash TEXT NOT NULL,
+  code_verifier TEXT CHECK (
+    code_verifier IS NULL
+    OR (json_valid(code_verifier) AND json_type(code_verifier) = 'object')
+  ),
+  redirect_uri TEXT NOT NULL,
+  connection_run_id TEXT,
+  return_to TEXT,
+  callback_binding_hash TEXT,
+  reauthorization_id TEXT,
+  reauthorization_revision INTEGER CHECK (
+    reauthorization_revision IS NULL OR reauthorization_revision >= 0
+  ),
+  reauthorization_connection_ids TEXT CHECK (
+    reauthorization_connection_ids IS NULL
+    OR (json_valid(reauthorization_connection_ids) AND json_type(reauthorization_connection_ids) = 'array')
+  ),
+  created_at TEXT NOT NULL,
+  expires_at TEXT NOT NULL,
+  PRIMARY KEY (project_id, connector_id, id),
+  UNIQUE (project_id, id),
+  UNIQUE (project_id, connector_id, connection_run_id),
+  FOREIGN KEY (project_id, connector_id, connection_run_id)
+    REFERENCES connector_connection_runs (project_id, connector_id, id)
+    ON DELETE RESTRICT,
+  CHECK (
+    (connection_run_id IS NULL AND return_to IS NULL AND callback_binding_hash IS NULL)
+    OR
+    (connection_run_id IS NOT NULL AND return_to IS NOT NULL AND callback_binding_hash IS NOT NULL)
+  ),
+  CHECK (
+    (reauthorization_id IS NULL AND reauthorization_revision IS NULL AND reauthorization_connection_ids IS NULL)
+    OR
+    (reauthorization_id IS NOT NULL AND reauthorization_revision IS NOT NULL AND reauthorization_connection_ids IS NOT NULL)
+  )
+);
+
+INSERT INTO connector_authorization_attempts_optional_pkce
+SELECT * FROM connector_authorization_attempts;
+
+DROP TABLE connector_authorization_attempts;
+ALTER TABLE connector_authorization_attempts_optional_pkce RENAME TO connector_authorization_attempts;
+
+CREATE INDEX idx_connector_attempts_expiry
+  ON connector_authorization_attempts (project_id, connector_id, expires_at);
+`;
+
 // src/migrations.ts
 var MIGRATIONS_TABLE_SQL = `
   CREATE TABLE IF NOT EXISTS sixb_migrations (
@@ -4030,7 +4132,9 @@ var sqliteStorageMigrations = defineMigrations({
     sqliteSql("034-device-authorizations", _034_device_authorizations_default),
     sqliteSql("035-share-grants", _035_share_grants_default),
     sqliteSql("036-share-sessions", _036_share_sessions_default),
-    sqliteSql("037-execution-requester-groups", _037_execution_requester_groups_default)
+    sqliteSql("037-execution-requester-groups", _037_execution_requester_groups_default),
+    sqliteSql("038-projection-source-roots", _038_projection_source_roots_default),
+    sqliteSql("039-connector-optional-pkce", _039_connector_optional_pkce_default)
   ]
 });
 function sqliteStoragePath(basePath) {
@@ -9014,7 +9118,7 @@ class SqliteConnectorConnectionPersistence {
             callback_binding_hash, reauthorization_id, reauthorization_revision,
             reauthorization_connection_ids, created_at, expires_at
           ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
-        `).run(record.projectId, record.connectorId, record.id, record.slot, record.initiatedByExecutionId, record.stateHash, json(record.codeVerifier), record.redirectUri, record.connectionRunId ?? null, record.returnTo ?? null, record.callbackBindingHash ?? null, record.reauthorizationId ?? null, record.reauthorizationRevision ?? null, record.reauthorizationConnectionIds ? json(record.reauthorizationConnectionIds) : null, iso(record.createdAt), iso(record.expiresAt));
+        `).run(record.projectId, record.connectorId, record.id, record.slot, record.initiatedByExecutionId, record.stateHash, record.codeVerifier === undefined ? null : json(record.codeVerifier), record.redirectUri, record.connectionRunId ?? null, record.returnTo ?? null, record.callbackBindingHash ?? null, record.reauthorizationId ?? null, record.reauthorizationRevision ?? null, record.reauthorizationConnectionIds ? json(record.reauthorizationConnectionIds) : null, iso(record.createdAt), iso(record.expiresAt));
       return true;
     } catch (error) {
       if (isUniqueConstraintError2(error))
@@ -9195,7 +9299,7 @@ function authorizationAttemptFromRow(row) {
     slot: row.slot,
     initiatedByExecutionId: row.initiated_by_execution_id,
     stateHash: row.state_hash,
-    codeVerifier: parseJson(row.code_verifier),
+    ...row.code_verifier === null ? {} : { codeVerifier: parseJson(row.code_verifier) },
     redirectUri: row.redirect_uri,
     ...row.connection_run_id === null ? {} : { connectionRunId: row.connection_run_id },
     ...row.return_to === null ? {} : { returnTo: row.return_to },
@@ -11387,6 +11491,12 @@ function sourceRecord(row) {
     projectionRevision: row.projection_revision,
     ownershipHash: row.ownership_hash,
     ontologyRevision: row.ontology_revision,
+    ...row.base_materialization_id === null ? {} : {
+      base: {
+        materializationId: row.base_materialization_id,
+        lastCommitId: row.base_commit_id
+      }
+    },
     rootCount: row.root_count,
     assertionCount: row.assertion_count,
     createdAt: row.created_at,
@@ -11558,7 +11668,7 @@ import {
   linkRefKey as linkRefKey3,
   linkRefSortKey,
   linkScopeSortKey as linkScopeSortKey2,
-  MaterializationConflictError as MaterializationConflictError5,
+  MaterializationConflictError as MaterializationConflictError6,
   objectRefKey as objectRefKey3,
   objectRefSortKey,
   telemetryPointKey as telemetryPointKey2,
@@ -11578,7 +11688,7 @@ import {
 
 // src/ontology-storage/materialization-session.ts
 import {
-  MaterializationConflictError as MaterializationConflictError3
+  MaterializationConflictError as MaterializationConflictError4
 } from "@sixb/core/internal/materialization";
 import {
   correlateMaterializationChunk,
@@ -11593,9 +11703,9 @@ import {
 import {
   linkRefKey,
   linkScopeSortKey,
-  MaterializationConflictError as MaterializationConflictError2,
+  MaterializationConflictError as MaterializationConflictError3,
   objectRefKey,
-  projectionEntityKey,
+  projectionEntityKey as projectionEntityKey2,
   telemetryPointSortKey
 } from "@sixb/core/internal/materialization";
 import {
@@ -11604,6 +11714,132 @@ import {
   linkSlotOverrideValue,
   startScopeAccumulator
 } from "@sixb/core/internal/ontology-storage-provider";
+
+// src/ontology-storage/source-roots.ts
+import {
+  MaterializationConflictError as MaterializationConflictError2,
+  MaterializationValidationError,
+  projectionEntityKey
+} from "@sixb/core/internal/materialization";
+import { sourceStageRoots, utf8SortKey } from "@sixb/core/internal/ontology-storage-provider";
+function replacementSourceRows(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";
+  return {
+    sql: `SELECT * FROM ontology_source_rows WHERE project_id = ? AND source_id = ? AND materialization_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] : []
+    ]
+  };
+}
+function stageSourceRoots(db, manifest, input) {
+  const roots = sourceStageRoots(manifest.projection_kind, input);
+  if (!manifest.base_materialization_id && roots.some((root) => root.deleted)) {
+    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 = ?`);
+  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`);
+  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));
+    if (inserted)
+      continue;
+    const previous = existing.get(input.projectId, input.source.projectionId, input.materializationId, root.sortKey);
+    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.");
+    }
+  }
+}
+function activateSourceRoots(db, projectId, candidate, activation) {
+  if (candidate.base_materialization_id !== null && (candidate.base_materialization_id !== activation.expected.activeMaterializationId || candidate.base_commit_id !== activation.expected.lastCommitId))
+    throw new MaterializationConflictError2("projection-fence", "Source delta base changed before activation.");
+  if (candidate.base_materialization_id !== null && 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);
+}
+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 = ?
+      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);
+  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 }));
+  });
+  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
+    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);
+}
+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 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
+    ${!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)`}`;
+  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] : []] : []);
+}
+
+// src/ontology-storage/materialization-state.ts
 var SQLITE_MATERIALIZATION_WORK_TABLE = "ontology_materialization_work";
 var SQLITE_REPLACEMENT_WORK_TABLE = "ontology_replacement_work";
 function linkScopeRequestJson(scopes) {
@@ -11640,18 +11876,7 @@ class SqliteMaterializationStateReader {
            ON objects.project_id = ?
           AND objects.object_type_id = requested.object_type_id
           AND objects.primary_id = requested.primary_id`).all(requested, this.projectId);
-    const sourceRows = this.db.query(`WITH requested AS (${requestedObjects})
-         SELECT rows.* FROM requested
-         CROSS JOIN ontology_source_rows AS rows
-           ON rows.project_id = ?
-          AND rows.entity_kind = 'object'
-          AND rows.object_type_id = requested.object_type_id
-          AND rows.primary_id = requested.primary_id
-         JOIN ontology_sources AS sources
-           ON sources.project_id = rows.project_id
-          AND sources.source_id = rows.source_id
-          AND sources.materialization_id = rows.materialization_id
-         WHERE sources.status = 'active'`).all(requested, this.projectId);
+    const sourceRows = activeSourceRows(this.db, this.projectId, refs.map((ref) => ({ kind: "object", ref })));
     const overrideRows = this.db.query(`WITH requested AS (${requestedObjects})
          SELECT overrides.* FROM requested
          CROSS JOIN ontology_object_overrides AS overrides
@@ -11690,7 +11915,7 @@ class SqliteMaterializationStateReader {
       const effectiveRow = effective.get(key);
       return {
         ref: structuredClone(ref),
-        source: sourceObject(sources.get(projectionEntityKey({ kind: "object", ref }))),
+        source: sourceObject(sources.get(projectionEntityKey2({ kind: "object", ref }))),
         override: overrides.get(key) ?? null,
         effective: effectiveRow ? effectiveObjectSnapshot(effectiveRow) : null,
         latestTelemetry: telemetry.get(key) ?? []
@@ -11735,21 +11960,7 @@ class SqliteMaterializationStateReader {
           AND links.link_id = requested.link_id
           AND links.target_type_id = requested.target_type_id
           AND links.target_id = requested.target_id`).all(requested, this.projectId);
-    const sourceRows = this.db.query(`WITH requested AS (${sourceRequest})
-         SELECT rows.* FROM requested
-         CROSS JOIN ontology_source_rows AS rows
-           ON rows.project_id = ?
-          AND 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
-          AND rows.target_type_id = requested.target_type_id
-          AND rows.target_primary_id = requested.target_primary_id
-         JOIN ontology_sources AS sources
-           ON sources.project_id = rows.project_id
-          AND sources.source_id = rows.source_id
-          AND sources.materialization_id = rows.materialization_id
-         WHERE sources.status = 'active'`).all(requested, this.projectId);
+    const sourceRows = activeSourceRows(this.db, this.projectId, refs.map((ref) => ({ kind: "link", ref })));
     const overrideRows = this.db.query(`WITH requested AS (${sourceRequest})
          SELECT overrides.* FROM requested
          CROSS JOIN ontology_link_overrides AS overrides
@@ -11780,7 +11991,7 @@ class SqliteMaterializationStateReader {
       const effectiveRow = effective.get(key);
       return {
         ref: structuredClone(ref),
-        source: sourceLink(sources.get(projectionEntityKey({ kind: "link", ref }))),
+        source: sourceLink(sources.get(projectionEntityKey2({ kind: "link", ref }))),
         override: overrides.get(key) ?? null,
         slotOverride: slotOverrides.get(linkScopeSortKey(ref.source, ref.linkId)) ?? null,
         effective: effectiveRow ? effectiveLinkSnapshot(effectiveRow) : null
@@ -11845,11 +12056,12 @@ class SqliteMaterializationStateReader {
           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_sources AS sources
+         JOIN ontology_source_roots AS sources
            ON sources.project_id = rows.project_id
           AND sources.source_id = rows.source_id
           AND sources.materialization_id = rows.materialization_id
-         WHERE sources.status = 'active'`).all(requestedJson, this.projectId);
+         AND sources.root_sort_key = rows.root_sort_key
+         WHERE sources.active = 1`).all(requestedJson, this.projectId);
     const slotOverrideRows = this.db.query(`WITH requested AS (
            SELECT DISTINCT
              json_extract(value, '$.sourceTypeId') AS source_type_id,
@@ -11907,7 +12119,7 @@ class SqliteMaterializationStateReader {
     for (const row of rows) {
       const accumulator = accumulators.get(row.scope_sort_key);
       if (!accumulator) {
-        throw new MaterializationConflictError2("effective-state", `Unexpected link scope '${row.scope_sort_key}' returned by storage.`);
+        throw new MaterializationConflictError3("effective-state", `Unexpected link scope '${row.scope_sort_key}' returned by storage.`);
       }
       const snapshot = effectiveLinkSnapshot(row);
       appendScopeSnapshot(accumulator, snapshot);
@@ -11938,11 +12150,12 @@ 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_sources AS sources
+              JOIN ontology_source_roots AS sources
                 ON sources.project_id = rows.project_id
                AND sources.source_id = rows.source_id
                AND sources.materialization_id = rows.materialization_id
-              WHERE rows.project_id = ? AND rows.entity_kind = 'link' AND sources.status = 'active'
+         AND sources.root_sort_key = rows.root_sort_key
+              WHERE rows.project_id = ? AND rows.entity_kind = 'link' AND sources.active = 1
             ), selected AS (
               SELECT DISTINCT links.*,
                 ${linkSortExpression("links")} AS sort_key
@@ -11985,19 +12198,19 @@ class SqliteMaterializationStateReader {
     const candidates = this.replacementSources(sourceId, [candidateMaterializationId], refs.map((ref) => ({ kind: "object", ref })));
     return base.map((state) => ({
       ref: state.ref,
-      candidateSource: sourceObject(candidates.byMaterialization.get(candidateMaterializationId)?.get(projectionEntityKey({ kind: "object", ref: state.ref }))),
+      candidateSource: sourceObject(candidates.byMaterialization.get(candidateMaterializationId)?.get(projectionEntityKey2({ kind: "object", ref: state.ref }))),
       override: state.override,
       effective: state.effective,
       latestTelemetry: state.latestTelemetry
     }));
   }
-  replacementLinkStates(sourceId, candidateMaterializationId, materializationIds, identities) {
+  replacementLinkStates(sourceId, candidateMaterializationId, materializationIds, identities, incremental = false) {
     const refs = identities.map((identity) => identity.ref);
     const base = this.linkStates(refs);
-    const replacements = this.replacementSources(sourceId, materializationIds, refs.map((ref) => ({ kind: "link", ref })));
+    const replacements = this.replacementSources(sourceId, materializationIds, refs.map((ref) => ({ kind: "link", ref })), incremental);
     const candidate = replacements.byMaterialization.get(candidateMaterializationId);
     return base.map((state, index) => {
-      const key = projectionEntityKey({ kind: "link", ref: state.ref });
+      const key = projectionEntityKey2({ kind: "link", ref: state.ref });
       return {
         ref: state.ref,
         candidateSource: replacements.owned.has(key) ? sourceLink(candidate?.get(key)) : state.source,
@@ -12021,32 +12234,23 @@ class SqliteMaterializationStateReader {
         `).get(this.projectId, ref.source.objectTypeId, ref.source.primaryId, ref.linkId, ref.target.objectTypeId, ref.target.primaryId);
     return row ? row.last_commit_id : undefined;
   }
-  replacementSources(sourceId, materializationIds, refs) {
+  replacementSources(sourceId, materializationIds, refs, incremental = false) {
     if (materializationIds.length === 0 || refs.length === 0) {
       return { owned: new Set, byMaterialization: new Map };
     }
-    const requestedEntities = canonicalJson(refs.map((ref) => ({ entityKind: ref.kind, entityKey: projectionEntityKey(ref) })));
-    const requestedMaterializations = canonicalJson([...new Set(materializationIds)]);
-    const rows = this.db.query(`WITH requested_entities AS (
-           SELECT DISTINCT json_extract(value, '$.entityKind') AS entity_kind,
-             json_extract(value, '$.entityKey') AS entity_key
-           FROM json_each(?)
-         ), requested_materializations AS (
-           SELECT value AS materialization_id FROM json_each(?)
-         )
-         SELECT rows.* FROM requested_materializations
-         CROSS JOIN requested_entities
-         CROSS JOIN ontology_source_rows AS rows
-           ON rows.project_id = ?
-          AND rows.source_id = ?
-          AND rows.materialization_id = requested_materializations.materialization_id
-          AND rows.entity_kind = requested_entities.entity_kind
-          AND rows.entity_key = requested_entities.entity_key`).all(requestedEntities, requestedMaterializations, this.projectId, sourceId);
+    const rows = replacementAssertionRows(this.db, {
+      projectId: this.projectId,
+      sourceId,
+      materializationId: materializationIds[0],
+      incremental,
+      includePrevious: materializationIds.length > 1,
+      refs
+    });
     const owned = new Set;
     const byMaterialization = new Map;
     for (const row of rows) {
       const source = storedSource(row);
-      const key = projectionEntityKey(source.assertion);
+      const key = projectionEntityKey2(source.assertion);
       owned.add(key);
       const materialization = byMaterialization.get(row.materialization_id) ?? new Map;
       materialization.set(key, source);
@@ -12062,19 +12266,30 @@ class SqliteMaterializationStateReader {
     this.prepareReplacementLinks(input);
   }
   prepareReplacementObjects(input) {
+    const rows = replacementSourceRows({
+      projectId: this.projectId,
+      sourceId: input.sourceId,
+      materializationId: input.candidateMaterializationId,
+      incremental: input.incremental ?? false
+    });
     this.db.query(`
           INSERT INTO ${SQLITE_REPLACEMENT_WORK_TABLE} (
             session_id, entity_kind, identity_key, sort_key, diff_required
           )
           SELECT ?, 'object', json_array(object_type_id, primary_id),
             MIN(entity_sort_key), 1
-          FROM ontology_source_rows
-          WHERE project_id = ? AND source_id = ? AND entity_kind = 'object'
-            AND materialization_id IN (?, COALESCE(?, ''))
+          FROM (${rows.sql}) AS rows
+          WHERE entity_kind = 'object'
           GROUP BY object_type_id, primary_id
-        `).run(input.sessionId, this.projectId, input.sourceId, input.candidateMaterializationId, input.previousMaterializationId);
+        `).run(input.sessionId, ...rows.values);
   }
   prepareReplacementLinks(input) {
+    const rows = replacementSourceRows({
+      projectId: this.projectId,
+      sourceId: input.sourceId,
+      materializationId: input.candidateMaterializationId,
+      incremental: input.incremental ?? false
+    });
     this.db.query(`
           WITH incident_objects AS (
             SELECT DISTINCT
@@ -12085,9 +12300,8 @@ class SqliteMaterializationStateReader {
           ), replacement_links AS (
             SELECT source_type_id, source_primary_id AS source_id, link_id,
               target_type_id, target_primary_id AS target_id
-            FROM ontology_source_rows
-            WHERE project_id = ? AND source_id = ? AND entity_kind = 'link'
-              AND materialization_id IN (?, COALESCE(?, ''))
+            FROM (${rows.sql}) AS rows
+            WHERE entity_kind = 'link'
           ), incident_links AS (
             SELECT links.source_type_id, links.source_id, links.link_id,
               links.target_type_id, links.target_id
@@ -12128,28 +12342,30 @@ class SqliteMaterializationStateReader {
             SELECT rows.source_type_id, rows.source_primary_id AS source_id,
               rows.link_id, rows.target_type_id, rows.target_primary_id AS target_id
             FROM ontology_source_rows AS rows
-            JOIN ontology_sources AS sources
+            JOIN ontology_source_roots AS sources
               ON sources.project_id = rows.project_id
              AND sources.source_id = rows.source_id
              AND sources.materialization_id = rows.materialization_id
+         AND sources.root_sort_key = rows.root_sort_key
             JOIN incident_objects
               ON incident_objects.object_type_id = rows.source_type_id
              AND incident_objects.primary_id = rows.source_primary_id
             WHERE rows.project_id = ? AND rows.entity_kind = 'link'
-              AND sources.status = 'active'
+              AND sources.active = 1
             UNION
             SELECT rows.source_type_id, rows.source_primary_id AS source_id,
               rows.link_id, rows.target_type_id, rows.target_primary_id AS target_id
             FROM ontology_source_rows AS rows
-            JOIN ontology_sources AS sources
+            JOIN ontology_source_roots AS sources
               ON sources.project_id = rows.project_id
              AND sources.source_id = rows.source_id
              AND sources.materialization_id = rows.materialization_id
+         AND sources.root_sort_key = rows.root_sort_key
             JOIN incident_objects
               ON incident_objects.object_type_id = rows.target_type_id
              AND incident_objects.primary_id = rows.target_primary_id
             WHERE rows.project_id = ? AND rows.entity_kind = 'link'
-              AND sources.status = 'active'
+              AND sources.active = 1
           ), diff_links AS (
             SELECT * FROM replacement_links
             UNION SELECT * FROM incident_links
@@ -12187,7 +12403,7 @@ class SqliteMaterializationStateReader {
             json_array(source_type_id, source_id, link_id, target_type_id, target_id),
             sort_key, diff_required
           FROM selected
-        `).run(input.sessionId, this.projectId, input.sourceId, input.candidateMaterializationId, input.previousMaterializationId, this.projectId, this.projectId, this.projectId, this.projectId, this.projectId, this.projectId, this.projectId, this.projectId, input.sessionId);
+        `).run(input.sessionId, ...rows.values, this.projectId, this.projectId, this.projectId, this.projectId, this.projectId, this.projectId, this.projectId, this.projectId, input.sessionId);
   }
   replacementRows(input, cursor) {
     return this.db.query(`
@@ -12225,9 +12441,9 @@ function activeSourceMap(rows) {
   const result = new Map;
   for (const row of rows) {
     const source = storedSource(row);
-    const key = projectionEntityKey(source.assertion);
+    const key = projectionEntityKey2(source.assertion);
     if (result.has(key)) {
-      throw new MaterializationConflictError2("source-materialization", `Multiple active sources assert ${key}.`);
+      throw new MaterializationConflictError3("source-materialization", `Multiple active sources assert ${key}.`);
     }
     result.set(key, source);
   }
@@ -12242,7 +12458,7 @@ function activeScopeSourceMap(rows) {
     const ref = source.assertion.ref;
     const key = linkScopeSortKey(ref.source, ref.linkId);
     if (result.has(key)) {
-      throw new MaterializationConflictError2("source-materialization", `Multiple active sources assert cardinality-one link slot ${key}.`);
+      throw new MaterializationConflictError3("source-materialization", `Multiple active sources assert cardinality-one link slot ${key}.`);
     }
     result.set(key, source);
   }
@@ -12306,7 +12522,7 @@ function storedSource(row) {
 }
 function effectiveObjectSnapshot(row) {
   if (!row.last_commit_id) {
-    throw new MaterializationConflictError2("effective-state", `Effective object ${row.object_type_id}:${row.primary_id} lacks materializer provenance.`);
+    throw new MaterializationConflictError3("effective-state", `Effective object ${row.object_type_id}:${row.primary_id} lacks materializer provenance.`);
   }
   return {
     ref: objectRefFromColumns(row),
@@ -12319,7 +12535,7 @@ function effectiveObjectSnapshot(row) {
 }
 function effectiveLinkSnapshot(row) {
   if (!row.last_commit_id) {
-    throw new MaterializationConflictError2("effective-state", `Effective link ${linkRefKey(linkRefFromColumns(row))} lacks materializer provenance.`);
+    throw new MaterializationConflictError3("effective-state", `Effective link ${linkRefKey(linkRefFromColumns(row))} lacks materializer provenance.`);
   }
   return {
     ref: linkRefFromColumns(row),
@@ -12333,7 +12549,7 @@ function effectiveLinkSnapshot(row) {
 }
 function storedPoint(row) {
   if (!row.last_commit_id) {
-    throw new MaterializationConflictError2("timeseries-point", `Telemetry point ${telemetryPointSortKey({
+    throw new MaterializationConflictError3("timeseries-point", `Telemetry point ${telemetryPointSortKey({
       object: { objectTypeId: row.object_type_id, primaryId: row.object_id },
       propertyId: row.property_id
     }, row.at)} lacks materializer provenance.`);
@@ -12372,7 +12588,7 @@ class SqliteMaterializationSessions {
   }
   create(header) {
     if (!this.context?.active) {
-      throw new MaterializationConflictError3("effective-state", "Materialization sessions require an active storage transaction.");
+      throw new MaterializationConflictError4("effective-state", "Materialization sessions require an active storage transaction.");
     }
     this.ensureTables();
     const session = new SqliteMaterializationSessionState(structuredClone(header), this.context.id);
@@ -12384,7 +12600,7 @@ class SqliteMaterializationSessions {
   require(session) {
     const value = this.sessions.get(session.providerToken);
     if (!value || !value.active || !this.context?.active || value.transactionId !== this.context.id) {
-      throw new MaterializationConflictError3("effective-state", "Materialization session is inactive.");
+      throw new MaterializationConflictError4("effective-state", "Materialization session is inactive.");
     }
     return value;
   }
@@ -12444,7 +12660,7 @@ class SqliteMaterializationSessions {
     const session = this.require(input.session);
     const stream = session.workStreams[input.order];
     if (stream.started) {
-      throw new MaterializationConflictError3("effective-state", `Materialization ${input.order} work may only be streamed once per session.`);
+      throw new MaterializationConflictError4("effective-state", `Materialization ${input.order} work may only be streamed once per session.`);
     }
     stream.started = true;
     session.workSealed = true;
@@ -12721,7 +12937,7 @@ function recordSummary(summary, record, columns) {
 // src/ontology-storage/materialization-writer.ts
 import {
   linkRefKey as linkRefKey2,
-  MaterializationConflictError as MaterializationConflictError4,
+  MaterializationConflictError as MaterializationConflictError5,
   objectRefKey as objectRefKey2,
   telemetryPointKey
 } from "@sixb/core/internal/materialization";
@@ -12893,7 +13109,7 @@ class SqliteMaterializationWriter {
               `).run(projectId, point.series.object.objectTypeId, point.series.object.primaryId, point.series.propertyId, canonicalJson(point.value), point.unit ?? null, point.at, point.lastCommitId);
         } catch (error) {
           if (isSqliteConstraintError(error)) {
-            throw new MaterializationConflictError4("timeseries-point", `Telemetry point ${telemetryPointKey(point.series, point.at)} changed.`);
+            throw new MaterializationConflictError5("timeseries-point", `Telemetry point ${telemetryPointKey(point.series, point.at)} changed.`);
           }
           throw error;
         }
@@ -12955,13 +13171,13 @@ class SqliteOntologyMaterializationStorage {
       const linkScopeRevisions = reader.linkScopeRevisions(input.expected.linkScopes);
       for (const [index, expected] of input.expected.linkScopes.entries()) {
         if (linkScopeRevisions[index]?.fingerprint !== expected.fingerprint) {
-          throw new MaterializationConflictError5("effective-state", `Expected link scope changed for ${expected.source.objectTypeId}:${expected.source.primaryId}.${expected.linkId}.`);
+          throw new MaterializationConflictError6("effective-state", `Expected link scope changed for ${expected.source.objectTypeId}:${expected.source.primaryId}.${expected.linkId}.`);
         }
       }
       for (const expected of input.expected.points) {
         const point = reader.exactPoint(expected.series, expected.at);
         if ((point?.lastCommitId ?? null) !== expected.lastCommitId) {
-          throw new MaterializationConflictError5("timeseries-point", `Telemetry point ${telemetryPointKey2(expected.series, expected.at)} changed.`);
+          throw new MaterializationConflictError6("timeseries-point", `Telemetry point ${telemetryPointKey2(expected.series, expected.at)} changed.`);
         }
       }
       return session.publicSession();
@@ -13019,10 +13235,10 @@ class SqliteOntologyMaterializationStorage {
     const reader = new SqliteMaterializationStateReader(this.db, session.header.commit.projectId);
     if (input.entityKind === "object") {
       if (replacement.projectionKind !== "object") {
-        throw new MaterializationConflictError5("source-materialization", "Link projection replacement cannot stream object state.");
+        throw new MaterializationConflictError6("source-materialization", "Link projection replacement cannot stream object state.");
       }
       if (replacement.objectStreamStarted) {
-        throw new MaterializationConflictError5("effective-state", "Replacement object state may only be streamed once per session.");
+        throw new MaterializationConflictError6("effective-state", "Replacement object state may only be streamed once per session.");
       }
       replacement.objectStreamStarted = true;
       for (const identities of reader.replacementIdentities({
@@ -13030,6 +13246,7 @@ class SqliteOntologyMaterializationStorage {
         sourceId: replacement.sourceId,
         candidateMaterializationId: replacement.candidateMaterializationId,
         previousMaterializationId: replacement.previousMaterializationId,
+        incremental: replacement.incremental,
         kind: "object",
         pageRows: input.pageRows
       })) {
@@ -13048,10 +13265,10 @@ class SqliteOntologyMaterializationStorage {
       return;
     }
     if (replacement.projectionKind === "object" && !replacement.objectStreamCompleted) {
-      throw new MaterializationConflictError5("effective-state", "Object projection replacement must fully stream object state before link state.");
+      throw new MaterializationConflictError6("effective-state", "Object projection replacement must fully stream object state before link state.");
     }
     if (replacement.linkStreamStarted) {
-      throw new MaterializationConflictError5("effective-state", "Replacement link state may only be streamed once per session.");
+      throw new MaterializationConflictError6("effective-state", "Replacement link state may only be streamed once per session.");
     }
     replacement.linkStreamStarted = true;
     const materializationIds = [
@@ -13063,6 +13280,7 @@ class SqliteOntologyMaterializationStorage {
       sourceId: replacement.sourceId,
       candidateMaterializationId: replacement.candidateMaterializationId,
       previousMaterializationId: replacement.previousMaterializationId,
+      incremental: replacement.incremental,
       kind: "link",
       pageRows: input.pageRows
     })) {
@@ -13073,7 +13291,7 @@ class SqliteOntologyMaterializationStorage {
         }
         return identity;
       });
-      const links = reader.replacementLinkStates(replacement.sourceId, replacement.candidateMaterializationId, materializationIds, linkIdentities);
+      const links = reader.replacementLinkStates(replacement.sourceId, replacement.candidateMaterializationId, materializationIds, linkIdentities, replacement.incremental);
       yield { objects: [], links };
     }
     this.sessions.require(input.session);
@@ -13125,14 +13343,14 @@ class SqliteOntologyMaterializationStorage {
   requireReplacement(session, input) {
     if (session.replacement) {
       if (session.replacement.sourceId !== input.source.projectionId || session.replacement.candidateMaterializationId !== input.candidateMaterializationId) {
-        throw new MaterializationConflictError5("source-materialization", "Materialization session already owns another replacement union.");
+        throw new MaterializationConflictError6("source-materialization", "Materialization session already owns another replacement union.");
       }
       return session.replacement;
     }
     const projectId = session.header.commit.projectId;
     const candidate = this.getSource(projectId, input.source.projectionId, input.candidateMaterializationId);
     if (!candidate || candidate.status !== "ready" || candidate.execution_token === null) {
-      throw new MaterializationConflictError5("source-materialization", `Candidate source materialization '${input.candidateMaterializationId}' is missing or is not ready.`);
+      throw new MaterializationConflictError6("source-materialization", `Candidate source materialization '${input.candidateMaterializationId}' is missing or is not ready.`);
     }
     assertProjectionExecution(this.db, {
       projectId,
@@ -13142,12 +13360,13 @@ class SqliteOntologyMaterializationStorage {
     });
     const previous = this.getActiveSource(projectId, input.source.projectionId);
     if (candidate.protocol !== "replacement" || previous && (previous.protocol !== candidate.protocol || previous.projection_kind !== candidate.projection_kind)) {
-      throw new MaterializationConflictError5("source-materialization", "Source replacement kind or protocol does not match its active materialization.");
+      throw new MaterializationConflictError6("source-materialization", "Source replacement kind or protocol does not match its active materialization.");
     }
     session.replacement = {
       sourceId: input.source.projectionId,
       candidateMaterializationId: input.candidateMaterializationId,
       previousMaterializationId: previous?.materialization_id ?? null,
+      incremental: candidate.base_materialization_id !== null,
       projectionKind: candidate.projection_kind,
       objectStreamStarted: false,
       objectStreamCompleted: false,
@@ -13176,38 +13395,38 @@ class SqliteOntologyMaterializationStorage {
     if (!duplicate)
       return;
     if (duplicate.duplicate === "origin") {
-      throw new MaterializationConflictError5("run-correlation", "Ontology commit origin already has an authoritative commit.");
+      throw new MaterializationConflictError6("run-correlation", "Ontology commit origin already has an authoritative commit.");
     }
-    throw new MaterializationConflictError5("idempotency", duplicate.duplicate === "id" ? `Ontology commit '${header.commit.id}' already exists.` : "Ontology idempotency key already exists.");
+    throw new MaterializationConflictError6("idempotency", duplicate.duplicate === "id" ? `Ontology commit '${header.commit.id}' already exists.` : "Ontology idempotency key already exists.");
   }
   assertSource(expected, projectId) {
     const active = this.getActiveSource(projectId, expected.source.projectionId);
     if ((active?.materialization_id ?? null) !== expected.activeMaterializationId || (active?.last_commit_id ?? null) !== expected.lastCommitId) {
-      throw new MaterializationConflictError5("projection-fence", `Source '${expected.source.projectionId}' changed.`);
+      throw new MaterializationConflictError6("projection-fence", `Source '${expected.source.projectionId}' changed.`);
     }
   }
   assertObject(reader, expected) {
     const row = reader.effectiveObjectRevision(expected.ref);
     if (!expected.exists) {
       if (row) {
-        throw new MaterializationConflictError5("effective-state", `Expected object ${objectRefKey3(expected.ref)} to be absent.`);
+        throw new MaterializationConflictError6("effective-state", `Expected object ${objectRefKey3(expected.ref)} to be absent.`);
       }
       return;
     }
     if (!row || row.version !== expected.version || row.lastCommitId !== expected.lastCommitId) {
-      throw new MaterializationConflictError5("effective-state", `Expected object ${objectRefKey3(expected.ref)} changed.`);
+      throw new MaterializationConflictError6("effective-state", `Expected object ${objectRefKey3(expected.ref)} changed.`);
     }
   }
   assertLink(reader, expected) {
     const lastCommitId = reader.effectiveLinkLastCommit(expected.ref);
     if (!expected.exists) {
       if (lastCommitId !== undefined) {
-        throw new MaterializationConflictError5("effective-state", `Expected link ${linkRefKey3(expected.ref)} to be absent.`);
+        throw new MaterializationConflictError6("effective-state", `Expected link ${linkRefKey3(expected.ref)} to be absent.`);
       }
       return;
     }
     if (lastCommitId === undefined || lastCommitId !== expected.lastCommitId) {
-      throw new MaterializationConflictError5("effective-state", `Expected link ${linkRefKey3(expected.ref)} changed.`);
+      throw new MaterializationConflictError6("effective-state", `Expected link ${linkRefKey3(expected.ref)} changed.`);
     }
   }
   async assertFinalization(session, input) {
@@ -13301,7 +13520,7 @@ class SqliteOntologyMaterializationStorage {
     assertSourceActivationCorrelation(session, activation);
     const candidate = this.getSource(commit.projectId, activation.source.projectionId, activation.materializationId);
     if (!candidate || candidate.status !== "ready" || candidate.execution_token === null) {
-      throw new MaterializationConflictError5("source-materialization", "Source activation candidate is missing or is not ready.");
+      throw new MaterializationConflictError6("source-materialization", "Source activation candidate is missing or is not ready.");
     }
     assertProjectionExecution(this.db, {
       projectId: commit.projectId,
@@ -13313,6 +13532,7 @@ class SqliteOntologyMaterializationStorage {
       invalidCorrelation2("Source activation does not match its ready candidate identity.");
     }
     this.assertSource(activation.expected, commit.projectId);
+    activateSourceRoots(this.db, commit.projectId, candidate, activation);
     const previous = this.getActiveSource(commit.projectId, activation.source.projectionId);
     if (previous) {
       assertPinnedDatasetWatermark({
@@ -13352,7 +13572,7 @@ class SqliteOntologyMaterializationStorage {
           `).run(commit.projectId, commit.id, commit.idempotencyKey, commit.requestHash, commit.executionId, origin.kind, origin.runId, origin.batchOrdinal, canonicalJson(commit.origin), commit.actor === undefined ? null : canonicalJson(commit.actor), commit.ontologyRevision, commit.projectionRevision ?? null, commit.ownershipHash ?? null, canonicalJson(commit.intent), canonicalJson(input.finalization.result), commit.committedAt);
     } catch (error) {
       if (isSqliteConstraintError(error)) {
-        throw new MaterializationConflictError5("idempotency", "Ontology commit identity already exists.");
+        throw new MaterializationConflictError6("idempotency", "Ontology commit identity already exists.");
       }
       throw error;
     }
@@ -13372,8 +13592,8 @@ class SqliteOntologyMaterializationStorage {
 // src/ontology-storage/outbox.ts
 import { serializeSixbFailure as serializeSixbFailure2 } from "@sixb/core/internal/errors";
 import {
-  MaterializationConflictError as MaterializationConflictError6,
-  MaterializationValidationError
+  MaterializationConflictError as MaterializationConflictError7,
+  MaterializationValidationError as MaterializationValidationError2
 } from "@sixb/core/internal/materialization";
 import { ONTOLOGY_OUTBOX_FAILURE_CODES as ONTOLOGY_OUTBOX_FAILURE_CODES2 } from "@sixb/core/storage";
 class SqliteOntologyOutboxStorage {
@@ -13391,7 +13611,7 @@ class SqliteOntologyOutboxStorage {
       const leaseExpiry = assertTimestamp(input.leaseExpiresAt, "Ontology outbox lease expiry");
       assertNonblank(input.leaseId, "Ontology outbox lease id");
       if (leaseExpiry <= now) {
-        throw new MaterializationValidationError("Ontology outbox lease expiry must be later than the claim time.");
+        throw new MaterializationValidationError2("Ontology outbox lease expiry must be later than the claim time.");
       }
       const rows = this.db.query(`
             UPDATE ontology_outbox
@@ -13409,7 +13629,7 @@ class SqliteOntologyOutboxStorage {
           `).all(input.leaseId, input.leaseExpiresAt, input.projectId, input.now, input.now, input.limit);
       return rows.map((row) => outboxRecord(row)).sort((left, right) => left.createdAt.localeCompare(right.createdAt) || left.envelope.id.localeCompare(right.envelope.id)).map((record) => {
         if (record.leaseId === null || record.leaseExpiresAt === null) {
-          throw new MaterializationConflictError6("outbox-lease", "Ontology outbox claim returned an unpaired lease.");
+          throw new MaterializationConflictError7("outbox-lease", "Ontology outbox claim returned an unpaired lease.");
         }
         return { ...record, leaseId: record.leaseId, leaseExpiresAt: record.leaseExpiresAt };
       });
@@ -13508,7 +13728,7 @@ function validateLeaseIds(ids) {
   for (const id of ids) {
     assertNonblank(id, "Ontology outbox event id");
     if (seen.has(id)) {
-      throw new MaterializationValidationError(`Ontology outbox lease batch repeats event '${id}'.`);
+      throw new MaterializationValidationError2(`Ontology outbox lease batch repeats event '${id}'.`);
     }
     seen.add(id);
   }
@@ -13519,11 +13739,11 @@ function assertLeaseInput(input) {
   assertNonblank(input.leaseId, "Ontology outbox lease id");
 }
 function leaseConflict() {
-  return new MaterializationConflictError6("outbox-lease", "Ontology outbox lease does not match.");
+  return new MaterializationConflictError7("outbox-lease", "Ontology outbox lease does not match.");
 }
 
 // src/ontology-storage/sources.ts
-import { MaterializationValidationError as MaterializationValidationError2 } from "@sixb/core/internal/materialization";
+import { MaterializationValidationError as MaterializationValidationError3 } from "@sixb/core/internal/materialization";
 import {
   assertSourceBeginInput as assertBeginInput,
   assertSourceExecutionIdentity as assertExecutionIdentity,
@@ -13537,8 +13757,53 @@ import {
   sourceMaterializationIdentity,
   sourceStageRow,
   sourceStageRows,
-  utf8SortKey
+  utf8SortKey as utf8SortKey2
 } from "@sixb/core/internal/ontology-storage-provider";
+
+// src/ontology-storage/source-cleanup.ts
+function cleanupSourceVersions(db, input) {
+  let remaining = input.limit;
+  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
+    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 ?
+    )`).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 < ?
+      AND NOT EXISTS (SELECT 1 FROM ontology_source_roots AS roots
+        WHERE roots.project_id = sources.project_id AND roots.source_id = sources.source_id
+          AND roots.materialization_id = sources.materialization_id)
+      AND NOT EXISTS (SELECT 1 FROM ontology_source_rows AS rows
+        WHERE rows.project_id = sources.project_id AND rows.source_id = sources.source_id
+          AND rows.materialization_id = sources.materialization_id)
+    ORDER BY terminal_at, source_id, materialization_id LIMIT ?
+  )`).run(input.projectId, input.terminalBefore, remaining).changes;
+  return { rowsDeleted, materializationsDeleted };
+}
+
+// src/ontology-storage/sources.ts
 class SqliteOntologySourceStorage {
   db;
   runRootOperation;
@@ -13573,10 +13838,10 @@ class SqliteOntologySourceStorage {
               dataset_id, dataset_version_id, dataset_version_created_at,
               projection_revision, ownership_hash, ontology_revision,
               root_count, assertion_count, created_at, ready_at, activated_at,
-              terminal_at, last_commit_id, updated_at
+              terminal_at, last_commit_id, updated_at, base_materialization_id, base_commit_id
             ) VALUES (?, ?, ?, ?, ?, 'replacement', 'staging', ?, ?, ?, ?, ?, ?, ?,
-              NULL, NULL, ?, NULL, NULL, NULL, NULL, ?)
-          `).run(input.projectId, input.source.projectionId, input.materializationId, input.execution.projectionRunId, input.projectionKind, input.execution.executionToken, input.datasetVersion.datasetId, input.datasetVersion.versionId, input.datasetVersion.createdAt, input.projectionRevision, input.ownershipHash, input.ontologyRevision, input.createdAt, input.createdAt);
+              NULL, NULL, ?, NULL, NULL, NULL, NULL, ?, ?, ?)
+          `).run(input.projectId, input.source.projectionId, input.materializationId, input.execution.projectionRunId, input.projectionKind, input.execution.executionToken, input.datasetVersion.datasetId, input.datasetVersion.versionId, input.datasetVersion.createdAt, input.projectionRevision, input.ownershipHash, input.ontologyRevision, input.createdAt, input.createdAt, input.base?.materializationId ?? null, input.base?.lastCommitId ?? null);
       return sourceRecord(this.requireManifest(input.projectId, input.source.projectionId, input.materializationId));
     });
   }
@@ -13592,6 +13857,7 @@ class SqliteOntologySourceStorage {
       const rows = sourceStageRows(manifest.projection_kind, input.rows);
       const existing = this.findStageRows(input, rows);
       const { pending, unchanged } = reconcileSourceStageRows(rows, existing);
+      stageSourceRoots(this.db, manifest, input);
       this.insertStageRows(input, pending);
       return { inserted: pending.length, unchanged };
     });
@@ -13617,7 +13883,7 @@ class SqliteOntologySourceStorage {
         throw sourceConflict(`Source materialization '${input.materializationId}' cannot transition from '${manifest.status}' to 'ready'.`);
       }
       if (input.readyAt < manifest.created_at) {
-        throw new MaterializationValidationError2("Source readyAt cannot precede source createdAt.");
+        throw new MaterializationValidationError3("Source readyAt cannot precede source createdAt.");
       }
       this.assertReadyState(manifest, input.rootCount, input.assertionCount);
       const result = this.db.query(`
@@ -13656,55 +13922,7 @@ class SqliteOntologySourceStorage {
       assertNonblank(input.projectId, "Terminal source cleanup project id");
       assertTimestamp(input.terminalBefore, "Terminal source cleanup cutoff", true);
       assertPositiveInteger(input.limit, "Terminal source cleanup limit");
-      const manifests = this.db.query(`
-            SELECT * FROM ontology_sources
-            WHERE project_id = ? AND status IN ('superseded', 'abandoned')
-              AND terminal_at < ?
-            ORDER BY terminal_at, source_id, materialization_id
-            LIMIT ?
-          `).all(input.projectId, input.terminalBefore, input.limit);
-      let remaining = input.limit;
-      let rowsDeleted = 0;
-      let materializationsDeleted = 0;
-      for (const manifest of manifests) {
-        if (remaining === 0)
-          break;
-        const deleted = this.db.query(`
-              DELETE FROM ontology_source_rows
-              WHERE rowid IN (
-                SELECT rows.rowid
-                FROM ontology_source_rows AS rows
-                JOIN ontology_sources AS sources
-                  ON sources.project_id = rows.project_id
-                 AND sources.source_id = rows.source_id
-                 AND sources.materialization_id = rows.materialization_id
-                WHERE rows.project_id = ? AND rows.source_id = ? AND rows.materialization_id = ?
-                  AND sources.status IN ('superseded', 'abandoned')
-                  AND sources.terminal_at = ? AND sources.terminal_at < ?
-                ORDER BY rows.entity_sort_key
-                LIMIT ?
-              )
-            `).run(manifest.project_id, manifest.source_id, manifest.materialization_id, manifest.terminal_at, input.terminalBefore, remaining).changes;
-        rowsDeleted += deleted;
-        remaining -= deleted;
-        if (remaining === 0)
-          break;
-        const removed = this.db.query(`
-              DELETE FROM ontology_sources
-              WHERE project_id = ? AND source_id = ? AND materialization_id = ?
-                AND status IN ('superseded', 'abandoned')
-                AND terminal_at = ? AND terminal_at < ?
-                AND NOT EXISTS (
-                  SELECT 1 FROM ontology_source_rows AS rows
-                  WHERE rows.project_id = ontology_sources.project_id
-                    AND rows.source_id = ontology_sources.source_id
-                    AND rows.materialization_id = ontology_sources.materialization_id
-                )
-            `).run(manifest.project_id, manifest.source_id, manifest.materialization_id, manifest.terminal_at, input.terminalBefore).changes;
-        materializationsDeleted += removed;
-        remaining -= removed;
-      }
-      return { rowsDeleted, materializationsDeleted };
+      return cleanupSourceVersions(this.db, input);
     });
   }
   async summarizeTerminal(input) {
@@ -13748,7 +13966,7 @@ class SqliteOntologySourceStorage {
   }
   transitionToAbandoned(manifest, abandonedAt) {
     if (abandonedAt < manifest.created_at || manifest.ready_at !== null && abandonedAt < manifest.ready_at) {
-      throw new MaterializationValidationError2("Source abandonedAt cannot precede source creation or readiness.");
+      throw new MaterializationValidationError3("Source abandonedAt cannot precede source creation or readiness.");
     }
     const changed = this.db.query(`
           UPDATE ontology_sources
@@ -13759,19 +13977,23 @@ 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 COUNT(*) AS assertions, COUNT(DISTINCT root_key) AS roots,
+          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,
             MIN(staging_ordinal) AS min_ordinal, MAX(staging_ordinal) AS max_ordinal
-          FROM ontology_source_rows
+          FROM ontology_source_roots
           WHERE project_id = ? AND source_id = ? AND materialization_id = ?
-        `).get(manifest.project_id, manifest.source_id, manifest.materialization_id);
+        `).get(manifest.project_id, manifest.source_id, manifest.materialization_id, manifest.project_id, manifest.source_id, manifest.materialization_id);
     if (counts.assertions !== assertionCount || counts.roots !== rootCount || counts.ordinals !== rootCount || rootCount > 0 && (counts.min_ordinal !== 0 || counts.max_ordinal !== rootCount - 1)) {
-      throw new MaterializationValidationError2("Source ready counts do not match the staged roots and assertions.");
+      throw new MaterializationValidationError3("Source ready counts do not match the staged roots and assertions.");
     }
+    assertSourceRootCoverage(this.db, manifest);
     const invalid = this.db.query(manifest.projection_kind === "link" ? `
               SELECT root_key
               FROM ontology_source_rows
@@ -13797,15 +14019,15 @@ class SqliteOntologySourceStorage {
               LIMIT 1
             `).get(manifest.project_id, manifest.source_id, manifest.materialization_id);
     if (invalid) {
-      throw new MaterializationValidationError2(manifest.projection_kind === "link" ? "Link projection roots must contain exactly their matching link assertion." : "Object projection roots must contain exactly their matching object assertion plus links sourced from that root.");
+      throw new MaterializationValidationError3(manifest.projection_kind === "link" ? "Link projection roots must contain exactly their matching link assertion." : "Object projection roots must contain exactly their matching object assertion plus links sourced from that root.");
     }
   }
   findStageRows(input, rows) {
     if (rows.length === 0)
       return [];
-    const rootSortKeys = [...new Set(rows.map((row) => utf8SortKey(row.rootKey)))];
+    const rootSortKeys = [...new Set(rows.map((row) => utf8SortKey2(row.rootKey)))];
     const ordinals = [...new Set(rows.map((row) => row.row.stagingOrdinal))];
-    const entitySortKeys = [...new Set(rows.map((row) => utf8SortKey(row.entityKey)))];
+    const entitySortKeys = [...new Set(rows.map((row) => utf8SortKey2(row.entityKey)))];
     const existing = this.db.query(`
           SELECT * FROM ontology_source_rows
           WHERE project_id = ? AND source_id = ? AND materialization_id = ?
@@ -13826,10 +14048,10 @@ class SqliteOntologySourceStorage {
       return {
         entityKind: row.assertion.kind,
         entityKey,
-        entitySortKey: utf8SortKey(entityKey),
+        entitySortKey: utf8SortKey2(entityKey),
         rootKind: row.root.kind,
         rootKey,
-        rootSortKey: utf8SortKey(rootKey),
+        rootSortKey: utf8SortKey2(rootKey),
         stagingOrdinal: row.stagingOrdinal,
         root: row.root,
         assertion: row.assertion,
@@ -14341,7 +14563,7 @@ class SqliteProjectionRunStorage {
                 input_exhausted = ?, missing_target_object_type_id = NULL,
                 missing_target_object_id = NULL, missing_target_batch_ordinal = NULL,
                 missing_target_first_seen_at = NULL, source_rows_read = 0,
-                source_rows_skipped = 0, error = NULL
+                source_rows_skipped = 0, source_changes_read = NULL, error = NULL
               WHERE project_id = ? AND id = ? AND status = 'failed'
                 AND json_extract(error, '$.code') = 'queue.enqueue_failed'
             `).run(queuedAt.toISOString(), input.fixedBatchSize === undefined ? null : 0, input.fixedBatchSize === undefined ? null : 0, input.fixedBatchSize === undefined ? null : 0, input.projectId, input.id);
@@ -14436,10 +14658,11 @@ class SqliteProjectionRunStorage {
             execution_token = NULL,
             source_rows_read = ?,
             source_rows_skipped = ?,
+            source_changes_read = ?,
             input_exhausted = ?,
             error = ?
           WHERE project_id = ? AND id = ? AND status = 'running' AND execution_token = ?
-        `).run(input.status, plan.finishedAt.toISOString(), plan.progress.sourceRowsRead, plan.progress.sourceRowsSkipped, plan.inputExhausted ? 1 : existingRow.input_exhausted, plan.error === undefined ? null : serializeSixbFailure4(plan.error, PROJECTION_RUN_FAILURE_CODES), input.projectId, input.id, input.executionToken);
+        `).run(input.status, plan.finishedAt.toISOString(), plan.progress.sourceRowsRead, plan.progress.sourceRowsSkipped, plan.progress.sourceChangesRead ?? null, plan.inputExhausted ? 1 : existingRow.input_exhausted, plan.error === undefined ? null : serializeSixbFailure4(plan.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));
@@ -14605,6 +14828,7 @@ class SqliteProjectionRunStorage {
     const args = [
       progress.sourceRowsRead,
       progress.sourceRowsSkipped,
+      progress.sourceChangesRead ?? null,
       existing.project_id,
       existing.id,
       executionToken
@@ -14613,7 +14837,8 @@ class SqliteProjectionRunStorage {
         UPDATE projection_runs
         SET
           source_rows_read = ?,
-          source_rows_skipped = ?
+          source_rows_skipped = ?,
+          source_changes_read = ?
         WHERE project_id = ? AND id = ? AND status = 'running'
           AND execution_token = ?
       `).run(...args);
@@ -14683,7 +14908,8 @@ function restoreProjectionRunRow(row) {
     missingTargetFirstSeenAt: row.missing_target_first_seen_at ? new Date(row.missing_target_first_seen_at) : undefined,
     progress: {
       sourceRowsRead: databaseSafeInteger(row.source_rows_read, "sourceRowsRead"),
-      sourceRowsSkipped: databaseSafeInteger(row.source_rows_skipped, "sourceRowsSkipped")
+      sourceRowsSkipped: databaseSafeInteger(row.source_rows_skipped, "sourceRowsSkipped"),
+      ...row.source_changes_read == null ? {} : { sourceChangesRead: databaseSafeInteger(row.source_changes_read, "sourceChangesRead") }
     },
     error: row.error ?? undefined
   };
@@ -16758,4 +16984,4 @@ export {
   migrateSqliteStorage
 };
 
-//# debugId=8848EEC97F2007FB64756E2164756E21
+//# debugId=B98ED3E1F74F05CB64756E2164756E21