ember.nvp 1.2.0 → 1.3.0

package/.release-plan.json

@@ -2,8 +2,8 @@
   "solution": {
     "ember.nvp": {
       "impact": "minor",
-      "oldVersion": "1.1.0",
-      "newVersion": "1.2.0",
+      "oldVersion": "1.2.0",
+      "newVersion": "1.3.0",
       "tagName": "latest",
       "constraints": [
         {
@@ -18,17 +18,13 @@
     },
     "@nullvoxpopuli/ember-rolldown": {
       "impact": "minor",
-      "oldVersion": "2.1.0",
-      "newVersion": "2.2.0",
+      "oldVersion": "2.4.0",
+      "newVersion": "2.5.0",
       "tagName": "latest",
       "constraints": [
         {
           "impact": "minor",
           "reason": "Appears in changelog section :rocket: Enhancement"
-        },
-        {
-          "impact": "patch",
-          "reason": "Appears in changelog section :bug: Bug Fix"
         }
       ],
       "pkgJSONPath": "./packages/rolldown/package.json"
@@ -37,5 +33,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.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"
 }

package/CHANGELOG.md

@@ -1,5 +1,47 @@
 # Changelog
 
+## 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.3.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

@@ -58,11 +58,30 @@ A `babel.config.js` is optional. Without one, `ember()` compiles templates
 [decorator-transforms](https://github.com/ef4/decorator-transforms)), and
 TypeScript; with one, your config runs instead.
 
+### 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 +101,33 @@ 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()],
+});
+```
+
+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 +186,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.
@@ -194,12 +241,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.5.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/externals.test.ts

@@ -0,0 +1,118 @@
+import { mkdir, mkdtemp, 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 { emberExternals } from "./externals.ts";
+
+let restoreCwd: (() => void) | undefined;
+
+afterEach(() => {
+  restoreCwd?.();
+  restoreCwd = undefined;
+});
+
+/**
+ * An ember-source stub whose `ember-addon.renamed-modules` provides
+ * `@glimmer/runtime` (file-path keys, like the real manifest).
+ */
+const EMBER_SOURCE_STUB = {
+  name: "ember-source",
+  version: "0.0.0",
+  "ember-addon": {
+    "renamed-modules": {
+      "@glimmer/runtime/index.js": "ember-source/@glimmer/runtime/index.js",
+      "@ember/-internals/glimmer/index.js": "ember-source/@ember/-internals/glimmer/index.js",
+    },
+  },
+};
+
+/**
+ * Writes a fixture package (manifest + optional stub ember-source in its
+ * node_modules) and cds into it — the plugin reads both from the library's
+ * own context, like the tsdown CLI.
+ */
+async function fixture(manifest: object, { emberSource = true } = {}): Promise<string> {
+  const dir = await mkdtemp(path.join(tmpdir(), "ember-rolldown-externals-"));
+  await writeFile(path.join(dir, "package.json"), JSON.stringify(manifest));
+
+  if (emberSource) {
+    const stubDir = path.join(dir, "node_modules/ember-source");
+    await mkdir(stubDir, { recursive: true });
+    await writeFile(path.join(stubDir, "package.json"), JSON.stringify(EMBER_SOURCE_STUB));
+  }
+
+  const previousCwd = process.cwd();
+  process.chdir(dir);
+  restoreCwd = () => process.chdir(previousCwd);
+
+  return dir;
+}
+
+/** Runs the plugin's own hooks directly against the current fixture. */
+function resolveWith(source: string): unknown {
+  const plugin = emberExternals();
+  // eslint-disable-next-line @typescript-eslint/no-unsafe-call, @typescript-eslint/no-explicit-any
+  (plugin.buildStart as any).call({ addWatchFile() {} });
+  // eslint-disable-next-line @typescript-eslint/no-unsafe-call, @typescript-eslint/no-explicit-any
+  return (plugin.resolveId as any).handler(source);
+}
+
+describe("emberExternals", () => {
+  it("externalizes declared dependencies and the ember virtual packages", async () => {
+    await fixture({ dependencies: { "some-dep": "*" } });
+    expect(resolveWith("some-dep")).toBe(false);
+    expect(resolveWith("@ember/component")).toBe(false);
+    expect(resolveWith("@glimmer/tracking")).toBe(false);
+  });
+
+  it("externalizes the modules ember-source provides via renamed-modules", async () => {
+    // Private API like @glimmer/runtime exists only inside the app's
+    // ember-source (its ember-addon.renamed-modules) — @embroider/core's
+    // emberVirtualPackages doesn't list it.
+    await fixture({});
+    expect(resolveWith("@glimmer/runtime")).toBe(false);
+    expect(resolveWith("@ember/-internals/glimmer")).toBe(false);
+  });
+
+  it("does not blanket-externalize @glimmer packages ember-source doesn't provide", async () => {
+    // e.g. @glimmer/component is a real package a library may want bundled;
+    // only declared deps / virtual packages / renamed-modules are external.
+    await fixture({});
+    expect(resolveWith("@glimmer/not-provided")).toBeUndefined();
+  });
+
+  it("leaves undeclared packages alone, with or without ember-source", async () => {
+    await fixture({});
+    expect(resolveWith("left-pad")).toBeUndefined();
+
+    await fixture({}, { emberSource: false });
+    expect(resolveWith("left-pad")).toBeUndefined();
+    // No ember-source in the graph -> no renamed-modules to consult.
+    expect(resolveWith("@glimmer/runtime")).toBeUndefined();
+  });
+
+  it("keeps a renamed-modules import external through a real build", async () => {
+    const dir = await fixture({ name: "build-fixture" });
+    await writeFile(
+      path.join(dir, "index.ts"),
+      `import { curry } from '@glimmer/runtime';\nexport const curried: unknown = curry;\n`,
+    );
+
+    const warnings: string[] = [];
+    const build = await rolldown({
+      input: path.join(dir, "index.ts"),
+      plugins: [emberExternals()],
+      onwarn(warning) {
+        warnings.push(warning.code ?? String(warning));
+      },
+    });
+    const { output } = await build.generate({ format: "es" });
+
+    expect(warnings.filter((code) => code === "UNRESOLVED_IMPORT")).toEqual([]);
+
+    const code = output.filter((chunk) => "code" in chunk).map((chunk) => chunk.code)[0] ?? "";
+    expect(code).toContain(`from "@glimmer/runtime"`);
+  });
+});

package/packages/rolldown/src/externals.ts

@@ -1,4 +1,6 @@
 import { readFileSync } from "node:fs";
+import { createRequire } from "node:module";
+import path from "node:path";
 
 import type { Plugin } from "rolldown";
 
@@ -33,6 +35,38 @@ function resolvableDependencies(): Set<string> {
   return deps;
 }
 
+/**
+ * The module names ember-source provides by renaming them into itself — the
+ * keys of its `ember-addon.renamed-modules`, normalized from file paths to
+ * import specifiers (`@glimmer/runtime/index.js` → `@glimmer/runtime`).
+ *
+ * This is the authoritative list of ember's provided modules, including
+ * private API that @embroider/core's emberVirtualPackages doesn't cover
+ * (e.g. `@glimmer/runtime`). It deliberately does NOT include real packages
+ * like `@glimmer/component`, which a library may want bundled.
+ *
+ * Resolved from the library's own dependency graph; empty when ember-source
+ * isn't resolvable there.
+ */
+function emberSourceRenamedModules(): Set<string> {
+  const provided = new Set<string>();
+
+  try {
+    const require = createRequire(path.resolve("package.json"));
+    const manifest = require("ember-source/package.json") as {
+      "ember-addon"?: { "renamed-modules"?: Record<string, string> };
+    };
+
+    for (const key of Object.keys(manifest["ember-addon"]?.["renamed-modules"] ?? {})) {
+      provided.add(key.replace(/\.js$/, "").replace(/\/index$/, ""));
+    }
+  } catch {
+    // The library doesn't have ember-source in its graph; nothing to provide.
+  }
+
+  return provided;
+}
+
 /**
  * Keeps the library's declared dependencies and the ember virtual packages
  * (things like `@ember/component`, `@glimmer/tracking`, the template compiler,
@@ -41,6 +75,7 @@ function resolvableDependencies(): Set<string> {
  */
 export function emberExternals(): Plugin {
   let deps: Set<string>;
+  let renamedModules: Set<string>;
 
   return {
     name: "ember:externals",
@@ -48,6 +83,7 @@ export function emberExternals(): Plugin {
     buildStart() {
       this.addWatchFile("package.json");
       deps = resolvableDependencies();
+      renamedModules = emberSourceRenamedModules();
     },
 
     resolveId: {
@@ -76,6 +112,15 @@ export function emberExternals(): Plugin {
           return false;
         }
 
+        // Modules ember-source provides by renaming them into itself
+        // (`ember-addon.renamed-modules`) — private API like
+        // `@glimmer/runtime` that only exists inside the app's ember-source.
+        // Matched on the full specifier: the renamed modules are module
+        // paths, not packages.
+        if (renamedModules.has(source)) {
+          return false;
+        }
+
         return undefined;
       },
     },

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

@@ -0,0 +1,122 @@
+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();
+  });
+});

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

@@ -1,10 +1,39 @@
-import { existsSync } from "node:fs";
+import { existsSync, statSync } from "node:fs";
 import { dirname, resolve } from "node:path";
 
 import type { Plugin } from "rolldown";
+import type { UserConfig } from "tsdown";
 
 /**
- * Errors the build when a `tsconfig.json` is present without
+ * Resolve the tsconfig the build will actually use, mirroring tsdown's own
+ * `tsconfig` option (`string | boolean`):
+ *
+ * - `undefined` / `true`: `tsconfig.json` in the cwd.
+ * - a path to a file: that file.
+ * - a path to a directory: `tsconfig.json` inside it.
+ * - `false`: no tsconfig at all.
+ *
+ * Under plain rolldown there is no such option, so the cwd's `tsconfig.json`
+ * is all there is.
+ */
+function resolveTsconfigPath(option: string | boolean | undefined): string | undefined {
+  if (option === false) return undefined;
+
+  if (typeof option === "string") {
+    const asPath = resolve(option);
+
+    if (existsSync(asPath) && statSync(asPath).isDirectory()) {
+      return resolve(asPath, "tsconfig.json");
+    }
+
+    return asPath;
+  }
+
+  return resolve("tsconfig.json");
+}
+
+/**
+ * Errors the build when the tsconfig it builds with does not set
  * `isolatedDeclarations: true`.
  *
  * This is required: declarations for `.gts`/`.gjs` (template tag) modules can
@@ -18,18 +47,34 @@ import type { Plugin } from "rolldown";
  * same rules the build enforces (exported values need explicit type
  * annotations, e.g. `export const X: TOC<Sig> = <template>...`).
  *
- * Projects without a `tsconfig.json` (JavaScript libraries) or without the
- * `typescript` package have no declarations to emit, so there is nothing to
- * check.
+ * The tsconfig checked is the one tsdown's `tsconfig` option points at, not
+ * necessarily `tsconfig.json`. A library whose package also holds dev-only code
+ * (a demo app, in-package tests) can therefore keep a permissive
+ * `tsconfig.json` covering everything for editors and `tsc --noEmit`, and point
+ * the build at a `tsconfig.publish.json` that covers only the publishable
+ * 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.
  */
 export function emberIsolatedDeclarations(): Plugin {
+  let tsconfigOption: string | boolean | undefined;
+
   return {
     name: "ember:isolated-declarations",
 
+    // Not called under plain rolldown, which leaves `tsconfigOption` undefined
+    // -- i.e. the cwd's tsconfig.json, the only thing it could mean there.
+    tsdownConfig(config: UserConfig) {
+      tsconfigOption = config.tsconfig;
+    },
+
     async buildStart() {
-      const tsconfigPath = resolve("tsconfig.json");
+      const tsconfigPath = resolveTsconfigPath(tsconfigOption);
 
-      if (!existsSync(tsconfigPath)) return;
+      if (!tsconfigPath || !existsSync(tsconfigPath)) return;
 
       let ts: typeof import("typescript");
 
@@ -57,7 +102,10 @@ export function emberIsolatedDeclarations(): Plugin {
             `isolated-declarations pipeline, which reads compiled modules from the bundler's ` +
             `module graph -- the tsc-based pipeline reads from disk and cannot see them.\n\n` +
             `Isolated declarations require exported values to have explicit type annotations, ` +
-            `e.g. \`export const X: TOC<Sig> = <template>...\`.`,
+            `e.g. \`export const X: TOC<Sig> = <template>...\`.\n\n` +
+            `If this tsconfig also covers dev-only code (a demo app, in-package tests) that ` +
+            `should not be constrained this way, point tsdown's \`tsconfig\` option at a ` +
+            `publish-only tsconfig that sets the flag and covers just the published sources.`,
         );
       }
     },

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

@@ -13,7 +13,10 @@ import { emberTransform } from "./transform.ts";
  * `.gts`/`.gjs`/`.ts` handling and doesn't need real dependencies installed.
  * Returns the concatenated code of every emitted chunk.
  */
-async function bundle(files: Record<string, string>): Promise<string> {
+async function bundle(
+  files: Record<string, string>,
+  { input = ["index.ts"] }: { input?: string[] } = {},
+): Promise<string> {
   const dir = await mkdtemp(path.join(tmpdir(), "ember-rolldown-build-"));
 
   for (const [relative, source] of Object.entries(files)) {
@@ -25,7 +28,7 @@ async function bundle(files: Record<string, string>): Promise<string> {
   const isLocal = (id: string) => id.startsWith(".") || id.startsWith("/") || path.isAbsolute(id);
 
   const build = await rolldown({
-    input: path.join(dir, "index.ts"),
+    input: input.map((relative) => path.join(dir, relative)),
     plugins: [emberTransform()],
     external: (id) => !isLocal(id),
     onwarn() {},
@@ -171,6 +174,54 @@ describe("emberTransform (full plugin via rolldown)", () => {
     `);
   });
 
+  it("compiles a .gts module used directly as an entry (no importer)", async () => {
+    const code = await bundle(
+      {
+        // Both an entry .gts and a .ts entry importing it: the shared module
+        // must resolve to ONE id (the entry resolution realpaths, matching
+        // rolldown's own resolver) so it lands in the entry chunk and the
+        // index chunk imports it, rather than duplicating the code.
+        "index.ts": `export { default as Foo } from './foo.gts';`,
+        "foo.gts": [
+          `import Component from '@glimmer/component';`,
+          `export default class Foo extends Component {`,
+          `  <template>Entry</template>`,
+          `}`,
+        ].join("\n"),
+      },
+      { input: ["index.ts", "foo.gts"] },
+    );
+
+    expect(code).not.toContain("<template>");
+    expect(code).toContain("template(");
+    expect(code).toContain(`from "@glimmer/component"`);
+    // deduplicated: the class body appears exactly once, in foo's own chunk
+    expect(code.match(/extends Component/g)).toHaveLength(1);
+    expect(code).toContain(`from "./foo.js"`);
+
+    expect(code).toMatchInlineSnapshot(`
+      "import { template } from "@ember/template-compiler";
+      import Component from "@glimmer/component";
+      //#region foo.ts
+      var Foo = class extends Component {
+      	static {
+      		template(\`Entry\`, {
+      			component: this,
+      			eval() {
+      				return eval(arguments[0]);
+      			}
+      		});
+      	}
+      };
+      //#endregion
+      export { Foo as default };
+
+      import Foo from "./foo.js";
+      export { Foo };
+      "
+    `);
+  });
+
   it("emits sourcemaps for the specifier rewrite (no SOURCEMAP_BROKEN warnings)", async () => {
     const dir = await mkdtemp(path.join(tmpdir(), "ember-rolldown-map-"));
 

package/packages/rolldown/src/transform.ts

@@ -1,5 +1,5 @@
 import { Preprocessor } from "content-tag";
-import { existsSync } from "node:fs";
+import { existsSync, realpathSync } from "node:fs";
 import { readFile, writeFile, readdir } from "node:fs/promises";
 import path from "node:path";
 import type { Plugin } from "rolldown";
@@ -70,7 +70,28 @@ export function emberTransform(): Plugin {
     resolveId: {
       order: "pre",
       handler(id, importer) {
-        if (!importer) return null;
+        // Entries have no importer: their ids come straight from the build
+        // config (tsdown expands entry globs to on-disk paths). Resolve a
+        // `.gts`/`.gjs` entry to the same virtual `.ts`/`.js` id an imported
+        // module gets, so the load hook compiles it via content-tag instead
+        // of the raw `<template>` source hitting the parser. Entries may be
+        // any extension — the emitted `.js`/`.d.ts` paths mirror the entry
+        // paths either way (that's how tsdown's dts support works).
+        if (!importer) {
+          if (!id.endsWith(".gts") && !id.endsWith(".gjs")) return null;
+          if (!existsSync(id)) return null;
+
+          // rolldown's default resolver realpaths entry ids (e.g. macOS
+          // /var -> /private/var). Match it, or this same file imported from
+          // another entry resolves to a second module id and gets duplicated
+          // into both chunks.
+          const fileName = realpathSync(path.resolve(id));
+
+          return {
+            id: fileName.replace(/\.gts$/, ".ts").replace(/\.gjs$/, ".js"),
+            meta: { fileName },
+          };
+        }
 
         const fileName = path.join(path.dirname(importer), id);
 

package/src/layers/github-actions/index.js

@@ -49,6 +49,9 @@ export default {
 
     return reasons.length === 0;
   },
+  readme() {
+    return "### GitHub Actions\n\nContinuous Integration (CI) is configured under `.github/workflows/ci.yml` for automated testing and linting.";
+  },
 };
 
 /**

package/src/layers/prettier/index.js

@@ -62,4 +62,16 @@ export default {
 
     return true;
   },
+
+  /**
+   * @param {import('#utils/project.js').Project} project
+   */
+  readme(project) {
+    return `### Prettier
+
+Code formatting is managed with [Prettier](https://prettier.io/).
+
+- \`${project.runPrefix} format\` - Format code
+- \`${project.runPrefix} lint:prettier\` - Check code formatting`;
+  },
 };

package/src/layers/readme/index.js

@@ -0,0 +1,176 @@
+import { existsSync } from "node:fs";
+import { writeFile } from "node:fs/promises";
+import { join } from "node:path";
+import { formatLabel } from "#utils/cli.js";
+
+/**
+ * @param {import('#utils/project.js').Project} project
+ * @param {string} layerDocsMarkdown
+ */
+function appReadme(project, layerDocsMarkdown) {
+  return `# ${project.name}
+
+An Ember application created with \`ember.nvp\`.
+
+## Getting Started
+
+### Prerequisites
+
+- Node.js >= 24
+- ${project.packageManager}
+
+### Installation
+
+~~~sh
+${project.packageManager} install
+~~~
+
+### Development
+
+To start the local development server:
+
+~~~sh
+${project.runPrefix} dev
+~~~
+
+or
+
+~~~sh
+${project.runPrefix} start
+~~~
+${layerDocsMarkdown}`;
+}
+
+/**
+ * @param {import('#utils/project.js').Project} project
+ * @param {string} layerDocsMarkdown
+ */
+function extensionReadme(project, layerDocsMarkdown) {
+  return `# ${project.name}
+
+A browser extension using Ember created with \`ember.nvp\`.
+
+## Getting Started
+
+### Prerequisites
+
+- Node.js >= 24
+- ${project.packageManager}
+
+### Development
+
+To start development:
+
+~~~sh
+${project.runPrefix} dev
+~~~
+
+or
+
+~~~sh
+${project.runPrefix} start
+~~~
+
+### Building
+
+To build the library:
+
+~~~sh
+${project.runPrefix} build
+~~~
+
+or
+
+~~~sh
+${project.runPrefix} build:watch
+~~~
+${layerDocsMarkdown}`;
+}
+
+/**
+ * @param {import('#utils/project.js').Project} project
+ * @param {string} layerDocsMarkdown
+ */
+function libraryReadme(project, layerDocsMarkdown) {
+  return `# ${project.name}
+
+An Ember library/addon created with \`ember.nvp\`.
+
+## Getting Started
+
+### Prerequisites
+
+- Node.js >= 24
+- ${project.packageManager}
+
+### Development & Building
+
+To build the library:
+
+~~~sh
+${project.runPrefix} build
+~~~
+${layerDocsMarkdown}`;
+}
+
+export default {
+  label: formatLabel("README.md", "generate project documentation"),
+  hint: "project README",
+
+  async defaultValue() {
+    return true;
+  },
+
+  /**
+   * @param {import('#utils/project.js').Project} project
+   */
+  async run(project) {
+    // Collect layer docs
+    const layerDocs = [];
+    for (const layer of project.desires.layers) {
+      if (layer.name === "readme" || !layer.readme) {
+        continue;
+      }
+
+      let doc;
+      if (typeof layer.readme === "function") {
+        doc = await layer.readme(project);
+      } else if (typeof layer.readme === "string") {
+        doc = layer.readme;
+      }
+
+      if (doc && typeof doc === "string" && doc.trim().length > 0) {
+        layerDocs.push(doc.trim());
+      }
+    }
+
+    let layerDocsMarkdown = "";
+    if (layerDocs.length > 0) {
+      layerDocsMarkdown = `\n## Features & Tooling\n\n${layerDocs.join("\n\n")}\n`;
+    }
+
+    // Merge the layers' snippets into the main readme template
+    let content;
+    switch (project.type) {
+      case "extension":
+        content = extensionReadme(project, layerDocsMarkdown);
+        break;
+      case "library":
+        content = libraryReadme(project, layerDocsMarkdown);
+        break;
+      default:
+        content = appReadme(project, layerDocsMarkdown);
+        break;
+    }
+
+    const targetPath = join(project.directory, "README.md");
+    await writeFile(targetPath, `${content.trim()}\n`, "utf-8");
+  },
+
+  /**
+   * @param {import('#utils/project.js').Project} project
+   */
+  async isSetup(project) {
+    return existsSync(join(project.directory, "README.md"));
+  },
+};

package/src/layers/typescript/index.js

@@ -120,6 +120,17 @@ export default {
 
     return reasons.length === 0;
   },
+
+  /**
+   * @param {import('#utils/project.js').Project} project
+   */
+  readme(project) {
+    return `### TypeScript
+
+This project uses TypeScript and Glint for static type checking.
+
+- \`${project.runPrefix} lint:types\` - Typecheck code with Glint/TypeScript`;
+  },
 };
 
 /**

package/src/layers/vitest/index.js

@@ -101,4 +101,15 @@ export default {
 
     return reasons.length === 0;
   },
+
+  /**
+   * @param {import('#utils/project.js').Project} project
+   */
+  readme(project) {
+    return `### Testing (Vitest)
+
+Testing is configured with [Vitest](https://vitest.dev/).
+
+- \`${project.runPrefix} test\` - Run tests`;
+  },
 };

package/src/utils/project.js

@@ -47,6 +47,13 @@ export class Project {
     return this.desires.packageManager;
   }
 
+  /**
+   * @type {string}
+   */
+  get runPrefix() {
+    return this.packageManager === "npm" ? "npm run" : "pnpm";
+  }
+
   /**
    * @type {string}
    */

package/src/utils/types.ts

@@ -13,6 +13,11 @@ export interface Layer {
    * deselect it).
    */
   defaultValue?: (projectType: ProjectType) => unknown;
+  /**
+   * Optional README documentation snippet or function. Whatever is returned
+   * will show up in the generated project's README file.
+   */
+  readme?: string | ((project: Project) => string | undefined | Promise<string | undefined>);
   /**
    * The function that applies the codemod
    *

package/test/ember.nvp/layer-readme.test.ts

@@ -0,0 +1,195 @@
+import { describe, it, expect, beforeAll, afterAll } from "vitest";
+import { generate } from "#test-helpers";
+import { rm } from "node:fs/promises";
+import type { Project } from "ember.nvp";
+
+describe("layer: readme", () => {
+  const dirs: string[] = [];
+
+  afterAll(async () => {
+    if (process.env.CI) return;
+
+    for (const dir of dirs) {
+      await rm(dir, { recursive: true, force: true, maxRetries: 3, retryDelay: 100 });
+    }
+  });
+
+  describe("App project README generation", () => {
+    let project: Project;
+
+    beforeAll(async () => {
+      project = await generate({
+        type: "app",
+        name: "my-app",
+        packageManager: "pnpm",
+        layers: ["readme", "git", "prettier", "typescript"],
+      });
+      dirs.push(project.directory);
+    });
+
+    it("generates README.md with project info and selected layer docs", async () => {
+      expect(await project.read("README.md")).toMatchInlineSnapshot(`
+        "# my-app
+
+        An Ember application created with \`ember.nvp\`.
+
+        ## Getting Started
+
+        ### Prerequisites
+
+        - Node.js >= 24
+        - pnpm
+
+        ### Installation
+
+        ~~~sh
+        pnpm install
+        ~~~
+
+        ### Development
+
+        To start the local development server:
+
+        ~~~sh
+        pnpm dev
+        ~~~
+
+        or
+
+        ~~~sh
+        pnpm start
+        ~~~
+
+        ## Features & Tooling
+
+        ### Prettier
+
+        Code formatting is managed with [Prettier](https://prettier.io/).
+
+        - \`pnpm format\` - Format code
+        - \`pnpm lint:prettier\` - Check code formatting
+
+        ### TypeScript
+
+        This project uses TypeScript and Glint for static type checking.
+
+        - \`pnpm lint:types\` - Typecheck code with Glint/TypeScript
+        "
+      `);
+    });
+  });
+
+  describe("Library project README generation with npm", () => {
+    let project: Project;
+
+    beforeAll(async () => {
+      project = await generate({
+        type: "library",
+        name: "my-lib",
+        packageManager: "npm",
+        layers: ["readme", "prettier"],
+      });
+      dirs.push(project.directory);
+    });
+
+    it("generates README.md with npm-specific commands for library", async () => {
+      expect(await project.read("README.md")).toMatchInlineSnapshot(`
+        "# my-lib
+
+        An Ember library/addon created with \`ember.nvp\`.
+
+        ## Getting Started
+
+        ### Prerequisites
+
+        - Node.js >= 24
+        - npm
+
+        ### Development & Building
+
+        To build the library:
+
+        ~~~sh
+        npm run build
+        ~~~
+
+        ## Features & Tooling
+
+        ### Prettier
+
+        Code formatting is managed with [Prettier](https://prettier.io/).
+
+        - \`npm run format\` - Format code
+        - \`npm run lint:prettier\` - Check code formatting
+        "
+      `);
+    });
+  });
+
+  describe("Extension project README generation", () => {
+    let project: Project;
+
+    beforeAll(async () => {
+      project = await generate({
+        type: "extension",
+        name: "my-extension",
+        packageManager: "pnpm",
+        layers: ["readme", "prettier"],
+      });
+      dirs.push(project.directory);
+    });
+
+    it("generates README.md for browser extension project", async () => {
+      expect(await project.read("README.md")).toMatchInlineSnapshot(`
+        "# my-extension
+
+        A browser extension using Ember created with \`ember.nvp\`.
+
+        ## Getting Started
+
+        ### Prerequisites
+
+        - Node.js >= 24
+        - pnpm
+
+        ### Development
+
+        To start development:
+
+        ~~~sh
+        pnpm dev
+        ~~~
+
+        or
+
+        ~~~sh
+        pnpm start
+        ~~~
+
+        ### Building
+
+        To build the library:
+
+        ~~~sh
+        pnpm build
+        ~~~
+
+        or
+
+        ~~~sh
+        pnpm build:watch
+        ~~~
+
+        ## Features & Tooling
+
+        ### Prettier
+
+        Code formatting is managed with [Prettier](https://prettier.io/).
+
+        - \`pnpm format\` - Format code
+        - \`pnpm lint:prettier\` - Check code formatting
+        "
+      `);
+    });
+  });
+});

package/test/ember.nvp/layers.test.ts

@@ -19,6 +19,7 @@ describe("discoverLayers", () => {
         "prettier",
         "publint",
         "qunit",
+        "readme",
         "renovate",
         "typescript",
         "vitest",