@sixb/core 0.0.1

package/dist/chunk-50kv63vj.js

@@ -0,0 +1,523 @@
+// @bun
+import {
+  MaterializationConflictError
+} from "./chunk-ry24jbr1.js";
+
+// src/storage/projection-runs/errors.ts
+class ProjectionRunError extends MaterializationConflictError {
+  name = "ProjectionRunError";
+  constructor(message, kind = "run-correlation") {
+    super(kind, message);
+  }
+}
+
+// src/storage/projection-runs/types.ts
+var progressKeyFlags = {
+  sourceRowsRead: true,
+  sourceRowsSkipped: true
+};
+var PROJECTION_RUN_PROGRESS_KEYS = Object.keys(progressKeyFlags);
+function zeroProjectionRunProgress() {
+  const progress = {};
+  for (const key of PROJECTION_RUN_PROGRESS_KEYS)
+    progress[key] = 0;
+  return progress;
+}
+function projectionRunObjectTypesVisible(run, canView) {
+  const target = run.target;
+  if ("sourceObjectTypeId" in target) {
+    return canView(target.sourceObjectTypeId) && canView(target.targetObjectTypeId);
+  }
+  return canView(target.objectTypeId);
+}
+
+// src/storage/projection-runs/lifecycle.ts
+function assertProjectionRunNonEmpty(value, fieldName) {
+  if (typeof value !== "string" || value.trim().length === 0) {
+    throw new ProjectionRunError(`[Sixb] Projection run ${fieldName} must not be empty.`);
+  }
+}
+function assertProjectionRunCounter(value, fieldName) {
+  if (!Number.isSafeInteger(value) || value < 0) {
+    throw new ProjectionRunError(`[Sixb] Projection run ${fieldName} must be a non-negative safe integer.`);
+  }
+}
+function assertProjectionRunListWindow(value, fieldName) {
+  if (value !== undefined && (!Number.isSafeInteger(value) || value < 0)) {
+    throw new ProjectionRunError(`[Sixb] Projection run list ${fieldName} must be >= 0.`);
+  }
+}
+function addProjectionRunCounter(left, right, fieldName) {
+  const result = left + right;
+  if (!Number.isSafeInteger(result)) {
+    throw new ProjectionRunError(`[Sixb] Projection run ${fieldName} exceeds safe integer range.`);
+  }
+  return result;
+}
+function assertProjectionRunIdentity(identity) {
+  assertProjectionRunNonEmpty(identity.projectionId, "projectionId");
+  if (!isProjectionKind(identity.projectionKind)) {
+    throw new ProjectionRunError("[Sixb] Projection run projectionKind must be 'object', 'link', or 'telemetry'.");
+  }
+  if (identity.protocol !== "replacement" && identity.protocol !== "telemetry") {
+    throw new ProjectionRunError("[Sixb] Projection run protocol must be 'replacement' or 'telemetry'.");
+  }
+  assertProjectionRunNonEmpty(identity.datasetVersion.datasetId, "datasetId");
+  assertProjectionRunNonEmpty(identity.datasetVersion.versionId, "datasetVersionId");
+  assertCanonicalTimestamp(identity.datasetVersion.createdAt, "datasetVersionCreatedAt");
+  assertProjectionRunNonEmpty(identity.ontologyRevision, "ontologyRevision");
+  assertProjectionRunNonEmpty(identity.projectionRevision, "projectionRevision");
+  assertProjectionRunNonEmpty(identity.ownershipHash, "ownershipHash");
+  if (identity.protocol === "telemetry" !== (identity.projectionKind === "telemetry")) {
+    throw new ProjectionRunError(`[Sixb] Projection run protocol '${identity.protocol}' is incompatible with kind '${identity.projectionKind}'.`);
+  }
+}
+function assertProjectionRunIdentityMatches(record, identity) {
+  if (projectionRunIdentitiesEqual(record.identity, identity))
+    return;
+  throw new ProjectionRunError(`[Sixb] Projection run '${record.id}' materialization identity does not match.`);
+}
+function assertProjectionRunTargetMatches(record, target) {
+  if (projectionTargetsEqual(record.target, target))
+    return;
+  throw new ProjectionRunError(`[Sixb] Projection run '${record.id}' target object types do not match.`);
+}
+function assertProjectionRunStartInput(input) {
+  assertProjectionRunNonEmpty(input.id, "id");
+  assertProjectionRunNonEmpty(input.projectId, "projectId");
+  assertProjectionRunIdentity(input.identity);
+  assertProjectionTarget(input.identity.projectionKind, input.target);
+  if (input.startedAt)
+    assertProjectionRunDate(input.startedAt, "startedAt");
+  if (input.identity.projectionKind === "telemetry") {
+    const telemetry = input;
+    assertPositiveCounter(telemetry.fixedBatchSize, "fixedBatchSize");
+  } else if (input.fixedBatchSize !== undefined) {
+    throw new ProjectionRunError("[Sixb] Replacement projection runs cannot declare a telemetry fixedBatchSize.");
+  }
+}
+function planProjectionRunReclaim(record, input) {
+  assertProjectionRunRunning(record);
+  assertProjectionRunIdentityMatches(record, input.identity);
+  assertProjectionRunTargetMatches(record, input.target);
+  if (record.telemetryCheckpoint?.fixedBatchSize !== input.fixedBatchSize) {
+    throw new ProjectionRunError(`[Sixb] Projection run '${input.id}' fixed batch size does not match.`);
+  }
+  return { attempt: nextProjectionRunAttempt(record.attempt) };
+}
+function createProjectionRunRecord(input, now = new Date) {
+  assertProjectionRunStartInput(input);
+  const base = {
+    id: input.id,
+    projectId: input.projectId,
+    status: "running",
+    attempt: 1,
+    progress: zeroProjectionRunProgress(),
+    startedAt: new Date(input.startedAt ?? now)
+  };
+  switch (input.identity.projectionKind) {
+    case "object": {
+      const object = input;
+      return { ...base, identity: object.identity, target: object.target };
+    }
+    case "link": {
+      const link = input;
+      return { ...base, identity: link.identity, target: link.target };
+    }
+    case "telemetry": {
+      const telemetry = input;
+      return {
+        ...base,
+        identity: telemetry.identity,
+        target: telemetry.target,
+        telemetryCheckpoint: {
+          fixedBatchSize: telemetry.fixedBatchSize,
+          nextBatchOrdinal: 0,
+          nextRowOffset: 0,
+          inputExhausted: false
+        }
+      };
+    }
+  }
+}
+function assertProjectionRunRunning(record) {
+  if (record.status === "running")
+    return;
+  throw new ProjectionRunError(`[Sixb] Projection run '${record.id}' for project '${record.projectId}' is already terminal.`);
+}
+function assertProjectionRunExecution(record, input) {
+  assertProjectionRunNonEmpty(input.executionToken, "executionToken");
+  assertProjectionRunIdentity(input.identity);
+  assertProjectionRunRunning(record);
+  assertProjectionRunIdentityMatches(record, input.identity);
+  if (record.executionToken !== input.executionToken) {
+    throw staleProjectionRunExecution(input.id);
+  }
+}
+function nextProjectionRunAttempt(current) {
+  assertProjectionRunCounter(current, "attempt");
+  return addProjectionRunCounter(current, 1, "attempt");
+}
+function mergeProjectionRunProgress(current, patch) {
+  const progress = { ...current };
+  for (const key of PROJECTION_RUN_PROGRESS_KEYS) {
+    const value = patch[key];
+    if (value === undefined)
+      continue;
+    assertProjectionRunCounter(value, key);
+    if (value < current[key]) {
+      throw new ProjectionRunError(`[Sixb] Projection run ${key} must not decrease.`);
+    }
+    progress[key] = value;
+  }
+  assertProjectionRunProgress(progress);
+  return progress;
+}
+function assertGenericProgressDoesNotAdvanceTelemetry(record, patch) {
+  if (record.identity.protocol !== "telemetry")
+    return;
+  for (const key of PROJECTION_RUN_PROGRESS_KEYS) {
+    if (patch[key] !== undefined && patch[key] !== record.progress[key]) {
+      throw new ProjectionRunError(`[Sixb] Telemetry projection run '${record.id}' progress can only advance with its checkpoint.`);
+    }
+  }
+}
+function advanceProjectionTelemetry(record, input) {
+  const telemetry = requireTelemetryProjectionRun(record);
+  const checkpoint = telemetry.telemetryCheckpoint;
+  assertProjectionRunCounter(input.batchOrdinal, "batchOrdinal");
+  assertPositiveCounter(input.batchRowCount, "batchRowCount");
+  assertProjectionRunCounter(input.batchRowsSkipped, "batchRowsSkipped");
+  if (input.batchRowsSkipped > input.batchRowCount) {
+    throw new ProjectionRunError(`[Sixb] Telemetry projection run '${record.id}' skipped rows exceed its batch row count.`);
+  }
+  if (input.batchOrdinal !== checkpoint.nextBatchOrdinal) {
+    throw new ProjectionRunError(`[Sixb] Telemetry projection run '${record.id}' expected batch ordinal ${checkpoint.nextBatchOrdinal}, got ${input.batchOrdinal}.`);
+  }
+  if (input.batchRowCount > checkpoint.fixedBatchSize) {
+    throw new ProjectionRunError(`[Sixb] Telemetry projection run '${record.id}' batch exceeds its fixed size.`);
+  }
+  if (!input.inputExhausted && input.batchRowCount !== checkpoint.fixedBatchSize) {
+    throw new ProjectionRunError(`[Sixb] Telemetry projection run '${record.id}' cannot advance past a partial non-final batch.`);
+  }
+  if (checkpoint.inputExhausted) {
+    throw new ProjectionRunError(`[Sixb] Telemetry projection run '${record.id}' has already exhausted its input.`);
+  }
+  const nextRowOffset = addProjectionRunCounter(checkpoint.nextRowOffset, input.batchRowCount, "nextRowOffset");
+  return {
+    progress: {
+      sourceRowsRead: nextRowOffset,
+      sourceRowsSkipped: addProjectionRunCounter(telemetry.progress.sourceRowsSkipped, input.batchRowsSkipped, "sourceRowsSkipped")
+    },
+    checkpoint: {
+      ...checkpoint,
+      nextBatchOrdinal: addProjectionRunCounter(checkpoint.nextBatchOrdinal, 1, "nextBatchOrdinal"),
+      nextRowOffset,
+      inputExhausted: input.inputExhausted
+    }
+  };
+}
+function planProjectionRunFinish(record, input, now = new Date) {
+  assertFinishDecision(record, input);
+  const patch = input.progress ?? {};
+  assertGenericProgressDoesNotAdvanceTelemetry(record, patch);
+  const progress = mergeProjectionRunProgress(record.progress, patch);
+  const finishedAt = new Date(input.finishedAt ?? now);
+  assertProjectionRunDate(finishedAt, "finishedAt");
+  return {
+    status: input.status,
+    finishedAt,
+    progress,
+    ...input.status === "succeeded" && input.protocol === "telemetry" ? { inputExhausted: true } : {},
+    ...input.status === "succeeded" || input.errorMessage === undefined ? {} : { errorMessage: input.errorMessage }
+  };
+}
+function finishProjectionRunRecord(record, input, now = new Date) {
+  const plan = planProjectionRunFinish(record, input, now);
+  const terminal = {
+    executionToken: undefined,
+    status: plan.status,
+    finishedAt: plan.finishedAt,
+    progress: plan.progress,
+    errorMessage: plan.errorMessage
+  };
+  if (plan.inputExhausted) {
+    const telemetry = requireTelemetryProjectionRun(record);
+    return {
+      ...telemetry,
+      ...terminal,
+      telemetryCheckpoint: { ...telemetry.telemetryCheckpoint, inputExhausted: true }
+    };
+  }
+  return { ...record, ...terminal };
+}
+function restoreProjectionRun(row) {
+  assertProjectionRunNonEmpty(row.id, "id");
+  assertProjectionRunNonEmpty(row.projectId, "projectId");
+  assertProjectionRunCounter(row.attempt, "attempt");
+  if (row.attempt < 1) {
+    throw new ProjectionRunError(`[Sixb] Projection run '${row.id}' attempt must be positive.`);
+  }
+  assertProjectionRunProgress(row.progress);
+  assertValidDate(row.startedAt, "startedAt");
+  if (row.finishedAt)
+    assertValidDate(row.finishedAt, "finishedAt");
+  if (row.status === "running" !== (row.finishedAt === undefined)) {
+    throw incompleteProjectionRun(row.id);
+  }
+  if (row.status === "running" !== (row.executionToken !== undefined)) {
+    throw incompleteProjectionRun(row.id);
+  }
+  const identity = restoreIdentity(row);
+  const base = {
+    id: row.id,
+    projectId: row.projectId,
+    identity,
+    status: row.status,
+    startedAt: new Date(row.startedAt),
+    finishedAt: row.finishedAt ? new Date(row.finishedAt) : undefined,
+    attempt: row.attempt,
+    progress: { ...row.progress },
+    errorMessage: row.errorMessage,
+    executionToken: row.executionToken
+  };
+  if (identity.projectionKind === "link") {
+    if (!row.sourceObjectTypeId || !row.targetObjectTypeId || row.objectTypeId) {
+      throw invalidProjectionRunTarget(row.id);
+    }
+    assertNoCheckpoint(row);
+    return {
+      ...base,
+      identity,
+      target: {
+        sourceObjectTypeId: row.sourceObjectTypeId,
+        targetObjectTypeId: row.targetObjectTypeId
+      }
+    };
+  }
+  if (!row.objectTypeId || row.sourceObjectTypeId || row.targetObjectTypeId) {
+    throw invalidProjectionRunTarget(row.id);
+  }
+  if (identity.projectionKind === "telemetry") {
+    const telemetryCheckpoint = restoreCheckpoint(row);
+    if (row.progress.sourceRowsRead !== telemetryCheckpoint.nextRowOffset) {
+      throw new ProjectionRunError(`[Sixb] Telemetry projection run '${row.id}' progress does not match its checkpoint.`);
+    }
+    if (row.status === "succeeded" && !telemetryCheckpoint.inputExhausted) {
+      throw incompleteProjectionRun(row.id);
+    }
+    const missingTarget = restoreMissingTarget(row, telemetryCheckpoint);
+    return {
+      ...base,
+      identity,
+      target: { objectTypeId: row.objectTypeId },
+      telemetryCheckpoint,
+      ...missingTarget ? { missingTarget } : {}
+    };
+  }
+  assertNoCheckpoint(row);
+  return { ...base, identity, target: { objectTypeId: row.objectTypeId } };
+}
+function publicProjectionRunRecord(record) {
+  const cloned = structuredClone(record);
+  Reflect.deleteProperty(cloned, "executionToken");
+  return cloned;
+}
+function createProjectionRunClaim(record) {
+  assertProjectionRunRunning(record);
+  const executionToken = requireProjectionRunExecutionToken(record);
+  return {
+    run: publicProjectionRunRecord(record),
+    execution: { projectionRunId: record.id, executionToken }
+  };
+}
+function requireProjectionRunExecutionToken(record) {
+  if (record.executionToken)
+    return record.executionToken;
+  throw incompleteProjectionRun(record.id);
+}
+function staleProjectionRunExecution(id) {
+  return new ProjectionRunError(`[Sixb] Projection run '${id}' execution token is stale.`, "execution-lost");
+}
+function projectionRunNotFound(projectId, id) {
+  return new ProjectionRunError(`[Sixb] Projection run '${id}' not found for project '${projectId}'.`);
+}
+function immutableDatasetVersionConflict(identity) {
+  return new ProjectionRunError(`[Sixb] Dataset version '${identity.datasetVersion.versionId}' reused an immutable dataset version id with different metadata.`);
+}
+function assertPositiveCounter(value, fieldName) {
+  if (!Number.isSafeInteger(value) || value <= 0) {
+    throw new ProjectionRunError(`[Sixb] Projection run ${fieldName} must be a positive safe integer.`);
+  }
+}
+function assertCanonicalTimestamp(value, fieldName) {
+  const milliseconds = Date.parse(value);
+  if (!Number.isFinite(milliseconds) || new Date(milliseconds).toISOString() !== value) {
+    throw new ProjectionRunError(`[Sixb] Projection run ${fieldName} must be a canonical UTC timestamp.`);
+  }
+}
+function assertValidDate(value, fieldName) {
+  if (!Number.isFinite(value.getTime())) {
+    throw new ProjectionRunError(`[Sixb] Projection run persisted ${fieldName} is invalid.`);
+  }
+}
+function assertProjectionRunDate(value, fieldName) {
+  if (!Number.isFinite(value.getTime())) {
+    throw new ProjectionRunError(`[Sixb] Projection run ${fieldName} is invalid.`);
+  }
+}
+function isProjectionKind(value) {
+  return value === "object" || value === "link" || value === "telemetry";
+}
+function assertProjectionTarget(kind, target) {
+  if (kind === "link") {
+    if (!("sourceObjectTypeId" in target)) {
+      throw new ProjectionRunError("[Sixb] Link projection runs must declare source and target object types.");
+    }
+    assertProjectionRunNonEmpty(target.sourceObjectTypeId, "sourceObjectTypeId");
+    assertProjectionRunNonEmpty(target.targetObjectTypeId, "targetObjectTypeId");
+    return;
+  }
+  if (!("objectTypeId" in target)) {
+    throw new ProjectionRunError("[Sixb] Object and telemetry projection runs must declare one object type.");
+  }
+  assertProjectionRunNonEmpty(target.objectTypeId, "objectTypeId");
+}
+function projectionRunIdentitiesEqual(left, right) {
+  return left.projectionId === right.projectionId && left.projectionKind === right.projectionKind && left.protocol === right.protocol && left.datasetVersion.datasetId === right.datasetVersion.datasetId && left.datasetVersion.versionId === right.datasetVersion.versionId && left.datasetVersion.createdAt === right.datasetVersion.createdAt && left.ontologyRevision === right.ontologyRevision && left.projectionRevision === right.projectionRevision && left.ownershipHash === right.ownershipHash;
+}
+function projectionTargetsEqual(left, right) {
+  if ("sourceObjectTypeId" in left || "sourceObjectTypeId" in right) {
+    return "sourceObjectTypeId" in left && "sourceObjectTypeId" in right && left.sourceObjectTypeId === right.sourceObjectTypeId && left.targetObjectTypeId === right.targetObjectTypeId;
+  }
+  return left.objectTypeId === right.objectTypeId;
+}
+function assertProjectionRunProgress(progress) {
+  for (const key of PROJECTION_RUN_PROGRESS_KEYS) {
+    assertProjectionRunCounter(progress[key], key);
+  }
+  if (progress.sourceRowsSkipped > progress.sourceRowsRead) {
+    throw new ProjectionRunError("[Sixb] Projection run sourceRowsSkipped must not exceed sourceRowsRead.");
+  }
+}
+function assertFinishDecision(record, input) {
+  if (input.status !== "succeeded" && input.status !== "failed" && input.status !== "cancelled") {
+    throw new ProjectionRunError(`[Sixb] Projection run '${record.id}' finish status must be terminal.`);
+  }
+  if (input.protocol !== "replacement" && input.protocol !== "telemetry") {
+    throw new ProjectionRunError(`[Sixb] Projection run '${record.id}' finish protocol is invalid.`);
+  }
+  if (input.protocol !== record.identity.protocol) {
+    throw new ProjectionRunError(`[Sixb] Projection run '${record.id}' finish protocol does not match its identity.`);
+  }
+  const inputExhausted = "inputExhausted" in input ? input.inputExhausted : undefined;
+  if (input.status === "succeeded" && input.protocol === "telemetry") {
+    if (inputExhausted === true)
+      return;
+    throw new ProjectionRunError(`[Sixb] Telemetry projection run '${record.id}' cannot succeed before input exhaustion.`);
+  }
+  if (inputExhausted !== undefined) {
+    throw new ProjectionRunError(`[Sixb] Projection run '${record.id}' contains telemetry-only completion metadata.`);
+  }
+}
+function restoreIdentity(row) {
+  if (!row.protocol || !row.datasetVersionCreatedAt || !row.ontologyRevision || !row.projectionRevision || !row.ownershipHash) {
+    throw incompleteProjectionRun(row.id);
+  }
+  const identity = {
+    projectionId: row.projectionId,
+    projectionKind: row.projectionKind,
+    protocol: row.protocol,
+    datasetVersion: {
+      datasetId: row.datasetId,
+      versionId: row.datasetVersionId,
+      createdAt: row.datasetVersionCreatedAt
+    },
+    ontologyRevision: row.ontologyRevision,
+    projectionRevision: row.projectionRevision,
+    ownershipHash: row.ownershipHash
+  };
+  assertProjectionRunIdentity(identity);
+  return identity;
+}
+function restoreCheckpoint(row) {
+  if (row.fixedBatchSize === undefined || row.nextBatchOrdinal === undefined || row.nextRowOffset === undefined || row.inputExhausted === undefined) {
+    throw new ProjectionRunError(`[Sixb] Telemetry projection run '${row.id}' has incomplete checkpoint state.`);
+  }
+  assertPositiveCounter(row.fixedBatchSize, "fixedBatchSize");
+  assertProjectionRunCounter(row.nextBatchOrdinal, "nextBatchOrdinal");
+  assertProjectionRunCounter(row.nextRowOffset, "nextRowOffset");
+  return {
+    fixedBatchSize: row.fixedBatchSize,
+    nextBatchOrdinal: row.nextBatchOrdinal,
+    nextRowOffset: row.nextRowOffset,
+    inputExhausted: row.inputExhausted
+  };
+}
+function restoreMissingTarget(row, checkpoint) {
+  const columns = [
+    row.missingTargetObjectTypeId,
+    row.missingTargetObjectId,
+    row.missingTargetBatchOrdinal,
+    row.missingTargetFirstSeenAt
+  ];
+  if (columns.every((column) => column === undefined))
+    return;
+  if (row.missingTargetObjectTypeId === undefined || row.missingTargetObjectId === undefined || row.missingTargetBatchOrdinal === undefined || row.missingTargetFirstSeenAt === undefined) {
+    throw new ProjectionRunError(`[Sixb] Telemetry projection run '${row.id}' has a partially persisted missing target.`);
+  }
+  const missingTarget = {
+    objectTypeId: row.missingTargetObjectTypeId,
+    objectId: row.missingTargetObjectId,
+    batchOrdinal: row.missingTargetBatchOrdinal,
+    firstSeenAt: new Date(row.missingTargetFirstSeenAt)
+  };
+  assertValidDate(missingTarget.firstSeenAt, "missingTarget.firstSeenAt");
+  assertProjectionRunCounter(missingTarget.batchOrdinal, "missingTarget.batchOrdinal");
+  if (missingTarget.batchOrdinal !== checkpoint.nextBatchOrdinal) {
+    throw new ProjectionRunError(`[Sixb] Telemetry projection run '${row.id}' is waiting on a batch it has already passed.`);
+  }
+  if (missingTarget.objectTypeId !== row.objectTypeId) {
+    throw new ProjectionRunError(`[Sixb] Telemetry projection run '${row.id}' is waiting on an object type it does not write.`);
+  }
+  return missingTarget;
+}
+function assertNoCheckpoint(row) {
+  if (row.fixedBatchSize === undefined && row.nextBatchOrdinal === undefined && row.nextRowOffset === undefined && row.inputExhausted === undefined) {
+    return;
+  }
+  throw new ProjectionRunError(`[Sixb] Replacement projection run '${row.id}' contains a telemetry checkpoint.`);
+}
+function incompleteProjectionRun(id) {
+  return new ProjectionRunError(`[Sixb] Projection run '${id}' has incomplete materialization state.`);
+}
+function invalidProjectionRunTarget(id) {
+  return new ProjectionRunError(`[Sixb] Projection run '${id}' has an invalid target.`);
+}
+function assertProjectionMissingTarget(record, missingTarget) {
+  assertProjectionRunNonEmpty(missingTarget.objectTypeId, "missingTarget.objectTypeId");
+  assertProjectionRunNonEmpty(missingTarget.objectId, "missingTarget.objectId");
+  assertProjectionRunCounter(missingTarget.batchOrdinal, "missingTarget.batchOrdinal");
+  if (Number.isNaN(missingTarget.firstSeenAt.getTime())) {
+    throw new ProjectionRunError("[Sixb] Projection run missingTarget.firstSeenAt is invalid.");
+  }
+  if (missingTarget.objectTypeId !== record.target.objectTypeId) {
+    throw new ProjectionRunError(`[Sixb] Telemetry projection run '${record.id}' cannot wait on '${missingTarget.objectTypeId}'; it writes '${record.target.objectTypeId}'.`);
+  }
+  if (missingTarget.batchOrdinal !== record.telemetryCheckpoint.nextBatchOrdinal) {
+    throw new ProjectionRunError(`[Sixb] Telemetry projection run '${record.id}' cannot wait on batch ${missingTarget.batchOrdinal}; it is at ${record.telemetryCheckpoint.nextBatchOrdinal}.`);
+  }
+  return missingTarget;
+}
+function requireTelemetryProjectionRun(record) {
+  if (isTelemetryProjectionRun(record))
+    return record;
+  throw new ProjectionRunError(`[Sixb] Projection run '${record.id}' does not have a telemetry checkpoint.`);
+}
+function isTelemetryProjectionRun(record) {
+  return record.identity.projectionKind === "telemetry";
+}
+
+export { ProjectionRunError, PROJECTION_RUN_PROGRESS_KEYS, zeroProjectionRunProgress, projectionRunObjectTypesVisible, assertProjectionRunNonEmpty, assertProjectionRunCounter, assertProjectionRunListWindow, addProjectionRunCounter, assertProjectionRunIdentity, assertProjectionRunIdentityMatches, assertProjectionRunTargetMatches, assertProjectionRunStartInput, planProjectionRunReclaim, createProjectionRunRecord, assertProjectionRunRunning, assertProjectionRunExecution, nextProjectionRunAttempt, mergeProjectionRunProgress, assertGenericProgressDoesNotAdvanceTelemetry, advanceProjectionTelemetry, planProjectionRunFinish, finishProjectionRunRecord, restoreProjectionRun, publicProjectionRunRecord, createProjectionRunClaim, requireProjectionRunExecutionToken, staleProjectionRunExecution, projectionRunNotFound, immutableDatasetVersionConflict, assertProjectionMissingTarget, requireTelemetryProjectionRun };
+
+//# debugId=6023FB3FE52DBB3D64756E2164756E21

package/dist/chunk-50kv63vj.js.map

@@ -0,0 +1,12 @@
+{
+  "version": 3,
+  "sources": ["../src/storage/projection-runs/errors.ts", "../src/storage/projection-runs/types.ts", "../src/storage/projection-runs/lifecycle.ts"],
+  "sourcesContent": [
+    "import {\n  MaterializationConflictError,\n  type MaterializationConflictKind,\n} from \"../../materialization/errors\"\n\n/**\n * Base error for projection-run storage operations.\n */\nexport class ProjectionRunError extends MaterializationConflictError {\n  readonly name = \"ProjectionRunError\"\n\n  constructor(message: string, kind: MaterializationConflictKind = \"run-correlation\") {\n    super(kind, message)\n  }\n}\n",
+    "import type {\n  PinnedDatasetVersion,\n  ProjectionExecution,\n  ProjectionMaterializationIdentity,\n  ProjectionRunTerminalDecision,\n} from \"../../materialization/model\"\nimport type {\n  LinkProjectionTarget,\n  ObjectProjectionTarget,\n  ProjectionKind,\n  ProjectionTarget,\n} from \"../../projections/types\"\n\nexport type ProjectionRunStatus = \"running\" | \"succeeded\" | \"failed\" | \"cancelled\"\n\nexport interface ProjectionRunProgress {\n  /** Physical immutable-version rows consumed, before normalization or semantic materialization. */\n  readonly sourceRowsRead: number\n  /** Physical rows intentionally skipped because a required mapped value was blank. */\n  readonly sourceRowsSkipped: number\n}\n\nconst progressKeyFlags: Record<keyof ProjectionRunProgress, true> = {\n  sourceRowsRead: true,\n  sourceRowsSkipped: true,\n}\n\nexport const PROJECTION_RUN_PROGRESS_KEYS = Object.keys(\n  progressKeyFlags\n) as readonly (keyof ProjectionRunProgress)[]\n\nexport function zeroProjectionRunProgress(): ProjectionRunProgress {\n  const progress = {} as Record<keyof ProjectionRunProgress, number>\n  for (const key of PROJECTION_RUN_PROGRESS_KEYS) progress[key] = 0\n  return progress\n}\n\nexport interface ProjectionTelemetryCheckpoint {\n  readonly fixedBatchSize: number\n  readonly nextBatchOrdinal: number\n  readonly nextRowOffset: number\n  readonly inputExhausted: boolean\n}\n\n/**\n * The object a telemetry batch is waiting for, and when this run first found it missing.\n *\n * A projection's dataset can legitimately be materialized before the objects it references, so\n * the run waits instead of failing. The wait needs a start, and the run has no other durable one:\n * `startedAt` is when the run began, which on a batched projection is long before the batch that\n * cannot commit, and `attempt` counts every reclaim including the ones an unreachable queue caused.\n *\n * Cleared by any committed batch, so a run that is making progress never carries a stale wait.\n */\nexport interface ProjectionMissingTarget {\n  readonly objectTypeId: string\n  readonly objectId: string\n  /** The batch that could not commit because of it. */\n  readonly batchOrdinal: number\n  readonly firstSeenAt: Date\n}\n\ninterface ProjectionRunRecordBase {\n  readonly id: string\n  readonly projectId: string\n  readonly status: ProjectionRunStatus\n  readonly attempt: number\n  readonly progress: ProjectionRunProgress\n  readonly startedAt: Date\n  readonly finishedAt?: Date\n  readonly errorMessage?: string\n}\n\ntype ProjectionIdentity<TKind extends ProjectionKind> = Extract<\n  ProjectionMaterializationIdentity,\n  { readonly projectionKind: TKind }\n>\n\nexport type ObjectProjectionRunRecord = ProjectionRunRecordBase & {\n  readonly identity: ProjectionIdentity<\"object\">\n  readonly target: ObjectProjectionTarget\n  readonly telemetryCheckpoint?: never\n  readonly missingTarget?: never\n}\n\nexport type LinkProjectionRunRecord = ProjectionRunRecordBase & {\n  readonly identity: ProjectionIdentity<\"link\">\n  readonly target: LinkProjectionTarget\n  readonly telemetryCheckpoint?: never\n  readonly missingTarget?: never\n}\n\nexport type TelemetryProjectionRunRecord = ProjectionRunRecordBase & {\n  readonly identity: ProjectionIdentity<\"telemetry\">\n  readonly target: ObjectProjectionTarget\n  readonly telemetryCheckpoint: ProjectionTelemetryCheckpoint\n  /**\n   * Only telemetry carries this: `MaterializationObjectNotFoundError` is raised by telemetry\n   * validation alone, and only a batched protocol has a checkpoint to anchor the wait to.\n   */\n  readonly missingTarget?: ProjectionMissingTarget\n}\n\n/** Durable projection lifecycle state. The execution token is deliberately returned separately. */\nexport type ProjectionRunRecord =\n  | ObjectProjectionRunRecord\n  | LinkProjectionRunRecord\n  | TelemetryProjectionRunRecord\n\nexport function projectionRunObjectTypesVisible(\n  run: ProjectionRunRecord,\n  canView: (objectTypeId: string) => boolean\n): boolean {\n  const target: ProjectionTarget = run.target\n  if (\"sourceObjectTypeId\" in target) {\n    return canView(target.sourceObjectTypeId) && canView(target.targetObjectTypeId)\n  }\n  return canView(target.objectTypeId)\n}\n\ninterface StartOrReclaimProjectionRunBase {\n  readonly id: string\n  readonly projectId: string\n  readonly startedAt?: Date\n}\n\nexport type StartOrReclaimProjectionRunInput =\n  | (StartOrReclaimProjectionRunBase & {\n      readonly identity: ProjectionIdentity<\"object\">\n      readonly target: ObjectProjectionRunRecord[\"target\"]\n      readonly fixedBatchSize?: never\n    })\n  | (StartOrReclaimProjectionRunBase & {\n      readonly identity: ProjectionIdentity<\"link\">\n      readonly target: LinkProjectionRunRecord[\"target\"]\n      readonly fixedBatchSize?: never\n    })\n  | (StartOrReclaimProjectionRunBase & {\n      readonly identity: ProjectionIdentity<\"telemetry\">\n      readonly target: TelemetryProjectionRunRecord[\"target\"]\n      readonly fixedBatchSize: number\n    })\n\nexport interface ProjectionRunClaim {\n  readonly run: ProjectionRunRecord\n  readonly execution: ProjectionExecution\n}\n\nexport interface LockProjectionRunForMaterializationInput {\n  readonly id: string\n  readonly projectId: string\n  readonly executionToken: string\n  readonly identity: ProjectionMaterializationIdentity\n}\n\nexport interface UpdateProjectionRunInput extends LockProjectionRunForMaterializationInput {\n  readonly progress: Partial<ProjectionRunProgress>\n}\n\nexport type FinishProjectionRunInput = ProjectionRunTerminalDecision &\n  LockProjectionRunForMaterializationInput & {\n    readonly finishedAt?: Date\n    readonly progress?: Partial<ProjectionRunProgress>\n  }\n\nexport interface AdvanceProjectionTelemetryCheckpointInput\n  extends LockProjectionRunForMaterializationInput {\n  /** Must equal the run's current nextBatchOrdinal. */\n  readonly batchOrdinal: number\n  /** Physical dataset rows consumed by this batch, including skipped rows. */\n  readonly batchRowCount: number\n  /** Physical rows intentionally skipped inside this batch. */\n  readonly batchRowsSkipped: number\n  /** True when this batch consumed the final row of the immutable dataset version. */\n  readonly inputExhausted: boolean\n}\n\nexport interface RecordProjectionMissingTargetInput\n  extends LockProjectionRunForMaterializationInput {\n  readonly missingTarget: ProjectionMissingTarget\n}\n\nexport interface ListProjectionRunsInput {\n  readonly projectId: string\n  readonly projectionId?: string\n  readonly projectionKind?: ProjectionKind\n  readonly datasetId?: string\n  readonly datasetVersionId?: string\n  /**\n   * Viewable object type ids. A run is included only if every target type is present. Omit for a\n   * privileged caller; an empty set matches no runs.\n   */\n  readonly objectTypeIds?: readonly string[]\n  readonly statuses?: readonly ProjectionRunStatus[]\n  readonly startedAfter?: Date\n  readonly startedBefore?: Date\n  readonly limit?: number\n  readonly offset?: number\n  readonly order?: \"asc\" | \"desc\"\n}\n\nexport interface ListProjectionRunsResult {\n  readonly runs: readonly ProjectionRunRecord[]\n  readonly hasMore: boolean\n  readonly total: number\n}\n\nexport interface ListLatestProjectionRunsInput {\n  readonly projectId: string\n  readonly projectionIds: readonly string[]\n}\n\nexport interface ListLatestProjectionRunsResult {\n  readonly runs: readonly ProjectionRunRecord[]\n}\n\nexport interface ProjectionRunStorage {\n  startOrReclaim(input: StartOrReclaimProjectionRunInput): Promise<ProjectionRunClaim>\n  /** Transactionally fences the current execution before ontology materialization writes. */\n  lockForMaterialization(\n    input: LockProjectionRunForMaterializationInput\n  ): Promise<ProjectionRunRecord>\n  /** Updates physical source progress only. */\n  update(input: UpdateProjectionRunInput): Promise<ProjectionRunRecord>\n  /**\n   * Advances telemetry progress atomically with the corresponding ontology commit.\n   *\n   * Clears any recorded missing target: a batch that commits is a batch that was not waiting.\n   */\n  advanceTelemetryCheckpoint(\n    input: AdvanceProjectionTelemetryCheckpointInput\n  ): Promise<TelemetryProjectionRunRecord>\n  /** Records the object a telemetry batch is waiting for, so the wait has a durable start. */\n  recordMissingTarget(\n    input: RecordProjectionMissingTargetInput\n  ): Promise<TelemetryProjectionRunRecord>\n  /** Telemetry success also records the worker's EOF observation atomically. */\n  finish(input: FinishProjectionRunInput): Promise<ProjectionRunRecord>\n  getById(params: { projectId: string; id: string }): Promise<ProjectionRunRecord | null>\n  list(input: ListProjectionRunsInput): Promise<ListProjectionRunsResult>\n  listLatestByProjectionIds(\n    input: ListLatestProjectionRunsInput\n  ): Promise<ListLatestProjectionRunsResult>\n}\n\nexport type {\n  LinkProjectionTarget,\n  ObjectProjectionTarget,\n  PinnedDatasetVersion,\n  ProjectionExecution,\n  ProjectionKind,\n  ProjectionMaterializationIdentity,\n  ProjectionTarget,\n}\n",
+    "import type {\n  ProjectionMaterializationIdentity,\n  ProjectionRunTerminalDecision,\n} from \"../../materialization/model\"\nimport type { ProjectionKind, ProjectionTarget } from \"../../projections/types\"\nimport { ProjectionRunError } from \"./errors\"\nimport type {\n  AdvanceProjectionTelemetryCheckpointInput,\n  FinishProjectionRunInput,\n  ProjectionMissingTarget,\n  ProjectionRunClaim,\n  ProjectionRunProgress,\n  ProjectionRunRecord,\n  ProjectionRunStatus,\n  ProjectionTelemetryCheckpoint,\n  StartOrReclaimProjectionRunInput,\n  TelemetryProjectionRunRecord,\n} from \"./types\"\nimport { PROJECTION_RUN_PROGRESS_KEYS, zeroProjectionRunProgress } from \"./types\"\n\nexport type StoredProjectionRunRecord = ProjectionRunRecord & {\n  readonly executionToken?: string\n}\n\nexport interface PersistedProjectionRunRecord {\n  readonly id: string\n  readonly projectId: string\n  readonly projectionId: string\n  readonly projectionKind: ProjectionKind\n  readonly protocol?: \"replacement\" | \"telemetry\"\n  readonly datasetId: string\n  readonly datasetVersionId: string\n  readonly datasetVersionCreatedAt?: string\n  readonly ontologyRevision?: string\n  readonly projectionRevision?: string\n  readonly ownershipHash?: string\n  readonly objectTypeId?: string\n  readonly sourceObjectTypeId?: string\n  readonly targetObjectTypeId?: string\n  readonly status: ProjectionRunStatus\n  readonly startedAt: Date\n  readonly finishedAt?: Date\n  readonly attempt: number\n  readonly executionToken?: string\n  readonly fixedBatchSize?: number\n  readonly nextBatchOrdinal?: number\n  readonly nextRowOffset?: number\n  readonly inputExhausted?: boolean\n  readonly missingTargetObjectTypeId?: string\n  readonly missingTargetObjectId?: string\n  readonly missingTargetBatchOrdinal?: number\n  readonly missingTargetFirstSeenAt?: Date\n  readonly progress: ProjectionRunProgress\n  readonly errorMessage?: string\n}\n\nexport interface ProjectionTelemetryAdvance {\n  readonly progress: ProjectionRunProgress\n  readonly checkpoint: ProjectionTelemetryCheckpoint\n}\n\nexport interface ProjectionRunFinishPlan {\n  readonly status: Exclude<ProjectionRunStatus, \"running\">\n  readonly finishedAt: Date\n  readonly progress: ProjectionRunProgress\n  readonly inputExhausted?: true\n  readonly errorMessage?: string\n}\n\n// ── Scalar and identity validation ──────────────────────────\n\nexport function assertProjectionRunNonEmpty(value: string, fieldName: string): void {\n  if (typeof value !== \"string\" || value.trim().length === 0) {\n    throw new ProjectionRunError(`[Sixb] Projection run ${fieldName} must not be empty.`)\n  }\n}\n\nexport function assertProjectionRunCounter(value: number, fieldName: string): void {\n  if (!Number.isSafeInteger(value) || value < 0) {\n    throw new ProjectionRunError(\n      `[Sixb] Projection run ${fieldName} must be a non-negative safe integer.`\n    )\n  }\n}\n\nexport function assertProjectionRunListWindow(value: number | undefined, fieldName: string): void {\n  if (value !== undefined && (!Number.isSafeInteger(value) || value < 0)) {\n    throw new ProjectionRunError(`[Sixb] Projection run list ${fieldName} must be >= 0.`)\n  }\n}\n\nexport function addProjectionRunCounter(left: number, right: number, fieldName: string): number {\n  const result = left + right\n  if (!Number.isSafeInteger(result)) {\n    throw new ProjectionRunError(`[Sixb] Projection run ${fieldName} exceeds safe integer range.`)\n  }\n  return result\n}\n\nexport function assertProjectionRunIdentity(identity: ProjectionMaterializationIdentity): void {\n  assertProjectionRunNonEmpty(identity.projectionId, \"projectionId\")\n  if (!isProjectionKind(identity.projectionKind)) {\n    throw new ProjectionRunError(\n      \"[Sixb] Projection run projectionKind must be 'object', 'link', or 'telemetry'.\"\n    )\n  }\n  if (identity.protocol !== \"replacement\" && identity.protocol !== \"telemetry\") {\n    throw new ProjectionRunError(\n      \"[Sixb] Projection run protocol must be 'replacement' or 'telemetry'.\"\n    )\n  }\n  assertProjectionRunNonEmpty(identity.datasetVersion.datasetId, \"datasetId\")\n  assertProjectionRunNonEmpty(identity.datasetVersion.versionId, \"datasetVersionId\")\n  assertCanonicalTimestamp(identity.datasetVersion.createdAt, \"datasetVersionCreatedAt\")\n  assertProjectionRunNonEmpty(identity.ontologyRevision, \"ontologyRevision\")\n  assertProjectionRunNonEmpty(identity.projectionRevision, \"projectionRevision\")\n  assertProjectionRunNonEmpty(identity.ownershipHash, \"ownershipHash\")\n  if ((identity.protocol === \"telemetry\") !== (identity.projectionKind === \"telemetry\")) {\n    throw new ProjectionRunError(\n      `[Sixb] Projection run protocol '${identity.protocol}' is incompatible with kind '${identity.projectionKind}'.`\n    )\n  }\n}\n\nexport function assertProjectionRunIdentityMatches(\n  record: Pick<ProjectionRunRecord, \"id\" | \"identity\">,\n  identity: ProjectionMaterializationIdentity\n): void {\n  if (projectionRunIdentitiesEqual(record.identity, identity)) return\n  throw new ProjectionRunError(\n    `[Sixb] Projection run '${record.id}' materialization identity does not match.`\n  )\n}\n\nexport function assertProjectionRunTargetMatches(\n  record: Pick<ProjectionRunRecord, \"id\" | \"target\">,\n  target: ProjectionTarget\n): void {\n  if (projectionTargetsEqual(record.target, target)) return\n  throw new ProjectionRunError(\n    `[Sixb] Projection run '${record.id}' target object types do not match.`\n  )\n}\n\nexport function assertProjectionRunStartInput(input: StartOrReclaimProjectionRunInput): void {\n  assertProjectionRunNonEmpty(input.id, \"id\")\n  assertProjectionRunNonEmpty(input.projectId, \"projectId\")\n  assertProjectionRunIdentity(input.identity)\n  assertProjectionTarget(input.identity.projectionKind, input.target)\n  if (input.startedAt) assertProjectionRunDate(input.startedAt, \"startedAt\")\n  if (input.identity.projectionKind === \"telemetry\") {\n    const telemetry = input as ProjectionRunStart<\"telemetry\">\n    assertPositiveCounter(telemetry.fixedBatchSize, \"fixedBatchSize\")\n  } else if (input.fixedBatchSize !== undefined) {\n    throw new ProjectionRunError(\n      \"[Sixb] Replacement projection runs cannot declare a telemetry fixedBatchSize.\"\n    )\n  }\n}\n\nexport function planProjectionRunReclaim(\n  record: StoredProjectionRunRecord,\n  input: StartOrReclaimProjectionRunInput\n): { readonly attempt: number } {\n  assertProjectionRunRunning(record)\n  assertProjectionRunIdentityMatches(record, input.identity)\n  assertProjectionRunTargetMatches(record, input.target)\n  if (record.telemetryCheckpoint?.fixedBatchSize !== input.fixedBatchSize) {\n    throw new ProjectionRunError(\n      `[Sixb] Projection run '${input.id}' fixed batch size does not match.`\n    )\n  }\n  return { attempt: nextProjectionRunAttempt(record.attempt) }\n}\n\n// ── Lifecycle transitions ───────────────────────────────────\n\nexport function createProjectionRunRecord(\n  input: StartOrReclaimProjectionRunInput,\n  now: Date = new Date()\n): ProjectionRunRecord {\n  assertProjectionRunStartInput(input)\n  const base = {\n    id: input.id,\n    projectId: input.projectId,\n    status: \"running\" as const,\n    attempt: 1,\n    progress: zeroProjectionRunProgress(),\n    startedAt: new Date(input.startedAt ?? now),\n  }\n  switch (input.identity.projectionKind) {\n    case \"object\": {\n      const object = input as ProjectionRunStart<\"object\">\n      return { ...base, identity: object.identity, target: object.target }\n    }\n    case \"link\": {\n      const link = input as ProjectionRunStart<\"link\">\n      return { ...base, identity: link.identity, target: link.target }\n    }\n    case \"telemetry\": {\n      const telemetry = input as ProjectionRunStart<\"telemetry\">\n      return {\n        ...base,\n        identity: telemetry.identity,\n        target: telemetry.target,\n        telemetryCheckpoint: {\n          fixedBatchSize: telemetry.fixedBatchSize,\n          nextBatchOrdinal: 0,\n          nextRowOffset: 0,\n          inputExhausted: false,\n        },\n      }\n    }\n  }\n}\n\nexport function assertProjectionRunRunning(\n  record: Pick<ProjectionRunRecord, \"id\" | \"projectId\" | \"status\">\n): void {\n  if (record.status === \"running\") return\n  throw new ProjectionRunError(\n    `[Sixb] Projection run '${record.id}' for project '${record.projectId}' is already terminal.`\n  )\n}\n\nexport function assertProjectionRunExecution(\n  record: StoredProjectionRunRecord,\n  input: {\n    readonly id: string\n    readonly executionToken: string\n    readonly identity: ProjectionMaterializationIdentity\n  }\n): asserts record is StoredProjectionRunRecord & { readonly executionToken: string } {\n  assertProjectionRunNonEmpty(input.executionToken, \"executionToken\")\n  assertProjectionRunIdentity(input.identity)\n  assertProjectionRunRunning(record)\n  assertProjectionRunIdentityMatches(record, input.identity)\n  if (record.executionToken !== input.executionToken) {\n    throw staleProjectionRunExecution(input.id)\n  }\n}\n\nexport function nextProjectionRunAttempt(current: number): number {\n  assertProjectionRunCounter(current, \"attempt\")\n  return addProjectionRunCounter(current, 1, \"attempt\")\n}\n\nexport function mergeProjectionRunProgress(\n  current: ProjectionRunProgress,\n  patch: Partial<ProjectionRunProgress>\n): ProjectionRunProgress {\n  const progress = { ...current }\n  for (const key of PROJECTION_RUN_PROGRESS_KEYS) {\n    const value = patch[key]\n    if (value === undefined) continue\n    assertProjectionRunCounter(value, key)\n    if (value < current[key]) {\n      throw new ProjectionRunError(`[Sixb] Projection run ${key} must not decrease.`)\n    }\n    progress[key] = value\n  }\n  assertProjectionRunProgress(progress)\n  return progress\n}\n\nexport function assertGenericProgressDoesNotAdvanceTelemetry(\n  record: Pick<ProjectionRunRecord, \"id\" | \"identity\" | \"progress\">,\n  patch: Partial<ProjectionRunProgress>\n): void {\n  if (record.identity.protocol !== \"telemetry\") return\n  for (const key of PROJECTION_RUN_PROGRESS_KEYS) {\n    if (patch[key] !== undefined && patch[key] !== record.progress[key]) {\n      throw new ProjectionRunError(\n        `[Sixb] Telemetry projection run '${record.id}' progress can only advance with its checkpoint.`\n      )\n    }\n  }\n}\n\nexport function advanceProjectionTelemetry(\n  record: ProjectionRunRecord,\n  input: AdvanceProjectionTelemetryCheckpointInput\n): ProjectionTelemetryAdvance {\n  const telemetry = requireTelemetryProjectionRun(record)\n  const checkpoint = telemetry.telemetryCheckpoint\n  assertProjectionRunCounter(input.batchOrdinal, \"batchOrdinal\")\n  assertPositiveCounter(input.batchRowCount, \"batchRowCount\")\n  assertProjectionRunCounter(input.batchRowsSkipped, \"batchRowsSkipped\")\n  if (input.batchRowsSkipped > input.batchRowCount) {\n    throw new ProjectionRunError(\n      `[Sixb] Telemetry projection run '${record.id}' skipped rows exceed its batch row count.`\n    )\n  }\n  if (input.batchOrdinal !== checkpoint.nextBatchOrdinal) {\n    throw new ProjectionRunError(\n      `[Sixb] Telemetry projection run '${record.id}' expected batch ordinal ${checkpoint.nextBatchOrdinal}, got ${input.batchOrdinal}.`\n    )\n  }\n  if (input.batchRowCount > checkpoint.fixedBatchSize) {\n    throw new ProjectionRunError(\n      `[Sixb] Telemetry projection run '${record.id}' batch exceeds its fixed size.`\n    )\n  }\n  if (!input.inputExhausted && input.batchRowCount !== checkpoint.fixedBatchSize) {\n    throw new ProjectionRunError(\n      `[Sixb] Telemetry projection run '${record.id}' cannot advance past a partial non-final batch.`\n    )\n  }\n  if (checkpoint.inputExhausted) {\n    throw new ProjectionRunError(\n      `[Sixb] Telemetry projection run '${record.id}' has already exhausted its input.`\n    )\n  }\n\n  const nextRowOffset = addProjectionRunCounter(\n    checkpoint.nextRowOffset,\n    input.batchRowCount,\n    \"nextRowOffset\"\n  )\n  return {\n    progress: {\n      sourceRowsRead: nextRowOffset,\n      sourceRowsSkipped: addProjectionRunCounter(\n        telemetry.progress.sourceRowsSkipped,\n        input.batchRowsSkipped,\n        \"sourceRowsSkipped\"\n      ),\n    },\n    checkpoint: {\n      ...checkpoint,\n      nextBatchOrdinal: addProjectionRunCounter(checkpoint.nextBatchOrdinal, 1, \"nextBatchOrdinal\"),\n      nextRowOffset,\n      inputExhausted: input.inputExhausted,\n    },\n  }\n}\n\nexport function planProjectionRunFinish(\n  record: ProjectionRunRecord,\n  input: FinishProjectionRunInput,\n  now: Date = new Date()\n): ProjectionRunFinishPlan {\n  assertFinishDecision(record, input)\n  const patch = input.progress ?? {}\n  assertGenericProgressDoesNotAdvanceTelemetry(record, patch)\n  const progress = mergeProjectionRunProgress(record.progress, patch)\n  const finishedAt = new Date(input.finishedAt ?? now)\n  assertProjectionRunDate(finishedAt, \"finishedAt\")\n  return {\n    status: input.status,\n    finishedAt,\n    progress,\n    ...(input.status === \"succeeded\" && input.protocol === \"telemetry\"\n      ? { inputExhausted: true as const }\n      : {}),\n    ...(input.status === \"succeeded\" || input.errorMessage === undefined\n      ? {}\n      : { errorMessage: input.errorMessage }),\n  }\n}\n\nexport function finishProjectionRunRecord(\n  record: StoredProjectionRunRecord,\n  input: FinishProjectionRunInput,\n  now: Date = new Date()\n): StoredProjectionRunRecord {\n  const plan = planProjectionRunFinish(record, input, now)\n  const terminal = {\n    executionToken: undefined,\n    status: plan.status,\n    finishedAt: plan.finishedAt,\n    progress: plan.progress,\n    errorMessage: plan.errorMessage,\n  }\n  if (plan.inputExhausted) {\n    const telemetry = requireTelemetryProjectionRun(record)\n    return {\n      ...telemetry,\n      ...terminal,\n      telemetryCheckpoint: { ...telemetry.telemetryCheckpoint, inputExhausted: true },\n    }\n  }\n  return { ...record, ...terminal }\n}\n\n// ── Persistence mapping ─────────────────────────────────────\n\nexport function restoreProjectionRun(row: PersistedProjectionRunRecord): StoredProjectionRunRecord {\n  assertProjectionRunNonEmpty(row.id, \"id\")\n  assertProjectionRunNonEmpty(row.projectId, \"projectId\")\n  assertProjectionRunCounter(row.attempt, \"attempt\")\n  if (row.attempt < 1) {\n    throw new ProjectionRunError(`[Sixb] Projection run '${row.id}' attempt must be positive.`)\n  }\n  assertProjectionRunProgress(row.progress)\n  assertValidDate(row.startedAt, \"startedAt\")\n  if (row.finishedAt) assertValidDate(row.finishedAt, \"finishedAt\")\n  if ((row.status === \"running\") !== (row.finishedAt === undefined)) {\n    throw incompleteProjectionRun(row.id)\n  }\n  if ((row.status === \"running\") !== (row.executionToken !== undefined)) {\n    throw incompleteProjectionRun(row.id)\n  }\n\n  const identity = restoreIdentity(row)\n  const base = {\n    id: row.id,\n    projectId: row.projectId,\n    identity,\n    status: row.status,\n    startedAt: new Date(row.startedAt),\n    finishedAt: row.finishedAt ? new Date(row.finishedAt) : undefined,\n    attempt: row.attempt,\n    progress: { ...row.progress },\n    errorMessage: row.errorMessage,\n    executionToken: row.executionToken,\n  }\n\n  if (identity.projectionKind === \"link\") {\n    if (!row.sourceObjectTypeId || !row.targetObjectTypeId || row.objectTypeId) {\n      throw invalidProjectionRunTarget(row.id)\n    }\n    assertNoCheckpoint(row)\n    return {\n      ...base,\n      identity,\n      target: {\n        sourceObjectTypeId: row.sourceObjectTypeId,\n        targetObjectTypeId: row.targetObjectTypeId,\n      },\n    }\n  }\n  if (!row.objectTypeId || row.sourceObjectTypeId || row.targetObjectTypeId) {\n    throw invalidProjectionRunTarget(row.id)\n  }\n  if (identity.projectionKind === \"telemetry\") {\n    const telemetryCheckpoint = restoreCheckpoint(row)\n    if (row.progress.sourceRowsRead !== telemetryCheckpoint.nextRowOffset) {\n      throw new ProjectionRunError(\n        `[Sixb] Telemetry projection run '${row.id}' progress does not match its checkpoint.`\n      )\n    }\n    if (row.status === \"succeeded\" && !telemetryCheckpoint.inputExhausted) {\n      throw incompleteProjectionRun(row.id)\n    }\n    const missingTarget = restoreMissingTarget(row, telemetryCheckpoint)\n    return {\n      ...base,\n      identity,\n      target: { objectTypeId: row.objectTypeId },\n      telemetryCheckpoint,\n      ...(missingTarget ? { missingTarget } : {}),\n    }\n  }\n  assertNoCheckpoint(row)\n  return { ...base, identity, target: { objectTypeId: row.objectTypeId } }\n}\n\nexport function publicProjectionRunRecord(record: StoredProjectionRunRecord): ProjectionRunRecord {\n  const cloned = structuredClone(record)\n  Reflect.deleteProperty(cloned, \"executionToken\")\n  return cloned\n}\n\nexport function createProjectionRunClaim(record: StoredProjectionRunRecord): ProjectionRunClaim {\n  assertProjectionRunRunning(record)\n  const executionToken = requireProjectionRunExecutionToken(record)\n  return {\n    run: publicProjectionRunRecord(record),\n    execution: { projectionRunId: record.id, executionToken },\n  }\n}\n\nexport function requireProjectionRunExecutionToken(record: StoredProjectionRunRecord): string {\n  if (record.executionToken) return record.executionToken\n  throw incompleteProjectionRun(record.id)\n}\n\nexport function staleProjectionRunExecution(id: string): ProjectionRunError {\n  return new ProjectionRunError(\n    `[Sixb] Projection run '${id}' execution token is stale.`,\n    \"execution-lost\"\n  )\n}\n\nexport function projectionRunNotFound(projectId: string, id: string): ProjectionRunError {\n  return new ProjectionRunError(\n    `[Sixb] Projection run '${id}' not found for project '${projectId}'.`\n  )\n}\n\nexport function immutableDatasetVersionConflict(\n  identity: ProjectionMaterializationIdentity\n): ProjectionRunError {\n  return new ProjectionRunError(\n    `[Sixb] Dataset version '${identity.datasetVersion.versionId}' reused an immutable dataset version id with different metadata.`\n  )\n}\n\n// ── Private helpers ─────────────────────────────────────────\n\nfunction assertPositiveCounter(value: number, fieldName: string): void {\n  if (!Number.isSafeInteger(value) || value <= 0) {\n    throw new ProjectionRunError(\n      `[Sixb] Projection run ${fieldName} must be a positive safe integer.`\n    )\n  }\n}\n\nfunction assertCanonicalTimestamp(value: string, fieldName: string): void {\n  const milliseconds = Date.parse(value)\n  if (!Number.isFinite(milliseconds) || new Date(milliseconds).toISOString() !== value) {\n    throw new ProjectionRunError(\n      `[Sixb] Projection run ${fieldName} must be a canonical UTC timestamp.`\n    )\n  }\n}\n\nfunction assertValidDate(value: Date, fieldName: string): void {\n  if (!Number.isFinite(value.getTime())) {\n    throw new ProjectionRunError(`[Sixb] Projection run persisted ${fieldName} is invalid.`)\n  }\n}\n\nfunction assertProjectionRunDate(value: Date, fieldName: string): void {\n  if (!Number.isFinite(value.getTime())) {\n    throw new ProjectionRunError(`[Sixb] Projection run ${fieldName} is invalid.`)\n  }\n}\n\nfunction isProjectionKind(value: unknown): value is ProjectionKind {\n  return value === \"object\" || value === \"link\" || value === \"telemetry\"\n}\n\nfunction assertProjectionTarget(kind: ProjectionKind, target: ProjectionTarget): void {\n  if (kind === \"link\") {\n    if (!(\"sourceObjectTypeId\" in target)) {\n      throw new ProjectionRunError(\n        \"[Sixb] Link projection runs must declare source and target object types.\"\n      )\n    }\n    assertProjectionRunNonEmpty(target.sourceObjectTypeId, \"sourceObjectTypeId\")\n    assertProjectionRunNonEmpty(target.targetObjectTypeId, \"targetObjectTypeId\")\n    return\n  }\n  if (!(\"objectTypeId\" in target)) {\n    throw new ProjectionRunError(\n      \"[Sixb] Object and telemetry projection runs must declare one object type.\"\n    )\n  }\n  assertProjectionRunNonEmpty(target.objectTypeId, \"objectTypeId\")\n}\n\nfunction projectionRunIdentitiesEqual(\n  left: ProjectionMaterializationIdentity,\n  right: ProjectionMaterializationIdentity\n): boolean {\n  return (\n    left.projectionId === right.projectionId &&\n    left.projectionKind === right.projectionKind &&\n    left.protocol === right.protocol &&\n    left.datasetVersion.datasetId === right.datasetVersion.datasetId &&\n    left.datasetVersion.versionId === right.datasetVersion.versionId &&\n    left.datasetVersion.createdAt === right.datasetVersion.createdAt &&\n    left.ontologyRevision === right.ontologyRevision &&\n    left.projectionRevision === right.projectionRevision &&\n    left.ownershipHash === right.ownershipHash\n  )\n}\n\nfunction projectionTargetsEqual(left: ProjectionTarget, right: ProjectionTarget): boolean {\n  if (\"sourceObjectTypeId\" in left || \"sourceObjectTypeId\" in right) {\n    return (\n      \"sourceObjectTypeId\" in left &&\n      \"sourceObjectTypeId\" in right &&\n      left.sourceObjectTypeId === right.sourceObjectTypeId &&\n      left.targetObjectTypeId === right.targetObjectTypeId\n    )\n  }\n  return left.objectTypeId === right.objectTypeId\n}\n\nfunction assertProjectionRunProgress(progress: ProjectionRunProgress): void {\n  for (const key of PROJECTION_RUN_PROGRESS_KEYS) {\n    assertProjectionRunCounter(progress[key], key)\n  }\n  if (progress.sourceRowsSkipped > progress.sourceRowsRead) {\n    throw new ProjectionRunError(\n      \"[Sixb] Projection run sourceRowsSkipped must not exceed sourceRowsRead.\"\n    )\n  }\n}\n\nfunction assertFinishDecision(\n  record: ProjectionRunRecord,\n  input: ProjectionRunTerminalDecision\n): void {\n  if (input.status !== \"succeeded\" && input.status !== \"failed\" && input.status !== \"cancelled\") {\n    throw new ProjectionRunError(\n      `[Sixb] Projection run '${record.id}' finish status must be terminal.`\n    )\n  }\n  if (input.protocol !== \"replacement\" && input.protocol !== \"telemetry\") {\n    throw new ProjectionRunError(`[Sixb] Projection run '${record.id}' finish protocol is invalid.`)\n  }\n  if (input.protocol !== record.identity.protocol) {\n    throw new ProjectionRunError(\n      `[Sixb] Projection run '${record.id}' finish protocol does not match its identity.`\n    )\n  }\n  const inputExhausted = \"inputExhausted\" in input ? input.inputExhausted : undefined\n  if (input.status === \"succeeded\" && input.protocol === \"telemetry\") {\n    if (inputExhausted === true) return\n    throw new ProjectionRunError(\n      `[Sixb] Telemetry projection run '${record.id}' cannot succeed before input exhaustion.`\n    )\n  }\n  if (inputExhausted !== undefined) {\n    throw new ProjectionRunError(\n      `[Sixb] Projection run '${record.id}' contains telemetry-only completion metadata.`\n    )\n  }\n}\n\nfunction restoreIdentity(row: PersistedProjectionRunRecord): ProjectionMaterializationIdentity {\n  if (\n    !row.protocol ||\n    !row.datasetVersionCreatedAt ||\n    !row.ontologyRevision ||\n    !row.projectionRevision ||\n    !row.ownershipHash\n  ) {\n    throw incompleteProjectionRun(row.id)\n  }\n  const identity = {\n    projectionId: row.projectionId,\n    projectionKind: row.projectionKind,\n    protocol: row.protocol,\n    datasetVersion: {\n      datasetId: row.datasetId,\n      versionId: row.datasetVersionId,\n      createdAt: row.datasetVersionCreatedAt,\n    },\n    ontologyRevision: row.ontologyRevision,\n    projectionRevision: row.projectionRevision,\n    ownershipHash: row.ownershipHash,\n  } as ProjectionMaterializationIdentity\n  assertProjectionRunIdentity(identity)\n  return identity\n}\n\nfunction restoreCheckpoint(row: PersistedProjectionRunRecord): ProjectionTelemetryCheckpoint {\n  if (\n    row.fixedBatchSize === undefined ||\n    row.nextBatchOrdinal === undefined ||\n    row.nextRowOffset === undefined ||\n    row.inputExhausted === undefined\n  ) {\n    throw new ProjectionRunError(\n      `[Sixb] Telemetry projection run '${row.id}' has incomplete checkpoint state.`\n    )\n  }\n  assertPositiveCounter(row.fixedBatchSize, \"fixedBatchSize\")\n  assertProjectionRunCounter(row.nextBatchOrdinal, \"nextBatchOrdinal\")\n  assertProjectionRunCounter(row.nextRowOffset, \"nextRowOffset\")\n  return {\n    fixedBatchSize: row.fixedBatchSize,\n    nextBatchOrdinal: row.nextBatchOrdinal,\n    nextRowOffset: row.nextRowOffset,\n    inputExhausted: row.inputExhausted,\n  }\n}\n\n/**\n * A wait is either fully persisted or absent. A partially written one would read as \"waiting since\n * the epoch\" or \"waiting for nothing\", and both would decide a run's fate.\n */\nfunction restoreMissingTarget(\n  row: PersistedProjectionRunRecord,\n  checkpoint: ProjectionTelemetryCheckpoint\n): ProjectionMissingTarget | undefined {\n  const columns = [\n    row.missingTargetObjectTypeId,\n    row.missingTargetObjectId,\n    row.missingTargetBatchOrdinal,\n    row.missingTargetFirstSeenAt,\n  ]\n  if (columns.every((column) => column === undefined)) return undefined\n  if (\n    row.missingTargetObjectTypeId === undefined ||\n    row.missingTargetObjectId === undefined ||\n    row.missingTargetBatchOrdinal === undefined ||\n    row.missingTargetFirstSeenAt === undefined\n  ) {\n    throw new ProjectionRunError(\n      `[Sixb] Telemetry projection run '${row.id}' has a partially persisted missing target.`\n    )\n  }\n  const missingTarget: ProjectionMissingTarget = {\n    objectTypeId: row.missingTargetObjectTypeId,\n    objectId: row.missingTargetObjectId,\n    batchOrdinal: row.missingTargetBatchOrdinal,\n    firstSeenAt: new Date(row.missingTargetFirstSeenAt),\n  }\n  assertValidDate(missingTarget.firstSeenAt, \"missingTarget.firstSeenAt\")\n  assertProjectionRunCounter(missingTarget.batchOrdinal, \"missingTarget.batchOrdinal\")\n  if (missingTarget.batchOrdinal !== checkpoint.nextBatchOrdinal) {\n    throw new ProjectionRunError(\n      `[Sixb] Telemetry projection run '${row.id}' is waiting on a batch it has already passed.`\n    )\n  }\n  if (missingTarget.objectTypeId !== row.objectTypeId) {\n    throw new ProjectionRunError(\n      `[Sixb] Telemetry projection run '${row.id}' is waiting on an object type it does not write.`\n    )\n  }\n  return missingTarget\n}\n\nfunction assertNoCheckpoint(row: PersistedProjectionRunRecord): void {\n  if (\n    row.fixedBatchSize === undefined &&\n    row.nextBatchOrdinal === undefined &&\n    row.nextRowOffset === undefined &&\n    row.inputExhausted === undefined\n  ) {\n    return\n  }\n  throw new ProjectionRunError(\n    `[Sixb] Replacement projection run '${row.id}' contains a telemetry checkpoint.`\n  )\n}\n\nfunction incompleteProjectionRun(id: string): ProjectionRunError {\n  return new ProjectionRunError(\n    `[Sixb] Projection run '${id}' has incomplete materialization state.`\n  )\n}\n\nfunction invalidProjectionRunTarget(id: string): ProjectionRunError {\n  return new ProjectionRunError(`[Sixb] Projection run '${id}' has an invalid target.`)\n}\n\n/**\n * Validates a wait before it is stored, so every adapter refuses the same shapes and the SQL\n * `CHECK` behind them never has to be the thing that catches it.\n *\n * The ordinal has to be the batch the run is actually stuck on: anchored to a stale one, a wait\n * would survive the progress that resolved it and fail a run that is working. The object type\n * has to be the one this run writes, since that is the only type its telemetry can reference.\n */\nexport function assertProjectionMissingTarget(\n  record: TelemetryProjectionRunRecord,\n  missingTarget: ProjectionMissingTarget\n): ProjectionMissingTarget {\n  assertProjectionRunNonEmpty(missingTarget.objectTypeId, \"missingTarget.objectTypeId\")\n  assertProjectionRunNonEmpty(missingTarget.objectId, \"missingTarget.objectId\")\n  assertProjectionRunCounter(missingTarget.batchOrdinal, \"missingTarget.batchOrdinal\")\n  if (Number.isNaN(missingTarget.firstSeenAt.getTime())) {\n    throw new ProjectionRunError(\"[Sixb] Projection run missingTarget.firstSeenAt is invalid.\")\n  }\n  if (missingTarget.objectTypeId !== record.target.objectTypeId) {\n    throw new ProjectionRunError(\n      `[Sixb] Telemetry projection run '${record.id}' cannot wait on '${missingTarget.objectTypeId}'; it writes '${record.target.objectTypeId}'.`\n    )\n  }\n  if (missingTarget.batchOrdinal !== record.telemetryCheckpoint.nextBatchOrdinal) {\n    throw new ProjectionRunError(\n      `[Sixb] Telemetry projection run '${record.id}' cannot wait on batch ${missingTarget.batchOrdinal}; it is at ${record.telemetryCheckpoint.nextBatchOrdinal}.`\n    )\n  }\n  return missingTarget\n}\n\nexport function requireTelemetryProjectionRun<TRecord extends ProjectionRunRecord>(\n  record: TRecord\n): TRecord & TelemetryProjectionRunRecord {\n  if (isTelemetryProjectionRun(record)) return record as TRecord & TelemetryProjectionRunRecord\n  throw new ProjectionRunError(\n    `[Sixb] Projection run '${record.id}' does not have a telemetry checkpoint.`\n  )\n}\n\ntype ProjectionRunStart<TKind extends ProjectionKind> = Extract<\n  StartOrReclaimProjectionRunInput,\n  { readonly identity: { readonly projectionKind: TKind } }\n>\n\nfunction isTelemetryProjectionRun(\n  record: ProjectionRunRecord\n): record is TelemetryProjectionRunRecord {\n  return record.identity.projectionKind === \"telemetry\"\n}\n"
+  ],
+  "mappings": "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",
+  "debugId": "6023FB3FE52DBB3D64756E2164756E21",
+  "names": []
+}