@sixb/core 0.1.8 → 0.1.9

package/dist/{chunk-rv2hkwwa.js → chunk-ppytyr6w.js}

@@ -1,146 +1,123 @@
 // @bun
 import {
-  findPrimitiveRunExecution
-} from "./chunk-j1sbhm7p.js";
+  parseSixbFailure2
+} from "./chunk-f4w3yp4f.js";
+import {
+  PROJECTION_RUN_FAILURE_CODES2,
+  PROJECTION_RUN_PROGRESS_KEYS2,
+  zeroProjectionRunProgress2
+} from "./chunk-3frsnm7x.js";
 import {
-  MaterializationConflictError
-} from "./chunk-ry24jbr1.js";
+  findPrimitiveRunExecution
+} from "./chunk-ey1nk510.js";
 import {
-  parseSixbFailure
-} from "./chunk-2xns679x.js";
+  MaterializationConflictError2
+} from "./chunk-yv79ncbv.js";
 
 // src/storage/projection-runs/errors.ts
-class ProjectionRunError extends MaterializationConflictError {
+class ProjectionRunError2 extends MaterializationConflictError2 {
   name = "ProjectionRunError";
   constructor(message, kind = "run-correlation") {
     super(kind, message);
   }
 }
 
-// src/projections/types.ts
-var PROJECTION_RUN_FAILURE_CODES = [
-  "internal.unexpected",
-  "runtime.cancelled",
-  "queue.enqueue_failed",
-  "projection.execution_failed"
-];
-
-// 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) {
+function assertProjectionRunNonEmpty2(value, fieldName) {
   if (typeof value !== "string" || value.trim().length === 0) {
-    throw new ProjectionRunError(`[Sixb] Projection run ${fieldName} must not be empty.`);
+    throw new ProjectionRunError2(`[Sixb] Projection run ${fieldName} must not be empty.`);
   }
 }
-function assertProjectionRunCounter(value, fieldName) {
+function assertProjectionRunCounter2(value, fieldName) {
   if (!Number.isSafeInteger(value) || value < 0) {
-    throw new ProjectionRunError(`[Sixb] Projection run ${fieldName} must be a non-negative safe integer.`);
+    throw new ProjectionRunError2(`[Sixb] Projection run ${fieldName} must be a non-negative safe integer.`);
   }
 }
-function assertProjectionRunListWindow(value, fieldName) {
+function assertProjectionRunListWindow2(value, fieldName) {
   if (value !== undefined && (!Number.isSafeInteger(value) || value < 0)) {
-    throw new ProjectionRunError(`[Sixb] Projection run list ${fieldName} must be >= 0.`);
+    throw new ProjectionRunError2(`[Sixb] Projection run list ${fieldName} must be >= 0.`);
   }
 }
-function addProjectionRunCounter(left, right, fieldName) {
+function addProjectionRunCounter2(left, right, fieldName) {
   const result = left + right;
   if (!Number.isSafeInteger(result)) {
-    throw new ProjectionRunError(`[Sixb] Projection run ${fieldName} exceeds safe integer range.`);
+    throw new ProjectionRunError2(`[Sixb] Projection run ${fieldName} exceeds safe integer range.`);
   }
   return result;
 }
-function assertProjectionRunIdentity(identity) {
-  assertProjectionRunNonEmpty(identity.projectionId, "projectionId");
+function assertProjectionRunIdentity2(identity) {
+  assertProjectionRunNonEmpty2(identity.projectionId, "projectionId");
   if (!isProjectionKind(identity.projectionKind)) {
-    throw new ProjectionRunError("[Sixb] Projection run projectionKind must be 'object', 'link', or 'telemetry'.");
+    throw new ProjectionRunError2("[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'.");
+    throw new ProjectionRunError2("[Sixb] Projection run protocol must be 'replacement' or 'telemetry'.");
   }
-  assertProjectionRunNonEmpty(identity.datasetVersion.datasetId, "datasetId");
-  assertProjectionRunNonEmpty(identity.datasetVersion.versionId, "datasetVersionId");
+  assertProjectionRunNonEmpty2(identity.datasetVersion.datasetId, "datasetId");
+  assertProjectionRunNonEmpty2(identity.datasetVersion.versionId, "datasetVersionId");
   assertCanonicalTimestamp(identity.datasetVersion.createdAt, "datasetVersionCreatedAt");
-  assertProjectionRunNonEmpty(identity.ontologyRevision, "ontologyRevision");
-  assertProjectionRunNonEmpty(identity.projectionRevision, "projectionRevision");
-  assertProjectionRunNonEmpty(identity.ownershipHash, "ownershipHash");
+  assertProjectionRunNonEmpty2(identity.ontologyRevision, "ontologyRevision");
+  assertProjectionRunNonEmpty2(identity.projectionRevision, "projectionRevision");
+  assertProjectionRunNonEmpty2(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}'.`);
+    throw new ProjectionRunError2(`[Sixb] Projection run protocol '${identity.protocol}' is incompatible with kind '${identity.projectionKind}'.`);
   }
 }
-function assertProjectionRunIdentityMatches(record, identity) {
+function assertProjectionRunIdentityMatches2(record, identity) {
   if (projectionRunIdentitiesEqual(record.identity, identity))
     return;
-  throw new ProjectionRunError(`[Sixb] Projection run '${record.id}' materialization identity does not match.`);
+  throw new ProjectionRunError2(`[Sixb] Projection run '${record.id}' materialization identity does not match.`);
 }
-function assertProjectionRunTargetMatches(record, target) {
+function assertProjectionRunTargetMatches2(record, target) {
   if (projectionTargetsEqual(record.target, target))
     return;
-  throw new ProjectionRunError(`[Sixb] Projection run '${record.id}' target object types do not match.`);
+  throw new ProjectionRunError2(`[Sixb] Projection run '${record.id}' target object types do not match.`);
 }
-function assertProjectionRunStartInput(input) {
-  assertProjectionRunNonEmpty(input.id, "id");
-  assertProjectionRunNonEmpty(input.projectId, "projectId");
+function assertProjectionRunStartInput2(input) {
+  assertProjectionRunNonEmpty2(input.id, "id");
+  assertProjectionRunNonEmpty2(input.projectId, "projectId");
   assertProjectionRunIdentityAndTarget(input);
   if (input.startedAt)
     assertProjectionRunDate(input.startedAt, "startedAt");
 }
-function assertProjectionRunQueueInput(input) {
-  assertProjectionRunNonEmpty(input.id, "id");
-  assertProjectionRunNonEmpty(input.projectId, "projectId");
-  assertProjectionRunNonEmpty(input.executionId, "executionId");
+function assertProjectionRunQueueInput2(input) {
+  assertProjectionRunNonEmpty2(input.id, "id");
+  assertProjectionRunNonEmpty2(input.projectId, "projectId");
+  assertProjectionRunNonEmpty2(input.executionId, "executionId");
   assertProjectionRunIdentityAndTarget(input);
   if (input.queuedAt)
     assertProjectionRunDate(input.queuedAt, "queuedAt");
 }
 function assertProjectionRunIdentityAndTarget(input) {
-  assertProjectionRunIdentity(input.identity);
+  assertProjectionRunIdentity2(input.identity);
   assertProjectionTarget(input.identity.projectionKind, input.target);
   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.");
+    throw new ProjectionRunError2("[Sixb] Replacement projection runs cannot declare a telemetry fixedBatchSize.");
   }
 }
-function planProjectionRunReclaim(record, input) {
+function planProjectionRunReclaim2(record, input) {
   if (record.status !== "queued" && record.status !== "running") {
-    throw new ProjectionRunError(`[Sixb] Projection run '${record.id}' cannot start from status '${record.status}'.`);
+    throw new ProjectionRunError2(`[Sixb] Projection run '${record.id}' cannot start from status '${record.status}'.`);
   }
-  assertProjectionRunIdentityMatches(record, input.identity);
-  assertProjectionRunTargetMatches(record, input.target);
+  assertProjectionRunIdentityMatches2(record, input.identity);
+  assertProjectionRunTargetMatches2(record, input.target);
   if (record.telemetryCheckpoint?.fixedBatchSize !== input.fixedBatchSize) {
-    throw new ProjectionRunError(`[Sixb] Projection run '${input.id}' fixed batch size does not match.`);
+    throw new ProjectionRunError2(`[Sixb] Projection run '${input.id}' fixed batch size does not match.`);
   }
-  return { attempt: record.status === "queued" ? 1 : nextProjectionRunAttempt(record.attempt) };
+  return { attempt: record.status === "queued" ? 1 : nextProjectionRunAttempt2(record.attempt) };
 }
-function createProjectionRunRecord(input, now = new Date) {
-  assertProjectionRunQueueInput(input);
+function createProjectionRunRecord2(input, now = new Date) {
+  assertProjectionRunQueueInput2(input);
   const base = {
     id: input.id,
     projectId: input.projectId,
     executionId: input.executionId,
     status: "queued",
     attempt: 0,
-    progress: zeroProjectionRunProgress(),
+    progress: zeroProjectionRunProgress2(),
     queuedAt: new Date(input.queuedAt ?? now)
   };
   switch (input.identity.projectionKind) {
@@ -168,91 +145,91 @@ function createProjectionRunRecord(input, now = new Date) {
     }
   }
 }
-function assertProjectionRunRunning(record) {
+function assertProjectionRunRunning2(record) {
   if (record.status === "running")
     return;
   if (record.status !== "queued") {
-    throw new ProjectionRunError(`[Sixb] Projection run '${record.id}' is already terminal.`);
+    throw new ProjectionRunError2(`[Sixb] Projection run '${record.id}' is already terminal.`);
   }
-  throw new ProjectionRunError(`[Sixb] Projection run '${record.id}' for project '${record.projectId}' is not running.`);
+  throw new ProjectionRunError2(`[Sixb] Projection run '${record.id}' for project '${record.projectId}' is not running.`);
 }
-function assertProjectionRunAttempt(record, input) {
-  assertProjectionRunNonEmpty(input.executionToken, "executionToken");
-  assertProjectionRunIdentity(input.identity);
-  assertProjectionRunRunning(record);
-  assertProjectionRunIdentityMatches(record, input.identity);
+function assertProjectionRunAttempt2(record, input) {
+  assertProjectionRunNonEmpty2(input.executionToken, "executionToken");
+  assertProjectionRunIdentity2(input.identity);
+  assertProjectionRunRunning2(record);
+  assertProjectionRunIdentityMatches2(record, input.identity);
   if (record.executionToken !== input.executionToken) {
-    throw staleProjectionRunExecution(input.id);
+    throw staleProjectionRunExecution2(input.id);
   }
 }
-function nextProjectionRunAttempt(current) {
-  assertProjectionRunCounter(current, "attempt");
-  return addProjectionRunCounter(current, 1, "attempt");
+function nextProjectionRunAttempt2(current) {
+  assertProjectionRunCounter2(current, "attempt");
+  return addProjectionRunCounter2(current, 1, "attempt");
 }
-function mergeProjectionRunProgress(current, patch) {
+function mergeProjectionRunProgress2(current, patch) {
   const progress = { ...current };
-  for (const key of PROJECTION_RUN_PROGRESS_KEYS) {
+  for (const key of PROJECTION_RUN_PROGRESS_KEYS2) {
     const value = patch[key];
     if (value === undefined)
       continue;
-    assertProjectionRunCounter(value, key);
+    assertProjectionRunCounter2(value, key);
     if (value < current[key]) {
-      throw new ProjectionRunError(`[Sixb] Projection run ${key} must not decrease.`);
+      throw new ProjectionRunError2(`[Sixb] Projection run ${key} must not decrease.`);
     }
     progress[key] = value;
   }
   assertProjectionRunProgress(progress);
   return progress;
 }
-function assertGenericProgressDoesNotAdvanceTelemetry(record, patch) {
+function assertGenericProgressDoesNotAdvanceTelemetry2(record, patch) {
   if (record.identity.protocol !== "telemetry")
     return;
-  for (const key of PROJECTION_RUN_PROGRESS_KEYS) {
+  for (const key of PROJECTION_RUN_PROGRESS_KEYS2) {
     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.`);
+      throw new ProjectionRunError2(`[Sixb] Telemetry projection run '${record.id}' progress can only advance with its checkpoint.`);
     }
   }
 }
-function advanceProjectionTelemetry(record, input) {
-  const telemetry = requireTelemetryProjectionRun(record);
+function advanceProjectionTelemetry2(record, input) {
+  const telemetry = requireTelemetryProjectionRun2(record);
   const checkpoint = telemetry.telemetryCheckpoint;
-  assertProjectionRunCounter(input.batchOrdinal, "batchOrdinal");
+  assertProjectionRunCounter2(input.batchOrdinal, "batchOrdinal");
   assertPositiveCounter(input.batchRowCount, "batchRowCount");
-  assertProjectionRunCounter(input.batchRowsSkipped, "batchRowsSkipped");
+  assertProjectionRunCounter2(input.batchRowsSkipped, "batchRowsSkipped");
   if (input.batchRowsSkipped > input.batchRowCount) {
-    throw new ProjectionRunError(`[Sixb] Telemetry projection run '${record.id}' skipped rows exceed its batch row count.`);
+    throw new ProjectionRunError2(`[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}.`);
+    throw new ProjectionRunError2(`[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.`);
+    throw new ProjectionRunError2(`[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.`);
+    throw new ProjectionRunError2(`[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.`);
+    throw new ProjectionRunError2(`[Sixb] Telemetry projection run '${record.id}' has already exhausted its input.`);
   }
-  const nextRowOffset = addProjectionRunCounter(checkpoint.nextRowOffset, input.batchRowCount, "nextRowOffset");
+  const nextRowOffset = addProjectionRunCounter2(checkpoint.nextRowOffset, input.batchRowCount, "nextRowOffset");
   return {
     progress: {
       sourceRowsRead: nextRowOffset,
-      sourceRowsSkipped: addProjectionRunCounter(telemetry.progress.sourceRowsSkipped, input.batchRowsSkipped, "sourceRowsSkipped")
+      sourceRowsSkipped: addProjectionRunCounter2(telemetry.progress.sourceRowsSkipped, input.batchRowsSkipped, "sourceRowsSkipped")
     },
     checkpoint: {
       ...checkpoint,
-      nextBatchOrdinal: addProjectionRunCounter(checkpoint.nextBatchOrdinal, 1, "nextBatchOrdinal"),
+      nextBatchOrdinal: addProjectionRunCounter2(checkpoint.nextBatchOrdinal, 1, "nextBatchOrdinal"),
       nextRowOffset,
       inputExhausted: input.inputExhausted
     }
   };
 }
-function planProjectionRunFinish(record, input, now = new Date) {
+function planProjectionRunFinish2(record, input, now = new Date) {
   assertFinishDecision(record, input);
   const patch = input.progress ?? {};
-  assertGenericProgressDoesNotAdvanceTelemetry(record, patch);
-  const progress = mergeProjectionRunProgress(record.progress, patch);
+  assertGenericProgressDoesNotAdvanceTelemetry2(record, patch);
+  const progress = mergeProjectionRunProgress2(record.progress, patch);
   const finishedAt = new Date(input.finishedAt ?? now);
   assertProjectionRunDate(finishedAt, "finishedAt");
   return {
@@ -260,11 +237,11 @@ function planProjectionRunFinish(record, input, now = new Date) {
     finishedAt,
     progress,
     ...input.status === "succeeded" && input.protocol === "telemetry" ? { inputExhausted: true } : {},
-    ...input.status === "succeeded" || input.error === undefined ? {} : { error: parseSixbFailure(input.error, PROJECTION_RUN_FAILURE_CODES) }
+    ...input.status === "succeeded" || input.error === undefined ? {} : { error: parseSixbFailure2(input.error, PROJECTION_RUN_FAILURE_CODES2) }
   };
 }
-function finishProjectionRunRecord(record, input, now = new Date) {
-  const plan = planProjectionRunFinish(record, input, now);
+function finishProjectionRunRecord2(record, input, now = new Date) {
+  const plan = planProjectionRunFinish2(record, input, now);
   const terminal = {
     executionToken: undefined,
     status: plan.status,
@@ -273,7 +250,7 @@ function finishProjectionRunRecord(record, input, now = new Date) {
     error: plan.error
   };
   if (plan.inputExhausted) {
-    const telemetry = requireTelemetryProjectionRun(record);
+    const telemetry = requireTelemetryProjectionRun2(record);
     return {
       ...telemetry,
       ...terminal,
@@ -282,13 +259,13 @@ function finishProjectionRunRecord(record, input, now = new Date) {
   }
   return { ...record, ...terminal };
 }
-function failProjectionRunEnqueue(record, input, now = new Date) {
+function failProjectionRunEnqueue2(record, input, now = new Date) {
   if (record.status !== "queued") {
-    throw new ProjectionRunError(`[Sixb] Projection run '${record.id}' cannot fail enqueue from status '${record.status}'.`);
+    throw new ProjectionRunError2(`[Sixb] Projection run '${record.id}' cannot fail enqueue from status '${record.status}'.`);
   }
-  const error = parseSixbFailure(input.error, PROJECTION_RUN_FAILURE_CODES);
+  const error = parseSixbFailure2(input.error, PROJECTION_RUN_FAILURE_CODES2);
   if (error.code !== "queue.enqueue_failed") {
-    throw new ProjectionRunError(`[Sixb] Projection run '${record.id}' enqueue failure must use code 'queue.enqueue_failed'.`);
+    throw new ProjectionRunError2(`[Sixb] Projection run '${record.id}' enqueue failure must use code 'queue.enqueue_failed'.`);
   }
   const finishedAt = new Date(input.finishedAt ?? now);
   assertProjectionRunDate(finishedAt, "finishedAt");
@@ -299,14 +276,14 @@ function failProjectionRunEnqueue(record, input, now = new Date) {
     error
   };
 }
-function canRequeueProjectionRunAfterEnqueueFailure(record, input) {
+function canRequeueProjectionRunAfterEnqueueFailure2(record, input) {
   return record.status === "failed" && record.error?.code === "queue.enqueue_failed" && record.error.retryable && record.executionId === input.executionId && projectionRunIdentitiesEqual(record.identity, input.identity) && projectionTargetsEqual(record.target, input.target) && record.telemetryCheckpoint?.fixedBatchSize === input.fixedBatchSize;
 }
-function restoreProjectionRun(row) {
-  assertProjectionRunNonEmpty(row.id, "id");
-  assertProjectionRunNonEmpty(row.projectId, "projectId");
-  assertProjectionRunNonEmpty(row.executionId, "executionId");
-  assertProjectionRunCounter(row.attempt, "attempt");
+function restoreProjectionRun2(row) {
+  assertProjectionRunNonEmpty2(row.id, "id");
+  assertProjectionRunNonEmpty2(row.projectId, "projectId");
+  assertProjectionRunNonEmpty2(row.executionId, "executionId");
+  assertProjectionRunCounter2(row.attempt, "attempt");
   assertProjectionRunProgress(row.progress);
   assertValidDate(row.queuedAt, "queuedAt");
   if (row.startedAt)
@@ -326,7 +303,7 @@ function restoreProjectionRun(row) {
     finishedAt: row.finishedAt ? new Date(row.finishedAt) : undefined,
     attempt: row.attempt,
     progress: { ...row.progress },
-    error: row.error === undefined ? undefined : parseSixbFailure(row.error, PROJECTION_RUN_FAILURE_CODES),
+    error: row.error === undefined ? undefined : parseSixbFailure2(row.error, PROJECTION_RUN_FAILURE_CODES2),
     executionToken: row.executionToken
   };
   if (identity.projectionKind === "link") {
@@ -349,7 +326,7 @@ function restoreProjectionRun(row) {
   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.`);
+      throw new ProjectionRunError2(`[Sixb] Telemetry projection run '${row.id}' progress does not match its checkpoint.`);
     }
     if (row.status === "succeeded" && !telemetryCheckpoint.inputExhausted) {
       throw incompleteProjectionRun(row.id);
@@ -366,47 +343,47 @@ function restoreProjectionRun(row) {
   assertNoCheckpoint(row);
   return { ...base, identity, target: { objectTypeId: row.objectTypeId } };
 }
-function publicProjectionRunRecord(record) {
+function publicProjectionRunRecord2(record) {
   const cloned = structuredClone(record);
   Reflect.deleteProperty(cloned, "executionToken");
   return cloned;
 }
-function createProjectionRunClaim(record) {
-  assertProjectionRunRunning(record);
-  const executionToken = requireProjectionRunExecutionToken(record);
+function createProjectionRunClaim2(record) {
+  assertProjectionRunRunning2(record);
+  const executionToken = requireProjectionRunExecutionToken2(record);
   return {
-    run: publicProjectionRunRecord(record),
+    run: publicProjectionRunRecord2(record),
     execution: { projectionRunId: record.id, executionToken }
   };
 }
-function requireProjectionRunExecutionToken(record) {
+function requireProjectionRunExecutionToken2(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 staleProjectionRunExecution2(id) {
+  return new ProjectionRunError2(`[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 projectionRunNotFound2(projectId, id) {
+  return new ProjectionRunError2(`[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 immutableDatasetVersionConflict2(identity) {
+  return new ProjectionRunError2(`[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.`);
+    throw new ProjectionRunError2(`[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.`);
+    throw new ProjectionRunError2(`[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.`);
+    throw new ProjectionRunError2(`[Sixb] Projection run persisted ${fieldName} is invalid.`);
   }
 }
 function assertPersistedLifecycle(row) {
@@ -427,7 +404,7 @@ function assertPersistedLifecycle(row) {
     throw incompleteProjectionRun(row.id);
   }
   if (row.error !== undefined) {
-    const failure = parseSixbFailure(row.error, PROJECTION_RUN_FAILURE_CODES);
+    const failure = parseSixbFailure2(row.error, PROJECTION_RUN_FAILURE_CODES2);
     if (failure.code === "queue.enqueue_failed") {
       if (!failure.retryable || row.status !== "failed" || row.attempt !== 0 || row.startedAt !== undefined) {
         throw incompleteProjectionRun(row.id);
@@ -441,7 +418,7 @@ function assertPersistedLifecycle(row) {
 }
 function assertProjectionRunDate(value, fieldName) {
   if (!Number.isFinite(value.getTime())) {
-    throw new ProjectionRunError(`[Sixb] Projection run ${fieldName} is invalid.`);
+    throw new ProjectionRunError2(`[Sixb] Projection run ${fieldName} is invalid.`);
   }
 }
 function isProjectionKind(value) {
@@ -450,16 +427,16 @@ function isProjectionKind(value) {
 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.");
+      throw new ProjectionRunError2("[Sixb] Link projection runs must declare source and target object types.");
     }
-    assertProjectionRunNonEmpty(target.sourceObjectTypeId, "sourceObjectTypeId");
-    assertProjectionRunNonEmpty(target.targetObjectTypeId, "targetObjectTypeId");
+    assertProjectionRunNonEmpty2(target.sourceObjectTypeId, "sourceObjectTypeId");
+    assertProjectionRunNonEmpty2(target.targetObjectTypeId, "targetObjectTypeId");
     return;
   }
   if (!("objectTypeId" in target)) {
-    throw new ProjectionRunError("[Sixb] Object and telemetry projection runs must declare one object type.");
+    throw new ProjectionRunError2("[Sixb] Object and telemetry projection runs must declare one object type.");
   }
-  assertProjectionRunNonEmpty(target.objectTypeId, "objectTypeId");
+  assertProjectionRunNonEmpty2(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;
@@ -471,31 +448,31 @@ function projectionTargetsEqual(left, right) {
   return left.objectTypeId === right.objectTypeId;
 }
 function assertProjectionRunProgress(progress) {
-  for (const key of PROJECTION_RUN_PROGRESS_KEYS) {
-    assertProjectionRunCounter(progress[key], key);
+  for (const key of PROJECTION_RUN_PROGRESS_KEYS2) {
+    assertProjectionRunCounter2(progress[key], key);
   }
   if (progress.sourceRowsSkipped > progress.sourceRowsRead) {
-    throw new ProjectionRunError("[Sixb] Projection run sourceRowsSkipped must not exceed sourceRowsRead.");
+    throw new ProjectionRunError2("[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.`);
+    throw new ProjectionRunError2(`[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.`);
+    throw new ProjectionRunError2(`[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.`);
+    throw new ProjectionRunError2(`[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.`);
+    throw new ProjectionRunError2(`[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.`);
+    throw new ProjectionRunError2(`[Sixb] Projection run '${record.id}' contains telemetry-only completion metadata.`);
   }
 }
 function restoreIdentity(row) {
@@ -515,16 +492,16 @@ function restoreIdentity(row) {
     projectionRevision: row.projectionRevision,
     ownershipHash: row.ownershipHash
   };
-  assertProjectionRunIdentity(identity);
+  assertProjectionRunIdentity2(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.`);
+    throw new ProjectionRunError2(`[Sixb] Telemetry projection run '${row.id}' has incomplete checkpoint state.`);
   }
   assertPositiveCounter(row.fixedBatchSize, "fixedBatchSize");
-  assertProjectionRunCounter(row.nextBatchOrdinal, "nextBatchOrdinal");
-  assertProjectionRunCounter(row.nextRowOffset, "nextRowOffset");
+  assertProjectionRunCounter2(row.nextBatchOrdinal, "nextBatchOrdinal");
+  assertProjectionRunCounter2(row.nextRowOffset, "nextRowOffset");
   return {
     fixedBatchSize: row.fixedBatchSize,
     nextBatchOrdinal: row.nextBatchOrdinal,
@@ -542,7 +519,7 @@ function restoreMissingTarget(row, checkpoint) {
   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.`);
+    throw new ProjectionRunError2(`[Sixb] Telemetry projection run '${row.id}' has a partially persisted missing target.`);
   }
   const missingTarget = {
     objectTypeId: row.missingTargetObjectTypeId,
@@ -551,12 +528,12 @@ function restoreMissingTarget(row, checkpoint) {
     firstSeenAt: new Date(row.missingTargetFirstSeenAt)
   };
   assertValidDate(missingTarget.firstSeenAt, "missingTarget.firstSeenAt");
-  assertProjectionRunCounter(missingTarget.batchOrdinal, "missingTarget.batchOrdinal");
+  assertProjectionRunCounter2(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.`);
+    throw new ProjectionRunError2(`[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.`);
+    throw new ProjectionRunError2(`[Sixb] Telemetry projection run '${row.id}' is waiting on an object type it does not write.`);
   }
   return missingTarget;
 }
@@ -564,40 +541,40 @@ 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.`);
+  throw new ProjectionRunError2(`[Sixb] Replacement projection run '${row.id}' contains a telemetry checkpoint.`);
 }
 function incompleteProjectionRun(id) {
-  return new ProjectionRunError(`[Sixb] Projection run '${id}' has incomplete materialization state.`);
+  return new ProjectionRunError2(`[Sixb] Projection run '${id}' has incomplete materialization state.`);
 }
 function invalidProjectionRunTarget(id) {
-  return new ProjectionRunError(`[Sixb] Projection run '${id}' has an invalid target.`);
+  return new ProjectionRunError2(`[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");
+function assertProjectionMissingTarget2(record, missingTarget) {
+  assertProjectionRunNonEmpty2(missingTarget.objectTypeId, "missingTarget.objectTypeId");
+  assertProjectionRunNonEmpty2(missingTarget.objectId, "missingTarget.objectId");
+  assertProjectionRunCounter2(missingTarget.batchOrdinal, "missingTarget.batchOrdinal");
   if (Number.isNaN(missingTarget.firstSeenAt.getTime())) {
-    throw new ProjectionRunError("[Sixb] Projection run missingTarget.firstSeenAt is invalid.");
+    throw new ProjectionRunError2("[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}'.`);
+    throw new ProjectionRunError2(`[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}.`);
+    throw new ProjectionRunError2(`[Sixb] Telemetry projection run '${record.id}' cannot wait on batch ${missingTarget.batchOrdinal}; it is at ${record.telemetryCheckpoint.nextBatchOrdinal}.`);
   }
   return missingTarget;
 }
-function requireTelemetryProjectionRun(record) {
+function requireTelemetryProjectionRun2(record) {
   if (isTelemetryProjectionRun(record))
     return record;
-  throw new ProjectionRunError(`[Sixb] Projection run '${record.id}' does not have a telemetry checkpoint.`);
+  throw new ProjectionRunError2(`[Sixb] Projection run '${record.id}' does not have a telemetry checkpoint.`);
 }
 function isTelemetryProjectionRun(record) {
   return record.identity.projectionKind === "telemetry";
 }
 
 // src/storage/projection-runs/provider.ts
-async function assertProjectionRunDurableExecution(input) {
+async function assertProjectionRunDurableExecution2(input) {
   const execution = await findPrimitiveRunExecution({
     executions: input.executions,
     projectId: input.projectId,
@@ -606,10 +583,10 @@ async function assertProjectionRunDurableExecution(input) {
     sourceTypes: ["datasetVersion"]
   });
   if (!execution || execution.source.type !== "datasetVersion" || execution.source.datasetId !== input.datasetId || execution.source.versionId !== input.datasetVersionId) {
-    throw new ProjectionRunError(`[Sixb] Execution '${input.executionId}' does not authorize Projection run '${input.runId}'.`);
+    throw new ProjectionRunError2(`[Sixb] Execution '${input.executionId}' does not authorize Projection run '${input.runId}'.`);
   }
 }
 
-export { ProjectionRunError, PROJECTION_RUN_FAILURE_CODES, PROJECTION_RUN_PROGRESS_KEYS, zeroProjectionRunProgress, projectionRunObjectTypesVisible, assertProjectionRunNonEmpty, assertProjectionRunCounter, assertProjectionRunListWindow, addProjectionRunCounter, assertProjectionRunIdentity, assertProjectionRunIdentityMatches, assertProjectionRunTargetMatches, assertProjectionRunStartInput, assertProjectionRunQueueInput, planProjectionRunReclaim, createProjectionRunRecord, assertProjectionRunRunning, assertProjectionRunAttempt, nextProjectionRunAttempt, mergeProjectionRunProgress, assertGenericProgressDoesNotAdvanceTelemetry, advanceProjectionTelemetry, planProjectionRunFinish, finishProjectionRunRecord, failProjectionRunEnqueue, canRequeueProjectionRunAfterEnqueueFailure, restoreProjectionRun, publicProjectionRunRecord, createProjectionRunClaim, requireProjectionRunExecutionToken, staleProjectionRunExecution, projectionRunNotFound, immutableDatasetVersionConflict, assertProjectionMissingTarget, requireTelemetryProjectionRun, assertProjectionRunDurableExecution };
+export { ProjectionRunError2, assertProjectionRunNonEmpty2, assertProjectionRunCounter2, assertProjectionRunListWindow2, addProjectionRunCounter2, assertProjectionRunIdentity2, assertProjectionRunIdentityMatches2, assertProjectionRunTargetMatches2, assertProjectionRunStartInput2, assertProjectionRunQueueInput2, planProjectionRunReclaim2, createProjectionRunRecord2, assertProjectionRunRunning2, assertProjectionRunAttempt2, nextProjectionRunAttempt2, mergeProjectionRunProgress2, assertGenericProgressDoesNotAdvanceTelemetry2, advanceProjectionTelemetry2, planProjectionRunFinish2, finishProjectionRunRecord2, failProjectionRunEnqueue2, canRequeueProjectionRunAfterEnqueueFailure2, restoreProjectionRun2, publicProjectionRunRecord2, createProjectionRunClaim2, requireProjectionRunExecutionToken2, staleProjectionRunExecution2, projectionRunNotFound2, immutableDatasetVersionConflict2, assertProjectionMissingTarget2, requireTelemetryProjectionRun2, assertProjectionRunDurableExecution2 };
 
-//# debugId=F1452D90C0D387BF64756E2164756E21
+//# debugId=26E512EA50F920A164756E2164756E21