@sixb/core 0.1.10 → 0.1.12

package/src/execution/authorized-object-reader.ts

@@ -1,6 +1,7 @@
 import { assertAuthorized, isAllowed } from "../authorization"
 import { AuthorizationError } from "../authorization/errors"
 import type { AuthorizationContext } from "../authorization/types"
+import type { EmbeddingModelCatalog } from "../models/catalog"
 import {
   type AuthorizedOntologySelection,
   type AuthorizedOntologyView,
@@ -84,6 +85,7 @@ class AuthorizedObjectReaderImpl {
   readonly #authority: ResolvedExecutionAuthority
   readonly #runtime: RuntimeReadAuthorization
   readonly #ontology: OntologyRegistry
+  readonly #embeddingModels?: EmbeddingModelCatalog
   #ontologyView?: AuthorizedOntologyView
   readonly #storage: ObjectReadStorage
   readonly #delegatedObjectTypeIds?: ReadonlySet<string>
@@ -95,6 +97,7 @@ class AuthorizedObjectReaderImpl {
     input: {
       readonly scope: ExecutionScope
       readonly ontology: OntologyRegistry
+      readonly embeddingModels?: EmbeddingModelCatalog
       readonly storage: ObjectReadStorage
       readonly authority: ResolvedExecutionAuthority
     }
@@ -106,6 +109,7 @@ class AuthorizedObjectReaderImpl {
     this.#authorization = input.scope.authorization
     this.#authority = input.authority
     this.#ontology = input.ontology
+    this.#embeddingModels = input.embeddingModels
     this.#storage = input.storage
     this.#delegatedObjectTypeIds =
       input.authority.type === "delegated"
@@ -316,6 +320,7 @@ class AuthorizedObjectReaderImpl {
           query: executionQuery,
           ...(includeTotal === undefined ? {} : { includeTotal }),
           projectId: this.#runtime.projectId,
+          signal: input.signal,
         },
         this.#queryExecutorOptions()
       )
@@ -459,10 +464,15 @@ class AuthorizedObjectReaderImpl {
       // The selected storage instance is the private execution capability. Passing the delegated
       // runtime token into the generic executor would either reject this admitted query or tempt a
       // forgeable bypass flag; neither is needed at this nominal boundary.
-      return { ontology: this.#ontology, storage: this.#storage }
+      return {
+        ontology: this.#ontology,
+        storage: this.#storage,
+        embeddingModels: this.#embeddingModels,
+      }
     }
     return {
       ontology: this.#ontology,
+      embeddingModels: this.#embeddingModels,
       storage: this.#storage,
       runtimeAuthorization: this.#runtime.runtimeAuthorization,
       ...(this.#runtime.authorization === undefined
@@ -546,6 +556,7 @@ export type AuthorizedObjectReader = AuthorizedObjectReaderImpl
 export function createAuthorizedObjectReader(input: {
   readonly scope: ExecutionScope
   readonly ontology: OntologyRegistry
+  readonly embeddingModels?: EmbeddingModelCatalog
   readonly objectStorage: ObjectStorage
 }): AuthorizedObjectReader {
   const scope = captureExecutionScope(input.scope)
@@ -555,6 +566,7 @@ export function createAuthorizedObjectReader(input: {
   const reader = new AuthorizedObjectReaderImpl(readerConstructionKey, {
     scope,
     ontology: input.ontology,
+    embeddingModels: input.embeddingModels,
     storage,
     authority,
   })
@@ -681,7 +693,30 @@ function snapshotFacetRequests(facets: readonly ObjectFacetRequest[]): ObjectFac
 /** Capture one serializable query before either authorization or execution sees it. */
 function snapshotAuthoredQuery(query: ObjectQuery): ObjectQuery {
   try {
-    return structuredClone(query)
+    const snapshot = structuredClone(query)
+    const pending = [snapshot]
+    const seen = new Set<ObjectQuery>()
+    for (const node of pending) {
+      if (seen.has(node)) continue
+      seen.add(node)
+      if (
+        node.kind === "vector" &&
+        (typeof node.vector !== "string" ||
+          typeof node.profile !== "string" ||
+          "propertyId" in node)
+      ) {
+        throw new ObjectQueryValidationError([
+          {
+            path: "$",
+            code: "invalid_vector_search_input",
+            message: "Vector search requires a named profile and search text",
+          },
+        ])
+      }
+      if ("input" in node) pending.push(node.input)
+      if (node.kind === "set") pending.push(...node.inputs)
+    }
+    return snapshot
   } catch (error) {
     if (error instanceof ObjectQueryValidationError) throw error
     throw new ObjectQueryValidationError([

package/src/execution/kernel-operation.ts

@@ -0,0 +1,27 @@
+import type { KernelOperation } from "./types"
+
+export function kernelOperationId(operation: KernelOperation): string {
+  switch (operation.type) {
+    case "ontology.recover":
+      return operation.recoveryId
+    case "ontology.indexVectors":
+      return operation.indexingId
+    default:
+      return unknownOperation(operation)
+  }
+}
+
+export function kernelOperationFromId(type: KernelOperation["type"], id: string): KernelOperation {
+  switch (type) {
+    case "ontology.recover":
+      return { type, recoveryId: id }
+    case "ontology.indexVectors":
+      return { type, indexingId: id }
+    default:
+      return unknownOperation(type)
+  }
+}
+
+function unknownOperation(_operation: never): never {
+  throw new Error("[Sixb] Unknown kernel operation.")
+}

package/src/execution/scopes.ts

@@ -197,6 +197,8 @@ function sourceIdentifier(source: ExecutionSource): {
   readonly value: string
 } {
   switch (source.type) {
+    case "ontologyCommit":
+      return { label: "Execution source commit id", value: source.commitId }
     case "http":
       return { label: "Execution source request id", value: source.requestId }
     case "webhook":

package/src/execution/types.ts

@@ -26,10 +26,9 @@ export interface SharedAccessDelegationRef {
   readonly sessionId: string
 }
 
-export type KernelOperation = {
-  readonly type: "ontology.recover"
-  readonly recoveryId: string
-}
+export type KernelOperation =
+  | { readonly type: "ontology.recover"; readonly recoveryId: string }
+  | { readonly type: "ontology.indexVectors"; readonly indexingId: string }
 
 /** Workload currently executing. This is provenance and never grants authority by itself. */
 export type ExecutionExecutor =
@@ -49,6 +48,7 @@ export type ExecutionExecutor =
  * An `execution` source is the single logical parent of a nested execution.
  */
 export type ExecutionSource =
+  | { 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/index.ts

@@ -27,6 +27,7 @@ export type {
   ObjectTypeSearchMetadata,
   ObjectTypeWithPropertyTokens,
   ObjectTypeWithTokens,
+  ObjectVectorSearchProfile,
   Ontology,
   OntologyDefinitionCatalog,
   OntologyRegistryOptions,
@@ -600,6 +601,7 @@ export type {
   SandboxFileRecord,
   SandboxNetworkPolicy,
   SandboxNetworkTarget,
+  SandboxRequestCredential,
   SandboxSessionOptions,
   SandboxStatus,
 } from "./sandboxes"
@@ -897,6 +899,7 @@ export type {
   SixbRunFailedContext,
   SixbRunFailureByKind,
   SixbRunIdentityByKind,
+  SixbVectorIndexingFailedContext,
 } from "./error-reporting/types"
 export type { SixbErrorCode, SixbFailure } from "./errors/types"
 export type { EventsRuntime } from "./events/execution"
@@ -922,6 +925,10 @@ export type {
   ObjectQueryLinksResult,
   ObjectsRuntime,
 } from "./objects/execution"
+export type {
+  ObjectVectorHandle,
+  VectorProfileName,
+} from "./objects/vectors/types"
 export type { PipelineRunsRuntime, PipelinesRuntime } from "./pipelines/execution"
 export type {
   ProjectionRunsRuntime,
@@ -990,6 +997,7 @@ export type {
   WebhookRunFailureCode,
   WorkflowRunFailureCode,
 } from "./storage"
+export type { VectorIndexingFailureCode } from "./storage/ontology/vector-indexing"
 export type { SyncRunsRuntime, SyncsRuntime } from "./syncs/execution"
 export type {
   LatestWorkflowRunListResult,
@@ -1066,16 +1074,51 @@ export {
   MAX_AGENT_APP_STATE_TOTAL_BYTES,
   MAX_AGENT_CONTEXT_ENTRIES,
 } from "./agents"
-export type { AgentThreadRecord, ListAgentThreadsResult } from "./storage/agents"
+export type { SandboxSourceAuth, SandboxSourceCredentials } from "./sandboxes/auth"
+export type {
+  SandboxConfig,
+  SandboxDefinition,
+  SandboxEnvironment,
+  SandboxResolveContext,
+  SandboxSource,
+} from "./sandboxes/configuration"
+export type { ParamOptions } from "./shared/params/builders"
+export type { InferParams, ParamConfig, ParamsConfig } from "./shared/params/types"
+export type {
+  AgentThreadRecord,
+  AgentThreadSandboxParams,
+  AgentThreadSandboxState,
+  ListAgentThreadsResult,
+} from "./storage/agents"
 
 // ── Models ──────────────────────────────────────────────────
 
 export type {
+  EmbeddingBatchLimits,
+  EmbeddingModel,
+  EmbeddingModelCatalog,
+  EmbeddingModelDefinition,
+  EmbeddingModelEntry,
+  EmbeddingModelRef,
+  EmbeddingModelRequest,
+  EmbeddingModelResponseMetadata,
+  EmbeddingModelResult,
   LanguageModelCatalog,
   LanguageModelEntry,
   LanguageModelRef,
+  ModelCallCost,
   ModelCatalog,
   ModelCatalogInput,
+  ModelCostComponent,
+  ModelCostEstimate,
+  ModelCostEstimator,
+  ModelCostMeter,
+  ModelMoney,
+  ModelProviderIds,
+  ModelRef,
+  ModelReportedCost,
+  ModelRoute,
+  ModelUsage,
 } from "./models"
 export type {
   InferLanguageModelOutput,
@@ -1098,6 +1141,22 @@ export type {
   ActionParamDescriptor,
   ActionPhaseDescriptor,
 } from "./actions/descriptor"
+export type { DecisionAnswerSchema, DecisionOutputShape } from "./models/decision/output"
+export { decisionOutput } from "./models/decision/output"
+export { question } from "./models/decision/questions"
+export type {
+  ChoiceQuestion,
+  DecisionAnswer,
+  DecisionAnswers,
+  DecisionContent,
+  DecisionEvaluateInput,
+  DecisionEvaluateResult,
+  DecisionModelsRuntime,
+  DecisionQuestion,
+  DecisionQuestions,
+  ProbabilityQuestion,
+  ScoreQuestion,
+} from "./models/decision/types"
 export type {
   ForeignKeyDescriptor,
   LinkProjectionDefinition,

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

@@ -1,7 +1,7 @@
 import { randomUUID } from "node:crypto"
 import { isDeepStrictEqual } from "node:util"
 import type { DatasetDefinition, DatasetSchema, MergeChange } from "../datasets"
-import { getDatasetRowValidationError } from "../datasets/validation"
+import { getDatasetRowValidationFailure } from "../datasets/validation"
 import { resolveDatasetChangeColumns } from "./changes"
 import { mergeStrictDatasetDefinition } from "./definition-updates"
 import { LakeConcurrencyError, LakeStorageError } from "./errors"
@@ -113,9 +113,11 @@ class InMemoryLakeWriteSession implements LakeWriteSession {
     const stagedRows: DatasetRow[] = []
     const stagedPrimaryKeys = new Set<string>()
     for await (const row of rows) {
-      const validationError = getDatasetRowValidationError(row, this.input.dataset)
+      const validationError = getDatasetRowValidationFailure(row, this.input.dataset)
       if (validationError) {
-        throw new LakeStorageError(`[LakeStorage] ${validationError}`)
+        throw new LakeStorageError(`[LakeStorage] ${validationError.message}`, {
+          cause: validationError,
+        })
       }
 
       if (getDatasetPrimaryKeyColumns(this.input.dataset) !== null) {
@@ -367,6 +369,7 @@ export class InMemoryLakeStorage implements LakeStorage {
   }
 
   async *readRows(input: ReadDatasetRowsInput): AsyncIterable<DatasetRow> {
+    input.signal?.throwIfAborted()
     const definition = this.datasets.get(input.datasetId)
     if (!definition) {
       throw new LakeStorageError(`[LakeStorage] Unknown dataset '${input.datasetId}'`)
@@ -390,6 +393,7 @@ export class InMemoryLakeStorage implements LakeStorage {
       ?.slice(offset, limit === undefined ? undefined : offset + limit)
 
     for (const row of rows ?? []) {
+      input.signal?.throwIfAborted()
       yield selectColumns(row, input.columns)
     }
   }

package/src/lake-storage/types.ts

@@ -71,6 +71,8 @@ export interface ReadDatasetRowsInput {
   readonly columns?: readonly string[]
   readonly limit?: number
   readonly offset?: number
+  /** Cancel an active read or a read waiting for provider capacity. */
+  readonly signal?: AbortSignal
 }
 
 export interface ReadDatasetChangesInput {

package/src/maintenance/ontology-maintenance.ts

@@ -93,6 +93,7 @@ export class OntologyMaintenance {
 
   /** Runs one coalesced pass. Exposed for deterministic hosting and tests. */
   runNow(): Promise<void> {
+    if (this.stopping) return this.stopping
     this.pass ??= this.runPass().finally(() => {
       this.pass = null
     })
@@ -244,12 +245,15 @@ export class OntologyMaintenance {
       this.timer = null
     }
     const activePass = this.pass ?? Promise.resolve()
-    const stopping = settlesWithin(activePass, this.shutdownTimeoutMs).then((settled) => {
+    const stopping = settlesWithin(activePass, this.shutdownTimeoutMs).then(async (settled) => {
       if (!settled) {
         this.reportError(
-          new Error(`[Sixb] Ontology maintenance did not stop within ${this.shutdownTimeoutMs}ms.`)
+          new Error(
+            `[Sixb] Ontology maintenance is still stopping after ${this.shutdownTimeoutMs}ms; waiting for active storage operations.`
+          )
         )
       }
+      await activePass
     })
     this.stopping = stopping.finally(() => {
       this.stopping = null

package/src/maintenance/types.ts

@@ -7,7 +7,7 @@ export interface OntologyMaintenanceOptions {
   readonly terminalSourceRetentionMs?: number
   /** Maximum deletions attempted per cleanup domain and pass. Defaults to 1,000. */
   readonly cleanupLimit?: number
-  /** Maximum time to wait for an active pass during shutdown. Defaults to 30 seconds. */
+  /** Warn after this shutdown grace period, then wait for active operations. Defaults to 30 seconds. */
   readonly shutdownTimeoutMs?: number
 }
 

package/src/materialization/errors.ts

@@ -24,8 +24,8 @@ function prefixMessage(message: string): string {
 export class MaterializationValidationError extends OntologyValidationError {
   readonly name: string = "MaterializationValidationError"
 
-  constructor(message: string) {
-    super(prefixMessage(message))
+  constructor(message: string, options?: ErrorOptions) {
+    super(prefixMessage(message), options)
   }
 }
 

package/src/materialization/index.ts

@@ -77,3 +77,4 @@ export {
   telemetryPointSortKey,
   telemetrySeriesKey,
 } from "./refs"
+export type { ObjectVectorWrite, PreparedObjectVector } from "./vectors"

package/src/materialization/model.ts

@@ -3,6 +3,7 @@ import type { EventOrigin } from "../events/envelope"
 import type { PropertyChange, PropertyChangeMap } from "../events/property-changes"
 import type { JsonValue } from "../json"
 import type { ProjectionProtocolIdentity, ProjectionRunFailureCode } from "../projections/types"
+import type { ObjectVectorWrite } from "./vectors"
 
 export type { ProjectionProtocolIdentity } from "../projections/types"
 
@@ -125,6 +126,7 @@ export type OntologyEditCommit =
       readonly source:
         | { readonly kind: "action"; readonly actionId: string; readonly runId: string }
         | { readonly kind: "runtime"; readonly requestId: string }
+      readonly vectorWrites?: readonly ObjectVectorWrite[]
       readonly expectedObjects: readonly ExpectedObjectRevision[]
       readonly expectedLinks: readonly ExpectedLinkRevision[]
       readonly expectedLinkScopes: readonly ExpectedLinkScopeRevision[]

package/src/materialization/vectors.ts

@@ -0,0 +1,18 @@
+import type { ExpectedObjectRevision, OntologyObjectRef } from "./model"
+
+/** Internal observation captured before embedding and fenced by the atomic vector write. */
+export interface PreparedObjectVector {
+  readonly projectId: string
+  readonly ref: OntologyObjectRef
+  readonly profile: string
+  readonly configuration: string
+  readonly text: string
+  readonly sourceFingerprint: string
+  readonly expectedObject: Extract<ExpectedObjectRevision, { exists: true }>
+  readonly expectedVectorCommitId: string | null
+}
+
+export interface ObjectVectorWrite {
+  readonly input: PreparedObjectVector
+  readonly values: readonly number[]
+}

package/src/materializer/README.md

@@ -17,7 +17,7 @@ runtime telemetry       -> telemetry.append (origin: telemetry/runtime)
 
 Committed facts are published from the transactional outbox after the commit resolves.
 `OntologyOutboxDispatcher` owns that protocol: ingresses call `notify()` for prompt, non-blocking
-in-process delivery, and a process may call `start()` to host the durable poll loop. Publication is
+in-process delivery; `OntologyMaintenance` hosts recovery catch-up. Publication is
 best effort — delivery may lag, but a committed fact is never lost.
 
 ## Common commit pipeline
@@ -124,3 +124,17 @@ finish still commit atomically.
 Keep use-case entrypoints explicit. Share mechanics only after they have identical semantics; do
 not hide projection candidate lifecycle, edit continuation, or telemetry batching behind a generic
 workflow engine.
+
+## Vector profiles
+
+The SDK's explicit `index()` captures an internal `PreparedObjectVector`: object/profile identity,
+configuration and source fingerprints, canonical input text, object revision and current vector
+commit id. Source values stay local to preparation rather than being copied into the write payload.
+Text is ordered JSON pairs of source names and values; missing/null values become `null`, while
+empty strings remain distinct. The configuration includes an encoding version.
+
+The configured model runs outside the transaction. Atomic edits then verify the object revision,
+source/configuration fingerprints and vector commit id before storing validated float32 values.
+An unrelated edit may conservatively reject in-flight indexing even when an existing vector remains
+valid. A provider failure leaves the current representation untouched and is never retried here.
+Effective-state changes invalidate affected profiles in the same transaction as the object write.

package/src/materializer/context.ts

@@ -49,6 +49,16 @@ export function createMaterializerContext(input: {
       "Materializer Ontology does not match the Ontology pinned by its projection registry."
     )
   }
+  if (
+    (!input.storage.ontology.vectors || !input.storage.ontology.vectorIndexing) &&
+    input.ontology
+      .listObjectTypes()
+      .some((type) => Object.keys(type.search?.vectors ?? {}).length > 0)
+  ) {
+    throw new MaterializationValidationError(
+      "Storage does not support transactional vector profiles and automatic indexing."
+    )
+  }
   const dependencies = input.dependencies ?? {}
   const maxSerializationRetries = dependencies.maxSerializationRetries ?? 2
   if (!Number.isSafeInteger(maxSerializationRetries) || maxSerializationRetries < 0) {

package/src/materializer/edits/commit.ts

@@ -34,6 +34,8 @@ import { compileEditExecutionUnits, type EditExecutionUnit } from "./execution-u
 import { loadEditWorkingState } from "./load-state"
 import { applyEditOperation, type EditUndoJournal, undoEditJournal } from "./operations"
 import { stageEditPlan } from "./plan"
+import { authorizeVectorIndexingCommit } from "./vector-authority"
+import { commitVectorWrites } from "./vectors"
 import type { EditWorkingState } from "./working-state"
 
 type NormalizedEditCommit = ReturnType<typeof normalizeOntologyEditCommit>
@@ -106,6 +108,7 @@ async function validateMutationExecution(
   input: NormalizedEditCommit,
   execution: MaterializerExecution
 ): Promise<void> {
+  if (await authorizeVectorIndexingCommit(storage, projectId, input, execution)) return
   if (input.source.kind !== "action") {
     assertRuntimeMutationExecution(execution)
     return
@@ -182,7 +185,8 @@ async function executeEditTransaction(
     workingState,
     editPlanContext(command)
   )
-  await drainStagedWork(context, storage.ontology.materializations, session)
+  await drainStagedWork(context, storage, session)
+  await commitVectorWrites(context, storage, command.input, command.identity.commitId, session)
   const eventCount = await drainStagedEvents(
     context,
     storage.ontology.materializations,
@@ -234,6 +238,9 @@ function buildEditCommit(
       kind: "edit",
       mode: command.input.mode,
       operationCount: command.input.operations.length,
+      ...(command.input.mode === "atomic" && command.input.vectorWrites?.length
+        ? { vectorWriteCount: command.input.vectorWrites.length }
+        : {}),
     },
     committedAt: command.identity.committedAt,
   }

package/src/materializer/edits/vector-authority.ts

@@ -0,0 +1,108 @@
+import {
+  MaterializationConflictError,
+  MaterializationValidationError,
+} from "../../materialization/errors"
+import type { OntologyEditCommit } from "../../materialization/model"
+import { objectRefKey } from "../../materialization/refs"
+import type { ObjectVectorWrite } from "../../materialization/vectors"
+import type { Storage } from "../../storage"
+import type { VectorIndexingWork } from "../../storage/ontology/vector-indexing"
+import type { MaterializerExecution } from "../execution/scope"
+
+/** Kernel indexing can publish only its persisted results, never change business data. */
+export async function authorizeVectorIndexingCommit(
+  storage: Storage,
+  projectId: string,
+  input: OntologyEditCommit,
+  execution: MaterializerExecution
+): Promise<boolean> {
+  const executor = execution.scope.execution.executor
+  if (executor.type !== "kernel" || executor.operation.type !== "ontology.indexVectors")
+    return false
+  if (
+    input.mode !== "atomic" ||
+    input.source.kind !== "runtime" ||
+    input.operations.length ||
+    !input.vectorWrites?.length ||
+    input.expectedLinks.length ||
+    input.expectedLinkScopes.length
+  ) {
+    throw new MaterializationValidationError(
+      "Vector indexing authority only permits its persisted vector writes."
+    )
+  }
+  const writes = input.vectorWrites!
+  const refs = new Set(writes.map((write) => objectRefKey(write.input.ref)))
+  if (
+    input.expectedObjects.length !== refs.size ||
+    input.expectedObjects.some((expected) => !refs.has(objectRefKey(expected.ref)))
+  ) {
+    throw new MaterializationValidationError(
+      "Vector indexing must fence exactly its written objects."
+    )
+  }
+
+  const indexing = storage.ontology.vectorIndexing
+  const indexingId = executor.operation.indexingId
+  const single = await indexing?.get({ projectId, id: indexingId })
+  if (single && writes.length !== 1) {
+    throw new MaterializationValidationError(
+      "Individual indexing authority only permits one vector write."
+    )
+  }
+
+  // Multi-object publication reads membership/results once, not once per object.
+  let members: readonly VectorIndexingWork[]
+  if (single) {
+    members = [single]
+  } else if (writes.length === 1) {
+    const member = await indexing?.getBatchMember({
+      projectId,
+      batchId: indexingId,
+      ref: writes[0]!.input.ref,
+      profile: writes[0]!.input.profile,
+    })
+    members = member ? [member] : []
+  } else {
+    members = (await indexing?.getBatch({ projectId, batchId: indexingId })) ?? []
+  }
+
+  const byProfile = new Map(
+    members.map((work) => [JSON.stringify([objectRefKey(work.ref), work.profile]), work])
+  )
+  const source = execution.scope.execution.source
+
+  for (const write of writes) {
+    const work = byProfile.get(JSON.stringify([objectRefKey(write.input.ref), write.input.profile]))
+    if (!work || work.status !== "ready") {
+      throw new MaterializationConflictError(
+        "effective-state",
+        "Vector indexing work is no longer ready."
+      )
+    }
+    if (
+      source.type !== "ontologyCommit" ||
+      source.commitId !== work.sourceCommitId ||
+      !matchesStoredResult(write, work)
+    ) {
+      throw new MaterializationValidationError(
+        "Vector indexing authority only permits its current prepared representation."
+      )
+    }
+  }
+  return true
+}
+
+function matchesStoredResult(write: ObjectVectorWrite, work: VectorIndexingWork): boolean {
+  const prepared = write.input
+  return (
+    prepared.ref.objectTypeId === work.ref.objectTypeId &&
+    prepared.ref.primaryId === work.ref.primaryId &&
+    prepared.profile === work.profile &&
+    prepared.configuration === work.configuration &&
+    prepared.sourceFingerprint === work.sourceFingerprint &&
+    work.values !== undefined &&
+    work.values.length === write.values.length &&
+    work.values.every((value, index) => value === write.values[index])
+  )
+}