@codemation/host 0.0.1

package/README.md

@@ -0,0 +1,75 @@
+# `@codemation/host`
+
+The **framework host**: application composition (`CodemationApplication`), HTTP/WebSocket gateway (Hono), persistence (Prisma/Postgres), plugin and workflow discovery, shared React UI shell pieces, and server/client **subpath bundles** so Next.js and Node servers only import what they need.
+
+## Install
+
+```bash
+pnpm add @codemation/host@^0.0.0
+# or
+npm install @codemation/host@^0.0.0
+```
+
+## When to use
+
+Depend on this package when you embed Codemation in a custom server, extend the host, or build tooling that must open the same application graph as production. Browser bundles should use `@codemation/host/client` (and related entry points), not the full server graph.
+
+## Usage
+
+Root re-exports types and `CodemationApplication` for programmatic hosting:
+
+```ts
+import { CodemationApplication, type CodemationApplicationConfig } from "@codemation/host";
+```
+
+Common subpaths (see `package.json` `exports`):
+
+| Import                                | Role                       |
+| ------------------------------------- | -------------------------- |
+| `@codemation/host/server`             | Hono/server wiring         |
+| `@codemation/host/next/server`        | Next.js server integration |
+| `@codemation/host/client`             | Browser/client bundle      |
+| `@codemation/host/consumer`           | Consumer-app helpers       |
+| `@codemation/host/credentials`        | Credential-related surface |
+| `@codemation/host/persistence`        | Persistence layer entry    |
+| `@codemation/host/dev-server-sidecar` | Dev-time sidecar/guards    |
+
+The `development` condition in `exports` can resolve TypeScript sources during local work; published builds use `dist`.
+
+## Persistence: TCP PostgreSQL vs PGlite
+
+Codemation uses a **single** Prisma schema (`provider = "postgresql"`). You can run it against either:
+
+- **TCP PostgreSQL** — a normal `postgresql://` or `postgres://` URL (Docker, managed cloud, CI services). Use this for production, shared databases, and any deployment where **multiple processes** need the same database (API + workers, horizontal scale).
+- **PGlite** — embedded Postgres via [`@electric-sql/pglite`](https://github.com/electric-sql/pglite), with the Prisma adapter. Data lives under a directory on disk (default relative path `.codemation/pglite` in the consumer app). **Single-process**; ideal for local dev, quick scaffolding, and tests that do not need a shared server.
+
+### Configuration
+
+In `codemation.config.ts`, `runtime.database` accepts:
+
+| Field           | Meaning                                                                                                               |
+| --------------- | --------------------------------------------------------------------------------------------------------------------- |
+| `kind`          | `"postgresql"` or `"pglite"` (if omitted, inferred from `url` or defaults to PGlite when no postgres URL is present). |
+| `url`           | Required when using TCP Postgres (`postgresql://…`).                                                                  |
+| `pgliteDataDir` | Relative to the **consumer root** or absolute; used when `kind` is `"pglite"` (default: `.codemation/pglite`).        |
+
+Environment overrides (optional; persistence is primarily defined in **`codemation.config.ts`** — use `process.env` **inside** that file if you want `.env` to supply values):
+
+- **`CODEMATION_DATABASE_KIND`** — `postgresql` or `pglite` to force kind.
+- **`CODEMATION_PGLITE_DATA_DIR`** — Path to the PGlite data directory (relative to consumer root or absolute).
+
+### Migrations
+
+`codemation db migrate` and startup migrations both run **`prisma migrate deploy`**: TCP Postgres uses your `runtime.database.url`; PGlite temporarily exposes the data directory on a local Postgres protocol socket ([`@electric-sql/pglite-socket`](https://github.com/electric-sql/pglite-socket)) so the Prisma CLI applies the same migration history as server Postgres.
+
+### Scheduler and PGlite
+
+**BullMQ** (non-local scheduler) requires a **shared** PostgreSQL database. The host **fails fast** at bootstrap if the scheduler is BullMQ and persistence is PGlite. Set `runtime.database` to TCP Postgres when `REDIS_URL` / BullMQ is enabled. The **local** in-process scheduler is compatible with PGlite.
+
+### Integration tests
+
+Point the suite at PGlite or TCP Postgres by setting **`DATABASE_URL`** for the harness factory (`pglite:///…` vs `postgresql://…`) and merging the resulting database into **`CodemationConfig.runtime.database`** (see `mergeIntegrationDatabaseRuntime` in host tests). CI can use a matrix: PGlite vs a Postgres service.
+
+### Gitignore
+
+Ignore the embedded data directory (e.g. `.codemation/pglite`) in consumer repos so PGlite files are not committed.

package/dist/CodemationConfig-XCkSV2dj.d.ts

@@ -0,0 +1,168 @@
+import { n as CodemationLogConfig, o as LoggerFactory, t as CodemationWhitelabelConfig } from "./CodemationWhitelabelConfig-DgbjgtrR.js";
+import { a as EngineExecutionLimitsPolicyConfig, j as WorkflowDefinition, n as Container, r as TypeToken, s as AnyCredentialType } from "./index-Bs4F1IsC.js";
+
+//#region 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 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;
+}
+//#endregion
+//#region src/presentation/config/CodemationClassToken.d.ts
+type CodemationClassToken<TValue> = TypeToken<TValue> & (new (...args: never[]) => TValue);
+//#endregion
+//#region src/presentation/config/CodemationAppContext.d.ts
+interface CodemationRegistrationContextBase {
+  readonly appConfig?: AppConfig;
+  registerCredentialType(type: AnyCredentialType): void;
+  registerNode<TValue>(token: TypeToken<TValue>, implementation?: CodemationClassToken<TValue>): void;
+  registerValue<TValue>(token: TypeToken<TValue>, value: TValue): void;
+  registerClass<TValue>(token: TypeToken<TValue>, implementation: CodemationClassToken<TValue>): void;
+  registerFactory<TValue>(token: TypeToken<TValue>, factory: (container: Container) => TValue): void;
+}
+interface CodemationAppContext extends CodemationRegistrationContextBase {
+  registerWorkflow(workflow: WorkflowDefinition): void;
+  registerWorkflows(workflows: ReadonlyArray<WorkflowDefinition>): void;
+  discoverWorkflows(...directories: ReadonlyArray<string>): void;
+}
+//#endregion
+//#region src/presentation/config/CodemationPlugin.d.ts
+interface CodemationPluginContext extends CodemationRegistrationContextBase {
+  readonly container: Container;
+  readonly appConfig: AppConfig;
+  readonly loggerFactory: LoggerFactory;
+}
+interface CodemationPlugin {
+  /**
+   * Optional npm package name for this plugin (e.g. `"@codemation/core-nodes-gmail"`).
+   * When set, the host merges configured and discovered plugin lists by this id so the same package is not
+   * registered twice when separate module graphs load duplicate class instances (different `constructor` values).
+   */
+  readonly pluginPackageId?: string;
+  register(context: CodemationPluginContext): void | Promise<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" | "pglite";
+interface CodemationDatabaseConfig {
+  readonly kind?: CodemationDatabaseKind;
+  /** TCP PostgreSQL URL when `kind` is `postgresql` (or omitted with a postgres URL). */
+  readonly url?: string;
+  /** Directory for embedded PGlite data when `kind` is `pglite`. Relative paths resolve from the consumer app root. */
+  readonly pgliteDataDir?: 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 { CodemationAuthOidcProviderConfig as C, CodemationAuthOAuthProviderConfig as S, CodemationRegistrationContextBase as _, CodemationConfig as a, CodemationAuthConfig as b, CodemationEngineExecutionLimitsConfig as c, CodemationSchedulerConfig as d, CodemationSchedulerKind as f, CodemationAppContext as g, CodemationPluginContext as h, CodemationApplicationRuntimeConfig as i, CodemationEventBusConfig as l, CodemationPlugin as m, CodemationAppSchedulerConfig as n, CodemationDatabaseConfig as o, CodemationWorkflowDiscovery as p, CodemationAppSchedulerKind as r, CodemationDatabaseKind as s, CodemationAppDefinition as t, CodemationEventBusKind as u, CodemationClassToken as v, CodemationAuthKind as x, AppConfig as y };
+//# sourceMappingURL=CodemationConfig-XCkSV2dj.d.ts.map

package/dist/CodemationConsumerConfigLoader-Dmm2TzAA.d.ts

@@ -0,0 +1,61 @@
+import { a as CodemationConfig } from "./CodemationConfig-XCkSV2dj.js";
+
+//#region src/presentation/server/CodemationConsumerAppResolver.d.ts
+type CodemationConsumerApp = Readonly<{
+  config: CodemationConfig;
+  workflowSources: ReadonlyArray<string>;
+}>;
+declare class CodemationConsumerAppResolver {
+  private readonly configExportsResolver;
+  private readonly configNormalizer;
+  private readonly workflowDefinitionExportsResolver;
+  private readonly discoveredWorkflowsEmptyMessageFactory;
+  resolve(args: Readonly<{
+    configModule: Readonly<Record<string, unknown>>;
+    workflowModules: ReadonlyArray<Readonly<Record<string, unknown>>>;
+    workflowSourcePaths: ReadonlyArray<string>;
+    workflowDiscoveryPathSegmentsList?: ReadonlyArray<readonly string[]>;
+  }>): CodemationConsumerApp;
+  private resolveDiscoveredWorkflows;
+  private mergeWorkflows;
+}
+//#endregion
+//#region src/presentation/server/CodemationConsumerConfigLoader.d.ts
+type CodemationConsumerConfigResolution = Readonly<{
+  config: CodemationConfig;
+  bootstrapSource: string | null;
+  workflowSources: ReadonlyArray<string>;
+}>;
+declare class CodemationConsumerConfigLoader {
+  private static readonly importerRegistrationsByTsconfig;
+  private readonly configExportsResolver;
+  private readonly configNormalizer;
+  private readonly workflowModulePathFinder;
+  private readonly workflowDefinitionExportsResolver;
+  private readonly discoveredWorkflowsEmptyMessageFactory;
+  private readonly pathSegmentsComputer;
+  private readonly performanceDiagnosticsLogger;
+  load(args: Readonly<{
+    consumerRoot: string;
+    configPathOverride?: string;
+  }>): Promise<CodemationConsumerConfigResolution>;
+  private resolveConfigPath;
+  private getConventionCandidates;
+  private resolveWorkflowSources;
+  private loadDiscoveredWorkflows;
+  private mergeWorkflows;
+  private importModule;
+  private importModuleWithNativeRuntime;
+  private resolveTsconfigPath;
+  private getOrCreateImporter;
+  private resetImporter;
+  private toNamespace;
+  private findNearestTsconfig;
+  private createImportSpecifier;
+  private shouldUseNativeRuntimeImport;
+  private isStoppedTransformServiceError;
+  private exists;
+}
+//#endregion
+export { CodemationConsumerAppResolver as i, CodemationConsumerConfigResolution as n, CodemationConsumerApp as r, CodemationConsumerConfigLoader as t };
+//# sourceMappingURL=CodemationConsumerConfigLoader-Dmm2TzAA.d.ts.map

package/dist/CodemationConsumerConfigLoader-scS_RQMy.js

@@ -0,0 +1,334 @@
+import { c as CodemationConfigNormalizer, s as logLevelPolicyFactory, t as ServerLoggerFactory } from "./ServerLoggerFactory-BRHxIDS7.js";
+import { access, readdir, stat } from "node:fs/promises";
+import path from "node:path";
+import { pathToFileURL } from "node:url";
+import { register } from "tsx/esm/api";
+
+//#region src/presentation/server/CodemationConsumerConfigExportsResolver.ts
+var CodemationConsumerConfigExportsResolver = class {
+	resolveConfig(moduleExports) {
+		const defaultExport = moduleExports.default;
+		if (this.isConfig(defaultExport)) return defaultExport;
+		const namedConfig = moduleExports.codemationHost ?? moduleExports.config;
+		if (this.isConfig(namedConfig)) return namedConfig;
+		return null;
+	}
+	isConfig(value) {
+		if (!value || typeof value !== "object") return false;
+		return "app" in value || "register" in value || "credentials" in value || "runtime" in value || "workflows" in value || "workflowDiscovery" in value || "plugins" in value || "whitelabel" in value || "auth" in value || "log" in value;
+	}
+};
+
+//#endregion
+//#region src/presentation/server/DiscoveredWorkflowsEmptyMessageFactory.ts
+var DiscoveredWorkflowsEmptyMessageFactory = class {
+	create(discoveredPaths) {
+		const lines = discoveredPaths.map((p) => `  - ${p}`).join("\n");
+		return [
+			`Discovered ${discoveredPaths.length} file(s) under workflow discovery, but none export a WorkflowDefinition.`,
+			lines,
+			"",
+			"Move shared helpers outside the discovery directories (for example src/lib), or export at least one object with id, name, nodes, and edges from a workflow module."
+		].join("\n");
+	}
+};
+
+//#endregion
+//#region src/presentation/server/WorkflowDefinitionExportsResolver.ts
+/**
+* Collects exported values that match the {@link WorkflowDefinition} shape.
+* Other exports (helpers, constants, type-only re-exports) are ignored.
+*/
+var WorkflowDefinitionExportsResolver = class {
+	resolve(moduleExports) {
+		const workflows = [];
+		for (const exportedValue of Object.values(moduleExports)) if (this.isWorkflowDefinition(exportedValue)) workflows.push(exportedValue);
+		return workflows;
+	}
+	isWorkflowDefinition(value) {
+		if (!value || typeof value !== "object") return false;
+		return "id" in value && "name" in value && "nodes" in value && "edges" in value;
+	}
+};
+
+//#endregion
+//#region src/presentation/server/CodemationConsumerAppResolver.ts
+var CodemationConsumerAppResolver = class {
+	configExportsResolver = new CodemationConsumerConfigExportsResolver();
+	configNormalizer = new CodemationConfigNormalizer();
+	workflowDefinitionExportsResolver = new WorkflowDefinitionExportsResolver();
+	discoveredWorkflowsEmptyMessageFactory = new DiscoveredWorkflowsEmptyMessageFactory();
+	resolve(args) {
+		const rawConfig = this.configExportsResolver.resolveConfig(args.configModule);
+		if (!rawConfig) throw new Error("Consumer app module does not export a Codemation config object.");
+		const config = this.configNormalizer.normalize(rawConfig);
+		const discoveredWorkflows = this.resolveDiscoveredWorkflows(args.workflowModules, args.workflowSourcePaths, args.workflowDiscoveryPathSegmentsList);
+		return {
+			config: {
+				...config,
+				workflows: this.mergeWorkflows(config.workflows ?? [], discoveredWorkflows)
+			},
+			workflowSources: args.workflowSourcePaths
+		};
+	}
+	resolveDiscoveredWorkflows(workflowModules, workflowSourcePaths, workflowDiscoveryPathSegmentsList) {
+		const workflowsById = /* @__PURE__ */ new Map();
+		workflowModules.forEach((workflowModule, index) => {
+			const pathSegments = workflowDiscoveryPathSegmentsList?.[index];
+			this.workflowDefinitionExportsResolver.resolve(workflowModule).forEach((workflow) => {
+				const enriched = pathSegments && pathSegments.length > 0 ? {
+					...workflow,
+					discoveryPathSegments: pathSegments
+				} : workflow;
+				workflowsById.set(workflow.id, enriched);
+			});
+		});
+		if (workflowsById.size === 0 && workflowSourcePaths.length > 0) throw new Error(this.discoveredWorkflowsEmptyMessageFactory.create(workflowSourcePaths));
+		return [...workflowsById.values()];
+	}
+	mergeWorkflows(configuredWorkflows, discoveredWorkflows) {
+		const workflowsById = /* @__PURE__ */ new Map();
+		for (const workflow of discoveredWorkflows) workflowsById.set(workflow.id, workflow);
+		for (const workflow of configuredWorkflows) workflowsById.set(workflow.id, workflow);
+		return [...workflowsById.values()];
+	}
+};
+
+//#endregion
+//#region src/presentation/server/WorkflowModulePathFinder.ts
+var WorkflowModulePathFinder = class WorkflowModulePathFinder {
+	static defaultWorkflowDirectories = ["src/workflows", "workflows"];
+	workflowExtensions = new Set([
+		".ts",
+		".js",
+		".mts",
+		".mjs"
+	]);
+	async discoverModulePaths(args) {
+		const directories = args.workflowDirectories ?? WorkflowModulePathFinder.defaultWorkflowDirectories;
+		const workflowModulePaths = [];
+		for (const directory of directories) {
+			const absoluteDirectory = path.resolve(args.consumerRoot, directory);
+			if (!await args.exists(absoluteDirectory)) continue;
+			workflowModulePaths.push(...await this.collectWorkflowModulePaths(absoluteDirectory));
+		}
+		return workflowModulePaths;
+	}
+	async collectWorkflowModulePaths(directoryPath) {
+		const entries = await readdir(directoryPath, { withFileTypes: true });
+		const workflowModulePaths = [];
+		for (const entry of entries) {
+			const entryPath = path.resolve(directoryPath, entry.name);
+			if (entry.isDirectory()) {
+				workflowModulePaths.push(...await this.collectWorkflowModulePaths(entryPath));
+				continue;
+			}
+			if (this.isWorkflowModulePath(entryPath)) workflowModulePaths.push(entryPath);
+		}
+		return workflowModulePaths;
+	}
+	isWorkflowModulePath(modulePath) {
+		const extension = path.extname(modulePath);
+		return this.workflowExtensions.has(extension) && !modulePath.endsWith(".d.ts");
+	}
+};
+
+//#endregion
+//#region src/presentation/server/WorkflowDiscoveryPathSegmentsComputer.ts
+var WorkflowDiscoveryPathSegmentsComputer = class {
+	compute(args) {
+		const normalizedConsumer = path.resolve(args.consumerRoot);
+		const normalizedWorkflowPath = path.resolve(args.absoluteWorkflowModulePath);
+		const directories = args.workflowDiscoveryDirectories.length > 0 ? args.workflowDiscoveryDirectories : [...WorkflowModulePathFinder.defaultWorkflowDirectories];
+		let bestRoot = null;
+		for (const directory of directories) {
+			const absoluteDirectory = path.resolve(normalizedConsumer, directory);
+			if (!(normalizedWorkflowPath === absoluteDirectory || normalizedWorkflowPath.startsWith(`${absoluteDirectory}${path.sep}`))) continue;
+			if (!bestRoot || absoluteDirectory.length > bestRoot.length) bestRoot = absoluteDirectory;
+		}
+		if (!bestRoot) return;
+		const relative = path.relative(bestRoot, normalizedWorkflowPath);
+		if (relative.startsWith("..") || path.isAbsolute(relative)) return;
+		if (relative.length === 0) return;
+		const parts = relative.split(path.sep).filter((segment) => segment.length > 0);
+		if (parts.length === 0) return;
+		const lastIndex = parts.length - 1;
+		const last = parts[lastIndex] ?? "";
+		const ext = path.extname(last);
+		parts[lastIndex] = ext ? last.slice(0, -ext.length) : last;
+		return parts;
+	}
+};
+
+//#endregion
+//#region src/presentation/server/CodemationConsumerConfigLoader.ts
+var CodemationConsumerConfigLoader = class CodemationConsumerConfigLoader {
+	static importerRegistrationsByTsconfig = /* @__PURE__ */ new Map();
+	configExportsResolver = new CodemationConsumerConfigExportsResolver();
+	configNormalizer = new CodemationConfigNormalizer();
+	workflowModulePathFinder = new WorkflowModulePathFinder();
+	workflowDefinitionExportsResolver = new WorkflowDefinitionExportsResolver();
+	discoveredWorkflowsEmptyMessageFactory = new DiscoveredWorkflowsEmptyMessageFactory();
+	pathSegmentsComputer = new WorkflowDiscoveryPathSegmentsComputer();
+	performanceDiagnosticsLogger = new ServerLoggerFactory(logLevelPolicyFactory).createPerformanceDiagnostics("codemation-config-loader.timing");
+	async load(args) {
+		const loadStarted = performance.now();
+		let mark = loadStarted;
+		const phaseMs = (label) => {
+			const now = performance.now();
+			const delta = now - mark;
+			mark = now;
+			this.performanceDiagnosticsLogger.info(`load.${label} +${delta.toFixed(1)}ms (cumulative ${(now - loadStarted).toFixed(1)}ms)`);
+		};
+		const bootstrapSource = await this.resolveConfigPath(args.consumerRoot, args.configPathOverride);
+		phaseMs("resolveConfigPath");
+		if (!bootstrapSource) throw new Error("Codemation config not found. Expected \"codemation.config.ts\" in the consumer project root or \"src/\".");
+		const moduleExports = await this.importModule(bootstrapSource);
+		phaseMs("importConfigModule");
+		const rawConfig = this.configExportsResolver.resolveConfig(moduleExports);
+		if (!rawConfig) throw new Error(`Config file does not export a Codemation config object: ${bootstrapSource}`);
+		const config = this.configNormalizer.normalize(rawConfig);
+		const workflowSources = await this.resolveWorkflowSources(args.consumerRoot, config);
+		phaseMs("resolveWorkflowSources");
+		const workflows = this.mergeWorkflows(config.workflows ?? [], await this.loadDiscoveredWorkflows(args.consumerRoot, config, workflowSources));
+		phaseMs("loadDiscoveredWorkflows");
+		const resolvedConfig = {
+			...config,
+			workflows
+		};
+		logLevelPolicyFactory.create().applyCodemationLogConfig(resolvedConfig.log);
+		return {
+			config: resolvedConfig,
+			bootstrapSource,
+			workflowSources
+		};
+	}
+	async resolveConfigPath(consumerRoot, configPathOverride) {
+		if (configPathOverride) {
+			const explicitPath = path.isAbsolute(configPathOverride) ? configPathOverride : path.resolve(consumerRoot, configPathOverride);
+			if (!await this.exists(explicitPath)) throw new Error(`Config file not found: ${explicitPath}`);
+			return explicitPath;
+		}
+		for (const candidate of this.getConventionCandidates(consumerRoot)) if (await this.exists(candidate)) return candidate;
+		return null;
+	}
+	getConventionCandidates(consumerRoot) {
+		return [
+			path.resolve(consumerRoot, "codemation.config.ts"),
+			path.resolve(consumerRoot, "codemation.config.js"),
+			path.resolve(consumerRoot, "src", "codemation.config.ts"),
+			path.resolve(consumerRoot, "src", "codemation.config.js")
+		];
+	}
+	async resolveWorkflowSources(consumerRoot, config) {
+		if ((config.workflowDiscovery?.directories?.length ?? 0) === 0) return [];
+		return [...await this.workflowModulePathFinder.discoverModulePaths({
+			consumerRoot,
+			workflowDirectories: config.workflowDiscovery?.directories,
+			exists: (absolutePath) => this.exists(absolutePath)
+		})].sort((left, right) => left.localeCompare(right));
+	}
+	async loadDiscoveredWorkflows(consumerRoot, config, workflowSources) {
+		const workflowDiscoveryDirectories = config.workflowDiscovery?.directories ?? [];
+		const workflowsById = /* @__PURE__ */ new Map();
+		const loadedWorkflowModules = await Promise.all(workflowSources.map(async (workflowSource) => ({
+			workflowSource,
+			segments: this.pathSegmentsComputer.compute({
+				consumerRoot,
+				workflowDiscoveryDirectories,
+				absoluteWorkflowModulePath: workflowSource
+			}),
+			moduleExports: await this.importModule(workflowSource)
+		})));
+		for (const loadedWorkflowModule of loadedWorkflowModules) for (const workflow of this.workflowDefinitionExportsResolver.resolve(loadedWorkflowModule.moduleExports)) {
+			const enriched = loadedWorkflowModule.segments && loadedWorkflowModule.segments.length > 0 ? {
+				...workflow,
+				discoveryPathSegments: loadedWorkflowModule.segments
+			} : workflow;
+			workflowsById.set(workflow.id, enriched);
+		}
+		if (workflowsById.size === 0 && workflowSources.length > 0) throw new Error(this.discoveredWorkflowsEmptyMessageFactory.create(workflowSources));
+		return [...workflowsById.values()];
+	}
+	mergeWorkflows(configuredWorkflows, discoveredWorkflows) {
+		const workflowsById = /* @__PURE__ */ new Map();
+		for (const workflow of discoveredWorkflows) workflowsById.set(workflow.id, workflow);
+		for (const workflow of configuredWorkflows) workflowsById.set(workflow.id, workflow);
+		return [...workflowsById.values()];
+	}
+	async importModule(modulePath) {
+		if (this.shouldUseNativeRuntimeImport()) return await this.importModuleWithNativeRuntime(modulePath);
+		const tsconfigPath = await this.resolveTsconfigPath(modulePath);
+		const importSpecifier = await this.createImportSpecifier(modulePath);
+		for (let attempt = 0; attempt < 3; attempt += 1) try {
+			return await this.getOrCreateImporter(tsconfigPath).import(importSpecifier, import.meta.url);
+		} catch (error) {
+			if (!this.isStoppedTransformServiceError(error) || attempt === 2) throw error;
+			await this.resetImporter(tsconfigPath);
+		}
+		throw new Error(`Failed to import consumer module after retries: ${modulePath}`);
+	}
+	async importModuleWithNativeRuntime(modulePath) {
+		return await import(await this.createImportSpecifier(modulePath));
+	}
+	async resolveTsconfigPath(modulePath) {
+		const overridePath = process.env.CODEMATION_TSCONFIG_PATH;
+		if (overridePath && await this.exists(overridePath)) return overridePath;
+		return await this.findNearestTsconfig(modulePath) ?? false;
+	}
+	getOrCreateImporter(tsconfigPath) {
+		const cacheKey = tsconfigPath || "default";
+		const existingImporter = CodemationConsumerConfigLoader.importerRegistrationsByTsconfig.get(cacheKey);
+		if (existingImporter) return existingImporter;
+		const nextImporter = register({
+			namespace: this.toNamespace(cacheKey),
+			tsconfig: tsconfigPath
+		});
+		CodemationConsumerConfigLoader.importerRegistrationsByTsconfig.set(cacheKey, nextImporter);
+		return nextImporter;
+	}
+	async resetImporter(tsconfigPath) {
+		const cacheKey = tsconfigPath || "default";
+		const existingImporter = CodemationConsumerConfigLoader.importerRegistrationsByTsconfig.get(cacheKey);
+		if (!existingImporter) return;
+		CodemationConsumerConfigLoader.importerRegistrationsByTsconfig.delete(cacheKey);
+		await existingImporter.unregister().catch(() => null);
+	}
+	toNamespace(cacheKey) {
+		return `codemation_consumer_${cacheKey.replace(/[^a-zA-Z0-9_-]+/g, "_")}`;
+	}
+	async findNearestTsconfig(modulePath) {
+		let currentDirectory = path.dirname(modulePath);
+		while (true) {
+			const candidate = path.resolve(currentDirectory, "tsconfig.json");
+			if (await this.exists(candidate)) return candidate;
+			const parentDirectory = path.dirname(currentDirectory);
+			if (parentDirectory === currentDirectory) return null;
+			currentDirectory = parentDirectory;
+		}
+	}
+	async createImportSpecifier(modulePath) {
+		const moduleUrl = pathToFileURL(modulePath);
+		const moduleStats = await stat(modulePath);
+		moduleUrl.searchParams.set("t", String(moduleStats.mtimeMs));
+		return moduleUrl.href;
+	}
+	shouldUseNativeRuntimeImport() {
+		return process.env.CODEMATION_TS_RUNTIME === "ts-node";
+	}
+	isStoppedTransformServiceError(error) {
+		return error instanceof Error && error.message.includes("The service is no longer running");
+	}
+	async exists(filePath) {
+		try {
+			await access(filePath);
+			return true;
+		} catch {
+			return false;
+		}
+	}
+};
+
+//#endregion
+export { CodemationConsumerAppResolver as i, WorkflowDiscoveryPathSegmentsComputer as n, WorkflowModulePathFinder as r, CodemationConsumerConfigLoader as t };
+//# sourceMappingURL=CodemationConsumerConfigLoader-scS_RQMy.js.map