@codemation/host 0.2.5 → 0.3.0

package/dist/CodemationPluginListMerger-PSTtEQjC.d.ts

@@ -0,0 +1,674 @@
+import { $ as PersistedRunState, B as NodeExecutionRequestHandler, H as WorkflowRepository, I as WorkflowDefinition, K as RunEvent, L as WorkflowId, M as RunId, Q as WorkflowRunDetailDto, R as BinaryStorage, U as Container, V as NodeExecutionScheduler, W as TypeToken, X as WorkflowActivationPolicy, at as TelemetryMetricRecord, et as RunCurrentState, it as TelemetryAttributes, j as PersistedRunPolicySnapshot, l as AnyCredentialType, n as Engine, nt as RunSummary, ot as TelemetrySpanEventRecord, q as RunEventBus, rt as TelemetryArtifactAttachment, st as Clock, tt as RunPruneCandidate } from "./index-CeS2saCe.js";
+import { C as CodemationContainerRegistration, l as CodemationPluginPackageMetadata, o as CodemationPlugin, r as AppConfig } from "./CodemationAppContext-P7P-xZhQ.js";
+import { a as CodemationAuthConfig, l as Logger, t as CodemationWhitelabelConfig, u as LoggerFactory } from "./CodemationWhitelabelConfig-D5rYcLlj.js";
+import { t as LogLevelPolicy } from "./LogLevelPolicy-CkiJAH75.js";
+import { t as CredentialStore } from "./CredentialServices-0Hk8RFY1.js";
+import { n as PrismaMigrationDeployer, r as PrismaDatabaseClient } from "./AppConfigFactory-Dq7ttwQ_.js";
+import "reflect-metadata";
+import { Hono } from "hono";
+
+//#region src/application/bus/Command.d.ts
+declare abstract class Command<TResult> {
+  protected readonly __resultType?: TResult;
+}
+//#endregion
+//#region src/application/bus/CommandBus.d.ts
+interface CommandBus {
+  execute<TResult>(command: Command<TResult>): Promise<TResult>;
+}
+//#endregion
+//#region src/application/bus/Query.d.ts
+declare abstract class Query<TResult> {
+  protected readonly __resultType?: TResult;
+}
+//#endregion
+//#region src/application/bus/QueryBus.d.ts
+interface QueryBus {
+  execute<TResult>(query: Query<TResult>): Promise<TResult>;
+}
+//#endregion
+//#region src/infrastructure/config/CodemationPluginRegistrar.d.ts
+declare class CodemationPluginRegistrar {
+  apply(args: Readonly<{
+    plugins: ReadonlyArray<CodemationPlugin>;
+    container: Container;
+    appConfig: AppConfig;
+    registerCredentialType: (type: AnyCredentialType) => void;
+    loggerFactory: LoggerFactory;
+  }>): Promise<void>;
+}
+//#endregion
+//#region src/application/contracts/WorkflowWebsocketMessage.d.ts
+type WorkflowWebsocketMessage = Readonly<{
+  kind: "event";
+  event: RunEvent;
+}> | Readonly<{
+  kind: "workflowChanged";
+  workflowId: string;
+}> | Readonly<{
+  kind: "devBuildStarted";
+  workflowId: string;
+  buildVersion?: string;
+}> | Readonly<{
+  kind: "devBuildCompleted";
+  workflowId: string;
+  buildVersion: string;
+}> | Readonly<{
+  kind: "devBuildFailed";
+  workflowId: string;
+  message: string;
+}>;
+//#endregion
+//#region src/application/websocket/WorkflowWebsocketPublisher.d.ts
+interface WorkflowWebsocketPublisher {
+  publishToRoom(roomId: string, message: WorkflowWebsocketMessage): Promise<void>;
+}
+//#endregion
+//#region src/presentation/websocket/WorkflowWebsocketServer.d.ts
+declare class WorkflowWebsocketServer implements WorkflowWebsocketPublisher {
+  private readonly port;
+  private readonly bindHost;
+  private readonly logger;
+  private websocketServer;
+  private readonly sockets;
+  private readonly roomIdsBySocket;
+  private started;
+  constructor(port: number, bindHost: string, logger: Logger);
+  start(): Promise<void>;
+  stop(): Promise<void>;
+  publishToRoom(roomId: string, message: WorkflowWebsocketMessage): Promise<void>;
+  private connect;
+  private handleMessage;
+  private awaitListening;
+  private closeAfterFailedStart;
+  private parseClientMessage;
+}
+//#endregion
+//#region src/bootstrap/CodemationContainerRegistrationRegistrar.d.ts
+declare class CodemationContainerRegistrationRegistrar {
+  apply(container: Container, registrations: ReadonlyArray<CodemationContainerRegistration<unknown>>): void;
+  private applyRegistration;
+  private isValueRegistration;
+  private isClassRegistration;
+}
+//#endregion
+//#region src/bootstrap/AppContainerFactory.d.ts
+type AppContainerInputs = Readonly<{
+  appConfig: AppConfig;
+  sharedWorkflowWebsocketServer: WorkflowWebsocketServer | null;
+}>;
+declare class AppContainerFactory {
+  private readonly containerRegistrationRegistrar;
+  private readonly pluginRegistrar;
+  private static readonly queryHandlers;
+  private static readonly commandHandlers;
+  private static readonly honoRouteRegistrars;
+  constructor(containerRegistrationRegistrar?: CodemationContainerRegistrationRegistrar, pluginRegistrar?: CodemationPluginRegistrar);
+  create(inputs: AppContainerInputs): Promise<Container>;
+  private collectCredentialTypes;
+  private applyPlugins;
+  private registerCredentialTypes;
+  private registerConfiguredRegistrations;
+  private registerCoreInfrastructure;
+  private registerRepositoriesAndBuses;
+  private registerApplicationServicesAndRoutes;
+  private registerOperationalInfrastructure;
+  private registerRuntimeInfrastructure;
+  private resolvePrismaOwnership;
+  private registerRuntimeNodeActivationScheduler;
+  private createWorkflowPolicyRuntimeDefaults;
+  private createBinaryStorage;
+  private createRuntimeSummary;
+  private requireRedisUrl;
+  private readPositiveInteger;
+  private synchronizeLiveWorkflowRepository;
+}
+//#endregion
+//#region src/bootstrap/AppContainerLifecycle.d.ts
+declare class AppContainerLifecycle {
+  private readonly container;
+  private readonly ownedPrismaClient;
+  constructor(container: Container, ownedPrismaClient: PrismaDatabaseClient | null);
+  stop(args?: Readonly<{
+    stopWebsocketServer?: boolean;
+  }>): Promise<void>;
+}
+//#endregion
+//#region src/bootstrap/runtime/DatabaseMigrations.d.ts
+declare class DatabaseMigrations {
+  private readonly appConfig;
+  private readonly prismaMigrationDeployer;
+  constructor(appConfig: AppConfig, prismaMigrationDeployer: PrismaMigrationDeployer);
+  migrate(): Promise<void>;
+}
+//#endregion
+//#region src/domain/workflows/WorkflowActivationRepository.d.ts
+type WorkflowActivationRow = Readonly<{
+  workflowId: string;
+  isActive: boolean;
+}>;
+interface WorkflowActivationRepository {
+  loadAll(): Promise<ReadonlyArray<WorkflowActivationRow>>;
+  upsert(workflowId: string, active: boolean): Promise<void>;
+}
+//#endregion
+//#region src/infrastructure/persistence/RuntimeWorkflowActivationPolicy.d.ts
+/**
+ * In-memory activation map: missing workflow id ⇒ inactive. Hydrated from persistence at startup and updated on command.
+ */
+declare class RuntimeWorkflowActivationPolicy implements WorkflowActivationPolicy {
+  private readonly activeByWorkflowId;
+  hydrateFromRepository(repository: WorkflowActivationRepository): Promise<void>;
+  set(workflowId: string, active: boolean): void;
+  isActive(workflowId: WorkflowId): boolean;
+}
+//#endregion
+//#region src/domain/telemetry/TelemetryContracts.d.ts
+type TelemetrySpanStatus = "running" | "completed" | "failed";
+type TelemetrySpanKind = "internal" | "client";
+interface TelemetryTraceContext {
+  readonly runId: string;
+  readonly workflowId: string;
+  readonly traceId: string;
+  readonly rootSpanId: string;
+  readonly serviceName?: string;
+  readonly createdAt: string;
+  readonly expiresAt?: string;
+}
+interface TelemetrySpanRecord {
+  readonly traceId: string;
+  readonly spanId: string;
+  readonly parentSpanId?: string;
+  readonly runId: string;
+  readonly workflowId: string;
+  readonly nodeId?: string;
+  readonly activationId?: string;
+  readonly connectionInvocationId?: string;
+  readonly name: string;
+  readonly kind: TelemetrySpanKind;
+  readonly status?: TelemetrySpanStatus;
+  readonly statusMessage?: string;
+  readonly startTime?: string;
+  readonly endTime?: string;
+  readonly workflowFolder?: string;
+  readonly nodeType?: string;
+  readonly nodeRole?: string;
+  readonly modelName?: string;
+  readonly attributes?: TelemetryAttributes;
+  readonly events?: ReadonlyArray<TelemetrySpanEventRecord>;
+  readonly retentionExpiresAt?: string;
+}
+interface TelemetrySpanUpsert {
+  readonly traceId: string;
+  readonly spanId: string;
+  readonly parentSpanId?: string;
+  readonly runId: string;
+  readonly workflowId: string;
+  readonly nodeId?: string;
+  readonly activationId?: string;
+  readonly connectionInvocationId?: string;
+  readonly name?: string;
+  readonly kind?: TelemetrySpanKind;
+  readonly status?: TelemetrySpanStatus;
+  readonly statusMessage?: string;
+  readonly startTime?: string;
+  readonly endTime?: string;
+  readonly workflowFolder?: string;
+  readonly nodeType?: string;
+  readonly nodeRole?: string;
+  readonly modelName?: string;
+  readonly attributes?: TelemetryAttributes;
+  readonly events?: ReadonlyArray<TelemetrySpanEventRecord>;
+  readonly retentionExpiresAt?: string;
+}
+interface TelemetryArtifactRecord {
+  readonly artifactId: string;
+  readonly traceId: string;
+  readonly spanId: string;
+  readonly runId: string;
+  readonly workflowId: string;
+  readonly nodeId?: string;
+  readonly activationId?: string;
+  readonly kind: string;
+  readonly contentType: string;
+  readonly previewText?: string;
+  readonly previewJson?: unknown;
+  readonly payloadText?: string;
+  readonly payloadJson?: unknown;
+  readonly bytes?: number;
+  readonly truncated?: boolean;
+  readonly createdAt: string;
+  readonly expiresAt?: string;
+  readonly retentionExpiresAt?: string;
+}
+interface TelemetryArtifactWrite extends TelemetryArtifactAttachment {
+  readonly traceId: string;
+  readonly spanId: string;
+  readonly runId: string;
+  readonly workflowId: string;
+  readonly nodeId?: string;
+  readonly activationId?: string;
+  readonly retentionExpiresAt?: string;
+}
+interface TelemetryMetricPointRecord {
+  readonly metricPointId: string;
+  readonly traceId?: string;
+  readonly spanId?: string;
+  readonly runId?: string;
+  readonly workflowId: string;
+  readonly nodeId?: string;
+  readonly activationId?: string;
+  readonly metricName: string;
+  readonly value: number;
+  readonly unit?: string;
+  readonly observedAt: string;
+  readonly workflowFolder?: string;
+  readonly nodeType?: string;
+  readonly nodeRole?: string;
+  readonly modelName?: string;
+  readonly dimensions?: TelemetryAttributes;
+  readonly retentionExpiresAt?: string;
+}
+interface TelemetryMetricPointWrite extends TelemetryMetricRecord {
+  readonly traceId?: string;
+  readonly spanId?: string;
+  readonly runId?: string;
+  readonly workflowId: string;
+  readonly nodeId?: string;
+  readonly activationId?: string;
+  readonly observedAt: string;
+  readonly workflowFolder?: string;
+  readonly nodeType?: string;
+  readonly nodeRole?: string;
+  readonly modelName?: string;
+  readonly retentionExpiresAt?: string;
+}
+interface TelemetrySpanListQuery {
+  readonly traceId?: string;
+  readonly runId?: string;
+  readonly runIds?: ReadonlyArray<string>;
+  readonly workflowId?: string;
+  readonly workflowIds?: ReadonlyArray<string>;
+  readonly statuses?: ReadonlyArray<TelemetrySpanStatus>;
+  readonly names?: ReadonlyArray<string>;
+  readonly modelNames?: ReadonlyArray<string>;
+  readonly startTimeGte?: string;
+  readonly endTimeLte?: string;
+  readonly limit?: number;
+}
+interface TelemetryMetricPointListQuery {
+  readonly traceId?: string;
+  readonly runId?: string;
+  readonly runIds?: ReadonlyArray<string>;
+  readonly workflowId?: string;
+  readonly workflowIds?: ReadonlyArray<string>;
+  readonly nodeId?: string;
+  readonly metricNames?: ReadonlyArray<string>;
+  readonly modelNames?: ReadonlyArray<string>;
+  readonly observedAtGte?: string;
+  readonly observedAtLte?: string;
+  readonly limit?: number;
+}
+interface TelemetryPruneArgs {
+  readonly nowIso: string;
+  readonly limit?: number;
+}
+interface RunTraceContextRepository {
+  load(runId: string): Promise<TelemetryTraceContext | undefined>;
+  getOrCreate(args: Readonly<{
+    runId: string;
+    workflowId: string;
+    serviceName?: string;
+  }>): Promise<TelemetryTraceContext>;
+  upsertExpiry(args: Readonly<{
+    runId: string;
+    expiresAt?: string;
+  }>): Promise<void>;
+}
+interface TelemetrySpanStore {
+  upsert(record: TelemetrySpanUpsert): Promise<void>;
+  list(args?: TelemetrySpanListQuery): Promise<ReadonlyArray<TelemetrySpanRecord>>;
+  listByTraceId(traceId: string): Promise<ReadonlyArray<TelemetrySpanRecord>>;
+  pruneExpired(args: TelemetryPruneArgs): Promise<number>;
+}
+interface TelemetryArtifactStore {
+  save(record: TelemetryArtifactWrite): Promise<TelemetryArtifactRecord>;
+  listByTraceId(traceId: string): Promise<ReadonlyArray<TelemetryArtifactRecord>>;
+  pruneExpired(args: TelemetryPruneArgs): Promise<number>;
+}
+interface TelemetryMetricPointStore {
+  save(record: TelemetryMetricPointWrite): Promise<TelemetryMetricPointRecord>;
+  list(args?: TelemetryMetricPointListQuery): Promise<ReadonlyArray<TelemetryMetricPointRecord>>;
+  pruneExpired(args: TelemetryPruneArgs): Promise<number>;
+}
+interface TelemetryExporter {
+  exportSpans(spans: ReadonlyArray<TelemetrySpanRecord>): Promise<void>;
+}
+//#endregion
+//#region src/domain/runs/WorkflowRunRepository.d.ts
+interface WorkflowRunRepository {
+  load(runId: string): Promise<PersistedRunState | undefined>;
+  loadRunDetail?(runId: string): Promise<WorkflowRunDetailDto | undefined>;
+  save(state: PersistedRunState): Promise<void>;
+  listRuns(args: Readonly<{
+    workflowId?: string;
+    limit?: number;
+  }>): Promise<ReadonlyArray<RunSummary>>;
+  listRunsOlderThan?(args: Readonly<{
+    nowIso: string;
+    defaultRetentionSeconds: number;
+    limit?: number;
+  }>): Promise<ReadonlyArray<RunPruneCandidate>>;
+  listBinaryStorageKeys?(runId: RunId): Promise<ReadonlyArray<string>>;
+  deleteRun(runId: RunId): Promise<void>;
+}
+//#endregion
+//#region src/application/telemetry/OtelIdentityFactory.d.ts
+declare class OtelIdentityFactory {
+  createTraceId(runId: string): string;
+  createRootSpanId(runId: string): string;
+  createNodeSpanId(activationId: string): string;
+  createConnectionInvocationSpanId(invocationId: string): string;
+  createArtifactId(): string;
+  createEphemeralSpanId(): string;
+  private hashToHex;
+  private ensureNonZeroHex;
+}
+//#endregion
+//#region src/domain/workflows/WorkflowDefinitionRepository.d.ts
+interface WorkflowDefinitionRepository {
+  listDefinitions(): Promise<ReadonlyArray<WorkflowDefinition>>;
+  getDefinition(workflowId: string): Promise<WorkflowDefinition | undefined>;
+  resolveSnapshot(args: Readonly<{
+    workflowId: string;
+    workflowSnapshot?: unknown;
+  }>): Promise<WorkflowDefinition | undefined>;
+}
+//#endregion
+//#region src/application/telemetry/TelemetryEnricherChain.d.ts
+interface TelemetryNodeMetadata {
+  readonly workflowFolder?: string;
+  readonly nodeType?: string;
+  readonly nodeRole?: string;
+}
+declare class TelemetryEnricherChain {
+  private readonly workflowDefinitionRepository;
+  private readonly definitionsByWorkflowId;
+  constructor(workflowDefinitionRepository: WorkflowDefinitionRepository);
+  enrichNode(args: Readonly<{
+    workflowId: string;
+    nodeId: string;
+  }>): Promise<TelemetryNodeMetadata>;
+  enrichRun(workflowId: string): Promise<Readonly<{
+    workflowFolder?: string;
+  }>>;
+  private loadDefinition;
+  private toWorkflowFolder;
+  private toNodeType;
+  private toNodeRole;
+}
+//#endregion
+//#region src/application/telemetry/TelemetryRetentionTimestampFactory.d.ts
+declare class TelemetryRetentionTimestampFactory {
+  createSpanExpiry(policySnapshot: PersistedRunPolicySnapshot | undefined, observedAt: Date): string | undefined;
+  createArtifactExpiry(policySnapshot: PersistedRunPolicySnapshot | undefined, observedAt: Date): string | undefined;
+  createMetricExpiry(policySnapshot: PersistedRunPolicySnapshot | undefined, observedAt: Date): string | undefined;
+  createTraceContextExpiry(policySnapshot: PersistedRunPolicySnapshot | undefined, observedAt: Date): string | undefined;
+  private createExpiry;
+}
+//#endregion
+//#region src/application/telemetry/RunEventBusTelemetryReporter.d.ts
+declare class RunEventBusTelemetryReporter {
+  private readonly runEventBus;
+  private readonly runTraceContextRepository;
+  private readonly workflowRunRepository;
+  private readonly telemetrySpanStore;
+  private readonly telemetryEnricherChain;
+  private readonly telemetryRetentionTimestampFactory;
+  private readonly otelIdentityFactory;
+  private subscription;
+  constructor(runEventBus: RunEventBus, runTraceContextRepository: RunTraceContextRepository, workflowRunRepository: WorkflowRunRepository, telemetrySpanStore: TelemetrySpanStore, telemetryEnricherChain: TelemetryEnricherChain, telemetryRetentionTimestampFactory: TelemetryRetentionTimestampFactory, otelIdentityFactory: OtelIdentityFactory);
+  start(): Promise<void>;
+  stop(): Promise<void>;
+  private handleEvent;
+  private handleRunCreated;
+  private handleRunSaved;
+  private handleNodeSnapshot;
+  private createNodeSpanUpsert;
+  private loadPolicySnapshot;
+}
+//#endregion
+//#region src/application/websocket/WorkflowRunEventWebsocketRelay.d.ts
+declare class WorkflowRunEventWebsocketRelay {
+  private readonly workflowWebsocketPublisher;
+  private readonly runEventBus;
+  private subscription;
+  constructor(workflowWebsocketPublisher: WorkflowWebsocketPublisher, runEventBus: RunEventBus);
+  start(): Promise<void>;
+  stop(): Promise<void>;
+}
+//#endregion
+//#region src/application/logging/LogFilter.d.ts
+type LogFilter = (entry: Readonly<{
+  scope: string;
+  level: "info" | "warn" | "error" | "debug";
+  message: string;
+}>) => boolean;
+//#endregion
+//#region src/infrastructure/logging/LogLevelPolicyFactory.d.ts
+/**
+ * Process-wide {@link LogLevelPolicy} singleton for server and browser loggers.
+ * Plain class (no `@injectable` from `@codemation/core`): client components import this file; decorating would pull core into the browser bundle.
+ */
+declare class LogLevelPolicyFactory {
+  private readonly policy;
+  create(): LogLevelPolicy;
+}
+/** Shared factory for call sites outside the DI container (e.g. next-host bootstrap). */
+declare const logLevelPolicyFactory: LogLevelPolicyFactory;
+//#endregion
+//#region src/infrastructure/logging/ServerLoggerFactory.d.ts
+declare class ServerLoggerFactory implements LoggerFactory {
+  private readonly logLevelPolicyFactory;
+  constructor(logLevelPolicyFactory: LogLevelPolicyFactory);
+  create(scope: string): Logger;
+  createFiltered(scope: string, filter: LogFilter): Logger;
+  createPerformanceDiagnostics(scope: string): Logger;
+}
+//#endregion
+//#region src/application/runs/WorkflowRunRetentionPruneScheduler.d.ts
+/**
+ * Periodically deletes terminal workflow runs whose age exceeds the effective retention
+ * (`policySnapshot.retentionSeconds` or `CODEMATION_RUN_RETENTION_DEFAULT_SECONDS`),
+ * removes binary blobs referenced from run state via {@link BinaryStorage}, and
+ * independently prunes spans, artifacts, and metric points once their own retention
+ * timestamps expire.
+ */
+declare class WorkflowRunRetentionPruneScheduler {
+  private readonly clock;
+  private readonly runs;
+  private readonly binaryStorage;
+  private readonly telemetrySpanStore;
+  private readonly telemetryArtifactStore;
+  private readonly telemetryMetricPointStore;
+  private readonly appConfig;
+  private static readonly defaultIntervalMs;
+  private timer;
+  private readonly logger;
+  constructor(clock: Clock, runs: WorkflowRunRepository, binaryStorage: BinaryStorage, telemetrySpanStore: TelemetrySpanStore, telemetryArtifactStore: TelemetryArtifactStore, telemetryMetricPointStore: TelemetryMetricPointStore, appConfig: AppConfig, loggerFactory: ServerLoggerFactory);
+  start(): void;
+  stop(): void;
+  /** Exposed for tests; production path is the interval started by {@link start}. */
+  runOnce(): Promise<void>;
+  private runScheduledTick;
+  private loadStorageKeysFromRunStateFallback;
+  private collectStorageKeysFromValue;
+}
+//#endregion
+//#region src/bootstrap/runtime/FrontendRuntime.d.ts
+declare class FrontendRuntime {
+  private readonly appConfig;
+  private readonly databaseMigrations;
+  private readonly runtimeWorkflowActivationPolicy;
+  private readonly workflowActivationRepository;
+  private readonly workflowRepository;
+  private readonly workflowWebsocketServer;
+  private readonly workflowRunEventWebsocketRelay;
+  private readonly runEventBusTelemetryReporter;
+  private readonly workflowRunRetentionPruneScheduler;
+  private readonly engine;
+  constructor(appConfig: AppConfig, databaseMigrations: DatabaseMigrations, runtimeWorkflowActivationPolicy: RuntimeWorkflowActivationPolicy, workflowActivationRepository: WorkflowActivationRepository, workflowRepository: WorkflowRepository, workflowWebsocketServer: WorkflowWebsocketServer, workflowRunEventWebsocketRelay: WorkflowRunEventWebsocketRelay, runEventBusTelemetryReporter: RunEventBusTelemetryReporter, workflowRunRetentionPruneScheduler: WorkflowRunRetentionPruneScheduler, engine: Engine);
+  start(args?: Readonly<{
+    skipPresentationServers?: boolean;
+  }>): Promise<void>;
+}
+//#endregion
+//#region src/infrastructure/scheduler/WorkerRuntimeScheduler.d.ts
+type WorkerRuntimeHandle = Readonly<{
+  stop: () => Promise<void>;
+}>;
+interface WorkerRuntimeScheduler extends NodeExecutionScheduler {
+  createWorker(args: Readonly<{
+    queues: ReadonlyArray<string>;
+    requestHandler: NodeExecutionRequestHandler;
+  }>): WorkerRuntimeHandle;
+  close(): Promise<void>;
+}
+//#endregion
+//#region src/bootstrap/runtime/WorkerRuntime.d.ts
+declare class WorkerRuntime {
+  private readonly appConfig;
+  private readonly databaseMigrations;
+  private readonly runtimeWorkflowActivationPolicy;
+  private readonly workflowActivationRepository;
+  private readonly workflowRepository;
+  private readonly engine;
+  private readonly runEventBusTelemetryReporter;
+  private readonly workflowRunRetentionPruneScheduler;
+  private readonly scheduler;
+  private readonly lifecycle;
+  constructor(appConfig: AppConfig, databaseMigrations: DatabaseMigrations, runtimeWorkflowActivationPolicy: RuntimeWorkflowActivationPolicy, workflowActivationRepository: WorkflowActivationRepository, workflowRepository: WorkflowRepository, engine: Engine, runEventBusTelemetryReporter: RunEventBusTelemetryReporter, workflowRunRetentionPruneScheduler: WorkflowRunRetentionPruneScheduler, scheduler: WorkerRuntimeScheduler, lifecycle: AppContainerLifecycle);
+  start(queues: ReadonlyArray<string>): Promise<WorkerRuntimeHandle>;
+}
+//#endregion
+//#region src/application/auth/AuthenticatedPrincipal.d.ts
+type AuthenticatedPrincipal = Readonly<{
+  id: string;
+  email: string | null;
+  name: string | null;
+}>;
+//#endregion
+//#region src/application/auth/SessionVerifier.d.ts
+interface SessionVerifier {
+  verify(request: Request): Promise<AuthenticatedPrincipal | null>;
+}
+//#endregion
+//#region src/application/bus/CommandHandler.d.ts
+declare abstract class CommandHandler<TCommand extends Command<TResult>, TResult> {
+  abstract execute(command: TCommand): Promise<TResult>;
+}
+//#endregion
+//#region src/application/bus/DomainEvent.d.ts
+declare abstract class DomainEvent {}
+//#endregion
+//#region src/application/bus/DomainEventBus.d.ts
+interface DomainEventBus {
+  publish(event: DomainEvent): Promise<void>;
+}
+//#endregion
+//#region src/application/bus/DomainEventHandler.d.ts
+declare abstract class DomainEventHandler<TEvent extends DomainEvent> {
+  abstract handle(event: TEvent): Promise<void>;
+}
+//#endregion
+//#region src/application/bus/QueryHandler.d.ts
+declare abstract class QueryHandler<TQuery extends Query<TResult>, TResult> {
+  abstract execute(query: TQuery): Promise<TResult>;
+}
+//#endregion
+//#region src/domain/workflows/WorkflowDebuggerOverlayState.d.ts
+type WorkflowDebuggerOverlayState = Readonly<{
+  workflowId: string;
+  updatedAt: string;
+  copiedFromRunId?: string;
+  currentState: RunCurrentState;
+}>;
+//#endregion
+//#region src/domain/workflows/WorkflowDebuggerOverlayRepository.d.ts
+interface WorkflowDebuggerOverlayRepository {
+  load(workflowId: string): Promise<WorkflowDebuggerOverlayState | undefined>;
+  save(state: WorkflowDebuggerOverlayState): Promise<void>;
+}
+//#endregion
+//#region src/presentation/http/hono/HonoApiRouteRegistrar.d.ts
+interface HonoApiRouteRegistrar {
+  register(app: Hono): void;
+}
+//#endregion
+//#region src/applicationTokens.d.ts
+declare const ApplicationTokens: {
+  readonly CodemationAuthConfig: TypeToken<CodemationAuthConfig | undefined>;
+  readonly CodemationWhitelabelConfig: TypeToken<CodemationWhitelabelConfig>;
+  readonly AppConfig: TypeToken<AppConfig>;
+  readonly WebSocketPort: TypeToken<number>;
+  readonly WebSocketBindHost: TypeToken<string>;
+  readonly QueryBus: TypeToken<QueryBus>;
+  readonly CommandBus: TypeToken<CommandBus>;
+  readonly DomainEventBus: TypeToken<DomainEventBus>;
+  readonly QueryHandler: TypeToken<QueryHandler<Query<unknown>, unknown>>;
+  readonly CommandHandler: TypeToken<CommandHandler<Command<unknown>, unknown>>;
+  readonly DomainEventHandler: TypeToken<DomainEventHandler<DomainEvent>>;
+  readonly HonoApiRouteRegistrar: TypeToken<HonoApiRouteRegistrar>;
+  readonly WorkflowWebsocketPublisher: TypeToken<WorkflowWebsocketPublisher>;
+  readonly WorkerRuntimeScheduler: TypeToken<WorkerRuntimeScheduler>;
+  readonly WorkflowDefinitionRepository: TypeToken<WorkflowDefinitionRepository>;
+  readonly WorkflowActivationRepository: TypeToken<WorkflowActivationRepository>;
+  readonly WorkflowDebuggerOverlayRepository: TypeToken<WorkflowDebuggerOverlayRepository>;
+  readonly WorkflowRunRepository: TypeToken<WorkflowRunRepository>;
+  readonly LoggerFactory: TypeToken<LoggerFactory>;
+  /**
+   * Opt-in timing/diagnostics logger (`CODEMATION_PERFORMANCE_LOGGING` + normal minimum log level).
+   */
+  readonly PerformanceDiagnosticsLogger: TypeToken<Logger>;
+  readonly CredentialStore: TypeToken<CredentialStore>;
+  readonly RunTraceContextRepository: TypeToken<RunTraceContextRepository>;
+  readonly TelemetrySpanStore: TypeToken<TelemetrySpanStore>;
+  readonly TelemetryArtifactStore: TypeToken<TelemetryArtifactStore>;
+  readonly TelemetryMetricPointStore: TypeToken<TelemetryMetricPointStore>;
+  readonly TelemetryExporter: TypeToken<TelemetryExporter>;
+  readonly PrismaClient: TypeToken<PrismaDatabaseClient>;
+  readonly SessionVerifier: TypeToken<SessionVerifier>;
+  readonly Clock: TypeToken<Clock>;
+};
+//#endregion
+//#region src/bootstrap/CodemationBootstrapRequest.d.ts
+declare class CodemationBootstrapRequest {
+  readonly consumerRoot: string;
+  readonly repoRoot: string;
+  readonly workflowSources: ReadonlyArray<string>;
+  readonly env?: Readonly<NodeJS.ProcessEnv>;
+  constructor(args: Readonly<{
+    consumerRoot: string;
+    repoRoot: string;
+    workflowSources?: ReadonlyArray<string>;
+    env?: Readonly<NodeJS.ProcessEnv>;
+  }>);
+  resolveEnvironment(): NodeJS.ProcessEnv;
+}
+//#endregion
+//#region src/presentation/config/CodemationPluginListMerger.d.ts
+/**
+ * Merges explicitly configured plugins with auto-discovered plugins.
+ * Configured plugins are applied first; discovered plugins fill in gaps.
+ * Plugins discovered from package.json manifests are deduped by npm package name so the same package is not
+ * registered twice when the consumer config lists a discovered plugin explicitly and auto-discovery also finds it.
+ */
+declare class CodemationPluginListMerger {
+  private readonly packageMetadata;
+  constructor(packageMetadata: CodemationPluginPackageMetadata);
+  merge(configuredPlugins: ReadonlyArray<CodemationPlugin>, discoveredPlugins: ReadonlyArray<CodemationPlugin>): ReadonlyArray<CodemationPlugin>;
+  private tryAdd;
+}
+//#endregion
+export { Command as S, AppContainerFactory as _, WorkflowDebuggerOverlayRepository as a, Query as b, FrontendRuntime as c, LogLevelPolicyFactory as d, logLevelPolicyFactory as f, AppContainerLifecycle as g, DatabaseMigrations as h, HonoApiRouteRegistrar as i, WorkflowRunRetentionPruneScheduler as l, WorkflowRunRepository as m, CodemationBootstrapRequest as n, SessionVerifier as o, LogFilter as p, ApplicationTokens as r, WorkerRuntime as s, CodemationPluginListMerger as t, ServerLoggerFactory as u, WorkflowWebsocketServer as v, CommandBus as x, QueryBus as y };
+//# sourceMappingURL=CodemationPluginListMerger-PSTtEQjC.d.ts.map

package/dist/{CredentialServices-BFQD_VN1.d.ts → CredentialServices-0Hk8RFY1.d.ts}

@@ -1,5 +1,5 @@
-import { C as CredentialType, E as CredentialTypeRegistry, F as WorkflowDefinition, S as CredentialSetupStatus, T as CredentialTypeId, V as WorkflowRepository, _ as CredentialMaterialSourceKind, d as CredentialBindingKey, f as CredentialFieldSchema, g as CredentialJsonRecord, h as CredentialInstanceRecord, l as AnyCredentialType, m as CredentialInstanceId, p as CredentialHealth, u as CredentialBinding, v as CredentialOAuth2AuthDefinition, w as CredentialTypeDefinition, x as CredentialSessionService, y as CredentialRequirement } from "./index-Dd6BrWyH.js";
-import { r as AppConfig } from "./CodemationAppContext-KqDoeHqN.js";
+import { C as CredentialType, E as CredentialTypeRegistry, H as WorkflowRepository, I as WorkflowDefinition, S as CredentialSetupStatus, T as CredentialTypeId, _ as CredentialMaterialSourceKind, d as CredentialBindingKey, f as CredentialFieldSchema, g as CredentialJsonRecord, h as CredentialInstanceRecord, l as AnyCredentialType, m as CredentialInstanceId, p as CredentialHealth, u as CredentialBinding, v as CredentialOAuth2AuthDefinition, w as CredentialTypeDefinition, x as CredentialSessionService, y as CredentialRequirement } from "./index-CeS2saCe.js";
+import { r as AppConfig } from "./CodemationAppContext-P7P-xZhQ.js";
 
 //#region src/domain/credentials/CredentialTypeRegistryImpl.d.ts
 declare class CredentialTypeRegistryImpl implements CredentialTypeRegistry {
@@ -298,4 +298,4 @@ type MutableCredentialSessionService = CredentialSessionService & Readonly<{
 }>;
 //#endregion
 export { CredentialInstanceService as a, CredentialSecretCipher as c, CredentialBindingService as i, CredentialFieldEnvOverlayService as l, CredentialType$1 as n, CredentialOAuth2ScopeResolver as o, CredentialRuntimeMaterialService as r, CredentialMaterialResolver as s, CredentialStore as t, CredentialTypeRegistryImpl as u };
-//# sourceMappingURL=CredentialServices-BFQD_VN1.d.ts.map
+//# sourceMappingURL=CredentialServices-0Hk8RFY1.d.ts.map