@savvy-web/github-action-builder 1.0.2 → 1.1.0

package/README.md

@@ -11,7 +11,7 @@ Build a GitHub Action from TypeScript source without writing build config. The b
 - **No build config required** - Picks up entry points from `src/main.ts`, `src/pre.ts`, `src/post.ts` on its own
 - **Node.js 24** - Emits ESM actions that run on the `node24` GitHub Actions runtime
 - **Schema validation** - Validates `action.yml` against GitHub's official metadata specification
-- **Single-file bundles** - All npm dependencies inlined via rsbuild; `node:` builtins externalized; user-configured `externals` and `ignore` options for optional or native modules
+- **Single-file bundles** - All npm dependencies inlined via rsbuild; `node:` builtins externalized; user-configured `externals`, `ignore` and `nativeDynamicImports` options for native modules, optional dependencies and runtime-resolved dynamic imports
 - **Local testing** - Auto-persists build output for testing with [nektos/act](https://github.com/nektos/act)
 - **CI-aware** - Strict validation in CI, warnings-only locally
 

package/bin/github-action-builder.js

@@ -26,7 +26,7 @@ const rootCommand = Command.make("github-action-builder").pipe(Command.withSubco
 */
 const cli = Command.run(rootCommand, {
 	name: "github-action-builder",
-	version: "1.0.2"
+	version: "1.1.0"
 });
 /**
 * Combined layer: AppLayer + NodeContext for CLI.

package/cli/commands/init.js

@@ -20,7 +20,7 @@ const forceOption = Options.boolean("force").pipe(Options.withAlias("f"), Option
 * Get current package version (replaced at build time).
 */
 const getPackageVersion = () => {
-	return "1.0.2";
+	return "1.1.0";
 };
 /**
 * Generate package.json content.

package/index.d.ts

@@ -51,6 +51,18 @@ declare const BuildOptionsSchema: Schema.Struct<{
   ignore: Schema.optionalWith<Schema.Array$<typeof Schema.String>, {
     default: () => never[];
   }>;
+  /**
+   * Packages whose dynamic `import(...)` calls must stay native `import()` at runtime instead of
+   * being compiled into an rspack context module. Use this for packages that resolve a module path
+   * at runtime (e.g. from a config value or a computed changelog id) and dynamically import it —
+   * rspack cannot statically analyze a fully dynamic `import(expr)`, so it emits an empty-context
+   * stub that throws `Cannot find module` at runtime even though the file exists on disk. Listing
+   * the package here injects a `webpackIgnore` comment into its dynamic imports so rspack leaves
+   * them alone. Defaults to [].
+   */
+  nativeDynamicImports: Schema.optionalWith<Schema.Array$<typeof Schema.String>, {
+    default: () => never[];
+  }>;
 }>;
 /**
  * Build options for the bundler.
@@ -127,6 +139,7 @@ declare const ConfigInputSchema: Schema.Struct<{
     sourceMap: Schema.optional<typeof Schema.Boolean>;
     externals: Schema.optional<Schema.Array$<typeof Schema.String>>;
     ignore: Schema.optional<Schema.Array$<typeof Schema.String>>;
+    nativeDynamicImports: Schema.optional<Schema.Array$<typeof Schema.String>>;
   }>>;
   validation: Schema.optional<Schema.Struct<{
     requireActionYml: Schema.optional<typeof Schema.Boolean>;
@@ -176,6 +189,18 @@ declare const ConfigSchema: Schema.Struct<{
     ignore: Schema.optionalWith<Schema.Array$<typeof Schema.String>, {
       default: () => never[];
     }>;
+    /**
+     * Packages whose dynamic `import(...)` calls must stay native `import()` at runtime instead of
+     * being compiled into an rspack context module. Use this for packages that resolve a module path
+     * at runtime (e.g. from a config value or a computed changelog id) and dynamically import it —
+     * rspack cannot statically analyze a fully dynamic `import(expr)`, so it emits an empty-context
+     * stub that throws `Cannot find module` at runtime even though the file exists on disk. Listing
+     * the package here injects a `webpackIgnore` comment into its dynamic imports so rspack leaves
+     * them alone. Defaults to [].
+     */
+    nativeDynamicImports: Schema.optionalWith<Schema.Array$<typeof Schema.String>, {
+      default: () => never[];
+    }>;
   }>;
   validation: Schema.Struct<{
     /** Require action.yml to exist and be valid. Defaults to true. */requireActionYml: Schema.optionalWith<typeof Schema.Boolean, {
@@ -247,6 +272,7 @@ type Config = typeof ConfigSchema.Type;
  *     sourceMap: true,
  *     externals: ["@aws-sdk/client-s3"],
  *     ignore: ["libxmljs2"],
+ *     nativeDynamicImports: ["@changesets/apply-release-plan"],
  *   },
  *   validation: {
  *     requireActionYml: true,

package/loaders/webpack-ignore-dynamic-imports.cjs

@@ -0,0 +1,100 @@
+"use strict";
+
+/**
+ * rspack loader that injects the `webpackIgnore` magic comment into dynamic
+ * `import(...)` calls whose argument is not a string literal (or is a
+ * template literal that isn't fully static).
+ *
+ * @remarks
+ * rspack compiles a fully dynamic `import(expr)` (an argument it cannot
+ * statically resolve to a literal path) into a "context module" — a stub
+ * that globs a directory at build time and throws `Cannot find module` at
+ * runtime for any path it didn't see, even when the real file exists on
+ * disk. Some third-party packages (e.g. `@changesets/apply-release-plan`)
+ * resolve a module path at runtime and dynamically import it; bundling that
+ * call as a context module breaks it. The same is true of an *interpolated*
+ * template literal — `` import(`./x/${y}.js`) `` compiles to the same
+ * context-module stub as a bare identifier, because rspack cannot statically
+ * resolve the interpolated segment either.
+ *
+ * rspack (like webpack) respects a `/* webpackIgnore: true *\/` comment
+ * immediately inside the `import(` call — it skips context-module analysis
+ * for that call and leaves a plain, native, runtime `import()` in the
+ * output. This loader is a pure string transform (no AST parsing, so no
+ * source-map chaining — the returned source is treated as a 1:1 replacement
+ * and any pre-existing source map for this file is not remapped) that runs
+ * in two passes:
+ *
+ * 1. Inject the comment into any `import(` call whose argument is not a
+ *    string literal, not a backtick template literal (handled in pass 2),
+ *    and does not already carry a `webpackIgnore` magic comment. A
+ *    *different* leading magic comment (e.g. `webpackChunkName`) does not
+ *    suppress injection — the ignore comment is prepended alongside it, so
+ *    both survive: `import(/* webpackIgnore: true *\/ /* webpackChunkName:
+ *    "x" *\/ ident)`.
+ * 2. Inject the comment into a backtick template-literal argument, but only
+ *    when it contains `${` interpolation. A fully static template literal
+ *    (e.g. `` import(`./static.js`) ``) compiles to a literal path just like
+ *    a plain string, so it is left untouched. Finding the template
+ *    literal's closing backtick is a pragmatic linear scan (skipping
+ *    backslash-escaped characters), not a real parser: it does not track
+ *    nested template literals inside an interpolation (e.g.
+ *    `` import(`${`nested`}`) ``) and will stop at the first unescaped
+ *    backtick it sees, which is a documented limitation of this non-AST
+ *    heuristic.
+ *
+ * Deliberately skipped (left untouched):
+ * - `import("./static.js")` — a string-literal import; the bundler already
+ *   resolves and bundles these correctly, no need to touch them.
+ * - `` import(`./static.js`) `` — a fully static template literal; same
+ *   reasoning as a plain string (see pass 2 above).
+ * - `import(/* webpackIgnore: true *\/ x)` — already has the comment
+ *   injected (idempotent: running this loader twice must not double-inject).
+ * - `important(x)` — the `\b` word-boundary guard on `import` prevents
+ *   matching inside a longer identifier.
+ *
+ * This file is shipped as a genuine on-disk `.cjs` file (not bundled away)
+ * because rspack loaders are loaded via `require()` at build time — see
+ * `public/` in this package's `package.json`, which is copied verbatim to
+ * the package root by the build (so this ships at `<pkg>/loaders/
+ * webpack-ignore-dynamic-imports.cjs`, not under a `public/` prefix).
+ *
+ * @param source - The original module source text.
+ * @returns The source text with `webpackIgnore` comments injected into
+ * every fully-dynamic `import(` call.
+ */
+module.exports = function webpackIgnoreDynamicImportsLoader(source) {
+	// Pass 1: string-literal and backtick arguments are excluded from this
+	// pass (the former never needs the comment; the latter is handled by
+	// pass 2 below). An optional single leading `/* ... */` magic comment is
+	// captured so it can be inspected: if it already contains
+	// `webpackIgnore`, the call is left untouched (idempotent); otherwise the
+	// new comment is prepended ahead of it.
+	let result = source.replace(/\bimport\s*\(\s*(\/\*[\s\S]*?\*\/\s*)?(?!["'`])/g, (match, existingComment) => {
+		if (existingComment && /webpackIgnore/.test(existingComment)) {
+			return match;
+		}
+		return match.replace("(", "(/* webpackIgnore: true */ ");
+	});
+
+	// Pass 2: backtick template-literal arguments. Only interpolated
+	// template literals (containing `${`) need the comment; a fully static
+	// one is left untouched.
+	result = result.replace(/\bimport\s*\(\s*`/g, (match, offset, full) => {
+		const backtickIndex = offset + match.length - 1;
+		let end = backtickIndex + 1;
+		while (end < full.length && full[end] !== "`") {
+			if (full[end] === "\\") {
+				end++;
+			}
+			end++;
+		}
+		const literal = full.slice(backtickIndex, end + 1);
+		if (!literal.includes("${")) {
+			return match;
+		}
+		return match.replace(/`$/, "/* webpackIgnore: true */ `");
+	});
+
+	return result;
+};

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@savvy-web/github-action-builder",
-	"version": "1.0.2",
+	"version": "1.1.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": [
@@ -40,6 +40,7 @@
 			"import": "./index.js"
 		},
 		"./tsconfig/action.json": "./tsconfig/action.json",
+		"./loaders/webpack-ignore-dynamic-imports.cjs": "./loaders/webpack-ignore-dynamic-imports.cjs",
 		"./package.json": "./package.json"
 	},
 	"bin": {
@@ -62,7 +63,7 @@
 		"yaml-effect": "^0.7.0"
 	},
 	"peerDependencies": {
-		"@types/node": "^26.0.0",
+		"@types/node": "^26.1.0",
 		"@typescript/native-preview": "^7.0.0-dev.20260612.1",
 		"typescript": "^6.0.0"
 	},

package/schemas/config.js

@@ -54,7 +54,17 @@ const BuildOptionsSchema = Schema.Struct({
 	/** Packages to exclude from the bundle (in addition to node: builtins). Defaults to []. */
 	externals: Schema.optionalWith(Schema.Array(Schema.String), { default: () => [] }),
 	/** Packages to exclude from the bundle and replace with a stub that throws if loaded at runtime. Use for optional transitive dependencies the action never exercises (e.g. native modules). Defaults to []. */
-	ignore: Schema.optionalWith(Schema.Array(Schema.String), { default: () => [] })
+	ignore: Schema.optionalWith(Schema.Array(Schema.String), { default: () => [] }),
+	/**
+	* Packages whose dynamic `import(...)` calls must stay native `import()` at runtime instead of
+	* being compiled into an rspack context module. Use this for packages that resolve a module path
+	* at runtime (e.g. from a config value or a computed changelog id) and dynamically import it —
+	* rspack cannot statically analyze a fully dynamic `import(expr)`, so it emits an empty-context
+	* stub that throws `Cannot find module` at runtime even though the file exists on disk. Listing
+	* the package here injects a `webpackIgnore` comment into its dynamic imports so rspack leaves
+	* them alone. Defaults to [].
+	*/
+	nativeDynamicImports: Schema.optionalWith(Schema.Array(Schema.String), { default: () => [] })
 });
 /**
 * Schema for validation options.
@@ -113,7 +123,8 @@ const ConfigInputSchema = 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))
+		ignore: Schema.optional(Schema.Array(Schema.String)),
+		nativeDynamicImports: Schema.optional(Schema.Array(Schema.String))
 	})),
 	validation: Schema.optional(Schema.Struct({
 		requireActionYml: Schema.optional(Schema.Boolean),
@@ -178,6 +189,7 @@ const ConfigSchema = Schema.Struct({
 *     sourceMap: true,
 *     externals: ["@aws-sdk/client-s3"],
 *     ignore: ["libxmljs2"],
+*     nativeDynamicImports: ["@changesets/apply-release-plan"],
 *   },
 *   validation: {
 *     requireActionYml: true,

package/services/build-live.js

@@ -1,9 +1,11 @@
 import { BundleFailed, CleanError, WriteError } from "../errors.js";
 import { BuildService } from "./build.js";
 import { ConfigService } from "./config.js";
+import { buildNativeDynamicImportRules } from "./native-dynamic-imports.js";
 import { Effect, Layer } from "effect";
 import { existsSync, mkdirSync, rmSync, statSync, writeFileSync } from "node:fs";
 import { resolve } from "node:path";
+import { fileURLToPath } from "node:url";
 import { createRsbuild } from "@rsbuild/core";
 
 //#region src/services/build-live.ts
@@ -18,6 +20,23 @@ import { createRsbuild } from "@rsbuild/core";
 */
 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));
+}
+/**
 * Format bytes as a human-readable string.
 */
 function formatBytes(bytes) {
@@ -90,6 +109,8 @@ function bundleEntry(entry, config, cwd) {
 		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);
@@ -122,7 +143,11 @@ function bundleEntry(entry, config, cwd) {
 						__dirname: "node-module",
 						__filename: "node-module"
 					},
-					module: { parser: { javascript: { importMeta: false } } },
+					module: {
+						parser: { javascript: { importMeta: false } },
+						// webpackIgnore-injecting loader (empty when the option is unset).
+						rules: nativeDynamicImportRules
+					},
 					output: { asyncChunks: false }
 				} }
 			} }),

package/services/native-dynamic-imports.js

@@ -0,0 +1,65 @@
+//#region src/services/native-dynamic-imports.ts
+/**
+* Helpers for the `build.nativeDynamicImports` option: building the rspack
+* module-rule `test` pattern that matches a package's resolved module path
+* under `node_modules`, and the module rules themselves.
+*
+* @remarks
+* See {@link ../schemas/config.js#BuildOptionsSchema} for the option this
+* supports, and `webpack-ignore-dynamic-imports.cjs` (shipped from
+* `public/loaders/`, see `package.json` `exports`) for the loader these
+* rules point at.
+*
+* @internal
+*/
+/**
+* Escape a string for literal use inside a `RegExp`, and turn every `/` into
+* a `[\/]` alternation so the result matches both POSIX and Windows path
+* separators.
+*
+* @remarks
+* Order matters: the regex-metacharacter escape runs first (it never
+* touches `/`, which is not a regex metacharacter), then `/` is expanded to
+* `[\/]` afterward — a scoped package name like `@changesets/apply-release-plan`
+* has a literal `/` that must become a path-separator alternation, not stay
+* a bare `/`.
+*/
+function escapePathSegment(value) {
+	return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&").replace(/\//g, "[\\/]");
+}
+/**
+* Build a `RegExp` matching a package's resolved absolute module path under
+* `node_modules`, in both the flat layout (`node_modules/<name>/`) and the
+* pnpm layout (`node_modules/.pnpm/<name>@x.y.z/node_modules/<name>/`).
+*
+* @param packageName - The npm package name to match, as configured in
+* `build.nativeDynamicImports` (e.g. `"@changesets/apply-release-plan"` or
+* `"some-unscoped-pkg"`).
+* @returns A `RegExp` suitable for an rspack module rule's `test`.
+*
+* @internal
+*/
+function buildNativeDynamicImportPathPattern(packageName) {
+	const escapedName = escapePathSegment(packageName);
+	return new RegExp(`[\\/]node_modules[\\/](\\.pnpm[\\/][^\\/]+[\\/]node_modules[\\/])?${escapedName}[\\/]`);
+}
+/**
+* Build the rspack `module.rules` entries for `build.nativeDynamicImports`:
+* one rule per configured package name, each pointing at the
+* `webpackIgnore`-injecting loader.
+*
+* @param packageNames - Package names configured in `build.nativeDynamicImports`.
+* @param loaderPath - Absolute, resolved path to `webpack-ignore-dynamic-imports.cjs`.
+* @returns One module rule per package name. Empty when `packageNames` is empty.
+*
+* @internal
+*/
+function buildNativeDynamicImportRules(packageNames, loaderPath) {
+	return packageNames.map((packageName) => ({
+		test: buildNativeDynamicImportPathPattern(packageName),
+		use: [{ loader: loaderPath }]
+	}));
+}
+
+//#endregion
+export { buildNativeDynamicImportPathPattern, buildNativeDynamicImportRules };