@akanjs/cli 3.0.2-rc.0 → 3.1.0-rc.0

package/{index-61mmsdjg.js → index-p9ystjrp.js}

@@ -1,6 +1,8 @@
 // @bun
 import {
   ApplicationBuildReporter,
+  UNAVAILABLE_REDIS_HOST,
+  redisTunnelPolicy,
   BUILDER_MIN_RSS_RECYCLE_INTERVAL_MS,
   SOURCE_EXTS,
   shouldRestartBackendByDevPlan,
@@ -33,33 +35,36 @@ import {
   filesChangedSince,
   HmrWatcher,
   WatchRootResolver
-} from "./index-senscydg.js";
+} from "./index-k9rrten6.js";
 import {
   runner,
   script
-} from "./index-q6ft9fkc.js";
+} from "./index-6jjtnhkw.js";
 import {
   WorkspaceExecutor,
   AppExecutor,
   LibExecutor,
   PkgExecutor
-} from "./index-50wb2a26.js";
+} from "./index-55mynnqs.js";
 import {
   DesktopServerStage,
-  resolveMobileTargets,
-  resolveAppId,
-  NativeApp
-} from "./index-jk9xnck6.js";
+  NativeApp,
+  UpdateUploader
+} from "./index-kjvrq3nc.js";
 import {
   LibraryScript
-} from "./index-1bjkfvm9.js";
+} from "./index-c1x0be5j.js";
 import {
   stripAnsi
 } from "./index-7md2g9vw.js";
 import {
   SlicePlanner,
   formatSlicePlan
-} from "./index-50jjwg8y.js";
+} from "./index-qt22xstj.js";
+import {
+  resolveMobileTargets,
+  resolveAppId
+} from "./index-q958tqqg.js";
 import {
   openBrowser
 } from "./index-9dp031by.js";
@@ -187,20 +192,29 @@ var closeBunSocket = (socket, error) => {
 // pkgs/@akanjs/devkit/createTunnel.ts
 var createTunnel = async (service, { app, environment, port = service === "postgres" ? 5432 : 6379 }) => {
   const { serveDomain, repoName } = WorkspaceExecutor.getBaseDevEnv();
-  await createSshTunnel({
-    localHost: "0.0.0.0",
-    localPort: port,
-    srcHost: "0.0.0.0",
-    srcPort: port,
-    dstHost: `${service}-0.${service}-svc.${app.name}-${environment}.svc.cluster.local`,
-    dstPort: service === "postgres" ? 5432 : 6379,
-    sshOptions: {
-      host: `${app.name}-${environment}.${serveDomain}`,
-      port: process.env.SSH_TUNNEL_PORT ? parseInt(process.env.SSH_TUNNEL_PORT) : 32767,
-      username: process.env.SSH_TUNNEL_USERNAME ?? "root",
-      password: process.env.SSH_TUNNEL_PASSWORD ?? repoName
-    }
-  });
+  const host = `${app.name}-${environment}.${serveDomain}`;
+  const sshPort = process.env.SSH_TUNNEL_PORT ? parseInt(process.env.SSH_TUNNEL_PORT) : 32767;
+  const dstHost = `${service}-0.${service}-svc.${app.name}-${environment}.svc.cluster.local`;
+  const dstPort = service === "postgres" ? 5432 : 6379;
+  try {
+    await createSshTunnel({
+      localHost: "0.0.0.0",
+      localPort: port,
+      srcHost: "0.0.0.0",
+      srcPort: port,
+      dstHost,
+      dstPort,
+      sshOptions: {
+        host: host.endsWith(".localhost") ? "localhost" : host,
+        port: sshPort,
+        username: process.env.SSH_TUNNEL_USERNAME ?? "root",
+        password: process.env.SSH_TUNNEL_PASSWORD ?? repoName
+      }
+    });
+  } catch (error) {
+    const reasons = error instanceof AggregateError ? error.errors.map((reason) => reason instanceof Error ? reason.message : String(reason)).join("; ") : error instanceof Error ? error.message : String(error);
+    throw new Error(`Could not open the ${service} tunnel for ${app.name}-${environment}: SSH ${host}:${sshPort} -> ${dstHost}:${dstPort} failed (${reasons})`, { cause: error });
+  }
   return `localhost:${port}`;
 };
 // pkgs/@akanjs/devkit/incrementalBuilder/incrementalBuilder.host.ts
@@ -818,9 +832,17 @@ class AkanAppHost {
   }
   async#prepareDatabase(type) {
     const environment = WorkspaceExecutor.getBaseDevEnv().env;
-    if (environment === "local")
+    const policy = redisTunnelPolicy({ environment, databaseMode: this.env.AKAN_DATABASE_MODE });
+    if (policy === "none")
       return "localhost";
-    return await createTunnel(type, { app: this.app, environment });
+    if (policy === "required")
+      return await createTunnel(type, { app: this.app, environment });
+    try {
+      return await createTunnel(type, { app: this.app, environment });
+    } catch (error) {
+      this.logger.warn(`${error instanceof Error ? error.message : String(error)} - continuing without Redis: the single database mode does not use it unless an app adaptor does`);
+      return UNAVAILABLE_REDIS_HOST;
+    }
   }
   #startBackend(startStatus = null) {
     if (this.#stopping)
@@ -1813,7 +1835,7 @@ ${this.#backendStderrTail.join(`
       this.#wakeFromIdle(`${message.type} arrived while suspended`);
       return;
     }
-    if (message.type === "build-csr" && this.env.AKAN_DEV_CSR_REBUILD !== "1") {
+    if (message.type === "build-csr" && !message.shell && this.env.AKAN_DEV_CSR_REBUILD !== "1") {
       Object.assign(this.env, { AKAN_DEV_CSR_REBUILD: "1" });
       this.logger.verbose(`[csr] armed dev CSR rebuilds (${message.reason})`);
     }
@@ -1867,7 +1889,7 @@ ${uniqueCandidates.map((candidate) => `  - ${candidate}`).join(`
 
 // pkgs/@akanjs/cli/application/application.runner.ts
 import { Logger as Logger3 } from "akanjs/common";
-var loadBuildRunner = async () => (await import("./applicationBuildRunner-etrzfwjj.js")).ApplicationBuildRunner;
+var loadBuildRunner = async () => (await import("./applicationBuildRunner-1yaqsrdq.js")).ApplicationBuildRunner;
 var loadPrompts = async () => await import("@inquirer/prompts");
 
 class ApplicationRunner extends runner("application") {
@@ -2024,6 +2046,18 @@ try {
   async typecheck(app, options = {}) {
     await new (await loadBuildRunner())(app).typecheck(options);
   }
+  async typecheckLibrary(lib, options = {}) {
+    const { ProjectTypecheck } = await import("./projectTypecheck-cvtkrzp2.js");
+    const root = lib.workspace.workspaceRoot;
+    await new ProjectTypecheck(lib.cwdPath, root, { ...process.env, AKAN_WORKSPACE_ROOT: root }).run([
+      "../../server.ts",
+      "../../client.ts",
+      "../../index.ts",
+      "../../page/**/*.ts",
+      "../../page/**/*.tsx",
+      "../../../../pkgs/akanjs/*/types/**/*.d.ts"
+    ], options);
+  }
   async test(exec) {
     const isSignalTarget = exec instanceof AppExecutor || exec instanceof LibExecutor;
     const preloadPath = isSignalTarget ? await resolveSignalTestPreloadPath(exec) : null;
@@ -2043,9 +2077,10 @@ try {
   async build(app, {
     fast = false,
     reporter,
-    spinner = false
+    spinner = false,
+    profile
   } = {}) {
-    return new (await loadBuildRunner())(app, { fast, reporter }).build({ spinner });
+    return new (await loadBuildRunner())(app, { fast, reporter, profile }).build({ spinner });
   }
   async start(app, {
     open = false,
@@ -2060,7 +2095,15 @@ try {
       setTimeout(() => openBrowser(`http://localhost:${env.AKAN_PUBLIC_CLIENT_PORT ?? env.PORT ?? "8282"}`), 3000);
     return appHost;
   }
-  async buildMobile(app, platform, { target, env = "debug", profile = "release", installer = false, arch } = {}) {
+  async buildMobile(app, platform, {
+    target,
+    env = "debug",
+    profile = "release",
+    installer = false,
+    arch,
+    sign = false,
+    notarize = false
+  } = {}) {
     const targets = await resolveMobileTargets(app, target);
     NativeApp.assertInstaller(platform, installer);
     if (arch && platform !== "macos" && platform !== "windows" && platform !== "linux")
@@ -2073,7 +2116,9 @@ try {
         profile,
         ...carried && ApplicationRunner.carriesServer(mobileTarget, platform) ? { server: carried } : {},
         ...installer ? { installer } : {},
-        ...arch ? { arch } : {}
+        ...arch ? { arch } : {},
+        sign,
+        notarize
       }));
     });
   }
@@ -2163,20 +2208,26 @@ try {
     if (!mobileTarget || targets.length > 1)
       throw new Error("pack-update packs one native target at a time; pass --target <name>.");
     await this.#buildMobileCsr(app, env);
-    const packed = await new NativeApp(app, mobileTarget, env).packUpdate(platform, { out });
-    const size = packed.manifest.files.reduce((sum, file) => sum + file.size, 0);
-    app.logger.info(`packed ${mobileTarget.name} ${platform} for channel '${packed.channel}' to ${packed.out}: ${packed.manifest.files.length} files, ${(size / 1024).toFixed(0)} KiB, native API ${packed.manifest.nativeApi}`);
-    if (!against)
-      return;
-    const bundle = path5.join(packed.out, "bundle.json");
-    const compat = await NativeApp.compareBundles(app.cwdPath, against, bundle);
-    await Bun.write(path5.join(packed.out, "compat.json"), `${JSON.stringify({ against, ...compat }, null, 2)}
+    const { pack } = await new NativeApp(app, mobileTarget, env).packUpdate(platform, { out });
+    app.logger.info(`packed ${mobileTarget.name} ${platform} for channel '${pack.channel}' to ${pack.out}: ${pack.files} files, ${(pack.size / 1024).toFixed(0)} KiB, native API ${pack.nativeApi}`);
+    if (against) {
+      const compat = await NativeApp.compareBundles(app.cwdPath, against, path5.join(pack.out, "bundle.json"));
+      pack.compat = { against, ...compat };
+      await Bun.write(path5.join(pack.out, "compat.json"), `${JSON.stringify(pack.compat, null, 2)}
 `);
-    if (!compat.compatible)
-      throw new Error(`This bundle needs a new store build; the one ${against} came from provides another native API:
-- ${compat.problems.join(`
+    }
+    await NativeApp.writePack(pack);
+    if (!pack.compat)
+      return pack;
+    if (pack.compat.compatible) {
+      app.logger.info(`runs in the store build of ${against}`);
+      return pack;
+    }
+    app.logger.error(`This bundle needs a new store build; the one ${against} came from provides another native API:
+- ${pack.compat.problems.join(`
 - `)}`);
-    app.logger.info(`runs in the store build of ${against}`);
+    process.exitCode = 2;
+    return pack;
   }
   async updateKeygen(app, platform, target) {
     const nativePlatform = platform === "desktop" ? NativeApp.desktopPlatform() : platform;
@@ -2188,30 +2239,47 @@ try {
       seen.add(appId);
       const { publicKey, keyPath, created } = await new NativeApp(app, mobileTarget).updateKeygen(nativePlatform);
       app.log(`${appId}: ${created ? "made" : "read"} ${keyPath}${created ? " (keep it private and backed up: without it, installed apps take no more updates)" : ""}`);
-      app.log(`  native: { updates: { url: "https://\u2026/${app.name}", publicKey: ${JSON.stringify(publicKey)} } }`);
-      const declared = mobileTarget.config.updates?.publicKey;
-      if (declared && declared !== publicKey)
-        app.logger.warn(`native.targets.${mobileTarget.name}.updates.publicKey is another key's; releases would not verify.`);
+      app.log(`  native: { updates: { url: "https://\u2026/${app.name}", publicKeys: [${JSON.stringify(publicKey)}] } }`);
+      const { publicKey: one, publicKeys } = mobileTarget.config.updates ?? {};
+      const declared = publicKeys ?? (one ? [one] : null);
+      if (declared && !declared.includes(publicKey))
+        app.logger.warn(`native.targets.${mobileTarget.name}.updates.publicKeys does not hold this key; releases it signs would not verify.`);
     }
   }
-  async publishUpdate(app, platform, { target, env = "main", channel } = {}) {
+  async publishUpdate(app, platform, { target, env = "main", channel, upload, arch, sign = false, notarize = false } = {}) {
+    if (arch && platform !== "desktop")
+      throw new Error(`--arch picks a desktop release's CPU; ${platform} publishes its web bundle.`);
     const targets = await resolveMobileTargets(app, target);
+    if (upload && targets.length > 1)
+      throw new Error(`--upload takes one target's release; name it with --target (${targets.map(({ name }) => name).join(", ")}).`);
+    const uploader = upload ? UpdateUploader.forTarget(upload) : null;
     const nativePlatform = platform === "desktop" ? NativeApp.desktopPlatform() : platform;
+    if (arch === "x64" && nativePlatform === "macos")
+      throw new Error("A macOS app is built for Apple silicon (arm64) only.");
     for (const mobileTarget of targets)
       await new NativeApp(app, mobileTarget, env).assertPublishable(nativePlatform, {
         server: ApplicationRunner.carriesServer(mobileTarget, nativePlatform),
-        ...channel ? { channel } : {}
+        ...channel ? { channel } : {},
+        ...arch ? { arch } : {}
       });
-    const carried = await this.#stageMobile(app, nativePlatform, targets, env);
+    const carried = await this.#stageMobile(app, nativePlatform, targets, env, arch);
     for (const mobileTarget of targets) {
       const nativeApp = new NativeApp(app, mobileTarget, env);
       const published = await nativeApp.publishUpdate(nativePlatform, {
         ...channel ? { channel } : {},
+        ...arch ? { arch } : {},
+        sign,
+        notarize,
         ...carried && ApplicationRunner.carriesServer(mobileTarget, nativePlatform) ? { server: carried } : {}
       });
       this.#reportBuild(app, mobileTarget, published.build);
       app.log(`${app.name}/${mobileTarget.name} ${published.bundle}: ${published.dir}/${published.channel}.json, ${published.files} files, ${Math.round(published.size / 1024)} KiB`);
-      app.log(`Upload ${nativeApp.updatesDir} to ${mobileTarget.config.updates?.url}, the manifests last.`);
+      if (!uploader) {
+        app.log(`Upload ${nativeApp.updatesDir} to ${mobileTarget.config.updates?.url}, the manifests last.`);
+        continue;
+      }
+      const { uploaded, skipped } = await uploader.upload(nativeApp.updatesDir);
+      app.log(`Uploaded ${uploaded} file(s) to ${upload}, the manifests last; ${skipped} the bucket already held. Installed apps read ${mobileTarget.config.updates?.url}.`);
     }
   }
   #reportBuild(app, mobileTarget, { artifacts, warnings, signing }) {
@@ -2225,24 +2293,45 @@ try {
   static carriesServer({ config }, platform = NativeApp.desktopPlatform()) {
     return platform !== "ios" && platform !== "android" && !!config.desktop?.server;
   }
-  static serverOmit(targets, platform) {
+  static carriedServer(targets, platform) {
     const carrying = targets.filter((target) => ApplicationRunner.carriesServer(target, platform));
-    const omits = carrying.map(({ config }) => {
+    const servers = carrying.map(({ config }) => {
       const server = config.desktop?.server;
-      return typeof server === "object" ? server.omit ?? [] : [];
+      if (typeof server !== "object")
+        return { omit: [], modules: [] };
+      const { omit = [], modules = [], profile, env, restart, watchdog } = server;
+      return {
+        omit,
+        modules,
+        ...profile ? { profile } : {},
+        ...env ? { env } : {},
+        ...restart !== undefined ? { restart } : {},
+        ...typeof watchdog === "object" ? { watchdog } : {}
+      };
     });
-    const [first = [], ...rest] = omits;
-    if (rest.some((omit) => omit.join("\x00") !== first.join("\x00")))
-      throw new Error(`The targets that carry the server omit different packages (${carrying.map(({ name }, idx) => `${name}: ${omits[idx]?.join(", ") || "none"}`).join("; ")}); build them one --target at a time.`);
+    const [first = { omit: [], modules: [] }, ...rest] = servers;
+    const agree = (what, of) => {
+      if (rest.every((server) => of(server) === of(first)))
+        return;
+      throw new Error(`The targets that carry the server ${what} (${carrying.map(({ name }, idx) => `${name}: ${servers[idx] && of(servers[idx]) || "none"}`).join("; ")}); build them one --target at a time.`);
+    };
+    agree("omit different packages", ({ omit }) => omit.join(", "));
+    agree("name different env profiles", ({ profile }) => profile ?? "");
+    agree("mount different modules", ({ modules }) => modules.join(", "));
+    agree("set a different env", ({ env }) => env ? JSON.stringify(env) : "");
+    agree("restart differently", ({ restart }) => String(restart ?? ""));
+    agree("watch it differently", ({ watchdog }) => watchdog ? JSON.stringify(watchdog) : "");
     return first;
   }
   async#stageMobile(app, platform, targets, env, arch) {
     const stage = targets.some((mobileTarget) => ApplicationRunner.carriesServer(mobileTarget, platform)) ? new DesktopServerStage(app) : null;
-    await stage?.install(arch, ApplicationRunner.serverOmit(targets, platform));
-    await this.#buildMobileCsr(app, env);
-    return await stage?.prepare(env);
+    const server = ApplicationRunner.carriedServer(targets, platform);
+    await stage?.install(arch, server.omit);
+    await this.#buildMobileCsr(app, env, stage ? server.profile : undefined);
+    const { modules, env: serverEnv, restart, watchdog } = server;
+    return await stage?.prepare(env, { modules, env: serverEnv, restart, watchdog });
   }
-  async#buildMobileCsr(app, env) {
+  async#buildMobileCsr(app, env, profile) {
     const prevEnv = {
       AKAN_PUBLIC_ENV: process.env.AKAN_PUBLIC_ENV,
       AKAN_PUBLIC_OPERATION_MODE: process.env.AKAN_PUBLIC_OPERATION_MODE,
@@ -2254,7 +2343,7 @@ try {
       APP_OPERATION_MODE: "release"
     });
     try {
-      await new (await loadBuildRunner())(app, { environment: env }).build({ spinner: true });
+      await new (await loadBuildRunner())(app, { environment: env, profile }).build({ spinner: true });
     } finally {
       for (const [key, value] of Object.entries(prevEnv)) {
         if (value === undefined)
@@ -3213,12 +3302,17 @@ class ApplicationScript extends script("application", [ApplicationRunner, Librar
   async logs(app, options) {
     await this.applicationRunner.runLogs(app, options);
   }
-  async build(app, { write = true, fast = false, quiet = false } = {}) {
+  async build(app, {
+    write = true,
+    fast = false,
+    quiet = false,
+    profile
+  } = {}) {
     await app.scanSync({ write });
     if (!quiet)
       Logger6.rawLog(`Creating an optimized production build for ${app.name}...`);
     try {
-      const result = await this.applicationRunner.build(app, { fast, spinner: !quiet });
+      const result = await this.applicationRunner.build(app, { fast, spinner: !quiet, profile });
       Logger6.rawLog(`${app.name} built in dist/apps/${app.name}`);
       if (!quiet)
         ApplicationBuildReporter.printSummary(result);
@@ -3228,14 +3322,22 @@ class ApplicationScript extends script("application", [ApplicationRunner, Librar
       throw error;
     }
   }
-  async typecheck(app, { write = true, clean = false, incremental = true } = {}) {
-    await app.scanSync({ write });
-    const spinner = app.spinning(`Typechecking ${app.name}...`);
+  async typecheck(exec, { write = true, clean = false, incremental = true, tests = false } = {}) {
+    if (!(exec instanceof AppExecutor) && !(exec instanceof LibExecutor))
+      throw new Error(`akan typecheck takes an app or a library; ${exec.name} is a package, checked by its own tsconfig.`);
+    if (exec instanceof LibExecutor)
+      await this.libraryScript.syncLibrary(exec);
+    else
+      await exec.scanSync({ write });
+    const spinner = exec.spinning(`Typechecking ${exec.name}${tests ? " with its tests" : ""}...`);
     try {
-      await this.applicationRunner.typecheck(app, { clean, incremental });
-      spinner.succeed(`${app.name} typechecked`);
+      if (exec instanceof LibExecutor)
+        await this.applicationRunner.typecheckLibrary(exec, { clean, incremental, tests });
+      else
+        await this.applicationRunner.typecheck(exec, { clean, incremental, tests });
+      spinner.succeed(`${exec.name} typechecked`);
     } catch (error) {
-      spinner.fail(`${app.name} typecheck failed`);
+      spinner.fail(`${exec.name} typecheck failed`);
       Logger6.rawLog(ApplicationBuildReporter.formatError(error), undefined, "error");
       throw error;
     }
@@ -3437,7 +3539,7 @@ class ApplicationScript extends script("application", [ApplicationRunner, Librar
   } = {}) {
     await app.scanSync({ write });
     ApplicationScript.#assertReleaseEnv("packUpdate", options.env ?? "main", allowLocalRelease);
-    await this.applicationRunner.packUpdate(app, platform, options);
+    return await this.applicationRunner.packUpdate(app, platform, options);
   }
   async updateKeygen(app, platform, { target } = {}) {
     await this.applicationRunner.updateKeygen(app, platform, target);
@@ -3491,7 +3593,7 @@ class ApplicationScript extends script("application", [ApplicationRunner, Librar
       await Promise.all(shares.map(async (share) => await share.close()));
     }, "Abandoning the tunnel release; the shares expire on their own.");
     await Promise.all(apps.map(async (app) => {
-      const { TunnelShare } = await import("./TunnelShare-cwh9ezsm.js");
+      const { TunnelShare } = await import("./TunnelShare-21mm6dr5.js");
       const share = await TunnelShare.open(app, { workspace: app.workspace });
       shares.push(share);
       urls.set(app.name, share.url);

package/index-q958tqqg.js

@@ -0,0 +1,77 @@
+// @bun
+// 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";
+};
+
+export { getMobileTargets, getMobileTargetChoices, resolveMobileTargets, resolveAppId, appIdsOf, targetHtmlFilename };

package/{index-50jjwg8y.js → index-qt22xstj.js}

@@ -1,7 +1,7 @@
 // @bun
 import {
   AppInfo
-} from "./index-50wb2a26.js";
+} from "./index-55mynnqs.js";
 
 // pkgs/@akanjs/devkit/slicePlanner.ts
 class SlicePlanner {

package/{index-94s080qm.js → index-r2tpeb3n.js}

@@ -52,6 +52,11 @@ class GlobalConfig {
       await GlobalConfig.#setAkanGlobalConfig(mutate(await GlobalConfig.#getAkanGlobalConfig()));
     });
   }
+  static async hostFor(workspace, host) {
+    if (host)
+      return host;
+    return (await workspace.getConfig()).cloudHost ?? GlobalConfig.akanCloudHost;
+  }
   static async getHostConfig(host = GlobalConfig.akanCloudHost) {
     const akanConfig = await GlobalConfig.#getAkanGlobalConfig();
     return GlobalConfig.toHostConfig(akanConfig.cloudHost[host] ?? getDefaultHostConfig(host));
@@ -197,6 +202,10 @@ class HttpClient {
 }
 
 class CloudApi {
+  static statusOf(error) {
+    const status = Number(/(?:^|: )(\d{3}) /.exec(error instanceof Error ? error.message : String(error))?.[1]);
+    return Number.isNaN(status) ? null : status;
+  }
   #api;
   #accessToken = null;
   #workspace;
@@ -231,6 +240,32 @@ class CloudApi {
     formData.append("file", file);
     return await this.#api.post(`/uploadEnv/${devProjectId}`, formData);
   }
+  async uploadSecret(devProjectId, secret) {
+    return await this.#api.post(`/uploadSecret/${encodeURIComponent(devProjectId)}`, secret);
+  }
+  async listSecrets(devProjectId) {
+    return await this.#api.get(`/listSecrets/${encodeURIComponent(devProjectId)}`);
+  }
+  async removeSecret(devProjectId, secret) {
+    return await this.#api.post(`/removeSecret/${encodeURIComponent(devProjectId)}`, secret);
+  }
+  async requestUpdateUpload(devProjectId, upload) {
+    return await this.#api.post(`/requestUpdateUpload/${encodeURIComponent(devProjectId)}`, upload);
+  }
+  async commitUpdateUpload(devProjectId, uploadId) {
+    return await this.#api.post(`/commitUpdateUpload/${encodeURIComponent(devProjectId)}`, { uploadId }, { signal: AbortSignal.timeout(11 * 60000) });
+  }
+  async registerAppBinary(devProjectId, binary) {
+    const formData = new FormData;
+    for (const key of ["appName", "target", "distribution"])
+      formData.append(key, binary[key]);
+    if (binary.channel)
+      formData.append("channel", binary.channel);
+    formData.append("bundle", binary.bundle, "bundle.json");
+    if (binary.pack)
+      formData.append("pack", binary.pack, "pack.tgz");
+    return await this.#api.post(`/registerAppBinary/${encodeURIComponent(devProjectId)}`, formData);
+  }
   async downloadEnv(devProjectId) {
     const localPath = `${this.#workspace.workspaceRoot}/local/env.tar`;
     await this.#api.getFile(`/downloadEnv/${devProjectId}`, localPath);
@@ -263,4 +298,95 @@ class CloudApi {
     }
   }
 }
-export { getDefaultHostConfig, GlobalConfig, CloudApi };
+// pkgs/@akanjs/devkit/cloud/updatePackUpload.ts
+import { Logger, sleep } from "akanjs/common";
+class UpdatePackUpload {
+  static maxBytes = 200 * 1024 * 1024;
+  static #transientPut = new Set([0, 408, 429, 500, 502, 503, 504]);
+  #api;
+  #devProjectId;
+  #putRetryMs;
+  #commitRetryMs;
+  #cutOffWindowMs;
+  #commitLimitMs;
+  constructor(api, devProjectId, {
+    putRetryMs = 1000,
+    commitRetryMs = 1e4,
+    cutOffWindowMs = 15 * 60000,
+    commitLimitMs = 60 * 60000
+  } = {}) {
+    this.#api = api;
+    this.#devProjectId = devProjectId;
+    this.#putRetryMs = putRetryMs;
+    this.#commitRetryMs = commitRetryMs;
+    this.#cutOffWindowMs = cutOffWindowMs;
+    this.#commitLimitMs = commitLimitMs;
+  }
+  async send(archive, fields) {
+    const file = Bun.file(archive);
+    if (file.size < 1 || file.size > UpdatePackUpload.maxBytes)
+      throw new Error(`The pack archive is ${file.size} bytes; a project takes 1 byte to 200 MiB.`);
+    const hasher = new Bun.CryptoHasher("sha256");
+    for await (const chunk of file.stream())
+      hasher.update(chunk);
+    const upload = { ...fields, size: file.size, sha256: hasher.digest("hex") };
+    for (let ticket = 1;; ticket++) {
+      const { uploadId, uploadUrl, contentType } = await this.#request(upload);
+      const status = await this.#put(uploadUrl, contentType, file);
+      if (status >= 200 && status < 300)
+        return await this.#commit(uploadId);
+      if (status !== 403 || ticket === 2)
+        throw new Error(`The storage refused the pack upload (${status ? `HTTP ${status}` : "no response"}).`);
+    }
+  }
+  async#request(upload) {
+    return await this.#api.requestUpdateUpload(this.#devProjectId, upload).catch((error) => {
+      const message = error instanceof Error ? error.message : String(error);
+      if (CloudApi.statusOf(error) === 404 && !/"error"\s*:\s*"[\w$-]+\.error\.[\w$-]+"/.test(message))
+        throw new Error("The project's server does not take direct pack uploads yet: update akasys and try again, or upload the pack from the project's release screen.");
+      throw error;
+    });
+  }
+  async#put(url, contentType, file) {
+    for (let retry = 0;; retry++) {
+      const status = await fetch(url, { method: "PUT", body: file, headers: { "Content-Type": contentType } }).then(async (response) => {
+        await response.arrayBuffer().catch(() => {
+          return;
+        });
+        return response.status;
+      }).catch(() => 0);
+      if (retry === 3 || !UpdatePackUpload.#transientPut.has(status))
+        return status;
+      await sleep(this.#putRetryMs * (retry + 1));
+    }
+  }
+  async#commit(uploadId) {
+    const limit = performance.now() + this.#commitLimitMs;
+    let cutOffSince = null;
+    for (;; ) {
+      try {
+        return await this.#api.commitUpdateUpload(this.#devProjectId, uploadId);
+      } catch (error) {
+        const now = performance.now();
+        if (CloudApi.statusOf(error) === 409)
+          cutOffSince = null;
+        else if (UpdatePackUpload.#cutOff(error))
+          cutOffSince ??= now;
+        else
+          throw error;
+        const deadline = cutOffSince === null ? limit : Math.min(limit, cutOffSince + this.#cutOffWindowMs);
+        if (now + this.#commitRetryMs > deadline)
+          throw error;
+        Logger.rawLog(`The project is still taking the pack; asking again in ${Math.round(this.#commitRetryMs / 1000)}s.`);
+        await sleep(this.#commitRetryMs);
+      }
+    }
+  }
+  static #cutOff(error) {
+    const status = CloudApi.statusOf(error);
+    if (status === null)
+      return !(error instanceof SyntaxError);
+    return status === 502 || status === 504 || status >= 520 && status <= 527;
+  }
+}
+export { getDefaultHostConfig, GlobalConfig, CloudApi, UpdatePackUpload };