@sixb/core 0.1.16 → 0.1.18

package/dist/{chunk-h4138ww2.js → chunk-p0dqwj3n.js}

@@ -15,8 +15,12 @@ import {
   linkScopeSortKey2,
   telemetryPointSortKey2,
   compareObjectRefs2,
-  compareLinkRefs2
-} from "./chunk-7ytf06d3.js";
+  compareLinkRefs2,
+  materializationEventKindOrdinal2,
+  sha256Canonical2,
+  createRequestHash2,
+  createCommitId2
+} from "./chunk-b9affek3.js";
 import {
   withFailureMessage
 } from "./chunk-z3y5kg1x.js";
@@ -31,37 +35,32 @@ import {
   normalizeLinkProperties2,
   validateLinkProperties2,
   validateTelemetryUnit2
-} from "./chunk-swxzncrv.js";
-import {
-  materializationEventKindOrdinal2,
-  sha256Canonical2,
-  createRequestHash2,
-  createCommitId2,
-  createEventId2,
-  materializationApplyPhase
-} from "./chunk-g4rbm4a6.js";
+} from "./chunk-y05543x6.js";
 import {
   ProjectionValidationError2,
   validateProjectionsAtStartup,
   isProjectionDefinition2,
   resolveExecutionScopeAuthorization
-} from "./chunk-69kt9q43.js";
+} from "./chunk-qkbx3tf6.js";
 import {
   objectBatchKey2,
   vectorConfiguration,
   vectorSources,
   normalizeVector2
-} from "./chunk-6z1q7j19.js";
+} from "./chunk-qq90g05n.js";
+import {
+  materializationApplyPhase2
+} from "./chunk-wt4szfec.js";
 import {
   parseDatasetTimestamp2
 } from "./chunk-z667z3sg.js";
 import {
   executionRecordInputFromRuntime,
   ensureExecutionRecord2
-} from "./chunk-7g2gjvah.js";
+} from "./chunk-ex496vct.js";
 import {
   isStorageSerializationFailure2
-} from "./chunk-zdkcdshk.js";
+} from "./chunk-y9jmd7e5.js";
 import {
   assertPinnedDatasetWatermark2
 } from "./chunk-6aawea28.js";
@@ -508,7 +507,8 @@ var DEFAULT_MATERIALIZATION_BATCHING = Object.freeze({
   sourceStageBytes: 4 * 1024 * 1024,
   statePageRows: 1000,
   planChunkRows: 1000,
-  planChunkBytes: 4 * 1024 * 1024
+  planChunkBytes: 4 * 1024 * 1024,
+  transactionReplanRows: 1000
 });
 function resolveMaterializationBatching(overrides = {}) {
   const resolved = { ...DEFAULT_MATERIALIZATION_BATCHING, ...overrides };
@@ -666,29 +666,9 @@ function prepareMaterializerExecution(projectId, scope) {
       runtimeAuthorization: scope.authorization
     }),
     executionId: scope.execution.id,
-    correlationId: scope.execution.correlationId,
-    attribution: executionAttribution(scope)
+    correlationId: scope.execution.correlationId
   };
 }
-function executionAttribution(scope) {
-  const { requestedBy, executor } = scope.execution;
-  const attributed = { executor: eventExecutor(executor) };
-  if (requestedBy === undefined)
-    return attributed;
-  return { ...attributed, requestedBy: { type: requestedBy.type, id: requestedBy.id } };
-}
-function eventExecutor(executor) {
-  switch (executor.type) {
-    case "request":
-      return { type: "request", requestId: executor.requestId };
-    case "primitive":
-      return { type: "primitive", kind: executor.kind, id: executor.id, runId: executor.runId };
-    case "agent":
-      return { type: "agent", runId: executor.runId };
-    case "kernel":
-      return { type: "kernel", operation: structuredClone(executor.operation) };
-  }
-}
 function ensureMaterializerExecution(executions, execution) {
   return ensureExecutionRecord2(executions, execution.record);
 }
@@ -710,138 +690,6 @@ function assertMaterializerRunExecution(execution, runExecutionId, label) {
   throw new MaterializationConflictError2("run-correlation", `${label} belongs to execution '${runExecutionId}', not '${execution.executionId}'.`);
 }
 
-// src/materializer/effective/build-events.ts
-function buildObjectMaterializationEventDraft(input) {
-  const draft = buildObjectEventDraft(input, input.change);
-  return orderedDraft(objectRefSortKey2(input.change.ref), draft);
-}
-function buildObjectEventDraft(context, change) {
-  const base = eventDraftBase(context);
-  const partitionKey = `${change.ref.objectTypeId}:${change.ref.primaryId}`;
-  if (change.kind === "deleted") {
-    return {
-      ...base,
-      type: "object.deleted",
-      topic: "objects",
-      partitionKey,
-      payload: {
-        objectTypeId: change.ref.objectTypeId,
-        primaryId: change.ref.primaryId,
-        propertyChanges: change.propertyChanges
-      }
-    };
-  }
-  const type = objectEventType(change);
-  return {
-    ...base,
-    type,
-    topic: "objects",
-    partitionKey,
-    payload: {
-      objectTypeId: change.ref.objectTypeId,
-      primaryId: change.ref.primaryId,
-      properties: change.after.properties,
-      propertyChanges: change.propertyChanges
-    }
-  };
-}
-function objectEventType(change) {
-  if (change.kind === "created")
-    return "object.created";
-  return "object.updated";
-}
-function buildLinkMaterializationEventDraft(input) {
-  const draft = buildLinkEventDraft(input, input.change);
-  return orderedDraft(linkRefSortKey2(input.change.ref), draft);
-}
-function buildLinkEventDraft(context, change) {
-  const base = eventDraftBase(context);
-  const partitionKey = `${change.ref.source.objectTypeId}:${change.ref.source.primaryId}:${change.ref.linkId}`;
-  const commonPayload = {
-    sourceTypeId: change.ref.source.objectTypeId,
-    sourceId: change.ref.source.primaryId,
-    linkId: change.ref.linkId,
-    targetTypeId: change.ref.target.objectTypeId,
-    targetId: change.ref.target.primaryId,
-    propertyChanges: change.propertyChanges
-  };
-  if (change.kind === "deleted") {
-    return {
-      ...base,
-      type: "link.deleted",
-      topic: "links",
-      partitionKey,
-      payload: commonPayload
-    };
-  }
-  const type = linkEventType(change);
-  if (change.after.properties === undefined) {
-    return { ...base, type, topic: "links", partitionKey, payload: commonPayload };
-  }
-  return {
-    ...base,
-    type,
-    topic: "links",
-    partitionKey,
-    payload: { ...commonPayload, properties: change.after.properties }
-  };
-}
-function linkEventType(change) {
-  if (change.kind === "created")
-    return "link.created";
-  return "link.updated";
-}
-function buildTelemetryMaterializationEventDraft(input) {
-  const draft = buildTelemetryEventDraft(input, input.point);
-  return orderedDraft(telemetryPointSortKey2(input.point.series, input.point.at), draft);
-}
-function buildTelemetryEventDraft(context, point) {
-  const base = eventDraftBase(context);
-  const partitionKey = `${point.series.object.objectTypeId}:${point.series.object.primaryId}:${point.series.propertyId}`;
-  const payload = {
-    objectTypeId: point.series.object.objectTypeId,
-    objectId: point.series.object.primaryId,
-    propertyId: point.series.propertyId,
-    value: point.value,
-    at: point.at
-  };
-  if (point.unit === undefined) {
-    return { ...base, type: "telemetry.appended", topic: "telemetry", partitionKey, payload };
-  }
-  return {
-    ...base,
-    type: "telemetry.appended",
-    topic: "telemetry",
-    partitionKey,
-    payload: { ...payload, unit: point.unit }
-  };
-}
-function eventDraftBase(context) {
-  return {
-    schemaVersion: 1,
-    projectId: context.projectId,
-    occurredAt: context.committedAt,
-    correlationId: context.correlationId,
-    origin: context.origin,
-    ...context.attribution,
-    commitId: context.commitId
-  };
-}
-function orderedDraft(sortKey, draft) {
-  return {
-    kindRank: materializationEventKindOrdinal2(draft.type),
-    sortKey,
-    draft
-  };
-}
-function sequenceMaterializationEvent(projectId, commitId, commitOrdinal, draft) {
-  const sequence = {
-    id: createEventId2(projectId, commitId, commitOrdinal),
-    commitOrdinal
-  };
-  return { ...draft, ...sequence };
-}
-
 // src/materializer/effective/vector-indexing.ts
 import { randomUUID as randomUUID2 } from "crypto";
 async function scheduleVectorChanges(context, storage, items, session, projection = false) {
@@ -966,237 +814,7 @@ async function* chunkBySize(items, input) {
     yield chunk;
 }
 
-// src/materializer/execution/plan-stream.ts
-async function* planStream(items, batching) {
-  for await (const itemsChunk of chunkBySize(items, {
-    maxRows: batching.planChunkRows,
-    maxBytes: batching.planChunkBytes,
-    byteLength: utf8JsonByteLength
-  })) {
-    const chunk = mutableChunk();
-    for (const item of itemsChunk)
-      appendItem(chunk, item);
-    yield chunk;
-  }
-}
-function mutableChunk() {
-  return {
-    overrides: {
-      objects: { upserts: [], deletes: [] },
-      links: {
-        edges: { upserts: [], deletes: [] },
-        slots: { upserts: [], deletes: [] }
-      }
-    },
-    effective: { objectUpserts: [], objectDeletes: [], linkUpserts: [], linkDeletes: [] },
-    timeseries: { pointUpserts: [] },
-    outbox: []
-  };
-}
-function appendItem(chunk, item) {
-  switch (item.kind) {
-    case "object-override-upsert":
-      chunk.overrides.objects.upserts.push(item.value);
-      break;
-    case "object-override-delete":
-      chunk.overrides.objects.deletes.push(item.value);
-      break;
-    case "link-override-upsert":
-      chunk.overrides.links.edges.upserts.push(item.value);
-      break;
-    case "link-override-delete":
-      chunk.overrides.links.edges.deletes.push(item.value);
-      break;
-    case "link-slot-override-upsert":
-      chunk.overrides.links.slots.upserts.push(item.value);
-      break;
-    case "link-slot-override-delete":
-      chunk.overrides.links.slots.deletes.push(item.value);
-      break;
-    case "object-upsert":
-      chunk.effective.objectUpserts.push(item.value);
-      break;
-    case "object-delete":
-      chunk.effective.objectDeletes.push(item.value);
-      break;
-    case "link-upsert":
-      chunk.effective.linkUpserts.push(item.value);
-      break;
-    case "link-delete":
-      chunk.effective.linkDeletes.push(item.value);
-      break;
-    case "point-upsert":
-      chunk.timeseries.pointUpserts.push(item.value);
-      break;
-    case "outbox":
-      chunk.outbox.push(item.value);
-      break;
-  }
-}
-
-// src/materializer/execution/work-records.ts
-function appendObjectOverrideWork(items, working, identity) {
-  if (stableJsonStringify2(working.originalOverride?.value ?? null) === stableJsonStringify2(working.override) && stableJsonStringify2(working.originalEditedAt) === stableJsonStringify2(working.editedAt)) {
-    return;
-  }
-  if (working.override) {
-    items.push({
-      kind: "object-override-upsert",
-      value: {
-        ref: working.ref,
-        value: working.override,
-        editedAt: working.editedAt,
-        expectedLastCommitId: working.originalOverride?.lastCommitId ?? null,
-        lastCommitId: identity.commitId,
-        updatedAt: identity.committedAt
-      }
-    });
-  } else if (working.originalOverride) {
-    items.push({
-      kind: "object-override-delete",
-      value: { ref: working.ref, expectedLastCommitId: working.originalOverride.lastCommitId }
-    });
-  }
-}
-function appendLinkEdgeOverrideWork(items, working, identity) {
-  if (stableJsonStringify2(working.originalOverride?.value ?? null) === stableJsonStringify2(working.override)) {
-    return;
-  }
-  if (working.override) {
-    items.push({
-      kind: "link-override-upsert",
-      value: {
-        ref: working.ref,
-        value: working.override,
-        expectedLastCommitId: working.originalOverride?.lastCommitId ?? null,
-        lastCommitId: identity.commitId,
-        updatedAt: identity.committedAt
-      }
-    });
-  } else if (working.originalOverride) {
-    items.push({
-      kind: "link-override-delete",
-      value: { ref: working.ref, expectedLastCommitId: working.originalOverride.lastCommitId }
-    });
-  }
-}
-function appendLinkSlotOverrideWork(items, working, identity) {
-  if (stableJsonStringify2(working.originalOverride?.value ?? null) === stableJsonStringify2(working.override)) {
-    return;
-  }
-  if (working.override) {
-    items.push({
-      kind: "link-slot-override-upsert",
-      value: {
-        ref: working.ref,
-        value: working.override,
-        expectedLastCommitId: working.originalOverride?.lastCommitId ?? null,
-        lastCommitId: identity.commitId,
-        updatedAt: identity.committedAt
-      }
-    });
-  } else if (working.originalOverride) {
-    items.push({
-      kind: "link-slot-override-delete",
-      value: {
-        ref: working.ref,
-        expectedLastCommitId: working.originalOverride.lastCommitId
-      }
-    });
-  }
-}
-function appendEffectiveObjectWork(items, change) {
-  if (change.kind === "deleted") {
-    items.push({
-      kind: "object-delete",
-      value: {
-        ref: change.ref,
-        expected: expectedObject(change.before)
-      }
-    });
-  } else {
-    items.push({
-      kind: "object-upsert",
-      value: {
-        row: change.after,
-        expected: change.before ? expectedObject(change.before) : { ref: change.ref, exists: false }
-      }
-    });
-  }
-}
-function appendEffectiveLinkWork(items, change) {
-  if (change.kind === "deleted") {
-    items.push({
-      kind: "link-delete",
-      value: {
-        ref: change.ref,
-        expected: expectedLink(change.before)
-      }
-    });
-  } else {
-    items.push({
-      kind: "link-upsert",
-      value: {
-        row: change.after,
-        expected: change.before ? expectedLink(change.before) : { ref: change.ref, exists: false }
-      }
-    });
-  }
-}
-function outboxItem(event, committedAt) {
-  const value = {
-    envelope: event,
-    availableAt: committedAt,
-    createdAt: committedAt
-  };
-  return { kind: "outbox", value };
-}
-function classificationWork(entityKind, identityKey, sortKey) {
-  return {
-    kind: "classification",
-    recordKey: `classification:${entityKind}:${sortKey}`,
-    entityKind,
-    identityKey
-  };
-}
-function planWork(item, sortKey) {
-  const applyPhase = materializationApplyPhase(item.kind);
-  return {
-    kind: "plan",
-    recordKey: `plan:${item.kind}:${sortKey}`,
-    applyPhase,
-    sortKey,
-    item
-  };
-}
-function eventWork(value) {
-  return {
-    kind: "event",
-    recordKey: `event:${value.kindRank}:${value.sortKey}`,
-    eventKindRank: value.kindRank,
-    sortKey: value.sortKey,
-    draft: value.draft
-  };
-}
-function expectedObject(snapshot) {
-  return {
-    ref: snapshot.ref,
-    exists: true,
-    version: snapshot.version,
-    lastCommitId: snapshot.lastCommitId
-  };
-}
-function expectedLink(snapshot) {
-  return { ref: snapshot.ref, exists: true, lastCommitId: snapshot.lastCommitId };
-}
-
 // src/materializer/execution/work-executor.ts
-async function applyItems(context, storage, session, items, signal) {
-  for await (const chunk of planStream(items, context.batching)) {
-    throwIfAborted(signal);
-    await storage.applyChunk({ session, chunk });
-  }
-}
 async function stageWorkBounded(context, storage, session, records) {
   for await (const chunk of chunkBySize(records, {
     maxRows: context.batching.planChunkRows,
@@ -1206,84 +824,23 @@ async function stageWorkBounded(context, storage, session, records) {
     await storage.stageWork({ session, records: chunk });
   }
 }
-async function drainStagedWork(context, transactionStorage, session, signal, projection = false) {
+async function applyStagedWork(context, transactionStorage, session, signal, projection = false) {
   const ontologyStorage = transactionStorage.ontology;
   const storage = ontologyStorage.materializations;
-  let phase = null;
-  let pending = [];
-  const flush = async () => {
-    if (pending.length === 0)
-      return;
-    await scheduleVectorChanges(context, transactionStorage, pending, session, projection);
-    await invalidateVectorChanges(context.projectId, ontologyStorage.vectors, pending, session);
-    await applyItems(context, storage, session, pending, signal);
-    pending = [];
-  };
-  for await (const page of storage.streamWork({
-    session,
-    order: "apply",
-    pageRows: context.batching.planChunkRows
-  })) {
-    for (const record of page.records) {
-      if (record.kind !== "plan") {
-        throw new MaterializationValidationError2("Provider returned non-plan apply work.");
-      }
-      if (phase !== null && record.applyPhase !== phase)
-        await flush();
-      phase = record.applyPhase;
-      pending.push(record.item);
-      if (pending.length >= context.batching.planChunkRows)
-        await flush();
-    }
-  }
-  await flush();
-}
-async function validateStagedCardinality(context, storage, session, signal) {
-  let currentView = null;
-  let currentScope = null;
-  let occupant = null;
-  for await (const page of storage.streamWork({
-    session,
-    order: "cardinality",
-    pageRows: context.batching.statePageRows
-  })) {
-    throwIfAborted(signal);
-    for (const record of page.records) {
-      if (record.kind !== "cardinality") {
-        throw new MaterializationValidationError2("Provider returned non-cardinality cardinality work.");
-      }
-      if (record.view !== currentView || record.scopeSortKey !== currentScope) {
-        currentView = record.view;
-        currentScope = record.scopeSortKey;
-        occupant = null;
-      }
-      if (!record.occupied)
-        continue;
-      if (occupant && occupant !== record.linkSortKey) {
-        throw new MaterializationValidationError2(record.view === "candidate" ? `Projection source scope '${record.ref.source.objectTypeId}.${record.ref.linkId}' has cardinality one.` : `Link scope '${record.ref.source.objectTypeId}.${record.ref.linkId}' has cardinality one.`);
-      }
-      occupant = record.linkSortKey;
-    }
-  }
-}
-async function drainStagedEvents(context, storage, session, identity, signal) {
-  let ordinal = 0;
-  for await (const page of storage.streamWork({
-    session,
-    order: "event",
-    pageRows: context.batching.planChunkRows
-  })) {
-    const items = [];
-    for (const record of page.records) {
-      if (record.kind !== "event") {
-        throw new MaterializationValidationError2("Provider returned non-event event work.");
-      }
-      const event = sequenceMaterializationEvent(context.projectId, identity.commitId, ordinal++, record.draft);
-      items.push(outboxItem(event, identity.committedAt));
+  if (ontologyStorage.vectorIndexing || ontologyStorage.vectors) {
+    for await (const page of storage.streamVectorChanges({
+      session,
+      objectTypeIds: context.ontology.listObjectTypes().filter((type) => Object.keys(type.search?.vectors ?? {}).length > 0).map((type) => type.id),
+      pageRows: context.batching.planChunkRows
+    })) {
+      throwIfAborted(signal);
+      await scheduleVectorChanges(context, transactionStorage, page.items, session, projection);
+      await invalidateVectorChanges(context.projectId, ontologyStorage.vectors, page.items, session);
     }
-    await applyItems(context, storage, session, items, signal);
   }
-  return ordinal;
+  throwIfAborted(signal);
+  const { eventCount } = await storage.apply({ session });
+  return eventCount;
 }
 
 // src/materializer/shared/normalize.ts
@@ -2731,112 +2288,336 @@ function applyLinkSlotOperation(context, state, operation, normalizedProperties,
       if (current && linkRefKey2(current.ref) !== linkRefKey2(operation.ref)) {
         throw new MaterializationValidationError2(`Link scope '${operation.ref.source.objectTypeId}.${operation.ref.linkId}' has cardinality one.`);
       }
-      next = {
-        kind: "set",
-        target: operation.ref.target,
-        ...normalizedProperties !== undefined ? { properties: normalizedProperties } : {}
-      };
-      break;
-    case "link.delete":
-      if (current && linkRefKey2(current.ref) === linkRefKey2(operation.ref)) {
-        next = { kind: "clear", target: operation.ref.target };
+      next = {
+        kind: "set",
+        target: operation.ref.target,
+        ...normalizedProperties !== undefined ? { properties: normalizedProperties } : {}
+      };
+      break;
+    case "link.delete":
+      if (current && linkRefKey2(current.ref) === linkRefKey2(operation.ref)) {
+        next = { kind: "clear", target: operation.ref.target };
+      }
+      break;
+    case "link.reset":
+      if (previous && objectRefKey2(previous.target) === objectRefKey2(operation.ref.target)) {
+        next = null;
+      }
+      break;
+  }
+  const changed = stableJsonStringify2(previous) !== stableJsonStringify2(next);
+  working.override = next;
+  journal?.push({
+    restore: () => {
+      working.override = previous;
+    }
+  });
+  return { id: operation.id, ok: true, authority: authorityOutcome(changed) };
+}
+function requireWorkingLinkEdge(state, operation) {
+  const working = state.links.edges.get(linkRefKey2(operation.ref));
+  if (!working)
+    throw new MaterializationValidationError2("Link state was not loaded.");
+  return working;
+}
+function validateLinkEndpoints(context, state, operation) {
+  if (operation.kind !== "link.upsert")
+    return;
+  const source = state.objects.get(objectRefKey2(operation.ref.source));
+  const target = state.objects.get(objectRefKey2(operation.ref.target));
+  const sourceExists = source && resolveObject(context.ontology, source);
+  const targetExists = target && resolveObject(context.ontology, target);
+  if (sourceExists && targetExists)
+    return;
+  throw new MaterializationValidationError2("Link upsert requires both endpoints to be effective.");
+}
+function validateLinkOperation(context, operation) {
+  if (operation.kind !== "link.upsert")
+    return;
+  return validateLinkAuthorityProperties(context.ontology, operation.ref, operation.properties);
+}
+function applyLinkEdgeTransition(working, next, journal) {
+  const previous = working.override;
+  working.override = next;
+  journal?.push({
+    restore: () => {
+      working.override = previous;
+    }
+  });
+}
+function authorityOutcome(changed) {
+  if (changed)
+    return "changed";
+  return "unchanged";
+}
+function isObjectOperation2(operation) {
+  switch (operation.kind) {
+    case "object.create":
+    case "object.upsert":
+    case "object.patch":
+    case "object.delete":
+    case "object.restore":
+      return true;
+    case "link.upsert":
+    case "link.delete":
+    case "link.reset":
+      return false;
+  }
+}
+
+// src/materializer/effective/build-events.ts
+function buildObjectMaterializationEventDraft(change) {
+  return orderedDraft(objectRefSortKey2(change.ref), buildObjectEventDraft(change));
+}
+function buildObjectEventDraft(change) {
+  const identity = { objectTypeId: change.ref.objectTypeId, primaryId: change.ref.primaryId };
+  switch (change.kind) {
+    case "created":
+      return {
+        type: "object.created",
+        payload: { ...identity, properties: change.after.properties }
+      };
+    case "updated":
+      return {
+        type: "object.updated",
+        payload: {
+          ...identity,
+          properties: change.after.properties,
+          propertyChanges: change.propertyChanges
+        }
+      };
+    case "deleted":
+      return {
+        type: "object.deleted",
+        payload: { ...identity, propertyChanges: change.propertyChanges }
+      };
+  }
+}
+function buildLinkMaterializationEventDraft(change) {
+  return orderedDraft(linkRefSortKey2(change.ref), buildLinkEventDraft(change));
+}
+function buildLinkEventDraft(change) {
+  const identity = {
+    sourceTypeId: change.ref.source.objectTypeId,
+    sourceId: change.ref.source.primaryId,
+    linkId: change.ref.linkId,
+    targetTypeId: change.ref.target.objectTypeId,
+    targetId: change.ref.target.primaryId
+  };
+  if (change.kind === "deleted") {
+    return {
+      type: "link.deleted",
+      payload: { ...identity, propertyChanges: change.propertyChanges }
+    };
+  }
+  const properties = change.after.properties === undefined ? {} : { properties: change.after.properties };
+  if (change.kind === "created") {
+    return { type: "link.created", payload: { ...identity, ...properties } };
+  }
+  return {
+    type: "link.updated",
+    payload: { ...identity, ...properties, propertyChanges: change.propertyChanges }
+  };
+}
+function buildTelemetryMaterializationEventDraft(point) {
+  const payload = {
+    objectTypeId: point.series.object.objectTypeId,
+    objectId: point.series.object.primaryId,
+    propertyId: point.series.propertyId,
+    value: point.value,
+    at: point.at,
+    ...point.unit === undefined ? {} : { unit: point.unit }
+  };
+  return orderedDraft(telemetryPointSortKey2(point.series, point.at), {
+    type: "telemetry.appended",
+    payload
+  });
+}
+function orderedDraft(sortKey, draft) {
+  return {
+    kindRank: materializationEventKindOrdinal2(draft.type),
+    sortKey,
+    draft
+  };
+}
+
+// src/materializer/execution/work-records.ts
+function appendObjectOverrideWork(items, working, identity) {
+  if (stableJsonStringify2(working.originalOverride?.value ?? null) === stableJsonStringify2(working.override) && stableJsonStringify2(working.originalEditedAt) === stableJsonStringify2(working.editedAt)) {
+    return;
+  }
+  if (working.override) {
+    items.push({
+      kind: "object-override-upsert",
+      value: {
+        ref: working.ref,
+        value: working.override,
+        editedAt: working.editedAt,
+        expectedLastCommitId: working.originalOverride?.lastCommitId ?? null,
+        lastCommitId: identity.commitId,
+        updatedAt: identity.committedAt
+      }
+    });
+  } else if (working.originalOverride) {
+    items.push({
+      kind: "object-override-delete",
+      value: { ref: working.ref, expectedLastCommitId: working.originalOverride.lastCommitId }
+    });
+  }
+}
+function appendLinkEdgeOverrideWork(items, working, identity) {
+  if (stableJsonStringify2(working.originalOverride?.value ?? null) === stableJsonStringify2(working.override)) {
+    return;
+  }
+  if (working.override) {
+    items.push({
+      kind: "link-override-upsert",
+      value: {
+        ref: working.ref,
+        value: working.override,
+        expectedLastCommitId: working.originalOverride?.lastCommitId ?? null,
+        lastCommitId: identity.commitId,
+        updatedAt: identity.committedAt
+      }
+    });
+  } else if (working.originalOverride) {
+    items.push({
+      kind: "link-override-delete",
+      value: { ref: working.ref, expectedLastCommitId: working.originalOverride.lastCommitId }
+    });
+  }
+}
+function appendLinkSlotOverrideWork(items, working, identity) {
+  if (stableJsonStringify2(working.originalOverride?.value ?? null) === stableJsonStringify2(working.override)) {
+    return;
+  }
+  if (working.override) {
+    items.push({
+      kind: "link-slot-override-upsert",
+      value: {
+        ref: working.ref,
+        value: working.override,
+        expectedLastCommitId: working.originalOverride?.lastCommitId ?? null,
+        lastCommitId: identity.commitId,
+        updatedAt: identity.committedAt
+      }
+    });
+  } else if (working.originalOverride) {
+    items.push({
+      kind: "link-slot-override-delete",
+      value: {
+        ref: working.ref,
+        expectedLastCommitId: working.originalOverride.lastCommitId
       }
-      break;
-    case "link.reset":
-      if (previous && objectRefKey2(previous.target) === objectRefKey2(operation.ref.target)) {
-        next = null;
+    });
+  }
+}
+function appendEffectiveObjectWork(items, change) {
+  if (change.kind === "deleted") {
+    items.push({
+      kind: "object-delete",
+      value: {
+        ref: change.ref,
+        expected: expectedObject(change.before)
       }
-      break;
+    });
+  } else {
+    items.push({
+      kind: "object-upsert",
+      value: {
+        row: change.after,
+        expected: change.before ? expectedObject(change.before) : { ref: change.ref, exists: false }
+      }
+    });
   }
-  const changed = stableJsonStringify2(previous) !== stableJsonStringify2(next);
-  working.override = next;
-  journal?.push({
-    restore: () => {
-      working.override = previous;
-    }
-  });
-  return { id: operation.id, ok: true, authority: authorityOutcome(changed) };
 }
-function requireWorkingLinkEdge(state, operation) {
-  const working = state.links.edges.get(linkRefKey2(operation.ref));
-  if (!working)
-    throw new MaterializationValidationError2("Link state was not loaded.");
-  return working;
+function appendEffectiveLinkWork(items, change) {
+  if (change.kind === "deleted") {
+    items.push({
+      kind: "link-delete",
+      value: {
+        ref: change.ref,
+        expected: expectedLink(change.before)
+      }
+    });
+  } else {
+    items.push({
+      kind: "link-upsert",
+      value: {
+        row: change.after,
+        expected: change.before ? expectedLink(change.before) : { ref: change.ref, exists: false }
+      }
+    });
+  }
 }
-function validateLinkEndpoints(context, state, operation) {
-  if (operation.kind !== "link.upsert")
-    return;
-  const source = state.objects.get(objectRefKey2(operation.ref.source));
-  const target = state.objects.get(objectRefKey2(operation.ref.target));
-  const sourceExists = source && resolveObject(context.ontology, source);
-  const targetExists = target && resolveObject(context.ontology, target);
-  if (sourceExists && targetExists)
-    return;
-  throw new MaterializationValidationError2("Link upsert requires both endpoints to be effective.");
+function classificationWork(entityKind, identityKey, sortKey) {
+  return {
+    kind: "classification",
+    recordKey: `classification:${entityKind}:${sortKey}`,
+    entityKind,
+    identityKey
+  };
 }
-function validateLinkOperation(context, operation) {
-  if (operation.kind !== "link.upsert")
-    return;
-  return validateLinkAuthorityProperties(context.ontology, operation.ref, operation.properties);
+function planWork(item, sortKey) {
+  const applyPhase = materializationApplyPhase2(item.kind);
+  return {
+    kind: "plan",
+    recordKey: `plan:${item.kind}:${sortKey}`,
+    applyPhase,
+    sortKey,
+    item
+  };
 }
-function applyLinkEdgeTransition(working, next, journal) {
-  const previous = working.override;
-  working.override = next;
-  journal?.push({
-    restore: () => {
-      working.override = previous;
-    }
-  });
+function eventWork(value) {
+  return {
+    kind: "event",
+    recordKey: `event:${value.kindRank}:${value.sortKey}`,
+    eventKindRank: value.kindRank,
+    sortKey: value.sortKey,
+    draft: value.draft
+  };
 }
-function authorityOutcome(changed) {
-  if (changed)
-    return "changed";
-  return "unchanged";
+function expectedObject(snapshot) {
+  return {
+    ref: snapshot.ref,
+    exists: true,
+    version: snapshot.version,
+    lastCommitId: snapshot.lastCommitId
+  };
 }
-function isObjectOperation2(operation) {
-  switch (operation.kind) {
-    case "object.create":
-    case "object.upsert":
-    case "object.patch":
-    case "object.delete":
-    case "object.restore":
-      return true;
-    case "link.upsert":
-    case "link.delete":
-    case "link.reset":
-      return false;
-  }
+function expectedLink(snapshot) {
+  return { ref: snapshot.ref, exists: true, lastCommitId: snapshot.lastCommitId };
 }
 
 // src/materializer/edits/plan.ts
-async function stageEditPlan(context, storage, session, state, planContext) {
+async function stageEditPlan(context, storage, session, state, identity) {
   validateWorkingCardinality(state.links.slots);
   const objectChanges = [];
   for (const working of sortedObjects(state.objects)) {
-    const change = await stageObject(context, storage, session, working, planContext);
+    const change = await stageObject(context, storage, session, working, identity);
     if (change)
       objectChanges.push(change);
   }
   const linkChanges = [];
   for (const working of sortedLinkEdges(state.links.edges)) {
-    const change = await stageLinkEdge(context, storage, session, state.objects, working, planContext);
+    const change = await stageLinkEdge(context, storage, session, state.objects, working, identity);
     if (change)
       linkChanges.push(change);
   }
   for (const working of sortedLinkSlots(state.links.slots)) {
-    linkChanges.push(...await stageLinkSlot(context, storage, session, state.objects, working, planContext));
+    linkChanges.push(...await stageLinkSlot(context, storage, session, state.objects, working, identity));
   }
   return { objects: objectChanges, links: linkChanges };
 }
-async function stageLinkSlot(context, storage, session, objects, working, planContext) {
+async function stageLinkSlot(context, storage, session, objects, working, identity) {
   const overrideItems = [];
-  appendLinkSlotOverrideWork(overrideItems, working, planContext.identity);
+  appendLinkSlotOverrideWork(overrideItems, working, identity);
   const resolved = resolveLinkSlot(context.ontology, working, objects);
   const changes = diffEffectiveLinkSlot({
     before: working.before,
     resolved,
-    commitId: planContext.identity.commitId,
-    committedAt: planContext.identity.committedAt
+    commitId: identity.commitId,
+    committedAt: identity.committedAt
   });
   const representative = resolved?.ref ?? working.before?.ref ?? (working.override ? {
     source: working.ref.source,
@@ -2853,22 +2634,22 @@ async function stageLinkSlot(context, storage, session, objects, working, planCo
     appendEffectiveLinkWork(effectiveItems, change);
     const sortKey = linkRefSortKey2(change.ref);
     work.push(...effectiveItems.map((item) => planWork(item, sortKey)));
-    work.push(eventWork(buildLinkEvent(context, planContext, change)));
+    work.push(eventWork(buildLinkMaterializationEventDraft(change)));
   }
   await stageWorkBounded(context, storage, session, work);
   return changes;
 }
-async function stageObject(context, storage, session, working, planContext) {
+async function stageObject(context, storage, session, working, identity) {
   const items = [];
-  appendObjectOverrideWork(items, working, planContext.identity);
+  appendObjectOverrideWork(items, working, identity);
   const resolved = resolveObject(context.ontology, working);
   if (resolved)
     validateEffectiveObject(context.ontology, resolved.ref, resolved.properties);
   const change = diffEffectiveObject({
     before: working.before,
     resolved,
-    commitId: planContext.identity.commitId,
-    committedAt: planContext.identity.committedAt
+    commitId: identity.commitId,
+    committedAt: identity.committedAt
   });
   if (change)
     appendEffectiveObjectWork(items, change);
@@ -2878,20 +2659,20 @@ async function stageObject(context, storage, session, working, planContext) {
     ...items.map((item) => planWork(item, sortKey))
   ];
   if (change) {
-    work.push(eventWork(buildObjectEvent(context, planContext, change)));
+    work.push(eventWork(buildObjectMaterializationEventDraft(change)));
   }
   await stageWorkBounded(context, storage, session, work);
   return change;
 }
-async function stageLinkEdge(context, storage, session, objects, working, planContext) {
+async function stageLinkEdge(context, storage, session, objects, working, identity) {
   const items = [];
-  appendLinkEdgeOverrideWork(items, working, planContext.identity);
+  appendLinkEdgeOverrideWork(items, working, identity);
   const resolved = resolveLinkEdge(context.ontology, working, objects);
   const change = diffEffectiveLink({
     before: working.before,
     resolved,
-    commitId: planContext.identity.commitId,
-    committedAt: planContext.identity.committedAt
+    commitId: identity.commitId,
+    committedAt: identity.committedAt
   });
   if (change)
     appendEffectiveLinkWork(items, change);
@@ -2901,29 +2682,11 @@ async function stageLinkEdge(context, storage, session, objects, working, planCo
     ...items.map((item) => planWork(item, sortKey))
   ];
   if (change) {
-    work.push(eventWork(buildLinkEvent(context, planContext, change)));
+    work.push(eventWork(buildLinkMaterializationEventDraft(change)));
   }
   await stageWorkBounded(context, storage, session, work);
   return change;
 }
-function buildObjectEvent(context, planContext, change) {
-  const eventContext = materializationEventContext(context, planContext);
-  return buildObjectMaterializationEventDraft({ ...eventContext, change });
-}
-function buildLinkEvent(context, planContext, change) {
-  const eventContext = materializationEventContext(context, planContext);
-  return buildLinkMaterializationEventDraft({ ...eventContext, change });
-}
-function materializationEventContext(context, planContext) {
-  return {
-    projectId: context.projectId,
-    commitId: planContext.identity.commitId,
-    committedAt: planContext.identity.committedAt,
-    origin: planContext.origin,
-    correlationId: planContext.correlationId,
-    attribution: planContext.attribution
-  };
-}
 function sortedObjects(objects) {
   return [...objects.values()].sort((left, right) => compareObjectRefs2(left.ref, right.ref));
 }
@@ -3123,10 +2886,9 @@ async function executeEditTransaction(context, storage, command) {
   const session = await beginEditMaterialization(context, storage, command);
   const workingState = await loadEditWorkingState(context, storage.ontology.materializations, session, command.input.operations);
   const outcomes = applyEditOperations(context, workingState, command);
-  const changes = await stageEditPlan(context, storage.ontology.materializations, session, workingState, editPlanContext(command));
-  await drainStagedWork(context, storage, session);
+  const changes = await stageEditPlan(context, storage.ontology.materializations, session, workingState, command.identity);
+  const eventCount = await applyStagedWork(context, storage, session);
   await commitVectorWrites(context, storage, command.input, command.identity.commitId, session);
-  const eventCount = await drainStagedEvents(context, storage.ontology.materializations, session, command.identity);
   const result = {
     kind: "edit",
     commitId: command.identity.commitId,
@@ -3157,7 +2919,6 @@ function buildEditCommit(context, command) {
     requestHash: command.identity.requestHash,
     executionId: command.execution.executionId,
     origin: command.origin,
-    ...command.execution.attribution,
     ontologyRevision: context.projectionRegistry.ontologyRevision,
     intent: {
       kind: "edit",
@@ -3234,14 +2995,6 @@ function isRecoverableEditValidation(input, error) {
     return false;
   return error instanceof MaterializationValidationError2;
 }
-function editPlanContext(command) {
-  return {
-    identity: command.identity,
-    origin: command.origin,
-    correlationId: command.execution.correlationId,
-    attribution: command.execution.attribution
-  };
-}
 async function finalizeEditMaterialization(storage, session, result) {
   const applied = await storage.ontology.materializations.finalize({
     session,
@@ -3570,44 +3323,52 @@ function projectionLinkTargetType(resolved, assertion) {
 }
 
 // src/materializer/projections/replacement-plan.ts
-async function planProjectionReplacement(context, storage, session, input) {
-  const counts = emptyCounts();
+async function planProjectionReplacement(context, plans, plan, input) {
+  const staged = { ...plan, commit: input.commit };
   if (input.projectionKind === "object") {
-    await planObjectReplacement(context, storage, session, input, counts);
+    for await (const page of plans.streamState({
+      ...plan,
+      entityKind: "object",
+      pageRows: context.batching.statePageRows
+    })) {
+      throwIfAborted(input.signal);
+      await stagePlanned(context, plans, staged, page.objects.map((state) => ({
+        identity: { kind: "object", ref: state.ref },
+        records: planReplacementObject(context, input, state)
+      })));
+    }
   }
-  await planLinkReplacement(context, storage, session, input, counts);
-  await validateStagedCardinality(context, storage, session, input.signal);
-  return counts;
-}
-async function planObjectReplacement(context, storage, session, input, counts) {
-  for await (const page of storage.streamSourceReplacementState({
-    session,
-    source: input.source,
-    candidateMaterializationId: input.materializationId,
-    entityKind: "object",
+  for await (const page of plans.streamState({
+    ...plan,
+    entityKind: "link",
     pageRows: context.batching.statePageRows
   })) {
     throwIfAborted(input.signal);
-    const work = planObjectPage(context, input, page, counts);
-    await stageWorkBounded(context, storage, session, work);
+    const endpoints = new Map(page.endpoints.map((endpoint) => [objectRefKey2(endpoint.ref), endpoint.exists]));
+    await stagePlanned(context, plans, staged, page.links.map((state) => ({
+      identity: { kind: "link", ref: state.ref },
+      records: planReplacementLink(context, input, state, endpoints)
+    })));
   }
 }
-function planObjectPage(context, input, page, counts) {
-  const work = [];
-  for (const state of page.objects) {
-    work.push(...planReplacementObject(context, input, state, counts));
+async function stagePlanned(context, plans, plan, planned) {
+  for await (const chunk of chunkBySize(planned, {
+    maxRows: context.batching.planChunkRows,
+    maxBytes: context.batching.planChunkBytes,
+    byteLength: (value) => utf8JsonByteLength(value.records)
+  })) {
+    await plans.stage({ ...plan, planned: chunk });
   }
-  return work;
 }
-function planReplacementObject(context, input, state, counts) {
+function planReplacementObject(context, input, state) {
   const resolved = resolveReplacementObject(context, state);
   if (resolved)
     validateEffectiveObject(context.ontology, resolved.ref, resolved.properties);
   const change = diffEffectiveObject({
     before: state.effective,
     resolved,
-    commitId: input.identity.commitId,
-    committedAt: input.identity.committedAt
+    commitId: input.commit.id,
+    committedAt: input.commit.committedAt
   });
   const sortKey = objectRefSortKey2(state.ref);
   const work = [
@@ -3622,88 +3383,19 @@ function planReplacementObject(context, input, state, counts) {
   if (Boolean(state.effective) !== Boolean(resolved)) {
     work.push({ kind: "incident-object", recordKey: `incident:${sortKey}`, ref: state.ref });
   }
-  if (!change) {
-    counts.objectsUnchanged += 1;
+  if (!change)
     return work;
-  }
-  incrementObjectCount(counts, change.kind);
-  appendObjectChangeWork(work, sortKey, context, input, change);
+  appendObjectChangeWork(work, sortKey, change);
   return work;
 }
-function appendObjectChangeWork(work, sortKey, context, input, change) {
+function appendObjectChangeWork(work, sortKey, change) {
   const items = [];
   appendEffectiveObjectWork(items, change);
   for (const item of items)
     work.push(planWork(item, sortKey));
-  work.push(eventWork(buildObjectMaterializationEventDraft({
-    projectId: context.projectId,
-    commitId: input.identity.commitId,
-    committedAt: input.identity.committedAt,
-    origin: input.origin,
-    correlationId: input.correlationId,
-    attribution: input.attribution,
-    change
-  })));
-}
-async function planLinkReplacement(context, storage, session, input, counts) {
-  for await (const page of storage.streamSourceReplacementState({
-    session,
-    source: input.source,
-    candidateMaterializationId: input.materializationId,
-    entityKind: "link",
-    pageRows: context.batching.statePageRows
-  })) {
-    throwIfAborted(input.signal);
-    const endpointExistence = await loadEndpointExistence(context, storage, session, page);
-    const work = planLinkPage(context, input, page, endpointExistence, counts);
-    await stageWorkBounded(context, storage, session, work);
-  }
-}
-async function loadEndpointExistence(context, storage, session, page) {
-  const endpointRefs = collectEndpointRefs(page.links);
-  const endpointExistence = new Map;
-  for (const value of await storage.readObjectExistence({
-    session,
-    refs: [...endpointRefs.values()]
-  })) {
-    endpointExistence.set(objectRefKey2(value.ref), value.exists);
-  }
-  const missingEndpoints = [...endpointRefs.values()].filter((ref) => !endpointExistence.has(objectRefKey2(ref)));
-  if (missingEndpoints.length === 0)
-    return endpointExistence;
-  for await (const endpointPage of storage.streamState({
-    session,
-    requests: oneStateRequest({
-      objects: missingEndpoints,
-      links: [],
-      linkScopes: [],
-      incidentObjects: [],
-      points: []
-    }),
-    pageRows: context.batching.statePageRows
-  })) {
-    for (const endpoint of endpointPage.objects) {
-      endpointExistence.set(objectRefKey2(endpoint.ref), endpoint.effective !== null);
-    }
-  }
-  return endpointExistence;
-}
-function collectEndpointRefs(links) {
-  const refs = new Map;
-  for (const state of links) {
-    refs.set(objectRefKey2(state.ref.source), state.ref.source);
-    refs.set(objectRefKey2(state.ref.target), state.ref.target);
-  }
-  return refs;
-}
-function planLinkPage(context, input, page, endpointExistence, counts) {
-  const work = [];
-  for (const state of page.links) {
-    work.push(...planReplacementLink(context, input, state, endpointExistence, counts));
-  }
-  return work;
+  work.push(eventWork(buildObjectMaterializationEventDraft(change)));
 }
-function planReplacementLink(context, input, state, endpointExistence, counts) {
+function planReplacementLink(context, input, state, endpointExistence) {
   const resolved = resolveReplacementLink(context, state, endpointExistence);
   const work = cardinalityWork(context, state, resolved !== null);
   if (!state.diffRequired)
@@ -3711,17 +3403,14 @@ function planReplacementLink(context, input, state, endpointExistence, counts) {
   const change = diffEffectiveLink({
     before: state.effective,
     resolved,
-    commitId: input.identity.commitId,
-    committedAt: input.identity.committedAt
+    commitId: input.commit.id,
+    committedAt: input.commit.committedAt
   });
   const sortKey = linkRefSortKey2(state.ref);
   work.push(classificationWork("link", linkRefKey2(state.ref), sortKey));
-  if (!change) {
-    counts.linksUnchanged += 1;
+  if (!change)
     return work;
-  }
-  incrementLinkCount(counts, change.kind);
-  appendLinkChangeWork(work, sortKey, context, input, change);
+  appendLinkChangeWork(work, sortKey, change);
   return work;
 }
 function resolveReplacementLink(context, state, endpointExistence) {
@@ -3771,20 +3460,12 @@ function cardinalityWork(context, state, occupied) {
     }
   ];
 }
-function appendLinkChangeWork(work, sortKey, context, input, change) {
+function appendLinkChangeWork(work, sortKey, change) {
   const items = [];
   appendEffectiveLinkWork(items, change);
   for (const item of items)
     work.push(planWork(item, sortKey));
-  work.push(eventWork(buildLinkMaterializationEventDraft({
-    projectId: context.projectId,
-    commitId: input.identity.commitId,
-    committedAt: input.identity.committedAt,
-    origin: input.origin,
-    correlationId: input.correlationId,
-    attribution: input.attribution,
-    change
-  })));
+  work.push(eventWork(buildLinkMaterializationEventDraft(change)));
 }
 function resolveReplacementObject(context, state) {
   return resolveEffectiveObject({
@@ -3796,34 +3477,6 @@ function resolveReplacementObject(context, state) {
     latestTelemetry: state.latestTelemetry
   });
 }
-function emptyCounts() {
-  return {
-    objectsCreated: 0,
-    objectsUpdated: 0,
-    objectsDeleted: 0,
-    objectsUnchanged: 0,
-    linksCreated: 0,
-    linksUpdated: 0,
-    linksDeleted: 0,
-    linksUnchanged: 0
-  };
-}
-function incrementObjectCount(counts, kind) {
-  if (kind === "created")
-    counts.objectsCreated += 1;
-  else if (kind === "updated")
-    counts.objectsUpdated += 1;
-  else
-    counts.objectsDeleted += 1;
-}
-function incrementLinkCount(counts, kind) {
-  if (kind === "created")
-    counts.linksCreated += 1;
-  else if (kind === "updated")
-    counts.linksUpdated += 1;
-  else
-    counts.linksDeleted += 1;
-}
 
 // src/materializer/projections/source-materialization.ts
 async function stageProjectionMaterialization(context, input) {
@@ -4055,15 +3708,36 @@ async function stageCandidateEntries(context, input, signal) {
     return stageProjectionMaterialization(context, input);
   return stageProjectionMaterialization(context, { ...input, signal });
 }
+var MAX_PLAN_ROUNDS = 3;
 async function commitProjectionCandidate(context, command, ready) {
-  return withSerializationRetry(context, () => context.storage.transaction((storage) => executeProjectionTransaction(context, storage, command, ready), { isolation: "serializable" }));
+  const plans = context.storage.ontology.replacementPlans;
+  const plan = {
+    projectId: context.projectId,
+    source: command.source,
+    materializationId: ready.materializationId,
+    execution: command.execution
+  };
+  const { committedAt } = await plans.open({
+    ...plan,
+    commit: projectionCommit(context.projectId, command, ready.identity)
+  });
+  const commit = projectionCommit(context.projectId, command, { ...ready.identity, committedAt });
+  for (let round = 1;; round += 1) {
+    await planProjectionReplacement(context, plans, plan, planInput(command, commit));
+    const attempt = await withSerializationRetry(context, () => context.storage.transaction((storage) => executeProjectionTransaction(context, storage, command, ready, commit, plan), { isolation: "serializable" }));
+    if (attempt.kind === "committed")
+      return attempt.result;
+    if (round === MAX_PLAN_ROUNDS) {
+      throw new MaterializationConflictError2("effective-state", `Projection '${command.source.projectionId}' inputs kept changing while it was planned ` + `(${attempt.unplanned} changed during the last of ${MAX_PLAN_ROUNDS} rounds).`);
+    }
+  }
 }
-async function executeProjectionTransaction(context, storage, command, ready) {
+async function executeProjectionTransaction(context, storage, command, ready, commit, plan) {
   await ensureMaterializerExecution(storage.executions, command.scopeExecution);
   await assertProjectionExecution(storage, context.projectId, command);
   const replay = await replayCommitRecord(context, command.identity, command.scopeExecution.executionId, storage);
   if (replay)
-    return projectionReplayResult(replay, command);
+    return { kind: "committed", result: projectionReplayResult(replay, command) };
   if (command.base) {
     const active = await storage.ontology.sources.getActive({
       projectId: context.projectId,
@@ -4072,37 +3746,49 @@ async function executeProjectionTransaction(context, storage, command, ready) {
     validateProjectionWatermark(active, command.datasetVersion);
     assertDeltaBase(active, command);
   }
-  const origin = projectionOrigin(command);
   throwIfAborted(command.signal);
+  const status = await refreshProjectionPlan(context, storage, command, commit, plan);
+  if (!status.fresh)
+    return { kind: "stale", unplanned: status.unplanned };
   const session = await storage.ontology.materializations.begin({
-    commit: projectionCommit(context.projectId, command, ready.identity, origin),
+    commit,
     expected: {
       sources: [ready.expectedSource],
       objects: [],
       links: [],
       linkScopes: [],
       points: []
-    }
+    },
+    plan: { source: command.source, materializationId: ready.materializationId }
   });
-  const counts = await planReadyProjection(context, storage.ontology.materializations, session, command, ready, origin);
-  await drainStagedWork(context, storage, session, command.signal, true);
-  const eventCount = await drainStagedEvents(context, storage.ontology.materializations, session, ready.identity, command.signal);
+  const eventCount = await applyStagedWork(context, storage, session, command.signal, true);
   const result = {
     kind: "projection",
-    commitId: ready.identity.commitId,
+    commitId: commit.id,
     created: true,
     eventCount,
-    committedAt: ready.identity.committedAt,
-    counts
+    committedAt: commit.committedAt,
+    counts: status.counts
   };
   throwIfAborted(command.signal);
-  return finalizeProjectionMaterialization(storage, session, command, ready, result);
+  return {
+    kind: "committed",
+    result: await finalizeProjectionMaterialization(storage, session, command, ready, commit, result)
+  };
+}
+async function refreshProjectionPlan(context, storage, command, commit, plan) {
+  const plans = storage.ontology.replacementPlans;
+  const status = await plans.refresh(plan);
+  if (status.fresh || status.unplanned > context.batching.transactionReplanRows)
+    return status;
+  await planProjectionReplacement(context, plans, plan, planInput(command, commit));
+  return plans.refresh(plan);
 }
-async function finalizeProjectionMaterialization(storage, session, command, ready, result) {
+async function finalizeProjectionMaterialization(storage, session, command, ready, commit, result) {
   const applied = await storage.ontology.materializations.finalize({
     session,
     finalization: {
-      sourceActivations: [projectionActivation(command, ready)],
+      sourceActivations: [projectionActivation(command, ready, commit)],
       result
     }
   });
@@ -4117,15 +3803,14 @@ function projectionOrigin(command) {
     datasetVersionId: command.datasetVersion.versionId
   };
 }
-function projectionCommit(projectId, command, identity, origin) {
+function projectionCommit(projectId, command, identity) {
   return {
     projectId,
     id: identity.commitId,
     idempotencyKey: identity.idempotencyKey,
     requestHash: identity.requestHash,
     executionId: command.scopeExecution.executionId,
-    origin,
-    ...command.scopeExecution.attribution,
+    origin: projectionOrigin(command),
     ontologyRevision: command.runIdentity.ontologyRevision,
     projectionRevision: command.runIdentity.projectionRevision,
     ownershipHash: command.runIdentity.ownershipHash,
@@ -4133,25 +3818,11 @@ function projectionCommit(projectId, command, identity, origin) {
     committedAt: identity.committedAt
   };
 }
-async function planReadyProjection(context, storage, session, command, ready, origin) {
-  const input = {
-    source: command.source,
-    materializationId: ready.materializationId,
-    projectionKind: command.projectionKind,
-    identity: ready.identity,
-    origin,
-    correlationId: command.scopeExecution.correlationId,
-    attribution: command.scopeExecution.attribution
-  };
-  if (command.signal === undefined) {
-    return planProjectionReplacement(context, storage, session, input);
-  }
-  return planProjectionReplacement(context, storage, session, {
-    ...input,
-    signal: command.signal
-  });
+function planInput(command, commit) {
+  const input = { projectionKind: command.projectionKind, commit };
+  return command.signal === undefined ? input : { ...input, signal: command.signal };
 }
-function projectionActivation(command, ready) {
+function projectionActivation(command, ready, commit) {
   return {
     source: command.source,
     materializationId: ready.materializationId,
@@ -4163,8 +3834,8 @@ function projectionActivation(command, ready) {
     ownershipHash: command.runIdentity.ownershipHash,
     ontologyRevision: command.runIdentity.ontologyRevision,
     expected: ready.expectedSource,
-    lastCommitId: ready.identity.commitId,
-    updatedAt: ready.identity.committedAt
+    lastCommitId: commit.id,
+    updatedAt: commit.committedAt
   };
 }
 function validateProjectionWatermark(active, next) {
@@ -4182,9 +3853,9 @@ function assertDeltaBase(active, command) {
 }
 
 // src/materializer/telemetry/plan.ts
-async function planTelemetryAppend(context, storage, session, input, identity, origin, event) {
+async function planTelemetryAppend(context, storage, session, input, identity) {
   const counts = emptyTelemetryCounts();
-  const planContext = { input, identity, origin, event };
+  const planContext = { input, identity };
   const objects = await loadTelemetryObjects(context, storage, session, input.points);
   const existingPoints = await loadExistingPoints(context, storage, session, input.points);
   for (const group of telemetryObjectGroups(input.points)) {
@@ -4214,7 +3885,7 @@ async function planTelemetryObject(context, storage, session, planContext, group
   for (let start = group.start;start < group.end; start += context.batching.statePageRows) {
     const end = Math.min(group.end, start + context.batching.statePageRows);
     const points = planContext.input.points.slice(start, end);
-    const work = planTelemetryChunk(context, planContext, points, existingPoints, latest, counts);
+    const work = planTelemetryChunk(planContext, points, existingPoints, latest, counts);
     await stageWorkBounded(context, storage, session, work);
   }
   working.latestTelemetry = [...latest.values()];
@@ -4233,10 +3904,10 @@ async function loadTelemetryObjects(context, storage, session, points) {
   });
   return new Map(objectState.objects.map((object) => [objectRefKey2(object.ref), object]));
 }
-function planTelemetryChunk(context, planContext, points, existingPoints, latest, counts) {
+function planTelemetryChunk(planContext, points, existingPoints, latest, counts) {
   const work = [];
   for (const point of points) {
-    work.push(...planTelemetryPoint(context, planContext, point, existingPoints, latest, counts));
+    work.push(...planTelemetryPoint(planContext, point, existingPoints, latest, counts));
   }
   return work;
 }
@@ -4260,7 +3931,7 @@ async function loadExistingPoints(context, storage, session, points) {
   context.observeCoreBuffer?.("telemetry.existing-points", existingPoints.size);
   return existingPoints;
 }
-function planTelemetryPoint(context, planContext, point, existingPoints, latest, counts) {
+function planTelemetryPoint(planContext, point, existingPoints, latest, counts) {
   const identityKey = telemetryPointKey2(point.series, point.at);
   const sortKey = telemetryPointSortKey2(point.series, point.at);
   const existing = existingPoints.get(identityKey);
@@ -4271,7 +3942,7 @@ function planTelemetryPoint(context, planContext, point, existingPoints, latest,
   } else {
     countTelemetryPointChange(counts, existing);
     work.push(planWork(telemetryPointUpsert(point, existing, planContext.identity), sortKey));
-    work.push(eventWork(buildTelemetryEvent(context, planContext, point)));
+    work.push(eventWork(buildTelemetryMaterializationEventDraft(point)));
   }
   updateLatestPoint(latest, point, existing, unchanged, planContext.identity);
   return work;
@@ -4312,10 +3983,6 @@ function storedTelemetryPointWithUnit(point, unit) {
     return point;
   return { ...point, unit };
 }
-function buildTelemetryEvent(context, planContext, point) {
-  const eventContext = telemetryEventContext(context, planContext);
-  return buildTelemetryMaterializationEventDraft({ ...eventContext, point });
-}
 function updateLatestPoint(latest, point, existing, unchanged, identity) {
   const current = latest.get(point.series.propertyId);
   if (current && point.at < current.at)
@@ -4354,21 +4021,10 @@ async function stageTelemetryObjectPlan(context, storage, session, planContext,
     const items = [];
     appendEffectiveObjectWork(items, change);
     work.push(...items.map((item) => planWork(item, sortKey)));
-    const eventContext = telemetryEventContext(context, planContext);
-    work.push(eventWork(buildObjectMaterializationEventDraft({ ...eventContext, change })));
+    work.push(eventWork(buildObjectMaterializationEventDraft(change)));
   }
   await stageWorkBounded(context, storage, session, work);
 }
-function telemetryEventContext(context, planContext) {
-  return {
-    projectId: context.projectId,
-    commitId: planContext.identity.commitId,
-    committedAt: planContext.identity.committedAt,
-    origin: planContext.origin,
-    correlationId: planContext.event.correlationId,
-    attribution: planContext.event.attribution
-  };
-}
 function emptyTelemetryCounts() {
   return {
     pointsCreated: 0,
@@ -4564,12 +4220,8 @@ async function executeTelemetryTransaction(context, storage, command) {
   }
   const origin = telemetryOrigin(command);
   const session = await beginTelemetryMaterialization(context, storage, command, origin);
-  const counts = await planTelemetryAppend(context, storage.ontology.materializations, session, command.input, command.identity, origin, {
-    correlationId: command.execution.correlationId,
-    attribution: command.execution.attribution
-  });
-  await drainStagedWork(context, storage, session);
-  const eventCount = await drainStagedEvents(context, storage.ontology.materializations, session, command.identity);
+  const counts = await planTelemetryAppend(context, storage.ontology.materializations, session, command.input, command.identity);
+  const eventCount = await applyStagedWork(context, storage, session);
   const result = {
     kind: "telemetry",
     commitId: command.identity.commitId,
@@ -4616,7 +4268,6 @@ function telemetryCommit(projectId, command, origin) {
     requestHash: command.identity.requestHash,
     executionId: command.execution.executionId,
     origin,
-    ...command.execution.attribution,
     ontologyRevision: command.ontologyRevision,
     intent: telemetryCommitIntent(command),
     committedAt: command.identity.committedAt
@@ -4723,4 +4374,4 @@ function createOntologyMaterializer2(input) {
 }
 export { computeOntologyRevision2, computeProjectionRevision2, computeProjectionOwnershipHash2, ProjectionRegistry2, createActionIdempotencyKey2, createRuntimeIdempotencyKey2, createProjectionIdempotencyKey2, createRuntimeTelemetryIdempotencyKey2, createProjectionTelemetryIdempotencyKey2, createCommitIdentity2, timestampCommitIdentity2, createTimedCommitIdentity2, createProjectionMaterializationId2, createLinkScopeFingerprint2, normalizeJsonProperties2, normalizeOntologyEditCommit2, normalizeProjectionExecution2, normalizeProjectionSourceEntry2, normalizeTelemetryAppend2, OntologyMaterializer2, createOntologyMaterializer2 };
 
-//# debugId=F46021ED4DFD665364756E2164756E21
+//# debugId=D24ACD49CAAE262364756E2164756E21