@sixb/core 0.0.1

package/dist/chunk-yvef9xwc.js

@@ -0,0 +1,3842 @@
+// @bun
+import {
+  isStorageSerializationFailure
+} from "./chunk-aebzcsxr.js";
+import {
+  materializationApplyPhase
+} from "./chunk-q4qzq0ea.js";
+import {
+  createCommitId,
+  createEventId,
+  createRequestHash,
+  materializationEventKindOrdinal,
+  sha256Canonical
+} from "./chunk-wxhdnwh4.js";
+import {
+  assertPinnedDatasetWatermark
+} from "./chunk-9dzba0f2.js";
+import {
+  compareLinkRefs,
+  compareObjectRefs,
+  linkOwnershipKey,
+  linkRefKey,
+  linkRefSortKey,
+  linkScopeKey,
+  linkScopeSortKey,
+  normalizeLinkRef,
+  normalizeObjectRef,
+  objectRefKey,
+  objectRefSortKey,
+  projectionEntityKey,
+  telemetryOwnershipKey,
+  telemetryPointKey,
+  telemetryPointSortKey,
+  utf8JsonByteLength
+} from "./chunk-p6r5g77m.js";
+import {
+  MaterializationCancellationError,
+  MaterializationConflictError,
+  MaterializationObjectNotFoundError,
+  MaterializationValidationError
+} from "./chunk-ry24jbr1.js";
+import {
+  assertKnownProperties,
+  normalizeLinkProperties,
+  normalizeObjectProperties,
+  normalizeSchemaValue,
+  validateLinkProperties,
+  validateObjectProperties,
+  validatePropertyValue,
+  validateTelemetryUnit
+} from "./chunk-tsk2bxs3.js";
+import {
+  ProjectionValidationError,
+  isProjectionDefinition,
+  validateProjectionsAtStartup
+} from "./chunk-btpe64e4.js";
+import {
+  assertJsonValue,
+  cloneJsonValue,
+  compareStrings,
+  stableJsonStringify
+} from "./chunk-1vffvydj.js";
+// src/projections/revision.ts
+function computeOntologyRevision(ontology) {
+  const referencedValueTypeIds = collectOntologyValueTypeDependencies(ontology);
+  return sha256Canonical({
+    objectTypes: normalizeOntologyObjectTypes(ontology),
+    valueTypes: normalizeOntologyValueTypes(ontology, referencedValueTypeIds)
+  });
+}
+function collectOntologyValueTypeDependencies(ontology) {
+  const referencedValueTypeIds = new Set;
+  for (const objectType of ontology.getObjectTypesById().values()) {
+    for (const property of objectType.properties) {
+      collectReferencedValueTypeIds(property.schema, referencedValueTypeIds);
+    }
+    for (const link of objectType.links) {
+      for (const property of link.properties ?? []) {
+        collectReferencedValueTypeIds(property.schema, referencedValueTypeIds);
+      }
+    }
+  }
+  const pending = [...referencedValueTypeIds];
+  const queued = new Set(pending);
+  for (let index = 0;index < pending.length; index += 1) {
+    const valueType = ontology.getValueTypesById().get(pending[index]);
+    if (!valueType)
+      continue;
+    collectReferencedValueTypeIds(valueType.schema, referencedValueTypeIds);
+    for (const valueTypeId of referencedValueTypeIds) {
+      if (queued.has(valueTypeId))
+        continue;
+      queued.add(valueTypeId);
+      pending.push(valueTypeId);
+    }
+  }
+  return referencedValueTypeIds;
+}
+function normalizeOntologyValueTypes(ontology, referencedValueTypeIds) {
+  return [...referencedValueTypeIds].sort(compareStrings).map((valueTypeId) => ontology.getValueTypesById().get(valueTypeId)).filter((valueType) => valueType !== undefined).map((valueType) => ({
+    id: valueType.id,
+    schema: normalizeSchema(valueType.schema),
+    semanticType: valueType.semanticType ?? null
+  }));
+}
+function normalizeOntologyObjectTypes(ontology) {
+  return [...ontology.getObjectTypesById().values()].sort((left, right) => compareStrings(left.id, right.id)).map((objectType) => ({
+    id: objectType.id,
+    extends: objectType.extends ?? null,
+    parents: [...objectType.parents ?? []].sort(),
+    implements: [...objectType.implements ?? []].sort(),
+    properties: [...objectType.properties].sort((left, right) => compareStrings(left.id, right.id)).map(normalizeProperty),
+    links: [...objectType.links].sort((left, right) => compareStrings(left.id, right.id)).map((link) => ({
+      id: link.id,
+      targetObjectTypeIds: Array.isArray(link.targetObjectTypeId) ? [...link.targetObjectTypeId].sort() : [link.targetObjectTypeId],
+      cardinality: link.cardinality ?? "many",
+      properties: [...link.properties ?? []].sort((left, right) => compareStrings(left.id, right.id)).map(normalizeProperty)
+    }))
+  }));
+}
+function collectReferencedValueTypeIds(schema, valueTypeIds) {
+  if (typeof schema === "string" || schema.type === "enum")
+    return;
+  if (schema.type === "valueTypeRef") {
+    valueTypeIds.add(schema.valueTypeId);
+    return;
+  }
+  if (schema.type === "array") {
+    collectReferencedValueTypeIds(schema.items, valueTypeIds);
+    return;
+  }
+  if (schema.type === "map") {
+    collectReferencedValueTypeIds(schema.valueSchema, valueTypeIds);
+    return;
+  }
+  for (const field of Object.values(schema.properties)) {
+    collectReferencedValueTypeIds(field.schema, valueTypeIds);
+  }
+}
+function computeProjectionRevision(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({
+    mapping: normalizeProjectionDefinition(projection),
+    columns
+  });
+}
+function computeProjectionOwnershipHash(ownership) {
+  return sha256Canonical(ownership);
+}
+function normalizeProjectionDefinition(projection) {
+  if (projection._tag === "ObjectProjectionDefinition") {
+    return {
+      kind: "object",
+      objectTypeId: projection.objectTypeId,
+      properties: Object.fromEntries(Object.entries(projection.properties).sort(([left], [right]) => compareStrings(left, right))),
+      links: Object.fromEntries(Object.entries(projection.links).sort(([left], [right]) => compareStrings(left, right)).map(([linkId, link]) => [
+        linkId,
+        {
+          linkId: link.linkId,
+          sourcePropertyId: link.sourcePropertyId ?? null,
+          sourceField: link.sourceField ?? null,
+          targetObjectTypeId: link.targetObjectTypeId
+        }
+      ]))
+    };
+  }
+  if (projection._tag === "LinkProjectionDefinition") {
+    return {
+      kind: "link",
+      sourceObjectTypeId: projection.sourceObjectTypeId,
+      linkId: projection.linkId,
+      targetObjectTypeId: projection.targetObjectTypeId,
+      sourceField: projection.sourceField,
+      targetField: projection.targetField
+    };
+  }
+  return {
+    kind: "telemetry",
+    objectTypeId: projection.objectTypeId,
+    propertyId: projection.propertyId,
+    objectIdField: projection.objectIdField,
+    atField: projection.atField,
+    valueField: projection.valueField,
+    unitField: projection.unitField ?? null
+  };
+}
+function projectionColumns(projection) {
+  if (projection._tag === "ObjectProjectionDefinition") {
+    return new Set([
+      ...Object.values(projection.properties),
+      ...Object.values(projection.links).flatMap((link) => link.sourceField === undefined ? [] : [link.sourceField])
+    ]);
+  }
+  if (projection._tag === "LinkProjectionDefinition") {
+    return new Set([projection.sourceField, projection.targetField]);
+  }
+  return new Set([
+    projection.objectIdField,
+    projection.atField,
+    projection.valueField,
+    ...projection.unitField === undefined ? [] : [projection.unitField]
+  ]);
+}
+function normalizeProperty(property) {
+  return {
+    id: property.id,
+    schema: normalizeSchema(property.schema),
+    required: property.required ?? false,
+    nullable: property.nullable ?? false,
+    primary: property.primary ?? false,
+    mode: property.mode ?? "static",
+    semanticType: property.semanticType ?? null
+  };
+}
+function normalizeSchema(schema) {
+  if (typeof schema === "string")
+    return schema;
+  if (schema.type === "valueTypeRef") {
+    return { type: "valueTypeRef", valueTypeId: schema.valueTypeId };
+  }
+  if (schema.type === "enum") {
+    return {
+      type: "enum",
+      valueType: schema.valueType,
+      values: schema.valueType === "string" ? [...schema.values].sort(compareStrings) : [...schema.values].sort((left, right) => left - right)
+    };
+  }
+  if (schema.type === "array") {
+    return { type: "array", items: normalizeSchema(schema.items) };
+  }
+  if (schema.type === "map") {
+    return {
+      type: "map",
+      keySchema: schema.keySchema,
+      valueSchema: normalizeSchema(schema.valueSchema)
+    };
+  }
+  return {
+    type: "object",
+    properties: Object.fromEntries(Object.entries(schema.properties).sort(([left], [right]) => compareStrings(left, right)).map(([fieldId, field]) => [fieldId, normalizeField(field)]))
+  };
+}
+function normalizeField(field) {
+  return {
+    schema: normalizeSchema(field.schema),
+    required: field.required ?? false,
+    nullable: field.nullable ?? false,
+    semanticType: field.semanticType ?? null
+  };
+}
+
+// src/projections/registry.ts
+class ProjectionRegistry {
+  ontologyRevision;
+  objectProjections;
+  linkProjections;
+  telemetryProjections;
+  projectionsById = new Map;
+  sourceById = new Map;
+  telemetryById = new Map;
+  dispatchById = new Map;
+  dispatchDescriptors;
+  constructor(input) {
+    const objectProjections = [];
+    const linkProjections = [];
+    const telemetryProjections = [];
+    for (const projection of input.projections) {
+      if (!isProjectionDefinition(projection)) {
+        throw new ProjectionValidationError("[Sixb] Invalid projection definition.");
+      }
+      switch (projection._tag) {
+        case "ObjectProjectionDefinition":
+          objectProjections.push(deepFreeze(cloneObjectProjectionDefinition(projection)));
+          break;
+        case "LinkProjectionDefinition":
+          linkProjections.push(deepFreeze(cloneLinkProjectionDefinition(projection)));
+          break;
+        case "TelemetryProjectionDefinition":
+          telemetryProjections.push(deepFreeze(cloneTelemetryProjectionDefinition(projection)));
+          break;
+      }
+    }
+    this.objectProjections = Object.freeze(objectProjections);
+    this.linkProjections = Object.freeze(linkProjections);
+    this.telemetryProjections = Object.freeze(telemetryProjections);
+    const projections = [
+      ...this.objectProjections,
+      ...this.linkProjections,
+      ...this.telemetryProjections
+    ];
+    assertUniqueProjectionIds(projections);
+    const validated = validateProjectionsAtStartup({
+      objectProjections: this.objectProjections,
+      linkProjections: this.linkProjections,
+      telemetryProjections: this.telemetryProjections
+    }, input.ontology, input.datasetsById);
+    this.ontologyRevision = computeOntologyRevision(input.ontology);
+    const dispatchDescriptors = [];
+    for (const record of validated.objectProjections) {
+      const resolved = createResolvedProjection(record);
+      this.sourceById.set(resolved.projectionId, resolved);
+      this.projectionsById.set(resolved.projectionId, resolved.definition);
+      dispatchDescriptors.push(createDispatchDescriptor(resolved, this.ontologyRevision));
+    }
+    for (const record of validated.linkProjections) {
+      const resolved = createResolvedProjection(record);
+      this.sourceById.set(resolved.projectionId, resolved);
+      this.projectionsById.set(resolved.projectionId, resolved.definition);
+      dispatchDescriptors.push(createDispatchDescriptor(resolved, this.ontologyRevision));
+    }
+    for (const record of validated.telemetryProjections) {
+      const resolved = createResolvedProjection(record);
+      this.telemetryById.set(resolved.projectionId, resolved);
+      this.projectionsById.set(resolved.projectionId, resolved.definition);
+      dispatchDescriptors.push(createDispatchDescriptor(resolved, this.ontologyRevision));
+    }
+    this.dispatchDescriptors = Object.freeze(dispatchDescriptors);
+    for (const descriptor of this.dispatchDescriptors) {
+      this.dispatchById.set(descriptor.projectionId, descriptor);
+    }
+  }
+  listObjectProjections() {
+    return this.objectProjections;
+  }
+  listLinkProjections() {
+    return this.linkProjections;
+  }
+  listTelemetryProjections() {
+    return this.telemetryProjections;
+  }
+  getProjectionById(projectionId) {
+    return this.projectionsById.get(projectionId) ?? null;
+  }
+  getDispatchDescriptors() {
+    return this.dispatchDescriptors;
+  }
+  resolveDispatch(projectionId) {
+    const descriptor = this.dispatchById.get(projectionId);
+    if (descriptor)
+      return descriptor;
+    throw new ProjectionValidationError(`[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 ProjectionValidationError(`[Sixb] Unknown source projection '${projectionId}'.`);
+    }
+    return resolved;
+  }
+  resolveTelemetry(projectionId) {
+    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 ProjectionValidationError(`[Sixb] Unknown telemetry projection '${projectionId}'.`);
+    }
+    return resolved;
+  }
+}
+function createDispatchDescriptor(resolved, ontologyRevision) {
+  const common = {
+    projectionId: resolved.projectionId,
+    datasetId: resolved.datasetId,
+    ontologyRevision,
+    projectionRevision: resolved.projectionRevision,
+    ownershipHash: resolved.ownershipHash
+  };
+  switch (resolved.definition._tag) {
+    case "ObjectProjectionDefinition":
+      return deepFreeze({ ...common, projectionKind: "object", protocol: "replacement" });
+    case "LinkProjectionDefinition":
+      return deepFreeze({ ...common, projectionKind: "link", protocol: "replacement" });
+    case "TelemetryProjectionDefinition":
+      return deepFreeze({ ...common, projectionKind: "telemetry", protocol: "telemetry" });
+  }
+}
+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}`);
+    }
+    ids.add(projection.id);
+  }
+}
+function createResolvedProjection(validated) {
+  const { definition, dataset, ownership } = validated;
+  return deepFreeze({
+    projectionId: definition.id,
+    datasetId: definition.datasetId,
+    projectionRevision: computeProjectionRevision(definition, dataset),
+    ownershipHash: computeProjectionOwnershipHash(ownership),
+    ownership,
+    definition
+  });
+}
+function cloneObjectProjectionDefinition(projection) {
+  return {
+    _tag: projection._tag,
+    id: projection.id,
+    objectTypeId: projection.objectTypeId,
+    datasetId: projection.datasetId,
+    properties: { ...projection.properties },
+    links: Object.fromEntries(Object.entries(projection.links).map(([linkId, descriptor]) => [
+      linkId,
+      {
+        linkId: descriptor.linkId,
+        ...descriptor.sourcePropertyId !== undefined ? { sourcePropertyId: descriptor.sourcePropertyId } : {},
+        ...descriptor.sourceField !== undefined ? { sourceField: descriptor.sourceField } : {},
+        targetObjectTypeId: descriptor.targetObjectTypeId
+      }
+    ]))
+  };
+}
+function cloneLinkProjectionDefinition(projection) {
+  return {
+    _tag: "LinkProjectionDefinition",
+    id: projection.id,
+    linkId: projection.linkId,
+    sourceObjectTypeId: projection.sourceObjectTypeId,
+    targetObjectTypeId: projection.targetObjectTypeId,
+    datasetId: projection.datasetId,
+    sourceField: projection.sourceField,
+    targetField: projection.targetField
+  };
+}
+function cloneTelemetryProjectionDefinition(projection) {
+  return {
+    _tag: "TelemetryProjectionDefinition",
+    id: projection.id,
+    objectTypeId: projection.objectTypeId,
+    propertyId: projection.propertyId,
+    datasetId: projection.datasetId,
+    objectIdField: projection.objectIdField,
+    atField: projection.atField,
+    valueField: projection.valueField,
+    ...projection.unitField !== undefined ? { unitField: projection.unitField } : {}
+  };
+}
+function deepFreeze(value) {
+  if (value === null || typeof value !== "object" || Object.isFrozen(value))
+    return value;
+  for (const child of Object.values(value)) {
+    deepFreeze(child);
+  }
+  return Object.freeze(value);
+}
+// src/materializer/shared/batching.ts
+var DEFAULT_MATERIALIZATION_BATCHING = Object.freeze({
+  sourceStageRows: 1000,
+  sourceStageBytes: 4 * 1024 * 1024,
+  statePageRows: 1000,
+  planChunkRows: 1000,
+  planChunkBytes: 4 * 1024 * 1024
+});
+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.`);
+    }
+  }
+  return Object.freeze(resolved);
+}
+
+// src/materializer/shared/identity.ts
+import { randomUUID } from "crypto";
+function createActionIdempotencyKey(runId) {
+  return `action:${runId}:edits`;
+}
+function createRuntimeIdempotencyKey(requestId) {
+  return `runtime:${requestId}`;
+}
+function projectionIdentityTuple(input) {
+  return [
+    input.projectionId,
+    input.projectionKind,
+    input.protocol,
+    input.datasetVersion.datasetId,
+    input.datasetVersion.versionId,
+    input.datasetVersion.createdAt,
+    input.ontologyRevision,
+    input.projectionRevision,
+    input.ownershipHash
+  ];
+}
+function createProjectionIdempotencyKey(identity) {
+  return `projection:replace:${sha256Canonical(projectionIdentityTuple(identity))}`;
+}
+function createRuntimeTelemetryIdempotencyKey(requestId) {
+  return `telemetry:runtime:${requestId}`;
+}
+function createProjectionTelemetryIdempotencyKey(identity, batchOrdinal) {
+  return `telemetry:projection:${sha256Canonical([
+    ...projectionIdentityTuple(identity),
+    batchOrdinal
+  ])}`;
+}
+function createCommitIdentity(input) {
+  return Object.freeze({
+    idempotencyKey: input.idempotencyKey,
+    requestHash: createRequestHash(input.normalizedCallerIntent),
+    commitId: createCommitId(input.projectId, input.idempotencyKey)
+  });
+}
+function timestampCommitIdentity(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.");
+  }
+  return Object.freeze({
+    ...identity,
+    committedAt: committedAt.toISOString()
+  });
+}
+function createTimedCommitIdentity(input) {
+  return timestampCommitIdentity(createCommitIdentity({
+    projectId: input.projectId,
+    idempotencyKey: input.idempotencyKey,
+    normalizedCallerIntent: input.normalizedCallerIntent
+  }), input.now);
+}
+function createProjectionMaterializationId() {
+  return randomUUID();
+}
+function createLinkScopeFingerprint(links) {
+  return sha256Canonical([...links].sort((left, right) => compareLinkRefs(left.ref, right.ref)).map((link) => ({
+    ref: link.ref,
+    properties: link.properties ?? {},
+    lastCommitId: link.lastCommitId
+  })));
+}
+
+// src/materializer/context.ts
+function createMaterializerContext(input) {
+  if (input.projectId.trim().length === 0) {
+    throw new MaterializationValidationError("Materializer project id must be nonblank.");
+  }
+  if (!input.storage?.ontology) {
+    throw new MaterializationValidationError("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.");
+  }
+  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.");
+  }
+  return {
+    projectId: input.projectId,
+    ontology: input.ontology,
+    projectionRegistry: input.projections,
+    storage: input.storage,
+    batching: resolveMaterializationBatching(dependencies.batching),
+    clock: dependencies.clock ?? (() => new Date),
+    materializationId: dependencies.materializationId ?? createProjectionMaterializationId,
+    maxSerializationRetries,
+    ...dependencies.onSerializationRetry !== undefined ? { onSerializationRetry: dependencies.onSerializationRetry } : {},
+    ...dependencies.observeCoreBuffer !== undefined ? { observeCoreBuffer: dependencies.observeCoreBuffer } : {}
+  };
+}
+
+// src/materializer/execution/commit-lifecycle.ts
+async function replayCommitRecord(context, identity, storage = context.storage) {
+  const existing = await storage.ontology.commits.getByIdempotencyKey({
+    projectId: context.projectId,
+    idempotencyKey: identity.idempotencyKey
+  });
+  if (!existing)
+    return null;
+  if (existing.requestHash !== identity.requestHash) {
+    throw new MaterializationConflictError("idempotency", `Idempotency key '${identity.idempotencyKey}' was reused with different intent.`);
+  }
+  return existing;
+}
+async function replayCommit(context, identity, storage = context.storage) {
+  const existing = await replayCommitRecord(context, identity, storage);
+  if (!existing)
+    return null;
+  return { ...structuredClone(existing.result), created: false };
+}
+async function withSerializationRetry(context, run) {
+  for (let attempt = 0;; attempt += 1) {
+    try {
+      return await run();
+    } catch (error) {
+      if (!isStorageSerializationFailure(error) || attempt >= context.maxSerializationRetries) {
+        throw error;
+      }
+      context.onSerializationRetry?.(attempt + 1, error);
+    }
+  }
+}
+
+// src/materializer/effective/build-events.ts
+function buildObjectMaterializationEventDraft(input) {
+  const draft = buildObjectEventDraft(input, input.change);
+  return orderedDraft(objectRefSortKey(input.change.ref), draft);
+}
+function buildObjectEventDraft(context, change) {
+  const base = eventDraftBase(context);
+  const partitionKey = `${change.ref.objectTypeId}:${change.ref.primaryId}`;
+  if (change.kind === "deleted") {
+    return {
+      ...base,
+      type: "object.deleted",
+      topic: "objects",
+      partitionKey,
+      payload: {
+        objectTypeId: change.ref.objectTypeId,
+        primaryId: change.ref.primaryId,
+        propertyChanges: change.propertyChanges
+      }
+    };
+  }
+  const type = objectEventType(change);
+  return {
+    ...base,
+    type,
+    topic: "objects",
+    partitionKey,
+    payload: {
+      objectTypeId: change.ref.objectTypeId,
+      primaryId: change.ref.primaryId,
+      properties: change.after.properties,
+      propertyChanges: change.propertyChanges
+    }
+  };
+}
+function objectEventType(change) {
+  if (change.kind === "created")
+    return "object.created";
+  return "object.updated";
+}
+function buildLinkMaterializationEventDraft(input) {
+  const draft = buildLinkEventDraft(input, input.change);
+  return orderedDraft(linkRefSortKey(input.change.ref), draft);
+}
+function buildLinkEventDraft(context, change) {
+  const base = eventDraftBase(context);
+  const partitionKey = `${change.ref.source.objectTypeId}:${change.ref.source.primaryId}:${change.ref.linkId}`;
+  const commonPayload = {
+    sourceTypeId: change.ref.source.objectTypeId,
+    sourceId: change.ref.source.primaryId,
+    linkId: change.ref.linkId,
+    targetTypeId: change.ref.target.objectTypeId,
+    targetId: change.ref.target.primaryId,
+    propertyChanges: change.propertyChanges
+  };
+  if (change.kind === "deleted") {
+    return {
+      ...base,
+      type: "link.deleted",
+      topic: "links",
+      partitionKey,
+      payload: commonPayload
+    };
+  }
+  const type = linkEventType(change);
+  if (change.after.properties === undefined) {
+    return { ...base, type, topic: "links", partitionKey, payload: commonPayload };
+  }
+  return {
+    ...base,
+    type,
+    topic: "links",
+    partitionKey,
+    payload: { ...commonPayload, properties: change.after.properties }
+  };
+}
+function linkEventType(change) {
+  if (change.kind === "created")
+    return "link.created";
+  return "link.updated";
+}
+function buildTelemetryMaterializationEventDraft(input) {
+  const draft = buildTelemetryEventDraft(input, input.point);
+  return orderedDraft(telemetryPointSortKey(input.point.series, input.point.at), draft);
+}
+function buildTelemetryEventDraft(context, point) {
+  const base = eventDraftBase(context);
+  const partitionKey = `${point.series.object.objectTypeId}:${point.series.object.primaryId}:${point.series.propertyId}`;
+  const payload = {
+    objectTypeId: point.series.object.objectTypeId,
+    objectId: point.series.object.primaryId,
+    propertyId: point.series.propertyId,
+    value: point.value,
+    at: point.at
+  };
+  if (point.unit === undefined) {
+    return { ...base, type: "telemetry.appended", topic: "telemetry", partitionKey, payload };
+  }
+  return {
+    ...base,
+    type: "telemetry.appended",
+    topic: "telemetry",
+    partitionKey,
+    payload: { ...payload, unit: point.unit }
+  };
+}
+function eventDraftBase(context) {
+  const base = {
+    schemaVersion: 1,
+    projectId: context.projectId,
+    occurredAt: context.committedAt,
+    origin: context.origin,
+    commitId: context.commitId
+  };
+  if (context.actor === undefined)
+    return base;
+  return { ...base, actor: context.actor };
+}
+function orderedDraft(sortKey, draft) {
+  return {
+    kindRank: materializationEventKindOrdinal(draft.type),
+    sortKey,
+    draft
+  };
+}
+function sequenceMaterializationEvent(projectId, commitId, commitOrdinal, draft) {
+  const sequence = {
+    id: createEventId(projectId, commitId, commitOrdinal),
+    commitOrdinal
+  };
+  return { ...draft, ...sequence };
+}
+
+// src/materializer/shared/abort.ts
+function throwIfAborted(signal) {
+  if (signal?.aborted) {
+    throw signal.reason instanceof Error ? signal.reason : new DOMException("Projection replacement aborted", "AbortError");
+  }
+}
+
+// src/materializer/shared/chunking.ts
+async function* chunkBySize(items, input) {
+  let chunk = [];
+  let bytes = 0;
+  for await (const item of items) {
+    const itemBytes = input.byteLength(item);
+    if (chunk.length > 0 && bytes + itemBytes > input.maxBytes) {
+      yield chunk;
+      chunk = [];
+      bytes = 0;
+    }
+    chunk.push(item);
+    bytes += itemBytes;
+    if (chunk.length >= input.maxRows || bytes >= input.maxBytes) {
+      yield chunk;
+      chunk = [];
+      bytes = 0;
+    }
+  }
+  if (chunk.length > 0)
+    yield chunk;
+}
+
+// src/materializer/execution/plan-stream.ts
+async function* planStream(items, batching) {
+  for await (const itemsChunk of chunkBySize(items, {
+    maxRows: batching.planChunkRows,
+    maxBytes: batching.planChunkBytes,
+    byteLength: utf8JsonByteLength
+  })) {
+    const chunk = mutableChunk();
+    for (const item of itemsChunk)
+      appendItem(chunk, item);
+    yield chunk;
+  }
+}
+function mutableChunk() {
+  return {
+    overrides: { objectUpserts: [], objectDeletes: [], linkUpserts: [], linkDeletes: [] },
+    effective: { objectUpserts: [], objectDeletes: [], linkUpserts: [], linkDeletes: [] },
+    timeseries: { pointUpserts: [] },
+    outbox: []
+  };
+}
+function appendItem(chunk, item) {
+  switch (item.kind) {
+    case "object-override-upsert":
+      chunk.overrides.objectUpserts.push(item.value);
+      break;
+    case "object-override-delete":
+      chunk.overrides.objectDeletes.push(item.value);
+      break;
+    case "link-override-upsert":
+      chunk.overrides.linkUpserts.push(item.value);
+      break;
+    case "link-override-delete":
+      chunk.overrides.linkDeletes.push(item.value);
+      break;
+    case "object-upsert":
+      chunk.effective.objectUpserts.push(item.value);
+      break;
+    case "object-delete":
+      chunk.effective.objectDeletes.push(item.value);
+      break;
+    case "link-upsert":
+      chunk.effective.linkUpserts.push(item.value);
+      break;
+    case "link-delete":
+      chunk.effective.linkDeletes.push(item.value);
+      break;
+    case "point-upsert":
+      chunk.timeseries.pointUpserts.push(item.value);
+      break;
+    case "outbox":
+      chunk.outbox.push(item.value);
+      break;
+  }
+}
+
+// src/materializer/execution/work-records.ts
+function appendObjectOverridePlan(items, working, identity) {
+  if (stableJsonStringify(working.originalOverride?.value ?? null) === stableJsonStringify(working.override)) {
+    return;
+  }
+  if (working.override) {
+    items.push({
+      kind: "object-override-upsert",
+      value: {
+        ref: working.ref,
+        value: working.override,
+        expectedLastCommitId: working.originalOverride?.lastCommitId ?? null,
+        lastCommitId: identity.commitId,
+        updatedAt: identity.committedAt
+      }
+    });
+  } else if (working.originalOverride) {
+    items.push({
+      kind: "object-override-delete",
+      value: { ref: working.ref, expectedLastCommitId: working.originalOverride.lastCommitId }
+    });
+  }
+}
+function appendLinkOverridePlan(items, working, identity) {
+  if (stableJsonStringify(working.originalOverride?.value ?? null) === stableJsonStringify(working.override)) {
+    return;
+  }
+  if (working.override) {
+    items.push({
+      kind: "link-override-upsert",
+      value: {
+        ref: working.ref,
+        value: working.override,
+        expectedLastCommitId: working.originalOverride?.lastCommitId ?? null,
+        lastCommitId: identity.commitId,
+        updatedAt: identity.committedAt
+      }
+    });
+  } else if (working.originalOverride) {
+    items.push({
+      kind: "link-override-delete",
+      value: { ref: working.ref, expectedLastCommitId: working.originalOverride.lastCommitId }
+    });
+  }
+}
+function appendObjectEffectivePlan(items, change) {
+  if (change.kind === "deleted") {
+    items.push({
+      kind: "object-delete",
+      value: {
+        ref: change.ref,
+        expected: expectedObject(change.before)
+      }
+    });
+  } else {
+    items.push({
+      kind: "object-upsert",
+      value: {
+        row: change.after,
+        expected: change.before ? expectedObject(change.before) : { ref: change.ref, exists: false }
+      }
+    });
+  }
+}
+function appendLinkEffectivePlan(items, change) {
+  if (change.kind === "deleted") {
+    items.push({
+      kind: "link-delete",
+      value: {
+        ref: change.ref,
+        expected: expectedLink(change.before)
+      }
+    });
+  } else {
+    items.push({
+      kind: "link-upsert",
+      value: {
+        row: change.after,
+        expected: change.before ? expectedLink(change.before) : { ref: change.ref, exists: false }
+      }
+    });
+  }
+}
+function outboxItem(event, committedAt) {
+  const value = {
+    envelope: event,
+    availableAt: committedAt,
+    createdAt: committedAt
+  };
+  return { kind: "outbox", value };
+}
+function classificationWork(entityKind, identityKey, sortKey) {
+  return {
+    kind: "classification",
+    recordKey: `classification:${entityKind}:${sortKey}`,
+    entityKind,
+    identityKey
+  };
+}
+function planWork(item, sortKey) {
+  const applyPhase = materializationApplyPhase(item.kind);
+  return {
+    kind: "plan",
+    recordKey: `plan:${item.kind}:${sortKey}`,
+    applyPhase,
+    sortKey,
+    item
+  };
+}
+function eventWork(value) {
+  return {
+    kind: "event",
+    recordKey: `event:${value.kindRank}:${value.sortKey}`,
+    eventKindRank: value.kindRank,
+    sortKey: value.sortKey,
+    draft: value.draft
+  };
+}
+function expectedObject(snapshot) {
+  return {
+    ref: snapshot.ref,
+    exists: true,
+    version: snapshot.version,
+    lastCommitId: snapshot.lastCommitId
+  };
+}
+function expectedLink(snapshot) {
+  return { ref: snapshot.ref, exists: true, lastCommitId: snapshot.lastCommitId };
+}
+
+// src/materializer/execution/work-executor.ts
+async function applyItems(context, storage, session, items, signal) {
+  for await (const chunk of planStream(items, context.batching)) {
+    throwIfAborted(signal);
+    await storage.applyChunk({ session, chunk });
+  }
+}
+async function stageWorkBounded(context, storage, session, records) {
+  for await (const chunk of chunkBySize(records, {
+    maxRows: context.batching.planChunkRows,
+    maxBytes: context.batching.planChunkBytes,
+    byteLength: utf8JsonByteLength
+  })) {
+    await storage.stageWork({ session, records: chunk });
+  }
+}
+async function drainStagedWork(context, storage, session, signal) {
+  let phase = null;
+  let pending = [];
+  const flush = async () => {
+    if (pending.length === 0)
+      return;
+    await applyItems(context, storage, session, pending, signal);
+    pending = [];
+  };
+  for await (const page of storage.streamWork({
+    session,
+    order: "apply",
+    pageRows: context.batching.planChunkRows
+  })) {
+    for (const record of page.records) {
+      if (record.kind !== "plan") {
+        throw new MaterializationValidationError("Provider returned non-plan apply work.");
+      }
+      if (phase !== null && record.applyPhase !== phase)
+        await flush();
+      phase = record.applyPhase;
+      pending.push(record.item);
+      if (pending.length >= context.batching.planChunkRows)
+        await flush();
+    }
+  }
+  await flush();
+}
+async function validateStagedCardinality(context, storage, session, signal) {
+  let currentScope = null;
+  let occupant = null;
+  for await (const page of storage.streamWork({
+    session,
+    order: "cardinality",
+    pageRows: context.batching.statePageRows
+  })) {
+    throwIfAborted(signal);
+    for (const record of page.records) {
+      if (record.kind !== "cardinality") {
+        throw new MaterializationValidationError("Provider returned non-cardinality cardinality work.");
+      }
+      if (record.scopeSortKey !== currentScope) {
+        currentScope = record.scopeSortKey;
+        occupant = null;
+      }
+      if (!record.occupied)
+        continue;
+      if (occupant && occupant !== record.linkSortKey) {
+        throw new MaterializationValidationError(`Link scope '${record.ref.source.objectTypeId}.${record.ref.linkId}' has cardinality one.`);
+      }
+      occupant = record.linkSortKey;
+    }
+  }
+}
+async function drainStagedEvents(context, storage, session, identity, signal) {
+  let ordinal = 0;
+  for await (const page of storage.streamWork({
+    session,
+    order: "event",
+    pageRows: context.batching.planChunkRows
+  })) {
+    const items = [];
+    for (const record of page.records) {
+      if (record.kind !== "event") {
+        throw new MaterializationValidationError("Provider returned non-event event work.");
+      }
+      const event = sequenceMaterializationEvent(context.projectId, identity.commitId, ordinal++, record.draft);
+      items.push(outboxItem(event, identity.committedAt));
+    }
+    await applyItems(context, storage, session, items, signal);
+  }
+  return ordinal;
+}
+
+// src/materializer/shared/normalize.ts
+function normalizeJsonProperties(properties, label = "Properties") {
+  if (typeof properties !== "object" || properties === null || Array.isArray(properties)) {
+    throw new MaterializationValidationError(`${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.`);
+    }
+    const value = properties[propertyId];
+    try {
+      assertJsonValue(value, `${label}.${propertyId}`);
+    } catch (error) {
+      throw new MaterializationValidationError(error instanceof Error ? error.message : `${label}.${propertyId} must be JSON.`);
+    }
+    normalized[propertyId] = cloneJsonValue(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.`);
+  }
+  return value;
+}
+function normalizeEventActor(actor) {
+  if (typeof actor !== "object" || actor === null || Array.isArray(actor)) {
+    throw new MaterializationValidationError("Event actor must be an object.");
+  }
+  if (actor.type !== "user" && actor.type !== "serviceAccount" && actor.type !== "system") {
+    throw new MaterializationValidationError("Event actor type must be 'user', 'serviceAccount', or 'system'.");
+  }
+  return Object.freeze({
+    type: actor.type,
+    id: normalizeNonblank(actor.id, "Event actor id")
+  });
+}
+function normalizeTimestamp(value, label) {
+  const milliseconds = Date.parse(value);
+  if (!Number.isFinite(milliseconds)) {
+    throw new MaterializationValidationError(`${label} must be a valid timestamp.`);
+  }
+  return new Date(milliseconds).toISOString();
+}
+function normalizePropertyIds(values, label) {
+  const seen = new Set;
+  const normalized = [];
+  for (const value of values) {
+    normalizeNonblank(value, label);
+    if (seen.has(value)) {
+      throw new MaterializationValidationError(`${label} contains duplicate '${value}'.`);
+    }
+    seen.add(value);
+    normalized.push(value);
+  }
+  return Object.freeze(normalized.sort(compareStrings));
+}
+function normalizeOperation(operation) {
+  normalizeNonblank(operation.id, "Operation id");
+  if (operation.kind === "object.create" || operation.kind === "object.upsert") {
+    return Object.freeze({
+      id: operation.id,
+      kind: operation.kind,
+      ref: normalizeObjectRef(operation.ref),
+      properties: normalizeJsonProperties(operation.properties)
+    });
+  }
+  if (operation.kind === "object.patch") {
+    const set = normalizeJsonProperties(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.`);
+      }
+    }
+    for (const propertyId of unset) {
+      if (reset.includes(propertyId)) {
+        throw new MaterializationValidationError(`Operation '${operation.id}' property '${propertyId}' appears in unset and reset.`);
+      }
+    }
+    return Object.freeze({
+      id: operation.id,
+      kind: operation.kind,
+      ref: normalizeObjectRef(operation.ref),
+      set,
+      unset,
+      reset
+    });
+  }
+  if (operation.kind === "object.delete" || operation.kind === "object.restore") {
+    return Object.freeze({
+      id: operation.id,
+      kind: operation.kind,
+      ref: normalizeObjectRef(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) } : {}
+    });
+  }
+  if (operation.kind === "link.delete" || operation.kind === "link.reset") {
+    return Object.freeze({
+      id: operation.id,
+      kind: operation.kind,
+      ref: normalizeLinkRef(operation.ref)
+    });
+  }
+  throw new MaterializationValidationError("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}.`);
+    }
+    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);
+  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.");
+  }
+  return Object.freeze({
+    ref,
+    exists: true,
+    version: value.version,
+    lastCommitId: normalizeNonblank(value.lastCommitId, "Expected object lastCommitId")
+  });
+}
+function normalizeExpectedLink(value) {
+  const ref = normalizeLinkRef(value.ref);
+  if (!value.exists)
+    return Object.freeze({ ref, exists: false });
+  return Object.freeze({
+    ref,
+    exists: true,
+    lastCommitId: normalizeNonblank(value.lastCommitId, "Expected link lastCommitId")
+  });
+}
+function normalizeExpectedLinkScope(value) {
+  return Object.freeze({
+    source: normalizeObjectRef(value.source),
+    linkId: normalizeNonblank(value.linkId, "Expected link scope link id"),
+    fingerprint: normalizeNonblank(value.fingerprint, "Expected link scope fingerprint")
+  });
+}
+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.");
+    }
+    const positions = group.map((id) => {
+      const position = operationIds.get(id);
+      if (position === undefined) {
+        throw new MaterializationValidationError(`Operation group references unknown operation id '${id}'.`);
+      }
+      if (grouped.has(id)) {
+        throw new MaterializationValidationError(`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.");
+    }
+    return { first, ids: Object.freeze([...group]) };
+  });
+  normalized.sort((left, right) => left.first - right.first);
+  return Object.freeze(normalized.map(({ ids }) => ids));
+}
+function normalizeOntologyEditCommit(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}'.`);
+    }
+    operationIds.set(normalized.id, index);
+    return normalized;
+  });
+  if (input.mode === "continue") {
+    return Object.freeze({
+      mode: "continue",
+      source: Object.freeze({
+        kind: "runtime",
+        requestId: normalizeNonblank(input.source.requestId, "Runtime request id")
+      }),
+      ...input.actor !== undefined ? { actor: normalizeEventActor(input.actor) } : {},
+      operations: Object.freeze(operations),
+      ...input.operationGroups !== undefined ? { operationGroups: normalizeOperationGroups(input.operationGroups, operationIds) } : {}
+    });
+  }
+  const source = input.source.kind === "action" ? Object.freeze({
+    kind: "action",
+    actionId: normalizeNonblank(input.source.actionId, "Action id"),
+    runId: normalizeNonblank(input.source.runId, "Action run id")
+  }) : Object.freeze({
+    kind: "runtime",
+    requestId: normalizeNonblank(input.source.requestId, "Runtime request id")
+  });
+  const expectedObjects = input.expectedObjects.map(normalizeExpectedObject);
+  const expectedLinks = input.expectedLinks.map(normalizeExpectedLink);
+  const expectedLinkScopes = input.expectedLinkScopes.map(normalizeExpectedLinkScope);
+  return Object.freeze({
+    mode: "atomic",
+    source,
+    ...input.actor !== undefined ? { actor: normalizeEventActor(input.actor) } : {},
+    operations: Object.freeze(operations),
+    expectedObjects: deduplicateExpectations(expectedObjects, (value) => objectRefKey(value.ref), "Expected objects"),
+    expectedLinks: deduplicateExpectations(expectedLinks, (value) => linkRefKey(value.ref), "Expected links"),
+    expectedLinkScopes: deduplicateExpectations(expectedLinkScopes, (value) => linkScopeKey(value.source, value.linkId), "Expected link scopes")
+  });
+}
+function normalizeProjectionSourceRef(source) {
+  return Object.freeze({
+    projectionId: normalizeNonblank(source.projectionId, "Projection id")
+  });
+}
+function normalizePinnedDatasetVersion(version) {
+  return Object.freeze({
+    datasetId: normalizeNonblank(version.datasetId, "Dataset id"),
+    versionId: normalizeNonblank(version.versionId, "Dataset version id"),
+    createdAt: normalizeTimestamp(version.createdAt, "Dataset version createdAt")
+  });
+}
+function normalizeProjectionRunId(runId) {
+  return normalizeNonblank(runId, "Projection run id");
+}
+function normalizeProjectionExecution(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) });
+}
+function normalizeProjectionAssertion(assertion) {
+  return assertion.kind === "object" ? Object.freeze({
+    kind: "object",
+    ref: normalizeObjectRef(assertion.ref),
+    properties: normalizeJsonProperties(assertion.properties)
+  }) : Object.freeze({
+    kind: "link",
+    ref: normalizeLinkRef(assertion.ref),
+    ...assertion.properties !== undefined ? { properties: normalizeJsonProperties(assertion.properties) } : {}
+  });
+}
+function normalizeProjectionSourceEntry(input) {
+  const root = normalizeProjectionEntity(input.root);
+  const seen = new Set;
+  const assertions = input.assertions.map((assertion) => {
+    const normalized = normalizeProjectionAssertion(assertion);
+    const key = projectionEntityKey(normalized);
+    if (seen.has(key)) {
+      throw new MaterializationValidationError(`Projection entry repeats asserted entity ${key}.`);
+    }
+    seen.add(key);
+    return normalized;
+  });
+  const rootKey = projectionEntityKey(root);
+  if (!seen.has(rootKey)) {
+    throw new MaterializationValidationError(`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.");
+    }
+    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.");
+      }
+    }
+  } 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.");
+  }
+  return Object.freeze({
+    root,
+    assertions: Object.freeze(assertions.sort((left, right) => compareStrings(projectionEntityKey(left), projectionEntityKey(right))))
+  });
+}
+function normalizeTelemetrySeries(series) {
+  return Object.freeze({
+    object: normalizeObjectRef(series.object),
+    propertyId: normalizeNonblank(series.propertyId, "Telemetry property id")
+  });
+}
+function normalizeTelemetryPoint(point) {
+  try {
+    assertJsonValue(point.value, "Telemetry point value");
+  } catch (error) {
+    throw new MaterializationValidationError(error instanceof Error ? error.message : "Telemetry point value must be JSON.");
+  }
+  return Object.freeze({
+    series: normalizeTelemetrySeries(point.series),
+    value: cloneJsonValue(point.value),
+    ...point.unit !== undefined ? { unit: normalizeNonblank(point.unit, "Telemetry point unit") } : {},
+    at: normalizeTimestamp(point.at, "Telemetry point timestamp")
+  });
+}
+function normalizeTelemetryAppend(input) {
+  const pointsByKey = new Map;
+  for (const point of input.points) {
+    const normalized = normalizeTelemetryPoint(point);
+    const key = telemetryPointKey(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}.`);
+    }
+    pointsByKey.set(key, normalized);
+  }
+  const points = [...pointsByKey.entries()].sort(([left], [right]) => compareStrings(left, right)).map(([, point]) => point);
+  const source = input.source.kind === "runtime" ? Object.freeze({
+    kind: "runtime",
+    requestId: normalizeNonblank(input.source.requestId, "Runtime request id")
+  }) : Object.freeze({
+    kind: "projection",
+    projection: normalizeProjectionSourceRef(input.source.projection),
+    datasetVersion: normalizePinnedDatasetVersion(input.source.datasetVersion),
+    execution: normalizeProjectionExecution(input.source.execution),
+    batchOrdinal: input.source.batchOrdinal,
+    sourceRowCount: input.source.sourceRowCount,
+    sourceRowsSkipped: input.source.sourceRowsSkipped,
+    inputExhausted: input.source.inputExhausted
+  });
+  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.");
+    }
+    if (!Number.isSafeInteger(source.sourceRowCount) || source.sourceRowCount < 0) {
+      throw new MaterializationValidationError("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.");
+    }
+    if (source.sourceRowsSkipped > source.sourceRowCount) {
+      throw new MaterializationValidationError("Telemetry projection sourceRowsSkipped cannot exceed sourceRowCount.");
+    }
+    if (typeof source.inputExhausted !== "boolean") {
+      throw new MaterializationValidationError("Telemetry projection inputExhausted must be a boolean.");
+    }
+  }
+  return Object.freeze({
+    source,
+    ...input.actor !== undefined ? { actor: normalizeEventActor(input.actor) } : {},
+    points: Object.freeze(points)
+  });
+}
+
+// src/materializer/edits/execution-units.ts
+function compileEditExecutionUnits(input) {
+  const groupByFirstId = new Map((input.operationGroups ?? []).map((ids) => [ids[0], new Set(ids)]));
+  const units = [];
+  for (let index = 0;index < input.operations.length; ) {
+    const operation = input.operations[index];
+    const groupIds = groupByFirstId.get(operation.id);
+    if (!groupIds) {
+      units.push({ kind: "single", operation });
+      index += 1;
+      continue;
+    }
+    const operations = input.operations.slice(index, index + groupIds.size);
+    units.push({ kind: "atomic-group", operations });
+    index += operations.length;
+  }
+  return units;
+}
+
+// src/materializer/effective/load-state.ts
+async function* oneStateRequest(request) {
+  yield request;
+}
+async function loadState(context, storage, session, request) {
+  const result = { objects: [], links: [], linkScopes: [], points: [] };
+  for await (const page of storage.streamState({
+    session,
+    requests: oneStateRequest(request),
+    pageRows: context.batching.statePageRows
+  })) {
+    result.objects.push(...page.objects);
+    result.links.push(...page.links);
+    result.linkScopes.push(...page.linkScopes);
+    result.points.push(...page.points);
+  }
+  return result;
+}
+
+// src/materializer/edits/read-set.ts
+function buildEditReadSet(ontology, operations) {
+  const objects = new Map;
+  const links = new Map;
+  const scopes = new Map;
+  const incidentObjects = new Map;
+  for (const operation of operations) {
+    if (isObjectOperation(operation)) {
+      if (!ontology.getObjectTypeById(operation.ref.objectTypeId))
+        continue;
+      objects.set(objectRefKey(operation.ref), operation.ref);
+      if (operation.kind !== "object.patch") {
+        incidentObjects.set(objectRefKey(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);
+    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),
+    linkScopes: [...scopes.values()].sort((left, right) => linkScopeKey(left.source, left.linkId).localeCompare(linkScopeKey(right.source, right.linkId))),
+    incidentObjects: [...incidentObjects.values()].sort(compareObjectRefs),
+    points: []
+  };
+}
+function isKnownLinkRef(ontology, ref) {
+  const sourceType = ontology.getObjectTypeById(ref.source.objectTypeId);
+  if (!sourceType || !ontology.getObjectTypeById(ref.target.objectTypeId))
+    return false;
+  const link = sourceType.links.find((candidate) => candidate.id === ref.linkId);
+  return Boolean(link && ontology.isValidLinkTarget(link.targetObjectTypeId, ref.target.objectTypeId));
+}
+function linkCardinality(ontology, ref) {
+  const definition = ontology.getObjectTypeById(ref.source.objectTypeId)?.links.find((candidate) => candidate.id === ref.linkId);
+  return definition?.cardinality ?? "many";
+}
+function isObjectOperation(operation) {
+  return operation.kind.startsWith("object.");
+}
+
+// src/materializer/effective/resolve.ts
+function resolveEffectiveObject(input) {
+  const properties = resolveObjectAuthority(input.source, input.override);
+  if (!properties)
+    return null;
+  properties[input.primaryPropertyId] = input.ref.primaryId;
+  applyLatestTelemetry(properties, input.latestTelemetry);
+  return { ref: input.ref, properties };
+}
+function resolveObjectAuthority(source, override) {
+  switch (override?.kind) {
+    case "delete":
+      return null;
+    case "create":
+      return { ...override.properties };
+    case "patch":
+      if (!source)
+        return null;
+      return applyObjectPatch(source.assertion.properties, override);
+    default:
+      if (!source)
+        return null;
+      return { ...source.assertion.properties };
+  }
+}
+function applyObjectPatch(sourceProperties, override) {
+  const properties = { ...sourceProperties, ...override.set };
+  for (const propertyId of override.unset)
+    delete properties[propertyId];
+  return properties;
+}
+function applyLatestTelemetry(properties, latestTelemetry) {
+  for (const point of latestTelemetry)
+    properties[point.series.propertyId] = point.value;
+}
+function resolveEffectiveLink(input) {
+  if (!input.sourceEndpointExists || !input.targetEndpointExists)
+    return null;
+  if (input.override?.kind === "delete")
+    return null;
+  if (input.override?.kind === "upsert") {
+    return resolvedLink(input.ref, input.override.properties);
+  }
+  if (!input.source)
+    return null;
+  return resolvedLink(input.ref, input.source.assertion.properties);
+}
+function resolvedLink(ref, properties) {
+  if (properties === undefined)
+    return { ref };
+  return { ref, properties };
+}
+
+// src/materializer/edits/working-state.ts
+function mergeWorkingState(objects, links, scopes, state) {
+  for (const object of state.objects) {
+    if (!objects.has(objectRefKey(object.ref))) {
+      objects.set(objectRefKey(object.ref), workingObjectFromState(object));
+    }
+  }
+  for (const link of state.links) {
+    if (!links.has(linkRefKey(link.ref))) {
+      links.set(linkRefKey(link.ref), workingLinkFromState(link));
+    }
+  }
+  for (const scope of state.linkScopes) {
+    if (!scopes.has(linkScopeKey(scope.source, scope.linkId))) {
+      scopes.set(linkScopeKey(scope.source, scope.linkId), scope);
+    }
+  }
+}
+function workingObjectFromState(object) {
+  return {
+    ref: object.ref,
+    source: object.source,
+    originalOverride: object.override,
+    override: object.override?.value ?? null,
+    before: object.effective,
+    latestTelemetry: [...object.latestTelemetry]
+  };
+}
+function workingLinkFromState(link) {
+  return {
+    ref: link.ref,
+    source: link.source,
+    originalOverride: link.override,
+    override: link.override?.value ?? null,
+    before: link.effective
+  };
+}
+function resolveObject(ontology, working) {
+  return resolveEffectiveObject({
+    ref: working.ref,
+    primaryPropertyId: ontology.getPrimaryPropertyId(working.ref.objectTypeId),
+    source: working.source,
+    override: working.override,
+    latestTelemetry: working.latestTelemetry
+  });
+}
+function resolveLink(ontology, working, objects) {
+  const source = objects.get(objectRefKey(working.ref.source));
+  const target = objects.get(objectRefKey(working.ref.target));
+  return resolveEffectiveLink({
+    ref: working.ref,
+    source: working.source,
+    override: working.override,
+    sourceEndpointExists: Boolean(source && resolveObject(ontology, source)),
+    targetEndpointExists: Boolean(target && resolveObject(ontology, target))
+  });
+}
+function distinctCardinalityOneScopes(ontology, links, existing) {
+  const scopes = new Map;
+  for (const state of links) {
+    const definition = ontology.resolveObjectType(state.ref.source.objectTypeId).links.find((candidate) => candidate.id === state.ref.linkId);
+    const key = linkScopeKey(state.ref.source, state.ref.linkId);
+    if (definition?.cardinality === "one" && !existing.has(key)) {
+      scopes.set(key, { source: state.ref.source, linkId: state.ref.linkId });
+    }
+  }
+  return [...scopes.values()];
+}
+function validateWorkingCardinality(ontology, objects, links, scopes) {
+  const effectiveByScope = new Map;
+  for (const [scope, snapshot] of scopes) {
+    effectiveByScope.set(scope, {
+      count: snapshot.effectiveCount,
+      source: snapshot.source,
+      linkId: snapshot.linkId
+    });
+  }
+  for (const working of links.values()) {
+    if (!isKnownLinkRef(ontology, working.ref))
+      continue;
+    const scope = linkScopeKey(working.ref.source, working.ref.linkId);
+    const state = effectiveByScope.get(scope);
+    if (!state)
+      continue;
+    const before = working.before ? 1 : 0;
+    const after = resolveLink(ontology, working, objects) ? 1 : 0;
+    state.count += after - before;
+  }
+  for (const { count, source, linkId } of effectiveByScope.values()) {
+    if (count <= 1)
+      continue;
+    const link = ontology.resolveObjectType(source.objectTypeId).links.find((candidate) => candidate.id === linkId);
+    if (link?.cardinality === "one") {
+      throw new MaterializationValidationError(`Link scope '${source.objectTypeId}.${linkId}' has cardinality one.`);
+    }
+  }
+}
+
+// src/materializer/edits/load-state.ts
+async function loadEditWorkingState(context, storage, session, operations) {
+  const state = {
+    objects: new Map,
+    links: new Map,
+    scopeSnapshots: new Map
+  };
+  const readSet = buildEditReadSet(context.ontology, operations);
+  const explicitLinkKeys = new Set(readSet.links.map(linkRefKey));
+  const incidentLinks = new Map;
+  const ignoredLinks = new Map;
+  const revivingObjects = new Set(operations.filter(isRevivingObjectOperation).map((operation) => objectRefKey(operation.ref)));
+  for await (const page of storage.streamState({
+    session,
+    requests: oneStateRequest(readSet),
+    pageRows: context.batching.statePageRows
+  })) {
+    mergeWorkingState(state.objects, ignoredLinks, state.scopeSnapshots, page);
+    for (const link of page.links) {
+      const key = linkRefKey(link.ref);
+      if (explicitLinkKeys.has(key) && !state.links.has(key)) {
+        state.links.set(key, workingLinkFromState(link));
+      }
+      if (readSet.incidentObjects.length > 0)
+        incidentLinks.set(key, link);
+    }
+  }
+  await mergeIncidentState(context, storage, session, state, [...incidentLinks.values()], revivingObjects);
+  return state;
+}
+function isRevivingObjectOperation(operation) {
+  return operation.kind === "object.create" || operation.kind === "object.upsert" || operation.kind === "object.restore";
+}
+async function mergeIncidentState(context, storage, session, state, incidentStates, revivingObjects) {
+  const knownIncidentStates = incidentStates.filter((link) => isKnownLinkRef(context.ontology, link.ref));
+  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 (missingEndpoints.size > 0) {
+    await mergeLoadedState(context, storage, session, state, {
+      objects: [...missingEndpoints.values()],
+      links: [],
+      linkScopes: [],
+      incidentObjects: [],
+      points: []
+    });
+  }
+  const relevantStates = knownIncidentStates.filter((link) => {
+    if (link.effective)
+      return true;
+    if (revivingObjects.has(objectRefKey(link.ref.source)) || revivingObjects.has(objectRefKey(link.ref.target))) {
+      return true;
+    }
+    return Boolean(resolveLink(context.ontology, workingLinkFromState(link), state.objects));
+  });
+  const missingScopes = distinctCardinalityOneScopes(context.ontology, relevantStates, state.scopeSnapshots);
+  if (missingScopes.length > 0) {
+    await mergeLoadedState(context, storage, session, state, {
+      objects: [],
+      links: [],
+      linkScopes: missingScopes,
+      incidentObjects: [],
+      points: []
+    });
+  }
+  for (const link of relevantStates) {
+    const key = linkRefKey(link.ref);
+    if (state.links.has(key))
+      continue;
+    state.links.set(key, workingLinkFromState(link));
+  }
+  context.observeCoreBuffer?.("edits.incident-links", state.links.size);
+}
+async function mergeLoadedState(context, storage, session, state, request) {
+  const loaded = await loadState(context, storage, session, request);
+  mergeWorkingState(state.objects, state.links, state.scopeSnapshots, loaded);
+}
+
+// src/materializer/effective/diff.ts
+function diffEffectiveObject(input) {
+  if (!input.before) {
+    if (!input.resolved)
+      return null;
+    return createObjectChange(input.resolved, input.commitId, input.committedAt);
+  }
+  if (!input.resolved)
+    return deleteObjectChange(input.before);
+  if (sameProperties(input.before.properties, input.resolved.properties))
+    return null;
+  return updateObjectChange(input.before, input.resolved, input.commitId, input.committedAt);
+}
+function createObjectChange(resolved, commitId, committedAt) {
+  const after = {
+    ...resolved,
+    version: 1,
+    createdAt: committedAt,
+    updatedAt: committedAt,
+    lastCommitId: commitId
+  };
+  return {
+    kind: "created",
+    ref: after.ref,
+    before: null,
+    after,
+    propertyChanges: propertyChanges({}, after.properties)
+  };
+}
+function deleteObjectChange(before) {
+  return {
+    kind: "deleted",
+    ref: before.ref,
+    before,
+    after: null,
+    propertyChanges: propertyChanges(before.properties, {})
+  };
+}
+function updateObjectChange(before, resolved, commitId, committedAt) {
+  const after = {
+    ...resolved,
+    version: before.version + 1,
+    createdAt: before.createdAt,
+    updatedAt: committedAt,
+    lastCommitId: commitId
+  };
+  return {
+    kind: "updated",
+    ref: after.ref,
+    before,
+    after,
+    propertyChanges: propertyChanges(before.properties, after.properties)
+  };
+}
+function diffEffectiveLink(input) {
+  if (!input.before) {
+    if (!input.resolved)
+      return null;
+    return createLinkChange(input.resolved, input.commitId, input.committedAt);
+  }
+  if (!input.resolved)
+    return deleteLinkChange(input.before);
+  if (sameProperties(input.before.properties ?? {}, input.resolved.properties ?? {}))
+    return null;
+  return updateLinkChange(input.before, input.resolved, input.commitId, input.committedAt);
+}
+function createLinkChange(resolved, commitId, committedAt) {
+  const after = {
+    ...resolved,
+    createdAt: committedAt,
+    updatedAt: committedAt,
+    lastCommitId: commitId
+  };
+  return {
+    kind: "created",
+    ref: after.ref,
+    before: null,
+    after,
+    propertyChanges: propertyChanges({}, after.properties ?? {})
+  };
+}
+function deleteLinkChange(before) {
+  return {
+    kind: "deleted",
+    ref: before.ref,
+    before,
+    after: null,
+    propertyChanges: propertyChanges(before.properties ?? {}, {})
+  };
+}
+function updateLinkChange(before, resolved, commitId, committedAt) {
+  const after = {
+    ...resolved,
+    createdAt: before.createdAt,
+    updatedAt: committedAt,
+    lastCommitId: commitId
+  };
+  return {
+    kind: "updated",
+    ref: after.ref,
+    before,
+    after,
+    propertyChanges: propertyChanges(before.properties ?? {}, after.properties ?? {})
+  };
+}
+function sameProperties(left, right) {
+  return stableJsonStringify(left) === stableJsonStringify(right);
+}
+function propertyChanges(before, after) {
+  const changes = {};
+  const ids = [...new Set([...Object.keys(before), ...Object.keys(after)])].sort(compareStrings);
+  for (const id of ids) {
+    if (!(id in before))
+      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])) {
+      changes[id] = { operation: "updated", before: before[id], after: after[id] };
+    }
+  }
+  return changes;
+}
+
+// src/materializer/effective/validate.ts
+function validateObjectRef(ontology, ref) {
+  materializationValidation(() => {
+    ontology.resolveObjectType(ref.objectTypeId);
+  });
+}
+function validateLinkRef(ontology, ref) {
+  materializationValidation(() => {
+    const sourceType = ontology.resolveObjectType(ref.source.objectTypeId);
+    ontology.resolveObjectType(ref.target.objectTypeId);
+    const link = sourceType.links.find((candidate) => candidate.id === ref.linkId);
+    if (!link)
+      throw new Error(`[Sixb] Unknown link '${ref.source.objectTypeId}.${ref.linkId}'.`);
+    if (!ontology.isValidLinkTarget(link.targetObjectTypeId, ref.target.objectTypeId)) {
+      throw new Error(`[Sixb] Link '${ref.source.objectTypeId}.${ref.linkId}' cannot target '${ref.target.objectTypeId}'.`);
+    }
+  });
+}
+function validateObjectAuthorityProperties(ontology, ref, properties) {
+  return materializationValidation(() => {
+    const objectType = ontology.resolveObjectType(ref.objectTypeId);
+    assertKnownProperties(objectType, properties);
+    const primaryId = ontology.getPrimaryPropertyId(ref.objectTypeId);
+    const result = { ...properties };
+    if (primaryId in result) {
+      if (result[primaryId] !== ref.primaryId) {
+        throw new Error(`[Sixb] Primary property '${primaryId}' must match object identity '${ref.primaryId}'.`);
+      }
+      delete result[primaryId];
+    }
+    for (const propertyId of Object.keys(result)) {
+      const property = objectType.properties.find((candidate) => candidate.id === propertyId);
+      if (property.mode === "telemetry") {
+        throw new Error(`[Sixb] Static authority cannot write telemetry property '${ref.objectTypeId}.${propertyId}'.`);
+      }
+    }
+    const valueTypesById = ontology.getValueTypesById();
+    validateObjectProperties(objectType, result, valueTypesById);
+    return normalizeObjectProperties(objectType.properties, result, valueTypesById, objectType.id);
+  });
+}
+function validateObjectPatchPropertyIds(ontology, ref, propertyIds, label) {
+  materializationValidation(() => {
+    const objectType = ontology.resolveObjectType(ref.objectTypeId);
+    const primaryId = ontology.getPrimaryPropertyId(ref.objectTypeId);
+    for (const propertyId of propertyIds) {
+      const property = objectType.properties.find((candidate) => candidate.id === propertyId);
+      if (!property) {
+        throw new Error(`[Sixb] Object patch ${label} references unknown property '${ref.objectTypeId}.${propertyId}'.`);
+      }
+      if (propertyId === primaryId) {
+        throw new Error(`[Sixb] Object patch ${label} cannot target primary property '${ref.objectTypeId}.${propertyId}'.`);
+      }
+      if (property.mode === "telemetry") {
+        throw new Error(`[Sixb] Object patch ${label} cannot target telemetry property '${ref.objectTypeId}.${propertyId}'.`);
+      }
+    }
+  });
+}
+function validateEffectiveObject(ontology, ref, properties) {
+  materializationValidation(() => {
+    const objectType = ontology.resolveObjectType(ref.objectTypeId);
+    assertKnownProperties(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());
+  });
+}
+function validateLinkAuthorityProperties(ontology, ref, properties) {
+  return materializationValidation(() => {
+    const objectType = ontology.resolveObjectType(ref.source.objectTypeId);
+    const link = objectType.links.find((candidate) => candidate.id === ref.linkId);
+    if (!link)
+      throw new Error(`[Sixb] Unknown link '${ref.source.objectTypeId}.${ref.linkId}'.`);
+    if (!ontology.isValidLinkTarget(link.targetObjectTypeId, ref.target.objectTypeId)) {
+      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);
+  });
+}
+function validateTelemetryPoint(ontology, point) {
+  return materializationValidation(() => {
+    const objectType = ontology.resolveObjectType(point.series.object.objectTypeId);
+    const property = objectType.properties.find((candidate) => candidate.id === point.series.propertyId);
+    if (!property || property.mode !== "telemetry") {
+      throw new Error(`[Sixb] Property '${point.series.object.objectTypeId}.${point.series.propertyId}' is not telemetry-enabled.`);
+    }
+    const path = `${objectType.id}.${property.id}`;
+    const valueTypesById = ontology.getValueTypesById();
+    validatePropertyValue(property, point.value, path, valueTypesById);
+    validateTelemetryUnit(property, path, point.unit, valueTypesById);
+    return {
+      ...point,
+      value: point.value === null ? null : normalizeSchemaValue(property.schema, point.value, path, valueTypesById)
+    };
+  });
+}
+function materializationValidation(run) {
+  try {
+    return run();
+  } catch (error) {
+    if (error instanceof MaterializationValidationError)
+      throw error;
+    throw new MaterializationValidationError(error instanceof Error ? error.message : String(error));
+  }
+}
+
+// src/materializer/edits/apply.ts
+function applyObjectEdit(input) {
+  const current = input.authority;
+  let next;
+  switch (input.operation.kind) {
+    case "object.create":
+      next = applyObjectCreate(input, input.operation);
+      break;
+    case "object.upsert":
+      next = applyObjectUpsert(input, input.operation);
+      break;
+    case "object.patch":
+      next = applyObjectPatch2(input, input.operation);
+      break;
+    case "object.delete":
+      next = applyObjectDelete(input);
+      break;
+    case "object.restore":
+      next = applyObjectRestore(input);
+      break;
+    default:
+      throw new MaterializationValidationError("Expected an object edit operation.");
+  }
+  return transition(current, next);
+}
+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}.`);
+  }
+  return { kind: "create", properties: input.normalizedProperties ?? operation.properties };
+}
+function applyObjectUpsert(input, operation) {
+  const properties = input.normalizedProperties ?? operation.properties;
+  const current = input.authority;
+  if (current?.kind === "create") {
+    return { kind: "create", properties: { ...current.properties, ...properties } };
+  }
+  if (current?.kind === "patch") {
+    return mergeUpsertIntoPatch(current, properties, input.sourceProperties !== null);
+  }
+  if (input.sourceProperties)
+    return { kind: "patch", set: properties, unset: [] };
+  return { kind: "create", properties };
+}
+function mergeUpsertIntoPatch(current, properties, hasSource) {
+  if (hasSource) {
+    const unset = current.unset.filter((propertyId) => !(propertyId in properties));
+    return { kind: "patch", set: { ...current.set, ...properties }, unset };
+  }
+  const created = { ...current.set };
+  for (const propertyId of current.unset)
+    delete created[propertyId];
+  return { kind: "create", properties: { ...created, ...properties } };
+}
+function applyObjectPatch2(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}.`);
+  }
+  const setInput = input.normalizedSet ?? operation.set;
+  if (current?.kind === "create" && !input.sourceProperties) {
+    return patchCreatedObject(current, operation, setInput);
+  }
+  return patchOverride(toPatchOverride(current), operation, setInput);
+}
+function patchCreatedObject(current, operation, setInput) {
+  const properties = { ...current.properties, ...setInput };
+  for (const propertyId of [...operation.unset, ...operation.reset]) {
+    delete properties[propertyId];
+  }
+  return { kind: "create", properties };
+}
+function toPatchOverride(current) {
+  if (current?.kind === "patch")
+    return current;
+  if (current?.kind === "create") {
+    return { kind: "patch", set: { ...current.properties }, unset: [] };
+  }
+  return { kind: "patch", set: {}, unset: [] };
+}
+function patchOverride(base, operation, setInput) {
+  const set = { ...base.set };
+  const unset = new Set(base.unset);
+  for (const propertyId of operation.reset) {
+    delete set[propertyId];
+    unset.delete(propertyId);
+  }
+  for (const propertyId of operation.unset) {
+    delete set[propertyId];
+    unset.add(propertyId);
+  }
+  for (const [propertyId, value] of Object.entries(setInput)) {
+    set[propertyId] = value;
+    unset.delete(propertyId);
+  }
+  if (Object.keys(set).length === 0 && unset.size === 0)
+    return null;
+  return { kind: "patch", set, unset: [...unset].sort() };
+}
+function applyObjectDelete(input) {
+  if (!input.effectiveExists)
+    return input.authority;
+  if (input.authority?.kind === "create" && !input.sourceProperties)
+    return null;
+  return { kind: "delete" };
+}
+function applyObjectRestore(input) {
+  if (input.authority?.kind !== "delete")
+    return input.authority;
+  return null;
+}
+function applyLinkEdit(input) {
+  const current = input.authority;
+  let next;
+  switch (input.operation.kind) {
+    case "link.upsert":
+      next = linkUpsertOverride(input);
+      break;
+    case "link.delete":
+      next = linkDeleteOverride(input);
+      break;
+    case "link.reset":
+      next = null;
+      break;
+    default:
+      throw new MaterializationValidationError("Expected a link edit operation.");
+  }
+  return transition(current, next);
+}
+function linkUpsertOverride(input) {
+  if (input.normalizedProperties !== undefined) {
+    return { kind: "upsert", properties: input.normalizedProperties };
+  }
+  if (input.operation.kind === "link.upsert" && input.operation.properties !== undefined) {
+    return { kind: "upsert", properties: input.operation.properties };
+  }
+  return { kind: "upsert" };
+}
+function linkDeleteOverride(input) {
+  if (!input.effectiveExists)
+    return input.authority;
+  if (input.authority?.kind === "upsert" && !input.hasSource)
+    return null;
+  return { kind: "delete" };
+}
+function transition(current, next) {
+  return { next, changed: !sameAuthority(current, next) };
+}
+function sameAuthority(left, right) {
+  return stableJsonStringify(left) === stableJsonStringify(right);
+}
+
+// src/materializer/edits/operations.ts
+function undoEditJournal(journal) {
+  for (let index = journal.length - 1;index >= 0; index -= 1) {
+    journal[index]?.restore();
+  }
+}
+function applyEditOperation(context, state, operation, identity, journal) {
+  validateOperationRef(context, operation);
+  if (isObjectOperation2(operation)) {
+    return applyObjectOperation(context, state, operation, identity, journal);
+  }
+  return applyLinkOperation(context, state, operation, linkCardinality(context.ontology, operation.ref), journal);
+}
+function validateOperationRef(context, operation) {
+  if (isObjectOperation2(operation)) {
+    validateObjectRef(context.ontology, operation.ref);
+    return;
+  }
+  validateLinkRef(context.ontology, operation.ref);
+}
+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({
+    operation,
+    sourceProperties: working.source?.assertion.properties ?? null,
+    authority: working.override,
+    effectiveExists: currentEffective !== null,
+    ...normalized
+  });
+  applyObjectTransition(context, state, working, transition2.next, journal);
+  return objectOperationOutcome(operation, working, transition2.changed, context, identity);
+}
+function requireWorkingObject(state, operation) {
+  const working = state.objects.get(objectRefKey(operation.ref));
+  if (!working)
+    throw new MaterializationValidationError("Object state was not loaded.");
+  return working;
+}
+function validateObjectOperation(context, operation) {
+  switch (operation.kind) {
+    case "object.create":
+    case "object.upsert":
+      return {
+        normalizedProperties: validateObjectAuthorityProperties(context.ontology, operation.ref, operation.properties)
+      };
+    case "object.patch":
+      validateObjectPatchPropertyIds(context.ontology, operation.ref, operation.unset, "unset");
+      validateObjectPatchPropertyIds(context.ontology, operation.ref, operation.reset, "reset");
+      return {
+        normalizedSet: validateObjectAuthorityProperties(context.ontology, operation.ref, operation.set)
+      };
+    case "object.delete":
+    case "object.restore":
+      return {};
+  }
+}
+function applyObjectTransition(context, state, working, next, journal) {
+  const previous = working.override;
+  working.override = next;
+  try {
+    const resolved = resolveObject(context.ontology, working);
+    if (resolved)
+      validateEffectiveObject(context.ontology, resolved.ref, resolved.properties);
+    validateWorkingCardinality(context.ontology, state.objects, state.links, state.scopeSnapshots);
+  } catch (error) {
+    working.override = previous;
+    throw error;
+  }
+  journal?.push({
+    restore: () => {
+      working.override = previous;
+    }
+  });
+}
+function objectOperationOutcome(operation, working, changed, context, identity) {
+  const outcome = {
+    id: operation.id,
+    ok: true,
+    authority: authorityOutcome(changed)
+  };
+  const resolved = resolveObject(context.ontology, working);
+  if (!resolved)
+    return outcome;
+  const change = diffEffectiveObject({
+    before: working.before,
+    resolved,
+    commitId: identity.commitId,
+    committedAt: identity.committedAt
+  });
+  const object = change?.after ?? working.before;
+  if (!object) {
+    throw new MaterializationValidationError("Effective object outcome could not be resolved.");
+  }
+  return { ...outcome, object };
+}
+function applyLinkOperation(context, state, operation, cardinality, journal) {
+  const working = requireWorkingLink(state, operation);
+  validateLinkEndpoints(context, state, operation);
+  const normalizedProperties = validateLinkOperation(context, operation);
+  const currentEffective = resolveLink(context.ontology, working, state.objects);
+  const transitionInput = {
+    operation,
+    hasSource: working.source !== null,
+    authority: working.override,
+    effectiveExists: currentEffective !== null
+  };
+  const transition2 = applyLinkEdit({ ...transitionInput, normalizedProperties });
+  applyLinkTransition(context, state, working, transition2.next, cardinality, journal);
+  return { id: operation.id, ok: true, authority: authorityOutcome(transition2.changed) };
+}
+function requireWorkingLink(state, operation) {
+  const working = state.links.get(linkRefKey(operation.ref));
+  if (!working)
+    throw new MaterializationValidationError("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 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.");
+}
+function validateLinkOperation(context, operation) {
+  if (operation.kind !== "link.upsert")
+    return;
+  return validateLinkAuthorityProperties(context.ontology, operation.ref, operation.properties);
+}
+function applyLinkTransition(context, state, working, next, cardinality, journal) {
+  const previous = working.override;
+  working.override = next;
+  try {
+    if (cardinality === "one") {
+      validateWorkingCardinality(context.ontology, state.objects, state.links, state.scopeSnapshots);
+    }
+  } catch (error) {
+    working.override = previous;
+    throw error;
+  }
+  journal?.push({
+    restore: () => {
+      working.override = previous;
+    }
+  });
+}
+function authorityOutcome(changed) {
+  if (changed)
+    return "changed";
+  return "unchanged";
+}
+function isObjectOperation2(operation) {
+  switch (operation.kind) {
+    case "object.create":
+    case "object.upsert":
+    case "object.patch":
+    case "object.delete":
+    case "object.restore":
+      return true;
+    case "link.upsert":
+    case "link.delete":
+    case "link.reset":
+      return false;
+  }
+}
+
+// src/materializer/edits/plan.ts
+async function stageEditPlan(context, storage, session, state, planContext) {
+  validateWorkingCardinality(context.ontology, state.objects, state.links, state.scopeSnapshots);
+  const objectChanges = [];
+  for (const working of sortedObjects(state.objects)) {
+    const change = await stageObjectPlan(context, storage, session, working, planContext);
+    if (change)
+      objectChanges.push(change);
+  }
+  const linkChanges = [];
+  for (const working of sortedLinks(state.links)) {
+    const change = await stageLinkPlan(context, storage, session, state.objects, working, planContext);
+    if (change)
+      linkChanges.push(change);
+  }
+  return { objects: objectChanges, links: linkChanges };
+}
+async function stageObjectPlan(context, storage, session, working, planContext) {
+  const items = [];
+  appendObjectOverridePlan(items, working, planContext.identity);
+  const resolved = resolveObject(context.ontology, working);
+  if (resolved)
+    validateEffectiveObject(context.ontology, resolved.ref, resolved.properties);
+  const change = diffEffectiveObject({
+    before: working.before,
+    resolved,
+    commitId: planContext.identity.commitId,
+    committedAt: planContext.identity.committedAt
+  });
+  if (change)
+    appendObjectEffectivePlan(items, change);
+  const sortKey = objectRefSortKey(working.ref);
+  const work = [
+    classificationWork("object", objectRefKey(working.ref), sortKey),
+    ...items.map((item) => planWork(item, sortKey))
+  ];
+  if (change) {
+    work.push(eventWork(buildObjectEvent(context, planContext, change)));
+  }
+  await stageWorkBounded(context, storage, session, work);
+  return change;
+}
+async function stageLinkPlan(context, storage, session, objects, working, planContext) {
+  const items = [];
+  appendLinkOverridePlan(items, working, planContext.identity);
+  const resolved = resolveLink(context.ontology, working, objects);
+  const change = diffEffectiveLink({
+    before: working.before,
+    resolved,
+    commitId: planContext.identity.commitId,
+    committedAt: planContext.identity.committedAt
+  });
+  if (change)
+    appendLinkEffectivePlan(items, change);
+  const sortKey = linkRefSortKey(working.ref);
+  const work = [
+    classificationWork("link", linkRefKey(working.ref), sortKey),
+    ...items.map((item) => planWork(item, sortKey))
+  ];
+  if (change) {
+    work.push(eventWork(buildLinkEvent(context, planContext, change)));
+  }
+  await stageWorkBounded(context, storage, session, work);
+  return change;
+}
+function buildObjectEvent(context, planContext, change) {
+  const eventContext = materializationEventContext(context, planContext);
+  return buildObjectMaterializationEventDraft({ ...eventContext, change });
+}
+function buildLinkEvent(context, planContext, change) {
+  const eventContext = materializationEventContext(context, planContext);
+  return buildLinkMaterializationEventDraft({ ...eventContext, change });
+}
+function materializationEventContext(context, planContext) {
+  const base = {
+    projectId: context.projectId,
+    commitId: planContext.identity.commitId,
+    committedAt: planContext.identity.committedAt,
+    origin: planContext.origin
+  };
+  if (planContext.actor === undefined)
+    return base;
+  return { ...base, actor: planContext.actor };
+}
+function sortedObjects(objects) {
+  return [...objects.values()].sort((left, right) => compareObjectRefs(left.ref, right.ref));
+}
+function sortedLinks(links) {
+  return [...links.values()].sort((left, right) => compareLinkRefs(left.ref, right.ref));
+}
+
+// src/materializer/edits/commit.ts
+async function commitEdits(context, raw) {
+  const command = prepareEditCommit(context, raw);
+  const replay = await replayEditCommit(context, command);
+  if (replay)
+    return replay;
+  return executeEditCommit(context, command);
+}
+function prepareEditCommit(context, raw) {
+  const input = normalizeOntologyEditCommit(raw);
+  const idempotencyKey = editIdempotencyKey(input);
+  const identity = createTimedCommitIdentity({
+    projectId: context.projectId,
+    idempotencyKey,
+    normalizedCallerIntent: input,
+    now: context.clock()
+  });
+  return { input, identity, origin: input.source };
+}
+function editIdempotencyKey(input) {
+  if (input.source.kind === "action") {
+    return createActionIdempotencyKey(input.source.runId);
+  }
+  return createRuntimeIdempotencyKey(input.source.requestId);
+}
+async function lockActionRunForMaterialization(storage, projectId, input) {
+  if (input.source.kind !== "action")
+    return;
+  if (!storage.actionRuns) {
+    throw new MaterializationValidationError("Storage does not provide Action run capabilities required by this commit.");
+  }
+  await storage.actionRuns.lockForMaterialization({
+    projectId,
+    actionId: input.source.actionId,
+    runId: input.source.runId
+  });
+}
+function replayEditCommit(context, command) {
+  return replayCommit(context, command.identity);
+}
+async function executeEditCommit(context, command) {
+  return withSerializationRetry(context, () => context.storage.transaction((storage) => executeEditTransaction(context, storage, command), {
+    isolation: "serializable"
+  }));
+}
+async function executeEditTransaction(context, storage, command) {
+  await lockActionRunForMaterialization(storage, context.projectId, command.input);
+  const replay = await replayCommit(context, command.identity, storage);
+  if (replay)
+    return replay;
+  const session = await beginEditMaterialization(context, storage, command);
+  const workingState = await loadEditWorkingState(context, storage.ontology.materializations, session, command.input.operations);
+  const outcomes = applyEditOperations(context, workingState, command);
+  const changes = await stageEditPlan(context, storage.ontology.materializations, session, workingState, editPlanContext(command));
+  await drainStagedWork(context, storage.ontology.materializations, session);
+  const eventCount = await drainStagedEvents(context, storage.ontology.materializations, session, command.identity);
+  const result = {
+    kind: "edit",
+    commitId: command.identity.commitId,
+    created: true,
+    eventCount,
+    committedAt: command.identity.committedAt,
+    outcomes,
+    changes
+  };
+  return finalizeEditMaterialization(storage, session, result);
+}
+async function beginEditMaterialization(context, storage, command) {
+  const commit = buildEditCommit(context, command);
+  return storage.ontology.materializations.begin({
+    commit,
+    expected: {
+      sources: [],
+      ...editExpectations(command.input),
+      points: []
+    }
+  });
+}
+function buildEditCommit(context, command) {
+  const commit = {
+    projectId: context.projectId,
+    id: command.identity.commitId,
+    idempotencyKey: command.identity.idempotencyKey,
+    requestHash: command.identity.requestHash,
+    origin: command.origin,
+    ontologyRevision: context.projectionRegistry.ontologyRevision,
+    intent: {
+      kind: "edit",
+      mode: command.input.mode,
+      operationCount: command.input.operations.length
+    },
+    committedAt: command.identity.committedAt
+  };
+  if (command.input.actor === undefined)
+    return commit;
+  return { ...commit, actor: command.input.actor };
+}
+function editExpectations(input) {
+  if (input.mode === "atomic") {
+    return {
+      objects: input.expectedObjects,
+      links: input.expectedLinks,
+      linkScopes: input.expectedLinkScopes
+    };
+  }
+  return { objects: [], links: [], linkScopes: [] };
+}
+function applyEditOperations(context, state, command) {
+  const outcomes = [];
+  const units = compileEditExecutionUnits(command.input);
+  for (const unit of units) {
+    outcomes.push(...applyEditExecutionUnit(context, state, command, unit));
+  }
+  return outcomes;
+}
+function applyEditExecutionUnit(context, state, command, unit) {
+  if (unit.kind === "atomic-group") {
+    return applyEditOperationGroup(context, state, command, unit.operations);
+  }
+  return [applyOneEditOperation(context, state, unit.operation, command)];
+}
+function applyOneEditOperation(context, state, operation, command) {
+  try {
+    return applyEditOperation(context, state, operation, command.identity);
+  } catch (error) {
+    if (!isRecoverableEditValidation(command.input, error))
+      throw error;
+    return { id: operation.id, ok: false, error: { code: "validation", message: error.message } };
+  }
+}
+function applyEditOperationGroup(context, state, command, group) {
+  const journal = [];
+  const applied = [];
+  for (const operation of group) {
+    let outcome;
+    try {
+      outcome = applyEditOperation(context, state, operation, command.identity, journal);
+    } catch (error) {
+      if (!isRecoverableEditValidation(command.input, error))
+        throw error;
+      undoEditJournal(journal);
+      return failedEditGroup(group, error.message);
+    }
+    if (!outcome.ok) {
+      undoEditJournal(journal);
+      return failedEditGroup(group, outcome.error.message);
+    }
+    applied.push(outcome);
+  }
+  return applied;
+}
+function failedEditGroup(group, message) {
+  return group.map((operation) => ({
+    id: operation.id,
+    ok: false,
+    error: { code: "validation", message }
+  }));
+}
+function isRecoverableEditValidation(input, error) {
+  if (input.mode === "atomic")
+    return false;
+  return error instanceof MaterializationValidationError;
+}
+function editPlanContext(command) {
+  const context = { identity: command.identity, origin: command.origin };
+  if (command.input.actor === undefined)
+    return context;
+  return { ...context, actor: command.input.actor };
+}
+async function finalizeEditMaterialization(storage, session, result) {
+  const applied = await storage.ontology.materializations.finalize({
+    session,
+    finalization: { sourceActivations: [], result }
+  });
+  return applied.commit.result;
+}
+
+// src/materializer/execution/run-correlation.ts
+async function lockProjectionRunForMaterialization(storage, input) {
+  const projectionRuns = storage.projectionRuns;
+  if (!projectionRuns) {
+    throw new MaterializationValidationError(input.capabilityErrorMessage ?? "Storage transaction does not provide projection run capabilities.");
+  }
+  const run = await projectionRuns.lockForMaterialization({
+    id: input.projectionRunId,
+    projectId: input.projectId,
+    executionToken: input.executionToken,
+    identity: input.identity
+  });
+  assertProjectionRunTargets(run, input.resolved);
+  return { projectionRuns, run };
+}
+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}'.`);
+}
+function projectionRunTargetsMatch(run, definition) {
+  switch (definition._tag) {
+    case "ObjectProjectionDefinition":
+    case "TelemetryProjectionDefinition":
+      return "objectTypeId" in run.target && run.target.objectTypeId === definition.objectTypeId;
+    case "LinkProjectionDefinition":
+      return "sourceObjectTypeId" in run.target && run.target.sourceObjectTypeId === definition.sourceObjectTypeId && run.target.targetObjectTypeId === definition.targetObjectTypeId;
+  }
+}
+
+// src/materializer/shared/projection-run.ts
+function createProjectionRunMaterializationIdentity(input) {
+  const base = {
+    projectionId: input.resolved.projectionId,
+    datasetVersion: input.datasetVersion,
+    ontologyRevision: input.ontologyRevision,
+    projectionRevision: input.resolved.projectionRevision,
+    ownershipHash: input.resolved.ownershipHash
+  };
+  switch (input.resolved.definition._tag) {
+    case "ObjectProjectionDefinition":
+      return { ...base, projectionKind: "object", protocol: "replacement" };
+    case "LinkProjectionDefinition":
+      return { ...base, projectionKind: "link", protocol: "replacement" };
+    case "TelemetryProjectionDefinition":
+      return { ...base, projectionKind: "telemetry", protocol: "telemetry" };
+    default:
+      throw new MaterializationValidationError("Expected a supported projection definition.");
+  }
+}
+
+// src/materializer/projections/finish-run.ts
+async function finishProjectionRun(context, raw) {
+  const command = prepareProjectionRunFinish(context, raw);
+  await withSerializationRetry(context, () => context.storage.transaction((storage) => finishProjectionRunTransaction(storage, command), {
+    isolation: "serializable"
+  }));
+}
+function prepareProjectionRunFinish(context, raw) {
+  assertValidTerminalDecision(raw);
+  const source = normalizeProjectionSourceRef(raw.source);
+  const datasetVersion = normalizePinnedDatasetVersion(raw.datasetVersion);
+  const execution = normalizeProjectionExecution(raw.execution);
+  const resolved = raw.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}'.`);
+  }
+  const identity = createProjectionRunMaterializationIdentity({
+    resolved,
+    datasetVersion,
+    ontologyRevision: context.projectionRegistry.ontologyRevision
+  });
+  return {
+    projectId: context.projectId,
+    input: { ...raw, source, datasetVersion, execution },
+    identity,
+    resolved,
+    finishedAt: context.clock()
+  };
+}
+async function finishProjectionRunTransaction(storage, command) {
+  const { projectionRuns } = await lockProjectionRunForMaterialization(storage, {
+    projectId: command.projectId,
+    projectionRunId: command.input.execution.projectionRunId,
+    executionToken: command.input.execution.executionToken,
+    identity: command.identity,
+    resolved: command.resolved
+  });
+  if (command.input.protocol === "replacement") {
+    await assertReplacementTerminalDecision(storage, command);
+  }
+  await projectionRuns.finish({
+    id: command.input.execution.projectionRunId,
+    projectId: command.projectId,
+    executionToken: command.input.execution.executionToken,
+    identity: command.identity,
+    ...terminalDecision(command.input),
+    finishedAt: command.finishedAt
+  });
+}
+function assertValidTerminalDecision(input) {
+  if (input.protocol !== "replacement" && input.protocol !== "telemetry") {
+    throw new MaterializationValidationError("Projection finish protocol is invalid.");
+  }
+  if (input.status !== "succeeded" && input.status !== "failed" && input.status !== "cancelled") {
+    throw new MaterializationValidationError("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.");
+  }
+  if (inputExhausted !== undefined) {
+    throw new MaterializationValidationError("Only telemetry projection success can acknowledge exhausted input.");
+  }
+}
+function terminalDecision(input) {
+  if (input.status !== "succeeded") {
+    return {
+      protocol: input.protocol,
+      status: input.status,
+      ...input.errorMessage === undefined ? {} : { errorMessage: input.errorMessage }
+    };
+  }
+  if (input.protocol === "telemetry") {
+    return { protocol: "telemetry", status: "succeeded", inputExhausted: true };
+  }
+  return { protocol: "replacement", status: "succeeded" };
+}
+async function assertReplacementTerminalDecision(storage, command) {
+  const commit = await storage.ontology.commits.getByOrigin({
+    projectId: command.projectId,
+    origin: {
+      kind: "projection",
+      projectionRunId: command.input.execution.projectionRunId
+    }
+  });
+  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.`);
+    }
+    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.`);
+  }
+}
+function assertReplacementCommitCorrelation(commit, command) {
+  const { input, identity } = command;
+  if (commit.origin.kind !== "projection" || 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.`);
+  }
+}
+function datasetVersionsEqual(left, right) {
+  return left.datasetId === right.datasetId && left.versionId === right.versionId && left.createdAt === right.createdAt;
+}
+
+// src/materializer/projections/entry-validator.ts
+function createProjectionEntryValidator(ontology, resolved) {
+  const policy = createValidationPolicy(resolved);
+  return (entry) => validateProjectionEntry(ontology, resolved, policy, entry);
+}
+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)));
+  if (resolved.definition._tag === "ObjectProjectionDefinition") {
+    return {
+      expectedRootKind: "object",
+      expectedRootDescription: "an object",
+      ownedProperties,
+      ownedLinks
+    };
+  }
+  return {
+    expectedRootKind: "link",
+    expectedRootDescription: "a link",
+    ownedProperties,
+    ownedLinks
+  };
+}
+function validateProjectionEntry(ontology, resolved, policy, entry) {
+  validateProjectionRoot(resolved, policy, entry);
+  return {
+    root: entry.root,
+    assertions: entry.assertions.map((assertion) => validateProjectionAssertion(ontology, resolved, policy, assertion))
+  };
+}
+function validateProjectionRoot(resolved, policy, entry) {
+  if (entry.root.kind === policy.expectedRootKind)
+    return;
+  throw new MaterializationValidationError(`Projection '${resolved.projectionId}' requires ${policy.expectedRootDescription} root.`);
+}
+function validateProjectionAssertion(ontology, resolved, policy, assertion) {
+  if (assertion.kind === "object") {
+    return validateObjectAssertion(ontology, resolved, policy, assertion);
+  }
+  return validateLinkAssertion(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.");
+  }
+  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}'.`);
+  }
+  return { ...assertion, properties };
+}
+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.");
+  }
+  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.`);
+  }
+  validateLinkAuthorityProperties(ontology, assertion.ref, assertion.properties);
+  if (assertion.properties !== undefined) {
+    throw new MaterializationValidationError(`Projection '${resolved.projectionId}' does not map link assertion properties.`);
+  }
+  return { ...assertion };
+}
+function projectionLinkTargetType(resolved, assertion) {
+  if (resolved.definition._tag === "LinkProjectionDefinition") {
+    return resolved.definition.targetObjectTypeId;
+  }
+  if (resolved.definition._tag === "ObjectProjectionDefinition") {
+    return resolved.definition.links[assertion.ref.linkId]?.targetObjectTypeId;
+  }
+  return;
+}
+
+// src/materializer/projections/replacement-plan.ts
+async function planProjectionReplacement(context, storage, session, input) {
+  const counts = emptyCounts();
+  if (input.projectionKind === "object") {
+    await planObjectReplacement(context, storage, session, input, counts);
+  }
+  await planLinkReplacement(context, storage, session, input, counts);
+  await validateStagedCardinality(context, storage, session, input.signal);
+  return counts;
+}
+async function planObjectReplacement(context, storage, session, input, counts) {
+  for await (const page of storage.streamSourceReplacementState({
+    session,
+    source: input.source,
+    candidateMaterializationId: input.materializationId,
+    entityKind: "object",
+    pageRows: context.batching.statePageRows
+  })) {
+    throwIfAborted(input.signal);
+    const work = planObjectPage(context, input, page, counts);
+    await stageWorkBounded(context, storage, session, work);
+  }
+}
+function planObjectPage(context, input, page, counts) {
+  const work = [];
+  for (const state of page.objects) {
+    work.push(...planReplacementObject(context, input, state, counts));
+  }
+  return work;
+}
+function planReplacementObject(context, input, state, counts) {
+  const resolved = resolveReplacementObject(context, state);
+  if (resolved)
+    validateEffectiveObject(context.ontology, resolved.ref, resolved.properties);
+  const change = diffEffectiveObject({
+    before: state.effective,
+    resolved,
+    commitId: input.identity.commitId,
+    committedAt: input.identity.committedAt
+  });
+  const sortKey = objectRefSortKey(state.ref);
+  const work = [
+    classificationWork("object", objectRefKey(state.ref), sortKey),
+    {
+      kind: "object-existence",
+      recordKey: `existence:${sortKey}`,
+      ref: state.ref,
+      exists: resolved !== null
+    }
+  ];
+  if (Boolean(state.effective) !== Boolean(resolved)) {
+    work.push({ kind: "incident-object", recordKey: `incident:${sortKey}`, ref: state.ref });
+  }
+  if (!change) {
+    counts.objectsUnchanged += 1;
+    return work;
+  }
+  incrementObjectCount(counts, change.kind);
+  appendObjectChangeWork(work, sortKey, context, input, change);
+  return work;
+}
+function appendObjectChangeWork(work, sortKey, context, input, change) {
+  const items = [];
+  appendObjectEffectivePlan(items, change);
+  for (const item of items)
+    work.push(planWork(item, sortKey));
+  work.push(eventWork(buildObjectMaterializationEventDraft({
+    projectId: context.projectId,
+    commitId: input.identity.commitId,
+    committedAt: input.identity.committedAt,
+    origin: input.origin,
+    change
+  })));
+}
+async function planLinkReplacement(context, storage, session, input, counts) {
+  for await (const page of storage.streamSourceReplacementState({
+    session,
+    source: input.source,
+    candidateMaterializationId: input.materializationId,
+    entityKind: "link",
+    pageRows: context.batching.statePageRows
+  })) {
+    throwIfAborted(input.signal);
+    const endpointExistence = await loadEndpointExistence(context, storage, session, page);
+    const work = planLinkPage(context, input, page, endpointExistence, counts);
+    await stageWorkBounded(context, storage, session, work);
+  }
+}
+async function loadEndpointExistence(context, storage, session, page) {
+  const endpointRefs = collectEndpointRefs(page.links);
+  const endpointExistence = new Map;
+  for (const value of await storage.readObjectExistence({
+    session,
+    refs: [...endpointRefs.values()]
+  })) {
+    endpointExistence.set(objectRefKey(value.ref), value.exists);
+  }
+  const missingEndpoints = [...endpointRefs.values()].filter((ref) => !endpointExistence.has(objectRefKey(ref)));
+  if (missingEndpoints.length === 0)
+    return endpointExistence;
+  for await (const endpointPage of storage.streamState({
+    session,
+    requests: oneStateRequest({
+      objects: missingEndpoints,
+      links: [],
+      linkScopes: [],
+      incidentObjects: [],
+      points: []
+    }),
+    pageRows: context.batching.statePageRows
+  })) {
+    for (const endpoint of endpointPage.objects) {
+      endpointExistence.set(objectRefKey(endpoint.ref), endpoint.effective !== null);
+    }
+  }
+  return endpointExistence;
+}
+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);
+  }
+  return refs;
+}
+function planLinkPage(context, input, page, endpointExistence, counts) {
+  const work = [];
+  for (const state of page.links) {
+    work.push(...planReplacementLink(context, input, state, endpointExistence, counts));
+  }
+  return work;
+}
+function planReplacementLink(context, input, state, endpointExistence, counts) {
+  const resolved = resolveReplacementLink(state, endpointExistence);
+  const work = cardinalityWork(context, state, resolved !== null);
+  if (!state.diffRequired)
+    return work;
+  const change = diffEffectiveLink({
+    before: state.effective,
+    resolved,
+    commitId: input.identity.commitId,
+    committedAt: input.identity.committedAt
+  });
+  const sortKey = linkRefSortKey(state.ref);
+  work.push(classificationWork("link", linkRefKey(state.ref), sortKey));
+  if (!change) {
+    counts.linksUnchanged += 1;
+    return work;
+  }
+  incrementLinkCount(counts, change.kind);
+  appendLinkChangeWork(work, sortKey, context, input, change);
+  return work;
+}
+function resolveReplacementLink(state, endpointExistence) {
+  if (!state.diffRequired)
+    return state.effective;
+  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
+  });
+}
+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);
+  return [
+    {
+      kind: "cardinality",
+      recordKey: `cardinality:${scopeSortKey}:${linkSortKey}`,
+      scopeSortKey,
+      linkSortKey,
+      ref: state.ref,
+      occupied
+    }
+  ];
+}
+function appendLinkChangeWork(work, sortKey, context, input, change) {
+  const items = [];
+  appendLinkEffectivePlan(items, change);
+  for (const item of items)
+    work.push(planWork(item, sortKey));
+  work.push(eventWork(buildLinkMaterializationEventDraft({
+    projectId: context.projectId,
+    commitId: input.identity.commitId,
+    committedAt: input.identity.committedAt,
+    origin: input.origin,
+    change
+  })));
+}
+function resolveReplacementObject(context, state) {
+  return resolveEffectiveObject({
+    ref: state.ref,
+    primaryPropertyId: context.ontology.getPrimaryPropertyId(state.ref.objectTypeId),
+    source: state.candidateSource,
+    override: state.override?.value ?? null,
+    latestTelemetry: state.latestTelemetry
+  });
+}
+function emptyCounts() {
+  return {
+    objectsCreated: 0,
+    objectsUpdated: 0,
+    objectsDeleted: 0,
+    objectsUnchanged: 0,
+    linksCreated: 0,
+    linksUpdated: 0,
+    linksDeleted: 0,
+    linksUnchanged: 0
+  };
+}
+function incrementObjectCount(counts, kind) {
+  if (kind === "created")
+    counts.objectsCreated += 1;
+  else if (kind === "updated")
+    counts.objectsUpdated += 1;
+  else
+    counts.objectsDeleted += 1;
+}
+function incrementLinkCount(counts, kind) {
+  if (kind === "created")
+    counts.linksCreated += 1;
+  else if (kind === "updated")
+    counts.linksUpdated += 1;
+  else
+    counts.linksDeleted += 1;
+}
+
+// src/materializer/projections/source-materialization.ts
+async function stageProjectionMaterialization(context, input) {
+  await context.storage.ontology.sources.beginMaterialization({
+    projectId: context.projectId,
+    source: input.source,
+    materializationId: input.materializationId,
+    execution: input.execution,
+    projectionKind: input.projectionKind,
+    protocol: "replacement",
+    datasetVersion: input.datasetVersion,
+    projectionRevision: input.projectionRevision,
+    ownershipHash: input.ownershipHash,
+    ontologyRevision: context.projectionRegistry.ontologyRevision,
+    createdAt: input.createdAt
+  });
+  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));
+      const stagingOrdinal = rootCount;
+      for (const assertion of entry.assertions) {
+        assertionCount += 1;
+        yield { root: entry.root, assertion, stagingOrdinal };
+      }
+      rootCount += 1;
+    }
+    throwIfAborted(input.signal);
+  }
+  for await (const rows of chunkBySize(assertions(), {
+    maxRows: context.batching.sourceStageRows,
+    maxBytes: context.batching.sourceStageBytes,
+    byteLength: utf8JsonByteLength
+  })) {
+    await context.storage.ontology.sources.stageRows({
+      projectId: context.projectId,
+      source: input.source,
+      materializationId: input.materializationId,
+      execution: input.execution,
+      rows
+    });
+  }
+  await context.storage.ontology.sources.markReady({
+    projectId: context.projectId,
+    source: input.source,
+    materializationId: input.materializationId,
+    execution: input.execution,
+    rootCount,
+    assertionCount,
+    readyAt: context.clock().toISOString()
+  });
+  return { rootCount, assertionCount };
+}
+
+// src/materializer/projections/replace.ts
+async function replaceProjection(context, raw) {
+  const command = prepareProjectionReplacement(context, raw);
+  await assertProjectionExecution(context.storage, context.projectId, command, {
+    capabilityErrorMessage: "Storage does not provide projection run capabilities required by source replacement."
+  });
+  const replay = await replayProjectionCommit(context, command);
+  if (replay)
+    return replay;
+  const candidate = await prepareProjectionCandidate(context, command);
+  try {
+    const ready = await stageProjectionCandidate(context, command, candidate);
+    return await commitProjectionCandidate(context, command, ready);
+  } catch (error) {
+    await abandonFailedCandidate(context, command, candidate, error);
+    throw error;
+  }
+}
+function prepareProjectionReplacement(context, raw) {
+  const source = normalizeProjectionSourceRef(raw.source);
+  const datasetVersion = normalizePinnedDatasetVersion(raw.datasetVersion);
+  const execution = normalizeProjectionExecution(raw.execution);
+  const resolved = context.projectionRegistry.resolveSource(source.projectionId);
+  validateProjectionDataset(resolved, datasetVersion);
+  const projectionKind = sourceProjectionKind(resolved);
+  const runIdentity = createProjectionRunMaterializationIdentity({
+    resolved,
+    datasetVersion,
+    ontologyRevision: context.projectionRegistry.ontologyRevision
+  });
+  const identity = createCommitIdentity({
+    projectId: context.projectId,
+    idempotencyKey: createProjectionIdempotencyKey(runIdentity),
+    normalizedCallerIntent: { source, datasetVersion }
+  });
+  const command = {
+    source,
+    datasetVersion,
+    execution,
+    entries: raw.entries,
+    resolved,
+    projectionKind,
+    runIdentity,
+    identity
+  };
+  if (raw.signal === undefined)
+    return command;
+  return { ...command, signal: raw.signal };
+}
+function validateProjectionDataset(resolved, datasetVersion) {
+  if (datasetVersion.datasetId === resolved.datasetId)
+    return;
+  throw new MaterializationValidationError(`Projection '${resolved.projectionId}' requires dataset '${resolved.datasetId}'.`);
+}
+function sourceProjectionKind(resolved) {
+  if (resolved.definition._tag === "ObjectProjectionDefinition")
+    return "object";
+  return "link";
+}
+async function assertProjectionExecution(storage, projectId, command, options = {}) {
+  await lockProjectionRunForMaterialization(storage, {
+    projectId,
+    projectionRunId: command.execution.projectionRunId,
+    executionToken: command.execution.executionToken,
+    identity: command.runIdentity,
+    resolved: command.resolved,
+    ...options
+  });
+}
+async function replayProjectionCommit(context, command) {
+  const existing = await replayCommitRecord(context, command.identity);
+  if (!existing)
+    return null;
+  return withSerializationRetry(context, () => context.storage.transaction(async (storage) => {
+    await assertProjectionExecution(storage, context.projectId, command);
+    const commit = await replayCommitRecord(context, command.identity, storage);
+    return commit ? projectionReplayResult(commit, command) : null;
+  }, { isolation: "serializable" }));
+}
+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.`);
+  }
+  return { ...structuredClone(commit.result), created: false };
+}
+async function prepareProjectionCandidate(context, command) {
+  await context.storage.ontology.sources.abandon({
+    kind: "reclaim",
+    projectId: context.projectId,
+    source: command.source,
+    execution: command.execution,
+    abandonedAt: context.clock().toISOString()
+  });
+  const active = await context.storage.ontology.sources.getActive({
+    projectId: context.projectId,
+    source: command.source
+  });
+  validateProjectionWatermark(active, command.datasetVersion);
+  return {
+    materializationId: context.materializationId(),
+    createdAt: context.clock().toISOString(),
+    expectedSource: {
+      source: command.source,
+      activeMaterializationId: active?.materializationId ?? null,
+      lastCommitId: active?.lastCommitId ?? null
+    }
+  };
+}
+async function stageProjectionCandidate(context, command, candidate) {
+  const input = {
+    source: command.source,
+    materializationId: candidate.materializationId,
+    execution: command.execution,
+    projectionKind: command.projectionKind,
+    datasetVersion: command.datasetVersion,
+    projectionRevision: command.resolved.projectionRevision,
+    ownershipHash: command.resolved.ownershipHash,
+    createdAt: candidate.createdAt,
+    entries: command.entries,
+    validateEntry: createProjectionEntryValidator(context.ontology, command.resolved)
+  };
+  const staged = await stageCandidateEntries(context, input, command.signal);
+  return {
+    ...candidate,
+    staged,
+    identity: timestampCommitIdentity(command.identity, context.clock())
+  };
+}
+async function stageCandidateEntries(context, input, signal) {
+  if (signal === undefined)
+    return stageProjectionMaterialization(context, input);
+  return stageProjectionMaterialization(context, { ...input, signal });
+}
+async function commitProjectionCandidate(context, command, ready) {
+  return withSerializationRetry(context, () => context.storage.transaction((storage) => executeProjectionTransaction(context, storage, command, ready), { isolation: "serializable" }));
+}
+async function executeProjectionTransaction(context, storage, command, ready) {
+  await assertProjectionExecution(storage, context.projectId, command);
+  const replay = await replayCommitRecord(context, command.identity, storage);
+  if (replay)
+    return projectionReplayResult(replay, command);
+  const origin = projectionOrigin(command);
+  throwIfAborted(command.signal);
+  const session = await storage.ontology.materializations.begin({
+    commit: projectionCommit(context.projectId, command, ready.identity, origin),
+    expected: {
+      sources: [ready.expectedSource],
+      objects: [],
+      links: [],
+      linkScopes: [],
+      points: []
+    }
+  });
+  const counts = await planReadyProjection(context, storage.ontology.materializations, session, command, ready, origin);
+  await drainStagedWork(context, storage.ontology.materializations, session, command.signal);
+  const eventCount = await drainStagedEvents(context, storage.ontology.materializations, session, ready.identity, command.signal);
+  const result = {
+    kind: "projection",
+    commitId: ready.identity.commitId,
+    created: true,
+    eventCount,
+    committedAt: ready.identity.committedAt,
+    counts
+  };
+  throwIfAborted(command.signal);
+  return finalizeProjectionMaterialization(storage, session, command, ready, result);
+}
+async function finalizeProjectionMaterialization(storage, session, command, ready, result) {
+  const applied = await storage.ontology.materializations.finalize({
+    session,
+    finalization: {
+      sourceActivations: [projectionActivation(command, ready)],
+      result
+    }
+  });
+  return applied.commit.result;
+}
+function projectionOrigin(command) {
+  return {
+    kind: "projection",
+    projectionId: command.resolved.projectionId,
+    projectionRunId: command.execution.projectionRunId,
+    datasetId: command.datasetVersion.datasetId,
+    datasetVersionId: command.datasetVersion.versionId
+  };
+}
+function projectionCommit(projectId, command, identity, origin) {
+  return {
+    projectId,
+    id: identity.commitId,
+    idempotencyKey: identity.idempotencyKey,
+    requestHash: identity.requestHash,
+    origin,
+    ontologyRevision: command.runIdentity.ontologyRevision,
+    projectionRevision: command.runIdentity.projectionRevision,
+    ownershipHash: command.runIdentity.ownershipHash,
+    intent: { kind: "projection", source: command.source, datasetVersion: command.datasetVersion },
+    committedAt: identity.committedAt
+  };
+}
+async function planReadyProjection(context, storage, session, command, ready, origin) {
+  const input = {
+    source: command.source,
+    materializationId: ready.materializationId,
+    projectionKind: command.projectionKind,
+    identity: ready.identity,
+    origin
+  };
+  if (command.signal === undefined) {
+    return planProjectionReplacement(context, storage, session, input);
+  }
+  return planProjectionReplacement(context, storage, session, {
+    ...input,
+    signal: command.signal
+  });
+}
+function projectionActivation(command, ready) {
+  return {
+    source: command.source,
+    materializationId: ready.materializationId,
+    execution: command.execution,
+    projectionKind: command.projectionKind,
+    protocol: "replacement",
+    datasetVersion: command.datasetVersion,
+    projectionRevision: command.runIdentity.projectionRevision,
+    ownershipHash: command.runIdentity.ownershipHash,
+    ontologyRevision: command.runIdentity.ontologyRevision,
+    expected: ready.expectedSource,
+    lastCommitId: ready.identity.commitId,
+    updatedAt: ready.identity.committedAt
+  };
+}
+async function abandonFailedCandidate(context, command, candidate, error) {
+  if (!shouldAbandonCandidate(error))
+    return;
+  await context.storage.ontology.sources.abandon({
+    kind: "candidate",
+    projectId: context.projectId,
+    source: command.source,
+    materializationId: candidate.materializationId,
+    execution: command.execution,
+    abandonedAt: context.clock().toISOString()
+  });
+}
+function shouldAbandonCandidate(error) {
+  if (error instanceof MaterializationValidationError)
+    return true;
+  if (error instanceof MaterializationCancellationError)
+    return true;
+  return error instanceof MaterializationConflictError && error.kind === "run-correlation";
+}
+function validateProjectionWatermark(active, next) {
+  if (!active)
+    return;
+  assertPinnedDatasetWatermark(active.datasetVersion, next, "Projection replacement");
+}
+
+// src/materializer/telemetry/plan.ts
+async function planTelemetryAppend(context, storage, session, input, identity, origin) {
+  const counts = emptyTelemetryCounts();
+  const planContext = { input, identity, origin };
+  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));
+    if (!storedObject?.effective) {
+      throw new MaterializationObjectNotFoundError(group.objectRef.objectTypeId, group.objectRef.primaryId);
+    }
+    await planTelemetryObject(context, storage, session, planContext, group, workingObjectFromState(storedObject), existingPoints, counts);
+  }
+  return counts;
+}
+function* telemetryObjectGroups(points) {
+  let start = 0;
+  while (start < points.length) {
+    const objectRef = points[start].series.object;
+    const objectKey = objectRefKey(objectRef);
+    let end = start + 1;
+    while (end < points.length && objectRefKey(points[end].series.object) === objectKey) {
+      end += 1;
+    }
+    yield { objectRef, start, end };
+    start = end;
+  }
+}
+async function planTelemetryObject(context, storage, session, planContext, group, working, existingPoints, counts) {
+  const latest = new Map(working.latestTelemetry.map((point) => [point.series.propertyId, point]));
+  for (let start = group.start;start < group.end; start += context.batching.statePageRows) {
+    const end = Math.min(group.end, start + context.batching.statePageRows);
+    const points = planContext.input.points.slice(start, end);
+    const work = planTelemetryChunk(context, planContext, points, existingPoints, latest, counts);
+    await stageWorkBounded(context, storage, session, work);
+  }
+  working.latestTelemetry = [...latest.values()];
+  await stageTelemetryObjectPlan(context, storage, session, planContext, working, counts);
+}
+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);
+  const objectState = await loadState(context, storage, session, {
+    objects: [...refs.values()],
+    links: [],
+    linkScopes: [],
+    incidentObjects: [],
+    points: []
+  });
+  return new Map(objectState.objects.map((object) => [objectRefKey(object.ref), object]));
+}
+function planTelemetryChunk(context, planContext, points, existingPoints, latest, counts) {
+  const work = [];
+  for (const point of points) {
+    work.push(...planTelemetryPoint(context, planContext, point, existingPoints, latest, counts));
+  }
+  return work;
+}
+async function loadExistingPoints(context, storage, session, points) {
+  const existingPoints = new Map;
+  for await (const page of storage.streamState({
+    session,
+    requests: oneStateRequest({
+      objects: [],
+      links: [],
+      linkScopes: [],
+      incidentObjects: [],
+      points: points.map((point) => ({ series: point.series, at: point.at }))
+    }),
+    pageRows: context.batching.statePageRows
+  })) {
+    for (const existing of page.points) {
+      existingPoints.set(telemetryPointKey(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 existing = existingPoints.get(identityKey);
+  const unchanged = telemetryPointUnchanged(existing, point);
+  const work = [classificationWork("point", identityKey, sortKey)];
+  if (unchanged) {
+    counts.pointsUnchanged += 1;
+  } else {
+    countTelemetryPointChange(counts, existing);
+    work.push(planWork(telemetryPointUpsert(point, existing, planContext.identity), sortKey));
+    work.push(eventWork(buildTelemetryEvent(context, planContext, point)));
+  }
+  updateLatestPoint(latest, point, existing, unchanged, planContext.identity);
+  return work;
+}
+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 });
+}
+function countTelemetryPointChange(counts, existing) {
+  if (existing)
+    counts.pointsUpdated += 1;
+  else
+    counts.pointsCreated += 1;
+}
+function telemetryPointUpsert(point, existing, identity) {
+  const storedPoint = {
+    series: point.series,
+    value: point.value,
+    at: point.at,
+    lastCommitId: identity.commitId
+  };
+  const pointWithUnit = storedTelemetryPointWithUnit(storedPoint, point.unit);
+  return {
+    kind: "point-upsert",
+    value: {
+      point: pointWithUnit,
+      expected: {
+        series: point.series,
+        at: point.at,
+        lastCommitId: existing?.lastCommitId ?? null
+      }
+    }
+  };
+}
+function storedTelemetryPointWithUnit(point, unit) {
+  if (unit === undefined)
+    return point;
+  return { ...point, unit };
+}
+function buildTelemetryEvent(context, planContext, point) {
+  const eventContext = telemetryEventContext(context, planContext);
+  return buildTelemetryMaterializationEventDraft({ ...eventContext, point });
+}
+function updateLatestPoint(latest, point, existing, unchanged, identity) {
+  const current = latest.get(point.series.propertyId);
+  if (current && point.at < current.at)
+    return;
+  let lastCommitId = identity.commitId;
+  if (unchanged && existing)
+    lastCommitId = existing.lastCommitId;
+  const storedPoint = {
+    series: point.series,
+    value: point.value,
+    at: point.at,
+    lastCommitId
+  };
+  if (point.unit === undefined) {
+    latest.set(point.series.propertyId, storedPoint);
+    return;
+  }
+  latest.set(point.series.propertyId, { ...storedPoint, unit: point.unit });
+}
+async function stageTelemetryObjectPlan(context, storage, session, planContext, working, counts) {
+  const resolved = resolveObject(context.ontology, working);
+  if (resolved)
+    validateEffectiveObject(context.ontology, resolved.ref, resolved.properties);
+  const change = diffEffectiveObject({
+    before: working.before,
+    resolved,
+    commitId: planContext.identity.commitId,
+    committedAt: planContext.identity.committedAt
+  });
+  const sortKey = objectRefSortKey(working.ref);
+  const work = [
+    classificationWork("object", objectRefKey(working.ref), sortKey)
+  ];
+  if (change) {
+    counts.latestObjectsChanged += 1;
+    const items = [];
+    appendObjectEffectivePlan(items, change);
+    work.push(...items.map((item) => planWork(item, sortKey)));
+    const eventContext = telemetryEventContext(context, planContext);
+    work.push(eventWork(buildObjectMaterializationEventDraft({ ...eventContext, change })));
+  }
+  await stageWorkBounded(context, storage, session, work);
+}
+function telemetryEventContext(context, planContext) {
+  const eventContext = {
+    projectId: context.projectId,
+    commitId: planContext.identity.commitId,
+    committedAt: planContext.identity.committedAt,
+    origin: planContext.origin
+  };
+  if (planContext.input.actor === undefined)
+    return eventContext;
+  return { ...eventContext, actor: planContext.input.actor };
+}
+function emptyTelemetryCounts() {
+  return {
+    pointsCreated: 0,
+    pointsUpdated: 0,
+    pointsUnchanged: 0,
+    latestObjectsChanged: 0
+  };
+}
+
+// src/materializer/telemetry/append.ts
+async function appendTelemetry(context, raw) {
+  const command = prepareTelemetryAppend(context, raw);
+  if (command.kind === "runtime") {
+    const replay = await replayCommit(context, command.identity);
+    if (replay)
+      return replay;
+  }
+  return executeTelemetryCommit(context, command);
+}
+function prepareTelemetryAppend(context, raw) {
+  const rawInputPointCount = raw.points.length;
+  const input = normalizeTelemetryAppend({
+    ...raw,
+    points: raw.points.map((point) => validateTelemetryPoint(context.ontology, point))
+  });
+  const inputPointCount = telemetryInputPointCount(input, rawInputPointCount);
+  validateTelemetryBatch(input, inputPointCount);
+  const ontologyRevision = context.projectionRegistry.ontologyRevision;
+  if (input.source.kind === "runtime") {
+    return prepareRuntimeTelemetry(context, input, input.source, inputPointCount, ontologyRevision);
+  }
+  return prepareProjectionTelemetry(context, input, input.source, inputPointCount, ontologyRevision);
+}
+function telemetryInputPointCount(input, rawInputPointCount) {
+  if (input.source.kind === "projection")
+    return rawInputPointCount;
+  return input.points.length;
+}
+function validateTelemetryBatch(input, inputPointCount) {
+  if (input.source.kind === "projection") {
+    if (input.source.sourceRowCount === 0) {
+      throw new MaterializationValidationError("Projection telemetry batches must consume at least one source row; an empty dataset produces no batch commit.");
+    }
+    if (input.source.sourceRowCount !== inputPointCount + input.source.sourceRowsSkipped) {
+      throw new MaterializationValidationError("Projection telemetry sourceRowCount must equal input points plus skipped rows.");
+    }
+  }
+}
+function prepareRuntimeTelemetry(context, input, source, inputPointCount, ontologyRevision) {
+  const identity = createTimedCommitIdentity({
+    projectId: context.projectId,
+    idempotencyKey: createRuntimeTelemetryIdempotencyKey(source.requestId),
+    normalizedCallerIntent: input,
+    now: context.clock()
+  });
+  return { kind: "runtime", input, source, inputPointCount, ontologyRevision, identity };
+}
+function prepareProjectionTelemetry(context, input, source, inputPointCount, ontologyRevision) {
+  const resolvedProjection = context.projectionRegistry.resolveTelemetry(source.projection.projectionId);
+  validateTelemetryProjectionDataset(resolvedProjection, source);
+  validateTelemetryOwnership(resolvedProjection, input);
+  const runIdentity = createProjectionRunMaterializationIdentity({
+    resolved: resolvedProjection,
+    datasetVersion: source.datasetVersion,
+    ontologyRevision
+  });
+  const identity = createTimedCommitIdentity({
+    projectId: context.projectId,
+    idempotencyKey: createProjectionTelemetryIdempotencyKey(runIdentity, source.batchOrdinal),
+    normalizedCallerIntent: projectionTelemetryCallerIntent(input, source, inputPointCount),
+    now: context.clock()
+  });
+  return {
+    kind: "projection",
+    input,
+    source,
+    inputPointCount,
+    ontologyRevision,
+    identity,
+    resolvedProjection,
+    runIdentity
+  };
+}
+function validateTelemetryProjectionDataset(resolved, source) {
+  if (resolved.datasetId === source.datasetVersion.datasetId)
+    return;
+  throw new MaterializationValidationError(`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)));
+  for (const point of input.points) {
+    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}'.`);
+  }
+}
+function projectionTelemetryCallerIntent(input, source, inputPointCount) {
+  const intent = {
+    source: {
+      kind: "projection",
+      projection: source.projection,
+      datasetVersion: source.datasetVersion,
+      batchOrdinal: source.batchOrdinal,
+      sourceRowCount: source.sourceRowCount,
+      sourceRowsSkipped: source.sourceRowsSkipped,
+      inputExhausted: source.inputExhausted
+    },
+    inputPointCount,
+    points: input.points
+  };
+  if (input.actor === undefined)
+    return intent;
+  return { ...intent, actor: input.actor };
+}
+async function assertTelemetryExecution(storage, projectId, command) {
+  if (command.kind === "runtime")
+    return null;
+  const execution = await lockProjectionRunForMaterialization(storage, {
+    projectId,
+    projectionRunId: command.source.execution.projectionRunId,
+    executionToken: command.source.execution.executionToken,
+    identity: command.runIdentity,
+    resolved: command.resolvedProjection,
+    capabilityErrorMessage: "Storage does not provide projection run capabilities required by telemetry projection."
+  });
+  assertTelemetryBatchPosition(execution.run, command.source.batchOrdinal, command.source.sourceRowCount, command.source.inputExhausted);
+  return execution;
+}
+function assertTelemetryBatchPosition(run, batchOrdinal, sourceRowCount, inputExhausted) {
+  const checkpoint = run.telemetryCheckpoint;
+  if (!checkpoint) {
+    throw new MaterializationValidationError(`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}.`);
+  }
+  if (checkpoint.inputExhausted && batchOrdinal >= checkpoint.nextBatchOrdinal) {
+    throw new MaterializationValidationError(`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.`);
+  }
+  if (!inputExhausted && sourceRowCount !== checkpoint.fixedBatchSize) {
+    throw new MaterializationValidationError(`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.`);
+  }
+}
+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.`);
+  }
+  return { ...structuredClone(commit.result), created: false };
+}
+async function executeTelemetryCommit(context, command) {
+  return withSerializationRetry(context, () => context.storage.transaction((storage) => executeTelemetryTransaction(context, storage, command), { isolation: "serializable" }));
+}
+async function executeTelemetryTransaction(context, storage, command) {
+  const execution = await assertTelemetryExecution(storage, context.projectId, command);
+  const replay = await replayCommitRecord(context, command.identity, storage);
+  if (replay) {
+    if (command.kind === "projection" && execution) {
+      assertTelemetryReplayCheckpoint(execution.run, command.source.batchOrdinal);
+      return telemetryProjectionReplayResult(replay, command);
+    }
+    return { ...structuredClone(replay.result), created: false };
+  }
+  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.`);
+    }
+  }
+  const origin = telemetryOrigin(command);
+  const session = await beginTelemetryMaterialization(context, storage, command, origin);
+  const counts = await planTelemetryAppend(context, storage.ontology.materializations, session, command.input, command.identity, origin);
+  await drainStagedWork(context, storage.ontology.materializations, session);
+  const eventCount = await drainStagedEvents(context, storage.ontology.materializations, session, command.identity);
+  const result = {
+    kind: "telemetry",
+    commitId: command.identity.commitId,
+    created: true,
+    eventCount,
+    committedAt: command.identity.committedAt,
+    ...counts
+  };
+  return finalizeTelemetryMaterialization(storage, session, command, result, execution?.projectionRuns);
+}
+function telemetryOrigin(command) {
+  if (command.kind === "runtime") {
+    return { kind: "telemetry", source: command.source };
+  }
+  return {
+    kind: "telemetry",
+    source: {
+      kind: "projection",
+      projectionId: command.source.projection.projectionId,
+      projectionRunId: command.source.execution.projectionRunId,
+      datasetId: command.source.datasetVersion.datasetId,
+      datasetVersionId: command.source.datasetVersion.versionId,
+      batchOrdinal: command.source.batchOrdinal
+    }
+  };
+}
+async function beginTelemetryMaterialization(context, storage, command, origin) {
+  return storage.ontology.materializations.begin({
+    commit: telemetryCommit(context.projectId, command, origin),
+    expected: {
+      sources: [],
+      objects: [],
+      links: [],
+      linkScopes: [],
+      points: []
+    }
+  });
+}
+function telemetryCommit(projectId, command, origin) {
+  const base = {
+    projectId,
+    id: command.identity.commitId,
+    idempotencyKey: command.identity.idempotencyKey,
+    requestHash: command.identity.requestHash,
+    origin,
+    ontologyRevision: command.ontologyRevision,
+    intent: telemetryCommitIntent(command),
+    committedAt: command.identity.committedAt
+  };
+  const withActor = telemetryCommitActor(base, command);
+  if (command.kind === "runtime")
+    return withActor;
+  return {
+    ...withActor,
+    projectionRevision: command.resolvedProjection.projectionRevision,
+    ownershipHash: command.resolvedProjection.ownershipHash
+  };
+}
+function telemetryCommitActor(commit, command) {
+  if (command.input.actor === undefined)
+    return commit;
+  return { ...commit, actor: command.input.actor };
+}
+function telemetryCommitIntent(command) {
+  if (command.kind === "runtime") {
+    return {
+      kind: "telemetry",
+      pointCount: command.input.points.length,
+      inputPointCount: command.inputPointCount,
+      source: { kind: "runtime" }
+    };
+  }
+  return {
+    kind: "telemetry",
+    pointCount: command.input.points.length,
+    inputPointCount: command.inputPointCount,
+    source: {
+      kind: "projection",
+      projection: command.source.projection,
+      datasetVersion: command.source.datasetVersion,
+      batchOrdinal: command.source.batchOrdinal,
+      sourceRowCount: command.source.sourceRowCount,
+      sourceRowsSkipped: command.source.sourceRowsSkipped,
+      inputExhausted: command.source.inputExhausted
+    }
+  };
+}
+async function finalizeTelemetryMaterialization(storage, session, command, result, projectionRuns) {
+  const applied = await storage.ontology.materializations.finalize({
+    session,
+    finalization: { sourceActivations: [], result }
+  });
+  if (command.kind === "projection") {
+    if (!projectionRuns) {
+      throw new MaterializationValidationError("Expected an asserted telemetry projection run.");
+    }
+    await projectionRuns.advanceTelemetryCheckpoint({
+      id: command.source.execution.projectionRunId,
+      projectId: applied.commit.projectId,
+      executionToken: command.source.execution.executionToken,
+      identity: command.runIdentity,
+      batchOrdinal: command.source.batchOrdinal,
+      batchRowCount: command.source.sourceRowCount,
+      batchRowsSkipped: command.source.sourceRowsSkipped,
+      inputExhausted: command.source.inputExhausted
+    });
+  }
+  return applied.commit.result;
+}
+
+// src/materializer/materializer.ts
+class OntologyMaterializer {
+  edits = { commit: (input) => commitEdits(this.context, input) };
+  projections = {
+    replace: (input) => replaceProjection(this.context, input),
+    finishRun: (input) => finishProjectionRun(this.context, input)
+  };
+  telemetry = { append: (input) => appendTelemetry(this.context, input) };
+  context;
+  constructor(projectId, ontology, projectionRegistry, storage, dependencies = {}) {
+    this.context = createMaterializerContext({
+      projectId,
+      ontology,
+      projections: projectionRegistry,
+      storage,
+      dependencies
+    });
+  }
+}
+function createOntologyMaterializer(input) {
+  return new OntologyMaterializer(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 };
+
+//# debugId=B1AC0F5B25E653E764756E2164756E21