@akanjs/cli 3.0.0-beta.18 → 3.0.0-beta.19

package/{index-h94faz96.js → index-bftkz6cp.js}

@@ -2,16 +2,16 @@
 import {
   runner,
   script
-} from "./index-ycy302an.js";
+} from "./index-qdgzsnhg.js";
 import {
   WorkspaceExecutor,
   AppExecutor,
   LibExecutor,
   PkgExecutor
-} from "./index-bwxpk2cj.js";
+} from "./index-crmeqnmf.js";
 import {
   LibraryScript
-} from "./index-6q589y9t.js";
+} from "./index-7ep8qtvp.js";
 import {
   HmrWatcher,
   WatchRootResolver
@@ -22,7 +22,7 @@ import {
 import {
   SlicePlanner,
   formatSlicePlan
-} from "./index-4r42ext5.js";
+} from "./index-kwaq3n9n.js";
 import {
   resolveMobileTargets
 } from "./index-47pj3aee.js";
@@ -1344,16 +1344,18 @@ ${this.#backendStderrTail.join(`
     this.#recycleBuilderForRss(settledBytes === null ? reason : `${reason}; still ${asMib(settledBytes)}MiB after settling`);
   }
   static async readProcessRssBytes(pid) {
+    if (process.platform === "win32")
+      return await AkanAppHost.#readRssKbVia(["tasklist", "/FI", `PID eq ${pid}`, "/FO", "CSV", "/NH"], AkanAppHost.#tasklistRssKb);
     const status = await Bun.file(`/proc/${pid}/status`).text().catch(() => null);
     const vmRssKb = status === null ? null : /VmRSS:\s+(\d+) kB/.exec(status)?.[1];
     if (vmRssKb)
       return Number(vmRssKb) * 1024;
-    return await AkanAppHost.#readRssViaPs(pid);
+    return await AkanAppHost.#readRssKbVia(["ps", "-o", "rss=", "-p", String(pid)], (output) => Number(output.trim()));
   }
-  static async#readRssViaPs(pid, timeoutMs = PS_RSS_TIMEOUT_MS) {
+  static async#readRssKbVia(command, parseKb, timeoutMs = PS_RSS_TIMEOUT_MS) {
     let proc;
     try {
-      proc = Bun.spawn(["ps", "-o", "rss=", "-p", String(pid)], { stdio: ["ignore", "pipe", "ignore"] });
+      proc = Bun.spawn(command, { stdio: ["ignore", "pipe", "ignore"] });
     } catch {
       return null;
     }
@@ -1361,7 +1363,7 @@ ${this.#backendStderrTail.join(`
     try {
       const output = await new Response(proc.stdout).text();
       await proc.exited;
-      const rssKb = Number(output.trim());
+      const rssKb = parseKb(output);
       return Number.isFinite(rssKb) && rssKb > 0 ? rssKb * 1024 : null;
     } catch {
       return null;
@@ -1369,6 +1371,10 @@ ${this.#backendStderrTail.join(`
       clearTimeout(killer);
     }
   }
+  static #tasklistRssKb(output) {
+    const memUsage = /"([^"]*)"\s*$/m.exec(output)?.[1];
+    return memUsage ? Number(memUsage.replace(/\D/g, "")) : Number.NaN;
+  }
   #cancelRssRecycle() {
     this.#rssRecycleReason = null;
     this.#rssRecycleOver = null;
@@ -1959,9 +1965,9 @@ ${uniqueCandidates.map((candidate) => `  - ${candidate}`).join(`
 
 // pkgs/@akanjs/cli/application/application.runner.ts
 import { Logger as Logger4 } from "akanjs/common";
-var loadBuildRunner = async () => (await import("./applicationBuildRunner-m0hhgwsx.js")).ApplicationBuildRunner;
-var loadReleasePackager = async () => (await import("./applicationReleasePackager-vykfzgx3.js")).ApplicationReleasePackager;
-var loadCapacitorApp = async () => (await import("./capacitorApp-2daqhb5h.js")).CapacitorApp;
+var loadBuildRunner = async () => (await import("./applicationBuildRunner-n9gzaxd0.js")).ApplicationBuildRunner;
+var loadReleasePackager = async () => (await import("./applicationReleasePackager-vpggfqgq.js")).ApplicationReleasePackager;
+var loadCapacitorApp = async () => (await import("./capacitorApp-q3z0qht0.js")).CapacitorApp;
 var loadPrompts = async () => await import("@inquirer/prompts");
 
 class ApplicationRunner extends runner("application") {
@@ -2004,7 +2010,7 @@ class ApplicationRunner extends runner("application") {
     if (!await app.exists(scriptPath))
       throw new Error(`Script file not found: apps/${app.name}/${scriptPath}`);
     await app.spawn("bun", [scriptPath], {
-      env: app.getCommandEnv({ AKAN_COMMAND_TYPE: "script" }),
+      env: app.getCommandEnv({ AKAN_COMMAND_TYPE: "script", ...await app.getDatabaseModeEnv() }),
       stdio: "inherit"
     });
   }
@@ -2095,7 +2101,29 @@ try {
 }
 `;
     await app.spawn("bun", ["-e", code], {
-      env: app.getCommandEnv({ AKAN_COMMAND_TYPE: "console" }),
+      env: app.getCommandEnv({ AKAN_COMMAND_TYPE: "console", ...await app.getDatabaseModeEnv() }),
+      stdio: "inherit"
+    });
+  }
+  async transferDatabase(app, direction, dir) {
+    const serverPath = `${app.cwdPath}/server.ts`;
+    if (!await app.exists("server.ts"))
+      throw new Error(`Server file not found: apps/${app.name}/server.ts`);
+    const target = path5.resolve(app.workspace.workspaceRoot, dir);
+    const code = `
+const { server } = await import(${JSON.stringify(serverPath)});
+const { DatabaseAdaptorRole, DocumentTransfer } = await import("akanjs/service");
+await server.start({ listen: false, web: false });
+try {
+  const transfer = new DocumentTransfer(server.get(DatabaseAdaptorRole));
+  const reports = await transfer.${direction === "export" ? "exportTo" : "importFrom"}(${JSON.stringify(target)});
+  for (const { table, rows } of reports) console.info(\`${direction === "export" ? "exported" : "imported"} \${table}: \${rows} rows\`);
+} finally {
+  await server.stop();
+}
+`;
+    await app.spawn("bun", ["-e", code], {
+      env: app.getCommandEnv({ AKAN_COMMAND_TYPE: "script", ...await app.getDatabaseModeEnv() }),
       stdio: "inherit"
     });
   }
@@ -2255,9 +2283,15 @@ try {
     if (mode === "single")
       return [];
     if (mode === "multiple")
-      return ["redis", "libsql"];
+      return ["redis"];
     return ["redis", "postgres"];
   }
+  async#assertComposeHas(workspace, services) {
+    const compose = Bun.YAML.parse(await Bun.file(`${workspace.workspaceRoot}/local/docker-compose.yaml`).text());
+    const missing = services.filter((service) => !compose?.services?.[service]);
+    if (missing.length)
+      throw new Error(`local/docker-compose.yaml declares no ${missing.join(" or ")} service. Add it, or move the file aside so the next akan dbup writes the current template.`);
+  }
   async#isLocalDatabaseUp(workspace, mode) {
     const requiredServices = this.#getLocalDatabaseServices(mode);
     if (!requiredServices.length)
@@ -2271,16 +2305,18 @@ try {
   async dbup(workspace, mode = "multiple") {
     if (mode === "single")
       return true;
+    const services = this.#getLocalDatabaseServices(mode);
+    await workspace.applyTemplate({
+      basePath: "local",
+      template: "localDev",
+      dict: { repoName: workspace.repoName },
+      overwrite: false
+    });
+    await this.#assertComposeHas(workspace, services);
     try {
-      await workspace.applyTemplate({
-        basePath: "local",
-        template: "localDev",
-        dict: { repoName: workspace.repoName },
-        overwrite: false
-      });
       const wasAlreadyUp = await this.#isLocalDatabaseUp(workspace, mode);
       if (!wasAlreadyUp)
-        await workspace.spawn(`docker`, ["compose", "up", "-d", ...this.#getLocalDatabaseServices(mode)], {
+        await workspace.spawn(`docker`, ["compose", "up", "-d", ...services], {
           cwd: `${workspace.workspaceRoot}/local`
         });
       return wasAlreadyUp;
@@ -2341,9 +2377,187 @@ ${detail}`
   }
 }
 
+// pkgs/@akanjs/cli/application/hostProcessProbe.ts
+import { readdirSync, readFileSync, readlinkSync } from "fs";
+
+class HostProcessProbe {
+  static timeoutMs = 3000;
+  static win32TimeoutMs = 20000;
+  static #procTcpListen = "0A";
+  static #win32ProcessQuery = "[Console]::OutputEncoding=[Text.Encoding]::UTF8; Get-CimInstance Win32_Process | Select-Object ProcessId,ParentProcessId,CommandLine,CreationDate | ConvertTo-Json -Compress";
+  platform;
+  #win32Table = null;
+  constructor(platform = process.platform) {
+    this.platform = platform;
+  }
+  async listenersOn(port) {
+    if (this.platform === "win32")
+      return HostProcessProbe.parseNetstat(await HostProcessProbe.run(["netstat", "-ano"]), port);
+    if (this.platform === "linux")
+      return HostProcessProbe.#procListenersOn(port);
+    const output = await HostProcessProbe.run(["lsof", "-ti", `tcp:${port}`, "-sTCP:LISTEN"]);
+    return [
+      ...new Set(output.split(`
+`).map((line) => Number(line.trim())).filter((pid) => Number.isInteger(pid) && pid > 0))
+    ];
+  }
+  async parentOf(pid) {
+    if (this.platform === "win32") {
+      const child = await this.#win32Process(pid);
+      const parent = child ? await this.#win32Process(child.ppid) : null;
+      return child && parent ? HostProcessProbe.parentPidOf(child, parent) : null;
+    }
+    if (this.platform === "linux") {
+      const stat = HostProcessProbe.#readProc(pid, "stat");
+      return stat === null ? null : HostProcessProbe.parseProcStatPpid(stat);
+    }
+    const parsed = Number((await HostProcessProbe.run(["ps", "-p", String(pid), "-o", "ppid="])).trim());
+    return Number.isInteger(parsed) && parsed > 0 ? parsed : null;
+  }
+  async commandOf(pid) {
+    if (this.platform === "win32")
+      return (await this.#win32Process(pid))?.command ?? null;
+    if (this.platform === "linux") {
+      const cmdline = HostProcessProbe.#readProc(pid, "cmdline");
+      return cmdline?.split("\x00").filter(Boolean).join(" ") || null;
+    }
+    return (await HostProcessProbe.run(["ps", "-ww", "-p", String(pid), "-o", "command="])).trim() || null;
+  }
+  static parentPidOf(child, parent) {
+    if (child.ppid !== parent.pid)
+      return null;
+    if (parent.startedAt !== null && child.startedAt !== null && parent.startedAt > child.startedAt)
+      return null;
+    return parent.pid;
+  }
+  static parseNetstat(output, port) {
+    const pids = new Set;
+    for (const line of output.split(/\r?\n/)) {
+      const fields = line.trim().split(/\s+/);
+      if (fields[0] !== "TCP" || fields.length < 5)
+        continue;
+      const [, local, remote] = fields;
+      if (!local?.endsWith(`:${port}`) || !remote?.endsWith(":0"))
+        continue;
+      const pid = Number(fields.at(-1));
+      if (Number.isInteger(pid) && pid > 0)
+        pids.add(pid);
+    }
+    return [...pids];
+  }
+  static parseProcNetTcp(text, port) {
+    const inodes = [];
+    for (const line of text.split(`
+`).slice(1)) {
+      const fields = line.trim().split(/\s+/);
+      const [, local, , state, , , , , , inode] = fields;
+      if (!local || !inode || state !== HostProcessProbe.#procTcpListen || inode === "0")
+        continue;
+      if (Number.parseInt(local.slice(local.lastIndexOf(":") + 1), 16) === port)
+        inodes.push(inode);
+    }
+    return inodes;
+  }
+  static parseProcStatPpid(stat) {
+    const ppid = Number(stat.slice(stat.lastIndexOf(")") + 2).split(" ")[1]);
+    return Number.isInteger(ppid) && ppid > 0 ? ppid : null;
+  }
+  static parseWin32Processes(json) {
+    const table = new Map;
+    let parsed;
+    try {
+      parsed = JSON.parse(json.trim() || "[]");
+    } catch {
+      return table;
+    }
+    const rows = Array.isArray(parsed) ? parsed : [parsed];
+    for (const row of rows) {
+      if (typeof row?.ProcessId !== "number")
+        continue;
+      table.set(row.ProcessId, {
+        pid: row.ProcessId,
+        ppid: row.ParentProcessId ?? 0,
+        command: row.CommandLine?.trim() || null,
+        startedAt: HostProcessProbe.#parseCimDate(row.CreationDate)
+      });
+    }
+    return table;
+  }
+  static async run(command, timeoutMs = HostProcessProbe.timeoutMs) {
+    let proc;
+    try {
+      proc = Bun.spawn(command, { stdio: ["ignore", "pipe", "ignore"], windowsHide: true });
+    } catch {
+      return "";
+    }
+    const timer = setTimeout(() => proc.kill("SIGKILL"), timeoutMs);
+    try {
+      return await new Response(proc.stdout).text();
+    } catch {
+      return "";
+    } finally {
+      clearTimeout(timer);
+    }
+  }
+  async#win32Process(pid) {
+    this.#win32Table ??= await HostProcessProbe.#queryWin32Processes();
+    if (!this.#win32Table.has(pid))
+      this.#win32Table = await HostProcessProbe.#queryWin32Processes();
+    return this.#win32Table.get(pid) ?? null;
+  }
+  static async#queryWin32Processes() {
+    const output = await HostProcessProbe.run(["powershell", "-NoProfile", "-NonInteractive", "-Command", HostProcessProbe.#win32ProcessQuery], HostProcessProbe.win32TimeoutMs);
+    return HostProcessProbe.parseWin32Processes(output);
+  }
+  static #parseCimDate(value) {
+    if (!value)
+      return null;
+    const legacy = /\/Date\((\d+)/.exec(value)?.[1];
+    const ms = legacy ? Number(legacy) : Date.parse(value);
+    return Number.isFinite(ms) ? ms : null;
+  }
+  static #procListenersOn(port) {
+    const inodes = new Set(["tcp", "tcp6"].flatMap((table) => HostProcessProbe.parseProcNetTcp(HostProcessProbe.#readProc("net", table) ?? "", port)));
+    if (!inodes.size)
+      return [];
+    const pids = [];
+    for (const entry of HostProcessProbe.#listDir("/proc")) {
+      if (!/^\d+$/.test(entry))
+        continue;
+      const holds = HostProcessProbe.#listDir(`/proc/${entry}/fd`).some((fd) => {
+        const inode = /^socket:\[(\d+)\]$/.exec(HostProcessProbe.#readLink(`/proc/${entry}/fd/${fd}`))?.[1];
+        return !!inode && inodes.has(inode);
+      });
+      if (holds)
+        pids.push(Number(entry));
+    }
+    return pids;
+  }
+  static #readProc(pid, file) {
+    try {
+      return readFileSync(`/proc/${pid}/${file}`, "utf8");
+    } catch {
+      return null;
+    }
+  }
+  static #listDir(dir) {
+    try {
+      return readdirSync(dir);
+    } catch {
+      return [];
+    }
+  }
+  static #readLink(link) {
+    try {
+      return readlinkSync(link);
+    } catch {
+      return "";
+    }
+  }
+}
+
 // pkgs/@akanjs/cli/application/devPortReclaimer.ts
 class DevPortReclaimer {
-  static lsofTimeoutMs = 3000;
   static releaseTimeoutMs = 8000;
   static maxAncestorDepth = 8;
   static #releasePollMs = 100;
@@ -2352,7 +2566,12 @@ class DevPortReclaimer {
     return [...new Set(ports.flatMap((port) => [port, port + DevPortReclaimer.wsPortOffset]))].sort((left, right) => left - right);
   }
   static isAkanCommand(command) {
-    return /(^|\/)akan(\s|$)/.test(command) || command.includes("@akanjs/cli") || command.includes("akanjs/server") || /\bapps\/[^/\s]+\/main\.ts\b/.test(command) || command.includes("incrementalBuilder.proc") || command.includes("rscWorker");
+    const normalized = command.replaceAll("\\", "/");
+    return /(^|\/)akan(\.exe)?"?(\s|$)/.test(normalized) || normalized.includes("@akanjs/cli") || normalized.includes("akanjs/server") || /\bapps\/[^/\s]+\/main\.ts\b/.test(normalized) || normalized.includes("incrementalBuilder.proc") || normalized.includes("rscWorker");
+  }
+  #probe;
+  constructor(probe = new HostProcessProbe) {
+    this.#probe = probe;
   }
   async reclaim(ports) {
     const killed = [];
@@ -2377,10 +2596,10 @@ class DevPortReclaimer {
   }
   async holdersOf(port) {
     const holders = [];
-    for (const listenerPid of await this.#pidsOn(port)) {
+    for (const listenerPid of await this.#probe.listenersOn(port)) {
       if (listenerPid === process.pid || listenerPid === process.ppid)
         continue;
-      const command = await this.#commandOf(listenerPid);
+      const command = await this.#probe.commandOf(listenerPid);
       if (!command)
         continue;
       if (!DevPortReclaimer.isAkanCommand(command)) {
@@ -2395,44 +2614,37 @@ class DevPortReclaimer {
   async#akanRootOf(pid, command) {
     let root = { pid, command };
     for (let depth = 0;depth < DevPortReclaimer.maxAncestorDepth; depth += 1) {
-      const parentPid = await this.#ppidOf(root.pid);
+      const parentPid = await this.#probe.parentOf(root.pid);
       if (parentPid === null || parentPid <= 1 || parentPid === process.pid || parentPid === process.ppid)
         break;
-      const parentCommand = await this.#commandOf(parentPid);
+      const parentCommand = await this.#probe.commandOf(parentPid);
       if (!parentCommand || !DevPortReclaimer.isAkanCommand(parentCommand))
         break;
       root = { pid: parentPid, command: parentCommand };
     }
     return root;
   }
-  async#ppidOf(pid) {
-    const output = await this.#run(["ps", "-p", String(pid), "-o", "ppid="]);
-    const parsed = Number(output.trim());
-    return Number.isInteger(parsed) && parsed > 0 ? parsed : null;
-  }
-  async#pidsOn(port) {
-    const output = await this.#run(["lsof", "-ti", `tcp:${port}`, "-sTCP:LISTEN"]);
-    return [
-      ...new Set(output.split(`
-`).map((line) => Number(line.trim())).filter((pid) => Number.isInteger(pid) && pid > 0))
-    ];
-  }
-  async#commandOf(pid) {
-    const output = await this.#run(["ps", "-p", String(pid), "-o", "command="]);
-    return output.trim() || null;
-  }
   async#terminate(pid) {
+    if (this.#probe.platform === "win32") {
+      await HostProcessProbe.run(["taskkill", "/PID", String(pid), "/T", "/F"]);
+      return await this.#released(pid);
+    }
     if (!this.#signal(pid, "SIGTERM"))
       return !this.#alive(pid);
+    if (await this.#released(pid))
+      return true;
+    this.#signal(pid, "SIGKILL");
+    await Bun.sleep(DevPortReclaimer.#releasePollMs);
+    return !this.#alive(pid);
+  }
+  async#released(pid) {
     const deadline = Date.now() + DevPortReclaimer.releaseTimeoutMs;
     while (Date.now() < deadline) {
       if (!this.#alive(pid))
         return true;
       await Bun.sleep(DevPortReclaimer.#releasePollMs);
     }
-    this.#signal(pid, "SIGKILL");
-    await Bun.sleep(DevPortReclaimer.#releasePollMs);
-    return !this.#alive(pid);
+    return false;
   }
   #signal(pid, signal) {
     try {
@@ -2450,17 +2662,6 @@ class DevPortReclaimer {
       return error.code === "EPERM";
     }
   }
-  async#run(command) {
-    const proc = Bun.spawn(command, { stdio: ["ignore", "pipe", "ignore"] });
-    const timer = setTimeout(() => proc.kill("SIGKILL"), DevPortReclaimer.lsofTimeoutMs);
-    try {
-      return await new Response(proc.stdout).text();
-    } catch {
-      return "";
-    } finally {
-      clearTimeout(timer);
-    }
-  }
 }
 
 // pkgs/@akanjs/cli/application/devStreamView.ts
@@ -3175,7 +3376,7 @@ class ApplicationScript extends script("application", [ApplicationRunner, Librar
   async startOne(app, { open = false, dbup = true, stdio = "inherit", write = true, onDevEvent } = {}) {
     await app.scanSync({ write });
     const akanConfig = await app.getConfig();
-    const databaseMode = process.env.AKAN_DATABASE_MODE ?? akanConfig.defaultDatabaseMode ?? "single";
+    const databaseMode = akanConfig.resolveDatabaseMode();
     await this.syncDatabaseModeDependencies(app, akanConfig, databaseMode);
     if (app.getEnv() === "local" && dbup && databaseMode !== "single") {
       const wasDbAlreadyUp = await this.dbup(app.workspace, databaseMode);
@@ -3233,7 +3434,7 @@ class ApplicationScript extends script("application", [ApplicationRunner, Librar
       if (app.getEnv() !== "local")
         continue;
       const akanConfig = await app.getConfig();
-      const mode = process.env.AKAN_DATABASE_MODE ?? akanConfig.defaultDatabaseMode ?? "single";
+      const mode = akanConfig.resolveDatabaseMode();
       await this.syncDatabaseModeDependencies(app, akanConfig, mode);
       if (mode !== "single")
         modes.add(mode);
@@ -3321,6 +3522,19 @@ class ApplicationScript extends script("application", [ApplicationRunner, Librar
   async codepush(app, os) {
     await this.applicationRunner.codepush(app, os);
   }
+  async transferDatabase(app, direction, dir) {
+    await this.applicationRunner.transferDatabase(app, direction, dir);
+  }
+  async dbupDeclared(workspace, mode) {
+    const declared = mode ? [mode] : await Promise.all((await workspace.getApps()).map(async (appName) => (await AppExecutor.from(workspace, appName).getConfig()).database.modes)).then((modes) => [...new Set(modes.flat())]);
+    const needing = declared.filter((each) => each !== "single");
+    if (!needing.length) {
+      workspace.log("No app here declares a database mode that runs on local services; single needs none.");
+      return;
+    }
+    for (const each of needing)
+      await this.dbup(workspace, each);
+  }
   async dbup(workspace, mode = "multiple") {
     const spinner = workspace.spinning(`Starting local database (${mode})...`);
     const wasAlreadyUp = await this.applicationRunner.dbup(workspace, mode);
@@ -3344,7 +3558,7 @@ class ApplicationScript extends script("application", [ApplicationRunner, Librar
       await Promise.all(shares.map(async (share) => await share.close()));
     }, "Abandoning the tunnel release; the shares expire on their own.");
     await Promise.all(apps.map(async (app) => {
-      const { TunnelShare } = await import("./TunnelShare-r5tc2qk5.js");
+      const { TunnelShare } = await import("./TunnelShare-2j6s511d.js");
       const share = await TunnelShare.open(app, { workspace: app.workspace });
       shares.push(share);
       urls.set(app.name, share.url);

package/{index-kcxmv48c.js → index-bhtmj233.js}

@@ -10,7 +10,10 @@ import ignore from "ignore";
 import ts from "typescript";
 var testFileRegex = /\.(?:test|spec)\.[cm]?[tj]sx?$/;
 var skipDirs = ["node_modules", "dist", "build", ".git", ".next", "public", "ios", "android", "__fixtures__"];
-var isSkippedPath = (filePath) => skipDirs.some((dir) => filePath.includes(`/${dir}/`) || filePath.startsWith(`${dir}/`));
+var isSkippedPath = (filePath) => {
+  const posixPath = filePath.split(path.sep).join("/");
+  return skipDirs.some((dir) => posixPath.includes(`/${dir}/`) || posixPath.startsWith(`${dir}/`));
+};
 var builtinModuleSet = new Set([...builtinModules, ...builtinModules.map((mod) => `node:${mod}`)]);
 var stripShebang = (source) => source.replace(/^#!.*(?:\r?\n|$)/, "");
 

package/{index-m41ptvat.js → index-bwf965h6.js}

@@ -2,7 +2,7 @@
 import {
   runner,
   script
-} from "./index-ycy302an.js";
+} from "./index-qdgzsnhg.js";
 import {
   AGENT_BLOCK_START,
   AGENT_BLOCK_END,
@@ -13,14 +13,14 @@ import {
   CLAUDE_COMMENT_RULE,
   AppExecutor,
   LibExecutor
-} from "./index-bwxpk2cj.js";
+} from "./index-crmeqnmf.js";
 import {
   collectRecipeSources2,
   scanRecipes2
 } from "./index-by5gpp8x.js";
 import {
   AkanContextAnalyzer
-} from "./index-rpgxs245.js";
+} from "./index-18zybgkc.js";
 import {
   Prompter2
 } from "./index-s5rhm04y.js";