@akanjs/cli 2.3.5-rc.9 → 2.3.6-rc.0

package/index.js

@@ -3938,6 +3938,36 @@ var createTunnel = async (service, { app, environment, port = service === "postg
   return `localhost:${port}`;
 };
 
+// pkgs/@akanjs/devkit/incrementalBuilder/devWatchBatch.ts
+var prepareDevWatchBatch = ({
+  generation,
+  batch,
+  indexSync,
+  changePlanner
+}) => {
+  const files = [...new Set([...batch.files, ...indexSync.changedFiles])].sort();
+  const kindSet = new Set(batch.kinds);
+  if (indexSync.changedFiles.length > 0)
+    kindSet.add("code");
+  const kinds = [...kindSet];
+  const expandedBatch = { files, kinds: kindSet };
+  const devPlan = changePlanner.plan({
+    generation,
+    files,
+    kinds,
+    generatedFiles: indexSync.changedFiles
+  });
+  if (indexSync.errors.length > 0 && !devPlan.actions.includes("report-error")) {
+    devPlan.actions = [...devPlan.actions, "report-error"].sort();
+  }
+  return {
+    files,
+    kinds,
+    expandedBatch,
+    event: { type: "invalidate", kinds, files, generation, devPlan },
+    hasSyncErrors: indexSync.errors.length > 0
+  };
+};
 // pkgs/@akanjs/devkit/incrementalBuilder/incrementalBuilder.host.ts
 import path8 from "path";
 import { Logger as Logger4 } from "akanjs/common";
@@ -3946,7 +3976,8 @@ var builderMsgTypeSet = new Set([
   "builder-ready",
   "invalidate",
   "css-updated",
-  "pages-updated"
+  "pages-updated",
+  "build-status"
 ]);
 
 class IncrementalBuilderHost {
@@ -4089,12 +4120,76 @@ var BUILDER_READY_TIMEOUT_MS = 15000;
 var BUILDER_START_MAX_ATTEMPTS = 3;
 var SOURCE_EXTS = new Set([".ts", ".tsx", ".js", ".jsx", ".mjs", ".cjs"]);
 var NON_SOURCE_EXT_RE = /\.(css|scss|sass|less|json|svg|png|jpe?g|webp|gif|avif|ico|woff2?|ttf|otf|mp3|mp4|wav|html)$/i;
+var SERVER_SUFFIXES = [".service.ts", ".document.ts"];
+var SHARED_SUFFIXES = [".constant.ts", ".dictionary.ts", ".signal.ts"];
+var RUNTIME_METADATA_BASENAMES = new Set(["dict.ts", "sig.ts", "useClient.ts", "useServer.ts"]);
 var GRAPH_IMPORT_KINDS = new Set([
   "import-statement",
   "require-call",
   "require-resolve",
   "dynamic-import"
 ]);
+var shouldRestartBackendByDevPlan = (message) => {
+  if (!message.devPlan)
+    return null;
+  if (message.devPlan.actions.includes("report-error"))
+    return false;
+  return message.devPlan.actions.includes("restart-backend");
+};
+var shouldRestartDevHostByDevPlan = (message) => message.devPlan?.actions.includes("restart-dev-host") ?? message.kinds.includes("config");
+var RESTART_ROLE_ORDER = ["server", "shared", "barrel", "config"];
+var generationValue = (generation) => generation ?? -1;
+var isLegacyBackendFallbackFile = (file, workspaceRoot) => {
+  const abs = path9.resolve(file);
+  const ext = path9.extname(abs).toLowerCase();
+  if (!SOURCE_EXTS.has(ext))
+    return false;
+  const rel = path9.relative(path9.resolve(workspaceRoot), abs);
+  if (!rel || rel.startsWith("..") || path9.isAbsolute(rel))
+    return false;
+  const parts = rel.split(path9.sep).filter(Boolean);
+  const [scope] = parts;
+  if (scope !== "apps" && scope !== "libs" && scope !== "pkgs")
+    return false;
+  const base = path9.basename(abs);
+  return parts.includes("srvkit") || parts.includes("common") || SERVER_SUFFIXES.some((suffix) => base.endsWith(suffix)) || SHARED_SUFFIXES.some((suffix) => base.endsWith(suffix)) || RUNTIME_METADATA_BASENAMES.has(base) || base === "main.ts" || base === "server.ts";
+};
+var shouldMarkBuildPhaseRecovered = (previousByPhase, status) => {
+  const previous = previousByPhase.get(status.phase);
+  return Boolean(previous && status.ok && !previous.ok && generationValue(status.generation) >= previous.generation);
+};
+var createBackendBuildStatus = ({
+  generation,
+  ok,
+  files = [],
+  message
+}) => ({
+  generation,
+  phase: "backend",
+  ok,
+  files,
+  message
+});
+var backendRestartReasonFromMessage = (message) => {
+  const roleSet = new Set;
+  for (const role of message.devPlan?.roles ?? []) {
+    if (role === "server" || role === "shared" || role === "barrel" || role === "config")
+      roleSet.add(role);
+  }
+  return {
+    generation: message.devPlan?.generation ?? message.generation,
+    files: [...new Set(message.files)].sort(),
+    roles: RESTART_ROLE_ORDER.filter((role) => roleSet.has(role))
+  };
+};
+var mergeBackendRestartReasons = (current, next) => ({
+  generation: generationValue(next.generation) >= generationValue(current?.generation) ? next.generation : current?.generation,
+  files: [...new Set([...current?.files ?? [], ...next.files])].sort(),
+  roles: RESTART_ROLE_ORDER.filter((role) => current?.roles.includes(role) || next.roles.includes(role))
+});
+var shouldReplaceLastGoodMessage = (current, next) => !current || generationValue(next.data.generation) >= generationValue(current.data.generation);
+var shouldQueueBuildStatusReplay = (backendReady, pendingReplayCount) => !backendReady || pendingReplayCount > 0;
+var buildStatusReplaySequence = (pendingReplay, latestByPhase) => [...pendingReplay, ...latestByPhase.values()];
 
 class BackendImportGraph {
   #app;
@@ -4105,6 +4200,7 @@ class BackendImportGraph {
   #jsxTranspiler = new Bun.Transpiler({ loader: "jsx" });
   #files = new Set;
   #ready = false;
+  #lastRefreshSucceeded = false;
   constructor(app, logger) {
     this.#app = app;
     this.#logger = logger;
@@ -4112,6 +4208,9 @@ class BackendImportGraph {
   get ready() {
     return this.#ready;
   }
+  get lastRefreshSucceeded() {
+    return this.#lastRefreshSucceeded;
+  }
   has(file) {
     return this.#files.has(path9.resolve(file));
   }
@@ -4120,10 +4219,12 @@ class BackendImportGraph {
       const files = await this.#build();
       this.#files = files;
       this.#ready = true;
+      this.#lastRefreshSucceeded = true;
       this.#logger.verbose(`[backend-graph] scanned ${files.size} files`);
       return true;
     } catch (err) {
       this.#ready = this.#files.size > 0;
+      this.#lastRefreshSucceeded = false;
       this.#logger.warn(`[backend-graph] scan failed; ${this.#ready ? "using previous graph" : "using fallback rules"}: ${err instanceof Error ? err.message : String(err)}`);
       return this.#ready;
     }
@@ -4210,9 +4311,13 @@ class AkanAppHost {
   #restartTimer = null;
   #backendRecoveryTimer = null;
   #backendRecoveryAttempts = 0;
-  #restartFiles = new Set;
-  #latestPagesUpdated = null;
-  #latestCssUpdated = null;
+  #backendLifecycleState = "stopped";
+  #pendingRestartReason = null;
+  #backendStartStatus = null;
+  #backendBuildStatusGeneration = 0;
+  #lastGoodFrontend = {};
+  #buildStatusByPhase = new Map;
+  #pendingBuildStatusReplay = [];
   #builderMessageQueue = Promise.resolve();
   #backendGraph;
   constructor(app, { env, withInk = false }) {
@@ -4257,7 +4362,9 @@ class AkanAppHost {
       return "localhost";
     return await createTunnel(type, { app: this.app, environment });
   }
-  #startBackend() {
+  #startBackend(startStatus = null) {
+    this.#backendStartStatus = startStatus;
+    this.#setBackendLifecycleState("starting");
     this.#backendReady = false;
     const backend = Bun.spawn(["bun", `apps/${this.app.name}/main.ts`], {
       cwd: this.app.workspace.workspaceRoot,
@@ -4269,6 +4376,8 @@ class AkanAppHost {
         if (msg.type === "backend-ready") {
           this.#backendReady = true;
           this.#backendRecoveryAttempts = 0;
+          this.#setBackendLifecycleState("ready", `pid=${msg.pid}`);
+          this.#recordBackendReadyStatus();
           this.logger.verbose(`backend ready pid=${msg.pid}`);
           this.#replayBuilderState();
           return;
@@ -4291,9 +4400,53 @@ class AkanAppHost {
     this.#backend = backend;
     this.logger.verbose(`backend spawned pid=${backend.pid}`);
   }
+  #nextBackendBuildStatusGeneration(generation) {
+    if (typeof generation === "number") {
+      this.#backendBuildStatusGeneration = Math.max(this.#backendBuildStatusGeneration, generation);
+      return generation;
+    }
+    this.#backendBuildStatusGeneration += 1;
+    return this.#backendBuildStatusGeneration;
+  }
+  #recordBackendBuildStatus({
+    generation,
+    ok,
+    files,
+    message
+  }) {
+    const status = createBackendBuildStatus({
+      generation: this.#nextBackendBuildStatusGeneration(generation),
+      ok,
+      files,
+      message
+    });
+    this.#recordBuildStatus(status);
+    return status;
+  }
+  #recordBackendReadyStatus() {
+    const previous = this.#buildStatusByPhase.get("backend");
+    const startStatus = this.#backendStartStatus;
+    if (startStatus || previous?.ok === false) {
+      const status = this.#recordBackendBuildStatus({
+        generation: startStatus?.generation ?? previous?.generation,
+        ok: true,
+        files: startStatus?.files ?? previous?.files ?? [],
+        message: "Backend ready"
+      });
+      this.#sendOrQueueBuildStatus(status);
+    }
+    this.#backendStartStatus = null;
+  }
+  #setBackendLifecycleState(next, detail) {
+    if (this.#backendLifecycleState === next && !detail)
+      return;
+    const prev = this.#backendLifecycleState;
+    this.#backendLifecycleState = next;
+    this.logger.verbose(`[backend-lifecycle] ${prev} -> ${next}${detail ? ` ${detail}` : ""}`);
+  }
   #sendToBackend(message) {
     if (!this.#backend || !this.#backendReady) {
-      if (message.type === "css-updated" || message.type === "pages-updated") {
+      if (message.type === "css-updated" || message.type === "pages-updated" || message.type === "build-status") {
         this.logger.verbose(`backend is not ready; will replay ${message.type}`);
         return;
       }
@@ -4313,6 +4466,7 @@ class AkanAppHost {
     const backend = this.#backend;
     this.#plannedBackendStops.add(backend);
     this.#backendReady = false;
+    this.#setBackendLifecycleState("stopping", `pid=${backend.pid}`);
     this.logger.verbose(`stopping backend pid=${backend.pid}`);
     try {
       backend.kill("SIGTERM");
@@ -4328,11 +4482,13 @@ class AkanAppHost {
     } finally {
       if (this.#backend === backend)
         this.#backend = null;
+      this.#setBackendLifecycleState("stopped", `pid=${backend.pid}`);
     }
   }
-  #scheduleBackendRestart(files) {
-    for (const file of files)
-      this.#restartFiles.add(file);
+  #scheduleBackendRestart(reason) {
+    this.#pendingRestartReason = mergeBackendRestartReasons(this.#pendingRestartReason, reason);
+    const pending = this.#pendingRestartReason;
+    this.#setBackendLifecycleState("restart-pending", `generation=${pending.generation ?? "(unknown)"} files=${pending.files.length} roles=${pending.roles.join(",") || "(none)"}`);
     if (this.#backendRecoveryTimer) {
       clearTimeout(this.#backendRecoveryTimer);
       this.#backendRecoveryTimer = null;
@@ -4341,23 +4497,31 @@ class AkanAppHost {
       clearTimeout(this.#restartTimer);
     this.#restartTimer = setTimeout(() => {
       this.#restartTimer = null;
-      const changed = [...this.#restartFiles];
-      this.#restartFiles.clear();
-      this.#restartBackend(changed);
+      const next = this.#pendingRestartReason;
+      this.#pendingRestartReason = null;
+      if (next)
+        this.#restartBackend(next);
     }, BACKEND_RESTART_DEBOUNCE_MS);
   }
-  async#restartBackend(files) {
-    this.logger.verbose(`[backend-reload] restarting backend for ${files.length} file(s)`);
+  async#restartBackend(reason) {
+    this.logger.verbose(`[backend-reload] restarting backend generation=${reason.generation ?? "(unknown)"} files=${reason.files.length} roles=${reason.roles.join(",") || "(none)"}`);
     this.#backendRecoveryAttempts = 0;
     await Promise.all([this.#stopBackend(), this.#backendGraph.refresh()]);
-    this.#startBackend();
+    this.#startBackend({ generation: reason.generation, files: reason.files });
   }
   #scheduleBackendRecovery(reason) {
     if (this.#backendRecoveryTimer || this.#backend)
       return;
+    this.#setBackendLifecycleState("recovering", reason);
     const attempt = this.#backendRecoveryAttempts;
     const delay = Math.min(BACKEND_RECOVERY_BASE_DELAY_MS * 2 ** attempt, BACKEND_RECOVERY_MAX_DELAY_MS);
     this.#backendRecoveryAttempts = attempt + 1;
+    const failureStatus = this.#recordBackendBuildStatus({
+      ok: false,
+      files: [],
+      message: `Backend exited unexpectedly (${reason}); restarting in ${delay}ms`
+    });
+    this.#sendOrQueueBuildStatus(failureStatus);
     this.logger.warn(`[backend-recovery] backend exited unexpectedly (${reason}); restarting in ${delay}ms (attempt ${this.#backendRecoveryAttempts})`);
     this.#backendRecoveryTimer = setTimeout(() => {
       this.#backendRecoveryTimer = null;
@@ -4365,7 +4529,7 @@ class AkanAppHost {
         return;
       this.#backendGraph.refresh().finally(() => {
         if (!this.#backend)
-          this.#startBackend();
+          this.#startBackend({ generation: failureStatus.generation, files: failureStatus.files });
       });
     }, delay);
   }
@@ -4375,10 +4539,15 @@ class AkanAppHost {
     });
   }
   async#handleBuilderMessage(message) {
+    if (message.type === "build-status") {
+      this.#recordBuildStatus(message.data);
+      this.#sendOrQueueBuildStatus(message.data);
+      return;
+    }
     if (message.type === "pages-updated")
-      this.#latestPagesUpdated = message;
+      this.#recordLastGood(message);
     if (message.type === "css-updated")
-      this.#latestCssUpdated = message;
+      this.#recordLastGood(message);
     if (message.type === "invalidate") {
       await this.#handleInvalidate(message);
       return;
@@ -4386,26 +4555,97 @@ class AkanAppHost {
     this.#sendToBackend(message);
   }
   async#handleInvalidate(message) {
+    if (shouldRestartDevHostByDevPlan(message)) {
+      this.#recordDevHostRestartRequired(message);
+      return;
+    }
     if (await this.#shouldRestartBackend(message)) {
-      this.#scheduleBackendRestart(message.files);
+      this.#scheduleBackendRestart(backendRestartReasonFromMessage(message));
       return;
     }
     this.#sendToBackend(message);
   }
+  #recordLastGood(message) {
+    if (message.type === "pages-updated") {
+      if (!shouldReplaceLastGoodMessage(this.#lastGoodFrontend.pages, message))
+        return;
+      this.#lastGoodFrontend.pages = message;
+      this.logger.verbose(`[last-good] pages generation=${message.data.generation ?? "(unknown)"} buildId=${message.data.buildId}`);
+      return;
+    }
+    if (!shouldReplaceLastGoodMessage(this.#lastGoodFrontend.css, message))
+      return;
+    this.#lastGoodFrontend.css = message;
+    this.logger.verbose(`[last-good] css generation=${message.data.generation ?? "(unknown)"} assets=${Object.keys(message.data.cssAssets).length}`);
+  }
+  #recordDevHostRestartRequired(message) {
+    const generation = message.devPlan?.generation ?? message.generation;
+    const detail = `generation=${generation ?? "(unknown)"} files=${message.files.length}`;
+    this.logger.warn(`[dev-host] config change requires a manual restart until controlled dev-host restart is implemented (${detail})`);
+    if (typeof generation === "number") {
+      const status = {
+        generation,
+        phase: "scan",
+        ok: false,
+        files: message.files,
+        message: "Config change requires restarting `akan start` to apply."
+      };
+      this.#recordBuildStatus(status);
+      this.#sendOrQueueBuildStatus(status);
+    }
+  }
+  #recordBuildStatus(status) {
+    const recovered = shouldMarkBuildPhaseRecovered(this.#buildStatusByPhase, status);
+    this.#buildStatusByPhase.set(status.phase, status);
+    const label = `[build-status] generation=${status.generation} phase=${status.phase} ok=${status.ok} files=${status.files.length}`;
+    if (status.ok)
+      this.logger.verbose(`${label}${recovered ? " recovered=1" : ""}`);
+    else
+      this.logger.warn(`${label}${status.message ? ` message=${status.message}` : ""}`);
+  }
+  #sendOrQueueBuildStatus(status) {
+    if (!this.#backend || shouldQueueBuildStatusReplay(this.#backendReady, this.#pendingBuildStatusReplay.length)) {
+      this.#pendingBuildStatusReplay.push(status);
+      this.logger.verbose(`backend is not ready; will replay build-status generation=${status.generation} phase=${status.phase}`);
+      return;
+    }
+    this.#sendToBackend({ type: "build-status", data: status });
+  }
   #replayBuilderState() {
     if (!this.#backendReady)
       return;
-    if (this.#latestCssUpdated)
-      this.#sendToBackend(this.#latestCssUpdated);
-    if (this.#latestPagesUpdated)
-      this.#sendToBackend(this.#latestPagesUpdated);
+    if (this.#lastGoodFrontend.css)
+      this.#sendToBackend(this.#lastGoodFrontend.css);
+    if (this.#lastGoodFrontend.pages)
+      this.#sendToBackend(this.#lastGoodFrontend.pages);
+    const queuedStatuses = this.#pendingBuildStatusReplay.splice(0);
+    for (const status of buildStatusReplaySequence(queuedStatuses, this.#buildStatusByPhase)) {
+      this.#sendToBackend({ type: "build-status", data: status });
+    }
   }
   async#shouldRestartBackend(message) {
     if (message.kinds.length === 1 && message.kinds[0] === "css")
       return false;
-    if (!this.#backendGraph.ready && message.kinds.includes("code"))
+    if (message.devPlan) {
+      const { generation, roles, actions, reasonByFile } = message.devPlan;
+      this.logger.verbose(`[dev-plan] generation=${generation} roles=${roles.join(",") || "(none)"} actions=${actions.join(",") || "(none)"} reasons=${Object.keys(reasonByFile).length}`);
+      const shouldRestart = shouldRestartBackendByDevPlan(message) ?? false;
+      if (shouldRestart && message.kinds.includes("code"))
+        await this.#backendGraph.refresh();
+      return shouldRestart;
+    }
+    if (message.kinds.includes("code"))
       await this.#backendGraph.refresh();
-    return message.files.some((file) => this.#isBackendFile(file));
+    if (message.files.some((file) => this.#isBackendFile(file)))
+      return true;
+    if (!this.#backendGraph.lastRefreshSucceeded) {
+      const fallbackFiles = message.files.filter((file) => isLegacyBackendFallbackFile(file, this.app.workspace.workspaceRoot));
+      if (fallbackFiles.length > 0) {
+        this.logger.warn(`[backend-graph] using path-role fallback for legacy invalidate; restart files=${fallbackFiles.length}`);
+        return true;
+      }
+    }
+    return false;
   }
   #isBackendFile(file) {
     return this.#backendGraph.has(file);
@@ -4761,8 +5001,8 @@ Caused by: ${ApplicationBuildReporter.formatError(error.cause)}` : "";
   }
 }
 // pkgs/@akanjs/devkit/applicationBuildRunner.ts
-import { mkdir as mkdir7, rm as rm2 } from "fs/promises";
-import path33 from "path";
+import { mkdir as mkdir8, rm as rm3 } from "fs/promises";
+import path35 from "path";
 
 // pkgs/@akanjs/devkit/frontendBuild/allRoutesBuilder.ts
 import path20 from "path";
@@ -7230,9 +7470,292 @@ function getPageKeyBasePath(pageKey, basePaths) {
   const firstPublicSegment = segments.find((segment) => segment !== "[lang]" && !/^\(.+\)$/.test(segment));
   return firstPublicSegment && basePaths.includes(firstPublicSegment) ? firstPublicSegment : null;
 }
-// pkgs/@akanjs/devkit/frontendBuild/fontOptimizer.ts
-import { mkdir as mkdir6 } from "fs/promises";
+// pkgs/@akanjs/devkit/frontendBuild/devChangePlanner.ts
 import path25 from "path";
+var SOURCE_EXTS4 = new Set([".ts", ".tsx", ".js", ".jsx", ".mjs", ".cjs"]);
+var CONFIG_BASENAMES = new Set(["akan.config.ts", "bunfig.toml", "tsconfig.json", "package.json"]);
+var BARREL_FACETS = new Set(["common", "srvkit", "ui", "webkit"]);
+var CLIENT_SUFFIXES = [".Template.tsx", ".Unit.tsx", ".Util.tsx", ".View.tsx", ".Zone.tsx", ".store.ts"];
+var SHARED_SUFFIXES2 = [".constant.ts", ".dictionary.ts", ".signal.ts"];
+var SERVER_SUFFIXES2 = [".service.ts", ".document.ts"];
+var RUNTIME_METADATA_BASENAMES2 = new Set(["dict.ts", "sig.ts", "useClient.ts", "useServer.ts"]);
+
+class DevChangePlanner {
+  #workspaceRoot;
+  constructor({ workspaceRoot }) {
+    this.#workspaceRoot = path25.resolve(workspaceRoot);
+  }
+  plan({ generation, files, kinds, generatedFiles: generatedFiles2 = [] }) {
+    const fileList = uniqueResolved([...files, ...generatedFiles2]);
+    const generatedSet = new Set(generatedFiles2.map((file) => path25.resolve(file)));
+    const kindSet = new Set(kinds);
+    const roles = new Set;
+    const actions = new Set;
+    const reasonByFile = {};
+    for (const kind of kindSet) {
+      if (kind === "css") {
+        roles.add("css");
+        actions.add("rebuild-css");
+      }
+      if (kind === "config") {
+        roles.add("config");
+        actions.add("restart-dev-host");
+      }
+    }
+    for (const file of fileList) {
+      const reasons = new Set;
+      const fileRoles = this.#rolesForFile(file, { isGenerated: generatedSet.has(path25.resolve(file)), reasons });
+      for (const role of fileRoles)
+        roles.add(role);
+      if (reasons.size > 0)
+        reasonByFile[path25.resolve(file)] = [...reasons].sort();
+    }
+    if (roles.has("barrel"))
+      actions.add("sync-generated");
+    if (roles.has("server") || roles.has("shared"))
+      actions.add("restart-backend");
+    if (roles.has("client") || roles.has("shared"))
+      actions.add("rebuild-client");
+    if (roles.has("css"))
+      actions.add("rebuild-css");
+    return {
+      generation,
+      files: fileList,
+      generatedFiles: uniqueResolved(generatedFiles2),
+      roles: [...roles].sort(),
+      actions: [...actions].sort(),
+      reasonByFile
+    };
+  }
+  #rolesForFile(file, { isGenerated, reasons }) {
+    const roles = new Set;
+    const abs = path25.resolve(file);
+    const base = path25.basename(abs);
+    const ext = path25.extname(abs).toLowerCase();
+    const isSource = SOURCE_EXTS4.has(ext);
+    const rel = path25.relative(this.#workspaceRoot, abs);
+    const parts = rel.split(path25.sep).filter(Boolean);
+    if (CONFIG_BASENAMES.has(base)) {
+      roles.add("config");
+      reasons.add("config-file");
+    }
+    if (ext === ".css") {
+      roles.add("css");
+      reasons.add("css-file");
+    }
+    if (isGenerated || isSource && this.#isBarrelFacetChild(parts)) {
+      roles.add("barrel");
+      reasons.add(isGenerated ? "generated-index" : "barrel-facet-child");
+    }
+    if (isSource && this.#isServerBiased(abs, parts)) {
+      roles.add("server");
+      reasons.add("server-path");
+    }
+    if (isSource && this.#isClientBiased(abs, parts)) {
+      roles.add("client");
+      reasons.add("client-path");
+    }
+    if (isSource && this.#isSharedBiased(abs, parts)) {
+      roles.add("shared");
+      reasons.add("shared-path");
+    }
+    if (roles.has("server") && roles.has("client")) {
+      roles.delete("server");
+      roles.delete("client");
+      roles.add("shared");
+      reasons.add("server-client-overlap");
+    }
+    if (roles.size === 0 && SOURCE_EXTS4.has(ext) && this.#isWorkspaceSource(rel)) {
+      roles.add("shared");
+      reasons.add("workspace-source-fallback");
+    }
+    return roles;
+  }
+  #isServerBiased(abs, parts) {
+    const base = path25.basename(abs);
+    return parts.includes("srvkit") || SERVER_SUFFIXES2.some((suffix) => base.endsWith(suffix)) || base === "main.ts" || base === "server.ts";
+  }
+  #isClientBiased(abs, parts) {
+    const base = path25.basename(abs);
+    return parts.includes("ui") || parts.includes("webkit") || parts.includes("page") || CLIENT_SUFFIXES.some((suffix) => base.endsWith(suffix));
+  }
+  #isSharedBiased(abs, parts) {
+    const base = path25.basename(abs);
+    return parts.includes("common") || SHARED_SUFFIXES2.some((suffix) => base.endsWith(suffix)) || RUNTIME_METADATA_BASENAMES2.has(base);
+  }
+  #isBarrelFacetChild(parts) {
+    if (parts.length < 4)
+      return false;
+    const [scope, , facet, child] = parts;
+    if (scope !== "apps" && scope !== "libs")
+      return false;
+    if (!facet || !BARREL_FACETS.has(facet))
+      return false;
+    if (!child || child.startsWith(".") || child === "index.ts" || child === "index.tsx")
+      return false;
+    return true;
+  }
+  #isWorkspaceSource(rel) {
+    if (!rel || rel.startsWith("..") || path25.isAbsolute(rel))
+      return false;
+    const [scope] = rel.split(path25.sep);
+    return scope === "apps" || scope === "libs" || scope === "pkgs";
+  }
+}
+var uniqueResolved = (files) => [...new Set(files.map((file) => path25.resolve(file)))].sort();
+// pkgs/@akanjs/devkit/frontendBuild/devGeneratedIndexSync.ts
+import { mkdir as mkdir6, readdir as readdir2, readFile, rm as rm2, stat as stat3, writeFile } from "fs/promises";
+import path26 from "path";
+var BARREL_FACETS2 = new Set(["common", "srvkit", "ui", "webkit"]);
+var FACET_SOURCE_FILE_RE = /\.(ts|tsx)$/;
+var FACET_EXCLUDED_FILE_RE = /(^index\.tsx?$|\.d\.ts$|\.(test|spec)\.(ts|tsx)$|\.css$|\.scss$|\.sass$)/;
+var MODULE_UI_TYPES = ["Template", "Unit", "Util", "View", "Zone"];
+var SERVICE_UI_TYPES = ["Util", "Zone"];
+var SCALAR_UI_TYPES = ["Template", "Unit"];
+
+class DevGeneratedIndexSync {
+  #workspaceRoot;
+  constructor({ workspaceRoot }) {
+    this.#workspaceRoot = path26.resolve(workspaceRoot);
+  }
+  async syncForBatch(files) {
+    const indexPaths = new Set;
+    const errors = [];
+    for (const file of files) {
+      const facetIndex = this.#facetIndexFor(file);
+      if (facetIndex)
+        indexPaths.add(facetIndex);
+      const moduleIndex = await this.#moduleIndexForDirectoryEvent(file).catch((err) => {
+        errors.push(`[generated-index] module detection failed for ${file}: ${formatError(err)}`);
+        return null;
+      });
+      if (moduleIndex)
+        indexPaths.add(moduleIndex);
+    }
+    const changedFiles = [];
+    for (const indexPath of [...indexPaths].sort()) {
+      try {
+        const changed = await this.#syncIndex(indexPath);
+        if (changed)
+          changedFiles.push(indexPath);
+      } catch (err) {
+        errors.push(`[generated-index] sync failed for ${indexPath}: ${formatError(err)}`);
+      }
+    }
+    return { changedFiles, errors };
+  }
+  #facetIndexFor(file) {
+    const abs = path26.resolve(file);
+    const rel = path26.relative(this.#workspaceRoot, abs);
+    if (rel.startsWith("..") || path26.isAbsolute(rel))
+      return null;
+    const parts = rel.split(path26.sep).filter(Boolean);
+    if (parts.length < 4)
+      return null;
+    const [scope, project, facet, child] = parts;
+    if (scope !== "apps" && scope !== "libs" || !project || !facet || !BARREL_FACETS2.has(facet))
+      return null;
+    if (!child || child.startsWith(".") || child === "index.ts" || child === "index.tsx")
+      return null;
+    return path26.join(this.#workspaceRoot, scope, project, facet, "index.ts");
+  }
+  async#moduleIndexForDirectoryEvent(file) {
+    const abs = path26.resolve(file);
+    const rel = path26.relative(this.#workspaceRoot, abs);
+    if (rel.startsWith("..") || path26.isAbsolute(rel))
+      return null;
+    const parts = rel.split(path26.sep).filter(Boolean);
+    if (parts.length !== 4 && parts.length !== 5)
+      return null;
+    const [scope, project, libSegment, moduleSegment, scalarSegment] = parts;
+    if (scope !== "apps" && scope !== "libs" || !project || libSegment !== "lib")
+      return null;
+    const isExistingDirectory = await stat3(abs).then((s) => s.isDirectory()).catch(() => false);
+    const looksLikeDeletedDirectory = !path26.extname(abs);
+    if (!isExistingDirectory && !looksLikeDeletedDirectory)
+      return null;
+    if (moduleSegment === "__scalar" && scalarSegment) {
+      return path26.join(this.#workspaceRoot, scope, project, "lib", "__scalar", scalarSegment, "index.ts");
+    }
+    if (!moduleSegment || moduleSegment === "__scalar")
+      return null;
+    return path26.join(this.#workspaceRoot, scope, project, "lib", moduleSegment, "index.ts");
+  }
+  async#syncIndex(indexPath) {
+    const dir = path26.dirname(indexPath);
+    const content = await this.#contentForIndex(indexPath);
+    if (content === null) {
+      if (!await exists(indexPath))
+        return false;
+      await rm2(indexPath, { force: true });
+      return true;
+    }
+    const current = await readFile(indexPath, "utf8").catch(() => null);
+    if (current === content)
+      return false;
+    await mkdir6(dir, { recursive: true });
+    await writeFile(indexPath, content);
+    return true;
+  }
+  async#contentForIndex(indexPath) {
+    const parts = path26.relative(this.#workspaceRoot, indexPath).split(path26.sep).filter(Boolean);
+    const facet = parts.at(-2);
+    if (facet && BARREL_FACETS2.has(facet))
+      return this.#facetContent(path26.dirname(indexPath));
+    return this.#moduleContent(path26.dirname(indexPath));
+  }
+  async#facetContent(dir) {
+    const entries = await readdir2(dir, { withFileTypes: true }).catch(() => []);
+    const exportNames = entries.flatMap((entry) => {
+      const name = entry.name;
+      if (name.startsWith("."))
+        return [];
+      if (entry.isDirectory())
+        return [name];
+      if (!entry.isFile())
+        return [];
+      if (!FACET_SOURCE_FILE_RE.test(name) || FACET_EXCLUDED_FILE_RE.test(name))
+        return [];
+      return [name.replace(FACET_SOURCE_FILE_RE, "")];
+    }).sort();
+    if (exportNames.length === 0)
+      return null;
+    return `${exportNames.map((name) => `export * from "./${name}";`).join(`
+`)}
+`;
+  }
+  async#moduleContent(dir) {
+    const rel = path26.relative(this.#workspaceRoot, dir);
+    const parts = rel.split(path26.sep).filter(Boolean);
+    const moduleSegment = parts.at(-1);
+    if (!moduleSegment)
+      return null;
+    const isScalar = parts.at(-2) === "__scalar";
+    const rawModel = moduleSegment.startsWith("_") ? moduleSegment.slice(1) : moduleSegment;
+    if (!rawModel)
+      return null;
+    const modelName = capitalize3(rawModel);
+    const allowedTypes = isScalar ? SCALAR_UI_TYPES : moduleSegment.startsWith("_") ? SERVICE_UI_TYPES : MODULE_UI_TYPES;
+    const fileTypes = [];
+    for (const type of allowedTypes) {
+      if (await exists(path26.join(dir, `${modelName}.${type}.tsx`)))
+        fileTypes.push(type);
+    }
+    if (fileTypes.length === 0)
+      return null;
+    return `
+${fileTypes.map((type) => `import * as ${type} from "./${modelName}.${type}";`).join(`
+`)}
+
+export const ${modelName} = { ${fileTypes.join(", ")} };`;
+  }
+}
+var exists = async (file) => stat3(file).then(() => true).catch(() => false);
+var capitalize3 = (value) => `${value.charAt(0).toUpperCase()}${value.slice(1)}`;
+var formatError = (err) => err instanceof Error ? err.message : String(err);
+// pkgs/@akanjs/devkit/frontendBuild/fontOptimizer.ts
+import { mkdir as mkdir7 } from "fs/promises";
+import path27 from "path";
 import {
   generateFontFace,
   getMetricsForFamily,
@@ -7256,7 +7779,7 @@ class FontOptimizer {
   constructor(app, command = "start") {
     this.#app = app;
     this.#command = command;
-    this.#artifactRoot = path25.join(command === "build" ? app.dist.cwdPath : app.cwdPath, ".akan/artifact");
+    this.#artifactRoot = path27.join(command === "build" ? app.dist.cwdPath : app.cwdPath, ".akan/artifact");
   }
   async optimize() {
     const fonts = await this.discoverFonts();
@@ -7275,7 +7798,7 @@ class FontOptimizer {
     const pageKeys = await this.#app.getPageKeys();
     const fonts = [];
     await Promise.all(pageKeys.map(async (key) => {
-      const filePath = path25.resolve(this.#app.cwdPath, "page", key);
+      const filePath = path27.resolve(this.#app.cwdPath, "page", key);
       const file = Bun.file(filePath);
       if (!await file.exists())
         return;
@@ -7291,8 +7814,8 @@ class FontOptimizer {
         this.#app.logger.warn(`[font] source not found: ${face.src}`);
         continue;
       }
-      const outputPath = path25.join(this.#artifactRoot, face.optimizedSrc.replace(/^\/_akan\//, ""));
-      await mkdir6(path25.dirname(outputPath), { recursive: true });
+      const outputPath = path27.join(this.#artifactRoot, face.optimizedSrc.replace(/^\/_akan\//, ""));
+      await mkdir7(path27.dirname(outputPath), { recursive: true });
       const sourceBuffer = Buffer.from(await Bun.file(sourcePath).arrayBuffer());
       const outputBuffer = font.subset === false ? await this.#convertToWoff2(sourceBuffer, sourcePath) : await subsetFont(sourceBuffer, await this.#getSubsetText(font), { targetFormat: "woff2" });
       await Bun.write(outputPath, outputBuffer);
@@ -7439,8 +7962,8 @@ class FontOptimizer {
       return null;
     const rel = src.replace(/^\//, "");
     const candidates = [
-      this.#command === "build" ? path25.join(this.#app.dist.cwdPath, "public", rel) : null,
-      path25.join(this.#app.cwdPath, "public", rel),
+      this.#command === "build" ? path27.join(this.#app.dist.cwdPath, "public", rel) : null,
+      path27.join(this.#app.cwdPath, "public", rel),
       this.#resolveWorkspacePublicPath(rel)
     ].filter(Boolean);
     for (const candidate of candidates) {
@@ -7468,7 +7991,7 @@ class FontOptimizer {
       return "woff2";
     if (signature === "OTTO")
       return "otf";
-    const ext = path25.extname(sourcePath).slice(1).toLowerCase();
+    const ext = path27.extname(sourcePath).slice(1).toLowerCase();
     if (ext === "otf" || ext === "woff" || ext === "woff2")
       return ext;
     return "ttf";
@@ -7477,7 +8000,7 @@ class FontOptimizer {
     const [root, dep, ...rest] = rel.split("/");
     if (root !== "libs" || !dep || rest.length === 0)
       return null;
-    return path25.join(this.#app.workspace.workspaceRoot, "libs", dep, "public", ...rest);
+    return path27.join(this.#app.workspace.workspaceRoot, "libs", dep, "public", ...rest);
   }
   async#getSubsetText(font) {
     const parts = new Set;
@@ -7487,7 +8010,7 @@ class FontOptimizer {
     if (font.subsetText)
       parts.add(font.subsetText);
     for (const filePath of font.subsetFiles ?? []) {
-      const abs = path25.isAbsolute(filePath) ? filePath : path25.join(this.#app.cwdPath, filePath);
+      const abs = path27.isAbsolute(filePath) ? filePath : path27.join(this.#app.cwdPath, filePath);
       const file = Bun.file(abs);
       if (await file.exists())
         parts.add(await file.text());
@@ -7506,7 +8029,7 @@ class FontOptimizer {
     return "";
   }
   async#collectAutoSubsetText() {
-    const roots = ["page", "ui"].map((dir) => path25.join(this.#app.cwdPath, dir));
+    const roots = ["page", "ui"].map((dir) => path27.join(this.#app.cwdPath, dir));
     const glob = new Bun.Glob("**/*.{ts,tsx,js,jsx,html,md}");
     const parts = [];
     await Promise.all(roots.map(async (root) => {
@@ -7620,43 +8143,43 @@ ${declarations.map(([prop, value]) => `  ${prop}: ${value};`).join(`
   }
 }
 // pkgs/@akanjs/devkit/frontendBuild/hmrChangeClassifier.ts
-import path26 from "path";
-var SOURCE_EXTS4 = new Set([".ts", ".tsx", ".js", ".jsx", ".mjs", ".cjs"]);
+import path28 from "path";
+var SOURCE_EXTS5 = new Set([".ts", ".tsx", ".js", ".jsx", ".mjs", ".cjs"]);
 var CSS_EXTS = new Set([".css"]);
-var CONFIG_BASENAMES = new Set(["akan.config.ts", "bunfig.toml", "tsconfig.json", "package.json"]);
+var CONFIG_BASENAMES2 = new Set(["akan.config.ts", "bunfig.toml", "tsconfig.json", "package.json"]);
 
 class HmrChangeClassifier {
   classify(abs) {
     if (this.#isUninteresting(abs))
       return "ignore";
-    const base = path26.basename(abs);
-    if (CONFIG_BASENAMES.has(base))
+    const base = path28.basename(abs);
+    if (CONFIG_BASENAMES2.has(base))
       return "config";
-    const ext = path26.extname(abs).toLowerCase();
+    const ext = path28.extname(abs).toLowerCase();
     if (CSS_EXTS.has(ext))
       return "css";
-    if (SOURCE_EXTS4.has(ext))
+    if (SOURCE_EXTS5.has(ext))
       return "code";
     return "ignore";
   }
   #isUninteresting(abs) {
-    const base = path26.basename(abs);
+    const base = path28.basename(abs);
     if (!base)
       return true;
     if (base.startsWith("."))
       return true;
     if (base.endsWith("~") || base.endsWith(".swp") || base.endsWith(".swx") || base.endsWith(".tmp"))
       return true;
-    if (abs.includes(`${path26.sep}node_modules${path26.sep}`))
+    if (abs.includes(`${path28.sep}node_modules${path28.sep}`))
       return true;
-    if (abs.includes(`${path26.sep}.akan${path26.sep}`))
+    if (abs.includes(`${path28.sep}.akan${path28.sep}`))
       return true;
     return false;
   }
 }
 // pkgs/@akanjs/devkit/frontendBuild/hmrWatcher.ts
 import fs4 from "fs";
-import path27 from "path";
+import path29 from "path";
 class HmrWatcher {
   #roots;
   #debounceMs;
@@ -7669,7 +8192,7 @@ class HmrWatcher {
   #stopped = false;
   #flushing = false;
   constructor(opts) {
-    this.#roots = [...new Set(opts.roots.map((r) => path27.resolve(r)))];
+    this.#roots = [...new Set(opts.roots.map((r) => path29.resolve(r)))];
     this.#debounceMs = opts.debounceMs ?? 80;
     this.#onBatch = opts.onBatch;
     this.#logger = opts.logger;
@@ -7680,7 +8203,7 @@ class HmrWatcher {
         const w = fs4.watch(root, { recursive: true, persistent: false }, (_event, filename) => {
           if (!filename)
             return;
-          const abs = path27.resolve(root, filename.toString());
+          const abs = path29.resolve(root, filename.toString());
           this.#queue(abs);
         });
         this.#watchers.push(w);
@@ -7738,10 +8261,10 @@ class HmrWatcher {
   }
 }
 // pkgs/@akanjs/devkit/frontendBuild/pagesBundleBuilder.ts
-import path29 from "path";
+import path31 from "path";
 
 // pkgs/@akanjs/devkit/transforms/externalizeFrameworkPlugin.ts
-import path28 from "path";
+import path30 from "path";
 var DEFAULT_INCLUDE = ["akanjs/", "@apps/", "@libs/"];
 var DEFAULT_EXCLUDE_EXACT = new Set(["akanjs/webkit", "@akanjs/cli", "@akanjs/devkit"]);
 var DEFAULT_EXCLUDE_PREFIX = ["@akanjs/cli/", "@akanjs/devkit/"];
@@ -7784,7 +8307,7 @@ async function createExternalizeFrameworkPlugin(options) {
         const replPath = repl?.endsWith("/*") ? repl.slice(0, -1) : repl ?? "";
         if (!replPath)
           continue;
-        const candidate = path28.resolve(workspaceRoot, replPath + suffix);
+        const candidate = path30.resolve(workspaceRoot, replPath + suffix);
         const hit = await firstExisting(candidate);
         if (hit)
           return hit;
@@ -7796,8 +8319,8 @@ async function createExternalizeFrameworkPlugin(options) {
       if (spec === pkg)
         continue;
       const suffix = spec.slice(pkg.length + 1);
-      const pkgDir = path28.dirname(path28.resolve(workspaceRoot, entryFile));
-      const candidate = path28.join(pkgDir, suffix);
+      const pkgDir = path30.dirname(path30.resolve(workspaceRoot, entryFile));
+      const candidate = path30.join(pkgDir, suffix);
       const hit = await firstExisting(candidate);
       if (hit)
         return hit;
@@ -7847,7 +8370,7 @@ async function firstExisting(basePath2) {
       return candidate;
   }
   for (const ext of CANDIDATE_EXTS3) {
-    const candidate = path28.join(basePath2, `index${ext}`);
+    const candidate = path30.join(basePath2, `index${ext}`);
     if (await Bun.file(candidate).exists())
       return candidate;
   }
@@ -7938,11 +8461,11 @@ class PagesBundleBuilder {
     const entryArtifact = result.outputs.find((a) => a.kind === "entry-point");
     if (!entryArtifact)
       throw new Error("[PagesBundleBuilder] Bun.build emitted no entry-point artifact");
-    const bundlePath = path29.resolve(entryArtifact.path);
+    const bundlePath = path31.resolve(entryArtifact.path);
     const buildId = Date.now();
     const outputBytes = result.outputs.reduce((sum, output) => sum + output.size, 0);
     const chunkCount = result.outputs.filter((output) => output.kind === "chunk").length;
-    this.#app.verbose(`[PagesBundleBuilder] ${path29.basename(bundlePath)} emitted in ${Date.now() - this.#started}ms splitting=${this.#splitting} entry=${entryArtifact.size} bytes outputs=${result.outputs.length} chunks=${chunkCount} total=${outputBytes} bytes`);
+    this.#app.verbose(`[PagesBundleBuilder] ${path31.basename(bundlePath)} emitted in ${Date.now() - this.#started}ms splitting=${this.#splitting} entry=${entryArtifact.size} bytes outputs=${result.outputs.length} chunks=${chunkCount} total=${outputBytes} bytes`);
     return {
       bundlePath,
       buildId,
@@ -8024,11 +8547,11 @@ function loaderFor4(absPath) {
 }
 // pkgs/@akanjs/devkit/frontendBuild/precompressArtifacts.ts
 import fs5 from "fs";
-import path30 from "path";
+import path32 from "path";
 var COMPRESSIBLE_EXTS = new Set([".css", ".html", ".js", ".json", ".svg"]);
 var MIN_COMPRESS_BYTES = 1024;
 async function precompressArtifacts(app) {
-  const roots = [path30.join(app.dist.cwdPath, ".akan/artifact/client")];
+  const roots = [path32.join(app.dist.cwdPath, ".akan/artifact/client")];
   const result = { files: 0, inputBytes: 0, outputBytes: 0 };
   await Promise.all(roots.map((root) => precompressRoot(root, result)));
   if (result.files > 0) {
@@ -8054,7 +8577,7 @@ async function precompressRoot(root, result) {
 async function shouldPrecompress(filePath) {
   if (filePath.endsWith(".gz"))
     return false;
-  if (!COMPRESSIBLE_EXTS.has(path30.extname(filePath).toLowerCase()))
+  if (!COMPRESSIBLE_EXTS.has(path32.extname(filePath).toLowerCase()))
     return false;
   const file = Bun.file(filePath);
   if (!await file.exists())
@@ -8072,7 +8595,7 @@ function formatBytes(bytes) {
   return `${(bytes / 1024 / 1024).toFixed(1)}MB`;
 }
 // pkgs/@akanjs/devkit/frontendBuild/ssrBaseArtifactBuilder.ts
-import path31 from "path";
+import path33 from "path";
 import { optimize } from "@tailwindcss/node";
 function prepareCssAsset(command, basePath2, cssText) {
   return optimize(cssText, { file: `${basePath2 || "root"}.css`, minify: command === "build" }).code;
@@ -8088,7 +8611,7 @@ class SsrBaseArtifactBuilder {
     this.#app = app;
     this.#command = command;
     this.#artifactDir = `${command === "build" ? app.dist.cwdPath : app.cwdPath}/.akan/artifact`;
-    this.#absArtifactDir = path31.resolve(this.#artifactDir);
+    this.#absArtifactDir = path33.resolve(this.#artifactDir);
   }
   async build() {
     const akanConfig2 = await this.#app.getConfig();
@@ -8110,7 +8633,7 @@ class SsrBaseArtifactBuilder {
       rscRuntimeSsrManifest,
       vendorMap,
       cssAssets,
-      pagesBundlePath: this.#command === "build" ? path31.relative(this.#absArtifactDir, pagesBundle.bundlePath) : pagesBundle.bundlePath,
+      pagesBundlePath: this.#command === "build" ? path33.relative(this.#absArtifactDir, pagesBundle.bundlePath) : pagesBundle.bundlePath,
       pagesBundleBuildId: pagesBundle.buildId,
       domains: [...akanConfig2.domains],
       subRoutes: Object.fromEntries(Array.from(akanConfig2.subRoutes.entries()).map(([basePath2, domains]) => [basePath2, [...domains]])),
@@ -8119,7 +8642,7 @@ class SsrBaseArtifactBuilder {
       i18n: akanConfig2.i18n,
       imageConfig: akanConfig2.images
     };
-    await Bun.write(path31.join(this.#absArtifactDir, "base-artifact.json"), `${JSON.stringify(artifact, null, 2)}
+    await Bun.write(path33.join(this.#absArtifactDir, "base-artifact.json"), `${JSON.stringify(artifact, null, 2)}
 `);
     this.#app.verbose(`[base-artifact] complete in ${Date.now() - this.#started}ms`);
     return { artifact, seedIndex, cssCompiler, optimizedFonts };
@@ -8167,15 +8690,15 @@ class SsrBaseArtifactBuilder {
   async#resolveAkanServerPath() {
     const candidates = [];
     try {
-      candidates.push(path31.dirname(Bun.resolveSync("akanjs/server", this.#app.workspace.workspaceRoot)));
+      candidates.push(path33.dirname(Bun.resolveSync("akanjs/server", this.#app.workspace.workspaceRoot)));
     } catch {}
-    candidates.push(path31.join(this.#app.workspace.workspaceRoot, "pkgs/akanjs/server"), path31.join(this.#app.workspace.workspaceRoot, "node_modules/akanjs/server"));
+    candidates.push(path33.join(this.#app.workspace.workspaceRoot, "pkgs/akanjs/server"), path33.join(this.#app.workspace.workspaceRoot, "node_modules/akanjs/server"));
     try {
-      candidates.push(path31.dirname(Bun.resolveSync("akanjs/server", path31.dirname(Bun.main))));
+      candidates.push(path33.dirname(Bun.resolveSync("akanjs/server", path33.dirname(Bun.main))));
     } catch {}
-    candidates.push(path31.join(path31.dirname(Bun.main), "node_modules/akanjs/server"), path31.join(path31.dirname(Bun.main), "../../akanjs/server"), path31.resolve(import.meta.dir, "../../server"), path31.resolve(import.meta.dir, "../server"));
+    candidates.push(path33.join(path33.dirname(Bun.main), "node_modules/akanjs/server"), path33.join(path33.dirname(Bun.main), "../../akanjs/server"), path33.resolve(import.meta.dir, "../../server"), path33.resolve(import.meta.dir, "../server"));
     for (const candidate of candidates) {
-      if (await Bun.file(path31.join(candidate, "rscClient.tsx")).exists())
+      if (await Bun.file(path33.join(candidate, "rscClient.tsx")).exists())
         return candidate;
     }
     throw new Error(`[base-artifact] failed to locate akanjs/server; looked in: ${candidates.join(", ")}`);
@@ -8204,14 +8727,14 @@ ${preparedCssText}`).toString(36);
       `styles/${cssAssetName}-${cssHash}.css`,
       `/_akan/styles/${cssAssetName}-${cssHash}.css`
     ];
-    await Bun.write(path31.join(this.#absArtifactDir, cssRelPath), preparedCssText);
+    await Bun.write(path33.join(this.#absArtifactDir, cssRelPath), preparedCssText);
     this.#app.verbose(`[base-artifact] wrote ${preparedCssText.length} bytes of CSS for ${basePath2} -> ${cssRelPath}`);
     return [basePath2, { cssUrl, cssRelPath }];
   }
 }
 // pkgs/@akanjs/devkit/frontendBuild/watchRootResolver.ts
 import fs6 from "fs";
-import path32 from "path";
+import path34 from "path";
 
 class WatchRootResolver {
   #app;
@@ -8221,15 +8744,15 @@ class WatchRootResolver {
   async resolve() {
     const tsconfig = await this.#app.getTsConfig();
     const set = new Set;
-    set.add(path32.resolve(`${this.#app.cwdPath}/page`));
+    set.add(path34.resolve(`${this.#app.cwdPath}/page`));
     for (const targets of Object.values(tsconfig.compilerOptions.paths ?? {})) {
       for (const target of targets) {
         if (!target)
           continue;
-        if (path32.isAbsolute(target))
+        if (path34.isAbsolute(target))
           continue;
         const cleaned = target.replace(/\/?\*+.*$/, "").replace(/\/[^/]+\.[^/]+$/, "");
-        const resolved = path32.resolve(this.#app.workspace.workspaceRoot, cleaned);
+        const resolved = path34.resolve(this.#app.workspace.workspaceRoot, cleaned);
         if (fs6.existsSync(resolved))
           set.add(resolved);
       }
@@ -8296,7 +8819,7 @@ class ApplicationBuildRunner {
       phases: this.#phases,
       durationMs: Date.now() - this.#startedAt,
       outputDir: this.#app.dist.cwdPath,
-      artifactDir: path33.join(this.#app.dist.cwdPath, ".akan/artifact")
+      artifactDir: path35.join(this.#app.dist.cwdPath, ".akan/artifact")
     };
   }
   async typecheck(options = {}) {
@@ -8304,7 +8827,7 @@ class ApplicationBuildRunner {
     await this.#app.getPageKeys({ refresh: true });
     const { typecheckDir, tsconfigPath } = await this.#writeTypecheckTsconfig({ incremental });
     if (clean)
-      await rm2(path33.join(typecheckDir, "tsconfig.tsbuildinfo"), { force: true });
+      await rm3(path35.join(typecheckDir, "tsconfig.tsbuildinfo"), { force: true });
     await this.#checkProjectInChildProcess(tsconfigPath);
   }
   async#runPhase(id, label, task, summarize, options = {}) {
@@ -8376,7 +8899,7 @@ class ApplicationBuildRunner {
     };
   }
   async#writeConsoleShim() {
-    await Bun.write(path33.join(this.#app.dist.cwdPath, "console.js"), `import { cnst, db, dict, option, server, sig, srv } from "./server.js";
+    await Bun.write(path35.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";
 
 const run = async () => {
@@ -8399,14 +8922,14 @@ void run().catch((error) => {
     try {
       return Bun.resolveSync("akanjs/server/rsc-worker", import.meta.dir);
     } catch {
-      return path33.join(this.#app.workspace.workspaceRoot, "pkgs/akanjs/server/rscWorker.tsx");
+      return path35.join(this.#app.workspace.workspaceRoot, "pkgs/akanjs/server/rscWorker.tsx");
     }
   }
   #resolveConsoleRuntimeBuildEntry() {
     try {
-      return path33.join(path33.dirname(Bun.resolveSync("akanjs/server", import.meta.dir)), "console.ts");
+      return path35.join(path35.dirname(Bun.resolveSync("akanjs/server", import.meta.dir)), "console.ts");
     } catch {
-      return path33.join(this.#app.workspace.workspaceRoot, "pkgs/akanjs/server/console.ts");
+      return path35.join(this.#app.workspace.workspaceRoot, "pkgs/akanjs/server/console.ts");
     }
   }
   async#buildCsr() {
@@ -8423,8 +8946,8 @@ void run().catch((error) => {
     return { base, allRoutes };
   }
   async#writeTypecheckTsconfig({ incremental = true } = {}) {
-    const typecheckDir = path33.join(this.#app.cwdPath, ".akan", "typecheck");
-    await mkdir7(typecheckDir, { recursive: true });
+    const typecheckDir = path35.join(this.#app.cwdPath, ".akan", "typecheck");
+    await mkdir8(typecheckDir, { recursive: true });
     const tsconfig = {
       extends: "../../tsconfig.json",
       compilerOptions: {
@@ -8442,7 +8965,7 @@ void run().catch((error) => {
       ],
       references: []
     };
-    const tsconfigPath = path33.join(typecheckDir, "tsconfig.json");
+    const tsconfigPath = path35.join(typecheckDir, "tsconfig.json");
     await Bun.write(tsconfigPath, `${JSON.stringify(tsconfig, null, 2)}
 `);
     return { typecheckDir, tsconfigPath };
@@ -8468,10 +8991,10 @@ void run().catch((error) => {
   }
   async#resolveTypecheckWorkerEntry() {
     const candidates = [
-      path33.join(this.#app.workspace.workspaceRoot, "pkgs/@akanjs/devkit/typecheck/typecheck.proc.ts"),
-      path33.join(this.#app.workspace.workspaceRoot, "node_modules/@akanjs/devkit/typecheck/typecheck.proc.ts"),
-      path33.join(import.meta.dir, "typecheck.proc.js"),
-      path33.join(import.meta.dir, "typecheck.proc.ts")
+      path35.join(this.#app.workspace.workspaceRoot, "pkgs/@akanjs/devkit/typecheck/typecheck.proc.ts"),
+      path35.join(this.#app.workspace.workspaceRoot, "node_modules/@akanjs/devkit/typecheck/typecheck.proc.ts"),
+      path35.join(import.meta.dir, "typecheck.proc.js"),
+      path35.join(import.meta.dir, "typecheck.proc.ts")
     ];
     for (const candidate of candidates)
       if (await Bun.file(candidate).exists())
@@ -8504,7 +9027,7 @@ void run().catch((error) => {
   }
 }
 // pkgs/@akanjs/devkit/applicationReleasePackager.ts
-import { cp, mkdir as mkdir8, rm as rm3 } from "fs/promises";
+import { cp, mkdir as mkdir9, rm as rm4 } from "fs/promises";
 
 // pkgs/@akanjs/devkit/uploadRelease.ts
 import { HttpClient as HttpClient2, Logger as Logger9 } from "akanjs/common";
@@ -8610,16 +9133,16 @@ class ApplicationReleasePackager {
     const platformVersion = akanConfig2.mobile.version;
     const buildRoot = `${this.#app.workspace.workspaceRoot}/releases/builds/${this.#app.name}`;
     if (await FileSys.dirExists(buildRoot))
-      await rm3(buildRoot, { recursive: true, force: true });
-    await mkdir8(buildRoot, { recursive: true });
+      await rm4(buildRoot, { recursive: true, force: true });
+    await mkdir9(buildRoot, { recursive: true });
     if (rebuild || !await FileSys.dirExists(`${this.#app.dist.cwdPath}/backend`))
       await this.#build();
     const buildVersion = `${platformVersion}-${buildNum}`;
     const buildPath = `${buildRoot}/${buildVersion}`;
-    await mkdir8(buildPath, { recursive: true });
+    await mkdir9(buildPath, { recursive: true });
     await cp(`${this.#app.dist.cwdPath}/backend`, `${buildPath}/backend`, { recursive: true });
     await cp(this.#app.dist.cwdPath, buildRoot, { recursive: true });
-    await rm3(`${buildRoot}/frontend/.next`, { recursive: true, force: true });
+    await rm4(`${buildRoot}/frontend/.next`, { recursive: true, force: true });
     await this.#app.workspace.spawn("tar", [
       "-zcf",
       `${this.#app.workspace.workspaceRoot}/releases/builds/${this.#app.name}-release.tar.gz`,
@@ -8639,7 +9162,7 @@ class ApplicationReleasePackager {
       `${this.#app.workspace.workspaceRoot}/releases/builds/${this.#app.name}-appBuild.zip`,
       "./csr"
     ]);
-    await rm3("./csr", { recursive: true, force: true });
+    await rm4("./csr", { recursive: true, force: true });
   }
   async#writeSourceArchive({ readme }) {
     const sourceRoot = `${this.#app.workspace.workspaceRoot}/releases/sources/${this.#app.name}`;
@@ -8647,13 +9170,13 @@ class ApplicationReleasePackager {
     await cp(this.#app.dist.cwdPath, `${sourceRoot}/apps/${this.#app.name}`, { recursive: true });
     const libDeps = ["social", "shared", "platform", "util"];
     await Promise.all(libDeps.map((lib) => cp(`${this.#app.workspace.cwdPath}/libs/${lib}`, `${sourceRoot}/libs/${lib}`, { recursive: true })));
-    await Promise.all([".next", "ios", "android", "public/libs"].map(async (path34) => {
-      const targetPath = `${sourceRoot}/apps/${this.#app.name}/${path34}`;
+    await Promise.all([".next", "ios", "android", "public/libs"].map(async (path36) => {
+      const targetPath = `${sourceRoot}/apps/${this.#app.name}/${path36}`;
       if (await FileSys.dirExists(targetPath))
-        await rm3(targetPath, { recursive: true, force: true });
+        await rm4(targetPath, { recursive: true, force: true });
     }));
     const syncPaths = [".husky", ".gitignore", "package.json"];
-    await Promise.all(syncPaths.map((path34) => cp(`${this.#app.workspace.cwdPath}/${path34}`, `${sourceRoot}/${path34}`, { recursive: true })));
+    await Promise.all(syncPaths.map((path36) => cp(`${this.#app.workspace.cwdPath}/${path36}`, `${sourceRoot}/${path36}`, { recursive: true })));
     await this.#writeSourceTsconfig(sourceRoot, libDeps);
     await Bun.write(`${sourceRoot}/README.md`, readme);
     await this.#app.workspace.spawn("tar", [
@@ -8669,11 +9192,11 @@ class ApplicationReleasePackager {
       const maxRetry = 3;
       for (let i = 0;i < maxRetry; i++) {
         try {
-          await rm3(sourceRoot, { recursive: true, force: true });
+          await rm4(sourceRoot, { recursive: true, force: true });
         } catch {}
       }
     }
-    await mkdir8(sourceRoot, { recursive: true });
+    await mkdir9(sourceRoot, { recursive: true });
   }
   async#writeSourceTsconfig(sourceRoot, libDeps) {
     const tsconfig = await this.#app.workspace.readJson("tsconfig.json");
@@ -8744,20 +9267,20 @@ class ApplicationReleasePackager {
   }
 }
 // pkgs/@akanjs/devkit/applicationTestPreload.ts
-import path34 from "path";
+import path36 from "path";
 var SIGNAL_TEST_PRELOAD_PATH = "test/signalTest.preload.ts";
 async function resolveSignalTestPreloadPath(target) {
   const candidates = [];
   const addResolvedPackageCandidate = (basePath2) => {
     try {
-      candidates.push(path34.join(path34.dirname(Bun.resolveSync("akanjs/package.json", basePath2)), SIGNAL_TEST_PRELOAD_PATH));
+      candidates.push(path36.join(path36.dirname(Bun.resolveSync("akanjs/package.json", basePath2)), SIGNAL_TEST_PRELOAD_PATH));
     } catch {}
   };
   addResolvedPackageCandidate(target.cwdPath);
   addResolvedPackageCandidate(process.cwd());
-  addResolvedPackageCandidate(path34.dirname(Bun.main));
+  addResolvedPackageCandidate(path36.dirname(Bun.main));
   addResolvedPackageCandidate(import.meta.dir);
-  candidates.push(path34.join(target.cwdPath, "../../node_modules/akanjs", SIGNAL_TEST_PRELOAD_PATH), path34.join(target.cwdPath, "../../pkgs/akanjs", SIGNAL_TEST_PRELOAD_PATH), path34.join(process.cwd(), "node_modules/akanjs", SIGNAL_TEST_PRELOAD_PATH), path34.join(process.cwd(), "pkgs/akanjs", SIGNAL_TEST_PRELOAD_PATH), path34.join(path34.dirname(Bun.main), "../../akanjs", SIGNAL_TEST_PRELOAD_PATH), path34.resolve(import.meta.dir, "../../akanjs", SIGNAL_TEST_PRELOAD_PATH));
+  candidates.push(path36.join(target.cwdPath, "../../node_modules/akanjs", SIGNAL_TEST_PRELOAD_PATH), path36.join(target.cwdPath, "../../pkgs/akanjs", SIGNAL_TEST_PRELOAD_PATH), path36.join(process.cwd(), "node_modules/akanjs", SIGNAL_TEST_PRELOAD_PATH), path36.join(process.cwd(), "pkgs/akanjs", SIGNAL_TEST_PRELOAD_PATH), path36.join(path36.dirname(Bun.main), "../../akanjs", SIGNAL_TEST_PRELOAD_PATH), path36.resolve(import.meta.dir, "../../akanjs", SIGNAL_TEST_PRELOAD_PATH));
   for (const candidate of [...new Set(candidates)]) {
     if (await Bun.file(candidate).exists())
       return candidate;
@@ -8766,8 +9289,8 @@ async function resolveSignalTestPreloadPath(target) {
 }
 // pkgs/@akanjs/devkit/builder.ts
 import { existsSync as existsSync2 } from "fs";
-import { mkdir as mkdir9 } from "fs/promises";
-import path35 from "path";
+import { mkdir as mkdir10 } from "fs/promises";
+import path37 from "path";
 var SKIP_ENTRY_DIR_SET = new Set(["node_modules", "dist", "build", ".git", ".next"]);
 var assetExtensions = [".css", ".md", ".js", ".png", ".ico", ".svg", ".json", ".template"];
 var assetLoader = Object.fromEntries(assetExtensions.map((ext) => [ext, "file"]));
@@ -8784,14 +9307,14 @@ class Builder {
   #globEntrypoints(cwd, pattern) {
     const glob = new Bun.Glob(pattern);
     return Array.from(glob.scanSync({ cwd, onlyFiles: true })).filter((relativePath) => {
-      const segments = relativePath.split(path35.sep);
+      const segments = relativePath.split(path37.sep);
       return !segments.some((segment) => SKIP_ENTRY_DIR_SET.has(segment));
-    }).map((rel) => path35.join(cwd, rel));
+    }).map((rel) => path37.join(cwd, rel));
   }
   #globFiles(cwd, pattern = "**/*.*") {
     const glob = new Bun.Glob(pattern);
     return Array.from(glob.scanSync({ cwd, onlyFiles: true })).filter((relativePath) => {
-      const segments = relativePath.split(path35.sep);
+      const segments = relativePath.split(path37.sep);
       return !segments.some((segment) => SKIP_ENTRY_DIR_SET.has(segment));
     });
   }
@@ -8799,17 +9322,17 @@ class Builder {
     const out = [];
     for (const p of additionalEntryPoints) {
       if (p.includes("*")) {
-        const rel = p.startsWith(`${cwd}/`) || p.startsWith(`${cwd}${path35.sep}`) ? p.slice(cwd.length + 1) : p;
+        const rel = p.startsWith(`${cwd}/`) || p.startsWith(`${cwd}${path37.sep}`) ? p.slice(cwd.length + 1) : p;
         out.push(...this.#globEntrypoints(cwd, rel));
       } else
-        out.push(path35.isAbsolute(p) ? p : path35.join(cwd, p));
+        out.push(path37.isAbsolute(p) ? p : path37.join(cwd, p));
     }
     return out;
   }
   #getBuildOptions({ bundle = false, additionalEntryPoints = [] } = {}) {
     const cwd = this.#executor.cwdPath;
     const entrypoints = [
-      ...bundle ? [path35.join(cwd, "index.ts")] : this.#globEntrypoints(cwd, "**/*.{ts,tsx}"),
+      ...bundle ? [path37.join(cwd, "index.ts")] : this.#globEntrypoints(cwd, "**/*.{ts,tsx}"),
       ...this.#resolveAdditionalEntrypoints(cwd, additionalEntryPoints)
     ];
     return {
@@ -8830,9 +9353,9 @@ class Builder {
     for (const relativePath of this.#globFiles(cwd)) {
       if (relativePath === "package.json")
         continue;
-      const sourcePath = path35.join(cwd, relativePath);
-      const targetPath = path35.join(this.#distExecutor.cwdPath, relativePath);
-      await mkdir9(path35.dirname(targetPath), { recursive: true });
+      const sourcePath = path37.join(cwd, relativePath);
+      const targetPath = path37.join(this.#distExecutor.cwdPath, relativePath);
+      await mkdir10(path37.dirname(targetPath), { recursive: true });
       await Bun.write(targetPath, Bun.file(sourcePath));
     }
   }
@@ -8843,13 +9366,13 @@ class Builder {
       return withoutFormatDir;
     if (!hasDotSlash && withoutFormatDir === publishedPath)
       return publishedPath;
-    const parsed = path35.posix.parse(withoutFormatDir);
+    const parsed = path37.posix.parse(withoutFormatDir);
     if (![".js", ".mjs", ".cjs"].includes(parsed.ext))
       return withoutFormatDir;
-    const withoutExt = path35.posix.join(parsed.dir, parsed.name);
+    const withoutExt = path37.posix.join(parsed.dir, parsed.name);
     const sourcePath = withoutExt.startsWith("./") ? withoutExt.slice(2) : withoutExt;
     const sourceCandidates = [`${sourcePath}.ts`, `${sourcePath}.tsx`];
-    const matchedSource = sourceCandidates.find((candidate) => existsSync2(path35.join(this.#executor.cwdPath, candidate)));
+    const matchedSource = sourceCandidates.find((candidate) => existsSync2(path37.join(this.#executor.cwdPath, candidate)));
     if (!matchedSource)
       return withoutFormatDir;
     return hasDotSlash ? `./${matchedSource}` : matchedSource;
@@ -8898,10 +9421,10 @@ class Builder {
   }
 }
 // pkgs/@akanjs/devkit/capacitorApp.ts
-import { cp as cp2, mkdir as mkdir10, rm as rm4 } from "fs/promises";
-import path36 from "path";
+import { cp as cp2, mkdir as mkdir11, rm as rm5 } from "fs/promises";
+import path38 from "path";
 import { MobileProject } from "@trapezedev/project";
-import { capitalize as capitalize3 } from "akanjs/common";
+import { capitalize as capitalize4 } from "akanjs/common";
 
 // pkgs/@akanjs/devkit/fileEditor.ts
 class FileEditor {
@@ -9094,10 +9617,10 @@ class CapacitorApp {
   constructor(app, target) {
     this.app = app;
     this.target = target;
-    this.targetRootPath = path36.posix.join(".akan", "mobile", this.target.name);
-    this.targetRoot = path36.join(this.app.cwdPath, this.targetRootPath);
-    this.targetWebRoot = path36.join(this.targetRoot, "www");
-    this.targetAssetRoot = path36.join(this.targetRoot, "assets");
+    this.targetRootPath = path38.posix.join(".akan", "mobile", this.target.name);
+    this.targetRoot = path38.join(this.app.cwdPath, this.targetRootPath);
+    this.targetWebRoot = path38.join(this.targetRoot, "www");
+    this.targetAssetRoot = path38.join(this.targetRoot, "assets");
     this.project = new MobileProject(this.app.cwdPath, {
       android: { path: this.androidRootPath },
       ios: { path: this.iosProjectPath }
@@ -9109,13 +9632,13 @@ class CapacitorApp {
     env = "debug",
     regenerate = false
   } = {}) {
-    await mkdir10(this.targetRoot, { recursive: true });
+    await mkdir11(this.targetRoot, { recursive: true });
     await this.#writeCapacitorConfig();
     if (regenerate) {
       if (!platform || platform === "ios")
-        await rm4(path36.join(this.app.cwdPath, this.iosRootPath), { recursive: true, force: true });
+        await rm5(path38.join(this.app.cwdPath, this.iosRootPath), { recursive: true, force: true });
       if (!platform || platform === "android")
-        await rm4(path36.join(this.app.cwdPath, this.androidRootPath), { recursive: true, force: true });
+        await rm5(path38.join(this.app.cwdPath, this.androidRootPath), { recursive: true, force: true });
     }
     const project = this.project;
     await this.project.load();
@@ -9179,7 +9702,7 @@ class CapacitorApp {
     await this.#spawnMobile("npx", ["cap", "sync", "android"], { operation, env });
   }
   async#updateAndroidBuildTypes() {
-    const appGradle = await FileEditor.create(path36.join(this.app.cwdPath, this.androidRootPath, "app/build.gradle"));
+    const appGradle = await FileEditor.create(path38.join(this.app.cwdPath, this.androidRootPath, "app/build.gradle"));
     const buildTypesBlock = `
       debug {
         applicationIdSuffix ".debug"
@@ -9222,7 +9745,7 @@ class CapacitorApp {
     const gradleCommand = isWindows ? "gradlew.bat" : "./gradlew";
     await this.app.spawn(gradleCommand, [assembleType === "apk" ? "assembleRelease" : "bundleRelease"], {
       stdio: "inherit",
-      cwd: path36.join(this.app.cwdPath, this.androidRootPath),
+      cwd: path38.join(this.app.cwdPath, this.androidRootPath),
       env: await this.#commandEnv("release", env)
     });
   }
@@ -9230,10 +9753,10 @@ class CapacitorApp {
     await this.#spawnMobile("npx", ["cap", "open", "android"], { operation: "local", env: "local" });
   }
   async#ensureAndroidAssetsDir() {
-    await mkdir10(path36.join(this.app.cwdPath, this.androidAssetsPath), { recursive: true });
+    await mkdir11(path38.join(this.app.cwdPath, this.androidAssetsPath), { recursive: true });
   }
   async#ensureAndroidDebugKeystore() {
-    const keystorePath = path36.join(this.app.cwdPath, this.androidRootPath, "app/debug.keystore");
+    const keystorePath = path38.join(this.app.cwdPath, this.androidRootPath, "app/debug.keystore");
     if (await Bun.file(keystorePath).exists())
       return;
     await this.#spawn("keytool", [
@@ -9279,12 +9802,12 @@ class CapacitorApp {
     await this.#prepareAndroid({ operation: "release", env: "main" });
   }
   async prepareWww() {
-    const htmlSource = path36.join(this.app.dist.cwdPath, "csr", targetHtmlFilename(this.target));
+    const htmlSource = path38.join(this.app.dist.cwdPath, "csr", targetHtmlFilename(this.target));
     if (!await Bun.file(htmlSource).exists())
       throw new Error(`CSR html for mobile target '${this.target.name}' not found: ${htmlSource}`);
-    await rm4(this.targetWebRoot, { recursive: true, force: true });
-    await mkdir10(this.targetWebRoot, { recursive: true });
-    await Bun.write(path36.join(this.targetWebRoot, "index.html"), this.#injectMobileTargetMeta(await Bun.file(htmlSource).text()));
+    await rm5(this.targetWebRoot, { recursive: true, force: true });
+    await mkdir11(this.targetWebRoot, { recursive: true });
+    await Bun.write(path38.join(this.targetWebRoot, "index.html"), this.#injectMobileTargetMeta(await Bun.file(htmlSource).text()));
   }
   #injectMobileTargetMeta(html) {
     const basePath2 = this.target.basePath?.replace(/^\/+|\/+$/g, "") ?? "";
@@ -9295,8 +9818,8 @@ class CapacitorApp {
 </head>`);
   }
   async#writeCapacitorConfig() {
-    await mkdir10(this.targetRoot, { recursive: true });
-    const appInfoPath = path36.relative(this.app.cwdPath, path36.join(this.app.cwdPath, "akan.app.json")).split(path36.sep).join("/");
+    await mkdir11(this.targetRoot, { recursive: true });
+    const appInfoPath = path38.relative(this.app.cwdPath, path38.join(this.app.cwdPath, "akan.app.json")).split(path38.sep).join("/");
     const content = `import type { AppScanResult } from "akanjs";
 import { withBase } from "${process.env.USE_AKANJS_PKGS === "true" ? "../../pkgs/" : ""}akanjs/capacitor.base.config";
 import appInfo from "${appInfoPath.startsWith(".") ? appInfoPath : `./${appInfoPath}`}";
@@ -9317,18 +9840,18 @@ export default withBase(
   appInfo as AppScanResult,
 );
 `;
-    await Bun.write(path36.join(this.app.cwdPath, "capacitor.config.ts"), content);
+    await Bun.write(path38.join(this.app.cwdPath, "capacitor.config.ts"), content);
   }
   async#prepareTargetAssets() {
     if (!this.target.assets)
       return;
-    await mkdir10(this.targetAssetRoot, { recursive: true });
+    await mkdir11(this.targetAssetRoot, { recursive: true });
     if (this.target.assets.icon)
-      await cp2(path36.join(this.app.cwdPath, this.target.assets.icon), path36.join(this.targetAssetRoot, "icon.png"), {
+      await cp2(path38.join(this.app.cwdPath, this.target.assets.icon), path38.join(this.targetAssetRoot, "icon.png"), {
         force: true
       });
     if (this.target.assets.splash)
-      await cp2(path36.join(this.app.cwdPath, this.target.assets.splash), path36.join(this.targetAssetRoot, "splash.png"), {
+      await cp2(path38.join(this.app.cwdPath, this.target.assets.splash), path38.join(this.targetAssetRoot, "splash.png"), {
         force: true
       });
   }
@@ -9336,11 +9859,11 @@ export default withBase(
     const files = this.target.files?.[platform];
     if (!files)
       return;
-    const platformRoot = path36.join(this.app.cwdPath, platform === "ios" ? this.iosRootPath : this.androidRootPath);
+    const platformRoot = path38.join(this.app.cwdPath, platform === "ios" ? this.iosRootPath : this.androidRootPath);
     await Promise.all(Object.entries(files).map(async ([to, from]) => {
-      const targetPath = path36.join(platformRoot, to);
-      await mkdir10(path36.dirname(targetPath), { recursive: true });
-      await cp2(path36.join(this.app.cwdPath, from), targetPath, { force: true });
+      const targetPath = path38.join(platformRoot, to);
+      await mkdir11(path38.dirname(targetPath), { recursive: true });
+      await cp2(path38.join(this.app.cwdPath, from), targetPath, { force: true });
     }));
   }
   async#generateAssets({ operation, env }) {
@@ -9350,7 +9873,7 @@ export default withBase(
       "@capacitor/assets",
       "generate",
       "--assetPath",
-      path36.posix.join(this.targetRootPath, "assets"),
+      path38.posix.join(this.targetRootPath, "assets"),
       "--iosProject",
       this.iosProjectPath,
       "--androidProject",
@@ -9452,7 +9975,7 @@ export default withBase(
     this.#setPermissionsInAndroid(["POST_NOTIFICATIONS"]);
   }
   async#setPermissionInIos(permissions) {
-    const updateNs = Object.fromEntries(Object.entries(permissions).map(([key, value]) => [`NS${capitalize3(key)}`, value]));
+    const updateNs = Object.fromEntries(Object.entries(permissions).map(([key, value]) => [`NS${capitalize4(key)}`, value]));
     await Promise.all([
       this.project.ios.updateInfoPlist(this.iosTargetName, "Debug", updateNs),
       this.project.ios.updateInfoPlist(this.iosTargetName, "Release", updateNs)
@@ -9537,15 +10060,15 @@ var Pkg = createInternalArgToken("Pkg");
 var Module = createInternalArgToken("Module");
 var Workspace = createInternalArgToken("Workspace");
 // pkgs/@akanjs/devkit/commandDecorators/command.ts
-import path37 from "path";
+import path39 from "path";
 import { confirm, input as input2, select as select2 } from "@inquirer/prompts";
 import { Logger as Logger10 } from "akanjs/common";
 import chalk6 from "chalk";
 import { program } from "commander";
 
 // pkgs/@akanjs/devkit/commandDecorators/dependencyBuilder.ts
-var capitalize4 = (value) => value.slice(0, 1).toUpperCase() + value.slice(1);
-var createDependencyKey = (refName, kind) => `${refName}${capitalize4(kind)}`;
+var capitalize5 = (value) => value.slice(0, 1).toUpperCase() + value.slice(1);
+var createDependencyKey = (refName, kind) => `${refName}${capitalize5(kind)}`;
 
 class CommandContainer {
   static #instances = new Map;
@@ -10037,7 +10560,7 @@ var runCommands = async (...commands) => {
     process.exit(1);
   });
   const __dirname2 = getDirname(import.meta.url);
-  const packageJsonCandidates = [`${path37.dirname(Bun.main)}/package.json`, `${__dirname2}/../package.json`];
+  const packageJsonCandidates = [`${path39.dirname(Bun.main)}/package.json`, `${__dirname2}/../package.json`];
   let cliPackageJson = null;
   for (const packageJsonPath of packageJsonCandidates) {
     if (!await FileSys.fileExists(packageJsonPath))
@@ -10315,8 +10838,8 @@ var scanModuleSpecifiers = (source, filePath, includeExports) => {
   return importSpecifiers;
 };
 var parseTsConfig = (tsConfigPath = "./tsconfig.json") => {
-  const configFile = ts7.readConfigFile(tsConfigPath, (path38) => {
-    return ts7.sys.readFile(path38);
+  const configFile = ts7.readConfigFile(tsConfigPath, (path40) => {
+    return ts7.sys.readFile(path40);
   });
   return ts7.parseJsonConfigFileContent(configFile.config, ts7.sys, realpathSync(tsConfigPath).replace(/[^/\\]+$/, ""));
 };
@@ -11513,7 +12036,7 @@ class ApplicationCommand extends command("application", [ApplicationScript], ({
 import { Logger as Logger16 } from "akanjs/common";
 
 // pkgs/@akanjs/cli/package/package.runner.ts
-import path38 from "path";
+import path40 from "path";
 import { Logger as Logger14 } from "akanjs/common";
 var {$: $2 } = globalThis.Bun;
 
@@ -11533,11 +12056,11 @@ class PackageRunner extends runner("package") {
   }
   async#getInstalledPackageJson() {
     const packageJsonCandidates = [
-      `${path38.dirname(Bun.main)}/package.json`,
+      `${path40.dirname(Bun.main)}/package.json`,
       `${process.cwd()}/node_modules/akanjs/package.json`
     ];
     try {
-      packageJsonCandidates.unshift(Bun.resolveSync("akanjs/package.json", path38.dirname(Bun.main)));
+      packageJsonCandidates.unshift(Bun.resolveSync("akanjs/package.json", path40.dirname(Bun.main)));
     } catch {}
     for (const packageJsonPath of packageJsonCandidates) {
       if (!await Bun.file(packageJsonPath).exists())
@@ -11546,7 +12069,7 @@ class PackageRunner extends runner("package") {
       if (packageJson.name === "akanjs" || packageJson.name === "@akanjs/cli")
         return packageJson;
     }
-    throw new Error(`[package] failed to locate akanjs package.json from ${path38.dirname(Bun.main)}`);
+    throw new Error(`[package] failed to locate akanjs package.json from ${path40.dirname(Bun.main)}`);
   }
   async createPackage(workspace, pkgName) {
     await workspace.applyTemplate({ basePath: `pkgs/${pkgName}`, template: "pkgRoot", dict: { pkgName } });
@@ -11721,7 +12244,7 @@ class PackageScript extends script("package", [PackageRunner]) {
 }
 
 // pkgs/@akanjs/cli/cloud/cloud.runner.ts
-import path39 from "path";
+import path41 from "path";
 import { confirm as confirm4, input as input5, select as select7 } from "@inquirer/prompts";
 import { Logger as Logger15, sleep } from "akanjs/common";
 import chalk7 from "chalk";
@@ -11992,7 +12515,7 @@ ${chalk7.green("\u27A4")} Authentication Required`));
     await Promise.all(akanPkgs.map(async (library) => {
       Logger15.info(`Publishing ${library}@${nextVersion} to ${registry ?? "npm"}...`);
       await workspace.spawn("npm", ["publish", "--tag", tag, ...this.#getRegistryArgs(registry), ...this.#getLocalRegistryAuthArgs(registry)], {
-        cwd: path39.join(workspace.workspaceRoot, "dist/pkgs", library),
+        cwd: path41.join(workspace.workspaceRoot, "dist/pkgs", library),
         env: this.#getRegistryEnv(registry),
         stdio: "inherit"
       });
@@ -12050,7 +12573,7 @@ ${chalk7.green("\u27A4")} Authentication Required`));
     await workspace.remove(localPath);
   }
   async uploadEnv(cloudApi2, workspaceId, filePath) {
-    const file = new File([Bun.file(filePath)], path39.basename(filePath));
+    const file = new File([Bun.file(filePath)], path41.basename(filePath));
     await cloudApi2.uploadEnv(workspaceId, file);
   }
   async downloadEnvByScp(workspace) {
@@ -12142,14 +12665,14 @@ class CloudScript extends script("cloud", [CloudRunner, ApplicationScript, Packa
   }
   async uploadEnv(workspace) {
     const workspaceId = workspace.getWorkspaceId({ allowEmpty: true });
-    const { path: path40 } = await this.cloudRunner.gatherEnvFiles(workspace);
+    const { path: path42 } = await this.cloudRunner.gatherEnvFiles(workspace);
     if (workspaceId) {
       await this.login(workspace);
       const cloudApi2 = await CloudApi.fromHost(workspace);
-      await this.cloudRunner.uploadEnv(cloudApi2, workspaceId, path40);
+      await this.cloudRunner.uploadEnv(cloudApi2, workspaceId, path42);
       return;
     }
-    await this.cloudRunner.uploadEnvByScp(workspace, path40);
+    await this.cloudRunner.uploadEnvByScp(workspace, path42);
   }
   async deployAkan(workspace, { test = true, registryUrl } = {}) {
     const akanPkgs = await this.cloudRunner.getAkanPkgs(workspace);
@@ -12563,14 +13086,14 @@ class GuidelinePrompt extends Prompter {
   async#getScanFilePaths(matchPattern, { avoidDirs = ["node_modules", ".next"], filterText } = {}) {
     const glob = new Bun.Glob(matchPattern);
     const paths = [];
-    for await (const path40 of glob.scan({ cwd: this.workspace.workspaceRoot, absolute: true })) {
-      if (avoidDirs.some((dir) => path40.includes(dir)))
+    for await (const path42 of glob.scan({ cwd: this.workspace.workspaceRoot, absolute: true })) {
+      if (avoidDirs.some((dir) => path42.includes(dir)))
         continue;
-      const fileContent = await FileSys.readText(path40);
+      const fileContent = await FileSys.readText(path42);
       const textFilter = filterText ? new RegExp(filterText) : null;
       if (filterText && !textFilter?.test(fileContent))
         continue;
-      paths.push(path40);
+      paths.push(path42);
     }
     return paths;
   }
@@ -12889,8 +13412,8 @@ class LibraryCommand extends command("library", [LibraryScript], ({ public: targ
 }
 
 // pkgs/@akanjs/cli/localRegistry/localRegistry.runner.ts
-import { mkdir as mkdir11, rm as rm5 } from "fs/promises";
-import path40 from "path";
+import { mkdir as mkdir12, rm as rm6 } from "fs/promises";
+import path42 from "path";
 import { Logger as Logger19 } from "akanjs/common";
 var defaultLocalRegistryUrl = "http://127.0.0.1:4873";
 var containerName = "akan-verdaccio";
@@ -12908,9 +13431,9 @@ class LocalRegistryRunner extends runner("localRegistry") {
       Logger19.info(`Local registry is already running at ${registry}`);
       return registry;
     } catch {}
-    const configPath2 = path40.join(workspace.workspaceRoot, "pkgs/@akanjs/cli/localRegistry/verdaccio.yaml");
-    const storagePath = path40.join(workspace.workspaceRoot, ".akan/verdaccio/storage");
-    await mkdir11(storagePath, { recursive: true });
+    const configPath2 = path42.join(workspace.workspaceRoot, "pkgs/@akanjs/cli/localRegistry/verdaccio.yaml");
+    const storagePath = path42.join(workspace.workspaceRoot, ".akan/verdaccio/storage");
+    await mkdir12(storagePath, { recursive: true });
     await workspace.spawn("docker", [
       "run",
       "--rm",
@@ -12932,13 +13455,13 @@ class LocalRegistryRunner extends runner("localRegistry") {
     try {
       await workspace.spawn("docker", ["rm", "-f", containerName], { stdio: "inherit" });
     } catch {}
-    await rm5(path40.join(workspace.workspaceRoot, ".akan/verdaccio"), { recursive: true, force: true });
+    await rm6(path42.join(workspace.workspaceRoot, ".akan/verdaccio"), { recursive: true, force: true });
     Logger19.info("Local registry storage has been reset");
   }
   async smoke(workspace, { registryUrl } = {}) {
     const registry = this.getRegistryUrl(registryUrl);
-    const smokeRoot = path40.join(workspace.workspaceRoot, ".akan/e2e");
-    await rm5(path40.join(smokeRoot, smokeRepoName), { recursive: true, force: true });
+    const smokeRoot = path42.join(workspace.workspaceRoot, ".akan/e2e");
+    await rm6(path42.join(smokeRoot, smokeRepoName), { recursive: true, force: true });
     await workspace.spawn(process.execPath, [
       "dist/pkgs/create-akan-workspace/index.js",
       smokeRepoName,
@@ -12955,12 +13478,12 @@ class LocalRegistryRunner extends runner("localRegistry") {
       stdio: "inherit"
     });
     await workspace.spawn("akan", ["typecheck", smokeAppName], {
-      cwd: path40.join(smokeRoot, smokeRepoName),
+      cwd: path42.join(smokeRoot, smokeRepoName),
       env: { ...process.env, AKAN_NPM_REGISTRY: registry, NPM_CONFIG_REGISTRY: registry },
       stdio: "inherit"
     });
     await workspace.spawn("akan", ["build", smokeAppName], {
-      cwd: path40.join(smokeRoot, smokeRepoName),
+      cwd: path42.join(smokeRoot, smokeRepoName),
       env: { ...process.env, AKAN_NPM_REGISTRY: registry, NPM_CONFIG_REGISTRY: registry },
       stdio: "inherit"
     });
@@ -13040,7 +13563,7 @@ import { lowerlize } from "akanjs/common";
 
 // pkgs/@akanjs/cli/module/module.script.ts
 import { input as input6 } from "@inquirer/prompts";
-import { capitalize as capitalize7, randomPicks as randomPicks2 } from "akanjs/common";
+import { capitalize as capitalize8, randomPicks as randomPicks2 } from "akanjs/common";
 
 // pkgs/@akanjs/cli/page/page.runner.ts
 class PageRunner extends runner("page") {
@@ -13070,7 +13593,7 @@ function pluralizeName(name) {
 }
 
 // pkgs/@akanjs/cli/module/module.request.ts
-import { capitalize as capitalize5 } from "akanjs/common";
+import { capitalize as capitalize6 } from "akanjs/common";
 
 // pkgs/@akanjs/cli/module/module.prompt.ts
 var componentDefaultDescription = ({
@@ -13195,7 +13718,7 @@ var requestTemplate = ({
 		${componentDefaultDescription({
   sysName,
   modelName,
-  ModelName: ModelName ?? capitalize5(modelName),
+  ModelName: ModelName ?? capitalize6(modelName),
   exampleFiles,
   constant,
   properties
@@ -13252,7 +13775,7 @@ var requestView = ({
 	 ${componentDefaultDescription({
   sysName,
   modelName,
-  ModelName: ModelName ?? capitalize5(modelName),
+  ModelName: ModelName ?? capitalize6(modelName),
   exampleFiles,
   constant,
   properties
@@ -13313,7 +13836,7 @@ var requestUnit = ({
 	 ${componentDefaultDescription({
   sysName,
   modelName,
-  ModelName: ModelName ?? capitalize5(modelName),
+  ModelName: ModelName ?? capitalize6(modelName),
   exampleFiles,
   constant,
   properties
@@ -13362,7 +13885,7 @@ var requestUnit = ({
 	`;
 
 // pkgs/@akanjs/cli/module/module.runner.ts
-import { capitalize as capitalize6 } from "akanjs/common";
+import { capitalize as capitalize7 } from "akanjs/common";
 class ModuleRunner extends runner("module") {
   async createService(module) {
     const serviceName = module.name.replace(/^_+/, "");
@@ -13392,13 +13915,13 @@ class ModuleRunner extends runner("module") {
   async createComponentTemplate(module, type) {
     await module.sys.applyTemplate({
       basePath: `./lib/${module.name}`,
-      template: `module/__Model__.${capitalize6(type)}.tsx`,
+      template: `module/__Model__.${capitalize7(type)}.tsx`,
       dict: { model: module.name, appName: module.sys.name }
     });
     return {
       component: {
-        filename: `${module.name}.${capitalize6(type)}.tsx`,
-        content: await module.sys.readFile(`lib/${module.name}/${capitalize6(module.name)}.${capitalize6(type)}.tsx`)
+        filename: `${module.name}.${capitalize7(type)}.tsx`,
+        content: await module.sys.readFile(`lib/${module.name}/${capitalize7(module.name)}.${capitalize7(type)}.tsx`)
       }
     };
   }
@@ -13524,7 +14047,7 @@ class ModuleScript extends script("module", [ModuleRunner, PageScript]) {
   async createTemplate(mod) {
     const { component: template } = await this.moduleRunner.createComponentTemplate(mod, "template");
     const templateExampleFiles = (await mod.sys.getTemplatesSourceCode()).filter((f) => !f.filePath.includes(`${mod.name}.Template.tsx`));
-    const Name = capitalize7(mod.name);
+    const Name = capitalize8(mod.name);
     const relatedCnsts = getRelatedCnsts(`${mod.sys.cwdPath}/lib/${mod.name}/${mod.name}.constant.ts`);
     const constant = await FileSys.readText(`${mod.sys.cwdPath}/lib/${mod.name}/${mod.name}.constant.ts`);
     const session = new AiSession("createTemplate", { workspace: mod.sys.workspace, cacheKey: mod.name });
@@ -13543,7 +14066,7 @@ class ModuleScript extends script("module", [ModuleRunner, PageScript]) {
   }
   async createUnit(mod) {
     const { component: unit } = await this.moduleRunner.createComponentTemplate(mod, "unit");
-    const Name = capitalize7(mod.name);
+    const Name = capitalize8(mod.name);
     const unitExampleFiles = (await mod.sys.getUnitsSourceCode()).filter((f) => !f.filePath.includes(`${mod.name}.Unit.tsx`));
     const relatedCnsts = getRelatedCnsts(`${mod.sys.cwdPath}/lib/${mod.name}/${mod.name}.constant.ts`);
     const constant = await FileSys.readText(`${mod.sys.cwdPath}/lib/${mod.name}/${mod.name}.constant.ts`);
@@ -13564,7 +14087,7 @@ class ModuleScript extends script("module", [ModuleRunner, PageScript]) {
   async createView(mod) {
     const { component: view } = await this.moduleRunner.createComponentTemplate(mod, "view");
     const viewExampleFiles = (await mod.sys.getViewsSourceCode()).filter((f) => !f.filePath.includes(`${mod.name}.View.tsx`));
-    const Name = capitalize7(mod.name);
+    const Name = capitalize8(mod.name);
     const relatedCnsts = getRelatedCnsts(`${mod.sys.cwdPath}/lib/${mod.name}/${mod.name}.constant.ts`);
     const constant = await FileSys.readText(`${mod.sys.cwdPath}/lib/${mod.name}/${mod.name}.constant.ts`);
     const session = new AiSession("createView", { workspace: mod.sys.workspace, cacheKey: mod.name });
@@ -13841,11 +14364,11 @@ class ScalarCommand extends command("scalar", [ScalarScript], ({ public: target
 }
 
 // pkgs/@akanjs/cli/workspace/workspace.script.ts
-import path42 from "path";
+import path44 from "path";
 import { Logger as Logger20 } from "akanjs/common";
 
 // pkgs/@akanjs/cli/workspace/workspace.runner.ts
-import path41 from "path";
+import path43 from "path";
 var defaultWorkspacePeerDependencies = new Set([
   "@react-spring/web",
   "@use-gesture/react",
@@ -13893,10 +14416,10 @@ class WorkspaceRunner extends runner("workspace") {
     init = true,
     akanVersion,
     registryUrl,
-    owner
+    owner = ""
   }) {
     const cwdPath = process.cwd();
-    const workspaceRoot = path41.join(cwdPath, dirname2, repoName);
+    const workspaceRoot = path43.join(cwdPath, dirname2, repoName);
     const normalizedRegistryUrl = registryUrl ? getNpmRegistryUrl(registryUrl) : undefined;
     const workspace = WorkspaceExecutor.fromRoot({ workspaceRoot, repoName });
     const templateSpinner = workspace.spinning(`Creating workspace template files in ${dirname2}/${repoName}...`);
@@ -13907,7 +14430,7 @@ class WorkspaceRunner extends runner("workspace") {
     await workspace.applyTemplate({
       basePath: ".",
       template: "workspaceRoot",
-      dict: { repoName, appName, serveDomain: "localhost" }
+      dict: { repoName, appName, serveDomain: "localhost", owner }
     });
     if (normalizedRegistryUrl)
       await workspace.writeFile(".npmrc", `registry=${normalizedRegistryUrl}/
@@ -13952,9 +14475,9 @@ class WorkspaceRunner extends runner("workspace") {
   }
   async#getCliPackageJson() {
     const packageJsonCandidates = [
-      path41.join(import.meta.dir, "../package.json"),
-      path41.join(import.meta.dir, "package.json"),
-      path41.join(path41.dirname(Bun.main), "package.json")
+      path43.join(import.meta.dir, "../package.json"),
+      path43.join(import.meta.dir, "package.json"),
+      path43.join(path43.dirname(Bun.main), "package.json")
     ];
     try {
       packageJsonCandidates.unshift(Bun.resolveSync("@akanjs/cli/package.json", import.meta.dir));
@@ -13970,9 +14493,9 @@ class WorkspaceRunner extends runner("workspace") {
   }
   async#getAkanPackageJson() {
     const packageJsonCandidates = [
-      path41.join(import.meta.dir, "../../../akanjs/package.json"),
-      path41.join(process.cwd(), "pkgs/akanjs/package.json"),
-      path41.join(path41.dirname(Bun.main), "node_modules/akanjs/package.json")
+      path43.join(import.meta.dir, "../../../akanjs/package.json"),
+      path43.join(process.cwd(), "pkgs/akanjs/package.json"),
+      path43.join(path43.dirname(Bun.main), "node_modules/akanjs/package.json")
     ];
     try {
       packageJsonCandidates.unshift(Bun.resolveSync("akanjs/package.json", import.meta.dir));
@@ -13986,13 +14509,13 @@ class WorkspaceRunner extends runner("workspace") {
     }
     let current = import.meta.dir;
     for (let depth = 0;depth < 6; depth++) {
-      const packageJsonPath = path41.join(current, "package.json");
+      const packageJsonPath = path43.join(current, "package.json");
       if (await Bun.file(packageJsonPath).exists()) {
         const packageJson = await FileSys.readJson(packageJsonPath);
         if (packageJson.name === "akanjs")
           return packageJson;
       }
-      const parent = path41.dirname(current);
+      const parent = path43.dirname(current);
       if (parent === current)
         break;
       current = parent;
@@ -14069,7 +14592,7 @@ class WorkspaceScript extends script("workspace", [
     } catch (_) {
       gitSpinner.fail("Git repository initialization failed. It's not fatal, you can commit manually");
     }
-    const workspacePath = path42.join(dirname2, repoName);
+    const workspacePath = path44.join(dirname2, repoName);
     Logger20.rawLog(`
 \uD83C\uDF89 Welcome aboard! Workspace created in ${dirname2}/${repoName}`);
     Logger20.rawLog(`\uD83D\uDE80 Run \`cd ${workspacePath} && akan start ${appName}\` to start the development server.`);
@@ -14160,9 +14683,15 @@ class WorkspaceCommand extends command("workspace", [WorkspaceScript], ({ public
     desc: "owner of the workspace",
     default: process.env.GITHUB_OWNER,
     nullable: true
-  }).exec(async function(workspaceName, app, dir, libs, init, registry) {
+  }).exec(async function(workspaceName, app, dir, libs, init, registry, owner) {
     const appName = app || "app";
-    await this.workspaceScript.createWorkspace(workspaceName.toLowerCase().replace(/ /g, "-"), appName.toLowerCase().replace(/ /g, "-"), { dirname: dir, installLibs: libs, init, ...registry ? { registryUrl: registry } : {} });
+    await this.workspaceScript.createWorkspace(workspaceName.toLowerCase().replace(/ /g, "-"), appName.toLowerCase().replace(/ /g, "-"), {
+      dirname: dir,
+      installLibs: libs,
+      init,
+      owner,
+      ...registry ? { registryUrl: registry } : {}
+    });
   }),
   generateAgentRules: target({ desc: "Generate AGENTS.md and optional Cursor rules for Akan coding agents" }).option("overwrite", Boolean, { desc: "Overwrite existing agent rule files", default: false }).option("cursorRules", Boolean, { desc: "Generate .cursor/rules/akan.mdc", default: true }).with(Workspace).exec(async function(overwrite, cursorRules, workspace) {
     await this.workspaceScript.generateAgentRules(workspace, { overwrite, cursorRules });