@sixb/core 0.1.10 → 0.1.12

package/src/storage/connector-connections/provider/runs.ts

@@ -360,6 +360,12 @@ export class DurableConnectorConnectionRuns extends ConnectorConnectionOperation
     })
   }
 
+  listPendingConnectionRuns(
+    input: Parameters<ConnectorConnectionStorage["listPendingConnectionRuns"]>[0]
+  ) {
+    return this.read(input, (persistence) => persistence.listPendingConnectionRuns())
+  }
+
   getConnectionRun(
     input: GetConnectorConnectionRunInput
   ): Promise<ConnectorConnectionRunRecord | null> {

package/src/storage/connector-connections/provider/shared.ts

@@ -31,6 +31,7 @@ export interface ConnectorConnectionPersistence {
   deleteAuthorizationAttempt(id: string): Promise<boolean>
 
   insertConnectionRun(record: ConnectorConnectionRunRecord): Promise<boolean>
+  listPendingConnectionRuns(): Promise<readonly ConnectorConnectionRunRecord[]>
   getConnectionRun(id: string): Promise<ConnectorConnectionRunRecord | null>
   updateConnectionRun(record: ConnectorConnectionRunRecord): Promise<void>
 
@@ -88,6 +89,7 @@ export async function currentConnectionRun(
   const run = await persistence.getConnectionRun(runId)
   if (!run || (run.status !== "waiting" && run.status !== "running")) return run
 
+  if (run.status === "waiting" && run.waitingFor === "account_selection") return run
   const now = await persistence.now()
   if (run.expiresAt.getTime() > now.getTime()) return run
 
@@ -96,9 +98,6 @@ export async function currentConnectionRun(
     if (attempt) await persistence.deleteAuthorizationAttempt(attempt.id)
   }
   if (run.status === "waiting") {
-    if (run.kind === "connect" && run.waitingFor === "account_selection") {
-      await markPendingAuthorizationForCleanup(persistence, run.authorizationId, now)
-    }
     const expired = expireConnectionRun(run, now)
     await persistence.updateConnectionRun(expired)
     return expired

package/src/storage/connector-connections/provider.ts

@@ -77,6 +77,12 @@ export class DurableConnectorConnectionStorage implements ConnectorConnectionSto
     return this.runs.finishConnectionRun(...args)
   }
 
+  listPendingConnectionRuns(
+    ...args: Parameters<ConnectorConnectionStorage["listPendingConnectionRuns"]>
+  ) {
+    return this.runs.listPendingConnectionRuns(...args)
+  }
+
   async getConnectionRun(
     ...args: Parameters<ConnectorConnectionStorage["getConnectionRun"]>
   ): Promise<Awaited<ReturnType<ConnectorConnectionStorage["getConnectionRun"]>>> {

package/src/storage/connector-connections/types.ts

@@ -58,6 +58,7 @@ export interface ConnectorConnectionRunAwaitingSelectionRecord extends Connector
   readonly status: "waiting"
   readonly waitingFor: "account_selection"
   readonly authorizationId: string
+  /** Legacy persistence field; account selection no longer expires. */
   readonly expiresAt: Date
 }
 
@@ -279,7 +280,7 @@ export interface ConnectorAuthorizationRecord {
   readonly scopes: readonly string[]
   readonly accounts: readonly ConnectorAccountCandidate[]
   readonly status: ConnectorAuthorizationStatus
-  /** Storage-authoritative deadline for the first account selection. */
+  /** Legacy persistence field; no longer enforced as a selection deadline. */
   readonly selectionExpiresAt?: Date
   readonly revision: number
   readonly credentialMutation?: ConnectorCredentialMutation
@@ -478,6 +479,9 @@ export interface ConnectorConnectionStorage {
   finishConnectionRun(
     input: FinishConnectorConnectionRunInput
   ): Promise<ConnectorConnectionRunRecord | null>
+  listPendingConnectionRuns(
+    input: ListConnectorConnectionsInput
+  ): Promise<readonly ConnectorConnectionRunRecord[]>
   getConnectionRun(
     input: GetConnectorConnectionRunInput
   ): Promise<ConnectorConnectionRunRecord | null>

package/src/storage/executions/provider.ts

@@ -1,4 +1,5 @@
-import type { TrustedPrimitiveKind } from "../../execution/types"
+import { kernelOperationFromId, kernelOperationId } from "../../execution/kernel-operation"
+import type { KernelOperation, TrustedPrimitiveKind } from "../../execution/types"
 import { ExecutionStorageError } from "./errors"
 import type { CreateExecutionInput, ExecutionRecord } from "./types"
 import { normalizeExecutionRecord } from "./validation"
@@ -16,7 +17,14 @@ export interface ExecutionStorageRow {
   readonly id: string
   readonly executorKind: "agent" | "kernel" | "request" | TrustedPrimitiveKind
   readonly executorId: string
-  readonly sourceKind: "datasetVersion" | "event" | "execution" | "http" | "schedule" | "webhook"
+  readonly sourceKind:
+    | "ontologyCommit"
+    | "datasetVersion"
+    | "event"
+    | "execution"
+    | "http"
+    | "schedule"
+    | "webhook"
   readonly sourceId: string
   readonly requestedByUserId: string | null
   readonly requestedByServiceAccountId: string | null
@@ -31,7 +39,7 @@ export interface ExecutionStorageRow {
   readonly authorityAccessTokenId: string | null
   readonly authorityPrimitiveKind: TrustedPrimitiveKind | null
   readonly authorityPrimitiveId: string | null
-  readonly authorityKernelOperation: "ontology.recover" | null
+  readonly authorityKernelOperation: KernelOperation["type"] | null
   readonly authorityDelegationKind: "share" | null
   readonly authorityDelegationId: string | null
   readonly authorityDelegationSessionId: string | null
@@ -108,7 +116,7 @@ function flattenExecutor(
     case "agent":
       return { executorKind: "agent", executorId: record.executor.runId }
     case "kernel":
-      return { executorKind: "kernel", executorId: record.executor.operation.recoveryId }
+      return { executorKind: "kernel", executorId: kernelOperationId(record.executor.operation) }
   }
 }
 
@@ -116,6 +124,8 @@ function flattenSource(
   record: ExecutionRecord
 ): Pick<ExecutionStorageRow, "sourceId" | "sourceKind"> {
   switch (record.source.type) {
+    case "ontologyCommit":
+      return { sourceKind: "ontologyCommit", sourceId: record.source.commitId }
     case "http":
       return { sourceKind: "http", sourceId: record.source.requestId }
     case "webhook":
@@ -219,10 +229,10 @@ function inflateExecutor(row: ExecutionStorageRow): CreateExecutionInput["execut
     case "kernel":
       return {
         type: "kernel",
-        operation: {
-          type: requireValue(row.authorityKernelOperation, "authority kernel operation"),
-          recoveryId: row.executorId,
-        },
+        operation: kernelOperationFromId(
+          requireValue(row.authorityKernelOperation, "authority kernel operation"),
+          row.executorId
+        ),
       }
     default:
       return { type: "primitive", kind: row.executorKind, runId: row.executorId }
@@ -231,6 +241,8 @@ function inflateExecutor(row: ExecutionStorageRow): CreateExecutionInput["execut
 
 function inflateSource(row: ExecutionStorageRow): CreateExecutionInput["source"] {
   switch (row.sourceKind) {
+    case "ontologyCommit":
+      return { type: "ontologyCommit", commitId: row.sourceId }
     case "http":
       return { type: "http", requestId: row.sourceId }
     case "webhook":
@@ -307,10 +319,10 @@ function inflateAuthority(row: ExecutionStorageRow): CreateExecutionInput["autho
     case "kernel":
       return {
         type: "kernel",
-        operation: {
-          type: requireValue(row.authorityKernelOperation, "authority kernel operation"),
-          recoveryId: row.executorId,
-        },
+        operation: kernelOperationFromId(
+          requireValue(row.authorityKernelOperation, "authority kernel operation"),
+          row.executorId
+        ),
       }
     case "disabled":
       return { type: "disabled" }

package/src/storage/executions/types.ts

@@ -17,6 +17,7 @@ export type DurableExecutionExecutor =
  * is attempt transport and is never persisted here.
  */
 export type DurableExecutionSource =
+  | { readonly type: "ontologyCommit"; readonly commitId: string }
   | { readonly type: "http"; readonly requestId: string }
   | { readonly type: "webhook"; readonly deliveryId: string }
   | { readonly type: "schedule"; readonly eventId: string }

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(),
@@ -176,9 +185,16 @@ export function insertBounded<T>(
   limit: number,
   compare: (left: T, right: T) => number
 ): void {
-  let index = values.findIndex((candidate) => compare(value, candidate) < 0)
-  if (index < 0) index = values.length
-  values.splice(index, 0, value)
+  if (limit <= 0) return
+  if (values.length >= limit && compare(value, values[values.length - 1]!) >= 0) return
+  let low = 0
+  let high = values.length
+  while (low < high) {
+    const middle = (low + high) >>> 1
+    if (compare(value, values[middle]!) < 0) high = middle
+    else low = middle + 1
+  }
+  values.splice(low, 0, value)
   if (values.length > limit) values.pop()
 }