@sixb/core 0.1.11 → 0.1.12

package/src/storage/executions/validation.ts

@@ -1,5 +1,6 @@
 import { isDeepStrictEqual } from "node:util"
 import { normalizeRequesterGroupIds, snapshotRequesterGroupIds } from "../../auth/attribution"
+import { kernelOperationId } from "../../execution/kernel-operation"
 import type {
   AuthorizablePrincipal,
   AuthorizationRef,
@@ -134,6 +135,9 @@ function assertExecutor(executor: DurableExecutionExecutor): void {
 
 function assertSource(source: DurableExecutionSource): void {
   switch (source.type) {
+    case "ontologyCommit":
+      assertNonBlank(source.commitId, "Execution source commit id")
+      return
     case "http":
       assertNonBlank(source.requestId, "Execution source request id")
       return
@@ -427,10 +431,10 @@ function assertPrincipal(principal: AuthorizablePrincipal, label: string): void
 }
 
 function assertKernelOperation(operation: KernelOperation, label: string): void {
-  if (operation.type !== "ontology.recover") {
+  if (operation.type !== "ontology.recover" && operation.type !== "ontology.indexVectors") {
     invalid(`${label} has unsupported type '${String((operation as { type?: unknown }).type)}'.`)
   }
-  assertNonBlank(operation.recoveryId, `${label} recovery id`)
+  assertNonBlank(kernelOperationId(operation), `${label} operation id`)
 }
 
 function assertTrustedPrimitiveKind(value: string, label: string): void {
@@ -459,7 +463,7 @@ function principalsEqual(
 }
 
 function kernelOperationsEqual(left: KernelOperation, right: KernelOperation): boolean {
-  return left.type === right.type && left.recoveryId === right.recoveryId
+  return left.type === right.type && kernelOperationId(left) === kernelOperationId(right)
 }
 
 function invalid(message: string): never {

package/src/storage/index.ts

@@ -75,6 +75,8 @@ export type {
   AgentStorage,
   AgentStorageErrorCode,
   AgentThreadRecord,
+  AgentThreadSandboxParams,
+  AgentThreadSandboxState,
   AgentThreadStatus,
   AgentThreadStore,
   AppendAgentMessageInput,
@@ -99,6 +101,7 @@ export type {
   SubagentRunRecord,
   SubagentRunResult,
   SubagentRunSpec,
+  TransitionAgentThreadSandboxInput,
 } from "./agents"
 export {
   AGENT_RUN_DIAGNOSTIC_CODES,
@@ -117,6 +120,7 @@ export type {
   AiAccountingOverview,
   AiAccountingRange,
   AiAccountingTimeBucket,
+  AiAccountingUsage,
   AiAccountingWorkflowBreakdown,
   AiBillableMeter,
   AiBillingIdentity,
@@ -503,6 +507,7 @@ export type {
   MaterializationWorkEntityKind,
   MaterializationWorkPage,
   MaterializationWorkRecord,
+  ObjectVectorState,
   OntologyCommitOriginSelector,
   OntologyCommitRecord,
   OntologyCommitRunSelector,
@@ -521,6 +526,7 @@ export type {
   OntologySourceRecord,
   OntologySourceStorage,
   OntologyStorage,
+  OntologyVectorStorage,
   ProjectionOntologyCommitIntent,
   PurgePublishedOntologyOutboxInput,
   ReadMaterializationObjectExistenceInput,
@@ -538,6 +544,7 @@ export type {
   StoredLinkOverride,
   StoredLinkSlotOverride,
   StoredObjectOverride,
+  StoredObjectVector,
   StoredSourceAssertion,
   StoredSourceLinkAssertion,
   StoredSourceObjectAssertion,
@@ -551,6 +558,14 @@ export type {
   TerminalSourceMaterializationSummary,
 } from "./ontology"
 export { ONTOLOGY_OUTBOX_FAILURE_CODES } from "./ontology"
+export type {
+  OntologyVectorIndexingStorage,
+  VectorIndexingFailureCode,
+  VectorIndexingRequest,
+  VectorIndexingUpdate,
+  VectorIndexingWork,
+} from "./ontology/vector-indexing"
+export { VECTOR_INDEXING_FAILURE_CODES } from "./ontology/vector-indexing"
 export type {
   FinishPipelineRunInput,
   FinishPipelineStepRunInput,
@@ -667,7 +682,6 @@ export type {
   TimeseriesPoint,
   TimeseriesStorage,
 } from "./timeseries"
-
 export type { Storage, StorageTransactionOptions } from "./types"
 export type {
   FinishWebhookRunInput,

package/src/storage/objects/in-memory/query.ts

@@ -7,6 +7,7 @@ import {
   compareQueryScalarValues,
   queryScalarValuesEqual,
 } from "../../../objects/query/scalar-values"
+import { vectorSources } from "../../../objects/vectors/profile"
 import type { LinkBatchKey } from "../keys"
 import {
   compareObjectLinkCursors,
@@ -132,17 +133,36 @@ export function evaluateObjectQuery(
       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": {
@@ -539,12 +559,6 @@ function compareSortField(
   return field.direction === "desc" ? -comparison : comparison
 }
 
-function compareEntriesByRelevance(left: QueryEntry, right: QueryEntry): number {
-  return (
-    right.score - left.score || rowIdentityKey(left.row).localeCompare(rowIdentityKey(right.row))
-  )
-}
-
 function projectRow(row: ObjectRow, properties: readonly string[]): ObjectRow {
   const projected: Record<string, unknown> = {}
   for (const propertyId of properties) {

package/src/storage/objects/in-memory/read-scope.ts

@@ -137,15 +137,16 @@ export function resolveSelectedReadUniverse(
     links.set(key, redactLinkRow(selected.row, selected.propertyIds))
   }
 
-  return createReadUniverse(source.projectId, objects, links, objectProperties)
+  return createReadUniverse(source, objects, links, objectProperties)
 }
 
 function createReadUniverse(
-  projectId: string,
+  source: InMemoryReadSource,
   objects: ReadonlyMap<string, ObjectRow>,
   links: ReadonlyMap<string, ObjectLinkRow>,
   objectProperties: ReadonlyMap<string, ReadonlySet<string>>
 ): InMemoryReadUniverse {
+  const projectId = source.projectId
   const linksBySource = new Map<string, ObjectLinkRow[]>()
   for (const link of links.values()) {
     const key = sourceLinkBucketKey(link.projectId, link.sourceTypeId, link.sourceId)
@@ -159,6 +160,12 @@ function createReadUniverse(
     links,
     linksBySource,
     objectProperties,
+    getVector: (ref, profile) => {
+      const key = rowIdentityKeyParts(ref.objectTypeId, ref.primaryId)
+      if (!objects.has(key)) return undefined
+      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) =>

package/src/storage/objects/in-memory/read-source.ts

@@ -1,8 +1,13 @@
+import type { StoredObjectVector } from "../../ontology/vectors"
 import type { ObjectLinkRow, ObjectRow } from "../types"
 
 /** Project-bound read input shared by ordinary and selected in-memory queries. */
 export interface InMemoryReadSource {
   readonly projectId: string
+  getVector?(
+    ref: { objectTypeId: string; primaryId: string },
+    profile: string
+  ): StoredObjectVector | undefined
   objectsOfType(objectTypeId: string): readonly ObjectRow[]
   getObject(objectTypeId: string, primaryId: string): ObjectRow | undefined
   outgoingLinks(objectTypeId: string, primaryId: string): Iterable<ObjectLinkRow>

package/src/storage/objects/in-memory/selected-reader.ts

@@ -1,3 +1,4 @@
+import { hasVectorProfile } from "../../../objects/vectors/query"
 import {
   assertObjectReadFacetCount,
   assertObjectReadOutputWithinLimit,
@@ -74,7 +75,10 @@ export function createInMemorySelectedReader(
       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),
+          ...(hasVectorProfile(input.query) ? { score: entry.score } : {}),
+        })),
         hasMore: result.hasMore,
         nextPageToken: result.nextPageToken,
         ...(input.includeTotal === false ? {} : { total: result.total }),

package/src/storage/objects/in-memory/storage.ts

@@ -1,4 +1,6 @@
 import type { EffectiveLinkSnapshot, EffectiveObjectSnapshot } from "../../../materialization/model"
+import { hasVectorProfile } from "../../../objects/vectors/query"
+import type { StoredObjectVector } from "../../ontology/vectors"
 import type { ObjectReadExecutionLimits } from "../execution-limits"
 import { type LinkBatchKey, type ObjectBatchKey, objectBatchKey } from "../keys"
 import type {
@@ -44,7 +46,14 @@ export interface InMemoryObjectStorageSnapshot {
   readonly links: Map<string, Map<string, ObjectLinkRow>>
 }
 
+type VectorReader = (
+  projectId: string,
+  ref: { objectTypeId: string; primaryId: string },
+  profile: string
+) => StoredObjectVector | undefined
+
 interface InMemoryObjectMaterializerAdapter {
+  setVectorReader(reader: VectorReader): void
   getExactObjectRow(projectId: string, objectTypeId: string, primaryId: string): ObjectRow | null
   getExactLinkRow(
     projectId: string,
@@ -92,8 +101,13 @@ export class InMemoryObjectStorage implements ObjectStorage {
   private readonly rows = new Map<string, Map<string, ObjectRow>>()
   private readonly links = new Map<string, Map<string, ObjectLinkRow>>()
 
+  private vectorReader?: 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),
@@ -243,6 +257,7 @@ export class InMemoryObjectStorage implements ObjectStorage {
     // Keep indexed access live across writes and snapshot restores; do not capture individual buckets.
     return {
       projectId,
+      getVector: (ref, profile) => this.vectorReader?.(projectId, ref, profile),
       objectsOfType: (objectTypeId) => [
         ...(this.rows.get(objectRowKey(projectId, objectTypeId))?.values() ?? []),
       ],
@@ -257,7 +272,10 @@ export class InMemoryObjectStorage implements ObjectStorage {
   async queryObjects(params: QueryObjectsInput): Promise<QueryObjectsResult> {
     const result = evaluateObjectQuery(params.query, this.readSource(params.projectId))
     return {
-      objects: result.entries.map((entry) => entry.row),
+      objects: result.entries.map((entry) => ({
+        ...entry.row,
+        ...(hasVectorProfile(params.query) ? { score: entry.score } : {}),
+      })),
       hasMore: result.hasMore,
       nextPageToken: result.nextPageToken,
       ...(params.includeTotal === false ? {} : { total: result.total }),

package/src/storage/objects/types.ts

@@ -14,6 +14,8 @@ import type { LinkBatchKey, ObjectBatchKey } from "./keys"
  */
 
 export interface ObjectRow {
+  /** Cosine similarity, present only on named vector query results. */
+  score?: number
   projectId: string
   objectTypeId: string
   primaryId: string

package/src/storage/ontology/commits.ts

@@ -68,6 +68,7 @@ export interface EditOntologyCommitIntent {
   readonly kind: "edit"
   readonly mode: "atomic" | "continue"
   readonly operationCount: number
+  readonly vectorWriteCount?: number
 }
 
 export interface ProjectionOntologyCommitIntent {

package/src/storage/ontology/in-memory/index.ts

@@ -1,4 +1,5 @@
 import type { InMemoryObjectStorage } from "../../objects/in-memory"
+import { getInMemoryObjectMaterializerAdapter } from "../../objects/in-memory"
 import type { InMemoryTimeseriesStorage } from "../../timeseries/store"
 import type { OntologyStorage } from ".."
 import type { ProviderMaterializationTransactionLifecycle } from "../provider"
@@ -29,8 +30,13 @@ interface InMemoryOntologyStorageOptions {
   readonly executionExists: (projectId: string, executionId: string) => Promise<boolean>
 }
 
+import { InMemoryVectorIndexingStorage } from "./vector-indexing"
+import { InMemoryOntologyVectorStorage, vectorObjectKey } from "./vectors"
+
 export class InMemoryOntologyStorage implements OntologyStorage {
   private readonly state = createInMemoryOntologyState()
+  readonly vectorIndexing: InMemoryVectorIndexingStorage
+  readonly vectors: InMemoryOntologyVectorStorage
   readonly commits: InMemoryOntologyCommitStorage
   readonly sources: InMemoryOntologySourceStorage
   readonly materializations: InMemoryOntologyMaterializationStorage
@@ -46,6 +52,20 @@ export class InMemoryOntologyStorage implements OntologyStorage {
     timeseries: InMemoryTimeseriesStorage,
     options: InMemoryOntologyStorageOptions
   ) {
+    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,

package/src/storage/ontology/in-memory/materializations.ts

@@ -814,6 +814,19 @@ export class InMemoryOntologyMaterializationStorage implements OntologyMateriali
     return { commit: structuredClone(record) }
   }
 
+  /** @internal Share the existing transaction/session fence with derived vector writes. */
+  assertVectorSession(session: MaterializationSession, projectId: string, commitId?: string): void {
+    const active = this.requireSession(session)
+    if (
+      active.header.commit.projectId !== projectId ||
+      (commitId !== undefined && active.header.commit.id !== commitId)
+    ) {
+      throw new MaterializationValidationError(
+        "Vector mutation does not belong to this materialization session."
+      )
+    }
+  }
+
   private requireSession(session: MaterializationSession): SessionState {
     const value = this.sessions.get(session.providerToken)
     if (

package/src/storage/ontology/in-memory/shared-state.ts

@@ -18,6 +18,8 @@ import type {
   StoredSourceAssertion,
   StoredSourceLinkAssertion,
 } from "../sources"
+import type { VectorIndexingWork } from "../vector-indexing"
+import type { StoredObjectVector } from "../vectors"
 
 export interface InMemorySourceRoot {
   readonly root: ProjectionEntityRef
@@ -49,6 +51,11 @@ export interface InMemoryStoredLinkSlotOverride extends Omit<StoredLinkSlotOverr
 }
 
 export interface InMemoryOntologyState {
+  readonly vectorIndexing: Map<
+    string,
+    VectorIndexingWork & { projectId: string; dispatchAt: string }
+  >
+  readonly vectors: Map<string, Map<string, StoredObjectVector>>
   readonly commitsById: Map<string, OntologyCommitRecord>
   readonly commitIdByIdempotency: Map<string, string>
   readonly commitIdByOrigin: Map<string, string>
@@ -73,6 +80,8 @@ export interface InMemoryOntologyStorageTestHooks {
 
 export function createInMemoryOntologyState(): InMemoryOntologyState {
   return {
+    vectors: new Map(),
+    vectorIndexing: new Map(),
     commitsById: new Map(),
     commitIdByIdempotency: new Map(),
     commitIdByOrigin: new Map(),

package/src/storage/ontology/in-memory/vector-indexing.ts

@@ -0,0 +1,179 @@
+import type { MaterializationSession } from "../materializations"
+import type { OntologyVectorIndexingStorage, VectorIndexingWork } from "../vector-indexing"
+
+export class InMemoryVectorIndexingStorage implements OntologyVectorIndexingStorage {
+  constructor(
+    private readonly state: Map<
+      string,
+      VectorIndexingWork & { projectId: string; dispatchAt: string }
+    >,
+    private readonly assertSession: (session: MaterializationSession, projectId: string) => void,
+    private readonly run: <T>(fn: () => T) => Promise<T>
+  ) {}
+
+  async schedule(input: Parameters<OntologyVectorIndexingStorage["schedule"]>[0]) {
+    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: Parameters<OntologyVectorIndexingStorage["complete"]>[0]) {
+    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: Parameters<OntologyVectorIndexingStorage["dispatched"]>[0]) {
+    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: Parameters<OntologyVectorIndexingStorage["get"]>[0]) {
+    return this.run(() =>
+      structuredClone(
+        [...this.state.values()].find(
+          (work) => work.projectId === input.projectId && work.id === input.id
+        ) ?? null
+      )
+    )
+  }
+
+  async getBatch(input: Parameters<OntologyVectorIndexingStorage["getBatch"]>[0]) {
+    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: Parameters<OntologyVectorIndexingStorage["getBatchMember"]>[0]) {
+    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: Parameters<OntologyVectorIndexingStorage["updateBatch"]>[0]) {
+    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: Parameters<OntologyVectorIndexingStorage["listDue"]>[0]) {
+    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: Parameters<OntologyVectorIndexingStorage["update"]>[0]) {
+    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: Parameters<OntologyVectorIndexingStorage["remove"]>[0]) {
+    await this.run(() => {
+      for (const [key, work] of this.state)
+        if (work.projectId === input.projectId && work.id === input.id) this.state.delete(key)
+    })
+  }
+}

package/src/storage/ontology/in-memory/vectors.ts

@@ -0,0 +1,73 @@
+import { MaterializationConflictError } from "../../../materialization/errors"
+import type { MaterializationSession } from "../materializations"
+import type { OntologyVectorStorage, StoredObjectVector } from "../vectors"
+
+export function vectorObjectKey(projectId: string, ref: StoredObjectVector["ref"]): string {
+  return JSON.stringify([projectId, ref.objectTypeId, ref.primaryId])
+}
+
+export class InMemoryOntologyVectorStorage implements OntologyVectorStorage {
+  constructor(
+    private readonly state: Map<string, Map<string, StoredObjectVector>>,
+    private readonly assertSession: (
+      session: MaterializationSession,
+      projectId: string,
+      commitId?: string
+    ) => void,
+    private readonly runRootOperation: <T>(run: () => T) => Promise<T>
+  ) {}
+
+  async list(input: Parameters<OntologyVectorStorage["list"]>[0]) {
+    return this.listBatch({ projectId: input.projectId, refs: [input.ref] })
+  }
+
+  async listBatch(input: Parameters<OntologyVectorStorage["listBatch"]>[0]) {
+    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: Parameters<OntologyVectorStorage["removeBatch"]>[0]) {
+    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: Parameters<OntologyVectorStorage["write"]>[0]) {
+    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<string, StoredObjectVector>()
+    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: Parameters<OntologyVectorStorage["writeBatch"]>[0]): Promise<void> {
+    for (const entry of input.entries) {
+      await this.write({ session: input.session, projectId: input.projectId, ...entry })
+    }
+  }
+
+  async remove(input: Parameters<OntologyVectorStorage["remove"]>[0]) {
+    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)
+  }
+
+  private assertRevision(current: StoredObjectVector | undefined, expected: string | null) {
+    if ((current?.lastCommitId ?? null) !== expected) {
+      throw new MaterializationConflictError(
+        "effective-state",
+        "Vector changed since it was prepared."
+      )
+    }
+  }
+}