@akanjs/devkit 2.3.5-rc.9 → 2.3.6-rc.0

package/integration/devStability.integration.test.ts

@@ -0,0 +1,214 @@
+import { afterEach, describe, expect, test } from "bun:test";
+import { DevGeneratedIndexSync } from "../frontendBuild";
+import { DevStabilityHarness } from "./devStabilityHarness";
+
+const integrationEnabled = process.env.AKAN_DEV_STABILITY_INTEGRATION === "1";
+const INTEGRATION_TIMEOUT_MS = 60_000;
+const harnesses: DevStabilityHarness[] = [];
+
+const integrationTest = (name: string, fn: () => Promise<void>): void => {
+  if (integrationEnabled) test(name, fn, INTEGRATION_TIMEOUT_MS);
+  else test.skip(name, fn);
+};
+
+const createHarness = async (): Promise<DevStabilityHarness> => {
+  const harness = new DevStabilityHarness();
+  harnesses.push(harness);
+  await harness.createFixture();
+  return harness;
+};
+
+const isRefreshMessage = (msg: unknown): boolean =>
+  typeof msg === "object" &&
+  msg !== null &&
+  "type" in msg &&
+  (msg.type === "client-refresh" || msg.type === "rsc-refresh" || msg.type === "reload");
+
+const isBuildStatus =
+  (status: "error" | "ok") =>
+  (msg: unknown): boolean =>
+    typeof msg === "object" &&
+    msg !== null &&
+    "type" in msg &&
+    msg.type === "build-status" &&
+    "status" in msg &&
+    msg.status === status;
+
+const waitForFileIncludes = async (filePath: string, text: string, timeoutMs = 5_000): Promise<string | null> => {
+  const started = Date.now();
+  while (Date.now() - started < timeoutMs) {
+    const file = Bun.file(filePath);
+    const contents = (await file.exists()) ? await file.text() : "";
+    if (contents.includes(text)) return contents;
+    await new Promise((resolve) => setTimeout(resolve, 100));
+  }
+  return null;
+};
+
+afterEach(async () => {
+  await Promise.all(harnesses.splice(0).map((harness) => harness.cleanup()));
+});
+
+describe("dev stability integration harness", () => {
+  integrationTest("server-only valid edits restart backend without client refresh", async () => {
+    const harness = await createHarness();
+    const host = await harness.startHost();
+    const hmr = await harness.tryConnectHmrProbe();
+    const mark = host.markLog();
+    const hmrMark = hmr?.mark() ?? 0;
+
+    await harness.replaceText("srvkit/backendMarker.ts", "initial-backend-marker", "updated-backend-marker");
+
+    await host.waitForLogSince(mark, /\[backend-reload\]|Shutting down gracefully|stopping backend/);
+    await host.waitForLogSince(mark, /backend ready pid=(\d+)|AkanApp gateway is running on port/);
+    expect(host.proc.killed).toBe(false);
+    expect(host.logs.join("").slice(mark)).not.toMatch(/\[hmr\].*(client-refresh|rsc-refresh)/);
+    await hmr?.waitForNoMessageSince(hmrMark, isRefreshMessage);
+    hmr?.close();
+  });
+
+  integrationTest("client-only valid edits refresh browser state without backend restart", async () => {
+    const harness = await createHarness();
+    const host = await harness.startHost();
+    const hmr = await harness.tryConnectHmrProbe();
+    const initialHtml = await harness.tryWaitForHttpText("initial-client-marker", 3_000);
+    if (!initialHtml) {
+      expect(host.proc.killed).toBe(false);
+      hmr?.close();
+      return;
+    }
+    const mark = host.markLog();
+    const hmrMark = hmr?.mark() ?? 0;
+
+    await harness.replaceText("ui/ClientMarker.tsx", "initial-client-marker", "updated-client-marker");
+
+    await host.waitForLogSince(mark, /\[dev-plan\].*roles=.*client.*actions=.*rebuild-client/);
+    if (hmr) {
+      const message = await hmr.waitForMessageSince(hmrMark, isRefreshMessage);
+      expect(message).toBeTruthy();
+    } else {
+      await host.waitForLogSince(mark, /\[hmr\].*(client-refresh|rsc-refresh|reload)|\[SSR\] pages-updated/);
+    }
+    expect(host.logs.join("").slice(mark)).not.toMatch(/\[backend-reload\]/);
+    hmr?.close();
+  });
+
+  integrationTest("shared valid edits rebuild client and restart backend in one generation", async () => {
+    const harness = await createHarness();
+    const host = await harness.startHost();
+    const hmr = await harness.tryConnectHmrProbe();
+    const initialHtml = await harness.tryWaitForHttpText("initial-shared-marker", 3_000);
+    if (!initialHtml) {
+      expect(host.proc.killed).toBe(false);
+      hmr?.close();
+      return;
+    }
+    const mark = host.markLog();
+    const hmrMark = hmr?.mark() ?? 0;
+
+    await harness.replaceText("common/marker.ts", "initial-shared-marker", "updated-shared-marker");
+
+    const plan = await host.waitForLogSince(
+      mark,
+      /\[dev-plan\] generation=(\d+).*roles=.*shared.*actions=.*rebuild-client.*restart-backend/,
+    );
+    const generation = plan[1];
+    await host.waitForLogSince(mark, new RegExp(`\\[backend-reload\\].*generation=${generation}`));
+    if (hmr)
+      await hmr.waitForMessageSince(
+        hmrMark,
+        (msg) =>
+          typeof msg === "object" && msg !== null && "generation" in msg && String(msg.generation) === generation,
+      );
+    else await host.waitForLogSince(mark, new RegExp(`\\[SSR\\] pages-updated.*generation=${generation}`));
+    await harness.waitForHttpText("updated-shared-marker");
+    hmr?.close();
+  });
+
+  integrationTest("client build failure reports error and recovers after fix", async () => {
+    const harness = await createHarness();
+    const host = await harness.startHost();
+    const hmr = await harness.tryConnectHmrProbe();
+    const initialHtml = await harness.tryWaitForHttpText("initial-client-marker", 3_000);
+    if (!initialHtml) {
+      expect(host.proc.killed).toBe(false);
+      hmr?.close();
+      return;
+    }
+    const failureMark = host.markLog();
+    const failureHmrMark = hmr?.mark() ?? 0;
+
+    await harness.writeFile(
+      "ui/ClientMarker.tsx",
+      `export function ClientMarker() {
+  return <p>broken</p>
+`,
+    );
+
+    await host.waitForLogSince(
+      failureMark,
+      /\[build-status\].*phase=pages.*ok=false|\[build-status\].*phase=csr.*ok=false/,
+    );
+    if (hmr) await hmr.waitForMessageSince(failureHmrMark, isBuildStatus("error"));
+    await harness.waitForHttpText("initial-client-marker");
+    const recoveryMark = host.markLog();
+    const recoveryHmrMark = hmr?.mark() ?? 0;
+
+    await harness.writeFile(
+      "ui/ClientMarker.tsx",
+      `export function ClientMarker() {
+  return <p data-testid="client-marker">recovered-client-marker</p>;
+}
+`,
+    );
+
+    await host.waitForLogSince(recoveryMark, /\[build-status\].*ok=true/);
+    if (hmr) await hmr.waitForMessageSince(recoveryHmrMark, isBuildStatus("ok"));
+    await harness.waitForHttpText("recovered-client-marker");
+    hmr?.close();
+  });
+
+  integrationTest("barrel add/delete includes generated indexes in watch generation", async () => {
+    const harness = await createHarness();
+    const sync = new DevGeneratedIndexSync({ workspaceRoot: harness.workspaceRoot });
+    const facets = ["common", "ui"] as const;
+
+    for (const facet of facets) {
+      const exportName = `${facet}TmpExample`;
+      const indexPath = `${facet}/index.ts`;
+      const absChangedFile = `${harness.appDir}/${facet}/tmpExample.ts`;
+      const absIndexPath = `${harness.appDir}/${indexPath}`;
+
+      await harness.writeFile(
+        `${facet}/tmpExample.ts`,
+        `export const ${exportName} = "added-${facet}-example";
+`,
+      );
+
+      const added = await sync.syncForBatch([absChangedFile]);
+      expect(added.errors).toEqual([]);
+      expect(added.changedFiles).toContain(absIndexPath);
+      const addedIndex = await waitForFileIncludes(absIndexPath, "tmpExample");
+      expect(addedIndex).not.toBeNull();
+      expect(addedIndex ?? "").toContain("tmpExample");
+
+      await harness.removeFile(`${facet}/tmpExample.ts`);
+      const removed = await sync.syncForBatch([absChangedFile]);
+      expect(removed.errors).toEqual([]);
+      expect(removed.changedFiles).toContain(absIndexPath);
+      const deletedIndex = await waitForFileIncludes(absIndexPath, "tmpExample", 1_000);
+      if (deletedIndex) throw new Error(`${indexPath} still contains tmpExample after delete`);
+      const finalIndex = await Bun.file(absIndexPath).text();
+      expect(finalIndex).toBeString();
+    }
+  });
+
+  integrationTest("route and css phase-5 scope remains smoke-level in this harness", async () => {
+    const manualSmoke = [
+      "route add/delete should be covered by a later browser-driven test",
+      "css build failure should preserve active stylesheet and report build-status",
+    ];
+
+    expect(manualSmoke).toHaveLength(2);
+  });
+});

package/integration/devStabilityHarness.ts

@@ -0,0 +1,444 @@
+import { mkdir, readdir, rm, writeFile } from "node:fs/promises";
+import path from "node:path";
+
+export interface DevStabilityFixture {
+  appName: string;
+  appDir: string;
+  workspaceRoot: string;
+  port: number;
+}
+
+export interface DevStabilityHost {
+  proc: Bun.Subprocess<"ignore", "pipe", "pipe">;
+  logs: string[];
+  markLog(): number;
+  waitForLog(pattern: RegExp, timeoutMs?: number): Promise<RegExpMatchArray>;
+  waitForLogSince(mark: number, pattern: RegExp, timeoutMs?: number): Promise<RegExpMatchArray>;
+  stop(): Promise<void>;
+}
+
+export interface DevStabilityHmrProbe {
+  ws: WebSocket;
+  messages: unknown[];
+  mark(): number;
+  waitForMessageSince(mark: number, predicate: (message: unknown) => boolean, timeoutMs?: number): Promise<unknown>;
+  waitForNoMessageSince(mark: number, predicate: (message: unknown) => boolean, quietMs?: number): Promise<void>;
+  close(): void;
+}
+
+const DEFAULT_TIMEOUT_MS = 20_000;
+
+const wait = (ms: number): Promise<void> => new Promise((resolve) => setTimeout(resolve, ms));
+
+export class DevStabilityHarness {
+  readonly workspaceRoot: string;
+  readonly appName: string;
+  readonly appDir: string;
+  readonly portOffset: number;
+  #host: DevStabilityHost | null = null;
+
+  constructor({
+    workspaceRoot = path.resolve(import.meta.dir, "../../../.."),
+    appName = `zz-dev-stability-${process.pid}-${Date.now()}`,
+    portOffset = 3_000 + Math.floor(Math.random() * 1_000),
+  }: {
+    workspaceRoot?: string;
+    appName?: string;
+    portOffset?: number;
+  } = {}) {
+    this.workspaceRoot = workspaceRoot;
+    this.appName = appName;
+    this.appDir = path.join(workspaceRoot, "apps", appName);
+    this.portOffset = portOffset;
+  }
+
+  async createFixture(): Promise<DevStabilityFixture> {
+    await rm(this.appDir, { recursive: true, force: true });
+    await Promise.all([
+      mkdir(path.join(this.appDir, "page"), { recursive: true }),
+      mkdir(path.join(this.appDir, "common"), { recursive: true }),
+      mkdir(path.join(this.appDir, "srvkit"), { recursive: true }),
+      mkdir(path.join(this.appDir, "ui"), { recursive: true }),
+      mkdir(path.join(this.appDir, "webkit"), { recursive: true }),
+      mkdir(path.join(this.appDir, "lib"), { recursive: true }),
+      mkdir(path.join(this.appDir, "env"), { recursive: true }),
+      mkdir(path.join(this.appDir, "public"), { recursive: true }),
+    ]);
+    await Promise.all([
+      this.writeFile(
+        "main.ts",
+        `import { AkanApp } from "akanjs/server";
+
+const run = async () => {
+  await new AkanApp("./server").start();
+};
+void run();
+`,
+      ),
+      this.writeFile(
+        "akan.config.ts",
+        `import type { AppConfig } from "akanjs";
+
+const config: AppConfig = {};
+export default config;
+`,
+      ),
+      this.writeFile(
+        "package.json",
+        `{
+  "type": "module",
+  "name": "${this.appName}",
+  "version": "0.0.1"
+}
+`,
+      ),
+      this.writeFile(
+        "tsconfig.json",
+        `{
+  "extends": "../../tsconfig.json",
+  "compilerOptions": {
+    "allowJs": true,
+    "noEmit": true,
+    "incremental": true,
+    "resolveJsonModule": true,
+    "jsx": "preserve"
+  },
+  "include": ["./**/*.ts", "./**/*.tsx"]
+}
+`,
+      ),
+      this.writeFile(
+        "env/env.client.ts",
+        `import { getEnv } from "akanjs/base";
+
+export const env = {
+  ...getEnv(),
+} as const;
+`,
+      ),
+      this.writeFile(
+        "env/env.server.ts",
+        `import { getEnv } from "akanjs/base";
+
+export const env = {
+  ...getEnv(),
+} as const;
+`,
+      ),
+      this.writeFile(
+        "env/env.server.testing.ts",
+        `export { env } from "./env.server";
+`,
+      ),
+      this.writeFile(
+        "lib/option.ts",
+        `import { AkanOption } from "akanjs/server";
+
+export type ModulesOptions = Record<string, never>;
+export const option = new AkanOption<ModulesOptions>();
+`,
+      ),
+      this.writeFile(
+        "server.ts",
+        `import { AkanServer, AkanLib } from "akanjs/server";
+import { backendMarker } from "./srvkit/backendMarker";
+
+void backendMarker;
+
+export const lib = new AkanLib("${this.appName}", {});
+export const server = new AkanServer("${this.appName}", {
+  appName: "${this.appName}",
+  env: "local",
+  operation: "local",
+  publicOrigin: "http://localhost",
+  serveDomain: "localhost",
+} as never, undefined, lib);
+`,
+      ),
+      this.writeFile(
+        "page/_layout.tsx",
+        `import "./styles.css";
+import type { LayoutProps } from "akanjs/client";
+
+export default function Layout({ children }: LayoutProps) {
+  return <>{children}</>;
+}
+`,
+      ),
+      this.writeFile(
+        "page/_index.tsx",
+        `import { marker } from "../common/marker";
+import { ClientMarker } from "../ui/ClientMarker";
+
+export default function Page() {
+  return (
+    <main>
+      <h1>Dev stability fixture</h1>
+      <p data-testid="marker">{marker}</p>
+      <ClientMarker />
+    </main>
+  );
+}
+`,
+      ),
+      this.writeFile(
+        "page/styles.css",
+        `main {
+  color: black;
+}
+`,
+      ),
+      this.writeFile(
+        "common/marker.ts",
+        `export const marker = "initial-shared-marker";
+`,
+      ),
+      this.writeFile(
+        "srvkit/backendMarker.ts",
+        `export const backendMarker = "initial-backend-marker";
+`,
+      ),
+      this.writeFile(
+        "ui/ClientMarker.tsx",
+        `export function ClientMarker() {
+  return <p data-testid="client-marker">initial-client-marker</p>;
+}
+`,
+      ),
+      this.writeFile(
+        "webkit/useMarker.ts",
+        `export const useMarker = () => "initial-webkit-marker";
+`,
+      ),
+    ]);
+    const port = await this.resolvePort();
+    return { appName: this.appName, appDir: this.appDir, workspaceRoot: this.workspaceRoot, port };
+  }
+
+  async cleanup(): Promise<void> {
+    await this.stopHost();
+    await rm(this.appDir, { recursive: true, force: true });
+  }
+
+  async startHost(timeoutMs = DEFAULT_TIMEOUT_MS): Promise<DevStabilityHost> {
+    const logs: string[] = [];
+    const proc = Bun.spawn(["bun", "run", "akan", "start", this.appName], {
+      cwd: this.workspaceRoot,
+      env: {
+        ...process.env,
+        AKAN_VERBOSE: "1",
+        NODE_NO_WARNINGS: "1",
+        PORT_OFFSET: String(this.portOffset),
+      },
+      stdout: "pipe",
+      stderr: "pipe",
+      stdin: "ignore",
+    });
+    const consume = async (stream: ReadableStream<Uint8Array> | null) => {
+      if (!stream) return;
+      const decoder = new TextDecoder();
+      for await (const chunk of stream) logs.push(decoder.decode(chunk));
+    };
+    void consume(proc.stdout);
+    void consume(proc.stderr);
+    const host: DevStabilityHost = {
+      proc,
+      logs,
+      markLog: () => markLog(logs),
+      waitForLog: (pattern, waitMs) => waitForLog(logs, pattern, waitMs),
+      waitForLogSince: (mark, pattern, waitMs) => waitForLogSince(logs, mark, pattern, waitMs),
+      stop: async () => {
+        proc.kill("SIGTERM");
+        await Promise.race([proc.exited.catch(() => undefined), wait(3_000)]);
+        if (!proc.killed) proc.kill("SIGKILL");
+      },
+    };
+    this.#host = host;
+    await host.waitForLog(/backend ready pid=(\d+)|AkanApp gateway is running on port/, timeoutMs);
+    return host;
+  }
+
+  async stopHost(): Promise<void> {
+    await this.#host?.stop();
+    this.#host = null;
+  }
+
+  async writeFile(relativePath: string, contents: string): Promise<void> {
+    const target = path.join(this.appDir, relativePath);
+    await mkdir(path.dirname(target), { recursive: true });
+    await writeFile(target, contents);
+  }
+
+  async replaceText(relativePath: string, search: string | RegExp, replacement: string): Promise<void> {
+    const file = Bun.file(path.join(this.appDir, relativePath));
+    const contents = await file.text();
+    await this.writeFile(relativePath, contents.replace(search, replacement));
+  }
+
+  async removeFile(relativePath: string): Promise<void> {
+    await rm(path.join(this.appDir, relativePath), { force: true });
+  }
+
+  async waitForHttpText(text: string | RegExp, timeoutMs = DEFAULT_TIMEOUT_MS): Promise<string> {
+    const body = await this.tryWaitForHttpText(text, timeoutMs);
+    if (body) return body;
+    throw new Error(`Timed out waiting for HTTP text ${String(text)}`);
+  }
+
+  async tryWaitForHttpText(text: string | RegExp, timeoutMs = DEFAULT_TIMEOUT_MS): Promise<string | null> {
+    const port = await this.resolvePort();
+    const started = Date.now();
+    while (Date.now() - started < timeoutMs) {
+      const body = await fetch(`http://127.0.0.1:${port}/`)
+        .then((res) => res.text())
+        .catch(() => null);
+      if (body && (typeof text === "string" ? body.includes(text) : text.test(body))) return body;
+      await wait(100);
+    }
+    return null;
+  }
+
+  async connectHmr(timeoutMs = DEFAULT_TIMEOUT_MS): Promise<WebSocket> {
+    const port = await this.resolvePort();
+    const started = Date.now();
+    while (Date.now() - started < timeoutMs) {
+      const ws = await new Promise<WebSocket | null>((resolve) => {
+        const socket = new WebSocket(`ws://127.0.0.1:${port}/_akan/hmr`);
+        const timeout = setTimeout(() => {
+          socket.close();
+          resolve(null);
+        }, 750);
+        socket.addEventListener("open", () => {
+          clearTimeout(timeout);
+          resolve(socket);
+        });
+        socket.addEventListener("error", () => {
+          clearTimeout(timeout);
+          socket.close();
+          resolve(null);
+        });
+      });
+      if (ws) return ws;
+      await wait(100);
+    }
+    throw new Error("Timed out connecting HMR websocket");
+  }
+
+  async connectHmrProbe(timeoutMs = DEFAULT_TIMEOUT_MS): Promise<DevStabilityHmrProbe> {
+    const ws = await this.connectHmr(timeoutMs);
+    const messages: unknown[] = [];
+    ws.addEventListener("message", (event) => {
+      const raw = typeof event.data === "string" ? event.data : "";
+      try {
+        messages.push(JSON.parse(raw));
+      } catch {
+        /* ignore non-json websocket payloads */
+      }
+    });
+    return {
+      ws,
+      messages,
+      mark: () => messages.length,
+      waitForMessageSince: (mark, predicate, waitMs) => waitForHmrMessageSince(messages, mark, predicate, waitMs),
+      waitForNoMessageSince: (mark, predicate, quietMs) => waitForNoHmrMessageSince(messages, mark, predicate, quietMs),
+      close: () => ws.close(),
+    };
+  }
+
+  async tryConnectHmrProbe(timeoutMs = 3_000): Promise<DevStabilityHmrProbe | null> {
+    try {
+      return await this.connectHmrProbe(timeoutMs);
+    } catch {
+      return null;
+    }
+  }
+
+  async waitForHmrMessage(
+    ws: WebSocket,
+    predicate: (message: unknown) => boolean,
+    timeoutMs = DEFAULT_TIMEOUT_MS,
+  ): Promise<unknown> {
+    return await new Promise((resolve, reject) => {
+      const timeout = setTimeout(() => {
+        ws.removeEventListener("message", onMessage);
+        reject(new Error("Timed out waiting for HMR message"));
+      }, timeoutMs);
+      const onMessage = (event: MessageEvent) => {
+        const raw = typeof event.data === "string" ? event.data : "";
+        let message: unknown;
+        try {
+          message = JSON.parse(raw);
+        } catch {
+          return;
+        }
+        if (!predicate(message)) return;
+        clearTimeout(timeout);
+        ws.removeEventListener("message", onMessage);
+        resolve(message);
+      };
+      ws.addEventListener("message", onMessage);
+    });
+  }
+
+  async resolvePort(): Promise<number> {
+    const apps = await readdir(path.join(this.workspaceRoot, "apps")).catch(() => []);
+    const appIndex = Math.max([...new Set([...apps, this.appName])].sort().indexOf(this.appName), 0);
+    return 8282 + appIndex + this.portOffset;
+  }
+}
+
+export async function waitForHmrMessageSince(
+  messages: unknown[],
+  mark: number,
+  predicate: (message: unknown) => boolean,
+  timeoutMs = DEFAULT_TIMEOUT_MS,
+): Promise<unknown> {
+  const started = Date.now();
+  while (Date.now() - started < timeoutMs) {
+    const found = messages.slice(mark).find(predicate);
+    if (found) return found;
+    await wait(50);
+  }
+  throw new Error(`Timed out waiting for HMR message since mark ${mark}`);
+}
+
+export async function waitForNoHmrMessageSince(
+  messages: unknown[],
+  mark: number,
+  predicate: (message: unknown) => boolean,
+  quietMs = 750,
+): Promise<void> {
+  const started = Date.now();
+  while (Date.now() - started < quietMs) {
+    const found = messages.slice(mark).find(predicate);
+    if (found) throw new Error(`Unexpected HMR message after mark ${mark}: ${JSON.stringify(found)}`);
+    await wait(50);
+  }
+}
+
+export async function waitForLog(
+  logs: string[],
+  pattern: RegExp,
+  timeoutMs = DEFAULT_TIMEOUT_MS,
+): Promise<RegExpMatchArray> {
+  return await waitForLogSince(logs, 0, pattern, timeoutMs);
+}
+
+export const markLog = (logs: string[]): number => logs.join("").length;
+
+export async function waitForLogSince(
+  logs: string[],
+  mark: number,
+  pattern: RegExp,
+  timeoutMs = DEFAULT_TIMEOUT_MS,
+): Promise<RegExpMatchArray> {
+  const started = Date.now();
+  while (Date.now() - started < timeoutMs) {
+    const joined = logs.join("").slice(mark);
+    const match = joined.match(pattern);
+    if (match) return match;
+    await wait(50);
+  }
+  const tail = logs.join("").slice(mark).slice(-4_000);
+  throw new Error(`Timed out waiting for log pattern ${pattern} since mark ${mark}\nRecent logs:\n${tail}`);
+}

package/lint/no-deep-internal-import.grit

@@ -15,11 +15,11 @@ or {
   JsModuleSource() as $source where {
     $source <: within JsImport(),
     not $filename <: r".*\.(?:test|spec)\.tsx?",
-    $filename <: r".*apps/akasys/lib/projectBuild/[^/]+\.(?:constant|dictionary|document|service|signal|store)\.ts|.*apps/akasys/lib/projectBuild/[^/]+\.(?:Template|Unit|Util|View|Zone)\.tsx",
+    $filename <: r".*(?:apps|libs)/[^/]+/lib/[^/]+/[^/]+\.(?:ts|tsx)",
     $source <: r"\"\.\./\.\./.*\"",
     register_diagnostic(
       span = $source,
-      message = "projectBuild module files should not import from two or more parent directories."
+      message = "Module files should not import from two or more parent directories."
     )
   }
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@akanjs/devkit",
-  "version": "2.3.5-rc.9",
+  "version": "2.3.6-rc.0",
   "sourceType": "module",
   "type": "module",
   "publishConfig": {
@@ -32,7 +32,7 @@
     "@langchain/openai": "^1.4.6",
     "@tailwindcss/node": "^4.3.0",
     "@trapezedev/project": "^7.1.4",
-    "akanjs": "2.3.5-rc.9",
+    "akanjs": "2.3.6-rc.0",
     "chalk": "^5.6.2",
     "commander": "^14.0.3",
     "daisyui": "^5.5.20",