ember.nvp 1.3.0 → 1.4.0

package/.release-plan.json

@@ -2,13 +2,17 @@
   "solution": {
     "ember.nvp": {
       "impact": "minor",
-      "oldVersion": "1.2.0",
-      "newVersion": "1.3.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,13 +22,17 @@
     },
     "@nullvoxpopuli/ember-rolldown": {
       "impact": "minor",
-      "oldVersion": "2.4.0",
-      "newVersion": "2.5.0",
+      "oldVersion": "2.5.0",
+      "newVersion": "2.6.0",
       "tagName": "latest",
       "constraints": [
         {
           "impact": "minor",
           "reason": "Appears in changelog section :rocket: Enhancement"
+        },
+        {
+          "impact": "patch",
+          "reason": "Appears in changelog section :house: Internal"
         }
       ],
       "pkgJSONPath": "./packages/rolldown/package.json"
@@ -33,5 +41,5 @@
       "oldVersion": "1.1.0"
     }
   },
-  "description": "## Release (2026-08-03)\n\n* ember.nvp 1.3.0 (minor)\n* @nullvoxpopuli/ember-rolldown 2.5.0 (minor)\n\n#### :rocket: Enhancement\n* `ember.nvp`\n  * [#106](https://github.com/NullVoxPopuli/ember.nvp/pull/106) README layer ([@tcjr](https://github.com/tcjr))\n* `@nullvoxpopuli/ember-rolldown`\n  * [#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))\n\n#### Committers: 2\n- Tom Carter ([@tcjr](https://github.com/tcjr))\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

@@ -2,6 +2,24 @@
 
 ## 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)
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ember.nvp",
-  "version": "1.3.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,10 +53,12 @@ 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
 
@@ -124,6 +126,21 @@ export default defineConfig({
 });
 ```
 
+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.
@@ -198,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
 
@@ -220,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

package/packages/rolldown/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nullvoxpopuli/ember-rolldown",
-  "version": "2.5.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/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.

package/packages/rolldown/src/isolated-declarations.ts

@@ -55,12 +55,15 @@ function resolveTsconfigPath(option: string | boolean | undefined): string | und
  * sources -- isolated declarations then constrain exactly the code that gets
  * declarations emitted for it, and nothing else.
  *
- * Projects with no tsconfig (JavaScript libraries, or `tsconfig: false`) or
- * without the `typescript` package have no declarations to emit, so there is
- * nothing to check.
+ * Projects with no tsconfig (JavaScript libraries) or without the `typescript`
+ * package have no declarations to emit, so there is nothing to check.
+ * `tsconfig: false` is different: it is an explicit opt-out, and combined with
+ * declaration emit it produces a confusing "Source file not found" from the
+ * tsc-based pipeline, so it errors here instead.
  */
 export function emberIsolatedDeclarations(): Plugin {
   let tsconfigOption: string | boolean | undefined;
+  let emitsDeclarations = true;
 
   return {
     name: "ember:isolated-declarations",
@@ -69,9 +72,31 @@ export function emberIsolatedDeclarations(): Plugin {
     // -- i.e. the cwd's tsconfig.json, the only thing it could mean there.
     tsdownConfig(config: UserConfig) {
       tsconfigOption = config.tsconfig;
+      // `emberConfig()` turns dts on unless the library turned it off, so an
+      // explicit `false` is the only "no declarations" signal. Hook order
+      // between plugins isn't guaranteed, so don't rely on it having run.
+      emitsDeclarations = config.dts !== false;
     },
 
     async buildStart() {
+      if (tsconfigOption === false) {
+        if (!emitsDeclarations) return;
+
+        // Without a tsconfig there is no `isolatedDeclarations`, so tsdown
+        // falls back to the tsc-based declaration pipeline -- which reads
+        // source files from disk and dies with "Source file not found" on
+        // every `.gts`/`.gjs`, since those only exist compiled in the module
+        // graph. Say so here instead of leaving that to be decoded.
+        this.error(
+          `\`tsconfig: false\` cannot be combined with declaration emit.\n\n` +
+            `Declarations are emitted by the isolated-declarations pipeline, which needs a ` +
+            `tsconfig setting "compilerOptions.isolatedDeclarations": true -- it is the only ` +
+            `pipeline that can see compiled .gts/.gjs modules.\n\n` +
+            `Either point tsdown's \`tsconfig\` option at such a config, or set \`dts: false\` ` +
+            `if this library ships no types.`,
+        );
+      }
+
       const tsconfigPath = resolveTsconfigPath(tsconfigOption);
 
       if (!tsconfigPath || !existsSync(tsconfigPath)) return;

package/test/ember.nvp/publish-configs.test.ts

@@ -0,0 +1,352 @@
+import { describe, it, beforeAll, afterAll, expect } from "vitest";
+import { generate, listFiles } from "#test-helpers";
+import { writeLibrarySource } from "./library-src-fixtures.ts";
+import { execa } from "execa";
+import { mkdir, rm, writeFile } from "node:fs/promises";
+import { join } from "node:path";
+
+import type { Project } from "ember.nvp";
+
+/**
+ * A library whose package also holds dev-only code (a demo app, in-package
+ * tests) keeps two of each build config: a permissive `tsconfig.json` and
+ * `babel.config.js` that editors and `tsc --noEmit` use over everything, and
+ * publish-only counterparts covering just what gets published. Either publish
+ * config can sit in the package root or in `config/`.
+ *
+ * These tests generate a real library, put the configs in each of those
+ * places, and run the real `pnpm build`.
+ */
+
+/**
+ * A development babel config: strips TypeScript, but leaves `<template>` as the
+ * `@ember/template-compiler` call content-tag produced. Publishing this output
+ * would tie the artifact to one exact ember-source.
+ */
+const devBabelConfig = `export default {
+  plugins: [
+    ["@babel/plugin-transform-typescript", { allExtensions: true, allowDeclareFields: true }],
+  ],
+};
+`;
+
+/**
+ * A publish babel config: compiles templates to \`precompileTemplate\`, which is
+ * what a published library ships (the consuming app does the final compile).
+ */
+const publishBabelConfig = `export default {
+  plugins: [
+    ["@babel/plugin-transform-typescript", { allExtensions: true, allowDeclareFields: true }],
+    ["babel-plugin-ember-template-compilation", { targetFormat: "hbs" }],
+    ["module:decorator-transforms", { runtime: { import: "decorator-transforms/runtime-esm" } }],
+  ],
+};
+`;
+
+/**
+ * The `tsconfig.json` such a library actually has: it covers the demo app as
+ * well as `src`, and deliberately has no `isolatedDeclarations` -- dev-only
+ * code shouldn't be held to a declaration-emit constraint. If the build reads
+ * this file rather than the publish tsconfig, the guard fails it, which is what
+ * makes every assertion below meaningful.
+ */
+const devTsconfig = `{
+  "extends": "@ember/library-tsconfig",
+  "include": ["src", "demo-app"],
+  "compilerOptions": {
+    "lib": ["esnext", "dom", "dom.iterable"],
+    "types": ["ember-source/types", "@glint/ember-tsc/types"]
+  }
+}
+`;
+
+/**
+ * Relative paths in a tsconfig resolve against the file itself, so the copy
+ * kept in `config/` has to reach back out to `src`.
+ */
+function publishTsconfig(directory: "." | "config"): string {
+  const src = directory === "config" ? "../src" : "./src";
+
+  return `{
+  "extends": "@ember/library-tsconfig",
+  "include": ["${src}"],
+  "compilerOptions": {
+    "rootDir": "${src}",
+    "lib": ["esnext", "dom", "dom.iterable"],
+    "isolatedDeclarations": true,
+    "types": ["ember-source/types", "@glint/ember-tsc/types"]
+  }
+}
+`;
+}
+
+/** `tsconfigOption` is a literal expression: a quoted path, or `false`. */
+function tsdownConfig(tsconfigOption: string): string {
+  return `import { defineConfig } from "tsdown";
+import { ember } from "@nullvoxpopuli/ember-rolldown";
+
+export default defineConfig({
+  entry: ["./src/index.ts"],
+  tsconfig: ${tsconfigOption},
+  plugins: [ember()],
+});
+`;
+}
+
+/** Every place a publish config can be found, so each layout starts clean. */
+const BABEL_CONFIG_PATHS = ["babel.publish.config.js", "config/babel.publish.config.js"];
+const TSCONFIG_PATHS = [
+  "tsconfig.publish.json",
+  "config/tsconfig.publish.json",
+  "config/tsconfig.json",
+  "tsconfig.base.json",
+];
+
+describe("publish configs", () => {
+  let project: Project;
+
+  beforeAll(async () => {
+    project = await generate({ type: "library", name: "my-lib", layers: ["typescript"] });
+
+    await writeLibrarySource(project, "typescript");
+
+    // A library that writes its own babel config declares the plugins it uses.
+    const manifest = JSON.parse((await project.read("package.json"))!);
+
+    manifest.devDependencies["@babel/core"] = "^7.28.10";
+    manifest.devDependencies["@babel/plugin-transform-typescript"] = "^7.28.10";
+    manifest.devDependencies["babel-plugin-ember-template-compilation"] = "^4.0.0";
+
+    await writeFile(
+      join(project.directory, "package.json"),
+      JSON.stringify(manifest, null, 2),
+      "utf-8",
+    );
+
+    // Dev-only source: exports with no type annotations, which the publish
+    // tsconfig must not cover.
+    await mkdir(join(project.directory, "demo-app"), { recursive: true });
+    await writeFile(
+      join(project.directory, "demo-app", "app.gts"),
+      `export const anything = { not: "annotated" };\nexport default <template>demo</template>;\n`,
+      "utf-8",
+    );
+
+    await writeFile(join(project.directory, "tsconfig.json"), devTsconfig, "utf-8");
+    await writeFile(join(project.directory, "babel.config.js"), devBabelConfig, "utf-8");
+
+    const install = await execa("pnpm install", { cwd: project.directory, shell: true });
+    expect(install.exitCode).toBe(0);
+  });
+
+  afterAll(async () => {
+    if (process.env.CI) return;
+
+    await rm(project.directory, { recursive: true, force: true, maxRetries: 3, retryDelay: 100 });
+  });
+
+  /** Clears every publish config, so one test's layout can't satisfy the next. */
+  async function resetConfigs() {
+    for (const relative of [...BABEL_CONFIG_PATHS, ...TSCONFIG_PATHS]) {
+      await rm(join(project.directory, relative), { force: true });
+    }
+
+    await rm(join(project.directory, "dist"), { recursive: true, force: true });
+    await mkdir(join(project.directory, "config"), { recursive: true });
+  }
+
+  async function runBuild() {
+    const build = await execa("pnpm build", {
+      cwd: project.directory,
+      shell: true,
+      reject: false,
+      all: true,
+    });
+
+    return { build, output: await project.read("dist/index.js") };
+  }
+
+  /** Puts the publish configs in the requested places and runs the real build. */
+  async function buildWith({
+    babel,
+    tsconfig,
+  }: {
+    babel: "." | "config" | false;
+    tsconfig: "." | "config";
+  }) {
+    await resetConfigs();
+
+    if (babel !== false) {
+      const relative = join(babel, "babel.publish.config.js");
+
+      await writeFile(join(project.directory, relative), publishBabelConfig, "utf-8");
+    }
+
+    const tsconfigRelative = join(tsconfig, "tsconfig.publish.json");
+
+    await writeFile(join(project.directory, tsconfigRelative), publishTsconfig(tsconfig), "utf-8");
+    await writeFile(
+      join(project.directory, "tsdown.config.js"),
+      tsdownConfig(`"./${tsconfigRelative}"`),
+      "utf-8",
+    );
+
+    return await runBuild();
+  }
+
+  for (const babel of [".", "config"] as const) {
+    for (const tsconfig of [".", "config"] as const) {
+      const where = (directory: string) => (directory === "." ? "the package root" : "config/");
+
+      it(`builds with the babel config in ${where(babel)} and the tsconfig in ${where(tsconfig)}`, async () => {
+        const { build, output } = await buildWith({ babel, tsconfig });
+
+        expect(build.exitCode, build.all).toBe(0);
+
+        // The publish babel config ran: templates came out as
+        // precompileTemplate, which only its template-compilation step emits.
+        expect(output).toContain("precompileTemplate");
+        expect(output).not.toContain("createTemplateFactory");
+
+        // ...and the dev config, which has no template compilation, did not.
+        expect(output).not.toContain("@ember/template-compiler");
+
+        // Declarations emitted, so the guard read the publish tsconfig: the
+        // dev tsconfig.json covering demo-app/ has no isolatedDeclarations and
+        // would have failed the build.
+        expect(await listFiles(join(project.directory, "dist"))).toContain("index.d.ts");
+      });
+    }
+  }
+
+  it("falls back to the dev babel config when there is no publish one", async () => {
+    const { build, output } = await buildWith({ babel: false, tsconfig: "." });
+
+    expect(build.exitCode, build.all).toBe(0);
+
+    // Nothing compiled the template, so content-tag's output survives -- the
+    // artifact you don't want to publish, which is why the preference exists.
+    expect(output).toContain("@ember/template-compiler");
+    expect(output).not.toContain("precompileTemplate");
+  });
+
+  /**
+   * Writes `files` into the project and builds with `tsconfigOption` as tsdown's
+   * `tsconfig`, for the cases about *which* tsconfig the guard ends up reading.
+   * The publish babel config is always present so these fail for tsconfig
+   * reasons only.
+   */
+  async function buildWithTsconfigOption(
+    tsconfigOption: string,
+    files: Record<string, string> = {},
+  ) {
+    await resetConfigs();
+
+    await writeFile(
+      join(project.directory, "babel.publish.config.js"),
+      publishBabelConfig,
+      "utf-8",
+    );
+
+    for (const [relative, contents] of Object.entries(files)) {
+      await writeFile(join(project.directory, relative), contents, "utf-8");
+    }
+
+    await writeFile(
+      join(project.directory, "tsdown.config.js"),
+      tsdownConfig(tsconfigOption),
+      "utf-8",
+    );
+
+    return await runBuild();
+  }
+
+  it("fails when the publish tsconfig itself lacks isolatedDeclarations", async () => {
+    const { build } = await buildWithTsconfigOption(`"./tsconfig.publish.json"`, {
+      "tsconfig.publish.json": publishTsconfig(".").replace(
+        `"isolatedDeclarations": true,\n    `,
+        "",
+      ),
+    });
+
+    expect(build.exitCode).not.toBe(0);
+    expect(build.all).toContain('"compilerOptions.isolatedDeclarations": true');
+    expect(build.all).toContain("tsconfig.publish.json");
+  });
+
+  it("accepts a directory, reading the tsconfig.json inside it", async () => {
+    const { build } = await buildWithTsconfigOption(`"./config"`, {
+      "config/tsconfig.json": publishTsconfig("config"),
+    });
+
+    expect(build.exitCode, build.all).toBe(0);
+  });
+
+  it("takes the flag from an extends chain", async () => {
+    const { build } = await buildWithTsconfigOption(`"./tsconfig.publish.json"`, {
+      "tsconfig.base.json": `{ "compilerOptions": { "isolatedDeclarations": true } }\n`,
+      "tsconfig.publish.json": publishTsconfig(".").replace(
+        `"extends": "@ember/library-tsconfig"`,
+        `"extends": ["@ember/library-tsconfig", "./tsconfig.base.json"]`,
+      ),
+    });
+
+    expect(build.exitCode, build.all).toBe(0);
+  });
+
+  it("rejects tsconfig: false while declarations are on", async () => {
+    // No tsconfig means no isolatedDeclarations, so tsdown falls back to the
+    // tsc-based pipeline, which can't see compiled .gts and dies with
+    // "Source file not found". Fail with something actionable instead.
+    const { build } = await buildWithTsconfigOption("false");
+
+    expect(build.exitCode).not.toBe(0);
+    expect(build.all).toContain("`tsconfig: false` cannot be combined with declaration emit");
+    expect(build.all).not.toContain("Source file not found");
+  });
+
+  it("allows tsconfig: false for a library that ships no types", async () => {
+    await resetConfigs();
+
+    await writeFile(
+      join(project.directory, "babel.publish.config.js"),
+      publishBabelConfig,
+      "utf-8",
+    );
+    await writeFile(
+      join(project.directory, "tsdown.config.js"),
+      `import { defineConfig } from "tsdown";
+import { ember } from "@nullvoxpopuli/ember-rolldown";
+
+export default defineConfig({
+  entry: ["./src/index.ts"],
+  tsconfig: false,
+  dts: false,
+  plugins: [ember()],
+});
+`,
+      "utf-8",
+    );
+
+    const { build } = await runBuild();
+
+    expect(build.exitCode, build.all).toBe(0);
+    expect(await listFiles(join(project.directory, "dist"))).not.toContain("index.d.ts");
+  });
+
+  it("keeps dev-only source out of the build", async () => {
+    // demo-app/app.gts would be an isolated-declarations error, and builds fine
+    // only because the publish tsconfig doesn't cover it.
+    const { build } = await buildWith({ babel: ".", tsconfig: "." });
+
+    expect(build.exitCode, build.all).toBe(0);
+    expect(await listFiles(join(project.directory, "dist"))).toMatchInlineSnapshot(`
+      [
+        "index.d.ts",
+        "index.d.ts.map",
+        "index.js",
+        "index.js.map",
+      ]
+    `);
+  });
+});

package/packages/rolldown/src/isolated-declarations.test.ts

@@ -1,122 +0,0 @@
-import { mkdir, mkdtemp, writeFile } from "node:fs/promises";
-import { tmpdir } from "node:os";
-import path from "node:path";
-import { build } from "tsdown";
-import { afterEach, describe, expect, it } from "vitest";
-
-import { ember } from "../index.ts";
-
-let restoreCwd: (() => void) | undefined;
-
-afterEach(() => {
-  restoreCwd?.();
-  restoreCwd = undefined;
-});
-
-/**
- * Runs a real tsdown build of a single trivial entry in a temp dir, so the
- * isolated-declarations guard reads the tsconfig files written by the test the
- * same way it does under the tsdown CLI. Returns the build's rejection, or
- * `undefined` when it succeeded.
- */
-async function buildFixture(
-  files: Record<string, string>,
-  tsconfig?: string | boolean,
-): Promise<Error | undefined> {
-  const dir = await mkdtemp(path.join(tmpdir(), "ember-rolldown-isolated-declarations-"));
-
-  const withDefaults: Record<string, string> = {
-    "package.json": JSON.stringify({ name: "fixture", version: "0.0.0", type: "module" }),
-    "src/index.ts": `export const greeting: string = 'hello';`,
-    ...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);
-
-  try {
-    await build({
-      entry: ["./src/index.ts"],
-      config: false,
-      logLevel: "silent",
-      tsconfig,
-      plugins: [ember()],
-    });
-
-    return undefined;
-  } catch (error) {
-    return error as Error;
-  }
-}
-
-const withFlag = JSON.stringify({
-  compilerOptions: { isolatedDeclarations: true, declaration: true },
-});
-const withoutFlag = JSON.stringify({ compilerOptions: { declaration: true } });
-
-describe("isolated declarations guard", () => {
-  it("errors when the cwd tsconfig.json does not set the flag", async () => {
-    const error = await buildFixture({ "tsconfig.json": withoutFlag });
-
-    expect(error?.message).toContain(`must set "compilerOptions.isolatedDeclarations": true`);
-  });
-
-  it("passes when the cwd tsconfig.json sets the flag", async () => {
-    expect(await buildFixture({ "tsconfig.json": withFlag })).toBeUndefined();
-  });
-
-  it("checks the tsconfig the `tsconfig` option points at, not tsconfig.json", async () => {
-    // The shape a library with in-package dev code wants: a permissive
-    // tsconfig.json for editors and `tsc --noEmit` over everything, and a
-    // publish-only tsconfig -- the one the build uses -- carrying the flag.
-    const error = await buildFixture(
-      { "tsconfig.json": withoutFlag, "tsconfig.publish.json": withFlag },
-      "./tsconfig.publish.json",
-    );
-
-    expect(error).toBeUndefined();
-  });
-
-  it("errors when the tsconfig the `tsconfig` option points at lacks the flag", async () => {
-    const error = await buildFixture(
-      { "tsconfig.json": withFlag, "tsconfig.publish.json": withoutFlag },
-      "./tsconfig.publish.json",
-    );
-
-    expect(error?.message).toContain("tsconfig.publish.json");
-    expect(error?.message).toContain(`must set "compilerOptions.isolatedDeclarations": true`);
-  });
-
-  it("resolves a directory `tsconfig` option to the tsconfig.json inside it", async () => {
-    const error = await buildFixture(
-      { "tsconfig.json": withFlag, "config/tsconfig.json": withoutFlag },
-      "./config",
-    );
-
-    expect(error?.message).toContain(`must set "compilerOptions.isolatedDeclarations": true`);
-  });
-
-  it("skips the check when there is no tsconfig at all", async () => {
-    expect(await buildFixture({})).toBeUndefined();
-  });
-
-  it("skips the check when tsconfig is disabled", async () => {
-    expect(await buildFixture({ "tsconfig.json": withoutFlag }, false)).toBeUndefined();
-  });
-
-  it("inherits the flag through an extends chain", async () => {
-    const error = await buildFixture({
-      "tsconfig.base.json": withFlag,
-      "tsconfig.json": JSON.stringify({ extends: "./tsconfig.base.json" }),
-    });
-
-    expect(error).toBeUndefined();
-  });
-});