@sixb/core 0.1.14 → 0.1.16

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,25 @@ 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 !== "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,
@@ -446,19 +447,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/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/projections/types.ts

@@ -6,6 +6,7 @@ export const PROJECTION_RUN_FAILURE_CODES = [
   "runtime.cancelled",
   "queue.enqueue_failed",
   "projection.execution_failed",
+  "storage.unavailable",
 ] as const satisfies readonly [SixbErrorCode, ...SixbErrorCode[]]
 
 export type ProjectionRunFailureCode = (typeof PROJECTION_RUN_FAILURE_CODES)[number]

package/src/storage/index.ts

@@ -449,8 +449,11 @@ export {
   snapshotObjectReadExecutionLimits,
 } from "./objects"
 export type {
+  AbandonRunSourceMaterializationInput,
   AbandonSourceMaterializationCandidateInput,
   AbandonSourceMaterializationInput,
+  AdoptedSourceMaterialization,
+  AdoptSourceMaterializationInput,
   ApplyMaterializationChunkInput,
   ApplyMaterializationResult,
   AssertSourceMaterializationExecution,
@@ -530,9 +533,9 @@ export type {
   OntologyStorage,
   OntologyVectorStorage,
   ProjectionOntologyCommitIntent,
+  PurgeAbandonedSourceMaterializationsInput,
   PurgePublishedOntologyOutboxInput,
   ReadMaterializationObjectExistenceInput,
-  ReclaimSourceMaterializationInput,
   RescheduleOntologyOutboxLeaseInput,
   SourceActivationWrite,
   SourceReplacementLinkState,
@@ -595,6 +598,7 @@ export {
 export type {
   AdvanceProjectionTelemetryCheckpointInput,
   FailProjectionRunEnqueueInput,
+  FindSupersedingProjectionRunInput,
   FinishProjectionRunInput,
   LinkProjectionRunRecord,
   LinkProjectionTarget,
@@ -616,6 +620,7 @@ export type {
   ProjectionTarget,
   ProjectionTelemetryCheckpoint,
   QueueProjectionRunInput,
+  RecordProjectionAttemptFailureInput,
   RecordProjectionMissingTargetInput,
   StartOrReclaimProjectionRunInput,
   TelemetryProjectionRunRecord,

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

@@ -16,8 +16,11 @@ import {
   sourceStageRoots,
 } from "../provider"
 import type {
+  AbandonRunSourceMaterializationInput,
   AbandonSourceMaterializationCandidateInput,
   AbandonSourceMaterializationInput,
+  AdoptedSourceMaterialization,
+  AdoptSourceMaterializationInput,
   AssertSourceMaterializationExecution,
   BeginSourceMaterializationInput,
   CleanupTerminalSourceMaterializationsInput,
@@ -26,7 +29,7 @@ import type {
   MarkSourceMaterializationReadyInput,
   OntologySourceRecord,
   OntologySourceStorage,
-  ReclaimSourceMaterializationInput,
+  PurgeAbandonedSourceMaterializationsInput,
   StageSourceAssertion,
   StageSourceRowsInput,
   StageSourceRowsResult,
@@ -38,6 +41,7 @@ import {
   assertNonblank,
   type InMemoryOntologyState,
   type InMemorySourceMaterialization,
+  type InMemorySourceRoot,
   insertBounded,
   sourceMaterializationKey,
   sourceMaterializationRecord,
@@ -78,7 +82,7 @@ export class InMemoryOntologySourceStorage implements OntologySourceStorage {
       )
       if (nonterminal.length > 0) {
         throw sourceConflict(
-          `Projection run '${input.execution.projectionRunId}' already has a nonterminal source materialization; reclaim it before beginning another.`
+          `Projection run '${input.execution.projectionRunId}' already has a nonterminal source materialization; adopt it before beginning another.`
         )
       }
 
@@ -191,8 +195,42 @@ export class InMemoryOntologySourceStorage implements OntologySourceStorage {
     })
   }
 
+  async adopt(
+    input: AdoptSourceMaterializationInput
+  ): Promise<AdoptedSourceMaterialization | null> {
+    return this.runRootOperation(async () => {
+      assertProjectAndSource(input)
+      assertSourceExecutionIdentity(input.execution.projectionRunId, input.execution.executionToken)
+      assertCanonicalTimestamp(input.adoptedAt, "Source adoptedAt")
+      await this.assertCurrentExecution(input)
+      const [candidate, ...others] = this.findRunCandidates(
+        input.projectId,
+        input.source.projectionId,
+        input.execution.projectionRunId
+      )
+      if (!candidate) return null
+      if (others.length > 0) throw multipleRunCandidates(input.execution.projectionRunId)
+      const [key, materialization] = candidate
+      const adopted: InMemorySourceMaterialization = {
+        ...materialization,
+        executionToken: input.execution.executionToken,
+        // Workers' clocks differ; adoption never moves the record back in time.
+        updatedAt:
+          input.adoptedAt > materialization.updatedAt ? input.adoptedAt : materialization.updatedAt,
+      }
+      this.state.sourceMaterializations.set(key, adopted)
+      return {
+        record: sourceMaterializationRecord(adopted),
+        resumeStagingOrdinal:
+          adopted.status === "ready"
+            ? (adopted.rootCount ?? 0)
+            : Math.max(0, ...adopted.ordinalRoots.keys()),
+      }
+    })
+  }
+
   async abandon(input: AbandonSourceMaterializationCandidateInput): Promise<OntologySourceRecord>
-  async abandon(input: ReclaimSourceMaterializationInput): Promise<OntologySourceRecord | null>
+  async abandon(input: AbandonRunSourceMaterializationInput): Promise<OntologySourceRecord | null>
   async abandon(input: AbandonSourceMaterializationInput): Promise<OntologySourceRecord | null> {
     return this.runRootOperation(async () => {
       assertProjectAndSource(input)
@@ -201,7 +239,7 @@ export class InMemoryOntologySourceStorage implements OntologySourceStorage {
       await this.assertCurrentExecution(input)
       return input.kind === "candidate"
         ? this.abandonCandidate(input)
-        : this.abandonForReclaim(input)
+        : this.abandonRunCandidate(input)
     })
   }
 
@@ -211,18 +249,14 @@ export class InMemoryOntologySourceStorage implements OntologySourceStorage {
     return this.runRootOperation(() => {
       assertNonblank(input.projectId, "Terminal source cleanup project id")
       assertCanonicalTimestamp(input.terminalBefore, "Terminal source cleanup cutoff")
-      if (!Number.isSafeInteger(input.limit) || input.limit <= 0) {
-        throw new MaterializationValidationError(
-          "Terminal source cleanup limit must be a positive safe integer."
-        )
-      }
+      assertCleanupLimit(input.limit)
 
       const candidates: [string, InMemorySourceMaterialization][] = []
       for (const entry of this.state.sourceMaterializations.entries()) {
         const materialization = entry[1]
         if (
           materialization.projectId !== input.projectId ||
-          (materialization.status !== "superseded" && materialization.status !== "abandoned") ||
+          materialization.status !== "superseded" ||
           materialization.terminalAt === null ||
           materialization.terminalAt >= input.terminalBefore
         ) {
@@ -239,42 +273,69 @@ export class InMemoryOntologySourceStorage implements OntologySourceStorage {
         insertBounded(candidates, entry, input.limit, compareTerminalMaterializations)
       }
 
-      let remaining = input.limit
-      let rowsDeleted = 0
-      let materializationsDeleted = 0
-      for (const [key, candidate] of candidates) {
+      return this.deleteRetiredRoots(
+        candidates,
+        input.limit,
+        (root) => !root.active && root.retiredAt !== null && root.retiredAt < input.terminalBefore
+      )
+    })
+  }
+
+  async purgeAbandoned(
+    input: PurgeAbandonedSourceMaterializationsInput
+  ): Promise<CleanupTerminalSourceMaterializationsResult> {
+    return this.runRootOperation(() => {
+      assertNonblank(input.projectId, "Abandoned source purge project id")
+      assertCleanupLimit(input.limit)
+      const abandoned = [...this.state.sourceMaterializations.entries()]
+        .filter(
+          ([, materialization]) =>
+            materialization.projectId === input.projectId && materialization.status === "abandoned"
+        )
+        .sort(compareTerminalMaterializations)
+      return this.deleteRetiredRoots(abandoned, input.limit, () => true)
+    })
+  }
+
+  private deleteRetiredRoots(
+    candidates: readonly [string, InMemorySourceMaterialization][],
+    limit: number,
+    retired: (root: InMemorySourceRoot) => boolean
+  ): CleanupTerminalSourceMaterializationsResult {
+    let remaining = limit
+    let rowsDeleted = 0
+    let materializationsDeleted = 0
+    for (const [key, candidate] of candidates) {
+      if (remaining === 0) break
+      const current = this.state.sourceMaterializations.get(key)
+      if (current !== candidate) continue
+      current.rootOrdinals.clear()
+      current.ordinalRoots.clear()
+      for (const [rootKey, root] of current.roots) {
         if (remaining === 0) break
-        const current = this.state.sourceMaterializations.get(key)
-        if (current !== candidate) continue
-        current.rootOrdinals.clear()
-        current.ordinalRoots.clear()
-        for (const [rootKey, root] of current.roots) {
+        if (!retired(root)) continue
+        for (const entityKey of root.entityKeys) {
           if (remaining === 0) break
-          if (root.active || root.retiredAt === null || root.retiredAt >= input.terminalBefore)
-            continue
-          for (const entityKey of root.entityKeys) {
-            if (remaining === 0) break
-            current.rowsByEntity.delete(entityKey)
-            root.entityKeys.delete(entityKey)
-            rowsDeleted += 1
-            remaining -= 1
-          }
-          if (root.entityKeys.size === 0 && remaining > 0) {
-            current.roots.delete(rootKey)
-            current.rootOrdinals.delete(rootKey)
-            current.ordinalRoots.delete(root.stagingOrdinal)
-            rowsDeleted += 1
-            remaining -= 1
-          }
+          current.rowsByEntity.delete(entityKey)
+          root.entityKeys.delete(entityKey)
+          rowsDeleted += 1
+          remaining -= 1
         }
-        if (current.roots.size === 0 && current.rowsByEntity.size === 0 && remaining > 0) {
-          this.state.sourceMaterializations.delete(key)
-          materializationsDeleted += 1
+        if (root.entityKeys.size === 0 && remaining > 0) {
+          current.roots.delete(rootKey)
+          current.rootOrdinals.delete(rootKey)
+          current.ordinalRoots.delete(root.stagingOrdinal)
+          rowsDeleted += 1
           remaining -= 1
         }
       }
-      return { rowsDeleted, materializationsDeleted }
-    })
+      if (current.roots.size === 0 && current.rowsByEntity.size === 0 && remaining > 0) {
+        this.state.sourceMaterializations.delete(key)
+        materializationsDeleted += 1
+        remaining -= 1
+      }
+    }
+    return { rowsDeleted, materializationsDeleted }
   }
 
   async summarizeTerminal(
@@ -356,26 +417,15 @@ export class InMemoryOntologySourceStorage implements OntologySourceStorage {
     return this.transitionToAbandoned(materialization, input.abandonedAt)
   }
 
-  private abandonForReclaim(input: ReclaimSourceMaterializationInput): OntologySourceRecord | null {
+  private abandonRunCandidate(
+    input: AbandonRunSourceMaterializationInput
+  ): OntologySourceRecord | null {
     const candidates = this.findRunCandidates(
       input.projectId,
       input.source.projectionId,
       input.execution.projectionRunId
     )
-    if (
-      candidates.some(
-        ([, materialization]) => materialization.executionToken === input.execution.executionToken
-      )
-    ) {
-      throw sourceConflict(
-        `Projection run '${input.execution.projectionRunId}' already has a source materialization owned by the current execution.`
-      )
-    }
-    if (candidates.length > 1) {
-      throw sourceConflict(
-        `Projection run '${input.execution.projectionRunId}' has multiple nonterminal source materializations.`
-      )
-    }
+    if (candidates.length > 1) throw multipleRunCandidates(input.execution.projectionRunId)
     const candidate = candidates[0]?.[1]
     return candidate ? this.transitionToAbandoned(candidate, input.abandonedAt) : null
   }
@@ -609,6 +659,20 @@ function assertNotBefore(
   }
 }
 
+function assertCleanupLimit(limit: number): void {
+  if (!Number.isSafeInteger(limit) || limit <= 0) {
+    throw new MaterializationValidationError(
+      "Terminal source cleanup limit must be a positive safe integer."
+    )
+  }
+}
+
+function multipleRunCandidates(projectionRunId: string) {
+  return sourceConflict(
+    `Projection run '${projectionRunId}' has multiple nonterminal source materializations.`
+  )
+}
+
 function compareTerminalMaterializations(
   [, left]: readonly [string, InMemorySourceMaterialization],
   [, right]: readonly [string, InMemorySourceMaterialization]

package/src/storage/ontology/index.ts

@@ -97,8 +97,11 @@ export type {
 } from "./outbox"
 export { ONTOLOGY_OUTBOX_FAILURE_CODES } from "./outbox"
 export type {
+  AbandonRunSourceMaterializationInput,
   AbandonSourceMaterializationCandidateInput,
   AbandonSourceMaterializationInput,
+  AdoptedSourceMaterialization,
+  AdoptSourceMaterializationInput,
   AssertSourceMaterializationExecution,
   AssertSourceMaterializationExecutionInput,
   BeginSourceMaterializationInput,
@@ -109,7 +112,7 @@ export type {
   OntologySourceMaterializationStatus,
   OntologySourceRecord,
   OntologySourceStorage,
-  ReclaimSourceMaterializationInput,
+  PurgeAbandonedSourceMaterializationsInput,
   StageSourceAssertion,
   StageSourceRoot,
   StageSourceRowsInput,

package/src/storage/ontology/provider.ts

@@ -11,6 +11,8 @@ import type {
   ExpectedObjectRevision,
   OntologyLinkRef,
   OntologyObjectRef,
+  ProjectionEntityRef,
+  ProjectionSourceAssertion,
 } from "../../materialization/model"
 import { linkRefKey, objectRefKey, projectionEntityKey } from "../../materialization/refs"
 import type { OntologyCommitOriginSelector, OntologyCommitWrite } from "./commits"
@@ -716,7 +718,6 @@ export function sourceStageRow(row: StageSourceAssertion): SourceStageRow {
 export interface SourceStageRoot {
   readonly root: StageSourceAssertion["root"]
   readonly rootKey: string
-  readonly sortKey: string
   readonly stagingOrdinal: number
   readonly deleted: boolean
 }
@@ -763,7 +764,6 @@ export function sourceStageRoots(
       roots.set(key, {
         root: row.root,
         rootKey: key,
-        sortKey: utf8SortKey(key),
         stagingOrdinal: row.stagingOrdinal,
         deleted,
       })
@@ -965,12 +965,69 @@ export function sourceEntityColumns(entity: StageSourceAssertion["root"]): {
   }
 }
 
-export function utf8SortKey(canonicalKey: string): string {
-  let key = ""
-  for (const byte of new TextEncoder().encode(canonicalKey)) {
-    key += byte.toString(16).padStart(2, "0")
+/** The inverse of `projectionEntityKey`, for providers that store only the canonical key. */
+export function sourceEntityFromKey(key: string): ProjectionEntityRef {
+  const parts: unknown = JSON.parse(key)
+  if (Array.isArray(parts) && parts.every((part) => typeof part === "string")) {
+    if (parts[0] === "object" && parts.length === 3) {
+      return { kind: "object", ref: { objectTypeId: parts[1]!, primaryId: parts[2]! } }
+    }
+    if (parts[0] === "link" && parts.length === 6) {
+      return {
+        kind: "link",
+        ref: {
+          source: { objectTypeId: parts[1]!, primaryId: parts[2]! },
+          linkId: parts[3]!,
+          target: { objectTypeId: parts[4]!, primaryId: parts[5]! },
+        },
+      }
+    }
   }
-  return key
+  throw new MaterializationConflictError(
+    "source-materialization",
+    `Stored source key ${key} is not a canonical entity key.`
+  )
+}
+
+/** What an assertion carries beyond its identity, or null when that is nothing. */
+export function sourceAssertionPayload(
+  assertion: ProjectionSourceAssertion
+): Readonly<Record<string, unknown>> | null {
+  const { kind: _kind, ref: _ref, ...payload } = assertion
+  return Object.keys(payload).length === 0 ? null : payload
+}
+
+/** Rebuilds an assertion from its typed identity columns and its payload. */
+export function sourceAssertionFromColumns(
+  columns: {
+    readonly entity_kind: "object" | "link"
+    readonly object_type_id: string | null
+    readonly primary_id: string | null
+    readonly source_type_id: string | null
+    readonly source_primary_id: string | null
+    readonly link_id: string | null
+    readonly target_type_id: string | null
+    readonly target_primary_id: string | null
+  },
+  payload: unknown
+): ProjectionSourceAssertion {
+  const rest = (payload ?? {}) as Record<string, unknown>
+  if (columns.entity_kind === "object") {
+    return {
+      kind: "object",
+      ref: { objectTypeId: columns.object_type_id!, primaryId: columns.primary_id! },
+      ...rest,
+    } as ProjectionSourceAssertion
+  }
+  return {
+    kind: "link",
+    ref: {
+      source: { objectTypeId: columns.source_type_id!, primaryId: columns.source_primary_id! },
+      linkId: columns.link_id!,
+      target: { objectTypeId: columns.target_type_id!, primaryId: columns.target_primary_id! },
+    },
+    ...rest,
+  } as ProjectionSourceAssertion
 }
 
 export function isExactStagingManifest(