@sixb/core 0.1.14 → 0.1.16

package/dist/{chunk-3fpgxpsq.js → chunk-6z1q7j19.js}

@@ -3,10 +3,10 @@ import {
   createSixbError2,
   toSixbFailure2,
   parseSixbFailure2
-} from "./chunk-rzkr70gr.js";
+} from "./chunk-6fsr7y93.js";
 import {
   parseActionRunFailure2
-} from "./chunk-xgptywp0.js";
+} from "./chunk-y2aq6ag9.js";
 import {
   ActionRunError2,
   assertActionRunExecution2
@@ -15,13 +15,13 @@ import {
   paginate,
   InMemoryAuthStorage2,
   principalsEqual2
-} from "./chunk-6rzb1g6h.js";
+} from "./chunk-2xvgy3x5.js";
 import {
   ObjectReadLimitExceededError2,
   snapshotObjectReadExecutionLimits2,
   assertObjectReadFacetCount2,
   assertObjectReadOutputWithinLimit2
-} from "./chunk-rzcjp5m2.js";
+} from "./chunk-69kt9q43.js";
 import {
   assertObjectReaderProject2
 } from "./chunk-v4jbb3rs.js";
@@ -80,7 +80,7 @@ import {
 } from "./chunk-h89wz928.js";
 import {
   DurableFileUploadSessions2
-} from "./chunk-3a338wrp.js";
+} from "./chunk-dp7yk20b.js";
 import {
   ExecutionStorageError2,
   prepareExecutionRecord2,
@@ -119,7 +119,7 @@ import {
   assertSourceStagedRow2,
   isExactStagingManifest2,
   sourceConflict2
-} from "./chunk-ht4a7mjg.js";
+} from "./chunk-g4rbm4a6.js";
 import {
   objectRefKey2,
   linkRefKey2,
@@ -146,7 +146,7 @@ import {
 } from "./chunk-mmagke4x.js";
 import {
   projectionRunObjectTypesVisible2
-} from "./chunk-qma80ych.js";
+} from "./chunk-hn2r7z41.js";
 import {
   ProjectionRunError2,
   assertProjectionRunNonEmpty2,
@@ -163,7 +163,9 @@ import {
   advanceProjectionTelemetry2,
   finishProjectionRunRecord2,
   failProjectionRunEnqueue2,
+  parseProjectionAttemptFailure2,
   canRequeueProjectionRunAfterEnqueueFailure2,
+  projectionRunSupersedes2,
   publicProjectionRunRecord2,
   createProjectionRunClaim2,
   staleProjectionRunExecution2,
@@ -172,7 +174,7 @@ import {
   assertProjectionMissingTarget2,
   requireTelemetryProjectionRun2,
   assertProjectionRunDurableExecution2
-} from "./chunk-znw0zvy4.js";
+} from "./chunk-4wn7bxxa.js";
 import {
   SyncRunError2,
   assertSyncRunExecution2
@@ -185,18 +187,7 @@ import {
   WorkflowRunError2,
   assertWorkflowRunExecution2,
   assertWorkflowAgentNodeRunExecution2
-} from "./chunk-gct3m1da.js";
-import {
-  actionSubjectsEqual2,
-  actionRunPhaseRecordsEqual2,
-  canRequeueActionRunAfterEnqueueFailure2,
-  isTerminalActionRun2,
-  StorageTransactionError2,
-  canRequeuePipelineRunAfterEnqueueFailure2,
-  canRequeueSyncRunAfterEnqueueFailure2,
-  createTransactionStorageProxy2,
-  throwNestedStorageTransaction2
-} from "./chunk-zdkcdshk.js";
+} from "./chunk-667x4drs.js";
 import {
   ShareGrantStorageError2,
   normalizeShareGrantCreate2,
@@ -215,13 +206,24 @@ import {
   normalizeRevokeShareSessionInput2,
   cloneShareSessionRecord2
 } from "./chunk-z8fx5cgb.js";
+import {
+  actionSubjectsEqual2,
+  actionRunPhaseRecordsEqual2,
+  canRequeueActionRunAfterEnqueueFailure2,
+  isTerminalActionRun2,
+  StorageTransactionError2,
+  canRequeuePipelineRunAfterEnqueueFailure2,
+  canRequeueSyncRunAfterEnqueueFailure2,
+  createTransactionStorageProxy2,
+  throwNestedStorageTransaction2
+} from "./chunk-zdkcdshk.js";
 import {
   ConnectorConnectionStorageError2,
   CONNECTOR_CONNECTION_RUN_FAILURE_CODES2
 } from "./chunk-2c4j899j.js";
 import {
   assertPinnedDatasetWatermark2
-} from "./chunk-3qpcrcj8.js";
+} from "./chunk-6aawea28.js";
 import {
   MaterializationValidationError2,
   MaterializationConflictError2
@@ -2572,10 +2574,22 @@ function isVectorProfileQuery2(query) {
     return isVectorProfileQuery2(query.input);
   if (query.kind !== "vector" || !query.profile)
     return false;
-  let input = query.input;
-  while (input.kind === "filter")
-    input = input.input;
-  return input.kind === "start" && !input.includeSubtypes;
+  return isVectorCandidateQuery(query.input);
+}
+function isVectorCandidateQuery(query) {
+  switch (query.kind) {
+    case "start":
+      return !query.includeSubtypes;
+    case "refs":
+      return true;
+    case "filter":
+    case "traverse":
+      return isVectorCandidateQuery(query.input);
+    case "set":
+      return query.inputs.every(isVectorCandidateQuery);
+    default:
+      return false;
+  }
 }
 
 // src/storage/objects/keys.ts
@@ -2741,6 +2755,7 @@ function vectorConfiguration(profile) {
     model: profile.model.modelId,
     representation: profile.model.definition.representation ?? { name: profile.model.modelId },
     dimensions: profile.model.definition.dimensions,
+    ...profile.model.definition.inputMode === "asymmetric" ? { inputMode: "asymmetric" } : {},
     metric: "cosine",
     precision: "float32",
     normalization: "l2-v1"
@@ -5701,7 +5716,7 @@ class InMemoryOntologySourceStorage {
       }
       const nonterminal = this.findRunCandidates(input.projectId, input.source.projectionId, input.execution.projectionRunId);
       if (nonterminal.length > 0) {
-        throw sourceConflict2(`Projection run '${input.execution.projectionRunId}' already has a nonterminal source materialization; reclaim it before beginning another.`);
+        throw sourceConflict2(`Projection run '${input.execution.projectionRunId}' already has a nonterminal source materialization; adopt it before beginning another.`);
       }
       const materialization = {
         projectId: input.projectId,
@@ -5785,72 +5800,105 @@ class InMemoryOntologySourceStorage {
       return active ? sourceMaterializationRecord(active) : null;
     });
   }
+  async adopt(input) {
+    return this.runRootOperation(async () => {
+      assertSourceProject2(input);
+      assertSourceExecutionIdentity2(input.execution.projectionRunId, input.execution.executionToken);
+      assertTimestamp2(input.adoptedAt, "Source adoptedAt");
+      await this.assertCurrentExecution(input);
+      const [candidate, ...others] = this.findRunCandidates(input.projectId, input.source.projectionId, input.execution.projectionRunId);
+      if (!candidate)
+        return null;
+      if (others.length > 0)
+        throw multipleRunCandidates(input.execution.projectionRunId);
+      const [key, materialization] = candidate;
+      const adopted = {
+        ...materialization,
+        executionToken: input.execution.executionToken,
+        updatedAt: input.adoptedAt > materialization.updatedAt ? input.adoptedAt : materialization.updatedAt
+      };
+      this.state.sourceMaterializations.set(key, adopted);
+      return {
+        record: sourceMaterializationRecord(adopted),
+        resumeStagingOrdinal: adopted.status === "ready" ? adopted.rootCount ?? 0 : Math.max(0, ...adopted.ordinalRoots.keys())
+      };
+    });
+  }
   async abandon(input) {
     return this.runRootOperation(async () => {
       assertSourceProject2(input);
       assertSourceExecutionIdentity2(input.execution.projectionRunId, input.execution.executionToken);
       assertTimestamp2(input.abandonedAt, "Source abandonedAt");
       await this.assertCurrentExecution(input);
-      return input.kind === "candidate" ? this.abandonCandidate(input) : this.abandonForReclaim(input);
+      return input.kind === "candidate" ? this.abandonCandidate(input) : this.abandonRunCandidate(input);
     });
   }
   async cleanupTerminal(input) {
     return this.runRootOperation(() => {
       assertNonblank(input.projectId, "Terminal source cleanup project id");
       assertTimestamp2(input.terminalBefore, "Terminal source cleanup cutoff");
-      if (!Number.isSafeInteger(input.limit) || input.limit <= 0) {
-        throw new MaterializationValidationError2("Terminal source cleanup limit must be a positive safe integer.");
-      }
+      assertCleanupLimit(input.limit);
       const candidates = [];
       for (const entry of this.state.sourceMaterializations.entries()) {
         const materialization = entry[1];
-        if (materialization.projectId !== input.projectId || materialization.status !== "superseded" && materialization.status !== "abandoned" || materialization.terminalAt === null || materialization.terminalAt >= input.terminalBefore) {
+        if (materialization.projectId !== input.projectId || materialization.status !== "superseded" || materialization.terminalAt === null || materialization.terminalAt >= input.terminalBefore) {
           continue;
         }
         if (materialization.roots.size > 0 && ![...materialization.roots.values()].some((root) => !root.active && root.retiredAt !== null && root.retiredAt < input.terminalBefore))
           continue;
         insertBounded(candidates, entry, input.limit, compareTerminalMaterializations);
       }
-      let remaining = input.limit;
-      let rowsDeleted = 0;
-      let materializationsDeleted = 0;
-      for (const [key, candidate] of candidates) {
+      return this.deleteRetiredRoots(candidates, input.limit, (root) => !root.active && root.retiredAt !== null && root.retiredAt < input.terminalBefore);
+    });
+  }
+  async purgeAbandoned(input) {
+    return this.runRootOperation(() => {
+      assertNonblank(input.projectId, "Abandoned source purge project id");
+      assertCleanupLimit(input.limit);
+      const abandoned = [...this.state.sourceMaterializations.entries()].filter(([, materialization]) => materialization.projectId === input.projectId && materialization.status === "abandoned").sort(compareTerminalMaterializations);
+      return this.deleteRetiredRoots(abandoned, input.limit, () => true);
+    });
+  }
+  deleteRetiredRoots(candidates, limit, retired) {
+    let remaining = limit;
+    let rowsDeleted = 0;
+    let materializationsDeleted = 0;
+    for (const [key, candidate] of candidates) {
+      if (remaining === 0)
+        break;
+      const current = this.state.sourceMaterializations.get(key);
+      if (current !== candidate)
+        continue;
+      current.rootOrdinals.clear();
+      current.ordinalRoots.clear();
+      for (const [rootKey, root] of current.roots) {
         if (remaining === 0)
           break;
-        const current = this.state.sourceMaterializations.get(key);
-        if (current !== candidate)
+        if (!retired(root))
           continue;
-        current.rootOrdinals.clear();
-        current.ordinalRoots.clear();
-        for (const [rootKey, root] of current.roots) {
+        for (const entityKey of root.entityKeys) {
           if (remaining === 0)
             break;
-          if (root.active || root.retiredAt === null || root.retiredAt >= input.terminalBefore)
-            continue;
-          for (const entityKey of root.entityKeys) {
-            if (remaining === 0)
-              break;
-            current.rowsByEntity.delete(entityKey);
-            root.entityKeys.delete(entityKey);
-            rowsDeleted += 1;
-            remaining -= 1;
-          }
-          if (root.entityKeys.size === 0 && remaining > 0) {
-            current.roots.delete(rootKey);
-            current.rootOrdinals.delete(rootKey);
-            current.ordinalRoots.delete(root.stagingOrdinal);
-            rowsDeleted += 1;
-            remaining -= 1;
-          }
+          current.rowsByEntity.delete(entityKey);
+          root.entityKeys.delete(entityKey);
+          rowsDeleted += 1;
+          remaining -= 1;
         }
-        if (current.roots.size === 0 && current.rowsByEntity.size === 0 && remaining > 0) {
-          this.state.sourceMaterializations.delete(key);
-          materializationsDeleted += 1;
+        if (root.entityKeys.size === 0 && remaining > 0) {
+          current.roots.delete(rootKey);
+          current.rootOrdinals.delete(rootKey);
+          current.ordinalRoots.delete(root.stagingOrdinal);
+          rowsDeleted += 1;
           remaining -= 1;
         }
       }
-      return { rowsDeleted, materializationsDeleted };
-    });
+      if (current.roots.size === 0 && current.rowsByEntity.size === 0 && remaining > 0) {
+        this.state.sourceMaterializations.delete(key);
+        materializationsDeleted += 1;
+        remaining -= 1;
+      }
+    }
+    return { rowsDeleted, materializationsDeleted };
   }
   async summarizeTerminal(input) {
     return this.runRootOperation(() => {
@@ -5898,14 +5946,10 @@ class InMemoryOntologySourceStorage {
     }
     return this.transitionToAbandoned(materialization, input.abandonedAt);
   }
-  abandonForReclaim(input) {
+  abandonRunCandidate(input) {
     const candidates = this.findRunCandidates(input.projectId, input.source.projectionId, input.execution.projectionRunId);
-    if (candidates.some(([, materialization]) => materialization.executionToken === input.execution.executionToken)) {
-      throw sourceConflict2(`Projection run '${input.execution.projectionRunId}' already has a source materialization owned by the current execution.`);
-    }
-    if (candidates.length > 1) {
-      throw sourceConflict2(`Projection run '${input.execution.projectionRunId}' has multiple nonterminal source materializations.`);
-    }
+    if (candidates.length > 1)
+      throw multipleRunCandidates(input.execution.projectionRunId);
     const candidate = candidates[0]?.[1];
     return candidate ? this.transitionToAbandoned(candidate, input.abandonedAt) : null;
   }
@@ -6058,6 +6102,14 @@ function assertNotBefore(value, minimum, label, minimumLabel) {
     throw new MaterializationValidationError2(`${label} cannot precede source ${minimumLabel}.`);
   }
 }
+function assertCleanupLimit(limit) {
+  if (!Number.isSafeInteger(limit) || limit <= 0) {
+    throw new MaterializationValidationError2("Terminal source cleanup limit must be a positive safe integer.");
+  }
+}
+function multipleRunCandidates(projectionRunId) {
+  return sourceConflict2(`Projection run '${projectionRunId}' has multiple nonterminal source materializations.`);
+}
 function compareTerminalMaterializations([, left], [, right]) {
   return (left.terminalAt ?? "").localeCompare(right.terminalAt ?? "") || left.source.projectionId.localeCompare(right.source.projectionId) || left.materializationId.localeCompare(right.materializationId);
 }
@@ -6613,6 +6665,9 @@ var runDirectly3 = async (run) => run();
 function projectionRunKey(projectId, id) {
   return JSON.stringify([projectId, id]);
 }
+function compareText(left, right) {
+  return left < right ? -1 : left > right ? 1 : 0;
+}
 function compareRuns2(a, b, order) {
   return compareStartedAt(a, b, order);
 }
@@ -6684,8 +6739,7 @@ class InMemoryProjectionRunStorage2 {
         attempt,
         executionToken,
         startedAt: existing.startedAt ?? new Date(input.startedAt ?? new Date),
-        finishedAt: undefined,
-        error: undefined
+        finishedAt: undefined
       };
       this.rows.set(key, structuredClone(record));
       return createProjectionRunClaim2(record);
@@ -6759,6 +6813,14 @@ class InMemoryProjectionRunStorage2 {
       return publicProjectionRunRecord2(next);
     });
   }
+  async recordAttemptFailure(input) {
+    return this.runRootOperation(() => {
+      const existing = this.requireExecution(input);
+      const next = { ...existing, error: parseProjectionAttemptFailure2(existing, input.error) };
+      this.rows.set(projectionRunKey(input.projectId, input.id), structuredClone(next));
+      return publicProjectionRunRecord2(next);
+    });
+  }
   async finish(input) {
     return this.runRootOperation(() => {
       const existing = this.requireExecution(input);
@@ -6795,9 +6857,18 @@ class InMemoryProjectionRunStorage2 {
       return { runs, hasMore: offset + runs.length < total, total };
     });
   }
+  async findSupersedingRun(input) {
+    return this.runRootOperation(() => {
+      const run = this.rows.get(projectionRunKey(input.projectId, input.id));
+      if (!run)
+        throw projectionRunNotFound2(input.projectId, input.id);
+      const newest = [...this.rows.values()].filter((candidate) => projectionRunSupersedes2(candidate, run)).sort((left, right) => compareText(right.identity.datasetVersion.createdAt, left.identity.datasetVersion.createdAt) || compareText(right.id, left.id))[0];
+      return newest ? publicProjectionRunRecord2(newest) : null;
+    });
+  }
   async listLatestByProjectionIds(input) {
     return this.runRootOperation(() => {
-      const runs = latestStartedAtByOwnerId([...this.rows.values()].filter((record) => record.projectId === input.projectId), input.projectionIds, (record) => record.identity.projectionId);
+      const runs = latestStartedAtByOwnerId([...this.rows.values()].filter((record) => record.projectId === input.projectId && record.status !== "superseded"), input.projectionIds, (record) => record.identity.projectionId);
       return { runs: runs.map(publicProjectionRunRecord2) };
     });
   }
@@ -8579,4 +8650,4 @@ var VECTOR_INDEXING_FAILURE_CODES2 = [
 ];
 export { InMemoryActionRunStorage2, AGENT_MESSAGE_CONTENT_VERSION2, InMemoryAgentStorage2, AiCostStorageError2, InMemoryAiCostStorage2, InMemoryAiLimitStorage2, InMemoryConnectorConnectionStorage2, InMemoryFileUploadSessions2, hasVectorProfile2, isVectorProfileQuery2, objectBatchKey2, linkBatchKey2, objectLinkCursor2, compareQueryScalarValues, queryScalarValuesEqual, MAX_VECTOR_K, vectorConfiguration, vectorSources, normalizeVector2, vectorSearchCandidateLimit2, PIPELINE_RUN_FAILURE_CODES2, InMemoryPipelineRunStorage2, InMemoryProjectionRunStorage2, InMemoryRulesStorage2, InMemoryShareGrantStorage2, InMemoryShareSessionStorage2, SYNC_RUN_FAILURE_CODES2, InMemorySyncRunStorage2, WEBHOOK_RUN_FAILURE_CODES2, canRetryWebhookRun2, InMemoryWebhookRunStorage2, WorkflowInterventionError2, InMemoryWorkflowInterventionStorage2, WORKFLOW_RUN_FAILURE_CODES2, InMemoryWorkflowRunStorage2, InMemoryWorkflowNodeRunStorage2, InMemoryWorkflowAgentNodeRunStorage2, InMemoryStorage2, isMigrationCapableStorage2, migrateStorage2, checkStorageSchema2, step2, defineMigrations2, runMigrationSet2, describeMigrationHistory2, VECTOR_INDEXING_FAILURE_CODES2 };
 
-//# debugId=1A5AE33B23C6729064756E2164756E21
+//# debugId=3E8E5105D8B7FDCD64756E2164756E21