@sixb/core 0.1.11 → 0.1.13

package/src/materializer/README.md

@@ -51,6 +51,8 @@ Materializer      -> semantic planning and cross-store transaction orchestration
 
 Every ontology commit references its immutable execution through `executionId`. Storage providers enforce that reference. `origin` remains the semantic idempotency and run-correlation key: it says which runtime request, Action, projection replacement, or telemetry batch the commit represents; the execution says under which durable authority it ran. Neither field duplicates the other.
 
+A commit and each of its events also carry a copy of two execution facts, so consumers can answer "who changed this" without reading the execution: `requestedBy`, the principal on whose behalf the execution chain runs (absent for automatic, anonymous, or auth-disabled work), and `executor`, the request, primitive run, Agent run, or kernel operation that wrote. Both are derived from the bound scope in `execution/scope.ts`, which is already proven identical to the durable record, so they are a pure function of `executionId` and never caller input. Authority is deliberately not copied: it stays on the execution's `authorizationRef`. Header validation requires an Action or projection origin to name the exact primitive run in `executor`, and provider work requires every event to carry its commit's attribution.
+
 Run records do not duplicate ontology commit ids or semantic commit history. Replacement projections need no resume checkpoint; projection telemetry stores only its next batch/row checkpoint on the run.
 
 Logical origins are unique in the ontology ledger: one commit per Action run, one per replacement
@@ -124,3 +126,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,9 @@ import { compileEditExecutionUnits, type EditExecutionUnit } from "./execution-u
 import { loadEditWorkingState } from "./load-state"
 import { applyEditOperation, type EditUndoJournal, undoEditJournal } from "./operations"
 import { stageEditPlan } from "./plan"
+import { loadReferencedUsers, type ReferencedUsers } from "./user-refs"
+import { authorizeVectorIndexingCommit } from "./vector-authority"
+import { commitVectorWrites } from "./vectors"
 import type { EditWorkingState } from "./working-state"
 
 type NormalizedEditCommit = ReturnType<typeof normalizeOntologyEditCommit>
@@ -43,20 +46,22 @@ interface PreparedEditCommit {
   readonly identity: TimedCommitIdentity
   readonly origin: OntologyMaterializationOrigin
   readonly execution: MaterializerExecution
+  /** Read before the transaction opens; see `user-refs.ts`. */
+  readonly users: ReferencedUsers
 }
 
 export async function commitEdits(
   context: MaterializerContext,
   raw: MaterializerCommand<OntologyEditCommit>
 ): Promise<EditCommitResult> {
-  const command = prepareEditCommit(context, raw)
+  const command = await prepareEditCommit(context, raw)
   return executeEditCommit(context, command)
 }
 
-function prepareEditCommit(
-  context: Pick<MaterializerContext, "projectId" | "clock">,
+async function prepareEditCommit(
+  context: Pick<MaterializerContext, "projectId" | "clock" | "ontology" | "storage">,
   raw: MaterializerCommand<OntologyEditCommit>
-): PreparedEditCommit {
+): Promise<PreparedEditCommit> {
   const input = normalizeOntologyEditCommit(raw.input)
   const idempotencyKey = editIdempotencyKey(input)
   const identity = createTimedCommitIdentity({
@@ -70,6 +75,7 @@ function prepareEditCommit(
     identity,
     origin: input.source,
     execution: prepareMaterializerExecution(context.projectId, raw.scope),
+    users: await loadReferencedUsers(context, input.operations),
   }
 }
 
@@ -106,6 +112,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 +189,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,
@@ -222,23 +230,25 @@ function buildEditCommit(
   context: Pick<MaterializerContext, "projectId" | "projectionRegistry">,
   command: PreparedEditCommit
 ): OntologyCommitWrite {
-  const commit: OntologyCommitWrite = {
+  return {
     projectId: context.projectId,
     id: command.identity.commitId,
     idempotencyKey: command.identity.idempotencyKey,
     requestHash: command.identity.requestHash,
     executionId: command.execution.executionId,
     origin: command.origin,
+    ...command.execution.attribution,
     ontologyRevision: context.projectionRegistry.ontologyRevision,
     intent: {
       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,
   }
-  if (command.execution.actor === undefined) return commit
-  return { ...commit, actor: command.execution.actor }
 }
 
 function editExpectations(input: NormalizedEditCommit) {
@@ -284,7 +294,7 @@ function applyOneEditOperation(
   command: PreparedEditCommit
 ): OntologyOperationOutcome {
   try {
-    return applyEditOperation(context, state, operation, command.identity)
+    return applyEditOperation(context, state, operation, command.identity, command.users)
   } catch (error) {
     if (!isRecoverableEditValidation(command.input, error)) throw error
     return { id: operation.id, ok: false, error: { code: "validation", message: error.message } }
@@ -310,7 +320,14 @@ function applyEditOperationGroup(
   for (const operation of group) {
     let outcome: OntologyOperationOutcome
     try {
-      outcome = applyEditOperation(context, state, operation, command.identity, journal)
+      outcome = applyEditOperation(
+        context,
+        state,
+        operation,
+        command.identity,
+        command.users,
+        journal
+      )
     } catch (error) {
       if (!isRecoverableEditValidation(command.input, error)) throw error
       undoEditJournal(journal)
@@ -346,13 +363,12 @@ function isRecoverableEditValidation(
 }
 
 function editPlanContext(command: PreparedEditCommit) {
-  const context = {
+  return {
     identity: command.identity,
     origin: command.origin,
     correlationId: command.execution.correlationId,
+    attribution: command.execution.attribution,
   }
-  if (command.execution.actor === undefined) return context
-  return { ...context, actor: command.execution.actor }
 }
 
 async function finalizeEditMaterialization(

package/src/materializer/edits/operations.ts

@@ -4,6 +4,7 @@ import type { OntologyEditOperation, OntologyOperationOutcome } from "../../mate
 import { linkRefKey, linkScopeKey, objectRefKey } from "../../materialization/refs"
 import type { MaterializerContext } from "../context"
 import { diffEffectiveObject } from "../effective/diff"
+import type { ResolvedObjectValue } from "../effective/resolve"
 import {
   validateEffectiveObject,
   validateLinkAuthorityProperties,
@@ -15,6 +16,7 @@ import {
 import type { TimedCommitIdentity } from "../shared/identity"
 import { applyLinkEdit, applyObjectEdit } from "./apply"
 import { linkCardinality } from "./read-set"
+import { assertIntroducedUsersActive, type ReferencedUsers } from "./user-refs"
 import {
   type EditWorkingState,
   resolveLinkEdge,
@@ -53,11 +55,12 @@ export function applyEditOperation(
   state: EditWorkingState,
   operation: OntologyEditOperation,
   identity: TimedCommitIdentity,
+  users: ReferencedUsers,
   journal?: EditUndoJournal
 ): OntologyOperationOutcome {
   validateOperationRef(context, operation)
   if (isObjectOperation(operation)) {
-    return applyObjectOperation(context, state, operation, identity, journal)
+    return applyObjectOperation(context, state, operation, identity, users, journal)
   }
   return applyLinkOperation(
     context,
@@ -84,6 +87,7 @@ function applyObjectOperation(
   state: EditWorkingState,
   operation: ObjectOperation,
   identity: TimedCommitIdentity,
+  users: ReferencedUsers,
   journal?: EditUndoJournal
 ): OntologyOperationOutcome {
   const working = requireWorkingObject(state, operation)
@@ -99,7 +103,27 @@ function applyObjectOperation(
     ...normalized,
   })
 
-  applyObjectTransition(context, state, working, transition.next, transition.editedAt, journal)
+  // Restore brings back values the object already held; only caller-written values are new.
+  const assertUsers =
+    operation.kind === "object.restore"
+      ? undefined
+      : (resolved: ResolvedObjectValue) =>
+          assertIntroducedUsersActive(
+            context.ontology,
+            operation.ref.objectTypeId,
+            currentEffective?.properties,
+            resolved.properties,
+            users
+          )
+  applyObjectTransition(
+    context,
+    state,
+    working,
+    transition.next,
+    transition.editedAt,
+    journal,
+    assertUsers
+  )
 
   return objectOperationOutcome(operation, working, transition.changed, context, identity)
 }
@@ -149,7 +173,8 @@ function applyObjectTransition(
   working: WorkingObject,
   next: WorkingObject["override"],
   nextEditedAt: Readonly<Record<string, string>>,
-  journal?: EditUndoJournal
+  journal?: EditUndoJournal,
+  validateResolved?: (resolved: ResolvedObjectValue) => void
 ): void {
   const previous = working.override
   const previousEditedAt = working.editedAt
@@ -157,7 +182,10 @@ function applyObjectTransition(
   working.editedAt = { ...nextEditedAt }
   try {
     const resolved = resolveObject(context.ontology, working)
-    if (resolved) validateEffectiveObject(context.ontology, resolved.ref, resolved.properties)
+    if (resolved) {
+      validateEffectiveObject(context.ontology, resolved.ref, resolved.properties)
+      validateResolved?.(resolved)
+    }
     validateWorkingCardinality(state.links.slots)
   } catch (error) {
     working.override = previous

package/src/materializer/edits/plan.ts

@@ -1,4 +1,3 @@
-import type { EventActor } from "../../events/envelope"
 import type {
   EffectiveLinkChange,
   EffectiveObjectChange,
@@ -27,6 +26,7 @@ import {
 } from "../effective/build-events"
 import { diffEffectiveLink, diffEffectiveLinkSlot, diffEffectiveObject } from "../effective/diff"
 import { validateEffectiveObject } from "../effective/validate"
+import type { MaterializerAttribution } from "../execution/scope"
 import { stageWorkBounded } from "../execution/work-executor"
 import {
   appendEffectiveLinkWork,
@@ -59,7 +59,7 @@ interface EditPlanContext {
   readonly identity: TimedCommitIdentity
   readonly origin: OntologyMaterializationOrigin
   readonly correlationId: string
-  readonly actor?: EventActor
+  readonly attribution: MaterializerAttribution
 }
 
 export async function stageEditPlan(
@@ -237,15 +237,14 @@ function materializationEventContext(
   context: Pick<MaterializerContext, "projectId">,
   planContext: EditPlanContext
 ) {
-  const base = {
+  return {
     projectId: context.projectId,
     commitId: planContext.identity.commitId,
     committedAt: planContext.identity.committedAt,
     origin: planContext.origin,
     correlationId: planContext.correlationId,
+    attribution: planContext.attribution,
   }
-  if (planContext.actor === undefined) return base
-  return { ...base, actor: planContext.actor }
 }
 
 function sortedObjects(objects: EditWorkingState["objects"]): WorkingObject[] {

package/src/materializer/edits/user-refs.ts

@@ -0,0 +1,115 @@
+/**
+ * Existence checks for `userRef` values written by managed edits.
+ *
+ * Auth storage is read once per commit, before the serializable transaction opens: every user id
+ * the operations carry is looked up, deduplicated, and the statuses travel into the synchronous
+ * edit pass. There, an operation may only introduce a user that exists and is active. A value the
+ * object already held is never re-checked, so suspending a user leaves the objects that reference
+ * them writable. Users are never deleted, so a check at write time stays true for existence.
+ */
+import type { JsonValue } from "../../json"
+import { MaterializationValidationError } from "../../materialization/errors"
+import type { OntologyEditOperation } from "../../materialization/model"
+import type { OntologyRegistry } from "../../ontology"
+import { collectUserRefIds, userReferenceProblem } from "../../ontology/user-ref"
+import type { UserStatus } from "../../storage/auth/types"
+import type { MaterializerContext } from "../context"
+
+/** Statuses of the users a commit's operations reference; `null` marks an unknown id. */
+export type ReferencedUsers =
+  | { readonly kind: "loaded"; readonly statuses: ReadonlyMap<string, UserStatus | null> }
+  | { readonly kind: "unavailable" }
+
+const NO_REFERENCED_USERS: ReferencedUsers = { kind: "loaded", statuses: new Map() }
+
+export async function loadReferencedUsers(
+  context: Pick<MaterializerContext, "projectId" | "ontology" | "storage">,
+  operations: readonly OntologyEditOperation[]
+): Promise<ReferencedUsers> {
+  const ids = new Set<string>()
+  for (const operation of operations) {
+    switch (operation.kind) {
+      case "object.create":
+      case "object.upsert":
+        collectObjectUserRefIds(
+          context.ontology,
+          operation.ref.objectTypeId,
+          operation.properties,
+          ids
+        )
+        break
+      case "object.patch":
+        collectObjectUserRefIds(context.ontology, operation.ref.objectTypeId, operation.set, ids)
+        break
+      default:
+        break
+    }
+  }
+  if (ids.size === 0) return NO_REFERENCED_USERS
+
+  const users = context.storage.auth?.users
+  if (!users) return { kind: "unavailable" }
+  const entries = await Promise.all(
+    [...ids].map(async (id) => {
+      const user = await users.getById({ projectId: context.projectId, id })
+      return [id, user?.status ?? null] as const
+    })
+  )
+  return { kind: "loaded", statuses: new Map(entries) }
+}
+
+/**
+ * Reject user references an object operation introduces unless the user exists and is active.
+ *
+ * `before` is the effective object the operation started from; ids it already held under the same
+ * property are accepted as they are.
+ */
+export function assertIntroducedUsersActive(
+  ontology: OntologyRegistry,
+  objectTypeId: string,
+  before: Readonly<Record<string, JsonValue>> | undefined,
+  after: Readonly<Record<string, JsonValue>>,
+  users: ReferencedUsers
+): void {
+  const objectType = ontology.resolveObjectType(objectTypeId)
+  const valueTypesById = ontology.getValueTypesById()
+  for (const property of objectType.properties) {
+    const introduced = collectUserRefIds(
+      property.schema,
+      after[property.id],
+      valueTypesById,
+      new Set()
+    )
+    if (introduced.size === 0) continue
+    const held = collectUserRefIds(
+      property.schema,
+      before?.[property.id],
+      valueTypesById,
+      new Set()
+    )
+    for (const id of introduced) {
+      if (held.has(id)) continue
+      const problem = userReferenceProblem(
+        `Property '${objectTypeId}.${property.id}'`,
+        id,
+        users.kind === "unavailable" ? "unverifiable" : (users.statuses.get(id) ?? null)
+      )
+      if (problem) throw new MaterializationValidationError(problem)
+    }
+  }
+}
+
+function collectObjectUserRefIds(
+  ontology: OntologyRegistry,
+  objectTypeId: string,
+  properties: Readonly<Record<string, JsonValue>>,
+  into: Set<string>
+): void {
+  // Unknown types and properties are rejected by the edit pass; nothing to look up for them.
+  const objectType = ontology.getObjectTypeById(objectTypeId)
+  if (!objectType) return
+  const valueTypesById = ontology.getValueTypesById()
+  for (const property of objectType.properties) {
+    collectUserRefIds(property.schema, properties[property.id], valueTypesById, into)
+  }
+}

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])
+  )
+}

package/src/materializer/edits/vectors.ts

@@ -0,0 +1,100 @@
+import {
+  MaterializationConflictError,
+  MaterializationValidationError,
+} from "../../materialization/errors"
+import type { OntologyEditCommit } from "../../materialization/model"
+import { objectRefKey } from "../../materialization/refs"
+import { normalizeVector, vectorConfiguration, vectorSources } from "../../objects/vectors/profile"
+import type { Storage } from "../../storage"
+import { objectBatchKey } from "../../storage/objects/keys"
+import type { MaterializationSession, OntologyVectorStorage } from "../../storage/ontology"
+import type { MaterializerContext } from "../context"
+
+export async function commitVectorWrites(
+  context: MaterializerContext,
+  storage: Storage,
+  input: OntologyEditCommit,
+  commitId: string,
+  session: MaterializationSession
+): Promise<void> {
+  if (input.mode !== "atomic" || !input.vectorWrites?.length) return
+  const vectors = storage.ontology.vectors
+  if (!vectors)
+    throw new MaterializationValidationError("Storage does not support vector profiles.")
+  const rows = await storage.objects.getByPrimaryIdBatch({
+    projectId: context.projectId,
+    items: input.vectorWrites.map((write) => write.input.ref),
+  })
+  const expectations = new Map(
+    input.expectedObjects.map((expected) => [objectRefKey(expected.ref), expected])
+  )
+  const entries: Parameters<OntologyVectorStorage["writeBatch"]>[0]["entries"][number][] = []
+  const seen = new Set<string>()
+  for (const write of input.vectorWrites) {
+    const prepared = write.input
+    const key = JSON.stringify([objectRefKey(prepared.ref), prepared.profile])
+    if (seen.has(key)) throw new MaterializationValidationError(`Duplicate vector write: ${key}`)
+    seen.add(key)
+    const profileDefinition = context.ontology.resolveObjectType(prepared.ref.objectTypeId).search
+      ?.vectors?.[prepared.profile]
+    if (
+      prepared.projectId !== context.projectId ||
+      !profileDefinition ||
+      vectorConfiguration(profileDefinition) !== prepared.configuration
+    ) {
+      throw new MaterializationConflictError(
+        "effective-state",
+        "Vector profile configuration changed; index it again."
+      )
+    }
+    const expected = expectations.get(objectRefKey(prepared.ref))
+    if (
+      !expected?.exists ||
+      !prepared.expectedObject?.exists ||
+      objectRefKey(prepared.expectedObject.ref) !== objectRefKey(prepared.ref) ||
+      expected.version !== prepared.expectedObject.version ||
+      expected.lastCommitId !== prepared.expectedObject.lastCommitId
+    ) {
+      throw new MaterializationValidationError(
+        "Vector writes must fence their prepared object revision."
+      )
+    }
+    const row = rows.get(objectBatchKey(prepared.ref.objectTypeId, prepared.ref.primaryId))
+    if (
+      !row ||
+      row.version !== expected.version ||
+      row.lastCommitId !== expected.lastCommitId ||
+      vectorSources(profileDefinition.source, row.properties).sourceFingerprint !==
+        prepared.sourceFingerprint
+    ) {
+      throw new MaterializationConflictError(
+        "effective-state",
+        "Vector sources changed; index the profile again."
+      )
+    }
+    entries.push({
+      expectedCommitId: prepared.expectedVectorCommitId,
+      value: {
+        ref: prepared.ref,
+        profile: prepared.profile,
+        configuration: prepared.configuration,
+        source: profileDefinition.source,
+        sourceFingerprint: prepared.sourceFingerprint,
+        values: normalizeVector(write.values, profileDefinition.model.definition.dimensions),
+        lastCommitId: commitId,
+      },
+    })
+  }
+
+  await vectors.writeBatch({ session, projectId: context.projectId, entries })
+  await storage.ontology.vectorIndexing?.complete({
+    session,
+    projectId: context.projectId,
+    entries: input.vectorWrites.map(({ input: prepared }) => ({
+      ref: prepared.ref,
+      profile: prepared.profile,
+      configuration: prepared.configuration,
+      sourceFingerprint: prepared.sourceFingerprint,
+    })),
+  })
+}

package/src/materializer/effective/build-events.ts

@@ -1,4 +1,3 @@
-import type { EventActor } from "../../events/envelope"
 import type {
   EffectiveLinkChange,
   EffectiveObjectChange,
@@ -10,6 +9,7 @@ import type {
   OntologyMaterializationEvent,
   OntologyMaterializationEventDraft,
 } from "../../storage/ontology"
+import type { MaterializerAttribution } from "../execution/scope"
 import { createEventId, materializationEventKindOrdinal } from "../shared/identity"
 
 export interface OrderedMaterializationEventDraft {
@@ -24,7 +24,7 @@ export interface MaterializationEventDraftContext {
   readonly committedAt: string
   readonly correlationId: string
   readonly origin: OntologyMaterializationOrigin
-  readonly actor?: EventActor
+  readonly attribution: MaterializerAttribution
 }
 
 export function buildObjectMaterializationEventDraft(
@@ -162,16 +162,15 @@ function buildTelemetryEventDraft(
 }
 
 function eventDraftBase(context: MaterializationEventDraftContext) {
-  const base = {
+  return {
     schemaVersion: 1 as const,
     projectId: context.projectId,
     occurredAt: context.committedAt,
     correlationId: context.correlationId,
     origin: context.origin,
+    ...context.attribution,
     commitId: context.commitId,
   }
-  if (context.actor === undefined) return base
-  return { ...base, actor: context.actor }
 }
 
 function orderedDraft(