@codemation/core 0.3.0 → 0.5.0

package/dist/{RunIntentService-Bkg4oYrM.d.cts → RunIntentService-Cjx-glgz.d.cts}

@@ -2,35 +2,6 @@ import { ReadableStream } from "node:stream/web";
 import { DependencyContainer as Container, DependencyContainer as DependencyContainer$1, Disposable, InjectionToken as InjectionToken$1, InjectionToken as TypeToken, Lifecycle, RegistrationOptions, container, delay, inject, injectAll, injectable, instanceCachingFactory, instancePerContainerCachingFactory, predicateAwareClassFactory, registry, singleton } from "tsyringe";
 import { ZodType } from "zod";
 
-//#region src/contracts/retryPolicySpec.types.d.ts
-
-/**
- * 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).
- */
-type RetryPolicySpec = NoneRetryPolicySpec | FixedRetryPolicySpec | ExponentialRetryPolicySpec;
-interface NoneRetryPolicySpec {
-  readonly kind: "none";
-}
-interface FixedRetryPolicySpec {
-  readonly kind: "fixed";
-  /** Total attempts including the first execution. Must be >= 1. */
-  readonly maxAttempts: number;
-  readonly delayMs: number;
-}
-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;
-}
-//#endregion
 //#region src/events/runEvents.d.ts
 type RunEvent = Readonly<{
   kind: "runCreated";
@@ -132,6 +103,157 @@ declare const CoreTokens: {
   readonly WorkflowActivationPolicy: TypeToken<WorkflowActivationPolicy>;
 };
 //#endregion
+//#region src/contracts/credentialTypes.d.ts
+type CredentialTypeId = string;
+type CredentialInstanceId = string;
+type CredentialMaterialSourceKind = "db" | "env" | "code";
+type CredentialSetupStatus = "draft" | "ready";
+type CredentialHealthStatus = "unknown" | "healthy" | "failing";
+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;
+}>;
+type CredentialRequirement = Readonly<{
+  slotKey: string;
+  label: string;
+  acceptedTypes: ReadonlyArray<CredentialTypeId>;
+  optional?: true;
+  helpText?: string;
+  helpUrl?: string;
+}>;
+type CredentialBindingKey = Readonly<{
+  workflowId: WorkflowId;
+  nodeId: NodeId;
+  slotKey: string;
+}>;
+type CredentialBinding = Readonly<{
+  key: CredentialBindingKey;
+  instanceId: CredentialInstanceId;
+  updatedAt: string;
+}>;
+type CredentialHealth = Readonly<{
+  status: CredentialHealthStatus;
+  message?: string;
+  testedAt?: string;
+  expiresAt?: string;
+  details?: Readonly<Record<string, unknown>>;
+}>;
+type OAuth2ProviderFromPublicConfig = Readonly<{
+  authorizeUrlFieldKey: string;
+  tokenUrlFieldKey: string;
+  userInfoUrlFieldKey?: string;
+}>;
+type CredentialOAuth2ScopesFromPublicConfig = Readonly<{
+  presetFieldKey: string;
+  presetScopes: Readonly<Record<string, ReadonlyArray<string>>>;
+  customPresetKey?: string;
+  customScopesFieldKey?: string;
+}>;
+type CredentialOAuth2AuthDefinition = Readonly<{
+  kind: "oauth2";
+  providerId: string;
+  scopes: ReadonlyArray<string>;
+  scopesFromPublicConfig?: CredentialOAuth2ScopesFromPublicConfig;
+  clientIdFieldKey?: string;
+  clientSecretFieldKey?: string;
+} | {
+  kind: "oauth2";
+  providerFromPublicConfig: OAuth2ProviderFromPublicConfig;
+  scopes: ReadonlyArray<string>;
+  scopesFromPublicConfig?: CredentialOAuth2ScopesFromPublicConfig;
+  clientIdFieldKey?: string;
+  clientSecretFieldKey?: string;
+}>;
+type CredentialAuthDefinition = CredentialOAuth2AuthDefinition;
+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.).
+ */
+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.
+ */
+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).
+ */
+type CredentialSessionFactoryArgs<TPublicConfig extends CredentialJsonRecord = CredentialJsonRecord, TMaterial extends CredentialJsonRecord = CredentialJsonRecord> = Readonly<{
+  instance: CredentialInstanceRecord<TPublicConfig>;
+  material: TMaterial;
+  publicConfig: TPublicConfig;
+}>;
+type CredentialSessionFactory<TPublicConfig extends CredentialJsonRecord = CredentialJsonRecord, TMaterial extends CredentialJsonRecord = CredentialJsonRecord, TSession = unknown> = (args: CredentialSessionFactoryArgs<TPublicConfig, TMaterial>) => Promise<TSession>;
+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.
+ */
+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.
+ */
+type AnyCredentialType = CredentialType<any, any, unknown>;
+interface CredentialSessionService {
+  getSession<TSession = unknown>(args: Readonly<{
+    workflowId: WorkflowId;
+    nodeId: NodeId;
+    slotKey: string;
+  }>): Promise<TSession>;
+}
+interface CredentialTypeRegistry {
+  listTypes(): ReadonlyArray<CredentialTypeDefinition>;
+  getType(typeId: CredentialTypeId): CredentialTypeDefinition | undefined;
+}
+declare class CredentialUnboundError extends Error {
+  readonly bindingKey: CredentialBindingKey;
+  readonly acceptedTypes: ReadonlyArray<CredentialTypeId>;
+  constructor(bindingKey: CredentialBindingKey, acceptedTypes?: ReadonlyArray<CredentialTypeId>);
+  private static createMessage;
+}
+//#endregion
 //#region src/contracts/runTypes.d.ts
 interface RunExecutionOptions {
   /** Run-intent override: force the inline scheduler and bypass node-level offload decisions. */
@@ -651,31 +773,41 @@ interface EngineHost {
   credentialSessions: CredentialSessionService;
   workflows?: WorkflowRunnerService;
 }
-interface Node<TConfig extends NodeConfigBase = NodeConfigBase> {
-  kind: "node";
-  outputPorts: ReadonlyArray<OutputPortKey>;
-  execute(items: Items, ctx: NodeExecutionContext<TConfig>): Promise<NodeOutputs>;
-}
 /**
- * Single-input runnable node with per-item execution on `main` only (1→1 default).
- * Engine applies {@link RunnableNodeConfig.mapInput} (if any) + `inputSchema.parse` before `executeOne`.
+ * Per-item runnable node: return JSON, an array to fan-out on `main`, or {@link emitPorts} for multi-port emission.
+ * Engine applies `inputSchema.parse(item.json)` and passes the result as `args.input` (wire `item.json` is unchanged).
  */
-interface ItemNode<TConfig extends NodeConfigBase = NodeConfigBase, TInputJson$1 = unknown, TOutputJson$1 = unknown> {
+interface RunnableNodeExecuteArgs<TConfig extends RunnableNodeConfig<any, any> = RunnableNodeConfig<any, any>, TInputJson$1 = unknown> {
+  readonly input: TInputJson$1;
+  readonly item: Item;
+  readonly itemIndex: number;
+  readonly items: Items;
+  readonly ctx: NodeExecutionContext<TConfig>;
+}
+interface RunnableNode<TConfig extends RunnableNodeConfig<any, any> = RunnableNodeConfig<any, any>, TInputJson$1 = unknown, _TOutputJson = unknown> {
   readonly kind: "node";
-  readonly outputPorts: readonly ["main"];
+  /**
+   * Declared output ports (e.g. `["main"]`).
+   *
+   * Prefer describing dynamic router ports (Switch) and fixed multi-ports (If true/false)
+   * via {@link NodeConfigBase.declaredOutputPorts}. Engine defaults to `["main"]` when omitted.
+   */
+  readonly outputPorts?: ReadonlyArray<OutputPortKey>;
   /** When omitted, engine uses {@link RunnableNodeConfig.inputSchema} or `z.unknown()`. */
   readonly inputSchema?: ZodType<TInputJson$1>;
-  executeOne(args: Readonly<{
-    input: TInputJson$1;
-    item: Item;
-    itemIndex: number;
-    items: Items;
-    ctx: NodeExecutionContext<TConfig>;
-  }>): Promise<TOutputJson$1> | TOutputJson$1;
+  execute(args: RunnableNodeExecuteArgs<TConfig, TInputJson$1>): Promise<unknown> | unknown;
 }
+/** @deprecated Use {@link RunnableNode} */
+type ItemNode<TConfig extends RunnableNodeConfig<any, any> = RunnableNodeConfig<any, any>, TInputJson$1 = unknown, TOutputJson$1 = unknown> = RunnableNode<TConfig, TInputJson$1, TOutputJson$1>;
 interface MultiInputNode<TConfig extends NodeConfigBase = NodeConfigBase> {
   kind: "node";
-  outputPorts: ReadonlyArray<OutputPortKey>;
+  /**
+   * Declared output ports (typically `["main"]`).
+   *
+   * Prefer describing ports for authoring/canvas via {@link NodeConfigBase.declaredOutputPorts}.
+   * Engine defaults to `["main"]` when omitted.
+   */
+  outputPorts?: ReadonlyArray<OutputPortKey>;
   executeMulti(inputsByPort: NodeInputsByPort, ctx: NodeExecutionContext<TConfig>): Promise<NodeOutputs>;
 }
 type TriggerSetupStateFor<TConfig extends TriggerNodeConfig<any, any>> = TriggerNodeSetupState<TConfig>;
@@ -805,6 +937,34 @@ interface EngineDeps {
   triggerRuntimeDiagnostics?: TriggerRuntimeDiagnostics;
 }
 //#endregion
+//#region src/contracts/retryPolicySpec.types.d.ts
+/**
+ * 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).
+ */
+type RetryPolicySpec = NoneRetryPolicySpec | FixedRetryPolicySpec | ExponentialRetryPolicySpec;
+interface NoneRetryPolicySpec {
+  readonly kind: "none";
+}
+interface FixedRetryPolicySpec {
+  readonly kind: "fixed";
+  /** Total attempts including the first execution. Must be >= 1. */
+  readonly maxAttempts: number;
+  readonly delayMs: number;
+}
+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;
+}
+//#endregion
 //#region src/contracts/workflowTypes.d.ts
 type WorkflowId = string;
 type NodeId = string;
@@ -818,6 +978,8 @@ interface JsonObject {
 }
 type JsonValue = JsonPrimitive | JsonObject | JsonArray;
 type JsonArray = ReadonlyArray<JsonValue>;
+/** JSON value that is not a top-level array (nested arrays inside objects are allowed). */
+type JsonNonArray = JsonPrimitive | JsonObject;
 interface Edge {
   from: {
     nodeId: NodeId;
@@ -887,65 +1049,42 @@ interface NodeConfigBase {
    * main batches skip downstream execution and propagate the empty path.
    */
   readonly continueWhenEmptyOutput?: boolean;
+  /**
+   * Declared I/O port names for canvas authoring (unioned with ports inferred from edges).
+   * Use for dynamic routers (Switch) and future error ports.
+   */
+  readonly declaredOutputPorts?: ReadonlyArray<OutputPortKey>;
+  readonly declaredInputPorts?: ReadonlyArray<InputPortKey>;
   getCredentialRequirements?(): ReadonlyArray<CredentialRequirement>;
 }
 declare const runnableNodeInputType: unique symbol;
 declare const runnableNodeOutputType: unique symbol;
-/** Phantom: JSON shape on the wire from upstream before {@link RunnableNodeConfig.mapInput}. */
-declare const runnableNodeWireType: unique symbol;
 declare const triggerNodeOutputType: unique symbol;
+type LineageCarryPolicy = "emitOnly" | "carryThrough";
 /**
- * Read-only execution slice passed to {@link RunnableNodeConfig.mapInput} (aligned with the engine’s
- * node execution context for `runId`, `data`, etc.). Use **`ctx.data`** to read **any completed** upstream
- * node’s outputs in this run (e.g. `ctx.data.getOutputItems(nodeIdA, "main")` while mapping at D), not only
- * the immediate predecessor’s {@link ItemInputMapperArgs.item}.
- */
-interface ItemInputMapperContext {
-  readonly runId: RunId;
-  readonly workflowId: WorkflowId;
-  /** Node whose activation is being prepared (the consumer of `mapInput`). */
-  readonly nodeId: NodeId;
-  readonly activationId: NodeActivationId;
-  readonly parent?: ParentExecutionRef;
-  readonly data: RunDataSnapshot;
-}
-/**
- * Arguments for optional per-item input mapping applied by the engine before Zod validation.
+ * Runnable node: **`TInputJson`** is what **`inputSchema`** validates on **`item.json`** (the wire payload).
+ * **`TOutputJson`** is emitted `item.json` on outputs.
  */
-interface ItemInputMapperArgs<TWireJson$1 = unknown> {
-  readonly item: Item<TWireJson$1>;
-  readonly itemIndex: number;
-  readonly items: Items<TWireJson$1>;
-  readonly ctx: ItemInputMapperContext;
-}
-/**
- * Per-item mapper before Zod validation. Uses a **bivariant** method signature so concrete
- * `ItemInputMapper<SpecificWire, TIn>` remains assignable to `RunnableNodeConfig` fields typed as
- * `ItemInputMapper<unknown, unknown>` (same pattern as React-style callbacks).
- */
-type ItemInputMapper<TWireJson$1 = unknown, TInputJson$1 = unknown> = {
-  bivarianceHack(args: ItemInputMapperArgs<TWireJson$1>): TInputJson$1 | Promise<TInputJson$1>;
-}["bivarianceHack"];
-/**
- * Runnable node: **`TInputJson`** is the payload after `mapInput` (if any) + Zod validation — what {@link ItemNode}
- * `executeOne` receives. **`TOutputJson`** is emitted `item.json` on outputs. **`TWireJson`** is `item.json` from
- * upstream **before** `mapInput`; it defaults to **`TInputJson`** when there is no mapper or wire differs from execute input.
- */
-interface RunnableNodeConfig<TInputJson$1 = unknown, TOutputJson$1 = unknown, TWireJson$1 = TInputJson$1> extends NodeConfigBase {
+interface RunnableNodeConfig<TInputJson$1 = unknown, TOutputJson$1 = unknown> extends NodeConfigBase {
   readonly kind: "node";
   readonly [runnableNodeInputType]?: TInputJson$1;
   readonly [runnableNodeOutputType]?: TOutputJson$1;
-  readonly [runnableNodeWireType]?: TWireJson$1;
   /**
-   * Optional Zod input contract for {@link ItemNode} when not set on the node class.
+   * Optional Zod input contract for {@link RunnableNode} when not set on the node class.
    * Resolution order: node instance `inputSchema`, then config `inputSchema`, then `z.unknown()`.
    */
   readonly inputSchema?: ZodType<TInputJson$1>;
   /**
-   * Optional per-item mapper: engine applies it before validating against the node’s `inputSchema`.
-   * When omitted, the engine validates `item.json` directly.
+   * Overrides default lineage propagation for `execute` outputs (binary/meta/paired).
+   * Routers with multiple {@link RunnableNode#outputPorts} default to **`carryThrough`**; others default to **`emitOnly`**.
+   */
+  readonly lineageCarry?: LineageCarryPolicy;
+  /**
+   * When an activation receives **zero** input items, the engine normally runs `execute` zero times.
+   * Set to **`runOnce`** to run `execute` once with an empty `items` batch (and a synthetic wire item for schema parsing).
+   * Used by batch-style callback nodes (built-in `Callback`) so `callback([], ctx)` still runs.
    */
-  readonly mapInput?: ItemInputMapper<TWireJson$1, TInputJson$1>;
+  readonly emptyBatchExecution?: "skip" | "runOnce";
 }
 declare const triggerNodeSetupStateType: unique symbol;
 interface TriggerNodeConfig<TOutputJson$1 = unknown, TSetupState$1 extends JsonValue | undefined = undefined> extends NodeConfigBase {
@@ -953,9 +1092,8 @@ interface TriggerNodeConfig<TOutputJson$1 = unknown, TSetupState$1 extends JsonV
   readonly [triggerNodeOutputType]?: TOutputJson$1;
   readonly [triggerNodeSetupStateType]?: TSetupState$1;
 }
-type RunnableNodeInputJson<TConfig extends RunnableNodeConfig<any, any, any>> = TConfig extends RunnableNodeConfig<infer TInputJson, any, any> ? TInputJson : never;
-type RunnableNodeWireJson<TConfig extends RunnableNodeConfig<any, any, any>> = TConfig extends RunnableNodeConfig<any, any, infer TWireJson> ? TWireJson : never;
-type RunnableNodeOutputJson<TConfig extends RunnableNodeConfig<any, any, any>> = TConfig extends RunnableNodeConfig<any, infer TOutputJson, any> ? TOutputJson : never;
+type RunnableNodeInputJson<TConfig extends RunnableNodeConfig<any, any>> = TConfig extends RunnableNodeConfig<infer TInputJson, any> ? TInputJson : never;
+type RunnableNodeOutputJson<TConfig extends RunnableNodeConfig<any, any>> = TConfig extends RunnableNodeConfig<any, infer TOutputJson> ? TOutputJson : never;
 type TriggerNodeOutputJson<TConfig extends TriggerNodeConfig<any, any>> = TConfig extends TriggerNodeConfig<infer TOutputJson, any> ? TOutputJson : never;
 type TriggerNodeSetupState<TConfig extends TriggerNodeConfig<any, any>> = TConfig extends TriggerNodeConfig<any, infer TSetupState> ? TSetupState : never;
 interface NodeDefinition {
@@ -1099,149 +1237,6 @@ interface WorkflowPolicyRuntimeDefaults {
   readonly storagePolicy?: WorkflowStoragePolicyMode;
 }
 //#endregion
-//#region src/contracts/credentialTypes.d.ts
-type CredentialTypeId = string;
-type CredentialInstanceId = string;
-type CredentialMaterialSourceKind = "db" | "env" | "code";
-type CredentialSetupStatus = "draft" | "ready";
-type CredentialHealthStatus = "unknown" | "healthy" | "failing";
-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;
-}>;
-type CredentialRequirement = Readonly<{
-  slotKey: string;
-  label: string;
-  acceptedTypes: ReadonlyArray<CredentialTypeId>;
-  optional?: true;
-  helpText?: string;
-  helpUrl?: string;
-}>;
-type CredentialBindingKey = Readonly<{
-  workflowId: WorkflowId;
-  nodeId: NodeId;
-  slotKey: string;
-}>;
-type CredentialBinding = Readonly<{
-  key: CredentialBindingKey;
-  instanceId: CredentialInstanceId;
-  updatedAt: string;
-}>;
-type CredentialHealth = Readonly<{
-  status: CredentialHealthStatus;
-  message?: string;
-  testedAt?: string;
-  expiresAt?: string;
-  details?: Readonly<Record<string, unknown>>;
-}>;
-type OAuth2ProviderFromPublicConfig = Readonly<{
-  authorizeUrlFieldKey: string;
-  tokenUrlFieldKey: string;
-  userInfoUrlFieldKey?: string;
-}>;
-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;
-}>;
-type CredentialAuthDefinition = CredentialOAuth2AuthDefinition;
-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.).
- */
-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.
- */
-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).
- */
-type CredentialSessionFactoryArgs<TPublicConfig extends CredentialJsonRecord = CredentialJsonRecord, TMaterial extends CredentialJsonRecord = CredentialJsonRecord> = Readonly<{
-  instance: CredentialInstanceRecord<TPublicConfig>;
-  material: TMaterial;
-  publicConfig: TPublicConfig;
-}>;
-type CredentialSessionFactory<TPublicConfig extends CredentialJsonRecord = CredentialJsonRecord, TMaterial extends CredentialJsonRecord = CredentialJsonRecord, TSession = unknown> = (args: CredentialSessionFactoryArgs<TPublicConfig, TMaterial>) => Promise<TSession>;
-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.
- */
-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.
- */
-type AnyCredentialType = CredentialType<any, any, unknown>;
-interface CredentialSessionService {
-  getSession<TSession = unknown>(args: Readonly<{
-    workflowId: WorkflowId;
-    nodeId: NodeId;
-    slotKey: string;
-  }>): Promise<TSession>;
-}
-interface CredentialTypeRegistry {
-  listTypes(): ReadonlyArray<CredentialTypeDefinition>;
-  getType(typeId: CredentialTypeId): CredentialTypeDefinition | undefined;
-}
-declare class CredentialUnboundError extends Error {
-  readonly bindingKey: CredentialBindingKey;
-  readonly acceptedTypes: ReadonlyArray<CredentialTypeId>;
-  constructor(bindingKey: CredentialBindingKey, acceptedTypes?: ReadonlyArray<CredentialTypeId>);
-  private static createMessage;
-}
-//#endregion
 //#region src/orchestration/Engine.d.ts
 interface EngineTriggerRuntime {
   startTriggers(): Promise<void>;
@@ -1444,5 +1439,5 @@ declare class RunIntentService {
   private createWebhookExecutionOptions;
 }
 //#endregion
-export { NodeKind as $, PersistedMutableNodeState as $n, ExecutionContextFactory as $t, BinaryPreviewKind as A, WorkflowRunnerService as An, container as Ar, WorkflowPrunePolicySpec as At, JsonArray as B, AllWorkflowsActiveWorkflowActivationPolicy as Bn, CoreTokens as Br, triggerNodeSetupStateType as Bt, CredentialTypeDefinition as C, TriggerSetupContext as Cn, Container as Cr, WorkflowErrorHandler as Ct, OAuth2ProviderFromPublicConfig as D, WorkflowNodeInstanceFactory as Dn, Lifecycle as Dr, WorkflowId as Dt, CredentialUnboundError as E, TriggerTestItemsContext as En, InjectionToken$1 as Er, WorkflowGraphFactory as Et, ItemBinary as F, WebhookControlSignal as Fn, instanceCachingFactory as Fr, branchRef as Ft, NodeActivationId as G, CurrentStateExecutionRequest as Gn, RunEventBus as Gr, BinaryStorageStatResult as Gt, JsonPrimitive as H, ConnectionInvocationAppendArgs as Hn, EngineExecutionLimitsPolicy as Hr, BinaryBody as Ht, ItemInputMapper as I, WebhookInvocationMatch as In, instancePerContainerCachingFactory as Ir, runnableNodeInputType as It, NodeDefinition as J, NodeExecutionError as Jn, FixedRetryPolicySpec as Jr, EngineDeps as Jt, NodeConfigBase as K, EngineRunCounters as Kn, RunEventSubscription as Kr, BinaryStorageWriteRequest as Kt, ItemInputMapperArgs as L, WebhookTriggerMatcher as Ln, predicateAwareClassFactory as Lr, runnableNodeOutputType as Lt, ExecutionMode as M, WorkflowSnapshotResolver as Mn, inject as Mr, WorkflowStoragePolicyMode as Mt, InputPortKey as N, HttpMethod as Nn, injectAll as Nr, WorkflowStoragePolicyResolver as Nt, ActivationIdFactory as O, WorkflowRepository as On, RegistrationOptions as Or, WorkflowNodeConnection as Ot, Item as P, TriggerInstanceId as Pn, injectable as Pr, WorkflowStoragePolicySpec as Pt, NodeId as Q, PendingNodeExecution as Qn, ExecutionContext as Qt, ItemInputMapperContext as R, WebhookTriggerResolution as Rn, registry as Rr, runnableNodeWireType as Rt, CredentialType as S, TriggerRuntimeDiagnostics as Sn, WorkflowExecutionRepository as Sr, WorkflowErrorContext as St, CredentialTypeRegistry as T, TriggerSetupStateRepository as Tn, Disposable as Tr, WorkflowGraph as Tt, JsonValue as U, ConnectionInvocationId as Un, EngineExecutionLimitsPolicyConfig as Ur, BinaryStorage as Ut, JsonObject as V, WorkflowActivationPolicy as Vn, ENGINE_EXECUTION_LIMITS_DEFAULTS as Vr, BinaryAttachmentCreateRequest as Vt, MutableRunData as W, ConnectionInvocationRecord as Wn, RunEvent as Wr, BinaryStorageReadResult as Wt, NodeErrorHandlerArgs as X, NodeExecutionStatus as Xn, RetryPolicySpec as Xr, ExecutableTriggerNode as Xt, NodeErrorHandler as Y, NodeExecutionSnapshot as Yn, NoneRetryPolicySpec as Yr, EngineHost as Yt, NodeErrorHandlerSpec as Z, NodeInputsByPort as Zn, ExecutionBinaryService as Zt, CredentialRequirement as _, PersistedTriggerSetupState as _n, RunStopCondition as _r, TriggerNodeConfig as _t, CredentialAuthDefinition as a, NodeActivationReceipt as an, PersistedWorkflowSnapshotNode as ar, PairedItemRef as at, CredentialSessionService as b, TriggerCleanupHandle as bn, WorkflowExecutionListingRepository as br, UpstreamRefPlaceholder as bt, CredentialFieldSchema as c, NodeActivationScheduler as cn, RunCompletionNotifier as cr, PersistedTokenId as ct, CredentialHealthTester as d, NodeExecutionRequest as dn, RunExecutionOptions as dr, RunId as dt, ItemNode as en, PersistedMutableRunState as er, NodeOffloadPolicy as et, CredentialInstanceId as f, NodeExecutionRequestHandler as fn, RunPruneCandidate as fr, RunIdFactory as ft, CredentialOAuth2AuthDefinition as g, NodeResolver as gn, RunStatus as gr, RunnableNodeWireJson as gt, CredentialMaterialSourceKind as h, NodeExecutor as hn, RunStateResetRequest as hr, RunnableNodeOutputJson as ht, AnyCredentialType as i, NodeActivationContinuation as in, PersistedWorkflowSnapshot as ir, OutputPortKey as it, Edge as j, WorkflowSnapshotFactory as jn, delay as jr, WorkflowStoragePolicyDecisionArgs as jt, BinaryAttachment as k, WorkflowRunnerResolver as kn, TypeToken as kr, WorkflowPolicyRuntimeDefaults as kt, CredentialHealth as l, NodeBinaryAttachmentService as ln, RunCurrentState as lr, RunDataFactory as lt, CredentialJsonRecord as m, NodeExecutionStatePublisher as mn, RunResult as mr, RunnableNodeInputJson as mt, InMemoryLiveWorkflowRepository as n, MultiInputNode as nn, PersistedRunSchedulingState as nr, NodeRef as nt, CredentialBinding as o, NodeActivationRequest as on, PersistedWorkflowTokenRegistryLike as or, ParentExecutionRef as ot, CredentialInstanceRecord as p, NodeExecutionScheduler as pn, RunQueueEntry as pr, RunnableNodeConfig as pt, NodeConnectionName as q, ExecutionFrontierPlan as qn, ExponentialRetryPolicySpec as qr, BinaryStorageWriteResult as qt, Engine as r, Node as rn, PersistedRunState as rr, NodeSchedulerDecision as rt, CredentialBindingKey as s, NodeActivationRequestBase as sn, PinnedNodeOutputsByPort as sr, PersistedRunPolicySnapshot as st, RunIntentService as t, LiveWorkflowRepository as tn, PersistedRunControlState as tr, NodeOutputs as tt, CredentialHealthStatus as u, NodeExecutionContext as un, RunEventPublisherDeps as ur, RunDataSnapshot as ut, CredentialSessionFactory as v, PreparedNodeActivationDispatch as vn, RunSummary as vr, TriggerNodeOutputJson as vt, CredentialTypeId as w, TriggerSetupStateFor as wn, DependencyContainer$1 as wr, WorkflowErrorHandlerSpec as wt, CredentialSetupStatus as x, TriggerNode as xn, WorkflowExecutionPruneRepository as xr, WorkflowDefinition as xt, CredentialSessionFactoryArgs as y, TestableTriggerNode as yn, WebhookRunResult as yr, TriggerNodeSetupState as yt, Items as z, WebhookTriggerRoutingDiagnostics as zn, singleton as zr, triggerNodeOutputType as zt };
-//# sourceMappingURL=RunIntentService-Bkg4oYrM.d.cts.map
+export { WorkflowGraph as $, WorkflowExecutionPruneRepository as $n, TriggerNode as $t, NodeOutputs as A, PendingNodeExecution as An, Lifecycle as Ar, ExecutionContextFactory as At, RunId as B, RunCompletionNotifier as Bn, predicateAwareClassFactory as Br, NodeExecutionContext as Bt, NodeDefinition as C, CurrentStateExecutionRequest as Cn, CredentialTypeRegistry as Cr, BinaryStorageWriteRequest as Ct, NodeId as D, NodeExecutionSnapshot as Dn, DependencyContainer$1 as Dr, ExecutableTriggerNode as Dt, NodeErrorHandlerSpec as E, NodeExecutionError as En, Container as Er, EngineHost as Et, ParentExecutionRef as F, PersistedRunState as Fn, inject as Fr, NodeActivationReceipt as Ft, TriggerNodeConfig as G, RunQueueEntry as Gn, EngineExecutionLimitsPolicy as Gr, NodeExecutor as Gt, RunnableNodeConfig as H, RunEventPublisherDeps as Hn, singleton as Hr, NodeExecutionRequestHandler as Ht, PersistedRunPolicySnapshot as I, PersistedWorkflowSnapshot as In, injectAll as Ir, NodeActivationRequest as It, UpstreamRefPlaceholder as J, RunStatus as Jn, RunEventBus as Jr, PreparedNodeActivationDispatch as Jt, TriggerNodeOutputJson as K, RunResult as Kn, EngineExecutionLimitsPolicyConfig as Kr, NodeResolver as Kt, PersistedTokenId as L, PersistedWorkflowSnapshotNode as Ln, injectable as Lr, NodeActivationRequestBase as Lt, NodeSchedulerDecision as M, PersistedMutableRunState as Mn, TypeToken as Mr, LiveWorkflowRepository as Mt, OutputPortKey as N, PersistedRunControlState as Nn, container as Nr, MultiInputNode as Nt, NodeKind as O, NodeExecutionStatus as On, Disposable as Or, ExecutionBinaryService as Ot, PairedItemRef as P, PersistedRunSchedulingState as Pn, delay as Pr, NodeActivationContinuation as Pt, WorkflowErrorHandlerSpec as Q, WorkflowExecutionListingRepository as Qn, TriggerCleanupHandle as Qt, RunDataFactory as R, PersistedWorkflowTokenRegistryLike as Rn, instanceCachingFactory as Rr, NodeActivationScheduler as Rt, NodeConnectionName as S, ConnectionInvocationRecord as Sn, CredentialTypeId as Sr, BinaryStorageStatResult as St, NodeErrorHandlerArgs as T, ExecutionFrontierPlan as Tn, OAuth2ProviderFromPublicConfig as Tr, EngineDeps as Tt, RunnableNodeInputJson as U, RunExecutionOptions as Un, CoreTokens as Ur, NodeExecutionScheduler as Ut, RunIdFactory as V, RunCurrentState as Vn, registry as Vr, NodeExecutionRequest as Vt, RunnableNodeOutputJson as W, RunPruneCandidate as Wn, ENGINE_EXECUTION_LIMITS_DEFAULTS as Wr, NodeExecutionStatePublisher as Wt, WorkflowErrorContext as X, RunSummary as Xn, RunnableNodeExecuteArgs as Xt, WorkflowDefinition as Y, RunStopCondition as Yn, RunEventSubscription as Yr, RunnableNode as Yt, WorkflowErrorHandler as Z, WebhookRunResult as Zn, TestableTriggerNode as Zt, JsonValue as _, WebhookTriggerRoutingDiagnostics as _n, CredentialSessionFactoryArgs as _r, RetryPolicySpec as _t, BinaryAttachment as a, WorkflowNodeInstanceFactory as an, CredentialFieldSchema as ar, WorkflowStoragePolicyDecisionArgs as at, NodeActivationId as b, ConnectionInvocationAppendArgs as bn, CredentialType as br, BinaryStorage as bt, ExecutionMode as c, WorkflowRunnerService as cn, CredentialHealthTester as cr, WorkflowStoragePolicySpec as ct, ItemBinary as d, HttpMethod as dn, CredentialJsonRecord as dr, runnableNodeOutputType as dt, TriggerRuntimeDiagnostics as en, WorkflowExecutionRepository as er, WorkflowGraphFactory as et, Items as f, TriggerInstanceId as fn, CredentialMaterialSourceKind as fr, triggerNodeOutputType as ft, JsonPrimitive as g, WebhookTriggerResolution as gn, CredentialSessionFactory as gr, NoneRetryPolicySpec as gt, JsonObject as h, WebhookTriggerMatcher as hn, CredentialRequirement as hr, FixedRetryPolicySpec as ht, ActivationIdFactory as i, TriggerTestItemsContext as in, CredentialBindingKey as ir, WorkflowPrunePolicySpec as it, NodeRef as j, PersistedMutableNodeState as jn, RegistrationOptions as jr, ItemNode as jt, NodeOffloadPolicy as k, NodeInputsByPort as kn, InjectionToken$1 as kr, ExecutionContext as kt, InputPortKey as l, WorkflowSnapshotFactory as ln, CredentialInstanceId as lr, branchRef as lt, JsonNonArray as m, WebhookInvocationMatch as mn, CredentialOAuth2ScopesFromPublicConfig as mr, ExponentialRetryPolicySpec as mt, InMemoryLiveWorkflowRepository as n, TriggerSetupStateFor as nn, CredentialAuthDefinition as nr, WorkflowNodeConnection as nt, BinaryPreviewKind as o, WorkflowRepository as on, CredentialHealth as or, WorkflowStoragePolicyMode as ot, JsonArray as p, WebhookControlSignal as pn, CredentialOAuth2AuthDefinition as pr, triggerNodeSetupStateType as pt, TriggerNodeSetupState as q, RunStateResetRequest as qn, RunEvent as qr, PersistedTriggerSetupState as qt, Engine as r, TriggerSetupStateRepository as rn, CredentialBinding as rr, WorkflowPolicyRuntimeDefaults as rt, Edge as s, WorkflowRunnerResolver as sn, CredentialHealthStatus as sr, WorkflowStoragePolicyResolver as st, RunIntentService as t, TriggerSetupContext as tn, AnyCredentialType as tr, WorkflowId as tt, Item as u, WorkflowSnapshotResolver as un, CredentialInstanceRecord as ur, runnableNodeInputType as ut, LineageCarryPolicy as v, AllWorkflowsActiveWorkflowActivationPolicy as vn, CredentialSessionService as vr, BinaryAttachmentCreateRequest as vt, NodeErrorHandler as w, EngineRunCounters as wn, CredentialUnboundError as wr, BinaryStorageWriteResult as wt, NodeConfigBase as x, ConnectionInvocationId as xn, CredentialTypeDefinition as xr, BinaryStorageReadResult as xt, MutableRunData as y, WorkflowActivationPolicy as yn, CredentialSetupStatus as yr, BinaryBody as yt, RunDataSnapshot as z, PinnedNodeOutputsByPort as zn, instancePerContainerCachingFactory as zr, NodeBinaryAttachmentService as zt };
+//# sourceMappingURL=RunIntentService-Cjx-glgz.d.cts.map