ember.nvp 1.2.0 → 1.4.0

package/.release-plan.json

@@ -2,13 +2,17 @@
   "solution": {
     "ember.nvp": {
       "impact": "minor",
-      "oldVersion": "1.1.0",
-      "newVersion": "1.2.0",
+      "oldVersion": "1.3.0",
+      "newVersion": "1.4.0",
       "tagName": "latest",
       "constraints": [
         {
           "impact": "minor",
           "reason": "Appears in changelog section :rocket: Enhancement"
+        },
+        {
+          "impact": "patch",
+          "reason": "Appears in changelog section :house: Internal"
         }
       ],
       "pkgJSONPath": "./package.json"
@@ -18,8 +22,8 @@
     },
     "@nullvoxpopuli/ember-rolldown": {
       "impact": "minor",
-      "oldVersion": "2.1.0",
-      "newVersion": "2.2.0",
+      "oldVersion": "2.5.0",
+      "newVersion": "2.6.0",
       "tagName": "latest",
       "constraints": [
         {
@@ -28,7 +32,7 @@
         },
         {
           "impact": "patch",
-          "reason": "Appears in changelog section :bug: Bug Fix"
+          "reason": "Appears in changelog section :house: Internal"
         }
       ],
       "pkgJSONPath": "./packages/rolldown/package.json"
@@ -37,5 +41,5 @@
       "oldVersion": "1.1.0"
     }
   },
-  "description": "## Release (2026-07-22)\n\n* ember.nvp 1.2.0 (minor)\n* @nullvoxpopuli/ember-rolldown 2.2.0 (minor)\n\n#### :rocket: Enhancement\n* `@nullvoxpopuli/ember-rolldown`, `ember.nvp`\n  * [#98](https://github.com/NullVoxPopuli/ember.nvp/pull/98) Integration-test ember-scoped-css; add babel.templateTransforms ([@NullVoxPopuli-ai-agent](https://github.com/NullVoxPopuli-ai-agent))\n\n#### :bug: Bug Fix\n* `@nullvoxpopuli/ember-rolldown`\n  * [#99](https://github.com/NullVoxPopuli/ember.nvp/pull/99) rolldown: fix virtual .gts declaration resolution + specifier-rewrite sourcemaps ([@NullVoxPopuli](https://github.com/NullVoxPopuli))\n\n#### Committers: 2\n- @NullVoxPopuli's reduced-access machine account for AI usage ([@NullVoxPopuli-ai-agent](https://github.com/NullVoxPopuli-ai-agent))\n- [@NullVoxPopuli](https://github.com/NullVoxPopuli)\n"
+  "description": "## Release (2026-08-03)\n\n* ember.nvp 1.4.0 (minor)\n* @nullvoxpopuli/ember-rolldown 2.6.0 (minor)\n\n#### :rocket: Enhancement\n* `@nullvoxpopuli/ember-rolldown`, `ember.nvp`\n  * [#111](https://github.com/NullVoxPopuli/ember.nvp/pull/111) rolldown: find publish configs in config/ too ([@NullVoxPopuli](https://github.com/NullVoxPopuli))\n* `@nullvoxpopuli/ember-rolldown`\n  * [#109](https://github.com/NullVoxPopuli/ember.nvp/pull/109) rolldown: prefer babel.publish.config over babel.config ([@NullVoxPopuli](https://github.com/NullVoxPopuli))\n\n#### :house: Internal\n* `@nullvoxpopuli/ember-rolldown`, `ember.nvp`\n  * [#112](https://github.com/NullVoxPopuli/ember.nvp/pull/112) rolldown: test the isolated-declarations guard through generated libraries ([@NullVoxPopuli](https://github.com/NullVoxPopuli))\n\n#### Committers: 1\n- [@NullVoxPopuli](https://github.com/NullVoxPopuli)\n"
 }

package/CHANGELOG.md

@@ -1,5 +1,65 @@
 # Changelog
 
+## Release (2026-08-03)
+
+* ember.nvp 1.4.0 (minor)
+* @nullvoxpopuli/ember-rolldown 2.6.0 (minor)
+
+#### :rocket: Enhancement
+* `@nullvoxpopuli/ember-rolldown`, `ember.nvp`
+  * [#111](https://github.com/NullVoxPopuli/ember.nvp/pull/111) rolldown: find publish configs in config/ too ([@NullVoxPopuli](https://github.com/NullVoxPopuli))
+* `@nullvoxpopuli/ember-rolldown`
+  * [#109](https://github.com/NullVoxPopuli/ember.nvp/pull/109) rolldown: prefer babel.publish.config over babel.config ([@NullVoxPopuli](https://github.com/NullVoxPopuli))
+
+#### :house: Internal
+* `@nullvoxpopuli/ember-rolldown`, `ember.nvp`
+  * [#112](https://github.com/NullVoxPopuli/ember.nvp/pull/112) rolldown: test the isolated-declarations guard through generated libraries ([@NullVoxPopuli](https://github.com/NullVoxPopuli))
+
+#### Committers: 1
+- [@NullVoxPopuli](https://github.com/NullVoxPopuli)
+
+## Release (2026-08-03)
+
+* ember.nvp 1.3.0 (minor)
+* @nullvoxpopuli/ember-rolldown 2.5.0 (minor)
+
+#### :rocket: Enhancement
+* `ember.nvp`
+  * [#106](https://github.com/NullVoxPopuli/ember.nvp/pull/106) README layer ([@tcjr](https://github.com/tcjr))
+* `@nullvoxpopuli/ember-rolldown`
+  * [#107](https://github.com/NullVoxPopuli/ember.nvp/pull/107) rolldown: check the tsconfig the build uses, not always tsconfig.json ([@NullVoxPopuli](https://github.com/NullVoxPopuli))
+
+#### Committers: 2
+- Tom Carter ([@tcjr](https://github.com/tcjr))
+- [@NullVoxPopuli](https://github.com/NullVoxPopuli)
+
+## Release (2026-07-24)
+
+* @nullvoxpopuli/ember-rolldown 2.4.0 (minor)
+
+#### :rocket: Enhancement
+* `@nullvoxpopuli/ember-rolldown`
+  * [#104](https://github.com/NullVoxPopuli/ember.nvp/pull/104) rolldown: support .gts/.gjs build entries ([@NullVoxPopuli](https://github.com/NullVoxPopuli))
+
+#### Committers: 1
+- [@NullVoxPopuli](https://github.com/NullVoxPopuli)
+
+## Release (2026-07-22)
+
+* @nullvoxpopuli/ember-rolldown 2.3.0 (minor)
+
+#### :rocket: Enhancement
+* `@nullvoxpopuli/ember-rolldown`
+  * [#101](https://github.com/NullVoxPopuli/ember.nvp/pull/101) appReexports: accept string[] include and options as second argument ([@NullVoxPopuli-ai-agent](https://github.com/NullVoxPopuli-ai-agent))
+
+#### :bug: Bug Fix
+* `@nullvoxpopuli/ember-rolldown`
+  * [#103](https://github.com/NullVoxPopuli/ember.nvp/pull/103) rolldown: externalize the modules ember-source provides (renamed-modules) ([@NullVoxPopuli](https://github.com/NullVoxPopuli))
+
+#### Committers: 2
+- @NullVoxPopuli's reduced-access machine account for AI usage ([@NullVoxPopuli-ai-agent](https://github.com/NullVoxPopuli-ai-agent))
+- [@NullVoxPopuli](https://github.com/NullVoxPopuli)
+
 ## Release (2026-07-22)
 
 * ember.nvp 1.2.0 (minor)

package/README.md

@@ -198,6 +198,11 @@ export default {
 
     await packageJson.addScripts({ "my-script": 'echo "Hello"' }, project.directory);
   },
+
+  // Optionally add something to the README.md file
+  readme() {
+    return "### My Feature\n\nHere's what my feature brings to the table.";
+  },
 };
 ```
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ember.nvp",
-  "version": "1.2.0",
+  "version": "1.4.0",
   "description": "ember project generator, alternative to the official blueprints, but more modern -- hopefully one day to upstream back in to ember-cli / official blueprints",
   "repository": {
     "type": "git",

package/packages/rolldown/README.md

@@ -53,16 +53,37 @@ export default defineConfig({
 });
 ```
 
-A `babel.config.js` is optional. Without one, `ember()` compiles templates
+A babel config is optional. Without one, `ember()` compiles templates
 (to `precompileTemplate`), decorators (via
 [decorator-transforms](https://github.com/ef4/decorator-transforms)), and
-TypeScript; with one, your config runs instead.
+TypeScript; with one, your config runs instead. A `babel.publish.config.*` is
+preferred over a `babel.config.*` — see
+[Publish vs. development babel config](#publish-vs-development-babel-config).
+
+### Entrypoints
+
+Entries may be any extension — `.ts`, `.js`, `.gts`, `.gjs`:
+
+```js
+export default defineConfig({
+  entry: ["./src/index.ts", "./src/components/menu.gts"],
+  plugins: [ember()],
+});
+```
+
+Whatever the source extension, the emitted `.js` and `.d.ts` paths mirror the
+entry paths (that's how tsdown's dts support works): the example emits
+`dist/index.js` + `dist/index.d.ts` and `dist/components/menu.js` +
+`dist/components/menu.d.ts`. Type imports resolve against those emitted
+paths, so your entries — together with your `exports` map — _are_ your
+public API: a module that isn't an entry has no stable `dist/` path of its
+own and is only reachable through the entrypoints that re-export it.
 
 ### Declarations
 
 Declarations are emitted with isolated declarations — the only declaration
 pipeline that can see `<template>` (`.gts`/`.gjs`) modules, which exist only
-inside the bundler's module graph. Your `tsconfig.json` must enable it
+inside the bundler's module graph. The tsconfig your build uses must enable it
 (`ember()` errors otherwise):
 
 ```jsonc
@@ -82,6 +103,48 @@ import type { TOC } from "@ember/component/template-only";
 export const Badge: TOC<BadgeSignature> = <template>...</template>;
 ```
 
+#### Keeping the constraint off dev-only code
+
+`isolatedDeclarations` is a constraint on how _published_ code is written, so it
+should cover only the code you emit declarations for. If your package also holds
+dev-only code — a demo app, in-package tests — putting the flag on the single
+`tsconfig.json` that covers everything would force explicit annotations on demo
+components and test helpers that never get a `.d.ts` emitted for them.
+
+The tsconfig `ember()` checks is the one
+[tsdown's `tsconfig` option](https://tsdown.dev/options/tsconfig) points at, so
+point the build at a publish-only config and leave `tsconfig.json` alone for
+editors and `tsc --noEmit`:
+
+```js
+// tsdown.config.js
+export default defineConfig({
+  entry: ["./src/index.ts"],
+  // include: ["src/**/*"], isolatedDeclarations: true
+  tsconfig: "./tsconfig.publish.json",
+  plugins: [ember()],
+});
+```
+
+Any path works, so the publish config can live wherever you keep build
+configuration — `tsconfig: "./config/tsconfig.publish.json"`. (A directory works
+too: `tsconfig: "./config"` picks up `config/tsconfig.json`.)
+
+`tsconfig: false` is rejected while declarations are on: with no tsconfig there
+is no `isolatedDeclarations`, and the fallback pipeline can't see compiled
+`.gts`, so it would fail later with "Source file not found". Set `dts: false`
+alongside it if the library ships no types.
+
+A tsconfig's relative paths resolve against the file itself, so a config kept in
+`config/` wants `"include": ["../src/**/*"]` and `"rootDir": "../src"`. The build
+won't tell you if you get that wrong — tsdown drives declaration emit from
+`entry`, not from the tsconfig's `include` — but `tsc`/`ember-tsc` and your
+editor will, if you ever point them at that config.
+
+The tradeoff: isolated-declaration errors in `src` then surface when you build
+rather than in your editor, since the editor uses `tsconfig.json`. Run the build
+(or `tsc --noEmit -p tsconfig.publish.json`) in CI so nothing lands unchecked.
+
 ## CSS
 
 Components that import co-located CSS (`import './popup.css'`) need
@@ -140,8 +203,9 @@ it.
 
 `ember()` returns an array of rolldown plugins:
 
-- **`emberIsolatedDeclarations()`** — errors when a `tsconfig.json` is present
-  without `isolatedDeclarations: true`.
+- **`emberIsolatedDeclarations()`** — errors when the tsconfig the build uses
+  (tsdown's `tsconfig` option, defaulting to `tsconfig.json`) is present without
+  `isolatedDeclarations: true`.
 - **`emberExternals()`** — keeps your `dependencies`, `peerDependencies`, and
   the ember virtual packages (e.g. `@ember/component`, `@glimmer/tracking`, the
   template compiler) external, so the consuming app resolves them.
@@ -151,7 +215,9 @@ it.
   `.gts` specifiers in emitted `.d.ts` files.
 - **`emberBabel()`** — runs babel with `babelHelpers: "bundled"`, but only on
   the files that actually need it (template-tag, decorators, template imports);
-  everything else stays on rolldown's fast native (oxc) transform.
+  everything else stays on rolldown's fast native (oxc) transform. Uses your
+  `babel.publish.config.*` (root or `config/`) in preference to your
+  `babel.config.*`.
 
 ## Configuration
 
@@ -173,6 +239,46 @@ combined with a babel config file — a config lists
 `babel-plugin-ember-template-compilation` itself, so its transforms belong
 there.
 
+### Publish vs. development babel config
+
+A library's plain `babel.config.*` is usually its _development_ config: it
+compiles `@embroider/macros` away, targets the wire format, and wires up
+whatever the in-package demo app or test suite needs. None of that belongs in a
+published artifact — macros must survive for the consuming app to evaluate, and
+the wire format is private between one template compiler and one glimmer
+runtime of the same version.
+
+Babel's own resolution can't tell those apart, so `ember()` looks for a config
+named for publishing first. With no explicit `configFile`, detection is:
+
+1. `babel.publish.config.{mjs,cjs,js,mts,cts,ts,json}` in the package root
+2. the same names in `config/`
+3. otherwise babel's own resolution (`babel.config.*`, honoring `rootMode`)
+4. otherwise no config file — templates, decorators and TypeScript are still
+   handled by the built-in defaults
+
+So a library that keeps both configs needs no `babel` option at all:
+
+```
+my-addon/
+  babel.config.mjs          # dev: macros compiled, wire format, test-app wiring
+  babel.publish.config.mjs  # what ember() uses
+```
+
+...and so does one that keeps build configuration out of its root:
+
+```
+my-addon/
+  babel.config.mjs
+  config/
+    babel.publish.config.mjs  # what ember() uses
+    tsconfig.publish.json     # see below
+```
+
+Set `configFile` explicitly to override that (`configFile: false` ignores config
+files entirely, which is what you want when your publish config would just
+restate the built-in defaults).
+
 ## App re-exports
 
 For libraries whose modules must appear in the consuming app's namespace
@@ -194,12 +300,14 @@ export default defineConfig({
 
 With no arguments, top-level services (`services/*`) are re-exported — under
 strict mode, components and helpers are imported, but services are still
-injected by name. A string argument is an include glob, and an object gives
-full control:
+injected by name. A string or array of strings is the include glob(s),
+optionally followed by the remaining options; an object gives full control:
 
 ```js
 appReexports(); // services/*
 appReexports("components/**"); // one include glob
+appReexports(["services/*", "helpers/*"]);
+appReexports("components/**", { exclude: ["components/-private/**"] });
 appReexports({ include: ["services/*", "helpers/*"], exclude: [...] });
 ```
 

package/packages/rolldown/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nullvoxpopuli/ember-rolldown",
-  "version": "2.2.0",
+  "version": "2.6.0",
   "description": "Meta plugin for building ember v2 libraries/addons with rolldown & tsdown.",
   "type": "module",
   "main": "index.ts",

package/packages/rolldown/src/app-reexports.test.ts

@@ -51,13 +51,16 @@ describe("appReexports", () => {
     await rm(projectDir, { recursive: true, force: true });
   });
 
-  async function build(options?: string | AppReexportsOptions) {
+  async function build(
+    include?: string | string[] | AppReexportsOptions,
+    options?: Omit<AppReexportsOptions, "include">,
+  ) {
     const bundle = await rolldown({
       input: {
         "components/foo": "./src/components/foo.js",
         "utils/math": "./src/utils/math.js",
       },
-      plugins: [appReexports(options)],
+      plugins: [appReexports(include, options)],
     });
 
     await bundle.write({ dir: "dist" });
@@ -100,6 +103,36 @@ describe("appReexports", () => {
     expect(Object.keys(manifest["ember-addon"]["app-js"])).toEqual(["./components/foo.js"]);
   });
 
+  it("accepts an array of include globs", async () => {
+    await build(["components/**", "utils/**"]);
+
+    const manifest = await readJson("package.json");
+
+    expect(Object.keys(manifest["ember-addon"]["app-js"])).toEqual([
+      "./components/foo.js",
+      "./utils/math.js",
+    ]);
+  });
+
+  it("accepts options as the second argument alongside a string or array include", async () => {
+    await build("**/*.js", { exclude: ["utils/**"] });
+
+    let manifest = await readJson("package.json");
+
+    expect(Object.keys(manifest["ember-addon"]["app-js"])).toEqual(["./components/foo.js"]);
+
+    await build(["components/**", "utils/**"], {
+      mapFilename: (name) => name.replace("math", "arithmetic"),
+    });
+
+    manifest = await readJson("package.json");
+
+    expect(manifest["ember-addon"]["app-js"]).toEqual({
+      "./components/foo.js": "./dist/_app_/components/foo.js",
+      "./utils/arithmetic.js": "./dist/_app_/utils/arithmetic.js",
+    });
+  });
+
   it("defaults to top-level services", async () => {
     await mkdir(join(projectDir, "src/services/nested"), { recursive: true });
     await writeFile(join(projectDir, "src/services/session.js"), "export default class {}\n");

package/packages/rolldown/src/app-reexports.ts

@@ -65,16 +65,27 @@ export interface AppReexportsOptions {
  * ```
  *
  * With no arguments, top-level services (`services/*`) are re-exported. A
- * string argument is an include glob; an object gives full control:
+ * string or array of strings is the include glob(s), optionally followed by
+ * the remaining options; an object gives full control:
  *
  * ```js
  * appReexports();                          // services/*
  * appReexports("components/**");           // one include glob
+ * appReexports(["services/*", "helpers/*"]);
+ * appReexports("components/**", { exclude: ["components/-private/**"] });
  * appReexports({ include: ["services/*", "helpers/*"], exclude: [...] });
  * ```
  */
-export function appReexports(options: string | AppReexportsOptions = {}): Plugin {
-  const resolved = typeof options === "string" ? { include: [options] } : options;
+export function appReexports(
+  includeOrOptions: string | string[] | AppReexportsOptions = {},
+  options: Omit<AppReexportsOptions, "include"> = {},
+): Plugin {
+  const resolved =
+    typeof includeOrOptions === "string"
+      ? { ...options, include: [includeOrOptions] }
+      : Array.isArray(includeOrOptions)
+        ? { ...options, include: includeOrOptions }
+        : includeOrOptions;
   const include = resolved.include ?? ["services/*"];
 
   return {

package/packages/rolldown/src/babel.test.ts

@@ -1,6 +1,85 @@
-import { describe, expect, it } from "vitest";
+import { mkdtemp, mkdir, writeFile } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import path from "node:path";
+import { rolldown } from "rolldown";
+import { afterEach, describe, expect, it } from "vitest";
 
-import { emberBabel } from "./babel.ts";
+import { emberBabel, type BabelOptions } from "./babel.ts";
+import { emberTransform } from "./transform.ts";
+
+let restoreCwd: (() => void) | undefined;
+
+afterEach(() => {
+  restoreCwd?.();
+  restoreCwd = undefined;
+});
+
+/**
+ * A babel config whose only plugin rewrites the string `"MARKER"` to `name`, so
+ * the emitted code says which config file babel actually loaded.
+ */
+function markerConfig(name: string): string {
+  return [
+    `export default {`,
+    `  plugins: [`,
+    `    function marker() {`,
+    `      return {`,
+    `        visitor: {`,
+    `          StringLiteral(path) {`,
+    `            if (path.node.value === 'MARKER') path.node.value = '${name}';`,
+    `          },`,
+    `        },`,
+    `      };`,
+    `    },`,
+    `  ],`,
+    `};`,
+  ].join("\n");
+}
+
+/**
+ * Builds a `.gts` entry (so babel actually runs -- `maybeBabel` skips files that
+ * need no transform) in a temp dir that becomes the cwd, the way config
+ * detection sees it under the tsdown CLI. Returns the emitted code.
+ */
+async function bundleWithBabel(
+  files: Record<string, string>,
+  options?: BabelOptions,
+): Promise<string> {
+  const dir = await mkdtemp(path.join(tmpdir(), "ember-rolldown-babel-"));
+
+  const withDefaults: Record<string, string> = {
+    "package.json": JSON.stringify({ name: "fixture", version: "0.0.0", type: "module" }),
+    "index.gts": [
+      `export const marker = 'MARKER';`,
+      `export default <template>hi</template>;`,
+    ].join("\n"),
+    ...files,
+  };
+
+  for (const [relative, source] of Object.entries(withDefaults)) {
+    const full = path.join(dir, relative);
+    await mkdir(path.dirname(full), { recursive: true });
+    await writeFile(full, source, "utf8");
+  }
+
+  const previousCwd = process.cwd();
+  process.chdir(dir);
+  restoreCwd = () => process.chdir(previousCwd);
+
+  const build = await rolldown({
+    input: [path.join(dir, "index.gts")],
+    plugins: [emberTransform(), emberBabel(options)],
+    external: (id) => !(id.startsWith(".") || path.isAbsolute(id)),
+    onwarn() {},
+  });
+
+  const { output } = await build.generate({ format: "es" });
+
+  return output
+    .filter((chunk): chunk is typeof chunk & { code: string } => "code" in chunk)
+    .map((chunk) => chunk.code)
+    .join("\n");
+}
 
 describe("emberBabel", () => {
   it("rejects templateTransforms combined with a config file", () => {
@@ -14,4 +93,48 @@ describe("emberBabel", () => {
       emberBabel({ configFile: false, templateTransforms: ["some-transform"] }),
     ).not.toThrow();
   });
+
+  describe("config detection", () => {
+    it("prefers babel.publish.config over babel.config", async () => {
+      const code = await bundleWithBabel({
+        "babel.config.mjs": markerConfig("dev"),
+        "babel.publish.config.mjs": markerConfig("publish"),
+      });
+
+      expect(code).toContain(`"publish"`);
+      expect(code).not.toContain(`"dev"`);
+    });
+
+    it("falls back to babel.config when there is no publish config", async () => {
+      const code = await bundleWithBabel({ "babel.config.mjs": markerConfig("dev") });
+
+      expect(code).toContain(`"dev"`);
+    });
+
+    it("uses an explicit configFile over either", async () => {
+      const code = await bundleWithBabel(
+        {
+          "babel.config.mjs": markerConfig("dev"),
+          "babel.publish.config.mjs": markerConfig("publish"),
+          "babel.explicit.config.mjs": markerConfig("explicit"),
+        },
+        { configFile: "./babel.explicit.config.mjs" },
+      );
+
+      expect(code).toContain(`"explicit"`);
+      expect(code).not.toContain(`"publish"`);
+    });
+
+    it("ignores every config file when configFile is false", async () => {
+      const code = await bundleWithBabel(
+        {
+          "babel.config.mjs": markerConfig("dev"),
+          "babel.publish.config.mjs": markerConfig("publish"),
+        },
+        { configFile: false },
+      );
+
+      expect(code).toContain(`"MARKER"`);
+    });
+  });
 });

package/packages/rolldown/src/babel.ts

@@ -3,6 +3,8 @@ import transformTypeScript from "@babel/plugin-transform-typescript";
 import templateCompilation from "babel-plugin-ember-template-compilation";
 import decoratorTransforms from "decorator-transforms";
 import { loadPartialConfigSync } from "@babel/core";
+import { existsSync } from "node:fs";
+import { resolve } from "node:path";
 import type { PluginItem } from "@babel/core";
 import type { Transform } from "babel-plugin-ember-template-compilation";
 import type { Plugin } from "rolldown";
@@ -12,8 +14,9 @@ export interface BabelOptions {
   /**
    * The babel config file to use.
    *
-   * - `undefined`: auto-detect the project's babel config (via babel's own
-   *   config resolution).
+   * - `undefined`: auto-detect. A `babel.publish.config.*` (in the package root
+   *   or `config/`) wins, because this is a publish build; otherwise babel's own
+   *   config resolution applies (see `detectConfigFile`).
    * - a string: use that config file.
    * - `false`: ignore config files entirely.
    *
@@ -46,14 +49,55 @@ export interface BabelOptions {
   };
 }
 
+/** Tried in order, so an ESM config wins over a JSON one of the same name. */
+const PUBLISH_CONFIG_EXTENSIONS = ["mjs", "cjs", "js", "mts", "cts", "ts", "json"];
+
+/**
+ * Tried in order: next to package.json first, then `config/` for libraries that
+ * keep their build configuration out of the package root.
+ */
+const PUBLISH_CONFIG_DIRECTORIES = [".", "config"];
+
 /**
- * Resolve the project's root babel config the way babel itself does
- * (`babel.config.{js,cjs,mjs,cts,json}`, honoring `rootMode` semantics).
+ * A `babel.publish.config.*` (in the package root or `config/`), if there is
+ * one.
+ *
+ * A library's plain `babel.config.*` is its *development* config: it typically
+ * compiles `@embroider/macros` away, targets the wire format, and wires up
+ * whatever the in-package demo app or test suite needs. None of that belongs in
+ * a published artifact -- macros must stay for the consuming app to evaluate,
+ * and the wire format is private between one template compiler and one glimmer
+ * runtime. Babel's own resolution can't tell the two apart (it finds whatever
+ * `babel.config.*` exists), so a publish build has to prefer the config named
+ * for publishing.
+ */
+function detectPublishConfigFile(): string | undefined {
+  for (const directory of PUBLISH_CONFIG_DIRECTORIES) {
+    for (const extension of PUBLISH_CONFIG_EXTENSIONS) {
+      const candidate = resolve(directory, `babel.publish.config.${extension}`);
+
+      if (existsSync(candidate)) return candidate;
+    }
+  }
+
+  return undefined;
+}
+
+/**
+ * The config this publish build should use: a `babel.publish.config.*` when the
+ * library has one, else the project's root babel config resolved the way babel
+ * itself does (`babel.config.{js,cjs,mjs,cts,json}`, honoring `rootMode`
+ * semantics) -- which for a library whose only config *is* its publish config
+ * is the same file either way.
  *
  * The sync API evaluates the config file; on node 24+ that works for native
  * ESM configs too (require(esm)).
  */
 function detectConfigFile(): string | undefined {
+  const publishConfig = detectPublishConfigFile();
+
+  if (publishConfig) return publishConfig;
+
   const partial = loadPartialConfigSync({ cwd: process.cwd() });
 
   return partial?.config ?? undefined;
@@ -112,9 +156,10 @@ function defaultPlugins(templateTransforms?: Transform[]): PluginItem[] {
  * to only the files that actually need it (template-tag, decorators, template
  * imports). Everything else stays on the native transform.
  *
- * The library's own babel config is used when it exists; without one,
- * `defaultPlugins` covers templates, decorators, and TypeScript, so no
- * config file is required.
+ * The library's own babel config is used when it exists -- its
+ * `babel.publish.config.*` (root or `config/`) in preference to its
+ * `babel.config.*`, since this is a publish build. Without one, `defaultPlugins` covers templates, decorators,
+ * and TypeScript, so no config file is required.
  *
  * Libraries default to `babelHelpers: "bundled"` so the emitted output is
  * self-contained.