@akanjs/cli 3.0.0-beta.8 → 3.0.0

package/index-gbggbqcp.js

@@ -0,0 +1,1058 @@
+// @bun
+import {
+  binPlatforms,
+  Executor
+} from "./index-3w94e7n3.js";
+
+// pkgs/@akanjs/devkit/mobile/mobileTarget.ts
+var trimSlashes = (value) => value.replace(/^\/+|\/+$/g, "");
+var getMobileTargets = async (app) => {
+  const config = await app.getConfig();
+  return Object.entries(config.native.targets).map(([name, target]) => ({ name, config: target }));
+};
+var isTemplateOnly = ({ basePaths, native }) => basePaths.size > 0 && Object.values(native.targets).every((target) => !target.basePath);
+var getMobileTargetChoices = async (app) => {
+  const config = await app.getConfig();
+  const targetNames = Object.keys(config.native.targets);
+  if (targetNames.length > 0 && !isTemplateOnly(config))
+    return targetNames;
+  return [...config.basePaths];
+};
+var resolveMobileTargetByBasePath = (targets, basePath) => {
+  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;
+  return {
+    name: normalizedBasePath,
+    config: { ...template.config, name: normalizedBasePath, basePath: normalizedBasePath }
+  };
+};
+var resolveMobileTargets = async (app, selection) => {
+  const config = await app.getConfig();
+  const targets = await getMobileTargets(app);
+  if (targets.length === 0)
+    throw new Error(`No native targets configured for ${app.name}`);
+  if (!selection && targets.length === 1 && !isTemplateOnly(config))
+    return targets;
+  if (!selection) {
+    const choices = await getMobileTargetChoices(app);
+    if (choices.length === 1)
+      return resolveMobileTargets(app, choices[0]);
+    throw new Error(`Multiple native targets found for ${app.name}. Pass --target <${choices.join("|")}|all>.`);
+  }
+  if (selection === "all") {
+    if (Object.keys(config.native.targets).length > 1)
+      return targets;
+    const basePaths = [...config.basePaths];
+    if (basePaths.length > 1 || isTemplateOnly(config)) {
+      return basePaths.flatMap((basePath) => {
+        const resolved = resolveMobileTargetByBasePath(targets, basePath);
+        return resolved ? [resolved] : [];
+      });
+    }
+    return targets;
+  }
+  const target = targets.find((candidate) => candidate.name === selection);
+  if (target)
+    return [target];
+  const basePathTarget = resolveMobileTargetByBasePath(targets, selection);
+  if (basePathTarget && config.basePaths.has(trimSlashes(selection)))
+    return [basePathTarget];
+  const choices = await getMobileTargetChoices(app);
+  throw new Error(`Native target '${selection}' was not found. Available: ${choices.join(", ")}`);
+};
+var resolveAppId = (appId, platform) => {
+  if (typeof appId === "string")
+    return appId;
+  const id = appId[platform] ?? appId.default;
+  if (!id)
+    throw new Error(`native.appId names no id for ${platform}; give it ${platform} or default.`);
+  return id;
+};
+var appIdsOf = (appId) => typeof appId === "string" ? [appId] : Object.values(appId).filter((id) => !!id);
+var targetHtmlFilename = (target) => {
+  const basePath = trimSlashes(target.basePath ?? "");
+  return basePath ? `${basePath}.html` : "index.html";
+};
+
+// pkgs/@akanjs/devkit/mobile/nativeApp.ts
+import path6 from "path";
+
+// pkgs/@akanjs/devkit/mobile/desktopBin.ts
+import { chmod, mkdir, rename, rm, writeFile } from "fs/promises";
+import path from "path";
+class DesktopBin {
+  app;
+  config;
+  constructor(app, config) {
+    this.app = app;
+    this.config = config;
+  }
+  static platform(arch = process.arch) {
+    const platform = `${process.platform}-${arch}`;
+    return binPlatforms.includes(platform) ? platform : null;
+  }
+  static select(config, libs) {
+    const chosen = new Map;
+    for (const [name, platforms] of Object.entries(config.bin))
+      chosen.set(name, { owner: `apps/${config.app.name}/akan.config.ts`, platforms });
+    for (const { lib, bin } of config.libBins) {
+      if (!libs.includes(lib))
+        continue;
+      const owner = `libs/${lib}/akan.config.ts`;
+      for (const [name, platforms] of Object.entries(bin)) {
+        const held = chosen.get(name);
+        if (!held)
+          chosen.set(name, { owner, platforms });
+        else if (held.owner.startsWith("libs/") && JSON.stringify(held.platforms) !== JSON.stringify(platforms))
+          throw new Error(`${held.owner} and ${owner} declare bin.${name} differently; declare it in apps/${config.app.name}/akan.config.ts to pick one.`);
+      }
+    }
+    return chosen;
+  }
+  static fileName(name, executable, platform = process.platform) {
+    if (platform !== "win32" || /\.(exe|cmd|bat|com)$/i.test(name))
+      return name;
+    return `${name}${path.extname(executable).toLowerCase() || ".exe"}`;
+  }
+  static downloadName(url) {
+    const extension = /(?:\.tar)?\.[A-Za-z0-9]{1,8}$/.exec(path.posix.basename(new URL(url).pathname))?.[0] ?? "";
+    return `download${extension.toLowerCase()}`;
+  }
+  static extractCommand(archive, dir, platform = process.platform) {
+    if (platform === "linux" && /\.zip$/i.test(archive))
+      return ["unzip", "-q", "-o", archive, "-d", dir];
+    const tar = platform === "win32" ? path.join(process.env.SystemRoot ?? "C:\\Windows", "System32", "tar.exe") : "tar";
+    return [tar, "-xf", archive, "-C", dir];
+  }
+  static async sha256(file) {
+    return new Bun.CryptoHasher("sha256").update(await Bun.file(file).arrayBuffer()).digest("hex");
+  }
+  get #cacheDir() {
+    return path.join(this.app.cwdPath, ".akan", "cache", "bin");
+  }
+  async stage(dir, arch = process.arch) {
+    const scanInfo = this.app.getScanInfo({ allowEmpty: true }) ?? await this.app.scan({ write: false });
+    const chosen = DesktopBin.select(this.config, scanInfo.getLibs());
+    if (!chosen.size)
+      return [];
+    const platform = DesktopBin.platform(arch);
+    if (!platform)
+      throw new Error(`bin: this desktop app is for ${process.platform}-${arch}, and a bin names only ${binPlatforms.join(", ")}.`);
+    await rm(dir, { recursive: true, force: true });
+    await mkdir(dir, { recursive: true });
+    for (const [name, { owner, platforms }] of chosen) {
+      const source = platforms[platform];
+      if (!source)
+        throw new Error(`${owner}: bin.${name} names no ${platform} file, the platform this desktop app is built for (it names ${Object.keys(platforms).join(", ") || "none"}).`);
+      const executable = await this.#executable(`${owner}: bin.${name}.${platform}`, source);
+      const target = path.join(dir, DesktopBin.fileName(name, executable));
+      await Bun.write(target, Bun.file(executable));
+      await chmod(target, 493);
+      this.app.logger.info(`The desktop app carries ${name} from ${"url" in source ? source.url : source.path}`);
+    }
+    return [...chosen.keys()];
+  }
+  async#executable(at, source) {
+    const file = "url" in source ? await this.#download(at, source) : source.path;
+    if (!await Bun.file(file).exists())
+      throw new Error(`${at}: ${file} does not exist`);
+    if (!source.file)
+      return file;
+    const key = "url" in source ? source.sha256 : await DesktopBin.sha256(file);
+    const executable = path.join(await this.#extract(file, key), ...source.file.split("/"));
+    if (!await Bun.file(executable).exists())
+      throw new Error(`${at}: the archive holds no ${source.file}`);
+    return executable;
+  }
+  async#download(at, { url, sha256 }) {
+    const dir = path.join(this.#cacheDir, sha256);
+    const file = path.join(dir, DesktopBin.downloadName(url));
+    if (await Bun.file(file).exists())
+      return file;
+    await mkdir(dir, { recursive: true });
+    this.app.logger.info(`Downloading ${url}`);
+    const res = await fetch(url, { signal: AbortSignal.timeout(600000) });
+    if (!res.ok)
+      throw new Error(`${at}: ${url} answered ${res.status}`);
+    const bytes = new Uint8Array(await res.arrayBuffer());
+    const digest = new Bun.CryptoHasher("sha256").update(bytes).digest("hex");
+    if (digest !== sha256)
+      throw new Error(`${at}: ${url} hashes to ${digest}, not the declared ${sha256}`);
+    await Bun.write(`${file}.partial`, bytes);
+    await rename(`${file}.partial`, file);
+    return file;
+  }
+  async#extract(archive, key) {
+    const dir = path.join(this.#cacheDir, key, "extracted");
+    if (await Bun.file(`${dir}.done`).exists())
+      return dir;
+    await rm(dir, { recursive: true, force: true });
+    await mkdir(dir, { recursive: true });
+    const [command = "tar", ...args] = DesktopBin.extractCommand(archive, dir);
+    if (command === "unzip" && !Bun.which("unzip"))
+      throw new Error(`${archive} is a zip, and this computer has no unzip: install it, or use a .tar.gz or .tar.xz.`);
+    await this.app.spawn(command, args, { cwd: dir });
+    await writeFile(`${dir}.done`, "");
+    return dir;
+  }
+}
+
+// pkgs/@akanjs/devkit/mobile/nativeApi.ts
+import path2 from "path";
+
+class NativeApi {
+  static supportedMajor = 0;
+  static entryOf(appDir) {
+    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 path2.join(path2.dirname(akanjsPackage), "vendor", "@akanjs", "native", "packages", "cli", "src", "api.ts");
+  }
+  static async load(appDir) {
+    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);
+    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, from) {
+    try {
+      return Bun.resolveSync(specifier, from);
+    } catch {
+      return null;
+    }
+  }
+}
+
+// pkgs/@akanjs/devkit/mobile/nativeAppLine.ts
+class NativeAppLine {
+  static #page = /^\[page(\+)?(?:#(\d+))? (trace|verbose|debug|log|info|warn|error)\] ?(.*)$/;
+  static #logcat = /^([VDIWEFA])\/([^(]+?)\s*\(\s*\d+\):\s?(.*)$/;
+  static #named = /^\[([^\]\s]+)\] ([\s\S]*)$/;
+  static #server = /^\[server\] /;
+  static #serverLevel = /\b(TRACE|VERBOSE|DEBUG|INFO|WARN|ERROR)\b/;
+  static #logcatLevels = {
+    V: "verbose",
+    D: "debug",
+    I: "info",
+    W: "warn",
+    E: "error",
+    F: "error",
+    A: "error"
+  };
+  static read(line, { verbose = false } = {}) {
+    const logcat = NativeAppLine.#logcat.exec(line);
+    if (logcat) {
+      const [, priority = "I", tag = "", text = ""] = logcat;
+      const level = NativeAppLine.#logcatLevels[priority] ?? "info";
+      if (tag === "AkanNativeConsole")
+        return NativeAppLine.#pageLine(level, text, { continuation: false });
+      if (tag === "AkanNative")
+        return NativeAppLine.#hostLine(`[akan-native] ${text}`, level);
+      return { level, message: `[${tag}] ${text}` };
+    }
+    const page = NativeAppLine.#page.exec(line);
+    if (page) {
+      const [, continuation, window, level = "info", text = ""] = page;
+      return NativeAppLine.#pageLine(level === "log" ? "info" : level, text, {
+        continuation: continuation === "+",
+        window
+      });
+    }
+    if (line.startsWith("[akan-native"))
+      return NativeAppLine.#hostLine(line, "info");
+    if (NativeAppLine.#server.test(line)) {
+      const word = NativeAppLine.#serverLevel.exec(Bun.stripANSI(line))?.[1];
+      return { level: word ? word.toLowerCase() : "info", message: line };
+    }
+    return { level: verbose ? "info" : "debug", message: line };
+  }
+  static #pageLine(level, text, { continuation, window }) {
+    if (continuation)
+      return { level, message: `  ${text}` };
+    const named = NativeAppLine.#named.exec(text);
+    const scope = `page${window ? `#${window}` : ""}${named ? `:${named[1]}` : ""}`;
+    return { level, message: `[${scope}] ${named ? named[2] : text}` };
+  }
+  static #hostLine(line, level) {
+    return { level: /\bpages from\b/.test(line) ? "debug" : level, message: line };
+  }
+}
+
+// pkgs/@akanjs/devkit/mobile/nativeConfig.ts
+import { readFileSync } from "fs";
+import path3 from "path";
+
+// pkgs/@akanjs/devkit/mobile/usageDescriptions.ts
+import { capitalize } from "akanjs/common";
+var iosUsageDescriptionKeys = {
+  cameraUsageDescription: ["NSCameraUsageDescription"],
+  photoAddUsageDescription: ["NSPhotoLibraryAddUsageDescription"],
+  photoUsageDescription: ["NSPhotoLibraryUsageDescription"],
+  contactsUsageDescription: ["NSContactsUsageDescription"],
+  locationAlwaysUsageDescription: ["NSLocationAlwaysAndWhenInUseUsageDescription", "NSLocationAlwaysUsageDescription"],
+  locationWhenInUseUsageDescription: ["NSLocationWhenInUseUsageDescription"],
+  microphoneUsageDescription: ["NSMicrophoneUsageDescription"],
+  speechRecognitionUsageDescription: ["NSSpeechRecognitionUsageDescription"]
+};
+var toIosInfoPlistUsageDescriptions = (descriptions) => Object.fromEntries(Object.entries(descriptions).flatMap(([key, value]) => {
+  const plistKeys = Object.hasOwn(iosUsageDescriptionKeys, key) ? iosUsageDescriptionKeys[key] : [`NS${capitalize(key)}`];
+  return plistKeys.map((plistKey) => [plistKey, value]);
+}));
+
+// pkgs/@akanjs/devkit/mobile/nativeConfig.ts
+class NativeConfig {
+  static basePlugins = [
+    "app",
+    "app-state",
+    "browser",
+    "opener",
+    "auth-session",
+    "device",
+    "dialog",
+    "keyboard",
+    "preferences",
+    "secure-storage",
+    "haptics"
+  ];
+  static builtinContributions = {
+    camera: {
+      permission: "camera",
+      plugins: ["camera"],
+      usageDescriptions: {
+        cameraUsageDescription: "$(PRODUCT_NAME) requires access to the camera to take photos.",
+        photoAddUsageDescription: "$(PRODUCT_NAME) requires access to the photo library to take photos.",
+        photoUsageDescription: "$(PRODUCT_NAME) requires access to the photo library to take photos."
+      }
+    },
+    contacts: {
+      permission: "contacts",
+      plugins: ["contacts"],
+      usageDescriptions: {
+        contactsUsageDescription: "$(PRODUCT_NAME) requires access to the contacts to find people you know."
+      }
+    },
+    location: {
+      permission: "location",
+      plugins: ["geolocation"],
+      usageDescriptions: {
+        locationAlwaysUsageDescription: "$(PRODUCT_NAME) requires access to the location to get the user's location.",
+        locationWhenInUseUsageDescription: "$(PRODUCT_NAME) requires access to the location to get the user's location."
+      }
+    },
+    push: { permission: "push", plugins: ["push"] },
+    speech: { permission: "speech" }
+  };
+  static build({
+    appPath,
+    target,
+    webDir,
+    contributions,
+    locales,
+    env,
+    platform,
+    desktopServer,
+    nativePlugins = [],
+    desktopBin
+  }) {
+    const warnings = [];
+    const applied = (target.permissions ?? []).flatMap((permission) => {
+      const claimed = contributions.filter((contribution) => contribution.permission === permission);
+      const used = claimed.length ? claimed : [NativeConfig.builtinContributions[permission]];
+      if (!used.some((contribution) => contribution.plugins?.length))
+        warnings.push(`Permission '${permission}' has no native plugin yet; the app ships without it.`);
+      return used;
+    });
+    const abs = (relative) => path3.resolve(appPath, relative);
+    const updates = NativeConfig.#updates(target, env);
+    const folders = new Set(nativePlugins.map((plugin) => path3.resolve(plugin.dir)));
+    const folderIds = new Set(nativePlugins.map((plugin) => plugin.id));
+    const listed = (target.plugins ?? []).filter((spec) => NativeConfig.#isId(spec) ? !folderIds.has(spec) : !folders.has(path3.resolve(appPath, spec)));
+    const plugins = [
+      ...new Set([
+        ...NativeConfig.basePlugins,
+        ...target.deepLinks?.schemes?.length ? ["single-instance"] : [],
+        ...applied.flatMap((contribution) => contribution.plugins ?? []),
+        ...desktopServer ? ["single-instance"] : [],
+        ...updates ? ["updates"] : [],
+        ...listed,
+        ...nativePlugins.map((plugin) => plugin.dir)
+      ])
+    ];
+    const pluginIds = plugins.map((spec) => nativePlugins.find((plugin) => plugin.dir === spec)?.id ?? NativeConfig.#pluginId(appPath, spec));
+    const usageDescriptions = Object.fromEntries(Object.entries(toIosInfoPlistUsageDescriptions(Object.assign({}, ...applied.map((contribution) => contribution.usageDescriptions ?? {})))).map(([key, text]) => [key, text.replaceAll("$(PRODUCT_NAME)", target.appName)]));
+    const ios = NativeConfig.#compact({
+      infoPlist: NativeConfig.#merged(applied.map((c) => c.infoPlist), target.ios?.infoPlist),
+      entitlements: NativeConfig.#merged(applied.map((c) => c.entitlements), target.ios?.entitlements)
+    });
+    const manifest = [
+      ...[...new Set(applied.flatMap((c) => c.androidPermissions ?? []))].map((name) => `<uses-permission android:name="android.permission.${name}" />`),
+      ...[...new Set(applied.flatMap((c) => c.androidFeatures ?? []))].map((name) => `<uses-feature android:name="${name}" android:required="false" />`),
+      ...target.android?.manifest ?? []
+    ];
+    const android = NativeConfig.#compact({
+      manifest,
+      application: target.android?.application ?? [],
+      activity: target.android?.activity ?? []
+    });
+    const resources = [
+      ...Object.entries(target.ios?.files ?? {}).map(([to, from]) => ({ from: abs(from), to: `ios/${to}` })),
+      ...Object.entries(target.android?.files ?? {}).map(([to, from]) => ({ from: abs(from), to: `android/${to}` }))
+    ];
+    const macos = NativeConfig.#compact({ entitlements: target.desktop?.entitlements });
+    const native = NativeConfig.#compact({ ios, macos, android, resources });
+    const googleServices = target.android?.googleServices;
+    const pushAndroid = target.android?.push;
+    const desktop = NativeConfig.#compact({
+      recovery: target.desktop?.recovery,
+      screenCapture: target.desktop?.screenCapture,
+      window: NativeConfig.#compact({ ...target.desktop?.window }),
+      server: desktopServer,
+      bin: desktopBin
+    });
+    const config = {
+      app: {
+        id: resolveAppId(target.appId, platform),
+        name: target.appName,
+        fileName: target.fileName ?? NativeConfig.fileNameOf(path3.basename(appPath)),
+        version: target.version,
+        build: target.buildNum
+      },
+      web: { dir: webDir },
+      plugins,
+      capabilities: [
+        {
+          identifier: "app",
+          description: `The plugins ${target.appName} ships, each with its default permissions`,
+          permissions: pluginIds.map((id) => `${id}:default`)
+        }
+      ],
+      ...Object.keys(usageDescriptions).length ? { usageDescriptions } : {},
+      ...target.deepLinks?.schemes?.length || target.deepLinks?.domains?.length ? { deepLinks: NativeConfig.#deepLinks(target, locales) } : {},
+      ...native ? { native } : {},
+      ...updates ? { updates } : {},
+      ...pushAndroid ? {
+        push: {
+          android: { ...pushAndroid, ...pushAndroid.smallIcon ? { smallIcon: abs(pushAndroid.smallIcon) } : {} }
+        }
+      } : {},
+      ...target.ios?.privacy ? { privacy: target.ios.privacy } : {},
+      android: {
+        debugAppIdSuffix: ".debug",
+        ...googleServices ? { googleServices: abs(googleServices) } : {},
+        ...target.android?.autoplay ? { autoplay: true } : {}
+      },
+      keyboard: { resize: "none" },
+      ...desktop ? { desktop } : {},
+      ...target.icon ? { icon: NativeConfig.#icon(target.icon, abs) } : {},
+      ...target.splash ? { splash: NativeConfig.#splash(target.splash, abs) } : {}
+    };
+    return { config, warnings };
+  }
+  static #icon(icon, abs) {
+    return typeof icon === "string" ? abs(icon) : { ...icon, image: abs(icon.image) };
+  }
+  static #splash(splash, abs) {
+    if (typeof splash === "string")
+      return { image: abs(splash) };
+    return { ...splash, ...splash.image ? { image: abs(splash.image) } : {} };
+  }
+  static #updates(target, env) {
+    const { url, publicKey, channel = env, ...rest } = target.updates ?? {};
+    return url && publicKey ? { ...rest, url, publicKey, ...channel ? { channel } : {} } : undefined;
+  }
+  static fileNameOf(name) {
+    return name.replace(/[^A-Za-z0-9._-]/g, "-").replace(/^[-.]+|[-.]+$/g, "") || "app";
+  }
+  static #pluginId(appPath, spec) {
+    if (NativeConfig.#isId(spec))
+      return spec;
+    try {
+      const { id } = JSON.parse(readFileSync(path3.join(path3.resolve(appPath, spec), "native-plugin.json"), "utf8"));
+      return typeof id === "string" ? id : spec;
+    } catch {
+      return spec;
+    }
+  }
+  static #isId(spec) {
+    return !spec.startsWith(".") && !path3.isAbsolute(spec);
+  }
+  static #compact(value) {
+    const kept = Object.entries(value).filter(([, entry]) => Array.isArray(entry) ? entry.length > 0 : entry && typeof entry === "object" ? Object.keys(entry).length > 0 : entry !== undefined);
+    return kept.length ? Object.fromEntries(kept) : undefined;
+  }
+  static #merged(contributed, own) {
+    return Object.assign({}, ...contributed, own);
+  }
+  static #deepLinks(target, locales) {
+    const basePath = target.basePath?.replace(/^\/+|\/+$/g, "");
+    const pathPrefixes = basePath ? locales.map((locale) => `/${locale}/${basePath}`) : undefined;
+    return {
+      ...target.deepLinks?.schemes?.length ? { schemes: target.deepLinks.schemes } : {},
+      ...target.deepLinks?.domains?.length ? { domains: target.deepLinks.domains.map((host) => pathPrefixes ? { host, pathPrefixes } : host) } : {}
+    };
+  }
+}
+
+// pkgs/@akanjs/devkit/mobile/nativePluginFolders.ts
+import { readdir } from "fs/promises";
+import path4 from "path";
+
+class NativePluginFolders {
+  static folder = "native";
+  static async in(root, owner) {
+    const base = path4.join(root, NativePluginFolders.folder);
+    const entries = await readdir(base, { withFileTypes: true }).catch(() => []);
+    const folders = entries.filter((entry) => entry.isDirectory()).map((entry) => entry.name);
+    return await Promise.all(folders.sort().map(async (name) => {
+      const where = `${owner}/${NativePluginFolders.folder}/${name}`;
+      const manifest = Bun.file(path4.join(base, name, "native-plugin.json"));
+      if (!await manifest.exists())
+        throw new Error(`${where} has no native-plugin.json; a folder in native/ is one native plugin.`);
+      const { id } = await manifest.json();
+      if (id !== name)
+        throw new Error(`${where}/native-plugin.json has id ${JSON.stringify(id)}; name the folder after its id.`);
+      return { id, dir: path4.join(base, name), owner };
+    }));
+  }
+  static select(own, fromLibs) {
+    const chosen = new Map(own.map((plugin) => [plugin.id, plugin]));
+    for (const plugin of fromLibs) {
+      const held = chosen.get(plugin.id);
+      if (!held)
+        chosen.set(plugin.id, plugin);
+      else if (held.owner.startsWith("libs/"))
+        throw new Error(`${held.owner} and ${plugin.owner} both hold native plugin "${plugin.id}"; give the app its own native/${plugin.id} to pick one.`);
+    }
+    return [...chosen.values()];
+  }
+  static async of(app) {
+    const scanInfo = app.getScanInfo({ allowEmpty: true }) ?? await app.scan({ write: false });
+    const root = app.workspace.workspaceRoot;
+    const [own, ...fromLibs] = await Promise.all([
+      NativePluginFolders.in(app.cwdPath, `apps/${app.name}`),
+      ...scanInfo.getLibs().map((lib) => NativePluginFolders.in(path4.join(root, "libs", lib), `libs/${lib}`))
+    ]);
+    return NativePluginFolders.select(own ?? [], fromLibs.flat());
+  }
+}
+
+// pkgs/@akanjs/devkit/mobile/nativeWebDir.ts
+import { cp, mkdir as mkdir2, rm as rm2, stat } from "fs/promises";
+import path5 from "path";
+
+class NativeWebDir {
+  dir;
+  static reservedEntry = "__akan_native";
+  constructor(dir) {
+    this.dir = dir;
+  }
+  static injectTarget(html, target) {
+    if (html.includes(NativeWebDir.#targetTag))
+      return html;
+    const basePath = target.basePath?.replace(/^\/+|\/+$/g, "") ?? "";
+    const script = `${NativeWebDir.#targetTag}${JSON.stringify({
+      name: target.name,
+      basePath,
+      indexPath: target.indexPath
+    })};</script>`;
+    const head = /<head(?:\s[^>]*)?>/i.exec(html);
+    if (!head)
+      return `${script}
+${html}`;
+    const at = head.index + head[0].length;
+    return `${html.slice(0, at)}
+${script}${html.slice(at)}`;
+  }
+  static #targetTag = "<script>window.__AKAN_MOBILE_TARGET__=";
+  async clear() {
+    await rm2(this.dir, { recursive: true, force: true });
+    await mkdir2(this.dir, { recursive: true });
+  }
+  async assemble(target, { html, publicDir, fontsDir }) {
+    if (!await Bun.file(html).exists())
+      throw new Error(`CSR html for native target '${target.name}' not found: ${html}`);
+    await this.clear();
+    if (publicDir && await NativeWebDir.#isDir(publicDir))
+      await cp(publicDir, this.dir, { recursive: true });
+    if (fontsDir && await NativeWebDir.#isDir(fontsDir))
+      await cp(fontsDir, path5.join(this.dir, "_akan", "fonts"), { recursive: true });
+    if (await NativeWebDir.#isDir(path5.join(this.dir, NativeWebDir.reservedEntry)))
+      throw new Error(`public/${NativeWebDir.reservedEntry} is reserved for the native runtime.`);
+    await Bun.write(path5.join(this.dir, "index.html"), NativeWebDir.injectTarget(await Bun.file(html).text(), target));
+    const files = await Array.fromAsync(new Bun.Glob("**/*").scan({ cwd: this.dir, onlyFiles: true, dot: true }));
+    return files.map((file) => file.split(path5.sep).join("/")).sort();
+  }
+  static async#isDir(dir) {
+    try {
+      return (await stat(dir)).isDirectory();
+    } catch {
+      return false;
+    }
+  }
+}
+
+// pkgs/@akanjs/devkit/mobile/nativeApp.ts
+class NativeApp {
+  app;
+  target;
+  env;
+  targetRoot;
+  web;
+  #boot = null;
+  constructor(app, target, env) {
+    this.app = app;
+    this.target = target;
+    this.env = env;
+    this.targetRoot = path6.join(app.cwdPath, ".akan", "native", target.name);
+    this.web = new NativeWebDir(path6.join(this.targetRoot, "web"));
+  }
+  outDir(platform) {
+    return path6.join(this.targetRoot, "build", platform);
+  }
+  devOutDir(platform) {
+    return path6.join(this.targetRoot, "dev", platform);
+  }
+  indexPath(platform) {
+    const { config } = this.target;
+    const section = platform === "ios" ? config.ios : platform === "android" ? config.android : config.desktop;
+    return section?.indexPath ?? config.indexPath;
+  }
+  async assembleWeb(platform) {
+    const dist = this.app.dist.cwdPath;
+    return await this.web.assemble({ ...this.target.config, indexPath: this.indexPath(platform) }, {
+      html: path6.join(dist, "csr", targetHtmlFilename(this.target.config)),
+      publicDir: path6.join(dist, "public"),
+      fontsDir: path6.join(dist, ".akan", "artifact", "fonts")
+    });
+  }
+  get binDir() {
+    return path6.join(this.targetRoot, "bin");
+  }
+  async config({
+    server,
+    platform,
+    stageBin = true,
+    arch
+  }) {
+    const [appConfig, plugins, nativePlugins] = await Promise.all([
+      this.app.getConfig(),
+      this.app.collectPlugins(),
+      NativePluginFolders.of(this.app)
+    ]);
+    const desktop = platform === "macos" || platform === "windows" || platform === "linux";
+    const carried = desktop && stageBin ? await new DesktopBin(this.app, appConfig).stage(this.binDir, arch) : [];
+    return NativeConfig.build({
+      appPath: this.app.cwdPath,
+      target: this.target.config,
+      webDir: this.web.dir,
+      contributions: plugins.flatMap((plugin) => plugin.native ? [plugin.native] : []),
+      locales: appConfig.i18n.locales,
+      env: this.env,
+      platform,
+      nativePlugins,
+      ...server ? { desktopServer: server } : {},
+      ...carried.length ? { desktopBin: this.binDir } : {}
+    });
+  }
+  async prepare(platform, server, arch) {
+    const [api, { config, warnings }] = await Promise.all([
+      NativeApi.load(this.app.cwdPath),
+      this.config({ platform, ...server ? { server } : {}, ...arch ? { arch } : {} })
+    ]);
+    for (const warning of warnings)
+      this.app.logger.warn(warning);
+    this.#assertValid(api, config);
+    return { api, config };
+  }
+  #assertValid(api, config) {
+    const problems = api.validateConfig(config, { appDir: this.app.cwdPath });
+    if (problems.length)
+      throw new Error(`Native target '${this.target.name}' makes an invalid native config:
+- ${problems.join(`
+- `)}`);
+  }
+  #appLine = (line) => {
+    const read = NativeAppLine.read(line, { verbose: Executor.verbose });
+    if (this.#boot)
+      this.#boot.lines.push(read);
+    else
+      this.app.logger[read.level](read.message);
+  };
+  #task(platform, config, outDir = this.outDir(platform)) {
+    return {
+      appDir: this.app.cwdPath,
+      config,
+      platform,
+      outDir,
+      envFiles: false,
+      skipWebBuild: true,
+      log: (event) => {
+        if (event.level === "error")
+          this.app.logger.error(event.message);
+        else if (event.level === "warn")
+          this.app.logger.warn(event.message);
+        else if (this.#boot)
+          this.#boot.steps.push(event.message);
+        else if (event.level === "tool")
+          this.app.logger.verbose(event.message);
+        else
+          this.app.logger.info(event.message);
+      }
+    };
+  }
+  async build(platform, { profile = "release", server, installer = false, arch } = {}) {
+    NativeApp.#assertServerPlatform(platform, server);
+    NativeApp.assertInstaller(platform, installer);
+    await this.assembleWeb(platform);
+    const { api, config } = await this.prepare(platform, server, arch);
+    return await api.build({
+      ...this.#task(platform, config),
+      profile,
+      ...arch ? { arch } : {},
+      ...platform === "windows" ? {
+        windows: {
+          ...installer ? { installer } : {},
+          ...profile === "release" ? NativeApp.#windowsSigning(api) : {}
+        }
+      } : {},
+      ...platform === "macos" ? {
+        macos: {
+          ...profile === "release" ? api.macosDistributionFromEnv(process.env) : {},
+          ...installer ? { dmg: true } : {}
+        }
+      } : {},
+      ...platform === "linux" && installer ? { linux: { appImage: true } } : {}
+    });
+  }
+  async run(platform, { device, teamId, profile = "debug", server } = {}) {
+    NativeApp.#assertServerPlatform(platform, server);
+    await this.assembleWeb(platform);
+    const { api, config } = await this.prepare(platform, server);
+    return await api.run({
+      ...this.#task(platform, config),
+      profile,
+      onLine: this.#appLine,
+      ...device ? { device } : {},
+      ...teamId ? { ios: { signing: { teamId } } } : {}
+    });
+  }
+  async dev(platform, { upstream, lang, device, teamId }) {
+    const startedAt = performance.now();
+    const boot = { steps: [], lines: [] };
+    this.#boot = boot;
+    try {
+      await this.web.clear();
+      const [{ api, config }, { api: routes }] = await Promise.all([this.prepare(platform), this.app.getConfig()]);
+      const session = await api.dev({
+        ...this.#task(platform, config, this.devOutDir(platform)),
+        upstream,
+        hmrPath: "/_akan/hmr",
+        wsPaths: [`${routes.prefix}${routes.websocketPrefix}`],
+        reversePorts: [Number(new URL(upstream).port)],
+        onLine: this.#appLine,
+        startPath: this.startPath(lang, platform),
+        ...device ? { device } : {},
+        ...teamId ? { ios: { signing: { teamId } } } : {}
+      });
+      this.#boot = null;
+      this.app.logger.info(this.readyLine(platform, { upstream, device: session.device, startedAt }));
+      for (const step of [...boot.steps, `pages through ${session.gateway}`])
+        this.app.logger.debug(step);
+      for (const line of boot.lines)
+        this.app.logger[line.level](line.message);
+      return session;
+    } catch (error) {
+      this.#boot = null;
+      for (const step of boot.steps)
+        this.app.logger.info(step);
+      for (const line of boot.lines)
+        this.app.logger[line.level === "debug" ? "info" : line.level](line.message);
+      throw error;
+    }
+  }
+  readyLine(platform, { upstream, device, startedAt }) {
+    const label = platform === "ios" || platform === "android" ? platform : "desktop";
+    const target = this.target.name === "default" ? "" : `/${this.target.name}`;
+    const seconds = ((performance.now() - startedAt) / 1000).toFixed(1);
+    return [`${this.app.name}${target} ${label} ready`, ...device ? [device.name] : [], upstream, `${seconds}s`].join(" \xB7 ");
+  }
+  async releaseIos({ teamId, adHoc = false } = {}) {
+    await this.assembleWeb("ios");
+    const { api, config } = await this.prepare("ios");
+    return await api.release({
+      ...this.#task("ios", config),
+      platform: "ios",
+      signing: { ...teamId ? { teamId } : {}, ...adHoc ? { distribution: "ad-hoc" } : {} }
+    });
+  }
+  get updatesDir() {
+    return path6.join(this.targetRoot, "updates");
+  }
+  async publishUpdate(platform, { channel, server } = {}) {
+    NativeApp.#assertServerPlatform(platform, server);
+    this.#assertUpdates();
+    await this.assembleWeb(platform);
+    const { api, config } = await this.prepare(platform, server);
+    return await api.publishUpdate({
+      ...this.#task(platform, config),
+      platform,
+      out: this.updatesDir,
+      ...channel ? { channel } : {},
+      ...platform === "macos" ? { macos: api.macosDistributionFromEnv(process.env) } : {},
+      ...platform === "windows" ? { windows: NativeApp.#windowsSigning(api) } : {}
+    });
+  }
+  async assertPublishable(platform, { channel, server = false } = {}) {
+    this.#assertUpdates();
+    const [api, { config }] = await Promise.all([
+      NativeApi.load(this.app.cwdPath),
+      this.config({ platform, stageBin: false })
+    ]);
+    this.#assertValid(api, config);
+    try {
+      api.checkPublishUpdate({
+        appDir: this.app.cwdPath,
+        config,
+        platform,
+        out: this.updatesDir,
+        server,
+        ...channel ? { channel } : {}
+      });
+    } catch (error) {
+      throw new Error(`Native target '${this.target.name}': ${error instanceof Error ? error.message : String(error)}`, {
+        cause: error
+      });
+    }
+  }
+  #assertUpdates() {
+    if (!this.target.config.updates)
+      throw new Error(`Native target '${this.target.name}' has no updates: add native.updates: { url, publicKey } to akan.config.ts; \`akan update-keygen ${this.app.name}\` prints the key.`);
+  }
+  async updateKeygen(platform) {
+    const [api, { config }] = await Promise.all([
+      NativeApi.load(this.app.cwdPath),
+      this.config({ platform, stageBin: false })
+    ]);
+    return api.updateKeygen({ config });
+  }
+  async releaseAndroid({ formats = ["aab"] } = {}) {
+    const signing = NativeApp.androidSigning();
+    await this.assembleWeb("android");
+    const { api, config } = await this.prepare("android");
+    return await api.release({ ...this.#task("android", config), platform: "android", signing, formats });
+  }
+  async packUpdate(platform, { out } = {}) {
+    await this.assembleWeb(platform);
+    const { api, config } = await this.prepare(platform);
+    if (!config.updates)
+      throw new Error(`Native target '${this.target.name}' takes no updates: add native.updates: { url, publicKey } to akan.config.ts first.`);
+    const packed = await api.packUpdate({
+      ...this.#task(platform, config),
+      platform,
+      out: out ?? path6.join(this.targetRoot, "updates", platform)
+    });
+    return { ...packed, channel: config.updates.channel ?? "production" };
+  }
+  static async compareBundles(appDir, shipped, bundle) {
+    return (await NativeApi.load(appDir)).compareBundles(shipped, bundle);
+  }
+  static androidSigning(env = process.env) {
+    const keystore = env.MYAPP_RELEASE_STORE_FILE;
+    const storePassword = env.MYAPP_RELEASE_STORE_PASSWORD;
+    const alias = env.MYAPP_RELEASE_KEY_ALIAS;
+    const keyPassword = env.MYAPP_RELEASE_KEY_PASSWORD;
+    if (!keystore || !storePassword || !alias) {
+      const missing = Object.entries({
+        MYAPP_RELEASE_STORE_FILE: keystore,
+        MYAPP_RELEASE_STORE_PASSWORD: storePassword,
+        MYAPP_RELEASE_KEY_ALIAS: alias
+      }).flatMap(([key, value]) => value ? [] : [key]);
+      throw new Error(`An Android release is signed with the upload key; set ${missing.join(", ")} in the environment.`);
+    }
+    return { keystore, storePassword, alias, ...keyPassword ? { keyPassword } : {} };
+  }
+  startPath(lang, platform) {
+    const basePath = this.target.config.basePath?.replace(/^\/+|\/+$/g, "");
+    const indexPath = this.indexPath(platform);
+    const params = new URLSearchParams({ csr: "true", akanMobileTarget: this.target.name });
+    if (basePath)
+      params.set("akanMobileBasePath", basePath);
+    if (indexPath)
+      params.set("akanMobileIndexPath", indexPath);
+    const home = [lang, basePath, indexPath].flatMap((part) => (part ?? "").split("/")).filter((segment) => segment.length > 0);
+    return `/${home.join("/")}?${params}`;
+  }
+  static #windowsSigning(api) {
+    const signing = api.windowsSigningFromEnv(process.env);
+    return signing ? { signing } : {};
+  }
+  static assertInstaller(platform, installer) {
+    if (installer && (platform === "ios" || platform === "android"))
+      throw new Error(`An installer is built for a desktop app (Windows, macOS, Linux), not for ${platform}.`);
+  }
+  static #assertServerPlatform(platform, server) {
+    if (server && (platform === "ios" || platform === "android"))
+      throw new Error(`Only a desktop app carries its server; ${platform} cannot run one.`);
+  }
+  static desktopPlatform(host = process.platform) {
+    if (host === "darwin")
+      return "macos";
+    if (host === "win32")
+      return "windows";
+    if (host === "linux")
+      return "linux";
+    throw new Error(`A desktop app builds on macOS, Windows or Linux, not on ${host}.`);
+  }
+  static async devices(appDir, platform) {
+    return await (await NativeApi.load(appDir)).devices({ platform });
+  }
+  static async doctor(appDir, platforms) {
+    return await (await NativeApi.load(appDir)).doctor({ platforms });
+  }
+}
+
+// pkgs/@akanjs/devkit/mobile/placeholderAppId.ts
+var PLACEHOLDER_APP_IDS = [
+  "com.myapp.app",
+  "com.myorg.myapp",
+  "com.example.app",
+  "com.example.myapp"
+];
+var placeholderAppIdSegment = /^(example|examples|myorg|myapp|mycompany|myorganization|changeme|todo|sample|test)$/;
+var isPlaceholderAppId = (appId) => {
+  const normalized = appId?.trim().toLowerCase() ?? "";
+  if (!normalized)
+    return true;
+  if (PLACEHOLDER_APP_IDS.includes(normalized))
+    return true;
+  return normalized.split(".").some((segment) => placeholderAppIdSegment.test(segment));
+};
+// pkgs/@akanjs/devkit/mobile/desktopServerStage.ts
+import { cp as cp2, mkdir as mkdir3, readdir as readdir2, rm as rm3, writeFile as writeFile2 } from "fs/promises";
+import path7 from "path";
+class DesktopServerStage {
+  app;
+  static uncarried = new Set([
+    "Dockerfile",
+    "package.json",
+    "rscWorker.js",
+    "console.js",
+    "console-runtime.js",
+    "csr",
+    "public",
+    ".akan"
+  ]);
+  static rscRenderer = "react-server-dom-webpack";
+  dir;
+  constructor(app) {
+    this.app = app;
+    this.dir = path7.join(app.cwdPath, ".akan", "desktop", "server");
+  }
+  static assertCarriable(config) {
+    if (!config.database.modes.includes("single"))
+      throw new Error(`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, environment) {
+    const { PORT: _port, AKAN_LOG_TO_FILE: _fileLog, ...image } = config.getProductionEnv(environment);
+    return {
+      ...image,
+      AKAN_PUBLIC_OPERATION_MODE: "edge",
+      AKAN_DATABASE_MODE: "single",
+      AKAN_DATABASE_MODES: "single",
+      AKAN_SSR: "false",
+      AKAN_CSR: "false",
+      AKAN_MCP: "false",
+      AKAN_SHUTDOWN_TIMEOUT_MS: "1000"
+    };
+  }
+  static imageStepsNotice(config, carried) {
+    const steps = typeof config.docker === "string" ? null : config.docker.preRuns.length + config.docker.postRuns.length;
+    if (steps === 0)
+      return null;
+    const image = steps === null ? `apps/${config.app.name}/akan.config.ts writes its own Dockerfile` : `The image runs ${steps} docker step${steps === 1 ? "" : "s"} from the app and its libs`;
+    return carried.length ? {
+      level: "info",
+      message: `${image}; the desktop app's server runs none of them and carries only bin: ${carried.join(", ")}.`
+    } : {
+      level: "warn",
+      message: `${image}, and a desktop app's server runs none of them: declare in bin the executables its code spawns, or those calls fail on the user's computer.`
+    };
+  }
+  static packageJson(config, built, omit = []) {
+    const otherDrivers = new Set(config.database.modes.filter((mode) => mode !== "single").flatMap((mode) => config.getDatabaseModeRuntimePackages(mode)));
+    const dependencies = Object.entries(built.dependencies ?? {}).filter(([name]) => !omit.includes(name) && (config.externalLibs.includes(name) || name !== DesktopServerStage.rscRenderer && !otherDrivers.has(name)));
+    return { ...built, dependencies: Object.fromEntries(dependencies) };
+  }
+  static async dependentsOf(nodeModules, name) {
+    const dependents = new Set;
+    for await (const manifest of new Bun.Glob("**/package.json").scan({ cwd: nodeModules, onlyFiles: true })) {
+      const json = await Bun.file(path7.join(nodeModules, manifest)).json().catch(() => null);
+      if (!json?.name || json.name === name)
+        continue;
+      const declared = { ...json.dependencies, ...json.optionalDependencies, ...json.peerDependencies };
+      if (name in declared)
+        dependents.add(json.name);
+    }
+    return [...dependents].sort();
+  }
+  static installArgs(arch) {
+    return ["install", "--production", "--prefer-offline", ...arch && arch !== process.arch ? [`--cpu=${arch}`] : []];
+  }
+  async install(arch, omit = []) {
+    const config = await this.app.getConfig();
+    DesktopServerStage.assertCarriable(config);
+    await rm3(this.dir, { recursive: true, force: true });
+    await mkdir3(this.dir, { recursive: true });
+    const built = config.getProductionPackageJson();
+    for (const name of omit.filter((name) => !(name in (built.dependencies ?? {}))))
+      this.app.logger.warn(`desktop.server.omit names ${name}, which the server does not depend on directly.`);
+    await writeFile2(path7.join(this.dir, "package.json"), JSON.stringify(DesktopServerStage.packageJson(config, built, omit), null, 2));
+    try {
+      await this.app.spawn(process.execPath, DesktopServerStage.installArgs(arch), { cwd: this.dir });
+    } catch (error) {
+      throw new Error(`The desktop app's server could not install its packages in ${this.dir}: it needs the npm registry, or a Bun cache that already holds every one of them.
+${error instanceof Error ? error.message : String(error)}`, { cause: error });
+    }
+    await rm3(path7.join(this.dir, "node_modules", ".bin"), { recursive: true, force: true });
+    await this.#assertOmitted(omit);
+  }
+  async#assertOmitted(omit) {
+    const nodeModules = path7.join(this.dir, "node_modules");
+    const kept = [];
+    for (const name of omit) {
+      if (!await Bun.file(path7.join(nodeModules, name, "package.json")).exists())
+        continue;
+      const dependents = await DesktopServerStage.dependentsOf(nodeModules, name);
+      kept.push(`${name} (needed by ${dependents.join(", ") || "a package that names it"})`);
+    }
+    if (kept.length)
+      throw new Error(`desktop.server.omit leaves out packages another dependency still installs: ${kept.join("; ")}. Omit those too, or keep the package.`);
+  }
+  async prepare(environment) {
+    const config = await this.app.getConfig();
+    const dist = this.app.dist.cwdPath;
+    await mkdir3(this.dir, { recursive: true });
+    for (const name of await readdir2(dist))
+      if (!DesktopServerStage.uncarried.has(name))
+        await cp2(path7.join(dist, name), path7.join(this.dir, name), { recursive: true });
+    const scanInfo = this.app.getScanInfo({ allowEmpty: true }) ?? await this.app.scan({ write: false });
+    const carried = [...DesktopBin.select(config, scanInfo.getLibs()).keys()];
+    const notice = DesktopServerStage.imageStepsNotice(config, carried);
+    if (notice)
+      this.app.logger[notice.level](notice.message);
+    return { dir: this.dir, entry: "main.js", env: DesktopServerStage.env(config, environment) };
+  }
+}
+export { DesktopServerStage, getMobileTargets, getMobileTargetChoices, resolveMobileTargets, resolveAppId, appIdsOf, NativeApp, isPlaceholderAppId };