@sixb/core 0.1.16 → 0.1.18

package/dist/{chunk-g4rbm4a6.js → chunk-wt4szfec.js}

@@ -5,19 +5,22 @@ import {
   projectionEntityKey2,
   telemetryPointKey2,
   linkRefSortKey2,
-  linkScopeSortKey2
-} from "./chunk-7ytf06d3.js";
+  linkScopeSortKey2,
+  materializationEventKindOrdinal2,
+  createEventId2,
+  materializationEvent2,
+  eventAttribution2
+} from "./chunk-b9affek3.js";
 import {
   MaterializationValidationError2,
   MaterializationConflictError2
 } from "./chunk-96yw3pwd.js";
 import {
-  assertJsonValue2,
   stableJsonStringify2
 } from "./chunk-wy0qdqfm.js";
 
 // src/storage/ontology/provider.ts
-import { createHash as createHash2, randomUUID } from "crypto";
+import { createHash, randomUUID } from "crypto";
 
 // src/storage/ontology/provider-validation.ts
 function assertNonblank2(value, label) {
@@ -46,36 +49,8 @@ function invalidCorrelation2(message) {
   throw new MaterializationValidationError2(message);
 }
 
-// src/materialization/identity.ts
-import { createHash } from "crypto";
-var ONTOLOGY_MATERIALIZATION_EVENT_KIND_ORDER2 = Object.freeze([
-  "object.created",
-  "object.updated",
-  "object.deleted",
-  "link.created",
-  "link.updated",
-  "link.deleted",
-  "telemetry.appended"
-]);
-function materializationEventKindOrdinal2(kind) {
-  return ONTOLOGY_MATERIALIZATION_EVENT_KIND_ORDER2.indexOf(kind);
-}
-function sha256Canonical2(value) {
-  assertJsonValue2(value, "Canonical hash input");
-  return createHash("sha256").update(stableJsonStringify2(value)).digest("hex");
-}
-function createRequestHash2(normalizedCallerIntent) {
-  return sha256Canonical2(normalizedCallerIntent);
-}
-function createCommitId2(projectId, idempotencyKey) {
-  return sha256Canonical2([projectId, idempotencyKey]);
-}
-function createEventId2(projectId, commitId, ordinal) {
-  return sha256Canonical2([projectId, commitId, ordinal]);
-}
-
 // src/storage/ontology/materializations.ts
-function materializationApplyPhase(kind) {
+function materializationApplyPhase2(kind) {
   switch (kind) {
     case "object-override-upsert":
     case "object-override-delete":
@@ -97,6 +72,126 @@ function materializationApplyPhase(kind) {
   }
 }
 
+// src/storage/ontology/provider-header-validation.ts
+function assertMaterializationHeader2({ commit }) {
+  assertCommitEnvelope(commit);
+  switch (commit.intent.kind) {
+    case "edit":
+      assertEditCommit(commit, commit.intent);
+      break;
+    case "projection":
+      assertProjectionCommit(commit, commit.intent);
+      break;
+    case "telemetry":
+      assertTelemetryCommit(commit, commit.intent);
+      break;
+  }
+}
+function assertCommitEnvelope(commit) {
+  assertNonblank2(commit.projectId, "Materialization project id");
+  assertNonblank2(commit.id, "Materialization commit id");
+  assertNonblank2(commit.idempotencyKey, "Materialization idempotency key");
+  assertNonblank2(commit.requestHash, "Materialization request hash");
+  assertNonblank2(commit.executionId, "Materialization execution id");
+  assertNonblank2(commit.ontologyRevision, "Materialization ontology revision");
+  assertTimestamp2(commit.committedAt, "Materialization commit time");
+}
+function assertEditCommit(commit, intent) {
+  assertNonnegativeInteger2(intent.operationCount, "Edit commit operation count");
+  switch (commit.origin.kind) {
+    case "action":
+      assertNonblank2(commit.origin.actionId, "Action origin action id");
+      assertNonblank2(commit.origin.runId, "Action origin run id");
+      return;
+    case "runtime":
+      assertNonblank2(commit.origin.requestId, "Runtime origin request id");
+      return;
+    default:
+      invalidCorrelation2("Edit commit origin does not correlate with its intent.");
+  }
+}
+function assertProjectionCommit(commit, intent) {
+  if (commit.origin.kind !== "projection") {
+    invalidCorrelation2("Projection commit origin does not correlate with its intent.");
+  }
+  assertProjectionSemanticMetadata(commit);
+  assertNonblank2(commit.origin.projectionRunId, "Projection run id");
+  assertTimestamp2(intent.datasetVersion.createdAt, "Projection dataset version createdAt");
+  if (commit.origin.projectionId !== intent.source.projectionId) {
+    invalidCorrelation2("Projection commit origin does not match its projection.");
+  }
+  if (commit.origin.datasetId !== intent.datasetVersion.datasetId || commit.origin.datasetVersionId !== intent.datasetVersion.versionId) {
+    invalidCorrelation2("Projection commit origin does not match its dataset version.");
+  }
+}
+function assertTelemetryCommit(commit, intent) {
+  if (commit.origin.kind !== "telemetry") {
+    invalidCorrelation2("Telemetry commit origin does not correlate with its intent.");
+  }
+  assertTelemetryPointCounts(intent);
+  if (intent.source.kind === "runtime") {
+    assertRuntimeTelemetryCommit(commit);
+    return;
+  }
+  assertProjectionTelemetryCommit(commit, intent.source, intent.inputPointCount);
+}
+function assertTelemetryPointCounts(intent) {
+  assertNonnegativeInteger2(intent.pointCount, "Telemetry commit point count");
+  assertNonnegativeInteger2(intent.inputPointCount, "Telemetry commit input point count");
+  if (intent.inputPointCount < intent.pointCount) {
+    invalidCorrelation2("Telemetry input point count cannot be lower than its canonical point count.");
+  }
+}
+function assertRuntimeTelemetryCommit(commit) {
+  if (commit.origin.kind !== "telemetry" || commit.origin.source.kind !== "runtime") {
+    invalidCorrelation2("Runtime telemetry origin does not correlate with its intent.");
+  }
+  if (commit.projectionRevision !== undefined || commit.ownershipHash !== undefined) {
+    invalidCorrelation2("Runtime telemetry commit contains projection-only metadata.");
+  }
+  assertNonblank2(commit.origin.source.requestId, "Runtime telemetry request id");
+}
+function assertProjectionTelemetryCommit(commit, source, inputPointCount) {
+  if (commit.origin.kind !== "telemetry" || commit.origin.source.kind !== "projection") {
+    invalidCorrelation2("Projection telemetry origin does not correlate with its intent.");
+  }
+  const origin = commit.origin.source;
+  assertProjectionSemanticMetadata(commit);
+  assertNonblank2(origin.projectionRunId, "Telemetry projection run id");
+  assertTimestamp2(source.datasetVersion.createdAt, "Telemetry dataset version createdAt");
+  assertProjectionTelemetryBatch(source, inputPointCount);
+  if (origin.projectionId !== source.projection.projectionId) {
+    invalidCorrelation2("Projection telemetry origin does not match its projection.");
+  }
+  if (origin.datasetId !== source.datasetVersion.datasetId || origin.datasetVersionId !== source.datasetVersion.versionId) {
+    invalidCorrelation2("Projection telemetry origin does not match its dataset version.");
+  }
+  if (origin.batchOrdinal !== source.batchOrdinal) {
+    invalidCorrelation2("Projection telemetry origin does not match its batch ordinal.");
+  }
+}
+function assertProjectionTelemetryBatch(source, inputPointCount) {
+  assertNonnegativeInteger2(source.batchOrdinal, "Projection telemetry batch ordinal");
+  assertPositiveInteger2(source.sourceRowCount, "Projection telemetry source row count");
+  assertNonnegativeInteger2(source.sourceRowsSkipped, "Projection telemetry skipped row count");
+  if (source.sourceRowsSkipped > source.sourceRowCount) {
+    invalidCorrelation2("Projection telemetry skipped rows exceed its source row count.");
+  }
+  if (inputPointCount < source.sourceRowCount - source.sourceRowsSkipped) {
+    invalidCorrelation2("Projection telemetry input points do not account for every non-skipped source row.");
+  }
+  if (typeof source.inputExhausted !== "boolean") {
+    invalidCorrelation2("Projection telemetry input exhaustion marker is invalid.");
+  }
+}
+function assertProjectionSemanticMetadata(commit) {
+  if (commit.projectionRevision === undefined || commit.ownershipHash === undefined) {
+    invalidCorrelation2("Projection materialization is missing semantic identity metadata.");
+  }
+  assertNonblank2(commit.projectionRevision, "Projection revision");
+  assertNonblank2(commit.ownershipHash, "Projection ownership hash");
+}
+
 // src/storage/ontology/provider-work.ts
 function assertPageRows2(value) {
   if (!Number.isSafeInteger(value) || value <= 0)
@@ -105,38 +200,220 @@ function assertPageRows2(value) {
 function materializationChunkRows2(chunk) {
   return chunk.overrides.objects.upserts.length + chunk.overrides.objects.deletes.length + chunk.overrides.links.edges.upserts.length + chunk.overrides.links.edges.deletes.length + chunk.overrides.links.slots.upserts.length + chunk.overrides.links.slots.deletes.length + chunk.effective.objectUpserts.length + chunk.effective.objectDeletes.length + chunk.effective.linkUpserts.length + chunk.effective.linkDeletes.length + chunk.timeseries.pointUpserts.length + chunk.outbox.length;
 }
-function materializationPlanItems2(chunk) {
-  return [
-    ...chunk.overrides.objects.upserts.map((value) => ({
-      kind: "object-override-upsert",
-      value
-    })),
-    ...chunk.overrides.objects.deletes.map((value) => ({
-      kind: "object-override-delete",
-      value
-    })),
-    ...chunk.overrides.links.edges.upserts.map((value) => ({
-      kind: "link-override-upsert",
-      value
-    })),
-    ...chunk.overrides.links.edges.deletes.map((value) => ({
-      kind: "link-override-delete",
-      value
-    })),
-    ...chunk.overrides.links.slots.upserts.map((value) => ({
-      kind: "link-slot-override-upsert",
-      value
-    })),
-    ...chunk.overrides.links.slots.deletes.map((value) => ({
-      kind: "link-slot-override-delete",
-      value
-    })),
-    ...chunk.effective.linkDeletes.map((value) => ({ kind: "link-delete", value })),
-    ...chunk.effective.objectDeletes.map((value) => ({ kind: "object-delete", value })),
-    ...chunk.effective.objectUpserts.map((value) => ({ kind: "object-upsert", value })),
-    ...chunk.effective.linkUpserts.map((value) => ({ kind: "link-upsert", value })),
-    ...chunk.timeseries.pointUpserts.map((value) => ({ kind: "point-upsert", value }))
-  ];
+function materializationPlanChunk2(items, outbox = []) {
+  const chunk = {
+    overrides: {
+      objects: {
+        upserts: [],
+        deletes: []
+      },
+      links: {
+        edges: {
+          upserts: [],
+          deletes: []
+        },
+        slots: {
+          upserts: [],
+          deletes: []
+        }
+      }
+    },
+    effective: {
+      objectUpserts: [],
+      objectDeletes: [],
+      linkUpserts: [],
+      linkDeletes: []
+    },
+    timeseries: { pointUpserts: [] },
+    outbox
+  };
+  for (const item of items) {
+    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;
+    }
+  }
+  return chunk;
+}
+function materializationOutboxWrite2(commit, event, commitOrdinal) {
+  return {
+    id: createEventId2(commit.projectId, commit.id, commitOrdinal),
+    commitOrdinal,
+    event,
+    createdAt: commit.committedAt
+  };
+}
+function claimedOutboxRows2(rows, contextOf) {
+  const attributions = new Map;
+  return rows.map(({ id, commitId, commitOrdinal, event, ...row }) => {
+    const context = contextOf(commitId);
+    if (!context) {
+      throw new Error(`[Sixb] Ontology outbox event '${id}' has no commit '${commitId}'.`);
+    }
+    let attribution = attributions.get(commitId);
+    if (!attribution) {
+      attribution = eventAttribution2(context.execution);
+      attributions.set(commitId, attribution);
+    }
+    return {
+      ...row,
+      envelope: materializationEvent2(event, { id, commitOrdinal }, context.commit, attribution)
+    };
+  });
+}
+function assertReplacementPlanCommit2(commit, opened) {
+  assertMaterializationHeader2({ commit, expected: NO_EXPECTATIONS });
+  if (opened && (commit.id !== opened.commitId || commit.committedAt !== opened.committedAt)) {
+    throw new MaterializationValidationError2("Replacement plan work must carry the commit its plan was opened with.");
+  }
+}
+var NO_EXPECTATIONS = { sources: [], objects: [], links: [], linkScopes: [], points: [] };
+function prepareReplacementIdentities2(input, opened) {
+  assertReplacementPlanCommit2(input.commit, opened);
+  const header = { commit: input.commit, expected: NO_EXPECTATIONS };
+  const keys = new Set;
+  return input.planned.map((planned) => {
+    const prepared = prepareReplacementIdentity(planned, header);
+    if (keys.has(prepared.entityKey)) {
+      throw new MaterializationValidationError2(`Replacement identity ${prepared.entityKey} is staged twice.`);
+    }
+    keys.add(prepared.entityKey);
+    return prepared;
+  });
+}
+function prepareReplacementIdentity(planned, header) {
+  const { identity } = planned;
+  const identityKind = identity.kind;
+  const key = identity.kind === "object" ? objectRefKey2(identity.ref) : linkRefKey2(identity.ref);
+  const keys = new Set;
+  let classified = false;
+  let change = null;
+  for (const record of planned.records) {
+    assertWorkRecord2(record, header);
+    if (keys.has(record.recordKey)) {
+      throw new MaterializationConflictError2("effective-state", `Duplicate materialization work key '${record.recordKey}'.`);
+    }
+    keys.add(record.recordKey);
+    if (record.kind === "classification") {
+      if (record.entityKind !== identityKind || record.identityKey !== key) {
+        throw new MaterializationValidationError2("A replacement identity can only classify itself.");
+      }
+      classified = true;
+    }
+    if (record.kind !== "plan")
+      continue;
+    const { item } = record;
+    if (item.kind === "object-upsert" || item.kind === "link-upsert") {
+      change = item.value.expected.exists ? "updated" : "created";
+    } else if (item.kind === "object-delete" || item.kind === "link-delete") {
+      change = "deleted";
+    }
+  }
+  return {
+    kind: identityKind,
+    key,
+    entityKey: projectionEntityKey2(identity),
+    records: planned.records,
+    classified,
+    change
+  };
+}
+function projectionChangeCounts(records) {
+  let objects = 0;
+  let links = 0;
+  const counts = {
+    objectsCreated: 0,
+    objectsUpdated: 0,
+    objectsDeleted: 0,
+    linksCreated: 0,
+    linksUpdated: 0,
+    linksDeleted: 0
+  };
+  for (const record of records) {
+    if (record.kind === "classification") {
+      if (record.entityKind === "object")
+        objects += 1;
+      if (record.entityKind === "link")
+        links += 1;
+      continue;
+    }
+    if (record.kind !== "plan")
+      continue;
+    const { item } = record;
+    if (item.kind === "object-upsert") {
+      if (item.value.expected.exists)
+        counts.objectsUpdated += 1;
+      else
+        counts.objectsCreated += 1;
+    } else if (item.kind === "object-delete")
+      counts.objectsDeleted += 1;
+    else if (item.kind === "link-upsert") {
+      if (item.value.expected.exists)
+        counts.linksUpdated += 1;
+      else
+        counts.linksCreated += 1;
+    } else if (item.kind === "link-delete")
+      counts.linksDeleted += 1;
+  }
+  return {
+    ...counts,
+    objectsUnchanged: objects - counts.objectsCreated - counts.objectsUpdated - counts.objectsDeleted,
+    linksUnchanged: links - counts.linksCreated - counts.linksUpdated - counts.linksDeleted
+  };
+}
+function createCardinalityValidator2() {
+  let view = null;
+  let scope = null;
+  let occupant = null;
+  return {
+    accept(record) {
+      if (record.view !== view || record.scopeSortKey !== scope) {
+        view = record.view;
+        scope = record.scopeSortKey;
+        occupant = null;
+      }
+      if (!record.occupied)
+        return;
+      if (occupant !== null && occupant !== record.linkSortKey) {
+        throw cardinalityViolation2(record.view, record.ref.source.objectTypeId, record.ref.linkId);
+      }
+      occupant = record.linkSortKey;
+    }
+  };
+}
+function cardinalityViolation2(view, sourceTypeId, linkId) {
+  return new MaterializationValidationError2(view === "candidate" ? `Projection source scope '${sourceTypeId}.${linkId}' has cardinality one.` : `Link scope '${sourceTypeId}.${linkId}' has cardinality one.`);
 }
 function assertWorkRecord2(record, header) {
   if (record.recordKey.trim().length === 0) {
@@ -150,7 +427,7 @@ function assertWorkRecord2(record, header) {
     return;
   }
   if (record.kind === "event") {
-    if (!/^[0-9a-f]+$/.test(record.sortKey) || !Number.isSafeInteger(record.eventKindRank) || record.eventKindRank < 0 || record.eventKindRank !== materializationEventKindOrdinal2(record.draft.type) || record.draft.projectId !== header.commit.projectId || record.draft.commitId !== header.commit.id || record.draft.occurredAt !== header.commit.committedAt || stableJsonStringify2(record.draft.origin) !== stableJsonStringify2(header.commit.origin) || !sameAttribution(record.draft, header.commit)) {
+    if (!/^[0-9a-f]+$/.test(record.sortKey) || !Number.isSafeInteger(record.eventKindRank) || record.eventKindRank < 0 || record.eventKindRank !== materializationEventKindOrdinal2(record.draft.type)) {
       throw new MaterializationValidationError2("Materialization event work is invalid.");
     }
     return;
@@ -182,9 +459,9 @@ function workUniquenessKey2(record) {
   }
 }
 function comparePlanWork2(left, right) {
-  return left.applyPhase - right.applyPhase || planKindOrder(left.item.kind) - planKindOrder(right.item.kind) || left.sortKey.localeCompare(right.sortKey) || left.recordKey.localeCompare(right.recordKey);
+  return left.applyPhase - right.applyPhase || materializationPlanKindRank2(left.item.kind) - materializationPlanKindRank2(right.item.kind) || left.sortKey.localeCompare(right.sortKey) || left.recordKey.localeCompare(right.recordKey);
 }
-function planKindOrder(kind) {
+function materializationPlanKindRank2(kind) {
   switch (kind) {
     case "object-override-upsert":
       return 0;
@@ -220,13 +497,7 @@ function compareEventWork2(left, right) {
   return left.eventKindRank - right.eventKindRank || left.sortKey.localeCompare(right.sortKey) || left.recordKey.localeCompare(right.recordKey);
 }
 function planPhaseMatches(record) {
-  return record.applyPhase === materializationApplyPhase(record.item.kind);
-}
-function assertPlanChunkCorrelations2(chunk, commit) {
-  for (const item of materializationPlanItems2(chunk))
-    assertPlanItemCorrelation(item, commit);
-  for (const value of chunk.outbox)
-    assertOutboxCorrelation(value, commit);
+  return record.applyPhase === materializationApplyPhase2(record.item.kind);
 }
 function assertPlanItemCorrelation(item, commit) {
   switch (item.kind) {
@@ -268,12 +539,6 @@ function assertPointWriteCorrelation(value, commit) {
     invalidCorrelation2("Timeseries point last commit id does not match its session commit.");
   }
 }
-function assertOutboxCorrelation(value, commit) {
-  const { envelope } = value;
-  if (envelope.projectId !== commit.projectId || envelope.commitId !== commit.id || envelope.occurredAt !== commit.committedAt || value.availableAt !== commit.committedAt || value.createdAt !== commit.committedAt || stableJsonStringify2(envelope.origin) !== stableJsonStringify2(commit.origin) || !sameAttribution(envelope, commit) || !Number.isSafeInteger(envelope.commitOrdinal) || envelope.commitOrdinal < 0 || envelope.id !== createEventId2(commit.projectId, commit.id, envelope.commitOrdinal)) {
-    invalidCorrelation2("Outbox event does not correlate with its materialization commit.");
-  }
-}
 function assertCommitWriteCorrelation(lastCommitId, updatedAt, commit, label) {
   if (lastCommitId !== commit.id || updatedAt !== commit.committedAt) {
     invalidCorrelation2(`${label} provenance does not match its session commit.`);
@@ -289,170 +554,10 @@ function assertLinkRefEqual(left, right, label) {
     invalidCorrelation2(`${label} row and expected references differ.`);
   }
 }
-function sameAttribution(event, commit) {
-  return stableJsonStringify2(event.requestedBy ?? null) === stableJsonStringify2(commit.requestedBy ?? null) && stableJsonStringify2(event.executor) === stableJsonStringify2(commit.executor);
-}
-
-// src/storage/ontology/provider-header-validation.ts
-function assertMaterializationHeader2({ commit }) {
-  assertCommitEnvelope(commit);
-  switch (commit.intent.kind) {
-    case "edit":
-      assertEditCommit(commit, commit.intent);
-      break;
-    case "projection":
-      assertProjectionCommit(commit, commit.intent);
-      break;
-    case "telemetry":
-      assertTelemetryCommit(commit, commit.intent);
-      break;
-  }
-}
-function assertCommitEnvelope(commit) {
-  assertNonblank2(commit.projectId, "Materialization project id");
-  assertNonblank2(commit.id, "Materialization commit id");
-  assertNonblank2(commit.idempotencyKey, "Materialization idempotency key");
-  assertNonblank2(commit.requestHash, "Materialization request hash");
-  assertNonblank2(commit.executionId, "Materialization execution id");
-  assertNonblank2(commit.ontologyRevision, "Materialization ontology revision");
-  assertTimestamp2(commit.committedAt, "Materialization commit time");
-  assertCommitAttribution(commit);
-}
-function assertCommitAttribution(commit) {
-  const { requestedBy, executor } = commit;
-  if (requestedBy !== undefined) {
-    if (requestedBy.type !== "user" && requestedBy.type !== "serviceAccount") {
-      invalidCorrelation2("Materialization requester must be a user or service account.");
-    }
-    assertNonblank2(requestedBy.id, "Materialization requester id");
-  }
-  switch (executor?.type) {
-    case "request":
-      assertNonblank2(executor.requestId, "Materialization executor request id");
-      return;
-    case "primitive":
-      assertNonblank2(executor.kind, "Materialization executor primitive kind");
-      assertNonblank2(executor.id, "Materialization executor primitive id");
-      assertNonblank2(executor.runId, "Materialization executor run id");
-      return;
-    case "agent":
-      assertNonblank2(executor.runId, "Materialization executor Agent run id");
-      return;
-    case "kernel":
-      assertNonblank2(executor.operation?.type, "Materialization executor kernel operation");
-      return;
-    default:
-      invalidCorrelation2("Materialization executor is invalid.");
-  }
-}
-function assertPrimitiveExecutor(commit, kind, id, runId) {
-  const { executor } = commit;
-  if (executor.type !== "primitive" || executor.kind !== kind || executor.id !== id || executor.runId !== runId) {
-    invalidCorrelation2(`Commit ${kind} origin does not match its executor.`);
-  }
-}
-function assertEditCommit(commit, intent) {
-  assertNonnegativeInteger2(intent.operationCount, "Edit commit operation count");
-  switch (commit.origin.kind) {
-    case "action":
-      assertNonblank2(commit.origin.actionId, "Action origin action id");
-      assertNonblank2(commit.origin.runId, "Action origin run id");
-      assertPrimitiveExecutor(commit, "action", commit.origin.actionId, commit.origin.runId);
-      return;
-    case "runtime":
-      assertNonblank2(commit.origin.requestId, "Runtime origin request id");
-      return;
-    default:
-      invalidCorrelation2("Edit commit origin does not correlate with its intent.");
-  }
-}
-function assertProjectionCommit(commit, intent) {
-  if (commit.origin.kind !== "projection") {
-    invalidCorrelation2("Projection commit origin does not correlate with its intent.");
-  }
-  assertProjectionSemanticMetadata(commit);
-  assertNonblank2(commit.origin.projectionRunId, "Projection run id");
-  assertTimestamp2(intent.datasetVersion.createdAt, "Projection dataset version createdAt");
-  if (commit.origin.projectionId !== intent.source.projectionId) {
-    invalidCorrelation2("Projection commit origin does not match its projection.");
-  }
-  if (commit.origin.datasetId !== intent.datasetVersion.datasetId || commit.origin.datasetVersionId !== intent.datasetVersion.versionId) {
-    invalidCorrelation2("Projection commit origin does not match its dataset version.");
-  }
-  assertPrimitiveExecutor(commit, "projection", commit.origin.projectionId, commit.origin.projectionRunId);
-}
-function assertTelemetryCommit(commit, intent) {
-  if (commit.origin.kind !== "telemetry") {
-    invalidCorrelation2("Telemetry commit origin does not correlate with its intent.");
-  }
-  assertTelemetryPointCounts(intent);
-  if (intent.source.kind === "runtime") {
-    assertRuntimeTelemetryCommit(commit);
-    return;
-  }
-  assertProjectionTelemetryCommit(commit, intent.source, intent.inputPointCount);
-}
-function assertTelemetryPointCounts(intent) {
-  assertNonnegativeInteger2(intent.pointCount, "Telemetry commit point count");
-  assertNonnegativeInteger2(intent.inputPointCount, "Telemetry commit input point count");
-  if (intent.inputPointCount < intent.pointCount) {
-    invalidCorrelation2("Telemetry input point count cannot be lower than its canonical point count.");
-  }
-}
-function assertRuntimeTelemetryCommit(commit) {
-  if (commit.origin.kind !== "telemetry" || commit.origin.source.kind !== "runtime") {
-    invalidCorrelation2("Runtime telemetry origin does not correlate with its intent.");
-  }
-  if (commit.projectionRevision !== undefined || commit.ownershipHash !== undefined) {
-    invalidCorrelation2("Runtime telemetry commit contains projection-only metadata.");
-  }
-  assertNonblank2(commit.origin.source.requestId, "Runtime telemetry request id");
-}
-function assertProjectionTelemetryCommit(commit, source, inputPointCount) {
-  if (commit.origin.kind !== "telemetry" || commit.origin.source.kind !== "projection") {
-    invalidCorrelation2("Projection telemetry origin does not correlate with its intent.");
-  }
-  const origin = commit.origin.source;
-  assertProjectionSemanticMetadata(commit);
-  assertNonblank2(origin.projectionRunId, "Telemetry projection run id");
-  assertTimestamp2(source.datasetVersion.createdAt, "Telemetry dataset version createdAt");
-  assertProjectionTelemetryBatch(source, inputPointCount);
-  if (origin.projectionId !== source.projection.projectionId) {
-    invalidCorrelation2("Projection telemetry origin does not match its projection.");
-  }
-  if (origin.datasetId !== source.datasetVersion.datasetId || origin.datasetVersionId !== source.datasetVersion.versionId) {
-    invalidCorrelation2("Projection telemetry origin does not match its dataset version.");
-  }
-  if (origin.batchOrdinal !== source.batchOrdinal) {
-    invalidCorrelation2("Projection telemetry origin does not match its batch ordinal.");
-  }
-  assertPrimitiveExecutor(commit, "projection", origin.projectionId, origin.projectionRunId);
-}
-function assertProjectionTelemetryBatch(source, inputPointCount) {
-  assertNonnegativeInteger2(source.batchOrdinal, "Projection telemetry batch ordinal");
-  assertPositiveInteger2(source.sourceRowCount, "Projection telemetry source row count");
-  assertNonnegativeInteger2(source.sourceRowsSkipped, "Projection telemetry skipped row count");
-  if (source.sourceRowsSkipped > source.sourceRowCount) {
-    invalidCorrelation2("Projection telemetry skipped rows exceed its source row count.");
-  }
-  if (inputPointCount < source.sourceRowCount - source.sourceRowsSkipped) {
-    invalidCorrelation2("Projection telemetry input points do not account for every non-skipped source row.");
-  }
-  if (typeof source.inputExhausted !== "boolean") {
-    invalidCorrelation2("Projection telemetry input exhaustion marker is invalid.");
-  }
-}
-function assertProjectionSemanticMetadata(commit) {
-  if (commit.projectionRevision === undefined || commit.ownershipHash === undefined) {
-    invalidCorrelation2("Projection materialization is missing semantic identity metadata.");
-  }
-  assertNonblank2(commit.projectionRevision, "Projection revision");
-  assertNonblank2(commit.ownershipHash, "Projection ownership hash");
-}
 
 // src/storage/ontology/provider.ts
 function startScopeAccumulator2(source, linkId) {
-  const hash = createHash2("sha256");
+  const hash = createHash("sha256");
   hash.update("[");
   return {
     source: structuredClone(source),
@@ -526,16 +631,11 @@ class ProviderMaterializationSessionState2 {
   transactionId;
   id = randomUUID();
   providerToken = {};
-  workStreams = {
-    apply: { started: false, completed: false, emittedCount: 0 },
-    cardinality: { started: false, completed: false, emittedCount: 0 },
-    event: { started: false, completed: false, emittedCount: 0 }
-  };
   active = true;
   workSealed = false;
-  appliedPlanCount = 0;
-  appliedOutboxCount = 0;
-  replacement = null;
+  vectorChangesStreamed = false;
+  applied = false;
+  appliedEventCount = 0;
   constructor(header, transactionId) {
     this.header = header;
     this.transactionId = transactionId;
@@ -544,6 +644,20 @@ class ProviderMaterializationSessionState2 {
     return { providerToken: this.providerToken };
   }
 }
+function beginMaterializationVectorChanges2(state) {
+  if (state.vectorChangesStreamed || state.applied) {
+    throw new MaterializationConflictError2("effective-state", "Materialization vector changes stream once per session, before the plan applies.");
+  }
+  state.vectorChangesStreamed = true;
+  state.workSealed = true;
+}
+function beginMaterializationApply2(state) {
+  if (state.applied) {
+    throw new MaterializationConflictError2("effective-state", "A materialization plan applies once per session.");
+  }
+  state.applied = true;
+  state.workSealed = true;
+}
 
 class ProviderMaterializationTransactionLifecycle2 {
   openSessions = new Set;
@@ -568,8 +682,11 @@ class ProviderMaterializationTransactionLifecycle2 {
   }
 }
 function prepareMaterializationWork2(state, input) {
+  if (state.header.plan) {
+    throw new MaterializationConflictError2("effective-state", "A plan-bound materialization session applies its plan and stages no work.");
+  }
   if (state.workSealed) {
-    throw new MaterializationConflictError2("effective-state", "Materialization work cannot be staged after draining begins.");
+    throw new MaterializationConflictError2("effective-state", "Materialization work cannot be staged once vector changes stream or the plan applies.");
   }
   const keys = new Set;
   const uniqueKeys = new Set;
@@ -579,46 +696,21 @@ function prepareMaterializationWork2(state, input) {
     if (keys.has(record.recordKey) || uniqueKeys.has(uniqueKey)) {
       throw duplicateMaterializationWork2(record.recordKey);
     }
-    if (record.kind === "incident-object" && (!state.replacement || state.replacement.linkStreamStarted)) {
-      throw new MaterializationConflictError2("effective-state", "Incident replacement work must be staged before link state is streamed.");
+    if (record.kind === "incident-object" || record.kind === "object-existence") {
+      throw new MaterializationConflictError2("effective-state", "Replacement work is staged on a replacement plan, not on a session.");
     }
     keys.add(record.recordKey);
     uniqueKeys.add(uniqueKey);
     return { record, uniqueKey, columns: materializationWorkColumns2(record) };
   });
 }
-function correlateMaterializationChunk2(state, chunk, actualItems, expectedItems, expectedEvents) {
-  if (actualItems.length > 0 && (!state.workStreams.apply.started || state.appliedPlanCount + actualItems.length > state.workStreams.apply.emittedCount)) {
-    invalidMaterializationCorrelation("Materialization plan items cannot be applied before they are streamed.");
-  }
-  for (let index = 0;index < actualItems.length; index += 1) {
-    if (stableJsonStringify2(actualItems[index]) !== stableJsonStringify2(expectedItems[index])) {
-      invalidMaterializationCorrelation("Materialization plan items must be applied in exact streamed order.");
-    }
-  }
-  if (chunk.outbox.length > 0 && (!state.workStreams.event.started || state.appliedOutboxCount + chunk.outbox.length > state.workStreams.event.emittedCount)) {
-    invalidMaterializationCorrelation("Materialization events cannot be applied before they are streamed.");
-  }
-  for (let index = 0;index < chunk.outbox.length; index += 1) {
-    const expected = expectedEvents[index];
-    const actual = chunk.outbox[index]?.envelope;
-    if (!expected || !actual) {
-      invalidMaterializationCorrelation("Materialization outbox events must follow exact streamed order.");
-    }
-    const { id: _id, commitOrdinal, ...draft } = actual;
-    if (commitOrdinal !== state.appliedOutboxCount + index || stableJsonStringify2(draft) !== stableJsonStringify2(expected.draft)) {
-      invalidMaterializationCorrelation("Materialization outbox events must follow exact streamed order.");
-    }
-  }
-  return {
-    appliedPlanCount: state.appliedPlanCount + actualItems.length,
-    appliedOutboxCount: state.appliedOutboxCount + chunk.outbox.length
-  };
-}
 function assertMaterializationFinalizationCorrelation2(state, input) {
   const { commit } = state.header;
   const { result, sourceActivations } = input.finalization;
-  if (result.commitId !== commit.id || result.kind !== commit.intent.kind || result.committedAt !== commit.committedAt || result.created !== true || !Number.isSafeInteger(result.eventCount) || result.eventCount < 0 || result.eventCount !== state.appliedOutboxCount) {
+  if (!state.applied) {
+    invalidMaterializationCorrelation("A materialization plan must apply before it finalizes.");
+  }
+  if (result.commitId !== commit.id || result.kind !== commit.intent.kind || result.committedAt !== commit.committedAt || result.created !== true || !Number.isSafeInteger(result.eventCount) || result.eventCount < 0 || result.eventCount !== state.appliedEventCount) {
     invalidMaterializationCorrelation("Materialization result does not correlate with its commit intent.");
   }
   if (commit.intent.kind === "edit") {
@@ -636,31 +728,13 @@ function assertMaterializationFinalizationCorrelation2(state, input) {
     invalidMaterializationCorrelation("Telemetry result does not correlate with its point intent.");
   }
 }
-function assertMaterializationLaneCompletion2(state, counts) {
-  if (counts.apply > 0 && !state.workStreams.apply.completed) {
-    invalidMaterializationCorrelation("Materialization plan work was not fully streamed.");
-  }
-  if (state.appliedPlanCount !== counts.apply) {
-    invalidMaterializationCorrelation("Materialization plan work was not applied exactly once.");
-  }
-  if (counts.cardinality > 0 && !state.workStreams.cardinality.completed) {
-    invalidMaterializationCorrelation("Materialization cardinality work was not fully validated.");
-  }
-  if (counts.event > 0 && !state.workStreams.event.completed) {
-    invalidMaterializationCorrelation("Materialization event work was not fully drained.");
-  }
-  if (counts.event !== state.appliedOutboxCount) {
-    invalidMaterializationCorrelation("Materialization event work was not fully written to the outbox.");
-  }
-}
 function assertSourceActivationCorrelation2(state, activation) {
   const { commit } = state.header;
   if (commit.intent.kind !== "projection" || commit.origin.kind !== "projection" || activation.source.projectionId !== commit.intent.source.projectionId || activation.source.projectionId !== commit.origin.projectionId || activation.execution.projectionRunId !== commit.origin.projectionRunId || activation.protocol !== "replacement" || stableJsonStringify2(activation.datasetVersion) !== stableJsonStringify2(commit.intent.datasetVersion) || activation.projectionRevision !== commit.projectionRevision || activation.ownershipHash !== commit.ownershipHash || activation.ontologyRevision !== commit.ontologyRevision || activation.lastCommitId !== commit.id || activation.updatedAt !== commit.committedAt || !state.header.expected.sources.some((expected) => stableJsonStringify2(expected) === stableJsonStringify2(activation.expected))) {
     invalidMaterializationCorrelation("Source activation does not correlate with its projection commit.");
   }
-  const replacement = state.replacement;
-  if (!replacement || replacement.sourceId !== activation.source.projectionId || replacement.candidateMaterializationId !== activation.materializationId || replacement.projectionKind !== activation.projectionKind || activation.projectionKind === "object" && (!replacement.objectStreamCompleted || !replacement.linkStreamCompleted) || activation.projectionKind === "link" && !replacement.linkStreamCompleted) {
-    invalidMaterializationCorrelation("Source activation does not match fully streamed replacement state.");
+  if (!state.header.plan || state.header.plan.source.projectionId !== activation.source.projectionId || state.header.plan.materializationId !== activation.materializationId) {
+    invalidMaterializationCorrelation("Source activation does not match the replacement plan the session applies.");
   }
 }
 function invalidMaterializationCorrelation(message) {
@@ -711,7 +785,7 @@ function materializationWorkColumns2(record) {
     return {
       lane: "apply",
       majorOrder: record.applyPhase,
-      minorOrder: materializationPlanKindRank(record.item.kind),
+      minorOrder: materializationPlanKindRank2(record.item.kind),
       sortOne: record.sortKey,
       sortTwo: ""
     };
@@ -736,32 +810,6 @@ function materializationWorkColumns2(record) {
   }
   return { lane: "none", majorOrder: 0, minorOrder: 0, sortOne: "", sortTwo: "" };
 }
-function materializationPlanKindRank(kind) {
-  switch (kind) {
-    case "object-override-upsert":
-      return 0;
-    case "object-override-delete":
-      return 1;
-    case "link-override-upsert":
-      return 2;
-    case "link-override-delete":
-      return 3;
-    case "link-slot-override-upsert":
-      return 4;
-    case "link-slot-override-delete":
-      return 5;
-    case "point-upsert":
-      return 6;
-    case "link-delete":
-      return 7;
-    case "object-delete":
-      return 8;
-    case "object-upsert":
-      return 9;
-    case "link-upsert":
-      return 10;
-  }
-}
 function duplicateMaterializationWork2(key) {
   return new MaterializationConflictError2("effective-state", key === undefined ? "Duplicate materialization work." : `Duplicate materialization work key '${key}'.`);
 }
@@ -1031,6 +1079,6 @@ function sourceConflict2(message) {
   return new MaterializationConflictError2("source-materialization", message);
 }
 
-export { ONTOLOGY_MATERIALIZATION_EVENT_KIND_ORDER2, materializationEventKindOrdinal2, sha256Canonical2, createRequestHash2, createCommitId2, createEventId2, assertNonblank2, assertPositiveInteger2, assertNonnegativeInteger2, assertTimestamp2, invalidCorrelation2, materializationApplyPhase, assertPageRows2, materializationChunkRows2, materializationPlanItems2, assertWorkRecord2, workUniquenessKey2, comparePlanWork2, compareCardinalityWork2, compareEventWork2, assertPlanChunkCorrelations2, assertMaterializationHeader2, startScopeAccumulator2, appendScopeSnapshot2, finishScopeAccumulator2, linkSlotOverrideValue2, ProviderMaterializationSessionState2, ProviderMaterializationTransactionLifecycle2, prepareMaterializationWork2, correlateMaterializationChunk2, assertMaterializationFinalizationCorrelation2, assertMaterializationLaneCompletion2, assertSourceActivationCorrelation2, uniqueSorted2, sameNonnegativeCounts2, effectiveConflict2, assertExpectedObjectRevision2, assertExpectedLinkRevision2, assertExpectedLinkScopeRevision2, materializationWorkColumns2, duplicateMaterializationWork2, canonicalJson2, originColumns2, originWhere2, objectRefFromColumns2, linkRefFromColumns2, sourceEntityKey2, sourceStageRows2, sourceStageRow2, sourceStageRoots2, reconcileSourceStageRows2, sourceMaterializationIdentity2, assertSourceBeginInput2, assertSourceWriteIdentity2, assertSourceProject2, assertSourceExecutionIdentity2, assertSourceCandidateOwner2, assertSourceStagedRow2, sourceEntityColumns2, sourceEntityFromKey2, sourceAssertionPayload2, sourceAssertionFromColumns2, isExactStagingManifest2, sourceConflict2 };
+export { assertNonblank2, assertPositiveInteger2, assertNonnegativeInteger2, assertTimestamp2, invalidCorrelation2, materializationApplyPhase2, assertMaterializationHeader2, assertPageRows2, materializationChunkRows2, materializationPlanChunk2, materializationOutboxWrite2, claimedOutboxRows2, assertReplacementPlanCommit2, prepareReplacementIdentities2, projectionChangeCounts, createCardinalityValidator2, cardinalityViolation2, assertWorkRecord2, workUniquenessKey2, comparePlanWork2, materializationPlanKindRank2, compareCardinalityWork2, compareEventWork2, startScopeAccumulator2, appendScopeSnapshot2, finishScopeAccumulator2, linkSlotOverrideValue2, ProviderMaterializationSessionState2, beginMaterializationVectorChanges2, beginMaterializationApply2, ProviderMaterializationTransactionLifecycle2, prepareMaterializationWork2, assertMaterializationFinalizationCorrelation2, assertSourceActivationCorrelation2, uniqueSorted2, sameNonnegativeCounts2, effectiveConflict2, assertExpectedObjectRevision2, assertExpectedLinkRevision2, assertExpectedLinkScopeRevision2, materializationWorkColumns2, duplicateMaterializationWork2, canonicalJson2, originColumns2, originWhere2, objectRefFromColumns2, linkRefFromColumns2, sourceEntityKey2, sourceStageRows2, sourceStageRow2, sourceStageRoots2, reconcileSourceStageRows2, sourceMaterializationIdentity2, assertSourceBeginInput2, assertSourceWriteIdentity2, assertSourceProject2, assertSourceExecutionIdentity2, assertSourceCandidateOwner2, assertSourceStagedRow2, sourceEntityColumns2, sourceEntityFromKey2, sourceAssertionPayload2, sourceAssertionFromColumns2, isExactStagingManifest2, sourceConflict2 };
 
-//# debugId=4F375DB5C3C8850F64756E2164756E21
+//# debugId=B570E8BCB142312B64756E2164756E21