@sixb/pg 0.1.11 → 0.1.13

package/src/objects/query-compiler.ts

@@ -7,6 +7,12 @@ import {
   type ObjectQuerySortField,
   type QueryScalarKind,
 } from "@sixb/core"
+import {
+  hasVectorProfile,
+  isVectorProfileQuery,
+  normalizeVector,
+  vectorSearchCandidateLimit,
+} from "@sixb/core/internal/query"
 
 export interface PgObjectQueryPageRow {
   object_type_id: string
@@ -16,6 +22,7 @@ export interface PgObjectQueryPageRow {
 }
 
 export interface CompiledPgObjectQuery {
+  vectorProbe?: { sql: string; args: unknown[]; limit: number }
   sql: string
   args: unknown[]
   totalSql: string
@@ -74,7 +81,8 @@ type CompiledOrderField =
     }
   | {
       kind: "column"
-      column: "object_type_id" | "primary_id"
+      column: "object_type_id" | "primary_id" | "_vector_score"
+      binary?: boolean
       direction: "asc" | "desc"
     }
 
@@ -99,6 +107,12 @@ export function compilePgObjectQuery(
   query: ObjectQuery,
   options: { includeTotal?: boolean; source?: PgObjectQuerySource } = {}
 ): CompiledPgObjectQuery {
+  if (hasVectorProfile(query) && !isVectorProfileQuery(query)) {
+    throw new ObjectQueryExecutionError(
+      "unsupported_vector_composition",
+      "Vector search supports one profile with filters before ranking and limit/project after."
+    )
+  }
   const source = options.source ?? DEFAULT_OBJECT_QUERY_SOURCE
   const compiled = source.wrapQuery(
     compileObjectQueryInternal(projectId, query, {
@@ -110,6 +124,9 @@ export function compilePgObjectQuery(
     ...compiled,
     sql: numberPlaceholders(compiled.sql),
     totalSql: numberPlaceholders(compiled.totalSql),
+    vectorProbe: compiled.vectorProbe
+      ? { ...compiled.vectorProbe, sql: numberPlaceholders(compiled.vectorProbe.sql) }
+      : undefined,
     hasMoreProbe: compiled.hasMoreProbe
       ? {
           ...compiled.hasMoreProbe,
@@ -123,6 +140,7 @@ export function compilePgObjectQuery(
 export interface PgObjectQuerySource {
   readonly objectsTable: string
   readonly linksTable: string
+  readonly objectPropertyPermissionsTable?: string
   /** Wrap a terminal SELECT without its own WITH clause; the selected source owns the only WITH. */
   wrapStatement(
     sql: string,
@@ -263,9 +281,74 @@ function compileObjectQueryInternal(
     case "expand":
       return compileExpand(projectId, query.input, query.expansions, ctx)
     case "vector":
-      throw new Error(
-        `[SixbPg] PostgreSQL object storage does not support query node '${query.kind}'`
-      )
+      return compileVector(projectId, query, ctx)
+  }
+}
+
+function compileVector(
+  projectId: string,
+  query: Extract<ObjectQuery, { kind: "vector" }>,
+  ctx: CompileContext
+): CompiledPgObjectQuery {
+  if (
+    typeof query.vector === "string" ||
+    !isVectorProfileQuery(query) ||
+    !query.configuration ||
+    !Number.isSafeInteger(query.k) ||
+    query.k < 1 ||
+    query.k > 1000 ||
+    query.vector.length < 1 ||
+    query.vector.length > 16000
+  ) {
+    throw new ObjectQueryExecutionError(
+      "invalid_vector_query",
+      "A validated named vector profile is required."
+    )
+  }
+  const input = compileObjectQueryInternal(projectId, query.input, exactContext(ctx))
+  const permissions = ctx.source.objectPropertyPermissionsTable
+  const permissionJoin = permissions
+    ? `JOIN (
+      SELECT project_id, object_type_id, primary_id, array_agg(property_id) AS property_ids
+      FROM ${permissions}
+      GROUP BY project_id, object_type_id, primary_id
+    ) AS vector_permissions ON vector_permissions.project_id = vectors.project_id
+      AND vector_permissions.object_type_id = vectors.object_type_id
+      AND vector_permissions.primary_id = vectors.primary_id`
+    : ""
+  const authorized = permissions ? `AND vectors.source <@ vector_permissions.property_ids` : ""
+  const candidates = `FROM (${input.sql}) AS input
+    JOIN object_vectors AS vectors ON vectors.project_id = input.project_id
+      AND vectors.object_type_id = input.object_type_id AND vectors.primary_id = input.primary_id
+    ${permissionJoin}
+    WHERE vectors.profile = ? AND vectors.configuration = ?
+      AND cardinality(vectors.embedding) = ? ${authorized}`
+  const candidateArgs = [...input.args, query.profile!, query.configuration, query.vector.length]
+  // Bound distance work, not just returned rows. Exceeding the envelope fails before ranking.
+  const limit = vectorSearchCandidateLimit(query.vector.length)
+  const values = normalizeVector(query.vector, query.vector.length)
+  const order = compileOrder([
+    { kind: "column", column: "_vector_score", direction: "desc" },
+    ...identityOrderFields().map((field) => ({ ...field, binary: true })),
+  ])
+  const sql = `SELECT * FROM (SELECT input.*, 1 - (vectors.embedding::public.vector OPERATOR(public.<=>) ?::public.vector) AS _vector_score
+    ${candidates}) AS ranked ORDER BY ${order.sql} LIMIT ?`
+  const args = [JSON.stringify(values), ...candidateArgs, query.k]
+  return {
+    sql,
+    args,
+    // Top-k cardinality depends on eligibility, not distances or ranking.
+    totalSql: `SELECT COUNT(*)::bigint AS total FROM (SELECT 1 ${candidates} LIMIT ?) AS eligible`,
+    totalArgs: [...candidateArgs, query.k],
+    order,
+    vectorProbe: {
+      sql: `SELECT COUNT(*)::bigint AS total FROM (SELECT 1 ${candidates} LIMIT ?) AS candidates`,
+      args: [...candidateArgs, limit + 1],
+      limit,
+    },
+    hasMore: () => false,
+    trimRows: identityRows,
+    nextPageToken: () => undefined,
   }
 }
 
@@ -377,6 +460,7 @@ function compileWhere(
       WHERE ${predicate.sql}
     `,
     totalArgs: [...input.args, ...predicate.args],
+    vectorProbe: input.vectorProbe,
     order: input.order,
     hasMore: () => false,
     trimRows: identityRows,
@@ -424,7 +508,7 @@ function compileSort(
         input.created_at,
         input.updated_at,
         input.version,
-        input.last_commit_id
+        input.last_commit_id${input.vectorProbe ? ", input._vector_score" : ""}
       FROM (${input.sql}) AS input
       ORDER BY ${order.sql}
     `,
@@ -462,6 +546,7 @@ function compileLimit(
       FROM (${input.sql}) AS input
     `,
     totalArgs: input.args,
+    vectorProbe: input.vectorProbe,
     order: input.order,
     hasMore: (rowCount, total) =>
       total === undefined ? ctx.probeLimit && rowCount > limit : limit < total,
@@ -499,6 +584,7 @@ function compilePage(
       FROM (${input.sql}) AS input
     `,
     totalArgs: input.args,
+    vectorProbe: input.vectorProbe,
     order: input.order,
     hasMore: (rowCount) => rowCount > pageSize,
     trimRows: (rows) => rows.slice(0, pageSize),
@@ -607,6 +693,7 @@ function compileExpand(
     args: [...expand.args, ...input.args, ...inputOrder.args],
     totalSql: input.totalSql,
     totalArgs: input.totalArgs,
+    vectorProbe: input.vectorProbe,
     order: input.order,
     hasMoreProbe: input.hasMoreProbe,
     hasMore: input.hasMore,
@@ -849,13 +936,14 @@ function compileProject(
         input.created_at,
         input.updated_at,
         input.version,
-        input.last_commit_id
+        input.last_commit_id${input.vectorProbe ? ", input._vector_score" : ""}
       FROM (${input.sql}) AS input
       ORDER BY ${inputOrder.sql}
     `,
     args: [...projection.args, ...input.args, ...inputOrder.args],
     totalSql: input.totalSql,
     totalArgs: input.totalArgs,
+    vectorProbe: input.vectorProbe,
     order: outputOrder,
     hasMoreProbe: input.hasMoreProbe,
     hasMore: input.hasMore,
@@ -909,9 +997,7 @@ function compileAggregateSource(
     case "page":
       return compileRowQueryAggregateSource(projectId, query, source)
     case "vector":
-      throw new Error(
-        `[SixbPg] PostgreSQL object storage does not support query node '${query.kind}'`
-      )
+      return compileRowQueryAggregateSource(projectId, query, source)
   }
 }
 
@@ -1416,7 +1502,9 @@ function compileOrder(
 
   for (const field of fields) {
     if (field.kind === "column") {
-      clauses.push(`${columnExpression(field.column, qualifier)} ${field.direction.toUpperCase()}`)
+      clauses.push(
+        `${columnExpression(field.column, qualifier)}${field.binary ? ' COLLATE "C"' : ""} ${field.direction.toUpperCase()}`
+      )
       continue
     }
 
@@ -1637,7 +1725,10 @@ function compiledPropertyValueExpression(
     : jsonValueExpression(propertyColumn)
 }
 
-function columnExpression(column: "object_type_id" | "primary_id", qualifier?: string): string {
+function columnExpression(
+  column: "object_type_id" | "primary_id" | "_vector_score",
+  qualifier?: string
+): string {
   return qualifier ? `${qualifier}.${column}` : column
 }
 

package/src/objects/read-scope.ts

@@ -18,6 +18,7 @@ export interface PgSelectedObjectReadSource extends PgObjectQuerySource {
  *
  * The complete compiled scope is serialized once. Every statement receives that one JSONB
  * document and the bound project id, keeping the parameter count constant as selections grow.
+ * Group property grants after resolving paths so redaction reads only each object's own grants.
  */
 export function compilePgSelectedObjectReadSource(
   projectId: string,
@@ -43,6 +44,9 @@ export function compilePgSelectedObjectReadSource(
     wrapQuery: (query: CompiledPgObjectQuery): CompiledPgObjectQuery => ({
       ...query,
       ...wrapStatement(query.sql, query.args),
+      vectorProbe: query.vectorProbe
+        ? { ...query.vectorProbe, ...wrapStatement(query.vectorProbe.sql, query.vectorProbe.args) }
+        : undefined,
       totalSql: `${compiled.sql}\n${query.totalSql}`,
       totalArgs: [...compiled.args, ...query.totalArgs],
       ...(query.hasMoreProbe
@@ -177,32 +181,29 @@ function compileSelectedReadScopeCte(scopeJson: string, projectId: string): Comp
         SELECT DISTINCT project_id, object_type_id, primary_id
         FROM _sixb_scope_reachable
       ),
+      _sixb_scope_object_grants AS (
+        SELECT reachable.project_id, reachable.object_type_id, reachable.primary_id,
+          array_agg(DISTINCT selected_property.value) FILTER (WHERE selected_property.value IS NOT NULL) AS property_ids
+        FROM _sixb_scope_reachable AS reachable
+        LEFT JOIN _sixb_scope_object_selections AS selection
+          ON selection.node_id = reachable.node_id
+         AND selection.object_type_id = reachable.object_type_id
+        LEFT JOIN LATERAL jsonb_array_elements_text(selection.property_ids) AS selected_property(value) ON true
+        GROUP BY reachable.project_id, reachable.object_type_id, reachable.primary_id
+      ),
       _sixb_scope_objects AS (
-        SELECT
-          stored.project_id,
-          stored.object_type_id,
-          stored.primary_id,
-          COALESCE(
-            (
-              SELECT jsonb_object_agg(property.key, property.value)
-              FROM jsonb_each(stored.properties) AS property(key, value)
-              JOIN _sixb_scope_object_permissions AS permission
-                ON permission.project_id = stored.project_id
-               AND permission.object_type_id = stored.object_type_id
-               AND permission.primary_id = stored.primary_id
-               AND permission.property_id = property.key
-            ),
-            '{}'::jsonb
-          ) AS properties,
-          stored.created_at,
-          stored.updated_at,
-          stored.version,
-          stored.last_commit_id
-        FROM objects AS stored
-        JOIN _sixb_scope_object_ids AS visible
-          ON visible.project_id = stored.project_id
-         AND visible.object_type_id = stored.object_type_id
-         AND visible.primary_id = stored.primary_id
+        SELECT stored.project_id, stored.object_type_id, stored.primary_id,
+          COALESCE((
+            SELECT jsonb_object_agg(property.key, property.value)
+            FROM jsonb_each(stored.properties) AS property(key, value)
+            WHERE property.key = ANY(grants.property_ids)
+          ), '{}'::jsonb) AS properties,
+          stored.created_at, stored.updated_at, stored.version, stored.last_commit_id
+        FROM _sixb_scope_object_grants AS grants
+        JOIN objects AS stored
+          ON stored.project_id = grants.project_id
+         AND stored.object_type_id = grants.object_type_id
+         AND stored.primary_id = grants.primary_id
       ),
       _sixb_scope_reached_links(
         project_id,

package/src/objects/reader.ts

@@ -1,4 +1,5 @@
-import type { ObjectQuery } from "@sixb/core"
+import { type ObjectQuery, ObjectQueryExecutionError } from "@sixb/core"
+import { hasVectorProfile } from "@sixb/core/internal/query"
 import type {
   CountObjectsInput,
   CountObjectsResult,
@@ -51,7 +52,35 @@ export class PgObjectReader {
     private readonly source: PgObjectQuerySource | PgSelectedObjectReadSource
   ) {}
 
+  private async assertVectorSearch(
+    params: QueryObjectsInput | CountObjectsInput | ExistsObjectsInput | FacetObjectsInput
+  ): Promise<void> {
+    if (!hasVectorProfile(params.query)) return
+    const compiled = compilePgObjectQuery(params.projectId, params.query, { source: this.source })
+    if (!compiled.vectorProbe) return
+    const extensions = await this.sql.unsafe<{ ready: boolean }[]>(
+      "SELECT EXISTS (SELECT 1 FROM pg_extension e JOIN pg_namespace n ON n.oid = e.extnamespace WHERE e.extname = 'vector' AND n.nspname = 'public') AS ready"
+    )
+    if (!extensions[0]?.ready)
+      throw new ObjectQueryExecutionError(
+        "vector_extension_missing",
+        "PostgreSQL vector search requires pgvector installed in schema public (CREATE EXTENSION vector WITH SCHEMA public)."
+      )
+    const probe = compiled.vectorProbe
+    const [row] = await this.sql.unsafe<{ total: string | number }[]>(
+      probe.sql,
+      probe.args as SqlParameter[]
+    )
+    if (Number(row?.total ?? 0) > probe.limit) {
+      throw new ObjectQueryExecutionError(
+        "vector_work_limit_exceeded",
+        `Exact vector search supports at most ${probe.limit} eligible vectors at this dimension. Narrow the query filters.`
+      )
+    }
+  }
+
   async queryObjects(params: QueryObjectsInput): Promise<QueryObjectsResult> {
+    await this.assertVectorSearch(params)
     const sql = this.sql
     const source = this.source
     const compiled = compilePgObjectQuery(params.projectId, params.query, {
@@ -85,6 +114,7 @@ export class PgObjectReader {
   }
 
   async countObjects(params: CountObjectsInput): Promise<CountObjectsResult> {
+    await this.assertVectorSearch(params)
     const sql = this.sql
     const source = this.source
     const compiled = compilePgObjectCountQuery(params.projectId, stripOuterRowShape(params.query), {
@@ -98,6 +128,7 @@ export class PgObjectReader {
   }
 
   async existsObjects(params: ExistsObjectsInput): Promise<ExistsObjectsResult> {
+    await this.assertVectorSearch(params)
     const sql = this.sql
     const source = this.source
     const compiled = compilePgObjectExistsQuery(
@@ -110,6 +141,7 @@ export class PgObjectReader {
   }
 
   async facetObjects(params: FacetObjectsInput): Promise<FacetObjectsResult> {
+    await this.assertVectorSearch(params)
     const sql = this.sql
     const source = this.source
     const facets: ObjectFacetResult[] = []

package/src/objects/rows.ts

@@ -23,7 +23,10 @@ export function rowToObject(row: ObjectDatabaseRow): ObjectRow {
 // base columns map as usual; `_expand` (a `jsonb_build_object`) is revived into
 // the runtime link shape the core executor's fallback also produces.
 export function queryRowToObject(row: ObjectQueryDatabaseRow): ObjectRow {
-  const base = rowToObject(row)
+  const base = {
+    ...rowToObject(row),
+    ...(row._vector_score === undefined ? {} : { score: row._vector_score }),
+  }
   const links = reviveExpandedLinks(row._expand)
   return links ? { ...base, links } : base
 }
@@ -109,6 +112,7 @@ export interface ObjectDatabaseRow {
 }
 
 export interface ObjectQueryDatabaseRow extends ObjectDatabaseRow {
+  _vector_score?: number
   _cursor_properties?: unknown
   /** `jsonb_build_object(linkId, value, ...)` from an `expand` pushdown; absent otherwise. */
   _expand?: unknown

package/src/objects/storage.ts

@@ -1,3 +1,4 @@
+import { hasVectorProfile } from "@sixb/core/internal/query"
 import type {
   CompiledSelectedObjectReadScope,
   CountObjectsInput,
@@ -21,7 +22,7 @@ import type {
   QueryObjectsResult,
 } from "@sixb/core/storage"
 import type { SQLClient, SqlParameter } from "../pg-client"
-import type { PgStoreClient } from "../transactions"
+import { type PgStoreClient, runPgRepeatableReadTransaction } from "../transactions"
 import { DEFAULT_OBJECT_QUERY_SOURCE } from "./query-compiler"
 import { assertLinkQueryLimit, PgObjectReader } from "./reader"
 import {
@@ -43,6 +44,7 @@ const PG_OBJECT_QUERY_CAPABILITIES: ObjectQueryCapabilities = {
     refs: true,
     filter: true,
     text: true,
+    vector: true,
     sort: true,
     limit: true,
     page: true,
@@ -86,6 +88,8 @@ const PG_OBJECT_QUERY_CAPABILITIES: ObjectQueryCapabilities = {
     decimal: { equality: true, ordering: true },
     date: { equality: true, ordering: true },
     timestamp: { equality: true, ordering: true },
+    // jsonb equality and containment compare both fields of `{ type, id }`, whatever key order.
+    userRef: { equality: true },
   },
   limits: {
     totalCount: true,
@@ -95,7 +99,7 @@ const PG_OBJECT_QUERY_CAPABILITIES: ObjectQueryCapabilities = {
     "PostgreSQL object query pushdown supports start/refs/filter/text/sort/limit/page/traverse/set/project/expand over JSONB properties and object links.",
     "expand hydrates linked objects in-database (top-N per parent via LATERAL + jsonb_agg); core resolves each expansion's cardinality before pushdown, and a mixed/unresolved one stays on the fallback.",
     "Exact decimal predicates, ordering, and keyset pagination use PostgreSQL numeric casts.",
-    "Relevance sorting, vector search, and unresolved start.includeSubtypes remain planner fallback or rejection cases.",
+    "Relevance sorting and unresolved start.includeSubtypes remain planner fallback or rejection cases.",
   ],
 }
 
@@ -120,18 +124,34 @@ export class PgObjectStorage implements ObjectStorage {
   }
 
   async queryObjects(params: QueryObjectsInput): Promise<QueryObjectsResult> {
+    if (hasVectorProfile(params.query))
+      return runPgRepeatableReadTransaction(this.sql, (tx) =>
+        new PgObjectReader(tx, DEFAULT_OBJECT_QUERY_SOURCE).queryObjects(params)
+      )
     return this.reader.queryObjects(params)
   }
 
   async countObjects(params: CountObjectsInput): Promise<CountObjectsResult> {
+    if (hasVectorProfile(params.query))
+      return runPgRepeatableReadTransaction(this.sql, (tx) =>
+        new PgObjectReader(tx, DEFAULT_OBJECT_QUERY_SOURCE).countObjects(params)
+      )
     return this.reader.countObjects(params)
   }
 
   async existsObjects(params: ExistsObjectsInput): Promise<ExistsObjectsResult> {
+    if (hasVectorProfile(params.query))
+      return runPgRepeatableReadTransaction(this.sql, (tx) =>
+        new PgObjectReader(tx, DEFAULT_OBJECT_QUERY_SOURCE).existsObjects(params)
+      )
     return this.reader.existsObjects(params)
   }
 
   async facetObjects(params: FacetObjectsInput): Promise<FacetObjectsResult> {
+    if (hasVectorProfile(params.query))
+      return runPgRepeatableReadTransaction(this.sql, (tx) =>
+        new PgObjectReader(tx, DEFAULT_OBJECT_QUERY_SOURCE).facetObjects(params)
+      )
     return this.reader.facetObjects(params)
   }
 

package/src/ontology-storage/index.ts

@@ -6,12 +6,16 @@ import { PgOntologyMaterializationStorage } from "./materializations"
 import { PgOntologyOutboxStorage } from "./outbox"
 import type { PgRootOperation } from "./shared"
 import { PgOntologySourceStorage } from "./sources"
+import { PgVectorIndexingStorage } from "./vector-indexing"
+import { PgOntologyVectorStorage } from "./vectors"
 
 export class PgOntologyStorage implements OntologyStorage {
   readonly commits: PgOntologyCommitStorage
   readonly sources: PgOntologySourceStorage
   readonly materializations: PgOntologyMaterializationStorage
   readonly outbox: PgOntologyOutboxStorage
+  readonly vectorIndexing: PgVectorIndexingStorage
+  readonly vectors: PgOntologyVectorStorage
 
   constructor(input: {
     readonly sql: SQLClient
@@ -25,6 +29,17 @@ export class PgOntologyStorage implements OntologyStorage {
       input.transactionContext
     )
     this.outbox = new PgOntologyOutboxStorage(input.runRootOperation)
+    this.vectorIndexing = new PgVectorIndexingStorage(
+      input.sql,
+      input.runRootOperation,
+      (session, projectId) => this.materializations.assertVectorSession(session, projectId)
+    )
+    this.vectors = new PgOntologyVectorStorage(
+      input.sql,
+      input.runRootOperation,
+      (session, projectId, commitId) =>
+        this.materializations.assertVectorSession(session, projectId, commitId)
+    )
   }
 
   deactivateSessions(): void {

package/src/ontology-storage/materializations.ts

@@ -1,20 +1,20 @@
-import type {
-  EffectiveChangeCounts,
-  ExpectedLinkRevision,
-  ExpectedObjectRevision,
-} from "@sixb/core/internal/materialization"
+import type { EffectiveChangeCounts } from "@sixb/core/internal/materialization"
 import {
   assertPinnedDatasetWatermark,
   linkRefKey,
   linkRefSortKey,
   linkScopeSortKey,
   MaterializationConflictError,
+  MaterializationValidationError,
   objectRefKey,
   objectRefSortKey,
   telemetryPointKey,
   telemetryPointSortKey,
 } from "@sixb/core/internal/materialization"
 import {
+  assertExpectedLinkRevision,
+  assertExpectedLinkScopeRevision,
+  assertExpectedObjectRevision,
   assertMaterializationFinalizationCorrelation,
   assertMaterializationHeader,
   assertMaterializationLaneCompletion,
@@ -100,6 +100,18 @@ export class PgOntologyMaterializationStorage implements OntologyMaterialization
     this.writer = new PgMaterializationWriter(sql)
   }
 
+  assertVectorSession(session: MaterializationSession, projectId: string, commitId?: string): void {
+    const active = this.sessions.require(session)
+    if (
+      active.header.commit.projectId !== projectId ||
+      (commitId !== undefined && active.header.commit.id !== commitId)
+    ) {
+      throw new MaterializationValidationError(
+        "Vector mutation does not belong to this materialization session."
+      )
+    }
+  }
+
   async begin(input: MaterializationPlanHeader): Promise<MaterializationSession> {
     assertMaterializationHeader(input)
     const session = await this.sessions.create(input)
@@ -113,23 +125,21 @@ export class PgOntologyMaterializationStorage implements OntologyMaterialization
         true
       )
       for (const expected of input.expected.objects) {
-        this.assertObject(objectRevisions.get(objectRefKey(expected.ref)) ?? null, expected)
+        assertExpectedObjectRevision(
+          objectRevisions.get(objectRefKey(expected.ref)) ?? null,
+          expected
+        )
       }
       const linkRevisions = await reader.effectiveLinkLastCommits(
         input.expected.links.map((expected) => expected.ref),
         true
       )
       for (const expected of input.expected.links) {
-        this.assertLink(linkRevisions.get(linkRefKey(expected.ref)), expected)
+        assertExpectedLinkRevision(linkRevisions.get(linkRefKey(expected.ref)), expected)
       }
       const linkScopeRevisions = await reader.linkScopeRevisions(input.expected.linkScopes)
       for (const [index, expected] of input.expected.linkScopes.entries()) {
-        if (linkScopeRevisions[index]?.fingerprint !== expected.fingerprint) {
-          throw new MaterializationConflictError(
-            "effective-state",
-            `Expected link scope changed for ${expected.source.objectTypeId}:${expected.source.primaryId}.${expected.linkId}.`
-          )
-        }
+        assertExpectedLinkScopeRevision(linkScopeRevisions[index]?.fingerprint, expected)
       }
       const points = await reader.exactPoints(input.expected.points, true)
       const pointRevisions = new Map(
@@ -501,48 +511,6 @@ export class PgOntologyMaterializationStorage implements OntologyMaterialization
     }
   }
 
-  private assertObject(
-    row: { readonly version: number; readonly lastCommitId: string | null } | null,
-    expected: ExpectedObjectRevision
-  ): void {
-    if (!expected.exists) {
-      if (row) {
-        throw new MaterializationConflictError(
-          "effective-state",
-          `Expected object ${objectRefKey(expected.ref)} to be absent.`
-        )
-      }
-      return
-    }
-    if (!row || row.version !== expected.version || row.lastCommitId !== expected.lastCommitId) {
-      throw new MaterializationConflictError(
-        "effective-state",
-        `Expected object ${objectRefKey(expected.ref)} changed.`
-      )
-    }
-  }
-
-  private assertLink(
-    lastCommitId: string | null | undefined,
-    expected: ExpectedLinkRevision
-  ): void {
-    if (!expected.exists) {
-      if (lastCommitId !== undefined) {
-        throw new MaterializationConflictError(
-          "effective-state",
-          `Expected link ${linkRefKey(expected.ref)} to be absent.`
-        )
-      }
-      return
-    }
-    if (lastCommitId === undefined || lastCommitId !== expected.lastCommitId) {
-      throw new MaterializationConflictError(
-        "effective-state",
-        `Expected link ${linkRefKey(expected.ref)} changed.`
-      )
-    }
-  }
-
   private async assertFinalization(
     session: PgMaterializationSessionState,
     input: FinalizeMaterializationInput
@@ -860,18 +828,20 @@ export class PgOntologyMaterializationStorage implements OntologyMaterialization
   ): Promise<OntologyCommitRecord> {
     const { commit } = header
     const origin = originColumns(commit.origin)
-    const actor = commit.actor === undefined ? null : jsonParameter(this.sql, commit.actor)
+    const requestedBy =
+      commit.requestedBy === undefined ? null : jsonParameter(this.sql, commit.requestedBy)
     const rows = await this.sql<PgOntologyCommitRow[]>`
       INSERT INTO ontology_commits (
         project_id, id, idempotency_key, request_hash, execution_id,
-        origin_kind, origin_run_id, origin_batch_ordinal, origin, actor,
+        origin_kind, origin_run_id, origin_batch_ordinal, origin, requested_by, executor,
         ontology_revision, projection_revision, ownership_hash,
         intent, result, committed_at
       ) VALUES (
         ${commit.projectId}, ${commit.id}, ${commit.idempotencyKey}, ${commit.requestHash},
         ${commit.executionId},
         ${origin.kind}, ${origin.runId}, ${origin.batchOrdinal},
-        ${jsonParameter(this.sql, commit.origin)}, ${actor}, ${commit.ontologyRevision},
+        ${jsonParameter(this.sql, commit.origin)}, ${requestedBy},
+        ${jsonParameter(this.sql, commit.executor)}, ${commit.ontologyRevision},
         ${commit.projectionRevision ?? null}, ${commit.ownershipHash ?? null},
         ${jsonParameter(this.sql, commit.intent)},
         ${jsonParameter(this.sql, input.finalization.result)}, ${commit.committedAt}

package/src/ontology-storage/shared.ts

@@ -39,7 +39,8 @@ export interface PgOntologyCommitRow {
   readonly origin_run_id: string | null
   readonly origin_batch_ordinal: number | string | null
   readonly origin: unknown
-  readonly actor: unknown | null
+  readonly requested_by: unknown | null
+  readonly executor: unknown
   readonly ontology_revision: string
   readonly projection_revision: string | null
   readonly ownership_hash: string | null
@@ -187,11 +188,14 @@ export function commitRecord(row: PgOntologyCommitRow): OntologyCommitRecord {
     requestHash: row.request_hash,
     executionId: row.execution_id,
     origin: structuredClone(row.origin) as OntologyCommitWrite["origin"],
-    ...(row.actor === null
+    ...(row.requested_by === null
       ? {}
       : {
-          actor: structuredClone(row.actor) as NonNullable<OntologyCommitWrite["actor"]>,
+          requestedBy: structuredClone(row.requested_by) as NonNullable<
+            OntologyCommitWrite["requestedBy"]
+          >,
         }),
+    executor: structuredClone(row.executor) as OntologyCommitWrite["executor"],
     ontologyRevision: row.ontology_revision,
     ...(row.projection_revision === null ? {} : { projectionRevision: row.projection_revision }),
     ...(row.ownership_hash === null ? {} : { ownershipHash: row.ownership_hash }),