@akanjs/devkit 3.0.0-beta.29 → 3.0.0-beta.30

package/akanConfig/akanConfig.ts

@@ -14,8 +14,12 @@ import {
   type AkanAssetsConfig,
   type AkanBinConfig,
   type AkanDatabaseConfig,
-  type AkanMobileConfig,
-  type AkanMobileTargetConfig,
+  type AkanNativeAppConfig,
+  type AkanNativeAppResult,
+  type AkanNativeDeepLinks,
+  type AkanNativeSettings,
+  type AkanNativeTarget,
+  type AkanNativeUpdatesConfig,
   type AkanRouteConfig,
   type AkanWebConfig,
   type AkanWebOption,
@@ -94,25 +98,18 @@ const normalizeDeepLinkDomain = (domain: string) => {
   }
 };
 
-const normalizeDeepLinks = (deepLinks: DeepPartial<AkanMobileTargetConfig["deepLinks"]> | undefined) => {
-  if (!deepLinks) return undefined;
-  const schemes = normalizeStringList(deepLinks.schemes as string[] | undefined);
-  const domains = normalizeStringList((deepLinks.domains as string[] | undefined)?.map(normalizeDeepLinkDomain));
-  const teamId = (deepLinks.ios?.teamId as string | undefined)?.trim();
-  const sha256CertFingerprints = normalizeStringList(deepLinks.android?.sha256CertFingerprints as string[] | undefined);
-  if (!schemes && !domains && !teamId && !sha256CertFingerprints) return undefined;
-  return {
-    ...(schemes ? { schemes } : {}),
-    ...(domains ? { domains } : {}),
-    ...(teamId ? { ios: { teamId } } : {}),
-    ...(sha256CertFingerprints ? { android: { sha256CertFingerprints } } : {}),
-  } satisfies AkanMobileTargetConfig["deepLinks"];
+const normalizeDeepLinks = (deepLinks: AkanNativeDeepLinks | undefined): AkanNativeDeepLinks | undefined => {
+  const schemes = normalizeStringList(deepLinks?.schemes);
+  const domains = normalizeStringList(deepLinks?.domains?.map(normalizeDeepLinkDomain));
+  if (!schemes && !domains) return undefined;
+  return { ...(schemes ? { schemes } : {}), ...(domains ? { domains } : {}) };
 };
 
-type AppConfigDeclaration = Omit<DeepPartial<AppConfigResult>, "docker" | "web" | "bin"> & {
+type AppConfigDeclaration = Omit<DeepPartial<AppConfigResult>, "docker" | "web" | "bin" | "native"> & {
   docker?: DockerOption;
   web?: AkanWebOption;
   bin?: AkanBinConfig;
+  native?: AkanNativeAppConfig;
 };
 
 type LibConfigDeclaration = Omit<DeepPartial<LibConfigResult>, "bin"> & { bin?: AkanBinConfig };
@@ -172,9 +169,9 @@ export class AkanAppConfig implements AppConfigResult {
   i18n: AkanI18nConfig;
   api: AkanApiConfig;
   publicEnv: string[];
-  mobile: AkanMobileConfig;
-  /** True only when the app's akan.config.ts explicitly declares a `mobile` section (vs. the synthesized default). */
-  hasMobileConfig: boolean;
+  native: AkanNativeAppResult;
+  /** True only when the app's akan.config.ts declares a `native` section (vs. the synthesized default target). */
+  hasNativeConfig: boolean;
   secrets: string[];
   assets: AkanAssetsConfig;
   /** Raw setting, resolved against the app's lib deps at sync time. */
@@ -240,8 +237,12 @@ export class AkanAppConfig implements AppConfigResult {
       ],
     };
     this.syncPageLibs = (config?.syncPageLibs as string[] | boolean | undefined) ?? false;
-    this.hasMobileConfig = Boolean(config.mobile);
-    this.mobile = this.#resolveMobileConfig(config.mobile);
+    if ((config as { mobile?: unknown }).mobile !== undefined)
+      throw new Error(
+        `apps/${this.app.name}/akan.config.ts declares \`mobile\`, which is now \`native\`: the platform settings sit in native.ios, native.android and native.desktop, and a target overrides them under native.targets.<name>.`,
+      );
+    this.hasNativeConfig = Boolean(config.native);
+    this.native = this.#resolveNativeConfig(config.native);
     this.web = this.#resolveWebConfig(config.web);
     this.docker = AkanAppConfig.#resolveDocker(config.docker, libContributions.docker);
     this.dockerfile = this.#makeDockerfile();
@@ -249,166 +250,185 @@ export class AkanAppConfig implements AppConfigResult {
   #resolveWebConfig(web: AkanWebOption | undefined): AkanWebConfig {
     const resolved = typeof web === "object" ? { ssr: true, csr: web.csr } : { ssr: web ?? true, csr: web ?? true };
     // `akan build-ios` / `build-android` copy `dist/apps/<app>/csr/<target>.html` into the native project.
-    if (!resolved.csr && this.hasMobileConfig)
+    if (!resolved.csr && this.hasNativeConfig)
       throw new Error(
-        `apps/${this.app.name}/akan.config.ts turns the CSR bundle off but declares mobile targets; the mobile apps ship that bundle. Drop the mobile section or leave CSR on.`,
+        `apps/${this.app.name}/akan.config.ts turns the CSR bundle off but declares a native section; the native apps ship that bundle. Drop the native section or leave CSR on.`,
       );
     return resolved;
   }
-  #resolveMobileConfig(mobile: DeepPartial<AkanMobileConfig> | undefined): AkanMobileConfig {
-    const {
-      targets: rawTargets,
-      indexPath: _indexPath,
-      ...rawMobile
-    } = (mobile ?? {}) as DeepPartial<AkanMobileConfig> & { indexPath?: unknown };
+  #resolveNativeConfig(native: AkanNativeAppConfig | undefined): AkanNativeAppResult {
     const configPath = `apps/${this.app.name}/akan.config.ts`;
-    AkanAppConfig.#assertMobileKeys(rawMobile, AkanAppConfig.#mobileKeys, "mobile", configPath);
-    const appName = rawMobile.appName ?? this.app.name;
-    const appId = rawMobile.appId ?? deriveDefaultAppId(this.baseDevEnv.repoName, this.app.name);
-    const version = rawMobile.version ?? "0.0.1";
-    const buildNum = rawMobile.buildNum ?? 1;
-    const files = AkanAppConfig.#resolveMobileFiles(rawMobile.files as AkanMobileConfig["files"], "mobile", configPath);
-    const native = rawMobile.native as AkanMobileConfig["native"];
-    const updates = rawMobile.updates as AkanMobileConfig["updates"];
-    const defaultTargetName = this.#defaultMobileTargetName(rawTargets);
-    const targetEntries = Object.entries(
-      rawTargets ?? {
-        [defaultTargetName]: {},
-      },
-    );
+    const { targets: rawTargets, ...root } = native ?? {};
+    AkanAppConfig.#assertNativeKeys(root, "native", configPath);
+    AkanAppConfig.#assertFiles(root, "native", configPath);
+    const appName = root.appName ?? this.app.name;
+    const appId = root.appId ?? deriveDefaultAppId(this.baseDevEnv.repoName, this.app.name);
+    const version = root.version ?? "0.0.1";
+    const buildNum = root.buildNum ?? 1;
+    const named = rawTargets !== undefined && Object.keys(rawTargets).length > 0;
+    const entries: [string, AkanNativeSettings][] = named
+      ? Object.entries(rawTargets)
+      : [[this.basePaths.has(this.app.name) ? this.app.name : "default", {}]];
     const targets = Object.fromEntries(
-      targetEntries.map(([name, rawTarget]) => {
-        const target = (rawTarget ?? {}) as DeepPartial<AkanMobileTargetConfig>;
-        const where = `mobile.targets.${name}`;
-        AkanAppConfig.#assertMobileKeys(target, AkanAppConfig.#targetKeys, where, configPath);
-        const fallbackBasePath = !rawTargets && this.basePaths.has(name) ? name : undefined;
-        const basePath = (target.basePath ?? fallbackBasePath)?.replace(/^\/+|\/+$/g, "") || undefined;
-        const indexPath = normalizeIndexPath(target.indexPath as string | undefined);
-        const deepLinks = normalizeDeepLinks(target.deepLinks);
-        if (basePath && !this.basePaths.has(basePath)) {
-          throw new Error(`Mobile target '${name}' uses unknown basePath '${basePath}' in ${configPath}`);
-        }
-        const targetFiles = AkanAppConfig.#resolveMobileFiles(
-          target.files as AkanMobileTargetConfig["files"],
-          where,
-          configPath,
-        );
-        const fileName = (target.fileName ?? rawMobile.fileName) as string | undefined;
-        const targetUpdates = updates || target.updates ? { ...updates, ...target.updates } : undefined;
-        if (targetUpdates && (!targetUpdates.url || !targetUpdates.publicKey))
+      entries.map(([name, own]) => {
+        const where = named ? `native.targets.${name}` : "native";
+        AkanAppConfig.#assertNativeKeys(own ?? {}, where, configPath);
+        const merged = AkanAppConfig.#overlay(root, own ?? {});
+        const fallbackBasePath = !named && this.basePaths.has(name) ? name : undefined;
+        const basePath = (merged.basePath ?? fallbackBasePath)?.replace(/^\/+|\/+$/g, "") || undefined;
+        if (basePath && !this.basePaths.has(basePath))
+          throw new Error(`Native target '${name}' uses unknown basePath '${basePath}' in ${configPath}`);
+        const { updates } = merged;
+        if (updates && (!updates.url || !updates.publicKey))
           throw new Error(
-            `${where}.updates in ${configPath} has no url or publicKey; give them in mobile.updates or the target's own.`,
+            `${where}.updates in ${configPath} has no url or publicKey${named ? "; give them in native.updates or the target's own" : ""}.`,
           );
-        const resolved = {
+        AkanAppConfig.#assertFiles(own ?? {}, where, configPath);
+        const {
+          basePath: _basePath,
+          indexPath: rawIndexPath,
+          deepLinks: rawDeepLinks,
+          updates: _updates,
+          ...rest
+        } = merged;
+        const indexPath = normalizeIndexPath(rawIndexPath);
+        const deepLinks = normalizeDeepLinks(rawDeepLinks);
+        const { teamId: rawTeamId, ...iosRest } = merged.ios ?? {};
+        const teamId = rawTeamId?.trim();
+        const { sha256CertFingerprints: rawFingerprints, ...androidRest } = merged.android ?? {};
+        const fingerprints = normalizeStringList(rawFingerprints);
+        const target: AkanNativeTarget = {
+          ...rest,
           name,
-          basePath,
-          indexPath,
-          deepLinks,
-          appName: target.appName ?? appName,
-          appId: target.appId ?? appId,
-          ...(fileName ? { fileName } : {}),
-          version: target.version ?? version,
-          buildNum: target.buildNum ?? buildNum,
-          ...(target.assets ? { assets: target.assets as AkanMobileTargetConfig["assets"] } : {}),
-          ...(target.permissions ? { permissions: target.permissions as AkanMobileTargetConfig["permissions"] } : {}),
-          ...(files || targetFiles ? { files: { ...files, ...targetFiles } } : {}),
-          ...(native || target.native
-            ? { native: AkanAppConfig.#mergeNative(native, target.native as AkanMobileTargetConfig["native"]) }
+          ...(basePath ? { basePath } : {}),
+          ...(indexPath ? { indexPath } : {}),
+          ...(deepLinks ? { deepLinks } : {}),
+          ...(merged.ios ? { ios: { ...iosRest, ...(teamId ? { teamId } : {}) } } : {}),
+          ...(merged.android
+            ? { android: { ...androidRest, ...(fingerprints ? { sha256CertFingerprints: fingerprints } : {}) } }
             : {}),
-          ...(targetUpdates ? { updates: targetUpdates } : {}),
-        } satisfies AkanMobileTargetConfig;
-        return [name, resolved];
+          appName: merged.appName ?? this.app.name,
+          appId: merged.appId ?? appId,
+          version: merged.version ?? version,
+          buildNum: merged.buildNum ?? buildNum,
+          ...(updates ? { updates: updates as AkanNativeUpdatesConfig } : {}),
+        };
+        return [name, target];
       }),
     );
-    return {
-      appName,
-      appId,
-      ...(rawMobile.fileName ? { fileName: rawMobile.fileName as string } : {}),
-      version,
-      buildNum,
-      ...(files ? { files } : {}),
-      ...(native ? { native } : {}),
-      ...(updates ? { updates } : {}),
-      targets,
+    return { appName, appId, ...(root.fileName ? { fileName: root.fileName } : {}), version, buildNum, targets };
+  }
+  /** `own` over `base`: plain objects merge key by key, and any other value, a list included, replaces. */
+  static #overlay(base: AkanNativeSettings, own: AkanNativeSettings): AkanNativeSettings {
+    const merge = (kept: unknown, value: unknown, top: boolean, key: string): unknown => {
+      if (!AkanAppConfig.#isPlainObject(kept) || !AkanAppConfig.#isPlainObject(value)) return value;
+      //? An icon or splash given as an object is one value: its image and color go together.
+      if (top && (key === "icon" || key === "splash")) return value;
+      const out: Record<string, unknown> = { ...kept };
+      for (const [inner, next] of Object.entries(value))
+        if (next !== undefined) out[inner] = merge(out[inner], next, false, inner);
+      return out;
     };
+    const out: Record<string, unknown> = { ...base };
+    for (const [key, value] of Object.entries(own))
+      if (value !== undefined) out[key] = merge(out[key], value, true, key);
+    return out as AkanNativeSettings;
   }
-  static readonly #mobileKeys = ["appName", "appId", "fileName", "version", "buildNum", "files", "native", "updates"];
-  static readonly #targetKeys = [
-    "basePath",
-    "indexPath",
-    "appName",
-    "appId",
-    "fileName",
-    "version",
-    "buildNum",
-    "assets",
-    "permissions",
-    "deepLinks",
-    "files",
-    "native",
-    "updates",
-  ];
-  //* The Capacitor keys used to pass straight through; the native runtime takes typed ones, so a leftover is refused.
-  static #assertMobileKeys(section: object, known: string[], where: string, configPath: string) {
-    for (const key of Object.keys(section)) {
-      if (known.includes(key)) continue;
-      if (key === "plugins" || key === "ios" || key === "android")
-        throw new Error(
-          `${where}.${key} in ${configPath} is a Capacitor setting. The native runtime reads native.plugins, native.ios.{infoPlist,entitlements} and native.android.{manifest,application,activity,googleServices} instead.`,
-        );
-      throw new Error(`${where}.${key} in ${configPath} is not a mobile setting. Known: ${known.join(", ")}.`);
-    }
+  static #isPlainObject(value: unknown): value is Record<string, unknown> {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
   }
-  static readonly #fileTargetPattern = /^(?:ios\/.+|android\/res\/[^/]+\/[^/]+|android\/assets\/.+)$/;
-  static #resolveMobileFiles(files: AkanMobileTargetConfig["files"] | undefined, where: string, configPath: string) {
-    if (!files) return undefined;
-    for (const [to, from] of Object.entries(files)) {
-      if (typeof from !== "string")
-        throw new Error(
-          `${where}.files in ${configPath} maps where a file lands to its source now, e.g. { "android/res/raw/chime.mp3": "assets/chime.mp3" }. google-services.json goes to native.android.googleServices, and GoogleService-Info.plist is no longer needed.`,
-        );
-      if (!AkanAppConfig.#fileTargetPattern.test(to))
+  static readonly #nativeKeys = {
+    native: [
+      "basePath",
+      "indexPath",
+      "appName",
+      "appId",
+      "fileName",
+      "version",
+      "buildNum",
+      "icon",
+      "splash",
+      "permissions",
+      "plugins",
+      "deepLinks",
+      "updates",
+      "ios",
+      "android",
+      "desktop",
+    ],
+    ios: ["teamId", "infoPlist", "entitlements", "privacy", "files"],
+    android: [
+      "sha256CertFingerprints",
+      "googleServices",
+      "push",
+      "autoplay",
+      "manifest",
+      "application",
+      "activity",
+      "files",
+    ],
+    desktop: ["server", "recovery", "window", "screenCapture"],
+    deepLinks: ["schemes", "domains"],
+  } as const;
+  //* Settings that moved when `mobile` became `native` are named with where they went, instead of "unknown".
+  static readonly #movedKeys: Readonly<Record<string, string>> = {
+    native: "the platform sections and plugins sit directly in the native section: ios, android, desktop, plugins",
+    assets: "icon and splash sit directly in the native section",
+    files:
+      "ios.files (keyed by the path in the app bundle) or android.files (keyed res/<type>/<file> or assets/<path>)",
+    push: "android.push",
+    privacy: "ios.privacy",
+    "deepLinks.ios": "ios.teamId",
+    "deepLinks.android": "android.sha256CertFingerprints",
+  };
+  static #assertNativeKeys(section: object, where: string, configPath: string) {
+    const check = (value: unknown, known: readonly string[], at: string, kind: string) => {
+      if (!AkanAppConfig.#isPlainObject(value)) return;
+      for (const key of Object.keys(value)) {
+        if (known.includes(key)) continue;
+        const moved = AkanAppConfig.#movedKeys[kind === "native" ? key : `${kind}.${key}`];
         throw new Error(
-          `${where}.files["${to}"] in ${configPath} must land under ios/<path>, android/res/<type>/<file> or android/assets/<path>.`,
+          moved
+            ? `${at}.${key} in ${configPath} has moved: ${moved}.`
+            : `${at}.${key} in ${configPath} is not a native setting. Known: ${known.join(", ")}.`,
         );
-    }
-    return files;
-  }
-  static #mergeNative(
-    base: AkanMobileTargetConfig["native"],
-    override: AkanMobileTargetConfig["native"],
-  ): NonNullable<AkanMobileTargetConfig["native"]> {
-    const plugins = [...new Set([...(base?.plugins ?? []), ...(override?.plugins ?? [])])];
-    const ios = { ...base?.ios, ...override?.ios };
-    const android: NonNullable<NonNullable<AkanMobileTargetConfig["native"]>["android"]> = {
-      ...base?.android,
-      ...override?.android,
-    };
-    for (const key of ["manifest", "application", "activity"] as const) {
-      const merged = [...(base?.android?.[key] ?? []), ...(override?.android?.[key] ?? [])];
-      if (merged.length) android[key] = merged;
-      else delete android[key];
-    }
-    const pushAndroid = { ...base?.push?.android, ...override?.push?.android };
-    const privacy = { ...base?.privacy, ...override?.privacy };
-    const window = { ...base?.desktop?.window, ...override?.desktop?.window };
-    const desktop = {
-      ...base?.desktop,
-      ...override?.desktop,
-      ...(Object.keys(window).length ? { window } : {}),
-    };
-    return {
-      ...(plugins.length ? { plugins } : {}),
-      ...(Object.keys(ios).length ? { ios } : {}),
-      ...(Object.keys(android).length ? { android } : {}),
-      ...(Object.keys(pushAndroid).length ? { push: { android: pushAndroid } } : {}),
-      ...(Object.keys(privacy).length ? { privacy } : {}),
-      ...(Object.keys(desktop).length ? { desktop } : {}),
+      }
     };
+    check(section, AkanAppConfig.#nativeKeys.native, where, "native");
+    const settings = section as AkanNativeSettings;
+    check(settings.ios, AkanAppConfig.#nativeKeys.ios, `${where}.ios`, "ios");
+    check(settings.android, AkanAppConfig.#nativeKeys.android, `${where}.android`, "android");
+    check(settings.desktop, AkanAppConfig.#nativeKeys.desktop, `${where}.desktop`, "desktop");
+    check(settings.deepLinks, AkanAppConfig.#nativeKeys.deepLinks, `${where}.deepLinks`, "deepLinks");
   }
-  #defaultMobileTargetName(rawTargets: DeepPartial<AkanMobileConfig>["targets"] | undefined) {
-    if (rawTargets && Object.keys(rawTargets).length > 0) return Object.keys(rawTargets)[0] as string;
-    return this.basePaths.has(this.app.name) ? this.app.name : "default";
+  static readonly #androidFilePattern = /^(?:res\/[^/]+\/[^/]+|assets\/.+)$/;
+  static #assertFiles(settings: AkanNativeSettings, where: string, configPath: string) {
+    const check = (
+      files: Record<string, string> | undefined,
+      at: string,
+      valid: (to: string) => boolean,
+      shape: string,
+    ) => {
+      for (const [to, from] of Object.entries(files ?? {})) {
+        if (typeof from !== "string")
+          throw new Error(
+            `${at}["${to}"] in ${configPath} must name its source file, relative to the app folder, e.g. { "${shape}": "assets/chime.mp3" }.`,
+          );
+        if (!valid(to)) throw new Error(`${at}["${to}"] in ${configPath} must land at ${shape}.`);
+      }
+    };
+    check(
+      settings.ios?.files,
+      `${where}.ios.files`,
+      (to) => to.length > 0 && !to.startsWith("/") && !to.split("/").includes(".."),
+      "<path in the app bundle>",
+    );
+    check(
+      settings.android?.files,
+      `${where}.android.files`,
+      (to) => AkanAppConfig.#androidFilePattern.test(to),
+      "res/<type>/<file> or assets/<path>",
+    );
   }
   #applyRoutes(routes: AkanRouteConfig[] = []) {
     for (const route of routes) {
@@ -695,7 +715,7 @@ export class AkanLibConfig implements LibConfigResult {
 
 //! need to refactor
 const shiftBuildNum = async (app: App, delta: number) => {
-  const { buildNum } = (await AkanAppConfig.from(app)).mobile;
+  const { buildNum } = (await AkanAppConfig.from(app)).native;
   const akanConfigPath = path.join(app.cwdPath, "akan.config.ts");
   const akanConfig = fs.readFileSync(akanConfigPath, "utf8");
   fs.writeFileSync(akanConfigPath, akanConfig.replace(`buildNum: ${buildNum}`, `buildNum: ${buildNum + delta}`));

package/akanConfig/types.ts

@@ -8,10 +8,16 @@ export type {
   AkanConfigFile,
   AkanDatabaseConfig,
   AkanExecutor,
-  AkanMobileConfig,
-  AkanMobileNativeConfig,
-  AkanMobileTargetConfig,
-  AkanMobileUpdatesConfig,
+  AkanNativeAndroidConfig,
+  AkanNativeAppConfig,
+  AkanNativeAppId,
+  AkanNativeAppResult,
+  AkanNativeDeepLinks,
+  AkanNativeDesktopConfig,
+  AkanNativeIosConfig,
+  AkanNativeSettings,
+  AkanNativeTarget,
+  AkanNativeUpdatesConfig,
   AkanNativeValue,
   AkanPlugin,
   AkanPluginNativeConfig,
@@ -39,8 +45,8 @@ export type {
   LibConfigResult,
   LibDockerConfig,
   LibScanResult,
-  MobileEnv,
-  MobilePermission,
+  NativeEnv,
+  NativePermission,
   PkgScanResult,
   ScanResult,
   WorkspaceScanResult,

package/executors.test.ts

@@ -338,8 +338,8 @@ describe("Workspace and app executor environment contracts", () => {
     await writeFile(path.join(root, "apps/startclean/akan.config.ts"), "export default {};\n");
     const akan = path.join(root, "apps/startclean/.akan");
     const kept = [
-      "mobile/desktop/updates/macos-arm64/main.json",
-      "mobile/desktop/native/macos/App.app",
+      "native/desktop/updates/macos-arm64/main.json",
+      "native/desktop/build/macos/App.app",
       "cache/bin/ffmpeg",
     ];
     const removed = [
@@ -347,6 +347,7 @@ describe("Workspace and app executor environment contracts", () => {
       "generated/dict/index.ts",
       "cache/cssCandidates.json",
       "desktop/server/main.js",
+      "mobile/desktop/native/macos/App.app",
     ];
     for (const file of [...kept, ...removed]) await writeText(path.join(akan, file), "x");
 
@@ -354,7 +355,7 @@ describe("Workspace and app executor environment contracts", () => {
     await app.prepareCommand("start");
 
     for (const file of kept) expect(existsSync(path.join(akan, file))).toBe(true);
-    for (const file of [...removed, "artifact", "generated", "desktop"])
+    for (const file of [...removed, "artifact", "generated", "desktop", "mobile"])
       expect(existsSync(path.join(akan, file))).toBe(false);
   });
 

package/executors.ts

@@ -1120,7 +1120,7 @@ export class AppExecutor extends SysExecutor {
     return new AppExecutor({ workspace: executor instanceof WorkspaceExecutor ? executor : executor.workspace, name });
   }
   //* Not dev output: native builds and the update releases waiting to be uploaded, and the downloaded `bin` sources.
-  static readonly #keptOnStart = [path.join(".akan", "mobile"), path.join(".akan", "cache", "bin")];
+  static readonly #keptOnStart = [path.join(".akan", "native"), path.join(".akan", "cache", "bin")];
   async #removeDevOutput(dir = ".akan") {
     const entries = await readDirEntries(this.getPath(dir)).catch(() => [] as string[]);
     await Promise.all(

package/frontendBuild/ssrBaseArtifactBuilder.ts

@@ -1,6 +1,6 @@
 import path from "node:path";
 import { optimize } from "@tailwindcss/node";
-import type { AkanMobileAppId, AkanWebConfig } from "akanjs";
+import type { AkanNativeAppId, AkanWebConfig } from "akanjs";
 import type { BaseBuildArtifact } from "akanjs/server";
 import { resolveSsrPageEntriesForApp } from "../artifact/implicitRootLayout";
 import { computeRouteSeedIndex, type RouteSeedIndex, saveRouteSeedIndex } from "../artifact/routeSeedIndex";
@@ -85,15 +85,15 @@ export class SsrBaseArtifactBuilder {
       i18n: akanConfig.i18n,
       imageConfig: akanConfig.images,
       web: SsrBaseArtifactBuilder.servedWeb(this.#command, akanConfig.web),
-      deepLinkAssociations: Object.values(akanConfig.mobile.targets)
+      deepLinkAssociations: Object.values(akanConfig.native.targets)
         .filter((target) => (target.deepLinks?.domains?.length ?? 0) > 0)
         .map((target) => ({
           targetName: target.name,
           iosAppId: SsrBaseArtifactBuilder.#appIdOn(target.appId, "ios"),
           androidAppId: SsrBaseArtifactBuilder.#appIdOn(target.appId, "android"),
           domains: target.deepLinks?.domains ?? [],
-          iosTeamId: target.deepLinks?.ios?.teamId,
-          androidSha256CertFingerprints: target.deepLinks?.android?.sha256CertFingerprints,
+          iosTeamId: target.ios?.teamId,
+          androidSha256CertFingerprints: target.android?.sha256CertFingerprints,
         })),
     };
     await Bun.write(path.join(this.#absArtifactDir, "base-artifact.json"), `${JSON.stringify(artifact, null, 2)}\n`);
@@ -224,7 +224,7 @@ export class SsrBaseArtifactBuilder {
   }
 
   // Checked against the written asset, not the compiled text: it is the only stylesheet an SSR render serves.
-  static #appIdOn(appId: AkanMobileAppId, platform: "ios" | "android"): string | null {
+  static #appIdOn(appId: AkanNativeAppId, platform: "ios" | "android"): string | null {
     return typeof appId === "string" ? appId : (appId[platform] ?? appId.default ?? null);
   }
 

package/mobile/desktopBin.test.ts

@@ -28,7 +28,7 @@ const stage = async (
   bin: AkanBinConfig,
   { libBins = [], libs = [] }: { libBins?: { lib: string; bin: AkanBinConfig }[]; libs?: string[] } = {},
 ) => {
-  const binDir = path.join(root, "apps/portal/.akan/mobile/default/bin");
+  const binDir = path.join(root, "apps/portal/.akan/native/default/bin");
   const config = { app: { name: "portal" }, bin, libBins } as never;
   const carried = await new DesktopBin(fakeApp(path.join(root, "apps/portal"), libs), config).stage(binDir);
   return { carried, binDir };

package/mobile/desktopServerStage.ts

@@ -1,6 +1,6 @@
 import { cp, mkdir, readdir, rm, writeFile } from "node:fs/promises";
 import path from "node:path";
-import type { AkanAppConfig, MobileEnv } from "../akanConfig";
+import type { AkanAppConfig, NativeEnv } from "../akanConfig";
 import type { App } from "../commandDecorators";
 import type { PackageJson } from "../types";
 import { DesktopBin } from "./desktopBin";
@@ -40,11 +40,11 @@ export class DesktopServerStage {
   static assertCarriable(config: AkanAppConfig) {
     if (!config.database.modes.includes("single"))
       throw new Error(
-        `native.desktop.server puts the server in the app, where only database mode single runs (no Redis or Postgres); apps/${config.app.name}/akan.config.ts declares ${config.database.modes.join(", ")}.`,
+        `desktop.server in native puts the server in the app, where only database mode single runs (no Redis or Postgres); apps/${config.app.name}/akan.config.ts declares ${config.database.modes.join(", ")}.`,
       );
   }
 
-  static env(config: AkanAppConfig, environment: MobileEnv): Record<string, string> {
+  static env(config: AkanAppConfig, environment: NativeEnv): Record<string, string> {
     //? The launcher picks the port, and the log file stays on: a user's computer has no log collector.
     const { PORT: _port, AKAN_LOG_TO_FILE: _fileLog, ...image } = config.getProductionEnv(environment);
     return {
@@ -122,7 +122,7 @@ export class DesktopServerStage {
   }
 
   //? Copies the build beside what `install` put in the stage, so it runs after both.
-  async prepare(environment: MobileEnv): Promise<DesktopServerBundle> {
+  async prepare(environment: NativeEnv): Promise<DesktopServerBundle> {
     const config = await this.app.getConfig();
     const dist = this.app.dist.cwdPath;
     await mkdir(this.dir, { recursive: true });

package/mobile/mobileTarget.test.ts

@@ -1,5 +1,5 @@
 import { describe, expect, test } from "bun:test";
-import type { AkanMobileTargetConfig } from "../akanConfig";
+import type { AkanNativeTarget } from "../akanConfig";
 import type { App } from "../commandDecorators";
 import {
   appIdsOf,
@@ -17,9 +17,9 @@ const target = {
   appId: "com.akanjs.app",
   version: "1.0.0",
   buildNum: 1,
-} as AkanMobileTargetConfig;
+} as AkanNativeTarget;
 
-describe("mobile target helpers", () => {
+describe("native target helpers", () => {
   test("maps deep links into target base paths without duplicating prefixes", () => {
     expect(resolveMobilePath(target, "/order/123")).toBe("/akanjs/order/123");
     expect(resolveMobilePath(target, "/akanjs/order/123")).toBe("/akanjs/order/123");
@@ -32,7 +32,7 @@ describe("mobile target helpers", () => {
     expect(resolveAppId(appId, "android")).toBe("com.yeollege");
     expect(resolveAppId("com.one.app", "macos")).toBe("com.one.app");
     expect(() => resolveAppId({ ios: "com.puffinplanet.yeollege" }, "android")).toThrow(
-      "mobile.appId names no id for android",
+      "native.appId names no id for android",
     );
     expect(appIdsOf(appId)).toEqual(["com.yeollege", "com.puffinplanet.yeollege"]);
   });
@@ -42,11 +42,11 @@ describe("mobile target helpers", () => {
     expect(targetHtmlFilename({ ...target, basePath: undefined })).toBe("index.html");
   });
 
-  test("uses the configured mobile target as the only choice when one target is configured", async () => {
+  test("uses the configured native target as the only choice when one target is configured", async () => {
     const app = {
       getConfig: async () => ({
         basePaths: new Set(["akanjs", "soft", "office"]),
-        mobile: { targets: { akanjs: target } },
+        native: { targets: { akanjs: target } },
       }),
     } as unknown as App;
 
@@ -59,13 +59,13 @@ describe("mobile target helpers", () => {
     const appWith = (basePaths: string[]) =>
       ({
         name: "angelo",
-        getConfig: async () => ({ basePaths: new Set(basePaths), mobile: { targets: { default: template } } }),
+        getConfig: async () => ({ basePaths: new Set(basePaths), native: { targets: { default: template } } }),
       }) as unknown as App;
 
     const two = appWith(["soft", "office"]);
     await expect(getMobileTargetChoices(two)).resolves.toEqual(["soft", "office"]);
     await expect(resolveMobileTargets(two, undefined)).rejects.toThrow(
-      "Multiple mobile targets found for angelo. Pass --target <soft|office|all>.",
+      "Multiple native targets found for angelo. Pass --target <soft|office|all>.",
     );
     await expect(resolveMobileTargets(two, "office")).resolves.toEqual([
       { name: "office", config: { ...template, name: "office", basePath: "office" } },
@@ -85,11 +85,11 @@ describe("mobile target helpers", () => {
     ]);
   });
 
-  test("resolves a route base path onto the default mobile target config", async () => {
+  test("resolves a route base path onto the default native target config", async () => {
     const app = {
       getConfig: async () => ({
         basePaths: new Set(["akanjs", "soft", "office"]),
-        mobile: { targets: { akanjs: target } },
+        native: { targets: { akanjs: target } },
       }),
     } as unknown as App;