@sixb/core 0.1.8 → 0.1.10

package/dist/{chunk-8tsf6dmc.js → chunk-gqh45d2n.js}

@@ -1,54 +1,54 @@
 // @bun
 import {
-  linkRefKey,
-  linkRefSortKey,
-  linkScopeSortKey,
-  objectRefKey,
-  projectionEntityKey,
-  telemetryPointKey
-} from "./chunk-dbc80ad7.js";
+  objectRefKey2,
+  linkRefKey2,
+  projectionEntityKey2,
+  telemetryPointKey2,
+  linkRefSortKey2,
+  linkScopeSortKey2
+} from "./chunk-c5rkjrgp.js";
 import {
-  MaterializationConflictError,
-  MaterializationValidationError
-} from "./chunk-ry24jbr1.js";
+  MaterializationValidationError2,
+  MaterializationConflictError2
+} from "./chunk-yv79ncbv.js";
 import {
-  assertJsonValue,
-  stableJsonStringify
-} from "./chunk-n6jxh8sw.js";
+  assertJsonValue2,
+  stableJsonStringify2
+} from "./chunk-wy0qdqfm.js";
 
 // src/storage/ontology/provider.ts
 import { createHash as createHash2, randomUUID } from "crypto";
 
 // src/storage/ontology/provider-validation.ts
-function assertNonblank(value, label) {
+function assertNonblank2(value, label) {
   if (typeof value !== "string" || value.trim().length === 0) {
-    throw new MaterializationValidationError(`${label} must be nonblank.`);
+    throw new MaterializationValidationError2(`${label} must be nonblank.`);
   }
 }
-function assertPositiveInteger(value, label) {
+function assertPositiveInteger2(value, label) {
   if (!Number.isSafeInteger(value) || value <= 0) {
-    throw new MaterializationValidationError(`${label} must be a positive safe integer.`);
+    throw new MaterializationValidationError2(`${label} must be a positive safe integer.`);
   }
 }
-function assertNonnegativeInteger(value, label) {
+function assertNonnegativeInteger2(value, label) {
   if (!Number.isSafeInteger(value) || value < 0) {
-    throw new MaterializationValidationError(`${label} must be a nonnegative safe integer.`);
+    throw new MaterializationValidationError2(`${label} must be a nonnegative safe integer.`);
   }
 }
-function assertTimestamp(value, label, canonical = true) {
+function assertTimestamp2(value, label, canonical = true) {
   const milliseconds = Date.parse(value);
   if (!Number.isFinite(milliseconds) || canonical && new Date(milliseconds).toISOString() !== value) {
-    throw new MaterializationValidationError(`${label} must be ${canonical ? "a canonical UTC" : "a valid"} timestamp.`);
+    throw new MaterializationValidationError2(`${label} must be ${canonical ? "a canonical UTC" : "a valid"} timestamp.`);
   }
   return milliseconds;
 }
-function invalidCorrelation(message) {
-  throw new MaterializationValidationError(message);
+function invalidCorrelation2(message) {
+  throw new MaterializationValidationError2(message);
 }
 
 // src/materialization/identity.ts
 import { createHash } from "crypto";
-var ONTOLOGY_MATERIALIZATION_EVENT_KIND_ORDER = Object.freeze([
+var ONTOLOGY_MATERIALIZATION_EVENT_KIND_ORDER2 = Object.freeze([
   "object.created",
   "object.updated",
   "object.deleted",
@@ -57,21 +57,21 @@ var ONTOLOGY_MATERIALIZATION_EVENT_KIND_ORDER = Object.freeze([
   "link.deleted",
   "telemetry.appended"
 ]);
-function materializationEventKindOrdinal(kind) {
-  return ONTOLOGY_MATERIALIZATION_EVENT_KIND_ORDER.indexOf(kind);
+function materializationEventKindOrdinal2(kind) {
+  return ONTOLOGY_MATERIALIZATION_EVENT_KIND_ORDER2.indexOf(kind);
 }
-function sha256Canonical(value) {
-  assertJsonValue(value, "Canonical hash input");
-  return createHash("sha256").update(stableJsonStringify(value)).digest("hex");
+function sha256Canonical2(value) {
+  assertJsonValue2(value, "Canonical hash input");
+  return createHash("sha256").update(stableJsonStringify2(value)).digest("hex");
 }
-function createRequestHash(normalizedCallerIntent) {
-  return sha256Canonical(normalizedCallerIntent);
+function createRequestHash2(normalizedCallerIntent) {
+  return sha256Canonical2(normalizedCallerIntent);
 }
-function createCommitId(projectId, idempotencyKey) {
-  return sha256Canonical([projectId, idempotencyKey]);
+function createCommitId2(projectId, idempotencyKey) {
+  return sha256Canonical2([projectId, idempotencyKey]);
 }
-function createEventId(projectId, commitId, ordinal) {
-  return sha256Canonical([projectId, commitId, ordinal]);
+function createEventId2(projectId, commitId, ordinal) {
+  return sha256Canonical2([projectId, commitId, ordinal]);
 }
 
 // src/storage/ontology/materializations.ts
@@ -98,14 +98,14 @@ function materializationApplyPhase(kind) {
 }
 
 // src/storage/ontology/provider-work.ts
-function assertPageRows(value) {
+function assertPageRows2(value) {
   if (!Number.isSafeInteger(value) || value <= 0)
-    throw new MaterializationValidationError("Materialization page size must be positive.");
+    throw new MaterializationValidationError2("Materialization page size must be positive.");
 }
-function materializationChunkRows(chunk) {
+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 materializationPlanItems(chunk) {
+function materializationPlanItems2(chunk) {
   return [
     ...chunk.overrides.objects.upserts.map((value) => ({
       kind: "object-override-upsert",
@@ -138,41 +138,41 @@ function materializationPlanItems(chunk) {
     ...chunk.timeseries.pointUpserts.map((value) => ({ kind: "point-upsert", value }))
   ];
 }
-function assertWorkRecord(record, header) {
+function assertWorkRecord2(record, header) {
   if (record.recordKey.trim().length === 0) {
-    throw new MaterializationValidationError("Materialization work key must be nonblank.");
+    throw new MaterializationValidationError2("Materialization work key must be nonblank.");
   }
   if (record.kind === "plan") {
     if (!/^[0-9a-f]+$/.test(record.sortKey) || !planPhaseMatches(record)) {
-      throw new MaterializationValidationError("Materialization plan work has an invalid order.");
+      throw new MaterializationValidationError2("Materialization plan work has an invalid order.");
     }
     assertPlanItemCorrelation(record.item, header.commit);
     return;
   }
   if (record.kind === "event") {
-    if (!/^[0-9a-f]+$/.test(record.sortKey) || !Number.isSafeInteger(record.eventKindRank) || record.eventKindRank < 0 || record.eventKindRank !== materializationEventKindOrdinal(record.draft.type) || record.draft.projectId !== header.commit.projectId || record.draft.commitId !== header.commit.id || record.draft.occurredAt !== header.commit.committedAt || stableJsonStringify(record.draft.origin) !== stableJsonStringify(header.commit.origin) || stableJsonStringify(record.draft.actor ?? null) !== stableJsonStringify(header.commit.actor ?? null)) {
-      throw new MaterializationValidationError("Materialization event work is invalid.");
+    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) || stableJsonStringify2(record.draft.actor ?? null) !== stableJsonStringify2(header.commit.actor ?? null)) {
+      throw new MaterializationValidationError2("Materialization event work is invalid.");
     }
     return;
   }
   if (record.kind === "cardinality") {
-    if (record.scopeSortKey !== linkScopeSortKey(record.ref.source, record.ref.linkId) || record.linkSortKey !== linkRefSortKey(record.ref)) {
-      throw new MaterializationValidationError("Materialization cardinality work has an invalid identity or order.");
+    if (record.scopeSortKey !== linkScopeSortKey2(record.ref.source, record.ref.linkId) || record.linkSortKey !== linkRefSortKey2(record.ref)) {
+      throw new MaterializationValidationError2("Materialization cardinality work has an invalid identity or order.");
     }
     return;
   }
   if (record.kind === "classification" && record.identityKey.trim().length === 0) {
-    throw new MaterializationValidationError("Materialization classification identity is invalid.");
+    throw new MaterializationValidationError2("Materialization classification identity is invalid.");
   }
 }
-function workUniquenessKey(record) {
+function workUniquenessKey2(record) {
   switch (record.kind) {
     case "classification":
       return `classification:${record.entityKind}:${record.identityKey}`;
     case "object-existence":
-      return `object-existence:${objectRefKey(record.ref)}`;
+      return `object-existence:${objectRefKey2(record.ref)}`;
     case "incident-object":
-      return `incident-object:${objectRefKey(record.ref)}`;
+      return `incident-object:${objectRefKey2(record.ref)}`;
     case "cardinality":
       return `cardinality:${record.view}:${record.scopeSortKey}:${record.linkSortKey}`;
     case "plan":
@@ -181,7 +181,7 @@ function workUniquenessKey(record) {
       return `event:${record.eventKindRank}:${record.sortKey}`;
   }
 }
-function comparePlanWork(left, right) {
+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);
 }
 function planKindOrder(kind) {
@@ -210,20 +210,20 @@ function planKindOrder(kind) {
       return 10;
   }
 }
-function compareCardinalityWork(left, right) {
+function compareCardinalityWork2(left, right) {
   return cardinalityViewOrder(left.view) - cardinalityViewOrder(right.view) || left.scopeSortKey.localeCompare(right.scopeSortKey) || left.linkSortKey.localeCompare(right.linkSortKey) || left.recordKey.localeCompare(right.recordKey);
 }
 function cardinalityViewOrder(view) {
   return view === "effective" ? 0 : 1;
 }
-function compareEventWork(left, right) {
+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 assertPlanChunkCorrelations(chunk, commit) {
-  for (const item of materializationPlanItems(chunk))
+function assertPlanChunkCorrelations2(chunk, commit) {
+  for (const item of materializationPlanItems2(chunk))
     assertPlanItemCorrelation(item, commit);
   for (const value of chunk.outbox)
     assertOutboxCorrelation(value, commit);
@@ -260,38 +260,38 @@ function assertPlanItemCorrelation(item, commit) {
   }
 }
 function assertPointWriteCorrelation(value, commit) {
-  if (telemetryPointKey(value.point.series, value.point.at) !== telemetryPointKey(value.expected.series, value.expected.at)) {
-    invalidCorrelation("Timeseries point write does not match its expected identity.");
+  if (telemetryPointKey2(value.point.series, value.point.at) !== telemetryPointKey2(value.expected.series, value.expected.at)) {
+    invalidCorrelation2("Timeseries point write does not match its expected identity.");
   }
-  assertTimestamp(value.point.at, "Timeseries point timestamp");
+  assertTimestamp2(value.point.at, "Timeseries point timestamp");
   if (value.point.lastCommitId !== commit.id) {
-    invalidCorrelation("Timeseries point last commit id does not match its session 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 || stableJsonStringify(envelope.origin) !== stableJsonStringify(commit.origin) || stableJsonStringify(envelope.actor ?? null) !== stableJsonStringify(commit.actor ?? null) || !Number.isSafeInteger(envelope.commitOrdinal) || envelope.commitOrdinal < 0 || envelope.id !== createEventId(commit.projectId, commit.id, envelope.commitOrdinal)) {
-    invalidCorrelation("Outbox event does not correlate with its materialization commit.");
+  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) || stableJsonStringify2(envelope.actor ?? null) !== stableJsonStringify2(commit.actor ?? null) || !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) {
-    invalidCorrelation(`${label} provenance does not match its session commit.`);
+    invalidCorrelation2(`${label} provenance does not match its session commit.`);
   }
 }
 function assertObjectRefEqual(left, right, label) {
-  if (objectRefKey(left) !== objectRefKey(right)) {
-    invalidCorrelation(`${label} row and expected references differ.`);
+  if (objectRefKey2(left) !== objectRefKey2(right)) {
+    invalidCorrelation2(`${label} row and expected references differ.`);
   }
 }
 function assertLinkRefEqual(left, right, label) {
-  if (linkRefKey(left) !== linkRefKey(right)) {
-    invalidCorrelation(`${label} row and expected references differ.`);
+  if (linkRefKey2(left) !== linkRefKey2(right)) {
+    invalidCorrelation2(`${label} row and expected references differ.`);
   }
 }
 
 // src/storage/ontology/provider-header-validation.ts
-function assertMaterializationHeader({ commit }) {
+function assertMaterializationHeader2({ commit }) {
   assertCommitEnvelope(commit);
   switch (commit.intent.kind) {
     case "edit":
@@ -306,45 +306,45 @@ function assertMaterializationHeader({ commit }) {
   }
 }
 function assertCommitEnvelope(commit) {
-  assertNonblank(commit.projectId, "Materialization project id");
-  assertNonblank(commit.id, "Materialization commit id");
-  assertNonblank(commit.idempotencyKey, "Materialization idempotency key");
-  assertNonblank(commit.requestHash, "Materialization request hash");
-  assertNonblank(commit.executionId, "Materialization execution id");
-  assertNonblank(commit.ontologyRevision, "Materialization ontology revision");
-  assertTimestamp(commit.committedAt, "Materialization commit time");
+  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) {
-  assertNonnegativeInteger(intent.operationCount, "Edit commit operation count");
+  assertNonnegativeInteger2(intent.operationCount, "Edit commit operation count");
   switch (commit.origin.kind) {
     case "action":
-      assertNonblank(commit.origin.actionId, "Action origin action id");
-      assertNonblank(commit.origin.runId, "Action origin run id");
+      assertNonblank2(commit.origin.actionId, "Action origin action id");
+      assertNonblank2(commit.origin.runId, "Action origin run id");
       return;
     case "runtime":
-      assertNonblank(commit.origin.requestId, "Runtime origin request id");
+      assertNonblank2(commit.origin.requestId, "Runtime origin request id");
       return;
     default:
-      invalidCorrelation("Edit commit origin does not correlate with its intent.");
+      invalidCorrelation2("Edit commit origin does not correlate with its intent.");
   }
 }
 function assertProjectionCommit(commit, intent) {
   if (commit.origin.kind !== "projection") {
-    invalidCorrelation("Projection commit origin does not correlate with its intent.");
+    invalidCorrelation2("Projection commit origin does not correlate with its intent.");
   }
   assertProjectionSemanticMetadata(commit);
-  assertNonblank(commit.origin.projectionRunId, "Projection run id");
-  assertTimestamp(intent.datasetVersion.createdAt, "Projection dataset version createdAt");
+  assertNonblank2(commit.origin.projectionRunId, "Projection run id");
+  assertTimestamp2(intent.datasetVersion.createdAt, "Projection dataset version createdAt");
   if (commit.origin.projectionId !== intent.source.projectionId) {
-    invalidCorrelation("Projection commit origin does not match its projection.");
+    invalidCorrelation2("Projection commit origin does not match its projection.");
   }
   if (commit.origin.datasetId !== intent.datasetVersion.datasetId || commit.origin.datasetVersionId !== intent.datasetVersion.versionId) {
-    invalidCorrelation("Projection commit origin does not match its dataset version.");
+    invalidCorrelation2("Projection commit origin does not match its dataset version.");
   }
 }
 function assertTelemetryCommit(commit, intent) {
   if (commit.origin.kind !== "telemetry") {
-    invalidCorrelation("Telemetry commit origin does not correlate with its intent.");
+    invalidCorrelation2("Telemetry commit origin does not correlate with its intent.");
   }
   assertTelemetryPointCounts(intent);
   if (intent.source.kind === "runtime") {
@@ -354,64 +354,64 @@ function assertTelemetryCommit(commit, intent) {
   assertProjectionTelemetryCommit(commit, intent.source, intent.inputPointCount);
 }
 function assertTelemetryPointCounts(intent) {
-  assertNonnegativeInteger(intent.pointCount, "Telemetry commit point count");
-  assertNonnegativeInteger(intent.inputPointCount, "Telemetry commit input point count");
+  assertNonnegativeInteger2(intent.pointCount, "Telemetry commit point count");
+  assertNonnegativeInteger2(intent.inputPointCount, "Telemetry commit input point count");
   if (intent.inputPointCount < intent.pointCount) {
-    invalidCorrelation("Telemetry input point count cannot be lower than its canonical point count.");
+    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") {
-    invalidCorrelation("Runtime telemetry origin does not correlate with its intent.");
+    invalidCorrelation2("Runtime telemetry origin does not correlate with its intent.");
   }
   if (commit.projectionRevision !== undefined || commit.ownershipHash !== undefined) {
-    invalidCorrelation("Runtime telemetry commit contains projection-only metadata.");
+    invalidCorrelation2("Runtime telemetry commit contains projection-only metadata.");
   }
-  assertNonblank(commit.origin.source.requestId, "Runtime telemetry request id");
+  assertNonblank2(commit.origin.source.requestId, "Runtime telemetry request id");
 }
 function assertProjectionTelemetryCommit(commit, source, inputPointCount) {
   if (commit.origin.kind !== "telemetry" || commit.origin.source.kind !== "projection") {
-    invalidCorrelation("Projection telemetry origin does not correlate with its intent.");
+    invalidCorrelation2("Projection telemetry origin does not correlate with its intent.");
   }
   const origin = commit.origin.source;
   assertProjectionSemanticMetadata(commit);
-  assertNonblank(origin.projectionRunId, "Telemetry projection run id");
-  assertTimestamp(source.datasetVersion.createdAt, "Telemetry dataset version createdAt");
+  assertNonblank2(origin.projectionRunId, "Telemetry projection run id");
+  assertTimestamp2(source.datasetVersion.createdAt, "Telemetry dataset version createdAt");
   assertProjectionTelemetryBatch(source, inputPointCount);
   if (origin.projectionId !== source.projection.projectionId) {
-    invalidCorrelation("Projection telemetry origin does not match its projection.");
+    invalidCorrelation2("Projection telemetry origin does not match its projection.");
   }
   if (origin.datasetId !== source.datasetVersion.datasetId || origin.datasetVersionId !== source.datasetVersion.versionId) {
-    invalidCorrelation("Projection telemetry origin does not match its dataset version.");
+    invalidCorrelation2("Projection telemetry origin does not match its dataset version.");
   }
   if (origin.batchOrdinal !== source.batchOrdinal) {
-    invalidCorrelation("Projection telemetry origin does not match its batch ordinal.");
+    invalidCorrelation2("Projection telemetry origin does not match its batch ordinal.");
   }
 }
 function assertProjectionTelemetryBatch(source, inputPointCount) {
-  assertNonnegativeInteger(source.batchOrdinal, "Projection telemetry batch ordinal");
-  assertPositiveInteger(source.sourceRowCount, "Projection telemetry source row count");
-  assertNonnegativeInteger(source.sourceRowsSkipped, "Projection telemetry skipped row count");
+  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) {
-    invalidCorrelation("Projection telemetry skipped rows exceed its source row count.");
+    invalidCorrelation2("Projection telemetry skipped rows exceed its source row count.");
   }
   if (inputPointCount < source.sourceRowCount - source.sourceRowsSkipped) {
-    invalidCorrelation("Projection telemetry input points do not account for every non-skipped source row.");
+    invalidCorrelation2("Projection telemetry input points do not account for every non-skipped source row.");
   }
   if (typeof source.inputExhausted !== "boolean") {
-    invalidCorrelation("Projection telemetry input exhaustion marker is invalid.");
+    invalidCorrelation2("Projection telemetry input exhaustion marker is invalid.");
   }
 }
 function assertProjectionSemanticMetadata(commit) {
   if (commit.projectionRevision === undefined || commit.ownershipHash === undefined) {
-    invalidCorrelation("Projection materialization is missing semantic identity metadata.");
+    invalidCorrelation2("Projection materialization is missing semantic identity metadata.");
   }
-  assertNonblank(commit.projectionRevision, "Projection revision");
-  assertNonblank(commit.ownershipHash, "Projection ownership hash");
+  assertNonblank2(commit.projectionRevision, "Projection revision");
+  assertNonblank2(commit.ownershipHash, "Projection ownership hash");
 }
 
 // src/storage/ontology/provider.ts
-function startScopeAccumulator(source, linkId) {
+function startScopeAccumulator2(source, linkId) {
   const hash = createHash2("sha256");
   hash.update("[");
   return {
@@ -421,17 +421,17 @@ function startScopeAccumulator(source, linkId) {
     effectiveCount: 0
   };
 }
-function appendScopeSnapshot(accumulator, snapshot) {
+function appendScopeSnapshot2(accumulator, snapshot) {
   if (accumulator.effectiveCount > 0)
     accumulator.hash.update(",");
-  accumulator.hash.update(stableJsonStringify({
+  accumulator.hash.update(stableJsonStringify2({
     ref: snapshot.ref,
     properties: snapshot.properties ?? {},
     lastCommitId: snapshot.lastCommitId
   }));
   accumulator.effectiveCount += 1;
 }
-function finishScopeAccumulator(accumulator) {
+function finishScopeAccumulator2(accumulator) {
   accumulator.hash.update("]");
   return {
     source: accumulator.source,
@@ -440,7 +440,7 @@ function finishScopeAccumulator(accumulator) {
     fingerprint: accumulator.hash.digest("hex")
   };
 }
-function linkSlotOverrideValue(value, scopeLabel) {
+function linkSlotOverrideValue2(value, scopeLabel) {
   if (!isRecord(value) || typeof value.kind !== "string") {
     throw invalidLinkSlotOverride(scopeLabel);
   }
@@ -463,7 +463,7 @@ function linkSlotOverrideValue(value, scopeLabel) {
   return { kind: "set", target, properties: structuredClone(value.properties) };
 }
 function invalidLinkSlotOverride(scopeLabel) {
-  return new MaterializationConflictError("effective-state", `Cardinality-one link slot ${scopeLabel} contains an invalid stored override.`);
+  return new MaterializationConflictError2("effective-state", `Cardinality-one link slot ${scopeLabel} contains an invalid stored override.`);
 }
 function isRecord(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
@@ -481,7 +481,7 @@ function isJsonValue(value) {
   return isRecord(value) && Object.values(value).every(isJsonValue);
 }
 
-class ProviderMaterializationSessionState {
+class ProviderMaterializationSessionState2 {
   header;
   transactionId;
   id = randomUUID();
@@ -505,12 +505,12 @@ class ProviderMaterializationSessionState {
   }
 }
 
-class ProviderMaterializationTransactionLifecycle {
+class ProviderMaterializationTransactionLifecycle2 {
   openSessions = new Set;
   active = true;
   register(sessionToken) {
     if (!this.active) {
-      throw new MaterializationValidationError("Cannot open a materialization session on an inactive storage transaction.");
+      throw new MaterializationValidationError2("Cannot open a materialization session on an inactive storage transaction.");
     }
     this.openSessions.add(sessionToken);
   }
@@ -520,39 +520,39 @@ class ProviderMaterializationTransactionLifecycle {
   assertCommittable() {
     if (this.openSessions.size === 0)
       return;
-    throw new MaterializationValidationError(`Storage transaction has ${this.openSessions.size} unfinished materialization session${this.openSessions.size === 1 ? "" : "s"}; every session returned by begin() must be finalized.`);
+    throw new MaterializationValidationError2(`Storage transaction has ${this.openSessions.size} unfinished materialization session${this.openSessions.size === 1 ? "" : "s"}; every session returned by begin() must be finalized.`);
   }
   deactivate() {
     this.active = false;
     this.openSessions.clear();
   }
 }
-function prepareMaterializationWork(state, input) {
+function prepareMaterializationWork2(state, input) {
   if (state.workSealed) {
-    throw new MaterializationConflictError("effective-state", "Materialization work cannot be staged after draining begins.");
+    throw new MaterializationConflictError2("effective-state", "Materialization work cannot be staged after draining begins.");
   }
   const keys = new Set;
   const uniqueKeys = new Set;
   return input.records.map((record) => {
-    assertWorkRecord(record, state.header);
-    const uniqueKey = workUniquenessKey(record);
+    assertWorkRecord2(record, state.header);
+    const uniqueKey = workUniquenessKey2(record);
     if (keys.has(record.recordKey) || uniqueKeys.has(uniqueKey)) {
-      throw duplicateMaterializationWork(record.recordKey);
+      throw duplicateMaterializationWork2(record.recordKey);
     }
     if (record.kind === "incident-object" && (!state.replacement || state.replacement.linkStreamStarted)) {
-      throw new MaterializationConflictError("effective-state", "Incident replacement work must be staged before link state is streamed.");
+      throw new MaterializationConflictError2("effective-state", "Incident replacement work must be staged before link state is streamed.");
     }
     keys.add(record.recordKey);
     uniqueKeys.add(uniqueKey);
-    return { record, uniqueKey, columns: materializationWorkColumns(record) };
+    return { record, uniqueKey, columns: materializationWorkColumns2(record) };
   });
 }
-function correlateMaterializationChunk(state, chunk, actualItems, expectedItems, expectedEvents) {
+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 (stableJsonStringify(actualItems[index]) !== stableJsonStringify(expectedItems[index])) {
+    if (stableJsonStringify2(actualItems[index]) !== stableJsonStringify2(expectedItems[index])) {
       invalidMaterializationCorrelation("Materialization plan items must be applied in exact streamed order.");
     }
   }
@@ -566,7 +566,7 @@ function correlateMaterializationChunk(state, chunk, actualItems, expectedItems,
       invalidMaterializationCorrelation("Materialization outbox events must follow exact streamed order.");
     }
     const { id: _id, commitOrdinal, ...draft } = actual;
-    if (commitOrdinal !== state.appliedOutboxCount + index || stableJsonStringify(draft) !== stableJsonStringify(expected.draft)) {
+    if (commitOrdinal !== state.appliedOutboxCount + index || stableJsonStringify2(draft) !== stableJsonStringify2(expected.draft)) {
       invalidMaterializationCorrelation("Materialization outbox events must follow exact streamed order.");
     }
   }
@@ -575,7 +575,7 @@ function correlateMaterializationChunk(state, chunk, actualItems, expectedItems,
     appliedOutboxCount: state.appliedOutboxCount + chunk.outbox.length
   };
 }
-function assertMaterializationFinalizationCorrelation(state, input) {
+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) {
@@ -596,7 +596,7 @@ function assertMaterializationFinalizationCorrelation(state, input) {
     invalidMaterializationCorrelation("Telemetry result does not correlate with its point intent.");
   }
 }
-function assertMaterializationLaneCompletion(state, counts) {
+function assertMaterializationLaneCompletion2(state, counts) {
   if (counts.apply > 0 && !state.workStreams.apply.completed) {
     invalidMaterializationCorrelation("Materialization plan work was not fully streamed.");
   }
@@ -613,9 +613,9 @@ function assertMaterializationLaneCompletion(state, counts) {
     invalidMaterializationCorrelation("Materialization event work was not fully written to the outbox.");
   }
 }
-function assertSourceActivationCorrelation(state, activation) {
+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" || stableJsonStringify(activation.datasetVersion) !== stableJsonStringify(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) => stableJsonStringify(expected) === stableJsonStringify(activation.expected))) {
+  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;
@@ -624,19 +624,19 @@ function assertSourceActivationCorrelation(state, activation) {
   }
 }
 function invalidMaterializationCorrelation(message) {
-  throw new MaterializationValidationError(message);
+  throw new MaterializationValidationError2(message);
 }
-function uniqueSorted(values, identity, sortKey) {
+function uniqueSorted2(values, identity, sortKey) {
   return [...new Map(values.map((value) => [identity(value), value])).values()].sort((left, right) => sortKey(left).localeCompare(sortKey(right)));
 }
-function sameNonnegativeCounts(actual, expected) {
+function sameNonnegativeCounts2(actual, expected) {
   const actualCounts = actual;
   return Object.entries(expected).every(([key, value]) => typeof value === "number" && Number.isSafeInteger(actualCounts[key]) && actualCounts[key] === value && value >= 0);
 }
-function effectiveConflict(message) {
-  return new MaterializationConflictError("effective-state", message);
+function effectiveConflict2(message) {
+  return new MaterializationConflictError2("effective-state", message);
 }
-function materializationWorkColumns(record) {
+function materializationWorkColumns2(record) {
   if (record.kind === "plan") {
     return {
       lane: "apply",
@@ -692,13 +692,13 @@ function materializationPlanKindRank(kind) {
       return 10;
   }
 }
-function duplicateMaterializationWork(key) {
-  return new MaterializationConflictError("effective-state", key === undefined ? "Duplicate materialization work." : `Duplicate materialization work key '${key}'.`);
+function duplicateMaterializationWork2(key) {
+  return new MaterializationConflictError2("effective-state", key === undefined ? "Duplicate materialization work." : `Duplicate materialization work key '${key}'.`);
 }
-function canonicalJson(value) {
-  return stableJsonStringify(value);
+function canonicalJson2(value) {
+  return stableJsonStringify2(value);
 }
-function originColumns(origin) {
+function originColumns2(origin) {
   if (origin.kind === "action") {
     return { kind: "action", runId: origin.runId, batchOrdinal: null };
   }
@@ -714,7 +714,7 @@ function originColumns(origin) {
   }
   return { kind: origin.kind, runId: null, batchOrdinal: null };
 }
-function originWhere(origin) {
+function originWhere2(origin) {
   if (origin.kind === "action") {
     return { kind: origin.kind, runId: origin.actionRunId, batchOrdinal: null };
   }
@@ -727,33 +727,65 @@ function originWhere(origin) {
     batchOrdinal: origin.batchOrdinal
   };
 }
-function objectRefFromColumns(row) {
+function objectRefFromColumns2(row) {
   return { objectTypeId: row.object_type_id, primaryId: row.primary_id };
 }
-function linkRefFromColumns(row) {
+function linkRefFromColumns2(row) {
   return {
     source: { objectTypeId: row.source_type_id, primaryId: row.source_id },
     linkId: row.link_id,
     target: { objectTypeId: row.target_type_id, primaryId: row.target_id }
   };
 }
-function sourceEntityKey(row) {
-  return projectionEntityKey(row.assertion);
+function sourceEntityKey2(row) {
+  return projectionEntityKey2(row.assertion);
 }
-function sourceStageRows(projectionKind, rows) {
+function sourceStageRows2(projectionKind, rows) {
   return rows.map((row) => {
-    assertSourceStagedRow(projectionKind, row);
-    return sourceStageRow(row);
+    assertSourceStagedRow2(projectionKind, row);
+    return sourceStageRow2(row);
   });
 }
-function sourceStageRow(row) {
+function sourceStageRow2(row) {
   return {
     row,
-    rootKey: projectionEntityKey(row.root),
-    entityKey: sourceEntityKey(row)
+    rootKey: projectionEntityKey2(row.root),
+    entityKey: sourceEntityKey2(row)
   };
 }
-function reconcileSourceStageRows(rows, existingRows) {
+function sourceStageRoots2(projectionKind, input) {
+  for (const row of input.rows)
+    assertSourceStagedRow2(projectionKind, row);
+  const roots = new Map;
+  const ordinals = new Map;
+  for (const [items, deleted] of [
+    [input.rows, false],
+    [input.deletions ?? [], true]
+  ]) {
+    for (const row of items) {
+      assertSourceEntity(row.root, "Source root");
+      if (row.root.kind !== projectionKind || !Number.isSafeInteger(row.stagingOrdinal) || row.stagingOrdinal < 0) {
+        throw new MaterializationValidationError2("Source root kind or staging ordinal is invalid.");
+      }
+      const key = projectionEntityKey2(row.root);
+      const previous = roots.get(key);
+      const otherRoot = ordinals.get(row.stagingOrdinal);
+      if (previous && (previous.deleted !== deleted || previous.stagingOrdinal !== row.stagingOrdinal) || otherRoot !== undefined && otherRoot !== key) {
+        throw new MaterializationValidationError2(`Source materialization repeats root or stream ordinal ${row.stagingOrdinal} with different content.`);
+      }
+      roots.set(key, {
+        root: row.root,
+        rootKey: key,
+        sortKey: utf8SortKey2(key),
+        stagingOrdinal: row.stagingOrdinal,
+        deleted
+      });
+      ordinals.set(row.stagingOrdinal, key);
+    }
+  }
+  return [...roots.values()];
+}
+function reconcileSourceStageRows2(rows, existingRows) {
   const rootOrdinals = new Map(existingRows.map(({ rootKey, row }) => [rootKey, row.stagingOrdinal]));
   const ordinalRoots = new Map(existingRows.map(({ rootKey, row }) => [row.stagingOrdinal, rootKey]));
   const assertions = new Map(existingRows.map((row) => [row.entityKey, row.row]));
@@ -763,19 +795,19 @@ function reconcileSourceStageRows(rows, existingRows) {
     const { entityKey, rootKey, row } = staged;
     const rootOrdinal = rootOrdinals.get(rootKey);
     if (rootOrdinal !== undefined && rootOrdinal !== row.stagingOrdinal) {
-      throw new MaterializationValidationError(`Source materialization repeats root ${rootKey} at a different stream ordinal.`);
+      throw new MaterializationValidationError2(`Source materialization repeats root ${rootKey} at a different stream ordinal.`);
     }
     const ordinalRoot = ordinalRoots.get(row.stagingOrdinal);
     if (ordinalRoot !== undefined && ordinalRoot !== rootKey) {
-      throw new MaterializationValidationError(`Source materialization repeats stream ordinal ${row.stagingOrdinal} for another root.`);
+      throw new MaterializationValidationError2(`Source materialization repeats stream ordinal ${row.stagingOrdinal} for another root.`);
     }
     const existing = assertions.get(entityKey) ?? pending.get(entityKey)?.row;
     if (existing) {
-      if (canonicalJson(existing) === canonicalJson(row)) {
+      if (canonicalJson2(existing) === canonicalJson2(row)) {
         unchanged += 1;
         continue;
       }
-      throw new MaterializationValidationError(`Source materialization repeats asserted entity ${entityKey}.`);
+      throw new MaterializationValidationError2(`Source materialization repeats asserted entity ${entityKey}.`);
     }
     rootOrdinals.set(rootKey, row.stagingOrdinal);
     ordinalRoots.set(row.stagingOrdinal, rootKey);
@@ -783,7 +815,7 @@ function reconcileSourceStageRows(rows, existingRows) {
   }
   return { pending: [...pending.values()], unchanged };
 }
-function sourceMaterializationIdentity(input) {
+function sourceMaterializationIdentity2(input) {
   return {
     projectionKind: input.projectionKind,
     protocol: input.protocol,
@@ -793,66 +825,73 @@ function sourceMaterializationIdentity(input) {
     ontologyRevision: input.ontologyRevision
   };
 }
-function assertSourceBeginInput(input) {
-  assertSourceWriteIdentity(input);
+function assertSourceBeginInput2(input) {
+  assertSourceWriteIdentity2(input);
   if (input.projectionKind !== "object" && input.projectionKind !== "link") {
-    throw new MaterializationValidationError("Source projection kind must be 'object' or 'link'.");
+    throw new MaterializationValidationError2("Source projection kind must be 'object' or 'link'.");
   }
   if (input.protocol !== "replacement") {
-    throw new MaterializationValidationError("Source materialization protocol must be 'replacement'.");
-  }
-  assertNonblank(input.projectionRevision, "Source projection revision");
-  assertNonblank(input.ownershipHash, "Source ownership hash");
-  assertNonblank(input.ontologyRevision, "Source ontology revision");
-  assertNonblank(input.datasetVersion.datasetId, "Source dataset id");
-  assertNonblank(input.datasetVersion.versionId, "Source dataset version id");
-  assertTimestamp(input.datasetVersion.createdAt, "Source dataset version createdAt", true);
-  assertTimestamp(input.createdAt, "Source createdAt", true);
-}
-function assertSourceWriteIdentity(input) {
-  assertSourceProject(input);
-  assertNonblank(input.materializationId, "Source materialization id");
-  assertSourceExecutionIdentity(input.execution.projectionRunId, input.execution.executionToken);
-}
-function assertSourceProject(input) {
-  assertNonblank(input.projectId, "Source project id");
-  assertNonblank(input.source.projectionId, "Source projection id");
-}
-function assertSourceExecutionIdentity(runId, token) {
-  assertNonblank(runId, "Source projection run id");
-  assertNonblank(token, "Source execution token");
-}
-function assertSourceCandidateOwner(manifest, execution) {
+    throw new MaterializationValidationError2("Source materialization protocol must be 'replacement'.");
+  }
+  assertNonblank2(input.projectionRevision, "Source projection revision");
+  assertNonblank2(input.ownershipHash, "Source ownership hash");
+  assertNonblank2(input.ontologyRevision, "Source ontology revision");
+  assertNonblank2(input.datasetVersion.datasetId, "Source dataset id");
+  assertNonblank2(input.datasetVersion.versionId, "Source dataset version id");
+  assertTimestamp2(input.datasetVersion.createdAt, "Source dataset version createdAt", true);
+  assertTimestamp2(input.createdAt, "Source createdAt", true);
+  if (input.base) {
+    assertNonblank2(input.base.materializationId, "Source base materialization id");
+    assertNonblank2(input.base.lastCommitId, "Source base commit id");
+    if (input.base.materializationId === input.materializationId) {
+      throw new MaterializationValidationError2("A source candidate cannot be its own base.");
+    }
+  }
+}
+function assertSourceWriteIdentity2(input) {
+  assertSourceProject2(input);
+  assertNonblank2(input.materializationId, "Source materialization id");
+  assertSourceExecutionIdentity2(input.execution.projectionRunId, input.execution.executionToken);
+}
+function assertSourceProject2(input) {
+  assertNonblank2(input.projectId, "Source project id");
+  assertNonblank2(input.source.projectionId, "Source projection id");
+}
+function assertSourceExecutionIdentity2(runId, token) {
+  assertNonblank2(runId, "Source projection run id");
+  assertNonblank2(token, "Source execution token");
+}
+function assertSourceCandidateOwner2(manifest, execution) {
   if (manifest.projectionRunId !== execution.projectionRunId || manifest.executionToken !== execution.executionToken) {
-    throw sourceConflict(`Source materialization '${manifest.materializationId}' is owned by another execution.`);
+    throw sourceConflict2(`Source materialization '${manifest.materializationId}' is owned by another execution.`);
   }
 }
-function assertSourceStagedRow(projectionKind, row) {
+function assertSourceStagedRow2(projectionKind, row) {
   if (!Number.isSafeInteger(row.stagingOrdinal) || row.stagingOrdinal < 0) {
-    throw new MaterializationValidationError("Source staging ordinal must be a nonnegative safe integer.");
+    throw new MaterializationValidationError2("Source staging ordinal must be a nonnegative safe integer.");
   }
   assertSourceEntity(row.root, "Source root");
   assertSourceEntity(row.assertion, "Source assertion");
   if (projectionKind === "object" && row.root.kind !== "object") {
-    throw new MaterializationValidationError("Object projection source rows require an object root.");
+    throw new MaterializationValidationError2("Object projection source rows require an object root.");
   }
   if (projectionKind === "link" && (row.root.kind !== "link" || row.assertion.kind !== "link")) {
-    throw new MaterializationValidationError("Link projection source rows require a link root and link assertion.");
+    throw new MaterializationValidationError2("Link projection source rows require a link root and link assertion.");
   }
 }
 function assertSourceEntity(entity, label) {
   if (entity.kind === "object") {
-    assertNonblank(entity.ref.objectTypeId, `${label} object type id`);
-    assertNonblank(entity.ref.primaryId, `${label} primary id`);
+    assertNonblank2(entity.ref.objectTypeId, `${label} object type id`);
+    assertNonblank2(entity.ref.primaryId, `${label} primary id`);
     return;
   }
-  assertNonblank(entity.ref.source.objectTypeId, `${label} source object type id`);
-  assertNonblank(entity.ref.source.primaryId, `${label} source primary id`);
-  assertNonblank(entity.ref.linkId, `${label} link id`);
-  assertNonblank(entity.ref.target.objectTypeId, `${label} target object type id`);
-  assertNonblank(entity.ref.target.primaryId, `${label} target primary id`);
+  assertNonblank2(entity.ref.source.objectTypeId, `${label} source object type id`);
+  assertNonblank2(entity.ref.source.primaryId, `${label} source primary id`);
+  assertNonblank2(entity.ref.linkId, `${label} link id`);
+  assertNonblank2(entity.ref.target.objectTypeId, `${label} target object type id`);
+  assertNonblank2(entity.ref.target.primaryId, `${label} target primary id`);
 }
-function sourceEntityColumns(entity) {
+function sourceEntityColumns2(entity) {
   if (entity.kind === "object") {
     return {
       objectTypeId: entity.ref.objectTypeId,
@@ -874,20 +913,20 @@ function sourceEntityColumns(entity) {
     targetPrimaryId: entity.ref.target.primaryId
   };
 }
-function utf8SortKey(canonicalKey) {
+function utf8SortKey2(canonicalKey) {
   let key = "";
   for (const byte of new TextEncoder().encode(canonicalKey)) {
     key += byte.toString(16).padStart(2, "0");
   }
   return key;
 }
-function isExactStagingManifest(row, input) {
-  return row.status === "staging" && row.executionToken === input.execution.executionToken && row.projectionRunId === input.execution.projectionRunId && row.projectionKind === input.projectionKind && row.protocol === input.protocol && row.createdAt === input.createdAt && row.datasetVersion.datasetId === input.datasetVersion.datasetId && row.datasetVersion.versionId === input.datasetVersion.versionId && row.datasetVersion.createdAt === input.datasetVersion.createdAt && row.projectionRevision === input.projectionRevision && row.ownershipHash === input.ownershipHash && row.ontologyRevision === input.ontologyRevision;
+function isExactStagingManifest2(row, input) {
+  return row.status === "staging" && row.executionToken === input.execution.executionToken && row.projectionRunId === input.execution.projectionRunId && row.projectionKind === input.projectionKind && row.protocol === input.protocol && row.createdAt === input.createdAt && row.datasetVersion.datasetId === input.datasetVersion.datasetId && row.datasetVersion.versionId === input.datasetVersion.versionId && row.datasetVersion.createdAt === input.datasetVersion.createdAt && row.projectionRevision === input.projectionRevision && row.ownershipHash === input.ownershipHash && row.base?.materializationId === input.base?.materializationId && row.base?.lastCommitId === input.base?.lastCommitId && row.ontologyRevision === input.ontologyRevision;
 }
-function sourceConflict(message) {
-  return new MaterializationConflictError("source-materialization", message);
+function sourceConflict2(message) {
+  return new MaterializationConflictError2("source-materialization", message);
 }
 
-export { ONTOLOGY_MATERIALIZATION_EVENT_KIND_ORDER, materializationEventKindOrdinal, sha256Canonical, createRequestHash, createCommitId, createEventId, assertNonblank, assertPositiveInteger, assertNonnegativeInteger, assertTimestamp, invalidCorrelation, materializationApplyPhase, assertPageRows, materializationChunkRows, materializationPlanItems, assertWorkRecord, workUniquenessKey, comparePlanWork, compareCardinalityWork, compareEventWork, assertPlanChunkCorrelations, assertMaterializationHeader, startScopeAccumulator, appendScopeSnapshot, finishScopeAccumulator, linkSlotOverrideValue, ProviderMaterializationSessionState, ProviderMaterializationTransactionLifecycle, prepareMaterializationWork, correlateMaterializationChunk, assertMaterializationFinalizationCorrelation, assertMaterializationLaneCompletion, assertSourceActivationCorrelation, uniqueSorted, sameNonnegativeCounts, effectiveConflict, materializationWorkColumns, duplicateMaterializationWork, canonicalJson, originColumns, originWhere, objectRefFromColumns, linkRefFromColumns, sourceEntityKey, sourceStageRows, sourceStageRow, reconcileSourceStageRows, sourceMaterializationIdentity, assertSourceBeginInput, assertSourceWriteIdentity, assertSourceProject, assertSourceExecutionIdentity, assertSourceCandidateOwner, assertSourceStagedRow, sourceEntityColumns, utf8SortKey, isExactStagingManifest, sourceConflict };
+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, materializationWorkColumns2, duplicateMaterializationWork2, canonicalJson2, originColumns2, originWhere2, objectRefFromColumns2, linkRefFromColumns2, sourceEntityKey2, sourceStageRows2, sourceStageRow2, sourceStageRoots2, reconcileSourceStageRows2, sourceMaterializationIdentity2, assertSourceBeginInput2, assertSourceWriteIdentity2, assertSourceProject2, assertSourceExecutionIdentity2, assertSourceCandidateOwner2, assertSourceStagedRow2, sourceEntityColumns2, utf8SortKey2, isExactStagingManifest2, sourceConflict2 };
 
-//# debugId=3C98B197EE41F0FE64756E2164756E21
+//# debugId=77BCC37F910FF7FD64756E2164756E21