@akanjs/cli 3.1.0-rc.1 → 3.1.0-rc.3

package/.build-stamp

@@ -1 +1 @@
-ee31653f86d9a17de2cf6fbfbfb3f585db1d135b4d2fa1dceaa1e6faee5fa437
+f6be05c6146350a182c921b0d0fe46efe9d3f1d211b8ec3c2978f83a3d11567e

package/{CodeAgent-kyprmy06.js → CodeAgent-ctk4fh2b.js}

@@ -1,8 +1,8 @@
 // @bun
 import {
   CodeAgent2
-} from "./index-krq7btbt.js";
-import"./index-rtct7d43.js";
+} from "./index-xm5tmpv0.js";
+import"./index-3675mvjw.js";
 import"./index-7md2g9vw.js";
 export {
   CodeAgent2 as CodeAgent

package/{CodeTui-21mtze3j.js → CodeTui-mrxtrdzw.js}

@@ -4,7 +4,7 @@ import {
   McpServerConfig,
   McpTokenStore,
   McpSignIn
-} from "./index-rtct7d43.js";
+} from "./index-3675mvjw.js";
 import {
   CodeTuiLines2,
   CodeTuiAgents2,

package/TunnelShare-rj74jd6x.js

@@ -0,0 +1,13 @@
+// @bun
+import {
+  TunnelShare2
+} from "./index-3ddt3qjg.js";
+import"./index-wjqbc7sf.js";
+import"./index-qf8g88j9.js";
+import"./index-2z3kykvd.js";
+import"./index-ec080x99.js";
+import"./index-bv210r6t.js";
+import"./index-52w0fvh8.js";
+export {
+  TunnelShare2 as TunnelShare
+};

package/{agent.command-f3gsc1gd.js → agent.command-ncre6kwz.js}

@@ -2,16 +2,16 @@
 import {
   Workspace,
   command
-} from "./index-6jjtnhkw.js";
+} from "./index-3x7yeecy.js";
 import"./index-52w0fvh8.js";
-import"./index-55mynnqs.js";
+import"./index-bv210r6t.js";
 import"./index-hj6w4ka1.js";
-import"./index-05g3jayg.js";
-import"./index-2mx692qq.js";
+import"./index-wdze51wz.js";
+import"./index-vhfjzda3.js";
 import"./index-zzvvc845.js";
 import {
   AgentScript
-} from "./index-v29746vb.js";
+} from "./index-8eqkxwsx.js";
 
 // pkgs/@akanjs/cli/agent/agent.command.ts
 class AgentCommand extends command("agent", [AgentScript], ({ public: target }) => ({

package/akanCode.js

@@ -28,7 +28,7 @@ import {
   CodeMailbox2,
   CodeSessionFork2,
   CodeAgent2
-} from "./index-krq7btbt.js";
+} from "./index-xm5tmpv0.js";
 import {
   akanCodeDefaultModel2,
   akanCodeModel2,
@@ -39,7 +39,7 @@ import {
 import {
   SubagentPool2,
   akanCodePaths2
-} from "./index-rtct7d43.js";
+} from "./index-3675mvjw.js";
 import"./index-7md2g9vw.js";
 import {
   CodeAgentRpcHost2

package/{application.command-5s780vnz.js → application.command-54mawreg.js}

@@ -3,30 +3,33 @@ import {
   App,
   Apps,
   Sys,
+  SysOrOnlyApp,
   Exec,
   Workspace,
   command
-} from "./index-6jjtnhkw.js";
+} from "./index-3x7yeecy.js";
 import"./index-52w0fvh8.js";
-import"./index-55mynnqs.js";
-import"./index-1w2qaee2.js";
+import"./index-bv210r6t.js";
 import"./index-k9rrten6.js";
-import"./index-c1x0be5j.js";
+import"./index-kmamh5bv.js";
+import"./index-qf8g88j9.js";
+import"./index-ec080x99.js";
+import"./index-dmsvd2rv.js";
 import {
   ApplicationScript
-} from "./index-jx4bzvwg.js";
+} from "./index-1a7nhq56.js";
 import"./index-7md2g9vw.js";
-import"./index-qt22xstj.js";
 import {
-  getMobileTargetChoices
-} from "./index-q958tqqg.js";
+  writeOption,
+  nativeTargetOption,
+  releaseEnvOption,
+  allowLocalOption,
+  publicEnvOption
+} from "./index-8935h3n1.js";
+import"./index-c9zjb3tw.js";
+import"./index-2z3kykvd.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: ""
@@ -41,11 +44,6 @@ var startEnvOption = {
   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) {
@@ -96,32 +94,32 @@ class ApplicationCommand extends command("application", [ApplicationScript], ({
       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 }).option("profile", String, {
+  build: target({ short: true, desc: "Build the application for production (frontend + backend)" }).with(App).option("write", Boolean, writeOption).option("fast", Boolean, { desc: "fast build", default: false }).option("quiet", Boolean, { desc: "hide build progress output", default: false }).option("profile", String, {
     desc: "server env profile: bundle env/env.server.<env>.<profile>.ts in place of the environment's own file",
     nullable: true
   }).exec(async function(app, write, fast, quiet, profile) {
     await this.applicationScript.build(app, { write, fast, quiet, profile: profile ?? undefined });
   }),
-  typecheck: target({ short: true, desc: "Typecheck an app or a library, its tests and specs included" }).with(Exec).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 }).option("tests", Boolean, { desc: "check its *.test.ts / *.spec.ts too, which nothing imports", default: true }).exec(async function(exec, write, clean, incremental, tests) {
-    await this.applicationScript.typecheck(exec, { write, clean, incremental, tests });
+  typecheck: target({ short: true, desc: "Typecheck an app or a library, its tests and specs included" }).with(SysOrOnlyApp).option("write", Boolean, writeOption).option("clean", Boolean, { desc: "clear typecheck cache before running", default: false }).option("incremental", Boolean, { desc: "reuse TypeScript incremental cache", default: true }).option("tests", Boolean, { desc: "check its *.test.ts / *.spec.ts too, which nothing imports", default: true }).exec(async function(sys, write, clean, incremental, tests) {
+    await this.applicationScript.typecheck(sys, { write, clean, incremental, tests });
   }),
-  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) {
+  test: target({ desc: "Prepare and test an app, library, or package" }).with(Exec).option("write", Boolean, writeOption).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) {
+  buildIos: target({ short: true, desc: "Build the iOS app on the native runtime" }).with(App).option("target", String, nativeTargetOption).option("env", String, buildEnvOption).option("debug", Boolean, { desc: "debug build instead of release", default: false }).option("write", Boolean, writeOption).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) {
+  buildAndroid: target({ short: true, desc: "Build the Android app (apk) on the native runtime" }).with(App).option("target", String, nativeTargetOption).option("env", String, buildEnvOption).option("debug", Boolean, { desc: "debug build instead of release", default: false }).option("write", Boolean, writeOption).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, {
+  buildDesktop: target({ short: true, desc: "Build the desktop app for this computer (macOS, Windows or Linux)" }).with(App).option("target", String, nativeTargetOption).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("sign", Boolean, { desc: signDesc, default: false }).option("notarize", Boolean, { desc: notarizeDesc, default: false }).option("write", Boolean, { desc: "write code generation", default: true }).exec(async function(app, target, env, debug, installer, arch, sign, notarize, write) {
+  }).option("sign", Boolean, { desc: signDesc, default: false }).option("notarize", Boolean, { desc: notarizeDesc, default: false }).option("write", Boolean, writeOption).exec(async function(app, target, env, debug, installer, arch, sign, notarize, write) {
     await this.applicationScript.buildDesktop(app, {
       target,
       env,
@@ -136,10 +134,10 @@ class ApplicationCommand extends command("application", [ApplicationScript], ({
   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) {
+  }).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, writeOption).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) {
+  startIos: target({ short: true, desc: "Run the iOS app in a simulator or on an iPhone, following `akan start`" }).with(App).option("target", String, nativeTargetOption).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, writeOption).exec(async function(app, target, env, release, device, team, write) {
     await this.applicationScript.startIos(app, {
       target,
       env,
@@ -152,7 +150,7 @@ class ApplicationCommand extends command("application", [ApplicationScript], ({
   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) {
+  }).with(App).option("target", String, nativeTargetOption).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, writeOption).exec(async function(app, target, env, release, device, write) {
     await this.applicationScript.startAndroid(app, {
       target,
       env,
@@ -164,7 +162,7 @@ class ApplicationCommand extends command("application", [ApplicationScript], ({
   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) {
+  }).with(App).option("target", String, nativeTargetOption).option("env", String, startEnvOption).option("release", Boolean, { desc: "run a release build of its own bundle instead", default: false }).option("write", Boolean, writeOption).exec(async function(app, target, env, release, write) {
     await this.applicationScript.startDesktop(app, {
       target,
       env,
@@ -172,54 +170,57 @@ class ApplicationCommand extends command("application", [ApplicationScript], ({
       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) {
+  releaseIos: target({ desc: "Build and sign the iOS app for the App Store (.ipa)" }).with(App).option("target", String, nativeTargetOption).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, writeOption).option("allowLocalRelease", Boolean, allowLocalOption("release")).option("publicEnv", String, publicEnvOption("the release")).exec(async function(app, target, env, team, adHoc, write, allowLocalRelease, publicEnv) {
     await this.applicationScript.releaseIos(app, {
       target,
       env,
       teamId: team || undefined,
       adHoc,
       write,
-      allowLocalRelease
+      allowLocalRelease,
+      publicEnv: publicEnv ?? undefined
     });
   }),
-  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) {
+  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, nativeTargetOption).option("env", String, releaseEnvOption).option("write", Boolean, writeOption).option("allowLocalRelease", Boolean, allowLocalOption("release")).option("publicEnv", String, publicEnvOption("the release")).exec(async function(app, assembleType, target, env, write, allowLocalRelease, publicEnv) {
     await this.applicationScript.releaseAndroid(app, assembleType, {
       target,
       env,
       write,
-      allowLocalRelease
+      allowLocalRelease,
+      publicEnv: publicEnv ?? undefined
     });
   }),
   packUpdate: target({
-    desc: "Pack an unsigned over-the-air update of the mobile web bundle for a signer; records it in <out>/pack.json, exits 2 when --against needs a new store build"
-  }).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: "Pack an unsigned over-the-air update of the mobile web bundle for a signer; records it in <out>/pack.json. Exits 2 when --against needs a new store build, 1 on any other failure"
+  }).with(App).option("platform", String, { enum: ["ios", "android"], desc: "the app it updates" }).option("target", String, nativeTargetOption).option("env", String, releaseEnvOption).option("out", String, {
     desc: "output folder (default: dist/native/<app>/<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) {
+  }).option("write", Boolean, writeOption).option("allowLocalRelease", Boolean, allowLocalOption("packing")).option("publicEnv", String, publicEnvOption("the update (default: what --against recorded)")).exec(async function(app, platform, target, env, out, against, write, allowLocalRelease, publicEnv) {
     await this.applicationScript.packUpdate(app, platform, {
       target,
       env,
       out: out ?? undefined,
       against: against ?? undefined,
       write,
-      allowLocalRelease
+      allowLocalRelease,
+      publicEnv: publicEnv ?? undefined
     });
   }),
   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) {
+  }).option("target", String, nativeTargetOption).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, {
+  }).option("target", String, nativeTargetOption).option("env", String, releaseEnvOption).option("channel", String, {
     desc: "the manifest to publish to (default: the target's updates.channel, else --env)",
     nullable: true
   }).option("upload", String, {
@@ -232,7 +233,15 @@ class ApplicationCommand extends command("application", [ApplicationScript], ({
   }).option("sign", Boolean, {
     desc: `${signDesc}; a signed app takes only a release signed the same way`,
     default: false
-  }).option("notarize", Boolean, { desc: notarizeDesc, 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, platform, target, env, channel, upload, arch, sign, notarize, write, allowLocalRelease) {
+  }).option("notarize", Boolean, { desc: notarizeDesc, default: false }).option("revoke", String, {
+    desc: "android, ios: keyIds of updates.publicKeys this release starts revoking, comma-separated (update-keygen prints a key's); it is signed with a key listed after them",
+    nullable: true
+  }).option("resetSequence", Boolean, {
+    flag: "R",
+    desc: "android, ios: with --revoke, phones compare the release with their own bundle instead of the running one",
+    default: false
+  }).option("write", Boolean, writeOption).option("allowLocalRelease", Boolean, allowLocalOption("release")).exec(async function(app, platform, target, env, channel, upload, arch, sign, notarize, revoke, resetSequence, write, allowLocalRelease) {
+    const revoked = revoke?.split(",").map((keyId) => keyId.trim()).filter(Boolean);
     await this.applicationScript.publishUpdate(app, platform, {
       target,
       env,
@@ -241,6 +250,8 @@ class ApplicationCommand extends command("application", [ApplicationScript], ({
       ...channel ? { channel } : {},
       ...upload ? { upload } : {},
       ...arch ? { arch } : {},
+      ...revoked?.length ? { revoke: revoked } : {},
+      ...resetSequence ? { resetSequence } : {},
       write,
       allowLocalRelease
     });

package/{applicationBuildRunner-1yaqsrdq.js → applicationBuildRunner-8573zr2w.js}

@@ -1,21 +1,22 @@
 // @bun
 import {
   ServerEnvProfile,
-  Spinner
-} from "./index-55mynnqs.js";
-import"./index-aprt7pkz.js";
+  Spinner,
+  ProjectTypecheck2
+} from "./index-bv210r6t.js";
+import"./index-fvn6f5wx.js";
+import"./index-ec080x99.js";
 import {
   AllRoutesBuilder,
-  CsrArtifactBuilder,
   FontPruner,
   precompressArtifacts,
   SsrBaseArtifactBuilder
-} from "./index-c2yrsxdh.js";
+} from "./index-91rt5bye.js";
 import"./index-52w0fvh8.js";
 import"./index-n68jx79w.js";
 import {
-  ProjectTypecheck2
-} from "./index-6w0rbr9d.js";
+  CsrArtifactBuilder
+} from "./index-2z3kykvd.js";
 
 // pkgs/@akanjs/devkit/applicationBuildRunner.ts
 import path2 from "path";
@@ -38,22 +39,9 @@ var createServerEnvPlugin = ({
   const own = new RegExp(`${folder}${escapeRegExp(environment)}\\.ts$`);
   const libEnvs = new Map;
   const libEnv = async (file) => {
-    const profileFile = ServerEnvProfile.profileFileOf(file, profile ?? "");
-    const libRoot = path.dirname(path.dirname(file));
-    if (await Bun.file(profileFile).exists()) {
-      const secrets = ServerEnvProfile.secretPaths(await ServerEnvProfile.evaluate(profileFile, libRoot));
-      if (secrets.length)
-        throw new Error(`${profileFile} holds secret-named values, which the "${profile}" bundle carries to every computer it runs on: ${secrets.join(", ")}.`);
-      onLibEnv?.(file, { profileFile: true, stripped: [] });
-      return { loader: "ts", contents: await Bun.file(profileFile).text() };
-    }
-    const { exports } = new Bun.Transpiler({ loader: "ts" }).scan(await Bun.file(file).text());
-    if (exports.some((name) => name !== "env"))
-      throw new Error(`${file} exports ${exports.join(", ")}: a "${profile}" build carries only a lib env's \`env\`, so give the lib ${path.basename(profileFile)}.`);
-    const { value, stripped } = ServerEnvProfile.strip(await ServerEnvProfile.evaluate(file, libRoot));
-    onLibEnv?.(file, { profileFile: false, stripped });
-    return { loader: "js", contents: `export const env = ${JSON.stringify(value ?? {})};
-` };
+    const { loader, contents, profileFile, stripped } = await ServerEnvProfile.libEnvSource(file, profile ?? "");
+    onLibEnv?.(file, { profileFile, stripped });
+    return { loader, contents };
   };
   return {
     name: "akan-server-env",
@@ -61,7 +49,7 @@ var createServerEnvPlugin = ({
       if (profile)
         build.onLoad({ filter: own }, async (args) => ({
           loader: "ts",
-          contents: await Bun.file(path.join(path.dirname(args.path), `env.server.${environment}.${profile}.ts`)).text()
+          contents: await ServerEnvProfile.sourceInPlaceOf(path.join(path.dirname(args.path), ServerEnvProfile.fileName(environment, profile)), args.path, profile)
         }));
       if (others.length)
         build.onLoad({ filter }, async (args) => {
@@ -79,7 +67,7 @@ var createServerEnvPlugin = ({
           };
         });
       if (profile)
-        build.onLoad({ filter: /[\\/]env[\\/]env\.server\.[A-Za-z0-9-]+\.ts$/ }, async (args) => {
+        build.onLoad({ filter: ServerEnvProfile.envFilePattern }, async (args) => {
           const name = path.basename(args.path, ".ts").slice("env.server.".length);
           if (dirs.has(path.dirname(args.path)) || name === "type" || name === "example")
             return { loader: "ts", contents: await Bun.file(args.path).text() };
@@ -138,12 +126,10 @@ class ApplicationBuildRunner {
   async build({ spinner = false } = {}) {
     this.#spinner = spinner;
     const { web, assets, baseDevEnv } = await this.#app.getConfig();
+    const environment = this.#environment ?? baseDevEnv.env;
+    process.env.AKAN_PUBLIC_ENV = environment;
     if (this.#profile)
-      await ServerEnvProfile.assertShippable({
-        envDir: this.#envDir,
-        environment: this.#environment ?? baseDevEnv.env,
-        profile: this.#profile
-      });
+      await ServerEnvProfile.assertShippable({ envDir: this.#envDir, environment, profile: this.#profile });
     await this.#runPhase("prepare", "Preparing output directory", () => this.#app.prepareCommand("build"));
     if (!this.#fast)
       await this.#runPhase("typecheck", "Typechecking", () => this.typecheck());

package/buildBatch.proc.js

@@ -6,23 +6,27 @@ import {
   resolveSsrPageEntriesForApp,
   WorkspaceExecutor,
   AppExecutor
-} from "./index-55mynnqs.js";
+} from "./index-bv210r6t.js";
 import {
   computeRouteSeedIndex,
   saveRouteSeedIndex,
-  ServerGraphFile,
-  PagesBundleBuilder,
   CsrDevBundler,
   SsrDevBundler
-} from "./index-aprt7pkz.js";
+} from "./index-fvn6f5wx.js";
 import"./index-52w0fvh8.js";
 import {
-  CsrArtifactBuilder,
+  ServerGraphFile,
+  PagesBundleBuilder
+} from "./index-ec080x99.js";
+import {
   CssCompiler,
   FontOptimizer,
   SsrBaseArtifactBuilder
-} from "./index-c2yrsxdh.js";
+} from "./index-91rt5bye.js";
 import"./index-n68jx79w.js";
+import {
+  CsrArtifactBuilder
+} from "./index-2z3kykvd.js";
 
 // pkgs/@akanjs/devkit/incrementalBuilder/buildBatch.proc.ts
 import path from "path";
@@ -40,17 +44,21 @@ class BuildBatch {
     this.#result = { generation: request.generation, errors: {} };
   }
   async run() {
-    if (this.#request.needs.includes("base"))
+    const { needs } = this.#request;
+    const cssFirst = needs.includes("css") && needs.includes("csr") && resolveDevCsrMode() === "artifact";
+    if (needs.includes("base"))
       await this.#buildBase();
-    if (this.#request.needs.includes("csr"))
+    if (cssFirst)
+      await this.#buildCss();
+    if (needs.includes("csr"))
       await this.#buildCsr();
-    if (this.#request.needs.includes("shell"))
+    if (needs.includes("shell"))
       await this.#buildShell();
-    if (this.#request.needs.includes("ssr"))
+    if (needs.includes("ssr"))
       await this.#buildSsrRegistry();
-    if (this.#request.needs.includes("css"))
+    if (needs.includes("css") && !cssFirst)
       await this.#buildCss();
-    if (this.#request.needs.includes("pages"))
+    if (needs.includes("pages"))
       await this.#buildPages();
     return this.#result;
   }
@@ -115,7 +123,8 @@ class BuildBatch {
     }
   }
   async#rebuildCsrArtifact(started) {
-    await new CsrArtifactBuilder(this.#app, "start", "en", { cssAssets: this.#request.cssAssets }).build();
+    const cssAssets = this.#result.cssAssets ?? this.#request.cssAssets;
+    await new CsrArtifactBuilder(this.#app, "start", "en", { cssAssets }).build();
     this.#logger.verbose(`csr-rebundle ok (${Date.now() - started}ms)`);
     if (this.#request.changedFiles.length === 0)
       return;