@sixb/core 0.1.0 → 0.1.2

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

@@ -1,8 +1,20 @@
 import { randomUUID } from "node:crypto"
-import type { DatasetDefinition, DatasetSchema } from "../datasets"
+import type { DatasetDefinition, DatasetSchema, MergeChange } from "../datasets"
 import { getDatasetRowValidationError } from "../datasets/validation"
 import { mergeStrictDatasetDefinition } from "./definition-updates"
 import { LakeStorageError } from "./errors"
+import type {
+  BeginDatasetMergeInput,
+  CommitDatasetMergeInput,
+  DatasetMergeCommitResult,
+  LakeMergeSession,
+} from "./merge"
+import {
+  cloneDatasetMergeChange,
+  encodeDatasetPrimaryKey,
+  getDatasetMergeChangeValidationError,
+  getDatasetPrimaryKeyColumns,
+} from "./merge-validation"
 import type {
   BeginDatasetWriteInput,
   CommitDatasetWriteInput,
@@ -74,6 +86,7 @@ function errorMessage(error: unknown): string {
 
 class InMemoryLakeWriteSession implements LakeWriteSession {
   private readonly rows: DatasetRow[] = []
+  private readonly primaryKeys = new Set<string>()
   private closed = false
 
   constructor(
@@ -84,13 +97,30 @@ class InMemoryLakeWriteSession implements LakeWriteSession {
   async writeRows(rows: Iterable<DatasetRow> | AsyncIterable<DatasetRow>): Promise<void> {
     this.assertOpen()
 
+    const stagedRows: DatasetRow[] = []
+    const stagedPrimaryKeys = new Set<string>()
     for await (const row of rows) {
       const validationError = getDatasetRowValidationError(row, this.input.dataset)
       if (validationError) {
         throw new LakeStorageError(`[LakeStorage] ${validationError}`)
       }
 
-      this.rows.push(cloneRow(row))
+      if (getDatasetPrimaryKeyColumns(this.input.dataset) !== null) {
+        const primaryKey = encodeDatasetPrimaryKey(this.input.dataset, row)
+        if (this.primaryKeys.has(primaryKey) || stagedPrimaryKeys.has(primaryKey)) {
+          throw new LakeStorageError(
+            `[LakeStorage] Dataset '${this.input.dataset.id}' write contains duplicate primary key ${primaryKey}.`
+          )
+        }
+        stagedPrimaryKeys.add(primaryKey)
+      }
+
+      stagedRows.push(cloneRow(row))
+    }
+
+    this.rows.push(...stagedRows)
+    for (const primaryKey of stagedPrimaryKeys) {
+      this.primaryKeys.add(primaryKey)
     }
   }
 
@@ -116,11 +146,63 @@ class InMemoryLakeWriteSession implements LakeWriteSession {
   }
 }
 
+class InMemoryLakeMergeSession implements LakeMergeSession {
+  private readonly changes: MergeChange<DatasetRow, DatasetRow>[] = []
+  private closed = false
+
+  constructor(
+    private readonly storage: InMemoryLakeStorage,
+    private readonly input: BeginDatasetMergeInput,
+    private readonly baseVersionId: string | null
+  ) {}
+
+  async writeChanges(
+    changes:
+      | Iterable<MergeChange<DatasetRow, DatasetRow>>
+      | AsyncIterable<MergeChange<DatasetRow, DatasetRow>>
+  ): Promise<void> {
+    this.assertOpen()
+
+    const stagedChanges: MergeChange<DatasetRow, DatasetRow>[] = []
+    for await (const change of changes) {
+      const validationError = getDatasetMergeChangeValidationError(change, this.input.dataset)
+      if (validationError) {
+        throw new LakeStorageError(`[LakeStorage] ${validationError}`)
+      }
+      stagedChanges.push(cloneDatasetMergeChange(change))
+    }
+    this.changes.push(...stagedChanges)
+  }
+
+  async commit(input?: CommitDatasetMergeInput): Promise<DatasetMergeCommitResult> {
+    this.assertOpen()
+    this.closed = true
+    return this.storage.commitMerge({
+      merge: this.input,
+      baseVersionId: this.baseVersionId,
+      changes: this.changes,
+      commit: input,
+    })
+  }
+
+  async abort(): Promise<void> {
+    this.closed = true
+    this.changes.length = 0
+  }
+
+  private assertOpen(): void {
+    if (this.closed) {
+      throw new LakeStorageError("[LakeStorage] Merge session is already closed")
+    }
+  }
+}
+
 export class InMemoryLakeStorage implements LakeStorage {
   private readonly datasets = new Map<string, DatasetDefinition>()
   private readonly versionsByDataset = new Map<string, DatasetVersion[]>()
   private readonly rowsByVersionId = new Map<string, readonly DatasetRow[]>()
   private readonly latestVersionIdByDataset = new Map<string, string>()
+  private readonly commitLocks = new Map<string, Promise<void>>()
 
   async createDataset(definition: DatasetDefinition): Promise<DatasetDefinition> {
     assertDatasetId(definition.id)
@@ -220,6 +302,36 @@ export class InMemoryLakeStorage implements LakeStorage {
     })
   }
 
+  async beginMerge(input: BeginDatasetMergeInput): Promise<LakeMergeSession> {
+    const definition = await this.getDataset(input.dataset.id)
+    if (!definition) {
+      throw new LakeStorageError(`[LakeStorage] Unknown dataset '${input.dataset.id}'`)
+    }
+    if (getDatasetPrimaryKeyColumns(definition) === null) {
+      throw new LakeStorageError(
+        `[LakeStorage] Dataset '${definition.id}' must define a primaryKey before it can be merged.`
+      )
+    }
+
+    const latestVersion = await this.getLatestVersion(definition.id)
+    if (
+      input.expectedLatestVersionId !== undefined &&
+      latestVersion?.versionId !== input.expectedLatestVersionId
+    ) {
+      throw new LakeStorageError(
+        `[LakeStorage] Optimistic merge start failed for dataset '${definition.id}': expected latest version '${input.expectedLatestVersionId}', found '${latestVersion?.versionId ?? "none"}'`
+      )
+    }
+    return new InMemoryLakeMergeSession(
+      this,
+      {
+        ...input,
+        dataset: definition,
+      },
+      latestVersion?.versionId ?? null
+    )
+  }
+
   async getLatestVersion(datasetId: string): Promise<DatasetVersion | null> {
     const latestVersionId = this.latestVersionIdByDataset.get(datasetId)
     if (!latestVersionId) {
@@ -267,6 +379,90 @@ export class InMemoryLakeStorage implements LakeStorage {
     write: BeginDatasetWriteInput
     rows: readonly DatasetRow[]
     commit?: CommitDatasetWriteInput
+  }): Promise<DatasetWriteCommitResult> {
+    return this.withDatasetCommitLock(options.write.dataset.id, () =>
+      this.commitWriteUnlocked(options)
+    )
+  }
+
+  async commitMerge(options: {
+    merge: BeginDatasetMergeInput
+    baseVersionId: string | null
+    changes: readonly MergeChange<DatasetRow, DatasetRow>[]
+    commit?: CommitDatasetMergeInput
+  }): Promise<DatasetMergeCommitResult> {
+    return this.withDatasetCommitLock(options.merge.dataset.id, async () => {
+      const definition = this.datasets.get(options.merge.dataset.id)
+      if (!definition) {
+        throw new LakeStorageError(`[LakeStorage] Unknown dataset '${options.merge.dataset.id}'`)
+      }
+
+      const latestVersion = await this.getLatestVersion(options.merge.dataset.id)
+      const actualVersionId = latestVersion?.versionId ?? null
+      if (actualVersionId !== options.baseVersionId) {
+        throw new LakeStorageError(
+          `[LakeStorage] Optimistic merge commit failed for dataset '${options.merge.dataset.id}': expected latest version '${options.baseVersionId ?? "none"}', found '${actualVersionId ?? "none"}'`
+        )
+      }
+
+      const previousRows = this.rowsByVersionId.get(latestVersion?.versionId ?? "") ?? []
+      const previousByKey = this.rowsByPrimaryKey(previousRows, definition)
+      const finalChanges = new Map<string, MergeChange<DatasetRow, DatasetRow>>()
+      for (const change of options.changes) {
+        const value = change.kind === "upsert" ? change.row : change.key
+        finalChanges.set(encodeDatasetPrimaryKey(definition, value), change)
+      }
+
+      const nextByKey = new Map(previousByKey)
+      for (const [primaryKey, change] of finalChanges) {
+        if (change.kind === "upsert") {
+          nextByKey.set(primaryKey, cloneRow(change.row))
+        } else {
+          nextByKey.delete(primaryKey)
+        }
+      }
+
+      if (this.sameKeyedRowContent(previousByKey, nextByKey, definition.schema)) {
+        return {
+          outcome: "unchanged",
+          version: latestVersion ? cloneDatasetVersion(latestVersion) : null,
+        }
+      }
+
+      const visibleRows = [...nextByKey.values()]
+      const versionId = `ver_${randomUUID()}`
+      const version: DatasetVersion = {
+        datasetId: options.merge.dataset.id,
+        versionId,
+        parentVersionId: latestVersion?.versionId,
+        mode: "merge",
+        createdAt: new Date(),
+        schema: definition.schema,
+        producer: options.merge.producer ? structuredClone(options.merge.producer) : undefined,
+        inputs: options.merge.inputs ? structuredClone(options.merge.inputs) : undefined,
+        rowCount: visibleRows.length,
+        sizeBytes: new TextEncoder().encode(
+          visibleRows.map((row) => JSON.stringify(row)).join("\n")
+        ).byteLength,
+      }
+
+      const versions = this.versionsByDataset.get(options.merge.dataset.id) ?? []
+      versions.push(version)
+      this.versionsByDataset.set(options.merge.dataset.id, versions)
+      this.rowsByVersionId.set(
+        versionId,
+        visibleRows.map((row) => cloneRow(row))
+      )
+      this.latestVersionIdByDataset.set(options.merge.dataset.id, versionId)
+
+      return { outcome: "created", version: cloneDatasetVersion(version) }
+    })
+  }
+
+  private async commitWriteUnlocked(options: {
+    write: BeginDatasetWriteInput
+    rows: readonly DatasetRow[]
+    commit?: CommitDatasetWriteInput
   }): Promise<DatasetWriteCommitResult> {
     const definition = this.datasets.get(options.write.dataset.id)
     if (!definition) {
@@ -285,6 +481,8 @@ export class InMemoryLakeStorage implements LakeStorage {
       }
     }
 
+    this.assertKeyedWriteIsUnique(mode, options.rows, latestVersion, definition)
+
     // Content-identical snapshots and empty appends reuse the latest version
     // instead of creating a new one.
     if (
@@ -345,4 +543,88 @@ export class InMemoryLakeStorage implements LakeStorage {
       previousRows.map((row) => rowContentKey(row, schema))
     )
   }
+
+  private assertKeyedWriteIsUnique(
+    mode: DatasetWriteMode,
+    rows: readonly DatasetRow[],
+    latestVersion: DatasetVersion | null,
+    definition: DatasetDefinition
+  ): void {
+    if (getDatasetPrimaryKeyColumns(definition) === null) {
+      return
+    }
+
+    const stagedByKey = this.rowsByPrimaryKey(rows, definition)
+    if (mode !== "append" || latestVersion === null) {
+      return
+    }
+
+    const previousRows = this.rowsByVersionId.get(latestVersion.versionId) ?? []
+    const previousByKey = this.rowsByPrimaryKey(previousRows, definition)
+    for (const primaryKey of stagedByKey.keys()) {
+      if (previousByKey.has(primaryKey)) {
+        throw new LakeStorageError(
+          `[LakeStorage] Dataset '${definition.id}' append contains duplicate primary key ${primaryKey}.`
+        )
+      }
+    }
+  }
+
+  private rowsByPrimaryKey(
+    rows: readonly DatasetRow[],
+    definition: DatasetDefinition
+  ): Map<string, DatasetRow> {
+    const byKey = new Map<string, DatasetRow>()
+    for (const row of rows) {
+      const primaryKey = encodeDatasetPrimaryKey(definition, row)
+      if (byKey.has(primaryKey)) {
+        throw new LakeStorageError(
+          `[LakeStorage] Dataset '${definition.id}' contains duplicate primary key ${primaryKey}.`
+        )
+      }
+      byKey.set(primaryKey, row)
+    }
+    return byKey
+  }
+
+  private sameKeyedRowContent(
+    left: ReadonlyMap<string, DatasetRow>,
+    right: ReadonlyMap<string, DatasetRow>,
+    schema: DatasetSchema
+  ): boolean {
+    if (left.size !== right.size) {
+      return false
+    }
+    for (const [primaryKey, leftRow] of left) {
+      const rightRow = right.get(primaryKey)
+      if (
+        rightRow === undefined ||
+        rowContentKey(leftRow, schema) !== rowContentKey(rightRow, schema)
+      ) {
+        return false
+      }
+    }
+    return true
+  }
+
+  private async withDatasetCommitLock<T>(datasetId: string, run: () => Promise<T>): Promise<T> {
+    const previous = this.commitLocks.get(datasetId) ?? Promise.resolve()
+    const ready = previous.catch(() => {})
+    let release!: () => void
+    const next = new Promise<void>((resolve) => {
+      release = resolve
+    })
+    const current = ready.then(() => next)
+    this.commitLocks.set(datasetId, current)
+
+    await ready
+    try {
+      return await run()
+    } finally {
+      release()
+      if (this.commitLocks.get(datasetId) === current) {
+        this.commitLocks.delete(datasetId)
+      }
+    }
+  }
 }

package/src/lake-storage/index.ts

@@ -2,7 +2,9 @@ export type {
   DatasetColumnDefinition,
   DatasetColumnType,
   DatasetDefinition,
+  DatasetPrimaryKey,
   DatasetSchema,
+  MergeChange,
 } from "../datasets"
 export type { JsonValue } from "../json"
 export type {
@@ -17,6 +19,18 @@ export {
 } from "./definition-updates"
 export { LakeStorageError } from "./errors"
 export { InMemoryLakeStorage } from "./in-memory"
+export type {
+  BeginDatasetMergeInput,
+  CommitDatasetMergeInput,
+  DatasetMergeCommitResult,
+  LakeMergeSession,
+} from "./merge"
+export {
+  cloneDatasetMergeChange,
+  encodeDatasetPrimaryKey,
+  getDatasetMergeChangeValidationError,
+  getDatasetPrimaryKeyColumns,
+} from "./merge-validation"
 export type {
   ExecuteSqlTransformInput,
   LakeSqlExecutor,

package/src/lake-storage/merge-validation.ts

@@ -0,0 +1,117 @@
+import type { DatasetDefinition, MergeChange } from "../datasets"
+import { getDatasetRowValidationError } from "../datasets"
+import { isPlainRecord } from "../json"
+import { LakeStorageError } from "./errors"
+import type { DatasetRow } from "./types"
+
+/** Return a new ordered primary-key column list, or `null` for an unkeyed dataset. */
+export function getDatasetPrimaryKeyColumns(dataset: DatasetDefinition): readonly string[] | null {
+  if (dataset.primaryKey === undefined) {
+    return null
+  }
+  return typeof dataset.primaryKey === "string" ? [dataset.primaryKey] : [...dataset.primaryKey]
+}
+
+/** Collision-safe internal identity for a validated row or delete-key object. */
+export function encodeDatasetPrimaryKey(dataset: DatasetDefinition, value: DatasetRow): string {
+  const columns = getDatasetPrimaryKeyColumns(dataset)
+  if (columns === null) {
+    throw new LakeStorageError(
+      `[SixbLake] Dataset '${dataset.id}' must define a primaryKey before rows can be keyed.`
+    )
+  }
+
+  const values = columns.map((columnName) => {
+    const columnValue = value[columnName]
+    if (typeof columnValue !== "string") {
+      throw new LakeStorageError(
+        `[SixbLake] Dataset '${dataset.id}' primary-key column '${columnName}' must be a string.`
+      )
+    }
+    return columnValue
+  })
+  return JSON.stringify(values)
+}
+
+export function getDatasetMergeChangeValidationError(
+  change: unknown,
+  dataset: DatasetDefinition
+): string | null {
+  const primaryKeyColumns = getDatasetPrimaryKeyColumns(dataset)
+  if (primaryKeyColumns === null) {
+    return `Dataset '${dataset.id}' must define a primaryKey before it can be merged.`
+  }
+  if (!isPlainRecord(change)) {
+    return `Dataset '${dataset.id}' merge changes must be plain objects.`
+  }
+
+  if (change.kind === "upsert") {
+    const shapeError = getChangeShapeError(change, dataset, "row")
+    if (shapeError) {
+      return shapeError
+    }
+    return getDatasetRowValidationError(change.row, dataset)
+  }
+
+  if (change.kind === "delete") {
+    const shapeError = getChangeShapeError(change, dataset, "key")
+    if (shapeError) {
+      return shapeError
+    }
+    return getDeleteKeyValidationError(change.key, dataset, primaryKeyColumns)
+  }
+
+  return `Dataset '${dataset.id}' merge change kind must be 'upsert' or 'delete'.`
+}
+
+/** Clone a validated change before a provider stages it beyond the caller's ownership. */
+export function cloneDatasetMergeChange(
+  change: MergeChange<DatasetRow, DatasetRow>
+): MergeChange<DatasetRow, DatasetRow> {
+  return change.kind === "upsert"
+    ? { kind: "upsert", row: structuredClone(change.row) }
+    : { kind: "delete", key: structuredClone(change.key) }
+}
+
+function getChangeShapeError(
+  change: Record<string, unknown>,
+  dataset: DatasetDefinition,
+  payloadField: "row" | "key"
+): string | null {
+  const allowedFields = new Set(["kind", payloadField])
+  for (const field of Object.keys(change)) {
+    if (!allowedFields.has(field)) {
+      return `Dataset '${dataset.id}' ${change.kind as string} change contains unknown field '${field}'.`
+    }
+  }
+  if (!Object.hasOwn(change, payloadField)) {
+    return `Dataset '${dataset.id}' ${change.kind as string} change is missing '${payloadField}'.`
+  }
+  return null
+}
+
+function getDeleteKeyValidationError(
+  key: unknown,
+  dataset: DatasetDefinition,
+  primaryKeyColumns: readonly string[]
+): string | null {
+  if (!isPlainRecord(key)) {
+    return `Dataset '${dataset.id}' delete keys must be plain objects.`
+  }
+
+  const expectedColumns = new Set(primaryKeyColumns)
+  for (const columnName of Object.keys(key)) {
+    if (!expectedColumns.has(columnName)) {
+      return `Dataset '${dataset.id}' delete key contains unknown column '${columnName}'.`
+    }
+  }
+  for (const columnName of primaryKeyColumns) {
+    if (!Object.hasOwn(key, columnName)) {
+      return `Dataset '${dataset.id}' delete key is missing primary-key column '${columnName}'.`
+    }
+    if (typeof key[columnName] !== "string") {
+      return `Dataset '${dataset.id}' delete key column '${columnName}' must be a string.`
+    }
+  }
+  return null
+}

package/src/lake-storage/merge.ts

@@ -0,0 +1,35 @@
+import type { DatasetDefinition, MergeChange } from "../datasets"
+import type { DatasetProducer, DatasetRow, DatasetVersion, DatasetVersionRef } from "./types"
+
+export interface BeginDatasetMergeInput {
+  /** Stored definition for the keyed dataset whose latest version is captured by `beginMerge`. */
+  readonly dataset: DatasetDefinition
+  /** Optional caller guard checked against the same latest version captured by the session. */
+  readonly expectedLatestVersionId?: string
+  readonly producer?: DatasetProducer
+  readonly inputs?: readonly DatasetVersionRef[]
+}
+
+export interface CommitDatasetMergeInput {
+  readonly commitMessage?: string
+}
+
+/**
+ * A merge can be unchanged before the dataset has a first version, so its result carries the
+ * version separately instead of extending `DatasetVersion` like ordinary write commits do.
+ */
+export type DatasetMergeCommitResult =
+  | { readonly outcome: "created"; readonly version: DatasetVersion }
+  | { readonly outcome: "unchanged"; readonly version: DatasetVersion | null }
+
+export interface LakeMergeSession {
+  /** Stage ordered complete-row upserts and exact primary-key deletes. */
+  writeChanges(
+    changes:
+      | Iterable<MergeChange<DatasetRow, DatasetRow>>
+      | AsyncIterable<MergeChange<DatasetRow, DatasetRow>>
+  ): Promise<void>
+  /** Commit only if the latest version still matches the version captured when the session began. */
+  commit(input?: CommitDatasetMergeInput): Promise<DatasetMergeCommitResult>
+  abort(): Promise<void>
+}

package/src/lake-storage/types.ts

@@ -1,7 +1,8 @@
 import type { DatasetDefinition, DatasetSchema } from "../datasets"
+import type { BeginDatasetMergeInput, LakeMergeSession } from "./merge"
 
 export type DatasetWriteMode = "snapshot" | "append"
-export type DatasetVersionMode = DatasetWriteMode | "schema"
+export type DatasetVersionMode = DatasetWriteMode | "merge" | "schema"
 
 export type DatasetRow = Readonly<Record<string, unknown>>
 
@@ -124,6 +125,7 @@ export interface LakeStorage {
   listVersions(datasetId: string, limit?: number): Promise<readonly DatasetVersion[]>
 
   beginWrite(input: BeginDatasetWriteInput): Promise<LakeWriteSession>
+  beginMerge(input: BeginDatasetMergeInput): Promise<LakeMergeSession>
 
   getLatestVersion(datasetId: string): Promise<DatasetVersion | null>
   getVersion(datasetId: string, versionId: string): Promise<DatasetVersion | null>

package/src/logging/execution.ts

@@ -0,0 +1,28 @@
+import { assertAuthorized } from "../authorization"
+import type { SixbRuntimeContext } from "../runtime/types"
+import type { LoggingService, LogsPage, LogsReadInput, LogsTailInput } from "./service"
+
+export interface LogsRuntime {
+  assertObservable(): void
+  read(input?: LogsReadInput): Promise<LogsPage>
+  tail(input?: LogsTailInput): Promise<LogsPage>
+}
+
+export function createLogsRuntime(
+  runtime: SixbRuntimeContext,
+  source: LoggingService
+): LogsRuntime {
+  const assertObservable = () => assertAuthorized(runtime, { kind: "logs.observe" })
+
+  return {
+    assertObservable,
+    read: (input) => {
+      assertObservable()
+      return source.read(input)
+    },
+    tail: (input) => {
+      assertObservable()
+      return source.tail(input)
+    },
+  }
+}

package/src/logging/index.ts

@@ -5,16 +5,16 @@ export {
   noopLoggerProvider,
 } from "./console-logger"
 export {
+  LoggingService,
+  type LoggingServiceOptions,
   type LogsObservabilityOptions,
   type LogsPage,
   type LogsReadInput,
-  LogsRuntime,
-  type LogsRuntimeOptions,
   type LogsSubscribeInput,
   type LogsTailInput,
   type ObservabilityOptions,
-  resolveLogsRuntime,
-} from "./runtime"
+  resolveLoggingService,
+} from "./service"
 export {
   DEFAULT_LOGS_MAX_BYTES,
   DEFAULT_LOGS_RETENTION,

package/src/logging/{runtime.ts → service.ts}

@@ -75,7 +75,7 @@ export interface ObservabilityOptions {
   readonly logs?: LogsObservabilityOptions
 }
 
-export interface LogsRuntimeOptions {
+export interface LoggingServiceOptions {
   readonly projectId: string
   /** Broker backing the `__logs` stream. Absent means output-only logging. */
   readonly broker?: Broker
@@ -86,8 +86,8 @@ export interface LogsRuntimeOptions {
   readonly stream?: BrokerStreamDefinition
 }
 
-/** Project-scoped logger factory and broker capture runtime. */
-export class LogsRuntime {
+/** Project-scoped logger factory and broker capture service. */
+export class LoggingService {
   private readonly projectId: string
   private readonly broker?: Broker
   private readonly provider: LoggerProvider
@@ -99,7 +99,7 @@ export class LogsRuntime {
   private readonly stream: BrokerStreamDefinition
   private ensureStreamPromise?: Promise<void>
 
-  constructor(options: LogsRuntimeOptions) {
+  constructor(options: LoggingServiceOptions) {
     const config = options.observability ?? {}
     this.projectId = options.projectId
     this.broker = options.broker
@@ -271,9 +271,9 @@ export class LogsRuntime {
   }
 }
 
-/** Resolve a worker runtime, falling back to a silent output-only runtime. */
-export function resolveLogsRuntime(projectId: string, logs?: LogsRuntime): LogsRuntime {
-  return logs ?? new LogsRuntime({ projectId, logger: noopLoggerProvider })
+/** Resolve the logging service, falling back to a silent output-only service. */
+export function resolveLoggingService(projectId: string, logging?: LoggingService): LoggingService {
+  return logging ?? new LoggingService({ projectId, logger: noopLoggerProvider })
 }
 
 function normalizeRedactPaths(paths: readonly string[]): readonly string[] {

package/src/materialization/events.ts

@@ -13,6 +13,7 @@ interface OntologyMaterializationEventBase {
   readonly schemaVersion: 1
   readonly projectId: string
   readonly occurredAt: string
+  readonly correlationId: string
   readonly actor?: EventActor
   readonly origin: OntologyMaterializationOrigin
   readonly commitId: string

package/src/materialization/index.ts

@@ -30,11 +30,13 @@ export type {
   ExpectedLinkScopeRevision,
   ExpectedObjectRevision,
   LinkOverride,
+  LinkSlotOverride,
   MaterializationItemError,
   ObjectOverride,
   OntologyEditCommit,
   OntologyEditOperation,
   OntologyLinkRef,
+  OntologyLinkScopeRef,
   OntologyMaterializationOrigin,
   OntologyMaterializationPropertyChange,
   OntologyMaterializationPropertyChangeMap,