@akanjs/devkit 3.0.0-beta.9 → 3.0.0

package/subspace.ts

@@ -75,15 +75,8 @@ export interface SubspacePullResult {
   incoming: SubspaceIncomingCommit[];
 }
 
-/**
- * One customer repo, mirrored from this workspace.
- *
- * Push is a squashed snapshot of the workspace's own tracked files, so a subspace's history never
- * carries the workspace's — which is also what keeps one customer's commit messages out of another's
- * repo. Pull is the reverse and rare: it compares the subspace against the last push it received rather
- * than against the workspace, so the diff is exactly the customer's own work however far the workspace
- * has moved on.
- */
+// Push is a squashed snapshot, so no workspace history (or other customer's commit message) reaches a subspace;
+// pull diffs against the last push received, so it is exactly the customer's own work.
 export class Subspace {
   static readonly anchorFile = "akan.subspace.json";
   /** Never reaches a subspace: it names every other customer's repo. */
@@ -133,7 +126,6 @@ export class Subspace {
     return (await this.#git(["rev-parse", "--short", "HEAD"])).trim();
   }
 
-  /** Adds the subspace as a remote if absent, then fetches the branch into this workspace's object store. */
   async fetch(branch: string) {
     const remotes = (await this.#git(["remote"])).split("\n").map((line) => line.trim());
     if (remotes.includes(this.#remote)) await this.#git(["remote", "set-url", this.#remote, this.#declaration.repo]);
@@ -147,10 +139,7 @@ export class Subspace {
     }
   }
 
-  /**
-   * The last push, located by the one file only a push writes. A tag or a recorded sha would have to be
-   * kept in step by hand; this file is already in the subspace's history and cannot drift out of it.
-   */
+  //* Located by the one file only a push writes: unlike a tag or a recorded sha, it cannot drift out of the history.
   async anchor(branch: string): Promise<SubspaceAnchor> {
     const ref = `${this.#remote}/${branch}`;
     const commit = (await this.#git(["log", "-1", "--format=%H", ref, "--", Subspace.anchorFile])).trim();
@@ -184,11 +173,7 @@ export class Subspace {
     return Subspace.subspaceOwnedDirs.includes(segments[2] ?? "");
   }
 
-  /**
-   * A library manifest always differs: the subspace's copy carries the `akan.source` stamp a push writes and
-   * the workspace's does not. Comparing it with that key removed is what keeps `status` and `diff` from
-   * reporting every library as changed forever.
-   */
+  // A library manifest always differs by the `akan.source` stamp a push writes, so it is compared without that key.
   #isStamped(file: string) {
     return /^libs\/[^/]+\/package\.json$/.test(file);
   }
@@ -201,9 +186,7 @@ export class Subspace {
     if (!theirs || !ours) return true;
     const normalize = (content: string) => {
       try {
-        const manifest = JSON.parse(content) as Record<string, unknown>;
-        delete manifest[LibSource.manifestKey];
-        return JSON.stringify(manifest);
+        return LibSource.unstamped(content);
       } catch {
         return content;
       }
@@ -211,7 +194,10 @@ export class Subspace {
     return normalize(theirs) !== normalize(ours);
   }
 
-  async #meaningfulFiles(ref: string, files: string[]) {
+  async #changedSliceFiles(ref: string, diffArgs: string[]) {
+    const files = (await this.#git(["diff", "--name-only", ...diffArgs]))
+      .split("\n")
+      .filter((file) => !!file.trim() && !this.#isSubspaceOwned(file));
     const kept = await Promise.all(
       files.map(async (file) => (this.#isStamped(file) ? await this.#differsBeyondStamp(ref, file) : true)),
     );
@@ -226,14 +212,7 @@ export class Subspace {
     ]);
     if (!hasBranch) return { name: this.name, branch, hasBranch, anchor, behindPaths: [], driftedLibs: [] };
     const ref = `${this.#remote}/${branch}`;
-    const diff = await this.#git(["diff", "--name-only", "HEAD", ref, "--", ...paths]);
-    const behindPaths = await this.#meaningfulFiles(
-      ref,
-      diff
-        .split("\n")
-        .filter((file) => !!file.trim())
-        .filter((file) => !this.#isSubspaceOwned(file)),
-    );
+    const behindPaths = await this.#changedSliceFiles(ref, ["HEAD", ref, "--", ...paths]);
     const driftedLibs = libs.filter((lib) => behindPaths.some((file) => file.startsWith(`libs/${lib}/`)));
     return { name: this.name, branch, hasBranch, anchor, behindPaths, driftedLibs };
   }
@@ -273,11 +252,7 @@ export class Subspace {
     return held;
   }
 
-  /**
-   * Puts back only the files the workspace does not ship. The workspace still owns the tracked env switch files
-   * (`env.server.ts` / `env.client.ts`), which is what keeps them in step; everything else under `env/` —
-   * the per-environment values, which the workspace gitignores and never had — belongs to the subspace and wins.
-   */
+  // The workspace owns the tracked env switch files; the per-environment values it gitignores belong to the subspace.
   async #restoreSubspaceOwned(held: { from: string; to: string }[]) {
     for (const { from, to } of held) await Subspace.#copyMissing(to, from);
     await rm(path.join(this.#clonePath, Subspace.holdDir), { recursive: true, force: true });
@@ -293,25 +268,26 @@ export class Subspace {
     }
   }
 
-  /**
-   * `git archive` emits exactly the tracked files at HEAD, which is why the copy needs no exclude list of
-   * its own: generated barrels, the `(libs)`/`public/libs` symlinks, env values, secrets and the lockfile
-   * are all outside git and cannot enter the archive. Directory arguments only — a file list would put
-   * route paths like `page/(docs)/…` through a shell.
-   */
+  // `git archive` emits only tracked files, so generated barrels, lib symlinks, env values and secrets never enter.
   async #extract(paths: string[], excludes: string[] = []) {
-    const pathspec = paths.map((entry) => `'${entry}'`).join(" ");
-    const excludeArgs = excludes.map((entry) => `--exclude='${entry}'`).join(" ");
-    await this.#workspace.exec(
-      `git archive HEAD -- ${pathspec} | tar -x -C '${this.#clonePath}' ${excludeArgs}`.trim(),
-    );
+    // Relative, because GNU tar reads a drive-letter archive name (`C:\…`) as `host:path` on a remote host.
+    const archivePath = path.relative(this.#workspace.workspaceRoot, `${this.#clonePath}.tar`);
+    await this.#workspace.spawn("git", ["archive", "-o", archivePath, "HEAD", "--", ...paths]);
+    try {
+      await this.#workspace.spawn("tar", [
+        "-x",
+        "-f",
+        archivePath,
+        "-C",
+        this.#clonePath,
+        ...excludes.map((entry) => `--exclude=${entry}`),
+      ]);
+    } finally {
+      await rm(path.join(this.#workspace.workspaceRoot, archivePath), { force: true });
+    }
   }
 
-  /**
-   * Verify-only, and an allowlist rather than a filter so no secret can reach a customer's clone even by
-   * accident. `AKAN_PUBLIC_*` values are the ones akan embeds in every client bundle, so they are public
-   * by construction; the cloud workspace id is pinned to `local` rather than copied.
-   */
+  // An allowlist, not a filter, so no secret can reach a customer's clone; `AKAN_PUBLIC_*` ships in every bundle anyway.
   #localEnv() {
     const { serveDomain } = WorkspaceExecutor.getBaseDevEnv();
     return {
@@ -324,13 +300,8 @@ export class Subspace {
     };
   }
 
-  /**
-   * The CLI identifies a workspace root by `package.json` + `tsconfig.json` + `.env`, so a clone with no
-   * `.env` cannot run `akan sync` at all — and one can never arrive with the slice, since every akan
-   * workspace gitignores it and the subspace's real values are its own. Excluded through the clone's
-   * `.git/info/exclude` rather than through the copied `.gitignore`: a workspace that omitted the pattern
-   * would otherwise commit this file into the customer's repo.
-   */
+  // The CLI needs a `.env` to recognise a workspace root and none arrives with the slice. Excluded through
+  // `.git/info/exclude`, not the copied `.gitignore`, so it can never be committed to the customer's repo.
   async #writeLocalEnv() {
     const excludePath = path.join(this.#clonePath, ".git/info/exclude");
     const exclude = (await FileSys.fileExists(excludePath)) ? await FileSys.readText(excludePath) : "";
@@ -344,11 +315,7 @@ export class Subspace {
     await FileSys.writeText(envPath, `${lines.join("\n")}\n`);
   }
 
-  /**
-   * A workspace's root manifest is the union of every app it holds, so shipping it verbatim installs
-   * every other customer's dependency tree in this repo. It is rebuilt from this subspace's own slices
-   * instead, keeping the workspace's exact version specs.
-   */
+  // The root manifest is the union of every app's dependencies, so it is rebuilt from this subspace's slices.
   async #rewriteManifest(plans: SlicePlan[]) {
     const manifestPath = path.join(this.#clonePath, "package.json");
     if (!(await FileSys.fileExists(manifestPath))) return [];
@@ -373,8 +340,7 @@ export class Subspace {
     for (const member of Subspace.memberDirs)
       await rm(path.join(this.#clonePath, member), { recursive: true, force: true });
 
-    //* The shell is overlaid, never reconciled: a subspace owns its deployment (its own CI files and
-    //* workflows live there), so a root entry the workspace does not have is left alone rather than deleted.
+    //* Overlaid, never reconciled: a subspace owns its deployment, so a root entry the workspace lacks is left alone.
     await this.#extract(["."], ["apps/*", "libs/*", "pkgs/*"]);
     await this.#extract(paths);
     await this.#restoreSubspaceOwned(held);
@@ -390,16 +356,13 @@ export class Subspace {
     return { libs, pruned };
   }
 
-  /**
-   * The `akan:secrets` block akan generates lists every app in the workspace by name, so it is filtered down to
-   * this subspace's own apps. `bun.lock` is un-ignored because a subspace commits its lockfile — that is what
-   * makes two subspaces on one branch resolve the same dependency tree rather than merely the same ranges.
-   */
+  // `akan:secrets` names every workspace app, so it is filtered; `bun.lock` is un-ignored because a subspace commits it.
   async #rewriteGitignore() {
     const gitignorePath = path.join(this.#clonePath, ".gitignore");
     if (!(await FileSys.fileExists(gitignorePath))) return;
     const [begin = "", end = ""] = Subspace.secretsMarkers;
-    const lines = (await FileSys.readText(gitignorePath)).split("\n");
+    // `git archive` checks text out as CRLF under Windows Git's default `core.autocrlf=true`.
+    const lines = (await FileSys.readText(gitignorePath)).split(/\r?\n/);
     const beginIdx = lines.indexOf(begin);
     const endIdx = lines.indexOf(end);
     const filtered =
@@ -431,12 +394,8 @@ export class Subspace {
     }
   }
 
-  /**
-   * Written onto the clone's manifest directly rather than through `LibSource`, which addresses a library
-   * by its position in the *workspace's* workspace. The hash follows the same rule — the library's own git files
-   * with `env/` and the stamp itself left out — and is only written when it would change, so an
-   * up-to-date subspace stays clean and the push is skipped.
-   */
+  // Not through `LibSource`, which addresses a library by its position in the workspace. The hash skips `env/` and
+  // the stamp itself.
   async #stampLib(clone: Executor, lib: string, branch: string) {
     const manifestPath = path.join(this.#clonePath, "libs", lib, "package.json");
     if (!(await FileSys.fileExists(manifestPath))) return;
@@ -445,9 +404,8 @@ export class Subspace {
     const [hash, previous] = await Promise.all([this.#hashLib(clone, lib), this.#committedStamp(clone, lib)]);
     const manifest = (await FileSys.readJson(manifestPath)) as Record<string, unknown>;
     const akan = (manifest[LibSource.manifestKey] ?? {}) as Record<string, unknown>;
-    //* The extraction overwrote the manifest with the workspace's, stamp and all, so the previous stamp has to
-    //* come from the clone's HEAD. Reusing its `syncedAt` when nothing else moved is what leaves the file
-    //* byte-identical to what is committed — otherwise every push is dirty and none is ever skipped.
+    //* The extraction overwrote the manifest, so the previous stamp comes from the clone's HEAD; reusing its
+    //* `syncedAt` when nothing moved keeps the file byte-identical, or no push would ever be skipped.
     const unchanged = previous?.origin === origin && previous.sha === sha && previous.hash === hash;
     const syncedAt = unchanged ? previous.syncedAt : new Date().toISOString();
     manifest[LibSource.manifestKey] = { ...akan, source: { origin, sha, hash, syncedAt } };
@@ -480,26 +438,15 @@ export class Subspace {
       .split("\0")
       .filter((file) => !!file && !this.#isSubspaceOwned(file))
       .sort();
-    //* `--cached` reads the clone's index, which the slice replaced the members without updating — so it still
-    //* names every file the workspace has deleted or moved since the last push, and opening one throws. The
-    //* index is only reconciled by the `git add -A` a push commits with, long after the stamp is written.
+    //* The index still lists files the workspace deleted since the last push (only the push's `git add -A`
+    //* reconciles it), and opening one throws.
     const present = await Promise.all(
       candidates.map(async (file) => await FileSys.entryExists(path.join(this.#clonePath, file))),
     );
     const files = candidates.filter((_, index) => present[index]);
-    const hasher = new Bun.CryptoHasher("sha256");
-    for (const file of files) {
-      const content = await FileSys.readText(path.join(this.#clonePath, file));
-      hasher.update(file);
-      hasher.update("\0");
-      if (file === `libs/${lib}/package.json`) {
-        const manifest = JSON.parse(content) as Record<string, unknown>;
-        delete manifest[LibSource.manifestKey];
-        hasher.update(JSON.stringify(manifest));
-      } else hasher.update(content);
-      hasher.update("\0");
-    }
-    return hasher.digest("hex").slice(0, 32);
+    return await LibSource.hashFiles(files, `libs/${lib}/package.json`, (file) =>
+      FileSys.readText(path.join(this.#clonePath, file)),
+    );
   }
 
   /** Direction is subspace → workspace, so the patch reads as what a push would apply rather than its inverse. */
@@ -519,25 +466,14 @@ export class Subspace {
     const scoped = filter ? paths.filter((entry) => entry.startsWith(filter) || filter.startsWith(entry)) : paths;
     if (!scoped.length) return { files: [], patch: "" };
     const from = `${this.#remote}/${branch}`;
-    const pathspec = filter ? [filter] : scoped;
-    const names = await this.#git(["diff", "--name-only", from, "HEAD", "--", ...pathspec]);
-    const files = await this.#meaningfulFiles(
-      from,
-      names
-        .split("\n")
-        .filter((file) => !!file.trim())
-        .filter((file) => !this.#isSubspaceOwned(file)),
-    );
+    const files = await this.#changedSliceFiles(from, [from, "HEAD", "--", ...(filter ? [filter] : scoped)]);
     if (!files.length) return { files: [], patch: "" };
     //? argv, not a shell: a route path such as `page/(docs)/…` would need quoting through one.
     return { files, patch: await this.#git(["diff", from, "HEAD", "--", ...files]) };
   }
 
-  /**
-   * Refuses the subspace rather than throwing, so one customer repo that fails to install or sync does not
-   * abort the push to the rest of the subspaces. The env is passed explicitly so the child sees the values
-   * written into the clone instead of inheriting the workspace's own.
-   */
+  // Refuses rather than throws, so one failing subspace does not abort the rest; the env is explicit so the child
+  // sees the clone's values, not the workspace's.
   async #verify(clone: Executor) {
     const env = { ...process.env, ...this.#localEnv() };
     try {
@@ -628,10 +564,7 @@ export class Subspace {
     await this.#git(["apply", "--3way", absolute]);
   }
 
-  /**
-   * A library hunk is never applied by default: the workspace is the one copy every other subspace is pushed from,
-   * so adopting one customer's edit silently would ship it to all of them.
-   */
+  // Not applied by default: every subspace is pushed from the workspace, so one customer's lib edit would ship to all.
   async #savePatch(range: string, files: string[], label: string) {
     const patchPath = path.join(this.#workspace.workspaceRoot, ".akan/subspace", `${this.name}-${label}.patch`);
     await mkdir(path.dirname(patchPath), { recursive: true });

package/subspaceConfig.ts

@@ -5,13 +5,7 @@ import { FileSys } from "./fileSys";
 
 export type { SubspaceConfigInput, SubspaceDeclaration };
 
-/**
- * `akan.subspace.ts` at the workspace root: which customer repo each app is mirrored to.
- *
- * There is no branch field. The branch is whichever one the workspace is on, so the same declaration
- * serves `develop` and `main`, and every subspace on one branch holds the same akanjs version and the
- * same library source.
- */
+// No branch field: the workspace's current branch is used, so every subspace on it holds the same akanjs and libs.
 export class SubspaceConfig {
   static readonly fileName = "akan.subspace.ts";
   static readonly defaultPushableBranches = ["main", "develop", "debug"];
@@ -48,8 +42,7 @@ export class SubspaceConfig {
         throw new Error(`${SubspaceConfig.fileName}: subspace "${subspace.name}" declares no apps`);
       for (const app of subspace.apps) {
         const owner = appOwners.get(app);
-        //* One app never goes to two subspaces: the two would need per-subspace domains and ids, which
-        //* this declaration cannot express. Share code through a lib instead.
+        //* One app never goes to two subspaces: per-subspace domains and ids are not expressible. Share a lib instead.
         if (owner)
           throw new Error(
             `${SubspaceConfig.fileName}: app "${app}" is claimed by both "${owner}" and "${subspace.name}"`,
@@ -58,8 +51,7 @@ export class SubspaceConfig {
       }
       if (!subspace.workspaceId) continue;
       const idOwner = idOwners.get(subspace.workspaceId);
-      //* An env upload replaces the cloud workspace's archive whole, so two subspaces sharing one would
-      //* each overwrite the other's values.
+      //* An env upload replaces the cloud workspace's archive whole, so two subspaces would overwrite each other.
       if (idOwner)
         throw new Error(
           `${SubspaceConfig.fileName}: subspaces "${idOwner}" and "${subspace.name}" declare the same workspaceId`,

package/testHelpers.ts

@@ -0,0 +1,194 @@
+import { afterEach, beforeEach } from "bun:test";
+import { mkdir, mkdtemp, rm, writeFile } from "node:fs/promises";
+import os from "node:os";
+import path from "node:path";
+
+// Executors are imported on first use: they load akanjs/base, which patches the String/Boolean/Date globals.
+const executors = () => import("@akanjs/devkit/executors");
+
+export interface CallRecord {
+  name: string;
+  args: unknown[];
+}
+
+export const createCallRecorder = () => {
+  const calls: CallRecord[] = [];
+  return {
+    calls,
+    /** `Returns` only types the stub: it always returns `undefined`, so use it where the result is not read. */
+    record<Returns = void>(name: string, ...args: unknown[]): Returns {
+      calls.push({ name, args });
+      return undefined as unknown as Returns;
+    },
+    names() {
+      return calls.map((call) => call.name);
+    },
+  };
+};
+
+export const createFakeSpinner = (recorder = createCallRecorder()) => ({
+  succeed: (message?: string) => recorder.record("spinner.succeed", message),
+  fail: (message?: string) => recorder.record("spinner.fail", message),
+});
+
+export const createFakeExecutor = <Extra extends object = object>(
+  name: string,
+  extra: Extra = {} as Extra,
+  recorder = createCallRecorder(),
+) =>
+  ({
+    name,
+    cwdPath: `/workspace/${name}`,
+    workspaceRoot: "/workspace",
+    spinning: (message: string) => {
+      recorder.record(`${name}.spinning`, message);
+      return createFakeSpinner(recorder);
+    },
+    spawn: async (...args: unknown[]) => {
+      recorder.record(`${name}.spawn`, ...args);
+      return "";
+    },
+    exec: async (...args: unknown[]) => {
+      recorder.record(`${name}.exec`, ...args);
+      return "";
+    },
+    scan: async (...args: unknown[]) => {
+      recorder.record(`${name}.scan`, ...args);
+      return { name };
+    },
+    scanSync: async (...args: unknown[]) => {
+      recorder.record(`${name}.scanSync`, ...args);
+      return { name };
+    },
+    ...extra,
+  }) as Extra & {
+    name: string;
+    cwdPath: string;
+    workspaceRoot: string;
+    spinning: (message: string) => ReturnType<typeof createFakeSpinner>;
+    spawn: (...args: unknown[]) => Promise<string>;
+    exec: (...args: unknown[]) => Promise<string>;
+    scan: (...args: unknown[]) => Promise<{ name: string }>;
+    scanSync: (...args: unknown[]) => Promise<{ name: string }>;
+  };
+
+export const makeCliTempWorkspace = async (parentDir = os.tmpdir()) => {
+  await mkdir(parentDir, { recursive: true });
+  const root = await mkdtemp(path.join(parentDir, "akan-cli-"));
+  await writeText(path.join(root, ".gitignore"), "");
+  await writeText(
+    path.join(root, ".env"),
+    ["AKAN_PUBLIC_REPO_NAME=repo", "AKAN_PUBLIC_SERVE_DOMAIN=localhost", "AKAN_PUBLIC_ENV=local", ""].join("\n"),
+  );
+  const { WorkspaceExecutor } = await executors();
+  const workspace = new WorkspaceExecutor({ workspaceRoot: root, repoName: "repo" });
+  return { root, workspace };
+};
+
+// Registers the afterEach that removes the root of every value the returned tracker was handed.
+export const tempRoots = (remove = (root: string) => rm(root, { recursive: true, force: true })) => {
+  const roots: string[] = [];
+  afterEach(async () => {
+    await Promise.all(roots.splice(0).map((root) => remove(root)));
+  });
+  return <Temp extends { root: string }>(temp: Temp) => {
+    roots.push(temp.root);
+    return temp;
+  };
+};
+
+// Registers the afterEach that removes every directory the returned factory created.
+export const tempDirs = (prefix: string, remove?: (root: string) => Promise<void>) => {
+  const track = tempRoots(remove);
+  return async () => track({ root: await mkdtemp(path.join(os.tmpdir(), prefix)) }).root;
+};
+
+export const isolateEnv = (env: Record<string, string> = {}) => {
+  const originalEnv = { ...process.env };
+  beforeEach(() => {
+    process.env = { ...originalEnv, ...env };
+  });
+  afterEach(() => {
+    process.env = { ...originalEnv };
+  });
+};
+
+export const writeText = async (filePath: string, content: string) => {
+  await mkdir(path.dirname(filePath), { recursive: true });
+  await writeFile(filePath, content);
+};
+
+export const writeJson = async (filePath: string, value: object) => {
+  await writeText(filePath, `${JSON.stringify(value, null, 2)}\n`);
+};
+
+const tsconfigJson = { compilerOptions: { target: "ESNext", paths: {} } };
+
+export const createTempApp = async (appName = "demo", parentDir?: string) => {
+  const { root, workspace } = await makeCliTempWorkspace(parentDir);
+  await writeJson(path.join(root, "package.json"), {
+    name: "repo",
+    version: "1.0.0",
+    description: "repo",
+    dependencies: {
+      react: "19.0.0",
+      "react-dom": "19.0.0",
+      "react-server-dom-webpack": "19.0.0",
+    },
+  });
+  await writeJson(path.join(root, "tsconfig.json"), { ...tsconfigJson, references: [] });
+  await writeJson(path.join(root, "apps", appName, "tsconfig.json"), tsconfigJson);
+  await writeJson(path.join(root, "apps", appName, "package.json"), {
+    name: appName,
+    version: "1.0.0",
+    description: appName,
+    dependencies: {},
+    devDependencies: {},
+  });
+  await writeText(path.join(root, "apps", appName, "akan.config.ts"), "export default {};\n");
+  await mkdir(path.join(root, "apps", appName, "lib", "__scalar"), { recursive: true });
+  const app = (await executors()).AppExecutor.from(workspace, appName);
+  return { root, workspace, app };
+};
+
+export const createTempLib = async (libName = "shared") => {
+  const { root, workspace } = await makeCliTempWorkspace();
+  await writeJson(path.join(root, "package.json"), {
+    name: "repo",
+    version: "1.0.0",
+    description: "repo",
+    dependencies: {},
+    devDependencies: {},
+  });
+  await writeJson(path.join(root, "tsconfig.json"), { ...tsconfigJson, references: [] });
+  const lib = (await executors()).LibExecutor.from(workspace, libName);
+  return { root, workspace, lib };
+};
+
+export const createTempPackage = async (pkgName = "@sample/tool") => {
+  const { root, workspace } = await makeCliTempWorkspace();
+  await writeJson(path.join(root, "package.json"), {
+    name: "repo",
+    version: "1.0.0",
+    description: "repo",
+    dependencies: { lodash: "4.0.0" },
+    devDependencies: { typescript: "6.0.0" },
+  });
+  await writeJson(path.join(root, "tsconfig.json"), tsconfigJson);
+  await writeJson(path.join(root, "pkgs", pkgName, "package.json"), {
+    name: pkgName,
+    version: "0.1.0",
+    description: "tool",
+    exports: {},
+  });
+  await writeJson(path.join(root, "pkgs", pkgName, "tsconfig.json"), tsconfigJson);
+  await writeText(path.join(root, "pkgs", pkgName, "index.ts"), 'import "lodash";\nexport const value = 1;\n');
+  const pkg = (await executors()).PkgExecutor.from(workspace, pkgName);
+  return { root, workspace, pkg };
+};
+
+export const createTempModule = async (moduleName = "post") => {
+  const { root, workspace, app } = await createTempApp("demo");
+  const module = (await executors()).ModuleExecutor.from(app, moduleName);
+  return { root, workspace, app, module };
+};

package/transforms/asyncDefaultExportDetector.ts

@@ -7,8 +7,7 @@ type TypeScript = typeof ts;
 export class AsyncDefaultExportDetector {
   static #typescriptLoad: Promise<TypeScript> | undefined;
 
-  // `typescript` costs ~70 MB resident and this detector is reached from the cli entry through the root
-  // layout generator, so the compiler loads on first use rather than at import (`entryModuleGraph.test.ts`).
+  // Lazy: `typescript` is ~70 MB resident and the cli entry reaches this file (`entryModuleGraph.test.ts`).
   static #loadTypescript(): Promise<TypeScript> {
     AsyncDefaultExportDetector.#typescriptLoad ??= import("typescript").then(
       (mod) => (mod.default ?? mod) as TypeScript,
@@ -25,7 +24,7 @@ export class AsyncDefaultExportDetector {
         source,
         typescript.ScriptTarget.Latest,
         true,
-        AsyncDefaultExportDetector.#scriptKind(typescript, moduleAbsPath),
+        /\.[tj]sx$/.test(moduleAbsPath) ? typescript.ScriptKind.TSX : typescript.ScriptKind.TS,
       );
       return new AsyncDefaultExportDetector(typescript).detectInSourceFile(sourceFile);
     } catch {
@@ -72,8 +71,7 @@ export class AsyncDefaultExportDetector {
       }
 
       if (ts.isExportDeclaration(statement) && statement.exportClause && ts.isNamedExports(statement.exportClause)) {
-        const exportClause = statement.exportClause;
-        for (const specifier of exportClause.elements) {
+        for (const specifier of statement.exportClause.elements) {
           if (specifier.name.text !== "default") continue;
           defaultIdentifier = specifier.propertyName?.text ?? specifier.name.text;
         }
@@ -96,10 +94,4 @@ export class AsyncDefaultExportDetector {
         this.#hasModifier(node, ts.SyntaxKind.AsyncKeyword),
     );
   }
-
-  static #scriptKind(typescript: TypeScript, moduleAbsPath: string): ts.ScriptKind {
-    return moduleAbsPath.endsWith(".tsx") || moduleAbsPath.endsWith(".jsx")
-      ? typescript.ScriptKind.TSX
-      : typescript.ScriptKind.TS;
-  }
 }