@sixb/core 0.1.17 → 0.1.19

package/src/datasets/builders.ts

@@ -1,3 +1,5 @@
+import { markingIdsFrom } from "../security/builders"
+import type { MarkingDefinition } from "../security/types"
 import { DatasetValidationError } from "./errors"
 import type {
   DatasetColumnDefinition,
@@ -10,6 +12,8 @@ import { assertDatasetColumnDefinition, assertDatasetDefinition } from "./valida
 
 type DatasetColumnOptions = {
   readonly nullable?: boolean
+  /** Principals need a clearance for every marking to read this column. */
+  readonly markings?: readonly MarkingDefinition[]
 }
 
 type DefineDatasetOptions = {
@@ -112,6 +116,13 @@ type DerivedColumns<
     : DerivedBaseColumns<TParent, TOptions>
   : DerivedBaseColumns<TParent, TOptions>
 
+/** The column records marking ids; only a declared, non-empty list marks it. */
+type MarkingsFromOptions<TOptions> = TOptions extends {
+  readonly markings: readonly [MarkingDefinition, ...MarkingDefinition[]]
+}
+  ? { readonly markings: readonly string[] }
+  : { readonly markings?: readonly string[] }
+
 type DatasetColumnResult<
   TName extends string,
   TType extends DatasetColumnType,
@@ -119,7 +130,8 @@ type DatasetColumnResult<
 > = {
   readonly name: TName
   readonly type: TType
-} & FieldFromOptions<TOptions, "nullable", boolean>
+} & FieldFromOptions<TOptions, "nullable", boolean> &
+  MarkingsFromOptions<TOptions>
 
 type DatasetDefinitionResult<TId extends string, TOptions extends DefineDatasetOptions> = Omit<
   DatasetDefinition<TId, TOptions["schema"]>,
@@ -165,10 +177,14 @@ export function col(
   type: DatasetColumnType,
   options?: DatasetColumnOptions
 ): DatasetColumnDefinition {
+  const markings = options?.markings
   const column: DatasetColumnDefinition = {
     name,
     type,
     ...(options?.nullable !== undefined ? { nullable: options.nullable } : {}),
+    ...(markings && markings.length > 0
+      ? { markings: markingIdsFrom(markings, `Dataset column '${name}' markings`) }
+      : {}),
   }
 
   assertDatasetColumnDefinition(column, (message) => new DatasetValidationError(message))

package/src/datasets/execution.ts

@@ -1,11 +1,18 @@
-import { assertPrivileged, isRuntimeAllowed } from "../authorization"
+import {
+  assertAuthorized,
+  assertPrivileged,
+  assertRuntimeAuthorizationBound,
+  isRuntimeAllowed,
+} from "../authorization"
 import type { BlobStorage } from "../blob-storage"
 import type { ExecutionContext } from "../execution"
 import { resolveRuntimeAuthorizationForProject } from "../execution/authorization"
 import type { DatasetMergeCommitResult } from "../lake-storage/merge"
 import { getDatasetPrimaryKeyColumns } from "../lake-storage/merge-validation"
-import type { DatasetRow, LakeStorage } from "../lake-storage/types"
+import type { DatasetRow, DatasetVersion, LakeStorage } from "../lake-storage/types"
 import type { SixbRuntimeContext } from "../runtime/types"
+import { missingClearanceRedactions } from "../security/redactions"
+import type { Redactions } from "../security/types"
 import type { MergeChange } from "./changes"
 import type { DatasetDefinition } from "./types"
 import { writeDataset } from "./write"
@@ -20,9 +27,36 @@ export interface DatasetIngestInput {
 /** Source commit result; downstream pipelines and projections run asynchronously. */
 export type DatasetIngestResult = DatasetMergeCommitResult & { readonly rowsRead: number }
 
+export interface DatasetReadRowsInput {
+  /** Defaults to the latest version. */
+  readonly versionId?: string
+  /** Defaults to every column of the version, in schema order. */
+  readonly columns?: readonly string[]
+  readonly limit?: number
+  readonly offset?: number
+  readonly signal?: AbortSignal
+}
+
+export interface DatasetRows {
+  readonly version: DatasetVersion
+  /** Columns each row holds. Redacted columns are left out. */
+  readonly columns: readonly string[]
+  /**
+   * Every column of the dataset the reader cannot read, whether or not it was requested. Absent
+   * when the reader can read every column.
+   */
+  readonly redactions?: Redactions
+  readonly rows: AsyncIterable<DatasetRow>
+}
+
 export interface DatasetsRuntime {
   list(): readonly DatasetDefinition[]
   getById(datasetId: string): DatasetDefinition | null
+  /**
+   * Read rows of one version. Returns null when the dataset has no version yet or the requested
+   * version does not exist.
+   */
+  readRows(dataset: DatasetDefinition, input?: DatasetReadRowsInput): Promise<DatasetRows | null>
   ingest(dataset: DatasetDefinition, input: DatasetIngestInput): Promise<DatasetIngestResult>
 }
 
@@ -47,6 +81,44 @@ export function createDatasetsRuntime(
       const dataset = source.getById(datasetId)
       return dataset && allowed(datasetId) ? dataset : null
     },
+    async readRows(dataset, input = {}) {
+      assertAuthorized(runtime, { kind: "dataset.view", datasetId: dataset.id })
+      const registered = source.getById(dataset.id)
+      if (!registered) throw new Error(`[Sixb] Dataset '${dataset.id}' is not registered.`)
+      const version =
+        input.versionId === undefined
+          ? await lakeStorage.getLatestVersion(registered.id)
+          : await lakeStorage.getVersion(registered.id, input.versionId)
+      if (!version) return null
+
+      const redacted = redactedColumns(registered, assertRuntimeAuthorizationBound(runtime))
+      const selected = selectColumns(version, input.columns)
+      const columns = selected.filter((column) => !redacted.has(column))
+      const read = (readColumns: readonly string[] | undefined) =>
+        lakeStorage.readRows({
+          datasetId: registered.id,
+          versionId: version.versionId,
+          columns: readColumns,
+          limit: input.limit,
+          offset: input.offset,
+          signal: input.signal,
+        })
+
+      // Redacted columns are not read. A provider reads every column when given none, so a page
+      // made only of redacted columns reads one of them to count its rows and returns them empty.
+      const rows =
+        columns.length === selected.length
+          ? read(input.columns)
+          : columns.length > 0
+            ? read(columns)
+            : emptyRows(read(selected.slice(0, 1)))
+      return {
+        version,
+        columns,
+        ...(redacted.size > 0 ? { redactions: missingClearanceRedactions(redacted) } : {}),
+        rows,
+      }
+    },
     async ingest(dataset, input) {
       assertPrivileged(runtime, "datasets.ingest")
       const registered = source.getById(dataset.id)
@@ -93,3 +165,39 @@ export function createDatasetsRuntime(
     },
   }
 }
+
+/** Requested columns, or every column of the version. Like the lake, an empty list means all. */
+function selectColumns(version: DatasetVersion, requested: readonly string[] | undefined) {
+  const available = version.schema.columns.map((column) => column.name)
+  if (requested === undefined || requested.length === 0) return available
+  for (const column of requested) {
+    if (!available.includes(column)) {
+      throw new Error(
+        `[Sixb] Dataset '${version.datasetId}' does not have column '${column}' at version '${version.versionId}'.`
+      )
+    }
+  }
+  return [...requested]
+}
+
+/**
+ * Columns the reader cannot read. Trusted code reads every column, a principal reads what its roles
+ * clear, and any other authority is cleared for nothing.
+ */
+function redactedColumns(
+  dataset: DatasetDefinition,
+  authority: ReturnType<typeof assertRuntimeAuthorizationBound>
+): ReadonlySet<string> {
+  if (authority.type === "unrestricted") return new Set()
+  const clearances =
+    authority.type === "principal" ? (authority.context.clearances ?? new Set()) : new Set()
+  return new Set(
+    dataset.schema.columns
+      .filter((column) => column.markings?.some((markingId) => !clearances.has(markingId)))
+      .map((column) => column.name)
+  )
+}
+
+async function* emptyRows(rows: AsyncIterable<DatasetRow>): AsyncIterable<DatasetRow> {
+  for await (const _row of rows) yield {}
+}

package/src/datasets/index.ts

@@ -2,7 +2,13 @@ export { col, defineDataset } from "./builders"
 export type { MergeChange } from "./changes"
 export { change } from "./changes"
 export { DatasetValidationError } from "./errors"
-export type { DatasetIngestInput, DatasetIngestResult, DatasetsRuntime } from "./execution"
+export type {
+  DatasetIngestInput,
+  DatasetIngestResult,
+  DatasetReadRowsInput,
+  DatasetRows,
+  DatasetsRuntime,
+} from "./execution"
 export type {
   DatasetColumnDefinition,
   DatasetColumnDefinitionOf,

package/src/datasets/types.ts

@@ -16,6 +16,8 @@ export interface DatasetColumnDefinition<
   readonly name: TName
   readonly type: TType
   readonly nullable?: boolean
+  /** Marking ids. Principals need a clearance for each one to read this column. */
+  readonly markings?: readonly string[]
 }
 
 export interface DatasetSchema<

package/src/datasets/write.ts

@@ -1,5 +1,6 @@
 import type { BlobStorage, FileRef } from "../blob-storage"
 import { isFileRef } from "../blob-storage"
+import { isValidFileRef } from "../blob-storage/validation"
 import type { DatasetMergeCommitResult } from "../lake-storage/merge"
 import { getDatasetMergeChangeValidationError } from "../lake-storage/merge-validation"
 import type {
@@ -37,6 +38,18 @@ export interface WriteDatasetInput<TValue extends DatasetWriteValue = DatasetWri
 
 export type WriteDatasetResult = DatasetMergeCommitResult & { readonly rowsRead: number }
 
+/**
+ * The definition the lake receives. Markings are enforced from the registered definition and never
+ * stored, so a stored schema cannot keep a classification the code has since changed.
+ */
+export function lakeDatasetDefinition(dataset: DatasetDefinition): DatasetDefinition {
+  if (!dataset.schema.columns.some((column) => column.markings)) return dataset
+  return {
+    ...dataset,
+    schema: { columns: dataset.schema.columns.map(({ markings: _markings, ...column }) => column) },
+  }
+}
+
 /**
  * Validate, stage, and commit one dataset write using existing lake sessions.
  *
@@ -47,7 +60,8 @@ export type WriteDatasetResult = DatasetMergeCommitResult & { readonly rowsRead:
 export async function writeDataset<TValue extends DatasetWriteValue>(
   input: WriteDatasetInput<TValue>
 ): Promise<WriteDatasetResult> {
-  const { lakeStorage, dataset, signal } = input
+  const { lakeStorage, signal } = input
+  const dataset = lakeDatasetDefinition(input.dataset)
   let abortWrite: (() => Promise<void>) | undefined
   let rowsRead = 0
   const onRead = () => {
@@ -207,8 +221,13 @@ async function verifyFileRef(
   columnName: string,
   itemIndex: number
 ): Promise<void> {
-  const blobInfo = await input.blobStorage.stat(fileRef.blobId)
   const context = `${sourceLabel(input)} returned row ${itemIndex} with dataset '${input.dataset.id}' column '${columnName}'`
+  if (!isValidFileRef(fileRef)) {
+    throw new Error(
+      `${context} with an invalid mediaType; use one media type, such as "application/pdf".`
+    )
+  }
+  const blobInfo = await input.blobStorage.stat(fileRef.blobId)
   if (!blobInfo) {
     throw new Error(`${context} referencing unknown blob '${fileRef.blobId}'.`)
   }

package/src/deploy/index.ts

@@ -8,7 +8,6 @@ export type {
   DeployCiCredential,
   DeployCommand,
   DeployConfig,
-  DeployConfigurableWorkerType,
   DeployContext,
   DeployControlAction,
   DeployEnv,

package/src/deploy/services.ts

@@ -1,5 +1,4 @@
 import type {
-  DeployConfigurableWorkerType,
   DeployHttpServiceName,
   DeployServiceName,
   DeploySingletonServiceName,
@@ -19,27 +18,19 @@ const SERVICES = {
   workers: "workers",
 } as const satisfies Record<DeployServiceName, "http" | "singleton" | "workers">
 
-/** Whether each worker type's concurrency can be configured. */
-const WORKER_TYPES: {
-  readonly [Type in DeployWorkerType]: Type extends DeployConfigurableWorkerType ? true : false
-} = {
+const WORKER_TYPES = {
   sync: true,
-  action: false,
   agent: true,
   pipeline: true,
   projection: true,
   workflow: true,
-}
+} as const satisfies Record<DeployWorkerType, true>
 
 /** Every service, in the order a deployment lists them. */
 export const DEPLOY_SERVICES = Object.keys(SERVICES) as DeployServiceName[]
 
 export const DEPLOY_WORKER_TYPES = Object.keys(WORKER_TYPES) as DeployWorkerType[]
 
-export const DEPLOY_CONFIGURABLE_WORKER_TYPES = DEPLOY_WORKER_TYPES.filter(
-  (workerType): workerType is DeployConfigurableWorkerType => WORKER_TYPES[workerType]
-)
-
 export function isDeployHttpService(service: DeployServiceName): service is DeployHttpServiceName {
   return SERVICES[service] === "http"
 }

package/src/deploy/types.ts

@@ -36,10 +36,7 @@ export type DeploySingletonServiceName = "orchestrator" | "scheduler" | "rules"
 
 export type DeployServiceName = DeployHttpServiceName | DeploySingletonServiceName | "workers"
 
-export type DeployWorkerType = "sync" | "action" | "agent" | "pipeline" | "projection" | "workflow"
-
-/** Action jobs run one at a time, so their concurrency is fixed. */
-export type DeployConfigurableWorkerType = Exclude<DeployWorkerType, "action">
+export type DeployWorkerType = "sync" | "agent" | "pipeline" | "projection" | "workflow"
 
 export interface DeployServicesConfig {
   readonly api?: boolean | DeployHttpServiceConfig
@@ -74,7 +71,7 @@ export interface DeployWorkersConfig {
   /** Wall-clock budget for one agent turn, such as `"30s"`, `"10m"`, or `"1h"`. */
   readonly agentTurnTimeout?: string
   /** Jobs each worker type runs at once inside one process. */
-  readonly concurrency?: Readonly<Partial<Record<DeployConfigurableWorkerType, number>>>
+  readonly concurrency?: Readonly<Partial<Record<DeployWorkerType, number>>>
   /** Added to the deployment's `env` for the workers only. */
   readonly env?: DeployEnv
   readonly process?: DeployScalableProcessOptions
@@ -90,7 +87,10 @@ export interface DeployProcessDefinition {
 }
 
 export interface DeployProcessOptions {
-  /** How long a stopping process may take before it is killed. Defaults to 10000. */
+  /**
+   * How long a stopping process may take before it is killed. Defaults to 10000, and to 70000 for
+   * the API, which first lets the Actions it is running and their effects finish.
+   */
   readonly killTimeoutMs?: number
   /** Wait before restarting a process that exited, growing with each restart. Defaults to 1000. */
   readonly restartDelayMs?: number

package/src/deploy/validation.ts

@@ -1,5 +1,4 @@
 import {
-  DEPLOY_CONFIGURABLE_WORKER_TYPES,
   DEPLOY_SERVICES,
   DEPLOY_WORKER_TYPES,
   isDeployHttpService,
@@ -131,6 +130,7 @@ function workerTypes(value: unknown, path: string): void {
   }
   const seen = new Set<string>()
   for (const workerType of value) {
+    if (workerType === "action") throw removedActionWorker(path)
     if (!(DEPLOY_WORKER_TYPES as readonly unknown[]).includes(workerType)) {
       throw new Error(
         `[SixbDeploy] ${path} has unknown worker type ${JSON.stringify(workerType)}. ` +
@@ -147,19 +147,25 @@ function workerTypes(value: unknown, path: string): void {
 function workerConcurrency(value: unknown, path: string): void {
   const config = record(value, path)
   for (const [workerType, concurrency] of Object.entries(config)) {
-    if (workerType === "action") {
-      throw new Error(`[SixbDeploy] ${path}.action cannot be set: action jobs run one at a time.`)
-    }
-    if (!(DEPLOY_CONFIGURABLE_WORKER_TYPES as readonly string[]).includes(workerType)) {
+    if (workerType === "action") throw removedActionWorker(path)
+    if (!(DEPLOY_WORKER_TYPES as readonly string[]).includes(workerType)) {
       throw new Error(
         `[SixbDeploy] ${path} has unknown worker type "${workerType}". ` +
-          `Available: ${DEPLOY_CONFIGURABLE_WORKER_TYPES.join(", ")}.`
+          `Available: ${DEPLOY_WORKER_TYPES.join(", ")}.`
       )
     }
     positiveInteger(concurrency, `${path}.${workerType}`)
   }
 }
 
+/** `"action"` was a worker type until Actions ran in the process that requests them. */
+function removedActionWorker(path: string): Error {
+  return new Error(
+    `[SixbDeploy] ${path} names "action", which is no longer a worker type: Actions run in the ` +
+      "process that requests them (API, workflows, syncs). Remove it."
+  )
+}
+
 function processOptions(
   value: unknown,
   path: string,

package/src/edits/properties.ts

@@ -3,6 +3,7 @@ import { OntologyValidationError } from "../ontology/errors"
 import type { ObjectTypeWithPropertyTokens } from "../ontology/tokens"
 import {
   assertKnownProperties,
+  assertValidFileRefs,
   normalizeObjectProperties,
   validateObjectProperties,
   validatePropertyValue,
@@ -20,6 +21,7 @@ export function normalizeObjectEditProperties(params: {
   assertKnownProperties(objectType, properties)
   assertNoTelemetryProperties(objectType.properties, properties, path)
   validateObjectProperties(objectType, properties, valueTypesById)
+  assertValidFileRefs(properties, objectType.id)
   return normalizeObjectProperties(objectType.properties, properties, valueTypesById, path)
 }
 
@@ -60,6 +62,7 @@ export function normalizeLinkEditProperties(params: {
       valueTypesById
     )
   }
+  assertValidFileRefs(properties, `${sourceObjectTypeId}.${linkId}`)
 
   return normalizeObjectProperties(
     linkProperties,

package/src/error-reporting/types.ts

@@ -93,19 +93,11 @@ export type SixbRunFailedContext = SixbFailureContext<"run.failed"> &
     readonly attempt?: number
   }
 
-/** A post-commit Action effects phase failed without changing the committed Action outcome. */
-export interface SixbActionPhaseFailedContext extends SixbFailureContext<"action.phase.failed"> {
-  readonly actionId: string
-  readonly runId: string
-  readonly phase: "effects"
-  readonly failure: ActionRunFailure<"effects">
-}
-
 /**
  * A post-commit Action phase failed without changing the committed Action outcome.
  *
- * Effects run after the authoritative commit, so the Action run remains succeeded while this
- * context exposes the exact phase failure stored on the run.
+ * Effects run after the run is recorded with its commit, so the run remains succeeded while this
+ * context exposes the exact phase failure recorded on it.
  */
 export interface SixbActionPhaseFailedContext extends SixbFailureContext<"action.phase.failed"> {
   readonly actionId: string

package/src/errors/catalog.ts

@@ -18,6 +18,15 @@ export const SIXB_ERROR_DEFINITIONS = {
     publicMessage: "Data the Action read changed before its commit.",
     retryable: true,
   },
+  "action.run_in_progress": {
+    publicMessage: "The Action run is already in progress.",
+    retryable: true,
+  },
+  // Not retryable: the deadline aborts a writeback whose external call may still have landed.
+  "action.timeout": {
+    publicMessage: "The Action exceeded its 30-second time limit.",
+    retryable: false,
+  },
   "agent.execution_failed": {
     publicMessage: "Agent execution failed.",
     retryable: false,
@@ -134,6 +143,10 @@ export const SIXB_ERROR_DEFINITIONS = {
     publicMessage: "Execution was cancelled.",
     retryable: false,
   },
+  "runtime.stopping": {
+    publicMessage: "The runtime is stopping; retry the request.",
+    retryable: true,
+  },
   "vector.model_unavailable": {
     publicMessage: "The embedding model configured for this vector profile is unavailable.",
     retryable: false,

package/src/events/definitions.ts

@@ -1,5 +1,4 @@
 import { EventsError } from "./errors"
-import type { ActionEvent } from "./types/actions"
 import type { DatasetEvent } from "./types/datasets"
 import type { DomainEvent, DomainEventDraft } from "./types/index"
 import type { LinkEvent } from "./types/links"
@@ -67,21 +66,6 @@ export const LINK_EVENT_DEFINITIONS = defineEventGroup<LinkEvent>({
   },
 })
 
-export const ACTION_EVENT_DEFINITIONS = defineEventGroup<ActionEvent>({
-  "action.requested": {
-    topic: "actions",
-    partitionKey: (payload) => payload.actionId,
-  },
-  "action.completed": {
-    topic: "actions",
-    partitionKey: (payload) => payload.actionId,
-  },
-  "action.failed": {
-    topic: "actions",
-    partitionKey: (payload) => payload.actionId,
-  },
-})
-
 export const SCHEDULE_EVENT_DEFINITIONS = defineEventGroup<ScheduleEvent>({
   "schedule.triggered": {
     topic: "schedules",
@@ -190,7 +174,6 @@ export const EVENT_DEFINITIONS = {
   ...OBJECT_EVENT_DEFINITIONS,
   ...TELEMETRY_EVENT_DEFINITIONS,
   ...LINK_EVENT_DEFINITIONS,
-  ...ACTION_EVENT_DEFINITIONS,
   ...SCHEDULE_EVENT_DEFINITIONS,
   ...SYNC_EVENT_DEFINITIONS,
   ...PIPELINE_EVENT_DEFINITIONS,

package/src/events/execution.ts

@@ -1,5 +1,6 @@
 import { assertPrivileged, canViewEvent } from "../authorization"
 import { resolveRuntimeAuthorizationForProject } from "../execution/authorization"
+import { redactDomainEvent, resolvePropertyClearance } from "../objects/property-clearance"
 import type { SixbRuntimeContext } from "../runtime/types"
 import type {
   EventsAppendInput,
@@ -10,7 +11,8 @@ import type {
 import type { StoredDomainEvent } from "./types"
 
 export interface EventsRuntime {
-  canRead(event: StoredDomainEvent): boolean
+  /** The event as this execution may read it: hidden events are `undefined`, others redacted. */
+  readable(event: StoredDomainEvent): StoredDomainEvent | undefined
   append(input: EventsAppendInput): Promise<readonly StoredDomainEvent[]>
   emit(input: EventsAppendInput, options: EventsEmitOptions): Promise<void>
   read(input?: EventsReadInput): Promise<readonly StoredDomainEvent[]>
@@ -23,30 +25,27 @@ export interface EventsRuntime {
 
 export function createEventsRuntime(runtime: SixbRuntimeContext): EventsRuntime {
   const authority = resolveRuntimeAuthorizationForProject(runtime)
-  const visibleEvents = (events: readonly StoredDomainEvent[]): readonly StoredDomainEvent[] => {
+  const clearance =
+    authority.type === "principal"
+      ? resolvePropertyClearance(runtime.ontology, authority.context.clearances ?? new Set())
+      : undefined
+  const readable = (event: StoredDomainEvent): StoredDomainEvent | undefined => {
     switch (authority.type) {
       case "denied":
       case "delegated":
-        return []
+        return undefined
       case "principal":
-        return events.filter((event) => canViewEvent(authority.context, event))
+        if (!canViewEvent(authority.context, event)) return undefined
+        return clearance ? redactDomainEvent(event, clearance) : event
       case "unrestricted":
-        return [...events]
+        return event
     }
   }
+  const visibleEvents = (events: readonly StoredDomainEvent[]): readonly StoredDomainEvent[] =>
+    events.flatMap((event) => readable(event) ?? [])
 
   return {
-    canRead: (event) => {
-      switch (authority.type) {
-        case "denied":
-        case "delegated":
-          return false
-        case "principal":
-          return canViewEvent(authority.context, event)
-        case "unrestricted":
-          return true
-      }
-    },
+    readable,
     append: (input) => {
       assertPrivileged(runtime, "events.append")
       return runtime.events.append(input)

package/src/events/index.ts

@@ -1,7 +1,6 @@
 export type { ErrorReporter } from "../error-reporting/reporter"
 export type { EventDefinition, EventDefinitionGroup, EventDefinitionMap } from "./definitions"
 export {
-  ACTION_EVENT_DEFINITIONS,
   DATASET_EVENT_DEFINITIONS,
   EVENT_DEFINITIONS,
   EVENT_TOPICS,
@@ -26,12 +25,6 @@ export {
 export type { EventScopeKeys } from "./scope"
 export { scopeKeysForEvent } from "./scope"
 export {
-  type ActionEventSelectorBuilder,
-  type ActionEventSelectorContext,
-  type ActionEventSelectorEvent,
-  type ActionEventSelectorOperation,
-  type ActionEventToken,
-  type ActionEventTokenOf,
   buildEventSelectorPredicate,
   type DatasetEventSelectorBuilder,
   type DatasetEventSelectorContext,
@@ -82,11 +75,7 @@ export {
 } from "./service"
 export { toStoredEvent } from "./toStoredEvent"
 export type {
-  ActionCompletedEvent,
-  ActionEvent,
   ActionEventOrigin,
-  ActionFailedEvent,
-  ActionRequestedEvent,
   AuthorableDomainEvent,
   AuthorableEventDraft,
   DatasetEvent,
@@ -122,9 +111,6 @@ export type {
   RuntimeMutationEventOrigin,
   ScheduleEvent,
   ScheduleTriggeredEvent,
-  StoredActionCompletedEvent,
-  StoredActionFailedEvent,
-  StoredActionRequestedEvent,
   StoredAuthorableEvent,
   StoredDatasetVersionCommittedEvent,
   StoredDomainEvent,

package/src/events/scope.ts

@@ -17,7 +17,6 @@ export interface EventScopeKeys {
   readonly linkId?: string
   readonly ruleId?: string
   readonly runId?: string
-  readonly actionId?: string
   readonly datasetId?: string
   readonly syncId?: string
   readonly pipelineId?: string
@@ -45,17 +44,6 @@ export function scopeKeysForEvent(event: DomainEvent): EventScopeKeys {
       return { pipelineId: event.payload.pipelineId, runId: event.payload.runId }
     case "syncs":
       return { syncId: event.payload.syncId, runId: event.payload.runId }
-    case "actions":
-      return {
-        actionId: event.payload.actionId,
-        runId: event.payload.runId,
-        ...(event.payload.subject.kind === "object"
-          ? {
-              objectTypeId: event.payload.subject.objectTypeId,
-              primaryId: event.payload.subject.primaryId,
-            }
-          : {}),
-      }
     case "rules":
       return { ruleId: event.payload.ruleId }
     case "schedules":