@codemation/core 0.0.1

package/README.md

@@ -0,0 +1,30 @@
+# `@codemation/core`
+
+The **Codemation engine**: workflow types, the execution model, builder DSL, dependency-injection primitives, and shared runtime contracts. It stays free of HTTP servers, databases, UI, and concrete node catalogs so apps and plugins can build on a stable core.
+
+## Install
+
+```bash
+pnpm add @codemation/core@^0.0.0
+# or
+npm install @codemation/core@^0.0.0
+```
+
+## When to use
+
+Use this package when you define workflows, implement **custom nodes** (config classes + `Node` implementations), or integrate with the engine in TypeScript. Consumer apps and node packages should depend on `@codemation/core`; they should not pull host or infrastructure code into engine-shaped modules.
+
+## Usage
+
+Main entry:
+
+```ts
+import { WorkflowBuilder /* engine types, DI helpers */ } from "@codemation/core";
+```
+
+Additional subpaths:
+
+- `@codemation/core/browser` — browser-safe surface where applicable
+- `@codemation/core/testing` — test helpers for engine-style code
+
+Build the package (`pnpm --filter @codemation/core build`) so `dist` matches the `exports` map before consuming from published tarballs.

package/dist/EngineExecutionLimitsPolicy-8MEFIYx1.d.cts

@@ -0,0 +1,160 @@
+import { En as WebhookTriggerResolution, Jt as NodeActivationContinuation, K as NodeId, N as Items, Nn as CurrentStateExecutionRequest, Qn as RunExecutionOptions, Tn as WebhookTriggerMatcher, Y as NodeOutputs, ar as RunStateStore, at as RunId, bn as WorkflowSnapshotResolver, bt as WorkflowId, et as ParentExecutionRef, lr as WebhookRunResult, mn as WorkflowCatalog, mt as WorkflowDefinition, qn as PersistedWorkflowTokenRegistryLike, rr as RunResult, xn as HttpMethod, z as NodeActivationId, zn as NodeInputsByPort } from "./credentialTypes-B5h3dI7r.cjs";
+
+//#region src/engine/api/Engine.d.ts
+interface EngineTriggerRuntime {
+  startTriggers(): Promise<void>;
+  stop(): Promise<void>;
+  syncWorkflowTriggersForActivation(workflowId: WorkflowId): Promise<void>;
+  createTriggerTestItems(args: {
+    workflow: WorkflowDefinition;
+    nodeId: NodeId;
+  }): Promise<Items | undefined>;
+}
+interface EngineWorkflowRunStarter {
+  runWorkflow(wf: WorkflowDefinition, startAt: NodeId, items: Items, parent?: ParentExecutionRef, executionOptions?: RunExecutionOptions, persistedStateOverrides?: Readonly<{
+    workflowSnapshot?: NonNullable<Awaited<ReturnType<RunStateStore["load"]>>>["workflowSnapshot"];
+    mutableState?: NonNullable<Awaited<ReturnType<RunStateStore["load"]>>>["mutableState"];
+  }>): Promise<RunResult>;
+}
+interface EngineCurrentStateRunStarter {
+  runWorkflowFromState(request: CurrentStateExecutionRequest): Promise<RunResult>;
+}
+interface EngineRunContinuationService {
+  markNodeRunning(args: {
+    runId: RunId;
+    activationId: NodeActivationId;
+    nodeId: NodeId;
+    inputsByPort: NodeInputsByPort;
+  }): Promise<void>;
+  resumeFromNodeResult(args: {
+    runId: RunId;
+    activationId: NodeActivationId;
+    nodeId: NodeId;
+    outputs: NodeOutputs;
+  }): Promise<RunResult>;
+  resumeFromNodeError(args: {
+    runId: RunId;
+    activationId: NodeActivationId;
+    nodeId: NodeId;
+    error: Error;
+  }): Promise<RunResult>;
+  resumeFromStepResult(args: {
+    runId: RunId;
+    activationId: NodeActivationId;
+    nodeId: NodeId;
+    outputs: NodeOutputs;
+  }): Promise<RunResult>;
+  resumeFromStepError(args: {
+    runId: RunId;
+    activationId: NodeActivationId;
+    nodeId: NodeId;
+    error: Error;
+  }): Promise<RunResult>;
+  waitForCompletion(runId: RunId): Promise<Extract<RunResult, {
+    status: "completed" | "failed";
+  }>>;
+  waitForWebhookResponse(runId: RunId): Promise<WebhookRunResult>;
+}
+interface EngineFacadeDeps {
+  workflowCatalog: WorkflowCatalog;
+  tokenRegistry: PersistedWorkflowTokenRegistryLike;
+  webhookTriggerMatcher: WebhookTriggerMatcher;
+  workflowSnapshotResolver: WorkflowSnapshotResolver;
+  triggerRuntime: EngineTriggerRuntime;
+  workflowRunStarter: EngineWorkflowRunStarter;
+  currentStateRunStarter: EngineCurrentStateRunStarter;
+  runContinuationService: EngineRunContinuationService;
+}
+/**
+ * Runtime facade for orchestration, continuation, triggers, and webhook routing.
+ * Prefer {@link import("../intents/RunIntentService").RunIntentService} for host/HTTP invocation boundaries.
+ * The class token is exported from `@codemation/core/bootstrap` (not the main `@codemation/core` barrel).
+ */
+declare class Engine implements NodeActivationContinuation {
+  private readonly deps;
+  constructor(deps: EngineFacadeDeps);
+  loadWorkflows(workflows: ReadonlyArray<WorkflowDefinition>): void;
+  getTokenRegistry(): EngineFacadeDeps["tokenRegistry"];
+  resolveWorkflowSnapshot(args: {
+    workflowId: WorkflowId;
+    workflowSnapshot?: NonNullable<Awaited<ReturnType<RunStateStore["load"]>>>["workflowSnapshot"];
+  }): WorkflowDefinition | undefined;
+  startTriggers(): Promise<void>;
+  syncWorkflowTriggersForActivation(workflowId: WorkflowId): Promise<void>;
+  start(workflows: WorkflowDefinition[]): Promise<void>;
+  stop(): Promise<void>;
+  resolveWebhookTrigger(args: {
+    endpointPath: string;
+    method: HttpMethod;
+  }): WebhookTriggerResolution;
+  createTriggerTestItems(args: {
+    workflow: WorkflowDefinition;
+    nodeId: NodeId;
+  }): Promise<Items | undefined>;
+  runWorkflow(wf: WorkflowDefinition, startAt: NodeId, items: Items, parent?: ParentExecutionRef, executionOptions?: RunExecutionOptions, persistedStateOverrides?: Readonly<{
+    workflowSnapshot?: NonNullable<Awaited<ReturnType<RunStateStore["load"]>>>["workflowSnapshot"];
+    mutableState?: NonNullable<Awaited<ReturnType<RunStateStore["load"]>>>["mutableState"];
+  }>): Promise<RunResult>;
+  runWorkflowFromState(request: CurrentStateExecutionRequest): Promise<RunResult>;
+  markNodeRunning(args: {
+    runId: RunId;
+    activationId: NodeActivationId;
+    nodeId: NodeId;
+    inputsByPort: NodeInputsByPort;
+  }): Promise<void>;
+  resumeFromNodeResult(args: {
+    runId: RunId;
+    activationId: NodeActivationId;
+    nodeId: NodeId;
+    outputs: NodeOutputs;
+  }): Promise<RunResult>;
+  resumeFromNodeError(args: {
+    runId: RunId;
+    activationId: NodeActivationId;
+    nodeId: NodeId;
+    error: Error;
+  }): Promise<RunResult>;
+  resumeFromStepResult(args: {
+    runId: RunId;
+    activationId: NodeActivationId;
+    nodeId: NodeId;
+    outputs: NodeOutputs;
+  }): Promise<RunResult>;
+  resumeFromStepError(args: {
+    runId: RunId;
+    activationId: NodeActivationId;
+    nodeId: NodeId;
+    error: Error;
+  }): Promise<RunResult>;
+  waitForCompletion(runId: RunId): Promise<Extract<RunResult, {
+    status: "completed" | "failed";
+  }>>;
+  waitForWebhookResponse(runId: RunId): Promise<WebhookRunResult>;
+}
+//#endregion
+//#region src/engine/policies/EngineExecutionLimitsPolicy.d.ts
+interface EngineExecutionLimitsPolicyConfig {
+  readonly defaultMaxNodeActivations: number;
+  readonly hardMaxNodeActivations: number;
+  readonly defaultMaxSubworkflowDepth: number;
+  readonly hardMaxSubworkflowDepth: number;
+}
+/** Framework defaults for {@link EngineExecutionLimitsPolicy} (merged with host `runtime.engineExecutionLimits`). */
+declare const ENGINE_EXECUTION_LIMITS_DEFAULTS: EngineExecutionLimitsPolicyConfig;
+/**
+ * Resolves per-run execution limits: defaults, hard ceilings, and subworkflow depth for new runs.
+ */
+declare class EngineExecutionLimitsPolicy {
+  private readonly config;
+  constructor(config?: EngineExecutionLimitsPolicyConfig);
+  /**
+   * Effective options for a new root run (depth 0): defaults merged with engine ceilings.
+   * Replaces a separate one-method factory for root-run bootstrap.
+   */
+  createRootExecutionOptions(): RunExecutionOptions;
+  mergeExecutionOptionsForNewRun(parent: ParentExecutionRef | undefined, user: RunExecutionOptions | undefined): RunExecutionOptions;
+  private capNumber;
+}
+//#endregion
+export { Engine as i, EngineExecutionLimitsPolicy as n, EngineExecutionLimitsPolicyConfig as r, ENGINE_EXECUTION_LIMITS_DEFAULTS as t };
+//# sourceMappingURL=EngineExecutionLimitsPolicy-8MEFIYx1.d.cts.map

package/dist/EngineExecutionLimitsPolicy-BWAXW9D6.d.cts

@@ -0,0 +1,160 @@
+import { En as WebhookTriggerResolution, Jt as NodeActivationContinuation, K as NodeId, N as Items, Nn as CurrentStateExecutionRequest, Qn as RunExecutionOptions, Tn as WebhookTriggerMatcher, Y as NodeOutputs, ar as RunStateStore, at as RunId, bn as WorkflowSnapshotResolver, bt as WorkflowId, et as ParentExecutionRef, lr as WebhookRunResult, mn as WorkflowCatalog, mt as WorkflowDefinition, qn as PersistedWorkflowTokenRegistryLike, rr as RunResult, xn as HttpMethod, z as NodeActivationId, zn as NodeInputsByPort } from "./credentialTypes-D0m7MQQl.cjs";
+
+//#region src/engine/api/Engine.d.ts
+interface EngineTriggerRuntime {
+  startTriggers(): Promise<void>;
+  stop(): Promise<void>;
+  syncWorkflowTriggersForActivation(workflowId: WorkflowId): Promise<void>;
+  createTriggerTestItems(args: {
+    workflow: WorkflowDefinition;
+    nodeId: NodeId;
+  }): Promise<Items | undefined>;
+}
+interface EngineWorkflowRunStarter {
+  runWorkflow(wf: WorkflowDefinition, startAt: NodeId, items: Items, parent?: ParentExecutionRef, executionOptions?: RunExecutionOptions, persistedStateOverrides?: Readonly<{
+    workflowSnapshot?: NonNullable<Awaited<ReturnType<RunStateStore["load"]>>>["workflowSnapshot"];
+    mutableState?: NonNullable<Awaited<ReturnType<RunStateStore["load"]>>>["mutableState"];
+  }>): Promise<RunResult>;
+}
+interface EngineCurrentStateRunStarter {
+  runWorkflowFromState(request: CurrentStateExecutionRequest): Promise<RunResult>;
+}
+interface EngineRunContinuationService {
+  markNodeRunning(args: {
+    runId: RunId;
+    activationId: NodeActivationId;
+    nodeId: NodeId;
+    inputsByPort: NodeInputsByPort;
+  }): Promise<void>;
+  resumeFromNodeResult(args: {
+    runId: RunId;
+    activationId: NodeActivationId;
+    nodeId: NodeId;
+    outputs: NodeOutputs;
+  }): Promise<RunResult>;
+  resumeFromNodeError(args: {
+    runId: RunId;
+    activationId: NodeActivationId;
+    nodeId: NodeId;
+    error: Error;
+  }): Promise<RunResult>;
+  resumeFromStepResult(args: {
+    runId: RunId;
+    activationId: NodeActivationId;
+    nodeId: NodeId;
+    outputs: NodeOutputs;
+  }): Promise<RunResult>;
+  resumeFromStepError(args: {
+    runId: RunId;
+    activationId: NodeActivationId;
+    nodeId: NodeId;
+    error: Error;
+  }): Promise<RunResult>;
+  waitForCompletion(runId: RunId): Promise<Extract<RunResult, {
+    status: "completed" | "failed";
+  }>>;
+  waitForWebhookResponse(runId: RunId): Promise<WebhookRunResult>;
+}
+interface EngineFacadeDeps {
+  workflowCatalog: WorkflowCatalog;
+  tokenRegistry: PersistedWorkflowTokenRegistryLike;
+  webhookTriggerMatcher: WebhookTriggerMatcher;
+  workflowSnapshotResolver: WorkflowSnapshotResolver;
+  triggerRuntime: EngineTriggerRuntime;
+  workflowRunStarter: EngineWorkflowRunStarter;
+  currentStateRunStarter: EngineCurrentStateRunStarter;
+  runContinuationService: EngineRunContinuationService;
+}
+/**
+ * Runtime facade for orchestration, continuation, triggers, and webhook routing.
+ * Prefer {@link import("../intents/RunIntentService").RunIntentService} for host/HTTP invocation boundaries.
+ * The class token is exported from `@codemation/core/bootstrap` (not the main `@codemation/core` barrel).
+ */
+declare class Engine implements NodeActivationContinuation {
+  private readonly deps;
+  constructor(deps: EngineFacadeDeps);
+  loadWorkflows(workflows: ReadonlyArray<WorkflowDefinition>): void;
+  getTokenRegistry(): EngineFacadeDeps["tokenRegistry"];
+  resolveWorkflowSnapshot(args: {
+    workflowId: WorkflowId;
+    workflowSnapshot?: NonNullable<Awaited<ReturnType<RunStateStore["load"]>>>["workflowSnapshot"];
+  }): WorkflowDefinition | undefined;
+  startTriggers(): Promise<void>;
+  syncWorkflowTriggersForActivation(workflowId: WorkflowId): Promise<void>;
+  start(workflows: WorkflowDefinition[]): Promise<void>;
+  stop(): Promise<void>;
+  resolveWebhookTrigger(args: {
+    endpointPath: string;
+    method: HttpMethod;
+  }): WebhookTriggerResolution;
+  createTriggerTestItems(args: {
+    workflow: WorkflowDefinition;
+    nodeId: NodeId;
+  }): Promise<Items | undefined>;
+  runWorkflow(wf: WorkflowDefinition, startAt: NodeId, items: Items, parent?: ParentExecutionRef, executionOptions?: RunExecutionOptions, persistedStateOverrides?: Readonly<{
+    workflowSnapshot?: NonNullable<Awaited<ReturnType<RunStateStore["load"]>>>["workflowSnapshot"];
+    mutableState?: NonNullable<Awaited<ReturnType<RunStateStore["load"]>>>["mutableState"];
+  }>): Promise<RunResult>;
+  runWorkflowFromState(request: CurrentStateExecutionRequest): Promise<RunResult>;
+  markNodeRunning(args: {
+    runId: RunId;
+    activationId: NodeActivationId;
+    nodeId: NodeId;
+    inputsByPort: NodeInputsByPort;
+  }): Promise<void>;
+  resumeFromNodeResult(args: {
+    runId: RunId;
+    activationId: NodeActivationId;
+    nodeId: NodeId;
+    outputs: NodeOutputs;
+  }): Promise<RunResult>;
+  resumeFromNodeError(args: {
+    runId: RunId;
+    activationId: NodeActivationId;
+    nodeId: NodeId;
+    error: Error;
+  }): Promise<RunResult>;
+  resumeFromStepResult(args: {
+    runId: RunId;
+    activationId: NodeActivationId;
+    nodeId: NodeId;
+    outputs: NodeOutputs;
+  }): Promise<RunResult>;
+  resumeFromStepError(args: {
+    runId: RunId;
+    activationId: NodeActivationId;
+    nodeId: NodeId;
+    error: Error;
+  }): Promise<RunResult>;
+  waitForCompletion(runId: RunId): Promise<Extract<RunResult, {
+    status: "completed" | "failed";
+  }>>;
+  waitForWebhookResponse(runId: RunId): Promise<WebhookRunResult>;
+}
+//#endregion
+//#region src/engine/policies/EngineExecutionLimitsPolicy.d.ts
+interface EngineExecutionLimitsPolicyConfig {
+  readonly defaultMaxNodeActivations: number;
+  readonly hardMaxNodeActivations: number;
+  readonly defaultMaxSubworkflowDepth: number;
+  readonly hardMaxSubworkflowDepth: number;
+}
+/** Framework defaults for {@link EngineExecutionLimitsPolicy} (merged with host `runtime.engineExecutionLimits`). */
+declare const ENGINE_EXECUTION_LIMITS_DEFAULTS: EngineExecutionLimitsPolicyConfig;
+/**
+ * Resolves per-run execution limits: defaults, hard ceilings, and subworkflow depth for new runs.
+ */
+declare class EngineExecutionLimitsPolicy {
+  private readonly config;
+  constructor(config?: EngineExecutionLimitsPolicyConfig);
+  /**
+   * Effective options for a new root run (depth 0): defaults merged with engine ceilings.
+   * Replaces a separate one-method factory for root-run bootstrap.
+   */
+  createRootExecutionOptions(): RunExecutionOptions;
+  mergeExecutionOptionsForNewRun(parent: ParentExecutionRef | undefined, user: RunExecutionOptions | undefined): RunExecutionOptions;
+  private capNumber;
+}
+//#endregion
+export { Engine as i, EngineExecutionLimitsPolicy as n, EngineExecutionLimitsPolicyConfig as r, ENGINE_EXECUTION_LIMITS_DEFAULTS as t };
+//# sourceMappingURL=EngineExecutionLimitsPolicy-BWAXW9D6.d.cts.map

package/dist/EngineExecutionLimitsPolicy-Bp8PS1Ss.d.cts

@@ -0,0 +1,159 @@
+import { En as WebhookTriggerResolution, Jt as NodeActivationContinuation, K as NodeId, N as Items, Nn as CurrentStateExecutionRequest, Qn as RunExecutionOptions, Tn as WebhookTriggerMatcher, Y as NodeOutputs, ar as RunStateStore, at as RunId, bn as WorkflowSnapshotResolver, bt as WorkflowId, et as ParentExecutionRef, lr as WebhookRunResult, mn as WorkflowCatalog, mt as WorkflowDefinition, qn as PersistedWorkflowTokenRegistryLike, rr as RunResult, xn as HttpMethod, z as NodeActivationId, zn as NodeInputsByPort } from "./credentialTypes-D0m7MQQl.cjs";
+
+//#region src/engine/api/Engine.d.ts
+interface EngineTriggerRuntime {
+  startTriggers(): Promise<void>;
+  stop(): Promise<void>;
+  syncWorkflowTriggersForActivation(workflowId: WorkflowId): Promise<void>;
+  createTriggerTestItems(args: {
+    workflow: WorkflowDefinition;
+    nodeId: NodeId;
+  }): Promise<Items | undefined>;
+}
+interface EngineWorkflowRunStarter {
+  runWorkflow(wf: WorkflowDefinition, startAt: NodeId, items: Items, parent?: ParentExecutionRef, executionOptions?: RunExecutionOptions, persistedStateOverrides?: Readonly<{
+    workflowSnapshot?: NonNullable<Awaited<ReturnType<RunStateStore["load"]>>>["workflowSnapshot"];
+    mutableState?: NonNullable<Awaited<ReturnType<RunStateStore["load"]>>>["mutableState"];
+  }>): Promise<RunResult>;
+}
+interface EngineCurrentStateRunStarter {
+  runWorkflowFromState(request: CurrentStateExecutionRequest): Promise<RunResult>;
+}
+interface EngineRunContinuationService {
+  markNodeRunning(args: {
+    runId: RunId;
+    activationId: NodeActivationId;
+    nodeId: NodeId;
+    inputsByPort: NodeInputsByPort;
+  }): Promise<void>;
+  resumeFromNodeResult(args: {
+    runId: RunId;
+    activationId: NodeActivationId;
+    nodeId: NodeId;
+    outputs: NodeOutputs;
+  }): Promise<RunResult>;
+  resumeFromNodeError(args: {
+    runId: RunId;
+    activationId: NodeActivationId;
+    nodeId: NodeId;
+    error: Error;
+  }): Promise<RunResult>;
+  resumeFromStepResult(args: {
+    runId: RunId;
+    activationId: NodeActivationId;
+    nodeId: NodeId;
+    outputs: NodeOutputs;
+  }): Promise<RunResult>;
+  resumeFromStepError(args: {
+    runId: RunId;
+    activationId: NodeActivationId;
+    nodeId: NodeId;
+    error: Error;
+  }): Promise<RunResult>;
+  waitForCompletion(runId: RunId): Promise<Extract<RunResult, {
+    status: "completed" | "failed";
+  }>>;
+  waitForWebhookResponse(runId: RunId): Promise<WebhookRunResult>;
+}
+interface EngineFacadeDeps {
+  workflowCatalog: WorkflowCatalog;
+  tokenRegistry: PersistedWorkflowTokenRegistryLike;
+  webhookTriggerMatcher: WebhookTriggerMatcher;
+  workflowSnapshotResolver: WorkflowSnapshotResolver;
+  triggerRuntime: EngineTriggerRuntime;
+  workflowRunStarter: EngineWorkflowRunStarter;
+  currentStateRunStarter: EngineCurrentStateRunStarter;
+  runContinuationService: EngineRunContinuationService;
+}
+/**
+ * Runtime facade for orchestration, continuation, triggers, and webhook routing.
+ * Prefer {@link import("../intents/RunIntentService").RunIntentService} for host/HTTP invocation boundaries.
+ */
+declare class Engine implements NodeActivationContinuation {
+  private readonly deps;
+  constructor(deps: EngineFacadeDeps);
+  loadWorkflows(workflows: ReadonlyArray<WorkflowDefinition>): void;
+  getTokenRegistry(): EngineFacadeDeps["tokenRegistry"];
+  resolveWorkflowSnapshot(args: {
+    workflowId: WorkflowId;
+    workflowSnapshot?: NonNullable<Awaited<ReturnType<RunStateStore["load"]>>>["workflowSnapshot"];
+  }): WorkflowDefinition | undefined;
+  startTriggers(): Promise<void>;
+  syncWorkflowTriggersForActivation(workflowId: WorkflowId): Promise<void>;
+  start(workflows: WorkflowDefinition[]): Promise<void>;
+  stop(): Promise<void>;
+  resolveWebhookTrigger(args: {
+    endpointPath: string;
+    method: HttpMethod;
+  }): WebhookTriggerResolution;
+  createTriggerTestItems(args: {
+    workflow: WorkflowDefinition;
+    nodeId: NodeId;
+  }): Promise<Items | undefined>;
+  runWorkflow(wf: WorkflowDefinition, startAt: NodeId, items: Items, parent?: ParentExecutionRef, executionOptions?: RunExecutionOptions, persistedStateOverrides?: Readonly<{
+    workflowSnapshot?: NonNullable<Awaited<ReturnType<RunStateStore["load"]>>>["workflowSnapshot"];
+    mutableState?: NonNullable<Awaited<ReturnType<RunStateStore["load"]>>>["mutableState"];
+  }>): Promise<RunResult>;
+  runWorkflowFromState(request: CurrentStateExecutionRequest): Promise<RunResult>;
+  markNodeRunning(args: {
+    runId: RunId;
+    activationId: NodeActivationId;
+    nodeId: NodeId;
+    inputsByPort: NodeInputsByPort;
+  }): Promise<void>;
+  resumeFromNodeResult(args: {
+    runId: RunId;
+    activationId: NodeActivationId;
+    nodeId: NodeId;
+    outputs: NodeOutputs;
+  }): Promise<RunResult>;
+  resumeFromNodeError(args: {
+    runId: RunId;
+    activationId: NodeActivationId;
+    nodeId: NodeId;
+    error: Error;
+  }): Promise<RunResult>;
+  resumeFromStepResult(args: {
+    runId: RunId;
+    activationId: NodeActivationId;
+    nodeId: NodeId;
+    outputs: NodeOutputs;
+  }): Promise<RunResult>;
+  resumeFromStepError(args: {
+    runId: RunId;
+    activationId: NodeActivationId;
+    nodeId: NodeId;
+    error: Error;
+  }): Promise<RunResult>;
+  waitForCompletion(runId: RunId): Promise<Extract<RunResult, {
+    status: "completed" | "failed";
+  }>>;
+  waitForWebhookResponse(runId: RunId): Promise<WebhookRunResult>;
+}
+//#endregion
+//#region src/engine/policies/EngineExecutionLimitsPolicy.d.ts
+interface EngineExecutionLimitsPolicyConfig {
+  readonly defaultMaxNodeActivations: number;
+  readonly hardMaxNodeActivations: number;
+  readonly defaultMaxSubworkflowDepth: number;
+  readonly hardMaxSubworkflowDepth: number;
+}
+/** Framework defaults for {@link EngineExecutionLimitsPolicy} (merged with host `runtime.engineExecutionLimits`). */
+declare const ENGINE_EXECUTION_LIMITS_DEFAULTS: EngineExecutionLimitsPolicyConfig;
+/**
+ * Resolves per-run execution limits: defaults, hard ceilings, and subworkflow depth for new runs.
+ */
+declare class EngineExecutionLimitsPolicy {
+  private readonly config;
+  constructor(config?: EngineExecutionLimitsPolicyConfig);
+  /**
+   * Effective options for a new root run (depth 0): defaults merged with engine ceilings.
+   * Replaces a separate one-method factory for root-run bootstrap.
+   */
+  createRootExecutionOptions(): RunExecutionOptions;
+  mergeExecutionOptionsForNewRun(parent: ParentExecutionRef | undefined, user: RunExecutionOptions | undefined): RunExecutionOptions;
+  private capNumber;
+}
+//#endregion
+export { Engine as i, EngineExecutionLimitsPolicy as n, EngineExecutionLimitsPolicyConfig as r, ENGINE_EXECUTION_LIMITS_DEFAULTS as t };
+//# sourceMappingURL=EngineExecutionLimitsPolicy-Bp8PS1Ss.d.cts.map

package/dist/EngineExecutionLimitsPolicy-CLxcN-D2.d.ts

@@ -0,0 +1,159 @@
+import { $t as NodeActivationContinuation, An as WebhookTriggerMatcher, En as HttpMethod, Qn as PersistedWorkflowTokenRegistryLike, R as Items, Rn as CurrentStateExecutionRequest, Tn as WorkflowSnapshotResolver, Tt as WorkflowId, W as NodeActivationId, Wn as NodeInputsByPort, Z as NodeId, at as ParentExecutionRef, cr as RunResult, et as NodeOutputs, jn as WebhookTriggerResolution, mr as WebhookRunResult, rr as RunExecutionOptions, ur as RunStateStore, ut as RunId, yn as WorkflowCatalog, yt as WorkflowDefinition } from "./index-Bjt7_7oS.js";
+
+//#region src/engine/api/Engine.d.ts
+interface EngineTriggerRuntime {
+  startTriggers(): Promise<void>;
+  stop(): Promise<void>;
+  syncWorkflowTriggersForActivation(workflowId: WorkflowId): Promise<void>;
+  createTriggerTestItems(args: {
+    workflow: WorkflowDefinition;
+    nodeId: NodeId;
+  }): Promise<Items | undefined>;
+}
+interface EngineWorkflowRunStarter {
+  runWorkflow(wf: WorkflowDefinition, startAt: NodeId, items: Items, parent?: ParentExecutionRef, executionOptions?: RunExecutionOptions, persistedStateOverrides?: Readonly<{
+    workflowSnapshot?: NonNullable<Awaited<ReturnType<RunStateStore["load"]>>>["workflowSnapshot"];
+    mutableState?: NonNullable<Awaited<ReturnType<RunStateStore["load"]>>>["mutableState"];
+  }>): Promise<RunResult>;
+}
+interface EngineCurrentStateRunStarter {
+  runWorkflowFromState(request: CurrentStateExecutionRequest): Promise<RunResult>;
+}
+interface EngineRunContinuationService {
+  markNodeRunning(args: {
+    runId: RunId;
+    activationId: NodeActivationId;
+    nodeId: NodeId;
+    inputsByPort: NodeInputsByPort;
+  }): Promise<void>;
+  resumeFromNodeResult(args: {
+    runId: RunId;
+    activationId: NodeActivationId;
+    nodeId: NodeId;
+    outputs: NodeOutputs;
+  }): Promise<RunResult>;
+  resumeFromNodeError(args: {
+    runId: RunId;
+    activationId: NodeActivationId;
+    nodeId: NodeId;
+    error: Error;
+  }): Promise<RunResult>;
+  resumeFromStepResult(args: {
+    runId: RunId;
+    activationId: NodeActivationId;
+    nodeId: NodeId;
+    outputs: NodeOutputs;
+  }): Promise<RunResult>;
+  resumeFromStepError(args: {
+    runId: RunId;
+    activationId: NodeActivationId;
+    nodeId: NodeId;
+    error: Error;
+  }): Promise<RunResult>;
+  waitForCompletion(runId: RunId): Promise<Extract<RunResult, {
+    status: "completed" | "failed";
+  }>>;
+  waitForWebhookResponse(runId: RunId): Promise<WebhookRunResult>;
+}
+interface EngineFacadeDeps {
+  workflowCatalog: WorkflowCatalog;
+  tokenRegistry: PersistedWorkflowTokenRegistryLike;
+  webhookTriggerMatcher: WebhookTriggerMatcher;
+  workflowSnapshotResolver: WorkflowSnapshotResolver;
+  triggerRuntime: EngineTriggerRuntime;
+  workflowRunStarter: EngineWorkflowRunStarter;
+  currentStateRunStarter: EngineCurrentStateRunStarter;
+  runContinuationService: EngineRunContinuationService;
+}
+/**
+ * Runtime facade for orchestration, continuation, triggers, and webhook routing.
+ * Prefer {@link import("../intents/RunIntentService").RunIntentService} for host/HTTP invocation boundaries.
+ */
+declare class Engine implements NodeActivationContinuation {
+  private readonly deps;
+  constructor(deps: EngineFacadeDeps);
+  loadWorkflows(workflows: ReadonlyArray<WorkflowDefinition>): void;
+  getTokenRegistry(): EngineFacadeDeps["tokenRegistry"];
+  resolveWorkflowSnapshot(args: {
+    workflowId: WorkflowId;
+    workflowSnapshot?: NonNullable<Awaited<ReturnType<RunStateStore["load"]>>>["workflowSnapshot"];
+  }): WorkflowDefinition | undefined;
+  startTriggers(): Promise<void>;
+  syncWorkflowTriggersForActivation(workflowId: WorkflowId): Promise<void>;
+  start(workflows: WorkflowDefinition[]): Promise<void>;
+  stop(): Promise<void>;
+  resolveWebhookTrigger(args: {
+    endpointPath: string;
+    method: HttpMethod;
+  }): WebhookTriggerResolution;
+  createTriggerTestItems(args: {
+    workflow: WorkflowDefinition;
+    nodeId: NodeId;
+  }): Promise<Items | undefined>;
+  runWorkflow(wf: WorkflowDefinition, startAt: NodeId, items: Items, parent?: ParentExecutionRef, executionOptions?: RunExecutionOptions, persistedStateOverrides?: Readonly<{
+    workflowSnapshot?: NonNullable<Awaited<ReturnType<RunStateStore["load"]>>>["workflowSnapshot"];
+    mutableState?: NonNullable<Awaited<ReturnType<RunStateStore["load"]>>>["mutableState"];
+  }>): Promise<RunResult>;
+  runWorkflowFromState(request: CurrentStateExecutionRequest): Promise<RunResult>;
+  markNodeRunning(args: {
+    runId: RunId;
+    activationId: NodeActivationId;
+    nodeId: NodeId;
+    inputsByPort: NodeInputsByPort;
+  }): Promise<void>;
+  resumeFromNodeResult(args: {
+    runId: RunId;
+    activationId: NodeActivationId;
+    nodeId: NodeId;
+    outputs: NodeOutputs;
+  }): Promise<RunResult>;
+  resumeFromNodeError(args: {
+    runId: RunId;
+    activationId: NodeActivationId;
+    nodeId: NodeId;
+    error: Error;
+  }): Promise<RunResult>;
+  resumeFromStepResult(args: {
+    runId: RunId;
+    activationId: NodeActivationId;
+    nodeId: NodeId;
+    outputs: NodeOutputs;
+  }): Promise<RunResult>;
+  resumeFromStepError(args: {
+    runId: RunId;
+    activationId: NodeActivationId;
+    nodeId: NodeId;
+    error: Error;
+  }): Promise<RunResult>;
+  waitForCompletion(runId: RunId): Promise<Extract<RunResult, {
+    status: "completed" | "failed";
+  }>>;
+  waitForWebhookResponse(runId: RunId): Promise<WebhookRunResult>;
+}
+//#endregion
+//#region src/engine/policies/EngineExecutionLimitsPolicy.d.ts
+interface EngineExecutionLimitsPolicyConfig {
+  readonly defaultMaxNodeActivations: number;
+  readonly hardMaxNodeActivations: number;
+  readonly defaultMaxSubworkflowDepth: number;
+  readonly hardMaxSubworkflowDepth: number;
+}
+/** Framework defaults for {@link EngineExecutionLimitsPolicy} (merged with host `runtime.engineExecutionLimits`). */
+declare const ENGINE_EXECUTION_LIMITS_DEFAULTS: EngineExecutionLimitsPolicyConfig;
+/**
+ * Resolves per-run execution limits: defaults, hard ceilings, and subworkflow depth for new runs.
+ */
+declare class EngineExecutionLimitsPolicy {
+  private readonly config;
+  constructor(config?: EngineExecutionLimitsPolicyConfig);
+  /**
+   * Effective options for a new root run (depth 0): defaults merged with engine ceilings.
+   * Replaces a separate one-method factory for root-run bootstrap.
+   */
+  createRootExecutionOptions(): RunExecutionOptions;
+  mergeExecutionOptionsForNewRun(parent: ParentExecutionRef | undefined, user: RunExecutionOptions | undefined): RunExecutionOptions;
+  private capNumber;
+}
+//#endregion
+export { Engine as i, EngineExecutionLimitsPolicy as n, EngineExecutionLimitsPolicyConfig as r, ENGINE_EXECUTION_LIMITS_DEFAULTS as t };
+//# sourceMappingURL=EngineExecutionLimitsPolicy-CLxcN-D2.d.ts.map