@savvy-web/github-action-builder 0.7.4 → 0.7.6

package/948.js

@@ -1,931 +0,0 @@
-import { Context, Data, Effect, Layer, ParseResult, Schema } from "effect";
-import { copyFileSync, existsSync, mkdirSync, readFileSync, readdirSync, rmSync, statSync, writeFileSync } from "node:fs";
-import { dirname, join, relative, resolve } from "node:path";
-import { createRsbuild } from "@rsbuild/core";
-import { fileURLToPath } from "node:url";
-import { createJiti } from "jiti";
-import { createHash } from "node:crypto";
-import { parse } from "yaml-effect";
-import { __webpack_require__ } from "./231.js";
-const ConfigNotFoundBase = Data.TaggedError("ConfigNotFound");
-class ConfigNotFound extends ConfigNotFoundBase {
-}
-const ConfigInvalidBase = Data.TaggedError("ConfigInvalid");
-class ConfigInvalid extends ConfigInvalidBase {
-}
-const ConfigLoadFailedBase = Data.TaggedError("ConfigLoadFailed");
-class ConfigLoadFailed extends ConfigLoadFailedBase {
-}
-const MainEntryMissingBase = Data.TaggedError("MainEntryMissing");
-class MainEntryMissing extends MainEntryMissingBase {
-}
-const EntryFileMissingBase = Data.TaggedError("EntryFileMissing");
-class EntryFileMissing extends (231 == __webpack_require__.j ? EntryFileMissingBase : null) {
-}
-const ActionYmlMissingBase = Data.TaggedError("ActionYmlMissing");
-class ActionYmlMissing extends ActionYmlMissingBase {
-}
-const ActionYmlSyntaxErrorBase = Data.TaggedError("ActionYmlSyntaxError");
-class ActionYmlSyntaxError extends ActionYmlSyntaxErrorBase {
-}
-const ActionYmlSchemaErrorBase = Data.TaggedError("ActionYmlSchemaError");
-class ActionYmlSchemaError extends ActionYmlSchemaErrorBase {
-}
-const ValidationFailedBase = Data.TaggedError("ValidationFailed");
-class ValidationFailed extends ValidationFailedBase {
-}
-const BundleFailedBase = Data.TaggedError("BundleFailed");
-class BundleFailed extends BundleFailedBase {
-}
-const WriteErrorBase = Data.TaggedError("WriteError");
-class WriteError extends WriteErrorBase {
-}
-const CleanErrorBase = Data.TaggedError("CleanError");
-class CleanError extends CleanErrorBase {
-}
-const BuildFailedBase = Data.TaggedError("BuildFailed");
-class BuildFailed extends BuildFailedBase {
-}
-const PersistLocalErrorBase = Data.TaggedError("PersistLocalError");
-class PersistLocalError extends PersistLocalErrorBase {
-}
-const ActionYmlPathErrorBase = Data.TaggedError("ActionYmlPathError");
-class ActionYmlPathError extends ActionYmlPathErrorBase {
-}
-function pathLikeToString(pathLike) {
-    if ("string" == typeof pathLike) return pathLike;
-    if (Buffer.isBuffer(pathLike)) return pathLike.toString("utf8");
-    if (pathLike instanceof URL) return fileURLToPath(pathLike);
-    return String(pathLike);
-}
-const PathLikeSchema = Schema.transform(Schema.Union(Schema.String, Schema.instanceOf(Buffer), Schema.instanceOf(URL)), Schema.String, {
-    strict: true,
-    decode: (pathLike)=>pathLikeToString(pathLike),
-    encode: (s)=>s
-});
-const OptionalPathLikeSchema = Schema.optional(PathLikeSchema);
-const BuildRunnerOptionsSchema = Schema.Struct({
-    cwd: OptionalPathLikeSchema,
-    clean: Schema.optional(Schema.Boolean)
-});
-const BundleStatsSchema = Schema.Struct({
-    entry: Schema.String,
-    size: Schema.Number,
-    duration: Schema.Number,
-    outputPath: Schema.String
-});
-const BundleResultSchema = Schema.Struct({
-    success: Schema.Boolean,
-    stats: Schema.optional(BundleStatsSchema),
-    error: Schema.optional(Schema.String)
-});
-const BuildResultSchema = Schema.Struct({
-    success: Schema.Boolean,
-    entries: Schema.Array(BundleResultSchema),
-    duration: Schema.Number,
-    error: Schema.optional(Schema.String)
-});
-const BuildService = Context.GenericTag("BuildService");
-const EntriesSchema = Schema.Struct({
-    main: Schema.optionalWith(Schema.String, {
-        default: ()=>"src/main.ts"
-    }),
-    pre: Schema.optional(Schema.String),
-    post: Schema.optional(Schema.String)
-});
-const BuildOptionsSchema = Schema.Struct({
-    minify: Schema.optionalWith(Schema.Boolean, {
-        default: ()=>true
-    }),
-    sourceMap: Schema.optionalWith(Schema.Boolean, {
-        default: ()=>false
-    }),
-    externals: Schema.optionalWith(Schema.Array(Schema.String), {
-        default: ()=>[]
-    }),
-    ignore: Schema.optionalWith(Schema.Array(Schema.String), {
-        default: ()=>[]
-    })
-});
-const ValidationOptionsSchema = Schema.Struct({
-    requireActionYml: Schema.optionalWith(Schema.Boolean, {
-        default: ()=>true
-    }),
-    maxBundleSize: Schema.optional(Schema.String),
-    strict: Schema.optional(Schema.Boolean)
-});
-const PersistLocalOptionsSchema = Schema.Struct({
-    enabled: Schema.optionalWith(Schema.Boolean, {
-        default: ()=>true
-    }),
-    path: Schema.optionalWith(Schema.String, {
-        default: ()=>".github/actions/local"
-    }),
-    actTemplate: Schema.optionalWith(Schema.Boolean, {
-        default: ()=>true
-    })
-});
-const ConfigInputSchema = Schema.Struct({
-    entries: Schema.optional(Schema.Struct({
-        main: Schema.optional(Schema.String),
-        pre: Schema.optional(Schema.String),
-        post: Schema.optional(Schema.String)
-    })),
-    build: Schema.optional(Schema.Struct({
-        minify: Schema.optional(Schema.Boolean),
-        sourceMap: Schema.optional(Schema.Boolean),
-        externals: Schema.optional(Schema.Array(Schema.String)),
-        ignore: Schema.optional(Schema.Array(Schema.String))
-    })),
-    validation: Schema.optional(Schema.Struct({
-        requireActionYml: Schema.optional(Schema.Boolean),
-        maxBundleSize: Schema.optional(Schema.String),
-        strict: Schema.optional(Schema.Boolean)
-    })),
-    persistLocal: Schema.optional(Schema.Struct({
-        enabled: Schema.optional(Schema.Boolean),
-        path: Schema.optional(Schema.String),
-        actTemplate: Schema.optional(Schema.Boolean)
-    }))
-});
-const ConfigSchema = Schema.Struct({
-    entries: EntriesSchema,
-    build: BuildOptionsSchema,
-    validation: ValidationOptionsSchema,
-    persistLocal: PersistLocalOptionsSchema
-});
-function defineConfig(config = {}) {
-    return Schema.decodeUnknownSync(ConfigSchema)({
-        entries: config.entries ?? {},
-        build: config.build ?? {},
-        validation: config.validation ?? {},
-        persistLocal: config.persistLocal ?? {}
-    });
-}
-const LoadConfigOptionsSchema = Schema.Struct({
-    cwd: OptionalPathLikeSchema,
-    configPath: OptionalPathLikeSchema
-});
-const EntryTypeSchema = Schema.Literal("main", "pre", "post");
-const DetectedEntrySchema = Schema.Struct({
-    type: EntryTypeSchema,
-    path: Schema.String,
-    output: Schema.String
-});
-const DetectEntriesResultSchema = Schema.Struct({
-    success: Schema.Boolean,
-    entries: Schema.Array(DetectedEntrySchema)
-});
-Schema.Struct({
-    config: ConfigSchema,
-    configPath: Schema.optional(Schema.String),
-    usingDefaults: Schema.Boolean
-});
-const ConfigService = Context.GenericTag("ConfigService");
-const IGNORE_STUB_SOURCE = `throw new Error("A module excluded via the build 'ignore' option was loaded at runtime.");\n`;
-function formatBytes(bytes) {
-    if (bytes < 1024) return `${bytes} B`;
-    if (bytes < 1048576) return `${(bytes / 1024).toFixed(1)} KB`;
-    return `${(bytes / 1048576).toFixed(1)} MB`;
-}
-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");
-}
-function cleanDirectory(dir) {
-    return Effect["try"]({
-        try: ()=>{
-            if (existsSync(dir)) rmSync(dir, {
-                recursive: true,
-                force: true
-            });
-        },
-        catch: (error)=>new CleanError({
-                directory: dir,
-                cause: error
-            })
-    });
-}
-function writeFile(path, content) {
-    return Effect["try"]({
-        try: ()=>{
-            const dir = resolve(path, "..");
-            mkdirSync(dir, {
-                recursive: true
-            });
-            writeFileSync(path, content, "utf8");
-        },
-        catch: (error)=>new WriteError({
-                path,
-                cause: error
-            })
-    });
-}
-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 = {};
-        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: {
-                        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: "inline",
-                            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"
-                                },
-                                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: new Error(`rsbuild close() failed: ${error}`)
-                })
-        });
-        const outputPath = resolve(outputDir, `${entry.type}.js`);
-        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
-            }
-        };
-    });
-}
-const BuildServiceLive = Layer.effect(BuildService, Effect.gen(function*() {
-    const configService = yield* ConfigService;
-    return {
-        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;
-                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.either(bundleEntry(entry, config, cwd));
-                    if ("Left" === result._tag) {
-                        const err = result.left;
-                        entryResults.push({
-                            success: false,
-                            error: err.cause instanceof Error ? err.cause.message : String(err.cause)
-                        });
-                    } else entryResults.push(result.right);
-                }
-                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
-                };
-            }),
-        bundle: (entry, config)=>bundleEntry(entry, config, process.cwd()),
-        clean: (outputDir)=>cleanDirectory(outputDir),
-        formatResult: formatBuildResult,
-        formatBytes: formatBytes
-    };
-}));
-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"
-};
-function findConfigFile(cwd) {
-    for (const filename of CONFIG_FILENAMES){
-        const configPath = resolve(cwd, filename);
-        if (existsSync(configPath)) return configPath;
-    }
-}
-function detectOptionalEntry(cwd, type, explicitPath) {
-    const defaultPath = DEFAULT_ENTRIES[type];
-    const entryPath = explicitPath ?? defaultPath;
-    const absolutePath = resolve(cwd, entryPath);
-    if (existsSync(absolutePath)) return {
-        type,
-        path: absolutePath,
-        output: `dist/${type}.js`
-    };
-}
-const ConfigServiceLive = Layer.succeed(ConfigService, {
-    load: (options = {})=>Effect.gen(function*() {
-            const cwd = options.cwd ?? process.cwd();
-            const configPath = options.configPath ?? findConfigFile(cwd);
-            if (!configPath) return {
-                config: defineConfig({}),
-                usingDefaults: true
-            };
-            if (!existsSync(configPath)) return yield* Effect.fail(new ConfigNotFound({
-                path: configPath,
-                message: "Specified config file does not exist"
-            }));
-            const absolutePath = resolve(cwd, configPath);
-            const configModule = yield* Effect.tryPromise({
-                try: async ()=>{
-                    if (absolutePath.endsWith(".ts")) {
-                        const jiti = createJiti(absolutePath, {
-                            interopDefault: true
-                        });
-                        return jiti.import(absolutePath);
-                    }
-                    return import(absolutePath);
-                },
-                catch: (error)=>new ConfigLoadFailed({
-                        path: configPath,
-                        cause: error
-                    })
-            });
-            const configInput = configModule.default;
-            if (!configInput || "object" != typeof configInput) return yield* Effect.fail(new ConfigInvalid({
-                path: configPath,
-                errors: [
-                    "Config file must export a default configuration object"
-                ]
-            }));
-            const config = defineConfig(configInput);
-            return {
-                config,
-                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);
-            return {
-                success: true,
-                entries: detected
-            };
-        })
-});
-const PersistLocalRunnerOptionsSchema = Schema.Struct({
-    cwd: Schema.optional(Schema.String)
-});
-const PersistLocalResultSchema = Schema.Struct({
-    success: Schema.Boolean,
-    filesCopied: Schema.Number,
-    filesSkipped: Schema.Number,
-    actTemplateGenerated: Schema.Boolean,
-    outputPath: Schema.String,
-    error: Schema.optional(Schema.String)
-});
-const PersistLocalService = Context.GenericTag("PersistLocalService");
-function fileHash(filePath) {
-    const content = readFileSync(filePath);
-    return createHash("sha256").update(content).digest("hex");
-}
-function syncFile(src, dest) {
-    if (existsSync(dest)) {
-        const srcHash = fileHash(src);
-        const destHash = fileHash(dest);
-        if (srcHash === destHash) return false;
-    }
-    mkdirSync(dirname(dest), {
-        recursive: true
-    });
-    copyFileSync(src, dest);
-    return true;
-}
-function walkDirectory(dir, base = dir) {
-    const files = [];
-    if (!existsSync(dir)) return files;
-    for (const entry of readdirSync(dir, {
-        withFileTypes: true
-    })){
-        const fullPath = join(dir, entry.name);
-        if (entry.isDirectory()) files.push(...walkDirectory(fullPath, base));
-        else files.push(relative(base, fullPath));
-    }
-    return files;
-}
-function syncDirectory(srcDir, destDir) {
-    const stats = {
-        copied: 0,
-        skipped: 0
-    };
-    const srcFiles = walkDirectory(srcDir);
-    for (const relPath of srcFiles){
-        const copied = syncFile(join(srcDir, relPath), join(destDir, relPath));
-        if (copied) stats.copied++;
-        else stats.skipped++;
-    }
-    const srcFileSet = new Set(srcFiles);
-    const destFiles = walkDirectory(destDir);
-    for (const relPath of destFiles)if (!srcFileSet.has(relPath)) {
-        rmSync(join(destDir, relPath), {
-            force: true
-        });
-        let parent = dirname(join(destDir, relPath));
-        while(parent !== destDir && existsSync(parent)){
-            const entries = readdirSync(parent);
-            if (0 === entries.length) {
-                rmSync(parent, {
-                    recursive: true
-                });
-                parent = dirname(parent);
-            } else break;
-        }
-    }
-    return stats;
-}
-function validateActionYmlPaths(actionYmlPath, destDir) {
-    return Effect.gen(function*() {
-        if (!existsSync(actionYmlPath)) return;
-        const content = readFileSync(actionYmlPath, "utf8");
-        const parsed = yield* parse(content).pipe(Effect.catchAll(()=>Effect.succeed(null)));
-        if (!parsed?.runs) return;
-        for (const entryType of [
-            "main",
-            "pre",
-            "post"
-        ]){
-            const specifiedPath = parsed.runs[entryType];
-            if (!specifiedPath) continue;
-            const expectedPath = resolve(destDir, specifiedPath);
-            if (!existsSync(expectedPath)) return yield* Effect.fail(new ActionYmlPathError({
-                entryType,
-                specifiedPath,
-                expectedPath
-            }));
-        }
-    });
-}
-const ACTRC_CONTENT = `--container-architecture linux/amd64
--W .github/workflows/act-test.yml
-`;
-const ACT_WORKFLOW_CONTENT = `name: Local Test
-on:
-  workflow_dispatch:
-
-jobs:
-  test:
-    runs-on: ubuntu-latest
-    steps:
-      - uses: actions/checkout@v6
-      - uses: ./.github/actions/local
-`;
-function formatPersistResult(result) {
-    const lines = [];
-    if (result.success) {
-        lines.push("Persist Local Summary:");
-        lines.push(`  Output: ${result.outputPath}`);
-        lines.push(`  Files copied: ${result.filesCopied}`);
-        lines.push(`  Files skipped (unchanged): ${result.filesSkipped}`);
-        if (result.actTemplateGenerated) lines.push("  Act template files generated");
-    } else lines.push(`Persist Local Failed: ${result.error}`);
-    return lines.join("\n");
-}
-const PersistLocalServiceLive = Layer.succeed(PersistLocalService, {
-    persist: (config, options = {})=>Effect.gen(function*() {
-            const cwd = options.cwd ?? process.cwd();
-            const outputPath = resolve(cwd, config.persistLocal.path);
-            if (!config.persistLocal.enabled) return {
-                success: true,
-                filesCopied: 0,
-                filesSkipped: 0,
-                actTemplateGenerated: false,
-                outputPath
-            };
-            yield* Effect["try"]({
-                try: ()=>mkdirSync(outputPath, {
-                        recursive: true
-                    }),
-                catch: (error)=>new PersistLocalError({
-                        path: outputPath,
-                        cause: error
-                    })
-            });
-            let totalCopied = 0;
-            let totalSkipped = 0;
-            const actionYmlSrc = resolve(cwd, "action.yml");
-            const actionYmlDest = resolve(outputPath, "action.yml");
-            if (existsSync(actionYmlSrc)) {
-                const copied = yield* Effect["try"]({
-                    try: ()=>syncFile(actionYmlSrc, actionYmlDest),
-                    catch: (error)=>new PersistLocalError({
-                            path: actionYmlSrc,
-                            cause: error
-                        })
-                });
-                if (copied) totalCopied++;
-                else totalSkipped++;
-            } else if (existsSync(actionYmlDest)) rmSync(actionYmlDest, {
-                force: true
-            });
-            const distSrc = resolve(cwd, "dist");
-            if (existsSync(distSrc) && statSync(distSrc).isDirectory()) {
-                const distStats = yield* Effect["try"]({
-                    try: ()=>syncDirectory(distSrc, resolve(outputPath, "dist")),
-                    catch: (error)=>new PersistLocalError({
-                            path: distSrc,
-                            cause: error
-                        })
-                });
-                totalCopied += distStats.copied;
-                totalSkipped += distStats.skipped;
-            }
-            const destActionYml = resolve(outputPath, "action.yml");
-            yield* validateActionYmlPaths(destActionYml, outputPath);
-            let actTemplateGenerated = false;
-            if (config.persistLocal.actTemplate) {
-                const actrcPath = resolve(cwd, ".actrc");
-                const actWorkflowPath = resolve(cwd, ".github/workflows/act-test.yml");
-                if (!existsSync(actrcPath)) {
-                    yield* Effect["try"]({
-                        try: ()=>writeFileSync(actrcPath, ACTRC_CONTENT, "utf8"),
-                        catch: (error)=>new PersistLocalError({
-                                path: actrcPath,
-                                cause: error
-                            })
-                    });
-                    actTemplateGenerated = true;
-                }
-                if (!existsSync(actWorkflowPath)) {
-                    yield* Effect["try"]({
-                        try: ()=>{
-                            mkdirSync(dirname(actWorkflowPath), {
-                                recursive: true
-                            });
-                            writeFileSync(actWorkflowPath, ACT_WORKFLOW_CONTENT, "utf8");
-                        },
-                        catch: (error)=>new PersistLocalError({
-                                path: actWorkflowPath,
-                                cause: error
-                            })
-                    });
-                    actTemplateGenerated = true;
-                }
-            }
-            return {
-                success: true,
-                filesCopied: totalCopied,
-                filesSkipped: totalSkipped,
-                actTemplateGenerated,
-                outputPath
-            };
-        }),
-    formatResult: formatPersistResult
-});
-const BrandingIcon = Schema.Literal("activity", "airplay", "alert-circle", "alert-octagon", "alert-triangle", "align-center", "align-justify", "align-left", "align-right", "anchor", "aperture", "archive", "arrow-down-circle", "arrow-down-left", "arrow-down-right", "arrow-down", "arrow-left-circle", "arrow-left", "arrow-right-circle", "arrow-right", "arrow-up-circle", "arrow-up-left", "arrow-up-right", "arrow-up", "at-sign", "award", "bar-chart-2", "bar-chart", "battery-charging", "battery", "bell-off", "bell", "bluetooth", "bold", "book-open", "book", "bookmark", "box", "briefcase", "calendar", "camera-off", "camera", "cast", "check-circle", "check-square", "check", "chevron-down", "chevron-left", "chevron-right", "chevron-up", "chevrons-down", "chevrons-left", "chevrons-right", "chevrons-up", "circle", "clipboard", "clock", "cloud-drizzle", "cloud-lightning", "cloud-off", "cloud-rain", "cloud-snow", "cloud", "code", "command", "compass", "copy", "corner-down-left", "corner-down-right", "corner-left-down", "corner-left-up", "corner-right-down", "corner-right-up", "corner-up-left", "corner-up-right", "cpu", "credit-card", "crop", "crosshair", "database", "delete", "disc", "dollar-sign", "download-cloud", "download", "droplet", "edit-2", "edit-3", "edit", "external-link", "eye-off", "eye", "fast-forward", "feather", "file-minus", "file-plus", "file-text", "file", "film", "filter", "flag", "folder-minus", "folder-plus", "folder", "gift", "git-branch", "git-commit", "git-merge", "git-pull-request", "globe", "grid", "hard-drive", "hash", "headphones", "heart", "help-circle", "home", "image", "inbox", "info", "italic", "layers", "layout", "life-buoy", "link-2", "link", "list", "loader", "lock", "log-in", "log-out", "mail", "map-pin", "map", "maximize-2", "maximize", "menu", "message-circle", "message-square", "mic-off", "mic", "minimize-2", "minimize", "minus-circle", "minus-square", "minus", "monitor", "moon", "more-horizontal", "more-vertical", "move", "music", "navigation-2", "navigation", "octagon", "package", "paperclip", "pause-circle", "pause", "percent", "phone-call", "phone-forwarded", "phone-incoming", "phone-missed", "phone-off", "phone-outgoing", "phone", "pie-chart", "play-circle", "play", "plus-circle", "plus-square", "plus", "pocket", "power", "printer", "radio", "refresh-ccw", "refresh-cw", "repeat", "rewind", "rotate-ccw", "rotate-cw", "rss", "save", "scissors", "search", "send", "server", "settings", "share-2", "share", "shield-off", "shield", "shopping-bag", "shopping-cart", "shuffle", "sidebar", "skip-back", "skip-forward", "slash", "sliders", "smartphone", "speaker", "square", "star", "stop-circle", "sun", "sunrise", "sunset", "table", "tablet", "tag", "target", "terminal", "thermometer", "thumbs-down", "thumbs-up", "toggle-left", "toggle-right", "trash-2", "trash", "trending-down", "trending-up", "triangle", "truck", "tv", "type", "umbrella", "underline", "unlock", "upload-cloud", "upload", "user-check", "user-minus", "user-plus", "user-x", "user", "users", "video-off", "video", "voicemail", "volume-1", "volume-2", "volume-x", "volume", "watch", "wifi-off", "wifi", "wind", "x-circle", "x-square", "x", "zap-off", "zap", "zoom-in", "zoom-out");
-const ActionInput = Schema.Struct({
-    description: Schema.String,
-    required: Schema.optional(Schema.Boolean),
-    default: Schema.optional(Schema.String),
-    deprecationMessage: Schema.optional(Schema.String)
-});
-const ActionOutput = Schema.Struct({
-    description: Schema.String
-});
-const Runs = Schema.Struct({
-    using: Schema.Literal("node24"),
-    main: Schema.String,
-    pre: Schema.optional(Schema.String),
-    "pre-if": Schema.optional(Schema.String),
-    post: Schema.optional(Schema.String),
-    "post-if": Schema.optional(Schema.String)
-});
-const BrandingColor = Schema.Literal("white", "black", "yellow", "blue", "green", "orange", "red", "purple", "gray-dark");
-const Branding = Schema.Struct({
-    icon: Schema.optional(BrandingIcon),
-    color: Schema.optional(BrandingColor)
-});
-const ActionYml = Schema.Struct({
-    name: Schema.String,
-    description: Schema.String,
-    author: Schema.optional(Schema.String),
-    inputs: Schema.optional(Schema.Record({
-        key: Schema.String,
-        value: ActionInput
-    })),
-    outputs: Schema.optional(Schema.Record({
-        key: Schema.String,
-        value: ActionOutput
-    })),
-    runs: Runs,
-    branding: Schema.optional(Branding)
-});
-const ValidateOptionsSchema = Schema.Struct({
-    cwd: OptionalPathLikeSchema,
-    strict: Schema.optional(Schema.Boolean)
-});
-const ValidationErrorSchema = Schema.Struct({
-    code: Schema.String,
-    message: Schema.String,
-    file: Schema.optional(Schema.String),
-    suggestion: Schema.optional(Schema.String)
-});
-const ValidationWarningSchema = Schema.Struct({
-    code: Schema.String,
-    message: Schema.String,
-    file: Schema.optional(Schema.String),
-    suggestion: Schema.optional(Schema.String)
-});
-const ValidationResultSchema = Schema.Struct({
-    valid: Schema.Boolean,
-    errors: Schema.Array(ValidationErrorSchema),
-    warnings: Schema.Array(ValidationWarningSchema)
-});
-const ActionYmlResultSchema = Schema.Struct({
-    valid: Schema.Boolean,
-    content: Schema.optional(Schema.Any),
-    errors: Schema.Array(ValidationErrorSchema),
-    warnings: Schema.Array(ValidationWarningSchema)
-});
-const ValidationService = Context.GenericTag("ValidationService");
-const isCI = ()=>"true" === process.env.CI || "1" === process.env.CI || "true" === process.env.GITHUB_ACTIONS;
-const resolveStrict = (configStrict)=>configStrict ?? isCI();
-const makeWarning = (code, message, suggestion, file)=>void 0 !== file ? {
-        code,
-        message,
-        suggestion,
-        file
-    } : {
-        code,
-        message,
-        suggestion
-    };
-const formatSchemaErrors = (error, filePath)=>[
-        {
-            path: filePath,
-            message: ParseResult.TreeFormatter.formatErrorSync(error)
-        }
-    ];
-const ValidationServiceLive = Layer.effect(ValidationService, Effect.gen(function*() {
-    const configService = yield* ConfigService;
-    const readActionYml = (path)=>Effect.gen(function*() {
-            if (!existsSync(path)) return yield* new ActionYmlMissing({
-                cwd: path
-            });
-            const content = yield* Effect["try"]({
-                try: ()=>readFileSync(path, "utf8"),
-                catch: ()=>new ActionYmlSyntaxError({
-                        path,
-                        message: "Failed to read file"
-                    })
-            });
-            const parsed = yield* parse(content).pipe(Effect.mapError((error)=>new ActionYmlSyntaxError({
-                    path,
-                    message: error.message
-                })));
-            if (!parsed || "object" != typeof parsed) return yield* new ActionYmlSyntaxError({
-                path,
-                message: "action.yml must be an object"
-            });
-            return parsed;
-        });
-    const validateSchema = (parsed, path)=>Effect.gen(function*() {
-            const result = Schema.decodeUnknownEither(ActionYml)(parsed);
-            if ("Left" === result._tag) return yield* new ActionYmlSchemaError({
-                path,
-                errors: formatSchemaErrors(result.left, path)
-            });
-            return result.right;
-        });
-    const checkRecommendations = (content, filePath)=>{
-        const warnings = [];
-        if (content.branding) {
-            const branding = content.branding;
-            if (!branding.icon) warnings.push(makeWarning("ACTION_YML_NO_BRANDING_ICON", "Branding icon not specified", "Add branding.icon for better marketplace visibility", filePath));
-            if (!branding.color) warnings.push(makeWarning("ACTION_YML_NO_BRANDING_COLOR", "Branding color not specified", "Add branding.color for better marketplace visibility", filePath));
-        } else warnings.push(makeWarning("ACTION_YML_NO_BRANDING", "No branding configuration found", "Add branding.icon and branding.color for better marketplace visibility", filePath));
-        if (content.inputs) {
-            const inputs = content.inputs;
-            for (const [name, input] of Object.entries(inputs))if (!input.description) warnings.push(makeWarning("ACTION_YML_INPUT_NO_DESCRIPTION", `Input '${name}' has no description`, `Add a description for the '${name}' input`, filePath));
-        }
-        if (content.outputs) {
-            const outputs = content.outputs;
-            for (const [name, output] of Object.entries(outputs))if (!output.description) warnings.push(makeWarning("ACTION_YML_OUTPUT_NO_DESCRIPTION", `Output '${name}' has no description`, `Add a description for the '${name}' output`, filePath));
-        }
-        return warnings;
-    };
-    const validateActionYml = (path)=>Effect.gen(function*() {
-            const parsed = yield* readActionYml(path);
-            const content = yield* validateSchema(parsed, path);
-            const warnings = checkRecommendations(parsed, path);
-            return {
-                valid: true,
-                content,
-                errors: [],
-                warnings
-            };
-        });
-    const checkEntries = (config, cwd)=>Effect.gen(function*() {
-            const errors = [];
-            const entriesConfig = {
-                main: config.entries.main
-            };
-            if (config.entries.pre) entriesConfig.pre = config.entries.pre;
-            if (config.entries.post) entriesConfig.post = config.entries.post;
-            const result = yield* Effect.either(configService.detectEntries(cwd, entriesConfig));
-            if ("Left" === result._tag && result.left instanceof MainEntryMissing) errors.push({
-                code: "MAIN_ENTRY_MISSING",
-                message: `Main entry point not found: ${result.left.expectedPath}`,
-                file: result.left.expectedPath,
-                suggestion: "Create src/main.ts or specify a different path in config"
-            });
-            return errors;
-        });
-    const checkActionYml = (config, cwd)=>Effect.gen(function*() {
-            const errors = [];
-            const warnings = [];
-            if (!config.validation.requireActionYml) return {
-                errors,
-                warnings
-            };
-            const actionYmlPath = resolve(cwd, "action.yml");
-            const result = yield* Effect.either(validateActionYml(actionYmlPath));
-            if ("Left" === result._tag) {
-                const error = result.left;
-                if (error instanceof ActionYmlMissing) warnings.push({
-                    code: "ACTION_YML_MISSING",
-                    message: "action.yml not found",
-                    file: actionYmlPath,
-                    suggestion: "Create action.yml to define your action metadata"
-                });
-                else if (error instanceof ActionYmlSyntaxError) errors.push({
-                    code: "ACTION_YML_SYNTAX_ERROR",
-                    message: error.message,
-                    file: error.path
-                });
-                else if (error instanceof ActionYmlSchemaError) for (const schemaError of error.errors)errors.push({
-                    code: "ACTION_YML_SCHEMA_ERROR",
-                    message: schemaError.message,
-                    file: error.path
-                });
-            } else warnings.push(...result.right.warnings);
-            return {
-                errors,
-                warnings
-            };
-        });
-    return {
-        validate: (config, options = {})=>Effect.gen(function*() {
-                const cwd = options.cwd ?? process.cwd();
-                const strict = resolveStrict(options.strict ?? config.validation.strict);
-                const entryErrors = yield* checkEntries(config, cwd);
-                const actionYmlResult = yield* checkActionYml(config, cwd);
-                const errors = [
-                    ...entryErrors,
-                    ...actionYmlResult.errors
-                ];
-                const warnings = [
-                    ...actionYmlResult.warnings
-                ];
-                const valid = 0 === errors.length && (!strict || 0 === warnings.length);
-                if (strict && warnings.length > 0 && 0 === errors.length) return yield* new ValidationFailed({
-                    errorCount: 0,
-                    warningCount: warnings.length,
-                    message: "Warnings treated as errors in strict mode"
-                });
-                return {
-                    valid,
-                    errors,
-                    warnings
-                };
-            }),
-        validateActionYml,
-        formatResult: (result)=>{
-            const lines = [];
-            if (result.errors.length > 0) {
-                lines.push("Errors:");
-                for (const error of result.errors){
-                    lines.push(`  \u2717 ${error.message}`);
-                    if (error.suggestion) lines.push(`    \u2192 ${error.suggestion}`);
-                }
-            }
-            if (result.warnings.length > 0) {
-                if (lines.length > 0) lines.push("");
-                lines.push("Warnings:");
-                for (const warning of result.warnings){
-                    lines.push(`  \u26A0 ${warning.message}`);
-                    if (warning.suggestion) lines.push(`    \u2192 ${warning.suggestion}`);
-                }
-            }
-            if (result.valid && 0 === result.errors.length && 0 === result.warnings.length) lines.push("\u2713 All checks passed");
-            return lines.join("\n");
-        },
-        isCI: ()=>Effect.succeed(isCI()),
-        isStrict: (configStrict)=>Effect.succeed(resolveStrict(configStrict))
-    };
-}));
-const ConfigLayer = 231 == __webpack_require__.j ? ConfigServiceLive : null;
-const ValidationLayer = ValidationServiceLive.pipe(Layer.provide(ConfigServiceLive));
-const BuildLayer = BuildServiceLive.pipe(Layer.provide(ConfigServiceLive));
-const PersistLocalLayer = PersistLocalServiceLive;
-const AppLayer = Layer.mergeAll(ConfigServiceLive, ValidationLayer, BuildLayer, PersistLocalLayer);
-export { ActionYmlMissing, ActionYmlMissingBase, ActionYmlPathError, ActionYmlPathErrorBase, ActionYmlResultSchema, ActionYmlSchemaError, ActionYmlSchemaErrorBase, ActionYmlSyntaxError, ActionYmlSyntaxErrorBase, AppLayer, BuildFailed, BuildFailedBase, BuildLayer, BuildOptionsSchema, BuildResultSchema, BuildRunnerOptionsSchema, BuildService, BundleFailed, BundleFailedBase, BundleResultSchema, BundleStatsSchema, CleanError, CleanErrorBase, ConfigInputSchema, ConfigInvalid, ConfigInvalidBase, ConfigLayer, ConfigLoadFailed, ConfigLoadFailedBase, ConfigNotFound, ConfigNotFoundBase, ConfigSchema, ConfigService, DetectEntriesResultSchema, DetectedEntrySchema, EntriesSchema, EntryFileMissing, EntryFileMissingBase, LoadConfigOptionsSchema, MainEntryMissing, MainEntryMissingBase, PersistLocalError, PersistLocalErrorBase, PersistLocalLayer, PersistLocalOptionsSchema, PersistLocalResultSchema, PersistLocalRunnerOptionsSchema, PersistLocalService, ValidateOptionsSchema, ValidationErrorSchema, ValidationFailed, ValidationFailedBase, ValidationLayer, ValidationOptionsSchema, ValidationResultSchema, ValidationService, ValidationWarningSchema, WriteError, WriteErrorBase, defineConfig };