@akanjs/devkit 3.1.0-rc.2 → 3.1.0-rc.21

package/frontendBuild/hmrWatcher.ts

@@ -197,7 +197,7 @@ export class HmrWatcher {
     const gaps = this.#index.coverageGaps;
     const key = gaps
       .map((gap) => `${gap.code}:${gap.path}`)
-      .sort()
+      .sort((a, b) => (a < b ? -1 : a > b ? 1 : 0))
       .join("|");
     if (key === this.#reportedGaps) return;
     this.#reportedGaps = key;

package/frontendBuild/pagesBundleBuilder.test.ts

@@ -0,0 +1,98 @@
+import { describe, expect, test } from "bun:test";
+import { PagesBundleBuilder } from "./pagesBundleBuilder";
+
+const macroImport = `import { getSerializedSignal } from "./sig" with { type: "macro" };`;
+const macroFetchProto =
+  "const fetchProto = FetchClient.build<typeof signal>(cnst, getSerializedSignal(), { Err: pageProto.Err });";
+const serverImport = `import { fetch as serverFetch } from "./sig";`;
+const serverFetchProto =
+  "const fetchProto = FetchClient.build<typeof signal>(cnst, serverFetch.serializedSignal, { Err: pageProto.Err, base: serverFetch });";
+
+const generatedUseClient = (lines: { importLine?: string; fetchProtoLine?: string } = {}) =>
+  [
+    'import { makePageProto, registerClientRuntime } from "akanjs/client";',
+    'import { FetchClient } from "akanjs/fetch";',
+    'import * as cnst from "./cnst";',
+    'import type * as dict from "./dict";',
+    lines.importLine ?? macroImport,
+    'import type * as signal from "./sig";',
+    "",
+    "// dict.ts is cumulative, so a lib dictionary is a subset of the mounting app's. Translator state is global,",
+    "const dictionary = {};",
+    "const pageProto = makePageProto<typeof dict>(dictionary);",
+    lines.fetchProtoLine ?? macroFetchProto,
+    'export const runtime = registerClientRuntime({ ...pageProto, ...fetchProto }, { scope: "lib" });',
+    "",
+    "export const { msg, Err, usePage, sig, fetch } = runtime;",
+    "",
+  ].join("\n");
+
+const transform = (source: string) => PagesBundleBuilder.transformServerUseClientFetchSource(source);
+
+describe("PagesBundleBuilder.transformServerUseClientFetchSource", () => {
+  test("swaps the signal macro for the live server fetch in the generated useClient.ts", () => {
+    expect(transform(generatedUseClient())).toBe(
+      generatedUseClient({ importLine: serverImport, fetchProtoLine: serverFetchProto }),
+    );
+  });
+
+  test("accepts the spacing and quoting variants the regex-based version accepted", () => {
+    const source = generatedUseClient({
+      importLine: `import   {getSerializedSignal}   from './sig'   with {type : 'macro'};`,
+      fetchProtoLine: [
+        "const fetchProto=FetchClient.build<typeof signal>(",
+        "  cnst,",
+        "  getSerializedSignal(),",
+        "  { Err: pageProto.Err },",
+        ");",
+      ].join("\n"),
+    }).replace("import type * as dict", `import { x } from "./x" with { type: "macro" };\nimport type * as dict`);
+    const transformed = transform(source);
+    expect(transformed).toContain(`\n${serverImport}\n`);
+    expect(transformed).toContain(`\n${serverFetchProto}\nexport const runtime`);
+    expect(transformed).not.toContain("getSerializedSignal");
+  });
+
+  test("keeps an export modifier in front of the rewritten declaration", () => {
+    const transformed = transform(generatedUseClient({ fetchProtoLine: `export ${macroFetchProto}` }));
+    expect(transformed).toContain(`\nexport ${serverFetchProto}\n`);
+  });
+
+  test("leaves comments and strings that spell the statements alone", () => {
+    const source = generatedUseClient().replace(
+      "const dictionary = {};",
+      `// ${macroFetchProto}\nconst note = "${macroImport.replaceAll('"', "'")}";\nconst dictionary = {};`,
+    );
+    const transformed = transform(source);
+    expect(transformed).toContain(`// ${macroFetchProto}\n`);
+    expect(transformed).toContain(`const note = "${macroImport.replaceAll('"', "'")}";`);
+    expect(transformed).toContain(`\n${serverImport}\n`);
+    expect(transformed).toContain(`\n${serverFetchProto}\n`);
+  });
+
+  test("returns sources it does not recognise unchanged", () => {
+    const transformed = generatedUseClient({ importLine: serverImport, fetchProtoLine: serverFetchProto });
+    expect(transform(transformed)).toBe(transformed);
+    const typeOnly = generatedUseClient({ importLine: macroImport.replace("import {", "import type {") });
+    expect(transform(typeOnly)).toContain(`import type { getSerializedSignal } from "./sig" with { type: "macro" };`);
+    const aliased = generatedUseClient({
+      importLine: macroImport.replace("getSerializedSignal", "getSerializedSignal as g"),
+    });
+    expect(transform(aliased)).toContain(`import { getSerializedSignal as g } from "./sig" with { type: "macro" };`);
+    const withoutMacro = 'import { x } from "./y";\n';
+    expect(transform(withoutMacro)).toBe(withoutMacro);
+  });
+
+  test("adversarial input finishes well under a second", () => {
+    const marker = `${macroImport}\nFetchClient.build\n`;
+    for (const source of [
+      marker + "const fetchProto=FetchClient.build<".repeat(100_000),
+      marker + `import { getSerializedSignal } from "./sig" with { type: `.repeat(100_000),
+      marker + "{".repeat(100_000),
+    ]) {
+      const started = performance.now();
+      transform(source);
+      expect(performance.now() - started).toBeLessThan(1000);
+    }
+  });
+});

package/frontendBuild/pagesBundleBuilder.ts

@@ -1,6 +1,7 @@
 import fs from "node:fs";
 import path from "node:path";
 import type { BunPlugin } from "bun";
+import ts from "typescript";
 import type { PageEntry } from "../artifact/implicitRootLayout";
 import { resolveSsrPageEntriesForApp } from "../artifact/implicitRootLayout";
 import type { App } from "../commandDecorators";
@@ -25,6 +26,12 @@ export interface BuildPagesBundleResult {
   chunkCount: number;
 }
 
+interface TextSpan {
+  start: number;
+  end: number;
+  text: string;
+}
+
 const VIRTUAL_PAGES_ENTRY = "akan-pages-entry";
 
 export class PagesBundleBuilder {
@@ -174,14 +181,62 @@ export class PagesBundleBuilder {
 
   static transformServerUseClientFetchSource(source: string): string {
     if (!source.includes(`with { type: "macro" }`) || !source.includes("FetchClient.build")) return source;
-    return source
-      .replace(
-        /import\s+\{\s*getSerializedSignal\s*\}\s+from\s+["']\.\/sig["']\s+with\s+\{\s*type\s*:\s*["']macro["']\s*\};/,
-        `import { fetch as serverFetch } from "./sig";`,
-      )
-      .replace(
-        /const\s+fetchProto\s*=\s*FetchClient\.build<[^;]+;/,
-        "const fetchProto = FetchClient.build<typeof signal>(cnst, serverFetch.serializedSignal, { Err: pageProto.Err, base: serverFetch });",
-      );
+    const tokens = PagesBundleBuilder.#tokenize(source);
+    const edits: TextSpan[] = [];
+    const importAt = PagesBundleBuilder.#indexOfTokens(tokens, PagesBundleBuilder.#macroImportTokens);
+    if (importAt !== -1)
+      edits.push({
+        start: tokens[importAt].start,
+        end: tokens[importAt + PagesBundleBuilder.#macroImportTokens.length - 1].end,
+        text: `import { fetch as serverFetch } from "./sig";`,
+      });
+    const fetchProtoAt = PagesBundleBuilder.#indexOfTokens(tokens, PagesBundleBuilder.#fetchProtoTokens);
+    const fetchProtoEnd = fetchProtoAt === -1 ? undefined : tokens.slice(fetchProtoAt).find(({ text }) => text === ";");
+    if (fetchProtoEnd)
+      edits.push({
+        start: tokens[fetchProtoAt].start,
+        end: fetchProtoEnd.end,
+        text: "const fetchProto = FetchClient.build<typeof signal>(cnst, serverFetch.serializedSignal, { Err: pageProto.Err, base: serverFetch });",
+      });
+    let transformed = source;
+    for (const { start, end, text } of edits.sort((a, b) => b.start - a.start))
+      transformed = transformed.slice(0, start) + text + transformed.slice(end);
+    return transformed;
+  }
+
+  static readonly #macroImportTokens = [
+    "import",
+    "{",
+    "getSerializedSignal",
+    "}",
+    "from",
+    '"./sig"',
+    "with",
+    "{",
+    "type",
+    ":",
+    '"macro"',
+    "}",
+    ";",
+  ] as const;
+  static readonly #fetchProtoTokens = ["const", "fetchProto", "=", "FetchClient", ".", "build", "<"] as const;
+
+  //? The scanner, not the parser: parsing recurses per nesting level and overflows the stack on a deep `{` run.
+  static #tokenize(source: string): TextSpan[] {
+    const scanner = ts.createScanner(ts.ScriptTarget.Latest, true, ts.LanguageVariant.Standard, source);
+    const tokens: TextSpan[] = [];
+    for (let kind = scanner.scan(); kind !== ts.SyntaxKind.EndOfFileToken; kind = scanner.scan()) {
+      const text =
+        kind === ts.SyntaxKind.StringLiteral ? JSON.stringify(scanner.getTokenValue()) : scanner.getTokenText();
+      tokens.push({ text, start: scanner.getTokenStart(), end: scanner.getTokenEnd() });
+    }
+    return tokens;
+  }
+
+  static #indexOfTokens(tokens: TextSpan[], pattern: readonly string[]): number {
+    for (let idx = 0; idx + pattern.length <= tokens.length; idx += 1) {
+      if (pattern.every((text, offset) => tokens[idx + offset].text === text)) return idx;
+    }
+    return -1;
   }
 }

package/frontendBuild/routeClientBuilder.ts

@@ -244,7 +244,7 @@ export class RouteClientBuilder {
   //? a probe export and only the ones the parser reports as exports are declarations.
   static #declaredNamedDefaultFunctions(source: string, filePath?: string) {
     const candidates = [
-      ...source.matchAll(/(^|\n)(\s*)export\s+default\s+(async\s+)?function\s+([A-Za-z_$][\w$]*)(?=\s*(?:<|\())/g),
+      ...source.matchAll(/(^|\n)([^\S\n]*)export\s+default\s+(async\s+)?function\s+([A-Za-z_$][\w$]*)(?=\s*(?:<|\())/g),
     ].map((match) => ({
       index: match.index,
       text: match[0],

package/frontendBuild/sourceMtimeIndex.test.ts

@@ -50,7 +50,7 @@ describe("SourceMtimeIndex", () => {
 
     for (const [i, abs] of files.entries()) await rewrite(abs, `${i}00`);
 
-    expect((await index.collectChanges()).sort()).toEqual([...files].sort());
+    expect((await index.collectChanges()).sort((a, b) => (a < b ? -1 : a > b ? 1 : 0))).toEqual([...files].sort());
   });
 
   test("reports a change once, then stops reporting it", async () => {

package/frontendBuild/themeValidator.test.ts

@@ -37,6 +37,67 @@ describe("ThemeValidator.parseThemeTokens", () => {
     const tokens = ThemeValidator.parseThemeTokens(css);
     expect(Object.keys(tokens)).toEqual([":root"]);
   });
+
+  test("reads every block, not every other one", () => {
+    const css = `.a {} :root { --background: #fff; } .b {} [data-theme='light'] { --background: #eee; } [data-theme="dark"] { --background: #111; }`;
+    expect(ThemeValidator.parseThemeTokens(css)).toEqual({
+      ":root": { background: "#fff" },
+      '[data-theme="light"]': { background: "#eee" },
+      '[data-theme="dark"]': { background: "#111" },
+    });
+  });
+
+  test("reads the first block after @source and @import lines", () => {
+    const css = [
+      `@source "./**/*";`,
+      `@import "tailwindcss";`,
+      `@plugin "tailwind-scrollbar";`,
+      `:root { --background: #ffffff; --foreground: #0a0a0a; }`,
+      `[data-theme="dark"] { --background: #0a0a0a; --foreground: #fafafa; }`,
+      `[data-theme="light"] { --background: #fafafa; --foreground: #171717; }`,
+    ].join("\n");
+    expect(Object.keys(ThemeValidator.parseThemeTokens(css))).toEqual([
+      ":root",
+      '[data-theme="dark"]',
+      '[data-theme="light"]',
+    ]);
+  });
+
+  test("keeps a block's own declarations, skipping comments and nested rules", () => {
+    const css = `:root { /* --background: #000; */ --background: #fff; .x { --foreground: #000; } --foreground: #111 }`;
+    expect(ThemeValidator.parseThemeTokens(css)).toEqual({ ":root": { background: "#fff", foreground: "#111" } });
+  });
+
+  test("merges a scope declared twice, the later value winning", () => {
+    const css = `:root { --background: #fff; --foreground: #000; } :root { --foreground: #111; }`;
+    expect(ThemeValidator.parseThemeTokens(css)).toEqual({ ":root": { background: "#fff", foreground: "#111" } });
+  });
+
+  test("reads through @layer and keys a conditional scope by its condition", () => {
+    const css = [
+      `@layer base { :root { --background: #fff; --foreground: #000; } }`,
+      `@media (prefers-color-scheme: dark) { :root { --background: #000; } }`,
+    ].join("\n");
+    expect(ThemeValidator.parseThemeTokens(css)).toEqual({
+      ":root": { background: "#fff", foreground: "#000" },
+      "@media (prefers-color-scheme: dark) :root": { background: "#000" },
+    });
+  });
+
+  test("adversarial input finishes well under a second", () => {
+    for (const css of [
+      " ".repeat(100_000),
+      `}${" ".repeat(100_000)}`,
+      `:root{${"--".repeat(100_000)}`,
+      `:root{---:${" ".repeat(100_000)}`,
+      ":root{--background:#fff}".repeat(100_000),
+      `${"@media x{".repeat(100_000)}:root{--background:#fff}`,
+    ]) {
+      const started = performance.now();
+      ThemeValidator.parseThemeTokens(css);
+      expect(performance.now() - started).toBeLessThan(1000);
+    }
+  });
 });
 
 describe("ThemeValidator.validate", () => {
@@ -58,12 +119,32 @@ describe("ThemeValidator.validate", () => {
     const css = `:root { --primary: var(--brand); --primary-foreground: #000000; }`;
     expect(validator.validate(css)).toHaveLength(0);
   });
+
+  test("checks a conditional scope over the scope it overrides", () => {
+    const css = [
+      `:root { --background: #ffffff; --foreground: #000000; }`,
+      `@media (prefers-color-scheme: dark) { :root { --background: #111111; } }`,
+    ].join("\n");
+    const violations = validator.validate(css);
+    expect(violations.map(({ scope, pair }) => [scope, pair])).toEqual([
+      ["@media (prefers-color-scheme: dark) :root", "background / foreground"],
+    ]);
+  });
 });
 
 describe("shipped framework palette", () => {
+  const css = readFileSync(path.resolve(import.meta.dir, "../../../akanjs/ui/styles.css"), "utf8");
+
+  test("pkgs/akanjs/ui/styles.css parses :root, dark and light", () => {
+    const tokens = ThemeValidator.parseThemeTokens(css);
+    expect(Object.keys(tokens)).toEqual([":root", '[data-theme="dark"]', '[data-theme="light"]']);
+    expect(tokens[":root"].background).toBe("#0a0a0a");
+    expect(tokens['[data-theme="dark"]'].background).toBe("#0a0a0a");
+    expect(tokens['[data-theme="light"]'].background).toBe("#ffffff");
+    for (const scopeTokens of Object.values(tokens)) expect(Object.keys(scopeTokens).length).toBeGreaterThanOrEqual(26);
+  });
+
   test("pkgs/akanjs/ui/styles.css passes WCAG contrast for all scopes", () => {
-    const stylesPath = path.resolve(import.meta.dir, "../../../akanjs/ui/styles.css");
-    const css = readFileSync(stylesPath, "utf8");
     const violations = validator.validate(css);
     expect(violations).toEqual([]);
   });

package/frontendBuild/themeValidator.ts

@@ -1,4 +1,5 @@
 // No akanjs runtime import: this runs inside the lint path.
+import { type CssBlock, CssBlockParser } from "./cssBlockParser";
 
 export interface ThemeContrastViolation {
   scope: string;
@@ -34,6 +35,7 @@ const PAIRS: PairDef[] = [
 ];
 
 const THEME_SCOPES = new Set([":root", '[data-theme="dark"]', '[data-theme="light"]']);
+const CONDITIONAL_AT_RULES = new Set(["@media", "@supports", "@container"]);
 
 export type ThemeTokensByScope = Record<string, Record<string, string>>;
 
@@ -42,8 +44,9 @@ export class ThemeValidator {
     const tokensByScope = ThemeValidator.parseThemeTokens(css);
     const violations: ThemeContrastViolation[] = [];
     for (const [scope, tokens] of Object.entries(tokensByScope)) {
-      if (!THEME_SCOPES.has(scope)) continue;
-      violations.push(...this.validateScope(tokens, scope));
+      const underlying = THEME_SCOPES.has(scope) ? null : [...THEME_SCOPES].find((name) => scope.endsWith(` ${name}`));
+      const effective = underlying ? ThemeValidator.#overlayPairs(tokensByScope[underlying] ?? {}, tokens) : tokens;
+      violations.push(...this.validateScope(effective, scope));
     }
     return violations;
   }
@@ -75,23 +78,42 @@ export class ThemeValidator {
   /** A scope declared twice keeps the later value, so pass the framework css before the app's. */
   static parseThemeTokens(css: string): ThemeTokensByScope {
     const result: ThemeTokensByScope = {};
-    const blockRe = /(?:^|})\s*([^{}@]+?)\s*\{([^{}]*)\}/g;
-    for (const block of css.matchAll(blockRe)) {
-      const selectors = block[1].split(",").map((s) => s.trim());
-      const relevant = selectors.filter((s) => THEME_SCOPES.has(ThemeValidator.#normalizeScope(s)));
-      if (relevant.length === 0) continue;
-      const decls: Record<string, string> = {};
-      for (const decl of block[2].matchAll(/--([\w-]+)\s*:\s*([^;]+?)\s*(?:;|$)/g)) {
-        decls[decl[1]] = decl[2].trim();
+    CssBlockParser.walk(CssBlockParser.parse(css), "", (node, condition) => {
+      if (node.kind !== "block") return null;
+      if (node.atRule === "@layer") return condition;
+      if (node.atRule) return CONDITIONAL_AT_RULES.has(node.atRule) ? node.prelude.replace(/\s+/g, " ") : null;
+      const scopes = node.prelude
+        .split(",")
+        .map((selector) => ThemeValidator.#normalizeScope(selector))
+        .filter((scope) => THEME_SCOPES.has(scope));
+      if (scopes.length === 0) return null;
+      const tokens = ThemeValidator.#customProperties(node);
+      for (const scope of scopes) {
+        const key = condition ? `${condition} ${scope}` : scope;
+        result[key] = Object.assign(result[key] ?? {}, tokens);
       }
-      for (const selector of relevant) {
-        const scope = ThemeValidator.#normalizeScope(selector);
-        result[scope] = { ...(result[scope] ?? {}), ...decls };
-      }
-    }
+      return null;
+    });
     return result;
   }
 
+  static #customProperties(block: CssBlock): Record<string, string> {
+    const tokens: Record<string, string> = {};
+    for (const node of block.nodes) {
+      if (node.kind === "declaration" && node.property.startsWith("--")) tokens[node.property.slice(2)] = node.value;
+    }
+    return tokens;
+  }
+
+  static #overlayPairs(underlying: Record<string, string>, tokens: Record<string, string>): Record<string, string> {
+    const effective: Record<string, string> = {};
+    for (const name of PAIRS.flatMap(({ base, fg }) => [base, fg])) {
+      const value = tokens[name] ?? underlying[name];
+      if (value) effective[name] = value;
+    }
+    return effective;
+  }
+
   static #normalizeScope(selector: string): string {
     return selector.replace(/\[data-theme=['"]?([\w-]+)['"]?\]/g, '[data-theme="$1"]').trim();
   }

package/getRelatedCnsts.ts

@@ -1,4 +1,5 @@
 import { readFileSync, realpathSync } from "node:fs";
+import { dirname } from "node:path";
 import ora from "ora";
 import * as ts from "typescript";
 
@@ -45,7 +46,7 @@ export const parseTsConfig = (tsConfigPath: string = "./tsconfig.json") => {
     return ts.sys.readFile(path);
   });
 
-  return ts.parseJsonConfigFileContent(configFile.config, ts.sys, realpathSync(tsConfigPath).replace(/[^/\\]+$/, ""));
+  return ts.parseJsonConfigFileContent(configFile.config, ts.sys, dirname(realpathSync(tsConfigPath)));
 };
 
 const collectFiles = (constantFilePath: string, parsedConfig: ts.ParsedCommandLine, includeExports: boolean) => {

package/integration/devStabilityHarness.ts

@@ -772,9 +772,11 @@ export const dictionary = serviceDictionary(["en", "ko"])
   }
 
   static async #psRowsOrThrow(): Promise<Array<{ pid: number; ppid: number; rssKb: number; cmd: string }>> {
-    const rows = (await DevStabilityHarness.#psRows()) ?? (await DevStabilityHarness.#psRows());
-    if (!rows) throw new Error("ps did not answer twice in a row; cannot measure the process tree");
-    return rows;
+    for (let attempt = 0; attempt < 2; attempt += 1) {
+      const rows = await DevStabilityHarness.#psRows();
+      if (rows) return rows;
+    }
+    throw new Error("ps did not answer twice in a row; cannot measure the process tree");
   }
 
   static #collectDescendants(rows: Array<{ pid: number; ppid: number }>, rootPid: number): Set<number> {

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

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

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

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

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

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

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

@@ -2,3 +2,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
+export { cnst, usePage };

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

@@ -4,3 +4,4 @@ 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
+export { Button, Card, cn, st, TaskStore, useSpeech };

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

@@ -3,3 +3,4 @@ import * as cnst from "../cnst"; // @ok
 import * as db from "../db"; // @ok
 import { Err } from "../dict"; // @ok
 import { Admin } from "@libs/shared/srvkit"; // @ok
+export { Admin, cnst, db, Err };

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

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

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

@@ -3,3 +3,4 @@ import { cnst } from "@libs/shared/client"; // @ok
 import { field } from "akanjs/constant"; // @ok
 import { useState } from "react"; // @ok
 import { test } from "bun:test"; // @ok
+export { cnst, field, test, Ticket, useState };

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

@@ -4,3 +4,4 @@ import fs from "node:fs"; // @ok
 import { Database } from "bun:sqlite"; // @ok
 import { describe } from "bun:test"; // @ok
 import { cnst } from "../cnst"; // @ok
+export { cnst, Database, dayjs, describe, fs, z };

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

@@ -4,3 +4,4 @@ import { tmpdir } from "node:os"; // @ok
 import { Database } from "bun:sqlite"; // @ok
 import { describe, expect, test } from "bun:test"; // @ok
 import { fetch } from "../sig"; // @ok
+export { createServer, Database, describe, expect, fetch, mkdtemp, test, tmpdir };

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

@@ -4,3 +4,4 @@ import { Admin } from "@libs/shared/srvkit"; // @flag
 import { AkanServer } from "akanjs/server"; // @flag
 import * as db from "../db"; // @flag
 import { Err } from "../dict"; // @flag
+export { AkanServer, Admin, db, Err, TaskModel, TaskService };

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

@@ -2,3 +2,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
+export { cnst, Err, st, Task };

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

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

package/lint/__fixtures__/no-static-in-object-light-model/bad.ts

@@ -1,4 +1,4 @@
-import { enumOf, ID, Int } from "akanjs/base";
+import { ID, Int } from "akanjs/base";
 import { via } from "akanjs/constant";
 
 export class QuizInput extends via((field) => ({
@@ -12,7 +12,7 @@ export class QuizObject extends via(QuizInput, (field) => ({
   static readonly minNum = 1; // @flag
   private static secretNum = 2; // @flag
   static { // @flag
-    QuizObject.maxNum = 5;
+    QuizObject.maxNum += 1;
   }
 }
 

package/mobile/mobileTarget.ts

@@ -1,4 +1,5 @@
 import type { AkanNativeAppId } from "akanjs";
+import { trimSlashes } from "akanjs/common";
 import type { AkanAppConfig, AkanNativeTarget, NativeEnv } from "../akanConfig";
 import type { App } from "../commandDecorators";
 
@@ -14,8 +15,6 @@ export interface ResolvedMobileTarget {
 
 export const MOBILE_ENVS = ["local", "debug", "develop", "main"] as const satisfies readonly NativeEnv[];
 
-const trimSlashes = (value: string) => value.replace(/^\/+|\/+$/g, "");
-
 export const getMobileTargets = async (app: App): Promise<ResolvedMobileTarget[]> => {
   const config = await app.getConfig();
   return Object.entries(config.native.targets).map(([name, target]) => ({ name, config: target }));

package/mobile/nativeApp.test.ts

@@ -151,7 +151,7 @@ describe("NativeApp", () => {
 
   describe("the public env a build inlined, recorded in its bundle.json", () => {
     const publicEnv = { AKAN_PUBLIC_ENV: "main", AKAN_PUBLIC_SERVE_DOMAIN: "akamir.com" };
-    const building = async (inlined: Record<string, string>, updates: object | undefined) => {
+    const building = async (inlined: Record<string, string>, updates: AkanNativeTarget["updates"]) => {
       const root = await makeTempRoot();
       const warned: string[] = [];
       const app = {

package/mobile/nativeConfig.test.ts

@@ -489,6 +489,9 @@ describe("NativeConfig.build", () => {
     expect(NativeConfig.fileNameOf("minimal")).toBe("minimal");
     expect(NativeConfig.fileNameOf("my app!")).toBe("my-app");
     expect(NativeConfig.fileNameOf("...")).toBe("app");
+    expect(NativeConfig.fileNameOf(".-my app!-.")).toBe("my-app");
+    expect(NativeConfig.fileNameOf("-a-")).toBe("a");
+    expect(NativeConfig.fileNameOf(`a${"-".repeat(50_000)}b`)).toHaveLength(50_002);
   });
 });
 

package/mobile/nativeConfig.ts

@@ -9,6 +9,7 @@ import type {
   NativeEnv,
   NativePermission,
 } from "akanjs";
+import { trimSlashes } from "akanjs/common";
 import type { DesktopServerBundle } from "./desktopServerStage";
 import { type NativePlatform, resolveAppId } from "./mobileTarget";
 import type { NativePluginFolder } from "./nativePluginFolders";
@@ -271,7 +272,7 @@ export class NativeConfig {
 
   /** Letters, digits, `.`, `_` and `-` only; the folder name of an akan app already is one almost always. */
   static fileNameOf(name: string) {
-    return name.replace(/[^A-Za-z0-9._-]/g, "-").replace(/^[-.]+|[-.]+$/g, "") || "app";
+    return /[^-.](?:.*[^-.])?/.exec(name.replace(/[^A-Za-z0-9._-]/g, "-"))?.[0] ?? "app";
   }
 
   //? A permission names a plugin by its id, and a plugin given by folder is named in its manifest; a spec the runtime
@@ -311,7 +312,7 @@ export class NativeConfig {
 
   //* Every route sits under /:lang, so an app link limited to a basePath lists it once per locale.
   static #deepLinks(target: AkanNativeTarget, locales: readonly string[]) {
-    const basePath = target.basePath?.replace(/^\/+|\/+$/g, "");
+    const basePath = target.basePath ? trimSlashes(target.basePath) : "";
     const pathPrefixes = basePath ? locales.map((locale) => `/${locale}/${basePath}`) : undefined;
     return {
       ...(target.deepLinks?.schemes?.length ? { schemes: target.deepLinks.schemes } : {}),

package/mobile/nativeWebDir.ts

@@ -1,6 +1,7 @@
 import { cp, mkdir, rm, stat } from "node:fs/promises";
 import path from "node:path";
 import type { AkanNativeTarget } from "akanjs";
+import { trimSlashes } from "akanjs/common";
 
 export interface NativeWebDirSources {
   /** The target's CSR bundle: one HTML file with its scripts and styles inlined. */
@@ -21,13 +22,13 @@ export class NativeWebDir {
   //* it goes first in <head>, ahead of every script, because the page reads it as it boots.
   static injectTarget(html: string, target: Pick<AkanNativeTarget, "name" | "basePath" | "indexPath">) {
     if (html.includes(NativeWebDir.#targetTag)) return html;
-    const basePath = target.basePath?.replace(/^\/+|\/+$/g, "") ?? "";
+    const basePath = target.basePath ? trimSlashes(target.basePath) : "";
     const script = `${NativeWebDir.#targetTag}${JSON.stringify({
       name: target.name,
       basePath,
       indexPath: target.indexPath,
     })};</script>`;
-    const head = /<head(?:\s[^>]*)?>/i.exec(html);
+    const head = /<head(?:\s[^<>]*)?>/i.exec(html);
     if (!head) return `${script}\n${html}`;
     const at = head.index + head[0].length;
     return `${html.slice(0, at)}\n${script}${html.slice(at)}`;

package/mobile/updateUploader.test.ts

@@ -45,6 +45,7 @@ describe("UpdateUploader", () => {
       prefix: "acme/kiosk",
     });
     expect(UpdateUploader.parseTarget("s3://releases")).toEqual({ bucket: "releases", prefix: "" });
+    expect(UpdateUploader.parseTarget("s3://releases//acme//")).toEqual({ bucket: "releases", prefix: "/acme" });
     expect(() => UpdateUploader.parseTarget("https://releases.example/acme")).toThrow("s3://<bucket>/<prefix>");
   });