@sixb/core 0.1.13 → 0.1.15

package/dist/{chunk-cbn96bve.js → chunk-r5sc1d2b.js}

@@ -2,12 +2,12 @@
 import {
   createSixbError2,
   isSixbError2
-} from "./chunk-rzkr70gr.js";
+} from "./chunk-6fsr7y93.js";
 import {
   resolveExecutionScopeAuthorization,
   AuthorizationError2,
   assertProviderAccess2
-} from "./chunk-rzcjp5m2.js";
+} from "./chunk-8fjmqjyx.js";
 import {
   isOAuthConnectorDefinition2
 } from "./chunk-9x8dybsb.js";

package/dist/{chunk-y6vnvayj.js → chunk-vjcd8d27.js}

@@ -6,7 +6,7 @@ import {
   reportEventDeliveryFailure3,
   reportRuleEvaluationFailure3,
   reportVectorIndexingFailure2
-} from "./chunk-bdhfn0ww.js";
+} from "./chunk-kkqwzy6h.js";
 
 // src/error-reporting/capability.ts
 var ERROR_REPORTER = Symbol("sixb.error-reporter");

package/dist/{chunk-jmwy25mf.js → chunk-wd34wnsy.js}

@@ -7,16 +7,16 @@ import {
   ShareDefinitionError2,
   isShareDefinition,
   snapshotShareDefinition
-} from "./chunk-9pfw47qx.js";
+} from "./chunk-qne45xqq.js";
 import {
   isProjectionDefinition2
-} from "./chunk-rzcjp5m2.js";
+} from "./chunk-8fjmqjyx.js";
 import {
   isDatasetDefinition2
 } from "./chunk-cd234ba4.js";
 import {
   isPipelineDefinition2
-} from "./chunk-2hbhn1ff.js";
+} from "./chunk-yfppyaty.js";
 import {
   assertPredicateShape,
   createPropertyPredicateBuilder,
@@ -28,13 +28,13 @@ import {
 } from "./chunk-e1c18xjx.js";
 import {
   isSyncDefinition2
-} from "./chunk-jhyc777j.js";
+} from "./chunk-q3grgzp1.js";
 import {
   isWorkflowDefinition2
-} from "./chunk-cvrbhvtr.js";
+} from "./chunk-2tz5vnvz.js";
 import {
   compileShareAccessPlan
-} from "./chunk-gmt22nxx.js";
+} from "./chunk-adbve9zt.js";
 import {
   isConnectorDefinition
 } from "./chunk-9x8dybsb.js";

package/dist/{chunk-63fp9x3q.js → chunk-wem5vqjw.js}

@@ -10,12 +10,12 @@ import {
   isAllowed2,
   assertAuthorized2,
   canViewActionRun2
-} from "./chunk-rzcjp5m2.js";
+} from "./chunk-8fjmqjyx.js";
 import {
   ActionRunTimeoutError2,
   createSixbError2,
   toSixbFailure2
-} from "./chunk-rzkr70gr.js";
+} from "./chunk-6fsr7y93.js";
 import {
   collectUserRefIds,
   userReferenceProblem
@@ -26,7 +26,7 @@ import {
 import {
   ACTION_RUN_FAILURE_CODES2,
   parseActionRunFailure2
-} from "./chunk-xgptywp0.js";
+} from "./chunk-y2aq6ag9.js";
 import {
   ActionRunError2
 } from "./chunk-fc5zfxy1.js";
@@ -35,7 +35,7 @@ import {
   normalizeActionParams,
   validateActionSubject,
   resolveObjectActionSubject
-} from "./chunk-9pfw47qx.js";
+} from "./chunk-qne45xqq.js";
 import {
   snapshotVectorProfiles
 } from "./chunk-3nx8vj5a.js";
@@ -49,10 +49,10 @@ import {
   validateObjectFacetRequests,
   preflightObjectQueryLinks,
   executeObjectQueryLinks2
-} from "./chunk-898y24dd.js";
+} from "./chunk-3c90jvfj.js";
 import {
   reportRunFailure2
-} from "./chunk-y6vnvayj.js";
+} from "./chunk-vjcd8d27.js";
 import {
   ObjectQueryValidationError2
 } from "./chunk-a0073121.js";
@@ -60,7 +60,7 @@ import {
   executionRecordInputFromRuntime,
   ensureExecutionRecord2,
   createPrimitiveExecutionRecord
-} from "./chunk-m8zkvep1.js";
+} from "./chunk-8w27xf9e.js";
 import {
   actionSubjectsEqual2,
   actionRunParamsEqual2,

package/dist/{chunk-darm7eeg.js → chunk-xr7y35yj.js}

@@ -3,14 +3,14 @@ import {
   AuthStorageError2,
   SYSTEM_PRINCIPAL2,
   principalsEqual2
-} from "./chunk-9pfw47qx.js";
+} from "./chunk-qne45xqq.js";
 import {
   agentServiceAccountId2,
   resolveAuthorizationContext2
-} from "./chunk-rzcjp5m2.js";
+} from "./chunk-8fjmqjyx.js";
 import {
   createSixbError2
-} from "./chunk-rzkr70gr.js";
+} from "./chunk-6fsr7y93.js";
 import {
   findPrimitiveRunExecution,
   findAgentRunExecution

package/dist/{chunk-a69fkrtr.js → chunk-y0zmae99.js}

@@ -2,17 +2,17 @@
 import {
   createSixbError2,
   toSixbFailure2
-} from "./chunk-rzkr70gr.js";
+} from "./chunk-6fsr7y93.js";
 import {
   reportRunFailure2
-} from "./chunk-y6vnvayj.js";
+} from "./chunk-vjcd8d27.js";
 import {
   resolveExecutionScopeAuthorization,
   assertAuthorized2
-} from "./chunk-rzcjp5m2.js";
+} from "./chunk-8fjmqjyx.js";
 import {
   SYNC_RUN_FAILURE_CODES2
-} from "./chunk-gc226ten.js";
+} from "./chunk-fjw417jf.js";
 import {
   SyncRunError2
 } from "./chunk-jmfet9r4.js";
@@ -20,7 +20,7 @@ import {
   executionRecordInputFromRuntime,
   ensureExecutionRecord2,
   createPrimitiveExecutionRecord
-} from "./chunk-m8zkvep1.js";
+} from "./chunk-8w27xf9e.js";
 
 // src/syncs/errors.ts
 class SyncValidationError2 extends Error {

package/dist/{chunk-xgptywp0.js → chunk-y2aq6ag9.js}

@@ -1,7 +1,7 @@
 // @bun
 import {
   parseSixbFailure2
-} from "./chunk-rzkr70gr.js";
+} from "./chunk-6fsr7y93.js";
 import {
   isPlainRecord
 } from "./chunk-wy0qdqfm.js";

package/dist/{chunk-2hbhn1ff.js → chunk-yfppyaty.js}

@@ -8,7 +8,7 @@ import {
 } from "./chunk-cd234ba4.js";
 import {
   PipelineError2
-} from "./chunk-w9bp61e7.js";
+} from "./chunk-n5t4mq6z.js";
 
 // src/lake-storage/sql-transforms.ts
 var SQL_DIALECT = {

package/dist/{chunk-rqtdtm43.js → chunk-z708gemf.js}

@@ -39,36 +39,35 @@ import {
   createCommitId2,
   createEventId2,
   materializationApplyPhase
-} from "./chunk-ht4a7mjg.js";
+} from "./chunk-g4rbm4a6.js";
 import {
   ProjectionValidationError2,
   validateProjectionsAtStartup,
   isProjectionDefinition2,
   resolveExecutionScopeAuthorization
-} from "./chunk-rzcjp5m2.js";
+} from "./chunk-8fjmqjyx.js";
 import {
   objectBatchKey2,
   vectorConfiguration,
   vectorSources,
   normalizeVector2
-} from "./chunk-gc226ten.js";
+} from "./chunk-fjw417jf.js";
 import {
   parseDatasetTimestamp2
 } from "./chunk-z667z3sg.js";
 import {
   executionRecordInputFromRuntime,
   ensureExecutionRecord2
-} from "./chunk-m8zkvep1.js";
+} from "./chunk-8w27xf9e.js";
 import {
   isStorageSerializationFailure2
 } from "./chunk-zdkcdshk.js";
 import {
   assertPinnedDatasetWatermark2
-} from "./chunk-3qpcrcj8.js";
+} from "./chunk-6aawea28.js";
 import {
   MaterializationValidationError2,
   MaterializationObjectNotFoundError2,
-  MaterializationCancellationError2,
   MaterializationConflictError2
 } from "./chunk-96yw3pwd.js";
 import {
@@ -3314,23 +3313,26 @@ function prepareProjectionRunFinish(context, raw) {
   const source = normalizeProjectionSourceRef(raw.input.source);
   const datasetVersion = normalizePinnedDatasetVersion(raw.input.datasetVersion);
   const projectionExecution = normalizeProjectionExecution2(raw.input.execution);
-  const resolved = raw.input.protocol === "replacement" ? context.projectionRegistry.resolveSource(source.projectionId) : context.projectionRegistry.resolveTelemetry(source.projectionId);
-  if (resolved.datasetId !== datasetVersion.datasetId) {
+  const input = { ...raw.input, source, datasetVersion, execution: projectionExecution };
+  return {
+    projectId: context.projectId,
+    input,
+    deployed: input.status === "succeeded" ? resolveDeployedProjection(context, input) : null,
+    finishedAt: new Date(raw.input.finishedAt ?? context.clock()),
+    execution: prepareMaterializerExecution(context.projectId, raw.scope)
+  };
+}
+function resolveDeployedProjection(context, input) {
+  const resolved = input.protocol === "replacement" ? context.projectionRegistry.resolveSource(input.source.projectionId) : context.projectionRegistry.resolveTelemetry(input.source.projectionId);
+  if (resolved.datasetId !== input.datasetVersion.datasetId) {
     throw new MaterializationValidationError2(`Projection '${resolved.projectionId}' requires dataset '${resolved.datasetId}'.`);
   }
   const identity = createProjectionRunMaterializationIdentity({
     resolved,
-    datasetVersion,
+    datasetVersion: input.datasetVersion,
     ontologyRevision: context.projectionRegistry.ontologyRevision
   });
-  return {
-    projectId: context.projectId,
-    input: { ...raw.input, source, datasetVersion, execution: projectionExecution },
-    identity,
-    resolved,
-    finishedAt: new Date(raw.input.finishedAt ?? context.clock()),
-    execution: prepareMaterializerExecution(context.projectId, raw.scope)
-  };
+  return { identity, resolved };
 }
 async function finishProjectionRunTransaction(storage, command) {
   await ensureMaterializerExecution(storage.executions, command.execution);
@@ -3339,33 +3341,78 @@ async function finishProjectionRunTransaction(storage, command) {
     id: command.input.source.projectionId,
     runId: command.input.execution.projectionRunId
   });
-  const { projectionRuns, run } = await lockProjectionRunForMaterialization(storage, {
+  const { projectionRuns, run } = command.deployed ? await lockProjectionRunForMaterialization(storage, {
     projectId: command.projectId,
     projectionRunId: command.input.execution.projectionRunId,
     executionToken: command.input.execution.executionToken,
-    identity: command.identity,
-    resolved: command.resolved
-  });
+    identity: command.deployed.identity,
+    resolved: command.deployed.resolved
+  }) : await lockProjectionRunAsStored(storage, command);
   assertMaterializerRunExecution(command.execution, run.executionId, `Projection run '${run.id}'`);
   if (command.input.protocol === "replacement") {
     await assertReplacementTerminalDecision(storage, command);
+    if (command.input.status === "superseded") {
+      await assertRunSuperseded(projectionRuns, command);
+    }
+    if (command.input.status !== "succeeded") {
+      await storage.ontology.sources.abandon({
+        kind: "run",
+        projectId: command.projectId,
+        source: command.input.source,
+        execution: command.input.execution,
+        abandonedAt: command.finishedAt.toISOString()
+      });
+    }
   }
   await projectionRuns.finish({
     id: command.input.execution.projectionRunId,
     projectId: command.projectId,
     executionToken: command.input.execution.executionToken,
-    identity: command.identity,
+    identity: run.identity,
     ...terminalDecision(command.input),
     finishedAt: command.finishedAt
   });
 }
+async function assertRunSuperseded(projectionRuns, command) {
+  const newer = await projectionRuns.findSupersedingRun({
+    projectId: command.projectId,
+    id: command.input.execution.projectionRunId
+  });
+  if (newer)
+    return;
+  throw new MaterializationConflictError2("run-correlation", `Projection run '${command.input.execution.projectionRunId}' cannot be superseded: no run of a later dataset version stands to replace it.`);
+}
+async function lockProjectionRunAsStored(storage, command) {
+  const projectionRuns = storage.projectionRuns;
+  if (!projectionRuns) {
+    throw new MaterializationValidationError2("Storage transaction does not provide projection run capabilities.");
+  }
+  const { input } = command;
+  const stored = await projectionRuns.getById({
+    projectId: command.projectId,
+    id: input.execution.projectionRunId
+  });
+  if (!stored || stored.identity.projectionId !== input.source.projectionId || stored.identity.protocol !== input.protocol || !datasetVersionsEqual(stored.identity.datasetVersion, input.datasetVersion)) {
+    throw new MaterializationConflictError2("run-correlation", `Projection run '${input.execution.projectionRunId}' does not match its finish decision.`);
+  }
+  const run = await projectionRuns.lockForMaterialization({
+    id: stored.id,
+    projectId: command.projectId,
+    executionToken: input.execution.executionToken,
+    identity: stored.identity
+  });
+  return { projectionRuns, run };
+}
 function assertValidTerminalDecision(input) {
   if (input.protocol !== "replacement" && input.protocol !== "telemetry") {
     throw new MaterializationValidationError2("Projection finish protocol is invalid.");
   }
-  if (input.status !== "succeeded" && input.status !== "failed" && input.status !== "cancelled") {
+  if (input.status !== "succeeded" && input.status !== "failed" && input.status !== "cancelled" && input.status !== "superseded") {
     throw new MaterializationValidationError2("Projection finish status must be terminal.");
   }
+  if (input.status === "superseded" && input.protocol !== "replacement") {
+    throw new MaterializationValidationError2("Only a replacement projection run can be superseded.");
+  }
   const inputExhausted = "inputExhausted" in input ? input.inputExhausted : undefined;
   if (input.status === "succeeded" && input.protocol === "telemetry") {
     if (inputExhausted === true)
@@ -3377,6 +3424,9 @@ function assertValidTerminalDecision(input) {
   }
 }
 function terminalDecision(input) {
+  if (input.status === "superseded") {
+    return { protocol: "replacement", status: "superseded" };
+  }
   if (input.status !== "succeeded") {
     return {
       protocol: input.protocol,
@@ -3409,8 +3459,9 @@ async function assertReplacementTerminalDecision(storage, command) {
   }
 }
 function assertReplacementCommitCorrelation(commit, command) {
-  const { input, identity } = command;
-  if (commit.origin.kind !== "projection" || commit.executionId !== command.execution.executionId || commit.intent.kind !== "projection" || commit.result.kind !== "projection" || commit.origin.projectionRunId !== input.execution.projectionRunId || commit.origin.projectionId !== input.source.projectionId || commit.intent.source.projectionId !== input.source.projectionId || !datasetVersionsEqual(commit.intent.datasetVersion, input.datasetVersion) || commit.ontologyRevision !== identity.ontologyRevision || commit.projectionRevision !== identity.projectionRevision || commit.ownershipHash !== identity.ownershipHash) {
+  const { input } = command;
+  const identity = command.deployed?.identity;
+  if (!identity || commit.origin.kind !== "projection" || commit.executionId !== command.execution.executionId || commit.intent.kind !== "projection" || commit.result.kind !== "projection" || commit.origin.projectionRunId !== input.execution.projectionRunId || commit.origin.projectionId !== input.source.projectionId || commit.intent.source.projectionId !== input.source.projectionId || !datasetVersionsEqual(commit.intent.datasetVersion, input.datasetVersion) || commit.ontologyRevision !== identity.ontologyRevision || commit.projectionRevision !== identity.projectionRevision || commit.ownershipHash !== identity.ownershipHash) {
     throw new MaterializationConflictError2("run-correlation", `Projection replacement run '${input.execution.projectionRunId}' commit identity does not match.`);
   }
 }
@@ -3801,16 +3852,19 @@ async function stageProjectionMaterialization(context, input) {
         }
         const root = normalizeProjectionEntity(rawEntry.root);
         validateProjectionRootRef(context.projectionRegistry.resolveSource(input.source.projectionId), root);
-        yield { root, stagingOrdinal: rootCount++ };
+        const stagingOrdinal = rootCount++;
+        if (stagingOrdinal >= input.resumeStagingOrdinal)
+          yield { root, stagingOrdinal };
         continue;
       }
       const entry = input.validateEntry(normalizeProjectionSourceEntry2(rawEntry));
-      const stagingOrdinal = rootCount;
+      const stagingOrdinal = rootCount++;
+      assertionCount += entry.assertions.length;
+      if (stagingOrdinal < input.resumeStagingOrdinal)
+        continue;
       for (const assertion of entry.assertions) {
-        assertionCount += 1;
         yield { root: entry.root, assertion, stagingOrdinal };
       }
-      rootCount += 1;
     }
     throwIfAborted(input.signal);
   }
@@ -3847,13 +3901,8 @@ async function replaceProjection(context, raw) {
   if (replay)
     return replay;
   const candidate = await prepareProjectionCandidate(context, command);
-  try {
-    const ready = await stageProjectionCandidate(context, command, candidate);
-    return await commitProjectionCandidate(context, command, ready);
-  } catch (error) {
-    await abandonFailedCandidate(context, command, candidate, error);
-    throw error;
-  }
+  const ready = await stageProjectionCandidate(context, command, candidate);
+  return commitProjectionCandidate(context, command, ready);
 }
 function prepareProjectionReplacement(context, raw) {
   const source = normalizeProjectionSourceRef(raw.input.source);
@@ -3931,12 +3980,11 @@ function projectionReplayResult(commit, command) {
   return { ...structuredClone(commit.result), created: false };
 }
 async function prepareProjectionCandidate(context, command) {
-  await context.storage.ontology.sources.abandon({
-    kind: "reclaim",
+  const adopted = await context.storage.ontology.sources.adopt({
     projectId: context.projectId,
     source: command.source,
     execution: command.execution,
-    abandonedAt: context.clock().toISOString()
+    adoptedAt: context.clock().toISOString()
   });
   const active = await context.storage.ontology.sources.getActive({
     projectId: context.projectId,
@@ -3944,17 +3992,48 @@ async function prepareProjectionCandidate(context, command) {
   });
   validateProjectionWatermark(active, command.datasetVersion);
   assertDeltaBase(active, command);
+  const expectedSource = {
+    source: command.source,
+    activeMaterializationId: active?.materializationId ?? null,
+    lastCommitId: active?.lastCommitId ?? null
+  };
+  if (adopted && sameSourceBase(adopted.record.base, command.base)) {
+    return {
+      materializationId: adopted.record.materializationId,
+      createdAt: adopted.record.createdAt,
+      adopted,
+      expectedSource
+    };
+  }
+  if (adopted) {
+    await context.storage.ontology.sources.abandon({
+      kind: "candidate",
+      projectId: context.projectId,
+      source: command.source,
+      materializationId: adopted.record.materializationId,
+      execution: command.execution,
+      abandonedAt: context.clock().toISOString()
+    });
+  }
   return {
     materializationId: context.materializationId(),
     createdAt: context.clock().toISOString(),
-    expectedSource: {
-      source: command.source,
-      activeMaterializationId: active?.materializationId ?? null,
-      lastCommitId: active?.lastCommitId ?? null
-    }
+    expectedSource
   };
 }
 async function stageProjectionCandidate(context, command, candidate) {
+  const staged = await stageOrReuseCandidate(context, command, candidate);
+  return {
+    ...candidate,
+    staged,
+    identity: timestampCommitIdentity2(command.identity, context.clock())
+  };
+}
+async function stageOrReuseCandidate(context, command, candidate) {
+  const adopted = candidate.adopted?.record;
+  if (adopted?.status === "ready" && adopted.rootCount !== null) {
+    return { rootCount: adopted.rootCount, assertionCount: adopted.assertionCount ?? 0 };
+  }
   const input = {
     source: command.source,
     materializationId: candidate.materializationId,
@@ -3966,14 +4045,10 @@ async function stageProjectionCandidate(context, command, candidate) {
     createdAt: candidate.createdAt,
     entries: command.entries,
     ...command.base ? { base: command.base } : {},
+    resumeStagingOrdinal: candidate.adopted?.resumeStagingOrdinal ?? 0,
     validateEntry: createProjectionEntryValidator(context.ontology, command.resolved)
   };
-  const staged = await stageCandidateEntries(context, input, command.signal);
-  return {
-    ...candidate,
-    staged,
-    identity: timestampCommitIdentity2(command.identity, context.clock())
-  };
+  return stageCandidateEntries(context, input, command.signal);
 }
 async function stageCandidateEntries(context, input, signal) {
   if (signal === undefined)
@@ -4092,30 +4167,14 @@ function projectionActivation(command, ready) {
     updatedAt: ready.identity.committedAt
   };
 }
-async function abandonFailedCandidate(context, command, candidate, error) {
-  if (!shouldAbandonCandidate(error))
-    return;
-  await context.storage.ontology.sources.abandon({
-    kind: "candidate",
-    projectId: context.projectId,
-    source: command.source,
-    materializationId: candidate.materializationId,
-    execution: command.execution,
-    abandonedAt: context.clock().toISOString()
-  });
-}
-function shouldAbandonCandidate(error) {
-  if (error instanceof MaterializationValidationError2)
-    return true;
-  if (error instanceof MaterializationCancellationError2)
-    return true;
-  return error instanceof MaterializationConflictError2 && (error.kind === "run-correlation" || error.kind === "idempotency");
-}
 function validateProjectionWatermark(active, next) {
   if (!active)
     return;
   assertPinnedDatasetWatermark2(active.datasetVersion, next, "Projection replacement");
 }
+function sameSourceBase(left, right) {
+  return left?.materializationId === right?.materializationId && left?.lastCommitId === right?.lastCommitId;
+}
 function assertDeltaBase(active, command) {
   if (command.base && (!active || active.materializationId !== command.base.materializationId || active.lastCommitId !== command.base.lastCommitId || active.projectionRevision !== command.runIdentity.projectionRevision || active.ontologyRevision !== command.runIdentity.ontologyRevision || active.ownershipHash !== command.runIdentity.ownershipHash)) {
     throw new MaterializationConflictError2("source-materialization", "Projection delta no longer matches the active source or its definition.");
@@ -4664,4 +4723,4 @@ function createOntologyMaterializer2(input) {
 }
 export { computeOntologyRevision2, computeProjectionRevision2, computeProjectionOwnershipHash2, ProjectionRegistry2, createActionIdempotencyKey2, createRuntimeIdempotencyKey2, createProjectionIdempotencyKey2, createRuntimeTelemetryIdempotencyKey2, createProjectionTelemetryIdempotencyKey2, createCommitIdentity2, timestampCommitIdentity2, createTimedCommitIdentity2, createProjectionMaterializationId2, createLinkScopeFingerprint2, normalizeJsonProperties2, normalizeOntologyEditCommit2, normalizeProjectionExecution2, normalizeProjectionSourceEntry2, normalizeTelemetryAppend2, OntologyMaterializer2, createOntologyMaterializer2 };
 
-//# debugId=61B9FC5452B219F064756E2164756E21
+//# debugId=F46021ED4DFD665364756E2164756E21