@codemation/core 0.0.1

package/src/contracts/ExpRetryPolicy.ts

@@ -0,0 +1,23 @@
+import type { ExponentialRetryPolicySpec } from "./retryPolicySpec.types";
+
+export class ExpRetryPolicy implements ExponentialRetryPolicySpec {
+  readonly kind = "exponential" as const;
+
+  constructor(
+    public readonly maxAttempts: number,
+    public readonly initialDelayMs: number,
+    public readonly multiplier: number,
+    public readonly maxDelayMs?: number,
+    public readonly jitter?: boolean,
+  ) {
+    if (!Number.isFinite(maxAttempts) || maxAttempts < 1 || !Number.isInteger(maxAttempts)) {
+      throw new Error(`ExpRetryPolicy.maxAttempts must be a positive integer, got ${maxAttempts}`);
+    }
+    if (!Number.isFinite(initialDelayMs) || initialDelayMs < 0) {
+      throw new Error(`ExpRetryPolicy.initialDelayMs must be a non-negative finite number, got ${initialDelayMs}`);
+    }
+    if (!Number.isFinite(multiplier) || multiplier < 1) {
+      throw new Error(`ExpRetryPolicy.multiplier must be >= 1, got ${multiplier}`);
+    }
+  }
+}

package/src/contracts/NoRetryPolicy.ts

@@ -0,0 +1,5 @@
+import type { NoneRetryPolicySpec } from "./retryPolicySpec.types";
+
+export class NoRetryPolicy implements NoneRetryPolicySpec {
+  readonly kind = "none" as const;
+}

package/src/contracts/RetryPolicy.ts

@@ -0,0 +1,23 @@
+import type { FixedRetryPolicySpec } from "./retryPolicySpec.types";
+
+export class RetryPolicy implements FixedRetryPolicySpec {
+  readonly kind = "fixed" as const;
+
+  constructor(
+    public readonly maxAttempts: number,
+    public readonly delayMs: number,
+  ) {
+    if (!Number.isFinite(maxAttempts) || maxAttempts < 1 || !Number.isInteger(maxAttempts)) {
+      throw new Error(`RetryPolicy.maxAttempts must be a positive integer, got ${maxAttempts}`);
+    }
+    if (!Number.isFinite(delayMs) || delayMs < 0) {
+      throw new Error(`RetryPolicy.delayMs must be a non-negative finite number, got ${delayMs}`);
+    }
+  }
+
+  /** Default for HTTP-style transient failures: 3 tries, 1s between attempts. */
+  static readonly defaultForHttp: FixedRetryPolicySpec = { kind: "fixed", maxAttempts: 3, delayMs: 1000 };
+
+  /** Default for LLM / agent calls: 3 tries, 2s fixed backoff. */
+  static readonly defaultForAiAgent: FixedRetryPolicySpec = { kind: "fixed", maxAttempts: 3, delayMs: 2000 };
+}

package/src/contracts/credentialTypes.ts

@@ -0,0 +1,194 @@
+import type { NodeId, WorkflowId } from "./workflowTypes";
+
+export type CredentialTypeId = string;
+export type CredentialInstanceId = string;
+
+export type CredentialMaterialSourceKind = "db" | "env" | "code";
+export type CredentialSetupStatus = "draft" | "ready";
+export type CredentialHealthStatus = "unknown" | "healthy" | "failing";
+
+export type CredentialFieldSchema = Readonly<{
+  key: string;
+  label: string;
+  type: "string" | "password" | "textarea" | "json" | "boolean";
+  required?: true;
+  order?: number;
+  placeholder?: string;
+  helpText?: string;
+  /** When set, host resolves this field from process.env at runtime; env wins over stored values. */
+  envVarName?: string;
+  /**
+   * When set, the dialog shows a copy action for this exact string (e.g. a static OAuth redirect URI
+   * pattern or documentation URL). Do not use for secret values.
+   */
+  copyValue?: string;
+  /** Accessible label for the copy control (default: Copy). */
+  copyButtonLabel?: string;
+}>;
+
+export type CredentialRequirement = Readonly<{
+  slotKey: string;
+  label: string;
+  acceptedTypes: ReadonlyArray<CredentialTypeId>;
+  optional?: true;
+  helpText?: string;
+  helpUrl?: string;
+}>;
+
+export type CredentialBindingKey = Readonly<{
+  workflowId: WorkflowId;
+  nodeId: NodeId;
+  slotKey: string;
+}>;
+
+export type CredentialBinding = Readonly<{
+  key: CredentialBindingKey;
+  instanceId: CredentialInstanceId;
+  updatedAt: string;
+}>;
+
+export type CredentialHealth = Readonly<{
+  status: CredentialHealthStatus;
+  message?: string;
+  testedAt?: string;
+  expiresAt?: string;
+  details?: Readonly<Record<string, unknown>>;
+}>;
+
+export type OAuth2ProviderFromPublicConfig = Readonly<{
+  authorizeUrlFieldKey: string;
+  tokenUrlFieldKey: string;
+  userInfoUrlFieldKey?: string;
+}>;
+
+export type CredentialOAuth2AuthDefinition = Readonly<
+  | {
+      kind: "oauth2";
+      providerId: string;
+      scopes: ReadonlyArray<string>;
+      clientIdFieldKey?: string;
+      clientSecretFieldKey?: string;
+    }
+  | {
+      kind: "oauth2";
+      providerFromPublicConfig: OAuth2ProviderFromPublicConfig;
+      scopes: ReadonlyArray<string>;
+      clientIdFieldKey?: string;
+      clientSecretFieldKey?: string;
+    }
+>;
+
+export type CredentialAuthDefinition = CredentialOAuth2AuthDefinition;
+
+export type CredentialTypeDefinition = Readonly<{
+  typeId: CredentialTypeId;
+  displayName: string;
+  description?: string;
+  publicFields?: ReadonlyArray<CredentialFieldSchema>;
+  secretFields?: ReadonlyArray<CredentialFieldSchema>;
+  supportedSourceKinds?: ReadonlyArray<CredentialMaterialSourceKind>;
+  auth?: CredentialAuthDefinition;
+}>;
+
+/**
+ * JSON-shaped credential field bag (public config, resolved secret material, etc.).
+ */
+export type CredentialJsonRecord = Readonly<Record<string, unknown>>;
+
+/**
+ * Persisted credential instance with typed `publicConfig`.
+ * Hosts may specialize `secretRef` with a stricter union while remaining
+ * assignable here for session/test callbacks.
+ */
+export type CredentialInstanceRecord<TPublicConfig extends CredentialJsonRecord = CredentialJsonRecord> = Readonly<{
+  instanceId: CredentialInstanceId;
+  typeId: CredentialTypeId;
+  displayName: string;
+  sourceKind: CredentialMaterialSourceKind;
+  publicConfig: TPublicConfig;
+  secretRef: CredentialJsonRecord;
+  tags: ReadonlyArray<string>;
+  setupStatus: CredentialSetupStatus;
+  createdAt: string;
+  updatedAt: string;
+}>;
+
+/**
+ * Arguments passed to `CredentialType.createSession` and `CredentialType.test`.
+ * Declare `TPublicConfig` / `TMaterial` on `CredentialType` so implementations are checked
+ * against your credential shapes (similar to `NodeExecutionContext.config` for nodes).
+ */
+export type CredentialSessionFactoryArgs<
+  TPublicConfig extends CredentialJsonRecord = CredentialJsonRecord,
+  TMaterial extends CredentialJsonRecord = CredentialJsonRecord,
+> = Readonly<{
+  instance: CredentialInstanceRecord<TPublicConfig>;
+  material: TMaterial;
+  publicConfig: TPublicConfig;
+}>;
+
+export type CredentialSessionFactory<
+  TPublicConfig extends CredentialJsonRecord = CredentialJsonRecord,
+  TMaterial extends CredentialJsonRecord = CredentialJsonRecord,
+  TSession = unknown,
+> = (args: CredentialSessionFactoryArgs<TPublicConfig, TMaterial>) => Promise<TSession>;
+
+export type CredentialHealthTester<
+  TPublicConfig extends CredentialJsonRecord = CredentialJsonRecord,
+  TMaterial extends CredentialJsonRecord = CredentialJsonRecord,
+> = (args: CredentialSessionFactoryArgs<TPublicConfig, TMaterial>) => Promise<CredentialHealth>;
+
+/**
+ * Full credential type implementation: `definition` (UI/schema), `createSession`, and `test`.
+ * Use this at registration and config boundaries; `CredentialTypeDefinition` is only the schema slice.
+ */
+export type CredentialType<
+  TPublicConfig extends CredentialJsonRecord = CredentialJsonRecord,
+  TMaterial extends CredentialJsonRecord = CredentialJsonRecord,
+  TSession = unknown,
+> = Readonly<{
+  definition: CredentialTypeDefinition;
+  createSession: CredentialSessionFactory<TPublicConfig, TMaterial, TSession>;
+  test: CredentialHealthTester<TPublicConfig, TMaterial>;
+}>;
+
+/**
+ * Credential type with unspecified generics — used for `CodemationConfig.credentialTypes`, the host registry,
+ * and anywhere a concrete `CredentialType<YourPublic, YourMaterial, YourSession>` is placed in a heterogeneous list.
+ * Using `any` here avoids unsafe `as` casts while keeping typed `satisfies CredentialType<…>` definitions.
+ */
+export type AnyCredentialType = CredentialType<any, any, unknown>;
+
+export interface CredentialSessionService {
+  getSession<TSession = unknown>(
+    args: Readonly<{
+      workflowId: WorkflowId;
+      nodeId: NodeId;
+      slotKey: string;
+    }>,
+  ): Promise<TSession>;
+}
+
+export interface CredentialTypeRegistry {
+  listTypes(): ReadonlyArray<CredentialTypeDefinition>;
+  getType(typeId: CredentialTypeId): CredentialTypeDefinition | undefined;
+}
+
+export class CredentialUnboundError extends Error {
+  constructor(
+    public readonly bindingKey: CredentialBindingKey,
+    public readonly acceptedTypes: ReadonlyArray<CredentialTypeId> = [],
+  ) {
+    super(CredentialUnboundError.createMessage(bindingKey, acceptedTypes));
+    this.name = "CredentialUnboundError";
+  }
+
+  private static createMessage(
+    bindingKey: CredentialBindingKey,
+    acceptedTypes: ReadonlyArray<CredentialTypeId>,
+  ): string {
+    const acceptedTypesSuffix =
+      acceptedTypes.length > 0 ? ` Accepted credential types: ${acceptedTypes.join(", ")}.` : "";
+    return `Credential slot "${bindingKey.slotKey}" is not bound for workflow ${bindingKey.workflowId} node ${bindingKey.nodeId}.${acceptedTypesSuffix}`;
+  }
+}

package/src/contracts/index.ts

@@ -0,0 +1,6 @@
+export * from "./credentialTypes";
+export * from "./runtimeTypes";
+export * from "./runFinishedAtFactory";
+export * from "./runTypes";
+export * from "./webhookTypes";
+export * from "./workflowTypes";

package/src/contracts/retryPolicySpec.types.ts

@@ -0,0 +1,30 @@
+/**
+ * In-process retry policy for runnable nodes. Serialized configs use the same
+ * `kind` discriminator (`JSON.stringify` / persisted workflows).
+ *
+ * `maxAttempts` is the total number of tries including the first (e.g. 3 means up to 2 delays after failures).
+ */
+
+export type RetryPolicySpec = NoneRetryPolicySpec | FixedRetryPolicySpec | ExponentialRetryPolicySpec;
+
+export interface NoneRetryPolicySpec {
+  readonly kind: "none";
+}
+
+export interface FixedRetryPolicySpec {
+  readonly kind: "fixed";
+  /** Total attempts including the first execution. Must be >= 1. */
+  readonly maxAttempts: number;
+  readonly delayMs: number;
+}
+
+export interface ExponentialRetryPolicySpec {
+  readonly kind: "exponential";
+  /** Total attempts including the first execution. Must be >= 1. */
+  readonly maxAttempts: number;
+  readonly initialDelayMs: number;
+  readonly multiplier: number;
+  readonly maxDelayMs?: number;
+  /** When true, each delay is multiplied by a random factor in [1, 1.2). */
+  readonly jitter?: boolean;
+}

package/src/contracts/runFinishedAtFactory.ts

@@ -0,0 +1,19 @@
+import type { PersistedRunState } from "./runTypes";
+
+type RunFinishedAtSource = Pick<PersistedRunState, "status" | "nodeSnapshotsByNodeId">;
+
+/** Derives workflow end time from node snapshots for run listings. */
+export class RunFinishedAtFactory {
+  static resolveIso(state: RunFinishedAtSource): string | undefined {
+    if (state.status === "running" || state.status === "pending") {
+      return undefined;
+    }
+    let max: string | undefined;
+    for (const snap of Object.values(state.nodeSnapshotsByNodeId)) {
+      if (snap?.finishedAt && (!max || snap.finishedAt > max)) {
+        max = snap.finishedAt;
+      }
+    }
+    return max;
+  }
+}

package/src/contracts/runTypes.ts

@@ -0,0 +1,314 @@
+import type { TypeToken } from "../di";
+import type { RunEventBus } from "../events/runEvents";
+import type {
+  Edge,
+  InputPortKey,
+  Items,
+  JsonValue,
+  NodeActivationId,
+  NodeId,
+  NodeKind,
+  NodeOutputs,
+  OutputPortKey,
+  ParentExecutionRef,
+  PersistedRunPolicySnapshot,
+  PersistedTokenId,
+  RunId,
+  WorkflowDefinition,
+  WorkflowId,
+  WorkflowNodeConnection,
+} from "./workflowTypes";
+
+export interface RunExecutionOptions {
+  /** Run-intent override: force the inline scheduler and bypass node-level offload decisions. */
+  localOnly?: boolean;
+  /** Marks runs started from webhook handling so orchestration can apply webhook-specific continuation rules. */
+  webhook?: boolean;
+  mode?: "manual" | "debug";
+  sourceWorkflowId?: WorkflowId;
+  sourceRunId?: RunId;
+  derivedFromRunId?: RunId;
+  isMutable?: boolean;
+  /** Set by the engine for this run: 0 = root, 1 = first child subworkflow, … */
+  subworkflowDepth?: number;
+  /** Effective cap after engine policy merge (successful node completions per run). */
+  maxNodeActivations?: number;
+  /** Effective cap after engine policy merge (subworkflow nesting). */
+  maxSubworkflowDepth?: number;
+}
+
+/** Engine-owned counters persisted with the run (worker-safe). */
+export interface EngineRunCounters {
+  completedNodeActivations: number;
+}
+
+export type RunStopCondition =
+  | Readonly<{
+      kind: "workflowCompleted";
+    }>
+  | Readonly<{
+      kind: "nodeCompleted";
+      nodeId: NodeId;
+    }>;
+
+export interface RunStateResetRequest {
+  clearFromNodeId: NodeId;
+}
+
+export interface PersistedRunControlState {
+  stopCondition?: RunStopCondition;
+}
+
+export interface PersistedWorkflowSnapshotNode {
+  id: NodeId;
+  kind: NodeKind;
+  name?: string;
+  nodeTokenId: PersistedTokenId;
+  configTokenId: PersistedTokenId;
+  tokenName?: string;
+  configTokenName?: string;
+  config: unknown;
+}
+
+export interface PersistedWorkflowSnapshot {
+  id: WorkflowId;
+  name: string;
+  nodes: ReadonlyArray<PersistedWorkflowSnapshotNode>;
+  edges: ReadonlyArray<Edge>;
+  /** When the snapshot was built from a live workflow definition that configured a workflow error handler. */
+  workflowErrorHandlerConfigured?: boolean;
+  /** Connection metadata for child nodes not in the execution graph (e.g. AI agent attachments). */
+  connections?: ReadonlyArray<WorkflowNodeConnection>;
+}
+
+export type PinnedNodeOutputsByPort = Readonly<Record<OutputPortKey, Items>>;
+
+export interface PersistedMutableNodeState {
+  pinnedOutputsByPort?: PinnedNodeOutputsByPort;
+  lastDebugInput?: Items;
+}
+
+export interface PersistedMutableRunState {
+  nodesById: Readonly<Record<NodeId, PersistedMutableNodeState>>;
+}
+
+export type NodeInputsByPort = Readonly<Record<InputPortKey, Items>>;
+
+export interface RunQueueEntry {
+  nodeId: NodeId;
+  input: Items;
+  toInput?: InputPortKey;
+  batchId?: string;
+  from?: Readonly<{ nodeId: NodeId; output: OutputPortKey }>;
+  collect?: Readonly<{
+    expectedInputs: ReadonlyArray<InputPortKey>;
+    received: Readonly<Record<InputPortKey, Items>>;
+  }>;
+}
+
+export type NodeExecutionStatus = "pending" | "queued" | "running" | "completed" | "failed" | "skipped";
+
+export interface NodeExecutionError {
+  message: string;
+  name?: string;
+  stack?: string;
+}
+
+export interface NodeExecutionSnapshot {
+  runId: RunId;
+  workflowId: WorkflowId;
+  nodeId: NodeId;
+  activationId?: NodeActivationId;
+  parent?: ParentExecutionRef;
+  status: NodeExecutionStatus;
+  usedPinnedOutput?: boolean;
+  queuedAt?: string;
+  startedAt?: string;
+  finishedAt?: string;
+  updatedAt: string;
+  inputsByPort?: NodeInputsByPort;
+  outputs?: NodeOutputs;
+  error?: NodeExecutionError;
+}
+
+/** Stable id for a single connection invocation row in {@link ConnectionInvocationRecord}. */
+export type ConnectionInvocationId = string;
+
+/**
+ * One logical LLM or tool call under an owning workflow node (e.g. AI agent).
+ * The owning node defines what {@link managedInput} and {@link managedOutput} contain.
+ */
+export interface ConnectionInvocationRecord {
+  readonly invocationId: ConnectionInvocationId;
+  readonly runId: RunId;
+  readonly workflowId: WorkflowId;
+  readonly connectionNodeId: NodeId;
+  readonly parentAgentNodeId: NodeId;
+  readonly parentAgentActivationId: NodeActivationId;
+  readonly status: NodeExecutionStatus;
+  readonly managedInput?: JsonValue;
+  readonly managedOutput?: JsonValue;
+  readonly error?: NodeExecutionError;
+  readonly queuedAt?: string;
+  readonly startedAt?: string;
+  readonly finishedAt?: string;
+  readonly updatedAt: string;
+}
+
+/** Arguments for appending a {@link ConnectionInvocationRecord} (engine fills run/workflow ids and timestamps). */
+export type ConnectionInvocationAppendArgs = Readonly<{
+  invocationId: ConnectionInvocationId;
+  connectionNodeId: NodeId;
+  parentAgentNodeId: NodeId;
+  parentAgentActivationId: NodeActivationId;
+  status: NodeExecutionStatus;
+  managedInput?: JsonValue;
+  managedOutput?: JsonValue;
+  error?: NodeExecutionError;
+  queuedAt?: string;
+  startedAt?: string;
+  finishedAt?: string;
+}>;
+
+export interface RunCurrentState {
+  outputsByNode: Record<NodeId, NodeOutputs>;
+  nodeSnapshotsByNodeId: Record<NodeId, NodeExecutionSnapshot>;
+  /** Append-only history of connection-scoped invocations (LLM/tool) for inspector and canvas. */
+  connectionInvocations?: ReadonlyArray<ConnectionInvocationRecord>;
+  mutableState?: PersistedMutableRunState;
+}
+
+export interface CurrentStateExecutionRequest {
+  workflow: WorkflowDefinition;
+  items?: Items;
+  parent?: ParentExecutionRef;
+  executionOptions?: RunExecutionOptions;
+  workflowSnapshot?: PersistedWorkflowSnapshot;
+  mutableState?: PersistedMutableRunState;
+  currentState?: RunCurrentState;
+  stopCondition?: RunStopCondition;
+  reset?: RunStateResetRequest;
+}
+
+export interface ExecutionFrontierPlan {
+  rootNodeId?: NodeId;
+  rootNodeInput?: Items;
+  queue: RunQueueEntry[];
+  currentState: RunCurrentState;
+  stopCondition: RunStopCondition;
+  satisfiedNodeIds: ReadonlyArray<NodeId>;
+  skippedNodeIds: ReadonlyArray<NodeId>;
+  clearedNodeIds: ReadonlyArray<NodeId>;
+  preservedPinnedNodeIds: ReadonlyArray<NodeId>;
+}
+
+export type RunStatus = "running" | "pending" | "completed" | "failed";
+
+export interface RunSummary {
+  runId: RunId;
+  workflowId: WorkflowId;
+  startedAt: string;
+  status: RunStatus;
+  /** ISO timestamp when the run finished (derived from node snapshots or store `updatedAt`); omit while running/pending. */
+  finishedAt?: string;
+  parent?: ParentExecutionRef;
+  executionOptions?: RunExecutionOptions;
+}
+
+export interface PendingNodeExecution {
+  runId: RunId;
+  activationId: NodeActivationId;
+  workflowId: WorkflowId;
+  nodeId: NodeId;
+  itemsIn: number;
+  inputsByPort: NodeInputsByPort;
+  receiptId: string;
+  queue?: string;
+  batchId?: string;
+  enqueuedAt: string;
+}
+
+export interface PersistedRunState {
+  runId: RunId;
+  workflowId: WorkflowId;
+  startedAt: string;
+  parent?: ParentExecutionRef;
+  executionOptions?: RunExecutionOptions;
+  control?: PersistedRunControlState;
+  workflowSnapshot?: PersistedWorkflowSnapshot;
+  mutableState?: PersistedMutableRunState;
+  /** Frozen at createRun from workflow + runtime defaults for prune/storage decisions. */
+  policySnapshot?: PersistedRunPolicySnapshot;
+  /** Successful node completions so far (for activation budget). */
+  engineCounters?: EngineRunCounters;
+  status: RunStatus;
+  pending?: PendingNodeExecution;
+  queue: RunQueueEntry[];
+  outputsByNode: Record<NodeId, NodeOutputs>;
+  nodeSnapshotsByNodeId: Record<NodeId, NodeExecutionSnapshot>;
+  /** Append-only history of connection invocations (LLM/tool) nested under owning nodes. */
+  connectionInvocations?: ReadonlyArray<ConnectionInvocationRecord>;
+}
+
+export interface WorkflowExecutionRepository {
+  createRun(args: {
+    runId: RunId;
+    workflowId: WorkflowId;
+    startedAt: string;
+    parent?: ParentExecutionRef;
+    executionOptions?: RunExecutionOptions;
+    control?: PersistedRunControlState;
+    workflowSnapshot?: PersistedWorkflowSnapshot;
+    mutableState?: PersistedMutableRunState;
+    policySnapshot?: PersistedRunPolicySnapshot;
+    engineCounters?: EngineRunCounters;
+  }): Promise<void>;
+  load(runId: RunId): Promise<PersistedRunState | undefined>;
+  save(state: PersistedRunState): Promise<void>;
+  deleteRun?(runId: RunId): Promise<void>;
+}
+
+export interface WorkflowExecutionListingRepository {
+  listRuns(args?: Readonly<{ workflowId?: WorkflowId; limit?: number }>): Promise<ReadonlyArray<RunSummary>>;
+}
+
+/** Runs eligible for retention-based pruning (completed or failed, older than cutoff). */
+export interface RunPruneCandidate {
+  readonly runId: RunId;
+  readonly workflowId: WorkflowId;
+  readonly startedAt: string;
+  readonly finishedAt: string;
+}
+
+export interface WorkflowExecutionPruneRepository {
+  listRunsOlderThan(args: Readonly<{ beforeIso: string; limit?: number }>): Promise<ReadonlyArray<RunPruneCandidate>>;
+}
+
+export type RunResult =
+  | { runId: RunId; workflowId: WorkflowId; startedAt: string; status: "completed"; outputs: Items }
+  | { runId: RunId; workflowId: WorkflowId; startedAt: string; status: "pending"; pending: PendingNodeExecution }
+  | { runId: RunId; workflowId: WorkflowId; startedAt: string; status: "failed"; error: { message: string } };
+
+export type WebhookRunResult = Readonly<{
+  runId: RunId;
+  workflowId: WorkflowId;
+  startedAt: string;
+  runStatus: "pending" | "completed";
+  response: Items;
+}>;
+
+export interface PersistedWorkflowTokenRegistryLike {
+  register(type: TypeToken<unknown>, packageId: string, persistedNameOverride?: string): string;
+  getTokenId(type: TypeToken<unknown>): string | undefined;
+  resolve(tokenId: string): TypeToken<unknown> | undefined;
+  registerFromWorkflows?(workflows: ReadonlyArray<WorkflowDefinition>): void;
+}
+
+export interface RunCompletionNotifier {
+  resolveRunCompletion(result: RunResult): void;
+  resolveWebhookResponse(result: WebhookRunResult): void;
+}
+
+export interface RunEventPublisherDeps {
+  eventBus?: RunEventBus;
+}