@akanjs/devkit 3.0.0-alpha.96 → 3.0.0-alpha.97

package/codegenLock.ts

@@ -11,10 +11,10 @@ interface LockHolder {
 /**
  * A workspace-wide mutex over the generated source files every dev server in the workspace rewrites.
  *
- * `WatchRootResolver` narrows the `apps/` container to one app but keeps `libs/` whole on purpose, so
- * with two dev servers up a save under `libs/` reaches both builders and both regenerate the same
- * barrel. Whichever watcher is mid-scan then reads a half-written file back as a user edit, which is a
- * rebuild per rewrite. `scanSync` writes the same files at boot for every mounting app.
+ * `WatchRootResolver` narrows each dev server to its own app and its own lib dependencies, but two apps
+ * that share a lib still both watch it, so a save there reaches both builders and both regenerate the
+ * same barrel. Whichever watcher is mid-scan then reads a half-written file back as a user edit, which is
+ * a rebuild per rewrite. `scanSync` writes the same files at boot for every mounting app.
  *
  * A wait that expires proceeds *without* the lock rather than failing: this sits on the dev server's
  * hot path, and stalling the file watcher is worse than the torn read `FileSys.writeTextAtomic` already

package/frontendBuild/watchRootResolver.test.ts

@@ -1,5 +1,5 @@
 import { afterEach, describe, expect, test } from "bun:test";
-import { mkdir, mkdtemp, rm } from "node:fs/promises";
+import { mkdir, mkdtemp, rm, writeFile } from "node:fs/promises";
 import os from "node:os";
 import path from "node:path";
 import type { App } from "../commandDecorators";
@@ -14,11 +14,23 @@ const makeWorkspace = async (dirs: string[]) => {
   return root;
 };
 
-const makeApp = (workspaceRoot: string, name: string, paths: Record<string, string[]>) =>
+const writeManifest = (workspaceRoot: string, scope: string, libDeps: unknown) =>
+  writeFile(
+    path.join(workspaceRoot, scope, scope.startsWith("apps/") ? "akan.app.json" : "akan.lib.json"),
+    JSON.stringify({ libDeps }),
+  );
+
+interface AppStub {
+  paths?: Record<string, string[]>;
+  libDeps?: string[] | null;
+}
+
+const makeApp = (workspaceRoot: string, name: string, { paths = {}, libDeps = null }: AppStub = {}) =>
   ({
     cwdPath: path.join(workspaceRoot, "apps", name),
     workspace: { workspaceRoot },
     getTsConfig: async () => ({ compilerOptions: { paths } }),
+    getScanInfo: () => (libDeps ? { type: "app", libDeps } : null),
   }) as unknown as App;
 
 afterEach(async () => {
@@ -29,7 +41,7 @@ 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/*"] }),
+      makeApp(workspaceRoot, "app1", { paths: { "@apps/*": ["./apps/*"], "@libs/*": ["./libs/*"] } }),
     ).resolve();
 
     expect(resolved).toContain(path.join(workspaceRoot, "apps/app1"));
@@ -37,9 +49,57 @@ describe("WatchRootResolver", () => {
     expect(resolved).not.toContain(path.join(workspaceRoot, "apps/app2"));
   });
 
-  test("keeps the libs container whole", async () => {
+  test("narrows the libs container to the app's own dependencies", async () => {
+    const workspaceRoot = await makeWorkspace(["apps/app1/page", "libs/util", "libs/shared"]);
+    const resolved = await new WatchRootResolver(
+      makeApp(workspaceRoot, "app1", { paths: { "@libs/*": ["./libs/*"] }, libDeps: ["util"] }),
+    ).resolve();
+
+    expect(resolved).toContain(path.join(workspaceRoot, "libs/util"));
+    expect(resolved).not.toContain(path.join(workspaceRoot, "libs"));
+    expect(resolved).not.toContain(path.join(workspaceRoot, "libs/shared"));
+  });
+
+  test("drops the libs container entirely when the app depends on no lib", async () => {
+    const workspaceRoot = await makeWorkspace(["apps/app1/page", "libs/util"]);
+    await writeManifest(workspaceRoot, "apps/app1", []);
+    const resolved = await new WatchRootResolver(
+      makeApp(workspaceRoot, "app1", { paths: { "@libs/*": ["./libs/*"] } }),
+    ).resolve();
+
+    expect(resolved).toEqual([path.join(workspaceRoot, "apps/app1/page")]);
+  });
+
+  test("takes the transitive closure from the synced manifests when nothing scanned in-process", async () => {
+    const workspaceRoot = await makeWorkspace(["apps/app1/page", "libs/util", "libs/shared", "libs/unused"]);
+    await writeManifest(workspaceRoot, "apps/app1", ["shared"]);
+    await writeManifest(workspaceRoot, "libs/shared", ["util"]);
+    await writeManifest(workspaceRoot, "libs/util", []);
+    await writeManifest(workspaceRoot, "libs/unused", []);
+    const resolved = await new WatchRootResolver(
+      makeApp(workspaceRoot, "app1", { paths: { "@libs/*": ["./libs/*"] } }),
+    ).resolve();
+
+    expect(resolved).toContain(path.join(workspaceRoot, "libs/shared"));
+    expect(resolved).toContain(path.join(workspaceRoot, "libs/util"));
+    expect(resolved).not.toContain(path.join(workspaceRoot, "libs/unused"));
+  });
+
+  test("keeps the libs container whole when the app manifest is missing", async () => {
+    const workspaceRoot = await makeWorkspace(["apps/app1/page", "libs/util", "libs/shared"]);
+    const resolved = await new WatchRootResolver(
+      makeApp(workspaceRoot, "app1", { paths: { "@libs/*": ["./libs/*"] } }),
+    ).resolve();
+
+    expect(resolved).toContain(path.join(workspaceRoot, "libs"));
+  });
+
+  test("keeps the libs container whole when a dependency lib is unsynced", async () => {
     const workspaceRoot = await makeWorkspace(["apps/app1/page", "libs/util", "libs/shared"]);
-    const resolved = await new WatchRootResolver(makeApp(workspaceRoot, "app1", { "@libs/*": ["./libs/*"] })).resolve();
+    await writeManifest(workspaceRoot, "apps/app1", ["shared"]);
+    const resolved = await new WatchRootResolver(
+      makeApp(workspaceRoot, "app1", { paths: { "@libs/*": ["./libs/*"] } }),
+    ).resolve();
 
     expect(resolved).toContain(path.join(workspaceRoot, "libs"));
   });
@@ -48,9 +108,11 @@ describe("WatchRootResolver", () => {
     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"],
+        paths: {
+          akanjs: ["./pkgs/akanjs/index.ts"],
+          "akanjs/*": ["./pkgs/akanjs/*"],
+          missing: ["./pkgs/nothing/index.ts"],
+        },
       }),
     ).resolve();
 
@@ -60,7 +122,7 @@ describe("WatchRootResolver", () => {
 
   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();
+    const resolved = await new WatchRootResolver(makeApp(workspaceRoot, "app1")).resolve();
 
     expect(resolved).toEqual([path.join(workspaceRoot, "apps/app1/page")]);
   });

package/frontendBuild/watchRootResolver.ts

@@ -1,15 +1,24 @@
 import fs from "node:fs";
+import { readFile } from "node:fs/promises";
 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.
+ * Two aliases strip down to a workspace container rather than a package, and taking either verbatim puts
+ * code the app never imports under the watcher — where a save rebuilds, restarts and reloads it for
+ * nothing, and both builders rewrite the same generated barrels:
+ *
+ * - `@apps/*` becomes the `apps/` container. Apps are leaves of the workspace graph — never one another's
+ *   dependencies — so it is replaced by this app's own directory.
+ * - `@libs/*` becomes the `libs/` container. A lib is a dependency only if the app reaches it, so it is
+ *   replaced by the app's own lib dependencies, transitively. The set is resolved once, at watcher
+ *   install: a lib that becomes a dependency mid-session needs a fresh `akan start` anyway, because the
+ *   import that made it one also needs a `sync`.
+ *
+ * Failing to resolve that set keeps the container whole, because a wrong narrowing is a dev server that
+ * silently ignores edits.
  */
 export class WatchRootResolver {
   #app: App;
@@ -22,6 +31,8 @@ export class WatchRootResolver {
     const tsconfig = await this.#app.getTsConfig();
     const appDir = path.resolve(this.#app.cwdPath);
     const appsContainer = path.dirname(appDir);
+    const libsContainer = path.resolve(this.#app.workspace.workspaceRoot, "libs");
+    const libRoots = await this.#resolveLibRoots(libsContainer);
     const set = new Set<string>();
     set.add(path.resolve(`${this.#app.cwdPath}/page`));
     for (const targets of Object.values(tsconfig.compilerOptions.paths ?? {})) {
@@ -31,10 +42,52 @@ 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 (resolved === libsContainer && libRoots) {
+          for (const root of libRoots) set.add(root);
+          continue;
+        }
         const root = resolved === appsContainer ? appDir : resolved;
         if (fs.existsSync(root)) set.add(root);
       }
     }
     return [...set];
   }
+
+  async #resolveLibRoots(libsContainer: string): Promise<string[] | null> {
+    const libDeps = await this.#resolveLibDeps(libsContainer);
+    if (!libDeps) return null;
+    return libDeps.map((name) => path.join(libsContainer, name)).filter((dir) => fs.existsSync(dir));
+  }
+
+  async #resolveLibDeps(libsContainer: string): Promise<string[] | null> {
+    const scanInfo = this.#app.getScanInfo({ allowEmpty: true });
+    // Already transitive, and present whenever this runs in a process that scanned. The builder and the
+    // idle watcher run in processes that did not, so they take the manifests `scan` wrote instead.
+    if (scanInfo?.type === "app") return scanInfo.libDeps;
+    const direct = await WatchRootResolver.#readManifestLibDeps(path.join(this.#app.cwdPath, "akan.app.json"));
+    if (!direct) return null;
+    const closure = new Set<string>();
+    const queue = [...direct];
+    while (queue.length > 0) {
+      const name = queue.shift();
+      if (!name || closure.has(name)) continue;
+      closure.add(name);
+      const nested = await WatchRootResolver.#readManifestLibDeps(path.join(libsContainer, name, "akan.lib.json"));
+      // An unsynced lib's own dependencies are unknowable, so no root can be ruled out.
+      if (!nested) return null;
+      queue.push(...nested);
+    }
+    return [...closure];
+  }
+
+  static async #readManifestLibDeps(manifestPath: string): Promise<string[] | null> {
+    try {
+      const parsed = JSON.parse(await readFile(manifestPath, "utf8")) as { libDeps?: unknown };
+      if (!Array.isArray(parsed.libDeps)) return null;
+      return parsed.libDeps.filter((name): name is string => typeof name === "string" && name.length > 0);
+    } catch {
+      // Missing before the first sync, and unparseable while sync is mid-write.
+      return null;
+    }
+  }
 }

package/package.json

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