@sixb/core 0.1.15 → 0.1.17

package/src/objects/vectors/handle.ts

@@ -65,7 +65,7 @@ export function createObjectVectorHandle(
       }
 
       // Network work never holds a storage transaction or retries an obsolete computation.
-      const result = await model.embed({ texts: [input.text] })
+      const result = await model.embed({ texts: [input.text], purpose: "document" })
       if (!Array.isArray(result?.vectors) || result.vectors.length !== 1) {
         throw new MaterializationValidationError(
           "Embedding model must return exactly one vector for one input text."

package/src/objects/vectors/indexing-dispatch.ts

@@ -0,0 +1,83 @@
+import type { Queues } from "../../queues"
+import type { OntologyVectorIndexingStorage } from "../../storage/ontology/vector-indexing"
+
+const PAGE_SIZE = 100
+/** A dispatched request becomes due again only if its job has not completed it by then. */
+const REDISPATCH_DELAY_MS = 30_000
+
+/**
+ * Hands durable indexing intent to the vector queue. Each commit wakes it in the committing
+ * process; ontology maintenance drains it as the repair path for a wake-up that never finished.
+ */
+export class VectorIndexingDispatcher {
+  private running: Promise<void> | null = null
+  private next: Promise<void> | null = null
+  private stopped = false
+
+  constructor(
+    private readonly projectId: string,
+    private readonly indexing: OntologyVectorIndexingStorage,
+    private readonly queue: Queues["vectorIndexing"]
+  ) {}
+
+  notify(): void {
+    this.drain().catch((error) =>
+      console.error("[Sixb] Could not dispatch vector indexing; maintenance will retry:", error)
+    )
+  }
+
+  /** Callers share one pass plus at most one follow-up, which sees every earlier commit. */
+  drain(): Promise<void> {
+    this.next ??= settled(this.running).then(() => {
+      this.next = null
+      if (this.stopped) return
+      this.running = this.pass().finally(() => {
+        this.running = null
+      })
+      return this.running
+    })
+    return this.next
+  }
+
+  async stop(): Promise<void> {
+    this.stopped = true
+    await settled(this.next)
+    await settled(this.running)
+  }
+
+  private async pass(): Promise<void> {
+    for (;;) {
+      const now = new Date()
+      const work = await this.indexing.listDue({
+        projectId: this.projectId,
+        now: now.toISOString(),
+        limit: PAGE_SIZE,
+      })
+      if (work.length) {
+        const jobs = [...new Map(work.map((item) => [item.batchId ?? item.id, item])).entries()]
+        await this.queue.enqueue({
+          projectId: this.projectId,
+          jobs: jobs.map(([id, item]) => ({
+            id,
+            type: "vector.index.requested",
+            payload: { indexingId: id },
+            availableAt: item.availableAt,
+          })),
+        })
+        await this.indexing.dispatched({
+          projectId: this.projectId,
+          ids: work.map((item) => item.id),
+          nextDispatchAt: new Date(now.getTime() + REDISPATCH_DELAY_MS).toISOString(),
+        })
+      }
+      if (work.length < PAGE_SIZE || this.stopped) return
+    }
+  }
+}
+
+function settled(promise: Promise<void> | null): Promise<void> {
+  return (promise ?? Promise.resolve()).then(
+    () => undefined,
+    () => undefined
+  )
+}

package/src/objects/vectors/indexing-generate.ts

@@ -63,7 +63,11 @@ export async function generateVectors(
       )
     }
 
-    const result = await model.embed({ texts: entries.map((entry) => entry.input.text), signal })
+    const result = await model.embed({
+      texts: entries.map((entry) => entry.input.text),
+      purpose: "document",
+      signal,
+    })
     const values = normalizeEmbeddingResult(
       result,
       entries.length,

package/src/objects/vectors/profile.ts

@@ -13,6 +13,8 @@ export function vectorConfiguration(profile: ObjectVectorSearchProfile): string
     model: profile.model.modelId,
     representation: profile.model.definition.representation ?? { name: profile.model.modelId },
     dimensions: profile.model.definition.dimensions,
+    // Include retrieval preparation without changing existing symmetric identities.
+    ...(profile.model.definition.inputMode === "asymmetric" ? { inputMode: "asymmetric" } : {}),
     metric: "cosine",
     precision: "float32",
     normalization: "l2-v1",

package/src/objects/vectors/query.ts

@@ -6,11 +6,28 @@ export function hasVectorProfile(query: ObjectQuery): boolean {
   return "input" in query && hasVectorProfile(query.input)
 }
 
-/** V1 supports one exact top-k, with filters applied before ranking. */
+/** Rank one eligible object set; validation resolves its type and admits every traversed edge. */
 export function isVectorProfileQuery(query: ObjectQuery): boolean {
   if (query.kind === "limit" || query.kind === "project") return isVectorProfileQuery(query.input)
+  if (query.kind === "rerank") {
+    return query.input.kind === "vector" && isVectorProfileQuery(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: ObjectQuery): boolean {
+  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
+  }
 }

package/src/objects/vectors/resolve-query.ts

@@ -3,6 +3,7 @@ import { type EmbeddingModel, sameEmbeddingModel } from "../../models/embedding-
 import type { OntologyRegistry } from "../../ontology"
 import { ObjectQueryExecutionError } from "../query/errors"
 import type { ObjectQuery, ObjectQueryVector } from "../query/ir"
+import { resolveObjectQueryResultShape } from "../query/validate"
 import { normalizeVector } from "./profile"
 
 const QUERY_EMBEDDING_TIMEOUT_MS = 30_000
@@ -30,16 +31,19 @@ function resolveProfileEmbeddingModel(
   ontology: OntologyRegistry,
   models: EmbeddingModelCatalog | undefined
 ): EmbeddingModel {
-  let input = query.input
-  while (input.kind === "filter") input = input.input
-  if (input.kind !== "start" || !query.profile) {
+  const { objectTypeIds } = resolveObjectQueryResultShape(query.input, {
+    ontology,
+    normalize: false,
+  })
+  const objectTypeId = objectTypeIds.length === 1 ? objectTypeIds[0] : undefined
+  if (!objectTypeId || !query.profile) {
     throw new ObjectQueryExecutionError(
       "embedding_model_unavailable",
       "Vector search requires the embedding model registered for its profile."
     )
   }
 
-  const profile = ontology.resolveObjectType(input.objectTypeId).search?.vectors?.[query.profile]
+  const profile = ontology.resolveObjectType(objectTypeId).search?.vectors?.[query.profile]
   if (!profile) {
     throw new ObjectQueryExecutionError(
       "embedding_model_unavailable",
@@ -69,7 +73,7 @@ async function embedSearchText(
   const timeout = AbortSignal.timeout(QUERY_EMBEDDING_TIMEOUT_MS)
   const requestSignal = signal ? AbortSignal.any([signal, timeout]) : timeout
   requestSignal.throwIfAborted()
-  const result = await model.embed({ texts: [text], signal: requestSignal })
+  const result = await model.embed({ texts: [text], purpose: "query", signal: requestSignal })
   requestSignal.throwIfAborted()
 
   if (!Array.isArray(result?.vectors) || result.vectors.length !== 1) {

package/src/objects/vectors/types.ts

@@ -2,7 +2,9 @@ import type { ObjectType } from "../../ontology"
 
 export type VectorProfileName<T extends ObjectType> = T extends { search: { vectors: infer P } }
   ? Extract<keyof P, string>
-  : never
+  : string extends T["id"]
+    ? string
+    : never
 
 export interface ObjectVectorHandle {
   /** Generate and atomically store this profile using its configured model. Conflicts are not retried. */

package/src/ontology/builders.ts

@@ -35,6 +35,7 @@ import type {
   ObjectLink,
   ObjectLinkTargetMetadata,
   ObjectType,
+  ObjectVectorSearchProfile,
   Ontology,
   Property,
   PropertyMode,
@@ -231,6 +232,7 @@ export function defineObjectType(input: DefineObjectTypeInput): ObjectTypeWithTo
     properties,
     links,
     search: input.search,
+    query: input.query,
   }
 
   return {
@@ -446,19 +448,32 @@ export type DirectLinkResult<
 > = LinkResult<TId, TTargetObjectTypeId, TOptions> & ObjectLinkTargetMetadata<TTarget>
 
 type ObjectTypeIdArray<TTargets extends readonly ObjectType[]> = Array<TTargets[number]["id"]>
+/** Keep profile names without carrying provider types through every linked declaration. */
 export type DirectLinkTarget<
   TId extends string,
   TName extends string,
   TProperties extends Property[],
-> = ObjectTypeWithPropertyTokens<{
-  id: TId
-  name: TName
-  properties: TProperties
-  links: ObjectLink[]
-}>
+  TVectorProfiles extends string = never,
+> = ObjectTypeWithPropertyTokens<
+  {
+    id: TId
+    name: TName
+    properties: TProperties
+    links: ObjectLink[]
+  } & ([TVectorProfiles] extends [never]
+    ? unknown
+    : { search: { vectors: Record<TVectorProfiles, ObjectVectorSearchProfile> } })
+>
 
 type DirectLinkTargetFor<TTarget extends ObjectType> = TTarget extends ObjectTypeWithPropertyTokens
-  ? DirectLinkTarget<TTarget["id"], TTarget["name"], TTarget["properties"]>
+  ? DirectLinkTarget<
+      TTarget["id"],
+      TTarget["name"],
+      TTarget["properties"],
+      TTarget extends { search: { vectors: infer TProfiles } }
+        ? Extract<keyof TProfiles, string>
+        : never
+    >
   : TTarget
 
 /**

package/src/ontology/index.ts

@@ -47,8 +47,10 @@ export type {
   ObjectLink,
   ObjectLinkTargetMetadata,
   ObjectLinkTargetType,
+  ObjectQueryIndexDefinition,
   ObjectSchema,
   ObjectType,
+  ObjectTypeQueryMetadata,
   ObjectTypeSearchMetadata,
   ObjectVectorSearchProfile,
   Ontology,

package/src/ontology/query-capabilities.ts

@@ -123,7 +123,7 @@ export function resolvePropertyQueryCapabilities(
   }
 }
 
-function resolveQuerySchema(
+export function resolveQuerySchema(
   schema: Schema,
   valueTypesById: ReadonlyMap<string, ValueType>,
   seen = new Set<string>()

package/src/ontology/types.ts

@@ -360,6 +360,25 @@ export interface Interface {
   links: ObjectLink[]
 }
 
+/** Compound query shapes prepared by the storage provider, in addition to property flags. */
+export type ObjectQueryIndexDefinition =
+  | {
+      kind: "sort"
+      fields: readonly { propertyId: string; direction?: "asc" | "desc" }[]
+      /** String equality filters preceding the ordered fields. */
+      filters?: readonly string[]
+    }
+  | {
+      kind: "text"
+      propertyId: string
+      /** String filters/facets commonly combined with this substring search. */
+      filters?: readonly string[]
+    }
+
+export interface ObjectTypeQueryMetadata {
+  indexes?: readonly ObjectQueryIndexDefinition[]
+}
+
 /**
  * Canonical ontology node for a real-world asset, system, concept, or process.
  *
@@ -413,6 +432,8 @@ export interface ObjectType {
 
   properties: Property[]
   links: ObjectLink[]
+  /** Query index declarations, prepared automatically after storage migrations. */
+  query?: ObjectTypeQueryMetadata
   /** Search profile for this object type. */
   search?: ObjectTypeSearchMetadata
 }

package/src/ontology/validation/query.ts

@@ -7,6 +7,8 @@ import {
   isFilterableSchema,
   isSortableSchema,
   isTextSchema,
+  queryScalarKindForSchema,
+  resolveQuerySchema,
 } from "../query-capabilities"
 
 type QueryFeature = "filterable" | "sortable" | "text" | "exact" | "facet"
@@ -27,6 +29,7 @@ export function validateQueryMetadata(
     }
 
     validateObjectSearchMetadata(typeId, objectType, valueTypesById)
+    validateQueryIndexes(typeId, objectType, valueTypesById)
   }
 }
 
@@ -250,3 +253,57 @@ function resolveSchema(
   seenValueTypeIds.add(schema.valueTypeId)
   return resolveSchema(resolved, valueTypesById, path, seenValueTypeIds)
 }
+
+function validateQueryIndexes(
+  typeId: string,
+  objectType: ObjectType,
+  valueTypes: ReadonlyMap<string, ValueType>
+): void {
+  for (const index of objectType.query?.indexes ?? []) {
+    const fields =
+      index.kind === "sort" ? index.fields.map((field) => field.propertyId) : [index.propertyId]
+    const filters = index.filters ?? []
+    if (
+      !fields.length ||
+      fields.length + filters.length > 8 ||
+      new Set([...fields, ...filters]).size !== fields.length + filters.length
+    )
+      throw new OntologyValidationError(
+        `[Sixb] Query index on '${typeId}' requires one to eight distinct properties`
+      )
+    if (index.kind === "text" && filters.length > 4)
+      throw new OntologyValidationError(
+        `[Sixb] Text query index on '${typeId}' accepts at most four filters`
+      )
+    for (const id of [...fields, ...filters]) {
+      const property = objectType.properties.find((property) => property.id === id)
+      if (!property)
+        throw new OntologyValidationError(
+          `[Sixb] Query index on '${typeId}' references unknown property '${id}'`
+        )
+      if (property.mode === "telemetry")
+        throw new OntologyValidationError(
+          `[Sixb] Query indexes cannot include telemetry property '${typeId}.${id}'`
+        )
+      const flag = filters.includes(id) ? "filterable" : index.kind === "sort" ? "sortable" : "text"
+      assertPropertyQueryFlag(typeId, property, flag, "query.indexes")
+      if (filters.includes(id)) {
+        const schema = resolveQuerySchema(property.schema, valueTypes)
+        if (!schema || queryScalarKindForSchema(schema) !== "string")
+          throw new OntologyValidationError(
+            `[Sixb] Query index filters must be strings: '${typeId}.${id}'`
+          )
+      }
+    }
+    if (
+      index.kind === "sort" &&
+      index.fields.some(
+        (field) =>
+          field.direction !== undefined && field.direction !== "asc" && field.direction !== "desc"
+      )
+    )
+      throw new OntologyValidationError(
+        `[Sixb] Query index direction must be asc or desc on '${typeId}'`
+      )
+  }
+}

package/src/ontology/vector-profiles.ts

@@ -17,6 +17,7 @@ export function snapshotVectorProfiles(
           providerId,
           modelId,
           dimensions: definition.dimensions,
+          ...(definition.inputMode ? { inputMode: definition.inputMode } : {}),
           ...(definition.representation
             ? {
                 representation: Object.freeze({

package/src/query.ts

@@ -6,6 +6,8 @@
  * top of this module.
  */
 
+export type { ModelRef } from "./models/catalog"
+export type { RerankingModelDefinition, RerankingModelRef } from "./models/reranking-model"
 export type { ObjectQueryPlanningIssue } from "./objects/query/errors"
 export {
   ObjectQueryExecutionError,
@@ -29,6 +31,7 @@ export type {
   ObjectQueryPredicateNot,
   ObjectQueryProject,
   ObjectQueryRefs,
+  ObjectQueryRerank,
   ObjectQueryResultShape,
   ObjectQuerySet,
   ObjectQuerySetOperation,
@@ -68,6 +71,7 @@ export type {
   ObjectQueryFacetBucket,
   ObjectQueryFacetInput,
   ObjectQueryFacetResult,
+  ObjectQueryFacetsResult,
   ObjectQueryListOptions,
   ObjectQueryRow,
   ObjectWhereBuilder,

package/src/queues/in-memory.ts

@@ -109,11 +109,16 @@ function eligibleAt(record: QueueRecord): number {
   return Math.max(record.availableAtMs, record.leaseExpiryMs ?? -Infinity)
 }
 
+// Largest delay `setTimeout` accepts; a waiting claim that wakes early just waits again.
+const MAX_TIMER_DELAY_MS = 2_147_483_647
+
 interface QueueLane {
   // Terminal records remain here for caller-id deduplication, never in the delivery indexes.
   readonly records: Map<string, QueueRecord>
   readonly ready: IndexedHeap<QueueRecord>
   readonly waiting: IndexedHeap<QueueRecord>
+  /** Wakes claims waiting on this lane. */
+  readonly waiters: Set<() => void>
 }
 
 function toClaimedQueueJob<TQueueJob extends QueueJob>(
@@ -175,6 +180,27 @@ class InMemoryQueueStore {
       lane.ready.delete(record)
       lane.waiting.set(record)
     }
+    // Any change can make a job claimable or move the next due time; waiters look again.
+    for (const wake of lane.waiters) wake()
+  }
+
+  /** Resolves when the lane changes, its next delayed job or lease comes due, or `signal` aborts. */
+  waitForWork(projectId: string, queueId: string, signal: AbortSignal): Promise<void> {
+    const lane = this.lane(projectId, queueId)
+    const next = lane.waiting.peek()
+    const dueInMs = next ? eligibleAt(next) - Date.now() : MAX_TIMER_DELAY_MS
+    return new Promise((resolve) => {
+      // Always armed: like a blocking read on a socket, a waiting claim keeps its process alive.
+      const timer = setTimeout(wake, Math.min(dueInMs, MAX_TIMER_DELAY_MS))
+      function wake(): void {
+        clearTimeout(timer)
+        lane.waiters.delete(wake)
+        signal.removeEventListener("abort", wake)
+        resolve()
+      }
+      lane.waiters.add(wake)
+      signal.addEventListener("abort", wake, { once: true })
+    })
   }
 
   takeReady<TQueueJob extends QueueJob>(
@@ -216,6 +242,7 @@ class InMemoryQueueStore {
         waiting: new IndexedHeap(
           (left, right) => eligibleAt(left) - eligibleAt(right) || left.sequence - right.sequence
         ),
+        waiters: new Set(),
       }
       queues.set(queueId, lane)
     }
@@ -263,6 +290,7 @@ class InMemoryQueue<TQueueJob extends QueueJob, TFailureCode extends SixbErrorCo
     workerId: string
     limit?: number
     leaseMs?: number
+    signal?: AbortSignal
   }): Promise<readonly ClaimedQueueJob<TQueueJob>[]> {
     assertNonEmpty(params.projectId, "projectId")
     assertNonEmpty(params.workerId, "workerId")
@@ -275,27 +303,34 @@ class InMemoryQueue<TQueueJob extends QueueJob, TFailureCode extends SixbErrorCo
     const leaseMs = params.leaseMs ?? 30_000
     assertPositiveNumber(leaseMs, "leaseMs")
 
-    const now = Date.now()
-    const claimedAt = new Date(now).toISOString()
-    // Validate before removing candidates, and cache the same millisecond precision we return.
-    const leaseExpiry = new Date(now + leaseMs)
-    const leaseExpiresAt = leaseExpiry.toISOString()
-    const claimable = this.store.takeReady<TQueueJob>(params.projectId, this.queueId, now, limit)
-
-    return claimable.map((record) => {
-      // Attempts count claims so redelivery after lease expiry or retry is visible to workers.
-      record.job = {
-        ...record.job,
-        attempt: record.job.attempt + 1,
+    for (;;) {
+      if (params.signal?.aborted) return []
+      const now = Date.now()
+      const claimedAt = new Date(now).toISOString()
+      // Validate before removing candidates, and cache the same millisecond precision we return.
+      const leaseExpiry = new Date(now + leaseMs)
+      const leaseExpiresAt = leaseExpiry.toISOString()
+      const claimable = this.store.takeReady<TQueueJob>(params.projectId, this.queueId, now, limit)
+      if (claimable.length === 0 && params.signal) {
+        await this.store.waitForWork(params.projectId, this.queueId, params.signal)
+        continue
       }
-      record.leaseId = randomUUID()
-      record.claimedAt = claimedAt
-      record.leaseExpiresAt = leaseExpiresAt
-      record.leaseExpiryMs = leaseExpiry.getTime()
-      this.store.schedule(params.projectId, record, now)
 
-      return toClaimedQueueJob(record)
-    })
+      return claimable.map((record) => {
+        // Attempts count claims so redelivery after lease expiry or retry is visible to workers.
+        record.job = {
+          ...record.job,
+          attempt: record.job.attempt + 1,
+        }
+        record.leaseId = randomUUID()
+        record.claimedAt = claimedAt
+        record.leaseExpiresAt = leaseExpiresAt
+        record.leaseExpiryMs = leaseExpiry.getTime()
+        this.store.schedule(params.projectId, record, now)
+
+        return toClaimedQueueJob(record)
+      })
+    }
   }
 
   async complete(params: { projectId: string; jobId: string; leaseId: string }): Promise<void> {

package/src/queues/types.ts

@@ -82,12 +82,16 @@ export interface Queue<
    *
    * `leaseMs` is the visibility timeout for this claim. If the lease expires
    * before the job is acknowledged, the job may be delivered again.
+   *
+   * Without `signal`, returns at once, possibly empty. With `signal`, waits for work instead:
+   * it resolves once it claims at least one job, and empty only after `signal` aborts.
    */
   claim(params: {
     projectId: string
     workerId: string
     limit?: number
     leaseMs?: number
+    signal?: AbortSignal
   }): Promise<readonly ClaimedQueueJob<TQueueJob>[]>
 
   /** Acknowledges successful processing and removes the claimed job from delivery. */

package/src/runtime/host.ts

@@ -54,8 +54,10 @@ import {
 import { createOntologyMaterializer, type OntologyMaterializerContract } from "../materializer"
 import type { ModelCatalogInput } from "../models"
 import { bindEmbeddingModels } from "../models/execution/embedding"
+import { bindRerankingModels } from "../models/execution/reranking"
 import { ModelExecutionSession } from "../models/execution/session"
 import { createVectorIndexingRuntime } from "../objects/vectors/indexing"
+import { VectorIndexingDispatcher } from "../objects/vectors/indexing-dispatch"
 import { registerVectorIndexingRuntime } from "../objects/vectors/indexing-runtime"
 import type { PipelineDefinition } from "../pipelines/types"
 import { registerProjectionRegistry } from "../projections/internal"
@@ -88,6 +90,7 @@ import {
   createOntologyMutationRuntime,
   registerOntologyMutationRuntime,
 } from "./ontology-mutations"
+import { getApiPublicOrigin } from "./public-origin"
 import { resolveDefinitions } from "./resolve-definitions"
 import { createBoundSixb, type Sixb, type SixbDependencies } from "./sixb"
 import { StorageReadiness } from "./storage-readiness"
@@ -141,6 +144,7 @@ export class SixbHost<in out TParams extends ParamsConfig = ParamsConfig> {
   private readonly webhookRegistry: WebhookRegistry
   private readonly hostContext: SixbHostContext
   private readonly committedFacts: OntologyOutboxDispatcher
+  private readonly vectorIndexing?: VectorIndexingDispatcher
   private readonly eventService: DomainEventService
   private readonly ontologyMaintenance: OntologyMaintenance
   private readonly storageReadiness: StorageReadiness
@@ -234,16 +238,31 @@ export class SixbHost<in out TParams extends ParamsConfig = ParamsConfig> {
           ...failure,
         }),
     })
+    const vectorIndexing = this.storage.ontology.vectorIndexing
+    if (
+      vectorIndexing &&
+      definitions.ontology
+        .listObjectTypes()
+        .some((type) => Object.keys(type.search?.vectors ?? {}).length > 0)
+    ) {
+      this.vectorIndexing = new VectorIndexingDispatcher(
+        this.projectId,
+        vectorIndexing,
+        this.queues.vectorIndexing
+      )
+    }
     this.ontologyMaintenance = new OntologyMaintenance({
       projectId: this.projectId,
       storage: this.storage,
       dispatcher: this.committedFacts,
+      vectorIndexing: this.vectorIndexing,
       blobStorage: this.blobStorage,
       options: options.ontologyMaintenance,
     })
 
     this.hostContext = {
       embeddingModels: definitions.models?.embedding,
+      rerankingModels: definitions.models?.reranking,
       projectId: this.projectId,
       broker: this.broker,
       ontology: definitions.ontology,
@@ -277,16 +296,19 @@ export class SixbHost<in out TParams extends ParamsConfig = ParamsConfig> {
       capturedScope.execution
     )
     const embeddingModels = bindEmbeddingModels(this.hostContext.embeddingModels, modelExecution)
+    const rerankingModels = bindRerankingModels(this.hostContext.rerankingModels, modelExecution)
     const objectReader = createAuthorizedObjectReader({
       scope: capturedScope,
       ontology: this.hostContext.ontology,
       objectStorage: this.storage.objects,
       embeddingModels,
+      rerankingModels,
     })
 
     const runtime: SixbRuntimeContext = {
       ...this.hostContext,
       embeddingModels,
+      rerankingModels,
       modelExecution,
       runtimeAuthorization: capturedScope.authorization,
       objectReader,
@@ -296,7 +318,10 @@ export class SixbHost<in out TParams extends ParamsConfig = ParamsConfig> {
       runtime,
       createOntologyMutationRuntime({
         materializer: this.materializer.withScope(capturedScope),
-        notifyCommittedFacts: () => this.committedFacts.notify(),
+        notifyCommittedFacts: () => {
+          this.committedFacts.notify()
+          this.vectorIndexing?.notify()
+        },
       })
     )
     return createBoundSixb<InferSandboxParams<TParams>>(
@@ -352,6 +377,7 @@ export class SixbHost<in out TParams extends ParamsConfig = ParamsConfig> {
   /** Close the runtime broker provider if it owns external resources. */
   async closeBroker(): Promise<void> {
     await this.committedFacts.stop()
+    await this.vectorIndexing?.stop()
     await this.ontologyMaintenance.stop()
     await this.broker.close?.()
   }
@@ -369,6 +395,7 @@ export class SixbHost<in out TParams extends ParamsConfig = ParamsConfig> {
         ? {}
         : { connectorConnections: this.connectorService.connectionProcess }),
       blobStorage: this.blobStorage,
+      apiPublicOrigin: () => getApiPublicOrigin(this),
       lakeStorage: this.lakeStorage,
     }
   }

package/src/runtime/index.ts

@@ -40,6 +40,7 @@ export type {
   ObjectQueryFacetBucket,
   ObjectQueryFacetInput,
   ObjectQueryFacetResult,
+  ObjectQueryFacetsResult,
   ObjectQueryListOptions,
   ObjectQueryRow,
   ObjectReadByIdHandle,