ember.nvp 1.7.0 → 1.7.1

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

@@ -5,16 +5,16 @@ import type { Plugin } from "rolldown";
 import type { UserConfig } from "tsdown";
 
 /**
- * Resolve the tsconfig the build will actually use, mirroring tsdown's own
- * `tsconfig` option (`string | boolean`):
+ * Resolve the tsconfig the build will use.
  *
- * - `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.
+ * Mirrors 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.
+ * 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;
@@ -33,33 +33,41 @@ function resolveTsconfigPath(option: string | boolean | undefined): string | und
 }
 
 /**
- * Errors the build when the tsconfig it builds with does not set
- * `isolatedDeclarations: true`.
+ * 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
- * only be emitted by the isolated-declarations pipeline, which reads compiled
- * modules from the bundler's module graph. The `tsc`-based pipeline reads
- * source files from disk, where the compiled modules don't exist, and fails
- * with "Source file not found".
+ * This is required.
+ * Declarations for `.gts` / `.gjs` (template tag) modules can only be emitted
+ * by the isolated-declarations pipeline,
+ * which reads compiled modules from the bundler's module graph.
  *
- * Failing fast here -- rather than only when declaration emit happens to run
- * -- keeps the project honest: editors and `tsc`/`ember-tsc` then check the
- * same rules the build enforces (exported values need explicit type
- * annotations, e.g. `export const X: TOC<Sig> = <template>...`).
+ * The `tsc`-based pipeline reads source files from disk.
+ * The compiled modules don't exist there, so it fails with "Source file not found".
  *
- * 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.
+ * Failing fast here, rather than only when declaration emit happens to run,
+ * keeps the project honest.
+ * Editors and `tsc` / `ember-tsc` then check the same rules the build enforces:
+ * exported values need explicit type annotations,
+ * e.g. `export const X: TOC<Sig> = <template>...`
  *
- * 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.
+ * The tsconfig checked is the one tsdown's `tsconfig` option points at,
+ * not necessarily `tsconfig.json`.
+ *
+ * So a library whose package also holds dev-only code (a demo app, in-package tests) can:
+ * - keep a permissive `tsconfig.json` covering everything,
+ *   for editors and `tsc --noEmit`
+ * - 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,
+ * and nothing else.
+ *
+ * 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.
+ * 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;
@@ -68,13 +76,15 @@ export function emberIsolatedDeclarations(): Plugin {
   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.
+    // Not called under plain rolldown, which leaves `tsconfigOption` undefined.
+    // That means 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.
+      // `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;
     },
 
@@ -82,11 +92,14 @@ export function emberIsolatedDeclarations(): Plugin {
       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.
+        // Without a tsconfig there is no `isolatedDeclarations`,
+        // so tsdown falls back to the tsc-based declaration pipeline.
+        //
+        // That pipeline 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 ` +
@@ -112,8 +125,8 @@ export function emberIsolatedDeclarations(): Plugin {
       const { config, error } = ts.readConfigFile(tsconfigPath, ts.sys.readFile);
 
       if (error) {
-        // Unreadable/unparsable tsconfig: tsc itself will report this with a
-        // better message than we can.
+        // Unreadable / unparsable tsconfig.
+        // tsc itself will report this with a better message than we can.
         return;
       }
 

package/packages/rolldown/src/plugin-like.ts

@@ -1,22 +1,25 @@
 /**
- * What this package hands back: an object that rolldown and tsdown accept in
- * `plugins`.
+ * What this package hands back:
+ * an object that rolldown and tsdown accept in `plugins`.
  *
- * Structurally this *is* rolldown's `Plugin` -- `name` is its only required
- * member, every hook is optional -- so the two are assignable in both
- * directions: a consumer who imports rolldown's own type can still write
- * `const plugins: Plugin[] = ember()`, and tsdown's `plugins` option lists
- * `{ name: string }` among the shapes it takes.
+ * Structurally this *is* rolldown's `Plugin`.
+ * `name` is its only required member, every hook is optional.
  *
- * Declaring it here rather than re-exporting rolldown's type is what keeps
- * `rolldown` out of the published declarations. Otherwise it has to become a
- * runtime `dependency` purely so consumers can resolve a type: leave it a
- * devDependency and the declaration bundler inlines a ~200kB private copy of
- * rolldown's types instead, nominally distinct from the consumer's own.
+ * So the two are assignable in both directions:
+ * - a consumer who imports rolldown's own type can still write
+ *   `const plugins: Plugin[] = ember()`
+ * - tsdown's `plugins` option lists `{ name: string }` among the shapes it takes
  *
- * The precise hook signatures still apply inside this package -- each plugin
- * function is typed with rolldown's real `Plugin` (a devDependency), and this
- * type only widens what crosses the package boundary.
+ * Declaring it here, rather than re-exporting rolldown's type,
+ * keeps `rolldown` out of the published declarations.
+ *
+ * Otherwise it has to become a runtime `dependency`, purely so consumers can resolve a type.
+ * Leave it a devDependency, and the declaration bundler inlines a ~200kB private copy
+ * of rolldown's types instead, nominally distinct from the consumer's own.
+ *
+ * The precise hook signatures still apply inside this package.
+ * Each plugin function is typed with rolldown's real `Plugin` (a devDependency).
+ * This type only widens what crosses the package boundary.
  */
 export interface RolldownPluginLike {
   name: string;

package/packages/rolldown/src/published-types.test.ts

@@ -5,10 +5,13 @@ import { fileURLToPath } from "node:url";
 import { beforeAll, describe, expect, it } from "vitest";
 
 /**
- * This package's own published shape: consumers write their build config in
- * TypeScript, so `import { ember } from "@nullvoxpopuli/ember-rolldown"` has to
- * carry types. Without them it is an implicit `any` (TS7016), and a config file
- * silently stops being type-checked.
+ * This package's own published shape.
+ *
+ * Consumers write their build config in TypeScript,
+ * so `import { ember } from "@nullvoxpopuli/ember-rolldown"` has to carry types.
+ *
+ * Without them it is an implicit `any` (TS7016),
+ * and a config file silently stops being type-checked.
  */
 const packageDir = path.resolve(path.dirname(fileURLToPath(import.meta.url)), "..");
 
@@ -43,8 +46,8 @@ async function declarations() {
 
 describe("published types", () => {
   beforeAll(async () => {
-    // `clean` is on, but don't let these assertions depend on that: stale
-    // artifacts from an earlier build satisfy every one of them on their own
+    // `clean` is on, but don't let these assertions depend on that.
+    // Stale artifacts from an earlier build satisfy every one of them on their own.
     await rm(path.join(packageDir, "dist"), { recursive: true, force: true });
     await execa("pnpm", ["build"], { cwd: packageDir });
   }, 120_000);
@@ -66,14 +69,16 @@ describe("published types", () => {
 
   /**
    * A declaration may only reach for packages a consumer is guaranteed to have.
-   * Reference a devDependency and there are two ways to lose, both quiet:
-   * the specifier survives and consumers can't resolve it (`skipLibCheck` hides
-   * that, degrading the type to an error type), or the declaration bundler
-   * inlines the whole type surface — a ~200kB copy of rolldown's types, in the
-   * case that prompted this test, nominally distinct from the consumer's own.
    *
-   * `ember()` returns plugins, so `RolldownPluginLike` exists to keep rolldown
-   * on the devDependency side of that line.
+   * Reference a devDependency, and there are two ways to lose, both quiet:
+   * - the specifier survives and consumers can't resolve it
+   *   (`skipLibCheck` hides that, degrading the type to an error type)
+   * - the declaration bundler inlines the whole type surface
+   *   (a ~200kB copy of rolldown's types, in the case that prompted this test,
+   *    nominally distinct from the consumer's own)
+   *
+   * `ember()` returns plugins,
+   * so `RolldownPluginLike` exists to keep rolldown on the devDependency side of that line.
    */
   it("declarations only reference packages consumers have", async () => {
     const manifest = await readManifest();

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

@@ -8,10 +8,15 @@ import { describe, expect, it } from "vitest";
 import { emberTransform } from "./transform.ts";
 
 /**
- * Drives the plugin through a real rolldown build. `files` is a map of
- * relative path -> source; the build entry is `index.ts`. Every bare (package)
- * specifier is marked external so the build only exercises the local
- * `.gts`/`.gjs`/`.ts` handling and doesn't need real dependencies installed.
+ * Drives the plugin through a real rolldown build.
+ *
+ * `files` is a map of relative path -> source.
+ * The build entry is `index.ts`.
+ *
+ * Every bare (package) specifier is marked external,
+ * so the build only exercises the local `.gts` / `.gjs` / `.ts` handling
+ * and doesn't need real dependencies installed.
+ *
  * Returns the concatenated code of every emitted chunk.
  */
 async function bundle(
@@ -45,8 +50,8 @@ async function bundle(
     .map((chunk) => chunk.code)
     .join("\n");
 
-  // rolldown's `//#region <path>` comments reference the random temp dir;
-  // collapse them to the bare filename so snapshots stay deterministic.
+  // rolldown's `//#region <path>` comments reference the random temp dir.
+  // Collapse them to the bare filename so snapshots stay deterministic.
   return code.replace(/(\/\/#region ).*\/([^/\n]+)$/gm, "$1$2");
 }
 
@@ -180,11 +185,13 @@ describe("emberTransform (full plugin via rolldown)", () => {
 
   it("resolves an absolute .gts specifier imported from a plugin's virtual module", async () => {
     /**
-     * The shape a code-generating plugin emits: a virtual module (id prefixed
-     * with `\0`, so it exists nowhere on disk) whose generated source imports
-     * real files by absolute path, because it has no directory to be relative
-     * to. `path.dirname` of such an id is `"\0."`, so the specifier must not be
-     * resolved against the importer's directory.
+     * The shape a code-generating plugin emits:
+     * a virtual module (id prefixed with `\0`, so it exists nowhere on disk)
+     * whose generated source imports real files by absolute path,
+     * because it has no directory to be relative to.
+     *
+     * `path.dirname` of such an id is `"\0."`,
+     * so the specifier must not be resolved against the importer's directory.
      */
     const registry = (dir: string): Plugin[] => {
       const source = "./registry?virtual=views";
@@ -225,10 +232,12 @@ 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.
+        // 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';`,
@@ -299,8 +308,8 @@ describe("emberTransform (full plugin via rolldown)", () => {
 
     const chunk = output.find((entry) => entry.type === "chunk" && "map" in entry);
     expect(chunk).toBeDefined();
-    // The composed map traces through the rewrite back to the original .gts
-    // source (content-tag's map survives the specifier-rewrite pass).
+    // The composed map traces through the rewrite back to the original .gts source.
+    // (content-tag's map survives the specifier-rewrite pass)
     const sources = (chunk as { map?: { sources: string[] } }).map?.sources ?? [];
     expect(sources.some((source) => source.endsWith("foo.gts"))).toBe(true);
   });

package/packages/rolldown/src/transform.ts

@@ -7,9 +7,10 @@ import type { Plugin } from "rolldown";
 const processor = new Preprocessor();
 
 /**
- * `.d.ts` files emitted for `.gts` source reference the original `.gts`
- * specifiers. Consumers can't resolve those, so we rewrite them back to
- * extension-less specifiers.
+ * `.d.ts` files emitted for `.gts` source reference the original `.gts` specifiers.
+ *
+ * Consumers can't resolve those,
+ * so we rewrite them back to extension-less specifiers.
  */
 function fixDeclarationImports(content: string): string {
   return content
@@ -41,10 +42,12 @@ async function fixDtsExtensionsInDir(dir: string): Promise<void> {
 /**
  * A sourcemap mapping every generated line to the same line of the input.
  *
- * `AAAA` is the [0, 0, 0, 0] VLQ segment (first line maps to source 0, line 0,
- * column 0); `AACA` is [0, 0, +1, 0] (each following line advances the source
- * line by one). Exact at line granularity, which is all the specifier rewrite
- * can disturb.
+ * - `AAAA` is the [0, 0, 0, 0] VLQ segment
+ *   (first line maps to source 0, line 0, column 0)
+ * - `AACA` is [0, 0, +1, 0]
+ *   (each following line advances the source line by one)
+ *
+ * Exact at line granularity, which is all the specifier rewrite can disturb.
  */
 function lineIdentityMap(id: string, source: string) {
   return {
@@ -60,8 +63,10 @@ function lineIdentityMap(id: string, source: string) {
 }
 
 /**
- * Maps `.gts` -> `.ts` and `.gjs` -> `.js` (so rolldown can identify them as
- * ts/js) and preprocesses `<template>` via content-tag.
+ * Preprocesses `<template>` via content-tag, and maps
+ *   `.gts` → `.ts`
+ *   `.gjs` → `.js`
+ * so rolldown can identify them as ts / js.
  */
 export function emberTransform(): Plugin {
   return {
@@ -70,21 +75,26 @@ export function emberTransform(): Plugin {
     resolveId: {
       order: "pre",
       handler(id, importer) {
-        // 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).
+        // 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.
+          // 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 {
@@ -93,13 +103,16 @@ export function emberTransform(): Plugin {
           };
         }
 
-        // An absolute specifier already names the file, so it needs no
-        // importer-relative resolution — and joining it onto the importer's
-        // directory would corrupt it. That is not hypothetical: a plugin's
-        // virtual module (id prefixed with `\0`) can generate imports of
-        // on-disk files by absolute path, and `path.dirname("\0./registry")`
-        // is `"\0."`, so joining yields `"\0./Users/.../thing.gts"` — a path
-        // no `existsSync`/`readFile` can accept (it has a null byte in it).
+        // An absolute specifier already names the file,
+        // so it needs no importer-relative resolution.
+        // Joining it onto the importer's directory would corrupt it.
+        //
+        // That is not hypothetical.
+        // A plugin's virtual module (id prefixed with `\0`)
+        // can generate imports of on-disk files by absolute path,
+        // and `path.dirname("\0./registry")` is `"\0."`.
+        // Joining then yields `"\0./Users/.../thing.gts"`:
+        // a path no `existsSync` / `readFile` can accept (it has a null byte in it).
         const fileName = path.isAbsolute(id) ? id : path.join(path.dirname(importer), id);
 
         if (id.endsWith(".gts")) {
@@ -116,15 +129,19 @@ export function emberTransform(): Plugin {
           };
         }
 
-        // A `.ts`/`.js` specifier whose only backing file is a `.gts`/`.gjs`
-        // resolves to the virtual module. This must also serve `.d.ts`
-        // importers: rolldown-plugin-dts resolves a declaration module's
-        // imports through the plugin pipeline (`this.resolve`), and — when the
-        // resolution is a source file — loads it (registering its declaration)
-        // before mapping the import to the declaration id. Virtual modules
-        // exist nowhere else, so if we don't answer here the import either
-        // fails to resolve (no file on disk) or, worse, resolves to a
-        // declaration id that was never registered.
+        // A `.ts` / `.js` specifier whose only backing file is a `.gts` / `.gjs`
+        // resolves to the virtual module.
+        //
+        // This must also serve `.d.ts` importers.
+        // rolldown-plugin-dts resolves a declaration module's imports
+        // through the plugin pipeline (`this.resolve`).
+        // When the resolution is a source file, it loads it (registering its declaration)
+        // before mapping the import to the declaration id.
+        //
+        // Virtual modules exist nowhere else.
+        // If we don't answer here, the import either:
+        // - fails to resolve (no file on disk)
+        // - or, worse, resolves to a declaration id that was never registered
         if (id.endsWith(".ts")) {
           const gtsFileName = fileName.replace(/\.ts$/, ".gts");
           if (existsSync(gtsFileName) && !existsSync(fileName)) {
@@ -152,9 +169,11 @@ export function emberTransform(): Plugin {
         const meta = this.getModuleInfo(id)?.meta ?? {};
         let fileName = meta?.fileName;
 
-        // A virtual id can be loaded without having passed through our
-        // resolveId (rolldown-plugin-dts calls `this.load({ id })` with just
-        // the id), so no meta is attached: recover the backing file from disk.
+        // A virtual id can be loaded without having passed through our resolveId
+        // (rolldown-plugin-dts calls `this.load({ id })` with just the id),
+        // so no meta is attached.
+        //
+        // Recover the backing file from disk.
         if (!fileName && !existsSync(id)) {
           if (id.endsWith(".ts") && existsSync(id.replace(/\.ts$/, ".gts"))) {
             fileName = id.replace(/\.ts$/, ".gts");
@@ -188,12 +207,13 @@ export function emberTransform(): Plugin {
         id: /\.(js|ts)$/,
       },
       handler(input, id) {
-        // Rewrite `.gts` specifiers to `.ts` — the (virtual) source id — in
-        // runtime modules AND declaration modules alike. Declaration modules
-        // must NOT be rewritten to `.d.ts`: rolldown-plugin-dts's resolver
-        // treats a source-file resolution as "load it (registering its
-        // declaration), then map to the declaration id", while a `.d.ts` id is
-        // returned as-is — unloadable when the module isn't registered yet
+        // Rewrite `.gts` specifiers to `.ts`, the (virtual) source id,
+        // in runtime modules AND declaration modules alike.
+        //
+        // Declaration modules must NOT be rewritten to `.d.ts`.
+        // rolldown-plugin-dts's resolver treats a source-file resolution as
+        // "load it (registering its declaration), then map to the declaration id".
+        // A `.d.ts` id is returned as-is: unloadable when the module isn't registered yet
         // (e.g. the `.gts` is only ever type-imported).
         const output = input.replace(
           /(['"`])((?:\.\.?\/|\/|@|[A-Za-z0-9_\-])[^'"]*?\.gts)\1/g,
@@ -204,9 +224,9 @@ export function emberTransform(): Plugin {
           return null;
         }
 
-        // The rewrite only shortens import specifiers in place, so a
-        // line-identity map is accurate to the line (and to the column for
-        // everything before the first rewritten specifier on a line).
+        // The rewrite only shortens import specifiers in place,
+        // so a line-identity map is accurate to the line
+        // (and to the column, for everything before the first rewritten specifier on a line).
         return { code: output, map: lineIdentityMap(id, input) };
       },
     },

package/packages/vite/README.md

@@ -8,30 +8,29 @@ A speed-optimized default meta-config for ember projects.
 npm add @nullvoxpopuli/ember-vite
 ```
 
-Requires node 24+, and — since these packages ship TypeScript source — a
-modern TypeScript when type-checking: 6+ with `lib` covering `es2025` (e.g.
-`esnext`).
+Requires node 24+. These packages ship TypeScript source, so type-checking
+needs TypeScript 6+ with `lib` covering `es2025` (for example `esnext`).
 
 ## Usage
 
-in your vite config
+In your vite config:
 
 ```js
 import { defineConfig } from "vite";
 import { ember } from "@nullvoxpopuli/ember-vite";
 
 export default defineConfig({
-  plugins: [
-    ember(),
-  ],
-}
+  plugins: [ember()],
+});
 ```
 
-And remove any plugins from embroider or babel.
-Then delete from your package.json: `@rollup/plugin-babel`, `@embroider/core`, `@embroider/vite`.
+Then:
+
+1. Remove any plugins from embroider or babel.
+2. Delete from your package.json: `@rollup/plugin-babel`, `@embroider/core`, `@embroider/vite`.
 
 > [!NOTE]
-> babel related deps are still needed for linting, so don't delete those
+> Linting still needs the babel related deps, so keep those.
 
 ## Requirements
 

package/packages/vite/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nullvoxpopuli/ember-vite",
-  "version": "1.1.0",
+  "version": "1.1.1",
   "description": "Meta plugin for ember projects focusing on speed.",
   "type": "module",
   "main": "index.ts",