ember.nvp 1.12.0 → 1.14.0

package/.release-plan.json

@@ -2,8 +2,8 @@
   "solution": {
     "ember.nvp": {
       "impact": "minor",
-      "oldVersion": "1.11.2",
-      "newVersion": "1.12.0",
+      "oldVersion": "1.13.0",
+      "newVersion": "1.14.0",
       "tagName": "latest",
       "constraints": [
         {
@@ -23,5 +23,5 @@
       "oldVersion": "1.2.0"
     }
   },
-  "description": "## Release (2026-09-30)\n\n* ember.nvp 1.12.0 (minor)\n\n#### :rocket: Enhancement\n* `ember.nvp`\n  * [#152](https://github.com/NullVoxPopuli/ember.nvp/pull/152) Ask about the project in the current directory first ([@NullVoxPopuli-ai-agent](https://github.com/NullVoxPopuli-ai-agent))\n\n#### Committers: 1\n- @NullVoxPopuli's reduced-access machine account for AI usage ([@NullVoxPopuli-ai-agent](https://github.com/NullVoxPopuli-ai-agent))\n"
+  "description": "## Release (2026-09-30)\n\n* ember.nvp 1.14.0 (minor)\n\n#### :rocket: Enhancement\n* `ember.nvp`\n  * [#156](https://github.com/NullVoxPopuli/ember.nvp/pull/156) Give TypeScript libraries with tests a publish tsconfig ([@NullVoxPopuli-ai-agent](https://github.com/NullVoxPopuli-ai-agent))\n\n#### Committers: 1\n- @NullVoxPopuli's reduced-access machine account for AI usage ([@NullVoxPopuli-ai-agent](https://github.com/NullVoxPopuli-ai-agent))\n"
 }

package/CHANGELOG.md

@@ -2,6 +2,28 @@
 
 ## Release (2026-09-30)
 
+* ember.nvp 1.14.0 (minor)
+
+#### :rocket: Enhancement
+* `ember.nvp`
+  * [#156](https://github.com/NullVoxPopuli/ember.nvp/pull/156) Give TypeScript libraries with tests a publish tsconfig ([@NullVoxPopuli-ai-agent](https://github.com/NullVoxPopuli-ai-agent))
+
+#### Committers: 1
+- @NullVoxPopuli's reduced-access machine account for AI usage ([@NullVoxPopuli-ai-agent](https://github.com/NullVoxPopuli-ai-agent))
+
+## Release (2026-09-30)
+
+* ember.nvp 1.13.0 (minor)
+
+#### :rocket: Enhancement
+* `ember.nvp`
+  * [#154](https://github.com/NullVoxPopuli/ember.nvp/pull/154) Default the project type to the detected type on update ([@NullVoxPopuli-ai-agent](https://github.com/NullVoxPopuli-ai-agent))
+
+#### Committers: 1
+- @NullVoxPopuli's reduced-access machine account for AI usage ([@NullVoxPopuli-ai-agent](https://github.com/NullVoxPopuli-ai-agent))
+
+## Release (2026-09-30)
+
 * ember.nvp 1.12.0 (minor)
 
 #### :rocket: Enhancement

package/README.md

@@ -40,7 +40,7 @@ You can run `ember.nvp` on top of an existing project to add layers to it.
 
 Run it inside the project. When the current directory has a `package.json`, the first question is what to do with it:
 
-- **update**: update the project in this directory. The project name starts as the `package.json` name.
+- **update**: update the project in this directory. The name starts as the `package.json` name, and the type starts as the type that ember.nvp detects (app, library, browser extension, or custom element).
 - **replace**: delete this directory and generate a new project in it.
 - **new**: generate a new project in another directory.
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ember.nvp",
-  "version": "1.12.0",
+  "version": "1.14.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",
@@ -9,6 +9,7 @@
   "type": "module",
   "imports": {
     "#args": "./src/cli/args.js",
+    "#bases": "./src/bases/index.js",
     "#bases/*": "./src/bases/*/index.js",
     "#consolidators/*": "./src/consolidators/*",
     "#layers": "./src/layers/index.js",

package/src/bases/index.js

@@ -0,0 +1,32 @@
+import app from "./minimal-app/index.js";
+import customElement from "./minimal-custom-element/index.js";
+import extension from "./minimal-extension/index.js";
+import library from "./minimal-library/index.js";
+
+/**
+ * The base for each project type.
+ *
+ * Detection asks the bases in this order,
+ * so each base comes before the bases whose markers it also has:
+ * - an extension has the index.html and app/ folder of an app
+ * - a custom element builds with tsdown, like a library
+ * - a library can have an app/ folder (classic addons) or an index.html (a docs app)
+ *
+ * @type {Record<import('#types').ProjectType, import('#types').Base>}
+ */
+export const bases = {
+  extension,
+  "custom-element": customElement,
+  library,
+  app,
+};
+
+/**
+ * @param {string} directory an existing project
+ * @returns {import('#types').ProjectType | undefined}
+ */
+export function detectProjectType(directory) {
+  for (let [type, base] of Object.entries(bases)) {
+    if (base.detect(directory)) return /** @type {import('#types').ProjectType} */ (type);
+  }
+}

package/src/bases/minimal-app/index.js

@@ -1,7 +1,8 @@
 import { packageJson, js } from "ember-apply";
+import { existsSync } from "node:fs";
 import { join } from "node:path";
 import { getLatest } from "#utils/npm.js";
-import { applyFolderTo } from "#utils/fs.js";
+import { applyFolderTo, readJSON } from "#utils/fs.js";
 import { removeConfiguredPlugin } from "#utils/babel.js";
 
 /**
@@ -14,11 +15,23 @@ import { removeConfiguredPlugin } from "#utils/babel.js";
  * - No linting or formatting
  * - No ember-welcome-page
  * - No warp-drive (opt-in if needed)
+ *
+ * @type {import('#types').Base}
  */
 export default {
   label: "Minimal App Base",
   description: "Bare minimum Ember app structure",
 
+  /**
+   * @param {string} directory
+   */
+  detect(directory) {
+    return (
+      readJSON(join(directory, "package.json"))?.["ember-addon"]?.type === "app" ||
+      existsSync(join(directory, "app"))
+    );
+  },
+
   /**
    * 1. Apply files
    *   a. Remove TS if needed

package/src/bases/minimal-custom-element/index.js

@@ -1,4 +1,5 @@
 import { packageJson } from "ember-apply";
+import { existsSync, readFileSync } from "node:fs";
 import { readFile, writeFile } from "node:fs/promises";
 import { join } from "node:path";
 import { getLatest } from "#utils/npm.js";
@@ -26,11 +27,24 @@ const TEMPLATE_TAG_NAME = "minimal-custom-element";
  * - No linting or formatting
  *
  * Testing, linting, formatting, etc. are opt-in via layers.
+ *
+ * @type {import('#types').Base}
  */
 export default {
   label: "Minimal Custom Element Base",
   description: "An Ember component packaged as a custom element (web component)",
 
+  /**
+   * @param {string} directory
+   */
+  detect(directory) {
+    return ["src/register.ts", "src/register.js"].some((file) => {
+      let path = join(directory, file);
+
+      return existsSync(path) && readFileSync(path, "utf-8").includes("customElements.define");
+    });
+  },
+
   /**
    * 1. Apply files
    *   a. Remove TS if needed

package/src/bases/minimal-extension/index.js

@@ -2,7 +2,7 @@ import { packageJson } from "ember-apply";
 import { readFile, writeFile } from "node:fs/promises";
 import { join } from "node:path";
 import { getLatest } from "#utils/npm.js";
-import { applyFolderTo } from "#utils/fs.js";
+import { applyFolderTo, readJSON } from "#utils/fs.js";
 import { removeConfiguredPlugin } from "#utils/babel.js";
 
 /**
@@ -17,11 +17,25 @@ import { removeConfiguredPlugin } from "#utils/babel.js";
  * - No testing framework
  * - No linting or formatting
  * - No ember-welcome-page
+ *
+ * @type {import('#types').Base}
  */
 export default {
   label: "Minimal Extension Base",
   description: "Bare minimum browser extension structure with an Ember popup",
 
+  /**
+   * A web app can have a manifest.json too (for a PWA),
+   * but only a browser extension's manifest has `manifest_version`.
+   *
+   * @param {string} directory
+   */
+  detect(directory) {
+    return ["manifest.json", "public/manifest.json"].some(
+      (file) => readJSON(join(directory, file))?.manifest_version !== undefined,
+    );
+  },
+
   /**
    * 1. Apply files
    *   a. Remove TS if needed

package/src/bases/minimal-library/index.js

@@ -1,8 +1,9 @@
 import { packageJson } from "ember-apply";
+import { existsSync } from "node:fs";
 import { readFile, writeFile } from "node:fs/promises";
 import { join } from "node:path";
 import { getLatest } from "#utils/npm.js";
-import { applyFolderTo } from "#utils/fs.js";
+import { applyFolderTo, readJSON } from "#utils/fs.js";
 import { removeConfiguredPlugin } from "#utils/babel.js";
 
 /**
@@ -18,11 +19,29 @@ import { removeConfiguredPlugin } from "#utils/babel.js";
  * - No linting or formatting
  *
  * Testing, linting, formatting, etc. are opt-in via layers.
+ *
+ * @type {import('#types').Base}
  */
 export default {
   label: "Minimal Library Base",
   description: "Bare minimum Ember v2 library (addon) structure",
 
+  /**
+   * `ember-addon` marks v2 and classic addons.
+   * A library from this base has no `ember-addon`, only a tsdown config.
+   *
+   * @param {string} directory
+   */
+  detect(directory) {
+    let manifest = readJSON(join(directory, "package.json"));
+
+    return (
+      manifest?.["ember-addon"]?.type === "addon" ||
+      Boolean(manifest?.keywords?.includes("ember-addon")) ||
+      existsSync(join(directory, "tsdown.config.js"))
+    );
+  },
+
   /**
    * 1. Apply files
    *   a. Remove TS if needed

package/src/cli/generator.js

@@ -1,9 +1,6 @@
 import { mkdir, rm } from "node:fs/promises";
 
-import baseApp from "#bases/minimal-app";
-import baseExtension from "#bases/minimal-extension";
-import baseLibrary from "#bases/minimal-library";
-import baseCustomElement from "#bases/minimal-custom-element";
+import { bases } from "#bases";
 import { consolidateLintingScripts } from "../consolidators/linting.js";
 import { hasGit } from "#utils/git.js";
 /**
@@ -19,20 +16,7 @@ export async function generateProject(project, replaceOrUpdate) {
 
   await mkdir(project.directory, { recursive: true });
 
-  switch (project.desires.type) {
-    case "app":
-      await baseApp.run(project);
-      break;
-    case "library":
-      await baseLibrary.run(project);
-      break;
-    case "extension":
-      await baseExtension.run(project);
-      break;
-    case "custom-element":
-      await baseCustomElement.run(project);
-      break;
-  }
+  await bases[project.desires.type].run(project);
 
   /**
    * We could run these in a loop until there is no git diff

package/src/cli/index.js

@@ -34,7 +34,7 @@ async function main() {
   const projectName = await askName(here === "update" ? cwd : undefined);
   const projectPath = here ? cwd : await askPath(projectName);
   const replaceOrUpdate = here ?? (await askReplaceOrUpdate(projectPath));
-  const projectType = await askProjectType();
+  const projectType = await askProjectType(replaceOrUpdate === "update" ? projectPath : undefined);
   const selectedLayers = await askLayers(projectType);
   const packageManager = await askPackageManager();
 

package/src/cli/questions/project-type.js

@@ -1,5 +1,6 @@
 import * as p from "@clack/prompts";
 import { answers, printArgInUse } from "#args";
+import { detectProjectType } from "#bases";
 
 /**
  * addon is alias for library
@@ -27,10 +28,10 @@ function isValid(selected) {
 }
 
 /**
- *
+ * @param {string} [existingProject] a directory whose project type becomes the default answer
  * @return {Promise<import('#types').ProjectType>}
  */
-export async function askProjectType() {
+export async function askProjectType(existingProject) {
   if (isValid(answers.type)) {
     printArgInUse("type", answers.type);
 
@@ -43,6 +44,7 @@ export async function askProjectType() {
 
   const answer = await p.select({
     message: "Which type of project?",
+    initialValue: existingProject ? detectProjectType(existingProject) : undefined,
     options: [
       { value: "app", label: "web app", hint: "generates html, js, and css to deploy to the web" },
       {

package/src/layers/qunit/index.js

@@ -1,7 +1,8 @@
 import { applyFolderTo } from "#utils/fs.js";
 import { getLatest } from "#utils/npm.js";
 import { hasConfiguredPlugin, prependPlugin, removeConfiguredPlugin } from "#utils/babel.js";
-import { packageJson } from "ember-apply";
+import { addTsdownConfigProperty } from "#utils/tsdown-config.js";
+import { packageJson, tsconfig } from "ember-apply";
 import { join } from "node:path";
 
 const deps = {
@@ -39,6 +40,7 @@ const libraryTsDeps = {
 };
 
 const TEST_BABEL_CONFIG = "config/test/babel.config.js";
+const PUBLISH_TSCONFIG = "config/tsconfig.publish.json";
 
 /**
  * @param {import('#utils/project.js').Project} project
@@ -72,6 +74,10 @@ export default {
 
     if (isLibrary) {
       await syncTestBabelConfig(project, ts);
+
+      if (ts) {
+        await usePublishTsconfig(project);
+      }
     }
 
     await packageJson.addDevDependencies(
@@ -141,6 +147,12 @@ export default {
       }
     }
 
+    if (project.isLibrary && project.wantsTypeScript && !project.hasFile(PUBLISH_TSCONFIG)) {
+      if (!explain) return false;
+
+      reasons.push(`${PUBLISH_TSCONFIG} is missing`);
+    }
+
     if (explain) {
       return {
         isSetup: reasons.length === 0,
@@ -203,3 +215,45 @@ async function syncTestBabelConfig(project, ts) {
     TEST_BABEL_CONFIG,
   );
 }
+
+/**
+ * A library's tsconfig.json starts as its publish config:
+ * it covers only `src`, with `isolatedDeclarations` for the declarations tsdown emits.
+ *
+ * Tests live outside `src`, and editors, `lint:types`, and eslint read tsconfig.json.
+ * So in a TypeScript library, this layer:
+ * - widens tsconfig.json to `src` and `tests`, without the publish-only settings
+ * - moves those settings to `config/tsconfig.publish.json`, which the build uses
+ *
+ * @param {import('#utils/project.js').Project} project
+ */
+async function usePublishTsconfig(project) {
+  await applyFolderTo(join(import.meta.dirname, "library-ts-files"), project);
+  await addTsdownConfigProperty(project, "tsconfig", `tsconfig: "./${PUBLISH_TSCONFIG}"`);
+
+  let config = await tsconfig.read(project.directory);
+
+  if (!needsWidening(config)) return;
+
+  await tsconfig.modify((json) => {
+    json.include ||= [];
+
+    if (!json.include.includes("tests")) {
+      json.include.push("tests");
+    }
+
+    delete json.compilerOptions?.rootDir;
+    delete json.compilerOptions?.isolatedDeclarations;
+  }, project.directory);
+}
+
+/**
+ * @param {Record<string, any>} config
+ */
+function needsWidening(config) {
+  return (
+    !config.include?.includes("tests") ||
+    config.compilerOptions?.rootDir !== undefined ||
+    config.compilerOptions?.isolatedDeclarations !== undefined
+  );
+}

package/src/layers/qunit/library-ts-files/config/tsconfig.publish.json

@@ -0,0 +1,8 @@
+{
+  "extends": "../tsconfig.json",
+  "include": ["../src"],
+  "compilerOptions": {
+    "rootDir": "../src",
+    "isolatedDeclarations": true
+  }
+}

package/src/utils/fs.js

@@ -1,4 +1,4 @@
-import { existsSync, lstatSync } from "node:fs";
+import { existsSync, lstatSync, readFileSync } from "node:fs";
 import { readFile, glob, mkdir, writeFile } from "node:fs/promises";
 import { join, dirname } from "node:path";
 import { parse as parsePath } from "node:path";
@@ -15,6 +15,23 @@ import { rewriteImportsToMatchFiles } from "./rewrite-imports.js";
  */
 const EVERY_FILE = ["**/*", "**/.*", "**/.*/**/*"];
 
+/**
+ * Project detection reads files that can be missing or broken,
+ * and a guess must not stop the CLI.
+ *
+ * @param {string} path
+ * @returns {any} undefined when the file is missing or is not JSON
+ */
+export function readJSON(path) {
+  if (!existsSync(path)) return;
+
+  try {
+    return JSON.parse(readFileSync(path, "utf-8"));
+  } catch {
+    return;
+  }
+}
+
 /**
  * Modified version of applyFolder from ember-apply.
  *

package/src/utils/types.ts

@@ -89,6 +89,18 @@ export interface Layer {
   >;
 }
 
+export interface Base {
+  label: string;
+  description: string;
+  /**
+   * Whether the directory holds a project of this base's type.
+   *
+   * When updating a project, the type question starts at the first base that detects it.
+   */
+  detect: (directory: string) => boolean;
+  run: (project: Project) => Promise<void>;
+}
+
 export interface DiscoveredLayer extends Layer {
   /**
    * The unique name of the layer.

package/test/ember.nvp/cli.test.ts

@@ -154,14 +154,15 @@ test("cli exits on an invalid layer option flag, before writing anything", async
   }
 });
 
-test("in a project directory, asks to update first and fills in the project's name", async () => {
+test("in a project directory, asks to update first and defaults to the project's name and type", async () => {
   let dir = await mktemp("cli-update-here");
-  await writeFile(join(dir, "package.json"), JSON.stringify({ name: "@scope/my-lib" }));
+  await writeFile(
+    join(dir, "package.json"),
+    JSON.stringify({ name: "@scope/my-lib", "ember-addon": { version: 2, type: "addon" } }),
+  );
 
-  // No --name or --path, so the CLI asks about the project in this directory
+  // No --name, --path, or --type, so the CLI asks about the project in this directory
   let args = [
-    "--type",
-    "library",
     "--layers",
     "prettier",
     "--packageManager",
@@ -171,7 +172,11 @@ test("in a project directory, asks to update first and fills in the project's na
     "--write",
     "yes",
   ];
-  let prompts = ["This directory has a package.json", "What is your project name?"];
+  let prompts = [
+    "This directory has a package.json",
+    "What is your project name?",
+    "Which type of project?",
+  ];
 
   try {
     let { execaPromise } = cli(args, { cwd: dir });
@@ -180,7 +185,7 @@ test("in a project directory, asks to update first and fills in the project's na
     execaPromise.stdout?.on("data", (chunk) => {
       output += chunk;
 
-      // Enter keeps the answer each prompt starts with: "update", then the name
+      // Enter keeps the answer each prompt starts with: "update", the name, then the type
       if (prompts[0] && stripVTControlCharacters(output).includes(prompts[0])) {
         prompts.shift();
         execaPromise.stdin?.write("\r");
@@ -195,6 +200,8 @@ test("in a project directory, asks to update first and fills in the project's na
       text.indexOf("What is your project name?"),
     );
     expect(text).not.toContain("Where would you like to place your project?");
+    expect(text).toMatch(/Which type of project\?\n│  library\n/);
+    expect(existsSync(join(dir, "tsdown.config.js")), "the library base ran").toBe(true);
     expect(text).not.toContain("cd ");
 
     let manifest = JSON.parse(await readFile(join(dir, "package.json"), "utf-8"));

package/test/ember.nvp/detect-project-type.test.ts

@@ -0,0 +1,86 @@
+import { describe, it, expect, afterAll } from "vitest";
+import { generate, mktemp } from "#test-helpers";
+import { detectProjectType } from "#bases";
+import { mkdir, rm, writeFile } from "node:fs/promises";
+import { dirname, join } from "node:path";
+import type { ProjectType } from "#types";
+
+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 });
+  }
+});
+
+async function fixture(files: Record<string, string>) {
+  let dir = await mktemp("detect-project-type");
+  dirs.push(dir);
+
+  for (let [file, contents] of Object.entries(files)) {
+    await mkdir(dirname(join(dir, file)), { recursive: true });
+    await writeFile(join(dir, file), contents);
+  }
+
+  return dir;
+}
+
+describe("detectProjectType", () => {
+  const types: ProjectType[] = ["app", "library", "extension", "custom-element"];
+
+  for (const type of types) {
+    it(`detects a generated ${type}`, async () => {
+      const project = await generate({ type });
+      dirs.push(project.directory);
+
+      expect(detectProjectType(project.directory)).toBe(type);
+    });
+  }
+
+  it("detects a v2 addon with a docs app as a library", async () => {
+    const dir = await fixture({
+      "package.json": JSON.stringify({ "ember-addon": { version: 2, type: "addon" } }),
+      "index.html": "<!doctype html>",
+      "src/index.ts": "",
+    });
+
+    expect(detectProjectType(dir)).toBe("library");
+  });
+
+  it("detects a classic addon as a library", async () => {
+    const dir = await fixture({
+      "package.json": JSON.stringify({ keywords: ["ember-addon"] }),
+      "addon/index.js": "",
+      "app/index.js": "",
+    });
+
+    expect(detectProjectType(dir)).toBe("library");
+  });
+
+  it("detects a vite app", async () => {
+    const dir = await fixture({
+      "package.json": JSON.stringify({ "ember-addon": { version: 2, type: "app" } }),
+      "index.html": "<!doctype html>",
+    });
+
+    expect(detectProjectType(dir)).toBe("app");
+  });
+
+  it("detects an app with a web app manifest as an app", async () => {
+    const dir = await fixture({
+      "package.json": "{}",
+      "app/app.ts": "",
+      "public/manifest.json": JSON.stringify({ name: "my-pwa", display: "standalone" }),
+    });
+
+    expect(detectProjectType(dir)).toBe("app");
+  });
+
+  it("makes no guess for a project it does not know", async () => {
+    const dir = await fixture({ "package.json": JSON.stringify({ name: "a-node-script" }) });
+
+    expect(detectProjectType(dir)).toBe(undefined);
+  });
+});

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

@@ -131,7 +131,7 @@ describe("layer: qunit", () => {
   });
 
   describe("app", () => {
-    it("it boots and run tests", async () => {
+    it("it boots and run tests", { timeout: 300_000 }, async () => {
       const project = await generate({ type: "app", layers: ["qunit"] });
       dirs.push(project.directory);
 
@@ -161,6 +161,7 @@ describe("layer: qunit", () => {
           "README.md",
           "config/test/babel.config.js",
           "config/test/testem.cjs",
+          "config/tsconfig.publish.json",
           "package.json",
           "src/index.ts",
           "tests/rendering/.gitkeep",
@@ -258,24 +259,51 @@ describe("layer: qunit", () => {
       `);
     });
 
-    it("leaves the publish build config alone", async () => {
+    it("builds with a publish tsconfig, so tsconfig.json can cover the tests", async () => {
       expect(await project.read("tsdown.config.js")).toMatchInlineSnapshot(`
         "import { defineConfig } from "tsdown";
         import { ember } from "@nullvoxpopuli/ember-rolldown";
-
-        export default defineConfig({
-          entry: ["./src/index.ts"],
-          plugins: [ember()],
-        });
+        export default defineConfig({ entry: ["./src/index.ts"], plugins: [ember()], tsconfig: "./config/tsconfig.publish.json" })"
+      `);
+      expect(await project.read("config/tsconfig.publish.json")).toMatchInlineSnapshot(`
+        "{
+          "extends": "../tsconfig.json",
+          "include": ["../src"],
+          "compilerOptions": {
+            "rootDir": "../src",
+            "isolatedDeclarations": true
+          }
+        }
+        "
+      `);
+      expect(await project.read("tsconfig.json")).toMatchInlineSnapshot(`
+        "{
+          "extends": "@ember/library-tsconfig",
+          "include": ["src", "tests"],
+          "compilerOptions": {
+            "lib": ["esnext", "dom", "dom.iterable"],
+            "types": ["ember-source/types", "@glint/ember-tsc/types"],
+          },
+          "contentMappers": [
+            {
+              "package": "ember-content-mapper",
+              "extensions": [".gts", ".gjs"],
+            },
+          ],
+        }
         "
       `);
     });
 
-    it("installs, and tests generated against the library's exports pass", async () => {
-      await writeLibrarySource(project, "typescript");
-      await writeExampleTests(project, "typescript");
-      await installAndTest(project);
-    });
+    it(
+      "installs, and tests generated against the library's exports pass",
+      { timeout: 300_000 },
+      async () => {
+        await writeLibrarySource(project, "typescript");
+        await writeExampleTests(project, "typescript");
+        await installAndTest(project);
+      },
+    );
 
     it("the publish build still ships precompileTemplate", async () => {
       let build = await execa("pnpm build", { cwd: project.directory, shell: true });
@@ -288,6 +316,29 @@ describe("layer: qunit", () => {
     });
   });
 
+  describe("library (TypeScript) with eslint", () => {
+    it("lints the tests", { timeout: 300_000 }, async () => {
+      const project = await generate({
+        type: "library",
+        name: "my-lib",
+        layers: ["eslint-bundled", "qunit", "typescript"],
+      });
+      dirs.push(project.directory);
+
+      let install = await execa("pnpm install", { cwd: project.directory, shell: true });
+      expect(install.exitCode).toBe(0);
+
+      // eslint's project service cannot parse a file that no tsconfig includes
+      let lint = await execa("pnpm lint:eslint", {
+        cwd: project.directory,
+        shell: true,
+        reject: false,
+        all: true,
+      });
+      expect(lint.exitCode, lint.all).toBe(0);
+    });
+  });
+
   describe("library (JavaScript)", () => {
     let project: Project;
 
@@ -363,11 +414,15 @@ describe("layer: qunit", () => {
       `);
     });
 
-    it("installs, and tests generated against the library's exports pass", async () => {
-      await writeLibrarySource(project, "javascript");
-      await writeExampleTests(project, "javascript");
-      await installAndTest(project);
-    });
+    it(
+      "installs, and tests generated against the library's exports pass",
+      { timeout: 300_000 },
+      async () => {
+        await writeLibrarySource(project, "javascript");
+        await writeExampleTests(project, "javascript");
+        await installAndTest(project);
+      },
+    );
 
     it("the publish build still ships precompileTemplate", async () => {
       let build = await execa("pnpm build", { cwd: project.directory, shell: true });