@akanjs/cli 3.0.0-beta.26 → 3.0.0-beta.28

package/{index-cfj73ck1.js → index-0ej0sr6m.js}

@@ -37,27 +37,29 @@ import {
 import {
   runner,
   script
-} from "./index-58cyna2s.js";
+} from "./index-b68zfsvz.js";
 import {
   WorkspaceExecutor,
   AppExecutor,
   LibExecutor,
   PkgExecutor
-} from "./index-0n9q1f23.js";
+} from "./index-r8gp8zk3.js";
 import {
   LibraryScript
-} from "./index-5mm3g24t.js";
+} from "./index-qtz88kh0.js";
 import {
+  DesktopServerStage,
   resolveMobileTargets,
+  resolveAppId,
   NativeApp
-} from "./index-ys6f0bvh.js";
+} from "./index-tfe3711h.js";
 import {
   stripAnsi
 } from "./index-7md2g9vw.js";
 import {
   SlicePlanner,
   formatSlicePlan
-} from "./index-860zjnr1.js";
+} from "./index-nbg9bfnr.js";
 import {
   openBrowser
 } from "./index-9dp031by.js";
@@ -725,6 +727,7 @@ class AkanAppHost {
   #backendGaveUp = false;
   #backendLifecycleState = "stopped";
   #pendingRestartReason = null;
+  #backendRestart = null;
   #pendingRecycle = null;
   #restartFailedAfterApply = null;
   #stopping = false;
@@ -796,7 +799,9 @@ class AkanAppHost {
     this.#cancelIdleSuspend();
     this.#stopIdleWatcher();
     this.#clearRestartTimers();
+    this.#pendingRestartReason = null;
     this.#failPendingBuilderMessages("dev server is shutting down");
+    await this.#backendRestart;
     await this.#stopBackend();
     this.#stopBuilder();
     return this;
@@ -817,6 +822,12 @@ class AkanAppHost {
     return await createTunnel(type, { app: this.app, environment });
   }
   #startBackend(startStatus = null) {
+    if (this.#stopping)
+      return;
+    if (this.#backend) {
+      this.logger.warn(`backend pid=${this.#backend.pid} is still running; not starting a second one`);
+      return;
+    }
     this.#builderRequests.startGeneration();
     this.#discardPendingBuilderMessages("the backend restarted while the builder was away");
     this.#backendStartStatus = startStatus;
@@ -997,11 +1008,17 @@ class AkanAppHost {
       clearTimeout(this.#restartTimer);
     this.#restartTimer = setTimeout(() => {
       this.#restartTimer = null;
+      this.#backendRestart ??= this.#drainBackendRestarts().finally(() => {
+        this.#backendRestart = null;
+      });
+    }, BACKEND_RESTART_DEBOUNCE_MS);
+  }
+  async#drainBackendRestarts() {
+    while (this.#pendingRestartReason && !this.#restartTimer && !this.#stopping) {
       const next = this.#pendingRestartReason;
       this.#pendingRestartReason = null;
-      if (next)
-        this.#restartBackend(next);
-    }, BACKEND_RESTART_DEBOUNCE_MS);
+      await this.#restartBackend(next);
+    }
   }
   async#restartBackend(reason) {
     this.logger.verbose(`[backend-reload] restarting backend generation=${reason.generation ?? "(unknown)"} files=${reason.files.length} roles=${reason.roles.join(",") || "(none)"}`);
@@ -1306,7 +1323,7 @@ ${this.#backendStderrTail.join(`
     this.logger.info(`[idle-suspend] no build activity for ${Math.round(idleMs / 1000)}s; released the builder \u2014 the next edit or route request brings it back`);
   }
   get #restartPending() {
-    return !!(this.#pendingRecycle || this.#restartTimer || this.#backendRecoveryTimer || this.#builderRecoveryTimer || this.#rssRecycleReason);
+    return !!(this.#pendingRecycle || this.#restartTimer || this.#backendRestart || this.#backendRecoveryTimer || this.#builderRecoveryTimer || this.#rssRecycleReason);
   }
   async#startIdleWatcher() {
     try {
@@ -1609,6 +1626,7 @@ ${this.#backendStderrTail.join(`
     this.#clearRestartTimers();
     this.#builderRecoveryAttempts = 0;
     this.#pendingRestartReason = null;
+    await this.#backendRestart;
     this.#lastGoodFrontend = {};
     this.#buildStatusByPhase.clear();
     this.#pendingBuildStatusReplay = [];
@@ -1846,7 +1864,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-412y0345.js")).ApplicationBuildRunner;
+var loadBuildRunner = async () => (await import("./applicationBuildRunner-w4917tje.js")).ApplicationBuildRunner;
 var loadPrompts = async () => await import("@inquirer/prompts");
 
 class ApplicationRunner extends runner("application") {
@@ -2038,60 +2056,137 @@ 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" } = {}) {
+  async buildMobile(app, platform, { target, env = "debug", profile = "release", installer = false } = {}) {
     const targets = await resolveMobileTargets(app, target);
-    await this.#buildMobileCsr(app, env);
+    if (installer && platform !== "windows")
+      throw new Error(`--installer builds a Windows setup program; this computer builds for ${platform}.`);
+    const carried = await this.#stageMobile(app, platform, targets, env);
     await this.#runMobileTargets(targets, async (mobileTarget) => {
-      this.#reportBuild(app, mobileTarget, await new NativeApp(app, mobileTarget).build(platform, { profile }));
+      this.#reportBuild(app, mobileTarget, await new NativeApp(app, mobileTarget, env).build(platform, {
+        profile,
+        ...carried && ApplicationRunner.carriesServer(mobileTarget, platform) ? { server: carried } : {},
+        ...installer ? { installer } : {}
+      }));
     });
   }
-  async startMobile(app, platform, { target, env = "local", operation = "local", device, teamId } = {}) {
-    const targets = await resolveMobileTargets(app, target);
-    const [mobileTarget] = targets;
-    if (!mobileTarget || targets.length > 1)
-      throw new Error(`start-${platform === "ios" || platform === "android" ? platform : "desktop"} runs one mobile target at a time; pass --target <name>.`);
-    const nativeApp = new NativeApp(app, mobileTarget);
+  async buildDesktop(app, options = {}) {
+    await this.buildMobile(app, NativeApp.desktopPlatform(), options);
+  }
+  async startMobile(app, platform, { target, env = "local", operation = "local", device, teamId, interrupt } = {}) {
+    const mobileTarget = await ApplicationRunner.startTarget(app, platform, target);
+    const nativeApp = new NativeApp(app, mobileTarget, env);
     const selection = { ...device ? { device } : {}, ...teamId ? { teamId } : {} };
     if (operation === "release") {
-      await this.#buildMobileCsr(app, env);
-      const running = await nativeApp.run(platform, { ...selection, profile: "release" });
+      const carried = await this.#stageMobile(app, platform, [mobileTarget], env);
+      const running = await nativeApp.run(platform, {
+        ...selection,
+        profile: "release",
+        ...carried ? { server: carried } : {}
+      });
       await running.exited;
       return;
     }
     const upstream = `http://localhost:${await app.getDevPort()}`;
-    if (!await ApplicationRunner.#answers(upstream))
+    if (!await ApplicationRunner.answers(upstream, app.name))
       throw new Error(`No dev server answers on ${upstream}; run \`akan start ${app.name}\` first.`);
     const { i18n } = await app.getConfig();
     const session = await nativeApp.dev(platform, { upstream, lang: i18n.defaultLocale, ...selection });
-    app.log(`${app.name}/${mobileTarget.name} on ${platform} follows ${upstream} through ${session.gateway}.`);
-    process.once("SIGINT", () => {
-      session.stop().finally(() => process.exit(130));
-    });
+    if (interrupt)
+      interrupt.add(async () => await session.stop(), "Abandoning the app's shutdown; its window may stay open.", 130);
+    else
+      process.once("SIGINT", () => {
+        session.stop().finally(() => process.exit(130));
+      });
     await session.exited;
   }
   async startDesktop(app, options = {}) {
     await this.startMobile(app, NativeApp.desktopPlatform(), options);
   }
-  static async#answers(url) {
-    try {
-      await fetch(url, { signal: AbortSignal.timeout(3000) });
-      return true;
-    } catch {
+  static async startTarget(app, platform = NativeApp.desktopPlatform(), target) {
+    const targets = await resolveMobileTargets(app, target);
+    const [mobileTarget] = targets;
+    if (!mobileTarget || targets.length > 1)
+      throw new Error(`start-${platform === "ios" || platform === "android" ? platform : "desktop"} runs one mobile target at a time; pass --target <name>.`);
+    return mobileTarget;
+  }
+  static async answers(url, appName) {
+    const signal = AbortSignal.timeout(3000);
+    const health = await fetch(new URL("/_akan/app/health", url), { signal }).catch(() => null);
+    if (!health)
       return false;
-    }
+    const info = await fetch(new URL("/_akan/app/info", url), { signal }).then(async (res) => res.ok ? await res.json() : null).catch(() => null);
+    if (info?.appName === appName)
+      return true;
+    const stopIt = `Stop it (\`akan start ${appName} --kill\` takes the port over) or give ${appName} another port with AKAN_DEV_PORT`;
+    if (typeof info?.appName === "string")
+      throw new Error(`${url} is the dev server of ${info.appName}, not ${appName}. ${stopIt}.`);
+    const { pid } = await health.json().catch(() => null) ?? {};
+    throw new Error(typeof pid === "number" ? `${url} is an akan dev server (pid ${pid}) too old to say which app it serves. ${stopIt}.` : `${url} answers, but not as an akan dev server. Stop what holds the port or give ${appName} another port with AKAN_DEV_PORT.`);
   }
   async releaseIos(app, { target, env = "main", teamId, adHoc = false } = {}) {
     const targets = await resolveMobileTargets(app, target);
     await this.#buildMobileCsr(app, env);
     for (const mobileTarget of targets)
-      this.#reportBuild(app, mobileTarget, await new NativeApp(app, mobileTarget).releaseIos({ teamId, adHoc }));
+      this.#reportBuild(app, mobileTarget, await new NativeApp(app, mobileTarget, env).releaseIos({ teamId, adHoc }));
   }
   async releaseAndroid(app, format, { target, env = "main" } = {}) {
     const targets = await resolveMobileTargets(app, target);
     NativeApp.androidSigning();
     await this.#buildMobileCsr(app, env);
     for (const mobileTarget of targets)
-      this.#reportBuild(app, mobileTarget, await new NativeApp(app, mobileTarget).releaseAndroid({ formats: [format] }));
+      this.#reportBuild(app, mobileTarget, await new NativeApp(app, mobileTarget, env).releaseAndroid({ formats: [format] }));
+  }
+  async packUpdate(app, platform, { target, env = "main", out, against }) {
+    const targets = await resolveMobileTargets(app, target);
+    const [mobileTarget] = targets;
+    if (!mobileTarget || targets.length > 1)
+      throw new Error("pack-update packs one mobile 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)}
+`);
+    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(`
+- `)}`);
+    app.logger.info(`runs in the store build of ${against}`);
+  }
+  async updateKeygen(app, platform, target) {
+    const nativePlatform = platform === "desktop" ? NativeApp.desktopPlatform() : platform;
+    const seen = new Set;
+    for (const mobileTarget of await resolveMobileTargets(app, target ?? "all")) {
+      const appId = resolveAppId(mobileTarget.config.appId, nativePlatform);
+      if (seen.has(appId))
+        continue;
+      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(`  mobile: { updates: { url: "https://\u2026/${app.name}", publicKey: ${JSON.stringify(publicKey)} } }`);
+      const declared = mobileTarget.config.updates?.publicKey;
+      if (declared && declared !== publicKey)
+        app.logger.warn(`mobile.targets.${mobileTarget.name}.updates.publicKey is another key's; releases would not verify.`);
+    }
+  }
+  async publishUpdate(app, platform, { target, env = "main", channel } = {}) {
+    const targets = await resolveMobileTargets(app, target);
+    const nativePlatform = platform === "desktop" ? NativeApp.desktopPlatform() : platform;
+    const carried = await this.#stageMobile(app, nativePlatform, targets, env);
+    for (const mobileTarget of targets) {
+      const nativeApp = new NativeApp(app, mobileTarget, env);
+      const published = await nativeApp.publishUpdate(nativePlatform, {
+        ...channel ? { channel } : {},
+        ...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.`);
+    }
   }
   #reportBuild(app, mobileTarget, { artifacts, warnings, signing }) {
     for (const warning of warnings)
@@ -2101,6 +2196,16 @@ try {
     for (const artifact of artifacts)
       app.log(`${app.name}/${mobileTarget.name} ${artifact.kind}: ${artifact.path}`);
   }
+  static carriesServer({ config }, platform = NativeApp.desktopPlatform()) {
+    return platform !== "ios" && platform !== "android" && config.native?.desktop?.server === true;
+  }
+  async#stageMobile(app, platform, targets, env) {
+    const carries = targets.some((mobileTarget) => ApplicationRunner.carriesServer(mobileTarget, platform));
+    if (carries)
+      DesktopServerStage.assertCarriable(await app.getConfig());
+    await this.#buildMobileCsr(app, env);
+    return carries ? await new DesktopServerStage(app).prepare(env) : undefined;
+  }
   async#buildMobileCsr(app, env) {
     const prevEnv = {
       AKAN_PUBLIC_ENV: process.env.AKAN_PUBLIC_ENV,
@@ -2113,7 +2218,7 @@ try {
       APP_OPERATION_MODE: "release"
     });
     try {
-      await new (await loadBuildRunner())(app).build({ spinner: true });
+      await new (await loadBuildRunner())(app, { environment: env }).build({ spinner: true });
     } finally {
       for (const [key, value] of Object.entries(prevEnv)) {
         if (value === undefined)
@@ -2957,6 +3062,7 @@ class InterruptTeardown {
   #listen;
   #report;
   #interrupted = false;
+  #chain = Promise.resolve();
   ownsExit = true;
   constructor({ exit, listen, report } = {}) {
     this.#exit = exit ?? ((code) => process.exit(code));
@@ -2965,36 +3071,48 @@ class InterruptTeardown {
     });
     this.#report = report ?? ((message) => Logger5.rawLog(message, undefined, "error"));
   }
-  add(run, abandoned) {
-    this.#teardowns.push({ run, abandoned, running: false });
+  add(run, abandoned, exitCode = 0) {
+    this.#teardowns.push({ run, abandoned, exitCode, state: "pending" });
     if (this.#teardowns.length === 1)
       this.#listen(() => this.#onSignal());
   }
+  async runAll() {
+    await this.#runTeardowns();
+  }
   #onSignal() {
     if (this.#interrupted) {
       for (const one of this.#teardowns)
-        if (one.running)
+        if (one.state !== "done")
           this.#report(one.abandoned);
       this.#exit(130);
       return;
     }
     this.#interrupted = true;
-    Promise.all(this.#teardowns.map(async (one) => {
-      one.running = true;
-      await one.run().catch(() => {
-        return;
-      });
-      one.running = false;
-    })).finally(() => {
+    this.#runTeardowns().finally(() => {
       if (this.ownsExit)
-        this.#exit(0);
+        this.#exit(Math.max(0, ...this.#teardowns.map((one) => one.exitCode)));
     });
   }
+  async#runTeardowns() {
+    this.#chain = this.#chain.then(async () => {
+      for (const one of this.#teardowns.toReversed()) {
+        if (one.state !== "pending")
+          continue;
+        one.state = "running";
+        await one.run().catch(() => {
+          return;
+        });
+        one.state = "done";
+      }
+    });
+    await this.#chain;
+  }
 }
 
 // pkgs/@akanjs/cli/application/application.script.ts
 class ApplicationScript extends script("application", [ApplicationRunner, LibraryScript]) {
   static dbShutdownTimeoutMs = 20000;
+  static devServerReadyTimeoutMs = DevSupervisor.bootTimeoutMs;
   #interrupt = new InterruptTeardown;
   async confirmDatabaseModeDependencyInstall(databaseMode, installSpecs) {
     return await confirm({
@@ -3206,6 +3324,10 @@ class ApplicationScript extends script("application", [ApplicationRunner, Librar
     await app.scanSync({ write });
     await this.applicationRunner.buildMobile(app, "android", options);
   }
+  async buildDesktop(app, { write = true, ...options } = {}) {
+    await app.scanSync({ write });
+    await this.applicationRunner.buildDesktop(app, options);
+  }
   async startIos(app, { write = true, ...options } = {}) {
     await app.scanSync({ write });
     await this.applicationRunner.startMobile(app, "ios", options);
@@ -3216,7 +3338,42 @@ class ApplicationScript extends script("application", [ApplicationRunner, Librar
   }
   async startDesktop(app, { write = true, ...options } = {}) {
     await app.scanSync({ write });
-    await this.applicationRunner.startDesktop(app, options);
+    if (options.operation === "release")
+      return await this.applicationRunner.startDesktop(app, options);
+    const mobileTarget = await ApplicationRunner.startTarget(app, undefined, options.target);
+    if (!ApplicationRunner.carriesServer(mobileTarget))
+      return await this.applicationRunner.startDesktop(app, options);
+    const upstream = `http://localhost:${await app.getDevPort()}`;
+    if (await ApplicationRunner.answers(upstream, app.name))
+      app.log(`The desktop app follows the dev server on ${upstream}.`);
+    else
+      await this.#startDevServerFor(app, upstream);
+    try {
+      await this.applicationRunner.startDesktop(app, { ...options, interrupt: this.#interrupt });
+    } finally {
+      await this.#interrupt.runAll();
+    }
+  }
+  async#startDevServerFor(app, upstream) {
+    app.log(`No dev server answers on ${upstream}; starting \`akan start ${app.name}\` for the desktop app.`);
+    let settle = () => {};
+    const settled = new Promise((resolve) => settle = resolve);
+    const appHost = await this.startOne(app, {
+      write: false,
+      onDevEvent: (event) => {
+        if ("state" in event && (event.state === "ready" || event.state === "failed"))
+          settle(event.state);
+      }
+    });
+    this.#interrupt.add(async () => {
+      await appHost.stop();
+    }, "Abandoning the dev server shutdown; its processes may still be running.", 130);
+    let state;
+    const timedOut = await DevSupervisor.timesOut(settled.then((settledState) => state = settledState), ApplicationScript.devServerReadyTimeoutMs);
+    if (state === "ready")
+      return;
+    await this.#interrupt.runAll();
+    throw new Error(timedOut ? `akan start ${app.name} did not answer within ${ApplicationScript.devServerReadyTimeoutMs / 1000}s; see its log above.` : `akan start ${app.name} gave up restarting its server; see its log above.`);
   }
   async releaseIos(app, {
     write = true,
@@ -3236,6 +3393,27 @@ class ApplicationScript extends script("application", [ApplicationRunner, Librar
     ApplicationScript.#assertReleaseEnv("releaseAndroid", options.env ?? "main", allowLocalRelease);
     await this.applicationRunner.releaseAndroid(app, format, options);
   }
+  async packUpdate(app, platform, {
+    write = true,
+    allowLocalRelease = false,
+    ...options
+  } = {}) {
+    await app.scanSync({ write });
+    ApplicationScript.#assertReleaseEnv("packUpdate", options.env ?? "main", allowLocalRelease);
+    await this.applicationRunner.packUpdate(app, platform, options);
+  }
+  async updateKeygen(app, platform, { target } = {}) {
+    await this.applicationRunner.updateKeygen(app, platform, target);
+  }
+  async publishUpdate(app, platform, {
+    write = true,
+    allowLocalRelease = false,
+    ...options
+  } = {}) {
+    await app.scanSync({ write });
+    ApplicationScript.#assertReleaseEnv("publishUpdate", options.env ?? "main", allowLocalRelease);
+    await this.applicationRunner.publishUpdate(app, platform, options);
+  }
   static #assertReleaseEnv(command, env, allowLocalRelease) {
     if (env === "local" && !allowLocalRelease)
       throw new Error(`${command} --env local is blocked. Pass allowLocalRelease only for explicit local release testing.`);

package/{index-hzy4pe24.js → index-0pqzrbpr.js}

@@ -8,7 +8,7 @@ import {
   isScannedRootEntry,
   AppExecutor,
   LibExecutor
-} from "./index-0n9q1f23.js";
+} from "./index-r8gp8zk3.js";
 import {
   FileSys2
 } from "./index-52w0fvh8.js";
@@ -21,7 +21,7 @@ import {
   workflowPathsForPlan,
   workflowRunArtifactPath,
   workflowSyncDir
-} from "./index-d65fzxvd.js";
+} from "./index-2s2e5qnd.js";
 
 // pkgs/@akanjs/devkit/akanContext.ts
 import { readdir } from "fs/promises";

package/{index-6dt6zft6.js → index-20r2g1t3.js}

@@ -1,12 +1,12 @@
 // @bun
 import {
   script
-} from "./index-58cyna2s.js";
+} from "./index-b68zfsvz.js";
 import {
   AppExecutor,
   LibExecutor,
   ModuleExecutor
-} from "./index-0n9q1f23.js";
+} from "./index-r8gp8zk3.js";
 import {
   workflowStatus,
   compactDiagnostics,
@@ -41,10 +41,10 @@ import {
   hasSignalFactoryEntry,
   insertSignalFactoryEntry,
   addFieldUiPolicyForType
-} from "./index-d65fzxvd.js";
+} from "./index-2s2e5qnd.js";
 import {
   ModuleScript
-} from "./index-zazvn45w.js";
+} from "./index-genegfnt.js";
 
 // pkgs/@akanjs/cli/primitive/primitive.script.ts
 import { capitalize, lowerlize } from "akanjs/common";

package/{index-xfgdmm5d.js → index-2ctqegdm.js}

@@ -2,12 +2,12 @@
 import {
   runner,
   script
-} from "./index-58cyna2s.js";
+} from "./index-b68zfsvz.js";
 import {
   generatedFilesForSync,
   createPassedPrimitiveReport,
   scalarChangedFiles
-} from "./index-d65fzxvd.js";
+} from "./index-2s2e5qnd.js";
 import {
   pluralizeName
 } from "./index-nz8prx9g.js";

package/{index-d65fzxvd.js → index-2s2e5qnd.js}

@@ -2,7 +2,7 @@
 import {
   AppExecutor,
   LibExecutor
-} from "./index-0n9q1f23.js";
+} from "./index-r8gp8zk3.js";
 
 // pkgs/@akanjs/devkit/workflow/utils.ts
 var jsonText = (value, { trailingNewline = true } = {}) => `${JSON.stringify(value, null, 2)}${trailingNewline ? `

package/{index-t02g6dpn.js → index-2z30v4k5.js}

@@ -5,13 +5,13 @@ import {
   writeGeneratedSyncState,
   createRepairReport,
   renderRepairReport
-} from "./index-d65fzxvd.js";
+} from "./index-2s2e5qnd.js";
 import {
   AkanContextAnalyzer
-} from "./index-hzy4pe24.js";
+} from "./index-0pqzrbpr.js";
 import {
   runner
-} from "./index-58cyna2s.js";
+} from "./index-b68zfsvz.js";
 
 // pkgs/@akanjs/cli/repair/repair.runner.ts
 var spawnShell = async (workspace, command) => await workspace.spawn("bash", ["-lc", command.startsWith("akan ") ? `bun run ${command}` : command], {

package/{index-tpdn30ya.js → index-52n8xr63.js}

@@ -116,7 +116,7 @@ class SubagentPool2 {
     }
   }
   async#run(id, kind, prompt, signal) {
-    const { CodeAgent } = await import("./CodeAgent-p65jja35.js");
+    const { CodeAgent } = await import("./CodeAgent-7acv4ah8.js");
     const budget = this.#options.parent.tools.subagent;
     const child = SubagentPool2.childOf(this.#options.parent, kind);
     const agent = await CodeAgent.create({

package/{index-mq74nzf8.js → index-9j0kykc6.js}

@@ -5,19 +5,19 @@ import {
 } from "./index-94s080qm.js";
 import {
   script
-} from "./index-58cyna2s.js";
+} from "./index-b68zfsvz.js";
 import {
   PkgExecutor
-} from "./index-0n9q1f23.js";
+} from "./index-r8gp8zk3.js";
 import {
   ApplicationScript
-} from "./index-cfj73ck1.js";
+} from "./index-0ej0sr6m.js";
 import {
   PackageScript
-} from "./index-per2kqy9.js";
+} from "./index-k7809wmg.js";
 import {
   CloudRunner
-} from "./index-56xwsgyn.js";
+} from "./index-rrt9pnb4.js";
 
 // pkgs/@akanjs/cli/cloud/cloud.script.ts
 import { Logger } from "akanjs/common";

package/{index-58cyna2s.js → index-b68zfsvz.js}

@@ -10,7 +10,7 @@ import {
   LibExecutor,
   PkgExecutor,
   ModuleExecutor
-} from "./index-0n9q1f23.js";
+} from "./index-r8gp8zk3.js";
 
 // pkgs/@akanjs/devkit/commandDecorators/camelToKebabCase.ts
 var camelToKebabCase = (str) => str.replace(/([A-Z])/g, "-$1").toLowerCase();

package/{index-qm4fppfk.js → index-ewbek95g.js}

@@ -4,7 +4,7 @@ import {
   akanCodePaths2,
   McpServerConfig,
   McpSignIn
-} from "./index-tpdn30ya.js";
+} from "./index-52n8xr63.js";
 import {
   stripAnsi
 } from "./index-7md2g9vw.js";
@@ -511,7 +511,7 @@ class AkanToolPack2 {
     return { name: "akan-tools", factory: async (pi) => await this.#register(pi) };
   }
   async names() {
-    const { ContextRunner } = await import("./context.runner-pjy89k2s.js");
+    const { ContextRunner } = await import("./context.runner-nzaf8c98.js");
     return [
       ...new ContextRunner().listMcpTools(this.#options.mode).map((tool) => tool.name),
       AkanToolPack2.verifyToolName
@@ -519,7 +519,7 @@ class AkanToolPack2 {
   }
   static verifyToolName = "akan_verify";
   async#register(pi) {
-    const { ContextRunner } = await import("./context.runner-pjy89k2s.js");
+    const { ContextRunner } = await import("./context.runner-nzaf8c98.js");
     const runner = new ContextRunner;
     const guidelineNames = await AkanToolPack2.#guidelineNames();
     for (const tool of runner.listMcpTools(this.#options.mode, { guidelineNames })) {

package/{index-wvebzf0y.js → index-fy42hyb9.js}

@@ -1,7 +1,7 @@
 // @bun
 import {
   resolveSsrPageEntriesForApp
-} from "./index-0n9q1f23.js";
+} from "./index-r8gp8zk3.js";
 import {
   computeRouteSeedIndex,
   saveRouteSeedIndex,
@@ -16,7 +16,7 @@ import {
   CsrEntryFiles,
   PagesEntrySourceGenerator,
   PagesBundleBuilder
-} from "./index-cd9qt2t6.js";
+} from "./index-ttn00pr3.js";
 import {
   SOURCE_EXTS
 } from "./index-48k96p55.js";
@@ -1640,7 +1640,8 @@ class SsrBaseArtifactBuilder {
       web: SsrBaseArtifactBuilder.servedWeb(this.#command, akanConfig.web),
       deepLinkAssociations: Object.values(akanConfig.mobile.targets).filter((target) => (target.deepLinks?.domains?.length ?? 0) > 0).map((target) => ({
         targetName: target.name,
-        appId: target.appId,
+        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
@@ -1736,6 +1737,9 @@ ${preparedCssText}`).toString(36);
     this.#app.verbose(`[base-artifact] wrote ${preparedCssText.length} bytes of CSS for ${basePath} -> ${cssRelPath}`);
     return [basePath, { cssUrl, cssRelPath }];
   }
+  static #appIdOn(appId, platform) {
+    return typeof appId === "string" ? appId : appId[platform] ?? appId.default ?? null;
+  }
   static #warnDroppedImports(app, cssRelPath, css, imported) {
     for (const { cssPath, declaredNames } of imported) {
       if (declaredNames.length === 0 || declaredNames.some((name) => css.includes(`${name}:`)))