@akanjs/cli 3.0.0-beta.20 → 3.0.0-beta.21

package/index-hr5n7t4x.js

@@ -0,0 +1,465 @@
+// @bun
+// pkgs/@akanjs/devkit/mobile/mobileTarget.ts
+var trimSlashes = (value) => value.replace(/^\/+|\/+$/g, "");
+var getMobileTargets = async (app) => {
+  const config = await app.getConfig();
+  return Object.entries(config.mobile.targets).map(([name, target]) => ({ name, config: target }));
+};
+var getMobileTargetChoices = async (app) => {
+  const config = await app.getConfig();
+  const targetNames = Object.keys(config.mobile.targets);
+  if (targetNames.length > 0)
+    return targetNames;
+  return [...config.basePaths];
+};
+var resolveMobileTargetByBasePath = (targets, basePath) => {
+  const normalizedBasePath = trimSlashes(basePath);
+  const byBasePath = targets.find(({ config }) => config.basePath !== undefined && trimSlashes(config.basePath) === normalizedBasePath);
+  if (byBasePath)
+    return byBasePath;
+  const [template] = targets;
+  if (!template)
+    return;
+  return {
+    name: normalizedBasePath,
+    config: { ...template.config, name: normalizedBasePath, basePath: normalizedBasePath }
+  };
+};
+var resolveMobileTargets = async (app, selection) => {
+  const config = await app.getConfig();
+  const targets = await getMobileTargets(app);
+  if (targets.length === 0)
+    throw new Error(`No mobile targets configured for ${app.name}`);
+  if (!selection && targets.length === 1)
+    return targets;
+  if (!selection) {
+    const choices = await getMobileTargetChoices(app);
+    if (choices.length === 1)
+      return resolveMobileTargets(app, choices[0]);
+    throw new Error(`Multiple mobile targets found for ${app.name}. Pass --target <${choices.join("|")}|all>.`);
+  }
+  if (selection === "all") {
+    if (Object.keys(config.mobile.targets).length > 1)
+      return targets;
+    const basePaths = [...config.basePaths];
+    if (basePaths.length > 1) {
+      return basePaths.flatMap((basePath) => {
+        const resolved = resolveMobileTargetByBasePath(targets, basePath);
+        return resolved ? [resolved] : [];
+      });
+    }
+    return targets;
+  }
+  const target = targets.find((candidate) => candidate.name === selection);
+  if (target)
+    return [target];
+  const basePathTarget = resolveMobileTargetByBasePath(targets, selection);
+  if (basePathTarget && config.basePaths.has(trimSlashes(selection)))
+    return [basePathTarget];
+  const choices = await getMobileTargetChoices(app);
+  throw new Error(`Mobile target '${selection}' was not found. Available: ${choices.join(", ")}`);
+};
+var targetHtmlFilename = (target) => {
+  const basePath = trimSlashes(target.basePath ?? "");
+  return basePath ? `${basePath}.html` : "index.html";
+};
+
+// pkgs/@akanjs/devkit/mobile/nativeApp.ts
+import { mkdir as mkdir2 } from "fs/promises";
+import path4 from "path";
+
+// pkgs/@akanjs/devkit/mobile/nativeApi.ts
+import path from "path";
+
+class NativeApi {
+  static supportedMajor = 0;
+  static entryOf(appDir) {
+    const workspaceEntry = NativeApi.#resolve("@akanjs/native/api", appDir);
+    if (workspaceEntry)
+      return workspaceEntry;
+    const akanjsPackage = NativeApi.#resolve("akanjs/package.json", appDir);
+    if (!akanjsPackage)
+      throw new Error(`akanjs is not installed for ${appDir}; the native build ships inside it.`);
+    return path.join(path.dirname(akanjsPackage), "vendor", "@akanjs", "native", "packages", "cli", "src", "api.ts");
+  }
+  static async load(appDir) {
+    const entry = NativeApi.entryOf(appDir);
+    if (!await Bun.file(entry).exists())
+      throw new Error(`The installed akanjs has no native build at ${entry}; update akanjs.`);
+    const api = await import(entry);
+    const major = Number(api.API_VERSION.split(".")[0]);
+    if (major !== NativeApi.supportedMajor)
+      throw new Error(`The native build API is ${api.API_VERSION}, and this akan CLI speaks ${NativeApi.supportedMajor}.x; install matching versions of akanjs and @akanjs/cli.`);
+    return api;
+  }
+  static #resolve(specifier, from) {
+    try {
+      return Bun.resolveSync(specifier, from);
+    } catch {
+      return null;
+    }
+  }
+}
+
+// pkgs/@akanjs/devkit/mobile/nativeConfig.ts
+import path2 from "path";
+
+// pkgs/@akanjs/devkit/mobile/usageDescriptions.ts
+import { capitalize } from "akanjs/common";
+var iosUsageDescriptionKeys = {
+  cameraUsageDescription: ["NSCameraUsageDescription"],
+  photoAddUsageDescription: ["NSPhotoLibraryAddUsageDescription"],
+  photoUsageDescription: ["NSPhotoLibraryUsageDescription"],
+  contactsUsageDescription: ["NSContactsUsageDescription"],
+  locationAlwaysUsageDescription: ["NSLocationAlwaysAndWhenInUseUsageDescription", "NSLocationAlwaysUsageDescription"],
+  locationWhenInUseUsageDescription: ["NSLocationWhenInUseUsageDescription"],
+  microphoneUsageDescription: ["NSMicrophoneUsageDescription"],
+  speechRecognitionUsageDescription: ["NSSpeechRecognitionUsageDescription"]
+};
+var toIosInfoPlistUsageDescriptions = (descriptions) => Object.fromEntries(Object.entries(descriptions).flatMap(([key, value]) => {
+  const plistKeys = Object.hasOwn(iosUsageDescriptionKeys, key) ? iosUsageDescriptionKeys[key] : [`NS${capitalize(key)}`];
+  return plistKeys.map((plistKey) => [plistKey, value]);
+}));
+
+// pkgs/@akanjs/devkit/mobile/nativeConfig.ts
+class NativeConfig {
+  static basePlugins = [
+    "app",
+    "app-state",
+    "browser",
+    "opener",
+    "auth-session",
+    "device",
+    "dialog",
+    "keyboard",
+    "preferences",
+    "secure-storage",
+    "haptics"
+  ];
+  static builtinContributions = {
+    camera: {
+      permission: "camera",
+      plugins: ["camera"],
+      usageDescriptions: {
+        cameraUsageDescription: "$(PRODUCT_NAME) requires access to the camera to take photos.",
+        photoAddUsageDescription: "$(PRODUCT_NAME) requires access to the photo library to take photos.",
+        photoUsageDescription: "$(PRODUCT_NAME) requires access to the photo library to take photos."
+      }
+    },
+    contacts: { permission: "contacts" },
+    location: {
+      permission: "location",
+      plugins: ["geolocation"],
+      usageDescriptions: {
+        locationAlwaysUsageDescription: "$(PRODUCT_NAME) requires access to the location to get the user's location.",
+        locationWhenInUseUsageDescription: "$(PRODUCT_NAME) requires access to the location to get the user's location."
+      }
+    },
+    push: { permission: "push", plugins: ["push"] },
+    speech: { permission: "speech" }
+  };
+  static build({ appPath, target, webDir, contributions, locales }) {
+    const warnings = [];
+    const applied = (target.permissions ?? []).flatMap((permission) => {
+      const claimed = contributions.filter((contribution) => contribution.permission === permission);
+      const used = claimed.length ? claimed : [NativeConfig.builtinContributions[permission]];
+      if (!used.some((contribution) => contribution.plugins?.length))
+        warnings.push(`Permission '${permission}' has no native plugin yet; the app ships without it.`);
+      return used;
+    });
+    const abs = (relative) => path2.resolve(appPath, relative);
+    const plugins = [
+      ...new Set([
+        ...NativeConfig.basePlugins,
+        ...applied.flatMap((contribution) => contribution.plugins ?? []),
+        ...target.native?.plugins ?? []
+      ])
+    ];
+    const usageDescriptions = Object.fromEntries(Object.entries(toIosInfoPlistUsageDescriptions(Object.assign({}, ...applied.map((contribution) => contribution.usageDescriptions ?? {})))).map(([key, text]) => [key, text.replaceAll("$(PRODUCT_NAME)", target.appName)]));
+    const ios = NativeConfig.#compact({
+      infoPlist: NativeConfig.#merged(applied.map((c) => c.infoPlist), target.native?.ios?.infoPlist),
+      entitlements: NativeConfig.#merged(applied.map((c) => c.entitlements), target.native?.ios?.entitlements)
+    });
+    const manifest = [
+      ...[...new Set(applied.flatMap((c) => c.androidPermissions ?? []))].map((name) => `<uses-permission android:name="android.permission.${name}" />`),
+      ...[...new Set(applied.flatMap((c) => c.androidFeatures ?? []))].map((name) => `<uses-feature android:name="${name}" android:required="false" />`),
+      ...target.native?.android?.manifest ?? []
+    ];
+    const android = NativeConfig.#compact({
+      manifest,
+      application: target.native?.android?.application ?? [],
+      activity: target.native?.android?.activity ?? []
+    });
+    const resources = Object.entries(target.files ?? {}).map(([to, from]) => ({ from: abs(from), to }));
+    const native = NativeConfig.#compact({ ios, android, resources });
+    const googleServices = target.native?.android?.googleServices;
+    const config = {
+      app: {
+        id: target.appId,
+        name: target.appName,
+        fileName: target.fileName ?? NativeConfig.fileNameOf(path2.basename(appPath)),
+        version: target.version,
+        build: target.buildNum
+      },
+      web: { dir: webDir },
+      plugins,
+      capabilities: [
+        {
+          identifier: "app",
+          description: `The plugins ${target.appName} ships, each with its default permissions`,
+          permissions: plugins.map((plugin) => `${plugin}:default`)
+        }
+      ],
+      ...Object.keys(usageDescriptions).length ? { usageDescriptions } : {},
+      ...target.deepLinks?.schemes?.length || target.deepLinks?.domains?.length ? { deepLinks: NativeConfig.#deepLinks(target, locales) } : {},
+      ...native ? { native } : {},
+      android: { debugAppIdSuffix: ".debug", ...googleServices ? { googleServices: abs(googleServices) } : {} },
+      keyboard: { resize: "none" },
+      ...target.assets?.icon ? { icon: abs(target.assets.icon) } : {},
+      ...target.assets?.splash ? { splash: { image: abs(target.assets.splash) } } : {}
+    };
+    return { config, warnings };
+  }
+  static fileNameOf(name) {
+    return name.replace(/[^A-Za-z0-9._-]/g, "-").replace(/^[-.]+|[-.]+$/g, "") || "app";
+  }
+  static #compact(value) {
+    const kept = Object.entries(value).filter(([, entry]) => Array.isArray(entry) ? entry.length > 0 : entry && typeof entry === "object" ? Object.keys(entry).length > 0 : entry !== undefined);
+    return kept.length ? Object.fromEntries(kept) : undefined;
+  }
+  static #merged(contributed, own) {
+    return Object.assign({}, ...contributed, own);
+  }
+  static #deepLinks(target, locales) {
+    const basePath = target.basePath?.replace(/^\/+|\/+$/g, "");
+    const pathPrefixes = basePath ? locales.map((locale) => `/${locale}/${basePath}`) : undefined;
+    return {
+      ...target.deepLinks?.schemes?.length ? { schemes: target.deepLinks.schemes } : {},
+      ...target.deepLinks?.domains?.length ? { domains: target.deepLinks.domains.map((host) => pathPrefixes ? { host, pathPrefixes } : host) } : {}
+    };
+  }
+}
+
+// pkgs/@akanjs/devkit/mobile/nativeWebDir.ts
+import { cp, mkdir, rm, stat } from "fs/promises";
+import path3 from "path";
+
+class NativeWebDir {
+  dir;
+  static reservedEntry = "__akan_native";
+  constructor(dir) {
+    this.dir = dir;
+  }
+  static injectTarget(html, target) {
+    if (html.includes(NativeWebDir.#targetTag))
+      return html;
+    const basePath = target.basePath?.replace(/^\/+|\/+$/g, "") ?? "";
+    const script = `${NativeWebDir.#targetTag}${JSON.stringify({
+      name: target.name,
+      basePath,
+      indexPath: target.indexPath
+    })};</script>`;
+    const head = /<head(?:\s[^>]*)?>/i.exec(html);
+    if (!head)
+      return `${script}
+${html}`;
+    const at = head.index + head[0].length;
+    return `${html.slice(0, at)}
+${script}${html.slice(at)}`;
+  }
+  static #targetTag = "<script>window.__AKAN_MOBILE_TARGET__=";
+  async assemble(target, { html, publicDir, fontsDir }) {
+    if (!await Bun.file(html).exists())
+      throw new Error(`CSR html for mobile target '${target.name}' not found: ${html}`);
+    await rm(this.dir, { recursive: true, force: true });
+    await mkdir(this.dir, { recursive: true });
+    if (publicDir && await NativeWebDir.#isDir(publicDir))
+      await cp(publicDir, this.dir, { recursive: true });
+    if (fontsDir && await NativeWebDir.#isDir(fontsDir))
+      await cp(fontsDir, path3.join(this.dir, "_akan", "fonts"), { recursive: true });
+    if (await NativeWebDir.#isDir(path3.join(this.dir, NativeWebDir.reservedEntry)))
+      throw new Error(`public/${NativeWebDir.reservedEntry} is reserved for the native runtime.`);
+    await Bun.write(path3.join(this.dir, "index.html"), NativeWebDir.injectTarget(await Bun.file(html).text(), target));
+    const files = await Array.fromAsync(new Bun.Glob("**/*").scan({ cwd: this.dir, onlyFiles: true, dot: true }));
+    return files.map((file) => file.split(path3.sep).join("/")).sort();
+  }
+  static async#isDir(dir) {
+    try {
+      return (await stat(dir)).isDirectory();
+    } catch {
+      return false;
+    }
+  }
+}
+
+// pkgs/@akanjs/devkit/mobile/nativeApp.ts
+class NativeApp {
+  app;
+  target;
+  targetRoot;
+  web;
+  constructor(app, target) {
+    this.app = app;
+    this.target = target;
+    this.targetRoot = path4.join(app.cwdPath, ".akan", "mobile", target.name);
+    this.web = new NativeWebDir(path4.join(this.targetRoot, "web"));
+  }
+  outDir(platform) {
+    return path4.join(this.targetRoot, "native", platform);
+  }
+  async assembleWeb() {
+    const dist = this.app.dist.cwdPath;
+    return await this.web.assemble(this.target.config, {
+      html: path4.join(dist, "csr", targetHtmlFilename(this.target.config)),
+      publicDir: path4.join(dist, "public"),
+      fontsDir: path4.join(dist, ".akan", "artifact", "fonts")
+    });
+  }
+  async config() {
+    const [appConfig, plugins] = await Promise.all([this.app.getConfig(), this.app.collectPlugins()]);
+    return NativeConfig.build({
+      appPath: this.app.cwdPath,
+      target: this.target.config,
+      webDir: this.web.dir,
+      contributions: plugins.flatMap((plugin) => plugin.native ? [plugin.native] : []),
+      locales: appConfig.i18n.locales
+    });
+  }
+  async prepare() {
+    const [api, { config, warnings }] = await Promise.all([NativeApi.load(this.app.cwdPath), this.config()]);
+    for (const warning of warnings)
+      this.app.logger.warn(warning);
+    const problems = api.validateConfig(config, { appDir: this.app.cwdPath });
+    if (problems.length)
+      throw new Error(`Mobile target '${this.target.name}' makes an invalid native config:
+- ${problems.join(`
+- `)}`);
+    return { api, config };
+  }
+  #appLine = (line) => {
+    this.app.logger.info(`[${this.target.name}] ${line}`);
+  };
+  #task(platform, config) {
+    return {
+      appDir: this.app.cwdPath,
+      config,
+      platform,
+      outDir: this.outDir(platform),
+      envFiles: false,
+      skipWebBuild: true,
+      log: (event) => {
+        if (event.level === "error")
+          this.app.logger.error(event.message);
+        else if (event.level === "warn")
+          this.app.logger.warn(event.message);
+        else if (event.level === "tool")
+          this.app.logger.verbose(event.message);
+        else
+          this.app.logger.info(event.message);
+      }
+    };
+  }
+  async build(platform, { profile = "release" } = {}) {
+    await this.assembleWeb();
+    const { api, config } = await this.prepare();
+    return await api.build({ ...this.#task(platform, config), profile });
+  }
+  async run(platform, { device, teamId, profile = "debug" } = {}) {
+    await this.assembleWeb();
+    const { api, config } = await this.prepare();
+    return await api.run({
+      ...this.#task(platform, config),
+      profile,
+      onLine: this.#appLine,
+      ...device ? { device } : {},
+      ...teamId ? { ios: { signing: { teamId } } } : {}
+    });
+  }
+  async dev(platform, { upstream, lang, device, teamId }) {
+    await mkdir2(this.web.dir, { recursive: true });
+    const [{ api, config }, { api: routes }] = await Promise.all([this.prepare(), this.app.getConfig()]);
+    return await api.dev({
+      ...this.#task(platform, config),
+      upstream,
+      hmrPath: "/_akan/hmr",
+      wsPaths: [`${routes.prefix}${routes.websocketPrefix}`],
+      onLine: this.#appLine,
+      startPath: this.startPath(lang),
+      ...device ? { device } : {},
+      ...teamId ? { ios: { signing: { teamId } } } : {}
+    });
+  }
+  async releaseIos({ teamId, adHoc = false } = {}) {
+    await this.assembleWeb();
+    const { api, config } = await this.prepare();
+    return await api.release({
+      ...this.#task("ios", config),
+      platform: "ios",
+      signing: { ...teamId ? { teamId } : {}, ...adHoc ? { distribution: "ad-hoc" } : {} }
+    });
+  }
+  async releaseAndroid({ formats = ["aab"] } = {}) {
+    const signing = NativeApp.androidSigning();
+    await this.assembleWeb();
+    const { api, config } = await this.prepare();
+    return await api.release({ ...this.#task("android", config), platform: "android", signing, formats });
+  }
+  static androidSigning(env = process.env) {
+    const keystore = env.MYAPP_RELEASE_STORE_FILE;
+    const storePassword = env.MYAPP_RELEASE_STORE_PASSWORD;
+    const alias = env.MYAPP_RELEASE_KEY_ALIAS;
+    const keyPassword = env.MYAPP_RELEASE_KEY_PASSWORD;
+    if (!keystore || !storePassword || !alias) {
+      const missing = Object.entries({
+        MYAPP_RELEASE_STORE_FILE: keystore,
+        MYAPP_RELEASE_STORE_PASSWORD: storePassword,
+        MYAPP_RELEASE_KEY_ALIAS: alias
+      }).flatMap(([key, value]) => value ? [] : [key]);
+      throw new Error(`An Android release is signed with the upload key; set ${missing.join(", ")} in the environment.`);
+    }
+    return { keystore, storePassword, alias, ...keyPassword ? { keyPassword } : {} };
+  }
+  startPath(lang) {
+    const basePath = this.target.config.basePath?.replace(/^\/+|\/+$/g, "");
+    const params = new URLSearchParams({ csr: "true", akanMobileTarget: this.target.name });
+    if (basePath)
+      params.set("akanMobileBasePath", basePath);
+    if (this.target.config.indexPath)
+      params.set("akanMobileIndexPath", this.target.config.indexPath);
+    const home = [lang, basePath, this.target.config.indexPath].flatMap((part) => (part ?? "").split("/")).filter((segment) => segment.length > 0);
+    return `/${home.join("/")}?${params}`;
+  }
+  static desktopPlatform(host = process.platform) {
+    if (host === "darwin")
+      return "macos";
+    if (host === "win32")
+      return "windows";
+    if (host === "linux")
+      return "linux";
+    throw new Error(`A desktop app builds on macOS, Windows or Linux, not on ${host}.`);
+  }
+  static async devices(appDir, platform) {
+    return await (await NativeApi.load(appDir)).devices({ platform });
+  }
+  static async doctor(appDir, platforms) {
+    return await (await NativeApi.load(appDir)).doctor({ platforms });
+  }
+}
+
+// pkgs/@akanjs/devkit/mobile/placeholderAppId.ts
+var PLACEHOLDER_APP_IDS = [
+  "com.myapp.app",
+  "com.myorg.myapp",
+  "com.example.app",
+  "com.example.myapp"
+];
+var placeholderAppIdSegment = /^(example|examples|myorg|myapp|mycompany|myorganization|changeme|todo|sample|test)$/;
+var isPlaceholderAppId = (appId) => {
+  const normalized = appId?.trim().toLowerCase() ?? "";
+  if (!normalized)
+    return true;
+  if (PLACEHOLDER_APP_IDS.includes(normalized))
+    return true;
+  return normalized.split(".").some((segment) => placeholderAppIdSegment.test(segment));
+};
+export { getMobileTargets, getMobileTargetChoices, resolveMobileTargets, NativeApp, isPlaceholderAppId };

package/{index-xqpzbab5.js → index-m0ms3n1c.js}

@@ -22,26 +22,26 @@ import {
   renderWorkflowApply,
   renderWorkflowValidation,
   renderWorkflowRunArtifact
-} from "./index-myhc3c1j.js";
+} from "./index-yy4s1j72.js";
 import {
   AkanContextAnalyzer
-} from "./index-ygn77a5w.js";
+} from "./index-9629w7ns.js";
 import {
   CommandContainer,
   runner
-} from "./index-w2zdcw3k.js";
+} from "./index-rmcw8yc8.js";
 import {
   ModuleScript
-} from "./index-8mna0947.js";
+} from "./index-tgjy8xf3.js";
 import {
   PrimitiveScript
-} from "./index-przybvy5.js";
+} from "./index-wp43xrjv.js";
 import {
   spawnShell
-} from "./index-31yr441d.js";
+} from "./index-ya5qbmyg.js";
 import {
   ScalarScript
-} from "./index-3sq321ak.js";
+} from "./index-pp54p5zk.js";
 
 // pkgs/@akanjs/cli/workflow/workflow.runner.ts
 import { mkdir, readFile, writeFile } from "fs/promises";

package/{index-as7xmyz8.js → index-mgfx3mfs.js}

@@ -2,13 +2,13 @@
 import {
   runner,
   script
-} from "./index-w2zdcw3k.js";
+} from "./index-rmcw8yc8.js";
 import {
   FileSys2
 } from "./index-5b6tavv3.js";
 import {
   PkgExecutor
-} from "./index-9d9bgcx4.js";
+} from "./index-ga6hygxr.js";
 import {
   TypeScriptDependencyScanner2
 } from "./index-3t7g9e4r.js";
@@ -175,8 +175,9 @@ class PackageRunner extends runner("package") {
       ].filter((dep) => dep !== "akanjs" && dep !== "@akanjs/devkit");
     }
     const packageBundledRuntimeDependencies = {
-      "@akanjs/cli": ["@akanjs/devkit"],
-      akanjs: ["use-agentic"]
+      "@akanjs/cli": ["@akanjs/devkit", "@akanjs/native"],
+      "@akanjs/devkit": ["@akanjs/native"],
+      akanjs: ["use-agentic", "@akanjs/native"]
     };
     const bundledRuntimeDeps = new Set(packageBundledRuntimeDependencies[pkg.name] ?? []);
     const forcedRuntimeDeps = packageRuntimeDependencies[pkg.name] ?? [];

package/{index-3sq321ak.js → index-pp54p5zk.js}

@@ -2,12 +2,12 @@
 import {
   runner,
   script
-} from "./index-w2zdcw3k.js";
+} from "./index-rmcw8yc8.js";
 import {
   generatedFilesForSync,
   createPassedPrimitiveReport,
   scalarChangedFiles
-} from "./index-myhc3c1j.js";
+} from "./index-yy4s1j72.js";
 import {
   pluralizeName
 } from "./index-nz8prx9g.js";

package/{index-xqjwd384.js → index-q44jbw48.js}

@@ -1,7 +1,7 @@
 // @bun
 import {
   AppInfo
-} from "./index-9d9bgcx4.js";
+} from "./index-ga6hygxr.js";
 
 // pkgs/@akanjs/devkit/slicePlanner.ts
 class SlicePlanner {

package/{index-w2zdcw3k.js → index-rmcw8yc8.js}

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

package/{index-dzf3r49a.js → index-rnt66vym.js}

@@ -2,7 +2,7 @@
 import {
   runner,
   script
-} from "./index-w2zdcw3k.js";
+} from "./index-rmcw8yc8.js";
 
 // pkgs/@akanjs/cli/page/page.runner.ts
 class PageRunner extends runner("page") {

package/{index-8mna0947.js → index-tgjy8xf3.js}

@@ -2,10 +2,10 @@
 import {
   runner,
   script
-} from "./index-w2zdcw3k.js";
+} from "./index-rmcw8yc8.js";
 import {
   ModuleExecutor
-} from "./index-9d9bgcx4.js";
+} from "./index-ga6hygxr.js";
 import {
   sourceFile,
   moduleSourcePaths,
@@ -13,10 +13,10 @@ import {
   createPassedPrimitiveReport,
   bilingualLabelForField,
   bilingualDescriptionForField
-} from "./index-myhc3c1j.js";
+} from "./index-yy4s1j72.js";
 import {
   PageScript
-} from "./index-dzf3r49a.js";
+} from "./index-rnt66vym.js";
 import {
   pluralizeName
 } from "./index-nz8prx9g.js";

package/{index-xsjh6nzh.js → index-v5eayqqw.js}

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

package/{index-przybvy5.js → index-wp43xrjv.js}

@@ -1,12 +1,12 @@
 // @bun
 import {
   script
-} from "./index-w2zdcw3k.js";
+} from "./index-rmcw8yc8.js";
 import {
   AppExecutor,
   LibExecutor,
   ModuleExecutor
-} from "./index-9d9bgcx4.js";
+} from "./index-ga6hygxr.js";
 import {
   workflowStatus,
   compactDiagnostics,
@@ -41,10 +41,10 @@ import {
   hasSignalFactoryEntry,
   insertSignalFactoryEntry,
   addFieldUiPolicyForType
-} from "./index-myhc3c1j.js";
+} from "./index-yy4s1j72.js";
 import {
   ModuleScript
-} from "./index-8mna0947.js";
+} from "./index-tgjy8xf3.js";
 
 // pkgs/@akanjs/cli/primitive/primitive.script.ts
 import { capitalize, lowerlize } from "akanjs/common";

package/{index-31yr441d.js → index-ya5qbmyg.js}

@@ -5,13 +5,13 @@ import {
   writeGeneratedSyncState,
   createRepairReport,
   renderRepairReport
-} from "./index-myhc3c1j.js";
+} from "./index-yy4s1j72.js";
 import {
   AkanContextAnalyzer
-} from "./index-ygn77a5w.js";
+} from "./index-9629w7ns.js";
 import {
   runner
-} from "./index-w2zdcw3k.js";
+} from "./index-rmcw8yc8.js";
 
 // pkgs/@akanjs/cli/repair/repair.runner.ts
 var spawnShell = async (workspace, command) => await workspace.spawn("bash", ["-lc", command.startsWith("akan ") ? `bun run ${command}` : command], {