@sixb/core 0.0.1

package/dist/chunk-q4qzq0ea.js

@@ -0,0 +1,832 @@
+// @bun
+import {
+  createEventId,
+  materializationEventKindOrdinal
+} from "./chunk-wxhdnwh4.js";
+import {
+  linkRefKey,
+  linkRefSortKey,
+  linkScopeSortKey,
+  objectRefKey,
+  objectRefSortKey,
+  projectionEntityKey,
+  telemetryPointKey
+} from "./chunk-p6r5g77m.js";
+import {
+  MaterializationConflictError,
+  MaterializationValidationError
+} from "./chunk-ry24jbr1.js";
+import {
+  stableJsonStringify
+} from "./chunk-1vffvydj.js";
+
+// src/storage/ontology/provider.ts
+import { createHash, randomUUID } from "crypto";
+
+// src/storage/ontology/provider-validation.ts
+function assertNonblank(value, label) {
+  if (typeof value !== "string" || value.trim().length === 0) {
+    throw new MaterializationValidationError(`${label} must be nonblank.`);
+  }
+}
+function assertPositiveInteger(value, label) {
+  if (!Number.isSafeInteger(value) || value <= 0) {
+    throw new MaterializationValidationError(`${label} must be a positive safe integer.`);
+  }
+}
+function assertNonnegativeInteger(value, label) {
+  if (!Number.isSafeInteger(value) || value < 0) {
+    throw new MaterializationValidationError(`${label} must be a nonnegative safe integer.`);
+  }
+}
+function assertTimestamp(value, label, canonical = true) {
+  const milliseconds = Date.parse(value);
+  if (!Number.isFinite(milliseconds) || canonical && new Date(milliseconds).toISOString() !== value) {
+    throw new MaterializationValidationError(`${label} must be ${canonical ? "a canonical UTC" : "a valid"} timestamp.`);
+  }
+  return milliseconds;
+}
+function invalidCorrelation(message) {
+  throw new MaterializationValidationError(message);
+}
+
+// src/storage/ontology/materializations.ts
+function materializationApplyPhase(kind) {
+  switch (kind) {
+    case "object-override-upsert":
+    case "object-override-delete":
+    case "link-override-upsert":
+    case "link-override-delete":
+      return 0;
+    case "point-upsert":
+      return 1;
+    case "link-delete":
+      return 2;
+    case "object-delete":
+      return 3;
+    case "object-upsert":
+      return 4;
+    case "link-upsert":
+      return 5;
+  }
+}
+
+// src/storage/ontology/provider-work.ts
+function assertPageRows(value) {
+  if (!Number.isSafeInteger(value) || value <= 0)
+    throw new MaterializationValidationError("Materialization page size must be positive.");
+}
+function materializationChunkRows(chunk) {
+  return chunk.overrides.objectUpserts.length + chunk.overrides.objectDeletes.length + chunk.overrides.linkUpserts.length + chunk.overrides.linkDeletes.length + chunk.effective.objectUpserts.length + chunk.effective.objectDeletes.length + chunk.effective.linkUpserts.length + chunk.effective.linkDeletes.length + chunk.timeseries.pointUpserts.length + chunk.outbox.length;
+}
+function materializationPlanItems(chunk) {
+  return [
+    ...chunk.overrides.objectUpserts.map((value) => ({
+      kind: "object-override-upsert",
+      value
+    })),
+    ...chunk.overrides.objectDeletes.map((value) => ({
+      kind: "object-override-delete",
+      value
+    })),
+    ...chunk.overrides.linkUpserts.map((value) => ({
+      kind: "link-override-upsert",
+      value
+    })),
+    ...chunk.overrides.linkDeletes.map((value) => ({
+      kind: "link-override-delete",
+      value
+    })),
+    ...chunk.effective.linkDeletes.map((value) => ({ kind: "link-delete", value })),
+    ...chunk.effective.objectDeletes.map((value) => ({ kind: "object-delete", value })),
+    ...chunk.effective.objectUpserts.map((value) => ({ kind: "object-upsert", value })),
+    ...chunk.effective.linkUpserts.map((value) => ({ kind: "link-upsert", value })),
+    ...chunk.timeseries.pointUpserts.map((value) => ({ kind: "point-upsert", value }))
+  ];
+}
+function assertWorkRecord(record, header) {
+  if (record.recordKey.trim().length === 0) {
+    throw new MaterializationValidationError("Materialization work key must be nonblank.");
+  }
+  if (record.kind === "plan") {
+    if (!/^[0-9a-f]+$/.test(record.sortKey) || !planPhaseMatches(record)) {
+      throw new MaterializationValidationError("Materialization plan work has an invalid order.");
+    }
+    assertPlanItemCorrelation(record.item, header.commit);
+    return;
+  }
+  if (record.kind === "event") {
+    if (!/^[0-9a-f]+$/.test(record.sortKey) || !Number.isSafeInteger(record.eventKindRank) || record.eventKindRank < 0 || record.eventKindRank !== materializationEventKindOrdinal(record.draft.type) || record.draft.projectId !== header.commit.projectId || record.draft.commitId !== header.commit.id || record.draft.occurredAt !== header.commit.committedAt || stableJsonStringify(record.draft.origin) !== stableJsonStringify(header.commit.origin) || stableJsonStringify(record.draft.actor ?? null) !== stableJsonStringify(header.commit.actor ?? null)) {
+      throw new MaterializationValidationError("Materialization event work is invalid.");
+    }
+    return;
+  }
+  if (record.kind === "cardinality") {
+    if (record.scopeSortKey !== linkScopeSortKey(record.ref.source, record.ref.linkId) || record.linkSortKey !== linkRefSortKey(record.ref)) {
+      throw new MaterializationValidationError("Materialization cardinality work has an invalid identity or order.");
+    }
+    return;
+  }
+  if (record.kind === "classification" && record.identityKey.trim().length === 0) {
+    throw new MaterializationValidationError("Materialization classification identity is invalid.");
+  }
+}
+function workUniquenessKey(record) {
+  switch (record.kind) {
+    case "classification":
+      return `classification:${record.entityKind}:${record.identityKey}`;
+    case "object-existence":
+      return `object-existence:${objectRefKey(record.ref)}`;
+    case "incident-object":
+      return `incident-object:${objectRefKey(record.ref)}`;
+    case "cardinality":
+      return `cardinality:${record.scopeSortKey}:${record.linkSortKey}`;
+    case "plan":
+      return `plan:${record.item.kind}:${record.sortKey}`;
+    case "event":
+      return `event:${record.eventKindRank}:${record.sortKey}`;
+  }
+}
+function comparePlanWork(left, right) {
+  return left.applyPhase - right.applyPhase || planKindOrder(left.item.kind) - planKindOrder(right.item.kind) || left.sortKey.localeCompare(right.sortKey) || left.recordKey.localeCompare(right.recordKey);
+}
+function planKindOrder(kind) {
+  switch (kind) {
+    case "object-override-upsert":
+      return 0;
+    case "object-override-delete":
+      return 1;
+    case "link-override-upsert":
+      return 2;
+    case "link-override-delete":
+      return 3;
+    case "point-upsert":
+      return 4;
+    case "link-delete":
+      return 5;
+    case "object-delete":
+      return 6;
+    case "object-upsert":
+      return 7;
+    case "link-upsert":
+      return 8;
+  }
+}
+function compareCardinalityWork(left, right) {
+  return left.scopeSortKey.localeCompare(right.scopeSortKey) || left.linkSortKey.localeCompare(right.linkSortKey) || left.recordKey.localeCompare(right.recordKey);
+}
+function compareEventWork(left, right) {
+  return left.eventKindRank - right.eventKindRank || left.sortKey.localeCompare(right.sortKey) || left.recordKey.localeCompare(right.recordKey);
+}
+function planPhaseMatches(record) {
+  return record.applyPhase === materializationApplyPhase(record.item.kind);
+}
+function assertPlanChunkCorrelations(chunk, commit) {
+  for (const item of materializationPlanItems(chunk))
+    assertPlanItemCorrelation(item, commit);
+  for (const value of chunk.outbox)
+    assertOutboxCorrelation(value, commit);
+}
+function assertPlanItemCorrelation(item, commit) {
+  switch (item.kind) {
+    case "object-override-upsert":
+      assertCommitWriteCorrelation(item.value.lastCommitId, item.value.updatedAt, commit, "Object override");
+      return;
+    case "object-override-delete":
+      return;
+    case "link-override-upsert":
+      assertCommitWriteCorrelation(item.value.lastCommitId, item.value.updatedAt, commit, "Link override");
+      return;
+    case "link-override-delete":
+      return;
+    case "object-upsert":
+      assertObjectRefEqual(item.value.row.ref, item.value.expected.ref, "Effective object upsert");
+      assertCommitWriteCorrelation(item.value.row.lastCommitId, item.value.row.updatedAt, commit, "Effective object");
+      return;
+    case "object-delete":
+      assertObjectRefEqual(item.value.ref, item.value.expected.ref, "Effective object delete");
+      return;
+    case "link-upsert":
+      assertLinkRefEqual(item.value.row.ref, item.value.expected.ref, "Effective link upsert");
+      assertCommitWriteCorrelation(item.value.row.lastCommitId, item.value.row.updatedAt, commit, "Effective link");
+      return;
+    case "link-delete":
+      assertLinkRefEqual(item.value.ref, item.value.expected.ref, "Effective link delete");
+      return;
+    case "point-upsert":
+      assertPointWriteCorrelation(item.value, commit);
+      return;
+  }
+}
+function assertPointWriteCorrelation(value, commit) {
+  if (telemetryPointKey(value.point.series, value.point.at) !== telemetryPointKey(value.expected.series, value.expected.at)) {
+    invalidCorrelation("Timeseries point write does not match its expected identity.");
+  }
+  assertTimestamp(value.point.at, "Timeseries point timestamp");
+  if (value.point.lastCommitId !== commit.id) {
+    invalidCorrelation("Timeseries point last commit id does not match its session commit.");
+  }
+}
+function assertOutboxCorrelation(value, commit) {
+  const { envelope } = value;
+  if (envelope.projectId !== commit.projectId || envelope.commitId !== commit.id || envelope.occurredAt !== commit.committedAt || value.availableAt !== commit.committedAt || value.createdAt !== commit.committedAt || stableJsonStringify(envelope.origin) !== stableJsonStringify(commit.origin) || stableJsonStringify(envelope.actor ?? null) !== stableJsonStringify(commit.actor ?? null) || !Number.isSafeInteger(envelope.commitOrdinal) || envelope.commitOrdinal < 0 || envelope.id !== createEventId(commit.projectId, commit.id, envelope.commitOrdinal)) {
+    invalidCorrelation("Outbox event does not correlate with its materialization commit.");
+  }
+}
+function assertCommitWriteCorrelation(lastCommitId, updatedAt, commit, label) {
+  if (lastCommitId !== commit.id || updatedAt !== commit.committedAt) {
+    invalidCorrelation(`${label} provenance does not match its session commit.`);
+  }
+}
+function assertObjectRefEqual(left, right, label) {
+  if (objectRefKey(left) !== objectRefKey(right)) {
+    invalidCorrelation(`${label} row and expected references differ.`);
+  }
+}
+function assertLinkRefEqual(left, right, label) {
+  if (linkRefKey(left) !== linkRefKey(right)) {
+    invalidCorrelation(`${label} row and expected references differ.`);
+  }
+}
+
+// src/storage/ontology/provider-header-validation.ts
+function assertMaterializationHeader({ commit }) {
+  assertCommitEnvelope(commit);
+  switch (commit.intent.kind) {
+    case "edit":
+      assertEditCommit(commit, commit.intent);
+      break;
+    case "projection":
+      assertProjectionCommit(commit, commit.intent);
+      break;
+    case "telemetry":
+      assertTelemetryCommit(commit, commit.intent);
+      break;
+  }
+}
+function assertCommitEnvelope(commit) {
+  assertNonblank(commit.projectId, "Materialization project id");
+  assertNonblank(commit.id, "Materialization commit id");
+  assertNonblank(commit.idempotencyKey, "Materialization idempotency key");
+  assertNonblank(commit.requestHash, "Materialization request hash");
+  assertNonblank(commit.ontologyRevision, "Materialization ontology revision");
+  assertTimestamp(commit.committedAt, "Materialization commit time");
+}
+function assertEditCommit(commit, intent) {
+  assertNonnegativeInteger(intent.operationCount, "Edit commit operation count");
+  switch (commit.origin.kind) {
+    case "action":
+      assertNonblank(commit.origin.actionId, "Action origin action id");
+      assertNonblank(commit.origin.runId, "Action origin run id");
+      return;
+    case "runtime":
+      assertNonblank(commit.origin.requestId, "Runtime origin request id");
+      return;
+    default:
+      invalidCorrelation("Edit commit origin does not correlate with its intent.");
+  }
+}
+function assertProjectionCommit(commit, intent) {
+  if (commit.origin.kind !== "projection") {
+    invalidCorrelation("Projection commit origin does not correlate with its intent.");
+  }
+  assertProjectionSemanticMetadata(commit);
+  assertNonblank(commit.origin.projectionRunId, "Projection run id");
+  assertTimestamp(intent.datasetVersion.createdAt, "Projection dataset version createdAt");
+  if (commit.origin.projectionId !== intent.source.projectionId) {
+    invalidCorrelation("Projection commit origin does not match its projection.");
+  }
+  if (commit.origin.datasetId !== intent.datasetVersion.datasetId || commit.origin.datasetVersionId !== intent.datasetVersion.versionId) {
+    invalidCorrelation("Projection commit origin does not match its dataset version.");
+  }
+}
+function assertTelemetryCommit(commit, intent) {
+  if (commit.origin.kind !== "telemetry") {
+    invalidCorrelation("Telemetry commit origin does not correlate with its intent.");
+  }
+  assertTelemetryPointCounts(intent);
+  if (intent.source.kind === "runtime") {
+    assertRuntimeTelemetryCommit(commit);
+    return;
+  }
+  assertProjectionTelemetryCommit(commit, intent.source, intent.inputPointCount);
+}
+function assertTelemetryPointCounts(intent) {
+  assertNonnegativeInteger(intent.pointCount, "Telemetry commit point count");
+  assertNonnegativeInteger(intent.inputPointCount, "Telemetry commit input point count");
+  if (intent.inputPointCount < intent.pointCount) {
+    invalidCorrelation("Telemetry input point count cannot be lower than its canonical point count.");
+  }
+}
+function assertRuntimeTelemetryCommit(commit) {
+  if (commit.origin.kind !== "telemetry" || commit.origin.source.kind !== "runtime") {
+    invalidCorrelation("Runtime telemetry origin does not correlate with its intent.");
+  }
+  if (commit.projectionRevision !== undefined || commit.ownershipHash !== undefined) {
+    invalidCorrelation("Runtime telemetry commit contains projection-only metadata.");
+  }
+  assertNonblank(commit.origin.source.requestId, "Runtime telemetry request id");
+}
+function assertProjectionTelemetryCommit(commit, source, inputPointCount) {
+  if (commit.origin.kind !== "telemetry" || commit.origin.source.kind !== "projection") {
+    invalidCorrelation("Projection telemetry origin does not correlate with its intent.");
+  }
+  const origin = commit.origin.source;
+  assertProjectionSemanticMetadata(commit);
+  assertNonblank(origin.projectionRunId, "Telemetry projection run id");
+  assertTimestamp(source.datasetVersion.createdAt, "Telemetry dataset version createdAt");
+  assertProjectionTelemetryBatch(source, inputPointCount);
+  if (origin.projectionId !== source.projection.projectionId) {
+    invalidCorrelation("Projection telemetry origin does not match its projection.");
+  }
+  if (origin.datasetId !== source.datasetVersion.datasetId || origin.datasetVersionId !== source.datasetVersion.versionId) {
+    invalidCorrelation("Projection telemetry origin does not match its dataset version.");
+  }
+  if (origin.batchOrdinal !== source.batchOrdinal) {
+    invalidCorrelation("Projection telemetry origin does not match its batch ordinal.");
+  }
+}
+function assertProjectionTelemetryBatch(source, inputPointCount) {
+  assertNonnegativeInteger(source.batchOrdinal, "Projection telemetry batch ordinal");
+  assertPositiveInteger(source.sourceRowCount, "Projection telemetry source row count");
+  assertNonnegativeInteger(source.sourceRowsSkipped, "Projection telemetry skipped row count");
+  if (source.sourceRowsSkipped > source.sourceRowCount) {
+    invalidCorrelation("Projection telemetry skipped rows exceed its source row count.");
+  }
+  if (source.sourceRowCount !== inputPointCount + source.sourceRowsSkipped) {
+    invalidCorrelation("Projection telemetry source row count does not match input points plus skipped rows.");
+  }
+  if (typeof source.inputExhausted !== "boolean") {
+    invalidCorrelation("Projection telemetry input exhaustion marker is invalid.");
+  }
+}
+function assertProjectionSemanticMetadata(commit) {
+  if (commit.projectionRevision === undefined || commit.ownershipHash === undefined) {
+    invalidCorrelation("Projection materialization is missing semantic identity metadata.");
+  }
+  assertNonblank(commit.projectionRevision, "Projection revision");
+  assertNonblank(commit.ownershipHash, "Projection ownership hash");
+}
+
+// src/storage/ontology/provider.ts
+function startScopeAccumulator(source, linkId, scopeSortKey) {
+  const hash = createHash("sha256");
+  hash.update("[");
+  return {
+    scopeSortKey,
+    source: structuredClone(source),
+    linkId,
+    hash,
+    effectiveCount: 0
+  };
+}
+function appendScopeSnapshot(accumulator, snapshot) {
+  if (accumulator.effectiveCount > 0)
+    accumulator.hash.update(",");
+  accumulator.hash.update(stableJsonStringify({
+    ref: snapshot.ref,
+    properties: snapshot.properties ?? {},
+    lastCommitId: snapshot.lastCommitId
+  }));
+  accumulator.effectiveCount += 1;
+}
+function finishScopeAccumulator(accumulator) {
+  accumulator.hash.update("]");
+  return {
+    source: accumulator.source,
+    linkId: accumulator.linkId,
+    effectiveCount: accumulator.effectiveCount,
+    fingerprint: accumulator.hash.digest("hex")
+  };
+}
+
+class ProviderMaterializationSessionState {
+  header;
+  transactionId;
+  id = randomUUID();
+  providerToken = {};
+  workStreams = {
+    apply: { started: false, completed: false, emittedCount: 0 },
+    cardinality: { started: false, completed: false, emittedCount: 0 },
+    event: { started: false, completed: false, emittedCount: 0 }
+  };
+  active = true;
+  workSealed = false;
+  appliedPlanCount = 0;
+  appliedOutboxCount = 0;
+  replacement = null;
+  constructor(header, transactionId) {
+    this.header = header;
+    this.transactionId = transactionId;
+  }
+  publicSession() {
+    return { providerToken: this.providerToken };
+  }
+}
+
+class ProviderMaterializationTransactionLifecycle {
+  openSessions = new Set;
+  active = true;
+  register(sessionToken) {
+    if (!this.active) {
+      throw new MaterializationValidationError("Cannot open a materialization session on an inactive storage transaction.");
+    }
+    this.openSessions.add(sessionToken);
+  }
+  complete(sessionToken) {
+    this.openSessions.delete(sessionToken);
+  }
+  assertCommittable() {
+    if (this.openSessions.size === 0)
+      return;
+    throw new MaterializationValidationError(`Storage transaction has ${this.openSessions.size} unfinished materialization session${this.openSessions.size === 1 ? "" : "s"}; every session returned by begin() must be finalized.`);
+  }
+  deactivate() {
+    this.active = false;
+    this.openSessions.clear();
+  }
+}
+function prepareMaterializationWork(state, input) {
+  if (state.workSealed) {
+    throw new MaterializationConflictError("effective-state", "Materialization work cannot be staged after draining begins.");
+  }
+  const keys = new Set;
+  const uniqueKeys = new Set;
+  return input.records.map((record) => {
+    assertWorkRecord(record, state.header);
+    const uniqueKey = workUniquenessKey(record);
+    if (keys.has(record.recordKey) || uniqueKeys.has(uniqueKey)) {
+      throw duplicateMaterializationWork(record.recordKey);
+    }
+    if (record.kind === "incident-object" && (!state.replacement || state.replacement.linkStreamStarted)) {
+      throw new MaterializationConflictError("effective-state", "Incident replacement work must be staged before link state is streamed.");
+    }
+    keys.add(record.recordKey);
+    uniqueKeys.add(uniqueKey);
+    return { record, uniqueKey, columns: materializationWorkColumns(record) };
+  });
+}
+function correlateMaterializationChunk(state, chunk, actualItems, expectedItems, expectedEvents) {
+  if (actualItems.length > 0 && (!state.workStreams.apply.started || state.appliedPlanCount + actualItems.length > state.workStreams.apply.emittedCount)) {
+    invalidMaterializationCorrelation("Materialization plan items cannot be applied before they are streamed.");
+  }
+  for (let index = 0;index < actualItems.length; index += 1) {
+    if (stableJsonStringify(actualItems[index]) !== stableJsonStringify(expectedItems[index])) {
+      invalidMaterializationCorrelation("Materialization plan items must be applied in exact streamed order.");
+    }
+  }
+  if (chunk.outbox.length > 0 && (!state.workStreams.event.started || state.appliedOutboxCount + chunk.outbox.length > state.workStreams.event.emittedCount)) {
+    invalidMaterializationCorrelation("Materialization events cannot be applied before they are streamed.");
+  }
+  for (let index = 0;index < chunk.outbox.length; index += 1) {
+    const expected = expectedEvents[index];
+    const actual = chunk.outbox[index]?.envelope;
+    if (!expected || !actual) {
+      invalidMaterializationCorrelation("Materialization outbox events must follow exact streamed order.");
+    }
+    const { id: _id, commitOrdinal, ...draft } = actual;
+    if (commitOrdinal !== state.appliedOutboxCount + index || stableJsonStringify(draft) !== stableJsonStringify(expected.draft)) {
+      invalidMaterializationCorrelation("Materialization outbox events must follow exact streamed order.");
+    }
+  }
+  return {
+    appliedPlanCount: state.appliedPlanCount + actualItems.length,
+    appliedOutboxCount: state.appliedOutboxCount + chunk.outbox.length
+  };
+}
+function assertMaterializationFinalizationCorrelation(state, input) {
+  const { commit } = state.header;
+  const { result, sourceActivations } = input.finalization;
+  if (result.commitId !== commit.id || result.kind !== commit.intent.kind || result.committedAt !== commit.committedAt || result.created !== true || !Number.isSafeInteger(result.eventCount) || result.eventCount < 0 || result.eventCount !== state.appliedOutboxCount) {
+    invalidMaterializationCorrelation("Materialization result does not correlate with its commit intent.");
+  }
+  if (commit.intent.kind === "edit") {
+    if (result.kind !== "edit" || result.outcomes.length !== commit.intent.operationCount) {
+      invalidMaterializationCorrelation("Edit result does not correlate with its operation count.");
+    }
+    if (sourceActivations.length !== 0) {
+      invalidMaterializationCorrelation("Edit materialization cannot activate a source materialization.");
+    }
+  } else if (commit.intent.kind === "projection") {
+    if (result.kind !== "projection" || sourceActivations.length !== 1) {
+      invalidMaterializationCorrelation("Projection result requires exactly one correlated source activation.");
+    }
+  } else if (result.kind !== "telemetry" || sourceActivations.length !== 0) {
+    invalidMaterializationCorrelation("Telemetry result does not correlate with its point intent.");
+  }
+}
+function assertMaterializationLaneCompletion(state, counts) {
+  if (counts.apply > 0 && !state.workStreams.apply.completed) {
+    invalidMaterializationCorrelation("Materialization plan work was not fully streamed.");
+  }
+  if (state.appliedPlanCount !== counts.apply) {
+    invalidMaterializationCorrelation("Materialization plan work was not applied exactly once.");
+  }
+  if (counts.cardinality > 0 && !state.workStreams.cardinality.completed) {
+    invalidMaterializationCorrelation("Materialization cardinality work was not fully validated.");
+  }
+  if (counts.event > 0 && !state.workStreams.event.completed) {
+    invalidMaterializationCorrelation("Materialization event work was not fully drained.");
+  }
+  if (counts.event !== state.appliedOutboxCount) {
+    invalidMaterializationCorrelation("Materialization event work was not fully written to the outbox.");
+  }
+}
+function assertSourceActivationCorrelation(state, activation) {
+  const { commit } = state.header;
+  if (commit.intent.kind !== "projection" || commit.origin.kind !== "projection" || activation.source.projectionId !== commit.intent.source.projectionId || activation.source.projectionId !== commit.origin.projectionId || activation.execution.projectionRunId !== commit.origin.projectionRunId || activation.protocol !== "replacement" || stableJsonStringify(activation.datasetVersion) !== stableJsonStringify(commit.intent.datasetVersion) || activation.projectionRevision !== commit.projectionRevision || activation.ownershipHash !== commit.ownershipHash || activation.ontologyRevision !== commit.ontologyRevision || activation.lastCommitId !== commit.id || activation.updatedAt !== commit.committedAt || !state.header.expected.sources.some((expected) => stableJsonStringify(expected) === stableJsonStringify(activation.expected))) {
+    invalidMaterializationCorrelation("Source activation does not correlate with its projection commit.");
+  }
+  const replacement = state.replacement;
+  if (!replacement || replacement.sourceId !== activation.source.projectionId || replacement.candidateMaterializationId !== activation.materializationId || replacement.projectionKind !== activation.projectionKind || activation.projectionKind === "object" && (!replacement.objectStreamCompleted || !replacement.linkStreamCompleted) || activation.projectionKind === "link" && !replacement.linkStreamCompleted) {
+    invalidMaterializationCorrelation("Source activation does not match fully streamed replacement state.");
+  }
+}
+function invalidMaterializationCorrelation(message) {
+  throw new MaterializationValidationError(message);
+}
+function uniqueSorted(values, identity, sortKey) {
+  return [...new Map(values.map((value) => [identity(value), value])).values()].sort((left, right) => sortKey(left).localeCompare(sortKey(right)));
+}
+function overrideEntityColumns(entity) {
+  if (entity.kind === "object") {
+    return {
+      sortKey: objectRefSortKey(entity.ref),
+      objectTypeId: entity.ref.objectTypeId,
+      primaryId: entity.ref.primaryId,
+      sourceTypeId: null,
+      sourcePrimaryId: null,
+      linkId: null,
+      targetTypeId: null,
+      targetPrimaryId: null
+    };
+  }
+  return {
+    sortKey: linkRefSortKey(entity.ref),
+    objectTypeId: null,
+    primaryId: null,
+    sourceTypeId: entity.ref.source.objectTypeId,
+    sourcePrimaryId: entity.ref.source.primaryId,
+    linkId: entity.ref.linkId,
+    targetTypeId: entity.ref.target.objectTypeId,
+    targetPrimaryId: entity.ref.target.primaryId
+  };
+}
+function sameNonnegativeCounts(actual, expected) {
+  const actualCounts = actual;
+  return Object.entries(expected).every(([key, value]) => typeof value === "number" && Number.isSafeInteger(actualCounts[key]) && actualCounts[key] === value && value >= 0);
+}
+function effectiveConflict(message) {
+  return new MaterializationConflictError("effective-state", message);
+}
+function materializationWorkColumns(record) {
+  if (record.kind === "plan") {
+    return {
+      lane: "apply",
+      majorOrder: record.applyPhase,
+      minorOrder: materializationPlanKindRank(record.item.kind),
+      sortOne: record.sortKey,
+      sortTwo: ""
+    };
+  }
+  if (record.kind === "cardinality") {
+    return {
+      lane: "cardinality",
+      majorOrder: 0,
+      minorOrder: 0,
+      sortOne: record.scopeSortKey,
+      sortTwo: record.linkSortKey
+    };
+  }
+  if (record.kind === "event") {
+    return {
+      lane: "event",
+      majorOrder: record.eventKindRank,
+      minorOrder: 0,
+      sortOne: record.sortKey,
+      sortTwo: ""
+    };
+  }
+  return { lane: "none", majorOrder: 0, minorOrder: 0, sortOne: "", sortTwo: "" };
+}
+function materializationPlanKindRank(kind) {
+  switch (kind) {
+    case "object-override-upsert":
+      return 0;
+    case "object-override-delete":
+      return 1;
+    case "link-override-upsert":
+      return 2;
+    case "link-override-delete":
+      return 3;
+    case "point-upsert":
+      return 4;
+    case "link-delete":
+      return 5;
+    case "object-delete":
+      return 6;
+    case "object-upsert":
+      return 7;
+    case "link-upsert":
+      return 8;
+  }
+}
+function duplicateMaterializationWork(key) {
+  return new MaterializationConflictError("effective-state", `Duplicate materialization work key '${key}'.`);
+}
+function canonicalJson(value) {
+  return stableJsonStringify(value);
+}
+function originColumns(origin) {
+  if (origin.kind === "action") {
+    return { kind: "action", runId: origin.runId, batchOrdinal: null };
+  }
+  if (origin.kind === "projection") {
+    return { kind: "projection", runId: origin.projectionRunId, batchOrdinal: null };
+  }
+  if (origin.kind === "telemetry" && origin.source.kind === "projection") {
+    return {
+      kind: "telemetry",
+      runId: origin.source.projectionRunId,
+      batchOrdinal: origin.source.batchOrdinal
+    };
+  }
+  return { kind: origin.kind, runId: null, batchOrdinal: null };
+}
+function originWhere(origin) {
+  if (origin.kind === "action") {
+    return { kind: origin.kind, runId: origin.actionRunId, batchOrdinal: null };
+  }
+  if (origin.kind === "projection") {
+    return { kind: origin.kind, runId: origin.projectionRunId, batchOrdinal: null };
+  }
+  return {
+    kind: origin.kind,
+    runId: origin.projectionRunId,
+    batchOrdinal: origin.batchOrdinal
+  };
+}
+function objectRefFromColumns(row) {
+  return { objectTypeId: row.object_type_id, primaryId: row.primary_id };
+}
+function linkRefFromColumns(row) {
+  return {
+    source: { objectTypeId: row.source_type_id, primaryId: row.source_id },
+    linkId: row.link_id,
+    target: { objectTypeId: row.target_type_id, primaryId: row.target_id }
+  };
+}
+function sourceEntityKey(row) {
+  return projectionEntityKey(row.assertion);
+}
+function sourceStageRows(projectionKind, rows) {
+  return rows.map((row) => {
+    assertSourceStagedRow(projectionKind, row);
+    return sourceStageRow(row);
+  });
+}
+function sourceStageRow(row) {
+  return {
+    row,
+    rootKey: projectionEntityKey(row.root),
+    entityKey: sourceEntityKey(row)
+  };
+}
+function reconcileSourceStageRows(rows, existingRows) {
+  const rootOrdinals = new Map(existingRows.map(({ rootKey, row }) => [rootKey, row.stagingOrdinal]));
+  const ordinalRoots = new Map(existingRows.map(({ rootKey, row }) => [row.stagingOrdinal, rootKey]));
+  const assertions = new Map(existingRows.map((row) => [row.entityKey, row.row]));
+  const pending = new Map;
+  let unchanged = 0;
+  for (const staged of rows) {
+    const { entityKey, rootKey, row } = staged;
+    const rootOrdinal = rootOrdinals.get(rootKey);
+    if (rootOrdinal !== undefined && rootOrdinal !== row.stagingOrdinal) {
+      throw new MaterializationValidationError(`Source materialization repeats root ${rootKey} at a different stream ordinal.`);
+    }
+    const ordinalRoot = ordinalRoots.get(row.stagingOrdinal);
+    if (ordinalRoot !== undefined && ordinalRoot !== rootKey) {
+      throw new MaterializationValidationError(`Source materialization repeats stream ordinal ${row.stagingOrdinal} for another root.`);
+    }
+    const existing = assertions.get(entityKey) ?? pending.get(entityKey)?.row;
+    if (existing) {
+      if (canonicalJson(existing) === canonicalJson(row)) {
+        unchanged += 1;
+        continue;
+      }
+      throw new MaterializationValidationError(`Source materialization repeats asserted entity ${entityKey}.`);
+    }
+    rootOrdinals.set(rootKey, row.stagingOrdinal);
+    ordinalRoots.set(row.stagingOrdinal, rootKey);
+    pending.set(entityKey, { ...staged, row: structuredClone(row) });
+  }
+  return { pending: [...pending.values()], unchanged };
+}
+function sourceMaterializationIdentity(input) {
+  return {
+    projectionKind: input.projectionKind,
+    protocol: input.protocol,
+    datasetVersion: input.datasetVersion,
+    projectionRevision: input.projectionRevision,
+    ownershipHash: input.ownershipHash,
+    ontologyRevision: input.ontologyRevision
+  };
+}
+function assertSourceBeginInput(input) {
+  assertSourceWriteIdentity(input);
+  if (input.projectionKind !== "object" && input.projectionKind !== "link") {
+    throw new MaterializationValidationError("Source projection kind must be 'object' or 'link'.");
+  }
+  if (input.protocol !== "replacement") {
+    throw new MaterializationValidationError("Source materialization protocol must be 'replacement'.");
+  }
+  assertNonblank(input.projectionRevision, "Source projection revision");
+  assertNonblank(input.ownershipHash, "Source ownership hash");
+  assertNonblank(input.ontologyRevision, "Source ontology revision");
+  assertNonblank(input.datasetVersion.datasetId, "Source dataset id");
+  assertNonblank(input.datasetVersion.versionId, "Source dataset version id");
+  assertTimestamp(input.datasetVersion.createdAt, "Source dataset version createdAt", true);
+  assertTimestamp(input.createdAt, "Source createdAt", true);
+}
+function assertSourceWriteIdentity(input) {
+  assertSourceProject(input);
+  assertNonblank(input.materializationId, "Source materialization id");
+  assertSourceExecutionIdentity(input.execution.projectionRunId, input.execution.executionToken);
+}
+function assertSourceProject(input) {
+  assertNonblank(input.projectId, "Source project id");
+  assertNonblank(input.source.projectionId, "Source projection id");
+}
+function assertSourceExecutionIdentity(runId, token) {
+  assertNonblank(runId, "Source projection run id");
+  assertNonblank(token, "Source execution token");
+}
+function assertSourceCandidateOwner(manifest, execution) {
+  if (manifest.projectionRunId !== execution.projectionRunId || manifest.executionToken !== execution.executionToken) {
+    throw sourceConflict(`Source materialization '${manifest.materializationId}' is owned by another execution.`);
+  }
+}
+function assertSourceStagedRow(projectionKind, row) {
+  if (!Number.isSafeInteger(row.stagingOrdinal) || row.stagingOrdinal < 0) {
+    throw new MaterializationValidationError("Source staging ordinal must be a nonnegative safe integer.");
+  }
+  assertSourceEntity(row.root, "Source root");
+  assertSourceEntity(row.assertion, "Source assertion");
+  if (projectionKind === "object" && row.root.kind !== "object") {
+    throw new MaterializationValidationError("Object projection source rows require an object root.");
+  }
+  if (projectionKind === "link" && (row.root.kind !== "link" || row.assertion.kind !== "link")) {
+    throw new MaterializationValidationError("Link projection source rows require a link root and link assertion.");
+  }
+}
+function assertSourceEntity(entity, label) {
+  if (entity.kind === "object") {
+    assertNonblank(entity.ref.objectTypeId, `${label} object type id`);
+    assertNonblank(entity.ref.primaryId, `${label} primary id`);
+    return;
+  }
+  assertNonblank(entity.ref.source.objectTypeId, `${label} source object type id`);
+  assertNonblank(entity.ref.source.primaryId, `${label} source primary id`);
+  assertNonblank(entity.ref.linkId, `${label} link id`);
+  assertNonblank(entity.ref.target.objectTypeId, `${label} target object type id`);
+  assertNonblank(entity.ref.target.primaryId, `${label} target primary id`);
+}
+function sourceEntityColumns(entity) {
+  if (entity.kind === "object") {
+    return {
+      objectTypeId: entity.ref.objectTypeId,
+      primaryId: entity.ref.primaryId,
+      sourceTypeId: null,
+      sourcePrimaryId: null,
+      linkId: null,
+      targetTypeId: null,
+      targetPrimaryId: null
+    };
+  }
+  return {
+    objectTypeId: null,
+    primaryId: null,
+    sourceTypeId: entity.ref.source.objectTypeId,
+    sourcePrimaryId: entity.ref.source.primaryId,
+    linkId: entity.ref.linkId,
+    targetTypeId: entity.ref.target.objectTypeId,
+    targetPrimaryId: entity.ref.target.primaryId
+  };
+}
+function utf8SortKey(canonicalKey) {
+  let key = "";
+  for (const byte of new TextEncoder().encode(canonicalKey)) {
+    key += byte.toString(16).padStart(2, "0");
+  }
+  return key;
+}
+function isExactStagingManifest(row, input) {
+  return row.status === "staging" && row.executionToken === input.execution.executionToken && row.projectionRunId === input.execution.projectionRunId && row.projectionKind === input.projectionKind && row.protocol === input.protocol && row.createdAt === input.createdAt && row.datasetVersion.datasetId === input.datasetVersion.datasetId && row.datasetVersion.versionId === input.datasetVersion.versionId && row.datasetVersion.createdAt === input.datasetVersion.createdAt && row.projectionRevision === input.projectionRevision && row.ownershipHash === input.ownershipHash && row.ontologyRevision === input.ontologyRevision;
+}
+function sourceConflict(message) {
+  return new MaterializationConflictError("source-materialization", message);
+}
+
+export { assertNonblank, assertPositiveInteger, assertNonnegativeInteger, assertTimestamp, invalidCorrelation, materializationApplyPhase, assertPageRows, materializationChunkRows, materializationPlanItems, assertWorkRecord, workUniquenessKey, comparePlanWork, compareCardinalityWork, compareEventWork, assertPlanChunkCorrelations, assertMaterializationHeader, startScopeAccumulator, appendScopeSnapshot, finishScopeAccumulator, ProviderMaterializationSessionState, ProviderMaterializationTransactionLifecycle, prepareMaterializationWork, correlateMaterializationChunk, assertMaterializationFinalizationCorrelation, assertMaterializationLaneCompletion, assertSourceActivationCorrelation, uniqueSorted, overrideEntityColumns, sameNonnegativeCounts, effectiveConflict, materializationWorkColumns, duplicateMaterializationWork, canonicalJson, originColumns, originWhere, objectRefFromColumns, linkRefFromColumns, sourceEntityKey, sourceStageRows, sourceStageRow, reconcileSourceStageRows, sourceMaterializationIdentity, assertSourceBeginInput, assertSourceWriteIdentity, assertSourceProject, assertSourceExecutionIdentity, assertSourceCandidateOwner, assertSourceStagedRow, sourceEntityColumns, utf8SortKey, isExactStagingManifest, sourceConflict };
+
+//# debugId=090390A7C7635B9064756E2164756E21