@akanjs/cli 3.0.0-beta.8 → 3.0.0

package/application.command-e968t0hw.js

@@ -0,0 +1,246 @@
+// @bun
+import {
+  App,
+  Apps,
+  Sys,
+  Exec,
+  Workspace,
+  command
+} from "./index-vpj42xwt.js";
+import"./index-52w0fvh8.js";
+import"./index-3w94e7n3.js";
+import {
+  getMobileTargetChoices
+} from "./index-gbggbqcp.js";
+import"./index-48k96p55.js";
+import"./index-mgxpx3f2.js";
+import {
+  ApplicationScript
+} from "./index-p993efkq.js";
+import"./index-7md2g9vw.js";
+import"./index-jmrn54tt.js";
+
+// pkgs/@akanjs/cli/application/application.command.ts
+var mobileTargetOption = {
+  desc: "native target name (a key of native.targets) or all",
+  ask: "Select native target",
+  enum: async ({ app }) => await getMobileTargetChoices(app)
+};
+var deviceOption = {
+  desc: "simulator, emulator or device to run on: its id or name (e.g. 'iPhone 17' or 'Pixel_10')",
+  default: ""
+};
+var teamOption = { flag: "T", desc: "Apple team id the signing is narrowed to", default: "" };
+var devEnvs = ["local", "debug", "develop", "main"];
+var buildEnvOption = { enum: devEnvs, desc: "backend environment", default: "debug" };
+var startEnvOption = {
+  enum: devEnvs,
+  desc: "backend environment of a --release build; a dev build follows `akan start`, which keeps its own",
+  default: "local"
+};
+var releaseEnvOption = {
+  enum: ["debug", "develop", "main", "local"],
+  desc: "backend environment",
+  default: "main"
+};
+
+class ApplicationCommand extends command("application", [ApplicationScript], ({ public: target }) => ({
+  createApplication: target({ desc: "Create a new application in the workspace" }).arg("appName", String, { desc: "name of application" }).option("start", Boolean, { desc: "start application", default: false }).with(Workspace).exec(async function(appName, start, workspace) {
+    await this.applicationScript.createApplication(appName.toLowerCase().replace(/ /g, "-"), workspace, { start });
+  }),
+  removeApplication: target({ desc: "Remove an application from the workspace" }).with(App).exec(async function(app) {
+    await this.applicationScript.removeApplication(app);
+  }),
+  planSlice: target({ desc: "List the exact files an app needs to live in a workspace of its own" }).with(App).option("format", String, { desc: "output format", default: "text", enum: ["text", "json"] }).exec(async function(app, format) {
+    await this.applicationScript.planSlice(app, format);
+  }),
+  sync: target({ desc: "Sync dependencies and configuration for an app or library" }).with(Sys).exec(async function(sys) {
+    await this.applicationScript.sync(sys);
+  }),
+  script: target({ desc: "Run a custom script in the application" }).with(App).arg("filename", String, { desc: "name of script", nullable: true }).exec(async function(app, filename) {
+    await this.applicationScript.script(app, filename);
+  }),
+  console: target({ desc: "Open an interactive server console for the application" }).with(App).exec(async function(app) {
+    await this.applicationScript.console(app);
+  }),
+  logs: target({ desc: "Tail the running application's logs, filtered (attaches to akan-control.sock)" }).with(App).option("level", String, { desc: "minimum level: trace, verbose, debug, info, warn, error", nullable: true }).option("grep", String, { desc: "substring the message must contain", nullable: true }).option("endpoint", String, {
+    desc: "endpoint glob(s), comma-separated: mutation:*, query:userList",
+    nullable: true
+  }).option("trace", String, { desc: "one request's traceId", nullable: true }).option("child", String, { desc: "replica index(es), comma-separated", nullable: true }).option("role", String, {
+    flag: "R",
+    desc: "process role(s): gateway, federation, batch, all, rsc-worker",
+    nullable: true
+  }).option("origin", String, { desc: "call origin(s): http, websocket, mcp, internal, page", nullable: true }).option("since", String, {
+    desc: "only records newer than this: a duration ago in ms, s, m, h or d (30s, 5m, 2h), or an epoch-ms timestamp",
+    nullable: true
+  }).option("replay", Number, { flag: "n", desc: "records to replay from the buffer before following", default: 0 }).option("json", Boolean, { desc: "print NDJSON records instead of rendered lines", default: false }).option("follow", Boolean, { desc: "keep streaming; pass --follow false for history only", default: true }).option("runtimeDir", String, {
+    flag: "d",
+    desc: "runtime dir holding akan-control.sock (default: local/apps/<app>/runtime)",
+    nullable: true
+  }).exec(async function(app, level, grep, endpoint, trace, child, role, origin, since, replay, json, follow, runtimeDir) {
+    await this.applicationScript.logs(app, {
+      level,
+      grep,
+      endpoint,
+      trace,
+      child,
+      role,
+      origin,
+      since,
+      replay,
+      json,
+      follow,
+      runtimeDir
+    });
+  }),
+  build: target({ short: true, desc: "Build the application for production (frontend + backend)" }).with(App).option("write", Boolean, { desc: "write code generation", default: true }).option("fast", Boolean, { desc: "fast build", default: false }).option("quiet", Boolean, { desc: "hide build progress output", default: false }).exec(async function(app, write, fast, quiet) {
+    await this.applicationScript.build(app, { write, fast, quiet });
+  }),
+  typecheck: target({ short: true, desc: "Typecheck the application" }).with(App).option("write", Boolean, { desc: "write code generation", default: true }).option("clean", Boolean, { desc: "clear typecheck cache before running", default: false }).option("incremental", Boolean, { desc: "reuse TypeScript incremental cache", default: true }).exec(async function(app, write, clean, incremental) {
+    await this.applicationScript.typecheck(app, { write, clean, incremental });
+  }),
+  test: target({ desc: "Prepare and test an app, library, or package" }).with(Exec).option("write", Boolean, { desc: "write code generation", default: true }).exec(async function(exec, write) {
+    await this.applicationScript.test(exec, { write });
+  }),
+  buildIos: target({ short: true, desc: "Build the iOS app on the native runtime" }).with(App).option("target", String, mobileTargetOption).option("env", String, buildEnvOption).option("debug", Boolean, { desc: "debug build instead of release", default: false }).option("write", Boolean, { desc: "write code generation", default: true }).exec(async function(app, target, env, debug, write) {
+    await this.applicationScript.buildIos(app, { target, env, profile: debug ? "debug" : "release", write });
+  }),
+  buildAndroid: target({ short: true, desc: "Build the Android app (apk) on the native runtime" }).with(App).option("target", String, mobileTargetOption).option("env", String, buildEnvOption).option("debug", Boolean, { desc: "debug build instead of release", default: false }).option("write", Boolean, { desc: "write code generation", default: true }).exec(async function(app, target, env, debug, write) {
+    await this.applicationScript.buildAndroid(app, { target, env, profile: debug ? "debug" : "release", write });
+  }),
+  buildDesktop: target({ short: true, desc: "Build the desktop app for this computer (macOS, Windows or Linux)" }).with(App).option("target", String, mobileTargetOption).option("env", String, buildEnvOption).option("debug", Boolean, { desc: "debug build instead of release", default: false }).option("installer", Boolean, {
+    desc: "also what a person downloads: a Windows setup program (NSIS, /S for silent), a macOS dmg, a Linux AppImage",
+    default: false
+  }).option("arch", String, {
+    desc: "the CPU the app runs on, arm64 or x64 of this OS (default this computer's); a macOS app is arm64 only",
+    enum: ["arm64", "x64"],
+    nullable: true
+  }).option("write", Boolean, { desc: "write code generation", default: true }).exec(async function(app, target, env, debug, installer, arch, write) {
+    await this.applicationScript.buildDesktop(app, {
+      target,
+      env,
+      profile: debug ? "debug" : "release",
+      installer,
+      write,
+      ...arch ? { arch } : {}
+    });
+  }),
+  start: target({ short: true, desc: "Start development server(s) (frontend SSR + backend)" }).with(Apps).option("plain", Boolean, { desc: "print prefixed lines instead of the full-screen view", default: false }).option("kill", Boolean, { flag: "k", desc: "free the dev ports first, whoever is holding them", default: false }).option("concurrency", Number, {
+    desc: "apps to boot at a time (default: what this machine's memory and cores allow)",
+    nullable: true
+  }).option("dbup", Boolean, { desc: "start the local database first", default: true }).option("open", Boolean, { desc: "open web browser?", default: false }).option("share", Boolean, { desc: "also share each app on a public URL through an akan tunnel", default: false }).option("write", Boolean, { desc: "write code generation", default: true }).exec(async function(apps, plain, kill, concurrency, dbup, open, share, write) {
+    await this.applicationScript.start(apps, { plain, kill, concurrency, dbup, open, share, write });
+  }),
+  startIos: target({ short: true, desc: "Run the iOS app in a simulator or on an iPhone, following `akan start`" }).with(App).option("target", String, mobileTargetOption).option("env", String, startEnvOption).option("release", Boolean, { desc: "run a release build of its own bundle instead", default: false }).option("device", String, deviceOption).option("team", String, teamOption).option("write", Boolean, { desc: "write code generation", default: true }).exec(async function(app, target, env, release, device, team, write) {
+    await this.applicationScript.startIos(app, {
+      target,
+      env,
+      operation: release ? "release" : "local",
+      device: device || undefined,
+      teamId: team || undefined,
+      write
+    });
+  }),
+  startAndroid: target({
+    short: true,
+    desc: "Run the Android app in an emulator or on a device, following `akan start`"
+  }).with(App).option("target", String, mobileTargetOption).option("env", String, startEnvOption).option("release", Boolean, { desc: "run a release build of its own bundle instead", default: false }).option("device", String, deviceOption).option("write", Boolean, { desc: "write code generation", default: true }).exec(async function(app, target, env, release, device, write) {
+    await this.applicationScript.startAndroid(app, {
+      target,
+      env,
+      operation: release ? "release" : "local",
+      device: device || undefined,
+      write
+    });
+  }),
+  startDesktop: target({
+    short: true,
+    desc: "Run the desktop app on this computer (macOS, Windows or Linux), following `akan start`"
+  }).with(App).option("target", String, mobileTargetOption).option("env", String, startEnvOption).option("release", Boolean, { desc: "run a release build of its own bundle instead", default: false }).option("write", Boolean, { desc: "write code generation", default: true }).exec(async function(app, target, env, release, write) {
+    await this.applicationScript.startDesktop(app, {
+      target,
+      env,
+      operation: release ? "release" : "local",
+      write
+    });
+  }),
+  releaseIos: target({ desc: "Build and sign the iOS app for the App Store (.ipa)" }).with(App).option("target", String, mobileTargetOption).option("env", String, releaseEnvOption).option("team", String, teamOption).option("adHoc", Boolean, { desc: "sign with an ad-hoc profile instead of app-store", default: false }).option("write", Boolean, { desc: "write code generation", default: true }).option("allowLocalRelease", Boolean, { flag: "l", desc: "allow release with --env local", default: false }).exec(async function(app, target, env, team, adHoc, write, allowLocalRelease) {
+    await this.applicationScript.releaseIos(app, {
+      target,
+      env,
+      teamId: team || undefined,
+      adHoc,
+      write,
+      allowLocalRelease
+    });
+  }),
+  releaseAndroid: target({ desc: "Build and sign the Android app for the Play Store (aab, or apk)" }).with(App).option("assembleType", String, { enum: ["aab", "apk"], default: "aab" }).option("target", String, mobileTargetOption).option("env", String, releaseEnvOption).option("write", Boolean, { desc: "write code generation", default: true }).option("allowLocalRelease", Boolean, { flag: "l", desc: "allow release with --env local", default: false }).exec(async function(app, assembleType, target, env, write, allowLocalRelease) {
+    await this.applicationScript.releaseAndroid(app, assembleType, {
+      target,
+      env,
+      write,
+      allowLocalRelease
+    });
+  }),
+  packUpdate: target({
+    desc: "Pack an unsigned over-the-air update of the mobile web bundle, for the signer to publish"
+  }).with(App).option("platform", String, { enum: ["ios", "android"], desc: "the app it updates" }).option("target", String, mobileTargetOption).option("env", String, releaseEnvOption).option("out", String, {
+    desc: "output folder (default: .akan/native/<target>/updates/<platform>)",
+    nullable: true
+  }).option("against", String, {
+    desc: "bundle.json of the store build it must run in; fails when it needs a new one",
+    nullable: true
+  }).option("write", Boolean, { desc: "write code generation", default: true }).option("allowLocalRelease", Boolean, { flag: "l", desc: "allow packing with --env local", default: false }).exec(async function(app, platform, target, env, out, against, write, allowLocalRelease) {
+    await this.applicationScript.packUpdate(app, platform, {
+      target,
+      env,
+      out: out ?? undefined,
+      against: against ?? undefined,
+      write,
+      allowLocalRelease
+    });
+  }),
+  updateKeygen: target({ desc: "Make (once) the key an app's update releases are signed with; print its public key" }).with(App).option("platform", String, {
+    enum: ["desktop", "android", "ios"],
+    default: "desktop",
+    desc: "the platform whose app id the key signs for (an appId may differ per platform)"
+  }).option("target", String, mobileTargetOption).exec(async function(app, platform, target) {
+    await this.applicationScript.updateKeygen(app, platform, { target });
+  }),
+  publishUpdate: target({ desc: "Build and sign an update release installed apps take (desktop, android or ios)" }).with(App).option("platform", String, {
+    enum: ["desktop", "android", "ios"],
+    default: "desktop",
+    desc: "desktop is this computer's OS and CPU; android and ios publish the web bundle"
+  }).option("target", String, mobileTargetOption).option("env", String, releaseEnvOption).option("channel", String, {
+    desc: "the manifest to publish to (default: the target's updates.channel, else --env)",
+    nullable: true
+  }).option("write", Boolean, { desc: "write code generation", default: true }).option("allowLocalRelease", Boolean, { flag: "l", desc: "allow release with --env local", default: false }).exec(async function(app, platform, target, env, channel, write, allowLocalRelease) {
+    await this.applicationScript.publishUpdate(app, platform, {
+      target,
+      env,
+      ...channel ? { channel } : {},
+      write,
+      allowLocalRelease
+    });
+  }),
+  dbup: target({ desc: "Start local database services for a database mode" }).with(Workspace).option("mode", String, {
+    desc: "database mode; left out, every mode the workspace's apps declare",
+    enum: ["single", "multiple", "cluster"],
+    nullable: true
+  }).exec(async function(workspace, mode) {
+    await this.applicationScript.dbupDeclared(workspace, mode);
+  }),
+  dbExport: target({ desc: "Write every model table of an app to one NDJSON file each" }).with(App).option("dir", String, { desc: "directory under the workspace to write", default: "local/transfer" }).exec(async function(app, dir) {
+    await this.applicationScript.transferDatabase(app, "export", dir);
+  }),
+  dbImport: target({ desc: "Read files db-export wrote into an app's database, in the mode the shell names" }).with(App).option("dir", String, { desc: "directory under the workspace to read", default: "local/transfer" }).exec(async function(app, dir) {
+    await this.applicationScript.transferDatabase(app, "import", dir);
+  }),
+  dbdown: target({ desc: "Stop local database services" }).with(Workspace).exec(async function(workspace) {
+    await this.applicationScript.dbdown(workspace);
+  })
+})) {
+}
+export {
+  ApplicationCommand
+};

package/{applicationBuildRunner-kxwbssgn.js → applicationBuildRunner-64taxseg.js}

@@ -1,22 +1,55 @@
 // @bun
 import {
   Spinner
-} from "./index-2tv3fdx4.js";
+} from "./index-3w94e7n3.js";
+import"./index-6he6gvfg.js";
 import {
   AllRoutesBuilder,
   CsrArtifactBuilder,
   FontPruner,
   precompressArtifacts,
   SsrBaseArtifactBuilder
-} from "./index-a64esmtb.js";
-import"./index-w8kmx1b6.js";
-import"./index-q0y2jq9j.js";
-import"./index-hwkygn9s.js";
+} from "./index-kcdj1z5v.js";
+import"./index-52w0fvh8.js";
 import"./index-n68jx79w.js";
 
 // pkgs/@akanjs/devkit/applicationBuildRunner.ts
 import { mkdir, rm } from "fs/promises";
+import path2 from "path";
+
+// pkgs/@akanjs/devkit/transforms/serverEnvPlugin.ts
+import { existsSync, realpathSync } from "fs";
 import path from "path";
+var escapeRegExp = (value) => value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+var createServerEnvPlugin = ({ envDir, environment, environments }) => {
+  const others = [...new Set(environments)].filter((name) => name !== environment);
+  const dirs = new Set([path.resolve(envDir), existsSync(envDir) ? realpathSync.native(envDir) : envDir]);
+  const names = others.map(escapeRegExp).join("|");
+  const filter = new RegExp(`^(?:${[...dirs].map(escapeRegExp).join("|")})[\\\\/]env\\.server\\.(?:${names})\\.ts$`);
+  return {
+    name: "akan-server-env",
+    setup(build) {
+      if (!others.length)
+        return;
+      build.onLoad({ filter }, async (args) => {
+        const name = path.basename(args.path, ".ts").slice("env.server.".length);
+        const { exports } = new Bun.Transpiler({ loader: "ts" }).scan(await Bun.file(args.path).text());
+        const message = `env/env.server.${name}.ts is not in this build: \`akan build\` bundles the server env of AKAN_PUBLIC_ENV=${environment} alone, the environment its image runs. To run ${name}, build for it: AKAN_PUBLIC_ENV=${name} in the workspace's .env, which outranks the shell, or --env ${name} on a desktop or mobile build.`;
+        return {
+          loader: "js",
+          contents: [
+            `const refuse = () => { throw new Error(${JSON.stringify(message)}); };`,
+            "const unbuilt = new Proxy({}, { get: refuse, has: refuse, ownKeys: refuse, getOwnPropertyDescriptor: refuse });",
+            `export { ${exports.map((exported) => `unbuilt as ${JSON.stringify(exported)}`).join(", ")} };`
+          ].join(`
+`)
+        };
+      });
+    }
+  };
+};
+
+// pkgs/@akanjs/devkit/applicationBuildRunner.ts
 var BUILD_PHASE_EMOJIS = {
   prepare: "\uD83E\uDDF9",
   typecheck: "\uD83D\uDD0E",
@@ -51,54 +84,52 @@ class ApplicationBuildRunner {
   #app;
   #fast;
   #reporter;
+  #environment;
+  #spinner;
   #startedAt = Date.now();
   #phases = [];
-  constructor(app, { fast = false, reporter } = {}) {
+  constructor(app, { fast = false, reporter, environment } = {}) {
     this.#app = app;
     this.#fast = fast;
     this.#reporter = reporter;
+    this.#environment = environment;
   }
   async build({ spinner = false } = {}) {
-    const phaseOptions = { spinner };
+    this.#spinner = spinner;
     const { web, assets } = await this.#app.getConfig();
-    await this.#runPhase("prepare", "Preparing output directory", () => this.#app.prepareCommand("build"), undefined, {
-      spinner
-    });
+    await this.#runPhase("prepare", "Preparing output directory", () => this.#app.prepareCommand("build"));
     if (!this.#fast)
-      await this.#runPhase("typecheck", "Typechecking", () => this.typecheck(), undefined, phaseOptions);
-    await this.#runPhase("backend", "Compiling backend", () => this.#buildBackend(), (result) => `${result.entrypoints} entrypoints, ${result.outputs} outputs`, phaseOptions);
-    await this.#runPhase("ssr", "Building SSR route artifacts", async () => web.ssr ? await this.#buildSsr() : null, (result) => result ? `${result.allRoutes.manifest.routeIds.length} routes, ${result.allRoutes.manifest.knownEntries.length} entries` : web.ssr ? "skipped" : "disabled by akan.config.ts web.ssr", phaseOptions);
-    await this.#runPhase("csr", "Building CSR assets", async () => web.csr ? await this.#buildCsr() : null, (result) => result?.outputDir ?? (web.csr ? "skipped" : "disabled by akan.config.ts web.csr"), phaseOptions);
-    await this.#runPhase("assets", "Trimming unread static assets", async () => assets.pruneFonts ? await new FontPruner(this.#app, assets).prune() : null, (result) => result ? `${result.removed.length} font file(s) dropped, ${ApplicationBuildRunner.formatBytes(result.freedBytes)} freed; ${result.kept.length} kept` : "disabled by akan.config.ts assets.pruneFonts", phaseOptions);
-    await this.#runPhase("compress", "Compressing static assets", () => precompressArtifacts(this.#app), (result) => result.files > 0 ? `${result.files} files, ${ApplicationBuildRunner.formatBytes(result.inputBytes)} -> gzip ${ApplicationBuildRunner.formatBytes(result.outputBytes)} / br ${ApplicationBuildRunner.formatBytes(result.brotliBytes)}` : "no files", phaseOptions);
-    await this.#runPhase("metadata", "Writing production metadata", () => this.#buildAppMeta(), undefined, {
-      spinner
-    });
+      await this.#runPhase("typecheck", "Typechecking", () => this.typecheck());
+    await this.#runPhase("backend", "Compiling backend", () => this.#buildBackend(), (result) => `${result.entrypoints} entrypoints, ${result.outputs} outputs`);
+    await this.#runPhase("ssr", "Building SSR route artifacts", async () => web.ssr ? await this.#buildSsr() : null, (result) => result ? `${result.allRoutes.manifest.routeIds.length} routes, ${result.allRoutes.manifest.knownEntries.length} entries` : web.ssr ? "skipped" : "disabled by akan.config.ts web.ssr");
+    await this.#runPhase("csr", "Building CSR assets", async () => web.csr ? await new CsrArtifactBuilder(this.#app, "build").build() : null, (result) => result?.outputDir ?? (web.csr ? "skipped" : "disabled by akan.config.ts web.csr"));
+    await this.#runPhase("assets", "Trimming unread static assets", async () => assets.pruneFonts ? await new FontPruner(this.#app, assets).prune() : null, (result) => result ? `${result.removed.length} font file(s) dropped, ${ApplicationBuildRunner.formatBytes(result.freedBytes)} freed; ${result.kept.length} kept` : "disabled by akan.config.ts assets.pruneFonts");
+    await this.#runPhase("compress", "Compressing static assets", () => precompressArtifacts(this.#app), (result) => result.files > 0 ? `${result.files} files, ${ApplicationBuildRunner.formatBytes(result.inputBytes)} -> gzip ${ApplicationBuildRunner.formatBytes(result.outputBytes)} / br ${ApplicationBuildRunner.formatBytes(result.brotliBytes)}` : "no files");
+    await this.#runPhase("metadata", "Writing production metadata", () => this.buildAppMeta());
     return {
       phases: this.#phases,
       durationMs: Date.now() - this.#startedAt,
       outputDir: this.#app.dist.cwdPath,
-      artifactDir: path.join(this.#app.dist.cwdPath, ".akan/artifact")
+      artifactDir: path2.join(this.#app.dist.cwdPath, ".akan/artifact")
     };
   }
   async typecheck(options = {}) {
     const { clean = false, incremental = true } = options;
     await this.#app.getPageKeys({ refresh: true });
-    const { typecheckDir, tsconfigPath } = await this.#writeTypecheckTsconfig({ incremental });
+    const { typecheckDir, tsconfigPath } = await this.#writeTypecheckTsconfig(incremental);
     if (clean)
-      await rm(path.join(typecheckDir, "tsconfig.tsbuildinfo"), { force: true });
+      await rm(path2.join(typecheckDir, "tsconfig.tsbuildinfo"), { force: true });
     await this.#checkProjectInChildProcess(tsconfigPath);
   }
-  async#runPhase(id, label, task, summarize, options = {}) {
+  async#runPhase(id, label, task, summarize) {
     this.#reporter?.phaseStart?.({ id, label });
     const phaseStartedAt = Date.now();
-    const spinner = options.spinner ? new Spinner(label, { prefix: `${BUILD_PHASE_EMOJIS[id]} ${id}` }).start() : undefined;
+    const spinner = this.#spinner ? new Spinner(label, { prefix: `${BUILD_PHASE_EMOJIS[id]} ${id}` }).start() : undefined;
     try {
       const result = await task();
       const phase = { id, label, durationMs: Date.now() - phaseStartedAt, summary: summarize?.(result) };
       this.#phases.push(phase);
-      const summary = phase.summary ? `: ${phase.summary}` : "";
-      spinner?.succeed(`${label}${summary}`);
+      spinner?.succeed(`${label}${phase.summary ? `: ${phase.summary}` : ""}`);
       this.#reporter?.phaseDone?.(phase);
       return result;
     } catch (error) {
@@ -107,63 +138,85 @@ class ApplicationBuildRunner {
       throw error;
     }
   }
-  async#buildAppMeta() {
+  async buildAppMeta() {
     const akanConfig = await this.#app.getConfig();
+    const dockerfile = akanConfig.dockerfileFor(this.#environment ?? akanConfig.baseDevEnv.env);
     await Promise.all([
       this.#app.dist.writeJson("package.json", akanConfig.getProductionPackageJson()),
-      this.#app.dist.writeFile(`${this.#app.dist.cwdPath}/Dockerfile`, akanConfig.dockerfile)
+      this.#app.dist.writeFile(`${this.#app.dist.cwdPath}/Dockerfile`, dockerfile),
+      this.#app.dist.writeJson("akan.build.json", {
+        buildId: await this.#resolveBuildId(),
+        akanVersion: akanConfig.akanVersion,
+        builtAt: new Date().toISOString()
+      })
     ]);
   }
+  async#resolveBuildId() {
+    const fromEnv = process.env.AKAN_BUILD_ID?.trim();
+    if (fromEnv)
+      return fromEnv;
+    const root = this.#app.workspace.workspaceRoot;
+    const sha = Bun.spawnSync(["git", "rev-parse", "--short=12", "HEAD"], { cwd: root, stderr: "ignore" });
+    if (sha.exitCode !== 0)
+      return null;
+    const dirty = Bun.spawnSync(["git", "status", "--porcelain", "--untracked-files=no"], {
+      cwd: root,
+      stderr: "ignore"
+    });
+    const suffix = dirty.exitCode === 0 && dirty.stdout.toString().trim() ? "-dirty" : "";
+    return `${sha.stdout.toString().trim()}${suffix}`;
+  }
   async#buildBackend() {
-    const akanConfig = await this.#app.getConfig();
-    const backendExternals = [
-      ...new Set([...akanConfig.externalLibs, ...SSR_RENDER_EXTERNALS, ...AKAN_OPTIONAL_BACKEND_EXTERNALS])
-    ];
-    const { web } = akanConfig;
+    const { externalLibs, web, baseDevEnv, branches } = await this.#app.getConfig();
     const backendEntryPoints = [`${this.#app.cwdPath}/main.ts`, `${this.#app.cwdPath}/server.ts`];
     for (const entrypoint of backendEntryPoints) {
       if (!await Bun.file(entrypoint).exists())
         throw new Error(`Backend entrypoint not found: ${entrypoint}`);
     }
-    const backendResult = await this.#buildOrThrow("backend", {
-      entrypoints: backendEntryPoints,
+    const sharedConfig = {
       outdir: this.#app.dist.cwdPath,
       target: "bun",
       minify: AKAN_BACKEND_MINIFY,
       naming: { entry: "[name].[ext]", chunk: "chunk-[hash].[ext]" },
-      define: { "process.env.NODE_ENV": JSON.stringify("production") },
-      plugins: backendExternals.length > 0 ? [this.#createExternalSpecifiersPlugin(backendExternals)] : []
+      define: { "process.env.NODE_ENV": JSON.stringify("production") }
+    };
+    const serverEnvPlugin = createServerEnvPlugin({
+      envDir: path2.join(this.#app.cwdPath, "env"),
+      environment: this.#environment ?? baseDevEnv.env,
+      environments: ["local", "testing", ...branches]
     });
+    const backendConfig = {
+      ...sharedConfig,
+      plugins: [this.#createExternalSpecifiersPlugin(externalLibs), serverEnvPlugin]
+    };
+    const [mainResult, serverResult] = [
+      await this.#buildOrThrow("backend", { ...backendConfig, entrypoints: [backendEntryPoints[0]] }),
+      await this.#buildOrThrow("backend", { ...backendConfig, entrypoints: [backendEntryPoints[1]], splitting: true })
+    ];
     const rscWorkerResult = web.ssr ? await this.#buildOrThrow("rsc-worker", {
+      ...backendConfig,
       entrypoints: [this.#resolveRscWorkerBuildEntry()],
-      outdir: this.#app.dist.cwdPath,
-      target: "bun",
-      minify: AKAN_BACKEND_MINIFY,
-      naming: { entry: "[name].[ext]", chunk: "chunk-[hash].[ext]" },
-      conditions: ["react-server"],
-      define: { "process.env.NODE_ENV": JSON.stringify("production") },
-      plugins: backendExternals.length > 0 ? [this.#createExternalSpecifiersPlugin(backendExternals)] : []
+      conditions: ["react-server"]
     }) : null;
     const consoleRuntimeResult = await this.#buildOrThrow("console-runtime", {
+      ...sharedConfig,
       entrypoints: [this.#resolveConsoleRuntimeBuildEntry()],
-      outdir: this.#app.dist.cwdPath,
-      target: "bun",
-      minify: AKAN_BACKEND_MINIFY,
-      naming: { entry: "console-runtime.[ext]", chunk: "chunk-[hash].[ext]" },
-      define: { "process.env.NODE_ENV": JSON.stringify("production") }
+      naming: { entry: "console-runtime.[ext]", chunk: "chunk-[hash].[ext]" }
     });
     await this.#writeConsoleShim();
+    const results = [mainResult, serverResult, rscWorkerResult, consoleRuntimeResult];
     return {
       entrypoints: backendEntryPoints.length + (rscWorkerResult ? 2 : 1),
-      outputs: backendResult.outputs.length + (rscWorkerResult?.outputs.length ?? 0) + consoleRuntimeResult.outputs.length + 1
+      outputs: results.reduce((sum, result) => sum + (result?.outputs.length ?? 0), 1)
     };
   }
   async#writeConsoleShim() {
-    await Bun.write(path.join(this.#app.dist.cwdPath, "console.js"), `import { cnst, db, dict, option, server, sig, srv } from "./server.js";
-import { assertAkanConsoleAllowed, startAkanConsole } from "./console-runtime.js";
+    await Bun.write(path2.join(this.#app.dist.cwdPath, "console.js"), `process.env.AKAN_COMMAND_TYPE = "console";
+const { cnst, db, dict, option, server, sig, srv } = await import("./server.js");
+const { assertAkanConsoleAllowed, startAkanConsole } = await import("./console-runtime.js");
 
 const run = async () => {
-  assertAkanConsoleAllowed(server.env);
+  assertAkanConsoleAllowed();
   await server.start({ listen: false, web: false });
   try {
     await startAkanConsole(server, { globals: { cnst, db, dict, option, sig, srv } });
@@ -182,19 +235,16 @@ void run().catch((error) => {
     try {
       return Bun.resolveSync("akanjs/server/rsc-worker", import.meta.dir);
     } catch {
-      return path.join(this.#app.workspace.workspaceRoot, "pkgs/akanjs/server/rscWorker.tsx");
+      return path2.join(this.#app.workspace.workspaceRoot, "pkgs/akanjs/server/rscWorker.tsx");
     }
   }
   #resolveConsoleRuntimeBuildEntry() {
     try {
-      return path.join(path.dirname(Bun.resolveSync("akanjs/server", import.meta.dir)), "console.ts");
+      return path2.join(path2.dirname(Bun.resolveSync("akanjs/server", import.meta.dir)), "console.ts");
     } catch {
-      return path.join(this.#app.workspace.workspaceRoot, "pkgs/akanjs/server/console.ts");
+      return path2.join(this.#app.workspace.workspaceRoot, "pkgs/akanjs/server/console.ts");
     }
   }
-  async#buildCsr() {
-    return await new CsrArtifactBuilder(this.#app, "build").build();
-  }
   async#buildSsr() {
     const pageKeys = await this.#app.getPageKeys();
     if (pageKeys.length === 0) {
@@ -205,11 +255,11 @@ void run().catch((error) => {
     const allRoutes = await new AllRoutesBuilder(this.#app, base.artifact, "build").build();
     return { base, allRoutes };
   }
-  async#writeTypecheckTsconfig({ incremental = true } = {}) {
-    const typecheckDir = path.join(this.#app.cwdPath, ".akan", "typecheck");
+  async#writeTypecheckTsconfig(incremental) {
+    const typecheckDir = path2.join(this.#app.cwdPath, ".akan", "typecheck");
     await mkdir(typecheckDir, { recursive: true });
     const libPageIncludes = (await this.#app.getPageRoots()).filter((root) => root.keyPrefix).flatMap((root) => {
-      const rel = path.relative(typecheckDir, root.realDir).split(path.sep).join("/");
+      const rel = path2.relative(typecheckDir, root.realDir).split(path2.sep).join("/");
       return [`${rel}/**/*.ts`, `${rel}/**/*.tsx`];
     });
     const tsconfig = {
@@ -230,7 +280,7 @@ void run().catch((error) => {
       ],
       references: []
     };
-    const tsconfigPath = path.join(typecheckDir, "tsconfig.json");
+    const tsconfigPath = path2.join(typecheckDir, "tsconfig.json");
     await Bun.write(tsconfigPath, `${JSON.stringify(tsconfig, null, 2)}
 `);
     return { typecheckDir, tsconfigPath };
@@ -256,10 +306,10 @@ void run().catch((error) => {
   }
   async#resolveTypecheckWorkerEntry() {
     const candidates = [
-      path.join(this.#app.workspace.workspaceRoot, "pkgs/@akanjs/devkit/typecheck/typecheck.proc.ts"),
-      path.join(this.#app.workspace.workspaceRoot, "node_modules/@akanjs/devkit/typecheck/typecheck.proc.ts"),
-      path.join(import.meta.dir, "typecheck.proc.js"),
-      path.join(import.meta.dir, "typecheck.proc.ts")
+      path2.join(this.#app.workspace.workspaceRoot, "pkgs/@akanjs/devkit/typecheck/typecheck.proc.ts"),
+      path2.join(this.#app.workspace.workspaceRoot, "node_modules/@akanjs/devkit/typecheck/typecheck.proc.ts"),
+      path2.join(import.meta.dir, "typecheck.proc.js"),
+      path2.join(import.meta.dir, "typecheck.proc.ts")
     ];
     for (const candidate of candidates)
       if (await Bun.file(candidate).exists())
@@ -272,9 +322,9 @@ void run().catch((error) => {
       throw new AggregateError(result.logs, `[${label}] Bun.build failed`);
     return result;
   }
-  #createExternalSpecifiersPlugin(specifiers) {
-    const uniqueSpecifiers = [...new Set(specifiers)];
-    const escaped = uniqueSpecifiers.map((specifier) => specifier.replace(/[.*+?^${}()|[\]\\]/g, "\\$&"));
+  #createExternalSpecifiersPlugin(externalLibs) {
+    const specifiers = new Set([...externalLibs, ...SSR_RENDER_EXTERNALS, ...AKAN_OPTIONAL_BACKEND_EXTERNALS]);
+    const escaped = [...specifiers].map((specifier) => specifier.replace(/[.*+?^${}()|[\]\\]/g, "\\$&"));
     const filter = new RegExp(`^(${escaped.join("|")})(?:/.*)?$`);
     return {
       name: "akan-backend-externalize-specifiers",
@@ -283,13 +333,7 @@ void run().catch((error) => {
       }
     };
   }
-  static formatBytes(bytes) {
-    if (bytes < 1024)
-      return `${bytes}B`;
-    if (bytes < 1024 * 1024)
-      return `${(bytes / 1024).toFixed(1)}KB`;
-    return `${(bytes / 1024 / 1024).toFixed(1)}MB`;
-  }
+  static formatBytes = FontPruner.formatBytes;
 }
 export {
   ApplicationBuildRunner