@akanjs/devkit 3.0.0-alpha.11 → 3.0.0-alpha.110

package/incrementalBuilder/incrementalBuilder.proc.ts

@@ -4,6 +4,7 @@ import path from "node:path";
 // barrel reaches `cssCompiler`/`ssrBaseArtifactBuilder`, which pull tailwindcss + @tailwindcss/node
 // (~40MB) into a process that then holds them for the whole dev session. Phase 2 moved css compilation
 // into the batch worker, so this process has no use for them — `entryModuleGraph.test.ts` keeps it that way.
+import { CodegenLock } from "@akanjs/devkit/codegenLock";
 import type { App } from "@akanjs/devkit/commandDecorators";
 import { AppExecutor, type PageRoot, WorkspaceExecutor } from "@akanjs/devkit/executors";
 import { AutoImportSync } from "@akanjs/devkit/frontendBuild/autoImportSync";
@@ -185,7 +186,12 @@ class IncrementalBuilder {
     if (this.#shuttingDown) return;
     this.#shuttingDown = true;
     const started = Date.now();
-    this.#logger.info(`shutdown requested (${reason}); draining ${this.#inFlight} work item(s)`);
+    this.#logger.debug(`shutdown requested (${reason}); draining ${this.#inFlight} work item(s)`);
+    // Stopped before the drain, or a save landing mid-drain would enqueue a batch behind the queue tail
+    // this method already awaited — and `process.exit(0)` would cut that batch off partway through
+    // writing its artifacts. The replacement rebuilds every artifact from its boot build anyway, so the
+    // batch is not lost; a half-written one would be.
+    this.#watcher?.stop();
     if (this.#cssRebuildTimer) {
       // Only reachable if a css batch landed between the idle report and this request: the fresh
       // boot build recompiles css from scratch anyway, so dropping the debounce loses nothing.
@@ -200,7 +206,7 @@ class IncrementalBuilder {
     // flushed — a `css-updated` relayed milliseconds before this line would be dropped with no error
     // anywhere, leaving the backend serving the previous bundle. See `BuilderChannel`.
     const flushed = await BuilderChannel.drain();
-    this.#logger.info(
+    this.#logger.debug(
       `drained in ${Date.now() - started}ms${flushed ? ` after flushing ${flushed} ipc write(s)` : ""}; exiting for recycle`,
     );
     process.exit(0);
@@ -294,22 +300,27 @@ class IncrementalBuilder {
     //* Insert framework imports that are used but omitted (e.g. `Int` in *.constant.ts, `fetch` in
     //* *.store.ts) before regenerating barrels. Edits land on files already in this batch, so they
     //* rebuild in this same generation; the write is idempotent so it does not re-trigger the watcher.
-    const autoImport = await this.#autoImportSync.syncForBatch(batch.files);
+    const [autoImport, indexSync] = await CodegenLock.run(
+      this.#app.workspace.workspaceRoot,
+      `hmr-batch:${this.#app.name}`,
+      async () => {
+        const auto = await this.#autoImportSync.syncForBatch(batch.files);
+        return [auto, await this.#generatedIndexSync.syncForBatch(batch.files)] as const;
+      },
+    );
     for (const error of autoImport.errors) this.#logger.error(error);
     if (autoImport.changedFiles.length > 0)
       this.#logger.verbose(`[auto-import] inserted imports into ${autoImport.changedFiles.length} file(s)`);
-    const indexSync = await this.#generatedIndexSync.syncForBatch(batch.files);
     //* Both passes above write source files, and this generation's build consumes what they wrote. Hand
     //* them to the watcher so its verification scan does not read them back as a user edit and spend a
     //* second generation rebuilding identical content.
     await this.#watcher?.absorb([...autoImport.changedFiles, ...indexSync.changedFiles]);
-    const { files, kinds, expandedBatch, event, hasSyncErrors } = prepareDevWatchBatch({
+    const { files, kinds, expandedBatch, devPlan, event, hasSyncErrors } = prepareDevWatchBatch({
       generation,
       batch,
       indexSync,
       changePlanner: this.#changePlanner,
     });
-    const devPlan = event.devPlan;
     this.#logger.verbose(
       `[hmr] batch generation=${generation} kinds=${kinds.join(",")} files=${files.length} generated=${indexSync.changedFiles.length} roles=${devPlan.roles.join(",") || "(none)"} actions=${devPlan.actions.join(",") || "(none)"}`,
     );

package/index.ts

@@ -22,19 +22,15 @@ export type * from "./applicationBuildRunner";
 export type * from "./applicationReleasePackager";
 export type * from "./applicationTestPreload";
 export type * from "./artifact";
-export type * from "./builder";
 export type * from "./capacitorApp";
 export type * from "./cloud";
 export type * from "./commandDecorators";
 export type * from "./createTunnel";
 export type * from "./dependencyScanner";
 export type * from "./executors";
-export type * from "./extractDeps";
 export type * from "./fileSys";
 export type * from "./frontendBuild";
-export type * from "./getCredentials";
 export type * from "./getDirname";
-export type * from "./getModelFileData";
 export type * from "./getRelatedCnsts";
 export type * from "./guideline";
 export type * from "./incrementalBuilder";
@@ -46,11 +42,8 @@ export type * from "./recipeScanner";
 export type * from "./scanInfo";
 export type * from "./selectModel";
 export type * from "./spinner";
-export type * from "./streamAi";
 export type * from "./transforms";
 export type * from "./typeChecker";
 export type * from "./types";
-export type * from "./ui";
 export type * from "./uploadRelease";
-export type * from "./useStdoutDimensions";
 export type * from "./workflow";

package/integration/devStabilityHarness.ts

@@ -118,20 +118,12 @@ export default config;
       ),
       this.writeFile(
         "env/env.client.ts",
-        `import { getEnv } from "akanjs/base";
-
-export const env = {
-  ...getEnv(),
-} as const;
+        `export const env = {} as const;
 `,
       ),
       this.writeFile(
         "env/env.server.ts",
-        `import { getEnv } from "akanjs/base";
-
-export const env = {
-  ...getEnv(),
-} as const;
+        `export const env = {} as const;
 `,
       ),
       this.writeFile(
@@ -167,19 +159,20 @@ export const server = new AkanServer("${this.appName}", {
       this.writeFile(
         "page/_layout.tsx",
         `import "./styles.css";
-import type { LayoutProps } from "akanjs/client";
+import { layout } from "akanjs/client";
 
-export default function Layout({ children }: LayoutProps) {
+export default layout().render(({ children }) => {
   return <>{children}</>;
-}
+});
 `,
       ),
       this.writeFile(
         "page/_index.tsx",
-        `import { marker } from "../common/marker";
+        `import { page } from "akanjs/client";
+import { marker } from "../common/marker";
 import { ClientMarker } from "../ui/ClientMarker";
 
-export default function Page() {
+export default page().render(() => {
   return (
     <main>
       <h1>Dev stability fixture</h1>
@@ -187,7 +180,7 @@ export default function Page() {
       <ClientMarker />
     </main>
   );
-}
+});
 `,
       ),
       // A second route exists so a test can ask for a page the backend has *never* built, at a moment of
@@ -195,16 +188,17 @@ export default function Page() {
       // request of a test is the only one that reaches the builder at all.
       this.writeFile(
         "page/second/_index.tsx",
-        `import { ClientMarker } from "../../ui/ClientMarker";
+        `import { page } from "akanjs/client";
+import { ClientMarker } from "../../ui/ClientMarker";
 
-export default function Page() {
+export default page().render(() => {
   return (
     <main>
       <h1>Second route</h1>
       <ClientMarker />
     </main>
   );
-}
+});
 `,
       ),
       this.writeFile(

package/libSource.test.ts

@@ -0,0 +1,112 @@
+import { afterEach, describe, expect, test } from "bun:test";
+import { mkdir, mkdtemp, rm, writeFile } from "node:fs/promises";
+import os from "node:os";
+import path from "node:path";
+import { Executor, LibExecutor, WorkspaceExecutor } from "./executors";
+import { formatLibStatuses, LibSource } from "./libSource";
+
+const tempRoots: string[] = [];
+
+afterEach(async () => {
+  await Promise.all(tempRoots.splice(0).map((root) => rm(root, { recursive: true, force: true })));
+});
+
+const write = async (filePath: string, content: string) => {
+  await mkdir(path.dirname(filePath), { recursive: true });
+  await writeFile(filePath, content);
+};
+
+// `LibExecutor.from` memoises by name, so each fixture needs a name no other test has used.
+const makeLib = async (libName: string) => {
+  const root = await mkdtemp(path.join(os.tmpdir(), "akan-libsource-"));
+  tempRoots.push(root);
+  await write(
+    path.join(root, "package.json"),
+    '{ "name": "workspace", "version": "0.0.1", "description": "workspace" }\n',
+  );
+  await write(path.join(root, ".gitignore"), "node_modules\n");
+  await write(path.join(root, `libs/${libName}/package.json`), `{ "name": "@${libName}", "version": "0.0.1" }\n`);
+  await write(path.join(root, `libs/${libName}/common/helper.ts`), "export const helper = 1;\n");
+  await write(path.join(root, `libs/${libName}/env/env.server.testing.ts`), "export const env = { key: 1 };\n");
+
+  const git = new Executor("fixture", root);
+  await git.spawn("git", ["init", "--quiet"]);
+
+  const workspace = WorkspaceExecutor.fromRoot({ workspaceRoot: root, repoName: `workspace-${libName}` });
+  const lib = LibExecutor.from(workspace, libName);
+  return { root, lib, source: new LibSource(lib) };
+};
+
+describe("LibSource", () => {
+  test("reports an unstamped library", async () => {
+    const { source } = await makeLib("plain-lib");
+    const status = await source.status();
+
+    expect(status.drift).toBe("unstamped");
+    expect(status.stamp).toBeNull();
+    expect(status.hash).toMatch(/^[0-9a-f]{32}$/);
+  });
+
+  test("stamps the origin into package.json and reads back clean", async () => {
+    const { lib, source } = await makeLib("stamped-lib");
+    const stamp = await source.write({ origin: "akanjs", sha: "3.0.0" });
+
+    expect(stamp.origin).toBe("akanjs");
+    expect(await source.read()).toEqual(stamp);
+    expect((await source.status()).drift).toBe("clean");
+
+    const manifest = await lib.getPackageJson();
+    expect(manifest.name).toBe("@stamped-lib");
+    expect((manifest.akan as { source: { sha: string } }).source.sha).toBe("3.0.0");
+  });
+
+  test("detects an edit to library source as drift", async () => {
+    const { root, source } = await makeLib("drift-lib");
+    await source.write({ origin: "akanjs", sha: "3.0.0" });
+    await write(path.join(root, "libs/drift-lib/common/helper.ts"), "export const helper = 2;\n");
+
+    expect((await source.status()).drift).toBe("drifted");
+  });
+
+  test("survives every other akan write to the manifest", async () => {
+    const { lib, source } = await makeLib("merge-lib");
+    const stamp = await source.write({ origin: "akanjs", sha: "3.0.0" });
+    const manifest = await lib.getPackageJson();
+    await lib.setPackageJson({ ...manifest, dependencies: { lodash: "4.0.0" } });
+
+    expect(await source.read()).toEqual(stamp);
+    expect((await source.status()).drift).toBe("drifted");
+  });
+
+  test("leaves env values out of the hash — they belong to the installing workspace", async () => {
+    const { root, source } = await makeLib("env-lib");
+    await source.write({ origin: "akanjs", sha: "3.0.0" });
+    await write(path.join(root, "libs/env-lib/env/env.server.testing.ts"), "export const env = { key: 999 };\n");
+
+    expect((await source.status()).drift).toBe("clean");
+  });
+});
+
+describe("formatLibStatuses", () => {
+  test("marks drifted libraries and counts them", () => {
+    const text = formatLibStatuses([
+      {
+        lib: "util",
+        drift: "clean",
+        hash: "a".repeat(32),
+        stamp: { origin: "akanjs", sha: "3.0.0", hash: "a".repeat(32), syncedAt: "now" },
+      },
+      {
+        lib: "shared",
+        drift: "drifted",
+        hash: "b".repeat(32),
+        stamp: { origin: "akanjs", sha: "3.0.0", hash: "a".repeat(32), syncedAt: "now" },
+      },
+      { lib: "local", drift: "unstamped", hash: "c".repeat(32), stamp: null },
+    ]);
+
+    expect(text).toContain("DRIFTED   libs/shared  akanjs@3.0.0");
+    expect(text).toContain("unstamped libs/local  no akan.source in package.json");
+    expect(text).toContain("drifted: 1 / 3");
+  });
+});

package/libSource.ts

@@ -0,0 +1,126 @@
+import type { LibExecutor } from "./executors";
+import type { PackageJson } from "./types";
+
+export interface LibSourceStamp {
+  /** Where the copy came from: a git remote URL, or `akanjs` for the published package. */
+  origin: string;
+  /** The origin's commit sha, or the package version when the origin is a registry. */
+  sha: string;
+  /** Content hash of the library as installed, so a later edit is detectable without the origin. */
+  hash: string;
+  syncedAt: string;
+}
+
+export type LibDrift = "clean" | "drifted" | "unstamped";
+
+export interface LibStatus {
+  lib: string;
+  drift: LibDrift;
+  stamp: LibSourceStamp | null;
+  hash: string;
+}
+
+/**
+ * A library's origin, recorded in its own `package.json` under an `akan.source` key.
+ *
+ * The key rides `package.json` rather than a file of its own because every akan write to a library's
+ * manifest is a spread of the existing object (`LibExecutor.syncPackageJson`), so an unknown top-level
+ * key survives — while a new root file would have to be added to `libRootAllowedFiles` before
+ * `akan sync` stopped rejecting it.
+ */
+export class LibSource {
+  static readonly manifestKey = "akan";
+  /**
+   * Left out of the hash. `env/` holds per-deployment values that belong to the workspace the library
+   * was installed into, not to the origin, so an env edit is not drift.
+   */
+  static readonly unhashedDirs = ["env"];
+
+  #lib: LibExecutor;
+  constructor(lib: LibExecutor) {
+    this.#lib = lib;
+  }
+
+  get #prefix() {
+    return `libs/${this.#lib.name}/`;
+  }
+
+  #isHashed(file: string) {
+    const relative = file.slice(this.#prefix.length);
+    return !LibSource.unhashedDirs.includes(relative.split("/")[0] ?? "");
+  }
+
+  /** `package.json` cannot hash the stamp it carries, so the key comes off before hashing. */
+  async #hashableContent(file: string) {
+    const content = await this.#lib.workspace.readFile(file);
+    if (file !== `${this.#prefix}package.json`) return content;
+    const manifest = JSON.parse(content) as PackageJson;
+    delete manifest[LibSource.manifestKey];
+    return JSON.stringify(manifest);
+  }
+
+  /**
+   * Hash over the library's own files. Untracked files count: a freshly copied library is not committed
+   * yet, and its hash has to be the same one a later `status` recomputes.
+   */
+  async computeHash() {
+    const files = (await this.#lib.workspace.listGitFiles([`libs/${this.#lib.name}`], { untracked: true })).filter(
+      (file) => this.#isHashed(file),
+    );
+    const hasher = new Bun.CryptoHasher("sha256");
+    for (const file of files) {
+      hasher.update(file);
+      hasher.update("\0");
+      hasher.update(await this.#hashableContent(file));
+      hasher.update("\0");
+    }
+    return hasher.digest("hex").slice(0, 32);
+  }
+
+  async read(): Promise<LibSourceStamp | null> {
+    const manifest = await this.#lib.getPackageJson();
+    const akan = manifest[LibSource.manifestKey] as { source?: LibSourceStamp } | undefined;
+    return akan?.source ?? null;
+  }
+
+  async write({ origin, sha }: Pick<LibSourceStamp, "origin" | "sha">) {
+    const [manifest, hash] = await Promise.all([this.#lib.getPackageJson(), this.computeHash()]);
+    const akan = (manifest[LibSource.manifestKey] ?? {}) as Record<string, unknown>;
+    const stamp: LibSourceStamp = { origin, sha, hash, syncedAt: new Date().toISOString() };
+    await this.#lib.setPackageJson({ ...manifest, [LibSource.manifestKey]: { ...akan, source: stamp } });
+    return stamp;
+  }
+
+  /**
+   * Writes the stamp only when it would change. `syncedAt` moves on every write, so an unconditional
+   * write leaves the manifest dirty and defeats an idempotent caller — the hash is computed with the
+   * stamp removed, so comparing it first is sound.
+   */
+  async syncStamp({ origin, sha }: Pick<LibSourceStamp, "origin" | "sha">) {
+    const [current, hash] = await Promise.all([this.read(), this.computeHash()]);
+    if (current?.origin === origin && current.sha === sha && current.hash === hash)
+      return { stamp: current, changed: false };
+    return { stamp: await this.write({ origin, sha }), changed: true };
+  }
+
+  async status(): Promise<LibStatus> {
+    const [stamp, hash] = await Promise.all([this.read(), this.computeHash()]);
+    const drift = !stamp ? "unstamped" : stamp.hash === hash ? "clean" : "drifted";
+    return { lib: this.#lib.name, drift, stamp, hash };
+  }
+}
+
+export function formatLibStatuses(statuses: LibStatus[]) {
+  const marks = { clean: "clean    ", drifted: "DRIFTED  ", unstamped: "unstamped" } as const;
+  const sections = [
+    "Akan Library Source Status",
+    "",
+    ...statuses.map((status) => {
+      const origin = status.stamp ? `${status.stamp.origin}@${status.stamp.sha}` : "no akan.source in package.json";
+      return `  ${marks[status.drift]} libs/${status.lib}  ${origin}`;
+    }),
+    "",
+    `drifted: ${statuses.filter((status) => status.drift === "drifted").length} / ${statuses.length}`,
+  ];
+  return sections.join("\n");
+}

package/lint/__fixtures__/README.md

@@ -0,0 +1,40 @@
+# grit rule fixtures
+
+One folder per `lint/*.grit` rule. `gritRules.test.ts` runs biome with that one plugin enabled and asserts
+`bad` reports **exactly** the marked lines and `good` reports nothing — so a rule that silently stops
+matching after a biome upgrade fails the suite instead of going quiet, and `every rule in this folder has a
+fixture` fails when a rule is added without one.
+
+## Contract
+
+- One case per line. `// @flag` marks a line the rule must report in `bad`; `// @ok` marks a line in `good`.
+- The `bad` assertion is set equality, not containment: a marked line nobody reported is a pattern that
+  stopped matching, and a reported line nobody marked is the rule reaching further than the fixture claims.
+- `good` is the half that matters most: an over-matching rule is what makes developers distrust the gate.
+- `fixture.json` is optional:
+  - `path` — where the source is written inside the temp workspace, for a rule that reads `$filename`
+    (`no-deep-internal-import`, `no-redeclare-predefined-endpoint`). Its extension also picks which of
+    `bad.ts` / `bad.tsx` is read.
+  - `expect: "file"` — for a rule whose span is the whole file (`no-bang-comment-in-client`), where there is
+    no per-line diagnostic to match. `bad` must report at least once.
+- A rule with two independent gates gets one subfolder per gate (`no-init-fetch-in-client/{use-client,store-file}`).
+- These files are excluded from the repo's own biome run (root `biome.json` `files.includes`) and from
+  `tsc` (`tsconfig.json` `exclude`), because they reference undeclared identifiers on purpose and the
+  formatter would reorder the class strings the vocabulary fixtures test.
+
+## Biome GritQL constraints these fixtures pinned down
+
+Each of these made a rule silently report nothing, and each was found by adding the fixture:
+
+- A bare snippet in JSX-attribute shape (`` `$name={$value}` ``) matches **no** JsxAttribute. Match the node
+  and read its fields: `JsxAttribute(name = $name, initializer = ...)`.
+- `JsModule()` never matches as a top-level pattern, and no node pattern is given comment trivia. A rule
+  about comments has to go through `file($name, $body)`, whose span is the whole file.
+- `file()`'s `$body` is the module's **token** span: interior trivia is visible, the leading and trailing
+  trivia are not. So a comment above the first statement or below the last one is unreachable from GritQL —
+  that is `no-bang-comment-in-client`'s blind spot, and why its fixture puts the marker between statements.
+- A regex capture (`r"..."($var)`) carries no source range: a diagnostic spanned on one gets no location,
+  and `$var` does not interpolate into a `message`.
+
+The five vocabulary fixtures were ported from `frontendBuild/styleGuard.test.ts`, the pre-grit
+implementation of the same rules, when that scanner was retired.

package/lint/__fixtures__/no-arbitrary-color/bad.tsx

@@ -0,0 +1,3 @@
+export const HexValue = () => <div className="bg-[#3b82f6]" />; // @flag
+export const ColorFunctionValue = () => <div className="text-[rgb(0,0,0)]" />; // @flag
+export const HslValue = () => <div className="border-[hsl(210,100%,50%)]" />; // @flag

package/lint/__fixtures__/no-arbitrary-color/good.tsx

@@ -0,0 +1,4 @@
+export const CssVariableShorthand = () => <div className="bg-[--brand]" />; // @ok
+export const CssVariableFunction = () => <div className="text-[var(--fg)]" />; // @ok
+export const ArbitrarySizeNotColor = () => <div className="min-h-[300px] w-[42ch]" />; // @ok
+export const SemanticToken = () => <div className="bg-primary" />; // @ok

package/lint/__fixtures__/no-async-component-in-ui/bad.tsx

@@ -0,0 +1,4 @@
+export const Card = async () => <div className="flex" />; // @flag
+export const Typed: FC = async () => <div className="flex" />; // @flag
+export async function Panel() { return <div className="flex" />; } // @flag
+export default async function Shell() { return <div className="flex" />; } // @flag

package/lint/__fixtures__/no-async-component-in-ui/good.tsx

@@ -0,0 +1,4 @@
+export const Card = () => <div className="flex" />; // @ok
+export const Handler = () => { const onSave = async () => save(); return <button onClick={onSave} />; }; // @ok
+export const loadThing = async () => await fetchThing(); // @ok
+export function Panel() { return <div className="flex" />; } // @ok

package/lint/__fixtures__/no-bang-comment-in-client/bad.tsx

@@ -0,0 +1,4 @@
+export const a = 1;
+//! FIXME: this marker survives minification and ships to every visitor
+/*! and so does the block form */
+export const b = 2;

package/lint/__fixtures__/no-bang-comment-in-client/fixture.json

@@ -0,0 +1 @@
+{ "expect": "file" }

package/lint/__fixtures__/no-bang-comment-in-client/good.tsx

@@ -0,0 +1,3 @@
+// FIXME: the client-reachable spelling of the same note // @ok
+export const url = "https://host//!path"; // @ok
+export const a = 1; // @ok

package/lint/__fixtures__/no-daisyui-legacy-class/bad.tsx

@@ -0,0 +1,7 @@
+export const CompoundButton = () => <button className="btn-primary" />; // @flag
+export const CompoundBadge = () => <span className="badge-success" />; // @flag
+export const DroppedBaseSurface = () => <div className="bg-base-100" />; // @flag
+export const DroppedBaseContentWithOpacity = () => <div className="text-base-content/70" />; // @flag
+export const DroppedBaseOnABorderSide = () => <div className="border-t-base-300" />; // @flag
+export const DroppedPrimaryContent = () => <div className="text-primary-content" />; // @flag
+export const DroppedErrorSlot = () => <div className="bg-error/5" />; // @flag

package/lint/__fixtures__/no-daisyui-legacy-class/good.tsx

@@ -0,0 +1,5 @@
+export const BareAmbiguousNamesCollideWithTailwind = () => <div className="card input badge btn" />; // @ok
+export const SurvivingSemanticPair = () => <div className="bg-primary text-primary-foreground" />; // @ok
+export const SurvivingStatusTokens = () => <div className="bg-neutral text-info border-warning" />; // @ok
+export const DestructiveReplacesError = () => <div className="bg-destructive/10 text-destructive" />; // @ok
+export const UnrelatedContentUtilities = () => <div className="content-center justify-content" />; // @ok

package/lint/__fixtures__/no-deep-internal-import/bad.tsx

@@ -0,0 +1,3 @@
+import { userConstant } from "@libs/shared/lib/user/user.constant"; // @flag
+import { helper } from "../../common/helper"; // @flag
+import * as cnst from "../cnst"; // @flag

package/lint/__fixtures__/no-deep-internal-import/fixture.json

@@ -0,0 +1 @@
+{ "path": "apps/demo/lib/task/Task.Zone.tsx" }

package/lint/__fixtures__/no-deep-internal-import/good.tsx

@@ -0,0 +1,3 @@
+import { cnst, st } from "@apps/demo/client"; // @ok
+import { Task } from "./task.constant"; // @ok
+import { env } from "@apps/demo/env/env.client"; // @ok

package/lint/__fixtures__/no-deprecated-log-level/bad.tsx

@@ -0,0 +1,4 @@
+export const viaLocal = () => logger.log("x"); // @flag
+export const viaStatic = () => Logger.log("x"); // @flag
+export class ViaField { run() { this.logger.log("x"); } } // @flag
+export class ViaPrivateField { run() { this.#logger.log("x"); } } // @flag

package/lint/__fixtures__/no-deprecated-log-level/good.tsx

@@ -0,0 +1,4 @@
+export const infoIsTheReplacement = () => logger.info("x"); // @ok
+export const otherLevelsAreFine = () => logger.warn("x"); // @ok
+export const anUnrelatedReceiverIsNotTheLadder = () => auditTrail.log("x"); // @ok
+export const consoleIsBiomesOwnRule = () => console.log("x"); // @ok

package/lint/__fixtures__/no-import-client-functions/bad.tsx

@@ -0,0 +1,2 @@
+import { useState } from "react"; // @flag
+import { st } from "../st"; // @flag

package/lint/__fixtures__/no-import-client-functions/good.tsx

@@ -0,0 +1,4 @@
+import type { ReactNode } from "react"; // @ok
+import { cnst } from "@libs/shared/client"; // @ok
+import { usePage } from "akanjs/client"; // @ok
+export const Card = ({ children }: { children: ReactNode }) => <div>{children}</div>; // @ok

package/lint/__fixtures__/no-import-client-in-server/bad.tsx

@@ -0,0 +1,6 @@
+import { TaskStore } from "./task.store"; // @flag
+import { Card } from "./Task.Unit"; // @flag
+import { Button } from "@libs/shared/ui"; // @flag
+import { useSpeech } from "@libs/util/webkit"; // @flag
+import { cn } from "akanjs/client"; // @flag
+import { st } from "../st"; // @flag

package/lint/__fixtures__/no-import-client-in-server/good.tsx

@@ -0,0 +1,5 @@
+import type { TaskStore } from "./task.store"; // @ok
+import * as cnst from "../cnst"; // @ok
+import * as db from "../db"; // @ok
+import { Err } from "../dict"; // @ok
+import { Admin } from "@libs/shared/srvkit"; // @ok

package/lint/__fixtures__/no-import-external-library/bad.tsx

@@ -0,0 +1,4 @@
+import dayjs from "dayjs"; // @flag
+import { z } from "zod"; // @flag
+import fs from "node:fs"; // @flag
+import { clsx } from "clsx"; // @flag

package/lint/__fixtures__/no-import-external-library/good.tsx

@@ -0,0 +1,5 @@
+import { Ticket } from "./ticket.constant"; // @ok
+import { cnst } from "@libs/shared/client"; // @ok
+import { field } from "akanjs/constant"; // @ok
+import { useState } from "react"; // @ok
+import { test } from "bun:test"; // @ok

package/lint/__fixtures__/no-import-server-in-client/bad.tsx

@@ -0,0 +1,6 @@
+import { TaskService } from "./task.service"; // @flag
+import { TaskModel } from "./task.document"; // @flag
+import { Admin } from "@libs/shared/srvkit"; // @flag
+import { AkanServer } from "akanjs/server"; // @flag
+import * as db from "../db"; // @flag
+import { Err } from "../dict"; // @flag

package/lint/__fixtures__/no-import-server-in-client/good.tsx

@@ -0,0 +1,4 @@
+import type { TaskService } from "./task.service"; // @ok
+import * as cnst from "../cnst"; // @ok
+import { st } from "../st"; // @ok
+import { Err, Task } from "@libs/shared/client"; // @ok

package/lint/__fixtures__/no-init-fetch-in-client/store-file/bad.ts

@@ -0,0 +1 @@
+export class TaskStore { async reload(orgId: string) { const snapshot = await fetch.initTaskInOrg(orgId); } } // @flag

package/lint/__fixtures__/no-init-fetch-in-client/store-file/fixture.json

@@ -0,0 +1 @@
+{ "path": "apps/demo/lib/task/task.store.ts" }

package/lint/__fixtures__/no-init-fetch-in-client/store-file/good.ts

@@ -0,0 +1 @@
+export class TaskStore { async reload() { await st.do.initTaskInOrg(); } } // @ok

package/lint/__fixtures__/no-init-fetch-in-client/use-client/bad.tsx

@@ -0,0 +1,4 @@
+"use client";
+
+export const A = () => { void fetch.initTaskInOrg(orgId); }; // @flag
+export const B = () => { void fetch.getTaskInitInOrg(orgId); }; // @flag

package/lint/__fixtures__/no-init-fetch-in-client/use-client/good.tsx

@@ -0,0 +1,5 @@
+"use client";
+
+export const C = () => { void fetch.initPayment(sessionId); }; // @ok
+export const D = () => { void st.do.initTaskInOrg(); }; // @ok
+export const E = () => { void fetch.viewTask(taskId); }; // @ok

package/lint/__fixtures__/no-inline-color/bad.tsx

@@ -0,0 +1,3 @@
+export const HexInStyleObject = () => <div style={{ color: "#fff" }} />; // @flag
+export const RgbInStyleObject = () => <div style={{ background: "rgb(0,0,0)" }} />; // @flag
+export const ColorLiteralInStyleTag = () => <style>{`.x { color: #abcdef; }`}</style>; // @flag

package/lint/__fixtures__/no-inline-color/good.tsx

@@ -0,0 +1,3 @@
+export const VarReferenceInStyleObject = () => <div style={{ color: "var(--primary)" }} />; // @ok
+export const NonColorStyleProperty = () => <div style={{ width: "100%" }} />; // @ok
+export const ComputedNonColorStyle = () => <div style={{ minHeight }} />; // @ok

package/lint/__fixtures__/no-interpolated-arbitrary-class/bad.tsx

@@ -0,0 +1,3 @@
+export const SizeFromRuntimeExpression = () => <div className={`min-h-[${minHeight}px] flex`} />; // @flag
+export const ColorFromRuntimeExpression = () => <div className={`bg-[${color}] w-full`} />; // @flag
+export const BrokenBracketSwallowsNextClass = () => <div className={`min-h-[ w-full${minHeight}px] flex`} />; // @flag

package/lint/__fixtures__/no-interpolated-arbitrary-class/good.tsx

@@ -0,0 +1,3 @@
+export const LiteralArbitraryValue = () => <div className="min-h-[300px] flex" />; // @ok
+export const InterpolationOutsideBrackets = () => <div className={`flex gap-2 ${isOpen ? "opacity-50" : ""}`} />; // @ok
+export const InterpolationInStylePropNotClass = () => <div style={{ minHeight }} className={`flex ${extra}`} />; // @ok

package/lint/__fixtures__/no-js-private-class-method/bad.tsx

@@ -0,0 +1,3 @@
+export class SyncPrivate { #compute() { return 1; } } // @flag
+export class AsyncPrivate { async #load() { return 1; } } // @flag
+export class CallsPrivate { run() { this.#compute(); } } // @flag