@sixb/core 0.1.8 → 0.1.10

package/dist/{chunk-f26bck4t.js → chunk-ftv470j8.js}

@@ -1,75 +1,75 @@
 // @bun
 import {
-  parseDatasetTimestamp
-} from "./chunk-96swp2wd.js";
+  normalizeObjectRef2,
+  normalizeLinkRef2,
+  objectRefKey2,
+  linkRefKey2,
+  projectionEntityKey2,
+  linkOwnershipKey,
+  telemetryOwnershipKey,
+  telemetryPointKey2,
+  utf8JsonByteLength,
+  objectRefSortKey2,
+  linkRefSortKey2,
+  linkScopeKey,
+  linkScopeSortKey2,
+  telemetryPointSortKey2,
+  compareObjectRefs2,
+  compareLinkRefs2
+} from "./chunk-c5rkjrgp.js";
 import {
-  ensureExecutionRecord,
-  executionRecordInputFromRuntime
-} from "./chunk-k522z7v6.js";
+  normalizeObjectProperties2,
+  normalizeSchemaValue2,
+  assertKnownProperties2,
+  validateObjectProperties2,
+  validatePropertyValue2,
+  normalizeLinkProperties2,
+  validateLinkProperties2,
+  validateTelemetryUnit2
+} from "./chunk-ms2tmn1k.js";
 import {
-  isStorageSerializationFailure
-} from "./chunk-sbzzr4kx.js";
+  materializationEventKindOrdinal2,
+  sha256Canonical2,
+  createRequestHash2,
+  createCommitId2,
+  createEventId2,
+  materializationApplyPhase
+} from "./chunk-gqh45d2n.js";
 import {
-  createCommitId,
-  createEventId,
-  createRequestHash,
-  materializationApplyPhase,
-  materializationEventKindOrdinal,
-  sha256Canonical
-} from "./chunk-8tsf6dmc.js";
+  ProjectionValidationError2,
+  validateProjectionsAtStartup,
+  isProjectionDefinition2,
+  resolveExecutionScopeAuthorization
+} from "./chunk-dz5h08xv.js";
 import {
-  assertPinnedDatasetWatermark
-} from "./chunk-9dzba0f2.js";
+  isStorageSerializationFailure2
+} from "./chunk-8vj0rjgs.js";
 import {
-  compareLinkRefs,
-  compareObjectRefs,
-  linkOwnershipKey,
-  linkRefKey,
-  linkRefSortKey,
-  linkScopeKey,
-  linkScopeSortKey,
-  normalizeLinkRef,
-  normalizeObjectRef,
-  objectRefKey,
-  objectRefSortKey,
-  projectionEntityKey,
-  telemetryOwnershipKey,
-  telemetryPointKey,
-  telemetryPointSortKey,
-  utf8JsonByteLength
-} from "./chunk-dbc80ad7.js";
+  parseDatasetTimestamp2
+} from "./chunk-z667z3sg.js";
 import {
-  MaterializationCancellationError,
-  MaterializationConflictError,
-  MaterializationObjectNotFoundError,
-  MaterializationValidationError
-} from "./chunk-ry24jbr1.js";
+  executionRecordInputFromRuntime,
+  ensureExecutionRecord2
+} from "./chunk-17kfctj6.js";
 import {
-  ProjectionValidationError,
-  isProjectionDefinition,
-  resolveExecutionScopeAuthorization,
-  validateProjectionsAtStartup
-} from "./chunk-p1x242ad.js";
+  assertPinnedDatasetWatermark2
+} from "./chunk-wjasrj67.js";
 import {
-  assertKnownProperties,
-  normalizeLinkProperties,
-  normalizeObjectProperties,
-  normalizeSchemaValue,
-  validateLinkProperties,
-  validateObjectProperties,
-  validatePropertyValue,
-  validateTelemetryUnit
-} from "./chunk-h0k55pc7.js";
+  MaterializationValidationError2,
+  MaterializationObjectNotFoundError2,
+  MaterializationCancellationError2,
+  MaterializationConflictError2
+} from "./chunk-yv79ncbv.js";
 import {
-  assertJsonValue,
-  cloneJsonValue,
-  compareStrings,
-  stableJsonStringify
-} from "./chunk-n6jxh8sw.js";
+  assertJsonValue2,
+  cloneJsonValue2,
+  stableJsonStringify2,
+  compareStrings
+} from "./chunk-wy0qdqfm.js";
 // src/projections/revision.ts
-function computeOntologyRevision(ontology) {
+function computeOntologyRevision2(ontology) {
   const referencedValueTypeIds = collectOntologyValueTypeDependencies(ontology);
-  return sha256Canonical({
+  return sha256Canonical2({
     objectTypes: normalizeOntologyObjectTypes(ontology),
     valueTypes: normalizeOntologyValueTypes(ontology, referencedValueTypeIds)
   });
@@ -143,20 +143,20 @@ function collectReferencedValueTypeIds(schema, valueTypeIds) {
     collectReferencedValueTypeIds(field.schema, valueTypeIds);
   }
 }
-function computeProjectionRevision(projection, dataset) {
+function computeProjectionRevision2(projection, dataset) {
   const referencedColumns = projectionColumns(projection);
   const columns = dataset.schema.columns.filter((column) => referencedColumns.has(column.name)).map((column) => ({
     name: column.name,
     type: column.type,
     nullable: column.nullable ?? false
   })).sort((left, right) => compareStrings(left.name, right.name));
-  return sha256Canonical({
+  return sha256Canonical2({
     mapping: normalizeProjectionDefinition(projection),
     columns
   });
 }
-function computeProjectionOwnershipHash(ownership) {
-  return sha256Canonical(ownership);
+function computeProjectionOwnershipHash2(ownership) {
+  return sha256Canonical2(ownership);
 }
 function normalizeProjectionDefinition(projection) {
   if (projection._tag === "ObjectProjectionDefinition") {
@@ -282,7 +282,7 @@ function normalizeField(field) {
 }
 
 // src/projections/registry.ts
-class ProjectionRegistry {
+class ProjectionRegistry2 {
   ontologyRevision;
   objectProjections;
   linkProjections;
@@ -297,8 +297,8 @@ class ProjectionRegistry {
     const linkProjections = [];
     const telemetryProjections = [];
     for (const projection of input.projections) {
-      if (!isProjectionDefinition(projection)) {
-        throw new ProjectionValidationError("[Sixb] Invalid projection definition.");
+      if (!isProjectionDefinition2(projection)) {
+        throw new ProjectionValidationError2("[Sixb] Invalid projection definition.");
       }
       switch (projection._tag) {
         case "ObjectProjectionDefinition":
@@ -326,7 +326,7 @@ class ProjectionRegistry {
       linkProjections: this.linkProjections,
       telemetryProjections: this.telemetryProjections
     }, input.ontology, input.datasetsById);
-    this.ontologyRevision = computeOntologyRevision(input.ontology);
+    this.ontologyRevision = computeOntologyRevision2(input.ontology);
     const dispatchDescriptors = [];
     for (const record of validated.objectProjections) {
       const resolved = createResolvedProjection(record);
@@ -373,15 +373,15 @@ class ProjectionRegistry {
     const descriptor = this.dispatchById.get(projectionId);
     if (descriptor)
       return descriptor;
-    throw new ProjectionValidationError(`[Sixb] Unknown projection '${projectionId}'.`);
+    throw new ProjectionValidationError2(`[Sixb] Unknown projection '${projectionId}'.`);
   }
   resolveSource(projectionId) {
     const resolved = this.sourceById.get(projectionId);
     if (!resolved) {
       if (this.telemetryById.has(projectionId)) {
-        throw new ProjectionValidationError(`[Sixb] Projection '${projectionId}' is telemetry-only and cannot replace source state.`);
+        throw new ProjectionValidationError2(`[Sixb] Projection '${projectionId}' is telemetry-only and cannot replace source state.`);
       }
-      throw new ProjectionValidationError(`[Sixb] Unknown source projection '${projectionId}'.`);
+      throw new ProjectionValidationError2(`[Sixb] Unknown source projection '${projectionId}'.`);
     }
     return resolved;
   }
@@ -389,9 +389,9 @@ class ProjectionRegistry {
     const resolved = this.telemetryById.get(projectionId);
     if (!resolved) {
       if (this.sourceById.has(projectionId)) {
-        throw new ProjectionValidationError(`[Sixb] Projection '${projectionId}' does not own a telemetry source.`);
+        throw new ProjectionValidationError2(`[Sixb] Projection '${projectionId}' does not own a telemetry source.`);
       }
-      throw new ProjectionValidationError(`[Sixb] Unknown telemetry projection '${projectionId}'.`);
+      throw new ProjectionValidationError2(`[Sixb] Unknown telemetry projection '${projectionId}'.`);
     }
     return resolved;
   }
@@ -417,7 +417,7 @@ function assertUniqueProjectionIds(projections) {
   const ids = new Set;
   for (const projection of projections) {
     if (ids.has(projection.id)) {
-      throw new ProjectionValidationError(`[Sixb] Duplicate projection id: ${projection.id}`);
+      throw new ProjectionValidationError2(`[Sixb] Duplicate projection id: ${projection.id}`);
     }
     ids.add(projection.id);
   }
@@ -427,8 +427,8 @@ function createResolvedProjection(validated) {
   return deepFreeze({
     projectionId: definition.id,
     datasetId: definition.datasetId,
-    projectionRevision: computeProjectionRevision(definition, dataset),
-    ownershipHash: computeProjectionOwnershipHash(ownership),
+    projectionRevision: computeProjectionRevision2(definition, dataset),
+    ownershipHash: computeProjectionOwnershipHash2(ownership),
     ownership,
     definition
   });
@@ -504,7 +504,7 @@ function resolveMaterializationBatching(overrides = {}) {
   const resolved = { ...DEFAULT_MATERIALIZATION_BATCHING, ...overrides };
   for (const [name, value] of Object.entries(resolved)) {
     if (!Number.isSafeInteger(value) || value <= 0) {
-      throw new MaterializationValidationError(`Materialization batching '${name}' must be a positive safe integer.`);
+      throw new MaterializationValidationError2(`Materialization batching '${name}' must be a positive safe integer.`);
     }
   }
   return Object.freeze(resolved);
@@ -512,10 +512,10 @@ function resolveMaterializationBatching(overrides = {}) {
 
 // src/materializer/shared/identity.ts
 import { randomUUID } from "crypto";
-function createActionIdempotencyKey(runId) {
+function createActionIdempotencyKey2(runId) {
   return `action:${runId}:edits`;
 }
-function createRuntimeIdempotencyKey(requestId) {
+function createRuntimeIdempotencyKey2(requestId) {
   return `runtime:${requestId}`;
 }
 function projectionIdentityTuple(input) {
@@ -531,47 +531,47 @@ function projectionIdentityTuple(input) {
     input.ownershipHash
   ];
 }
-function createProjectionIdempotencyKey(identity) {
-  return `projection:replace:${sha256Canonical(projectionIdentityTuple(identity))}`;
+function createProjectionIdempotencyKey2(identity) {
+  return `projection:replace:${sha256Canonical2(projectionIdentityTuple(identity))}`;
 }
-function createRuntimeTelemetryIdempotencyKey(requestId) {
+function createRuntimeTelemetryIdempotencyKey2(requestId) {
   return `telemetry:runtime:${requestId}`;
 }
-function createProjectionTelemetryIdempotencyKey(identity, batchOrdinal) {
-  return `telemetry:projection:${sha256Canonical([
+function createProjectionTelemetryIdempotencyKey2(identity, batchOrdinal) {
+  return `telemetry:projection:${sha256Canonical2([
     ...projectionIdentityTuple(identity),
     batchOrdinal
   ])}`;
 }
-function createCommitIdentity(input) {
+function createCommitIdentity2(input) {
   return Object.freeze({
     idempotencyKey: input.idempotencyKey,
-    requestHash: createRequestHash(input.normalizedCallerIntent),
-    commitId: createCommitId(input.projectId, input.idempotencyKey)
+    requestHash: createRequestHash2(input.normalizedCallerIntent),
+    commitId: createCommitId2(input.projectId, input.idempotencyKey)
   });
 }
-function timestampCommitIdentity(identity, now = new Date) {
+function timestampCommitIdentity2(identity, now = new Date) {
   const committedAt = new Date(now);
   if (Number.isNaN(committedAt.getTime())) {
-    throw new MaterializationValidationError("Materialization commit time must be a valid date.");
+    throw new MaterializationValidationError2("Materialization commit time must be a valid date.");
   }
   return Object.freeze({
     ...identity,
     committedAt: committedAt.toISOString()
   });
 }
-function createTimedCommitIdentity(input) {
-  return timestampCommitIdentity(createCommitIdentity({
+function createTimedCommitIdentity2(input) {
+  return timestampCommitIdentity2(createCommitIdentity2({
     projectId: input.projectId,
     idempotencyKey: input.idempotencyKey,
     normalizedCallerIntent: input.normalizedCallerIntent
   }), input.now);
 }
-function createProjectionMaterializationId() {
+function createProjectionMaterializationId2() {
   return randomUUID();
 }
-function createLinkScopeFingerprint(links) {
-  return sha256Canonical([...links].sort((left, right) => compareLinkRefs(left.ref, right.ref)).map((link) => ({
+function createLinkScopeFingerprint2(links) {
+  return sha256Canonical2([...links].sort((left, right) => compareLinkRefs2(left.ref, right.ref)).map((link) => ({
     ref: link.ref,
     properties: link.properties ?? {},
     lastCommitId: link.lastCommitId
@@ -581,18 +581,18 @@ function createLinkScopeFingerprint(links) {
 // src/materializer/context.ts
 function createMaterializerContext(input) {
   if (input.projectId.trim().length === 0) {
-    throw new MaterializationValidationError("Materializer project id must be nonblank.");
+    throw new MaterializationValidationError2("Materializer project id must be nonblank.");
   }
   if (!input.storage?.ontology) {
-    throw new MaterializationValidationError("Storage does not provide ontology capabilities.");
+    throw new MaterializationValidationError2("Storage does not provide ontology capabilities.");
   }
-  if (computeOntologyRevision(input.ontology) !== input.projections.ontologyRevision) {
-    throw new MaterializationValidationError("Materializer Ontology does not match the Ontology pinned by its projection registry.");
+  if (computeOntologyRevision2(input.ontology) !== input.projections.ontologyRevision) {
+    throw new MaterializationValidationError2("Materializer Ontology does not match the Ontology pinned by its projection registry.");
   }
   const dependencies = input.dependencies ?? {};
   const maxSerializationRetries = dependencies.maxSerializationRetries ?? 2;
   if (!Number.isSafeInteger(maxSerializationRetries) || maxSerializationRetries < 0) {
-    throw new MaterializationValidationError("Materializer serialization retry count must be a nonnegative safe integer.");
+    throw new MaterializationValidationError2("Materializer serialization retry count must be a nonnegative safe integer.");
   }
   return {
     projectId: input.projectId,
@@ -601,7 +601,7 @@ function createMaterializerContext(input) {
     storage: input.storage,
     batching: resolveMaterializationBatching(dependencies.batching),
     clock: dependencies.clock ?? (() => new Date),
-    materializationId: dependencies.materializationId ?? createProjectionMaterializationId,
+    materializationId: dependencies.materializationId ?? createProjectionMaterializationId2,
     maxSerializationRetries,
     ...dependencies.onSerializationRetry !== undefined ? { onSerializationRetry: dependencies.onSerializationRetry } : {},
     ...dependencies.observeCoreBuffer !== undefined ? { observeCoreBuffer: dependencies.observeCoreBuffer } : {}
@@ -617,10 +617,10 @@ async function replayCommitRecord(context, identity, executionId, storage = cont
   if (!existing)
     return null;
   if (existing.requestHash !== identity.requestHash) {
-    throw new MaterializationConflictError("idempotency", `Idempotency key '${identity.idempotencyKey}' was reused with different intent.`);
+    throw new MaterializationConflictError2("idempotency", `Idempotency key '${identity.idempotencyKey}' was reused with different intent.`);
   }
   if (existing.executionId !== executionId) {
-    throw new MaterializationConflictError("idempotency", `Idempotency key '${identity.idempotencyKey}' belongs to execution '${existing.executionId}', not '${executionId}'.`);
+    throw new MaterializationConflictError2("idempotency", `Idempotency key '${identity.idempotencyKey}' belongs to execution '${existing.executionId}', not '${executionId}'.`);
   }
   return existing;
 }
@@ -635,7 +635,7 @@ async function withSerializationRetry(context, run) {
     try {
       return await run();
     } catch (error) {
-      if (!isStorageSerializationFailure(error) || attempt >= context.maxSerializationRetries) {
+      if (!isStorageSerializationFailure2(error) || attempt >= context.maxSerializationRetries) {
         throw error;
       }
       context.onSerializationRetry?.(attempt + 1, error);
@@ -660,30 +660,30 @@ function prepareMaterializerExecution(projectId, scope) {
   return { ...base, actor: authorization.context.principal };
 }
 function ensureMaterializerExecution(executions, execution) {
-  return ensureExecutionRecord(executions, execution.record);
+  return ensureExecutionRecord2(executions, execution.record);
 }
 function assertRuntimeMutationExecution(execution) {
   if (execution.scope.execution.executor.type !== "kernel")
     return;
-  throw new MaterializationValidationError(`Kernel execution '${execution.executionId}' cannot enter the runtime mutation boundary.`);
+  throw new MaterializationValidationError2(`Kernel execution '${execution.executionId}' cannot enter the runtime mutation boundary.`);
 }
 function assertTrustedPrimitiveMutationExecution(execution, primitive) {
   const executor = execution.scope.execution.executor;
   if (executor.type === "primitive" && executor.kind === primitive.kind && executor.id === primitive.id && executor.runId === primitive.runId) {
     return;
   }
-  throw new MaterializationConflictError("run-correlation", `Execution '${execution.executionId}' does not own ${primitive.kind} run '${primitive.runId}'.`);
+  throw new MaterializationConflictError2("run-correlation", `Execution '${execution.executionId}' does not own ${primitive.kind} run '${primitive.runId}'.`);
 }
 function assertMaterializerRunExecution(execution, runExecutionId, label) {
   if (runExecutionId === execution.executionId)
     return;
-  throw new MaterializationConflictError("run-correlation", `${label} belongs to execution '${runExecutionId}', not '${execution.executionId}'.`);
+  throw new MaterializationConflictError2("run-correlation", `${label} belongs to execution '${runExecutionId}', not '${execution.executionId}'.`);
 }
 
 // src/materializer/effective/build-events.ts
 function buildObjectMaterializationEventDraft(input) {
   const draft = buildObjectEventDraft(input, input.change);
-  return orderedDraft(objectRefSortKey(input.change.ref), draft);
+  return orderedDraft(objectRefSortKey2(input.change.ref), draft);
 }
 function buildObjectEventDraft(context, change) {
   const base = eventDraftBase(context);
@@ -722,7 +722,7 @@ function objectEventType(change) {
 }
 function buildLinkMaterializationEventDraft(input) {
   const draft = buildLinkEventDraft(input, input.change);
-  return orderedDraft(linkRefSortKey(input.change.ref), draft);
+  return orderedDraft(linkRefSortKey2(input.change.ref), draft);
 }
 function buildLinkEventDraft(context, change) {
   const base = eventDraftBase(context);
@@ -763,7 +763,7 @@ function linkEventType(change) {
 }
 function buildTelemetryMaterializationEventDraft(input) {
   const draft = buildTelemetryEventDraft(input, input.point);
-  return orderedDraft(telemetryPointSortKey(input.point.series, input.point.at), draft);
+  return orderedDraft(telemetryPointSortKey2(input.point.series, input.point.at), draft);
 }
 function buildTelemetryEventDraft(context, point) {
   const base = eventDraftBase(context);
@@ -801,14 +801,14 @@ function eventDraftBase(context) {
 }
 function orderedDraft(sortKey, draft) {
   return {
-    kindRank: materializationEventKindOrdinal(draft.type),
+    kindRank: materializationEventKindOrdinal2(draft.type),
     sortKey,
     draft
   };
 }
 function sequenceMaterializationEvent(projectId, commitId, commitOrdinal, draft) {
   const sequence = {
-    id: createEventId(projectId, commitId, commitOrdinal),
+    id: createEventId2(projectId, commitId, commitOrdinal),
     commitOrdinal
   };
   return { ...draft, ...sequence };
@@ -914,7 +914,7 @@ function appendItem(chunk, item) {
 
 // src/materializer/execution/work-records.ts
 function appendObjectOverrideWork(items, working, identity) {
-  if (stableJsonStringify(working.originalOverride?.value ?? null) === stableJsonStringify(working.override) && stableJsonStringify(working.originalEditedAt) === stableJsonStringify(working.editedAt)) {
+  if (stableJsonStringify2(working.originalOverride?.value ?? null) === stableJsonStringify2(working.override) && stableJsonStringify2(working.originalEditedAt) === stableJsonStringify2(working.editedAt)) {
     return;
   }
   if (working.override) {
@@ -937,7 +937,7 @@ function appendObjectOverrideWork(items, working, identity) {
   }
 }
 function appendLinkEdgeOverrideWork(items, working, identity) {
-  if (stableJsonStringify(working.originalOverride?.value ?? null) === stableJsonStringify(working.override)) {
+  if (stableJsonStringify2(working.originalOverride?.value ?? null) === stableJsonStringify2(working.override)) {
     return;
   }
   if (working.override) {
@@ -959,7 +959,7 @@ function appendLinkEdgeOverrideWork(items, working, identity) {
   }
 }
 function appendLinkSlotOverrideWork(items, working, identity) {
-  if (stableJsonStringify(working.originalOverride?.value ?? null) === stableJsonStringify(working.override)) {
+  if (stableJsonStringify2(working.originalOverride?.value ?? null) === stableJsonStringify2(working.override)) {
     return;
   }
   if (working.override) {
@@ -1100,7 +1100,7 @@ async function drainStagedWork(context, storage, session, signal) {
   })) {
     for (const record of page.records) {
       if (record.kind !== "plan") {
-        throw new MaterializationValidationError("Provider returned non-plan apply work.");
+        throw new MaterializationValidationError2("Provider returned non-plan apply work.");
       }
       if (phase !== null && record.applyPhase !== phase)
         await flush();
@@ -1124,7 +1124,7 @@ async function validateStagedCardinality(context, storage, session, signal) {
     throwIfAborted(signal);
     for (const record of page.records) {
       if (record.kind !== "cardinality") {
-        throw new MaterializationValidationError("Provider returned non-cardinality cardinality work.");
+        throw new MaterializationValidationError2("Provider returned non-cardinality cardinality work.");
       }
       if (record.view !== currentView || record.scopeSortKey !== currentScope) {
         currentView = record.view;
@@ -1134,7 +1134,7 @@ async function validateStagedCardinality(context, storage, session, signal) {
       if (!record.occupied)
         continue;
       if (occupant && occupant !== record.linkSortKey) {
-        throw new MaterializationValidationError(record.view === "candidate" ? `Projection source scope '${record.ref.source.objectTypeId}.${record.ref.linkId}' has cardinality one.` : `Link scope '${record.ref.source.objectTypeId}.${record.ref.linkId}' has cardinality one.`);
+        throw new MaterializationValidationError2(record.view === "candidate" ? `Projection source scope '${record.ref.source.objectTypeId}.${record.ref.linkId}' has cardinality one.` : `Link scope '${record.ref.source.objectTypeId}.${record.ref.linkId}' has cardinality one.`);
       }
       occupant = record.linkSortKey;
     }
@@ -1150,7 +1150,7 @@ async function drainStagedEvents(context, storage, session, identity, signal) {
     const items = [];
     for (const record of page.records) {
       if (record.kind !== "event") {
-        throw new MaterializationValidationError("Provider returned non-event event work.");
+        throw new MaterializationValidationError2("Provider returned non-event event work.");
       }
       const event = sequenceMaterializationEvent(context.projectId, identity.commitId, ordinal++, record.draft);
       items.push(outboxItem(event, identity.committedAt));
@@ -1161,42 +1161,42 @@ async function drainStagedEvents(context, storage, session, identity, signal) {
 }
 
 // src/materializer/shared/normalize.ts
-function normalizeJsonProperties(properties, label = "Properties") {
+function normalizeJsonProperties2(properties, label = "Properties") {
   if (typeof properties !== "object" || properties === null || Array.isArray(properties)) {
-    throw new MaterializationValidationError(`${label} must be a JSON object.`);
+    throw new MaterializationValidationError2(`${label} must be a JSON object.`);
   }
   const normalized = {};
   for (const propertyId of Object.keys(properties).sort(compareStrings)) {
     if (propertyId.trim().length === 0) {
-      throw new MaterializationValidationError(`${label} contains a blank property id.`);
+      throw new MaterializationValidationError2(`${label} contains a blank property id.`);
     }
     const value = properties[propertyId];
     try {
-      assertJsonValue(value, `${label}.${propertyId}`);
+      assertJsonValue2(value, `${label}.${propertyId}`);
     } catch (error) {
-      throw new MaterializationValidationError(error instanceof Error ? error.message : `${label}.${propertyId} must be JSON.`);
+      throw new MaterializationValidationError2(error instanceof Error ? error.message : `${label}.${propertyId} must be JSON.`);
     }
-    normalized[propertyId] = cloneJsonValue(value);
+    normalized[propertyId] = cloneJsonValue2(value);
   }
   return Object.freeze(normalized);
 }
 function normalizeNonblank(value, label) {
   if (typeof value !== "string" || value.trim().length === 0) {
-    throw new MaterializationValidationError(`${label} must be a nonblank string.`);
+    throw new MaterializationValidationError2(`${label} must be a nonblank string.`);
   }
   return value;
 }
 function normalizeTimestamp(value, label) {
   const milliseconds = Date.parse(value);
   if (!Number.isFinite(milliseconds)) {
-    throw new MaterializationValidationError(`${label} must be a valid timestamp.`);
+    throw new MaterializationValidationError2(`${label} must be a valid timestamp.`);
   }
   return new Date(milliseconds).toISOString();
 }
 function normalizeProjectionSourceTimestamp(value) {
-  const timestamp = parseDatasetTimestamp(value);
+  const timestamp = parseDatasetTimestamp2(value);
   if (!timestamp) {
-    throw new MaterializationValidationError("Projection source update timestamp must be a valid timestamp.");
+    throw new MaterializationValidationError2("Projection source update timestamp must be a valid timestamp.");
   }
   return timestamp.toISOString();
 }
@@ -1206,7 +1206,7 @@ function normalizePropertyIds(values, label) {
   for (const value of values) {
     normalizeNonblank(value, label);
     if (seen.has(value)) {
-      throw new MaterializationValidationError(`${label} contains duplicate '${value}'.`);
+      throw new MaterializationValidationError2(`${label} contains duplicate '${value}'.`);
     }
     seen.add(value);
     normalized.push(value);
@@ -1219,29 +1219,29 @@ function normalizeOperation(operation) {
     return Object.freeze({
       id: operation.id,
       kind: operation.kind,
-      ref: normalizeObjectRef(operation.ref),
-      properties: normalizeJsonProperties(operation.properties)
+      ref: normalizeObjectRef2(operation.ref),
+      properties: normalizeJsonProperties2(operation.properties)
     });
   }
   if (operation.kind === "object.patch") {
-    const set = normalizeJsonProperties(operation.set, `Operation '${operation.id}' set`);
+    const set = normalizeJsonProperties2(operation.set, `Operation '${operation.id}' set`);
     const unset = normalizePropertyIds(operation.unset, `Operation '${operation.id}' unset`);
     const reset = normalizePropertyIds(operation.reset, `Operation '${operation.id}' reset`);
     const setIds = new Set(Object.keys(set));
     for (const propertyId of [...unset, ...reset]) {
       if (setIds.has(propertyId)) {
-        throw new MaterializationValidationError(`Operation '${operation.id}' property '${propertyId}' appears in set and unset/reset.`);
+        throw new MaterializationValidationError2(`Operation '${operation.id}' property '${propertyId}' appears in set and unset/reset.`);
       }
     }
     for (const propertyId of unset) {
       if (reset.includes(propertyId)) {
-        throw new MaterializationValidationError(`Operation '${operation.id}' property '${propertyId}' appears in unset and reset.`);
+        throw new MaterializationValidationError2(`Operation '${operation.id}' property '${propertyId}' appears in unset and reset.`);
       }
     }
     return Object.freeze({
       id: operation.id,
       kind: operation.kind,
-      ref: normalizeObjectRef(operation.ref),
+      ref: normalizeObjectRef2(operation.ref),
       set,
       unset,
       reset
@@ -1251,44 +1251,44 @@ function normalizeOperation(operation) {
     return Object.freeze({
       id: operation.id,
       kind: operation.kind,
-      ref: normalizeObjectRef(operation.ref)
+      ref: normalizeObjectRef2(operation.ref)
     });
   }
   if (operation.kind === "link.upsert") {
     return Object.freeze({
       id: operation.id,
       kind: operation.kind,
-      ref: normalizeLinkRef(operation.ref),
-      ...operation.properties !== undefined ? { properties: normalizeJsonProperties(operation.properties) } : {}
+      ref: normalizeLinkRef2(operation.ref),
+      ...operation.properties !== undefined ? { properties: normalizeJsonProperties2(operation.properties) } : {}
     });
   }
   if (operation.kind === "link.delete" || operation.kind === "link.reset") {
     return Object.freeze({
       id: operation.id,
       kind: operation.kind,
-      ref: normalizeLinkRef(operation.ref)
+      ref: normalizeLinkRef2(operation.ref)
     });
   }
-  throw new MaterializationValidationError("Unknown ontology edit operation kind.");
+  throw new MaterializationValidationError2("Unknown ontology edit operation kind.");
 }
 function deduplicateExpectations(values, keyOf, label) {
   const byKey = new Map;
   for (const value of values) {
     const key = keyOf(value);
     const existing = byKey.get(key);
-    if (existing && stableJsonStringify(existing) !== stableJsonStringify(value)) {
-      throw new MaterializationValidationError(`${label} has contradictory values for ${key}.`);
+    if (existing && stableJsonStringify2(existing) !== stableJsonStringify2(value)) {
+      throw new MaterializationValidationError2(`${label} has contradictory values for ${key}.`);
     }
     byKey.set(key, value);
   }
   return Object.freeze([...byKey.entries()].sort(([left], [right]) => compareStrings(left, right)).map(([, value]) => value));
 }
 function normalizeExpectedObject(value) {
-  const ref = normalizeObjectRef(value.ref);
+  const ref = normalizeObjectRef2(value.ref);
   if (!value.exists)
     return Object.freeze({ ref, exists: false });
   if (!Number.isSafeInteger(value.version) || value.version < 1) {
-    throw new MaterializationValidationError("Expected object version must be a positive integer.");
+    throw new MaterializationValidationError2("Expected object version must be a positive integer.");
   }
   return Object.freeze({
     ref,
@@ -1298,7 +1298,7 @@ function normalizeExpectedObject(value) {
   });
 }
 function normalizeExpectedLink(value) {
-  const ref = normalizeLinkRef(value.ref);
+  const ref = normalizeLinkRef2(value.ref);
   if (!value.exists)
     return Object.freeze({ ref, exists: false });
   return Object.freeze({
@@ -1309,7 +1309,7 @@ function normalizeExpectedLink(value) {
 }
 function normalizeExpectedLinkScope(value) {
   return Object.freeze({
-    source: normalizeObjectRef(value.source),
+    source: normalizeObjectRef2(value.source),
     linkId: normalizeNonblank(value.linkId, "Expected link scope link id"),
     fingerprint: normalizeNonblank(value.fingerprint, "Expected link scope fingerprint")
   });
@@ -1318,34 +1318,34 @@ function normalizeOperationGroups(groups, operationIds) {
   const grouped = new Set;
   const normalized = groups.map((group) => {
     if (group.length < 2) {
-      throw new MaterializationValidationError("Operation groups must contain at least two operations.");
+      throw new MaterializationValidationError2("Operation groups must contain at least two operations.");
     }
     const positions = group.map((id) => {
       const position = operationIds.get(id);
       if (position === undefined) {
-        throw new MaterializationValidationError(`Operation group references unknown operation id '${id}'.`);
+        throw new MaterializationValidationError2(`Operation group references unknown operation id '${id}'.`);
       }
       if (grouped.has(id)) {
-        throw new MaterializationValidationError(`Operation id '${id}' appears in more than one operation group.`);
+        throw new MaterializationValidationError2(`Operation id '${id}' appears in more than one operation group.`);
       }
       grouped.add(id);
       return position;
     });
     const first = positions[0];
     if (positions.some((position, index) => position !== first + index)) {
-      throw new MaterializationValidationError("Operation groups must list a contiguous run in operation order.");
+      throw new MaterializationValidationError2("Operation groups must list a contiguous run in operation order.");
     }
     return { first, ids: Object.freeze([...group]) };
   });
   normalized.sort((left, right) => left.first - right.first);
   return Object.freeze(normalized.map(({ ids }) => ids));
 }
-function normalizeOntologyEditCommit(input) {
+function normalizeOntologyEditCommit2(input) {
   const operationIds = new Map;
   const operations = input.operations.map((operation, index) => {
     const normalized = normalizeOperation(operation);
     if (operationIds.has(normalized.id)) {
-      throw new MaterializationValidationError(`Duplicate operation id '${normalized.id}'.`);
+      throw new MaterializationValidationError2(`Duplicate operation id '${normalized.id}'.`);
     }
     operationIds.set(normalized.id, index);
     return normalized;
@@ -1376,8 +1376,8 @@ function normalizeOntologyEditCommit(input) {
     mode: "atomic",
     source,
     operations: Object.freeze(operations),
-    expectedObjects: deduplicateExpectations(expectedObjects, (value) => objectRefKey(value.ref), "Expected objects"),
-    expectedLinks: deduplicateExpectations(expectedLinks, (value) => linkRefKey(value.ref), "Expected links"),
+    expectedObjects: deduplicateExpectations(expectedObjects, (value) => objectRefKey2(value.ref), "Expected objects"),
+    expectedLinks: deduplicateExpectations(expectedLinks, (value) => linkRefKey2(value.ref), "Expected links"),
     expectedLinkScopes: deduplicateExpectations(expectedLinkScopes, (value) => linkScopeKey(value.source, value.linkId), "Expected link scopes")
   });
 }
@@ -1396,90 +1396,90 @@ function normalizePinnedDatasetVersion(version) {
 function normalizeProjectionRunId(runId) {
   return normalizeNonblank(runId, "Projection run id");
 }
-function normalizeProjectionExecution(input) {
+function normalizeProjectionExecution2(input) {
   return Object.freeze({
     projectionRunId: normalizeProjectionRunId(input.projectionRunId),
     executionToken: normalizeNonblank(input.executionToken, "Projection execution token")
   });
 }
 function normalizeProjectionEntity(entity) {
-  return entity.kind === "object" ? Object.freeze({ kind: "object", ref: normalizeObjectRef(entity.ref) }) : Object.freeze({ kind: "link", ref: normalizeLinkRef(entity.ref) });
+  return entity.kind === "object" ? Object.freeze({ kind: "object", ref: normalizeObjectRef2(entity.ref) }) : Object.freeze({ kind: "link", ref: normalizeLinkRef2(entity.ref) });
 }
 function normalizeProjectionAssertion(assertion) {
   return assertion.kind === "object" ? Object.freeze({
     kind: "object",
-    ref: normalizeObjectRef(assertion.ref),
-    properties: normalizeJsonProperties(assertion.properties),
+    ref: normalizeObjectRef2(assertion.ref),
+    properties: normalizeJsonProperties2(assertion.properties),
     ...assertion.sourceUpdatedAt !== undefined ? {
       sourceUpdatedAt: normalizeProjectionSourceTimestamp(assertion.sourceUpdatedAt)
     } : {}
   }) : Object.freeze({
     kind: "link",
-    ref: normalizeLinkRef(assertion.ref),
-    ...assertion.properties !== undefined ? { properties: normalizeJsonProperties(assertion.properties) } : {}
+    ref: normalizeLinkRef2(assertion.ref),
+    ...assertion.properties !== undefined ? { properties: normalizeJsonProperties2(assertion.properties) } : {}
   });
 }
-function normalizeProjectionSourceEntry(input) {
+function normalizeProjectionSourceEntry2(input) {
   const root = normalizeProjectionEntity(input.root);
   const seen = new Set;
   const assertions = input.assertions.map((assertion) => {
     const normalized = normalizeProjectionAssertion(assertion);
-    const key = projectionEntityKey(normalized);
+    const key = projectionEntityKey2(normalized);
     if (seen.has(key)) {
-      throw new MaterializationValidationError(`Projection entry repeats asserted entity ${key}.`);
+      throw new MaterializationValidationError2(`Projection entry repeats asserted entity ${key}.`);
     }
     seen.add(key);
     return normalized;
   });
-  const rootKey = projectionEntityKey(root);
+  const rootKey = projectionEntityKey2(root);
   if (!seen.has(rootKey)) {
-    throw new MaterializationValidationError(`Projection entry must contain an assertion matching root ${rootKey}.`);
+    throw new MaterializationValidationError2(`Projection entry must contain an assertion matching root ${rootKey}.`);
   }
   if (root.kind === "object") {
     const objectAssertions = assertions.filter((assertion) => assertion.kind === "object");
-    if (objectAssertions.length !== 1 || projectionEntityKey(objectAssertions[0]) !== rootKey) {
-      throw new MaterializationValidationError("An object projection root must contain exactly its matching object assertion plus links.");
+    if (objectAssertions.length !== 1 || projectionEntityKey2(objectAssertions[0]) !== rootKey) {
+      throw new MaterializationValidationError2("An object projection root must contain exactly its matching object assertion plus links.");
     }
     for (const assertion of assertions) {
-      if (assertion.kind === "link" && objectRefKey(assertion.ref.source) !== objectRefKey(root.ref)) {
-        throw new MaterializationValidationError("An object projection root may contain only links sourced from that root.");
+      if (assertion.kind === "link" && objectRefKey2(assertion.ref.source) !== objectRefKey2(root.ref)) {
+        throw new MaterializationValidationError2("An object projection root may contain only links sourced from that root.");
       }
     }
-  } else if (assertions.length !== 1 || assertions[0].kind !== "link" || projectionEntityKey(assertions[0]) !== rootKey) {
-    throw new MaterializationValidationError("A link projection root must contain exactly its matching link assertion.");
+  } else if (assertions.length !== 1 || assertions[0].kind !== "link" || projectionEntityKey2(assertions[0]) !== rootKey) {
+    throw new MaterializationValidationError2("A link projection root must contain exactly its matching link assertion.");
   }
   return Object.freeze({
     root,
-    assertions: Object.freeze(assertions.sort((left, right) => compareStrings(projectionEntityKey(left), projectionEntityKey(right))))
+    assertions: Object.freeze(assertions.sort((left, right) => compareStrings(projectionEntityKey2(left), projectionEntityKey2(right))))
   });
 }
 function normalizeTelemetrySeries(series) {
   return Object.freeze({
-    object: normalizeObjectRef(series.object),
+    object: normalizeObjectRef2(series.object),
     propertyId: normalizeNonblank(series.propertyId, "Telemetry property id")
   });
 }
 function normalizeTelemetryPoint(point) {
   try {
-    assertJsonValue(point.value, "Telemetry point value");
+    assertJsonValue2(point.value, "Telemetry point value");
   } catch (error) {
-    throw new MaterializationValidationError(error instanceof Error ? error.message : "Telemetry point value must be JSON.");
+    throw new MaterializationValidationError2(error instanceof Error ? error.message : "Telemetry point value must be JSON.");
   }
   return Object.freeze({
     series: normalizeTelemetrySeries(point.series),
-    value: cloneJsonValue(point.value),
+    value: cloneJsonValue2(point.value),
     ...point.unit !== undefined ? { unit: normalizeNonblank(point.unit, "Telemetry point unit") } : {},
     at: normalizeTimestamp(point.at, "Telemetry point timestamp")
   });
 }
-function normalizeTelemetryAppend(input) {
+function normalizeTelemetryAppend2(input) {
   const pointsByKey = new Map;
   for (const point of input.points) {
     const normalized = normalizeTelemetryPoint(point);
-    const key = telemetryPointKey(normalized.series, normalized.at);
+    const key = telemetryPointKey2(normalized.series, normalized.at);
     const existing = pointsByKey.get(key);
-    if (input.source.kind === "runtime" && existing && stableJsonStringify(existing) !== stableJsonStringify(normalized)) {
-      throw new MaterializationValidationError(`Conflicting telemetry points for ${key}.`);
+    if (input.source.kind === "runtime" && existing && stableJsonStringify2(existing) !== stableJsonStringify2(normalized)) {
+      throw new MaterializationValidationError2(`Conflicting telemetry points for ${key}.`);
     }
     pointsByKey.set(key, normalized);
   }
@@ -1491,7 +1491,7 @@ function normalizeTelemetryAppend(input) {
     kind: "projection",
     projection: normalizeProjectionSourceRef(input.source.projection),
     datasetVersion: normalizePinnedDatasetVersion(input.source.datasetVersion),
-    execution: normalizeProjectionExecution(input.source.execution),
+    execution: normalizeProjectionExecution2(input.source.execution),
     batchOrdinal: input.source.batchOrdinal,
     sourceRowCount: input.source.sourceRowCount,
     sourceRowsSkipped: input.source.sourceRowsSkipped,
@@ -1499,19 +1499,19 @@ function normalizeTelemetryAppend(input) {
   });
   if (source.kind === "projection") {
     if (!Number.isSafeInteger(source.batchOrdinal) || source.batchOrdinal < 0) {
-      throw new MaterializationValidationError("Telemetry projection batch ordinal must be a nonnegative safe integer.");
+      throw new MaterializationValidationError2("Telemetry projection batch ordinal must be a nonnegative safe integer.");
     }
     if (!Number.isSafeInteger(source.sourceRowCount) || source.sourceRowCount < 0) {
-      throw new MaterializationValidationError("Telemetry projection sourceRowCount must be a nonnegative safe integer.");
+      throw new MaterializationValidationError2("Telemetry projection sourceRowCount must be a nonnegative safe integer.");
     }
     if (!Number.isSafeInteger(source.sourceRowsSkipped) || source.sourceRowsSkipped < 0) {
-      throw new MaterializationValidationError("Telemetry projection sourceRowsSkipped must be a nonnegative safe integer.");
+      throw new MaterializationValidationError2("Telemetry projection sourceRowsSkipped must be a nonnegative safe integer.");
     }
     if (source.sourceRowsSkipped > source.sourceRowCount) {
-      throw new MaterializationValidationError("Telemetry projection sourceRowsSkipped cannot exceed sourceRowCount.");
+      throw new MaterializationValidationError2("Telemetry projection sourceRowsSkipped cannot exceed sourceRowCount.");
     }
     if (typeof source.inputExhausted !== "boolean") {
-      throw new MaterializationValidationError("Telemetry projection inputExhausted must be a boolean.");
+      throw new MaterializationValidationError2("Telemetry projection inputExhausted must be a boolean.");
     }
   }
   return Object.freeze({
@@ -1566,7 +1566,7 @@ function usableLinkSlotOverride(stored) {
     return stored.value;
   const { source, linkId } = stored.ref;
   const scopeLabel = JSON.stringify([source.objectTypeId, source.primaryId, linkId]);
-  throw new MaterializationConflictError("effective-state", `Cardinality-one link slot ${scopeLabel} could not be migrated automatically because it ` + "contains multiple legacy upsert overrides. Consolidate the stored overrides and clear " + "the migration conflict marker before materializing this scope.");
+  throw new MaterializationConflictError2("effective-state", `Cardinality-one link slot ${scopeLabel} could not be migrated automatically because it ` + "contains multiple legacy upsert overrides. Consolidate the stored overrides and clear " + "the migration conflict marker before materializing this scope.");
 }
 function resolveEffectiveObject(input) {
   const properties = resolveObjectAuthority(input.source, input.override, input.editedAt);
@@ -1680,7 +1680,7 @@ function resolveEffectiveLinkSlotMember(input) {
     override: input.override,
     endpointExists: input.endpointExists
   });
-  return resolved && linkRefKey(resolved.ref) === linkRefKey(input.ref) ? resolved : null;
+  return resolved && linkRefKey2(resolved.ref) === linkRefKey2(input.ref) ? resolved : null;
 }
 function resolvedLink(ref, properties) {
   if (properties === undefined)
@@ -1698,27 +1698,27 @@ function buildEditReadSet(ontology, operations) {
     if (isObjectOperation(operation)) {
       if (!ontology.getObjectTypeById(operation.ref.objectTypeId))
         continue;
-      objects.set(objectRefKey(operation.ref), operation.ref);
+      objects.set(objectRefKey2(operation.ref), operation.ref);
       if (operation.kind !== "object.patch") {
-        incidentObjects.set(objectRefKey(operation.ref), operation.ref);
+        incidentObjects.set(objectRefKey2(operation.ref), operation.ref);
       }
       continue;
     }
     if (!isKnownLinkRef(ontology, operation.ref))
       continue;
-    links.set(linkRefKey(operation.ref), operation.ref);
-    objects.set(objectRefKey(operation.ref.source), operation.ref.source);
-    objects.set(objectRefKey(operation.ref.target), operation.ref.target);
+    links.set(linkRefKey2(operation.ref), operation.ref);
+    objects.set(objectRefKey2(operation.ref.source), operation.ref.source);
+    objects.set(objectRefKey2(operation.ref.target), operation.ref.target);
     if (linkCardinality(ontology, operation.ref) === "one") {
       const scope = { source: operation.ref.source, linkId: operation.ref.linkId };
       scopes.set(linkScopeKey(scope.source, scope.linkId), scope);
     }
   }
   return {
-    objects: [...objects.values()].sort(compareObjectRefs),
-    links: [...links.values()].sort(compareLinkRefs),
+    objects: [...objects.values()].sort(compareObjectRefs2),
+    links: [...links.values()].sort(compareLinkRefs2),
     linkScopes: [...scopes.values()].sort((left, right) => linkScopeKey(left.source, left.linkId).localeCompare(linkScopeKey(right.source, right.linkId))),
-    incidentObjects: [...incidentObjects.values()].sort(compareObjectRefs),
+    incidentObjects: [...incidentObjects.values()].sort(compareObjectRefs2),
     points: []
   };
 }
@@ -1740,13 +1740,13 @@ function isObjectOperation(operation) {
 // src/materializer/edits/working-state.ts
 function mergeWorkingState(ontology, working, state) {
   for (const object of state.objects) {
-    if (!working.objects.has(objectRefKey(object.ref))) {
-      working.objects.set(objectRefKey(object.ref), workingObjectFromState(object));
+    if (!working.objects.has(objectRefKey2(object.ref))) {
+      working.objects.set(objectRefKey2(object.ref), workingObjectFromState(object));
     }
   }
   for (const link of state.links) {
-    if (linkCardinality(ontology, link.ref) !== "one" && !working.links.edges.has(linkRefKey(link.ref))) {
-      working.links.edges.set(linkRefKey(link.ref), workingLinkEdgeFromState(link));
+    if (linkCardinality(ontology, link.ref) !== "one" && !working.links.edges.has(linkRefKey2(link.ref))) {
+      working.links.edges.set(linkRefKey2(link.ref), workingLinkEdgeFromState(link));
     }
   }
   for (const scope of state.linkScopes) {
@@ -1799,8 +1799,8 @@ function resolveObject(ontology, working) {
   });
 }
 function resolveLinkEdge(ontology, working, objects) {
-  const source = objects.get(objectRefKey(working.ref.source));
-  const target = objects.get(objectRefKey(working.ref.target));
+  const source = objects.get(objectRefKey2(working.ref.source));
+  const target = objects.get(objectRefKey2(working.ref.target));
   return resolveEffectiveLink({
     ref: working.ref,
     source: working.source,
@@ -1815,7 +1815,7 @@ function resolveLinkSlot(ontology, working, objects) {
     source: working.source,
     override: working.override,
     endpointExists: (ref) => {
-      const object = objects.get(objectRefKey(ref));
+      const object = objects.get(objectRefKey2(ref));
       return Boolean(object && resolveObject(ontology, object));
     }
   });
@@ -1834,7 +1834,7 @@ function validateWorkingCardinality(slots) {
   for (const { effectiveCount, ref } of slots.values()) {
     if (effectiveCount <= 1)
       continue;
-    throw new MaterializationValidationError(`Link scope '${ref.source.objectTypeId}.${ref.linkId}' has cardinality one.`);
+    throw new MaterializationValidationError2(`Link scope '${ref.source.objectTypeId}.${ref.linkId}' has cardinality one.`);
   }
 }
 
@@ -1848,7 +1848,7 @@ async function loadEditWorkingState(context, storage, session, operations) {
     }
   };
   const readSet = buildEditReadSet(context.ontology, operations);
-  const explicitLinkKeys = new Set(readSet.links.map(linkRefKey));
+  const explicitLinkKeys = new Set(readSet.links.map(linkRefKey2));
   const incidentLinks = new Map;
   const loadedState = {
     objects: state.objects,
@@ -1857,7 +1857,7 @@ async function loadEditWorkingState(context, storage, session, operations) {
       slots: state.links.slots
     }
   };
-  const revivingObjects = new Set(operations.filter(isRevivingObjectOperation).map((operation) => objectRefKey(operation.ref)));
+  const revivingObjects = new Set(operations.filter(isRevivingObjectOperation).map((operation) => objectRefKey2(operation.ref)));
   for await (const page of storage.streamState({
     session,
     requests: oneStateRequest(readSet),
@@ -1865,7 +1865,7 @@ async function loadEditWorkingState(context, storage, session, operations) {
   })) {
     mergeWorkingState(context.ontology, loadedState, page);
     for (const link of page.links) {
-      const key = linkRefKey(link.ref);
+      const key = linkRefKey2(link.ref);
       if (linkCardinality(context.ontology, link.ref) !== "one" && explicitLinkKeys.has(key) && !state.links.edges.has(key)) {
         state.links.edges.set(key, workingLinkEdgeFromState(link));
       }
@@ -1885,8 +1885,8 @@ async function mergeIncidentState(context, storage, session, state, incidentStat
   const missingEndpoints = new Map;
   for (const link of knownIncidentStates) {
     for (const ref of [link.ref.source, link.ref.target]) {
-      if (!state.objects.has(objectRefKey(ref)))
-        missingEndpoints.set(objectRefKey(ref), ref);
+      if (!state.objects.has(objectRefKey2(ref)))
+        missingEndpoints.set(objectRefKey2(ref), ref);
     }
   }
   if (missingEndpoints.size > 0) {
@@ -1901,7 +1901,7 @@ async function mergeIncidentState(context, storage, session, state, incidentStat
   const relevantStates = knownIncidentStates.filter((link) => {
     if (link.effective)
       return true;
-    if (revivingObjects.has(objectRefKey(link.ref.source)) || revivingObjects.has(objectRefKey(link.ref.target))) {
+    if (revivingObjects.has(objectRefKey2(link.ref.source)) || revivingObjects.has(objectRefKey2(link.ref.target))) {
       return true;
     }
     if (linkCardinality(context.ontology, link.ref) === "one") {
@@ -1910,7 +1910,7 @@ async function mergeIncidentState(context, storage, session, state, incidentStat
         source: link.source,
         override: usableLinkSlotOverride(link.slotOverride),
         endpointExists: (ref) => {
-          const object = state.objects.get(objectRefKey(ref));
+          const object = state.objects.get(objectRefKey2(ref));
           return Boolean(object && resolveObject(context.ontology, object));
         }
       }));
@@ -1931,7 +1931,7 @@ async function mergeIncidentState(context, storage, session, state, incidentStat
   for (const link of relevantStates) {
     if (linkCardinality(context.ontology, link.ref) === "one")
       continue;
-    const key = linkRefKey(link.ref);
+    const key = linkRefKey2(link.ref);
     if (state.links.edges.has(key))
       continue;
     state.links.edges.set(key, workingLinkEdgeFromState(link));
@@ -1948,8 +1948,8 @@ async function mergeMissingLinkSlotEndpoints(context, storage, session, state) {
       working.before?.ref.target
     ];
     for (const ref of refs) {
-      if (ref && !state.objects.has(objectRefKey(ref)))
-        missing.set(objectRefKey(ref), ref);
+      if (ref && !state.objects.has(objectRefKey2(ref)))
+        missing.set(objectRefKey2(ref), ref);
     }
   }
   if (missing.size === 0)
@@ -2034,7 +2034,7 @@ function diffEffectiveLink(input) {
   return updateLinkChange(input.before, input.resolved, input.commitId, input.committedAt);
 }
 function diffEffectiveLinkSlot(input) {
-  if (input.before && input.resolved && linkRefKey(input.before.ref) !== linkRefKey(input.resolved.ref)) {
+  if (input.before && input.resolved && linkRefKey2(input.before.ref) !== linkRefKey2(input.resolved.ref)) {
     return [
       diffEffectiveLink({ ...input, resolved: null }),
       diffEffectiveLink({ ...input, before: null })
@@ -2083,7 +2083,7 @@ function updateLinkChange(before, resolved, commitId, committedAt) {
   };
 }
 function sameProperties(left, right) {
-  return stableJsonStringify(left) === stableJsonStringify(right);
+  return stableJsonStringify2(left) === stableJsonStringify2(right);
 }
 function propertyChanges(before, after) {
   const changes = {};
@@ -2093,7 +2093,7 @@ function propertyChanges(before, after) {
       changes[id] = { operation: "created", after: after[id] };
     else if (!(id in after))
       changes[id] = { operation: "cleared", before: before[id], after: null };
-    else if (stableJsonStringify(before[id]) !== stableJsonStringify(after[id])) {
+    else if (stableJsonStringify2(before[id]) !== stableJsonStringify2(after[id])) {
       changes[id] = { operation: "updated", before: before[id], after: after[id] };
     }
   }
@@ -2121,7 +2121,7 @@ function validateLinkRef(ontology, ref) {
 function validateObjectAuthorityProperties(ontology, ref, properties) {
   return materializationValidation(() => {
     const objectType = ontology.resolveObjectType(ref.objectTypeId);
-    assertKnownProperties(objectType, properties);
+    assertKnownProperties2(objectType, properties);
     const primaryId = ontology.getPrimaryPropertyId(ref.objectTypeId);
     const result = { ...properties };
     if (primaryId in result) {
@@ -2137,8 +2137,8 @@ function validateObjectAuthorityProperties(ontology, ref, properties) {
       }
     }
     const valueTypesById = ontology.getValueTypesById();
-    validateObjectProperties(objectType, result, valueTypesById);
-    return normalizeObjectProperties(objectType.properties, result, valueTypesById, objectType.id);
+    validateObjectProperties2(objectType, result, valueTypesById);
+    return normalizeObjectProperties2(objectType.properties, result, valueTypesById, objectType.id);
   });
 }
 function validateObjectPatchPropertyIds(ontology, ref, propertyIds, label) {
@@ -2162,13 +2162,13 @@ function validateObjectPatchPropertyIds(ontology, ref, propertyIds, label) {
 function validateEffectiveObject(ontology, ref, properties) {
   materializationValidation(() => {
     const objectType = ontology.resolveObjectType(ref.objectTypeId);
-    assertKnownProperties(objectType, properties);
+    assertKnownProperties2(objectType, properties);
     for (const property of objectType.properties) {
       if (property.mode !== "telemetry" && property.required && properties[property.id] === undefined) {
         throw new Error(`[Sixb] Missing required property '${property.id}' for object type '${objectType.id}'`);
       }
     }
-    validateObjectProperties(objectType, properties, ontology.getValueTypesById());
+    validateObjectProperties2(objectType, properties, ontology.getValueTypesById());
   });
 }
 function validateLinkAuthorityProperties(ontology, ref, properties) {
@@ -2181,8 +2181,8 @@ function validateLinkAuthorityProperties(ontology, ref, properties) {
       throw new Error(`[Sixb] Link '${ref.source.objectTypeId}.${ref.linkId}' cannot target '${ref.target.objectTypeId}'.`);
     }
     const valueTypesById = ontology.getValueTypesById();
-    validateLinkProperties(objectType, link, properties, undefined, valueTypesById);
-    return normalizeLinkProperties(objectType, link, properties, valueTypesById);
+    validateLinkProperties2(objectType, link, properties, undefined, valueTypesById);
+    return normalizeLinkProperties2(objectType, link, properties, valueTypesById);
   });
 }
 function validateTelemetryPoint(ontology, point) {
@@ -2194,11 +2194,11 @@ function validateTelemetryPoint(ontology, point) {
     }
     const path = `${objectType.id}.${property.id}`;
     const valueTypesById = ontology.getValueTypesById();
-    validatePropertyValue(property, point.value, path, valueTypesById);
-    validateTelemetryUnit(property, path, point.unit, valueTypesById);
+    validatePropertyValue2(property, point.value, path, valueTypesById);
+    validateTelemetryUnit2(property, path, point.unit, valueTypesById);
     return {
       ...point,
-      value: point.value === null ? null : normalizeSchemaValue(property.schema, point.value, path, valueTypesById)
+      value: point.value === null ? null : normalizeSchemaValue2(property.schema, point.value, path, valueTypesById)
     };
   });
 }
@@ -2206,9 +2206,9 @@ function materializationValidation(run) {
   try {
     return run();
   } catch (error) {
-    if (error instanceof MaterializationValidationError)
+    if (error instanceof MaterializationValidationError2)
       throw error;
-    throw new MaterializationValidationError(error instanceof Error ? error.message : String(error));
+    throw new MaterializationValidationError2(error instanceof Error ? error.message : String(error));
   }
 }
 
@@ -2233,7 +2233,7 @@ function applyObjectEdit(input) {
       next = applyObjectRestore(input);
       break;
     default:
-      throw new MaterializationValidationError("Expected an object edit operation.");
+      throw new MaterializationValidationError2("Expected an object edit operation.");
   }
   const editedAt = applyObjectEditTimes(input, next);
   const authority = transition(current, next);
@@ -2279,7 +2279,7 @@ function sameStringRecord(left, right) {
 }
 function applyObjectCreate(input, operation) {
   if (input.sourceProperties || input.authority) {
-    throw new MaterializationValidationError(`Object create requires complete authority absence for ${operation.ref.objectTypeId}:${operation.ref.primaryId}.`);
+    throw new MaterializationValidationError2(`Object create requires complete authority absence for ${operation.ref.objectTypeId}:${operation.ref.primaryId}.`);
   }
   return { kind: "create", properties: input.normalizedProperties ?? operation.properties };
 }
@@ -2309,7 +2309,7 @@ function mergeUpsertIntoPatch(current, properties, hasSource) {
 function applyObjectPatch(input, operation) {
   const current = input.authority;
   if (!input.effectiveExists && current?.kind !== "patch") {
-    throw new MaterializationValidationError(`Object patch requires an effective object for ${operation.ref.objectTypeId}:${operation.ref.primaryId}.`);
+    throw new MaterializationValidationError2(`Object patch requires an effective object for ${operation.ref.objectTypeId}:${operation.ref.primaryId}.`);
   }
   const setInput = input.normalizedSet ?? operation.set;
   if (current?.kind === "create" && !input.sourceProperties) {
@@ -2377,7 +2377,7 @@ function applyLinkEdit(input) {
       next = null;
       break;
     default:
-      throw new MaterializationValidationError("Expected a link edit operation.");
+      throw new MaterializationValidationError2("Expected a link edit operation.");
   }
   return transition(current, next);
 }
@@ -2401,7 +2401,7 @@ function transition(current, next) {
   return { next, changed: !sameAuthority(current, next) };
 }
 function sameAuthority(left, right) {
-  return stableJsonStringify(left) === stableJsonStringify(right);
+  return stableJsonStringify2(left) === stableJsonStringify2(right);
 }
 
 // src/materializer/edits/operations.ts
@@ -2428,7 +2428,7 @@ function applyObjectOperation(context, state, operation, identity, journal) {
   const working = requireWorkingObject(state, operation);
   const normalized = validateObjectOperation(context, operation);
   const currentEffective = resolveObject(context.ontology, working);
-  const transition2 = applyObjectEdit({
+  const transition = applyObjectEdit({
     operation,
     sourceProperties: working.source?.assertion.properties ?? null,
     authority: working.override,
@@ -2437,13 +2437,13 @@ function applyObjectOperation(context, state, operation, identity, journal) {
     effectiveExists: currentEffective !== null,
     ...normalized
   });
-  applyObjectTransition(context, state, working, transition2.next, transition2.editedAt, journal);
-  return objectOperationOutcome(operation, working, transition2.changed, context, identity);
+  applyObjectTransition(context, state, working, transition.next, transition.editedAt, journal);
+  return objectOperationOutcome(operation, working, transition.changed, context, identity);
 }
 function requireWorkingObject(state, operation) {
-  const working = state.objects.get(objectRefKey(operation.ref));
+  const working = state.objects.get(objectRefKey2(operation.ref));
   if (!working)
-    throw new MaterializationValidationError("Object state was not loaded.");
+    throw new MaterializationValidationError2("Object state was not loaded.");
   return working;
 }
 function validateObjectOperation(context, operation) {
@@ -2503,7 +2503,7 @@ function objectOperationOutcome(operation, working, changed, context, identity)
   });
   const object = change?.after ?? working.before;
   if (!object) {
-    throw new MaterializationValidationError("Effective object outcome could not be resolved.");
+    throw new MaterializationValidationError2("Effective object outcome could not be resolved.");
   }
   return { ...outcome, object };
 }
@@ -2521,23 +2521,23 @@ function applyLinkOperation(context, state, operation, cardinality, journal) {
     authority: working.override,
     effectiveExists: currentEffective !== null
   };
-  const transition2 = applyLinkEdit({ ...transitionInput, normalizedProperties });
-  applyLinkEdgeTransition(working, transition2.next, journal);
-  return { id: operation.id, ok: true, authority: authorityOutcome(transition2.changed) };
+  const transition = applyLinkEdit({ ...transitionInput, normalizedProperties });
+  applyLinkEdgeTransition(working, transition.next, journal);
+  return { id: operation.id, ok: true, authority: authorityOutcome(transition.changed) };
 }
 function applyLinkSlotOperation(context, state, operation, normalizedProperties, journal) {
   const key = linkScopeKey(operation.ref.source, operation.ref.linkId);
   const working = state.links.slots.get(key);
   if (!working) {
-    throw new MaterializationValidationError("Link slot state was not loaded.");
+    throw new MaterializationValidationError2("Link slot state was not loaded.");
   }
   const current = resolveLinkSlot(context.ontology, working, state.objects);
   const previous = working.override;
   let next = previous;
   switch (operation.kind) {
     case "link.upsert":
-      if (current && linkRefKey(current.ref) !== linkRefKey(operation.ref)) {
-        throw new MaterializationValidationError(`Link scope '${operation.ref.source.objectTypeId}.${operation.ref.linkId}' has cardinality one.`);
+      if (current && linkRefKey2(current.ref) !== linkRefKey2(operation.ref)) {
+        throw new MaterializationValidationError2(`Link scope '${operation.ref.source.objectTypeId}.${operation.ref.linkId}' has cardinality one.`);
       }
       next = {
         kind: "set",
@@ -2546,17 +2546,17 @@ function applyLinkSlotOperation(context, state, operation, normalizedProperties,
       };
       break;
     case "link.delete":
-      if (current && linkRefKey(current.ref) === linkRefKey(operation.ref)) {
+      if (current && linkRefKey2(current.ref) === linkRefKey2(operation.ref)) {
         next = { kind: "clear", target: operation.ref.target };
       }
       break;
     case "link.reset":
-      if (previous && objectRefKey(previous.target) === objectRefKey(operation.ref.target)) {
+      if (previous && objectRefKey2(previous.target) === objectRefKey2(operation.ref.target)) {
         next = null;
       }
       break;
   }
-  const changed = stableJsonStringify(previous) !== stableJsonStringify(next);
+  const changed = stableJsonStringify2(previous) !== stableJsonStringify2(next);
   working.override = next;
   journal?.push({
     restore: () => {
@@ -2566,21 +2566,21 @@ function applyLinkSlotOperation(context, state, operation, normalizedProperties,
   return { id: operation.id, ok: true, authority: authorityOutcome(changed) };
 }
 function requireWorkingLinkEdge(state, operation) {
-  const working = state.links.edges.get(linkRefKey(operation.ref));
+  const working = state.links.edges.get(linkRefKey2(operation.ref));
   if (!working)
-    throw new MaterializationValidationError("Link state was not loaded.");
+    throw new MaterializationValidationError2("Link state was not loaded.");
   return working;
 }
 function validateLinkEndpoints(context, state, operation) {
   if (operation.kind !== "link.upsert")
     return;
-  const source = state.objects.get(objectRefKey(operation.ref.source));
-  const target = state.objects.get(objectRefKey(operation.ref.target));
+  const source = state.objects.get(objectRefKey2(operation.ref.source));
+  const target = state.objects.get(objectRefKey2(operation.ref.target));
   const sourceExists = source && resolveObject(context.ontology, source);
   const targetExists = target && resolveObject(context.ontology, target);
   if (sourceExists && targetExists)
     return;
-  throw new MaterializationValidationError("Link upsert requires both endpoints to be effective.");
+  throw new MaterializationValidationError2("Link upsert requires both endpoints to be effective.");
 }
 function validateLinkOperation(context, operation) {
   if (operation.kind !== "link.upsert")
@@ -2651,15 +2651,15 @@ async function stageLinkSlot(context, storage, session, objects, working, planCo
     linkId: working.ref.linkId,
     target: working.override.target
   } : null);
-  const scopeSortKey = linkScopeSortKey(working.ref.source, working.ref.linkId);
+  const scopeSortKey = linkScopeSortKey2(working.ref.source, working.ref.linkId);
   const work = overrideItems.map((item) => planWork(item, scopeSortKey));
   if (representative) {
-    work.push(classificationWork("link", linkRefKey(representative), linkRefSortKey(representative)));
+    work.push(classificationWork("link", linkRefKey2(representative), linkRefSortKey2(representative)));
   }
   for (const change of changes) {
     const effectiveItems = [];
     appendEffectiveLinkWork(effectiveItems, change);
-    const sortKey = linkRefSortKey(change.ref);
+    const sortKey = linkRefSortKey2(change.ref);
     work.push(...effectiveItems.map((item) => planWork(item, sortKey)));
     work.push(eventWork(buildLinkEvent(context, planContext, change)));
   }
@@ -2680,9 +2680,9 @@ async function stageObject(context, storage, session, working, planContext) {
   });
   if (change)
     appendEffectiveObjectWork(items, change);
-  const sortKey = objectRefSortKey(working.ref);
+  const sortKey = objectRefSortKey2(working.ref);
   const work = [
-    classificationWork("object", objectRefKey(working.ref), sortKey),
+    classificationWork("object", objectRefKey2(working.ref), sortKey),
     ...items.map((item) => planWork(item, sortKey))
   ];
   if (change) {
@@ -2703,9 +2703,9 @@ async function stageLinkEdge(context, storage, session, objects, working, planCo
   });
   if (change)
     appendEffectiveLinkWork(items, change);
-  const sortKey = linkRefSortKey(working.ref);
+  const sortKey = linkRefSortKey2(working.ref);
   const work = [
-    classificationWork("link", linkRefKey(working.ref), sortKey),
+    classificationWork("link", linkRefKey2(working.ref), sortKey),
     ...items.map((item) => planWork(item, sortKey))
   ];
   if (change) {
@@ -2735,10 +2735,10 @@ function materializationEventContext(context, planContext) {
   return { ...base, actor: planContext.actor };
 }
 function sortedObjects(objects) {
-  return [...objects.values()].sort((left, right) => compareObjectRefs(left.ref, right.ref));
+  return [...objects.values()].sort((left, right) => compareObjectRefs2(left.ref, right.ref));
 }
 function sortedLinkEdges(edges) {
-  return [...edges.values()].sort((left, right) => compareLinkRefs(left.ref, right.ref));
+  return [...edges.values()].sort((left, right) => compareLinkRefs2(left.ref, right.ref));
 }
 function sortedLinkSlots(slots) {
   return [...slots.values()].sort((left, right) => linkScopeKey(left.ref.source, left.ref.linkId).localeCompare(linkScopeKey(right.ref.source, right.ref.linkId)));
@@ -2750,9 +2750,9 @@ async function commitEdits(context, raw) {
   return executeEditCommit(context, command);
 }
 function prepareEditCommit(context, raw) {
-  const input = normalizeOntologyEditCommit(raw.input);
+  const input = normalizeOntologyEditCommit2(raw.input);
   const idempotencyKey = editIdempotencyKey(input);
-  const identity = createTimedCommitIdentity({
+  const identity = createTimedCommitIdentity2({
     projectId: context.projectId,
     idempotencyKey,
     normalizedCallerIntent: input,
@@ -2767,15 +2767,15 @@ function prepareEditCommit(context, raw) {
 }
 function editIdempotencyKey(input) {
   if (input.source.kind === "action") {
-    return createActionIdempotencyKey(input.source.runId);
+    return createActionIdempotencyKey2(input.source.runId);
   }
-  return createRuntimeIdempotencyKey(input.source.requestId);
+  return createRuntimeIdempotencyKey2(input.source.requestId);
 }
 async function lockActionRunForMaterialization(storage, projectId, input, execution) {
   if (input.source.kind !== "action")
     return;
   if (!storage.actionRuns) {
-    throw new MaterializationValidationError("Storage does not provide Action run capabilities required by this commit.");
+    throw new MaterializationValidationError2("Storage does not provide Action run capabilities required by this commit.");
   }
   const run = await storage.actionRuns.lockForMaterialization({
     projectId,
@@ -2795,14 +2795,14 @@ async function validateMutationExecution(storage, projectId, input, execution) {
     runId: input.source.runId
   });
   if (!storage.actionRuns) {
-    throw new MaterializationValidationError("Storage does not provide Action run capabilities required by this commit.");
+    throw new MaterializationValidationError2("Storage does not provide Action run capabilities required by this commit.");
   }
   const run = await storage.actionRuns.getById({ projectId, id: input.source.runId });
   if (!run) {
-    throw new MaterializationValidationError(`Action run '${input.source.runId}' was not found.`);
+    throw new MaterializationValidationError2(`Action run '${input.source.runId}' was not found.`);
   }
   if (run.actionId !== input.source.actionId) {
-    throw new MaterializationConflictError("run-correlation", `Action run '${run.id}' does not belong to action '${input.source.actionId}'.`);
+    throw new MaterializationConflictError2("run-correlation", `Action run '${run.id}' does not belong to action '${input.source.actionId}'.`);
   }
   assertMaterializerRunExecution(execution, run.executionId, `Action run '${run.id}'`);
 }
@@ -2930,7 +2930,7 @@ function failedEditGroup(group, message) {
 function isRecoverableEditValidation(input, error) {
   if (input.mode === "atomic")
     return false;
-  return error instanceof MaterializationValidationError;
+  return error instanceof MaterializationValidationError2;
 }
 function editPlanContext(command) {
   const context = {
@@ -2954,7 +2954,7 @@ async function finalizeEditMaterialization(storage, session, result) {
 async function lockProjectionRunForMaterialization(storage, input) {
   const projectionRuns = storage.projectionRuns;
   if (!projectionRuns) {
-    throw new MaterializationValidationError(input.capabilityErrorMessage ?? "Storage transaction does not provide projection run capabilities.");
+    throw new MaterializationValidationError2(input.capabilityErrorMessage ?? "Storage transaction does not provide projection run capabilities.");
   }
   const run = await projectionRuns.lockForMaterialization({
     id: input.projectionRunId,
@@ -2968,7 +2968,7 @@ async function lockProjectionRunForMaterialization(storage, input) {
 function assertProjectionRunTargets(run, resolved) {
   if (projectionRunTargetsMatch(run, resolved.definition))
     return;
-  throw new MaterializationConflictError("run-correlation", `Projection run '${run.id}' target object types do not match projection '${resolved.projectionId}'.`);
+  throw new MaterializationConflictError2("run-correlation", `Projection run '${run.id}' target object types do not match projection '${resolved.projectionId}'.`);
 }
 function projectionRunTargetsMatch(run, definition) {
   switch (definition._tag) {
@@ -2997,7 +2997,7 @@ function createProjectionRunMaterializationIdentity(input) {
     case "TelemetryProjectionDefinition":
       return { ...base, projectionKind: "telemetry", protocol: "telemetry" };
     default:
-      throw new MaterializationValidationError("Expected a supported projection definition.");
+      throw new MaterializationValidationError2("Expected a supported projection definition.");
   }
 }
 
@@ -3012,10 +3012,10 @@ function prepareProjectionRunFinish(context, raw) {
   assertValidTerminalDecision(raw.input);
   const source = normalizeProjectionSourceRef(raw.input.source);
   const datasetVersion = normalizePinnedDatasetVersion(raw.input.datasetVersion);
-  const projectionExecution = normalizeProjectionExecution(raw.input.execution);
+  const projectionExecution = normalizeProjectionExecution2(raw.input.execution);
   const resolved = raw.input.protocol === "replacement" ? context.projectionRegistry.resolveSource(source.projectionId) : context.projectionRegistry.resolveTelemetry(source.projectionId);
   if (resolved.datasetId !== datasetVersion.datasetId) {
-    throw new MaterializationValidationError(`Projection '${resolved.projectionId}' requires dataset '${resolved.datasetId}'.`);
+    throw new MaterializationValidationError2(`Projection '${resolved.projectionId}' requires dataset '${resolved.datasetId}'.`);
   }
   const identity = createProjectionRunMaterializationIdentity({
     resolved,
@@ -3060,19 +3060,19 @@ async function finishProjectionRunTransaction(storage, command) {
 }
 function assertValidTerminalDecision(input) {
   if (input.protocol !== "replacement" && input.protocol !== "telemetry") {
-    throw new MaterializationValidationError("Projection finish protocol is invalid.");
+    throw new MaterializationValidationError2("Projection finish protocol is invalid.");
   }
   if (input.status !== "succeeded" && input.status !== "failed" && input.status !== "cancelled") {
-    throw new MaterializationValidationError("Projection finish status must be terminal.");
+    throw new MaterializationValidationError2("Projection finish status must be terminal.");
   }
   const inputExhausted = "inputExhausted" in input ? input.inputExhausted : undefined;
   if (input.status === "succeeded" && input.protocol === "telemetry") {
     if (inputExhausted === true)
       return;
-    throw new MaterializationValidationError("Telemetry projection success requires an explicit exhausted-input acknowledgement.");
+    throw new MaterializationValidationError2("Telemetry projection success requires an explicit exhausted-input acknowledgement.");
   }
   if (inputExhausted !== undefined) {
-    throw new MaterializationValidationError("Only telemetry projection success can acknowledge exhausted input.");
+    throw new MaterializationValidationError2("Only telemetry projection success can acknowledge exhausted input.");
   }
 }
 function terminalDecision(input) {
@@ -3098,19 +3098,19 @@ async function assertReplacementTerminalDecision(storage, command) {
   });
   if (command.input.status === "succeeded") {
     if (!commit) {
-      throw new MaterializationConflictError("run-correlation", `Projection replacement run '${command.input.execution.projectionRunId}' cannot succeed before its ontology commit exists.`);
+      throw new MaterializationConflictError2("run-correlation", `Projection replacement run '${command.input.execution.projectionRunId}' cannot succeed before its ontology commit exists.`);
     }
     assertReplacementCommitCorrelation(commit, command);
     return;
   }
   if (commit) {
-    throw new MaterializationConflictError("run-correlation", `Projection replacement run '${command.input.execution.projectionRunId}' cannot finish as '${command.input.status}' after its ontology commit exists.`);
+    throw new MaterializationConflictError2("run-correlation", `Projection replacement run '${command.input.execution.projectionRunId}' cannot finish as '${command.input.status}' after its ontology commit exists.`);
   }
 }
 function assertReplacementCommitCorrelation(commit, command) {
   const { input, identity } = command;
   if (commit.origin.kind !== "projection" || commit.executionId !== command.execution.executionId || commit.intent.kind !== "projection" || commit.result.kind !== "projection" || commit.origin.projectionRunId !== input.execution.projectionRunId || commit.origin.projectionId !== input.source.projectionId || commit.intent.source.projectionId !== input.source.projectionId || !datasetVersionsEqual(commit.intent.datasetVersion, input.datasetVersion) || commit.ontologyRevision !== identity.ontologyRevision || commit.projectionRevision !== identity.projectionRevision || commit.ownershipHash !== identity.ownershipHash) {
-    throw new MaterializationConflictError("run-correlation", `Projection replacement run '${input.execution.projectionRunId}' commit identity does not match.`);
+    throw new MaterializationConflictError2("run-correlation", `Projection replacement run '${input.execution.projectionRunId}' commit identity does not match.`);
   }
 }
 function datasetVersionsEqual(left, right) {
@@ -3122,6 +3122,12 @@ function createProjectionEntryValidator(ontology, resolved) {
   const policy = createValidationPolicy(resolved);
   return (entry) => validateProjectionEntry(ontology, resolved, policy, entry);
 }
+function validateProjectionRootRef(resolved, root) {
+  const definition = resolved.definition;
+  const owned = definition._tag === "ObjectProjectionDefinition" ? root.kind === "object" && root.ref.objectTypeId === definition.objectTypeId : root.kind === "link" && root.ref.source.objectTypeId === definition.sourceObjectTypeId && root.ref.target.objectTypeId === definition.targetObjectTypeId && root.ref.linkId === definition.linkId;
+  if (!owned)
+    throw new MaterializationValidationError2("Projection root is outside its owned type or link scope.");
+}
 function createValidationPolicy(resolved) {
   const ownedProperties = new Map(resolved.ownership.objects.map((object) => [object.objectTypeId, new Set(object.propertyIds)]));
   const ownedLinks = new Set(resolved.ownership.links.map((link) => linkOwnershipKey(link.sourceObjectTypeId, link.linkId)));
@@ -3150,7 +3156,7 @@ function validateProjectionEntry(ontology, resolved, policy, entry) {
 function validateProjectionRoot(resolved, policy, entry) {
   if (entry.root.kind === policy.expectedRootKind)
     return;
-  throw new MaterializationValidationError(`Projection '${resolved.projectionId}' requires ${policy.expectedRootDescription} root.`);
+  throw new MaterializationValidationError2(`Projection '${resolved.projectionId}' requires ${policy.expectedRootDescription} root.`);
 }
 function validateProjectionAssertion(ontology, resolved, policy, assertion) {
   if (assertion.kind === "object") {
@@ -3160,21 +3166,21 @@ function validateProjectionAssertion(ontology, resolved, policy, assertion) {
 }
 function validateObjectAssertion(ontology, resolved, policy, assertion) {
   if (resolved.definition._tag !== "ObjectProjectionDefinition" || assertion.ref.objectTypeId !== resolved.definition.objectTypeId) {
-    throw new MaterializationValidationError("Projection asserted an object outside its owned type.");
+    throw new MaterializationValidationError2("Projection asserted an object outside its owned type.");
   }
   const properties = validateObjectAuthorityProperties(ontology, assertion.ref, assertion.properties);
   const owned = policy.ownedProperties.get(assertion.ref.objectTypeId) ?? new Set;
   for (const propertyId of Object.keys(properties)) {
     if (owned.has(propertyId))
       continue;
-    throw new MaterializationValidationError(`Projection '${resolved.projectionId}' asserted unowned property '${assertion.ref.objectTypeId}.${propertyId}'.`);
+    throw new MaterializationValidationError2(`Projection '${resolved.projectionId}' asserted unowned property '${assertion.ref.objectTypeId}.${propertyId}'.`);
   }
   const conflictResolution = resolved.definition.conflictResolution ?? { strategy: "editsWin" };
   if (conflictResolution.strategy !== "mostRecent") {
     return { kind: "object", ref: assertion.ref, properties };
   }
   if (assertion.sourceUpdatedAt === undefined) {
-    throw new MaterializationValidationError(`Projection '${resolved.projectionId}' requires source update timestamp ` + `'${conflictResolution.sourceTimestamp}' on every object assertion.`);
+    throw new MaterializationValidationError2(`Projection '${resolved.projectionId}' requires source update timestamp ` + `'${conflictResolution.sourceTimestamp}' on every object assertion.`);
   }
   const primaryPropertyId = ontology.getPrimaryPropertyId(assertion.ref.objectTypeId);
   const absentSourcePropertyIds = [...owned].filter((propertyId) => propertyId !== primaryPropertyId && !Object.hasOwn(properties, propertyId)).sort();
@@ -3189,15 +3195,15 @@ function validateObjectAssertion(ontology, resolved, policy, assertion) {
 function validateLinkAssertion(ontology, resolved, policy, assertion) {
   const ownershipKey = linkOwnershipKey(assertion.ref.source.objectTypeId, assertion.ref.linkId);
   if (!policy.ownedLinks.has(ownershipKey)) {
-    throw new MaterializationValidationError("Projection asserted a link outside its owned scope.");
+    throw new MaterializationValidationError2("Projection asserted a link outside its owned scope.");
   }
   const expectedTargetTypeId = projectionLinkTargetType(resolved, assertion);
   if (expectedTargetTypeId !== assertion.ref.target.objectTypeId) {
-    throw new MaterializationValidationError(`Projection '${resolved.projectionId}' asserted link target type '${assertion.ref.target.objectTypeId}' outside its mapping.`);
+    throw new MaterializationValidationError2(`Projection '${resolved.projectionId}' asserted link target type '${assertion.ref.target.objectTypeId}' outside its mapping.`);
   }
   validateLinkAuthorityProperties(ontology, assertion.ref, assertion.properties);
   if (assertion.properties !== undefined) {
-    throw new MaterializationValidationError(`Projection '${resolved.projectionId}' does not map link assertion properties.`);
+    throw new MaterializationValidationError2(`Projection '${resolved.projectionId}' does not map link assertion properties.`);
   }
   return { ...assertion };
 }
@@ -3251,9 +3257,9 @@ function planReplacementObject(context, input, state, counts) {
     commitId: input.identity.commitId,
     committedAt: input.identity.committedAt
   });
-  const sortKey = objectRefSortKey(state.ref);
+  const sortKey = objectRefSortKey2(state.ref);
   const work = [
-    classificationWork("object", objectRefKey(state.ref), sortKey),
+    classificationWork("object", objectRefKey2(state.ref), sortKey),
     {
       kind: "object-existence",
       recordKey: `existence:${sortKey}`,
@@ -3307,9 +3313,9 @@ async function loadEndpointExistence(context, storage, session, page) {
     session,
     refs: [...endpointRefs.values()]
   })) {
-    endpointExistence.set(objectRefKey(value.ref), value.exists);
+    endpointExistence.set(objectRefKey2(value.ref), value.exists);
   }
-  const missingEndpoints = [...endpointRefs.values()].filter((ref) => !endpointExistence.has(objectRefKey(ref)));
+  const missingEndpoints = [...endpointRefs.values()].filter((ref) => !endpointExistence.has(objectRefKey2(ref)));
   if (missingEndpoints.length === 0)
     return endpointExistence;
   for await (const endpointPage of storage.streamState({
@@ -3324,7 +3330,7 @@ async function loadEndpointExistence(context, storage, session, page) {
     pageRows: context.batching.statePageRows
   })) {
     for (const endpoint of endpointPage.objects) {
-      endpointExistence.set(objectRefKey(endpoint.ref), endpoint.effective !== null);
+      endpointExistence.set(objectRefKey2(endpoint.ref), endpoint.effective !== null);
     }
   }
   return endpointExistence;
@@ -3332,8 +3338,8 @@ async function loadEndpointExistence(context, storage, session, page) {
 function collectEndpointRefs(links) {
   const refs = new Map;
   for (const state of links) {
-    refs.set(objectRefKey(state.ref.source), state.ref.source);
-    refs.set(objectRefKey(state.ref.target), state.ref.target);
+    refs.set(objectRefKey2(state.ref.source), state.ref.source);
+    refs.set(objectRefKey2(state.ref.target), state.ref.target);
   }
   return refs;
 }
@@ -3355,8 +3361,8 @@ function planReplacementLink(context, input, state, endpointExistence, counts) {
     commitId: input.identity.commitId,
     committedAt: input.identity.committedAt
   });
-  const sortKey = linkRefSortKey(state.ref);
-  work.push(classificationWork("link", linkRefKey(state.ref), sortKey));
+  const sortKey = linkRefSortKey2(state.ref);
+  work.push(classificationWork("link", linkRefKey2(state.ref), sortKey));
   if (!change) {
     counts.linksUnchanged += 1;
     return work;
@@ -3374,23 +3380,23 @@ function resolveReplacementLink(context, state, endpointExistence) {
       ref: state.ref,
       source: state.candidateSource,
       override: usableLinkSlotOverride(state.slotOverride),
-      endpointExists: (ref) => endpointExistence.get(objectRefKey(ref)) ?? false
+      endpointExists: (ref) => endpointExistence.get(objectRefKey2(ref)) ?? false
     });
   }
   return resolveEffectiveLink({
     ref: state.ref,
     source: state.candidateSource,
     override: state.override?.value ?? null,
-    sourceEndpointExists: endpointExistence.get(objectRefKey(state.ref.source)) ?? false,
-    targetEndpointExists: endpointExistence.get(objectRefKey(state.ref.target)) ?? false
+    sourceEndpointExists: endpointExistence.get(objectRefKey2(state.ref.source)) ?? false,
+    targetEndpointExists: endpointExistence.get(objectRefKey2(state.ref.target)) ?? false
   });
 }
 function cardinalityWork(context, state, occupied) {
   const definition = context.ontology.resolveObjectType(state.ref.source.objectTypeId).links.find((candidate) => candidate.id === state.ref.linkId);
   if (definition?.cardinality !== "one")
     return [];
-  const scopeSortKey = linkScopeSortKey(state.ref.source, state.ref.linkId);
-  const linkSortKey = linkRefSortKey(state.ref);
+  const scopeSortKey = linkScopeSortKey2(state.ref.source, state.ref.linkId);
+  const linkSortKey = linkRefSortKey2(state.ref);
   return [
     {
       kind: "cardinality",
@@ -3478,14 +3484,24 @@ async function stageProjectionMaterialization(context, input) {
     projectionRevision: input.projectionRevision,
     ownershipHash: input.ownershipHash,
     ontologyRevision: context.projectionRegistry.ontologyRevision,
-    createdAt: input.createdAt
+    createdAt: input.createdAt,
+    ...input.base ? { base: input.base } : {}
   });
   let rootCount = 0;
   let assertionCount = 0;
   async function* assertions() {
     for await (const rawEntry of input.entries) {
       throwIfAborted(input.signal);
-      const entry = input.validateEntry(normalizeProjectionSourceEntry(rawEntry));
+      if ("deleted" in rawEntry) {
+        if (!input.base || rawEntry.deleted !== true) {
+          throw new MaterializationValidationError2("Explicit root deletions require a pinned source base.");
+        }
+        const root = normalizeProjectionEntity(rawEntry.root);
+        validateProjectionRootRef(context.projectionRegistry.resolveSource(input.source.projectionId), root);
+        yield { root, stagingOrdinal: rootCount++ };
+        continue;
+      }
+      const entry = input.validateEntry(normalizeProjectionSourceEntry2(rawEntry));
       const stagingOrdinal = rootCount;
       for (const assertion of entry.assertions) {
         assertionCount += 1;
@@ -3505,7 +3521,8 @@ async function stageProjectionMaterialization(context, input) {
       source: input.source,
       materializationId: input.materializationId,
       execution: input.execution,
-      rows
+      rows: rows.filter((row) => ("assertion" in row)),
+      deletions: rows.filter((row) => !("assertion" in row))
     });
   }
   await context.storage.ontology.sources.markReady({
@@ -3538,7 +3555,7 @@ async function replaceProjection(context, raw) {
 function prepareProjectionReplacement(context, raw) {
   const source = normalizeProjectionSourceRef(raw.input.source);
   const datasetVersion = normalizePinnedDatasetVersion(raw.input.datasetVersion);
-  const execution = normalizeProjectionExecution(raw.input.execution);
+  const execution = normalizeProjectionExecution2(raw.input.execution);
   const resolved = context.projectionRegistry.resolveSource(source.projectionId);
   validateProjectionDataset(resolved, datasetVersion);
   const projectionKind = sourceProjectionKind(resolved);
@@ -3547,9 +3564,9 @@ function prepareProjectionReplacement(context, raw) {
     datasetVersion,
     ontologyRevision: context.projectionRegistry.ontologyRevision
   });
-  const identity = createCommitIdentity({
+  const identity = createCommitIdentity2({
     projectId: context.projectId,
-    idempotencyKey: createProjectionIdempotencyKey(runIdentity),
+    idempotencyKey: createProjectionIdempotencyKey2(runIdentity),
     normalizedCallerIntent: { source, datasetVersion }
   });
   const command = {
@@ -3557,6 +3574,7 @@ function prepareProjectionReplacement(context, raw) {
     datasetVersion,
     execution,
     entries: raw.input.entries,
+    ...raw.input.base ? { base: Object.freeze({ ...raw.input.base }) } : {},
     resolved,
     projectionKind,
     runIdentity,
@@ -3570,7 +3588,7 @@ function prepareProjectionReplacement(context, raw) {
 function validateProjectionDataset(resolved, datasetVersion) {
   if (datasetVersion.datasetId === resolved.datasetId)
     return;
-  throw new MaterializationValidationError(`Projection '${resolved.projectionId}' requires dataset '${resolved.datasetId}'.`);
+  throw new MaterializationValidationError2(`Projection '${resolved.projectionId}' requires dataset '${resolved.datasetId}'.`);
 }
 function sourceProjectionKind(resolved) {
   if (resolved.definition._tag === "ObjectProjectionDefinition")
@@ -3605,7 +3623,7 @@ async function admitProjectionExecution(context, command) {
 }
 function projectionReplayResult(commit, command) {
   if (commit.origin.kind !== "projection" || commit.origin.projectionRunId !== command.execution.projectionRunId || commit.result.kind !== "projection") {
-    throw new MaterializationConflictError("run-correlation", `Projection commit '${commit.id}' belongs to a different logical run.`);
+    throw new MaterializationConflictError2("run-correlation", `Projection commit '${commit.id}' belongs to a different logical run.`);
   }
   return { ...structuredClone(commit.result), created: false };
 }
@@ -3622,6 +3640,7 @@ async function prepareProjectionCandidate(context, command) {
     source: command.source
   });
   validateProjectionWatermark(active, command.datasetVersion);
+  assertDeltaBase(active, command);
   return {
     materializationId: context.materializationId(),
     createdAt: context.clock().toISOString(),
@@ -3643,13 +3662,14 @@ async function stageProjectionCandidate(context, command, candidate) {
     ownershipHash: command.resolved.ownershipHash,
     createdAt: candidate.createdAt,
     entries: command.entries,
+    ...command.base ? { base: command.base } : {},
     validateEntry: createProjectionEntryValidator(context.ontology, command.resolved)
   };
   const staged = await stageCandidateEntries(context, input, command.signal);
   return {
     ...candidate,
     staged,
-    identity: timestampCommitIdentity(command.identity, context.clock())
+    identity: timestampCommitIdentity2(command.identity, context.clock())
   };
 }
 async function stageCandidateEntries(context, input, signal) {
@@ -3666,6 +3686,14 @@ async function executeProjectionTransaction(context, storage, command, ready) {
   const replay = await replayCommitRecord(context, command.identity, command.scopeExecution.executionId, storage);
   if (replay)
     return projectionReplayResult(replay, command);
+  if (command.base) {
+    const active = await storage.ontology.sources.getActive({
+      projectId: context.projectId,
+      source: command.source
+    });
+    validateProjectionWatermark(active, command.datasetVersion);
+    assertDeltaBase(active, command);
+  }
   const origin = projectionOrigin(command);
   throwIfAborted(command.signal);
   const session = await storage.ontology.materializations.begin({
@@ -3772,16 +3800,21 @@ async function abandonFailedCandidate(context, command, candidate, error) {
   });
 }
 function shouldAbandonCandidate(error) {
-  if (error instanceof MaterializationValidationError)
+  if (error instanceof MaterializationValidationError2)
     return true;
-  if (error instanceof MaterializationCancellationError)
+  if (error instanceof MaterializationCancellationError2)
     return true;
-  return error instanceof MaterializationConflictError && (error.kind === "run-correlation" || error.kind === "idempotency");
+  return error instanceof MaterializationConflictError2 && (error.kind === "run-correlation" || error.kind === "idempotency");
 }
 function validateProjectionWatermark(active, next) {
   if (!active)
     return;
-  assertPinnedDatasetWatermark(active.datasetVersion, next, "Projection replacement");
+  assertPinnedDatasetWatermark2(active.datasetVersion, next, "Projection replacement");
+}
+function assertDeltaBase(active, command) {
+  if (command.base && (!active || active.materializationId !== command.base.materializationId || active.lastCommitId !== command.base.lastCommitId || active.projectionRevision !== command.runIdentity.projectionRevision || active.ontologyRevision !== command.runIdentity.ontologyRevision || active.ownershipHash !== command.runIdentity.ownershipHash)) {
+    throw new MaterializationConflictError2("source-materialization", "Projection delta no longer matches the active source or its definition.");
+  }
 }
 
 // src/materializer/telemetry/plan.ts
@@ -3791,9 +3824,9 @@ async function planTelemetryAppend(context, storage, session, input, identity, o
   const objects = await loadTelemetryObjects(context, storage, session, input.points);
   const existingPoints = await loadExistingPoints(context, storage, session, input.points);
   for (const group of telemetryObjectGroups(input.points)) {
-    const storedObject = objects.get(objectRefKey(group.objectRef));
+    const storedObject = objects.get(objectRefKey2(group.objectRef));
     if (!storedObject?.effective) {
-      throw new MaterializationObjectNotFoundError(group.objectRef.objectTypeId, group.objectRef.primaryId);
+      throw new MaterializationObjectNotFoundError2(group.objectRef.objectTypeId, group.objectRef.primaryId);
     }
     await planTelemetryObject(context, storage, session, planContext, group, workingObjectFromState(storedObject), existingPoints, counts);
   }
@@ -3803,9 +3836,9 @@ function* telemetryObjectGroups(points) {
   let start = 0;
   while (start < points.length) {
     const objectRef = points[start].series.object;
-    const objectKey = objectRefKey(objectRef);
+    const objectKey = objectRefKey2(objectRef);
     let end = start + 1;
-    while (end < points.length && objectRefKey(points[end].series.object) === objectKey) {
+    while (end < points.length && objectRefKey2(points[end].series.object) === objectKey) {
       end += 1;
     }
     yield { objectRef, start, end };
@@ -3826,7 +3859,7 @@ async function planTelemetryObject(context, storage, session, planContext, group
 async function loadTelemetryObjects(context, storage, session, points) {
   const refs = new Map;
   for (const point of points)
-    refs.set(objectRefKey(point.series.object), point.series.object);
+    refs.set(objectRefKey2(point.series.object), point.series.object);
   const objectState = await loadState(context, storage, session, {
     objects: [...refs.values()],
     links: [],
@@ -3834,7 +3867,7 @@ async function loadTelemetryObjects(context, storage, session, points) {
     incidentObjects: [],
     points: []
   });
-  return new Map(objectState.objects.map((object) => [objectRefKey(object.ref), object]));
+  return new Map(objectState.objects.map((object) => [objectRefKey2(object.ref), object]));
 }
 function planTelemetryChunk(context, planContext, points, existingPoints, latest, counts) {
   const work = [];
@@ -3857,15 +3890,15 @@ async function loadExistingPoints(context, storage, session, points) {
     pageRows: context.batching.statePageRows
   })) {
     for (const existing of page.points) {
-      existingPoints.set(telemetryPointKey(existing.series, existing.at), existing);
+      existingPoints.set(telemetryPointKey2(existing.series, existing.at), existing);
     }
   }
   context.observeCoreBuffer?.("telemetry.existing-points", existingPoints.size);
   return existingPoints;
 }
 function planTelemetryPoint(context, planContext, point, existingPoints, latest, counts) {
-  const identityKey = telemetryPointKey(point.series, point.at);
-  const sortKey = telemetryPointSortKey(point.series, point.at);
+  const identityKey = telemetryPointKey2(point.series, point.at);
+  const sortKey = telemetryPointSortKey2(point.series, point.at);
   const existing = existingPoints.get(identityKey);
   const unchanged = telemetryPointUnchanged(existing, point);
   const work = [classificationWork("point", identityKey, sortKey)];
@@ -3882,7 +3915,7 @@ function planTelemetryPoint(context, planContext, point, existingPoints, latest,
 function telemetryPointUnchanged(existing, point) {
   if (!existing)
     return false;
-  return stableJsonStringify({ value: existing.value, unit: existing.unit ?? null }) === stableJsonStringify({ value: point.value, unit: point.unit ?? null });
+  return stableJsonStringify2({ value: existing.value, unit: existing.unit ?? null }) === stableJsonStringify2({ value: point.value, unit: point.unit ?? null });
 }
 function countTelemetryPointChange(counts, existing) {
   if (existing)
@@ -3948,9 +3981,9 @@ async function stageTelemetryObjectPlan(context, storage, session, planContext,
     commitId: planContext.identity.commitId,
     committedAt: planContext.identity.committedAt
   });
-  const sortKey = objectRefSortKey(working.ref);
+  const sortKey = objectRefSortKey2(working.ref);
   const work = [
-    classificationWork("object", objectRefKey(working.ref), sortKey)
+    classificationWork("object", objectRefKey2(working.ref), sortKey)
   ];
   if (change) {
     counts.latestObjectsChanged += 1;
@@ -3990,7 +4023,7 @@ async function appendTelemetry(context, raw) {
 }
 function prepareTelemetryAppend(context, raw) {
   const rawInputPointCount = raw.input.points.length;
-  const input = normalizeTelemetryAppend({
+  const input = normalizeTelemetryAppend2({
     ...raw.input,
     points: raw.input.points.map((point) => validateTelemetryPoint(context.ontology, point))
   });
@@ -4014,9 +4047,9 @@ function telemetryInputPointCount(input, rawInputPointCount) {
   return input.points.length;
 }
 function prepareRuntimeTelemetry(context, input, source, inputPointCount, ontologyRevision) {
-  const identity = createTimedCommitIdentity({
+  const identity = createTimedCommitIdentity2({
     projectId: context.projectId,
-    idempotencyKey: createRuntimeTelemetryIdempotencyKey(source.requestId),
+    idempotencyKey: createRuntimeTelemetryIdempotencyKey2(source.requestId),
     normalizedCallerIntent: input,
     now: context.clock()
   });
@@ -4032,9 +4065,9 @@ function prepareProjectionTelemetry(context, input, source, inputPointCount, ont
     datasetVersion: source.datasetVersion,
     ontologyRevision
   });
-  const identity = createTimedCommitIdentity({
+  const identity = createTimedCommitIdentity2({
     projectId: context.projectId,
-    idempotencyKey: createProjectionTelemetryIdempotencyKey(runIdentity, source.batchOrdinal),
+    idempotencyKey: createProjectionTelemetryIdempotencyKey2(runIdentity, source.batchOrdinal),
     normalizedCallerIntent: projectionTelemetryCallerIntent(input, source, inputPointCount),
     now: context.clock()
   });
@@ -4051,25 +4084,25 @@ function prepareProjectionTelemetry(context, input, source, inputPointCount, ont
 }
 function validateTelemetryBatchCardinality(resolved, source, inputPointCount) {
   if (source.sourceRowCount === 0) {
-    throw new MaterializationValidationError("Projection telemetry batches must consume at least one source row; an empty dataset produces no batch commit.");
+    throw new MaterializationValidationError2("Projection telemetry batches must consume at least one source row; an empty dataset produces no batch commit.");
   }
   const mappedPropertyCount = resolved.ownership.telemetry.length;
   if (mappedPropertyCount === 0) {
-    throw new MaterializationValidationError(`Telemetry projection '${resolved.projectionId}' must own at least one telemetry property.`);
+    throw new MaterializationValidationError2(`Telemetry projection '${resolved.projectionId}' must own at least one telemetry property.`);
   }
   const sourceRowsEmitted = source.sourceRowCount - source.sourceRowsSkipped;
   const maximumPointCount = sourceRowsEmitted * mappedPropertyCount;
   if (!Number.isSafeInteger(maximumPointCount)) {
-    throw new MaterializationValidationError(`Telemetry projection '${resolved.projectionId}' batch point capacity exceeds the safe integer range.`);
+    throw new MaterializationValidationError2(`Telemetry projection '${resolved.projectionId}' batch point capacity exceeds the safe integer range.`);
   }
   if (inputPointCount < sourceRowsEmitted || inputPointCount > maximumPointCount) {
-    throw new MaterializationValidationError(`Telemetry projection '${resolved.projectionId}' must emit between ${sourceRowsEmitted} and ${maximumPointCount} points for ${source.sourceRowCount} source rows with ${source.sourceRowsSkipped} skipped.`);
+    throw new MaterializationValidationError2(`Telemetry projection '${resolved.projectionId}' must emit between ${sourceRowsEmitted} and ${maximumPointCount} points for ${source.sourceRowCount} source rows with ${source.sourceRowsSkipped} skipped.`);
   }
 }
 function validateTelemetryProjectionDataset(resolved, source) {
   if (resolved.datasetId === source.datasetVersion.datasetId)
     return;
-  throw new MaterializationValidationError(`Telemetry projection '${resolved.projectionId}' requires dataset '${resolved.datasetId}'.`);
+  throw new MaterializationValidationError2(`Telemetry projection '${resolved.projectionId}' requires dataset '${resolved.datasetId}'.`);
 }
 function validateTelemetryOwnership(resolved, input) {
   const ownedSeries = new Set(resolved.ownership.telemetry.map(({ objectTypeId, propertyId }) => telemetryOwnershipKey(objectTypeId, propertyId)));
@@ -4077,7 +4110,7 @@ function validateTelemetryOwnership(resolved, input) {
     const scope = telemetryOwnershipKey(point.series.object.objectTypeId, point.series.propertyId);
     if (ownedSeries.has(scope))
       continue;
-    throw new MaterializationValidationError(`Telemetry projection '${resolved.projectionId}' does not own series '${point.series.object.objectTypeId}.${point.series.propertyId}'.`);
+    throw new MaterializationValidationError2(`Telemetry projection '${resolved.projectionId}' does not own series '${point.series.object.objectTypeId}.${point.series.propertyId}'.`);
   }
 }
 function projectionTelemetryCallerIntent(input, source, inputPointCount) {
@@ -4121,30 +4154,30 @@ async function assertTelemetryExecution(storage, projectId, command) {
 function assertTelemetryBatchPosition(run, batchOrdinal, sourceRowCount, inputExhausted) {
   const checkpoint = run.telemetryCheckpoint;
   if (!checkpoint) {
-    throw new MaterializationValidationError(`Telemetry projection run '${run.id}' has incomplete checkpoint state.`);
+    throw new MaterializationValidationError2(`Telemetry projection run '${run.id}' has incomplete checkpoint state.`);
   }
   if (batchOrdinal > checkpoint.nextBatchOrdinal) {
-    throw new MaterializationValidationError(`Telemetry projection run '${run.id}' expected batch ordinal ${checkpoint.nextBatchOrdinal}, got ${batchOrdinal}.`);
+    throw new MaterializationValidationError2(`Telemetry projection run '${run.id}' expected batch ordinal ${checkpoint.nextBatchOrdinal}, got ${batchOrdinal}.`);
   }
   if (checkpoint.inputExhausted && batchOrdinal >= checkpoint.nextBatchOrdinal) {
-    throw new MaterializationValidationError(`Telemetry projection run '${run.id}' has already exhausted its input.`);
+    throw new MaterializationValidationError2(`Telemetry projection run '${run.id}' has already exhausted its input.`);
   }
   if (sourceRowCount > checkpoint.fixedBatchSize) {
-    throw new MaterializationValidationError(`Telemetry projection run '${run.id}' batch exceeds its fixed size.`);
+    throw new MaterializationValidationError2(`Telemetry projection run '${run.id}' batch exceeds its fixed size.`);
   }
   if (!inputExhausted && sourceRowCount !== checkpoint.fixedBatchSize) {
-    throw new MaterializationValidationError(`Telemetry projection run '${run.id}' cannot advance past a partial non-final batch.`);
+    throw new MaterializationValidationError2(`Telemetry projection run '${run.id}' cannot advance past a partial non-final batch.`);
   }
 }
 function assertTelemetryReplayCheckpoint(run, batchOrdinal) {
   if (!run.telemetryCheckpoint || batchOrdinal >= run.telemetryCheckpoint.nextBatchOrdinal) {
-    throw new MaterializationValidationError(`Telemetry commit batch ${batchOrdinal} exists without an advanced run checkpoint.`);
+    throw new MaterializationValidationError2(`Telemetry commit batch ${batchOrdinal} exists without an advanced run checkpoint.`);
   }
 }
 function telemetryProjectionReplayResult(commit, command) {
   const origin = commit.origin;
   if (origin.kind !== "telemetry" || origin.source.kind !== "projection" || origin.source.projectionRunId !== command.source.execution.projectionRunId || origin.source.batchOrdinal !== command.source.batchOrdinal || commit.result.kind !== "telemetry") {
-    throw new MaterializationConflictError("run-correlation", `Telemetry commit '${commit.id}' belongs to a different logical run or batch.`);
+    throw new MaterializationConflictError2("run-correlation", `Telemetry commit '${commit.id}' belongs to a different logical run or batch.`);
   }
   return { ...structuredClone(commit.result), created: false };
 }
@@ -4164,7 +4197,7 @@ async function executeTelemetryTransaction(context, storage, command) {
   }
   if (command.kind === "projection") {
     if (!execution?.run.telemetryCheckpoint || execution.run.telemetryCheckpoint.nextBatchOrdinal !== command.source.batchOrdinal) {
-      throw new MaterializationValidationError(`Telemetry projection batch ${command.source.batchOrdinal} is behind its run checkpoint.`);
+      throw new MaterializationValidationError2(`Telemetry projection batch ${command.source.batchOrdinal} is behind its run checkpoint.`);
     }
   }
   const origin = telemetryOrigin(command);
@@ -4270,7 +4303,7 @@ async function finalizeTelemetryMaterialization(storage, session, command, resul
   });
   if (command.kind === "projection") {
     if (!projectionRuns) {
-      throw new MaterializationValidationError("Expected an asserted telemetry projection run.");
+      throw new MaterializationValidationError2("Expected an asserted telemetry projection run.");
     }
     await projectionRuns.advanceTelemetryCheckpoint({
       id: command.source.execution.projectionRunId,
@@ -4287,11 +4320,15 @@ async function finalizeTelemetryMaterialization(storage, session, command, resul
 }
 
 // src/materializer/materializer.ts
-class OntologyMaterializer {
+class OntologyMaterializer2 {
   edits = {
     commit: (command) => commitEdits(this.context, command)
   };
   projections = {
+    getActive: (source) => this.context.storage.ontology.sources.getActive({
+      projectId: this.context.projectId,
+      source
+    }),
     replace: (command) => replaceProjection(this.context, command),
     finishRun: (command) => finishProjectionRun(this.context, command)
   };
@@ -4304,6 +4341,7 @@ class OntologyMaterializer {
         commit: (input) => this.edits.commit({ scope, input })
       }),
       projections: Object.freeze({
+        getActive: (source) => this.projections.getActive(source),
         replace: (input) => this.projections.replace({ scope, input }),
         finishRun: (input) => this.projections.finishRun({ scope, input })
       }),
@@ -4323,9 +4361,9 @@ class OntologyMaterializer {
     });
   }
 }
-function createOntologyMaterializer(input) {
-  return new OntologyMaterializer(input.projectId, input.ontology, input.projections, input.storage, input.dependencies);
+function createOntologyMaterializer2(input) {
+  return new OntologyMaterializer2(input.projectId, input.ontology, input.projections, input.storage, input.dependencies);
 }
-export { computeOntologyRevision, computeProjectionRevision, computeProjectionOwnershipHash, ProjectionRegistry, createActionIdempotencyKey, createRuntimeIdempotencyKey, createProjectionIdempotencyKey, createRuntimeTelemetryIdempotencyKey, createProjectionTelemetryIdempotencyKey, createCommitIdentity, timestampCommitIdentity, createTimedCommitIdentity, createProjectionMaterializationId, createLinkScopeFingerprint, normalizeJsonProperties, normalizeOntologyEditCommit, normalizeProjectionExecution, normalizeProjectionSourceEntry, normalizeTelemetryAppend, OntologyMaterializer, createOntologyMaterializer };
+export { computeOntologyRevision2, computeProjectionRevision2, computeProjectionOwnershipHash2, ProjectionRegistry2, createActionIdempotencyKey2, createRuntimeIdempotencyKey2, createProjectionIdempotencyKey2, createRuntimeTelemetryIdempotencyKey2, createProjectionTelemetryIdempotencyKey2, createCommitIdentity2, timestampCommitIdentity2, createTimedCommitIdentity2, createProjectionMaterializationId2, createLinkScopeFingerprint2, normalizeJsonProperties2, normalizeOntologyEditCommit2, normalizeProjectionExecution2, normalizeProjectionSourceEntry2, normalizeTelemetryAppend2, OntologyMaterializer2, createOntologyMaterializer2 };
 
-//# debugId=D96E192C1BE0917864756E2164756E21
+//# debugId=45B690D58E462D3C64756E2164756E21