@savvy-web/github-action-builder 2.1.1 → 2.2.0

package/bin/github-action-builder.js

@@ -24,7 +24,7 @@ const rootCommand = Command.make("github-action-builder").pipe(Command.withSubco
 /**
 * CLI application: reads argv from the Stdio service provided by NodeServices.
 */
-const cli = Command.run(rootCommand, { version: "2.1.1" });
+const cli = Command.run(rootCommand, { version: "2.2.0" });
 /**
 * Combined layer: AppLayer + the Node implementations of the CLI
 * environment (FileSystem, Path, Terminal, Stdio, ChildProcessSpawner).

package/cli/commands/build.js

@@ -1,6 +1,6 @@
 import { BuildFailed, ValidationFailed } from "../../errors.js";
-import { BuildService } from "../../services/build.js";
 import { ConfigService } from "../../services/config.js";
+import { BuildService } from "../../services/build.js";
 import { PersistLocalService } from "../../services/persist-local.js";
 import { ValidationService } from "../../services/validation.js";
 import { Console, Effect, Option } from "effect";

package/cli/commands/init.js

@@ -20,7 +20,7 @@ const forceOption = Flag.boolean("force").pipe(Flag.withAlias("f"), Flag.withDes
 * Get current package version (replaced at build time).
 */
 const getPackageVersion = () => {
-	return "2.1.1";
+	return "2.2.0";
 };
 /**
 * Generate package.json content.
@@ -206,7 +206,8 @@ const writeFile = (path, content, force, createdFiles, skippedFiles) => {
 * Init command handler.
 */
 const initHandler = ({ actionName, force }) => Effect.gen(function* () {
-	const projectDir = resolve(process.cwd(), actionName);
+	const cwd = process.cwd();
+	const projectDir = resolve(cwd, actionName);
 	const createdFiles = [];
 	const skippedFiles = [];
 	if (existsSync(projectDir) && !force) {

package/github-action.js

@@ -1,6 +1,6 @@
-import { BuildResultSchema, BuildService } from "./services/build.js";
 import { defineConfig } from "./schemas/config.js";
 import { ConfigService } from "./services/config.js";
+import { BuildResultSchema, BuildService } from "./services/build.js";
 import { PersistLocalResultSchema, PersistLocalService } from "./services/persist-local.js";
 import { ValidationResultSchema, ValidationService } from "./services/validation.js";
 import { AppLayer } from "./layers/app.js";

package/index.d.ts

@@ -925,7 +925,14 @@ declare const ConfigService_base: Context.ServiceClass<ConfigService, "ConfigSer
  *
  * @public
  */
-declare class ConfigService extends ConfigService_base {}
+declare class ConfigService extends ConfigService_base {
+  /**
+   * Production implementation of {@link ConfigService}.
+   *
+   * @public
+   */
+  static readonly layer: Layer.Layer<ConfigService>;
+}
 //#endregion
 //#region src/services/build.d.ts
 /**
@@ -1103,7 +1110,17 @@ declare const BuildService_base: Context.ServiceClass<BuildService, "BuildServic
  *
  * @public
  */
-declare class BuildService extends BuildService_base {}
+declare class BuildService extends BuildService_base {
+  /**
+   * Production implementation of {@link BuildService}.
+   *
+   * @remarks
+   * Uses rsbuild for bundling. Depends on {@link ConfigService}.
+   *
+   * @public
+   */
+  static readonly layer: Layer.Layer<BuildService, never, ConfigService>;
+}
 //#endregion
 //#region src/services/persist-local.d.ts
 /**
@@ -1181,7 +1198,14 @@ declare const PersistLocalService_base: Context.ServiceClass<PersistLocalService
  *
  * @public
  */
-declare class PersistLocalService extends PersistLocalService_base {}
+declare class PersistLocalService extends PersistLocalService_base {
+  /**
+   * Production implementation of {@link PersistLocalService}.
+   *
+   * @public
+   */
+  static readonly layer: Layer.Layer<PersistLocalService>;
+}
 //#endregion
 //#region src/services/validation.d.ts
 /**
@@ -1387,7 +1411,17 @@ declare const ValidationService_base: Context.ServiceClass<ValidationService, "V
  *
  * @public
  */
-declare class ValidationService extends ValidationService_base {}
+declare class ValidationService extends ValidationService_base {
+  /**
+   * Production implementation of {@link ValidationService}.
+   *
+   * @remarks
+   * Depends on {@link ConfigService}.
+   *
+   * @public
+   */
+  static readonly layer: Layer.Layer<ValidationService, never, ConfigService>;
+}
 //#endregion
 //#region src/github-action.d.ts
 /**

package/index.js

@@ -1,7 +1,7 @@
 import { ActionYmlMissing, ActionYmlMissingBase, ActionYmlPathError, ActionYmlPathErrorBase, ActionYmlSchemaError, ActionYmlSchemaErrorBase, ActionYmlSyntaxError, ActionYmlSyntaxErrorBase, BuildFailed, BuildFailedBase, BundleFailed, BundleFailedBase, CleanError, CleanErrorBase, ConfigInvalid, ConfigInvalidBase, ConfigLoadFailed, ConfigLoadFailedBase, ConfigNotFound, ConfigNotFoundBase, EntryFileMissing, EntryFileMissingBase, MainEntryMissing, MainEntryMissingBase, PersistLocalError, PersistLocalErrorBase, ValidationFailed, ValidationFailedBase, WorkerEntryInvalidName, WorkerEntryInvalidNameBase, WorkerEntryMissing, WorkerEntryMissingBase, WriteError, WriteErrorBase } from "./errors.js";
-import { BuildResultSchema, BuildRunnerOptionsSchema, BuildService, BundleResultSchema, BundleStatsSchema } from "./services/build.js";
 import { BuildOptionsSchema, ConfigInputSchema, ConfigSchema, EntriesSchema, PersistLocalOptionsSchema, ValidationOptionsSchema, defineConfig } from "./schemas/config.js";
 import { ConfigService, DetectEntriesResultSchema, DetectedEntrySchema, LoadConfigOptionsSchema } from "./services/config.js";
+import { BuildResultSchema, BuildRunnerOptionsSchema, BuildService, BundleResultSchema, BundleStatsSchema } from "./services/build.js";
 import { PersistLocalResultSchema, PersistLocalRunnerOptionsSchema, PersistLocalService } from "./services/persist-local.js";
 import { ActionYmlResultSchema, ValidateOptionsSchema, ValidationErrorSchema, ValidationResultSchema, ValidationService, ValidationWarningSchema } from "./services/validation.js";
 import { AppLayer, BuildLayer, ConfigLayer, PersistLocalLayer, ValidationLayer } from "./layers/app.js";

package/layers/app.js

@@ -1,7 +1,7 @@
-import { BuildServiceLive } from "../services/build-live.js";
-import { ConfigServiceLive } from "../services/config-live.js";
-import { PersistLocalServiceLive } from "../services/persist-local-live.js";
-import { ValidationServiceLive } from "../services/validation-live.js";
+import { ConfigService } from "../services/config.js";
+import { BuildService } from "../services/build.js";
+import { PersistLocalService } from "../services/persist-local.js";
+import { ValidationService } from "../services/validation.js";
 import { Layer } from "effect";
 
 //#region src/layers/app.ts
@@ -21,7 +21,7 @@ import { Layer } from "effect";
 *
 * @public
 */
-const ConfigLayer = ConfigServiceLive;
+const ConfigLayer = ConfigService.layer;
 /**
 * Layer providing ValidationService (depends on ConfigService).
 *
@@ -30,7 +30,7 @@ const ConfigLayer = ConfigServiceLive;
 *
 * @public
 */
-const ValidationLayer = ValidationServiceLive.pipe(Layer.provide(ConfigServiceLive));
+const ValidationLayer = ValidationService.layer.pipe(Layer.provide(ConfigService.layer));
 /**
 * Layer providing BuildService (depends on ConfigService).
 *
@@ -39,7 +39,7 @@ const ValidationLayer = ValidationServiceLive.pipe(Layer.provide(ConfigServiceLi
 *
 * @public
 */
-const BuildLayer = BuildServiceLive.pipe(Layer.provide(ConfigServiceLive));
+const BuildLayer = BuildService.layer.pipe(Layer.provide(ConfigService.layer));
 /**
 * Layer providing PersistLocalService (no dependencies).
 *
@@ -48,7 +48,7 @@ const BuildLayer = BuildServiceLive.pipe(Layer.provide(ConfigServiceLive));
 *
 * @public
 */
-const PersistLocalLayer = PersistLocalServiceLive;
+const PersistLocalLayer = PersistLocalService.layer;
 /**
 * Combined layer providing all services.
 *
@@ -77,7 +77,7 @@ const PersistLocalLayer = PersistLocalServiceLive;
 *
 * @public
 */
-const AppLayer = Layer.mergeAll(ConfigServiceLive, ValidationLayer, BuildLayer, PersistLocalLayer);
+const AppLayer = Layer.mergeAll(ConfigService.layer, ValidationLayer, BuildLayer, PersistLocalLayer);
 
 //#endregion
 export { AppLayer, BuildLayer, ConfigLayer, PersistLocalLayer, ValidationLayer };

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@savvy-web/github-action-builder",
-	"version": "2.1.1",
+	"version": "2.2.0",
 	"private": false,
 	"description": "A zero-config build tool for creating GitHub Actions from TypeScript. Bundles with rsbuild, validates action.yml against GitHub's schema, and outputs production-ready Node.js 24 actions.",
 	"keywords": [

package/services/build.js

@@ -1,7 +1,24 @@
+import { BundleFailed, CleanError, WriteError } from "../errors.js";
 import { OptionalPathLikeSchema } from "../schemas/path.js";
-import { Context, Schema } from "effect";
+import { ConfigService } from "./config.js";
+import { buildNativeDynamicImportRules } from "./native-dynamic-imports.js";
+import { Context, Effect, Layer, Result, Schema } from "effect";
+import { existsSync, mkdirSync, readFileSync, rmSync, statSync, unlinkSync, writeFileSync } from "node:fs";
+import { basename, resolve } from "node:path";
+import { fileURLToPath } from "node:url";
+import { createRsbuild } from "@rsbuild/core";
 
 //#region src/services/build.ts
+/* v8 ignore start - build service requires actual bundling for integration testing */
+/**
+* BuildService - Effect service for building GitHub Actions.
+*
+* @remarks
+* Provides bundling and build orchestration capabilities
+* using Effect's service pattern with Context.Service.
+*
+* @internal
+*/
 /**
 * Options for the build process.
 * @public
@@ -53,6 +70,216 @@ const BuildResultSchema = Schema.Struct({
 	error: Schema.optional(Schema.String)
 });
 /**
+* Format bytes as a human-readable string.
+*/
+function formatBytes(bytes) {
+	if (bytes < 1024) return `${bytes} B`;
+	if (bytes < 1048576) return `${(bytes / 1024).toFixed(1)} KB`;
+	return `${(bytes / 1048576).toFixed(1)} MB`;
+}
+/**
+* Format build result for terminal output.
+*/
+/* v8 ignore start - formatting function tested via integration */
+function formatBuildResult(result) {
+	const lines = [];
+	if (result.success) {
+		lines.push("Build Summary:");
+		for (const entry of result.entries) if (entry.success && entry.stats) {
+			const { entry: name, size, duration, outputPath } = entry.stats;
+			lines.push(`  ✓ ${name}: ${formatBytes(size)} (${duration}ms) → ${outputPath}`);
+		}
+		lines.push(`\nTotal time: ${result.duration}ms`);
+	} else {
+		lines.push("Build Failed:");
+		for (const entry of result.entries) if (!entry.success) lines.push(`  ✗ ${entry.error}`);
+	}
+	return lines.join("\n");
+}
+/* v8 ignore stop */
+/**
+* Source of the stub module that replaces packages listed in `build.ignore`.
+* It is bundled in place of the real module and throws if ever loaded.
+*/
+const IGNORE_STUB_SOURCE = `throw new Error("A module excluded via the build 'ignore' option was loaded at runtime.");\n`;
+/**
+* Self-referencing specifier for the `webpackIgnore`-injecting loader
+* shipped from `public/loaders/webpack-ignore-dynamic-imports.cjs` (see
+* `package.json` `exports`). Resolved through the package's own `exports`
+* map via `import.meta.resolve`, which stays correct whether this module is
+* running from `src` (the map points at `./public/loaders/...`) or from a
+* built `dist` (the map points at the flattened `./loaders/...`, since the
+* `public/` copy step drops the `public/` prefix both on disk and in the
+* built manifest) — no relative-path assumption needed either way.
+*/
+const WEBPACK_IGNORE_LOADER_SPECIFIER = "@savvy-web/github-action-builder/loaders/webpack-ignore-dynamic-imports.cjs";
+/**
+* Resolve the absolute on-disk path to the `webpackIgnore`-injecting loader.
+*/
+function resolveWebpackIgnoreLoaderPath() {
+	return fileURLToPath(import.meta.resolve(WEBPACK_IGNORE_LOADER_SPECIFIER));
+}
+/**
+* Clean output directory.
+*/
+function cleanDirectory(dir) {
+	return Effect.try({
+		try: () => {
+			if (existsSync(dir)) rmSync(dir, {
+				recursive: true,
+				force: true
+			});
+		},
+		/* v8 ignore next 5 - error branch requires fs permission failures */
+		catch: (error) => new CleanError({
+			directory: dir,
+			cause: error
+		})
+	});
+}
+/**
+* Write file with directory creation.
+*/
+function writeFile(path, content) {
+	return Effect.try({
+		try: () => {
+			const dir = resolve(path, "..");
+			mkdirSync(dir, { recursive: true });
+			writeFileSync(path, content, "utf8");
+		},
+		/* v8 ignore next 5 - error branch requires fs permission failures */
+		catch: (error) => new WriteError({
+			path,
+			cause: error
+		})
+	});
+}
+/**
+* Fold an extracted `*.LICENSE.txt` sidecar back into its bundle.
+*
+* `legalComments: "linked"` is the only mode whose extraction actually sees
+* bundled license banners — the "inline" mode's SWC comment-preservation path
+* never receives them and silently drops attribution (verified against
+* rsbuild 2.1.8). A committed action still must not carry sidecar files
+* (issue #94), so the sidecar's verbatim comment blocks replace the
+* `LICENSE:` reference banner in the bundle and the sidecar is deleted —
+* attribution inline, no extra dist file.
+*/
+function inlineLicenseSidecar(outputPath) {
+	return Effect.try({
+		try: () => {
+			const sidecarPath = `${outputPath}.LICENSE.txt`;
+			if (!existsSync(sidecarPath)) return;
+			const licenses = readFileSync(sidecarPath, "utf8").trim();
+			const bundle = readFileSync(outputPath, "utf8");
+			const reference = `/*! LICENSE: ${basename(sidecarPath)} */`;
+			const afterReference = bundle.startsWith(reference) && bundle.charAt(reference.length) === "\n" ? reference.length + 1 : bundle.startsWith(reference) ? reference.length : 0;
+			const folded = `${licenses}\n${bundle.slice(afterReference)}`;
+			writeFileSync(outputPath, folded, "utf8");
+			unlinkSync(sidecarPath);
+		},
+		/* v8 ignore next 5 - error branch requires fs permission failures */
+		catch: (error) => new WriteError({
+			path: outputPath,
+			cause: error
+		})
+	});
+}
+/**
+* Bundle a single entry with rsbuild.
+*/
+/* v8 ignore start - bundling requires actual rsbuild execution */
+function bundleEntry(entry, config, cwd) {
+	return Effect.gen(function* () {
+		const startTime = Date.now();
+		const outputDir = resolve(cwd, "dist");
+		const externalsSet = new Set(config.build.externals);
+		const ignoreSet = new Set(config.build.ignore);
+		const ignoreAlias = {};
+		// webpackIgnore-injecting loader below leaves those calls as native
+		const nativeDynamicImportRules = config.build.nativeDynamicImports.length > 0 ? buildNativeDynamicImportRules(config.build.nativeDynamicImports, resolveWebpackIgnoreLoaderPath()) : [];
+		if (config.build.ignore.length > 0) {
+			const stubPath = resolve(cwd, "node_modules", ".cache", "github-action-builder", "ignore-stub.mjs");
+			yield* writeFile(stubPath, IGNORE_STUB_SOURCE);
+			for (const moduleName of config.build.ignore) ignoreAlias[`${moduleName}$`] = stubPath;
+		}
+		const rsbuild = yield* Effect.tryPromise({
+			try: () => createRsbuild({ rsbuildConfig: {
+				mode: "production",
+				source: { entry: { [entry.type]: entry.path } },
+				resolve: { alias: ignoreAlias },
+				output: {
+					target: "node",
+					module: true,
+					distPath: { root: outputDir },
+					filename: { js: "[name].js" },
+					externals: (data) => {
+						const request = data.request;
+						if (!request) return false;
+						if (request.startsWith("node:")) return `node-commonjs ${request}`;
+						if (externalsSet.has(request) && !ignoreSet.has(request)) return request;
+						return false;
+					},
+					cleanDistPath: false,
+					legalComments: "linked",
+					minify: config.build.minify,
+					sourceMap: config.build.sourceMap ? { js: "source-map" } : false
+				},
+				performance: { chunkSplit: { strategy: "all-in-one" } },
+				tools: { rspack: {
+					node: {
+						__dirname: "node-module",
+						__filename: "node-module"
+					},
+					module: {
+						parser: { javascript: { importMeta: false } },
+						// webpackIgnore-injecting loader (empty when the option is unset).
+						rules: nativeDynamicImportRules
+					},
+					output: { asyncChunks: false }
+				} }
+			} }),
+			catch: (error) => new BundleFailed({
+				entry: entry.path,
+				cause: error
+			})
+		});
+		const buildResult = yield* Effect.tryPromise({
+			try: () => rsbuild.build(),
+			catch: (error) => new BundleFailed({
+				entry: entry.path,
+				cause: error
+			})
+		});
+		yield* Effect.tryPromise({
+			try: () => buildResult.close(),
+			catch: (error) => new BundleFailed({
+				entry: entry.path,
+				cause: /* @__PURE__ */ new Error(`rsbuild close() failed: ${error}`)
+			})
+		});
+		const outputPath = resolve(outputDir, `${entry.type}.js`);
+		yield* inlineLicenseSidecar(outputPath);
+		const size = yield* Effect.try({
+			try: () => statSync(outputPath).size,
+			catch: (error) => new BundleFailed({
+				entry: entry.path,
+				cause: error
+			})
+		});
+		const duration = Date.now() - startTime;
+		return {
+			success: true,
+			stats: {
+				entry: entry.type,
+				size,
+				duration,
+				outputPath: entry.output
+			}
+		};
+	});
+}
+/**
 * BuildService key for dependency injection.
 *
 * @example Using BuildService with Effect
@@ -77,7 +304,64 @@ const BuildResultSchema = Schema.Struct({
 *
 * @public
 */
-var BuildService = class extends Context.Service()("BuildService") {};
+var BuildService = class extends Context.Service()("BuildService") {
+	/**
+	* Production implementation of {@link BuildService}.
+	*
+	* @remarks
+	* Uses rsbuild for bundling. Depends on {@link ConfigService}.
+	*
+	* @public
+	*/
+	static layer = Layer.effect(this, Effect.gen(function* () {
+		const configService = yield* ConfigService;
+		return {
+			/* v8 ignore start - build execution requires actual rsbuild bundling */
+			build: (config, options = {}) => Effect.gen(function* () {
+				const cwd = options.cwd ?? process.cwd();
+				const shouldClean = options.clean ?? true;
+				const startTime = Date.now();
+				const entriesConfig = { main: config.entries.main };
+				if (config.entries.pre) entriesConfig.pre = config.entries.pre;
+				if (config.entries.post) entriesConfig.post = config.entries.post;
+				if (config.entries.workers) entriesConfig.workers = config.entries.workers;
+				const entriesResult = yield* configService.detectEntries(cwd, entriesConfig);
+				if (shouldClean) yield* cleanDirectory(resolve(cwd, "dist"));
+				const entryResults = [];
+				for (const entry of entriesResult.entries) {
+					const result = yield* Effect.result(bundleEntry(entry, config, cwd));
+					if (Result.isFailure(result)) {
+						const err = result.failure;
+						entryResults.push({
+							success: false,
+							error: err.cause instanceof Error ? err.cause.message : String(err.cause)
+						});
+					} else entryResults.push(result.success);
+				}
+				yield* writeFile(resolve(cwd, "dist/package.json"), "{ \"type\": \"module\" }");
+				const duration = Date.now() - startTime;
+				const success = entryResults.every((r) => r.success);
+				if (!success) return {
+					success,
+					entries: entryResults,
+					duration,
+					error: "One or more entries failed to build"
+				};
+				return {
+					success,
+					entries: entryResults,
+					duration
+				};
+			}),
+			/* v8 ignore stop */
+			bundle: (entry, config) => bundleEntry(entry, config, process.cwd()),
+			clean: (outputDir) => cleanDirectory(outputDir),
+			formatResult: formatBuildResult,
+			formatBytes
+		};
+	}));
+};
+/* v8 ignore stop */
 
 //#endregion
 export { BuildResultSchema, BuildRunnerOptionsSchema, BuildService, BundleResultSchema, BundleStatsSchema };

package/services/config.js

@@ -1,9 +1,59 @@
+import { ConfigInvalid, ConfigLoadFailed, ConfigNotFound, MainEntryMissing, WorkerEntryInvalidName, WorkerEntryMissing } from "../errors.js";
 import { OptionalPathLikeSchema } from "../schemas/path.js";
-import { ConfigSchema } from "../schemas/config.js";
-import { Context, Schema } from "effect";
+import { ConfigSchema, defineConfig } from "../schemas/config.js";
+import { Context, Effect, Layer, Schema } from "effect";
+import { existsSync } from "node:fs";
+import { resolve } from "node:path";
+import { createJiti } from "jiti";
 
 //#region src/services/config.ts
 /**
+* ConfigService - Effect service for configuration management.
+*
+* @remarks
+* Provides configuration loading, resolution, and entry point detection
+* using Effect's service pattern with Context.Service.
+*
+* @internal
+*/
+const CONFIG_FILENAMES = [
+	"action.config.ts",
+	"action.config.js",
+	"action.config.mjs"
+];
+const DEFAULT_ENTRIES = {
+	main: "src/main.ts",
+	pre: "src/pre.ts",
+	post: "src/post.ts"
+};
+/** Lifecycle bundle names a worker entry must not reuse — they own `dist/main.js` etc. */
+const RESERVED_ENTRY_NAMES = /* @__PURE__ */ new Set([
+	"main",
+	"pre",
+	"post"
+]);
+/**
+* Find config file in the given directory.
+*/
+function findConfigFile(cwd) {
+	for (const filename of CONFIG_FILENAMES) {
+		const configPath = resolve(cwd, filename);
+		if (existsSync(configPath)) return configPath;
+	}
+}
+/**
+* Detect a single optional entry.
+*/
+function detectOptionalEntry(cwd, type, explicitPath) {
+	const defaultPath = DEFAULT_ENTRIES[type];
+	const absolutePath = resolve(cwd, explicitPath ?? defaultPath);
+	if (existsSync(absolutePath)) return {
+		type,
+		path: absolutePath,
+		output: `dist/${type}.js`
+	};
+}
+/**
 * Options for loading configuration.
 * @public
 */
@@ -75,7 +125,95 @@ const LoadConfigResultSchema = Schema.Struct({
 *
 * @public
 */
-var ConfigService = class extends Context.Service()("ConfigService") {};
+var ConfigService = class extends Context.Service()("ConfigService") {
+	/**
+	* Production implementation of {@link ConfigService}.
+	*
+	* @public
+	*/
+	static layer = Layer.succeed(this, {
+		load: (options = {}) => Effect.gen(function* () {
+			const cwd = options.cwd ?? process.cwd();
+			const configPath = options.configPath ?? findConfigFile(cwd);
+			if (!configPath) return {
+				config: defineConfig({}),
+				usingDefaults: true
+			};
+			/* v8 ignore start - requires explicit configPath to non-existent file */
+			if (!existsSync(configPath)) return yield* Effect.fail(new ConfigNotFound({
+				path: configPath,
+				message: "Specified config file does not exist"
+			}));
+			/* v8 ignore stop */
+			const absolutePath = resolve(cwd, configPath);
+			/* v8 ignore stop */
+			const configInput = (yield* Effect.tryPromise({
+				try: async () => {
+					if (absolutePath.endsWith(".ts")) return createJiti(absolutePath, { interopDefault: true }).import(absolutePath);
+					return import(absolutePath);
+				},
+				catch: (error) => new ConfigLoadFailed({
+					path: configPath,
+					cause: error
+				})
+			})).default;
+			/* v8 ignore start - requires config file with non-object default export */
+			if (!configInput || typeof configInput !== "object") return yield* Effect.fail(new ConfigInvalid({
+				path: configPath,
+				errors: ["Config file must export a default configuration object"]
+			}));
+			return {
+				config: defineConfig(configInput),
+				configPath,
+				usingDefaults: false
+			};
+		}),
+		resolve: (input = {}) => Effect.succeed(defineConfig(input)),
+		detectEntries: (cwd, entries) => Effect.gen(function* () {
+			const detected = [];
+			const mainPath = entries?.main ?? DEFAULT_ENTRIES.main;
+			const absoluteMainPath = resolve(cwd, mainPath);
+			if (!existsSync(absoluteMainPath)) return yield* Effect.fail(new MainEntryMissing({
+				expectedPath: mainPath,
+				cwd
+			}));
+			detected.push({
+				type: "main",
+				path: absoluteMainPath,
+				output: "dist/main.js"
+			});
+			const preEntry = detectOptionalEntry(cwd, "pre", entries?.pre);
+			if (preEntry) detected.push(preEntry);
+			const postEntry = detectOptionalEntry(cwd, "post", entries?.post);
+			if (postEntry) detected.push(postEntry);
+			for (const [name, workerPath] of Object.entries(entries?.workers ?? {})) {
+				if (RESERVED_ENTRY_NAMES.has(name)) return yield* Effect.fail(new WorkerEntryInvalidName({
+					workerName: name,
+					reason: `"${name}" is a reserved lifecycle bundle name (main/pre/post)`
+				}));
+				if (name.length === 0 || name.includes("/") || name.includes("\\") || name.includes("..")) return yield* Effect.fail(new WorkerEntryInvalidName({
+					workerName: name,
+					reason: "worker names must be non-empty and free of path separators"
+				}));
+				const absoluteWorkerPath = resolve(cwd, workerPath);
+				if (!existsSync(absoluteWorkerPath)) return yield* Effect.fail(new WorkerEntryMissing({
+					workerName: name,
+					expectedPath: workerPath,
+					cwd
+				}));
+				detected.push({
+					type: name,
+					path: absoluteWorkerPath,
+					output: `dist/${name}.js`
+				});
+			}
+			return {
+				success: true,
+				entries: detected
+			};
+		})
+	});
+};
 
 //#endregion
 export { ConfigService, DetectEntriesResultSchema, DetectedEntrySchema, LoadConfigOptionsSchema };