@sixb/core 0.1.0 → 0.1.2

package/src/pipelines/run-dispatch.ts

@@ -0,0 +1,308 @@
+import { randomUUID } from "node:crypto"
+import { reportRunFailure } from "../error-reporting/capability"
+import { createSixbError, toSixbFailure } from "../errors/internal"
+import type { SixbFailure } from "../errors/types"
+import type { RunDispatcher } from "../execution/dispatch"
+import { createPrimitiveExecutionRecord } from "../execution/durable"
+import type { Queues } from "../queues"
+import type { SixbDefinitions } from "../runtime/definitions"
+import type {
+  CreateExecutionInput,
+  PipelineRunFailureCode,
+  PipelineRunRecord,
+  Storage,
+} from "../storage"
+import { PIPELINE_RUN_FAILURE_CODES, PipelineRunError } from "../storage"
+import { PipelineError } from "./errors"
+import type { PipelineRunRequestOptions, PipelineRunRequestResult } from "./request"
+import type { PipelineDefinition } from "./types"
+
+export type AutomaticPipelineExecutionSource =
+  | { readonly type: "schedule"; readonly eventId: string }
+  | { readonly type: "event"; readonly eventId: string }
+
+export interface AutomaticPipelineRunDispatchInput extends PipelineRunRequestOptions {
+  readonly pipelineId: string
+  readonly runId: string
+  readonly source: AutomaticPipelineExecutionSource
+  readonly correlationId: string
+  readonly metadata?: Readonly<Record<string, string>>
+}
+
+export type PipelineRunDispatchPort = RunDispatcher<
+  AutomaticPipelineRunDispatchInput,
+  PipelineRunRequestResult
+>
+
+export interface PipelineRunDispatcherDependencies {
+  readonly id: string
+  readonly definitions: Pick<SixbDefinitions, "pipelines">
+  readonly storage: Storage
+  readonly queues: Pick<Queues, "pipelines">
+}
+
+interface DispatchPipelineRunInput extends PipelineRunRequestOptions {
+  readonly errorReporterHost: object
+  readonly projectId: string
+  readonly pipeline: PipelineDefinition
+  readonly storage: Storage
+  readonly queue: Queues["pipelines"]
+  readonly metadata?: Readonly<Record<string, string>>
+  readonly createExecution: (executionId: string, runId: string) => Promise<CreateExecutionInput>
+  readonly validateExistingRun?: (run: PipelineRunRecord, storage: Storage) => Promise<void>
+}
+
+type PersistedPipelineRun =
+  | { readonly publish: false; readonly run: PipelineRunRecord }
+  | {
+      readonly publish: true
+      readonly run: PipelineRunRecord
+      readonly execution: CreateExecutionInput
+      readonly queuedAt: Date
+      readonly created: boolean
+    }
+
+/** Core-owned durable dispatch boundary used by automatic Pipeline triggers. */
+export class PipelineRunDispatcher implements PipelineRunDispatchPort {
+  constructor(private readonly dependencies: PipelineRunDispatcherDependencies) {}
+
+  async dispatch(input: AutomaticPipelineRunDispatchInput): Promise<PipelineRunRequestResult> {
+    assertAutomaticDispatchInput(input)
+    const pipeline = this.dependencies.definitions.pipelines.getById(input.pipelineId)
+    if (!pipeline) throw new PipelineError(`[Sixb] Unknown pipeline '${input.pipelineId}'`)
+
+    return dispatchPipelineRun({
+      errorReporterHost: this.dependencies,
+      projectId: this.dependencies.id,
+      pipeline,
+      storage: this.dependencies.storage,
+      queue: this.dependencies.queues.pipelines,
+      runId: input.runId,
+      metadata: input.metadata,
+      validateExistingRun: (run, storage) =>
+        assertAutomaticExecutionIdentity(storage, this.dependencies.id, input, run),
+      createExecution: async (executionId, runId) =>
+        createPrimitiveExecutionRecord({
+          id: executionId,
+          primitive: { kind: "pipeline", id: pipeline.id, runId },
+          origin: {
+            type: "automatic",
+            projectId: this.dependencies.id,
+            source: input.source,
+            correlationId: input.correlationId,
+          },
+        }),
+    })
+  }
+}
+
+/** Persist a Pipeline execution and queued run before publishing its queue job. */
+export async function dispatchPipelineRun(
+  input: DispatchPipelineRunInput
+): Promise<PipelineRunRequestResult> {
+  const runId = createPipelineRunId(input.runId)
+  const persisted = await persistPipelineRun(input, runId)
+  if (!persisted.publish) return existingPipelineRunResult(persisted.run)
+  return publishPipelineRun(input, persisted)
+}
+
+async function persistPipelineRun(
+  input: DispatchPipelineRunInput,
+  runId: string
+): Promise<PersistedPipelineRun> {
+  const pipelineRuns = requirePipelineRunStorage(input.storage)
+  const existing = await pipelineRuns.getById({ projectId: input.projectId, id: runId })
+  if (existing) return reusePipelineRun(input, existing)
+
+  const execution = await input.createExecution(`exec_${randomUUID()}`, runId)
+  const queuedAt = new Date()
+  try {
+    return await input.storage.transaction(
+      async (tx): Promise<PersistedPipelineRun> => {
+        const transactionalRuns = requirePipelineRunStorage(tx)
+        const raced = await transactionalRuns.getById({ projectId: input.projectId, id: runId })
+        if (raced) {
+          assertExistingRunMatchesRequest(raced, input)
+          await input.validateExistingRun?.(raced, tx)
+          return { publish: false, run: raced }
+        }
+
+        await tx.executions.create(execution)
+        const run = await transactionalRuns.queue({
+          projectId: input.projectId,
+          id: runId,
+          executionId: execution.id,
+          pipelineId: input.pipeline.id,
+          queuedAt,
+        })
+        return { publish: true, run, execution, queuedAt, created: true }
+      },
+      { isolation: "serializable" }
+    )
+  } catch (error) {
+    if (!(error instanceof PipelineRunError)) throw error
+    const raced = await pipelineRuns.getById({ projectId: input.projectId, id: runId })
+    if (!raced) throw error
+    assertExistingRunMatchesRequest(raced, input)
+    await input.validateExistingRun?.(raced, input.storage)
+    return { publish: false, run: raced }
+  }
+}
+
+async function reusePipelineRun(
+  input: DispatchPipelineRunInput,
+  existing: PipelineRunRecord
+): Promise<PersistedPipelineRun> {
+  assertExistingRunMatchesRequest(existing, input)
+  await input.validateExistingRun?.(existing, input.storage)
+  if (
+    existing.status !== "failed" ||
+    existing.error?.code !== "queue.enqueue_failed" ||
+    !existing.error.retryable
+  ) {
+    return { publish: false, run: existing }
+  }
+
+  const execution = await input.storage.executions.getById({
+    projectId: input.projectId,
+    id: existing.executionId,
+  })
+  if (!execution) {
+    throw new PipelineRunError(
+      `[Sixb] Execution '${existing.executionId}' for Pipeline run '${existing.id}' was not found.`
+    )
+  }
+
+  const queuedAt = new Date()
+  const run = await requirePipelineRunStorage(input.storage).queue({
+    projectId: input.projectId,
+    id: existing.id,
+    executionId: existing.executionId,
+    pipelineId: existing.pipelineId,
+    queuedAt,
+  })
+  return { publish: true, run, execution, queuedAt, created: false }
+}
+
+async function publishPipelineRun(
+  input: DispatchPipelineRunInput,
+  persisted: Extract<PersistedPipelineRun, { readonly publish: true }>
+): Promise<PipelineRunRequestResult> {
+  try {
+    const [job] = await input.queue.enqueue({
+      projectId: input.projectId,
+      jobs: [
+        {
+          id: persisted.run.id,
+          type: "pipeline.run.requested",
+          payload: { runId: persisted.run.id },
+          ...(input.metadata === undefined ? {} : { metadata: input.metadata }),
+        },
+      ],
+    })
+    return {
+      pipelineId: persisted.run.pipelineId,
+      runId: persisted.run.id,
+      queuedAt: persisted.queuedAt.toISOString(),
+      ...(job?.id ? { jobId: job.id } : {}),
+      created: persisted.created,
+    }
+  } catch (error) {
+    const failedAt = new Date()
+    const failure = toEnqueueFailure(error, persisted.run, failedAt)
+    const failed = await requirePipelineRunStorage(input.storage).finish({
+      projectId: input.projectId,
+      id: persisted.run.id,
+      status: "failed",
+      finishedAt: failedAt,
+      error: failure,
+    })
+    reportRunFailure(input.errorReporterHost, error, {
+      projectId: input.projectId,
+      runKind: "pipeline",
+      run: { runId: failed.id, pipelineId: failed.pipelineId },
+      failure,
+    })
+    throw error
+  }
+}
+
+function assertExistingRunMatchesRequest(
+  existing: PipelineRunRecord,
+  input: Pick<DispatchPipelineRunInput, "pipeline">
+): void {
+  if (existing.pipelineId !== input.pipeline.id) {
+    throw new PipelineRunError(
+      `[Sixb] Pipeline run '${existing.id}' already exists with a different request payload.`
+    )
+  }
+}
+
+function existingPipelineRunResult(existing: PipelineRunRecord): PipelineRunRequestResult {
+  return {
+    pipelineId: existing.pipelineId,
+    runId: existing.id,
+    queuedAt: existing.queuedAt.toISOString(),
+    created: false,
+  }
+}
+
+function requirePipelineRunStorage(storage: Storage): NonNullable<Storage["pipelineRuns"]> {
+  if (!storage.pipelineRuns) {
+    throw new PipelineError("[Sixb] Pipeline run storage is not configured.")
+  }
+  return storage.pipelineRuns
+}
+
+function createPipelineRunId(runId: string | undefined): string {
+  if (runId === undefined) return `run_${randomUUID()}`
+  if (!runId.trim()) throw new PipelineError("[Sixb] Pipeline run id must not be empty")
+  return runId
+}
+
+function assertAutomaticDispatchInput(input: AutomaticPipelineRunDispatchInput): void {
+  assertNonBlank(input.pipelineId, "Pipeline id")
+  assertNonBlank(input.runId, "Pipeline run id")
+  assertNonBlank(input.source.eventId, "Pipeline source event id")
+  assertNonBlank(input.correlationId, "Pipeline correlation id")
+}
+
+async function assertAutomaticExecutionIdentity(
+  storage: Storage,
+  projectId: string,
+  input: AutomaticPipelineRunDispatchInput,
+  run: PipelineRunRecord
+): Promise<void> {
+  const execution = await storage.executions.getById({ projectId, id: run.executionId })
+  if (
+    !execution ||
+    execution.source.type !== input.source.type ||
+    execution.source.eventId !== input.source.eventId ||
+    execution.correlationId !== input.correlationId ||
+    execution.requestedBy !== undefined
+  ) {
+    throw new PipelineError(
+      `[Sixb] Pipeline run '${run.id}' already exists with different automatic provenance.`
+    )
+  }
+}
+
+function toEnqueueFailure(
+  error: unknown,
+  run: PipelineRunRecord,
+  at: Date
+): SixbFailure<PipelineRunFailureCode> {
+  const enqueueError = createSixbError(
+    "queue.enqueue_failed",
+    `[Sixb] Could not enqueue Pipeline run '${run.id}'.`,
+    {
+      cause: error,
+      details: { pipelineId: run.pipelineId, runId: run.id, phase: "enqueue" },
+    }
+  )
+  return toSixbFailure(enqueueError, { allowedCodes: PIPELINE_RUN_FAILURE_CODES, at })
+}
+
+function assertNonBlank(value: string, label: string): void {
+  if (!value.trim()) throw new PipelineError(`[Sixb] ${label} must not be empty.`)
+}

package/src/projections/builders.ts

@@ -718,15 +718,6 @@ export function isProjectionDefinition(value: unknown): value is ProjectionDefin
   )
 }
 
-/** Returns the queue/runtime kind for a projection definition. */
-export function projectionKindOf(
-  projection: ProjectionDefinition
-): "object" | "link" | "telemetry" {
-  if (projection._tag === "ObjectProjectionDefinition") return "object"
-  if (projection._tag === "LinkProjectionDefinition") return "link"
-  return "telemetry"
-}
-
 /**
  * Extracts the object type id(s) a projection targets, used to authorize run
  * visibility (`object.view`). Link projections require both ends; object and

package/src/projections/capability.ts

@@ -0,0 +1,37 @@
+import type { ProjectionRegistry } from "./registry"
+import type { ProjectionDispatchDescriptor } from "./types"
+
+const projectionRegistryKey: unique symbol = Symbol("sixb.projectionRegistry")
+
+interface ProjectionRegistryOwner {
+  readonly [projectionRegistryKey]?: ProjectionRegistry
+}
+
+export function registerProjectionRegistry(owner: object, registry: ProjectionRegistry): void {
+  const registered = (owner as ProjectionRegistryOwner)[projectionRegistryKey]
+  if (registered && registered !== registry) {
+    throw new Error("[Sixb] Projection registry is already registered for this owner.")
+  }
+  Object.defineProperty(owner, projectionRegistryKey, {
+    configurable: false,
+    enumerable: false,
+    value: registry,
+    writable: false,
+  })
+}
+
+export function getProjectionRegistry(owner: object): ProjectionRegistry {
+  const registry = (owner as ProjectionRegistryOwner)[projectionRegistryKey]
+  if (registry) return registry
+  throw new Error("[Sixb] Projection registry is not registered for this runtime.")
+}
+
+export function getProjectionDispatchDescriptors(
+  owner: object
+): readonly ProjectionDispatchDescriptor[] {
+  return getProjectionRegistry(owner).getDispatchDescriptors()
+}
+
+export function shareProjectionRegistry(source: object, target: object): void {
+  registerProjectionRegistry(target, getProjectionRegistry(source))
+}

package/src/projections/execution.ts

@@ -0,0 +1,85 @@
+import { canViewProjection, canViewProjectionRun } from "../authorization"
+import type { SixbRuntimeContext } from "../runtime/types"
+import type {
+  ListLatestProjectionRunsResult,
+  ListProjectionRunsInput,
+  ListProjectionRunsResult,
+  ProjectionRunRecord,
+} from "../storage/projection-runs"
+import type { ProjectionDefinitionCatalog } from "./registry"
+import type {
+  LinkProjectionDefinition,
+  ObjectProjectionDefinition,
+  ProjectionDefinition,
+  TelemetryProjectionDefinition,
+} from "./types"
+
+export interface ProjectionRunsRuntime {
+  getById(runId: string): Promise<ProjectionRunRecord | null>
+  list(
+    input?: Omit<ListProjectionRunsInput, "projectId" | "objectTypeIds">
+  ): Promise<ListProjectionRunsResult>
+  listLatest(projectionIds: readonly string[]): Promise<ListLatestProjectionRunsResult>
+}
+
+export interface ProjectionsRuntime {
+  list(): readonly ProjectionDefinition[]
+  listObjects(): readonly ObjectProjectionDefinition[]
+  listLinks(): readonly LinkProjectionDefinition[]
+  listTelemetry(): readonly TelemetryProjectionDefinition[]
+  getById(projectionId: string): ProjectionDefinition | null
+  readonly runs: ProjectionRunsRuntime
+}
+
+export function createProjectionsRuntime(
+  runtime: SixbRuntimeContext,
+  source: ProjectionDefinitionCatalog
+): ProjectionsRuntime {
+  const visible = (projection: ProjectionDefinition) =>
+    canViewProjection(runtime.authorization, projection)
+  const visibleIds = (projectionIds: readonly string[]) =>
+    projectionIds.filter((projectionId) => {
+      const projection = source.getById(projectionId)
+      return projection !== null && visible(projection)
+    })
+
+  return {
+    list: () => source.list().filter(visible),
+    listObjects: () => source.listObjects().filter(visible),
+    listLinks: () => source.listLinks().filter(visible),
+    listTelemetry: () => source.listTelemetry().filter(visible),
+    getById: (projectionId) => {
+      const projection = source.getById(projectionId)
+      return projection && visible(projection) ? projection : null
+    },
+    runs: {
+      getById: async (runId) => {
+        const run =
+          (await runtime.storage.projectionRuns?.getById({
+            projectId: runtime.projectId,
+            id: runId,
+          })) ?? null
+        return run && canViewProjectionRun(runtime.authorization, run.target) ? run : null
+      },
+      list: (input = {}) => {
+        const storage = runtime.storage.projectionRuns
+        if (!storage) return Promise.resolve({ runs: [], hasMore: false, total: 0 })
+        return storage.list({
+          projectId: runtime.projectId,
+          ...input,
+          objectTypeIds: runtime.authorization
+            ? [...runtime.authorization.grants["view:object"]]
+            : undefined,
+        })
+      },
+      listLatest: (projectionIds) => {
+        const storage = runtime.storage.projectionRuns
+        if (!storage || projectionIds.length === 0) return Promise.resolve({ runs: [] })
+        const ids = visibleIds(projectionIds)
+        return ids.length === 0
+          ? Promise.resolve({ runs: [] })
+          : storage.listLatestByProjectionIds({ projectId: runtime.projectId, projectionIds: ids })
+      },
+    },
+  }
+}

package/src/projections/index.ts

@@ -8,10 +8,11 @@ export {
   isObjectProjectionDefinition,
   isProjectionDefinition,
   isTelemetryProjectionDefinition,
-  projectionKindOf,
 } from "./builders"
 // ── Errors ──────────────────────────────────────────────────
 export { ProjectionValidationError } from "./errors"
+export type { ProjectionDefinitionCatalog, ProjectionRegistryOptions } from "./registry"
+export { ProjectionRegistry } from "./registry"
 // ── Types ────────────────────────────────────────────────────
 export type {
   ForeignKeyDescriptor,

package/src/projections/internal.ts

@@ -1,75 +1,32 @@
-import { sha256Canonical } from "../materialization/identity"
 import type { ProjectionMaterializationIdentity } from "../materialization/model"
 import type { ProjectionRegistry } from "./registry"
 import type { ProjectionDispatchDescriptor } from "./types"
 
-const projectionRegistryKey: unique symbol = Symbol("sixb.projectionRegistry")
-
-interface ProjectionRegistryOwner {
-  readonly [projectionRegistryKey]?: ProjectionRegistry
-}
-
-export function registerProjectionRegistry(owner: object, registry: ProjectionRegistry): void {
-  const registered = (owner as ProjectionRegistryOwner)[projectionRegistryKey]
-  if (registered && registered !== registry) {
-    throw new Error("[Sixb] Projection registry is already registered for this owner.")
-  }
-
-  Object.defineProperty(owner, projectionRegistryKey, {
-    configurable: false,
-    enumerable: false,
-    value: registry,
-    writable: false,
-  })
-}
-
-export function getProjectionRegistry(owner: object): ProjectionRegistry {
-  const registry = (owner as ProjectionRegistryOwner)[projectionRegistryKey]
-  if (registry) return registry
-  throw new Error("[Sixb] Projection registry is not registered for this runtime.")
-}
-
-/** Read-only orchestration view without exposing the registry capability to callers. */
-export function getProjectionDispatchDescriptors(
-  owner: object
-): readonly ProjectionDispatchDescriptor[] {
-  return getProjectionRegistry(owner).getDispatchDescriptors()
-}
-
-/** Copies the opaque registry capability when an internal runtime context is reconstructed. */
-export function shareProjectionRegistry(source: object, target: object): void {
-  registerProjectionRegistry(target, getProjectionRegistry(source))
-}
-
-export function createProjectionRunId(
-  projectId: string,
-  identity: ProjectionMaterializationIdentity
-): string {
-  return sha256Canonical({
-    projectId,
-    projectionId: identity.projectionId,
-    projectionKind: identity.projectionKind,
-    protocol: identity.protocol,
-    datasetId: identity.datasetVersion.datasetId,
-    versionId: identity.datasetVersion.versionId,
-    createdAt: identity.datasetVersion.createdAt,
-    ontologyRevision: identity.ontologyRevision,
-    projectionRevision: identity.projectionRevision,
-    ownershipHash: identity.ownershipHash,
-  })
-}
-
 /**
  * What the projection worker needs and an app author does not.
  *
  * `projectionTargetOf` derives the object types a projection writes, to record them on the run.
  * `validateTelemetryProjectionFieldMapping` re-checks a telemetry mapping against the dataset schema
  * before writing. Both are plumbing, so they live here instead of on the `@sixb/core` root.
- *
- * `projectionKindOf` deliberately does not follow: nothing outside `packages/core` calls it, and a
- * subpath export with no importer is the dead surface this curation removes.
  */
 export { projectionTargetOf } from "./builders"
+export {
+  getProjectionDispatchDescriptors,
+  getProjectionRegistry,
+  registerProjectionRegistry,
+  shareProjectionRegistry,
+} from "./capability"
+export type {
+  ProjectionRunDispatcherDependencies,
+  ProjectionRunDispatchInput,
+  ProjectionRunDispatchPort,
+  ProjectionRunDispatchResult,
+} from "./run-dispatch"
+export {
+  PROJECTION_TELEMETRY_BATCH_SIZE,
+  ProjectionRunDispatcher,
+} from "./run-dispatch"
+export { createProjectionRunId } from "./run-id"
 export { validateTelemetryProjectionFieldMapping } from "./validation"
 
 export type { ProjectionDispatchDescriptor, ProjectionMaterializationIdentity, ProjectionRegistry }

package/src/projections/ownership.ts

@@ -1,11 +1,11 @@
 import { compareStrings } from "../json"
-import type { OntologyRegistry } from "../ontology"
+import type { OntologyDefinitionCatalog } from "../ontology"
 import { ProjectionValidationError } from "./errors"
 import type { ProjectionDefinition, ProjectionOwnership } from "./types"
 
 export function computeProjectionOwnership(
   projection: ProjectionDefinition,
-  ontology: OntologyRegistry
+  ontology: OntologyDefinitionCatalog
 ): ProjectionOwnership {
   if (projection._tag === "ObjectProjectionDefinition") {
     const primaryId = ontology.getPrimaryPropertyId(projection.objectTypeId)

package/src/projections/registry.ts

@@ -1,5 +1,5 @@
 import type { DatasetDefinition } from "../datasets"
-import type { OntologyRegistry } from "../ontology"
+import type { OntologyDefinitionCatalog } from "../ontology"
 import { isProjectionDefinition } from "./builders"
 import { ProjectionValidationError } from "./errors"
 import {
@@ -19,7 +19,22 @@ import { type ValidatedProjectionRecord, validateProjectionsAtStartup } from "./
 
 type SourceProjectionDefinition = ObjectProjectionDefinition | LinkProjectionDefinition
 
-export class ProjectionRegistry {
+/** Public definition catalog backed by the host's validated projection registry. */
+export interface ProjectionDefinitionCatalog {
+  list(): readonly ProjectionDefinition[]
+  getById(projectionId: string): ProjectionDefinition | null
+  listObjects(): readonly ObjectProjectionDefinition[]
+  listLinks(): readonly LinkProjectionDefinition[]
+  listTelemetry(): readonly TelemetryProjectionDefinition[]
+}
+
+export interface ProjectionRegistryOptions {
+  readonly projections: readonly ProjectionDefinition[]
+  readonly ontology: OntologyDefinitionCatalog
+  readonly datasetsById: ReadonlyMap<string, DatasetDefinition>
+}
+
+export class ProjectionRegistry implements ProjectionDefinitionCatalog {
   readonly ontologyRevision: string
   private readonly objectProjections: readonly ObjectProjectionDefinition[]
   private readonly linkProjections: readonly LinkProjectionDefinition[]
@@ -33,11 +48,7 @@ export class ProjectionRegistry {
   private readonly dispatchById = new Map<string, ProjectionDispatchDescriptor>()
   private readonly dispatchDescriptors: readonly ProjectionDispatchDescriptor[]
 
-  constructor(input: {
-    readonly projections: readonly ProjectionDefinition[]
-    readonly ontology: OntologyRegistry
-    readonly datasetsById: ReadonlyMap<string, DatasetDefinition>
-  }) {
+  constructor(input: ProjectionRegistryOptions) {
     const objectProjections: ObjectProjectionDefinition[] = []
     const linkProjections: LinkProjectionDefinition[] = []
     const telemetryProjections: TelemetryProjectionDefinition[] = []
@@ -103,19 +114,23 @@ export class ProjectionRegistry {
     }
   }
 
-  listObjectProjections(): readonly ObjectProjectionDefinition[] {
+  list(): readonly ProjectionDefinition[] {
+    return [...this.objectProjections, ...this.linkProjections, ...this.telemetryProjections]
+  }
+
+  listObjects(): readonly ObjectProjectionDefinition[] {
     return this.objectProjections
   }
 
-  listLinkProjections(): readonly LinkProjectionDefinition[] {
+  listLinks(): readonly LinkProjectionDefinition[] {
     return this.linkProjections
   }
 
-  listTelemetryProjections(): readonly TelemetryProjectionDefinition[] {
+  listTelemetry(): readonly TelemetryProjectionDefinition[] {
     return this.telemetryProjections
   }
 
-  getProjectionById(projectionId: string): ProjectionDefinition | null {
+  getById(projectionId: string): ProjectionDefinition | null {
     return this.projectionsById.get(projectionId) ?? null
   }
 

package/src/projections/revision.ts

@@ -1,11 +1,11 @@
 import type { DatasetDefinition } from "../datasets"
 import { compareStrings, type JsonValue } from "../json"
 import { sha256Canonical } from "../materialization/identity"
-import type { OntologyRegistry } from "../ontology"
+import type { OntologyDefinitionCatalog } from "../ontology"
 import type { ObjectFieldSchema, Property, Schema } from "../ontology/types"
 import type { ProjectionDefinition, ProjectionOwnership } from "./types"
 
-export function computeOntologyRevision(ontology: OntologyRegistry): string {
+export function computeOntologyRevision(ontology: OntologyDefinitionCatalog): string {
   const referencedValueTypeIds = collectOntologyValueTypeDependencies(ontology)
   return sha256Canonical({
     objectTypes: normalizeOntologyObjectTypes(ontology),
@@ -13,7 +13,9 @@ export function computeOntologyRevision(ontology: OntologyRegistry): string {
   })
 }
 
-function collectOntologyValueTypeDependencies(ontology: OntologyRegistry): ReadonlySet<string> {
+function collectOntologyValueTypeDependencies(
+  ontology: OntologyDefinitionCatalog
+): ReadonlySet<string> {
   const referencedValueTypeIds = new Set<string>()
   for (const objectType of ontology.getObjectTypesById().values()) {
     for (const property of objectType.properties) {
@@ -41,7 +43,7 @@ function collectOntologyValueTypeDependencies(ontology: OntologyRegistry): Reado
 }
 
 function normalizeOntologyValueTypes(
-  ontology: OntologyRegistry,
+  ontology: OntologyDefinitionCatalog,
   referencedValueTypeIds: ReadonlySet<string>
 ): JsonValue[] {
   return [...referencedValueTypeIds]
@@ -55,7 +57,7 @@ function normalizeOntologyValueTypes(
     }))
 }
 
-function normalizeOntologyObjectTypes(ontology: OntologyRegistry): JsonValue[] {
+function normalizeOntologyObjectTypes(ontology: OntologyDefinitionCatalog): JsonValue[] {
   return [...ontology.getObjectTypesById().values()]
     .sort((left, right) => compareStrings(left.id, right.id))
     .map((objectType) => ({