@sixb/core 0.1.11 → 0.1.13

package/dist/{chunk-gqm76kse.js → chunk-gc226ten.js}

@@ -3,30 +3,32 @@ import {
   createSixbError2,
   toSixbFailure2,
   parseSixbFailure2
-} from "./chunk-f4w3yp4f.js";
+} from "./chunk-rzkr70gr.js";
 import {
   parseActionRunFailure2
-} from "./chunk-b19g04jk.js";
+} from "./chunk-xgptywp0.js";
 import {
   ActionRunError2,
   assertActionRunExecution2
-} from "./chunk-vsj3mdfj.js";
+} from "./chunk-fc5zfxy1.js";
+import {
+  paginate,
+  InMemoryAuthStorage2,
+  principalsEqual2
+} from "./chunk-9pfw47qx.js";
 import {
   ObjectReadLimitExceededError2,
   snapshotObjectReadExecutionLimits2,
   assertObjectReadFacetCount2,
   assertObjectReadOutputWithinLimit2
-} from "./chunk-dz5h08xv.js";
+} from "./chunk-rzcjp5m2.js";
 import {
   assertObjectReaderProject2
 } from "./chunk-v4jbb3rs.js";
-import {
-  paginate,
-  InMemoryAuthStorage2,
-  principalsEqual2
-} from "./chunk-g00bfdq6.js";
 import {
   AgentStorageError2,
+  transitionAgentThreadSandbox2,
+  snapshotAgentThreadSandboxParams2,
   assertConversationAgentRunSpec2,
   assertAgentRunExecution2,
   assertCreateSubagentRunInput2,
@@ -37,7 +39,7 @@ import {
   assertAgentContextCheckpointAnchors2,
   assertAgentContextCheckpointReplayState2,
   agentContextCheckpointMatchesCreateInput2
-} from "./chunk-7bs40fe1.js";
+} from "./chunk-69266efg.js";
 import {
   InMemoryAiUsageStorage2,
   buildAiAccountingOverview,
@@ -46,7 +48,7 @@ import {
   buildAiModelCallGroups,
   normalizeAiModelCallCostRecord2,
   aiModelCallCostMatchesUsage2
-} from "./chunk-g53f0e4j.js";
+} from "./chunk-xnx96gfy.js";
 import {
   AiLimitStorageError2,
   aiLimitCalendarMonth2,
@@ -73,38 +75,19 @@ import {
   cloneValidDate2
 } from "./chunk-jgwb25gc.js";
 import {
-  actionSubjectsEqual2,
-  actionRunPhaseRecordsEqual2,
-  canRequeueActionRunAfterEnqueueFailure2,
-  isTerminalActionRun2,
-  StorageTransactionError2,
-  createFileUploadId2,
-  principalKey,
-  isFileUploadSessionExpired,
-  shouldDeleteFileUploadSession,
-  isTerminalFileUploadSessionExpired,
-  canRequeuePipelineRunAfterEnqueueFailure2,
-  canRequeueSyncRunAfterEnqueueFailure2,
-  createTransactionStorageProxy2,
-  throwNestedStorageTransaction2
-} from "./chunk-8vj0rjgs.js";
+  isAbandonedFileUploadSession,
+  shouldDeleteFileUploadSession
+} from "./chunk-h89wz928.js";
+import {
+  DurableFileUploadSessions2
+} from "./chunk-n33e8dz8.js";
 import {
   ExecutionStorageError2,
   prepareExecutionRecord2,
   cloneExecutionRecord
-} from "./chunk-93csa55g.js";
-import {
-  objectRefKey2,
-  linkRefKey2,
-  projectionEntityKey2,
-  telemetryPointKey2,
-  objectRefSortKey2,
-  linkRefSortKey2,
-  linkScopeKey,
-  linkScopeSortKey2,
-  telemetryPointSortKey2
-} from "./chunk-c5rkjrgp.js";
+} from "./chunk-tw03bsmb.js";
 import {
+  sha256Canonical2,
   createEventId2,
   assertTimestamp2,
   invalidCorrelation2,
@@ -123,6 +106,9 @@ import {
   finishScopeAccumulator2,
   ProviderMaterializationTransactionLifecycle2,
   uniqueSorted2,
+  assertExpectedObjectRevision2,
+  assertExpectedLinkRevision2,
+  assertExpectedLinkScopeRevision2,
   sourceStageRoots2,
   sourceMaterializationIdentity2,
   assertSourceBeginInput2,
@@ -133,7 +119,18 @@ import {
   assertSourceStagedRow2,
   isExactStagingManifest2,
   sourceConflict2
-} from "./chunk-gqh45d2n.js";
+} from "./chunk-ht4a7mjg.js";
+import {
+  objectRefKey2,
+  linkRefKey2,
+  projectionEntityKey2,
+  telemetryPointKey2,
+  objectRefSortKey2,
+  linkRefSortKey2,
+  linkScopeKey,
+  linkScopeSortKey2,
+  telemetryPointSortKey2
+} from "./chunk-7ytf06d3.js";
 import {
   createStorageOperationScope2,
   createOperationScopedFacade2,
@@ -142,7 +139,7 @@ import {
   createOntologyOperationScope2,
   createObjectOperationScope2,
   createWorkflowRunOperationScope2
-} from "./chunk-z30bv4ga.js";
+} from "./chunk-mr60an99.js";
 import {
   PipelineRunError2,
   assertPipelineRunExecution2
@@ -175,7 +172,7 @@ import {
   assertProjectionMissingTarget2,
   requireTelemetryProjectionRun2,
   assertProjectionRunDurableExecution2
-} from "./chunk-358caqf5.js";
+} from "./chunk-znw0zvy4.js";
 import {
   SyncRunError2,
   assertSyncRunExecution2
@@ -188,7 +185,18 @@ import {
   WorkflowRunError2,
   assertWorkflowRunExecution2,
   assertWorkflowAgentNodeRunExecution2
-} from "./chunk-pr2h4bv4.js";
+} from "./chunk-darm7eeg.js";
+import {
+  actionSubjectsEqual2,
+  actionRunPhaseRecordsEqual2,
+  canRequeueActionRunAfterEnqueueFailure2,
+  isTerminalActionRun2,
+  StorageTransactionError2,
+  canRequeuePipelineRunAfterEnqueueFailure2,
+  canRequeueSyncRunAfterEnqueueFailure2,
+  createTransactionStorageProxy2,
+  throwNestedStorageTransaction2
+} from "./chunk-zdkcdshk.js";
 import {
   ShareGrantStorageError2,
   normalizeShareGrantCreate2,
@@ -213,11 +221,11 @@ import {
 } from "./chunk-2c4j899j.js";
 import {
   assertPinnedDatasetWatermark2
-} from "./chunk-wjasrj67.js";
+} from "./chunk-3qpcrcj8.js";
 import {
   MaterializationValidationError2,
   MaterializationConflictError2
-} from "./chunk-yv79ncbv.js";
+} from "./chunk-96yw3pwd.js";
 import {
   AGENT_RUN_FAILURE_CODES2
 } from "./chunk-98cw09sw.js";
@@ -517,7 +525,7 @@ function normalizeFailure(failure) {
   return failure ? parseSixbFailure2(failure, AGENT_RUN_FAILURE_CODES2) : undefined;
 }
 function key(projectId, id) {
-  return `${projectId}:${id}`;
+  return JSON.stringify([projectId, id]);
 }
 function clone(value) {
   return structuredClone(value);
@@ -544,7 +552,18 @@ class InMemoryAgentThreadStore {
   constructor(state) {
     this.state = state;
   }
+  async transitionSandbox(input) {
+    const threadKey = key(input.projectId, input.id);
+    const thread = this.state.threads.get(threadKey) ?? null;
+    const run = input.action === "recreate" ? null : this.state.runs.get(key(input.projectId, input.runId)) ?? null;
+    const sandboxState = transitionAgentThreadSandbox2(thread, run, input);
+    if (!thread)
+      throw new AgentStorageError2("thread_not_found", "[Sixb] Thread not found.");
+    this.state.threads.set(threadKey, { ...thread, sandboxState: clone(sandboxState) });
+    return clone(sandboxState);
+  }
   async create(input) {
+    const sandboxParams = input.sandboxParams === undefined ? undefined : snapshotAgentThreadSandboxParams2(input.sandboxParams);
     const threadKey = key(input.projectId, input.id);
     if (this.state.threads.has(threadKey)) {
       throw new AgentStorageError2("duplicate_id", `[Sixb] Agent thread '${input.id}' already exists for project '${input.projectId}'.`);
@@ -554,6 +573,7 @@ class InMemoryAgentThreadStore {
       id: input.id,
       projectId: input.projectId,
       ownerPrincipal: clone(input.ownerPrincipal),
+      ...sandboxParams === undefined ? {} : { sandboxParams },
       ...input.title === undefined ? {} : { title: input.title },
       status: input.status ?? "active",
       activeRunId: null,
@@ -2410,18 +2430,18 @@ function applyStagedCredentials(record, staged, now, input) {
     updatedAt: now
   };
 }
-// src/storage/file-upload-sessions/errors.ts
-class FileUploadSessionError2 extends Error {
-  reason;
-  name = "FileUploadSessionError";
-  constructor(reason, message) {
-    super(message);
-    this.reason = reason;
-  }
-}
 // src/storage/file-upload-sessions/in-memory.ts
-class InMemoryFileUploadSessions2 {
-  sessionsById = new Map;
+class InMemoryFileUploadSessions2 extends DurableFileUploadSessions2 {
+  sessionsById;
+  constructor() {
+    const sessionsById = new Map;
+    super(new InMemoryFileUploadSessionBackend(sessionsById));
+    this.sessionsById = sessionsById;
+  }
+  async create(input) {
+    await this.cleanupExpired();
+    return super.create(input);
+  }
   snapshot() {
     return structuredClone(this.sessionsById);
   }
@@ -2431,86 +2451,50 @@ class InMemoryFileUploadSessions2 {
       this.sessionsById.set(id, structuredClone(session));
     }
   }
-  async create(input) {
-    await this.cleanupExpired();
-    const session = {
-      id: input.id ?? createFileUploadId2(),
-      projectId: input.projectId,
-      principalKey: principalKey(input.principal),
-      strategy: input.strategy,
-      status: "pending",
-      ...input.fileName === undefined ? {} : { fileName: input.fileName },
-      ...input.mediaType === undefined ? {} : { mediaType: input.mediaType },
-      ...input.logicalPath === undefined ? {} : { logicalPath: input.logicalPath },
-      ...input.expectedSizeBytes === undefined ? {} : { expectedSizeBytes: input.expectedSizeBytes },
-      ...input.expectedDigest === undefined ? {} : { expectedDigest: input.expectedDigest },
-      ...input.providerUpload === undefined ? {} : { providerUpload: input.providerUpload },
-      signedParts: [],
-      createdAt: new Date,
-      expiresAt: input.expiresAt
-    };
-    this.sessionsById.set(session.id, session);
-    return session;
+}
+
+class InMemoryFileUploadSessionBackend {
+  persistence;
+  tail = Promise.resolve();
+  constructor(sessionsById) {
+    this.persistence = new InMemoryFileUploadSessionPersistence(sessionsById);
+  }
+  read(run) {
+    return run(this.persistence);
+  }
+  transaction(run) {
+    const result = this.tail.then(() => run(this.persistence));
+    this.tail = result.catch(() => {
+      return;
+    });
+    return result;
   }
-  async getForPrincipal(uploadId, principal) {
-    const session = this.sessionsById.get(uploadId);
-    if (!session || session.principalKey !== principalKey(principal)) {
-      throw new FileUploadSessionError2("not_found", "File upload session not found.");
-    }
-    const nowMs = Date.now();
-    if (isFileUploadSessionExpired(session, nowMs)) {
-      this.sessionsById.delete(uploadId);
-      throw new FileUploadSessionError2("expired", "File upload session has expired.");
-    }
-    if (isTerminalFileUploadSessionExpired(session, nowMs)) {
-      this.sessionsById.delete(uploadId);
-      throw new FileUploadSessionError2("not_found", "File upload session not found.");
-    }
-    return session;
+}
+
+class InMemoryFileUploadSessionPersistence {
+  sessionsById;
+  constructor(sessionsById) {
+    this.sessionsById = sessionsById;
   }
-  async markUploaded(uploadId, fileRef) {
-    const session = this.requirePending(uploadId);
-    const updated = {
-      ...session,
-      fileRef
-    };
-    this.sessionsById.set(uploadId, updated);
-    return updated;
+  async now() {
+    return new Date;
   }
-  async addSignedPart(uploadId, part) {
-    const session = this.requirePending(uploadId);
-    const updated = {
-      ...session,
-      signedParts: [
-        ...session.signedParts.filter((candidate) => candidate.partNumber !== part.partNumber),
-        part
-      ].sort((left, right) => left.partNumber - right.partNumber)
-    };
-    this.sessionsById.set(uploadId, updated);
-    return updated;
+  async insert(session) {
+    if (this.sessionsById.has(session.id))
+      return false;
+    this.sessionsById.set(session.id, session);
+    return true;
   }
-  async complete(uploadId, fileRef) {
-    const session = this.requirePending(uploadId);
-    const updated = {
-      ...session,
-      status: "completed",
-      fileRef,
-      completedAt: new Date
-    };
-    this.sessionsById.set(uploadId, updated);
-    return updated;
+  async get(uploadId) {
+    return this.sessionsById.get(uploadId) ?? null;
   }
-  async abort(uploadId) {
-    const session = this.requirePending(uploadId);
-    const updated = {
-      ...session,
-      status: "aborted",
-      abortedAt: new Date
-    };
-    this.sessionsById.set(uploadId, updated);
-    return updated;
+  async update(session) {
+    this.sessionsById.set(session.id, session);
   }
-  async cleanupExpired(now = new Date) {
+  async listAbandoned(input) {
+    return [...this.sessionsById.values()].filter((session) => session.projectId === input.projectId && isAbandonedFileUploadSession(session, input.now.getTime())).sort((left, right) => left.expiresAt.getTime() - right.expiresAt.getTime()).slice(0, input.limit);
+  }
+  async deleteReapable(now) {
     let deleted = 0;
     for (const [id, session] of this.sessionsById) {
       if (shouldDeleteFileUploadSession(session, now.getTime())) {
@@ -2520,16 +2504,6 @@ class InMemoryFileUploadSessions2 {
     }
     return deleted;
   }
-  requirePending(uploadId) {
-    const session = this.sessionsById.get(uploadId);
-    if (!session) {
-      throw new FileUploadSessionError2("not_found", "File upload session not found.");
-    }
-    if (session.status !== "pending") {
-      throw new FileUploadSessionError2(session.status === "completed" ? "already_completed" : "already_aborted", `File upload session is already ${session.status}.`);
-    }
-    return session;
-  }
 }
 // src/storage/in-memory/index.ts
 import { AsyncLocalStorage } from "async_hooks";
@@ -2585,6 +2559,25 @@ class InMemoryExecutionStorage {
   }
 }
 
+// src/objects/vectors/query.ts
+function hasVectorProfile2(query) {
+  if (query.kind === "vector")
+    return true;
+  if (query.kind === "set")
+    return query.inputs.some(hasVectorProfile2);
+  return "input" in query && hasVectorProfile2(query.input);
+}
+function isVectorProfileQuery2(query) {
+  if (query.kind === "limit" || query.kind === "project")
+    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;
+}
+
 // src/storage/objects/keys.ts
 function objectBatchKey2(objectTypeId, primaryId) {
   return JSON.stringify([objectTypeId, primaryId]);
@@ -2665,6 +2658,8 @@ function compareQueryScalarValues(left, right, scalarKind) {
     case "date":
     case "timestamp":
       return compareTemporalValues(left, right);
+    case "userRef":
+      return Number.NaN;
   }
 }
 function queryScalarValuesEqual(left, right, scalarKind) {
@@ -2676,10 +2671,20 @@ function queryScalarValuesEqual(left, right, scalarKind) {
     const comparison = compareTemporalValues(left, right);
     return !Number.isNaN(comparison) && comparison === 0;
   }
+  if (scalarKind === "userRef")
+    return userRefsEqual(left, right);
   if (scalarKind !== undefined)
     return Object.is(left, right);
   return runtimeValuesEqual(left, right);
 }
+function userRefsEqual(left, right) {
+  if (left === null || right === null)
+    return left === right;
+  return isRecord(left) && isRecord(right) && left.type === right.type && typeof left.id === "string" && left.id === right.id;
+}
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
 function compareRuntimeValues(left, right) {
   if (typeof left === "number" && typeof right === "number")
     return left - right;
@@ -2725,6 +2730,54 @@ function compareStrings2(left, right) {
   return 0;
 }
 
+// src/objects/vectors/profile.ts
+var MAX_VECTOR_K = 1000;
+var VECTOR_INPUT_VERSION = 1;
+function vectorConfiguration(profile) {
+  return sha256Canonical2({
+    format: VECTOR_INPUT_VERSION,
+    sources: [...profile.source],
+    provider: profile.model.providerId,
+    model: profile.model.modelId,
+    representation: profile.model.definition.representation ?? { name: profile.model.modelId },
+    dimensions: profile.model.definition.dimensions,
+    metric: "cosine",
+    precision: "float32",
+    normalization: "l2-v1"
+  });
+}
+function vectorSources(source, properties) {
+  const values = Object.create(null);
+  for (const key of source) {
+    const value = properties[key];
+    if (value !== undefined && value !== null && typeof value !== "string") {
+      throw new MaterializationValidationError2(`Vector source must be text: ${key}`);
+    }
+    values[key] = typeof value === "string" ? value : null;
+  }
+  const text = JSON.stringify(source.map((key) => [key, values[key]]));
+  return { text, sourceFingerprint: sha256Canonical2(text) };
+}
+function normalizeVector2(values, dimensions) {
+  if (!Array.isArray(values) || values.length !== dimensions) {
+    throw new MaterializationValidationError2(`Vector dimension mismatch; expected ${dimensions}`);
+  }
+  const normalized = Array.from(values, (value) => {
+    if (typeof value !== "number" || !Number.isFinite(value) || !Number.isFinite(Math.fround(value))) {
+      throw new MaterializationValidationError2("Vector values must be finite float32 numbers.");
+    }
+    return Math.fround(value);
+  });
+  if (!normalized.some((value) => value !== 0)) {
+    throw new MaterializationValidationError2("Cosine search requires a nonzero vector.");
+  }
+  const norm = Math.hypot(...normalized);
+  return Object.freeze(normalized.map((value) => Math.fround(value / norm)));
+}
+function vectorSearchCandidateLimit2(dimensions) {
+  return Math.min(1e4, Math.floor(16000000 / dimensions));
+}
+
 // src/storage/objects/in-memory/query.ts
 var IN_MEMORY_OBJECT_QUERY_CAPABILITIES = {
   queryObjects: true,
@@ -2779,7 +2832,8 @@ var IN_MEMORY_OBJECT_QUERY_CAPABILITIES = {
     double: { equality: true, ordering: true },
     decimal: { equality: true, ordering: true },
     date: { equality: true, ordering: true },
-    timestamp: { equality: true, ordering: true }
+    timestamp: { equality: true, ordering: true },
+    userRef: { equality: true }
   },
   limits: {
     totalCount: true,
@@ -2812,17 +2866,23 @@ function evaluateObjectQuery(query, source) {
       return completeEvaluation(scoredEntries);
     }
     case "vector": {
+      if (typeof query.vector === "string")
+        throw new Error("[Sixb] Vector search text must be embedded before storage execution.");
+      const vector = query.vector;
       const input = evaluateObjectQuery(query.input, source);
       const scoredEntries = input.entries.flatMap((entry) => {
-        const score = vectorSimilarity(entry.row.properties[query.propertyId], query.vector);
-        return score === null ? [] : [{ ...entry, score: entry.score + score }];
+        const stored = source.getVector?.(entry.row, query.profile);
+        if (!stored || !query.configuration || stored.configuration !== query.configuration || vectorSources(stored.source, entry.row.properties).sourceFingerprint !== stored.sourceFingerprint)
+          return [];
+        const score = vectorSimilarity(stored.values, vector);
+        return score === null ? [] : [{ ...entry, score: entry.score + Math.max(-1, Math.min(1, score)) }];
       });
-      scoredEntries.sort(compareEntriesByRelevance);
+      scoredEntries.sort((a, b) => b.score - a.score || Buffer.compare(Buffer.from(a.row.objectTypeId), Buffer.from(b.row.objectTypeId)) || Buffer.compare(Buffer.from(a.row.primaryId), Buffer.from(b.row.primaryId)));
       const limit = Math.max(0, query.k);
       return {
         entries: scoredEntries.slice(0, limit),
-        total: scoredEntries.length,
-        hasMore: limit < scoredEntries.length
+        total: Math.min(limit, scoredEntries.length),
+        hasMore: false
       };
     }
     case "traverse": {
@@ -3000,15 +3060,15 @@ function matchesPredicate(row, predicate) {
       return predicate.value ? exists : !exists;
     }
     case "contains":
-      return containsValue(row.properties[predicate.propertyId], predicate.value);
+      return containsValue(row.properties[predicate.propertyId], predicate.value, predicate.scalarKind);
   }
 }
-function containsValue(actual, expected) {
+function containsValue(actual, expected, itemScalarKind) {
   if (typeof actual === "string" && typeof expected === "string") {
     return actual.includes(expected);
   }
   if (Array.isArray(actual)) {
-    return actual.some((item) => queryScalarValuesEqual(item, expected));
+    return actual.some((item) => queryScalarValuesEqual(item, expected, itemScalarKind));
   }
   if (isPlainObject(actual) && typeof expected === "string") {
     return Object.hasOwn(actual, expected);
@@ -3101,9 +3161,6 @@ function compareSortField(left, right, field) {
     return 0;
   return field.direction === "desc" ? -comparison : comparison;
 }
-function compareEntriesByRelevance(left, right) {
-  return right.score - left.score || rowIdentityKey(left.row).localeCompare(rowIdentityKey(right.row));
-}
 function projectRow(row, properties) {
   const projected = {};
   for (const propertyId of properties) {
@@ -3346,9 +3403,10 @@ function resolveSelectedReadUniverse(source, plan, limits) {
     }
     links.set(key, redactLinkRow(selected.row, selected.propertyIds));
   }
-  return createReadUniverse(source.projectId, objects, links, objectProperties);
+  return createReadUniverse(source, objects, links, objectProperties);
 }
-function createReadUniverse(projectId, objects, links, objectProperties) {
+function createReadUniverse(source, objects, links, objectProperties) {
+  const projectId = source.projectId;
   const linksBySource = new Map;
   for (const link of links.values()) {
     const key = sourceLinkBucketKey(link.projectId, link.sourceTypeId, link.sourceId);
@@ -3362,6 +3420,13 @@ function createReadUniverse(projectId, objects, links, objectProperties) {
     links,
     linksBySource,
     objectProperties,
+    getVector: (ref, profile) => {
+      const key = rowIdentityKeyParts(ref.objectTypeId, ref.primaryId);
+      if (!objects.has(key))
+        return;
+      const value = source.getVector?.(ref, profile);
+      return value?.source.every((id) => objectProperties.get(key)?.has(id)) ? value : undefined;
+    },
     objectsOfType: (objectTypeId) => [...objects.values()].filter((row) => row.objectTypeId === objectTypeId),
     getObject: (objectTypeId, primaryId) => objects.get(rowIdentityKeyParts(objectTypeId, primaryId)),
     outgoingLinks: (objectTypeId, primaryId) => linksBySource.get(sourceLinkBucketKey(projectId, objectTypeId, primaryId)) ?? [],
@@ -3425,7 +3490,10 @@ function createInMemorySelectedReader(source, params, queryCapabilities) {
       const universe = resolveSelectedReadUniverse(source, plan, limits);
       const result = evaluateObjectQuery(input.query, universe);
       return visible({
-        objects: result.entries.map((entry) => structuredClone(entry.row)),
+        objects: result.entries.map((entry) => ({
+          ...structuredClone(entry.row),
+          ...hasVectorProfile2(input.query) ? { score: entry.score } : {}
+        })),
         hasMore: result.hasMore,
         nextPageToken: result.nextPageToken,
         ...input.includeTotal === false ? {} : { total: result.total }
@@ -3553,8 +3621,12 @@ function getInMemoryObjectMaterializerAdapter(storage) {
 class InMemoryObjectStorage {
   rows = new Map;
   links = new Map;
+  vectorReader;
   constructor() {
     materializerAdapters.set(this, {
+      setVectorReader: (reader) => {
+        this.vectorReader = reader;
+      },
       getExactObjectRow: (projectId, objectTypeId, primaryId) => this.getExactObjectRow(projectId, objectTypeId, primaryId),
       getExactLinkRow: (projectId, ref) => this.getExactLinkRow(projectId, ref),
       applyExactObject: (row, projectId) => this.applyExactObject(row, projectId),
@@ -3651,6 +3723,7 @@ class InMemoryObjectStorage {
   readSource(projectId) {
     return {
       projectId,
+      getVector: (ref, profile) => this.vectorReader?.(projectId, ref, profile),
       objectsOfType: (objectTypeId) => [
         ...this.rows.get(objectRowKey(projectId, objectTypeId))?.values() ?? []
       ],
@@ -3662,7 +3735,10 @@ class InMemoryObjectStorage {
   async queryObjects(params) {
     const result = evaluateObjectQuery(params.query, this.readSource(params.projectId));
     return {
-      objects: result.entries.map((entry) => entry.row),
+      objects: result.entries.map((entry) => ({
+        ...entry.row,
+        ...hasVectorProfile2(params.query) ? { score: entry.score } : {}
+      })),
       hasMore: result.hasMore,
       nextPageToken: result.nextPageToken,
       ...params.includeTotal === false ? {} : { total: result.total }
@@ -3854,6 +3930,8 @@ function* allLinkRows(buckets) {
 // src/storage/ontology/in-memory/shared-state.ts
 function createInMemoryOntologyState() {
   return {
+    vectors: new Map,
+    vectorIndexing: new Map,
     commitsById: new Map,
     commitIdByIdempotency: new Map,
     commitIdByOrigin: new Map,
@@ -4696,9 +4774,7 @@ class InMemoryOntologyMaterializationStorage {
       const key = linkScopeSortKey2(expected.source, expected.linkId);
       const current = expectedScopeRevisions.get(key) ?? this.computeEffectiveLinkScope(input.commit.projectId, expected.source, expected.linkId);
       expectedScopeRevisions.set(key, current);
-      if (current.fingerprint !== expected.fingerprint) {
-        throw new MaterializationConflictError2("effective-state", `Expected link scope changed for ${expected.source.objectTypeId}:${expected.source.primaryId}.${expected.linkId}.`);
-      }
+      assertExpectedLinkScopeRevision2(current.fingerprint, expected);
     }
     for (const expected of input.expected.points)
       this.assertPoint(expected, input.commit.projectId);
@@ -5140,6 +5216,12 @@ class InMemoryOntologyMaterializationStorage {
     this.releaseSession(session);
     return { commit: structuredClone(record) };
   }
+  assertVectorSession(session, projectId, commitId) {
+    const active = this.requireSession(session);
+    if (active.header.commit.projectId !== projectId || commitId !== undefined && active.header.commit.id !== commitId) {
+      throw new MaterializationValidationError2("Vector mutation does not belong to this materialization session.");
+    }
+  }
   requireSession(session) {
     const value = this.sessions.get(session.providerToken);
     if (!value || !value.active || !this.getTransactionToken() || this.getTransactionToken() !== value.transactionToken) {
@@ -5279,14 +5361,7 @@ class InMemoryOntologyMaterializationStorage {
   }
   assertObjectSync(expected, projectId) {
     const row = getInMemoryObjectMaterializerAdapter(this.objects).getExactObjectRow(projectId, expected.ref.objectTypeId, expected.ref.primaryId);
-    if (!expected.exists) {
-      if (row)
-        throw new MaterializationConflictError2("effective-state", `Expected object ${objectRefKey2(expected.ref)} to be absent.`);
-      return;
-    }
-    if (!row || row.version !== expected.version || row.lastCommitId !== expected.lastCommitId) {
-      throw new MaterializationConflictError2("effective-state", `Expected object ${objectRefKey2(expected.ref)} changed.`);
-    }
+    assertExpectedObjectRevision2(row ?? null, expected);
   }
   async assertLink(expected, projectId) {
     this.assertLinkSync(expected, projectId);
@@ -5299,14 +5374,7 @@ class InMemoryOntologyMaterializationStorage {
       targetTypeId: expected.ref.target.objectTypeId,
       targetId: expected.ref.target.primaryId
     });
-    if (!expected.exists) {
-      if (row)
-        throw new MaterializationConflictError2("effective-state", `Expected link ${linkRefKey2(expected.ref)} to be absent.`);
-      return;
-    }
-    if (!row || row.lastCommitId !== expected.lastCommitId) {
-      throw new MaterializationConflictError2("effective-state", `Expected link ${linkRefKey2(expected.ref)} changed.`);
-    }
+    assertExpectedLinkRevision2(row?.lastCommitId, expected);
   }
   assertPoint(expected, projectId) {
     const point = getInMemoryTimeseriesMaterializerAdapter(this.timeseries).getExactPoint(projectId, expected.series, expected.at);
@@ -6000,9 +6068,188 @@ function registerInMemoryOntologyStorageTestingAdapter(storage, adapter) {
   testingAdapters.set(storage, adapter);
 }
 
+// src/storage/ontology/in-memory/vector-indexing.ts
+class InMemoryVectorIndexingStorage {
+  state;
+  assertSession;
+  run;
+  constructor(state, assertSession, run) {
+    this.state = state;
+    this.assertSession = assertSession;
+    this.run = run;
+  }
+  async schedule(input) {
+    this.assertSession(input.session, input.projectId);
+    if (input.deleted.length) {
+      const deleted = new Set(input.deleted.map((ref) => JSON.stringify([ref.objectTypeId, ref.primaryId])));
+      for (const [key, work] of this.state) {
+        if (work.projectId === input.projectId && deleted.has(JSON.stringify([work.ref.objectTypeId, work.ref.primaryId])))
+          this.state.delete(key);
+      }
+    }
+    for (const request of input.requests) {
+      const key = JSON.stringify([
+        input.projectId,
+        request.ref.objectTypeId,
+        request.ref.primaryId,
+        request.profile
+      ]);
+      this.state.set(key, structuredClone({
+        ...request,
+        projectId: input.projectId,
+        status: "pending",
+        availableAt: input.availableAt,
+        dispatchAt: input.availableAt
+      }));
+    }
+  }
+  async complete(input) {
+    this.assertSession(input.session, input.projectId);
+    for (const entry of input.entries) {
+      const key = JSON.stringify([
+        input.projectId,
+        entry.ref.objectTypeId,
+        entry.ref.primaryId,
+        entry.profile
+      ]);
+      const work = this.state.get(key);
+      if (work?.configuration === entry.configuration && work.sourceFingerprint === entry.sourceFingerprint) {
+        this.state.delete(key);
+      }
+    }
+  }
+  async dispatched(input) {
+    await this.run(() => {
+      for (const [key, work] of this.state)
+        if (work.projectId === input.projectId && input.ids.includes(work.id))
+          this.state.set(key, { ...work, dispatchAt: input.nextDispatchAt });
+    });
+  }
+  async get(input) {
+    return this.run(() => structuredClone([...this.state.values()].find((work) => work.projectId === input.projectId && work.id === input.id) ?? null));
+  }
+  async getBatch(input) {
+    return this.run(() => structuredClone([...this.state.values()].filter((work) => work.projectId === input.projectId && work.batchId === input.batchId).sort((a, b) => a.id.localeCompare(b.id))));
+  }
+  async getBatchMember(input) {
+    return this.run(() => {
+      const work = this.state.get(JSON.stringify([
+        input.projectId,
+        input.ref.objectTypeId,
+        input.ref.primaryId,
+        input.profile
+      ]));
+      return work?.batchId === input.batchId ? structuredClone(work) : null;
+    });
+  }
+  async updateBatch(input) {
+    return this.run(() => {
+      const updates = new Map(input.updates.map((update) => [update.id, update]));
+      const matches = [...this.state.entries()].filter(([, work]) => work.projectId === input.projectId && updates.get(work.id)?.expectedStatus === work.status);
+      if (input.requireAll && matches.length !== input.updates.length)
+        return false;
+      for (const [key, work] of matches) {
+        const update = updates.get(work.id);
+        this.state.set(key, structuredClone({
+          ...work,
+          status: update.status,
+          availableAt: update.availableAt,
+          values: update.values ?? work.values,
+          error: update.error
+        }));
+      }
+      return true;
+    });
+  }
+  async listDue(input) {
+    return this.run(() => [...this.state.values()].filter((work) => work.projectId === input.projectId && work.status !== "failed" && work.dispatchAt <= input.now).sort((a, b) => a.dispatchAt.localeCompare(b.dispatchAt) || a.id.localeCompare(b.id)).slice(0, input.limit).map(({ values: _values, ...work }) => structuredClone(work)));
+  }
+  async update(input) {
+    return this.run(() => {
+      for (const [key, work] of this.state) {
+        if (work.projectId !== input.projectId || work.id !== input.id || work.status !== input.expectedStatus)
+          continue;
+        this.state.set(key, structuredClone({
+          ...work,
+          status: input.status,
+          availableAt: input.availableAt,
+          values: input.values ?? work.values,
+          error: input.error
+        }));
+        return true;
+      }
+      return false;
+    });
+  }
+  async remove(input) {
+    await this.run(() => {
+      for (const [key, work] of this.state)
+        if (work.projectId === input.projectId && work.id === input.id)
+          this.state.delete(key);
+    });
+  }
+}
+
+// src/storage/ontology/in-memory/vectors.ts
+function vectorObjectKey(projectId, ref) {
+  return JSON.stringify([projectId, ref.objectTypeId, ref.primaryId]);
+}
+
+class InMemoryOntologyVectorStorage {
+  state;
+  assertSession;
+  runRootOperation;
+  constructor(state, assertSession, runRootOperation) {
+    this.state = state;
+    this.assertSession = assertSession;
+    this.runRootOperation = runRootOperation;
+  }
+  async list(input) {
+    return this.listBatch({ projectId: input.projectId, refs: [input.ref] });
+  }
+  async listBatch(input) {
+    return this.runRootOperation(() => [...new Set(input.refs.map((ref) => vectorObjectKey(input.projectId, ref)))].flatMap((key) => [...this.state.get(key)?.values() ?? []].map(({ values: _values, ...metadata }) => structuredClone(metadata))));
+  }
+  async removeBatch(input) {
+    this.assertSession(input.session, input.projectId);
+    for (const entry of input.entries) {
+      await this.remove({ session: input.session, projectId: input.projectId, ...entry });
+    }
+  }
+  async write(input) {
+    this.assertSession(input.session, input.projectId, input.value.lastCommitId);
+    const key = vectorObjectKey(input.projectId, input.value.ref);
+    const profiles = this.state.get(key) ?? new Map;
+    this.assertRevision(profiles.get(input.value.profile), input.expectedCommitId);
+    profiles.set(input.value.profile, structuredClone(input.value));
+    this.state.set(key, profiles);
+  }
+  async writeBatch(input) {
+    for (const entry of input.entries) {
+      await this.write({ session: input.session, projectId: input.projectId, ...entry });
+    }
+  }
+  async remove(input) {
+    this.assertSession(input.session, input.projectId);
+    const key = vectorObjectKey(input.projectId, input.ref);
+    const profiles = this.state.get(key);
+    this.assertRevision(profiles?.get(input.profile), input.expectedCommitId);
+    profiles?.delete(input.profile);
+    if (profiles?.size === 0)
+      this.state.delete(key);
+  }
+  assertRevision(current, expected) {
+    if ((current?.lastCommitId ?? null) !== expected) {
+      throw new MaterializationConflictError2("effective-state", "Vector changed since it was prepared.");
+    }
+  }
+}
+
 // src/storage/ontology/in-memory/index.ts
 class InMemoryOntologyStorage {
   state = createInMemoryOntologyState();
+  vectorIndexing;
+  vectors;
   commits;
   sources;
   materializations;
@@ -6013,6 +6260,9 @@ class InMemoryOntologyStorage {
     snapshot: () => this.snapshot()
   };
   constructor(objects, timeseries, options) {
+    this.vectorIndexing = new InMemoryVectorIndexingStorage(this.state.vectorIndexing, (session, projectId) => this.materializations.assertVectorSession(session, projectId), options.runRootOperation);
+    this.vectors = new InMemoryOntologyVectorStorage(this.state.vectors, (session, projectId, commitId) => this.materializations.assertVectorSession(session, projectId, commitId), options.runRootOperation);
+    getInMemoryObjectMaterializerAdapter(objects).setVectorReader((projectId, ref, profile) => this.state.vectors.get(vectorObjectKey(projectId, ref))?.get(profile));
     this.commits = new InMemoryOntologyCommitStorage(this.state, options.runRootOperation);
     this.sources = new InMemoryOntologySourceStorage(this.state, options.runRootOperation, options.assertSourceMaterializationExecution);
     this.outbox = new InMemoryOntologyOutboxStorage(this.state, options.runRootOperation);
@@ -8320,6 +8570,13 @@ function assertAppliedPrefix(migrations, rows) {
   }
   return [...rows].sort((a, b) => a.version - b.version);
 }
-export { InMemoryActionRunStorage2, AGENT_MESSAGE_CONTENT_VERSION2, InMemoryAgentStorage2, AiCostStorageError2, InMemoryAiCostStorage2, InMemoryAiLimitStorage2, InMemoryConnectorConnectionStorage2, FileUploadSessionError2, InMemoryFileUploadSessions2, objectBatchKey2, linkBatchKey2, objectLinkCursor2, compareQueryScalarValues, queryScalarValuesEqual, 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 };
+// src/storage/ontology/vector-indexing.ts
+var VECTOR_INDEXING_FAILURE_CODES2 = [
+  "vector.model_unavailable",
+  "vector.response_invalid",
+  "vector.outcome_unknown",
+  "internal.unexpected"
+];
+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=1AE2F63489E4A4EB64756E2164756E21
+//# debugId=1A5AE33B23C6729064756E2164756E21