@sixb/core 0.1.11 → 0.1.13

package/src/objects/sdk/object-set.ts

@@ -9,7 +9,6 @@ import type { AuthorizationContext } from "../../authorization"
 import { shareSixbErrorReporter } from "../../error-reporting/capability"
 import type { ExecutionContext } from "../../execution"
 import { assertAuthorizedObjectReaderBinding } from "../../execution/authorized-object-reader"
-import type { ValueType } from "../../ontology"
 import { OntologyValidationError } from "../../ontology/errors"
 import type { ObjectTypeWithPropertyTokens } from "../../ontology/tokens"
 import { shareOntologyMutationRuntime } from "../../runtime/ontology-mutations"
@@ -32,17 +31,13 @@ import { createObjectByIdHandle } from "./object-handle"
 import { createObjectQueryBuilder } from "./query-builder"
 import { createRuntimeQueryExecutor } from "./runtime-query-executor"
 
-export function createObjectSet<
-  TObjectType extends ObjectTypeWithPropertyTokens,
-  TRegisteredObjectTypes extends ObjectTypeWithPropertyTokens,
-  TValueTypes extends readonly ValueType[],
->(
+export function createObjectSet<TObjectType extends ObjectTypeWithPropertyTokens>(
   params: SixbRuntimeContext & {
     readonly execution: ExecutionContext
     readonly objectType: TObjectType
     readonly authorization?: AuthorizationContext
   }
-): ObjectSet<TObjectType, TValueTypes, TRegisteredObjectTypes> {
+): ObjectSet<TObjectType> {
   assertAuthorizedObjectReaderBinding({
     reader: params.objectReader,
     scope: { execution: params.execution, authorization: params.runtimeAuthorization },
@@ -73,6 +68,7 @@ export function createObjectSet<
   })
 
   const resolvedCtx: ExecutionObjectContext = {
+    embeddingModels: params.embeddingModels,
     projectId,
     broker,
     ontology,
@@ -96,21 +92,21 @@ export function createObjectSet<
         objectTypeId: objectType.id,
         primaryId: id,
       })
-      return row ? (row as unknown as TwinObject<TObjectType, TValueTypes>) : null
+      return row ? (row as unknown as TwinObject<TObjectType>) : null
     },
 
     upsert: async (input: { properties: Record<string, unknown> }) => {
       const row = await upsertObjectLeaf(resolvedCtx, input.properties)
-      return row as unknown as TwinObject<TObjectType, TValueTypes>
+      return row as unknown as TwinObject<TObjectType>
     },
 
     query: () =>
-      createObjectQueryBuilder<TObjectType, TRegisteredObjectTypes, TValueTypes>({
+      createObjectQueryBuilder<TObjectType>({
         query: { kind: "start", objectTypeId: objectType.id },
         executor: queryExecutor,
       }),
 
-    byId: (id: string) => createObjectByIdHandle<TObjectType, TValueTypes>(resolvedCtx, id),
+    byId: (id: string) => createObjectByIdHandle<TObjectType>(resolvedCtx, id),
 
     list: async (input?: ObjectSetListInput) => {
       const result = await objectReader.list({
@@ -128,9 +124,7 @@ export function createObjectSet<
       })
 
       return {
-        objects: result.objects.map(
-          (row) => row as unknown as TwinObject<TObjectType, TValueTypes>
-        ),
+        objects: result.objects.map((row) => row as unknown as TwinObject<TObjectType>),
         hasMore: result.hasMore,
         total: result.total ?? result.objects.length,
       }
@@ -229,5 +223,5 @@ export function createObjectSet<
     },
   }
 
-  return objectSet as unknown as ObjectSet<TObjectType, TValueTypes, TRegisteredObjectTypes>
+  return objectSet as unknown as ObjectSet<TObjectType>
 }

package/src/objects/sdk/query-builder.ts

@@ -6,9 +6,9 @@
  * `ObjectQueryExecutor` — the server runtime executor or the HTTP client
  * executor — so the same builder serves both sides.
  */
-import type { ValueType } from "../../ontology"
 import { OntologyValidationError } from "../../ontology/errors"
 import type { LinkToken, ObjectTypeWithPropertyTokens, PropertyToken } from "../../ontology/tokens"
+import { RuntimeError } from "../../runtime/errors"
 import type {
   ListResult,
   ListResultWithoutTotal,
@@ -39,24 +39,40 @@ type QueryBuilderParams = {
   executor: ObjectQueryExecutor
 }
 
-export function createObjectQueryBuilder<
-  TObjectType extends ObjectTypeWithPropertyTokens,
-  TRegisteredObjectTypes extends ObjectTypeWithPropertyTokens,
-  TValueTypes extends readonly ValueType[],
->(
+export function createObjectQueryBuilder<TObjectType extends ObjectTypeWithPropertyTokens>(
   params: QueryBuilderParams
-): ObjectQueryBuilder<TObjectType, TRegisteredObjectTypes, TValueTypes> {
-  return new ObjectQueryBuilderImpl<TObjectType, TRegisteredObjectTypes, TValueTypes>(
+): ObjectQueryBuilder<TObjectType> {
+  return new ObjectQueryBuilderImpl<TObjectType>(
     params
-  ) as unknown as ObjectQueryBuilder<TObjectType, TRegisteredObjectTypes, TValueTypes>
+  ) as unknown as ObjectQueryBuilder<TObjectType>
 }
 
-class ObjectQueryBuilderImpl<
-  TObjectType extends ObjectTypeWithPropertyTokens,
-  TRegisteredObjectTypes extends ObjectTypeWithPropertyTokens,
-  TValueTypes extends readonly ValueType[],
-> {
-  constructor(private readonly params: QueryBuilderParams) {}
+/**
+ * Returns the same query running through the executor `decorate` wraps around the builder's own.
+ *
+ * Refinements copy their builder's executor, so every query derived from the result, and every
+ * terminal it runs, goes through the decorated executor too.
+ */
+export function decorateObjectQueryExecutor<TObjectType extends ObjectTypeWithPropertyTokens>(
+  builder: ObjectQueryBuilder<TObjectType>,
+  decorate: (executor: ObjectQueryExecutor) => ObjectQueryExecutor
+): ObjectQueryBuilder<TObjectType> {
+  // Narrowed from `unknown`: narrowing the builder interface to the class relates both structures.
+  const source: unknown = builder
+  if (!(source instanceof ObjectQueryBuilderImpl)) {
+    throw new RuntimeError(
+      "[Sixb] Only query builders created by createObjectQueryBuilder can change executor."
+    )
+  }
+  return new ObjectQueryBuilderImpl<TObjectType>({
+    ...source.params,
+    executor: decorate(source.params.executor),
+  }) as unknown as ObjectQueryBuilder<TObjectType>
+}
+
+class ObjectQueryBuilderImpl<TObjectType extends ObjectTypeWithPropertyTokens> {
+  /** Not private because `decorateObjectQueryExecutor` reads it; the class is not exported. */
+  constructor(readonly params: QueryBuilderParams) {}
 
   get ir(): ObjectQuery {
     return normalizeObjectQuery(this.params.query)
@@ -64,14 +80,11 @@ class ObjectQueryBuilderImpl<
 
   where(
     whereFn: (
-      builder: ObjectWhereBuilder<TObjectType, TValueTypes>
-    ) =>
-      | ObjectWhereClause<TObjectType, TValueTypes>
-      | readonly ObjectWhereClause<TObjectType, TValueTypes>[]
-  ): ObjectQueryBuilder<TObjectType, TRegisteredObjectTypes, TValueTypes> {
-    const predicate = resolveWhere<TObjectType, TValueTypes>(whereFn)
-    if (!predicate)
-      return this as unknown as ObjectQueryBuilder<TObjectType, TRegisteredObjectTypes, TValueTypes>
+      builder: ObjectWhereBuilder<TObjectType>
+    ) => ObjectWhereClause<TObjectType> | readonly ObjectWhereClause<TObjectType>[]
+  ): ObjectQueryBuilder<TObjectType> {
+    const predicate = resolveWhere<TObjectType>(whereFn)
+    if (!predicate) return this as unknown as ObjectQueryBuilder<TObjectType>
 
     return this.withQuery({
       kind: "filter",
@@ -83,7 +96,7 @@ class ObjectQueryBuilderImpl<
   search(
     query: string,
     options?: { fields?: readonly PropertyToken<TObjectType["id"], string>[] }
-  ): ObjectQueryBuilder<TObjectType, TRegisteredObjectTypes, TValueTypes> {
+  ): ObjectQueryBuilder<TObjectType> {
     return this.withQuery({
       kind: "text",
       input: this.ir,
@@ -92,15 +105,14 @@ class ObjectQueryBuilderImpl<
     })
   }
 
-  vector(
-    property: PropertyToken<TObjectType["id"], string>,
-    vector: readonly number[],
-    options: { k: number }
-  ): ObjectQueryBuilder<TObjectType, TRegisteredObjectTypes, TValueTypes> {
+  vector(profile: string, vector: string, options: { k: number }): ObjectQueryBuilder<TObjectType> {
+    if (typeof profile !== "string" || typeof vector !== "string") {
+      throw new Error("[Sixb] Vector search requires a named profile and search text")
+    }
     return this.withQuery({
       kind: "vector",
       input: this.ir,
-      propertyId: property.id,
+      profile,
       vector,
       k: options.k,
     })
@@ -109,25 +121,21 @@ class ObjectQueryBuilderImpl<
   traverse(
     link: LinkToken<TObjectType["id"], string, string>,
     options?: { direction?: "outgoing" }
-  ): ObjectQueryBuilder<ObjectTypeWithPropertyTokens, TRegisteredObjectTypes, TValueTypes>
+  ): ObjectQueryBuilder<ObjectTypeWithPropertyTokens>
   traverse(
     link: LinkToken<string, string, TObjectType["id"] | readonly TObjectType["id"][]>,
     options: { direction: "incoming" }
-  ): ObjectQueryBuilder<ObjectTypeWithPropertyTokens, TRegisteredObjectTypes, TValueTypes>
+  ): ObjectQueryBuilder<ObjectTypeWithPropertyTokens>
   traverse(
     link: LinkToken,
     options: { direction?: ObjectQueryDirection } = {}
-  ): ObjectQueryBuilder<ObjectTypeWithPropertyTokens, TRegisteredObjectTypes, TValueTypes> {
+  ): ObjectQueryBuilder<ObjectTypeWithPropertyTokens> {
     const direction = options.direction ?? "outgoing"
     if (direction === "outgoing") {
       requireSingleTargetObjectTypeId(link)
     }
 
-    return new ObjectQueryBuilderImpl<
-      ObjectTypeWithPropertyTokens,
-      TRegisteredObjectTypes,
-      TValueTypes
-    >({
+    return new ObjectQueryBuilderImpl<ObjectTypeWithPropertyTokens>({
       ...this.params,
       query: {
         kind: "traverse",
@@ -139,18 +147,14 @@ class ObjectQueryBuilderImpl<
         // matching the result type the fluent API advertises.
         ...(direction === "incoming" ? { sourceObjectTypeId: link.objectTypeId } : {}),
       },
-    }) as unknown as ObjectQueryBuilder<
-      ObjectTypeWithPropertyTokens,
-      TRegisteredObjectTypes,
-      TValueTypes
-    >
+    }) as unknown as ObjectQueryBuilder<ObjectTypeWithPropertyTokens>
   }
 
   expand(
     link: LinkToken<string, string, string | readonly string[]>,
     optionsOrBuild?: ObjectExpandOptions<ObjectTypeWithPropertyTokens> | NestedExpandBuild,
     build?: NestedExpandBuild
-  ): ObjectQueryBuilder<TObjectType, TRegisteredObjectTypes, TValueTypes> {
+  ): ObjectQueryBuilder<TObjectType> {
     return this.withQuery({
       kind: "expand",
       input: this.ir,
@@ -161,7 +165,7 @@ class ObjectQueryBuilderImpl<
   orderBy(
     property: PropertyToken<TObjectType["id"], string>,
     direction?: ObjectQuerySortDirection
-  ): ObjectQueryBuilder<TObjectType, TRegisteredObjectTypes, TValueTypes> {
+  ): ObjectQueryBuilder<TObjectType> {
     return this.withQuery(
       appendSortField(this.ir, {
         kind: "property",
@@ -171,9 +175,7 @@ class ObjectQueryBuilderImpl<
     )
   }
 
-  orderByRelevance(
-    direction?: ObjectQuerySortDirection
-  ): ObjectQueryBuilder<TObjectType, TRegisteredObjectTypes, TValueTypes> {
+  orderByRelevance(direction?: ObjectQuerySortDirection): ObjectQueryBuilder<TObjectType> {
     return this.withQuery(
       appendSortField(this.ir, {
         kind: "relevance",
@@ -182,7 +184,7 @@ class ObjectQueryBuilderImpl<
     )
   }
 
-  limit(limit: number): ObjectQueryBuilder<TObjectType, TRegisteredObjectTypes, TValueTypes> {
+  limit(limit: number): ObjectQueryBuilder<TObjectType> {
     return this.withQuery({
       kind: "limit",
       input: this.ir,
@@ -190,10 +192,7 @@ class ObjectQueryBuilderImpl<
     })
   }
 
-  page(input: {
-    pageSize: number
-    pageToken?: string
-  }): ObjectQueryBuilder<TObjectType, TRegisteredObjectTypes, TValueTypes> {
+  page(input: { pageSize: number; pageToken?: string }): ObjectQueryBuilder<TObjectType> {
     return this.withQuery({
       kind: "page",
       input: this.ir,
@@ -224,25 +223,25 @@ class ObjectQueryBuilderImpl<
     return formatObjectQueryExplanation(this.explain())
   }
 
-  async list(): Promise<ListResult<TwinObject<TObjectType, TValueTypes>>>
+  async list(): Promise<ListResult<TwinObject<TObjectType>>>
   async list(options: {
     includeTotal: false
-  }): Promise<ListResultWithoutTotal<TwinObject<TObjectType, TValueTypes>>>
+    signal?: AbortSignal
+  }): Promise<ListResultWithoutTotal<TwinObject<TObjectType>>>
   async list(options: {
     includeTotal?: true
-  }): Promise<ListResult<TwinObject<TObjectType, TValueTypes>>>
+    signal?: AbortSignal
+  }): Promise<ListResult<TwinObject<TObjectType>>>
   async list(
     options?: ObjectQueryListOptions
   ): Promise<
-    | ListResult<TwinObject<TObjectType, TValueTypes>>
-    | ListResultWithoutTotal<TwinObject<TObjectType, TValueTypes>>
+    ListResult<TwinObject<TObjectType>> | ListResultWithoutTotal<TwinObject<TObjectType>>
   > {
     const result = await this.params.executor.list(this.ir, {
       includeTotal: options?.includeTotal,
+      signal: options?.signal,
     })
-    const objects = result.objects.map(
-      (row) => row as unknown as TwinObject<TObjectType, TValueTypes>
-    )
+    const objects = result.objects.map((row) => row as unknown as TwinObject<TObjectType>)
 
     if (options?.includeTotal === false) {
       return {
@@ -280,26 +279,21 @@ class ObjectQueryBuilderImpl<
     )
   }
 
-  async first(): Promise<TwinObject<TObjectType, TValueTypes> | null> {
+  async first(): Promise<TwinObject<TObjectType> | null> {
     const result = await this.params.executor.list({ kind: "limit", input: this.ir, limit: 1 })
     const row = result.objects[0]
-    return row ? (row as unknown as TwinObject<TObjectType, TValueTypes>) : null
+    return row ? (row as unknown as TwinObject<TObjectType>) : null
   }
 
-  private withQuery(
-    query: ObjectQuery
-  ): ObjectQueryBuilder<TObjectType, TRegisteredObjectTypes, TValueTypes> {
-    return new ObjectQueryBuilderImpl<TObjectType, TRegisteredObjectTypes, TValueTypes>({
+  private withQuery(query: ObjectQuery): ObjectQueryBuilder<TObjectType> {
+    return new ObjectQueryBuilderImpl<TObjectType>({
       ...this.params,
       query,
-    }) as unknown as ObjectQueryBuilder<TObjectType, TRegisteredObjectTypes, TValueTypes>
+    }) as unknown as ObjectQueryBuilder<TObjectType>
   }
 }
 
-type AnyExpandBuilder = ObjectExpandBuilder<
-  ObjectTypeWithPropertyTokens,
-  ObjectTypeWithPropertyTokens
->
+type AnyExpandBuilder = ObjectExpandBuilder<ObjectTypeWithPropertyTokens>
 type NestedExpandBuild = (nested: AnyExpandBuilder) => AnyExpandBuilder
 
 /**

package/src/objects/sdk/query-executor.ts

@@ -11,6 +11,7 @@ import type { ObjectQuery } from "../query/ir"
 import type { ValidatedObjectQuery } from "../query/validate"
 
 export type ObjectQueryExecutorRow = {
+  score?: number
   primaryId: string
   objectTypeId: string
   properties: Record<string, unknown>
@@ -47,7 +48,7 @@ export type ObjectQueryExecutorFacetRequest = {
 export interface ObjectQueryExecutor {
   list(
     query: ObjectQuery,
-    options?: { includeTotal?: boolean }
+    options?: { includeTotal?: boolean; signal?: AbortSignal }
   ): Promise<ObjectQueryExecutorListResult>
   count(query: ObjectQuery): Promise<number>
   exists(query: ObjectQuery): Promise<boolean>

package/src/objects/sdk/runtime-query-executor.ts

@@ -19,9 +19,13 @@ export function createRuntimeQueryExecutor(params: {
   const { ontology, objectReader } = params
 
   return {
-    async list(query: ObjectQuery, options?: { includeTotal?: boolean }) {
+    async list(query: ObjectQuery, options?: { includeTotal?: boolean; signal?: AbortSignal }) {
       try {
-        return await objectReader.executeQuery({ query, includeTotal: options?.includeTotal })
+        return await objectReader.executeQuery({
+          query,
+          includeTotal: options?.includeTotal,
+          signal: options?.signal,
+        })
       } catch (error) {
         if (error instanceof ObjectQueryPlanningError) {
           throw addSdkPlanningHints(error)

package/src/objects/sdk/telemetry-channel.ts

@@ -5,7 +5,6 @@
  * reads the same series back through `getTelemetryHistoryBatch`, both keyed by the property token.
  */
 import type { TelemetryPointWrite } from "../../materialization/model"
-import type { ValueType } from "../../ontology"
 import type { ObjectTypeWithPropertyTokens } from "../../ontology/tokens"
 import {
   assertPropertyTokenBelongsToObjectType,
@@ -20,13 +19,13 @@ import type {
 import type { ResolvedObjectContext } from "../context"
 import { getTelemetryHistoryBatch, writeTelemetryBatch } from "../telemetry"
 
-export function createTelemetryChannel<
-  TObjectType extends ObjectTypeWithPropertyTokens,
-  TValueTypes extends readonly ValueType[],
->(ctx: ResolvedObjectContext, primaryId: string) {
+export function createTelemetryChannel<TObjectType extends ObjectTypeWithPropertyTokens>(
+  ctx: ResolvedObjectContext,
+  primaryId: string
+) {
   return <TToken extends TelemetryPropertyToken<TObjectType>>(
     property: TToken
-  ): TelemetryChannel<TToken, TValueTypes> => {
+  ): TelemetryChannel<TToken> => {
     const { objectType } = ctx
     assertPropertyTokenBelongsToObjectType(objectType, property)
     assertTelemetryProperty(property.property)
@@ -84,6 +83,6 @@ export function createTelemetryChannel<
     }
 
     // Cast needed: generic token inference boundary — TToken is narrower than what `channel` sees
-    return channel as unknown as TelemetryChannel<TToken, TValueTypes>
+    return channel as unknown as TelemetryChannel<TToken>
   }
 }

package/src/objects/sdk/where.ts

@@ -6,7 +6,6 @@
  * on demand through a Proxy, so no runtime ontology access is required —
  * property names are constrained at compile time and validated server-side.
  */
-import type { ValueType } from "../../ontology"
 import type { ObjectTypeWithPropertyTokens } from "../../ontology/tokens"
 import type { ObjectWhereBuilder, ObjectWhereClause } from "../../runtime/types"
 import type { ObjectQueryPredicate } from "../query"
@@ -47,8 +46,7 @@ function createPropertyPredicate(propertyId: string) {
 
 export function createWhereBuilder<
   TObjectType extends ObjectTypeWithPropertyTokens,
-  TValueTypes extends readonly ValueType[],
->(): ObjectWhereBuilder<TObjectType, TValueTypes> {
+>(): ObjectWhereBuilder<TObjectType> {
   const p = new Proxy(
     {},
     {
@@ -62,21 +60,16 @@ export function createWhereBuilder<
     and: (...items: readonly ObjectQueryPredicate[]) => ({ op: "and", items }),
     or: (...items: readonly ObjectQueryPredicate[]) => ({ op: "or", items }),
     not: (item: ObjectQueryPredicate) => ({ op: "not", item }),
-  } as ObjectWhereBuilder<TObjectType, TValueTypes>
+  } as ObjectWhereBuilder<TObjectType>
 }
 
-export function resolveWhere<
-  TObjectType extends ObjectTypeWithPropertyTokens,
-  TValueTypes extends readonly ValueType[],
->(
+export function resolveWhere<TObjectType extends ObjectTypeWithPropertyTokens>(
   whereFn?: (
-    builder: ObjectWhereBuilder<TObjectType, TValueTypes>
-  ) =>
-    | ObjectWhereClause<TObjectType, TValueTypes>
-    | readonly ObjectWhereClause<TObjectType, TValueTypes>[]
+    builder: ObjectWhereBuilder<TObjectType>
+  ) => ObjectWhereClause<TObjectType> | readonly ObjectWhereClause<TObjectType>[]
 ): ObjectQueryPredicate | undefined {
   if (!whereFn) return undefined
-  const whereBuilder = createWhereBuilder<TObjectType, TValueTypes>()
+  const whereBuilder = createWhereBuilder<TObjectType>()
   const whereInput = whereFn(whereBuilder)
   if (!whereInput) return undefined
   const predicates = (

package/src/objects/vectors/README.md

@@ -0,0 +1,59 @@
+# Vector indexing
+
+A named profile identifies a derived representation, separate from object properties.
+
+```text
+Effective object change → invalidate stale vector + persist latest intent (one transaction)
+ProjectionWorker → durable queue → project AI admission → provider → save result → fenced commit
+```
+
+`materializer/effective/vector-indexing.ts` compares effective source fingerprints after projection
+conflict resolution, including managed overrides. New objects schedule every profile. Unrelated
+changes schedule nothing. Deletion removes intent; each new generation replaces the old id.
+There is no historical scan or configuration-only backfill.
+
+The queue owns delivery leases. Ontology storage owns intent keyed by project/object/profile, plus
+its generation id and `pending → running → ready` state. Dispatch has a separate due time so long
+queues cannot starve later entries. Reconciliation can enqueue the same generation safely.
+
+`indexing.ts` exposes only a core-owned processing capability. Kernel authority cannot bind the
+public domain SDK. `ontology.indexVectors` authorizes only the persisted results of its work item or durable group.
+The Materializer checks membership, identity, values and each object/vector revision in the transaction. Execution provenance
+references the source ontology commit; requester and groups are empty, so only project budgets apply.
+
+The durable `running` fence precedes admission, so superseded work cannot reserve budget. The
+provider starts only after both succeed. An admission rejection returns work to pending for retry.
+Redelivered `running` work has an uncertain provider outcome: fail visibly through `onError`, never
+silently repeat inference. The provider may have billed a lost response. Failures remain inspectable until superseded or explicitly indexed.
+
+Persist `ready` values before committing. On unrelated edits, reprepare the object revision and reuse
+those values. Source changes, deletion/recreation, or configuration mismatch discard obsolete work.
+A vector-only commit never schedules itself. Manual indexing remains available through authorized
+SDK executions; its valid result also makes queued work unnecessary.
+
+Projection replacement assigns `batchId` within each materialization page: same object type,
+profile, configuration and source commit, at most 32 members / 32 KiB of serialized source text.
+Membership is stored alongside intent in the activation transaction; there is no fill timer, process
+buffer or cross-run aggregation. An oversized text is isolated, never truncated.
+
+Dispatch uses the group id. Processing reads current members, drops obsolete work, and splits them
+to the adapter's optional `EmbeddingModel.batching` count / UTF-8 byte bounds. Unknown bounds or
+oversized inputs use individual calls. Search, explicit indexing and managed edits stay individual.
+Each actual provider request produces one usage/cost record, under the project's group execution.
+Admission claims all prepared members atomically before reserving budget; a superseded member
+aborts that claim. Results become ready atomically for surviving members, then publish together in
+one materialization transaction. PostgreSQL groups vector writes and intent cleanup in SQL; SQLite
+reuses prepared statements within that transaction. Every object and vector retains its own revision
+fence. A conflict rolls back publication and reprepares the current subset without inference. After
+three conflicts, individual publication lets stable peers finish while contended members are deferred.
+Restarted ready members only retry storage; running members fail with an unknown outcome.
+A partly processed group publishes ready members together and resumes other members individually.
+
+Network calls never hold storage transactions. Applications without projections do not start this
+indexing consumer. Byte bounds are conservative transport eligibility, not the accounting layer's
+token estimate; they do not reject or truncate a text that can still be sent individually.
+
+Terminal failures persist a canonical `SixbFailure` before `onError`: `vector.model_unavailable`,
+`vector.response_invalid`, or `vector.outcome_unknown` for interrupted calls. Unclassified failures
+use `internal.unexpected`. These codes never authorize automatic inference retries. Accounting uses
+`ModelExecutionSession`; its existing recovery consumer can replay accounting without inference.

package/src/objects/vectors/handle.ts

@@ -0,0 +1,91 @@
+import { randomUUID } from "node:crypto"
+import { assertCanEdit } from "../../authorization"
+import { AuthorizationError } from "../../authorization/errors"
+import { MaterializationValidationError } from "../../materialization/errors"
+import type { PreparedObjectVector } from "../../materialization/vectors"
+import { sameEmbeddingModel } from "../../models/embedding-model"
+import { getOntologyMutationRuntime } from "../../runtime/ontology-mutations"
+import type { ExecutionObjectContext } from "../context"
+import { normalizeVector, vectorConfiguration, vectorSources } from "./profile"
+import type { ObjectVectorHandle } from "./types"
+
+export function createObjectVectorHandle(
+  ctx: ExecutionObjectContext,
+  primaryId: string,
+  profileName: string
+): ObjectVectorHandle {
+  const ref = Object.freeze({ objectTypeId: ctx.objectType.id, primaryId })
+  const profileDefinition = ctx.ontology.resolveObjectType(ref.objectTypeId).search?.vectors?.[
+    profileName
+  ]
+  if (!profileDefinition)
+    throw new MaterializationValidationError(`Unknown vector profile: ${profileName}`)
+  const vectors = ctx.storage.ontology.vectors
+  if (!vectors)
+    throw new MaterializationValidationError("Storage does not support vector profiles.")
+
+  const assertReadable = async () => {
+    const allowed = await ctx.objectReader.canReadObjectPropertiesBatch({
+      items: profileDefinition.source.map((propertyId) => ({ ...ref, propertyId })),
+    })
+    if (allowed.some((value) => !value))
+      throw new AuthorizationError(
+        `view:object:${ref.objectTypeId}`,
+        "[Sixb] Vector profile requires access to all its source properties."
+      )
+  }
+
+  return Object.freeze({
+    async index(): Promise<void> {
+      assertCanEdit(ctx, ref.objectTypeId)
+      await assertReadable()
+      const mutations = getOntologyMutationRuntime(ctx)
+      const model = ctx.embeddingModels?.getByRef({
+        provider: profileDefinition.model.providerId,
+        modelId: profileDefinition.model.modelId,
+      })?.model
+      if (!model || !sameEmbeddingModel(model, profileDefinition.model)) {
+        throw new MaterializationValidationError(
+          `Vector profile '${profileName}' requires its configured embedding model.`
+        )
+      }
+      const row = await ctx.objectReader.getByPrimaryId(ref)
+      if (!row) throw new MaterializationValidationError("Cannot index a missing object.")
+      const current = (await vectors.list({ projectId: ctx.projectId, ref })).find(
+        (entry) => entry.profile === profileName
+      )
+      const input: PreparedObjectVector = {
+        projectId: ctx.projectId,
+        ref,
+        profile: profileName,
+        configuration: vectorConfiguration(profileDefinition),
+        ...vectorSources(profileDefinition.source, row.properties),
+        expectedObject: { ref, exists: true, version: row.version, lastCommitId: row.lastCommitId },
+        expectedVectorCommitId: current?.lastCommitId ?? null,
+      }
+
+      // Network work never holds a storage transaction or retries an obsolete computation.
+      const result = await model.embed({ texts: [input.text] })
+      if (!Array.isArray(result?.vectors) || result.vectors.length !== 1) {
+        throw new MaterializationValidationError(
+          "Embedding model must return exactly one vector for one input text."
+        )
+      }
+      const values = normalizeVector(
+        result.vectors[0]!,
+        profileDefinition.model.definition.dimensions
+      )
+      assertCanEdit(ctx, ref.objectTypeId)
+      await assertReadable()
+      await mutations.commitEdits({
+        mode: "atomic",
+        source: { kind: "runtime", requestId: randomUUID() },
+        operations: [],
+        vectorWrites: [{ input, values }],
+        expectedObjects: [input.expectedObject],
+        expectedLinks: [],
+        expectedLinkScopes: [],
+      })
+    },
+  })
+}