@akanjs/devkit 3.0.0-beta.2 → 3.0.0-beta.21

package/lint/no-web-only-api-outside-webkit.grit

@@ -0,0 +1,44 @@
+engine biome(1.0)
+language js(typescript, jsx)
+
+// Browser APIs a native shell's WebView lacks: Android's WebView has no Web Share, an app:// page on iOS has no
+// service worker, no WebView has the Notification API, and iOS has no vibration. They stay legal on the web, so the
+// rule does not ban them — it keeps them in `webkit/`, the layer whose hooks branch on the platform (and is
+// excluded from this rule's scope in biome.base.json), and names the native side where one exists.
+//
+// Pinned to member access, so JSX text naming an API does not match; `Notification` only through its static entry
+// points, because the name is also the libs/shared model (`Notification.View`, `cnst.Notification`).
+or {
+  JsStaticMemberExpression() as $access where {
+    $access <: or { `navigator.share`, `navigator.canShare` },
+    register_diagnostic(
+      span = $access,
+      message = "Android's WebView has no Web Share, so this does nothing in the app. Move it into a `webkit/` hook that branches on `isNativeApp()` from `akanjs/client/native`; the runtime's `share` plugin is the app side.",
+      severity = "warn"
+    )
+  },
+  JsStaticMemberExpression() as $access where {
+    $access <: or { `navigator.serviceWorker`, `Notification.requestPermission`, `Notification.permission` },
+    register_diagnostic(
+      span = $access,
+      message = "A native app page has no service worker or Notification API. Keep this in a `webkit/` hook behind `isNativeApp()`; native push is `push` from `akanjs/client/native`, and `usePushNotification` in libs/util wraps both.",
+      severity = "warn"
+    )
+  },
+  JsStaticMemberExpression() as $access where {
+    $access <: `navigator.geolocation`,
+    register_diagnostic(
+      span = $access,
+      message = "`navigator.geolocation` skips the app's location plugin and its permission flow. Use `useGeoLocation` from `akanjs/webkit`.",
+      severity = "warn"
+    )
+  },
+  JsStaticMemberExpression() as $access where {
+    $access <: `navigator.vibrate`,
+    register_diagnostic(
+      span = $access,
+      message = "iOS has no `navigator.vibrate`. Use `haptics` from `akanjs/client/native` in a `webkit/` hook.",
+      severity = "warn"
+    )
+  }
+}

package/lint/no-web-storage.grit

@@ -0,0 +1,30 @@
+engine biome(1.0)
+language js(typescript, jsx)
+
+// Web Storage works inside the native shells, so this is not about a crash: akanjs/client's `storage` is where the
+// backend is chosen per platform (the shell's Preferences — UserDefaults, SharedPreferences, a JSON file on the
+// desktop — in an app, localStorage on the web), `secretStorage` keeps credentials in the Keychain/Keystore and
+// clears them on a reinstall, and both answer nothing on the server where a bare `localStorage` read during SSR
+// throws.
+//
+// Only the global is matched — a reference, or a member of window/globalThis/self — pinned to those node kinds: a
+// bare snippet matches the name in any position, a field, an object key or JSX text included.
+or {
+  JsIdentifierExpression() as $access where {
+    $access <: or { `localStorage`, `sessionStorage` },
+    register_diagnostic(
+      span = $access,
+      message = "Web Storage bypasses the store akanjs picks per platform (the shell's Preferences in an app) and throws during SSR. Use `storage` from `akanjs/client`, or `secretStorage` for tokens and credentials; a value that may be lost with the tab belongs in component state or the store.",
+      severity = "error"
+    )
+  },
+  JsStaticMemberExpression(object = $root, member = $name) as $access where {
+    $root <: or { `window`, `globalThis`, `self` },
+    $name <: or { `localStorage`, `sessionStorage` },
+    register_diagnostic(
+      span = $access,
+      message = "Web Storage bypasses the store akanjs picks per platform (the shell's Preferences in an app) and throws during SSR. Use `storage` from `akanjs/client`, or `secretStorage` for tokens and credentials; a value that may be lost with the tab belongs in component state or the store.",
+      severity = "error"
+    )
+  }
+}

package/linter.test.ts

@@ -27,8 +27,7 @@ describe("parseBiomeReport", () => {
   });
 
   test("reads a report behind leading text that carries a brace", () => {
-    // The whole reason the first-brace-to-last-brace slice was wrong: Biome prints configuration and IO
-    // diagnostics onto the same stream as the report, and those messages quote source and config.
+    // Biome prints configuration and IO diagnostics onto the report's stream, and they quote source and config.
     const output = [
       "configuration/deserialize: unknown key `overrides[0].includes { }`",
       "  the file `biome.jsonc` cannot be read",

package/linter.ts

@@ -58,16 +58,8 @@ interface LintResponse {
   warnings: LintMessage[];
 }
 
-/**
- * Extracts the `--reporter=json` report from Biome's output.
- *
- * Biome mixes configuration and IO diagnostics into the same stream as the report, so the output is not
- * always JSON alone. Slicing from the first `{` to the last `}` mis-parses as soon as that leading text
- * carries a brace of its own, which is not hypothetical: a config error printed ahead of the report made
- * one unchanged command alternate between 2 and 10 diagnostics. So every `{` is tried as a start, its
- * match is found by depth while string literals are skipped, and the first candidate that both parses and
- * carries a report field wins — a brace in prose parses as nothing, and `{"a":1}` in prose is not a report.
- */
+// Biome mixes config and IO diagnostics into the report stream, and that text can carry braces of its own, so every
+// `{` is tried as a start (string literals skipped) and the first candidate that parses and carries a report field wins.
 export const parseBiomeReport = (output: string): BiomeReport => {
   for (let start = output.indexOf("{"); start !== -1; start = output.indexOf("{", start + 1)) {
     const end = objectEndAt(output, start);
@@ -111,7 +103,19 @@ const asBiomeReport = (candidate: string): BiomeReport | null => {
 /** Biome reads `biome.json` first and `biome.jsonc` second; only the latter may carry comments. */
 const BIOME_CONFIG_FILES = ["biome.json", "biome.jsonc"] as const;
 
+const emptyResult = (filePath: string): LintResult => ({
+  filePath,
+  messages: [],
+  errorCount: 0,
+  warningCount: 0,
+  fixableErrorCount: 0,
+  fixableWarningCount: 0,
+});
+
 export class Linter {
+  //? Bun links a package bin as `<name>.exe` (plus a `.bunx` stub) on Windows, and a bare `<name>` elsewhere.
+  static readonly biomeBinName = process.platform === "win32" ? "biome.exe" : "biome";
+
   lintRoot: string;
   configPath: string;
   #biomeBin: string;
@@ -119,7 +123,7 @@ export class Linter {
   constructor(cwdPath: string) {
     this.lintRoot = this.#findBiomeRootPath(cwdPath);
     this.configPath = Linter.#configPathIn(this.lintRoot) ?? path.join(this.lintRoot, "biome.json");
-    const localBiomeBin = path.join(this.lintRoot, "node_modules/.bin/biome");
+    const localBiomeBin = path.join(this.lintRoot, "node_modules", ".bin", Linter.biomeBinName);
     this.#biomeBin = existsSync(localBiomeBin) ? localBiomeBin : "biome";
   }
 
@@ -199,16 +203,7 @@ export class Linter {
     for (const diagnostic of report.diagnostics ?? []) {
       if (diagnostic.severity !== "error" && diagnostic.severity !== "warning") continue;
       const diagnosticFilePath = this.#diagnosticFilePath(diagnostic, filePath);
-      const result =
-        resultsByPath.get(diagnosticFilePath) ??
-        ({
-          filePath: diagnosticFilePath,
-          messages: [],
-          errorCount: 0,
-          warningCount: 0,
-          fixableErrorCount: 0,
-          fixableWarningCount: 0,
-        } satisfies LintResult);
+      const result = resultsByPath.get(diagnosticFilePath) ?? emptyResult(diagnosticFilePath);
       const message = this.#createLintMessage(diagnostic);
       result.messages.push(message);
       if (message.severity === 2) result.errorCount += 1;
@@ -217,15 +212,7 @@ export class Linter {
     }
 
     return [
-      resultsByPath.get(filePath) ??
-        ({
-          filePath,
-          messages: [],
-          errorCount: 0,
-          warningCount: 0,
-          fixableErrorCount: 0,
-          fixableWarningCount: 0,
-        } satisfies LintResult),
+      resultsByPath.get(filePath) ?? emptyResult(filePath),
       ...[...resultsByPath.entries()].filter(([resultPath]) => resultPath !== filePath).map(([, result]) => result),
     ];
   }
@@ -269,22 +256,12 @@ export class Linter {
     return await this.lintFile(filePath);
   }
 
-  /**
-   * Lint a single file using Biome.
-   * @param filePath - Path to the file to lint
-   * @returns Array of Biome results in the legacy lint result shape
-   */
   async lintFile(filePath: string): Promise<LintResponse> {
     const resolvedFilePath = this.#resolveFilePath(filePath);
     if (!existsSync(resolvedFilePath)) throw new Error(`File not found: ${filePath}`);
     return await this.#checkFile(resolvedFilePath);
   }
 
-  /**
-   * Format lint results for console output
-   * @param results - Array of Biome results
-   * @returns Formatted string
-   */
   formatLintResults(results: LintResult[]): string {
     if (results.length === 0) return "No files to lint";
 
@@ -305,7 +282,7 @@ export class Linter {
             const sourceContent = readFileSync(result.filePath, "utf8");
             sourceLines = sourceContent.split("\n");
           } catch {
-            // Ignore read errors
+            //? An unreadable source only loses its code frame.
           }
         }
 
@@ -318,14 +295,12 @@ export class Linter {
           output.push(`\n  ${icon} ${typeColor(type)}: ${message.message}${ruleInfo}`);
           output.push(`     ${chalk.gray("at")} ${result.filePath}:${chalk.bold(`${message.line}:${message.column}`)}`);
 
-          // Show source line with underline
           if (sourceLines.length > 0 && message.line <= sourceLines.length) {
             const sourceLine = sourceLines[message.line - 1];
             const lineNumber = message.line.toString().padStart(5, " ");
 
             output.push(`\n${chalk.dim(`${lineNumber} |`)} ${sourceLine}`);
 
-            // Create underline
             const underlinePrefix = " ".repeat(message.column - 1);
             const underlineLength = message.endColumn ? message.endColumn - message.column : 1;
             const underline = "^".repeat(Math.max(1, underlineLength));
@@ -345,27 +320,7 @@ export class Linter {
     return summary.concat(output).join("\n");
   }
 
-  /**
-   * Get detailed lint information
-   * @param filePath - Path to the file to lint
-   * @returns Object containing detailed lint information
-   */
-  async getDetailedLintInfo(filePath: string): Promise<{
-    results: LintResult[];
-    details: {
-      line: number;
-      column: number;
-      message: string;
-      ruleId: string | null;
-      severity: "error" | "warning";
-    }[];
-    stats: {
-      errorCount: number;
-      warningCount: number;
-      fixableErrorCount: number;
-      fixableWarningCount: number;
-    };
-  }> {
+  async getDetailedLintInfo(filePath: string) {
     const { results } = await this.lintFile(filePath);
 
     const details = results.flatMap((result) =>
@@ -385,22 +340,13 @@ export class Linter {
         fixableErrorCount: acc.fixableErrorCount + result.fixableErrorCount,
         fixableWarningCount: acc.fixableWarningCount + result.fixableWarningCount,
       }),
-      {
-        errorCount: 0,
-        warningCount: 0,
-        fixableErrorCount: 0,
-        fixableWarningCount: 0,
-      },
+      { errorCount: 0, warningCount: 0, fixableErrorCount: 0, fixableWarningCount: 0 },
     );
 
     return { results, details, stats };
   }
 
-  /**
-   * Check if a file has lint errors
-   * @param filePath - Path to the file to check
-   * @returns true if there are no errors, false otherwise
-   */
+  /** Also false when the file cannot be linted at all. */
   async hasNoLintErrors(filePath: string): Promise<boolean> {
     try {
       const { results } = await this.lintFile(filePath);
@@ -410,32 +356,17 @@ export class Linter {
     }
   }
 
-  /**
-   * Get only error messages (excluding warnings)
-   * @param filePath - Path to the file to lint
-   * @returns Array of error messages
-   */
   async getErrors(filePath: string): Promise<LintMessage[]> {
     const { results } = await this.lintFile(filePath);
     return results.flatMap((result) => result.messages.filter((message) => message.severity === 2));
   }
 
-  /**
-   * Get only warning messages
-   * @param filePath - Path to the file to lint
-   * @returns Array of warning messages
-   */
   async getWarnings(filePath: string): Promise<LintMessage[]> {
     const { results } = await this.lintFile(filePath);
     return results.flatMap((result) => result.messages.filter((message) => message.severity === 1));
   }
 
-  /**
-   * Fix lint errors automatically
-   * @param filePath - Path to the file to fix
-   * @param dryRun - If true, returns the fixed content without writing to file
-   * @returns Fixed content and remaining issues
-   */
+  /** `dryRun` returns the fixed content in `output` without writing the file. */
   async fixFile(filePath: string, dryRun = false): Promise<LintResponse> {
     const resolvedFilePath = this.#resolveFilePath(filePath);
     if (!existsSync(resolvedFilePath)) throw new Error(`File not found: ${filePath}`);
@@ -451,19 +382,8 @@ export class Linter {
     return { ...lintResult, fixed: stdout !== source, output: stdout };
   }
 
-  /**
-   * Get Biome configuration for a file
-   * @param filePath - Path to the file
-   * @returns Biome configuration object
-   */
-  /**
-   * Applies Biome's safe fixes to many files in one process.
-   *
-   * One spawn, not one per file: Biome's startup dominates a small file, so the per-file path turns a
-   * fifteen-file scaffold into three seconds of process launches. Paths that do not exist are dropped
-   * rather than thrown on, because the caller is usually reporting what a template just wrote and a
-   * template is allowed to decline a file.
-   */
+  // One spawn for all files: Biome's startup dominates a small file. Missing paths are dropped (a template may
+  // decline a file).
   async fixFiles(filePaths: string[]): Promise<{ fixed: string[] }> {
     const resolved = filePaths.map((filePath) => this.#resolveFilePath(filePath)).filter(existsSync);
     if (resolved.length === 0) return { fixed: [] };
@@ -489,21 +409,11 @@ export class Linter {
     return JSON.parse(readFileSync(this.configPath, "utf8")) as unknown;
   }
 
-  /**
-   * Get rules that are causing errors in a file
-   * @param filePath - Path to the file to check
-   * @returns Object mapping rule IDs to their error counts
-   */
   async getProblematicRules(filePath: string): Promise<Record<string, number>> {
     const { results } = await this.lintFile(filePath);
     const ruleCounts: Record<string, number> = {};
-
-    results.forEach((result) => {
-      result.messages.forEach((message) => {
-        if (message.ruleId) ruleCounts[message.ruleId] = (ruleCounts[message.ruleId] || 0) + 1;
-      });
-    });
-
+    for (const message of results.flatMap((result) => result.messages))
+      if (message.ruleId) ruleCounts[message.ruleId] = (ruleCounts[message.ruleId] || 0) + 1;
     return ruleCounts;
   }
 }

package/mobile/index.ts

@@ -1 +1,7 @@
 export * from "./mobileTarget";
+export * from "./nativeApi";
+export * from "./nativeApp";
+export * from "./nativeConfig";
+export * from "./nativeWebDir";
+export * from "./placeholderAppId";
+export * from "./usageDescriptions";

package/mobile/mobileTarget.ts

@@ -2,6 +2,8 @@ import type { AkanMobileTargetConfig, MobileEnv } from "../akanConfig";
 import type { App } from "../commandDecorators";
 
 export type MobilePlatform = "ios" | "android";
+export type DesktopPlatform = "macos" | "windows" | "linux";
+export type NativePlatform = MobilePlatform | DesktopPlatform;
 export type MobileTargetSelection = string | "all" | undefined;
 
 export interface ResolvedMobileTarget {
@@ -11,6 +13,8 @@ export interface ResolvedMobileTarget {
 
 export const MOBILE_ENVS = ["local", "debug", "develop", "main"] as const satisfies readonly MobileEnv[];
 
+const trimSlashes = (value: string) => value.replace(/^\/+|\/+$/g, "");
+
 export const getMobileTargets = async (app: App): Promise<ResolvedMobileTarget[]> => {
   const config = await app.getConfig();
   return Object.entries(config.mobile.targets).map(([name, target]) => ({ name, config: target }));
@@ -20,26 +24,23 @@ export const getMobileTargetChoices = async (app: App): Promise<string[]> => {
   const config = await app.getConfig();
   const targetNames = Object.keys(config.mobile.targets);
   if (targetNames.length > 0) return targetNames;
-  const basePaths = [...config.basePaths];
-  return basePaths;
+  return [...config.basePaths];
 };
 
 const resolveMobileTargetByBasePath = (
   targets: ResolvedMobileTarget[],
   basePath: string,
 ): ResolvedMobileTarget | undefined => {
-  const normalizedBasePath = basePath.replace(/^\/+|\/+$/g, "");
-  const byBasePath = targets.find((target) => target.config.basePath?.replace(/^\/+|\/+$/g, "") === normalizedBasePath);
+  const normalizedBasePath = trimSlashes(basePath);
+  const byBasePath = targets.find(
+    ({ config }) => config.basePath !== undefined && trimSlashes(config.basePath) === normalizedBasePath,
+  );
   if (byBasePath) return byBasePath;
   const [template] = targets;
   if (!template) return undefined;
   return {
     name: normalizedBasePath,
-    config: {
-      ...template.config,
-      name: normalizedBasePath,
-      basePath: normalizedBasePath,
-    },
+    config: { ...template.config, name: normalizedBasePath, basePath: normalizedBasePath },
   };
 };
 
@@ -70,18 +71,20 @@ export const resolveMobileTargets = async (
   const target = targets.find((candidate) => candidate.name === selection);
   if (target) return [target];
   const basePathTarget = resolveMobileTargetByBasePath(targets, selection);
-  if (basePathTarget && config.basePaths.has(selection.replace(/^\/+|\/+$/g, ""))) return [basePathTarget];
+  if (basePathTarget && config.basePaths.has(trimSlashes(selection))) return [basePathTarget];
   const choices = await getMobileTargetChoices(app);
   throw new Error(`Mobile target '${selection}' was not found. Available: ${choices.join(", ")}`);
 };
 
 export const resolveMobilePath = (target: AkanMobileTargetConfig, pathname: string) => {
-  const basePath = target.basePath?.replace(/^\/+|\/+$/g, "");
+  const basePath = trimSlashes(target.basePath ?? "");
   const normalizedPath = `/${pathname.replace(/^\/+/, "")}`;
   if (!basePath) return normalizedPath;
   if (normalizedPath === `/${basePath}` || normalizedPath.startsWith(`/${basePath}/`)) return normalizedPath;
   return `/${basePath}${normalizedPath === "/" ? "" : normalizedPath}`;
 };
 
-export const targetHtmlFilename = (target: AkanMobileTargetConfig) =>
-  target.basePath?.replace(/^\/+|\/+$/g, "") ? `${target.basePath.replace(/^\/+|\/+$/g, "")}.html` : "index.html";
+export const targetHtmlFilename = (target: AkanMobileTargetConfig) => {
+  const basePath = trimSlashes(target.basePath ?? "");
+  return basePath ? `${basePath}.html` : "index.html";
+};

package/mobile/nativeApi.test.ts

@@ -0,0 +1,30 @@
+import { describe, expect, test } from "bun:test";
+import { mkdir, realpath, writeFile } from "node:fs/promises";
+import path from "node:path";
+import { tempDirs } from "../testHelpers";
+import { NativeApi } from "./nativeApi";
+
+const makeTempRoot = tempDirs("akan-native-api-");
+const repoApp = path.resolve(import.meta.dir, "../../../../apps/minimal");
+
+describe("NativeApi", () => {
+  test("inside this repo, loads the workspace package and checks its major", async () => {
+    expect(NativeApi.entryOf(repoApp)).toBe(path.resolve(import.meta.dir, "../../native/packages/cli/src/api.ts"));
+    const api = await NativeApi.load(repoApp);
+    expect(api.API_VERSION.split(".")[0]).toBe(String(NativeApi.supportedMajor));
+  });
+
+  test("elsewhere, looks for the copy akanjs vendors, and says so when it is missing", async () => {
+    const root = await realpath(await makeTempRoot());
+    await mkdir(path.join(root, "node_modules/akanjs"), { recursive: true });
+    await writeFile(
+      path.join(root, "node_modules/akanjs/package.json"),
+      JSON.stringify({ name: "akanjs", exports: { "./package.json": "./package.json" } }),
+    );
+
+    expect(NativeApi.entryOf(root)).toBe(
+      path.join(root, "node_modules/akanjs/vendor/@akanjs/native/packages/cli/src/api.ts"),
+    );
+    await expect(NativeApi.load(root)).rejects.toThrow("The installed akanjs has no native build");
+  });
+});

package/mobile/nativeApi.ts

@@ -0,0 +1,40 @@
+import path from "node:path";
+import type * as NativeBuildApi from "@akanjs/native/api";
+
+export type NativeBuildApiModule = typeof NativeBuildApi;
+
+export class NativeApi {
+  //* The build API versions itself; a major this devkit was not written against is refused before anything builds.
+  static readonly supportedMajor = 0;
+
+  /** The API of the akanjs the app installed: the workspace package inside this repo, akanjs's vendored copy elsewhere. */
+  static entryOf(appDir: string): string {
+    const workspaceEntry = NativeApi.#resolve("@akanjs/native/api", appDir);
+    if (workspaceEntry) return workspaceEntry;
+    const akanjsPackage = NativeApi.#resolve("akanjs/package.json", appDir);
+    if (!akanjsPackage) throw new Error(`akanjs is not installed for ${appDir}; the native build ships inside it.`);
+    return path.join(path.dirname(akanjsPackage), "vendor", "@akanjs", "native", "packages", "cli", "src", "api.ts");
+  }
+
+  static async load(appDir: string): Promise<NativeBuildApiModule> {
+    const entry = NativeApi.entryOf(appDir);
+    if (!(await Bun.file(entry).exists()))
+      throw new Error(`The installed akanjs has no native build at ${entry}; update akanjs.`);
+    const api = (await import(entry)) as NativeBuildApiModule;
+    const major = Number(api.API_VERSION.split(".")[0]);
+    if (major !== NativeApi.supportedMajor)
+      throw new Error(
+        `The native build API is ${api.API_VERSION}, and this akan CLI speaks ${NativeApi.supportedMajor}.x; install matching versions of akanjs and @akanjs/cli.`,
+      );
+    return api;
+  }
+
+  static #resolve(specifier: string, from: string) {
+    try {
+      return Bun.resolveSync(specifier, from);
+    } catch {
+      // Not installed where the app can reach it, which the caller answers with the next place to look.
+      return null;
+    }
+  }
+}

package/mobile/nativeApp.test.ts

@@ -0,0 +1,85 @@
+import { describe, expect, test } from "bun:test";
+import path from "node:path";
+import type { AkanPlugin } from "akanjs";
+import type { AkanMobileTargetConfig } from "../akanConfig";
+import type { App } from "../commandDecorators";
+import { NativeApp } from "./nativeApp";
+import { NativeConfig } from "./nativeConfig";
+
+const target = (config: Partial<AkanMobileTargetConfig> = {}) => ({
+  name: config.name ?? "default",
+  config: {
+    name: config.name ?? "default",
+    appName: "Portal",
+    appId: "com.portal.app",
+    version: "1.0.0",
+    buildNum: 1,
+    ...config,
+  },
+});
+
+const appDir = "/repo/apps/portal";
+
+const fakeApp = (plugins: AkanPlugin[] = []) =>
+  ({
+    cwdPath: appDir,
+    dist: { cwdPath: "/repo/dist/apps/portal" },
+    getConfig: async () => ({ i18n: { locales: ["en", "ko"] }, api: { prefix: "/api", websocketPrefix: "/ws" } }),
+    collectPlugins: async () => plugins,
+    logger: { warn: () => undefined },
+  }) as unknown as App;
+
+describe("NativeApp", () => {
+  test("keeps each target's web root and each platform's output apart", () => {
+    const admin = new NativeApp(fakeApp(), target({ name: "admin", basePath: "admin" }));
+
+    expect(admin.web.dir).toBe(path.join(appDir, ".akan/mobile/admin/web"));
+    expect(admin.outDir("ios")).toBe(path.join(appDir, ".akan/mobile/admin/native/ios"));
+    expect(admin.outDir("android")).toBe(path.join(appDir, ".akan/mobile/admin/native/android"));
+  });
+
+  test("opens a dev build on its target's home, the CSR shell under the locale", () => {
+    expect(new NativeApp(fakeApp(), target({ indexPath: "/explore" })).startPath("en")).toBe(
+      "/en/explore?csr=true&akanMobileTarget=default&akanMobileIndexPath=%2Fexplore",
+    );
+    expect(new NativeApp(fakeApp(), target({ name: "admin", basePath: "/admin/" })).startPath("ko")).toBe(
+      "/ko/admin?csr=true&akanMobileTarget=admin&akanMobileBasePath=admin",
+    );
+  });
+
+  test("builds its config from the app's locales and the plugins' native contributions", async () => {
+    const push: AkanPlugin = { name: "push-notification", native: { permission: "push", plugins: ["push"] } };
+    const app = new NativeApp(
+      fakeApp([push, { name: "other" }]),
+      target({ basePath: undefined, permissions: ["push"] }),
+    );
+
+    const { config, warnings } = await app.config();
+
+    expect(warnings).toEqual([]);
+    expect(config.plugins).toEqual([...NativeConfig.basePlugins, "push"]);
+    expect(config.web.dir).toBe(path.join(appDir, ".akan/mobile/default/web"));
+  });
+
+  test("a desktop app is this computer's platform", () => {
+    expect(["darwin", "win32", "linux"].map((host) => NativeApp.desktopPlatform(host as NodeJS.Platform))).toEqual([
+      "macos",
+      "windows",
+      "linux",
+    ]);
+    expect(() => NativeApp.desktopPlatform("freebsd")).toThrow("A desktop app builds on macOS, Windows or Linux");
+  });
+
+  test("signs an Android release with the upload key the environment names, and says which part is missing", () => {
+    expect(
+      NativeApp.androidSigning({
+        MYAPP_RELEASE_STORE_FILE: "keys/upload.jks",
+        MYAPP_RELEASE_STORE_PASSWORD: "store",
+        MYAPP_RELEASE_KEY_ALIAS: "upload",
+      }),
+    ).toEqual({ keystore: "keys/upload.jks", storePassword: "store", alias: "upload" });
+    expect(() => NativeApp.androidSigning({ MYAPP_RELEASE_STORE_FILE: "keys/upload.jks" })).toThrow(
+      "set MYAPP_RELEASE_STORE_PASSWORD, MYAPP_RELEASE_KEY_ALIAS in the environment",
+    );
+  });
+});