@codemation/host 0.1.7 → 0.2.1

package/dist/{CodemationConfig-9PkOBCh-.d.ts → CodemationAppContext-Vtn0U2Ga.d.ts}

@@ -1,5 +1,5 @@
-import { a as CodemationWhitelabelConfig, o as CodemationLogConfig, t as CodemationAuthConfig, u as LoggerFactory } from "./CodemationAuthConfig-7hEfICPf.js";
-import { B as Container, H as EngineExecutionLimitsPolicyConfig, N as WorkflowDefinition, V as TypeToken, s as AnyCredentialType } from "./index-CLRTQLAp.js";
+import { B as Container, H as EngineExecutionLimitsPolicyConfig, N as WorkflowDefinition, V as TypeToken, s as AnyCredentialType } from "./index-SKC6oys-.js";
+import { a as CodemationAuthConfig, n as CodemationLogConfig, t as CodemationWhitelabelConfig, u as LoggerFactory } from "./CodemationWhitelabelConfig-D5rYcLlj.js";
 
 //#region src/presentation/config/CodemationClassToken.d.ts
 type CodemationClassToken<TValue> = TypeToken<TValue> & (new (...args: never[]) => TValue);
@@ -19,6 +19,82 @@ interface CodemationFactoryRegistration<TValue> extends CodemationContainerRegis
 }
 type CodemationContainerRegistration<TValue = unknown> = CodemationValueRegistration<TValue> | CodemationClassRegistration<TValue> | CodemationFactoryRegistration<TValue>;
 //#endregion
+//#region src/presentation/config/CodemationWorkflowDiscovery.d.ts
+interface CodemationWorkflowDiscovery {
+  readonly directories?: ReadonlyArray<string>;
+}
+//#endregion
+//#region src/presentation/config/CodemationConfig.d.ts
+type CodemationEventBusKind = "memory" | "redis";
+type CodemationSchedulerKind = "local" | "bullmq";
+type CodemationDatabaseKind = "postgresql" | "sqlite";
+interface CodemationDatabaseConfig {
+  readonly kind?: CodemationDatabaseKind;
+  /** TCP PostgreSQL URL when `kind` is `postgresql` (or omitted with a postgres URL). */
+  readonly url?: string;
+  /** SQLite database file path when `kind` is `sqlite`. Relative paths resolve from the consumer app root. */
+  readonly sqliteFilePath?: string;
+}
+interface CodemationEventBusConfig {
+  readonly kind?: CodemationEventBusKind;
+  readonly redisUrl?: string;
+  readonly queuePrefix?: string;
+}
+interface CodemationSchedulerConfig {
+  readonly kind?: CodemationSchedulerKind;
+  readonly queuePrefix?: string;
+  readonly workerQueues?: ReadonlyArray<string>;
+}
+type CodemationAppSchedulerKind = "inline" | "queue";
+interface CodemationAppSchedulerConfig {
+  readonly kind?: CodemationAppSchedulerKind;
+  readonly queuePrefix?: string;
+  readonly workerQueues?: ReadonlyArray<string>;
+  readonly redisUrl?: string;
+}
+/**
+ * Optional overrides for engine execution limits (activation budget and subworkflow depth caps).
+ * Omitted fields keep framework defaults. Advanced users can bind `CoreTokens.EngineExecutionLimitsPolicy` for full control.
+ */
+type CodemationEngineExecutionLimitsConfig = Readonly<Partial<EngineExecutionLimitsPolicyConfig>>;
+interface CodemationAppDefinition {
+  readonly frontendPort?: number;
+  readonly databaseUrl?: string;
+  readonly database?: CodemationDatabaseConfig;
+  readonly scheduler?: CodemationAppSchedulerConfig;
+  readonly auth?: CodemationAuthConfig;
+  readonly whitelabel?: CodemationWhitelabelConfig;
+  readonly log?: CodemationLogConfig;
+  readonly engineExecutionLimits?: CodemationEngineExecutionLimitsConfig;
+}
+interface CodemationApplicationRuntimeConfig {
+  readonly frontendPort?: number;
+  readonly database?: CodemationDatabaseConfig;
+  readonly eventBus?: CodemationEventBusConfig;
+  readonly scheduler?: CodemationSchedulerConfig;
+  /** Merged with engine defaults when building the execution limits policy (API + workers). */
+  readonly engineExecutionLimits?: CodemationEngineExecutionLimitsConfig;
+}
+interface CodemationConfig {
+  readonly app?: CodemationAppDefinition;
+  readonly register?: (context: CodemationAppContext) => void;
+  readonly runtime?: CodemationApplicationRuntimeConfig;
+  readonly workflows?: ReadonlyArray<WorkflowDefinition>;
+  readonly workflowDiscovery?: CodemationWorkflowDiscovery;
+  readonly plugins?: ReadonlyArray<CodemationPlugin>;
+  /** Consumer-defined `CredentialType` entries (see `@codemation/core`), applied when the host loads config. */
+  readonly credentialTypes?: ReadonlyArray<AnyCredentialType>;
+  /** Optional shell whitelabel (product name, logo path). */
+  readonly whitelabel?: CodemationWhitelabelConfig;
+  /** Required for production hosts; optional only when using development bypass (never in production). */
+  readonly auth?: CodemationAuthConfig;
+  /**
+   * Namespace-level log filters (first matching rule wins). Unmatched namespaces use `CODEMATION_LOG_LEVEL` / defaults.
+   * Omit to keep env-only behavior.
+   */
+  readonly log?: CodemationLogConfig;
+}
+//#endregion
 //#region src/presentation/config/CodemationPlugin.d.ts
 interface CodemationPluginContext extends CodemationRegistrationContextBase {
   readonly container: Container;
@@ -100,81 +176,5 @@ interface CodemationAppContext extends CodemationRegistrationContextBase {
   discoverWorkflows(...directories: ReadonlyArray<string>): void;
 }
 //#endregion
-//#region src/presentation/config/CodemationWorkflowDiscovery.d.ts
-interface CodemationWorkflowDiscovery {
-  readonly directories?: ReadonlyArray<string>;
-}
-//#endregion
-//#region src/presentation/config/CodemationConfig.d.ts
-type CodemationEventBusKind = "memory" | "redis";
-type CodemationSchedulerKind = "local" | "bullmq";
-type CodemationDatabaseKind = "postgresql" | "sqlite";
-interface CodemationDatabaseConfig {
-  readonly kind?: CodemationDatabaseKind;
-  /** TCP PostgreSQL URL when `kind` is `postgresql` (or omitted with a postgres URL). */
-  readonly url?: string;
-  /** SQLite database file path when `kind` is `sqlite`. Relative paths resolve from the consumer app root. */
-  readonly sqliteFilePath?: string;
-}
-interface CodemationEventBusConfig {
-  readonly kind?: CodemationEventBusKind;
-  readonly redisUrl?: string;
-  readonly queuePrefix?: string;
-}
-interface CodemationSchedulerConfig {
-  readonly kind?: CodemationSchedulerKind;
-  readonly queuePrefix?: string;
-  readonly workerQueues?: ReadonlyArray<string>;
-}
-type CodemationAppSchedulerKind = "inline" | "queue";
-interface CodemationAppSchedulerConfig {
-  readonly kind?: CodemationAppSchedulerKind;
-  readonly queuePrefix?: string;
-  readonly workerQueues?: ReadonlyArray<string>;
-  readonly redisUrl?: string;
-}
-/**
- * Optional overrides for engine execution limits (activation budget and subworkflow depth caps).
- * Omitted fields keep framework defaults. Advanced users can bind `CoreTokens.EngineExecutionLimitsPolicy` for full control.
- */
-type CodemationEngineExecutionLimitsConfig = Readonly<Partial<EngineExecutionLimitsPolicyConfig>>;
-interface CodemationAppDefinition {
-  readonly frontendPort?: number;
-  readonly databaseUrl?: string;
-  readonly database?: CodemationDatabaseConfig;
-  readonly scheduler?: CodemationAppSchedulerConfig;
-  readonly auth?: CodemationAuthConfig;
-  readonly whitelabel?: CodemationWhitelabelConfig;
-  readonly log?: CodemationLogConfig;
-  readonly engineExecutionLimits?: CodemationEngineExecutionLimitsConfig;
-}
-interface CodemationApplicationRuntimeConfig {
-  readonly frontendPort?: number;
-  readonly database?: CodemationDatabaseConfig;
-  readonly eventBus?: CodemationEventBusConfig;
-  readonly scheduler?: CodemationSchedulerConfig;
-  /** Merged with engine defaults when building the execution limits policy (API + workers). */
-  readonly engineExecutionLimits?: CodemationEngineExecutionLimitsConfig;
-}
-interface CodemationConfig {
-  readonly app?: CodemationAppDefinition;
-  readonly register?: (context: CodemationAppContext) => void;
-  readonly runtime?: CodemationApplicationRuntimeConfig;
-  readonly workflows?: ReadonlyArray<WorkflowDefinition>;
-  readonly workflowDiscovery?: CodemationWorkflowDiscovery;
-  readonly plugins?: ReadonlyArray<CodemationPlugin>;
-  /** Consumer-defined `CredentialType` entries (see `@codemation/core`), applied when the host loads config. */
-  readonly credentialTypes?: ReadonlyArray<AnyCredentialType>;
-  /** Optional shell whitelabel (product name, logo path). */
-  readonly whitelabel?: CodemationWhitelabelConfig;
-  /** Required for production hosts; optional only when using development bypass (never in production). */
-  readonly auth?: CodemationAuthConfig;
-  /**
-   * Namespace-level log filters (first matching rule wins). Unmatched namespaces use `CODEMATION_LOG_LEVEL` / defaults.
-   * Omit to keep env-only behavior.
-   */
-  readonly log?: CodemationLogConfig;
-}
-//#endregion
-export { CodemationContainerRegistration as C, CodemationPluginPackageMetadata as S, AppPersistenceConfig as _, CodemationConfig as a, CodemationPluginConfig as b, CodemationEngineExecutionLimitsConfig as c, CodemationSchedulerConfig as d, CodemationSchedulerKind as f, AppConfig as g, CodemationRegistrationContextBase as h, CodemationApplicationRuntimeConfig as i, CodemationEventBusConfig as l, CodemationAppContext as m, CodemationAppSchedulerConfig as n, CodemationDatabaseConfig as o, CodemationWorkflowDiscovery as p, CodemationAppSchedulerKind as r, CodemationDatabaseKind as s, CodemationAppDefinition as t, CodemationEventBusKind as u, AppPluginLoadSummary as v, CodemationClassToken as w, CodemationPluginContext as x, CodemationPlugin as y };
-//# sourceMappingURL=CodemationConfig-9PkOBCh-.d.ts.map
+export { CodemationContainerRegistration as C, CodemationWorkflowDiscovery as S, CodemationEngineExecutionLimitsConfig as _, AppPluginLoadSummary as a, CodemationSchedulerConfig as b, CodemationPluginContext as c, CodemationAppSchedulerConfig as d, CodemationAppSchedulerKind as f, CodemationDatabaseKind as g, CodemationDatabaseConfig as h, AppPersistenceConfig as i, CodemationPluginPackageMetadata as l, CodemationConfig as m, CodemationRegistrationContextBase as n, CodemationPlugin as o, CodemationApplicationRuntimeConfig as p, AppConfig as r, CodemationPluginConfig as s, CodemationAppContext as t, CodemationAppDefinition as u, CodemationEventBusConfig as v, CodemationClassToken as w, CodemationSchedulerKind as x, CodemationEventBusKind as y };
+//# sourceMappingURL=CodemationAppContext-Vtn0U2Ga.d.ts.map

package/dist/CodemationAuthoring.types-CXubuYvd.d.ts

@@ -0,0 +1,196 @@
+import { D as Item, G as ChainCursor, I as NodeExecutionContext, K as AnyRunnableNodeConfig, M as RunnableNodeOutputJson, N as WorkflowDefinition, O as Items, V as TypeToken, a as ToolConfig, i as ChatModelConfig, j as RunnableNodeConfig, o as DefinedNode, r as AgentGuardrailConfig, s as AnyCredentialType } from "./index-SKC6oys-.js";
+import { c as CodemationPluginContext, m as CodemationConfig, o as CodemationPlugin, t as CodemationAppContext } from "./CodemationAppContext-Vtn0U2Ga.js";
+import { t as CodemationWhitelabelConfig } from "./CodemationWhitelabelConfig-D5rYcLlj.js";
+import { ZodType, z } from "zod";
+
+//#region ../core-nodes/src/nodes/aggregate.d.ts
+declare class Aggregate<TIn = unknown, TOut = unknown> implements RunnableNodeConfig<TIn, TOut> {
+  readonly name: string;
+  readonly aggregate: (items: Items<TIn>, ctx: NodeExecutionContext<Aggregate<TIn, TOut>>) => TOut | Promise<TOut>;
+  readonly id?: string | undefined;
+  readonly kind: "node";
+  readonly type: TypeToken<unknown>;
+  readonly execution: {
+    readonly hint: "local";
+  };
+  readonly icon: "lucide:layers";
+  constructor(name: string, aggregate: (items: Items<TIn>, ctx: NodeExecutionContext<Aggregate<TIn, TOut>>) => TOut | Promise<TOut>, id?: string | undefined);
+}
+//#endregion
+//#region ../core-nodes/src/nodes/filter.d.ts
+declare class Filter<TIn = unknown> implements RunnableNodeConfig<TIn, TIn> {
+  readonly name: string;
+  readonly predicate: (item: Item<TIn>, index: number, items: Items<TIn>, ctx: NodeExecutionContext<Filter<TIn>>) => boolean;
+  readonly id?: string | undefined;
+  readonly kind: "node";
+  readonly type: TypeToken<unknown>;
+  readonly execution: {
+    readonly hint: "local";
+  };
+  readonly icon: "lucide:filter";
+  constructor(name: string, predicate: (item: Item<TIn>, index: number, items: Items<TIn>, ctx: NodeExecutionContext<Filter<TIn>>) => boolean, id?: string | undefined);
+}
+//#endregion
+//#region ../core-nodes/src/nodes/split.d.ts
+declare class Split<TIn = unknown, TElem = unknown> implements RunnableNodeConfig<TIn, TElem> {
+  readonly name: string;
+  readonly getElements: (item: Item<TIn>, ctx: NodeExecutionContext<Split<TIn, TElem>>) => readonly TElem[];
+  readonly id?: string | undefined;
+  readonly kind: "node";
+  readonly type: TypeToken<unknown>;
+  readonly execution: {
+    readonly hint: "local";
+  };
+  /**
+   * When splitting yields zero items for a batch, downstream single-input nodes still run once with an empty batch.
+   * Mirrors {@link MapData}'s empty-output behavior.
+   */
+  readonly continueWhenEmptyOutput: true;
+  readonly icon: "lucide:ungroup";
+  constructor(name: string, getElements: (item: Item<TIn>, ctx: NodeExecutionContext<Split<TIn, TElem>>) => readonly TElem[], id?: string | undefined);
+}
+//#endregion
+//#region ../core-nodes/src/nodes/merge.d.ts
+type MergeMode = "passThrough" | "append" | "mergeByPosition";
+//#endregion
+//#region ../core-nodes/src/workflowAuthoring/WorkflowAuthoringOptions.types.d.ts
+type WorkflowAgentPrompt<TCurrentJson> = string | ((item: TCurrentJson) => string);
+interface WorkflowAgentOptions<TCurrentJson, TOutputSchema extends z.ZodTypeAny | undefined = undefined> {
+  readonly prompt: WorkflowAgentPrompt<TCurrentJson>;
+  readonly model: string | ChatModelConfig;
+  readonly tools?: ReadonlyArray<ToolConfig>;
+  readonly outputSchema?: TOutputSchema;
+  readonly retryPolicy?: RunnableNodeConfig["retryPolicy"];
+  readonly guardrails?: AgentGuardrailConfig;
+  readonly id?: string;
+}
+//#endregion
+//#region ../core-nodes/src/workflowAuthoring/WorkflowBranchBuilder.types.d.ts
+declare class WorkflowBranchBuilder<TCurrentJson> {
+  private readonly steps;
+  constructor(steps?: ReadonlyArray<AnyRunnableNodeConfig>);
+  then<TOutputJson, TConfig extends RunnableNodeConfig<TCurrentJson, TOutputJson>>(config: TConfig): WorkflowBranchBuilder<RunnableNodeOutputJson<TConfig>>;
+  map<TNextJson>(mapper: (item: TCurrentJson) => TNextJson): WorkflowBranchBuilder<TNextJson>;
+  map<TNextJson>(name: string, mapper: (item: TCurrentJson) => TNextJson, id?: string): WorkflowBranchBuilder<TNextJson>;
+  wait(duration: number | string): WorkflowBranchBuilder<TCurrentJson>;
+  wait(name: string, duration: number | string, id?: string): WorkflowBranchBuilder<TCurrentJson>;
+  split<TElem>(getElements: (item: Item<TCurrentJson>, ctx: NodeExecutionContext<Split<TCurrentJson, TElem>>) => readonly TElem[]): WorkflowBranchBuilder<TElem>;
+  split<TElem>(name: string, getElements: (item: Item<TCurrentJson>, ctx: NodeExecutionContext<Split<TCurrentJson, TElem>>) => readonly TElem[], id?: string): WorkflowBranchBuilder<TElem>;
+  filter(predicate: (item: Item<TCurrentJson>, index: number, items: Items<TCurrentJson>, ctx: NodeExecutionContext<Filter<TCurrentJson>>) => boolean): WorkflowBranchBuilder<TCurrentJson>;
+  filter(name: string, predicate: (item: Item<TCurrentJson>, index: number, items: Items<TCurrentJson>, ctx: NodeExecutionContext<Filter<TCurrentJson>>) => boolean, id?: string): WorkflowBranchBuilder<TCurrentJson>;
+  aggregate<TOut>(aggregateFn: (items: Items<TCurrentJson>, ctx: NodeExecutionContext<Aggregate<TCurrentJson, TOut>>) => TOut | Promise<TOut>): WorkflowBranchBuilder<TOut>;
+  aggregate<TOut>(name: string, aggregateFn: (items: Items<TCurrentJson>, ctx: NodeExecutionContext<Aggregate<TCurrentJson, TOut>>) => TOut | Promise<TOut>, id?: string): WorkflowBranchBuilder<TOut>;
+  agent<TOutputSchema extends z.ZodTypeAny>(options: WorkflowAgentOptions<TCurrentJson, TOutputSchema>): WorkflowBranchBuilder<z.output<TOutputSchema>>;
+  agent(options: WorkflowAgentOptions<TCurrentJson, undefined>): WorkflowBranchBuilder<Record<string, unknown>>;
+  agent<TOutputSchema extends z.ZodTypeAny>(name: string, options: WorkflowAgentOptions<TCurrentJson, TOutputSchema | undefined>): WorkflowBranchBuilder<TOutputSchema extends z.ZodTypeAny ? z.output<TOutputSchema> : Record<string, unknown>>;
+  node<TConfig extends Record<string, unknown>, TOutputJson>(definitionOrKey: DefinedNode<string, TConfig, TCurrentJson, TOutputJson> | string, config: TConfig, name?: string, id?: string): WorkflowBranchBuilder<TOutputJson>;
+  getSteps(): ReadonlyArray<AnyRunnableNodeConfig>;
+}
+//#endregion
+//#region ../core-nodes/src/workflowAuthoring/WorkflowChain.types.d.ts
+type BranchCallback<TCurrentJson, TNextJson> = (branch: WorkflowBranchBuilder<TCurrentJson>) => WorkflowBranchBuilder<TNextJson>;
+type RouteBranchCallback<TCurrentJson, TNextJson> = (branch: WorkflowChain<TCurrentJson>) => WorkflowChain<TNextJson>;
+declare class WorkflowChain<TCurrentJson> {
+  private readonly chain;
+  constructor(chain: ChainCursor<TCurrentJson>);
+  then<TOutputJson, TConfig extends RunnableNodeConfig<TCurrentJson, TOutputJson>>(config: TConfig): WorkflowChain<RunnableNodeOutputJson<TConfig>>;
+  map<TNextJson>(mapper: (item: TCurrentJson) => TNextJson): WorkflowChain<TNextJson>;
+  map<TNextJson>(name: string, mapper: (item: TCurrentJson) => TNextJson, id?: string): WorkflowChain<TNextJson>;
+  wait(duration: number | string): WorkflowChain<TCurrentJson>;
+  wait(name: string, duration: number | string, id?: string): WorkflowChain<TCurrentJson>;
+  split<TElem>(getElements: (item: Item<TCurrentJson>, ctx: NodeExecutionContext<Split<TCurrentJson, TElem>>) => readonly TElem[]): WorkflowChain<TElem>;
+  split<TElem>(name: string, getElements: (item: Item<TCurrentJson>, ctx: NodeExecutionContext<Split<TCurrentJson, TElem>>) => readonly TElem[], id?: string): WorkflowChain<TElem>;
+  filter(predicate: (item: Item<TCurrentJson>, index: number, items: Items<TCurrentJson>, ctx: NodeExecutionContext<Filter<TCurrentJson>>) => boolean): WorkflowChain<TCurrentJson>;
+  filter(name: string, predicate: (item: Item<TCurrentJson>, index: number, items: Items<TCurrentJson>, ctx: NodeExecutionContext<Filter<TCurrentJson>>) => boolean, id?: string): WorkflowChain<TCurrentJson>;
+  aggregate<TOut>(aggregateFn: (items: Items<TCurrentJson>, ctx: NodeExecutionContext<Aggregate<TCurrentJson, TOut>>) => TOut | Promise<TOut>): WorkflowChain<TOut>;
+  aggregate<TOut>(name: string, aggregateFn: (items: Items<TCurrentJson>, ctx: NodeExecutionContext<Aggregate<TCurrentJson, TOut>>) => TOut | Promise<TOut>, id?: string): WorkflowChain<TOut>;
+  merge(): WorkflowChain<TCurrentJson>;
+  merge(cfg: Readonly<{
+    mode: MergeMode;
+    prefer?: ReadonlyArray<string>;
+  }>, id?: string): WorkflowChain<TCurrentJson>;
+  merge(name: string, cfg?: Readonly<{
+    mode: MergeMode;
+    prefer?: ReadonlyArray<string>;
+  }>, id?: string): WorkflowChain<TCurrentJson>;
+  if<TBranchJson>(predicate: (item: TCurrentJson) => boolean, branches: Readonly<{
+    true?: BranchCallback<TCurrentJson, TBranchJson>;
+    false?: BranchCallback<TCurrentJson, TBranchJson>;
+  }>): WorkflowChain<TBranchJson>;
+  if<TBranchJson>(name: string, predicate: (item: TCurrentJson) => boolean, branches: Readonly<{
+    true?: BranchCallback<TCurrentJson, TBranchJson>;
+    false?: BranchCallback<TCurrentJson, TBranchJson>;
+  }>): WorkflowChain<TBranchJson>;
+  route<TBranchJson>(branches: Readonly<Record<string, RouteBranchCallback<TCurrentJson, TBranchJson> | undefined>>): WorkflowChain<TBranchJson>;
+  switch<TBranchJson>(cfg: Readonly<{
+    cases: readonly string[];
+    defaultCase: string;
+    resolveCaseKey: (item: TCurrentJson) => string | Promise<string>;
+    branches: Readonly<Record<string, RouteBranchCallback<TCurrentJson, TBranchJson> | undefined>>;
+  }>): WorkflowChain<TBranchJson>;
+  switch<TBranchJson>(name: string, cfg: Readonly<{
+    cases: readonly string[];
+    defaultCase: string;
+    resolveCaseKey: (item: TCurrentJson) => string | Promise<string>;
+    branches: Readonly<Record<string, RouteBranchCallback<TCurrentJson, TBranchJson> | undefined>>;
+  }>, id?: string): WorkflowChain<TBranchJson>;
+  agent<TOutputSchema extends z.ZodTypeAny>(options: WorkflowAgentOptions<TCurrentJson, TOutputSchema>): WorkflowChain<z.output<TOutputSchema>>;
+  agent(options: WorkflowAgentOptions<TCurrentJson, undefined>): WorkflowChain<Record<string, unknown>>;
+  agent<TOutputSchema extends z.ZodTypeAny>(name: string, options: WorkflowAgentOptions<TCurrentJson, TOutputSchema | undefined>): WorkflowChain<TOutputSchema extends z.ZodTypeAny ? z.output<TOutputSchema> : Record<string, unknown>>;
+  node<TConfig extends Record<string, unknown>, TOutputJson>(definitionOrKey: DefinedNode<string, TConfig, TCurrentJson, TOutputJson> | string, config: TConfig, name?: string, id?: string): WorkflowChain<TOutputJson>;
+  build(): WorkflowDefinition;
+}
+//#endregion
+//#region ../core-nodes/src/workflowAuthoring/WorkflowAuthoringBuilder.types.d.ts
+declare class WorkflowAuthoringBuilder {
+  private readonly id;
+  private readonly workflowName;
+  constructor(id: string, workflowName?: string);
+  name(name: string): WorkflowAuthoringBuilder;
+  manualTrigger<TOutputJson>(defaultItems: TOutputJson | ReadonlyArray<TOutputJson>): WorkflowChain<TOutputJson>;
+  manualTrigger<TOutputJson>(name: string, defaultItems?: TOutputJson | ReadonlyArray<TOutputJson>, id?: string): WorkflowChain<TOutputJson>;
+}
+//#endregion
+//#region ../core-nodes/src/workflowAuthoring.types.d.ts
+declare function workflow(id: string): WorkflowAuthoringBuilder;
+//#endregion
+//#region src/presentation/config/CodemationAuthoring.types.d.ts
+interface FriendlyCodemationDatabaseConfig {
+  readonly kind: "postgresql" | "sqlite";
+  readonly url?: string;
+  readonly filePath?: string;
+}
+interface FriendlyCodemationExecutionConfig {
+  readonly mode?: "inline" | "queue";
+  readonly queuePrefix?: string;
+  readonly workerQueues?: ReadonlyArray<string>;
+  readonly redisUrl?: string;
+}
+interface DefineCodemationAppOptions extends Omit<CodemationConfig, "app" | "credentialTypes" | "register" | "whitelabel" | "auth"> {
+  readonly name?: string;
+  readonly auth?: CodemationConfig["auth"];
+  readonly database?: FriendlyCodemationDatabaseConfig;
+  readonly execution?: FriendlyCodemationExecutionConfig;
+  readonly nodes?: ReadonlyArray<DefinedNode<string, Record<string, unknown>, unknown, unknown>>;
+  readonly credentialTypes?: ReadonlyArray<AnyCredentialType>;
+  readonly credentials?: ReadonlyArray<AnyCredentialType>;
+  readonly register?: (context: CodemationAppContext) => void;
+  readonly whitelabel?: CodemationWhitelabelConfig;
+}
+interface DefinePluginOptions {
+  readonly name?: string;
+  readonly pluginPackageId?: string;
+  readonly nodes?: ReadonlyArray<DefinedNode<string, Record<string, unknown>, unknown, unknown>>;
+  readonly credentials?: ReadonlyArray<AnyCredentialType>;
+  readonly register?: (context: CodemationPluginContext) => void | Promise<void>;
+  readonly sandbox?: DefineCodemationAppOptions & Readonly<{
+    workflows?: ReadonlyArray<WorkflowDefinition>;
+  }>;
+}
+declare function defineCodemationApp(options: DefineCodemationAppOptions): CodemationConfig;
+declare function definePlugin(options: DefinePluginOptions): CodemationPlugin & Readonly<{
+  sandbox?: DefinePluginOptions["sandbox"];
+}>;
+//#endregion
+export { defineCodemationApp as a, FriendlyCodemationExecutionConfig as i, DefinePluginOptions as n, definePlugin as o, FriendlyCodemationDatabaseConfig as r, workflow as s, DefineCodemationAppOptions as t };
+//# sourceMappingURL=CodemationAuthoring.types-CXubuYvd.d.ts.map

package/dist/CodemationAuthoring.types-SxVJ1qu5.js

@@ -0,0 +1,86 @@
+//#region src/presentation/config/CodemationAuthoring.types.ts
+var CodemationAuthoringConfigFactory = class {
+	static createApp(options) {
+		const appDefinition = this.createAppDefinition(options);
+		const credentialTypes = [...options.credentialTypes ?? [], ...options.credentials ?? []];
+		const register = this.composeAppRegister(options.register, options.nodes);
+		const { workflows, workflowDiscovery, plugins, runtime, log } = options;
+		return {
+			workflows,
+			workflowDiscovery,
+			plugins,
+			runtime,
+			log,
+			app: appDefinition,
+			credentialTypes,
+			register
+		};
+	}
+	static createPlugin(options) {
+		return {
+			pluginPackageId: options.pluginPackageId,
+			sandbox: options.sandbox,
+			async register(context) {
+				for (const nodeDefinition of options.nodes ?? []) nodeDefinition.register(context);
+				for (const credential of options.credentials ?? []) context.registerCredentialType(credential);
+				await options.register?.(context);
+			}
+		};
+	}
+	static createAppDefinition(options) {
+		const scheduler = this.createSchedulerConfig(options.execution);
+		const database = this.createDatabaseConfig(options.database);
+		const whitelabel = this.createWhitelabel(options.name, options.whitelabel);
+		if (!options.auth && !database && !scheduler && !whitelabel) return;
+		return {
+			auth: options.auth,
+			database,
+			scheduler,
+			whitelabel
+		};
+	}
+	static createDatabaseConfig(database) {
+		if (!database) return;
+		if (database.kind === "sqlite") return {
+			kind: "sqlite",
+			sqliteFilePath: database.filePath
+		};
+		return {
+			kind: "postgresql",
+			url: database.url
+		};
+	}
+	static createSchedulerConfig(execution) {
+		if (!execution) return;
+		return {
+			kind: execution.mode,
+			queuePrefix: execution.queuePrefix,
+			workerQueues: execution.workerQueues,
+			redisUrl: execution.redisUrl
+		};
+	}
+	static createWhitelabel(name, whitelabel) {
+		if (!name && !whitelabel) return;
+		return {
+			productName: name ?? whitelabel?.productName,
+			logoPath: whitelabel?.logoPath
+		};
+	}
+	static composeAppRegister(register, nodes) {
+		if (!register && (!nodes || nodes.length === 0)) return;
+		return (context) => {
+			for (const nodeDefinition of nodes ?? []) nodeDefinition.register(context);
+			register?.(context);
+		};
+	}
+};
+function defineCodemationApp(options) {
+	return CodemationAuthoringConfigFactory.createApp(options);
+}
+function definePlugin(options) {
+	return CodemationAuthoringConfigFactory.createPlugin(options);
+}
+
+//#endregion
+export { definePlugin as n, defineCodemationApp as t };
+//# sourceMappingURL=CodemationAuthoring.types-SxVJ1qu5.js.map

package/dist/CodemationAuthoring.types-SxVJ1qu5.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"CodemationAuthoring.types-SxVJ1qu5.js","names":[],"sources":["../src/presentation/config/CodemationAuthoring.types.ts"],"sourcesContent":["import type { AnyCredentialType, DefinedNode, WorkflowDefinition } from \"@codemation/core\";\nimport type { CodemationAppContext } from \"./CodemationAppContext\";\nimport type {\n  CodemationAppDefinition,\n  CodemationAppSchedulerConfig,\n  CodemationConfig,\n  CodemationDatabaseConfig,\n} from \"./CodemationConfig\";\nimport type { CodemationPlugin, CodemationPluginContext } from \"./CodemationPlugin\";\nimport type { CodemationWhitelabelConfig } from \"./CodemationWhitelabelConfig\";\n\nexport interface FriendlyCodemationDatabaseConfig {\n  readonly kind: \"postgresql\" | \"sqlite\";\n  readonly url?: string;\n  readonly filePath?: string;\n}\n\nexport interface FriendlyCodemationExecutionConfig {\n  readonly mode?: \"inline\" | \"queue\";\n  readonly queuePrefix?: string;\n  readonly workerQueues?: ReadonlyArray<string>;\n  readonly redisUrl?: string;\n}\n\nexport interface DefineCodemationAppOptions extends Omit<\n  CodemationConfig,\n  \"app\" | \"credentialTypes\" | \"register\" | \"whitelabel\" | \"auth\"\n> {\n  readonly name?: string;\n  readonly auth?: CodemationConfig[\"auth\"];\n  readonly database?: FriendlyCodemationDatabaseConfig;\n  readonly execution?: FriendlyCodemationExecutionConfig;\n  readonly nodes?: ReadonlyArray<DefinedNode<string, Record<string, unknown>, unknown, unknown>>;\n  readonly credentialTypes?: ReadonlyArray<AnyCredentialType>;\n  readonly credentials?: ReadonlyArray<AnyCredentialType>;\n  readonly register?: (context: CodemationAppContext) => void;\n  readonly whitelabel?: CodemationWhitelabelConfig;\n}\n\nexport interface DefinePluginOptions {\n  readonly name?: string;\n  readonly pluginPackageId?: string;\n  readonly nodes?: ReadonlyArray<DefinedNode<string, Record<string, unknown>, unknown, unknown>>;\n  readonly credentials?: ReadonlyArray<AnyCredentialType>;\n  readonly register?: (context: CodemationPluginContext) => void | Promise<void>;\n  readonly sandbox?: DefineCodemationAppOptions & Readonly<{ workflows?: ReadonlyArray<WorkflowDefinition> }>;\n}\n\nclass CodemationAuthoringConfigFactory {\n  static createApp(options: DefineCodemationAppOptions): CodemationConfig {\n    const appDefinition = this.createAppDefinition(options);\n    const credentialTypes = [...(options.credentialTypes ?? []), ...(options.credentials ?? [])];\n    const register = this.composeAppRegister(options.register, options.nodes);\n    const { workflows, workflowDiscovery, plugins, runtime, log } = options;\n    return {\n      workflows,\n      workflowDiscovery,\n      plugins,\n      runtime,\n      log,\n      app: appDefinition,\n      credentialTypes,\n      register,\n    };\n  }\n\n  static createPlugin(\n    options: DefinePluginOptions,\n  ): CodemationPlugin & Readonly<{ sandbox?: DefinePluginOptions[\"sandbox\"] }> {\n    return {\n      pluginPackageId: options.pluginPackageId,\n      sandbox: options.sandbox,\n      async register(context: CodemationPluginContext): Promise<void> {\n        for (const nodeDefinition of options.nodes ?? []) {\n          nodeDefinition.register(context);\n        }\n        for (const credential of options.credentials ?? []) {\n          context.registerCredentialType(credential);\n        }\n        await options.register?.(context);\n      },\n    };\n  }\n\n  private static createAppDefinition(options: DefineCodemationAppOptions): CodemationAppDefinition | undefined {\n    const scheduler = this.createSchedulerConfig(options.execution);\n    const database = this.createDatabaseConfig(options.database);\n    const whitelabel = this.createWhitelabel(options.name, options.whitelabel);\n    if (!options.auth && !database && !scheduler && !whitelabel) {\n      return undefined;\n    }\n    return {\n      auth: options.auth,\n      database,\n      scheduler,\n      whitelabel,\n    };\n  }\n\n  private static createDatabaseConfig(\n    database: FriendlyCodemationDatabaseConfig | undefined,\n  ): CodemationDatabaseConfig | undefined {\n    if (!database) {\n      return undefined;\n    }\n    if (database.kind === \"sqlite\") {\n      return {\n        kind: \"sqlite\",\n        sqliteFilePath: database.filePath,\n      };\n    }\n    return {\n      kind: \"postgresql\",\n      url: database.url,\n    };\n  }\n\n  private static createSchedulerConfig(\n    execution: FriendlyCodemationExecutionConfig | undefined,\n  ): CodemationAppSchedulerConfig | undefined {\n    if (!execution) {\n      return undefined;\n    }\n    return {\n      kind: execution.mode,\n      queuePrefix: execution.queuePrefix,\n      workerQueues: execution.workerQueues,\n      redisUrl: execution.redisUrl,\n    };\n  }\n\n  private static createWhitelabel(\n    name: string | undefined,\n    whitelabel: CodemationWhitelabelConfig | undefined,\n  ): CodemationWhitelabelConfig | undefined {\n    if (!name && !whitelabel) {\n      return undefined;\n    }\n    return {\n      productName: name ?? whitelabel?.productName,\n      logoPath: whitelabel?.logoPath,\n    };\n  }\n\n  private static composeAppRegister(\n    register: ((context: CodemationAppContext) => void) | undefined,\n    nodes: ReadonlyArray<DefinedNode<string, Record<string, unknown>, unknown, unknown>> | undefined,\n  ): ((context: CodemationAppContext) => void) | undefined {\n    if (!register && (!nodes || nodes.length === 0)) {\n      return undefined;\n    }\n    return (context: CodemationAppContext) => {\n      for (const nodeDefinition of nodes ?? []) {\n        nodeDefinition.register(context);\n      }\n      register?.(context);\n    };\n  }\n}\n\nexport function defineCodemationApp(options: DefineCodemationAppOptions): CodemationConfig {\n  return CodemationAuthoringConfigFactory.createApp(options);\n}\n\nexport function definePlugin(\n  options: DefinePluginOptions,\n): CodemationPlugin & Readonly<{ sandbox?: DefinePluginOptions[\"sandbox\"] }> {\n  return CodemationAuthoringConfigFactory.createPlugin(options);\n}\n"],"mappings":";AAgDA,IAAM,mCAAN,MAAuC;CACrC,OAAO,UAAU,SAAuD;EACtE,MAAM,gBAAgB,KAAK,oBAAoB,QAAQ;EACvD,MAAM,kBAAkB,CAAC,GAAI,QAAQ,mBAAmB,EAAE,EAAG,GAAI,QAAQ,eAAe,EAAE,CAAE;EAC5F,MAAM,WAAW,KAAK,mBAAmB,QAAQ,UAAU,QAAQ,MAAM;EACzE,MAAM,EAAE,WAAW,mBAAmB,SAAS,SAAS,QAAQ;AAChE,SAAO;GACL;GACA;GACA;GACA;GACA;GACA,KAAK;GACL;GACA;GACD;;CAGH,OAAO,aACL,SAC2E;AAC3E,SAAO;GACL,iBAAiB,QAAQ;GACzB,SAAS,QAAQ;GACjB,MAAM,SAAS,SAAiD;AAC9D,SAAK,MAAM,kBAAkB,QAAQ,SAAS,EAAE,CAC9C,gBAAe,SAAS,QAAQ;AAElC,SAAK,MAAM,cAAc,QAAQ,eAAe,EAAE,CAChD,SAAQ,uBAAuB,WAAW;AAE5C,UAAM,QAAQ,WAAW,QAAQ;;GAEpC;;CAGH,OAAe,oBAAoB,SAA0E;EAC3G,MAAM,YAAY,KAAK,sBAAsB,QAAQ,UAAU;EAC/D,MAAM,WAAW,KAAK,qBAAqB,QAAQ,SAAS;EAC5D,MAAM,aAAa,KAAK,iBAAiB,QAAQ,MAAM,QAAQ,WAAW;AAC1E,MAAI,CAAC,QAAQ,QAAQ,CAAC,YAAY,CAAC,aAAa,CAAC,WAC/C;AAEF,SAAO;GACL,MAAM,QAAQ;GACd;GACA;GACA;GACD;;CAGH,OAAe,qBACb,UACsC;AACtC,MAAI,CAAC,SACH;AAEF,MAAI,SAAS,SAAS,SACpB,QAAO;GACL,MAAM;GACN,gBAAgB,SAAS;GAC1B;AAEH,SAAO;GACL,MAAM;GACN,KAAK,SAAS;GACf;;CAGH,OAAe,sBACb,WAC0C;AAC1C,MAAI,CAAC,UACH;AAEF,SAAO;GACL,MAAM,UAAU;GAChB,aAAa,UAAU;GACvB,cAAc,UAAU;GACxB,UAAU,UAAU;GACrB;;CAGH,OAAe,iBACb,MACA,YACwC;AACxC,MAAI,CAAC,QAAQ,CAAC,WACZ;AAEF,SAAO;GACL,aAAa,QAAQ,YAAY;GACjC,UAAU,YAAY;GACvB;;CAGH,OAAe,mBACb,UACA,OACuD;AACvD,MAAI,CAAC,aAAa,CAAC,SAAS,MAAM,WAAW,GAC3C;AAEF,UAAQ,YAAkC;AACxC,QAAK,MAAM,kBAAkB,SAAS,EAAE,CACtC,gBAAe,SAAS,QAAQ;AAElC,cAAW,QAAQ;;;;AAKzB,SAAgB,oBAAoB,SAAuD;AACzF,QAAO,iCAAiC,UAAU,QAAQ;;AAG5D,SAAgB,aACd,SAC2E;AAC3E,QAAO,iCAAiC,aAAa,QAAQ"}

package/dist/{CodemationConfigNormalizer-DIc-LYqW.d.ts → CodemationConfigNormalizer-kJmyHNDp.d.ts}

@@ -1,4 +1,4 @@
-import { C as CodemationContainerRegistration, a as CodemationConfig } from "./CodemationConfig-9PkOBCh-.js";
+import { C as CodemationContainerRegistration, m as CodemationConfig } from "./CodemationAppContext-Vtn0U2Ga.js";
 
 //#region src/presentation/config/CodemationConfigNormalizer.d.ts
 type NormalizedCodemationConfig = CodemationConfig & Readonly<{
@@ -6,4 +6,4 @@ type NormalizedCodemationConfig = CodemationConfig & Readonly<{
 }>;
 //#endregion
 export { NormalizedCodemationConfig as t };
-//# sourceMappingURL=CodemationConfigNormalizer-DIc-LYqW.d.ts.map
+//# sourceMappingURL=CodemationConfigNormalizer-kJmyHNDp.d.ts.map

package/dist/{CodemationConsumerConfigLoader-CeW4bnOg.d.ts → CodemationConsumerConfigLoader-BvTE-7tX.d.ts}

@@ -1,4 +1,4 @@
-import { t as NormalizedCodemationConfig } from "./CodemationConfigNormalizer-DIc-LYqW.js";
+import { t as NormalizedCodemationConfig } from "./CodemationConfigNormalizer-kJmyHNDp.js";
 
 //#region src/presentation/server/CodemationConsumerAppResolver.d.ts
 type CodemationConsumerApp = Readonly<{
@@ -63,4 +63,4 @@ declare class CodemationConsumerConfigLoader {
 }
 //#endregion
 export { CodemationConsumerAppResolver as i, CodemationConsumerConfigResolution as n, CodemationConsumerApp as r, CodemationConsumerConfigLoader as t };
-//# sourceMappingURL=CodemationConsumerConfigLoader-CeW4bnOg.d.ts.map
+//# sourceMappingURL=CodemationConsumerConfigLoader-BvTE-7tX.d.ts.map

package/dist/{CodemationConsumerConfigLoader-D6LFSlp5.js → CodemationConsumerConfigLoader-DovlxZNb.js}

@@ -1,4 +1,4 @@
-import { s as logLevelPolicyFactory, t as ServerLoggerFactory } from "./ServerLoggerFactory-BltIIDfQ.js";
+import { s as logLevelPolicyFactory, t as ServerLoggerFactory } from "./ServerLoggerFactory-CsNW5qhz.js";
 import { access, readdir, stat } from "node:fs/promises";
 import path from "node:path";
 import { pathToFileURL } from "node:url";
@@ -490,4 +490,4 @@ var CodemationConsumerConfigLoader = class CodemationConsumerConfigLoader {
 
 //#endregion
 export { CodemationConfigNormalizer as a, CodemationConsumerAppResolver as i, WorkflowDiscoveryPathSegmentsComputer as n, WorkflowModulePathFinder as r, CodemationConsumerConfigLoader as t };
-//# sourceMappingURL=CodemationConsumerConfigLoader-D6LFSlp5.js.map
+//# sourceMappingURL=CodemationConsumerConfigLoader-DovlxZNb.js.map