@akanjs/devkit 3.0.0-alpha.5 → 3.0.0-alpha.7

package/capacitorApp.test.ts

@@ -11,6 +11,7 @@ import {
   clearRootCapacitorConfigs,
   formatAndroidReleaseSigningError,
   getAdbDeviceStateIssues,
+  getAndroidLocalServerHost,
   getMissingAndroidReleaseSigningKeys,
   isPlaceholderAppId,
   materializeCapacitorConfig,
@@ -339,6 +340,13 @@ describe("Android signing diagnostics", () => {
       "Android device abc123 is unauthorized. Confirm USB debugging authorization on the device.",
       "Android device xyz is offline. Reconnect the device or restart adb.",
     ]);
+    expect(getAndroidLocalServerHost("List of devices attached\nemulator-5554 device\n", "192.168.0.5")).toBe(
+      "10.0.2.2",
+    );
+    expect(getAndroidLocalServerHost("List of devices attached\nabc123 device\n", "192.168.0.5")).toBe("192.168.0.5");
+    expect(
+      getAndroidLocalServerHost("List of devices attached\nemulator-5554 device\nabc123 device\n", "192.168.0.5"),
+    ).toBe("192.168.0.5");
   });
 });
 

package/capacitorApp.ts

@@ -24,7 +24,9 @@ interface RunIosConfig extends RunConfig {
   iosDeviceId?: string;
 }
 
-interface PrepareConfig extends RunConfig {}
+interface PrepareConfig extends RunConfig {
+  iosRunTargetKind?: IosRunTargetKind;
+}
 
 type MobileCommandEnv = Record<string, string | undefined>;
 
@@ -119,10 +121,11 @@ interface MaterializeCapacitorConfigOptions {
   localServerUrl?: string;
   localIp?: string;
 }
+type MobilePlatform = "ios" | "android";
 
 export interface LocalDevHostResolution {
   host: string;
-  source: "override" | "detected" | "loopback";
+  source: "override" | "detected" | "loopback" | "platform";
   candidates: { name: string; address: string }[];
 }
 
@@ -565,6 +568,16 @@ export function getAdbDeviceStateIssues(output: string) {
     });
 }
 
+export function getAndroidLocalServerHost(adbDevicesOutput: string | undefined, fallbackHost: string) {
+  const onlineDeviceIds =
+    adbDevicesOutput
+      ?.split(/\r?\n/)
+      .map((line) => line.trim().split(/\s+/))
+      .filter(([id, state]) => id && state === "device")
+      .map(([id]) => id) ?? [];
+  return onlineDeviceIds.length === 1 && onlineDeviceIds[0]?.startsWith("emulator-") ? "10.0.2.2" : fallbackHost;
+}
+
 export const ANDROID_MIN_SDK_VERSION = 26;
 export function raiseGradleMinSdkVersion(content: string, floor: number = ANDROID_MIN_SDK_VERSION): string | null {
   const match = content.match(/minSdkVersion\s*=\s*(\d+)/);
@@ -748,7 +761,7 @@ export class CapacitorApp {
   async save() {
     await this.project.commit();
   }
-  async #prepareIos({ operation, env, regenerate = false }: PrepareConfig) {
+  async #prepareIos({ operation, env, regenerate = false, iosRunTargetKind }: PrepareConfig) {
     await this.init({ platform: "ios", operation, env, regenerate });
     await this.#prepareTargetAssets();
     await this.#prepareExternalFiles("ios");
@@ -757,9 +770,10 @@ export class CapacitorApp {
     await this.#applyDeepLinks("ios", { operation, env });
     await this.#flushIosEntitlements();
     await this.project.commit();
+    await this.#setCodeSignEntitlementsInIosIfExists("App/App.entitlements");
     await this.#generateAssets({ operation, env });
     this.app.verbose(`syncing iOS`);
-    await this.#spawnMobile("npx", ["cap", "sync", "ios"], { operation, env });
+    await this.#spawnMobile("npx", ["cap", "sync", "ios"], { operation, env }, { iosRunTargetKind });
     this.app.verbose(`sync completed.`);
   }
   async buildIos({ env = "debug", regenerate = false }: { env?: RunConfig["env"]; regenerate?: boolean } = {}) {
@@ -777,14 +791,14 @@ export class CapacitorApp {
   }
   async runIos({ operation, env, regenerate = false, noAllowProvisioningUpdates = false, iosDeviceId }: RunIosConfig) {
     if (operation === "release") await this.prepareWww();
-    await this.#prepareIos({ operation, env, regenerate });
     const runTarget = await this.#selectIosRunTarget(iosDeviceId);
+    await this.#prepareIos({ operation, env, regenerate, iosRunTargetKind: runTarget.kind });
     if (runTarget.kind === "simulator") {
       await this.#spawnMobile(
         "npx",
-        ["cap", "run", "ios", "--target", runTarget.id],
+        ["cap", "run", "ios", "--target", runTarget.id, "--no-sync"],
         { operation, env },
-        { stdio: "inherit" },
+        { stdio: "inherit", platform: "ios", iosRunTargetKind: runTarget.kind },
       );
       return;
     }
@@ -878,7 +892,10 @@ export class CapacitorApp {
     noAllowProvisioningUpdates: boolean;
   }) {
     const mobileEnv = sanitizeIosNativeRunEnv(await this.#commandEnv(operation, env));
-    const configContent = await this.#writeCapacitorConfig({ operation }, mobileEnv);
+    const configContent = await this.#writeCapacitorConfig(
+      { operation, platform: "ios", iosRunTargetKind: runTarget.kind },
+      mobileEnv,
+    );
     await this.#writeRootCapacitorConfig(configContent);
     const scheme = this.#iosScheme();
     const command = buildIosNativeRunCommand({
@@ -943,6 +960,7 @@ export class CapacitorApp {
     await this.#applyAndroidMinSdkVersion();
     await this.#applyPermissions({ operation, env });
     await this.#applyDeepLinks("android", { operation, env });
+    await this.#disableNativeKeyboardResizeInAndroid();
     await this.project.commit();
     await this.#generateAssets({ operation, env });
     await this.#ensureAndroidAssetsDir();
@@ -1010,6 +1028,24 @@ export class CapacitorApp {
   async openAndroid() {
     await this.#spawnMobile("npx", ["cap", "open", "android"], { operation: "local", env: "local" });
   }
+  async #disableNativeKeyboardResizeInAndroid() {
+    const manifestPath = path.join(this.app.cwdPath, this.androidRootPath, "app/src/main/AndroidManifest.xml");
+    let manifest = await readFile(manifestPath, "utf8");
+    let changed = false;
+    manifest = manifest.replace(/<activity\b[^>]*android:name="\.MainActivity"[^>]*>/, (activityTag) => {
+      if (activityTag.includes("android:windowSoftInputMode=")) {
+        const nextTag = activityTag.replace(
+          /android:windowSoftInputMode="[^"]*"/,
+          'android:windowSoftInputMode="adjustNothing"',
+        );
+        changed ||= nextTag !== activityTag;
+        return nextTag;
+      }
+      changed = true;
+      return activityTag.replace(/>$/, '\n            android:windowSoftInputMode="adjustNothing">');
+    });
+    if (changed) await writeFile(manifestPath, manifest);
+  }
   async #ensureAndroidAssetsDir() {
     await mkdir(path.join(this.app.cwdPath, this.androidAssetsPath), { recursive: true });
   }
@@ -1100,12 +1136,19 @@ export class CapacitorApp {
     if (html.includes("window.__AKAN_MOBILE_TARGET__")) return html;
     return html.replace(/<\/head\s*>/i, `${script}\n</head>`);
   }
-  async #writeCapacitorConfig({ operation }: Pick<RunConfig, "operation">, commandEnv: MobileCommandEnv) {
+  async #writeCapacitorConfig(
+    {
+      operation,
+      platform,
+      iosRunTargetKind,
+    }: Pick<RunConfig, "operation"> & { platform?: MobilePlatform; iosRunTargetKind?: IosRunTargetKind },
+    commandEnv: MobileCommandEnv,
+  ) {
     await mkdir(this.targetRoot, { recursive: true });
     let localIp: string | undefined;
     if (operation === "local") {
       const override = commandEnv.AKAN_PUBLIC_CLIENT_HOST ?? process.env.AKAN_PUBLIC_CLIENT_HOST;
-      const resolution = selectLocalDevHost(os.networkInterfaces(), { override });
+      const resolution = await this.#resolveLocalDevHost({ override, platform, iosRunTargetKind });
       localIp = resolution.host;
       this.#logDevHostResolution(resolution, commandEnv);
     }
@@ -1118,11 +1161,36 @@ export class CapacitorApp {
     await Bun.write(path.join(this.targetRoot, "capacitor.config.json"), content);
     return content;
   }
+  // An explicit override always wins; an emulator/simulator run reaches the host machine through a
+  // loopback alias (10.0.2.2 / localhost), so LAN detection only applies to physical-device runs.
+  async #resolveLocalDevHost({
+    override,
+    platform,
+    iosRunTargetKind,
+  }: {
+    override?: string;
+    platform?: MobilePlatform;
+    iosRunTargetKind?: IosRunTargetKind;
+  }): Promise<LocalDevHostResolution> {
+    const resolution = selectLocalDevHost(os.networkInterfaces(), { override });
+    if (resolution.source === "override") return resolution;
+    if (platform === "ios" && iosRunTargetKind === "simulator")
+      return { ...resolution, host: "localhost", source: "platform" };
+    if (platform === "android") {
+      try {
+        const host = getAndroidLocalServerHost(await this.#spawn("adb", ["devices"]), resolution.host);
+        return host === resolution.host ? resolution : { ...resolution, host, source: "platform" };
+      } catch {
+        return resolution;
+      }
+    }
+    return resolution;
+  }
   // Surface the live-reload URL a physical device must reach, and warn when auto-detection landed on
   // a likely-unreachable host so a blank WebView is not mistaken for an app bug.
   #logDevHostResolution(resolution: LocalDevHostResolution, commandEnv: MobileCommandEnv) {
     this.app.log(`Mobile live-reload server: ${this.#localCsrUrl(resolution.host, commandEnv)}`);
-    if (resolution.source === "override") return;
+    if (resolution.source === "override" || resolution.source === "platform") return;
     const suspicious = resolution.host === "127.0.0.1" || resolution.host.startsWith("169.254.");
     const alternatives = resolution.candidates.filter((candidate) => candidate.address !== resolution.host);
     if (!suspicious && alternatives.length === 0) return;
@@ -1332,20 +1400,29 @@ export class CapacitorApp {
     command: string,
     args: string[] = [],
     { operation, env }: Pick<RunConfig, "operation" | "env">,
-    options: Parameters<AppExecutor["spawn"]>[2] = {},
+    options: SpawnMobileOptions = {},
   ) {
+    const { iosRunTargetKind, platform, ...spawnOptions } = options;
     const mobileEnv = { ...(await this.#commandEnv(operation, env)), ...options.env };
-    const configContent = await this.#writeCapacitorConfig({ operation }, mobileEnv);
+    const configContent = await this.#writeCapacitorConfig(
+      { operation, platform: platform ?? this.#inferMobilePlatform(args), iosRunTargetKind },
+      mobileEnv,
+    );
     await this.#writeRootCapacitorConfig(configContent);
     try {
       return await this.#spawn(command, args, {
-        ...options,
+        ...spawnOptions,
         env: mobileEnv,
       });
     } finally {
       await this.#clearRootCapacitorConfigs();
     }
   }
+  #inferMobilePlatform(args: string[]): MobilePlatform | undefined {
+    if (args.includes("android")) return "android";
+    if (args.includes("ios")) return "ios";
+    return undefined;
+  }
   async addCamera() {
     await this.#setPermissionInIos({
       cameraUsageDescription: "$(PRODUCT_NAME) requires access to the camera to take photos.",
@@ -1446,14 +1523,31 @@ export class CapacitorApp {
       let end = index;
       while (end < lines.length && !/^\s*\};\s*$/.test(lines[end] ?? "")) end++;
       const settings = lines.slice(start, end + 1);
-      if (settings.some((setting) => setting.includes("CODE_SIGN_ENTITLEMENTS"))) continue;
+      const configName = lines.slice(end + 1, end + 8).find((setting) => setting.includes("name = ")) ?? "";
       const indent = line.match(/^\s*/)?.[0] ?? "";
-      lines.splice(index, 0, `${indent}CODE_SIGN_ENTITLEMENTS = ${entitlementsRelPath};`);
-      index++;
-      changed = true;
+      const insertSettings = [];
+      if (!settings.some((setting) => setting.includes("CODE_SIGN_ENTITLEMENTS"))) {
+        insertSettings.push(`${indent}CODE_SIGN_ENTITLEMENTS = ${entitlementsRelPath};`);
+      }
+      if (
+        configName.includes("name = Debug;") &&
+        !settings.some((setting) => setting.includes("CODE_SIGN_ALLOW_ENTITLEMENTS_MODIFICATION"))
+      ) {
+        insertSettings.push(`${indent}CODE_SIGN_ALLOW_ENTITLEMENTS_MODIFICATION = YES;`);
+      }
+      if (insertSettings.length > 0) {
+        lines.splice(index, 0, ...insertSettings);
+        index += insertSettings.length;
+        changed = true;
+      }
     }
     if (changed) await writeFile(pbxprojPath, lines.join("\n"));
   }
+  async #setCodeSignEntitlementsInIosIfExists(entitlementsRelPath: string) {
+    const entitlementsPath = path.join(this.app.cwdPath, this.iosProjectPath, entitlementsRelPath);
+    if (!(await Bun.file(entitlementsPath).exists())) return;
+    await this.#setCodeSignEntitlementsInIos(entitlementsRelPath);
+  }
   async #setUrlSchemesInAndroid(schemes: string[]) {
     const manifestPath = path.join(this.app.cwdPath, this.androidRootPath, "app/src/main/AndroidManifest.xml");
     let manifest = await readFile(manifestPath, "utf8");

package/frontendBuild/cssCandidateCache.test.ts

@@ -0,0 +1,38 @@
+import { describe, expect, test } from "bun:test";
+import { mkdtemp, writeFile } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import path from "node:path";
+import { CssCandidateCache } from "./cssCandidateCache";
+
+const scan = async (source: string) => {
+  const dir = await mkdtemp(path.join(tmpdir(), "css-candidate-"));
+  const file = path.join(dir, "probe.tsx");
+  await writeFile(file, source);
+  return await new CssCandidateCache(path.join(dir, "cache.json")).load().then((c) => c.candidatesFor(file));
+};
+
+describe("CssCandidateCache token extraction", () => {
+  test("keeps plain utilities, variants and arbitrary values whole", async () => {
+    const candidates = await scan(`const c = "w-full hover:bg-muted md:w-1/2 text-[#fff]";`);
+    expect(candidates).toEqual(expect.arrayContaining(["w-full", "hover:bg-muted", "md:w-1/2", "text-[#fff]"]));
+  });
+
+  // A candidate that opens with `[` used to be torn into `_td` + `px-3`, so every descendant-variant
+  // rule in the framework compiled to nothing and its element rendered unstyled with no diagnostic.
+  test("keeps an arbitrary variant that starts with a bracket", async () => {
+    const candidates = await scan(`const c = "[&_td]:px-3 [&>*]:gap-2 [&_tbody_tr]:border-t";`);
+    expect(candidates).toEqual(expect.arrayContaining(["[&_td]:px-3", "[&>*]:gap-2", "[&_tbody_tr]:border-t"]));
+    expect(candidates).not.toContain("_td");
+  });
+
+  // A labelled tuple type looks like an arbitrary property, and compiles to a rule whose declaration is
+  // TypeScript. `optimize()` cannot parse that, and drops far more than the offending rule on its way
+  // out — every variant in the build went missing, so nothing hovered, focused or responded to a
+  // breakpoint. Tailwind writes a space in an arbitrary value as `_`, so whitespace rules the token out.
+  test("ignores a labelled tuple type that only looks like an arbitrary property", async () => {
+    const candidates = await scan(
+      `type A = [key: string, make: () => unknown][];\ntype B = [setQueryArgs: (a: Args) => Args, options?: Policy];`,
+    );
+    expect(candidates.filter((candidate) => candidate.startsWith("["))).toEqual([]);
+  });
+});

package/frontendBuild/cssCandidateCache.ts

@@ -1,7 +1,19 @@
 import { stat } from "node:fs/promises";
 
-/** Every identifier-ish token in a source file is a potential tailwind class. */
-const CANDIDATE_RE = /-?[\w@][\w:/.-]*(?:\[[^\]]+\][\w:/.-]*)*/g;
+/**
+ * Every identifier-ish token in a source file is a potential tailwind class. The leading alternation
+ * matters: an arbitrary variant starts with `[` (`[&_td]:px-3`, `[&>*]:gap-2`), and a pattern anchored
+ * on a word character tears it into `_td` plus `px-3` instead — both meaningless, so the rule compiles
+ * to nothing and the element silently renders unstyled.
+ *
+ * Brackets must hold no whitespace. Tailwind spells a space in an arbitrary value `_`, so a bracket
+ * group containing one is never a class — but it is exactly the shape of a labelled tuple type
+ * (`[key: string, make: () => unknown]`). Scanned as a candidate, that compiles to an arbitrary
+ * *property* rule carrying TypeScript as its declaration, which the lightningcss pass in `optimize()`
+ * cannot parse; its error recovery then drops a whole span of the stylesheet — in practice every
+ * variant rule in the build, leaving hover, focus, responsive and dark styles silently absent.
+ */
+const CANDIDATE_RE = /-?(?:[\w@]|\[[^\]\s]+\])[\w:/.-]*(?:\[[^\]\s]+\][\w:/.-]*)*/g;
 
 interface CachedFile {
   mtimeMs: number;
@@ -27,7 +39,7 @@ interface CacheFile {
  */
 export class CssCandidateCache {
   /** Bump when the token regex or the entry shape changes, so stale extractions are not reused. */
-  static readonly #version = 1;
+  static readonly #version = 3;
   readonly #path: string;
   readonly #entries = new Map<string, CachedFile>();
   #dirty = false;

package/lint/no-return-in-store-action.grit

@@ -0,0 +1,35 @@
+engine biome(1.0)
+language js(typescript, jsx)
+
+// Every prototype method of a `store(...)` class is registered as an action
+// (StoreRegistry.register) and reaches callers only as `st.do.<action>`, which re-wraps it
+// (StoreInstance.#extendAccessors) and is typed void by `VoidActions` in
+// pkgs/akanjs/store/types.ts. A returned value is therefore unreachable from every call
+// site — it reads like a contract while being dead code. Write the result into state with
+// `this.set({ ... })` instead.
+//
+// Deliberately not flagged, because none of these are actions: a bare `return;` guard, a
+// `return` belonging to a nested callback, a getter, a `static` helper, and a class-property
+// arrow (an instance field, so `register` never sees it).
+`return $value;` as $return where {
+  not $value <: r"",
+  $return <: within JsClassDeclaration() as $storeClass where {
+    $storeClass <: contains JsExtendsClause() as $extends where {
+      $extends <: r"extends\s+store\([\s\S]*"
+    }
+  },
+  $return <: within JsMethodClassMember() as $action where {
+    not $action <: r"static[\s\S]*"
+  },
+  not $return <: within JsArrowFunctionExpression(),
+  not $return <: within JsFunctionExpression(),
+  not $return <: within JsFunctionDeclaration(),
+  not $return <: within JsMethodObjectMember(),
+  not $return <: within JsGetterObjectMember(),
+  not $return <: within JsSetterObjectMember(),
+  register_diagnostic(
+    span = $return,
+    message = "Store actions dispatch as void — st.do.<action>() never exposes this value. Write the result into state with this.set({ ... }) and drop the returned value; a bare 'return;' guard clause is fine.",
+    severity = "error"
+  )
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@akanjs/devkit",
-  "version": "3.0.0-alpha.5",
+  "version": "3.0.0-alpha.7",
   "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.5",
+    "akanjs": "3.0.0-alpha.7",
     "chalk": "^5.6.2",
     "commander": "^14.0.3",
     "dayjs": "^1.11.20",

package/qualityScanner.ts

@@ -1,6 +1,7 @@
 import { createHash } from "node:crypto";
 import { readdir, readFile, stat } from "node:fs/promises";
 import path from "node:path";
+import { RESERVED_ROUTE_CONFIG_EXPORTS } from "akanjs/common";
 import ignore from "ignore";
 import ts from "typescript";
 import { AbstractDoc } from "./abstractDoc";
@@ -100,24 +101,6 @@ const CONVENTION_SUFFIXES = [
   ".store.ts",
 ] as const;
 
-// Non-PascalCase exports the framework recognizes on page/layout route modules (see PageModule/LayoutModule
-// in pkgs/akanjs/client/csrTypes.ts). PascalCase route exports (Loading, NotFound, Error) pass the component
-// check, and the `default` export is handled separately.
-const PAGE_RESERVED_EXPORTS = new Set([
-  "pageConfig",
-  "head",
-  "metadata",
-  "generateHead",
-  "generateMetadata",
-  "fonts",
-  "manifest",
-  "theme",
-  "reconnect",
-  "wsConnect",
-  "layoutStyle",
-  "gaTrackingId",
-]);
-
 // How to remediate each rule, keyed by rule id. Surfaced as a `fix:` line per warning (text + JSON output)
 // so the scan result tells the reader what to do, not just what is wrong.
 const RULE_FIXES: Record<string, string> = {
@@ -669,7 +652,7 @@ function isRestrictedInternalKind(kind: ComponentFileDeclaration["kind"]) {
 
 function isAllowedComponentExport(declaration: ComponentFileDeclaration, isPage: boolean) {
   if (isComponentValueKind(declaration.kind) && isPascalCaseName(declaration.name)) return true;
-  return isPage && PAGE_RESERVED_EXPORTS.has(declaration.name);
+  return isPage && RESERVED_ROUTE_CONFIG_EXPORTS.has(declaration.name);
 }
 
 function isPascalCaseName(name: string) {

package/routeSourceValidator.test.ts

@@ -0,0 +1,41 @@
+import { describe, expect, test } from "bun:test";
+
+import { RouteSourceValidator } from "./routeSourceValidator";
+
+const validate = (source: string, kind: "page" | "layout", rootLayout = false) =>
+  RouteSourceValidator.validateRouteSourceExports(source, `page/_${kind}.tsx`, kind, { rootLayout });
+
+describe("RouteSourceValidator", () => {
+  test("accepts every root-layout config export the route tree honors", () => {
+    const source = [
+      "export default function Layout() { return null; }",
+      "export const fonts = [];",
+      "export const manifest = {};",
+      'export const theme = "dark";',
+      "export const reconnect = true;",
+      "export const wsConnect = true;",
+      "export const layoutStyle = {};",
+      'export const gaTrackingId = "G-1";',
+    ].join("\n");
+
+    expect(() => validate(source, "layout", true)).not.toThrow();
+  });
+
+  test("rejects root-layout-only exports on a nested layout and on a page", () => {
+    const source = ["export default function Layout() { return null; }", "export const wsConnect = true;"].join("\n");
+
+    expect(() => validate(source, "layout")).toThrow('unsupported export "wsConnect"');
+    expect(() => validate(source, "page")).toThrow('unsupported export "wsConnect"');
+  });
+
+  test("reads devOnly off pageConfig without evaluating the module", () => {
+    const source = [
+      "export default function Page() { return null; }",
+      "export const pageConfig = { devOnly: true };",
+    ].join("\n");
+
+    expect(RouteSourceValidator.validateRouteSourceExports(source, "page/_index.tsx", "page")).toEqual({
+      devOnly: true,
+    });
+  });
+});

package/routeSourceValidator.ts

@@ -1,3 +1,4 @@
+import { getRouteExports } from "akanjs/common";
 import ts from "typescript";
 
 /** What the build needs out of a route module without evaluating it. */
@@ -16,44 +17,6 @@ export interface RouteSourceInfo {
  * validate a route source stay lean.
  */
 export class RouteSourceValidator {
-  static readonly #pageExports = new Set([
-    "default",
-    "pageConfig",
-    "head",
-    "metadata",
-    "generateHead",
-    "generateMetadata",
-    "Loading",
-  ]);
-  static readonly #rootLayoutExports = new Set([
-    "default",
-    "pageConfig",
-    "head",
-    "metadata",
-    "generateHead",
-    "generateMetadata",
-    "fonts",
-    "manifest",
-    "theme",
-    "reconnect",
-    "layoutStyle",
-    "gaTrackingId",
-    "Loading",
-    "NotFound",
-    "Error",
-  ]);
-  static readonly #layoutExports = new Set([
-    "default",
-    "pageConfig",
-    "head",
-    "metadata",
-    "generateHead",
-    "generateMetadata",
-    "Loading",
-    "NotFound",
-    "Error",
-  ]);
-
   static validateRouteSourceExports(
     source: string,
     filePath: string,
@@ -61,12 +24,7 @@ export class RouteSourceValidator {
     options: { rootLayout?: boolean } = {},
   ): RouteSourceInfo {
     const sourceFile = ts.createSourceFile(filePath, source, ts.ScriptTarget.Latest, true, ts.ScriptKind.TSX);
-    const allowed =
-      kind === "page"
-        ? RouteSourceValidator.#pageExports
-        : options.rootLayout
-          ? RouteSourceValidator.#rootLayoutExports
-          : RouteSourceValidator.#layoutExports;
+    const allowed = getRouteExports(kind, { rootLayout: options.rootLayout });
     const exported = new Set<string>();
     const assertExport = (name: string) => {
       if (!allowed.has(name)) {