@sixb/core 0.1.1 → 0.1.2

package/src/error-reporting/types.ts

@@ -1,49 +1,74 @@
+import type { SixbFailure } from "../errors/types"
+import type { ActionRunFailure } from "../storage/action-runs"
+import type { AgentRunFailureCode } from "../storage/agents"
+import type { PipelineRunFailureCode } from "../storage/pipeline-runs"
+import type { ProjectionRunFailureCode } from "../storage/projection-runs"
+import type { SyncRunFailureCode } from "../storage/sync-runs"
+import type { WebhookRunFailureCode } from "../storage/webhook-runs"
+import type { WorkflowRunFailureCode } from "../storage/workflow-runs"
+
+/** Correlation fields exposed by `run.failed`, indexed by run primitive. */
+export interface SixbRunIdentityByKind {
+  readonly action: {
+    readonly runId: string
+    readonly actionId: string
+  }
+  readonly agent: {
+    readonly runId: string
+    readonly agentId: string
+  }
+  readonly pipeline: {
+    readonly runId: string
+    readonly pipelineId: string
+  }
+  readonly projection: {
+    readonly runId: string
+    readonly projectionId: string
+    readonly projectionKind: "object" | "link" | "telemetry"
+  }
+  readonly sync: {
+    readonly runId: string
+    readonly syncId: string
+  }
+  readonly workflow: {
+    readonly runId: string
+    readonly workflowId: string
+  }
+  readonly webhook: {
+    readonly runId: string
+    readonly connectorId: string
+    readonly webhookId: string
+  }
+}
+
+/** Canonical failure record exposed by `run.failed`, indexed by run primitive. */
+export interface SixbRunFailureByKind {
+  readonly action: ActionRunFailure
+  readonly agent: SixbFailure<AgentRunFailureCode>
+  readonly pipeline: SixbFailure<PipelineRunFailureCode>
+  readonly projection: SixbFailure<ProjectionRunFailureCode>
+  readonly sync: SixbFailure<SyncRunFailureCode>
+  readonly workflow: SixbFailure<WorkflowRunFailureCode>
+  readonly webhook: SixbFailure<WebhookRunFailureCode>
+}
+
 /**
  * The failed unit of work, discriminated by primitive. Each variant carries the correlation its
- * primitive actually has, and there is exactly one variant per `SixbRunKind`.
+ * primitive actually has and the exact failure persisted by that run. There is exactly one variant
+ * per `SixbRunKind`.
  *
  * Rules are deliberately absent: they are evaluated live, per subject, with no run record, so they
  * report through `SixbRuleEvaluationFailedContext` instead of being handed a `runId` that would name
  * an entity nothing can resolve.
  */
-export type SixbFailedRun =
-  | {
-      readonly kind: "action"
-      readonly runId: string
-      readonly actionId: string
-    }
-  | {
-      readonly kind: "agent"
-      readonly runId: string
-      readonly agentId: string
-    }
-  | {
-      readonly kind: "pipeline"
-      readonly runId: string
-      readonly pipelineId: string
-    }
-  | {
-      readonly kind: "projection"
-      readonly runId: string
-      readonly projectionId: string
-      readonly projectionKind: "object" | "link" | "telemetry"
-    }
-  | {
-      readonly kind: "sync"
-      readonly runId: string
-      readonly syncId: string
-    }
-  | {
-      readonly kind: "workflow"
-      readonly runId: string
-      readonly workflowId: string
-    }
-  | {
-      readonly kind: "webhook"
-      readonly runId: string
-      readonly connectorId: string
-      readonly webhookId: string
-    }
+export type SixbFailedRun = {
+  readonly [TKind in keyof SixbRunIdentityByKind]: {
+    /** Top-level discriminant so TypeScript narrows both `run` and `failure` without casts. */
+    readonly runKind: TKind
+    readonly run: SixbRunIdentityByKind[TKind]
+    readonly failure: SixbRunFailureByKind[TKind]
+  }
+}[keyof SixbRunIdentityByKind]
 
 interface SixbFailureContext<TType extends string> {
   readonly type: TType
@@ -59,10 +84,31 @@ interface SixbFailureContext<TType extends string> {
   readonly occurredAt: string
 }
 
-export interface SixbRunFailedContext extends SixbFailureContext<"run.failed"> {
-  /** Queue delivery attempt, when the run was executed through a queue. */
-  readonly attempt?: number
-  readonly run: SixbFailedRun
+export type SixbRunFailedContext = SixbFailureContext<"run.failed"> &
+  SixbFailedRun & {
+    /** Queue delivery attempt, when the run was executed through a queue. */
+    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.
+ */
+export interface SixbActionPhaseFailedContext extends SixbFailureContext<"action.phase.failed"> {
+  readonly actionId: string
+  readonly runId: string
+  readonly phase: "effects"
+  readonly failure: ActionRunFailure<"effects">
 }
 
 /**
@@ -79,6 +125,8 @@ export interface SixbRunFailedContext extends SixbFailureContext<"run.failed"> {
  */
 export interface SixbEventDeliveryFailedContext
   extends SixbFailureContext<"event.delivery.failed"> {
+  /** Canonical delivery failure, also persisted when the outbox owns the delivery. */
+  readonly failure: SixbFailure<"event.delivery_failed">
   /** Delivery attempts so far. A rejected emit is terminal, so it reports 1. */
   readonly attempts: number
   /** Which event types never reached subscribers. Payloads are never included. */
@@ -104,6 +152,11 @@ export interface SixbEventDeliveryFailedContext
  */
 export interface SixbRuleEvaluationFailedContext
   extends SixbFailureContext<"rule.evaluation.failed"> {
+  /**
+   * Canonical snapshot of the thrown value. Rule failures remain `internal.unexpected` until the
+   * evaluator can distinguish deterministic rule failures from retryable dependency failures.
+   */
+  readonly failure: SixbFailure<"internal.unexpected">
   readonly source: "live" | "reconciliation"
   /** Envelope IDs involved in a live evaluation; empty for reconciliation. */
   readonly eventIds: readonly string[]
@@ -117,6 +170,7 @@ export interface SixbRuleEvaluationFailedContext
  * Failure notifications never change the outcome of the operation they observe.
  */
 export type SixbErrorContext =
+  | SixbActionPhaseFailedContext
   | SixbRunFailedContext
   | SixbEventDeliveryFailedContext
   | SixbRuleEvaluationFailedContext

package/src/errors/catalog.ts

@@ -0,0 +1,149 @@
+interface SixbErrorDefinition {
+  readonly publicMessage: string
+  readonly retryable: boolean
+}
+
+/**
+ * Source of truth for stable Sixb error codes and their framework-level policy.
+ *
+ * Keep this catalog internal. Consumers receive the `SixbErrorCode` union and persisted
+ * `SixbFailure` values, not a mutable registry.
+ */
+export const SIXB_ERROR_DEFINITIONS = {
+  "action.phase_failed": {
+    publicMessage: "Action execution failed.",
+    retryable: false,
+  },
+  "agent.execution_failed": {
+    publicMessage: "Agent execution failed.",
+    retryable: false,
+  },
+  "connector.adapter_invalid": {
+    publicMessage: "Connector adapter returned an invalid result.",
+    retryable: false,
+  },
+  "connector.authorization_invalid": {
+    publicMessage: "Connector authorization is invalid.",
+    retryable: false,
+  },
+  "connector.authorization_required": {
+    publicMessage: "Connector authorization is required.",
+    retryable: false,
+  },
+  "connector.configuration_invalid": {
+    publicMessage: "Connector configuration is invalid.",
+    retryable: false,
+  },
+  "connector.credentials_unavailable": {
+    publicMessage: "Connector credentials are unavailable.",
+    retryable: false,
+  },
+  "connector.not_found": {
+    publicMessage: "Connector resource not found.",
+    retryable: false,
+  },
+  "connector.operation_conflict": {
+    publicMessage: "Connector operation conflicts with the current state.",
+    retryable: false,
+  },
+  "connector.operation_in_progress": {
+    publicMessage: "Another connector credential operation is in progress.",
+    retryable: true,
+  },
+  "connector.provider_failed": {
+    publicMessage: "Connector provider operation failed.",
+    retryable: false,
+  },
+  "connector.provider_unavailable": {
+    publicMessage: "Connector provider is temporarily unavailable.",
+    retryable: true,
+  },
+  "connector.replacement_required": {
+    publicMessage: "Connector selection requires explicit replacement.",
+    retryable: false,
+  },
+  "connector.revocation_pending": {
+    publicMessage: "Connector revocation is pending.",
+    retryable: true,
+  },
+  "dataset.not_found": {
+    publicMessage: "Dataset not found.",
+    retryable: false,
+  },
+  "dataset.version_incompatible": {
+    publicMessage: "Dataset version is incompatible.",
+    retryable: false,
+  },
+  "dataset.version_not_found": {
+    publicMessage: "Dataset version not found.",
+    retryable: false,
+  },
+  "dataset.version_read_inconsistent": {
+    publicMessage: "Dataset version could not be read consistently.",
+    retryable: true,
+  },
+  "event.delivery_failed": {
+    publicMessage: "Event delivery failed.",
+    retryable: true,
+  },
+  "internal.unexpected": {
+    publicMessage: "An unexpected internal error occurred.",
+    retryable: false,
+  },
+  "queue.enqueue_failed": {
+    publicMessage: "The job could not be enqueued.",
+    retryable: true,
+  },
+  "pipeline.step_failed": {
+    publicMessage: "Pipeline step execution failed.",
+    retryable: false,
+  },
+  "projection.definition_invalid": {
+    publicMessage: "Projection definition is invalid.",
+    retryable: false,
+  },
+  "projection.execution_failed": {
+    publicMessage: "Projection execution failed.",
+    retryable: false,
+  },
+  "projection.not_found": {
+    publicMessage: "Projection not found.",
+    retryable: false,
+  },
+  "projection.run_already_terminal": {
+    publicMessage: "Projection run is already terminal.",
+    retryable: false,
+  },
+  "projection.run_identity_mismatch": {
+    publicMessage: "Projection run identity does not match the queued job.",
+    retryable: false,
+  },
+  "runtime.cancelled": {
+    publicMessage: "Execution was cancelled.",
+    retryable: false,
+  },
+  "sync.execution_failed": {
+    publicMessage: "Sync execution failed.",
+    retryable: false,
+  },
+  "webhook.delivery_failed": {
+    publicMessage: "Webhook delivery failed.",
+    retryable: true,
+  },
+  "webhook.delivery_rejected": {
+    publicMessage: "Webhook delivery was rejected.",
+    retryable: false,
+  },
+  "workflow.node_failed": {
+    publicMessage: "Workflow node execution failed.",
+    retryable: false,
+  },
+} as const satisfies Readonly<Record<string, SixbErrorDefinition>>
+
+type CatalogErrorCode = keyof typeof SIXB_ERROR_DEFINITIONS
+
+/** Runtime counterpart of `SixbErrorCode` for internal schema boundaries. */
+export const SIXB_ERROR_CODES = Object.freeze(Object.keys(SIXB_ERROR_DEFINITIONS)) as readonly [
+  CatalogErrorCode,
+  ...CatalogErrorCode[],
+]

package/src/errors/internal.ts

@@ -0,0 +1,322 @@
+import { cloneJsonValue, isJsonValue, isPlainRecord, type ReadonlyJsonValue } from "../json"
+import { SIXB_ERROR_CODES, SIXB_ERROR_DEFINITIONS } from "./catalog"
+import type { SixbErrorCode, SixbFailure } from "./types"
+
+export const SIXB_FAILURE_MAX_MESSAGE_BYTES = 4 * 1024
+export const SIXB_FAILURE_MAX_SERIALIZED_BYTES = 32 * 1024
+const TRUNCATION_SUFFIX = "… [truncated]"
+const SIXB_ERROR_CODE_SET: ReadonlySet<string> = new Set(SIXB_ERROR_CODES)
+
+type SixbErrorCodeTuple = readonly [SixbErrorCode, ...SixbErrorCode[]]
+
+export { SIXB_ERROR_CODES }
+
+export interface SixbErrorOptions {
+  readonly cause?: unknown
+  readonly details?: ReadonlyJsonValue
+}
+
+/** Internal structural view returned by the factory. The implementing class stays private. */
+export interface SixbCodedError extends Error {
+  readonly code: SixbErrorCode
+  readonly retryable: boolean
+  readonly details?: ReadonlyJsonValue
+  readonly cause?: unknown
+}
+
+export interface ToSixbFailureOptions {
+  /** Timestamp for deterministic persistence. Defaults to the current time. */
+  readonly at?: Date
+}
+
+export interface ToScopedSixbFailureOptions<TCodes extends SixbErrorCodeTuple>
+  extends ToSixbFailureOptions {
+  /** Codes this boundary is allowed to expose. */
+  readonly allowedCodes: TCodes
+}
+
+export interface CaptureSixbFailureOptions<TCodes extends SixbErrorCodeTuple>
+  extends ToScopedSixbFailureOptions<TCodes> {
+  /** Code assigned when the captured value is uncoded or outside this boundary's contract. */
+  readonly defaultCode: TCodes[number]
+  /** Context attached only to the boundary error created for such a captured value. */
+  readonly details?: ReadonlyJsonValue
+}
+
+/**
+ * The canonical exception used inside Sixb.
+ *
+ * The class is deliberately not exported: repo-internal callers use the factory and consumers only
+ * ever observe serializable `SixbFailure` values.
+ */
+class SixbError extends Error implements SixbCodedError {
+  override readonly name = "SixbError"
+  readonly retryable: boolean
+  readonly details?: ReadonlyJsonValue
+
+  constructor(
+    readonly code: SixbErrorCode,
+    message: string,
+    options: SixbErrorOptions = {}
+  ) {
+    super(message, options.cause === undefined ? undefined : { cause: options.cause })
+    this.retryable = SIXB_ERROR_DEFINITIONS[code].retryable
+    if (options.details !== undefined) {
+      this.details = cloneJsonValue(options.details, "Sixb error details")
+    }
+  }
+}
+
+/** Creates a coded internal error without exposing its runtime class. */
+export function createSixbError(
+  code: SixbErrorCode,
+  message: string,
+  options: SixbErrorOptions = {}
+): SixbCodedError {
+  return new SixbError(code, message, options)
+}
+
+/**
+ * Captures an unknown terminal error as a scoped durable failure.
+ *
+ * An already-coded error is preserved only when its code belongs to this boundary. Every other
+ * value is wrapped once with the boundary's default code and context before serialization.
+ */
+export function captureSixbFailure<const TCodes extends SixbErrorCodeTuple>(
+  error: unknown,
+  options: CaptureSixbFailureOptions<TCodes>
+): SixbFailure<TCodes[number]> {
+  const allowedCodes = new Set<SixbErrorCode>(options.allowedCodes)
+  const codedError =
+    isSixbError(error) && allowedCodes.has(error.code)
+      ? error
+      : createSixbError(options.defaultCode, summarizeErrorMessage(error), {
+          cause: error,
+          ...(options.details === undefined ? {} : { details: options.details }),
+        })
+
+  return toSixbFailure(codedError, {
+    allowedCodes: options.allowedCodes,
+    ...(options.at === undefined ? {} : { at: options.at }),
+  })
+}
+
+/** Identifies errors created by Sixb without making their class part of the contract. */
+export function isSixbError(error: unknown): error is SixbCodedError {
+  return error instanceof SixbError
+}
+
+/**
+ * Takes a detached, serializable snapshot of a coded internal error.
+ *
+ * Use `captureSixbFailure()` instead when a terminal boundary receives an unknown thrown value.
+ */
+export function toSixbFailure<const TCodes extends SixbErrorCodeTuple>(
+  error: SixbCodedError,
+  options: ToScopedSixbFailureOptions<TCodes>
+): SixbFailure<TCodes[number]>
+export function toSixbFailure(error: SixbCodedError, options?: ToSixbFailureOptions): SixbFailure
+export function toSixbFailure(
+  error: SixbCodedError,
+  options: ToSixbFailureOptions | ToScopedSixbFailureOptions<SixbErrorCodeTuple> = {}
+): SixbFailure {
+  if (!isSixbError(error)) {
+    throw new Error("[Sixb] A durable failure can only be created from a coded Sixb error.")
+  }
+  const allowedCodes = "allowedCodes" in options ? new Set(options.allowedCodes) : undefined
+  if (allowedCodes && !allowedCodes.has(error.code)) {
+    throw new Error(`[Sixb] Error code '${error.code}' is not allowed by this failure contract.`)
+  }
+  const code = error.code
+  const details = error.details
+  const message = truncateUtf8(
+    SIXB_ERROR_DEFINITIONS[code].publicMessage,
+    SIXB_FAILURE_MAX_MESSAGE_BYTES
+  )
+  const failure: SixbFailure = {
+    code,
+    message: message.value,
+    retryable: SIXB_ERROR_DEFINITIONS[code].retryable,
+    at: failureTimestamp(options.at),
+    ...(details === undefined ? {} : { details: cloneJsonValue(details, "Sixb failure details") }),
+    ...(message.truncated ? { truncated: true } : {}),
+  }
+
+  if (serializedByteLength(failure) <= SIXB_FAILURE_MAX_SERIALIZED_BYTES) return failure
+
+  return {
+    code: failure.code,
+    message: failure.message,
+    retryable: failure.retryable,
+    at: failure.at,
+    truncated: true,
+  }
+}
+
+/** Serializes a validated failure for durable storage. */
+export function serializeSixbFailure<const TCodes extends SixbErrorCodeTuple>(
+  failure: SixbFailure<TCodes[number]>,
+  allowedCodes: TCodes
+): string
+export function serializeSixbFailure(failure: SixbFailure): string
+export function serializeSixbFailure(
+  failure: SixbFailure,
+  allowedCodes?: SixbErrorCodeTuple
+): string {
+  const parsed = allowedCodes ? parseSixbFailure(failure, allowedCodes) : parseSixbFailure(failure)
+  return JSON.stringify(parsed)
+}
+
+/**
+ * Validates and detaches a failure read from a storage boundary.
+ *
+ * Strings are accepted for SQLite; PostgreSQL adapters can pass their decoded JSON value directly.
+ */
+export function parseSixbFailure<const TCodes extends SixbErrorCodeTuple>(
+  value: unknown,
+  allowedCodes: TCodes
+): SixbFailure<TCodes[number]>
+export function parseSixbFailure(value: unknown): SixbFailure
+export function parseSixbFailure(
+  value: unknown,
+  allowedCodes: SixbErrorCodeTuple = SIXB_ERROR_CODES
+): SixbFailure {
+  const candidate = parseStoredFailureValue(value)
+  if (!isPlainRecord(candidate)) {
+    throw invalidStoredFailure("expected a JSON object")
+  }
+
+  const { code, message, retryable, at, details, truncated } = candidate
+  if (typeof code !== "string" || !SIXB_ERROR_CODE_SET.has(code)) {
+    throw invalidStoredFailure("code is not a known Sixb error code")
+  }
+  if (!(allowedCodes as readonly string[]).includes(code)) {
+    throw invalidStoredFailure("code is not allowed by this failure contract")
+  }
+  if (typeof message !== "string") {
+    throw invalidStoredFailure("message is not a string")
+  }
+  if (utf8ByteLength(message) > SIXB_FAILURE_MAX_MESSAGE_BYTES) {
+    throw invalidStoredFailure(`message exceeds ${SIXB_FAILURE_MAX_MESSAGE_BYTES} UTF-8 bytes`)
+  }
+  if (typeof retryable !== "boolean") {
+    throw invalidStoredFailure("retryable is not a boolean")
+  }
+  if (retryable !== SIXB_ERROR_DEFINITIONS[code as SixbErrorCode].retryable) {
+    throw invalidStoredFailure("retryable does not match the error code policy")
+  }
+  if (typeof at !== "string" || !isCanonicalIsoTimestamp(at)) {
+    throw invalidStoredFailure("at is not a canonical ISO-8601 timestamp")
+  }
+  if (details !== undefined && !isJsonValue(details)) {
+    throw invalidStoredFailure("details is not a JSON value")
+  }
+  if (truncated !== undefined && truncated !== true) {
+    throw invalidStoredFailure("truncated must be true when present")
+  }
+
+  const failure: SixbFailure = {
+    code: code as SixbErrorCode,
+    message,
+    retryable,
+    at,
+    ...(details === undefined
+      ? {}
+      : { details: cloneJsonValue(details, "Stored Sixb failure details") }),
+    ...(truncated === true ? { truncated: true } : {}),
+  }
+  if (serializedByteLength(failure) > SIXB_FAILURE_MAX_SERIALIZED_BYTES) {
+    throw invalidStoredFailure(
+      `record exceeds ${SIXB_FAILURE_MAX_SERIALIZED_BYTES} serialized UTF-8 bytes`
+    )
+  }
+  return failure
+}
+
+function parseStoredFailureValue(value: unknown): unknown {
+  if (typeof value !== "string") return value
+  try {
+    return JSON.parse(value) as unknown
+  } catch {
+    throw invalidStoredFailure("value is not valid JSON")
+  }
+}
+
+function isCanonicalIsoTimestamp(value: string): boolean {
+  const timestamp = new Date(value)
+  return Number.isFinite(timestamp.getTime()) && timestamp.toISOString() === value
+}
+
+function invalidStoredFailure(reason: string): Error {
+  return new Error(`[Sixb] Stored failure is invalid: ${reason}.`)
+}
+
+/**
+ * Extracts a diagnostic message for an internal error or log entry.
+ *
+ * The result can contain provider data and must not be persisted or returned by an API.
+ * `toSixbFailure()` selects the catalog-owned public message instead.
+ */
+export function summarizeErrorMessage(value: unknown, fallback?: string): string {
+  const message = readStringProperty(value, "message")
+  if (message !== undefined) return message
+  if (typeof value === "string") return value
+  return fallback ?? safeString(value)
+}
+
+function readStringProperty(value: unknown, property: "message"): string | undefined {
+  if (!isObjectLike(value)) return undefined
+  try {
+    const result = Reflect.get(value, property)
+    return typeof result === "string" ? result : undefined
+  } catch {
+    return undefined
+  }
+}
+
+function isObjectLike(value: unknown): value is object {
+  return (typeof value === "object" && value !== null) || typeof value === "function"
+}
+
+function safeString(value: unknown): string {
+  try {
+    return String(value)
+  } catch {
+    return "Unknown thrown value"
+  }
+}
+
+function failureTimestamp(at: Date | undefined): string {
+  const timestamp = at ?? new Date()
+  if (!Number.isFinite(timestamp.getTime())) {
+    throw new Error("[Sixb] Failure timestamp must be a valid Date.")
+  }
+  return timestamp.toISOString()
+}
+
+function serializedByteLength(value: SixbFailure): number {
+  return utf8ByteLength(JSON.stringify(value))
+}
+
+function utf8ByteLength(value: string): number {
+  return new TextEncoder().encode(value).byteLength
+}
+
+function truncateUtf8(value: string, maxBytes: number): { value: string; truncated: boolean } {
+  if (utf8ByteLength(value) <= maxBytes) return { value, truncated: false }
+
+  const suffixBytes = utf8ByteLength(TRUNCATION_SUFFIX)
+  const characters = Array.from(value)
+  let low = 0
+  let high = characters.length
+  while (low < high) {
+    const middle = Math.ceil((low + high) / 2)
+    if (utf8ByteLength(characters.slice(0, middle).join("")) + suffixBytes <= maxBytes) {
+      low = middle
+    } else {
+      high = middle - 1
+    }
+  }
+
+  return { value: `${characters.slice(0, low).join("")}${TRUNCATION_SUFFIX}`, truncated: true }
+}

package/src/errors/types.ts

@@ -0,0 +1,21 @@
+import type { ReadonlyJsonValue } from "../json"
+import type { SIXB_ERROR_DEFINITIONS } from "./catalog"
+
+/** Stable machine-readable identity for a Sixb failure. */
+export type SixbErrorCode = keyof typeof SIXB_ERROR_DEFINITIONS
+
+/**
+ * Serializable snapshot of a failure at the point where Sixb records it.
+ *
+ * Unlike the internal error object, this value can cross storage, HTTP, and process boundaries.
+ */
+export interface SixbFailure<TCode extends SixbErrorCode = SixbErrorCode> {
+  readonly code: TCode
+  readonly message: string
+  readonly retryable: boolean
+  /** ISO-8601 UTC timestamp of the failure occurrence. */
+  readonly at: string
+  readonly details?: ReadonlyJsonValue
+  /** Present when optional context exceeded the durable failure size budget and was omitted. */
+  readonly truncated?: true
+}

package/src/events/definitions.ts

@@ -220,10 +220,6 @@ export function isOntologyFactType(
   )
 }
 
-export function getEventTopic(type: DomainEvent["type"]): DomainEvent["topic"] {
-  return EVENT_DEFINITIONS[type].topic
-}
-
 export function resolveEventStorage(event: DomainEventDraft): {
   readonly topic: DomainEvent["topic"]
   readonly partitionKey: string