@akanjs/devkit 3.0.0-alpha.84 → 3.0.0-alpha.86

package/biome.base.json

@@ -1,5 +1,5 @@
 {
-  "$schema": "https://biomejs.dev/schemas/2.5.8/schema.json",
+  "$schema": "https://biomejs.dev/schemas/2.5.12/schema.json",
   "vcs": {
     "enabled": true,
     "clientKind": "git",
@@ -24,7 +24,9 @@
         },
         "noArrayIndexKey": "off",
         "noShadowRestrictedNames": "off",
-        "noUnnecessaryConditions": "off"
+        "noUnnecessaryConditions": {
+          "level": "warn"
+        }
       },
       "correctness": {
         "noUnusedFunctionParameters": "off",
@@ -58,10 +60,10 @@
       }
     },
     "domains": {
+      "project": "recommended",
       "react": "recommended",
       "test": "recommended",
-      "types": "none",
-      "project": "none"
+      "types": "all"
     }
   },
   "javascript": {

package/biomeBase.ts

@@ -6,4 +6,4 @@ export const biomeBaseConfig = "@akanjs/devkit/biome.base.json";
 // Biome disagrees with the shipped base config therefore fails to load it at all, which is why the version is
 // pinned here instead of resolved to latest at create time. Bump this and `biome.base.json` in one commit, and run
 // `biome migrate --write` in the workspace root and in `pkgs/@akanjs/devkit` so both configs move together.
-export const biomeVersion = "2.5.8";
+export const biomeVersion = "2.5.12";

package/frontendBuild/sourceMtimeIndex.ts

@@ -377,7 +377,7 @@ export class SourceMtimeIndex {
     return !name || name.startsWith(".") || name === "node_modules";
   }
 
-  /** `WatchRootResolver` can return `apps/<app>/page` alongside `apps/`; walking both doubles the work. */
+  /** `WatchRootResolver` can return `apps/<app>/page` alongside `apps/<app>`; walking both doubles the work. */
   static #pruneNestedRoots(roots: string[]): string[] {
     const resolved = [...new Set(roots.map((root) => path.resolve(root)))].sort();
     return resolved.filter(

package/frontendBuild/watchRootResolver.test.ts

@@ -0,0 +1,67 @@
+import { afterEach, describe, expect, test } from "bun:test";
+import { mkdir, mkdtemp, rm } from "node:fs/promises";
+import os from "node:os";
+import path from "node:path";
+import type { App } from "../commandDecorators";
+import { WatchRootResolver } from "./watchRootResolver";
+
+const roots: string[] = [];
+
+const makeWorkspace = async (dirs: string[]) => {
+  const root = await mkdtemp(path.join(os.tmpdir(), "akan-watch-roots-"));
+  roots.push(root);
+  await Promise.all(dirs.map((dir) => mkdir(path.join(root, dir), { recursive: true })));
+  return root;
+};
+
+const makeApp = (workspaceRoot: string, name: string, paths: Record<string, string[]>) =>
+  ({
+    cwdPath: path.join(workspaceRoot, "apps", name),
+    workspace: { workspaceRoot },
+    getTsConfig: async () => ({ compilerOptions: { paths } }),
+  }) as unknown as App;
+
+afterEach(async () => {
+  await Promise.all(roots.splice(0).map((root) => rm(root, { recursive: true, force: true })));
+});
+
+describe("WatchRootResolver", () => {
+  test("narrows the apps container to the app being served", async () => {
+    const workspaceRoot = await makeWorkspace(["apps/app1/page", "apps/app2/page", "libs/util"]);
+    const resolved = await new WatchRootResolver(
+      makeApp(workspaceRoot, "app1", { "@apps/*": ["./apps/*"], "@libs/*": ["./libs/*"] }),
+    ).resolve();
+
+    expect(resolved).toContain(path.join(workspaceRoot, "apps/app1"));
+    expect(resolved).not.toContain(path.join(workspaceRoot, "apps"));
+    expect(resolved).not.toContain(path.join(workspaceRoot, "apps/app2"));
+  });
+
+  test("keeps the libs container whole", async () => {
+    const workspaceRoot = await makeWorkspace(["apps/app1/page", "libs/util", "libs/shared"]);
+    const resolved = await new WatchRootResolver(makeApp(workspaceRoot, "app1", { "@libs/*": ["./libs/*"] })).resolve();
+
+    expect(resolved).toContain(path.join(workspaceRoot, "libs"));
+  });
+
+  test("resolves a package alias to its own directory, filename and glob stripped", async () => {
+    const workspaceRoot = await makeWorkspace(["apps/app1/page", "pkgs/akanjs/base"]);
+    const resolved = await new WatchRootResolver(
+      makeApp(workspaceRoot, "app1", {
+        akanjs: ["./pkgs/akanjs/index.ts"],
+        "akanjs/*": ["./pkgs/akanjs/*"],
+        missing: ["./pkgs/nothing/index.ts"],
+      }),
+    ).resolve();
+
+    expect(resolved).toContain(path.join(workspaceRoot, "pkgs/akanjs"));
+    expect(resolved).not.toContain(path.join(workspaceRoot, "pkgs/nothing"));
+  });
+
+  test("always watches the app's page tree", async () => {
+    const workspaceRoot = await makeWorkspace(["apps/app1/page"]);
+    const resolved = await new WatchRootResolver(makeApp(workspaceRoot, "app1", {})).resolve();
+
+    expect(resolved).toEqual([path.join(workspaceRoot, "apps/app1/page")]);
+  });
+});

package/frontendBuild/watchRootResolver.ts

@@ -2,6 +2,15 @@ import fs from "node:fs";
 import path from "node:path";
 import type { App } from "../commandDecorators";
 
+/**
+ * The directories one app's dev watcher follows, resolved from its tsconfig `paths`.
+ *
+ * `@apps/*` strips down to the `apps/` container, so taking it verbatim puts every sibling app under the
+ * watcher: with two dev servers up, a save in app2 rebuilds, restarts and reloads app1, and both builders
+ * rewrite the same generated barrels. Apps are leaves of the workspace graph — never one another's
+ * dependencies — so the container is replaced by this app's own directory. `libs/` stays whole, because a
+ * lib becomes a dependency the moment someone types the import, with no restart in between.
+ */
 export class WatchRootResolver {
   #app: App;
 
@@ -11,6 +20,8 @@ export class WatchRootResolver {
 
   async resolve(): Promise<string[]> {
     const tsconfig = await this.#app.getTsConfig();
+    const appDir = path.resolve(this.#app.cwdPath);
+    const appsContainer = path.dirname(appDir);
     const set = new Set<string>();
     set.add(path.resolve(`${this.#app.cwdPath}/page`));
     for (const targets of Object.values(tsconfig.compilerOptions.paths ?? {})) {
@@ -20,7 +31,8 @@ export class WatchRootResolver {
         // Strip the trailing filename and glob so we watch the package root dir.
         const cleaned = target.replace(/\/?\*+.*$/, "").replace(/\/[^/]+\.[^/]+$/, "");
         const resolved = path.resolve(this.#app.workspace.workspaceRoot, cleaned);
-        if (fs.existsSync(resolved)) set.add(resolved);
+        const root = resolved === appsContainer ? appDir : resolved;
+        if (fs.existsSync(root)) set.add(root);
       }
     }
     return [...set];

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@akanjs/devkit",
-  "version": "3.0.0-alpha.84",
+  "version": "3.0.0-alpha.86",
   "sourceType": "module",
   "type": "module",
   "publishConfig": {
@@ -45,7 +45,7 @@
     "@langchain/openai": "^1.4.6",
     "@tailwindcss/node": "^4.3.0",
     "@trapezedev/project": "^7.1.4",
-    "akanjs": "3.0.0-alpha.84",
+    "akanjs": "3.0.0-alpha.86",
     "chalk": "^5.6.2",
     "commander": "^14.0.3",
     "dayjs": "^1.11.20",