@codemation/cli 0.0.4 → 0.0.7

package/dist/index.d.ts

@@ -1,6 +1,7 @@
 import { createRequire } from "node:module";
 import "reflect-metadata";
 import { ChildProcess } from "node:child_process";
+import { Hono } from "hono";
 import { ReadableStream } from "node:stream/web";
 import { DependencyContainer as Container, InjectionToken as TypeToken } from "tsyringe";
 import { AnyNull, AnyNullClass, DbNull, DbNullClass, Decimal, JsonNull, JsonNullClass, NullTypes as NullTypes$1, ObjectEnumValue, PrismaClientInitializationError, PrismaClientKnownRequestError, PrismaClientRustPanicError, PrismaClientUnknownRequestError, PrismaClientValidationError, RawValue, Sql, Value, empty, isAnyNull, isDbNull, isJsonNull, isObjectEnumValue, join, raw, sql as sqltag } from "@prisma/client-runtime-utils";
@@ -56,15 +57,123 @@ interface ExponentialRetryPolicySpec {
 }
 //#endregion
 //#region ../core/src/contracts/runTypes.d.ts
+interface RunExecutionOptions {
+  /** Run-intent override: force the inline scheduler and bypass node-level offload decisions. */
+  localOnly?: boolean;
+  /** Marks runs started from webhook handling so orchestration can apply webhook-specific continuation rules. */
+  webhook?: boolean;
+  mode?: "manual" | "debug";
+  sourceWorkflowId?: WorkflowId;
+  sourceRunId?: RunId;
+  derivedFromRunId?: RunId;
+  isMutable?: boolean;
+  /** Set by the engine for this run: 0 = root, 1 = first child subworkflow, … */
+  subworkflowDepth?: number;
+  /** Effective cap after engine policy merge (successful node completions per run). */
+  maxNodeActivations?: number;
+  /** Effective cap after engine policy merge (subworkflow nesting). */
+  maxSubworkflowDepth?: number;
+}
+/** Engine-owned counters persisted with the run (worker-safe). */
+interface EngineRunCounters {
+  completedNodeActivations: number;
+}
+type RunStopCondition = Readonly<{
+  kind: "workflowCompleted";
+}> | Readonly<{
+  kind: "nodeCompleted";
+  nodeId: NodeId;
+}>;
+interface PersistedRunControlState {
+  stopCondition?: RunStopCondition;
+}
+interface PersistedWorkflowSnapshotNode {
+  id: NodeId;
+  kind: NodeKind;
+  name?: string;
+  nodeTokenId: PersistedTokenId;
+  configTokenId: PersistedTokenId;
+  tokenName?: string;
+  configTokenName?: string;
+  config: unknown;
+}
+interface PersistedWorkflowSnapshot {
+  id: WorkflowId;
+  name: string;
+  nodes: ReadonlyArray<PersistedWorkflowSnapshotNode>;
+  edges: ReadonlyArray<Edge>;
+  /** When the snapshot was built from a live workflow definition that configured a workflow error handler. */
+  workflowErrorHandlerConfigured?: boolean;
+  /** Connection metadata for child nodes not in the execution graph (e.g. AI agent attachments). */
+  connections?: ReadonlyArray<WorkflowNodeConnection>;
+}
+type PinnedNodeOutputsByPort = Readonly<Record<OutputPortKey, Items>>;
+interface PersistedMutableNodeState {
+  pinnedOutputsByPort?: PinnedNodeOutputsByPort;
+  lastDebugInput?: Items;
+}
+interface PersistedMutableRunState {
+  nodesById: Readonly<Record<NodeId, PersistedMutableNodeState>>;
+}
 type NodeInputsByPort = Readonly<Record<InputPortKey, Items>>;
+interface RunQueueEntry {
+  nodeId: NodeId;
+  input: Items;
+  toInput?: InputPortKey;
+  batchId?: string;
+  from?: Readonly<{
+    nodeId: NodeId;
+    output: OutputPortKey;
+  }>;
+  collect?: Readonly<{
+    expectedInputs: ReadonlyArray<InputPortKey>;
+    received: Readonly<Record<InputPortKey, Items>>;
+  }>;
+}
 type NodeExecutionStatus = "pending" | "queued" | "running" | "completed" | "failed" | "skipped";
 interface NodeExecutionError {
   message: string;
   name?: string;
   stack?: string;
 }
+interface NodeExecutionSnapshot {
+  runId: RunId;
+  workflowId: WorkflowId;
+  nodeId: NodeId;
+  activationId?: NodeActivationId;
+  parent?: ParentExecutionRef;
+  status: NodeExecutionStatus;
+  usedPinnedOutput?: boolean;
+  queuedAt?: string;
+  startedAt?: string;
+  finishedAt?: string;
+  updatedAt: string;
+  inputsByPort?: NodeInputsByPort;
+  outputs?: NodeOutputs;
+  error?: NodeExecutionError;
+}
 /** Stable id for a single connection invocation row in {@link ConnectionInvocationRecord}. */
 type ConnectionInvocationId = string;
+/**
+ * One logical LLM or tool call under an owning workflow node (e.g. AI agent).
+ * The owning node defines what {@link managedInput} and {@link managedOutput} contain.
+ */
+interface ConnectionInvocationRecord {
+  readonly invocationId: ConnectionInvocationId;
+  readonly runId: RunId;
+  readonly workflowId: WorkflowId;
+  readonly connectionNodeId: NodeId;
+  readonly parentAgentNodeId: NodeId;
+  readonly parentAgentActivationId: NodeActivationId;
+  readonly status: NodeExecutionStatus;
+  readonly managedInput?: JsonValue$1;
+  readonly managedOutput?: JsonValue$1;
+  readonly error?: NodeExecutionError;
+  readonly queuedAt?: string;
+  readonly startedAt?: string;
+  readonly finishedAt?: string;
+  readonly updatedAt: string;
+}
 /** Arguments for appending a {@link ConnectionInvocationRecord} (engine fills run/workflow ids and timestamps). */
 type ConnectionInvocationAppendArgs = Readonly<{
   invocationId: ConnectionInvocationId;
@@ -79,6 +188,40 @@ type ConnectionInvocationAppendArgs = Readonly<{
   startedAt?: string;
   finishedAt?: string;
 }>;
+type RunStatus = "running" | "pending" | "completed" | "failed";
+interface PendingNodeExecution {
+  runId: RunId;
+  activationId: NodeActivationId;
+  workflowId: WorkflowId;
+  nodeId: NodeId;
+  itemsIn: number;
+  inputsByPort: NodeInputsByPort;
+  receiptId: string;
+  queue?: string;
+  batchId?: string;
+  enqueuedAt: string;
+}
+interface PersistedRunState {
+  runId: RunId;
+  workflowId: WorkflowId;
+  startedAt: string;
+  parent?: ParentExecutionRef;
+  executionOptions?: RunExecutionOptions;
+  control?: PersistedRunControlState;
+  workflowSnapshot?: PersistedWorkflowSnapshot;
+  mutableState?: PersistedMutableRunState;
+  /** Frozen at createRun from workflow + runtime defaults for prune/storage decisions. */
+  policySnapshot?: PersistedRunPolicySnapshot;
+  /** Successful node completions so far (for activation budget). */
+  engineCounters?: EngineRunCounters;
+  status: RunStatus;
+  pending?: PendingNodeExecution;
+  queue: RunQueueEntry[];
+  outputsByNode: Record<NodeId, NodeOutputs>;
+  nodeSnapshotsByNodeId: Record<NodeId, NodeExecutionSnapshot>;
+  /** Append-only history of connection invocations (LLM/tool) nested under owning nodes. */
+  connectionInvocations?: ReadonlyArray<ConnectionInvocationRecord>;
+}
 //#endregion
 //#region ../core/src/contracts/runtimeTypes.d.ts
 interface NodeExecutionStatePublisher {
@@ -157,6 +300,7 @@ type WorkflowId = string;
 type NodeId = string;
 type OutputPortKey = string;
 type InputPortKey = string;
+type PersistedTokenId = string;
 type NodeKind = "trigger" | "node";
 type JsonPrimitive = string | number | boolean | null;
 interface JsonObject$1 {
@@ -298,6 +442,11 @@ interface WorkflowPrunePolicySpec {
   readonly runDataRetentionSeconds?: number;
   readonly binaryRetentionSeconds?: number;
 }
+interface PersistedRunPolicySnapshot {
+  readonly retentionSeconds?: number;
+  readonly binaryRetentionSeconds?: number;
+  readonly storagePolicy: WorkflowStoragePolicyMode;
+}
 interface WorkflowErrorHandler {
   onError(ctx: WorkflowErrorContext): void | Promise<void>;
 }
@@ -439,6 +588,50 @@ type CredentialType<TPublicConfig extends CredentialJsonRecord = CredentialJsonR
  */
 type AnyCredentialType = CredentialType<any, any, unknown>;
 //#endregion
+//#region ../core/src/events/runEvents.d.ts
+type RunEvent = Readonly<{
+  kind: "runCreated";
+  runId: RunId;
+  workflowId: WorkflowId;
+  parent?: ParentExecutionRef;
+  at: string;
+}> | Readonly<{
+  kind: "runSaved";
+  runId: RunId;
+  workflowId: WorkflowId;
+  parent?: ParentExecutionRef;
+  at: string;
+  state: PersistedRunState;
+}> | Readonly<{
+  kind: "nodeQueued";
+  runId: RunId;
+  workflowId: WorkflowId;
+  parent?: ParentExecutionRef;
+  at: string;
+  snapshot: NodeExecutionSnapshot;
+}> | Readonly<{
+  kind: "nodeStarted";
+  runId: RunId;
+  workflowId: WorkflowId;
+  parent?: ParentExecutionRef;
+  at: string;
+  snapshot: NodeExecutionSnapshot;
+}> | Readonly<{
+  kind: "nodeCompleted";
+  runId: RunId;
+  workflowId: WorkflowId;
+  parent?: ParentExecutionRef;
+  at: string;
+  snapshot: NodeExecutionSnapshot;
+}> | Readonly<{
+  kind: "nodeFailed";
+  runId: RunId;
+  workflowId: WorkflowId;
+  parent?: ParentExecutionRef;
+  at: string;
+  snapshot: NodeExecutionSnapshot;
+}>;
+//#endregion
 //#region ../core/src/policies/executionLimits/EngineExecutionLimitsPolicy.d.ts
 interface EngineExecutionLimitsPolicyConfig {
   readonly defaultMaxNodeActivations: number;
@@ -447,72 +640,34 @@ interface EngineExecutionLimitsPolicyConfig {
   readonly hardMaxSubworkflowDepth: number;
 }
 //#endregion
-//#region ../host/src/presentation/config/CodemationAuthConfig.d.ts
-/**
- * Consumer-declared authentication profile for the hosted UI + HTTP API.
- * NextAuth / Auth.js wires concrete providers from this configuration plus environment secrets.
- */
-type CodemationAuthKind = "local" | "oauth" | "oidc";
-interface CodemationAuthOAuthProviderConfig {
-  readonly provider: "google" | "github" | "microsoft-entra-id";
-  readonly clientIdEnv: string;
-  readonly clientSecretEnv: string;
-  /** Microsoft Entra ID tenant; environment variable name whose value is the tenant ID. */
-  readonly tenantIdEnv?: string;
+//#region ../host/src/presentation/config/CodemationClassToken.d.ts
+type CodemationClassToken<TValue> = TypeToken<TValue> & (new (...args: never[]) => TValue);
+//#endregion
+//#region ../host/src/bootstrap/CodemationContainerRegistration.d.ts
+interface CodemationContainerRegistrationBase<TValue> {
+  readonly token: TypeToken<TValue>;
 }
-interface CodemationAuthOidcProviderConfig {
-  readonly id: string;
-  readonly issuer: string;
-  readonly clientIdEnv: string;
-  readonly clientSecretEnv: string;
+interface CodemationValueRegistration<TValue> extends CodemationContainerRegistrationBase<TValue> {
+  readonly useValue: TValue;
 }
-interface CodemationAuthConfig {
-  readonly kind: CodemationAuthKind;
-  /**
-   * When true and NODE_ENV is not production, the API accepts requests without a real session
-   * (synthetic principal only — never honored in production).
-   */
-  readonly allowUnauthenticatedInDevelopment?: boolean;
-  readonly oauth?: ReadonlyArray<CodemationAuthOAuthProviderConfig>;
-  readonly oidc?: ReadonlyArray<CodemationAuthOidcProviderConfig>;
+interface CodemationClassRegistration<TValue> extends CodemationContainerRegistrationBase<TValue> {
+  readonly useClass: CodemationClassToken<TValue>;
 }
-//#endregion
-//#region ../host/src/presentation/config/CodemationWhitelabelConfig.d.ts
-/**
- * Optional host shell whitelabeling (sidebar, login, document title).
- * `logoPath` is resolved relative to the consumer project root.
- */
-interface CodemationWhitelabelConfig {
-  readonly productName?: string;
-  /** Relative to consumer project root, e.g. `branding/logo.svg`. */
-  readonly logoPath?: string;
+interface CodemationFactoryRegistration<TValue> extends CodemationContainerRegistrationBase<TValue> {
+  readonly useFactory: (container: Container) => TValue;
 }
+type CodemationContainerRegistration<TValue = unknown> = CodemationValueRegistration<TValue> | CodemationClassRegistration<TValue> | CodemationFactoryRegistration<TValue>;
 //#endregion
-//#region ../host/src/presentation/config/AppConfig.d.ts
-interface AppConfig {
-  readonly consumerRoot: string;
-  readonly repoRoot: string;
-  readonly env: Readonly<NodeJS.ProcessEnv>;
-  readonly workflowSources: ReadonlyArray<string>;
-  readonly databaseUrl?: string;
-  readonly database?: CodemationDatabaseConfig;
-  readonly scheduler: Readonly<{
-    kind: CodemationSchedulerKind;
-    queuePrefix?: string;
-    workerQueues: ReadonlyArray<string>;
-    redisUrl?: string;
-  }>;
-  readonly eventing: Readonly<{
-    kind: CodemationEventBusKind;
-    queuePrefix?: string;
-    redisUrl?: string;
-  }>;
-  readonly auth?: CodemationAuthConfig;
-  readonly whitelabel: CodemationWhitelabelConfig;
+//#region ../host/src/application/logging/Logger.d.ts
+interface Logger {
+  info(message: string, exception?: Error): void;
+  warn(message: string, exception?: Error): void;
+  error(message: string, exception?: Error): void;
+  debug(message: string, exception?: Error): void;
+}
+interface LoggerFactory {
+  create(scope: string): Logger;
 }
-//#endregion
-//#region ../host/src/presentation/config/CodemationClassToken.d.ts
-type CodemationClassToken<TValue> = TypeToken<TValue> & (new (...args: never[]) => TValue);
 //#endregion
 //#region ../host/src/presentation/config/CodemationAppContext.d.ts
 interface CodemationRegistrationContextBase {
@@ -529,17 +684,6 @@ interface CodemationAppContext extends CodemationRegistrationContextBase {
   discoverWorkflows(...directories: ReadonlyArray<string>): void;
 }
 //#endregion
-//#region ../host/src/application/logging/Logger.d.ts
-interface Logger {
-  info(message: string, exception?: Error): void;
-  warn(message: string, exception?: Error): void;
-  error(message: string, exception?: Error): void;
-  debug(message: string, exception?: Error): void;
-}
-interface LoggerFactory {
-  create(scope: string): Logger;
-}
-//#endregion
 //#region ../host/src/presentation/config/CodemationPlugin.d.ts
 interface CodemationPluginContext extends CodemationRegistrationContextBase {
   readonly container: Container;
@@ -556,6 +700,36 @@ interface CodemationPlugin {
   register(context: CodemationPluginContext): void | Promise<void>;
 }
 //#endregion
+//#region ../host/src/presentation/config/CodemationAuthConfig.d.ts
+/**
+ * Consumer-declared authentication profile for the hosted UI + HTTP API.
+ * NextAuth / Auth.js wires concrete providers from this configuration plus environment secrets.
+ */
+type CodemationAuthKind = "local" | "oauth" | "oidc";
+interface CodemationAuthOAuthProviderConfig {
+  readonly provider: "google" | "github" | "microsoft-entra-id";
+  readonly clientIdEnv: string;
+  readonly clientSecretEnv: string;
+  /** Microsoft Entra ID tenant; environment variable name whose value is the tenant ID. */
+  readonly tenantIdEnv?: string;
+}
+interface CodemationAuthOidcProviderConfig {
+  readonly id: string;
+  readonly issuer: string;
+  readonly clientIdEnv: string;
+  readonly clientSecretEnv: string;
+}
+interface CodemationAuthConfig {
+  readonly kind: CodemationAuthKind;
+  /**
+   * When true and NODE_ENV is not production, the API accepts requests without a real session
+   * (synthetic principal only — never honored in production).
+   */
+  readonly allowUnauthenticatedInDevelopment?: boolean;
+  readonly oauth?: ReadonlyArray<CodemationAuthOAuthProviderConfig>;
+  readonly oidc?: ReadonlyArray<CodemationAuthOidcProviderConfig>;
+}
+//#endregion
 //#region ../host/src/presentation/config/CodemationLogConfig.d.ts
 /**
  * Minimum level for namespaces matched by {@link CodemationLogRule.filter}.
@@ -580,6 +754,17 @@ type CodemationLogConfig = Readonly<{
   rules: ReadonlyArray<CodemationLogRule>;
 }> | CodemationLogRule;
 //#endregion
+//#region ../host/src/presentation/config/CodemationWhitelabelConfig.d.ts
+/**
+ * Optional host shell whitelabeling (sidebar, login, document title).
+ * `logoPath` is resolved relative to the consumer project root.
+ */
+interface CodemationWhitelabelConfig {
+  readonly productName?: string;
+  /** Relative to consumer project root, e.g. `branding/logo.svg`. */
+  readonly logoPath?: string;
+}
+//#endregion
 //#region ../host/src/presentation/config/CodemationWorkflowDiscovery.d.ts
 interface CodemationWorkflowDiscovery {
   readonly directories?: ReadonlyArray<string>;
@@ -656,8 +841,8 @@ interface CodemationConfig {
   readonly log?: CodemationLogConfig;
 }
 //#endregion
-//#region ../host/src/infrastructure/persistence/DatabasePersistenceResolver.d.ts
-type ResolvedDatabasePersistence = Readonly<{
+//#region ../host/src/presentation/config/AppConfig.d.ts
+type AppPersistenceConfig = Readonly<{
   kind: "none";
 }> | Readonly<{
   kind: "postgresql";
@@ -666,23 +851,36 @@ type ResolvedDatabasePersistence = Readonly<{
   kind: "pglite";
   dataDir: string;
 }>;
-/**
- * Resolves whether persistence uses TCP PostgreSQL, embedded PGlite, or in-memory stores.
- * Uses {@link CodemationConfig.runtime.database} as the source of truth; optional `CODEMATION_DATABASE_KIND`
- * and `CODEMATION_PGLITE_DATA_DIR` can override kind / PGlite directory. `DATABASE_URL` is not read here—put
- * connection strings in `runtime.database.url` (often sourced from `process.env` inside `codemation.config.ts`).
- */
-declare class DatabasePersistenceResolver {
-  resolve(args: Readonly<{
-    runtimeConfig: CodemationApplicationRuntimeConfig;
-    env: NodeJS.ProcessEnv;
-    consumerRoot: string;
-  }>): ResolvedDatabasePersistence;
-  resolveDatabaseKind(configured: CodemationDatabaseKind | undefined, env: NodeJS.ProcessEnv): CodemationDatabaseKind;
-  private inferDatabaseKind;
-  isPostgresUrl(value: string): boolean;
-  isPgliteUrl(value: string): boolean;
-  private resolvePgliteDataDirFromConfig;
+interface AppConfig {
+  readonly consumerRoot: string;
+  readonly repoRoot: string;
+  readonly env: Readonly<NodeJS.ProcessEnv>;
+  readonly workflowSources: ReadonlyArray<string>;
+  readonly workflows: ReadonlyArray<WorkflowDefinition>;
+  readonly containerRegistrations: ReadonlyArray<CodemationContainerRegistration<unknown>>;
+  readonly credentialTypes: ReadonlyArray<AnyCredentialType>;
+  readonly plugins: ReadonlyArray<CodemationPlugin>;
+  readonly hasConfiguredCredentialSessionServiceRegistration: boolean;
+  readonly log?: CodemationLogConfig;
+  readonly engineExecutionLimits?: CodemationEngineExecutionLimitsConfig;
+  readonly databaseUrl?: string;
+  readonly database?: CodemationDatabaseConfig;
+  readonly persistence: AppPersistenceConfig;
+  readonly scheduler: Readonly<{
+    kind: CodemationSchedulerKind;
+    queuePrefix?: string;
+    workerQueues: ReadonlyArray<string>;
+    redisUrl?: string;
+  }>;
+  readonly eventing: Readonly<{
+    kind: CodemationEventBusKind;
+    queuePrefix?: string;
+    redisUrl?: string;
+  }>;
+  readonly auth?: CodemationAuthConfig;
+  readonly whitelabel: CodemationWhitelabelConfig;
+  readonly webSocketPort: number;
+  readonly webSocketBindHost: string;
 }
 declare namespace client_d_exports {
   export { Action, Aggregate, AllModelsToStringIndex, AnyNull, AnyNullClass, ApplyOmit, Args, Args_3, BaseDMMF, Bytes, Call, Cast, ClientArg, ClientArgs, ClientBuiltInProp, ClientOptionDef, ClientOtherOps, Compute, ComputeDeep, Count, DMMF, DbNull, DbNullClass, Debug, Decimal, DecimalJsLike, DefaultArgs, DefaultSelection, DevTypeMapDef, DevTypeMapFnDef, DynamicClientExtensionArgs, DynamicClientExtensionThis, DynamicClientExtensionThisBuiltin, DynamicModelExtensionArgs, DynamicModelExtensionFluentApi, DynamicModelExtensionFnResult, DynamicModelExtensionFnResultBase, DynamicModelExtensionFnResultNull, DynamicModelExtensionOperationFn, DynamicModelExtensionThis, DynamicQueryExtensionArgs, DynamicQueryExtensionCb, DynamicQueryExtensionCbArgs, DynamicQueryExtensionCbArgsArgs, DynamicResultExtensionArgs, DynamicResultExtensionData, DynamicResultExtensionNeeds, EmptyToUnknown, Equals, Exact, ExtendsHook, ExtensionArgs, Extensions, ExtractGlobalOmit, FieldRef$1 as FieldRef, Fn, GetAggregateResult, GetBatchResult, GetCountResult, GetFindResult, GetGroupByResult, GetOmit, GetPayloadResult, GetPayloadResultExtensionKeys, GetPayloadResultExtensionObject, GetPrismaClientConfig, GetResult, GetSelect, ITXClientDenyList, InputJsonArray, InputJsonObject, InputJsonValue, InternalArgs, JsArgs, JsInputValue, JsOutputValue, JsPromise, JsonArray, JsonBatchQuery, JsonConvertible, JsonNull, JsonNullClass, JsonObject, JsonQuery, JsonValue, MergeExtArgs, ModelArg, ModelArgs, ModelKey, ModelQueryOptionsCb, ModelQueryOptionsCbArgs, NameArgs, Narrow, Narrowable, NeverToUnknown, NullTypes$1 as NullTypes, ObjectEnumValue, Omission, Omit_2 as Omit, OmitValue, Operation, OperationPayload, Optional, OptionalFlat$1 as OptionalFlat, OptionalKeys, Or$1 as Or, Param, PatchFlat, Path, Payload, PayloadToResult, Pick_2 as Pick, PrismaClientInitializationError, PrismaClientKnownRequestError, PrismaClientOptions, PrismaClientRustPanicError, PrismaClientUnknownRequestError, PrismaClientValidationError, PrismaPromise, PrivateResultType, Public, QueryOptions, QueryOptionsCb, QueryOptionsCbArgs, RawParameters, RawQueryArgs, RawValue, ReadonlyDeep, Record_2 as Record, RenameAndNestPayloadKeys, RequiredExtensionArgs, RequiredKeys$1 as RequiredKeys, Result, ResultArg, ResultArgs, ResultArgsFieldCompute, ResultFieldDefinition, Result_2, Return, RuntimeDataModel, Select, SelectField, SelectablePayloadFields, Selection_2 as Selection, Sql, SqlCommenterContext, SqlCommenterPlugin, SqlCommenterQueryInfo, SqlCommenterSingleQueryInfo, SqlCommenterTags, SqlDriverAdapterFactory, ToTuple, TypeMapCbDef, TypeMapDef, TypedSql, Types, UnknownTypedSql, UnwrapPayload, UnwrapPromise, UnwrapTuple, RequiredExtensionArgs as UserArgs, Value, createParam, defineDmmfProperty, deserializeJsonObject, deserializeRawResult, dmmfToRuntimeDataModel, empty, getPrismaClient, getRuntime, isAnyNull, isDbNull, isJsonNull, isObjectEnumValue, isTypedSql, itxClientDenyList, join, makeStrictEnum, makeTypedQueryFactory, raw, serializeJsonQuery, skip, sqltag, warnOnce };
@@ -22646,35 +22844,146 @@ declare namespace Prisma {
   export const dmmf: BaseDMMF;
 }
 //#endregion
-//#region ../host/src/application/dev/DevBootstrapSummaryJson.types.d.ts
-type DevBootstrapSummaryJson = Readonly<{
-  logLevel: string;
-  codemationLogLevelEnv?: string;
-  databaseLabel: string;
-  schedulerLabel: string;
-  eventBusLabel: string;
-  redisUrlRedacted?: string;
-  activeWorkflows: ReadonlyArray<Readonly<{
-    id: string;
-    name: string;
-  }>>;
+//#region ../host/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 ../host/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 ../host/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;
+//#region ../host/src/application/websocket/WorkflowWebsocketPublisher.d.ts
+interface WorkflowWebsocketPublisher {
+  publishToRoom(roomId: string, message: WorkflowWebsocketMessage): Promise<void>;
+}
+//#endregion
+//#region ../host/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 ../host/src/bootstrap/CodemationContainerRegistrationRegistrar.d.ts
+declare class CodemationContainerRegistrationRegistrar {
+  apply(container: Container, registrations: ReadonlyArray<CodemationContainerRegistration<unknown>>): void;
+  private applyRegistration;
+  private isValueRegistration;
+  private isClassRegistration;
+}
+//#endregion
+//#region ../host/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 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 createBinaryStorage;
+  private createRuntimeSummary;
+  private requireRedisUrl;
+  private synchronizeLiveWorkflowRepository;
+}
+//#endregion
+//#region ../host/src/presentation/config/CodemationConfigNormalizer.d.ts
+type NormalizedCodemationConfig = CodemationConfig & Readonly<{
+  containerRegistrations: ReadonlyArray<CodemationContainerRegistration<unknown>>;
+}>;
+//#endregion
+//#region ../host/src/bootstrap/runtime/AppConfigFactory.d.ts
+declare class AppConfigFactory {
+  create(args: Readonly<{
     repoRoot: string;
-    workflowSources?: ReadonlyArray<string>;
-    env?: Readonly<NodeJS.ProcessEnv>;
-  }>);
-  resolveEnvironment(): NodeJS.ProcessEnv;
+    consumerRoot: string;
+    env: NodeJS.ProcessEnv;
+    config: NormalizedCodemationConfig;
+    workflowSources: ReadonlyArray<string>;
+  }>): AppConfig;
+  private resolvePersistence;
+  private resolveDatabaseKind;
+  private resolvePgliteDataDir;
+  private resolveSchedulerKind;
+  private resolveEventBusKind;
+  private readSchedulerKind;
+  private readEventBusKind;
+  private resolveWebSocketPort;
 }
 //#endregion
+//#region ../host/src/presentation/frontend/CodemationFrontendAuthSnapshot.d.ts
+type CodemationFrontendAuthProviderSnapshot = Readonly<{
+  id: string;
+  name: string;
+}>;
+type CodemationFrontendAuthSnapshot = Readonly<{
+  config: CodemationAuthConfig | undefined;
+  credentialsEnabled: boolean;
+  oauthProviders: ReadonlyArray<CodemationFrontendAuthProviderSnapshot>;
+  secret: string | null;
+  uiAuthEnabled: boolean;
+}>;
+//#endregion
+//#region ../host/src/presentation/frontend/FrontendAppConfig.d.ts
+/**
+ * Frontend-safe projection of host app configuration for packaged Next UI and SSR.
+ */
+type FrontendAppConfig = Readonly<{
+  auth: CodemationFrontendAuthSnapshot;
+  productName: string;
+  logoUrl: string | null;
+}>;
+//#endregion
 //#region ../host/src/presentation/config/CodemationPackageManifest.d.ts
 interface CodemationPluginPackageManifest {
   readonly kind: "plugin";
@@ -22687,7 +22996,7 @@ interface CodemationPackageManifest {
 //#endregion
 //#region ../host/src/presentation/server/CodemationConsumerConfigLoader.d.ts
 type CodemationConsumerConfigResolution = Readonly<{
-  config: CodemationConfig;
+  config: NormalizedCodemationConfig;
   bootstrapSource: string | null;
   workflowSources: ReadonlyArray<string>;
 }>;
@@ -22722,6 +23031,23 @@ declare class CodemationConsumerConfigLoader {
   private exists;
 }
 //#endregion
+//#region ../host/src/presentation/server/AppConfigLoader.d.ts
+type AppConfigLoadResult = Readonly<{
+  appConfig: AppConfig;
+  bootstrapSource: string | null;
+}>;
+declare class AppConfigLoader {
+  private readonly consumerConfigLoader;
+  private readonly appConfigFactory;
+  constructor(consumerConfigLoader?: CodemationConsumerConfigLoader, appConfigFactory?: AppConfigFactory);
+  load(args: Readonly<{
+    consumerRoot: string;
+    repoRoot: string;
+    env: NodeJS.ProcessEnv;
+    configPathOverride?: string;
+  }>): Promise<AppConfigLoadResult>;
+}
+//#endregion
 //#region ../host/src/presentation/server/CodemationPluginDiscovery.d.ts
 type CodemationDiscoveredPluginPackage = Readonly<{
   packageName: string;
@@ -22746,17 +23072,39 @@ declare class CodemationPluginDiscovery {
   private resolveDevelopmentPluginEntry;
 }
 //#endregion
+//#region ../host/src/presentation/frontend/CodemationFrontendAuthSnapshotFactory.d.ts
+declare class CodemationFrontendAuthSnapshotFactory {
+  createFromAppConfig(appConfig: AppConfig): CodemationFrontendAuthSnapshot;
+  createFromResolvedInputs(args: Readonly<{
+    authConfig: CodemationAuthConfig | undefined;
+    env: NodeJS.ProcessEnv;
+    uiAuthEnabled: boolean;
+  }>): CodemationFrontendAuthSnapshot;
+  private resolveUiAuthEnabled;
+  private resolveAuthSecret;
+  private createOauthProviders;
+  private createOAuthProvider;
+  private createOidcProvider;
+}
+//#endregion
+//#region ../host/src/presentation/frontend/FrontendAppConfigJsonCodec.d.ts
+declare class FrontendAppConfigJsonCodec {
+  serialize(config: FrontendAppConfig): string;
+  deserialize(serialized: string | undefined): FrontendAppConfig | null;
+  private resolveAuthConfig;
+  private resolveOauthProviders;
+}
+//#endregion
 //#region src/bootstrap/CodemationCliApplicationSession.d.ts
 /**
- * Opens a {@link CodemationApplication} with persistence + command/query buses (no HTTP/WebSocket servers),
+ * Opens an app container with persistence + command/query buses (no HTTP/WebSocket servers),
  * for CLI tools that dispatch application commands or queries (e.g. user admin).
  */
 declare class CodemationCliApplicationSession {
-  private readonly application;
+  private readonly container;
   private constructor();
   static open(args: Readonly<{
-    resolution: CodemationConsumerConfigResolution;
-    bootstrap: CodemationBootstrapRequest;
+    appConfig: AppConfig;
   }>): Promise<CodemationCliApplicationSession>;
   getPrismaClient(): PrismaClient | undefined;
   getCommandBus(): CommandBus;
@@ -22792,6 +23140,20 @@ declare class ConsumerBuildOptionsParser {
   private parseTarget;
 }
 //#endregion
+//#region ../host/src/application/dev/DevBootstrapSummaryJson.types.d.ts
+type DevBootstrapSummaryJson = Readonly<{
+  logLevel: string;
+  codemationLogLevelEnv?: string;
+  databaseLabel: string;
+  schedulerLabel: string;
+  eventBusLabel: string;
+  redisUrlRedacted?: string;
+  activeWorkflows: ReadonlyArray<Readonly<{
+    id: string;
+    name: string;
+  }>>;
+}>;
+//#endregion
 //#region src/consumer/ConsumerOutputBuilder.d.ts
 type ConsumerOutputBuildSnapshot = Readonly<{
   buildVersion: string;
@@ -22921,6 +23283,7 @@ declare class CliPathResolver {
 //#region src/runtime/TypeScriptRuntimeConfigurator.d.ts
 declare class TypeScriptRuntimeConfigurator {
   configure(repoRoot: string): void;
+  private hasExplicitOverride;
 }
 //#endregion
 //#region src/commands/BuildCommand.d.ts
@@ -22949,8 +23312,9 @@ declare class ConsumerCliTsconfigPreparation {
  * Resolves TCP PostgreSQL vs PGlite vs none from env + {@link CodemationConfig} (same rules as the host runtime).
  */
 declare class ConsumerDatabaseConnectionResolver {
-  private readonly resolver;
-  resolve(processEnv: NodeJS.ProcessEnv, config: CodemationConfig, consumerRoot: string): ResolvedDatabasePersistence;
+  resolve(processEnv: NodeJS.ProcessEnv, config: CodemationConfig, consumerRoot: string): AppPersistenceConfig;
+  private resolveDatabaseKind;
+  private resolvePgliteDataDir;
 }
 //#endregion
 //#region src/user/CliDatabaseUrlDescriptor.d.ts
@@ -22958,7 +23322,7 @@ declare class ConsumerDatabaseConnectionResolver {
  * Formats a database URL for CLI messages without exposing credentials (no user/password).
  */
 declare class CliDatabaseUrlDescriptor {
-  describePersistence(persistence: ResolvedDatabasePersistence): string;
+  describePersistence(persistence: AppPersistenceConfig): string;
   describeForDisplay(databaseUrl: string | undefined): string;
 }
 //#endregion
@@ -22976,7 +23340,7 @@ declare class UserAdminConsumerDotenvLoader {
 //#endregion
 //#region src/database/DatabaseMigrationsApplyService.d.ts
 type DatabaseMigrationDeployer = {
-  deployPersistence(persistence: ResolvedDatabasePersistence, env?: Readonly<NodeJS.ProcessEnv>): Promise<void>;
+  deployPersistence(persistence: AppPersistenceConfig, env?: Readonly<NodeJS.ProcessEnv>): Promise<void>;
 };
 /**
  * Loads consumer config + env, resolves persistence, and runs Prisma migrations.
@@ -23018,14 +23382,98 @@ declare class DbMigrateCommand {
   execute(options: DbMigrateCommandOptions): Promise<void>;
 }
 //#endregion
+//#region src/dev/LoopbackPortAllocator.d.ts
+declare class LoopbackPortAllocator {
+  allocate(): Promise<number>;
+}
+//#endregion
+//#region src/dev/DevApiRuntimeTypes.d.ts
+type DevApiRuntimeFactoryArgs = Readonly<{
+  consumerRoot: string;
+  env: NodeJS.ProcessEnv;
+  runtimeWorkingDirectory: string;
+}>;
+type DevApiRuntimeServerHandle = Readonly<{
+  buildVersion: string;
+  httpPort: number;
+  stop: () => Promise<void>;
+  workflowIds: ReadonlyArray<string>;
+  workflowWebSocketPort: number;
+}>;
+//#endregion
+//#region src/dev/DevApiRuntimeFactory.d.ts
+declare class DevApiRuntimeFactory {
+  private readonly portAllocator;
+  private readonly configLoader;
+  private readonly pluginDiscovery;
+  constructor(portAllocator: LoopbackPortAllocator, configLoader: AppConfigLoader, pluginDiscovery: CodemationPluginDiscovery);
+  create(args: DevApiRuntimeFactoryArgs): Promise<DevApiRuntimeServerHandle>;
+}
+//#endregion
 //#region src/dev/DevBootstrapSummaryFetcher.d.ts
 /**
- * Fetches {@link DevBootstrapSummaryJson} from the dev gateway (proxied to runtime-dev).
+ * Fetches {@link DevBootstrapSummaryJson} from the stable CLI-owned dev endpoint.
  */
 declare class DevBootstrapSummaryFetcher {
   fetch(gatewayBaseUrl: string): Promise<DevBootstrapSummaryJson | null>;
 }
 //#endregion
+//#region src/dev/CliDevProxyServer.d.ts
+type ProxyRuntimeTarget = Readonly<{
+  httpPort: number;
+  workflowWebSocketPort: number;
+}>;
+type BuildStatus = "idle" | "building";
+declare class CliDevProxyServer {
+  private readonly listenPort;
+  private readonly proxy;
+  private readonly devClients;
+  private readonly devWss;
+  private readonly workflowClients;
+  private readonly workflowWss;
+  private readonly roomIdsByWorkflowClient;
+  private readonly workflowClientCountByRoomId;
+  private activeRuntime;
+  private activeBuildStatus;
+  private childWorkflowSocket;
+  private server;
+  private uiProxyTarget;
+  constructor(listenPort: number);
+  start(): Promise<void>;
+  stop(): Promise<void>;
+  setUiProxyTarget(target: string | null): void;
+  activateRuntime(target: ProxyRuntimeTarget | null): Promise<void>;
+  setBuildStatus(status: BuildStatus): void;
+  broadcastBuildStarted(): void;
+  broadcastBuildCompleted(buildVersion: string): void;
+  broadcastBuildFailed(message: string): void;
+  private bindDevWebSocket;
+  private bindWorkflowWebSocket;
+  private handleHttpRequest;
+  private handleUpgrade;
+  private safePathname;
+  private broadcastDev;
+  private broadcastWorkflowLifecycleToSubscribedRooms;
+  private connectWorkflowClient;
+  private disconnectWorkflowClient;
+  private handleWorkflowClientMessage;
+  private parseWorkflowClientMessage;
+  private retainWorkflowRoom;
+  private releaseWorkflowRoom;
+  private sendToChildWorkflowSocket;
+  private connectChildWorkflowSocket;
+  private openChildWorkflowSocket;
+  private disconnectChildWorkflowSocket;
+  private handleChildWorkflowSocketMessage;
+  private broadcastWorkflowTextToRoom;
+  private broadcastWorkflowTextToAll;
+}
+//#endregion
+//#region src/dev/CliDevProxyServerFactory.d.ts
+declare class CliDevProxyServerFactory {
+  create(gatewayPort: number): CliDevProxyServer;
+}
+//#endregion
 //#region src/dev/DevCliBannerRenderer.d.ts
 /**
  * Dev-only stdout branding (not the structured host logger).
@@ -23074,6 +23522,30 @@ declare class ConsumerEnvDotenvFilePredicate {
   matches(filePath: string): boolean;
 }
 //#endregion
+//#region src/dev/DevRebuildQueue.d.ts
+type DevRebuildRequest = Readonly<{
+  changedPaths: ReadonlyArray<string>;
+  shouldRepublishConsumerOutput: boolean;
+  shouldRestartUi: boolean;
+}>;
+interface DevRebuildHandler {
+  run(request: DevRebuildRequest): Promise<void>;
+}
+declare class DevRebuildQueue {
+  private readonly handler;
+  private pendingRequest;
+  private drainPromise;
+  constructor(handler: DevRebuildHandler);
+  enqueue(request: DevRebuildRequest): Promise<void>;
+  private drain;
+  private mergePendingRequest;
+}
+//#endregion
+//#region src/dev/DevRebuildQueueFactory.d.ts
+declare class DevRebuildQueueFactory {
+  create(handler: DevRebuildHandler): DevRebuildQueue;
+}
+//#endregion
 //#region src/consumer/ConsumerEnvLoader.d.ts
 /**
  * Loads the consumer project's dotenv files so `codemation dev` can forward them to the Next host.
@@ -23103,8 +23575,9 @@ type DevResolvedAuthSettings = Readonly<{
 }>;
 declare class DevAuthSettingsLoader {
   private readonly configLoader;
+  private readonly consumerEnvLoader;
   static readonly defaultDevelopmentAuthSecret = "codemation-dev-auth-secret-not-for-production";
-  constructor(configLoader: CodemationConsumerConfigLoader);
+  constructor(configLoader: CodemationConsumerConfigLoader, consumerEnvLoader: ConsumerEnvLoader);
   resolveDevelopmentServerToken(rawToken: string | undefined): string;
   loadForConsumer(consumerRoot: string): Promise<DevResolvedAuthSettings>;
   resolveDevelopmentAuthSecret(env: NodeJS.ProcessEnv): string;
@@ -23115,18 +23588,34 @@ declare class DevHttpProbe {
   waitUntilUrlRespondsOk(url: string): Promise<void>;
   waitUntilGatewayHealthy(gatewayBaseUrl: string): Promise<void>;
   /**
-   * Polls until the runtime child serves bootstrap summary (after gateway is up, the disposable runtime may still be wiring).
+   * Polls until the active disposable runtime serves bootstrap summary through the stable CLI dev endpoint.
    */
   waitUntilBootstrapSummaryReady(gatewayBaseUrl: string): Promise<void>;
+  private isRedirectStatus;
 }
 //#endregion
 //#region src/dev/DevNextHostEnvironmentBuilder.d.ts
 declare class DevNextHostEnvironmentBuilder {
   private readonly consumerEnvLoader;
   private readonly sourceMapNodeOptions;
-  constructor(consumerEnvLoader: ConsumerEnvLoader, sourceMapNodeOptions: SourceMapNodeOptions);
+  private readonly frontendAuthSnapshotFactory;
+  private readonly frontendAppConfigJsonCodec;
+  constructor(consumerEnvLoader: ConsumerEnvLoader, sourceMapNodeOptions: SourceMapNodeOptions, frontendAuthSnapshotFactory?: CodemationFrontendAuthSnapshotFactory, frontendAppConfigJsonCodec?: FrontendAppConfigJsonCodec);
+  buildConsumerUiProxy(args: Readonly<{
+    authConfigJson: string;
+    authSecret: string;
+    consumerRoot: string;
+    developmentServerToken: string;
+    nextPort: number;
+    publicBaseUrl: string;
+    runtimeDevUrl: string;
+    skipUiAuth: boolean;
+    websocketPort: number;
+    consumerOutputManifestPath?: string;
+  }>): NodeJS.ProcessEnv;
   build(args: Readonly<{
     authConfigJson: string;
+    authSecret?: string;
     consumerRoot: string;
     developmentServerToken: string;
     nextPort: number;
@@ -23136,6 +23625,7 @@ declare class DevNextHostEnvironmentBuilder {
     /** Same manifest as `codemation build` / serve-web so @codemation/next-host can load consumer config (whitelabel, etc.). */
     consumerOutputManifestPath?: string;
   }>): NodeJS.ProcessEnv;
+  private parseAuthConfig;
 }
 //#endregion
 //#region src/runtime/ListenPortResolver.d.ts
@@ -23152,18 +23642,13 @@ declare class ListenPortResolver {
   }>): number;
 }
 //#endregion
-//#region src/dev/LoopbackPortAllocator.d.ts
-declare class LoopbackPortAllocator {
-  allocate(): Promise<number>;
-}
-//#endregion
 //#region src/dev/DevSessionPortsResolver.d.ts
 declare class DevSessionPortsResolver {
   private readonly listenPorts;
   private readonly loopbackPorts;
   constructor(listenPorts: ListenPortResolver, loopbackPorts: LoopbackPortAllocator);
   resolve(args: Readonly<{
-    devMode: "consumer" | "framework";
+    devMode: "packaged-ui" | "watch-framework";
     portEnv: string | undefined;
     gatewayPortEnv: string | undefined;
   }>): Promise<Readonly<{
@@ -23172,51 +23657,26 @@ declare class DevSessionPortsResolver {
   }>>;
 }
 //#endregion
-//#region src/dev/DevelopmentGatewayNotifier.d.ts
-declare class DevelopmentGatewayNotifier {
-  private readonly cliLogger;
-  constructor(cliLogger: Logger);
-  notify(args: Readonly<{
-    gatewayBaseUrl: string;
-    developmentServerToken: string;
-    payload: Readonly<{
-      kind: "buildStarted" | "buildCompleted" | "buildFailed";
-      buildVersion?: string;
-      message?: string;
-    }>;
-  }>): Promise<void>;
-}
-//#endregion
-//#region src/dev/DevSourceRestartCoordinator.d.ts
-declare class DevSourceRestartCoordinator {
-  private readonly gatewayNotifier;
-  private readonly performanceDiagnosticsLogger;
-  private readonly cliLogger;
-  constructor(gatewayNotifier: DevelopmentGatewayNotifier, performanceDiagnosticsLogger: Logger, cliLogger: Logger);
-  runHandshakeAfterSourceChange(gatewayBaseUrl: string, developmentServerToken: string): Promise<void>;
-}
-//#endregion
-//#region src/dev/RuntimeToolEntrypointResolver.d.ts
-type ResolvedRuntimeToolEntrypoint = Readonly<{
-  args: ReadonlyArray<string>;
-  command: string;
-  env: Readonly<Record<string, string>>;
-}>;
-declare class RuntimeToolEntrypointResolver {
-  private readonly require;
-  resolve(args: Readonly<{
-    packageName: string;
-    repoRoot: string;
-    sourceEntrypoint: string;
-  }>): Promise<ResolvedRuntimeToolEntrypoint>;
-  private exists;
+//#region src/dev/DevSourceChangeClassifier.d.ts
+declare class DevSourceChangeClassifier {
+  private static readonly configFileNames;
+  shouldRepublishConsumerOutput(args: Readonly<{
+    changedPaths: ReadonlyArray<string>;
+    consumerRoot: string;
+  }>): boolean;
+  requiresUiRestart(args: Readonly<{
+    changedPaths: ReadonlyArray<string>;
+    consumerRoot: string;
+  }>): boolean;
+  private isPathInsideDirectory;
+  private pathRequiresUiRestart;
 }
 //#endregion
 //#region src/dev/WatchRootsResolver.d.ts
 declare class WatchRootsResolver {
   resolve(args: Readonly<{
     consumerRoot: string;
-    devMode: "consumer" | "framework";
+    devMode: "packaged-ui" | "watch-framework";
     repoRoot: string;
   }>): ReadonlyArray<string>;
 }
@@ -23231,12 +23691,11 @@ declare class DevSessionServices {
   readonly sessionPorts: DevSessionPortsResolver;
   readonly loopbackPortAllocator: LoopbackPortAllocator;
   readonly devHttpProbe: DevHttpProbe;
-  readonly runtimeEntrypointResolver: RuntimeToolEntrypointResolver;
   readonly devAuthLoader: DevAuthSettingsLoader;
   readonly nextHostEnvBuilder: DevNextHostEnvironmentBuilder;
   readonly watchRootsResolver: WatchRootsResolver;
-  readonly sourceRestartCoordinator: DevSourceRestartCoordinator;
-  constructor(consumerEnvLoader: ConsumerEnvLoader, sourceMapNodeOptions: SourceMapNodeOptions, sessionPorts: DevSessionPortsResolver, loopbackPortAllocator: LoopbackPortAllocator, devHttpProbe: DevHttpProbe, runtimeEntrypointResolver: RuntimeToolEntrypointResolver, devAuthLoader: DevAuthSettingsLoader, nextHostEnvBuilder: DevNextHostEnvironmentBuilder, watchRootsResolver: WatchRootsResolver, sourceRestartCoordinator: DevSourceRestartCoordinator);
+  readonly sourceChangeClassifier: DevSourceChangeClassifier;
+  constructor(consumerEnvLoader: ConsumerEnvLoader, sourceMapNodeOptions: SourceMapNodeOptions, sessionPorts: DevSessionPortsResolver, loopbackPortAllocator: LoopbackPortAllocator, devHttpProbe: DevHttpProbe, devAuthLoader: DevAuthSettingsLoader, nextHostEnvBuilder: DevNextHostEnvironmentBuilder, watchRootsResolver: WatchRootsResolver, sourceChangeClassifier: DevSourceChangeClassifier);
 }
 //#endregion
 //#region src/dev/DevLock.d.ts
@@ -23319,7 +23778,6 @@ declare class NextHostConsumerServerCommandFactory {
 //#region src/commands/DevCommand.d.ts
 declare class DevCommand {
   private readonly pathResolver;
-  private readonly pluginDiscovery;
   private readonly tsRuntime;
   private readonly devLockFactory;
   private readonly devSourceWatcherFactory;
@@ -23332,33 +23790,44 @@ declare class DevCommand {
   private readonly consumerEnvDotenvFilePredicate;
   private readonly devTrackedProcessTreeKiller;
   private readonly nextHostConsumerServerCommandFactory;
+  private readonly devApiRuntimeFactory;
+  private readonly cliDevProxyServerFactory;
+  private readonly devRebuildQueueFactory;
   private readonly require;
-  constructor(pathResolver: CliPathResolver, pluginDiscovery: CodemationPluginDiscovery, tsRuntime: TypeScriptRuntimeConfigurator, devLockFactory: DevLockFactory, devSourceWatcherFactory: DevSourceWatcherFactory, cliLogger: Logger, session: DevSessionServices, databaseMigrationsApplyService: DatabaseMigrationsApplyService, devBootstrapSummaryFetcher: DevBootstrapSummaryFetcher, devCliBannerRenderer: DevCliBannerRenderer, devConsumerPublishBootstrap: DevConsumerPublishBootstrap, consumerEnvDotenvFilePredicate: ConsumerEnvDotenvFilePredicate, devTrackedProcessTreeKiller: DevTrackedProcessTreeKiller, nextHostConsumerServerCommandFactory: NextHostConsumerServerCommandFactory);
-  execute(consumerRoot: string): Promise<void>;
-  private resolveDevModeFromEnv;
+  constructor(pathResolver: CliPathResolver, tsRuntime: TypeScriptRuntimeConfigurator, devLockFactory: DevLockFactory, devSourceWatcherFactory: DevSourceWatcherFactory, cliLogger: Logger, session: DevSessionServices, databaseMigrationsApplyService: DatabaseMigrationsApplyService, devBootstrapSummaryFetcher: DevBootstrapSummaryFetcher, devCliBannerRenderer: DevCliBannerRenderer, devConsumerPublishBootstrap: DevConsumerPublishBootstrap, consumerEnvDotenvFilePredicate: ConsumerEnvDotenvFilePredicate, devTrackedProcessTreeKiller: DevTrackedProcessTreeKiller, nextHostConsumerServerCommandFactory: NextHostConsumerServerCommandFactory, devApiRuntimeFactory: DevApiRuntimeFactory, cliDevProxyServerFactory: CliDevProxyServerFactory, devRebuildQueueFactory: DevRebuildQueueFactory);
+  execute(args: Readonly<{
+    consumerRoot: string;
+    watchFramework?: boolean;
+  }>): Promise<void>;
+  private resolveDevMode;
   private prepareDevRuntime;
   private createInitialProcessState;
   private wireStopPromise;
   private gatewayBaseHttpUrl;
-  /**
-   * Consumer mode: run `next start` for the host UI and wait until it responds, so the gateway can proxy to it.
-   * Framework mode: no separate UI child (Next runs in dev later).
-   */
-  private startConsumerUiProxyWhenNeeded;
-  private spawnGatewayChildAndWaitForHealth;
+  private startPackagedUiWhenNeeded;
+  private spawnPackagedUi;
+  private startProxyServer;
+  private bootInitialRuntime;
   private devDetachedChildSpawnOptions;
   private bindShutdownSignalsToChildProcesses;
-  /**
-   * Framework mode: run `next dev` for the Next host with HMR, pointed at the dev gateway runtime URL.
-   */
-  private spawnFrameworkNextHostWhenNeeded;
+  private spawnDevUiWhenNeeded;
+  private spawnDevUi;
   private startWatcherForSourceRestart;
-  private logConsumerDevHintWhenNeeded;
+  private runQueuedRebuild;
+  private restartUiAfterSourceChange;
+  private restartPackagedUi;
+  private restartDevUi;
+  private failDevSessionAfterIrrecoverableSourceError;
+  private stopLiveProcesses;
+  private stopCurrentRuntime;
+  private createRuntime;
+  private logPackagedUiDevHintWhenNeeded;
 }
 //#endregion
 //#region src/commands/ServeWebCommand.d.ts
 declare class ServeWebCommand {
   private readonly pathResolver;
+  private readonly configLoader;
   private readonly pluginDiscovery;
   private readonly artifactsPublisher;
   private readonly tsRuntime;
@@ -23367,17 +23836,21 @@ declare class ServeWebCommand {
   private readonly envLoader;
   private readonly listenPortResolver;
   private readonly nextHostConsumerServerCommandFactory;
+  private readonly frontendAuthSnapshotFactory;
+  private readonly frontendAppConfigJsonCodec;
   private readonly require;
-  constructor(pathResolver: CliPathResolver, pluginDiscovery: CodemationPluginDiscovery, artifactsPublisher: ConsumerBuildArtifactsPublisher, tsRuntime: TypeScriptRuntimeConfigurator, sourceMapNodeOptions: SourceMapNodeOptions, outputBuilderLoader: ConsumerOutputBuilderLoader, envLoader: ConsumerEnvLoader, listenPortResolver: ListenPortResolver, nextHostConsumerServerCommandFactory: NextHostConsumerServerCommandFactory);
+  constructor(pathResolver: CliPathResolver, configLoader: CodemationConsumerConfigLoader, pluginDiscovery: CodemationPluginDiscovery, artifactsPublisher: ConsumerBuildArtifactsPublisher, tsRuntime: TypeScriptRuntimeConfigurator, sourceMapNodeOptions: SourceMapNodeOptions, outputBuilderLoader: ConsumerOutputBuilderLoader, envLoader: ConsumerEnvLoader, listenPortResolver: ListenPortResolver, nextHostConsumerServerCommandFactory: NextHostConsumerServerCommandFactory, frontendAuthSnapshotFactory: CodemationFrontendAuthSnapshotFactory, frontendAppConfigJsonCodec: FrontendAppConfigJsonCodec);
   execute(consumerRoot: string, buildOptions: ConsumerBuildOptions): Promise<void>;
 }
 //#endregion
 //#region src/commands/ServeWorkerCommand.d.ts
 declare class ServeWorkerCommand {
-  private readonly sourceMapNodeOptions;
-  private readonly require;
-  constructor(sourceMapNodeOptions: SourceMapNodeOptions);
+  private readonly pathResolver;
+  private readonly appConfigLoader;
+  private readonly appContainerFactory;
+  constructor(pathResolver: CliPathResolver, appConfigLoader: AppConfigLoader, appContainerFactory: AppContainerFactory);
   execute(consumerRoot: string, configPathOverride?: string): Promise<void>;
+  private bindSignals;
 }
 //#endregion
 //#region src/user/UserAdminCliBootstrap.d.ts
@@ -23389,12 +23862,11 @@ type UserAdminCliOptions = Readonly<{
  * Shared env/config/session wiring for `codemation user *` commands (local auth + database).
  */
 declare class UserAdminCliBootstrap {
-  private readonly configLoader;
+  private readonly appConfigLoader;
   private readonly pathResolver;
   private readonly consumerDotenvLoader;
   private readonly tsconfigPreparation;
-  private readonly databasePersistenceResolver;
-  constructor(configLoader: CodemationConsumerConfigLoader, pathResolver: CliPathResolver, consumerDotenvLoader: UserAdminConsumerDotenvLoader, tsconfigPreparation: ConsumerCliTsconfigPreparation, databasePersistenceResolver: DatabasePersistenceResolver);
+  constructor(appConfigLoader: AppConfigLoader, pathResolver: CliPathResolver, consumerDotenvLoader: UserAdminConsumerDotenvLoader, tsconfigPreparation: ConsumerCliTsconfigPreparation);
   withSession<T$1>(options: UserAdminCliOptions, fn: (session: CodemationCliApplicationSession) => Promise<T$1>): Promise<T$1>;
 }
 //#endregion