@akanjs/devkit 3.1.2-rc.4 → 3.2.0-rc.1

package/structureScanner.test.ts

@@ -0,0 +1,167 @@
+import { describe, expect, test } from "bun:test";
+import ts from "typescript";
+import { StructureScanner } from "./structureScanner";
+
+const measure = (source: string, file = "unit.ts") =>
+  new StructureScanner().measure(
+    ts.createSourceFile(
+      file,
+      source,
+      ts.ScriptTarget.Latest,
+      true,
+      file.endsWith(".tsx") ? ts.ScriptKind.TSX : ts.ScriptKind.TS,
+    ),
+  );
+const namesOf = (source: string) => measure(source).functions.map(({ name }) => name);
+
+describe("StructureScanner functions", () => {
+  test("names a function by the classes and functions around it, and counts the lines it spans", () => {
+    const { functions } = measure(`export class Host {
+  #children = new Map();
+  constructor() {}
+  get status() {
+    return 1;
+  }
+  set status(value: number) {}
+  async start() {
+    const tick = () => {
+      return 1;
+    };
+  }
+  static #restart = function named() {};
+}
+export function build() {}
+export default function () {}
+`);
+
+    expect(functions).toEqual([
+      { name: "Host.constructor", line: 3, lineCount: 1 },
+      { name: "Host.get status", line: 4, lineCount: 3 },
+      { name: "Host.set status", line: 7, lineCount: 1 },
+      { name: "Host.start", line: 8, lineCount: 5 },
+      { name: "Host.start.tick", line: 9, lineCount: 3 },
+      { name: "Host.named", line: 13, lineCount: 1 },
+      { name: "build", line: 15, lineCount: 1 },
+      { name: "default", line: 16, lineCount: 1 },
+    ]);
+  });
+
+  test("names an anonymous function after what its call is bound to, else after the call", () => {
+    expect(
+      namesOf(`const rows = items.map((item) => item).filter(Boolean);
+const View = memo(() => null);
+const routes = { "/*": answering(async (req) => req), list: (() => []) as unknown };
+describe("suite", () => {
+  useEffect(() => {});
+  holder.onExit = () => {};
+});
+export class ShowCommand extends command("show", ({ public: target }) => ({
+  show: target().exec(async function (format) {}),
+})) {}
+export default () => {};
+`),
+    ).toEqual([
+      "rows",
+      "View",
+      "routes./*",
+      "routes.list",
+      "describe()",
+      "describe().useEffect()",
+      "describe().onExit",
+      "ShowCommand.command()",
+      "ShowCommand.command().show",
+      "default",
+    ]);
+  });
+
+  test("names a repeat like the first, whatever stands before it", () => {
+    expect(namesOf("test('a', () => {});\ntest('b', () => {});\ntest('c', () => {});\n")).toEqual([
+      "test()",
+      "test()",
+      "test()",
+    ]);
+  });
+
+  test("names an object literal's members after what the literal is bound to", () => {
+    expect(
+      namesOf(`const h = { foo() {} };
+const k = { foo() {} };
+const routes = { api: { list: () => [] } };
+export function make() {
+  return { setX() {} };
+}
+register({ onDone() {} });
+`),
+    ).toEqual(["h.foo", "k.foo", "routes.api.list", "make", "make.setX", "register().onDone"]);
+  });
+
+  test("names an inline JSX callback after its attribute, and a function child children", () => {
+    const { functions } = measure(
+      `export const Board = () => (
+  <List onClick={() => {}} render={(row) => row}>
+    {(row) => row}
+  </List>
+);
+`,
+      "Board.tsx",
+    );
+
+    expect(functions.map(({ name }) => name)).toEqual(["Board", "Board.onClick", "Board.render", "Board.children"]);
+  });
+
+  test("skips a signature without a body", () => {
+    expect(
+      namesOf(
+        "export function overload(a: string): void;\nexport function overload(a: unknown) {}\ninterface I { m(): void }\n",
+      ),
+    ).toEqual(["overload"]);
+  });
+});
+
+describe("StructureScanner classes", () => {
+  test("counts every member of a class or class expression, named like a function", () => {
+    const { classes } = measure(`export class Exception extends Error {
+  static BadRequest = class BadRequestException extends Exception {
+    constructor() {
+      super();
+    }
+  };
+  readonly code = 1;;
+  #secret = 2;
+  get status() {
+    return 3;
+  }
+  set status(value: number) {}
+  [key: string]: unknown;
+}
+const Mixin = class extends Base {};
+export default class {}
+`);
+
+    expect(classes).toEqual([
+      { name: "Exception", line: 1, memberCount: 5 },
+      { name: "Exception.BadRequestException", line: 2, memberCount: 1 },
+      { name: "Mixin", line: 15, memberCount: 0 },
+      { name: "default", line: 16, memberCount: 0 },
+    ]);
+  });
+
+  test("counts an overloaded method once, and neither an index signature nor a static block", () => {
+    const { classes } = measure(`export abstract class Store {
+  static {
+    Store.ready = true;
+  }
+  [key: string]: unknown;
+  constructor(name: string);
+  constructor(name: string, id?: number) {}
+  load(id: string): void;
+  load(ids: string[]): void;
+  load(arg: unknown) {}
+  static load() {}
+  abstract save(): void;
+}
+`);
+
+    expect(classes).toEqual([{ name: "Store", line: 1, memberCount: 4 }]);
+  });
+});

package/structureScanner.ts

@@ -0,0 +1,164 @@
+import ts from "typescript";
+
+export interface FunctionSize {
+  name: string;
+  line: number;
+  lineCount: number;
+}
+
+export interface ClassSize {
+  name: string;
+  line: number;
+  memberCount: number;
+}
+
+type FunctionNode =
+  | ts.FunctionDeclaration
+  | ts.MethodDeclaration
+  | ts.ConstructorDeclaration
+  | ts.GetAccessorDeclaration
+  | ts.SetAccessorDeclaration
+  | ts.FunctionExpression
+  | ts.ArrowFunction;
+
+export class StructureScanner {
+  measure(sourceFile: ts.SourceFile): { functions: FunctionSize[]; classes: ClassSize[] } {
+    const functions: FunctionSize[] = [];
+    const classes: ClassSize[] = [];
+    const lineOf = (pos: number) => sourceFile.getLineAndCharacterOfPosition(pos).line + 1;
+    const visit = (node: ts.Node, owners: string[]) => {
+      if (ts.isClassDeclaration(node) || ts.isClassExpression(node)) {
+        const name = StructureScanner.#classNameOf(node);
+        classes.push({
+          name: [...owners, name].join("."),
+          line: lineOf(node.getStart(sourceFile)),
+          memberCount: StructureScanner.#memberCountOf(node),
+        });
+        ts.forEachChild(node, (child) => visit(child, [...owners, name]));
+        return;
+      }
+      if (StructureScanner.#isFunction(node)) {
+        const name = StructureScanner.#functionNameOf(node);
+        const line = lineOf(node.getStart(sourceFile));
+        functions.push({
+          name: [...owners, name].join("."),
+          line,
+          lineCount: lineOf(node.getEnd()) - line + 1,
+        });
+        ts.forEachChild(node, (child) => visit(child, [...owners, name]));
+        return;
+      }
+      if (ts.isObjectLiteralExpression(node)) {
+        const name = StructureScanner.#boundNameOf(node);
+        ts.forEachChild(node, (child) => visit(child, name === "<anonymous>" ? owners : [...owners, name]));
+        return;
+      }
+      ts.forEachChild(node, (child) => visit(child, owners));
+    };
+    ts.forEachChild(sourceFile, (child) => visit(child, []));
+    return { functions, classes };
+  }
+
+  static #memberCountOf(node: ts.ClassDeclaration | ts.ClassExpression) {
+    const methods = new Set<string>();
+    return node.members.filter((member) => {
+      if (
+        ts.isSemicolonClassElement(member) ||
+        ts.isIndexSignatureDeclaration(member) ||
+        ts.isClassStaticBlockDeclaration(member)
+      )
+        return false;
+      if (!ts.isMethodDeclaration(member) && !ts.isConstructorDeclaration(member)) return true;
+      const isStatic = ts.getModifiers(member)?.some((modifier) => modifier.kind === ts.SyntaxKind.StaticKeyword);
+      const key = `${isStatic ? "static " : ""}${ts.isConstructorDeclaration(member) ? "constructor" : StructureScanner.#textOf(member.name)}`;
+      if (methods.has(key)) return false;
+      methods.add(key);
+      return true;
+    }).length;
+  }
+
+  static #isFunction(node: ts.Node): node is FunctionNode {
+    return (
+      (ts.isFunctionDeclaration(node) ||
+        ts.isMethodDeclaration(node) ||
+        ts.isConstructorDeclaration(node) ||
+        ts.isGetAccessorDeclaration(node) ||
+        ts.isSetAccessorDeclaration(node) ||
+        ts.isFunctionExpression(node) ||
+        ts.isArrowFunction(node)) &&
+      node.body !== undefined
+    );
+  }
+
+  static #functionNameOf(node: FunctionNode) {
+    if (ts.isConstructorDeclaration(node)) return "constructor";
+    if (ts.isGetAccessorDeclaration(node)) return `get ${StructureScanner.#textOf(node.name)}`;
+    if (ts.isSetAccessorDeclaration(node)) return `set ${StructureScanner.#textOf(node.name)}`;
+    if (node.name) return StructureScanner.#textOf(node.name);
+    return ts.isFunctionDeclaration(node) ? "default" : StructureScanner.#boundNameOf(node);
+  }
+
+  static #classNameOf(node: ts.ClassDeclaration | ts.ClassExpression) {
+    if (node.name) return node.name.text;
+    return ts.isClassDeclaration(node) ? "default" : StructureScanner.#boundNameOf(node);
+  }
+
+  static #boundNameOf(node: ts.Node) {
+    let current: ts.Node = StructureScanner.#outerOf(node);
+    let call: string | null = null;
+    while (ts.isCallExpression(current.parent) || ts.isNewExpression(current.parent)) {
+      const callee = current.parent.expression;
+      if (current === callee) break;
+      call ??= `${ts.isPropertyAccessExpression(callee) ? callee.name.text : ts.isIdentifier(callee) ? callee.text : "call"}()`;
+      current = StructureScanner.#outerOf(current.parent);
+    }
+    const { parent } = current;
+    if (
+      (ts.isVariableDeclaration(parent) ||
+        ts.isPropertyAssignment(parent) ||
+        ts.isPropertyDeclaration(parent) ||
+        ts.isParameter(parent) ||
+        ts.isBindingElement(parent)) &&
+      parent.name &&
+      !ts.isObjectBindingPattern(parent.name) &&
+      !ts.isArrayBindingPattern(parent.name)
+    )
+      return StructureScanner.#textOf(parent.name);
+    if (ts.isBinaryExpression(parent) && parent.operatorToken.kind === ts.SyntaxKind.EqualsToken)
+      return ts.isPropertyAccessExpression(parent.left)
+        ? parent.left.name.text
+        : ts.isIdentifier(parent.left)
+          ? parent.left.text
+          : "assigned";
+    if (ts.isExportAssignment(parent)) return "default";
+    if (ts.isJsxExpression(parent))
+      return ts.isJsxAttribute(parent.parent)
+        ? ts.isIdentifier(parent.parent.name)
+          ? parent.parent.name.text
+          : parent.parent.name.getText()
+        : "children";
+    return call ?? "<anonymous>";
+  }
+
+  static #outerOf(node: ts.Node) {
+    let current = node;
+    while (
+      ts.isParenthesizedExpression(current.parent) ||
+      ts.isAsExpression(current.parent) ||
+      ts.isSatisfiesExpression(current.parent) ||
+      ts.isNonNullExpression(current.parent) ||
+      ts.isTypeAssertionExpression(current.parent) ||
+      (ts.isPropertyAccessExpression(current.parent) && current.parent.expression === current) ||
+      (ts.isCallExpression(current.parent) && current.parent.expression === current)
+    )
+      current = current.parent;
+    return current;
+  }
+
+  static #textOf(name: ts.PropertyName | ts.BindingName) {
+    if (ts.isIdentifier(name) || ts.isPrivateIdentifier(name) || ts.isStringLiteral(name)) return name.text;
+    if (ts.isNumericLiteral(name) || ts.isNoSubstitutionTemplateLiteral(name)) return name.text;
+    if (ts.isComputedPropertyName(name)) return `[${name.expression.getText()}]`;
+    return "<pattern>";
+  }
+}

package/transforms/barrelAnalyzer.ts

@@ -5,6 +5,8 @@ import { parseNamedList } from "./moduleSyntax";
 export interface BarrelExportTarget {
   subpath: string;
   originalName: string;
+  /** `export * as name from`: an import of the name binds the whole module at `subpath`. */
+  namespace?: boolean;
 }
 
 export type BarrelExportMap = Map<string, BarrelExportTarget>;
@@ -100,9 +102,14 @@ export class BarrelAnalyzer {
       if (!isRelative(spec)) continue;
 
       if (star) {
-        // A namespace re-export cannot be flattened into subpath imports, nor is it a local declaration.
-        if (nsAs) authoritative.delete(nsAs);
-        else starSpecs.push(spec);
+        if (!nsAs) starSpecs.push(spec);
+        else if (authoritative.has(nsAs)) {
+          attributed.add(nsAs);
+          const targetAbs = await this.#resolveRel(absFile, spec);
+          const targetSubpath = targetAbs ? this.#subpathFor(pkg, targetAbs) : null;
+          if (targetSubpath && !map.has(nsAs))
+            map.set(nsAs, { subpath: targetSubpath, originalName: nsAs, namespace: true });
+        }
         continue;
       }
 

package/transforms/barrelImportsPlugin.ts

@@ -1,6 +1,7 @@
 import path from "node:path";
 import type { BunPlugin } from "bun";
 import ts from "typescript";
+import { StoreBootstrap } from "../artifact/storeBootstrap";
 import type { App } from "../commandDecorators";
 import { BarrelAnalyzer, type BarrelExportMap, type PackageEntry } from "./barrelAnalyzer";
 import { loaderFor, type NamedItem, parseNamedList } from "./moduleSyntax";
@@ -101,8 +102,9 @@ export const createTsconfigPackageResolver = async (
         if (!repl) continue;
         const replPath = repl.endsWith("/*") ? repl.slice(0, -1) : repl;
         const candidate = path.resolve(app.workspace.workspaceRoot, replPath + suffix);
-        // A sibling file (`apps/minimal/client.ts`) is a facet barrel too: parent specifier, as above.
-        for (const ext of CANDIDATE_EXTS) {
+        // A sibling file (`apps/minimal/client.ts`), or the file a specifier names with its extension
+        // (`akanjs/ui/System/index.tsx`), is a facet barrel too: parent specifier, as above.
+        for (const ext of CANDIDATE_EXTS.includes(path.extname(candidate)) ? ["", ...CANDIDATE_EXTS] : CANDIDATE_EXTS) {
           const file = `${candidate}${ext}`;
           if (await Bun.file(file).exists()) {
             const lastSlash = pkgName.lastIndexOf("/");
@@ -339,6 +341,7 @@ const rewriteSingleStatement = (stmt: ImportStatement, map: BarrelExportMap): st
 
   const remaining: NamedItem[] = [];
   const rewrites = new Map<string, NamedItem[]>();
+  const namespaceLines: string[] = [];
   for (const item of clause.named) {
     if (item.isType) {
       remaining.push(item);
@@ -349,15 +352,19 @@ const rewriteSingleStatement = (stmt: ImportStatement, map: BarrelExportMap): st
       remaining.push(item);
       continue;
     }
+    if (target.namespace) {
+      namespaceLines.push(`import * as ${item.local} from "${target.subpath}";`);
+      continue;
+    }
     const list = rewrites.get(target.subpath) ?? [];
     list.push({ imported: target.originalName, local: item.local, isType: false });
     rewrites.set(target.subpath, list);
   }
 
-  if (rewrites.size === 0) return null;
+  if (rewrites.size === 0 && namespaceLines.length === 0) return null;
 
-  const lines: string[] = [];
-  if (shouldPreserveBarrelSideEffects(stmt.specifier)) lines.push(`import "${stmt.specifier}";`);
+  //? An app or lib client barrel's import-time side effects are its client runtime and store, not its module UI.
+  const lines: string[] = [...(StoreBootstrap.ofClientBarrel(stmt.specifier, map) ?? [])];
 
   if (clause.defaultImport || remaining.length > 0) {
     const parts: string[] = [];
@@ -369,12 +376,11 @@ const rewriteSingleStatement = (stmt: ImportStatement, map: BarrelExportMap): st
   for (const [subpath, items] of rewrites) {
     lines.push(`import { ${items.map(serializeNamedItem).join(", ")} } from "${subpath}";`);
   }
+  lines.push(...namespaceLines);
 
   return lines.join("\n");
 };
 
-const shouldPreserveBarrelSideEffects = (specifier: string): boolean => /^@(apps|libs)\/[^/]+\/client$/.test(specifier);
-
 const serializeNamedItem = (item: NamedItem): string => {
   const prefix = item.isType ? "type " : "";
   if (item.imported === item.local) return `${prefix}${item.imported}`;

package/transforms/serverEnvPlugin.test.ts

@@ -86,7 +86,7 @@ describe("createServerEnvPlugin", () => {
       "env/env.server.develop.ts is not in this build: `akan build` bundles the server env of AKAN_PUBLIC_ENV=main alone",
     );
     expect(proc.stderr.toString()).toContain(
-      "To run develop, build for it: AKAN_PUBLIC_ENV=develop in the workspace's .env, which outranks the shell, or --env develop on a desktop or mobile build.",
+      "To run develop, build for it with `--env develop` (`akan build` or a desktop or mobile build), or AKAN_PUBLIC_ENV=develop in the shell or the workspace's .env.",
     );
   });
 

package/transforms/serverEnvPlugin.ts

@@ -54,7 +54,7 @@ export const createServerEnvPlugin = ({
         build.onLoad({ filter }, async (args) => {
           const name = path.basename(args.path, ".ts").slice("env.server.".length);
           const { exports } = new Bun.Transpiler({ loader: "ts" }).scan(await Bun.file(args.path).text());
-          const message = `env/env.server.${name}.ts is not in this build: \`akan build\` bundles the server env of AKAN_PUBLIC_ENV=${environment} alone, the environment its image runs. To run ${name}, build for it: AKAN_PUBLIC_ENV=${name} in the workspace's .env, which outranks the shell, or --env ${name} on a desktop or mobile build.`;
+          const message = `env/env.server.${name}.ts is not in this build: \`akan build\` bundles the server env of AKAN_PUBLIC_ENV=${environment} alone, the environment its image runs. To run ${name}, build for it with \`--env ${name}\` (\`akan build\` or a desktop or mobile build), or AKAN_PUBLIC_ENV=${name} in the shell or the workspace's .env.`;
           return {
             loader: "js",
             contents: [

package/transforms/transforms.test.ts

@@ -3,7 +3,7 @@ import path from "node:path";
 import { ApplicationBuildReporter } from "../applicationBuildReporter";
 import { tempDirs, writeText as write } from "../testHelpers";
 import { BarrelAnalyzer, type BarrelExportTarget } from "./barrelAnalyzer";
-import { rewriteBarrelImports } from "./barrelImportsPlugin";
+import { createTsconfigPackageResolver, rewriteBarrelImports } from "./barrelImportsPlugin";
 import {
   hasUseClientDirective,
   scanUseClientExports,
@@ -140,7 +140,7 @@ describe('export * in a "use client" module', () => {
 });
 
 describe("BarrelAnalyzer and rewriteBarrelImports", () => {
-  test("analyzes local, named, aliased, and star re-exports while skipping type and namespace exports", async () => {
+  test("analyzes local, named, aliased, star and namespace re-exports while skipping type exports", async () => {
     const root = await makeTempRoot();
     const pkgDir = path.join(root, "pkg");
     await write(
@@ -149,6 +149,7 @@ describe("BarrelAnalyzer and rewriteBarrelImports", () => {
         'export { A, B as Bee, type TypeOnly } from "./leaf";',
         'export * from "./star";',
         'export * as ns from "./namespace";',
+        'export type * as typeNs from "./namespace";',
         "export const Local = 1;",
         "export type LocalType = string;",
         "",
@@ -171,7 +172,9 @@ describe("BarrelAnalyzer and rewriteBarrelImports", () => {
     expect(map?.get("Star")).toEqual({ subpath: "@scope/pkg/star", originalName: "Star" });
     expect(map?.get("Local")).toEqual({ subpath: "@scope/pkg", originalName: "Local" });
     expect(map?.has("TypeOnly")).toBe(false);
-    expect(map?.has("ns")).toBe(false);
+    expect(map?.get("ns")).toEqual({ subpath: "@scope/pkg/namespace", originalName: "ns", namespace: true });
+    expect(map?.has("typeNs")).toBe(false);
+    expect(map?.has("Hidden")).toBe(false);
   });
 
   test("a name a module exports itself wins over the same name its star re-exports bring, as ES decides", async () => {
@@ -284,17 +287,66 @@ describe("BarrelAnalyzer and rewriteBarrelImports", () => {
     expect(await rewriteBarrelImports('import { A } from "@other/pkg";', ["@scope/pkg"], analyzer)).toBeNull();
   });
 
-  test("preserves generated client barrel side effects when flattening app client imports", async () => {
-    const analyzer = fakeAnalyzer([["st", { subpath: "@apps/demo/lib/st", originalName: "st" }]]);
+  test("keeps a client barrel's runtime and store, never its module UI, when flattening an app or lib import", async () => {
+    const root = await makeTempRoot();
+    for (const sys of ["apps/demo", "libs/kit"]) {
+      await write(
+        path.join(root, sys, "client.ts"),
+        [
+          'export * as cnst from "./lib/cnst";',
+          'export { msg, Err, usePage, fetch, sig } from "./lib/useClient";',
+          'export { st, RootStore } from "./lib/st";',
+          'export * as store from "./lib/st";',
+          'export { Memo } from "./lib/memo";',
+          "",
+        ].join("\n"),
+      );
+      await write(path.join(root, sys, "lib/cnst.ts"), "export const Sample = 1;\n");
+      await write(path.join(root, sys, "lib/useClient.ts"), "export const { msg, Err, usePage, fetch, sig } = {};\n");
+      await write(path.join(root, sys, "lib/st.ts"), "export class RootStore {}\nexport const st = {};\n");
+      await write(path.join(root, sys, "lib/memo/index.ts"), "export const Memo = {};\n");
+    }
+    await write(path.join(root, "libs/hand/client.ts"), 'export { thing } from "./lib/thing";\n');
+    await write(path.join(root, "libs/hand/lib/thing.ts"), "export const thing = 1;\n");
+    const analyzer = new BarrelAnalyzer({
+      resolvePackage: await createTsconfigPackageResolver({
+        workspace: { workspaceRoot: root },
+        getTsConfig: async () => ({ compilerOptions: { paths: { "@apps/*": ["./apps/*"], "@libs/*": ["./libs/*"] } } }),
+      } as never),
+    });
+    const barrels = ["@apps/demo/client", "@libs/kit/client", "@libs/hand/client"];
+    const rewrite = async (source: string) => await rewriteBarrelImports(source, barrels, analyzer);
 
-    const rewritten = await rewriteBarrelImports(
-      'import { st } from "@apps/demo/client";\nvoid st;\n',
-      ["@apps/demo/client"],
-      analyzer,
+    expect(await rewrite('import { Memo, st } from "@apps/demo/client";\n')).toBe(
+      [
+        'import "@apps/demo/lib/useClient";',
+        'import "@apps/demo/lib/st";',
+        'import { Memo } from "@apps/demo/lib/memo";',
+        'import { st } from "@apps/demo/lib/st";',
+        "",
+      ].join("\n"),
     );
-
-    expect(rewritten).toBe(
-      ['import "@apps/demo/client";', 'import { st } from "@apps/demo/lib/st";', "void st;\n"].join("\n"),
+    expect(await rewrite('import { cnst as c, st, store, type cnst as T } from "@apps/demo/client";\n')).toBe(
+      [
+        'import "@apps/demo/lib/useClient";',
+        'import "@apps/demo/lib/st";',
+        'import { type cnst as T } from "@apps/demo/client";',
+        'import { st } from "@apps/demo/lib/st";',
+        'import * as c from "@apps/demo/lib/cnst";',
+        'import * as store from "@apps/demo/lib/st";',
+        "",
+      ].join("\n"),
+    );
+    expect(await rewrite('import { RootStore as kit } from "@libs/kit/client";\n')).toBe(
+      [
+        'import "@libs/kit/lib/useClient";',
+        'import "@libs/kit/lib/st";',
+        'import { RootStore as kit } from "@libs/kit/lib/st";',
+        "",
+      ].join("\n"),
+    );
+    expect(await rewrite('import { thing } from "@libs/hand/client";\n')).toBe(
+      ['import "@libs/hand/client";', 'import { thing } from "@libs/hand/lib/thing";', ""].join("\n"),
     );
   });
 

package/transforms/tsconfigPackageResolver.test.ts

@@ -99,6 +99,18 @@ describe("createTsconfigPackageResolver — wildcard tsconfig mapping", () => {
     });
   });
 
+  test("resolves a specifier that names its file with an extension, as the generated root layout imports System", async () => {
+    const root = await makeTempRoot();
+    const entryFile = await write(root, "pkgs/akanjs/ui/System/index.tsx");
+    const resolve = await resolverFor(root, { "akanjs/ui/*": ["./pkgs/akanjs/ui/*"] });
+
+    expect(await resolve("akanjs/ui/System/index.tsx")).toEqual({
+      pkgName: "akanjs/ui/System",
+      entryFile,
+      pkgDir: path.join(root, "pkgs/akanjs/ui/System"),
+    });
+  });
+
   test("resolves a directory barrel and keeps the specifier", async () => {
     const root = await makeTempRoot();
     const entryFile = await write(root, "apps/minimal/index.tsx");