@kodycodes/cli 1.26.1 → 1.26.3

package/dist/dev-command-3LX234N6.js

@@ -0,0 +1,4900 @@
+import { createRequire as __createRequire } from 'node:module'; const require = __createRequire(import.meta.url);
+import {
+  appLogMarker,
+  buildLocalPackageContext,
+  createPackageAppEntrySource,
+  createPackageLocalRuntimeModuleSource,
+  devErrorHeader,
+  devRequestIdHeader,
+  runLocalPackageModule
+} from "./chunk-64XN367G.js";
+import {
+  forwardLocalGatewayFetchStream,
+  installMockFetchShimModules,
+  startLocalRuntimeBridge
+} from "./chunk-SXHULGL4.js";
+import {
+  BundleError,
+  bundleLocalUserModule,
+  createBundleError,
+  createRuntimeFlatAliasSource,
+  createWorkerdConfig,
+  formatBundleDiagnostic,
+  init,
+  localBundleOptions,
+  localExecuteGatewayFetchShimModuleName,
+  localWorkerModuleNames,
+  parse,
+  resolveLocalPackageGraph,
+  runSecretEnvVar,
+  runSecretHeader,
+  writePackageModuleFiles
+} from "./chunk-D55XPY3T.js";
+import {
+  ensureMockTarget
+} from "./chunk-XDCOWU5R.js";
+import {
+  packageMocksRelativePath,
+  resolveMockFetchGateway,
+  tryHandleMockGatewayFetchCall
+} from "./chunk-XOPPGRUP.js";
+import {
+  loadPackageManifest,
+  resolveExportModulePath,
+  resolvePackagePath
+} from "./chunk-64IM6G4Z.js";
+import {
+  StructuredCliError
+} from "./chunk-BPGY4IE7.js";
+import {
+  formatToolResult
+} from "./chunk-46IJPEID.js";
+import {
+  assertTokenSafeApiUrl,
+  callCapabilityProxy
+} from "./chunk-R4IUV5P5.js";
+import {
+  ensureWorkerdBinary,
+  userCacheDir
+} from "./chunk-BISUL7CE.js";
+import "./chunk-G4YN6XP5.js";
+import {
+  redact
+} from "./chunk-CASGRYOF.js";
+import "./chunk-G6LJWROP.js";
+import "./chunk-RTWUNV76.js";
+import "./chunk-RM34N3KI.js";
+import {
+  apiTokenEnvVar
+} from "./chunk-IHP6PV6X.js";
+import "./chunk-QHBCP4OB.js";
+
+// src/dev-command.ts
+import { access, mkdir as mkdir3, readFile as readFile4, rm as rm4, writeFile as writeFile4 } from "node:fs/promises";
+import { dirname as dirname3, join as join8, resolve as resolve7 } from "node:path";
+
+// src/credentialed-fetch-scan.ts
+var esModuleLexerReady = init();
+async function detectCredentialedFetchInSource(code, where = "source") {
+  await esModuleLexerReady;
+  const signals = [];
+  const seen = /* @__PURE__ */ new Set();
+  const push = (kind) => {
+    if (seen.has(kind)) return;
+    seen.add(kind);
+    signals.push({ kind, where });
+  };
+  const codeWithoutComments = stripCommentsForScan(code);
+  if (/\bcreateAuthenticatedFetch\b/.test(codeWithoutComments)) {
+    push("createAuthenticatedFetch");
+  }
+  if (/\bauthenticatedFetch\b/.test(codeWithoutComments)) {
+    push("authenticatedFetch");
+  }
+  try {
+    const [imports] = parse(code);
+    for (const im of imports) {
+      if (im.type === "dynamic") {
+        continue;
+      }
+      if (im.typeOnly === true) continue;
+      if (im.specifier !== "kody:runtime") continue;
+      const record = im;
+      const statementStart = record.importStart ?? record.ss;
+      const statementEnd = record.importEnd ?? record.se;
+      if (typeof statementStart !== "number" || typeof statementEnd !== "number") {
+        continue;
+      }
+      const statement = code.slice(statementStart, statementEnd);
+      if (/\bcredentials?\b/.test(statement)) {
+        push("credential_runtime");
+      }
+    }
+  } catch {
+  }
+  return signals;
+}
+function stripCommentsForScan(code) {
+  return code.replace(/\/\*[\s\S]*?\*\//g, (block) => block.replace(/[^\n]/g, " ")).replace(/(^|[^:])\/\/.*$/gm, "$1");
+}
+function formatCredentialedFetchKinds(signals) {
+  const kinds = [...new Set(signals.map((s) => s.kind))];
+  return kinds.map((kind) => {
+    switch (kind) {
+      case "createAuthenticatedFetch":
+        return "createAuthenticatedFetch";
+      case "authenticatedFetch":
+        return "authenticatedFetch";
+      case "credential_runtime":
+        return "credential()/credentials()";
+      default: {
+        const _exhaustive = kind;
+        return _exhaustive;
+      }
+    }
+  }).join(", ");
+}
+function mocksSuggestionDetail(input) {
+  if (input.signals.length === 0) return null;
+  const kinds = formatCredentialedFetchKinds(input.signals);
+  if (input.hasMocksFile) {
+    return `present (credentialed fetch detected: ${kinds})`;
+  }
+  return `suggested \u2014 package uses credentialed fetch (${kinds}); add .kody/mocks.ts so --target mock can MSW-match outbound requests (unmocked credentialed hops fail closed)`;
+}
+
+// src/package-app-dev.ts
+import { randomBytes } from "node:crypto";
+import { rmSync } from "node:fs";
+import { mkdir as mkdir2, mkdtemp, rm as rm3, writeFile as writeFile3 } from "node:fs/promises";
+import {
+  createServer,
+  request as httpRequest
+} from "node:http";
+import { tmpdir as tmpdir2 } from "node:os";
+import { join as join7, relative as relative4, resolve as resolve6, sep as sep3 } from "node:path";
+
+// src/dev/dev-assets.ts
+import * as esbuild2 from "esbuild";
+import { createHash } from "node:crypto";
+import { readFile, stat } from "node:fs/promises";
+import { join as join2, resolve as resolve2, sep } from "node:path";
+
+// src/dev/dev-bundler.ts
+import * as esbuild from "esbuild";
+import { join, resolve } from "node:path";
+function createDevBundler(input) {
+  const entry = resolve(input.entryPath);
+  const base = localBundleOptions(entry);
+  const options = {
+    ...base,
+    sourcemap: "external",
+    sourcesContent: false,
+    metafile: true,
+    // Never written (write: false); only anchors source map paths at the root.
+    outfile: join(input.root, "__kody_dev_bundle.js")
+  };
+  const paths = { workingDir: base.absWorkingDir, displayRoot: input.root };
+  let disposed = false;
+  let context3 = null;
+  return {
+    build: async () => {
+      let result;
+      try {
+        if (disposed) throw new Error("kody dev bundler was already disposed.");
+        context3 ??= esbuild.context(options);
+        result = await (await context3).rebuild();
+      } catch (error) {
+        throw createBundleError(input.entryPath, error, paths);
+      }
+      return readBundle(result, base.absWorkingDir, input.entryPath);
+    },
+    dispose: async () => {
+      disposed = true;
+      const current = context3;
+      context3 = null;
+      await (await current?.catch(() => null))?.dispose();
+    }
+  };
+}
+function bundleInputs(metafile, workingDir) {
+  return Object.keys(metafile?.inputs ?? {}).filter((path) => !path.includes("node_modules") && !path.includes(":")).map((path) => resolve(workingDir, path));
+}
+function readBundle(result, workingDir, entryPath) {
+  const outputs = result.outputFiles ?? [];
+  const js = outputs.find((file) => file.path.endsWith(".js"));
+  const map = outputs.find((file) => file.path.endsWith(".js.map"));
+  if (!js) {
+    throw new BundleError(`Could not bundle ${entryPath}: esbuild produced no output.`, []);
+  }
+  return {
+    code: js.text.replace(/\n\/\/# sourceMappingURL=\S+\s*$/, "\n"),
+    sourceMap: map?.text ?? null,
+    inputs: bundleInputs(result.metafile, workingDir)
+  };
+}
+
+// src/dev/dev-assets.ts
+var devAssetsPathPrefix = "/_assets/";
+var devVersionAssetName = "__version.json";
+var clientModuleHashLength = 16;
+function createDevClientBundler(input) {
+  const externals = input.externals ?? [];
+  const workingDir = process.cwd();
+  let disposed = false;
+  let context3 = null;
+  const createContext = () => esbuild2.context({
+    absWorkingDir: workingDir,
+    entryPoints: [resolve2(input.entryPath)],
+    bundle: true,
+    write: false,
+    metafile: true,
+    format: "esm",
+    platform: "browser",
+    target: "es2022",
+    sourcemap: "inline",
+    logLevel: "silent",
+    outfile: join2(input.root, "_assets", "client.js"),
+    plugins: externals.length > 0 ? [clientExternalsPlugin(externals)] : []
+  });
+  return {
+    build: async () => {
+      try {
+        if (disposed) throw new Error("kody dev bundler was already disposed.");
+        context3 ??= createContext();
+        const result = await (await context3).rebuild();
+        const code = result.outputFiles.find((file) => file.path.endsWith(".js"))?.text ?? "";
+        const hash = createHash("sha256").update(code).digest("base64url").slice(0, clientModuleHashLength);
+        return {
+          name: `client.${hash}.js`,
+          code,
+          inputs: bundleInputs(result.metafile, workingDir)
+        };
+      } catch (error) {
+        throw createBundleError(input.entryPath, error, {
+          workingDir,
+          displayRoot: input.root
+        });
+      }
+    },
+    dispose: async () => {
+      disposed = true;
+      const current = context3;
+      context3 = null;
+      await (await current?.catch(() => null))?.dispose();
+    }
+  };
+}
+function clientExternalsPlugin(externals) {
+  return {
+    name: "kody-dev-client-externals",
+    setup(build) {
+      build.onResolve(
+        { filter: /^[^./]/ },
+        (args) => externals.some(
+          (external) => args.path === external || args.path.startsWith(`${external}/`)
+        ) ? { path: args.path, external: true } : void 0
+      );
+    }
+  };
+}
+function parseDevAssetPath(pathname) {
+  if (!pathname.startsWith(devAssetsPathPrefix)) return null;
+  const encoded = pathname.slice(devAssetsPathPrefix.length);
+  if (!encoded) return null;
+  try {
+    return decodeURIComponent(encoded);
+  } catch {
+    return null;
+  }
+}
+function resolveDevAssetFile(assetsDir, relativePath) {
+  if (relativePath.includes("\0") || relativePath.startsWith("/")) return null;
+  const root = resolve2(assetsDir);
+  const file = resolve2(root, relativePath);
+  return file.startsWith(`${root}${sep}`) ? file : null;
+}
+async function serveDevAsset(input) {
+  const { req, res } = input;
+  if (req.method !== "GET" && req.method !== "HEAD") {
+    res.writeHead(405, { allow: "GET, HEAD", "cache-control": "no-store" });
+    res.end("Method not allowed\n");
+    return;
+  }
+  if (input.relativePath === devVersionAssetName) {
+    send(req, res, "application/json; charset=utf-8", JSON.stringify({
+      clientModuleUrl: input.clientModuleUrl,
+      assetBasePath: `${input.appBasePath}/_assets`,
+      publishedCommit: null
+    }));
+    return;
+  }
+  if (input.client && input.relativePath === input.client.name) {
+    send(req, res, "text/javascript; charset=utf-8", input.client.code);
+    return;
+  }
+  const file = input.assetsDir ? resolveDevAssetFile(input.assetsDir, input.relativePath) : null;
+  const body = file ? await readAssetFile(file) : null;
+  if (!file || !body) {
+    res.writeHead(404, {
+      "content-type": "text/plain; charset=utf-8",
+      "cache-control": "no-store"
+    });
+    res.end("Not found\n");
+    return;
+  }
+  const contentType = inferDevAssetContentType(file);
+  send(req, res, contentType, body, contentType.startsWith("text/javascript") ? { "service-worker-allowed": `${input.appBasePath}/` } : {});
+}
+async function readAssetFile(file) {
+  try {
+    if (!(await stat(file)).isFile()) return null;
+    return await readFile(file);
+  } catch {
+    return null;
+  }
+}
+function send(req, res, contentType, body, extraHeaders = {}) {
+  const bytes = typeof body === "string" ? Buffer.from(body, "utf8") : body;
+  res.writeHead(200, {
+    "content-type": contentType,
+    "content-length": String(bytes.length),
+    "cache-control": "no-store",
+    "x-content-type-options": "nosniff",
+    ...extraHeaders
+  });
+  res.end(req.method === "HEAD" ? void 0 : bytes);
+}
+var contentTypesByExtension = {
+  avif: "image/avif",
+  css: "text/css; charset=utf-8",
+  csv: "text/csv; charset=utf-8",
+  gif: "image/gif",
+  htm: "text/html; charset=utf-8",
+  html: "text/html; charset=utf-8",
+  ico: "image/x-icon",
+  jpeg: "image/jpeg",
+  jpg: "image/jpeg",
+  js: "text/javascript; charset=utf-8",
+  json: "application/json; charset=utf-8",
+  map: "application/json; charset=utf-8",
+  md: "text/markdown; charset=utf-8",
+  mjs: "text/javascript; charset=utf-8",
+  mp3: "audio/mpeg",
+  mp4: "video/mp4",
+  oga: "audio/ogg",
+  ogg: "audio/ogg",
+  ogv: "video/ogg",
+  otf: "font/otf",
+  pdf: "application/pdf",
+  png: "image/png",
+  svg: "image/svg+xml; charset=utf-8",
+  ttf: "font/ttf",
+  txt: "text/plain; charset=utf-8",
+  wasm: "application/wasm",
+  wav: "audio/wav",
+  webm: "video/webm",
+  webmanifest: "application/manifest+json; charset=utf-8",
+  webp: "image/webp",
+  woff: "font/woff",
+  woff2: "font/woff2",
+  xml: "application/xml; charset=utf-8"
+};
+function inferDevAssetContentType(path) {
+  const name = path.split(/[\\/]/).pop() ?? "";
+  const separator = name.lastIndexOf(".");
+  const extension = separator <= 0 ? "" : name.slice(separator + 1).toLowerCase();
+  return contentTypesByExtension[extension] ?? "application/octet-stream";
+}
+
+// src/dev/dev-events.ts
+var logLevels = /* @__PURE__ */ new Set(["log", "info", "warn", "error", "debug"]);
+function parseWorkerdStdoutLine(line) {
+  if (line.startsWith(appLogMarker)) {
+    try {
+      const parsed = JSON.parse(line.slice(appLogMarker.length));
+      const level = typeof parsed.level === "string" && logLevels.has(parsed.level) ? parsed.level : "log";
+      return {
+        type: "log",
+        source: "app",
+        level,
+        message: typeof parsed.message === "string" ? parsed.message : String(parsed.message),
+        request: readRequestTag(parsed.request)
+      };
+    } catch {
+    }
+  }
+  return { type: "log", source: "app", level: "log", message: line, request: null };
+}
+function readRequestTag(value) {
+  if (!value || typeof value !== "object") return null;
+  const record = value;
+  if (typeof record.id !== "string") return null;
+  return {
+    id: record.id,
+    method: typeof record.method === "string" ? record.method : "GET",
+    path: typeof record.path === "string" ? record.path : "/"
+  };
+}
+function runtimeErrorFix(message) {
+  const dynamicRequire = /Dynamic require of "([^"]+)" is not supported/.exec(message);
+  if (dynamicRequire) {
+    return `A CommonJS dependency calls require("${dynamicRequire[1]}"), which an ESM Worker cannot run (hosted apps fail the same way). It likely resolved to its Node build: import the package\u2019s Workers/edge entry (an exports subpath or condition like \`edge\`, \`worker\`, or \`workerd\`) or an ESM build instead.`;
+  }
+  return void 0;
+}
+function formatRequestTag(request) {
+  return request ? `[${request.method} ${request.path} #${request.id}]` : "[app]";
+}
+function formatDevEvent(event) {
+  switch (event.type) {
+    case "rebuild_start":
+      return {
+        stream: "stderr",
+        text: event.files.length > 0 ? `Rebuilding (${event.files.join(", ")})\u2026` : "Building\u2026"
+      };
+    case "rebuild_ok":
+      return {
+        stream: "stderr",
+        text: event.restarted ? `Ready in ${event.ms}ms (build ${event.buildId})` : `No bundle changes (${event.ms}ms)`
+      };
+    case "build_error":
+      return {
+        stream: "stderr",
+        text: `Build failed${event.diagnostics.length > 0 ? `:
+${event.diagnostics.map(formatBundleDiagnostic).join("\n")}` : `: ${event.message}`}
+The last good build is paused until this is fixed; requests get the error page.`
+      };
+    case "runtime_error":
+      return {
+        stream: "stderr",
+        text: `${formatRequestTag(event.request)} Uncaught ${event.stack || event.message}${event.fix ? `
+fix: ${event.fix}` : ""}`
+      };
+    case "log": {
+      const tag = event.source === "app" ? formatRequestTag(event.request) : `[${event.source}]`;
+      const level = event.level === "log" || event.level === "info" ? "" : `${event.level}: `;
+      const stream = event.level === "error" || event.level === "warn" ? "stderr" : "stdout";
+      return { stream, text: `${tag} ${level}${event.message}` };
+    }
+    default: {
+      const exhaustive = event;
+      throw new Error(`Unhandled dev event: ${JSON.stringify(exhaustive)}`);
+    }
+  }
+}
+
+// src/dev/dev-port.ts
+import { createHash as createHash2 } from "node:crypto";
+var devPortRange = { min: 4100, max: 4999 };
+var fallbackAttempts = 20;
+function defaultDevPort(kodyId) {
+  const span = devPortRange.max - devPortRange.min + 1;
+  const hash = createHash2("sha256").update(kodyId).digest();
+  return devPortRange.min + hash.readUInt32BE(0) % span;
+}
+function parseDevPort(raw) {
+  const port = /^\d+$/.test(raw.trim()) ? Number(raw) : Number.NaN;
+  if (!Number.isInteger(port) || port > 65535) {
+    throw new StructuredCliError({
+      code: "invalid_port",
+      message: `--port must be an integer from 0 to 65535 (got "${raw}").`,
+      fix: "Pass --port 0 for any free port, or omit --port to use this package\u2019s stable default."
+    });
+  }
+  return port;
+}
+async function listenDevServer(server, input) {
+  const attempts = input.explicit || input.port === 0 ? 1 : fallbackAttempts;
+  for (let attempt = 0; attempt < attempts; attempt += 1) {
+    const port = input.port === 0 ? 0 : wrapPort(input.port + attempt);
+    try {
+      await listenOnce(server, input.host, port);
+      return server.address().port;
+    } catch (error) {
+      if (!isAddressInUse(error)) throw error;
+      if (input.explicit) throw portInUseError(input.host, port);
+    }
+  }
+  throw new StructuredCliError({
+    code: "dev_port_in_use",
+    message: `Ports ${input.port}\u2013${wrapPort(input.port + attempts - 1)} on ${input.host} are all in use.`,
+    fix: "Stop old `kody dev` processes, or pass --port 0 for any free port."
+  });
+}
+function portInUseError(host, port) {
+  return new StructuredCliError({
+    code: "dev_port_in_use",
+    message: `Port ${port} on ${host} is already in use.`,
+    fix: `Find the owner with \`lsof -nP -iTCP:${port} -sTCP:LISTEN\` and stop it, pass another --port, or omit --port to use this package\u2019s default (it moves to the next free port automatically).`
+  });
+}
+function wrapPort(port) {
+  return port > 65535 ? devPortRange.min + (port - 65536) : port;
+}
+function listenOnce(server, host, port) {
+  return new Promise((resolve8, reject) => {
+    const onError = (error) => {
+      server.off("listening", onListening);
+      reject(error);
+    };
+    const onListening = () => {
+      server.off("error", onError);
+      resolve8();
+    };
+    server.once("error", onError);
+    server.once("listening", onListening);
+    server.listen(port, host);
+  });
+}
+function isAddressInUse(error) {
+  return error?.code === "EADDRINUSE";
+}
+
+// src/dev/dev-registry.ts
+import { createHash as createHash3 } from "node:crypto";
+import { mkdir, readFile as readFile3, rm as rm2, writeFile as writeFile2 } from "node:fs/promises";
+import { join as join4 } from "node:path";
+
+// src/dev/process-reaper.ts
+import { spawn } from "node:child_process";
+import { readdir, readFile as readFile2, rm, stat as stat2, writeFile } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { join as join3 } from "node:path";
+import psList from "ps-list";
+var devWorkDirPrefix = "kody-dev-";
+var ownerFileName = "owner.json";
+var legacyDirMinAgeMs = 10 * 6e4;
+var reaperScript = `
+pids=" "
+while IFS= read -r line; do
+  case "$line" in
+    +*) pids="$pids\${line#+} " ;;
+    -*) pids="$(printf '%s' "$pids" | sed "s/ \${line#-} / /g")" ;;
+  esac
+done
+for entry in $pids; do
+  case "$entry" in
+    g*) /bin/kill -s KILL -- -\${entry#g} 2>/dev/null ;;
+    *) /bin/kill -s KILL -- $entry 2>/dev/null ;;
+  esac
+done
+rm -rf "$1"
+`;
+async function startProcessReaper(input) {
+  await writeFile(
+    join3(input.workDir, ownerFileName),
+    JSON.stringify({ pid: process.pid, startedAt: (/* @__PURE__ */ new Date()).toISOString() })
+  );
+  let reaper;
+  try {
+    reaper = spawn("/bin/sh", ["-c", reaperScript, "kody-dev-reaper", input.workDir], {
+      stdio: ["pipe", "ignore", "ignore"],
+      detached: true
+    });
+    reaper.on("error", () => {
+      reaper = void 0;
+    });
+    reaper.stdin?.on("error", () => {
+    });
+    reaper.unref();
+    reaper.stdin?.unref?.();
+  } catch {
+    reaper = void 0;
+  }
+  const send2 = (line) => {
+    if (reaper?.stdin?.writable) reaper.stdin.write(`${line}
+`);
+  };
+  return {
+    track: (pid) => send2(`+${pid}`),
+    untrack: (pid) => send2(`-${pid}`),
+    trackGroup: (pid) => send2(`+g${pid}`),
+    untrackGroup: (pid) => send2(`-g${pid}`),
+    close: () => {
+      reaper?.stdin?.end();
+      reaper = void 0;
+    }
+  };
+}
+async function sweepStaleDevDirs(input = {}) {
+  const tmp = input.tmp ?? tmpdir();
+  const now = input.now ?? Date.now();
+  const isAlive = input.isAlive ?? isProcessAlive;
+  const kill = input.kill ?? ((pid) => process.kill(pid, "SIGKILL"));
+  const removed = [];
+  const killed = [];
+  let entries;
+  try {
+    entries = (await readdir(tmp)).filter((name) => name.startsWith(devWorkDirPrefix));
+  } catch {
+    return { removed, killed };
+  }
+  if (entries.length === 0) return { removed, killed };
+  let processes = [];
+  try {
+    processes = await (input.listProcesses ?? psList)();
+  } catch {
+    processes = [];
+  }
+  const byPid = new Map(processes.map((item) => [item.pid, item]));
+  for (const name of entries) {
+    const dir = join3(tmp, name);
+    try {
+      const owner = await readOwnerPid(dir);
+      if (owner !== null && isAlive(owner)) continue;
+      const workerds = processes.filter(
+        (item) => /workerd/.test(item.name) && (item.cmd ?? "").includes(`${dir}/`)
+      );
+      if (owner === null) {
+        const info = await stat2(dir);
+        if (now - info.mtimeMs < legacyDirMinAgeMs) continue;
+        if (workerds.some((item) => !isOrphaned(item, byPid, isAlive))) continue;
+      }
+      for (const item of workerds) {
+        try {
+          kill(item.pid);
+          killed.push(item.pid);
+        } catch {
+        }
+      }
+      await rm(dir, { recursive: true, force: true });
+      removed.push(dir);
+    } catch {
+    }
+  }
+  return { removed, killed };
+}
+function isOrphaned(item, byPid, isAlive) {
+  if (item.ppid === void 0) return false;
+  if (item.ppid <= 1 || !isAlive(item.ppid)) return true;
+  const parent = byPid.get(item.ppid);
+  return parent !== void 0 && !/node|kody/i.test(`${parent.name} ${parent.cmd ?? ""}`);
+}
+async function readOwnerPid(dir) {
+  try {
+    const parsed = JSON.parse(await readFile2(join3(dir, ownerFileName), "utf8"));
+    return typeof parsed.pid === "number" ? parsed.pid : null;
+  } catch {
+    return null;
+  }
+}
+function isProcessAlive(pid) {
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch (error) {
+    return error.code === "EPERM";
+  }
+}
+
+// src/dev/dev-registry.ts
+var devStatusPath = "/__kody/dev/status";
+function devRegistryPath(root, target, cacheDir = userCacheDir()) {
+  const key = createHash3("sha256").update(`${root}\0${target}`).digest("hex").slice(0, 16);
+  return join4(cacheDir, "dev-servers", `${key}.json`);
+}
+async function writeDevRegistration(registration, cacheDir) {
+  const path = devRegistryPath(registration.root, registration.target, cacheDir);
+  await mkdir(join4(path, ".."), { recursive: true });
+  await writeFile2(path, `${JSON.stringify(registration, null, 2)}
+`);
+  return path;
+}
+async function removeDevRegistration(root, pid, target, cacheDir) {
+  const path = devRegistryPath(root, target, cacheDir);
+  try {
+    const current = await readRegistration(path);
+    if (!current || current.pid !== pid) return;
+    await rm2(path, { force: true });
+  } catch {
+  }
+}
+async function findRunningDevServer(input) {
+  const path = devRegistryPath(input.root, input.target, input.cacheDir);
+  const registration = await readRegistration(path);
+  if (!registration || registration.root !== input.root) return null;
+  if (!isProcessAlive(registration.pid)) {
+    const current = await readRegistration(path);
+    if (current && current.pid === registration.pid) {
+      await rm2(path, { force: true });
+    }
+    return null;
+  }
+  if (registration.target !== input.target) return null;
+  try {
+    const response = await (input.fetchFn ?? fetch)(
+      new URL(devStatusPath, registration.origin),
+      { signal: AbortSignal.timeout(input.timeoutMs ?? 1500) }
+    );
+    if (!response.ok) return null;
+    const status = await response.json();
+    if (status.package?.root !== input.root || status.target !== input.target) return null;
+    return { registration, status };
+  } catch {
+    return null;
+  }
+}
+async function readRegistration(path) {
+  try {
+    const parsed = JSON.parse(await readFile3(path, "utf8"));
+    if (typeof parsed.pid !== "number" || typeof parsed.origin !== "string" || typeof parsed.root !== "string" || parsed.target !== "mock" && parsed.target !== "prod") {
+      return null;
+    }
+    return {
+      pid: parsed.pid,
+      origin: parsed.origin,
+      port: typeof parsed.port === "number" ? parsed.port : Number(new URL(parsed.origin).port),
+      basePath: typeof parsed.basePath === "string" ? parsed.basePath : "",
+      target: parsed.target,
+      root: parsed.root
+    };
+  } catch {
+    return null;
+  }
+}
+
+// node_modules/chokidar/esm/index.js
+import { stat as statcb } from "fs";
+import { stat as stat5, readdir as readdir3 } from "fs/promises";
+import { EventEmitter } from "events";
+import * as sysPath2 from "path";
+
+// node_modules/readdirp/esm/index.js
+import { stat as stat3, lstat, readdir as readdir2, realpath } from "node:fs/promises";
+import { Readable } from "node:stream";
+import { resolve as presolve, relative as prelative, join as pjoin, sep as psep } from "node:path";
+var EntryTypes = {
+  FILE_TYPE: "files",
+  DIR_TYPE: "directories",
+  FILE_DIR_TYPE: "files_directories",
+  EVERYTHING_TYPE: "all"
+};
+var defaultOptions = {
+  root: ".",
+  fileFilter: (_entryInfo) => true,
+  directoryFilter: (_entryInfo) => true,
+  type: EntryTypes.FILE_TYPE,
+  lstat: false,
+  depth: 2147483648,
+  alwaysStat: false,
+  highWaterMark: 4096
+};
+Object.freeze(defaultOptions);
+var RECURSIVE_ERROR_CODE = "READDIRP_RECURSIVE_ERROR";
+var NORMAL_FLOW_ERRORS = /* @__PURE__ */ new Set(["ENOENT", "EPERM", "EACCES", "ELOOP", RECURSIVE_ERROR_CODE]);
+var ALL_TYPES = [
+  EntryTypes.DIR_TYPE,
+  EntryTypes.EVERYTHING_TYPE,
+  EntryTypes.FILE_DIR_TYPE,
+  EntryTypes.FILE_TYPE
+];
+var DIR_TYPES = /* @__PURE__ */ new Set([
+  EntryTypes.DIR_TYPE,
+  EntryTypes.EVERYTHING_TYPE,
+  EntryTypes.FILE_DIR_TYPE
+]);
+var FILE_TYPES = /* @__PURE__ */ new Set([
+  EntryTypes.EVERYTHING_TYPE,
+  EntryTypes.FILE_DIR_TYPE,
+  EntryTypes.FILE_TYPE
+]);
+var isNormalFlowError = (error) => NORMAL_FLOW_ERRORS.has(error.code);
+var wantBigintFsStats = process.platform === "win32";
+var emptyFn = (_entryInfo) => true;
+var normalizeFilter = (filter) => {
+  if (filter === void 0)
+    return emptyFn;
+  if (typeof filter === "function")
+    return filter;
+  if (typeof filter === "string") {
+    const fl = filter.trim();
+    return (entry) => entry.basename === fl;
+  }
+  if (Array.isArray(filter)) {
+    const trItems = filter.map((item) => item.trim());
+    return (entry) => trItems.some((f) => entry.basename === f);
+  }
+  return emptyFn;
+};
+var ReaddirpStream = class extends Readable {
+  constructor(options = {}) {
+    super({
+      objectMode: true,
+      autoDestroy: true,
+      highWaterMark: options.highWaterMark
+    });
+    const opts = { ...defaultOptions, ...options };
+    const { root, type } = opts;
+    this._fileFilter = normalizeFilter(opts.fileFilter);
+    this._directoryFilter = normalizeFilter(opts.directoryFilter);
+    const statMethod = opts.lstat ? lstat : stat3;
+    if (wantBigintFsStats) {
+      this._stat = (path) => statMethod(path, { bigint: true });
+    } else {
+      this._stat = statMethod;
+    }
+    this._maxDepth = opts.depth ?? defaultOptions.depth;
+    this._wantsDir = type ? DIR_TYPES.has(type) : false;
+    this._wantsFile = type ? FILE_TYPES.has(type) : false;
+    this._wantsEverything = type === EntryTypes.EVERYTHING_TYPE;
+    this._root = presolve(root);
+    this._isDirent = !opts.alwaysStat;
+    this._statsProp = this._isDirent ? "dirent" : "stats";
+    this._rdOptions = { encoding: "utf8", withFileTypes: this._isDirent };
+    this.parents = [this._exploreDir(root, 1)];
+    this.reading = false;
+    this.parent = void 0;
+  }
+  async _read(batch) {
+    if (this.reading)
+      return;
+    this.reading = true;
+    try {
+      while (!this.destroyed && batch > 0) {
+        const par = this.parent;
+        const fil = par && par.files;
+        if (fil && fil.length > 0) {
+          const { path, depth } = par;
+          const slice = fil.splice(0, batch).map((dirent) => this._formatEntry(dirent, path));
+          const awaited = await Promise.all(slice);
+          for (const entry of awaited) {
+            if (!entry)
+              continue;
+            if (this.destroyed)
+              return;
+            const entryType = await this._getEntryType(entry);
+            if (entryType === "directory" && this._directoryFilter(entry)) {
+              if (depth <= this._maxDepth) {
+                this.parents.push(this._exploreDir(entry.fullPath, depth + 1));
+              }
+              if (this._wantsDir) {
+                this.push(entry);
+                batch--;
+              }
+            } else if ((entryType === "file" || this._includeAsFile(entry)) && this._fileFilter(entry)) {
+              if (this._wantsFile) {
+                this.push(entry);
+                batch--;
+              }
+            }
+          }
+        } else {
+          const parent = this.parents.pop();
+          if (!parent) {
+            this.push(null);
+            break;
+          }
+          this.parent = await parent;
+          if (this.destroyed)
+            return;
+        }
+      }
+    } catch (error) {
+      this.destroy(error);
+    } finally {
+      this.reading = false;
+    }
+  }
+  async _exploreDir(path, depth) {
+    let files;
+    try {
+      files = await readdir2(path, this._rdOptions);
+    } catch (error) {
+      this._onError(error);
+    }
+    return { files, depth, path };
+  }
+  async _formatEntry(dirent, path) {
+    let entry;
+    const basename3 = this._isDirent ? dirent.name : dirent;
+    try {
+      const fullPath = presolve(pjoin(path, basename3));
+      entry = { path: prelative(this._root, fullPath), fullPath, basename: basename3 };
+      entry[this._statsProp] = this._isDirent ? dirent : await this._stat(fullPath);
+    } catch (err) {
+      this._onError(err);
+      return;
+    }
+    return entry;
+  }
+  _onError(err) {
+    if (isNormalFlowError(err) && !this.destroyed) {
+      this.emit("warn", err);
+    } else {
+      this.destroy(err);
+    }
+  }
+  async _getEntryType(entry) {
+    if (!entry && this._statsProp in entry) {
+      return "";
+    }
+    const stats = entry[this._statsProp];
+    if (stats.isFile())
+      return "file";
+    if (stats.isDirectory())
+      return "directory";
+    if (stats && stats.isSymbolicLink()) {
+      const full = entry.fullPath;
+      try {
+        const entryRealPath = await realpath(full);
+        const entryRealPathStats = await lstat(entryRealPath);
+        if (entryRealPathStats.isFile()) {
+          return "file";
+        }
+        if (entryRealPathStats.isDirectory()) {
+          const len = entryRealPath.length;
+          if (full.startsWith(entryRealPath) && full.substr(len, 1) === psep) {
+            const recursiveError = new Error(`Circular symlink detected: "${full}" points to "${entryRealPath}"`);
+            recursiveError.code = RECURSIVE_ERROR_CODE;
+            return this._onError(recursiveError);
+          }
+          return "directory";
+        }
+      } catch (error) {
+        this._onError(error);
+        return "";
+      }
+    }
+  }
+  _includeAsFile(entry) {
+    const stats = entry && entry[this._statsProp];
+    return stats && this._wantsEverything && !stats.isDirectory();
+  }
+};
+function readdirp(root, options = {}) {
+  let type = options.entryType || options.type;
+  if (type === "both")
+    type = EntryTypes.FILE_DIR_TYPE;
+  if (type)
+    options.type = type;
+  if (!root) {
+    throw new Error("readdirp: root argument is required. Usage: readdirp(root, options)");
+  } else if (typeof root !== "string") {
+    throw new TypeError("readdirp: root argument must be a string. Usage: readdirp(root, options)");
+  } else if (type && !ALL_TYPES.includes(type)) {
+    throw new Error(`readdirp: Invalid type passed. Use one of ${ALL_TYPES.join(", ")}`);
+  }
+  options.root = root;
+  return new ReaddirpStream(options);
+}
+
+// node_modules/chokidar/esm/handler.js
+import { watchFile, unwatchFile, watch as fs_watch } from "fs";
+import { open, stat as stat4, lstat as lstat2, realpath as fsrealpath } from "fs/promises";
+import * as sysPath from "path";
+import { type as osType } from "os";
+var STR_DATA = "data";
+var STR_END = "end";
+var STR_CLOSE = "close";
+var EMPTY_FN = () => {
+};
+var pl = process.platform;
+var isWindows = pl === "win32";
+var isMacos = pl === "darwin";
+var isLinux = pl === "linux";
+var isFreeBSD = pl === "freebsd";
+var isIBMi = osType() === "OS400";
+var EVENTS = {
+  ALL: "all",
+  READY: "ready",
+  ADD: "add",
+  CHANGE: "change",
+  ADD_DIR: "addDir",
+  UNLINK: "unlink",
+  UNLINK_DIR: "unlinkDir",
+  RAW: "raw",
+  ERROR: "error"
+};
+var EV = EVENTS;
+var THROTTLE_MODE_WATCH = "watch";
+var statMethods = { lstat: lstat2, stat: stat4 };
+var KEY_LISTENERS = "listeners";
+var KEY_ERR = "errHandlers";
+var KEY_RAW = "rawEmitters";
+var HANDLER_KEYS = [KEY_LISTENERS, KEY_ERR, KEY_RAW];
+var binaryExtensions = /* @__PURE__ */ new Set([
+  "3dm",
+  "3ds",
+  "3g2",
+  "3gp",
+  "7z",
+  "a",
+  "aac",
+  "adp",
+  "afdesign",
+  "afphoto",
+  "afpub",
+  "ai",
+  "aif",
+  "aiff",
+  "alz",
+  "ape",
+  "apk",
+  "appimage",
+  "ar",
+  "arj",
+  "asf",
+  "au",
+  "avi",
+  "bak",
+  "baml",
+  "bh",
+  "bin",
+  "bk",
+  "bmp",
+  "btif",
+  "bz2",
+  "bzip2",
+  "cab",
+  "caf",
+  "cgm",
+  "class",
+  "cmx",
+  "cpio",
+  "cr2",
+  "cur",
+  "dat",
+  "dcm",
+  "deb",
+  "dex",
+  "djvu",
+  "dll",
+  "dmg",
+  "dng",
+  "doc",
+  "docm",
+  "docx",
+  "dot",
+  "dotm",
+  "dra",
+  "DS_Store",
+  "dsk",
+  "dts",
+  "dtshd",
+  "dvb",
+  "dwg",
+  "dxf",
+  "ecelp4800",
+  "ecelp7470",
+  "ecelp9600",
+  "egg",
+  "eol",
+  "eot",
+  "epub",
+  "exe",
+  "f4v",
+  "fbs",
+  "fh",
+  "fla",
+  "flac",
+  "flatpak",
+  "fli",
+  "flv",
+  "fpx",
+  "fst",
+  "fvt",
+  "g3",
+  "gh",
+  "gif",
+  "graffle",
+  "gz",
+  "gzip",
+  "h261",
+  "h263",
+  "h264",
+  "icns",
+  "ico",
+  "ief",
+  "img",
+  "ipa",
+  "iso",
+  "jar",
+  "jpeg",
+  "jpg",
+  "jpgv",
+  "jpm",
+  "jxr",
+  "key",
+  "ktx",
+  "lha",
+  "lib",
+  "lvp",
+  "lz",
+  "lzh",
+  "lzma",
+  "lzo",
+  "m3u",
+  "m4a",
+  "m4v",
+  "mar",
+  "mdi",
+  "mht",
+  "mid",
+  "midi",
+  "mj2",
+  "mka",
+  "mkv",
+  "mmr",
+  "mng",
+  "mobi",
+  "mov",
+  "movie",
+  "mp3",
+  "mp4",
+  "mp4a",
+  "mpeg",
+  "mpg",
+  "mpga",
+  "mxu",
+  "nef",
+  "npx",
+  "numbers",
+  "nupkg",
+  "o",
+  "odp",
+  "ods",
+  "odt",
+  "oga",
+  "ogg",
+  "ogv",
+  "otf",
+  "ott",
+  "pages",
+  "pbm",
+  "pcx",
+  "pdb",
+  "pdf",
+  "pea",
+  "pgm",
+  "pic",
+  "png",
+  "pnm",
+  "pot",
+  "potm",
+  "potx",
+  "ppa",
+  "ppam",
+  "ppm",
+  "pps",
+  "ppsm",
+  "ppsx",
+  "ppt",
+  "pptm",
+  "pptx",
+  "psd",
+  "pya",
+  "pyc",
+  "pyo",
+  "pyv",
+  "qt",
+  "rar",
+  "ras",
+  "raw",
+  "resources",
+  "rgb",
+  "rip",
+  "rlc",
+  "rmf",
+  "rmvb",
+  "rpm",
+  "rtf",
+  "rz",
+  "s3m",
+  "s7z",
+  "scpt",
+  "sgi",
+  "shar",
+  "snap",
+  "sil",
+  "sketch",
+  "slk",
+  "smv",
+  "snk",
+  "so",
+  "stl",
+  "suo",
+  "sub",
+  "swf",
+  "tar",
+  "tbz",
+  "tbz2",
+  "tga",
+  "tgz",
+  "thmx",
+  "tif",
+  "tiff",
+  "tlz",
+  "ttc",
+  "ttf",
+  "txz",
+  "udf",
+  "uvh",
+  "uvi",
+  "uvm",
+  "uvp",
+  "uvs",
+  "uvu",
+  "viv",
+  "vob",
+  "war",
+  "wav",
+  "wax",
+  "wbmp",
+  "wdp",
+  "weba",
+  "webm",
+  "webp",
+  "whl",
+  "wim",
+  "wm",
+  "wma",
+  "wmv",
+  "wmx",
+  "woff",
+  "woff2",
+  "wrm",
+  "wvx",
+  "xbm",
+  "xif",
+  "xla",
+  "xlam",
+  "xls",
+  "xlsb",
+  "xlsm",
+  "xlsx",
+  "xlt",
+  "xltm",
+  "xltx",
+  "xm",
+  "xmind",
+  "xpi",
+  "xpm",
+  "xwd",
+  "xz",
+  "z",
+  "zip",
+  "zipx"
+]);
+var isBinaryPath = (filePath) => binaryExtensions.has(sysPath.extname(filePath).slice(1).toLowerCase());
+var foreach = (val, fn) => {
+  if (val instanceof Set) {
+    val.forEach(fn);
+  } else {
+    fn(val);
+  }
+};
+var addAndConvert = (main, prop, item) => {
+  let container = main[prop];
+  if (!(container instanceof Set)) {
+    main[prop] = container = /* @__PURE__ */ new Set([container]);
+  }
+  container.add(item);
+};
+var clearItem = (cont) => (key) => {
+  const set = cont[key];
+  if (set instanceof Set) {
+    set.clear();
+  } else {
+    delete cont[key];
+  }
+};
+var delFromSet = (main, prop, item) => {
+  const container = main[prop];
+  if (container instanceof Set) {
+    container.delete(item);
+  } else if (container === item) {
+    delete main[prop];
+  }
+};
+var isEmptySet = (val) => val instanceof Set ? val.size === 0 : !val;
+var FsWatchInstances = /* @__PURE__ */ new Map();
+function createFsWatchInstance(path, options, listener, errHandler, emitRaw) {
+  const handleEvent = (rawEvent, evPath) => {
+    listener(path);
+    emitRaw(rawEvent, evPath, { watchedPath: path });
+    if (evPath && path !== evPath) {
+      fsWatchBroadcast(sysPath.resolve(path, evPath), KEY_LISTENERS, sysPath.join(path, evPath));
+    }
+  };
+  try {
+    return fs_watch(path, {
+      persistent: options.persistent
+    }, handleEvent);
+  } catch (error) {
+    errHandler(error);
+    return void 0;
+  }
+}
+var fsWatchBroadcast = (fullPath, listenerType, val1, val2, val3) => {
+  const cont = FsWatchInstances.get(fullPath);
+  if (!cont)
+    return;
+  foreach(cont[listenerType], (listener) => {
+    listener(val1, val2, val3);
+  });
+};
+var setFsWatchListener = (path, fullPath, options, handlers) => {
+  const { listener, errHandler, rawEmitter } = handlers;
+  let cont = FsWatchInstances.get(fullPath);
+  let watcher;
+  if (!options.persistent) {
+    watcher = createFsWatchInstance(path, options, listener, errHandler, rawEmitter);
+    if (!watcher)
+      return;
+    return watcher.close.bind(watcher);
+  }
+  if (cont) {
+    addAndConvert(cont, KEY_LISTENERS, listener);
+    addAndConvert(cont, KEY_ERR, errHandler);
+    addAndConvert(cont, KEY_RAW, rawEmitter);
+  } else {
+    watcher = createFsWatchInstance(
+      path,
+      options,
+      fsWatchBroadcast.bind(null, fullPath, KEY_LISTENERS),
+      errHandler,
+      // no need to use broadcast here
+      fsWatchBroadcast.bind(null, fullPath, KEY_RAW)
+    );
+    if (!watcher)
+      return;
+    watcher.on(EV.ERROR, async (error) => {
+      const broadcastErr = fsWatchBroadcast.bind(null, fullPath, KEY_ERR);
+      if (cont)
+        cont.watcherUnusable = true;
+      if (isWindows && error.code === "EPERM") {
+        try {
+          const fd = await open(path, "r");
+          await fd.close();
+          broadcastErr(error);
+        } catch (err) {
+        }
+      } else {
+        broadcastErr(error);
+      }
+    });
+    cont = {
+      listeners: listener,
+      errHandlers: errHandler,
+      rawEmitters: rawEmitter,
+      watcher
+    };
+    FsWatchInstances.set(fullPath, cont);
+  }
+  return () => {
+    delFromSet(cont, KEY_LISTENERS, listener);
+    delFromSet(cont, KEY_ERR, errHandler);
+    delFromSet(cont, KEY_RAW, rawEmitter);
+    if (isEmptySet(cont.listeners)) {
+      cont.watcher.close();
+      FsWatchInstances.delete(fullPath);
+      HANDLER_KEYS.forEach(clearItem(cont));
+      cont.watcher = void 0;
+      Object.freeze(cont);
+    }
+  };
+};
+var FsWatchFileInstances = /* @__PURE__ */ new Map();
+var setFsWatchFileListener = (path, fullPath, options, handlers) => {
+  const { listener, rawEmitter } = handlers;
+  let cont = FsWatchFileInstances.get(fullPath);
+  const copts = cont && cont.options;
+  if (copts && (copts.persistent < options.persistent || copts.interval > options.interval)) {
+    unwatchFile(fullPath);
+    cont = void 0;
+  }
+  if (cont) {
+    addAndConvert(cont, KEY_LISTENERS, listener);
+    addAndConvert(cont, KEY_RAW, rawEmitter);
+  } else {
+    cont = {
+      listeners: listener,
+      rawEmitters: rawEmitter,
+      options,
+      watcher: watchFile(fullPath, options, (curr, prev) => {
+        foreach(cont.rawEmitters, (rawEmitter2) => {
+          rawEmitter2(EV.CHANGE, fullPath, { curr, prev });
+        });
+        const currmtime = curr.mtimeMs;
+        if (curr.size !== prev.size || currmtime > prev.mtimeMs || currmtime === 0) {
+          foreach(cont.listeners, (listener2) => listener2(path, curr));
+        }
+      })
+    };
+    FsWatchFileInstances.set(fullPath, cont);
+  }
+  return () => {
+    delFromSet(cont, KEY_LISTENERS, listener);
+    delFromSet(cont, KEY_RAW, rawEmitter);
+    if (isEmptySet(cont.listeners)) {
+      FsWatchFileInstances.delete(fullPath);
+      unwatchFile(fullPath);
+      cont.options = cont.watcher = void 0;
+      Object.freeze(cont);
+    }
+  };
+};
+var NodeFsHandler = class {
+  constructor(fsW) {
+    this.fsw = fsW;
+    this._boundHandleError = (error) => fsW._handleError(error);
+  }
+  /**
+   * Watch file for changes with fs_watchFile or fs_watch.
+   * @param path to file or dir
+   * @param listener on fs change
+   * @returns closer for the watcher instance
+   */
+  _watchWithNodeFs(path, listener) {
+    const opts = this.fsw.options;
+    const directory = sysPath.dirname(path);
+    const basename3 = sysPath.basename(path);
+    const parent = this.fsw._getWatchedDir(directory);
+    parent.add(basename3);
+    const absolutePath = sysPath.resolve(path);
+    const options = {
+      persistent: opts.persistent
+    };
+    if (!listener)
+      listener = EMPTY_FN;
+    let closer;
+    if (opts.usePolling) {
+      const enableBin = opts.interval !== opts.binaryInterval;
+      options.interval = enableBin && isBinaryPath(basename3) ? opts.binaryInterval : opts.interval;
+      closer = setFsWatchFileListener(path, absolutePath, options, {
+        listener,
+        rawEmitter: this.fsw._emitRaw
+      });
+    } else {
+      closer = setFsWatchListener(path, absolutePath, options, {
+        listener,
+        errHandler: this._boundHandleError,
+        rawEmitter: this.fsw._emitRaw
+      });
+    }
+    return closer;
+  }
+  /**
+   * Watch a file and emit add event if warranted.
+   * @returns closer for the watcher instance
+   */
+  _handleFile(file, stats, initialAdd) {
+    if (this.fsw.closed) {
+      return;
+    }
+    const dirname4 = sysPath.dirname(file);
+    const basename3 = sysPath.basename(file);
+    const parent = this.fsw._getWatchedDir(dirname4);
+    let prevStats = stats;
+    if (parent.has(basename3))
+      return;
+    const listener = async (path, newStats) => {
+      if (!this.fsw._throttle(THROTTLE_MODE_WATCH, file, 5))
+        return;
+      if (!newStats || newStats.mtimeMs === 0) {
+        try {
+          const newStats2 = await stat4(file);
+          if (this.fsw.closed)
+            return;
+          const at = newStats2.atimeMs;
+          const mt = newStats2.mtimeMs;
+          if (!at || at <= mt || mt !== prevStats.mtimeMs) {
+            this.fsw._emit(EV.CHANGE, file, newStats2);
+          }
+          if ((isMacos || isLinux || isFreeBSD) && prevStats.ino !== newStats2.ino) {
+            this.fsw._closeFile(path);
+            prevStats = newStats2;
+            const closer2 = this._watchWithNodeFs(file, listener);
+            if (closer2)
+              this.fsw._addPathCloser(path, closer2);
+          } else {
+            prevStats = newStats2;
+          }
+        } catch (error) {
+          this.fsw._remove(dirname4, basename3);
+        }
+      } else if (parent.has(basename3)) {
+        const at = newStats.atimeMs;
+        const mt = newStats.mtimeMs;
+        if (!at || at <= mt || mt !== prevStats.mtimeMs) {
+          this.fsw._emit(EV.CHANGE, file, newStats);
+        }
+        prevStats = newStats;
+      }
+    };
+    const closer = this._watchWithNodeFs(file, listener);
+    if (!(initialAdd && this.fsw.options.ignoreInitial) && this.fsw._isntIgnored(file)) {
+      if (!this.fsw._throttle(EV.ADD, file, 0))
+        return;
+      this.fsw._emit(EV.ADD, file, stats);
+    }
+    return closer;
+  }
+  /**
+   * Handle symlinks encountered while reading a dir.
+   * @param entry returned by readdirp
+   * @param directory path of dir being read
+   * @param path of this item
+   * @param item basename of this item
+   * @returns true if no more processing is needed for this entry.
+   */
+  async _handleSymlink(entry, directory, path, item) {
+    if (this.fsw.closed) {
+      return;
+    }
+    const full = entry.fullPath;
+    const dir = this.fsw._getWatchedDir(directory);
+    if (!this.fsw.options.followSymlinks) {
+      this.fsw._incrReadyCount();
+      let linkPath;
+      try {
+        linkPath = await fsrealpath(path);
+      } catch (e) {
+        this.fsw._emitReady();
+        return true;
+      }
+      if (this.fsw.closed)
+        return;
+      if (dir.has(item)) {
+        if (this.fsw._symlinkPaths.get(full) !== linkPath) {
+          this.fsw._symlinkPaths.set(full, linkPath);
+          this.fsw._emit(EV.CHANGE, path, entry.stats);
+        }
+      } else {
+        dir.add(item);
+        this.fsw._symlinkPaths.set(full, linkPath);
+        this.fsw._emit(EV.ADD, path, entry.stats);
+      }
+      this.fsw._emitReady();
+      return true;
+    }
+    if (this.fsw._symlinkPaths.has(full)) {
+      return true;
+    }
+    this.fsw._symlinkPaths.set(full, true);
+  }
+  _handleRead(directory, initialAdd, wh, target, dir, depth, throttler) {
+    directory = sysPath.join(directory, "");
+    throttler = this.fsw._throttle("readdir", directory, 1e3);
+    if (!throttler)
+      return;
+    const previous = this.fsw._getWatchedDir(wh.path);
+    const current = /* @__PURE__ */ new Set();
+    let stream = this.fsw._readdirp(directory, {
+      fileFilter: (entry) => wh.filterPath(entry),
+      directoryFilter: (entry) => wh.filterDir(entry)
+    });
+    if (!stream)
+      return;
+    stream.on(STR_DATA, async (entry) => {
+      if (this.fsw.closed) {
+        stream = void 0;
+        return;
+      }
+      const item = entry.path;
+      let path = sysPath.join(directory, item);
+      current.add(item);
+      if (entry.stats.isSymbolicLink() && await this._handleSymlink(entry, directory, path, item)) {
+        return;
+      }
+      if (this.fsw.closed) {
+        stream = void 0;
+        return;
+      }
+      if (item === target || !target && !previous.has(item)) {
+        this.fsw._incrReadyCount();
+        path = sysPath.join(dir, sysPath.relative(dir, path));
+        this._addToNodeFs(path, initialAdd, wh, depth + 1);
+      }
+    }).on(EV.ERROR, this._boundHandleError);
+    return new Promise((resolve8, reject) => {
+      if (!stream)
+        return reject();
+      stream.once(STR_END, () => {
+        if (this.fsw.closed) {
+          stream = void 0;
+          return;
+        }
+        const wasThrottled = throttler ? throttler.clear() : false;
+        resolve8(void 0);
+        previous.getChildren().filter((item) => {
+          return item !== directory && !current.has(item);
+        }).forEach((item) => {
+          this.fsw._remove(directory, item);
+        });
+        stream = void 0;
+        if (wasThrottled)
+          this._handleRead(directory, false, wh, target, dir, depth, throttler);
+      });
+    });
+  }
+  /**
+   * Read directory to add / remove files from `@watched` list and re-read it on change.
+   * @param dir fs path
+   * @param stats
+   * @param initialAdd
+   * @param depth relative to user-supplied path
+   * @param target child path targeted for watch
+   * @param wh Common watch helpers for this path
+   * @param realpath
+   * @returns closer for the watcher instance.
+   */
+  async _handleDir(dir, stats, initialAdd, depth, target, wh, realpath2) {
+    const parentDir = this.fsw._getWatchedDir(sysPath.dirname(dir));
+    const tracked = parentDir.has(sysPath.basename(dir));
+    if (!(initialAdd && this.fsw.options.ignoreInitial) && !target && !tracked) {
+      this.fsw._emit(EV.ADD_DIR, dir, stats);
+    }
+    parentDir.add(sysPath.basename(dir));
+    this.fsw._getWatchedDir(dir);
+    let throttler;
+    let closer;
+    const oDepth = this.fsw.options.depth;
+    if ((oDepth == null || depth <= oDepth) && !this.fsw._symlinkPaths.has(realpath2)) {
+      if (!target) {
+        await this._handleRead(dir, initialAdd, wh, target, dir, depth, throttler);
+        if (this.fsw.closed)
+          return;
+      }
+      closer = this._watchWithNodeFs(dir, (dirPath, stats2) => {
+        if (stats2 && stats2.mtimeMs === 0)
+          return;
+        this._handleRead(dirPath, false, wh, target, dir, depth, throttler);
+      });
+    }
+    return closer;
+  }
+  /**
+   * Handle added file, directory, or glob pattern.
+   * Delegates call to _handleFile / _handleDir after checks.
+   * @param path to file or ir
+   * @param initialAdd was the file added at watch instantiation?
+   * @param priorWh depth relative to user-supplied path
+   * @param depth Child path actually targeted for watch
+   * @param target Child path actually targeted for watch
+   */
+  async _addToNodeFs(path, initialAdd, priorWh, depth, target) {
+    const ready = this.fsw._emitReady;
+    if (this.fsw._isIgnored(path) || this.fsw.closed) {
+      ready();
+      return false;
+    }
+    const wh = this.fsw._getWatchHelpers(path);
+    if (priorWh) {
+      wh.filterPath = (entry) => priorWh.filterPath(entry);
+      wh.filterDir = (entry) => priorWh.filterDir(entry);
+    }
+    try {
+      const stats = await statMethods[wh.statMethod](wh.watchPath);
+      if (this.fsw.closed)
+        return;
+      if (this.fsw._isIgnored(wh.watchPath, stats)) {
+        ready();
+        return false;
+      }
+      const follow = this.fsw.options.followSymlinks;
+      let closer;
+      if (stats.isDirectory()) {
+        const absPath = sysPath.resolve(path);
+        const targetPath = follow ? await fsrealpath(path) : path;
+        if (this.fsw.closed)
+          return;
+        closer = await this._handleDir(wh.watchPath, stats, initialAdd, depth, target, wh, targetPath);
+        if (this.fsw.closed)
+          return;
+        if (absPath !== targetPath && targetPath !== void 0) {
+          this.fsw._symlinkPaths.set(absPath, targetPath);
+        }
+      } else if (stats.isSymbolicLink()) {
+        const targetPath = follow ? await fsrealpath(path) : path;
+        if (this.fsw.closed)
+          return;
+        const parent = sysPath.dirname(wh.watchPath);
+        this.fsw._getWatchedDir(parent).add(wh.watchPath);
+        this.fsw._emit(EV.ADD, wh.watchPath, stats);
+        closer = await this._handleDir(parent, stats, initialAdd, depth, path, wh, targetPath);
+        if (this.fsw.closed)
+          return;
+        if (targetPath !== void 0) {
+          this.fsw._symlinkPaths.set(sysPath.resolve(path), targetPath);
+        }
+      } else {
+        closer = this._handleFile(wh.watchPath, stats, initialAdd);
+      }
+      ready();
+      if (closer)
+        this.fsw._addPathCloser(path, closer);
+      return false;
+    } catch (error) {
+      if (this.fsw._handleError(error)) {
+        ready();
+        return path;
+      }
+    }
+  }
+};
+
+// node_modules/chokidar/esm/index.js
+var SLASH = "/";
+var SLASH_SLASH = "//";
+var ONE_DOT = ".";
+var TWO_DOTS = "..";
+var STRING_TYPE = "string";
+var BACK_SLASH_RE = /\\/g;
+var DOUBLE_SLASH_RE = /\/\//;
+var DOT_RE = /\..*\.(sw[px])$|~$|\.subl.*\.tmp/;
+var REPLACER_RE = /^\.[/\\]/;
+function arrify(item) {
+  return Array.isArray(item) ? item : [item];
+}
+var isMatcherObject = (matcher) => typeof matcher === "object" && matcher !== null && !(matcher instanceof RegExp);
+function createPattern(matcher) {
+  if (typeof matcher === "function")
+    return matcher;
+  if (typeof matcher === "string")
+    return (string) => matcher === string;
+  if (matcher instanceof RegExp)
+    return (string) => matcher.test(string);
+  if (typeof matcher === "object" && matcher !== null) {
+    return (string) => {
+      if (matcher.path === string)
+        return true;
+      if (matcher.recursive) {
+        const relative5 = sysPath2.relative(matcher.path, string);
+        if (!relative5) {
+          return false;
+        }
+        return !relative5.startsWith("..") && !sysPath2.isAbsolute(relative5);
+      }
+      return false;
+    };
+  }
+  return () => false;
+}
+function normalizePath(path) {
+  if (typeof path !== "string")
+    throw new Error("string expected");
+  path = sysPath2.normalize(path);
+  path = path.replace(/\\/g, "/");
+  let prepend = false;
+  if (path.startsWith("//"))
+    prepend = true;
+  const DOUBLE_SLASH_RE2 = /\/\//;
+  while (path.match(DOUBLE_SLASH_RE2))
+    path = path.replace(DOUBLE_SLASH_RE2, "/");
+  if (prepend)
+    path = "/" + path;
+  return path;
+}
+function matchPatterns(patterns, testString, stats) {
+  const path = normalizePath(testString);
+  for (let index = 0; index < patterns.length; index++) {
+    const pattern = patterns[index];
+    if (pattern(path, stats)) {
+      return true;
+    }
+  }
+  return false;
+}
+function anymatch(matchers, testString) {
+  if (matchers == null) {
+    throw new TypeError("anymatch: specify first argument");
+  }
+  const matchersArray = arrify(matchers);
+  const patterns = matchersArray.map((matcher) => createPattern(matcher));
+  if (testString == null) {
+    return (testString2, stats) => {
+      return matchPatterns(patterns, testString2, stats);
+    };
+  }
+  return matchPatterns(patterns, testString);
+}
+var unifyPaths = (paths_) => {
+  const paths = arrify(paths_).flat();
+  if (!paths.every((p) => typeof p === STRING_TYPE)) {
+    throw new TypeError(`Non-string provided as watch path: ${paths}`);
+  }
+  return paths.map(normalizePathToUnix);
+};
+var toUnix = (string) => {
+  let str = string.replace(BACK_SLASH_RE, SLASH);
+  let prepend = false;
+  if (str.startsWith(SLASH_SLASH)) {
+    prepend = true;
+  }
+  while (str.match(DOUBLE_SLASH_RE)) {
+    str = str.replace(DOUBLE_SLASH_RE, SLASH);
+  }
+  if (prepend) {
+    str = SLASH + str;
+  }
+  return str;
+};
+var normalizePathToUnix = (path) => toUnix(sysPath2.normalize(toUnix(path)));
+var normalizeIgnored = (cwd = "") => (path) => {
+  if (typeof path === "string") {
+    return normalizePathToUnix(sysPath2.isAbsolute(path) ? path : sysPath2.join(cwd, path));
+  } else {
+    return path;
+  }
+};
+var getAbsolutePath = (path, cwd) => {
+  if (sysPath2.isAbsolute(path)) {
+    return path;
+  }
+  return sysPath2.join(cwd, path);
+};
+var EMPTY_SET = Object.freeze(/* @__PURE__ */ new Set());
+var DirEntry = class {
+  constructor(dir, removeWatcher) {
+    this.path = dir;
+    this._removeWatcher = removeWatcher;
+    this.items = /* @__PURE__ */ new Set();
+  }
+  add(item) {
+    const { items } = this;
+    if (!items)
+      return;
+    if (item !== ONE_DOT && item !== TWO_DOTS)
+      items.add(item);
+  }
+  async remove(item) {
+    const { items } = this;
+    if (!items)
+      return;
+    items.delete(item);
+    if (items.size > 0)
+      return;
+    const dir = this.path;
+    try {
+      await readdir3(dir);
+    } catch (err) {
+      if (this._removeWatcher) {
+        this._removeWatcher(sysPath2.dirname(dir), sysPath2.basename(dir));
+      }
+    }
+  }
+  has(item) {
+    const { items } = this;
+    if (!items)
+      return;
+    return items.has(item);
+  }
+  getChildren() {
+    const { items } = this;
+    if (!items)
+      return [];
+    return [...items.values()];
+  }
+  dispose() {
+    this.items.clear();
+    this.path = "";
+    this._removeWatcher = EMPTY_FN;
+    this.items = EMPTY_SET;
+    Object.freeze(this);
+  }
+};
+var STAT_METHOD_F = "stat";
+var STAT_METHOD_L = "lstat";
+var WatchHelper = class {
+  constructor(path, follow, fsw) {
+    this.fsw = fsw;
+    const watchPath = path;
+    this.path = path = path.replace(REPLACER_RE, "");
+    this.watchPath = watchPath;
+    this.fullWatchPath = sysPath2.resolve(watchPath);
+    this.dirParts = [];
+    this.dirParts.forEach((parts) => {
+      if (parts.length > 1)
+        parts.pop();
+    });
+    this.followSymlinks = follow;
+    this.statMethod = follow ? STAT_METHOD_F : STAT_METHOD_L;
+  }
+  entryPath(entry) {
+    return sysPath2.join(this.watchPath, sysPath2.relative(this.watchPath, entry.fullPath));
+  }
+  filterPath(entry) {
+    const { stats } = entry;
+    if (stats && stats.isSymbolicLink())
+      return this.filterDir(entry);
+    const resolvedPath = this.entryPath(entry);
+    return this.fsw._isntIgnored(resolvedPath, stats) && this.fsw._hasReadPermissions(stats);
+  }
+  filterDir(entry) {
+    return this.fsw._isntIgnored(this.entryPath(entry), entry.stats);
+  }
+};
+var FSWatcher = class extends EventEmitter {
+  // Not indenting methods for history sake; for now.
+  constructor(_opts = {}) {
+    super();
+    this.closed = false;
+    this._closers = /* @__PURE__ */ new Map();
+    this._ignoredPaths = /* @__PURE__ */ new Set();
+    this._throttled = /* @__PURE__ */ new Map();
+    this._streams = /* @__PURE__ */ new Set();
+    this._symlinkPaths = /* @__PURE__ */ new Map();
+    this._watched = /* @__PURE__ */ new Map();
+    this._pendingWrites = /* @__PURE__ */ new Map();
+    this._pendingUnlinks = /* @__PURE__ */ new Map();
+    this._readyCount = 0;
+    this._readyEmitted = false;
+    const awf = _opts.awaitWriteFinish;
+    const DEF_AWF = { stabilityThreshold: 2e3, pollInterval: 100 };
+    const opts = {
+      // Defaults
+      persistent: true,
+      ignoreInitial: false,
+      ignorePermissionErrors: false,
+      interval: 100,
+      binaryInterval: 300,
+      followSymlinks: true,
+      usePolling: false,
+      // useAsync: false,
+      atomic: true,
+      // NOTE: overwritten later (depends on usePolling)
+      ..._opts,
+      // Change format
+      ignored: _opts.ignored ? arrify(_opts.ignored) : arrify([]),
+      awaitWriteFinish: awf === true ? DEF_AWF : typeof awf === "object" ? { ...DEF_AWF, ...awf } : false
+    };
+    if (isIBMi)
+      opts.usePolling = true;
+    if (opts.atomic === void 0)
+      opts.atomic = !opts.usePolling;
+    const envPoll = process.env.CHOKIDAR_USEPOLLING;
+    if (envPoll !== void 0) {
+      const envLower = envPoll.toLowerCase();
+      if (envLower === "false" || envLower === "0")
+        opts.usePolling = false;
+      else if (envLower === "true" || envLower === "1")
+        opts.usePolling = true;
+      else
+        opts.usePolling = !!envLower;
+    }
+    const envInterval = process.env.CHOKIDAR_INTERVAL;
+    if (envInterval)
+      opts.interval = Number.parseInt(envInterval, 10);
+    let readyCalls = 0;
+    this._emitReady = () => {
+      readyCalls++;
+      if (readyCalls >= this._readyCount) {
+        this._emitReady = EMPTY_FN;
+        this._readyEmitted = true;
+        process.nextTick(() => this.emit(EVENTS.READY));
+      }
+    };
+    this._emitRaw = (...args) => this.emit(EVENTS.RAW, ...args);
+    this._boundRemove = this._remove.bind(this);
+    this.options = opts;
+    this._nodeFsHandler = new NodeFsHandler(this);
+    Object.freeze(opts);
+  }
+  _addIgnoredPath(matcher) {
+    if (isMatcherObject(matcher)) {
+      for (const ignored of this._ignoredPaths) {
+        if (isMatcherObject(ignored) && ignored.path === matcher.path && ignored.recursive === matcher.recursive) {
+          return;
+        }
+      }
+    }
+    this._ignoredPaths.add(matcher);
+  }
+  _removeIgnoredPath(matcher) {
+    this._ignoredPaths.delete(matcher);
+    if (typeof matcher === "string") {
+      for (const ignored of this._ignoredPaths) {
+        if (isMatcherObject(ignored) && ignored.path === matcher) {
+          this._ignoredPaths.delete(ignored);
+        }
+      }
+    }
+  }
+  // Public methods
+  /**
+   * Adds paths to be watched on an existing FSWatcher instance.
+   * @param paths_ file or file list. Other arguments are unused
+   */
+  add(paths_, _origAdd, _internal) {
+    const { cwd } = this.options;
+    this.closed = false;
+    this._closePromise = void 0;
+    let paths = unifyPaths(paths_);
+    if (cwd) {
+      paths = paths.map((path) => {
+        const absPath = getAbsolutePath(path, cwd);
+        return absPath;
+      });
+    }
+    paths.forEach((path) => {
+      this._removeIgnoredPath(path);
+    });
+    this._userIgnored = void 0;
+    if (!this._readyCount)
+      this._readyCount = 0;
+    this._readyCount += paths.length;
+    Promise.all(paths.map(async (path) => {
+      const res = await this._nodeFsHandler._addToNodeFs(path, !_internal, void 0, 0, _origAdd);
+      if (res)
+        this._emitReady();
+      return res;
+    })).then((results) => {
+      if (this.closed)
+        return;
+      results.forEach((item) => {
+        if (item)
+          this.add(sysPath2.dirname(item), sysPath2.basename(_origAdd || item));
+      });
+    });
+    return this;
+  }
+  /**
+   * Close watchers or start ignoring events from specified paths.
+   */
+  unwatch(paths_) {
+    if (this.closed)
+      return this;
+    const paths = unifyPaths(paths_);
+    const { cwd } = this.options;
+    paths.forEach((path) => {
+      if (!sysPath2.isAbsolute(path) && !this._closers.has(path)) {
+        if (cwd)
+          path = sysPath2.join(cwd, path);
+        path = sysPath2.resolve(path);
+      }
+      this._closePath(path);
+      this._addIgnoredPath(path);
+      if (this._watched.has(path)) {
+        this._addIgnoredPath({
+          path,
+          recursive: true
+        });
+      }
+      this._userIgnored = void 0;
+    });
+    return this;
+  }
+  /**
+   * Close watchers and remove all listeners from watched paths.
+   */
+  close() {
+    if (this._closePromise) {
+      return this._closePromise;
+    }
+    this.closed = true;
+    this.removeAllListeners();
+    const closers = [];
+    this._closers.forEach((closerList) => closerList.forEach((closer) => {
+      const promise = closer();
+      if (promise instanceof Promise)
+        closers.push(promise);
+    }));
+    this._streams.forEach((stream) => stream.destroy());
+    this._userIgnored = void 0;
+    this._readyCount = 0;
+    this._readyEmitted = false;
+    this._watched.forEach((dirent) => dirent.dispose());
+    this._closers.clear();
+    this._watched.clear();
+    this._streams.clear();
+    this._symlinkPaths.clear();
+    this._throttled.clear();
+    this._closePromise = closers.length ? Promise.all(closers).then(() => void 0) : Promise.resolve();
+    return this._closePromise;
+  }
+  /**
+   * Expose list of watched paths
+   * @returns for chaining
+   */
+  getWatched() {
+    const watchList = {};
+    this._watched.forEach((entry, dir) => {
+      const key = this.options.cwd ? sysPath2.relative(this.options.cwd, dir) : dir;
+      const index = key || ONE_DOT;
+      watchList[index] = entry.getChildren().sort();
+    });
+    return watchList;
+  }
+  emitWithAll(event, args) {
+    this.emit(event, ...args);
+    if (event !== EVENTS.ERROR)
+      this.emit(EVENTS.ALL, event, ...args);
+  }
+  // Common helpers
+  // --------------
+  /**
+   * Normalize and emit events.
+   * Calling _emit DOES NOT MEAN emit() would be called!
+   * @param event Type of event
+   * @param path File or directory path
+   * @param stats arguments to be passed with event
+   * @returns the error if defined, otherwise the value of the FSWatcher instance's `closed` flag
+   */
+  async _emit(event, path, stats) {
+    if (this.closed)
+      return;
+    const opts = this.options;
+    if (isWindows)
+      path = sysPath2.normalize(path);
+    if (opts.cwd)
+      path = sysPath2.relative(opts.cwd, path);
+    const args = [path];
+    if (stats != null)
+      args.push(stats);
+    const awf = opts.awaitWriteFinish;
+    let pw;
+    if (awf && (pw = this._pendingWrites.get(path))) {
+      pw.lastChange = /* @__PURE__ */ new Date();
+      return this;
+    }
+    if (opts.atomic) {
+      if (event === EVENTS.UNLINK) {
+        this._pendingUnlinks.set(path, [event, ...args]);
+        setTimeout(() => {
+          this._pendingUnlinks.forEach((entry, path2) => {
+            this.emit(...entry);
+            this.emit(EVENTS.ALL, ...entry);
+            this._pendingUnlinks.delete(path2);
+          });
+        }, typeof opts.atomic === "number" ? opts.atomic : 100);
+        return this;
+      }
+      if (event === EVENTS.ADD && this._pendingUnlinks.has(path)) {
+        event = EVENTS.CHANGE;
+        this._pendingUnlinks.delete(path);
+      }
+    }
+    if (awf && (event === EVENTS.ADD || event === EVENTS.CHANGE) && this._readyEmitted) {
+      const awfEmit = (err, stats2) => {
+        if (err) {
+          event = EVENTS.ERROR;
+          args[0] = err;
+          this.emitWithAll(event, args);
+        } else if (stats2) {
+          if (args.length > 1) {
+            args[1] = stats2;
+          } else {
+            args.push(stats2);
+          }
+          this.emitWithAll(event, args);
+        }
+      };
+      this._awaitWriteFinish(path, awf.stabilityThreshold, event, awfEmit);
+      return this;
+    }
+    if (event === EVENTS.CHANGE) {
+      const isThrottled = !this._throttle(EVENTS.CHANGE, path, 50);
+      if (isThrottled)
+        return this;
+    }
+    if (opts.alwaysStat && stats === void 0 && (event === EVENTS.ADD || event === EVENTS.ADD_DIR || event === EVENTS.CHANGE)) {
+      const fullPath = opts.cwd ? sysPath2.join(opts.cwd, path) : path;
+      let stats2;
+      try {
+        stats2 = await stat5(fullPath);
+      } catch (err) {
+      }
+      if (!stats2 || this.closed)
+        return;
+      args.push(stats2);
+    }
+    this.emitWithAll(event, args);
+    return this;
+  }
+  /**
+   * Common handler for errors
+   * @returns The error if defined, otherwise the value of the FSWatcher instance's `closed` flag
+   */
+  _handleError(error) {
+    const code = error && error.code;
+    if (error && code !== "ENOENT" && code !== "ENOTDIR" && (!this.options.ignorePermissionErrors || code !== "EPERM" && code !== "EACCES")) {
+      this.emit(EVENTS.ERROR, error);
+    }
+    return error || this.closed;
+  }
+  /**
+   * Helper utility for throttling
+   * @param actionType type being throttled
+   * @param path being acted upon
+   * @param timeout duration of time to suppress duplicate actions
+   * @returns tracking object or false if action should be suppressed
+   */
+  _throttle(actionType, path, timeout) {
+    if (!this._throttled.has(actionType)) {
+      this._throttled.set(actionType, /* @__PURE__ */ new Map());
+    }
+    const action = this._throttled.get(actionType);
+    if (!action)
+      throw new Error("invalid throttle");
+    const actionPath = action.get(path);
+    if (actionPath) {
+      actionPath.count++;
+      return false;
+    }
+    let timeoutObject;
+    const clear = () => {
+      const item = action.get(path);
+      const count = item ? item.count : 0;
+      action.delete(path);
+      clearTimeout(timeoutObject);
+      if (item)
+        clearTimeout(item.timeoutObject);
+      return count;
+    };
+    timeoutObject = setTimeout(clear, timeout);
+    const thr = { timeoutObject, clear, count: 0 };
+    action.set(path, thr);
+    return thr;
+  }
+  _incrReadyCount() {
+    return this._readyCount++;
+  }
+  /**
+   * Awaits write operation to finish.
+   * Polls a newly created file for size variations. When files size does not change for 'threshold' milliseconds calls callback.
+   * @param path being acted upon
+   * @param threshold Time in milliseconds a file size must be fixed before acknowledging write OP is finished
+   * @param event
+   * @param awfEmit Callback to be called when ready for event to be emitted.
+   */
+  _awaitWriteFinish(path, threshold, event, awfEmit) {
+    const awf = this.options.awaitWriteFinish;
+    if (typeof awf !== "object")
+      return;
+    const pollInterval = awf.pollInterval;
+    let timeoutHandler;
+    let fullPath = path;
+    if (this.options.cwd && !sysPath2.isAbsolute(path)) {
+      fullPath = sysPath2.join(this.options.cwd, path);
+    }
+    const now = /* @__PURE__ */ new Date();
+    const writes = this._pendingWrites;
+    function awaitWriteFinishFn(prevStat) {
+      statcb(fullPath, (err, curStat) => {
+        if (err || !writes.has(path)) {
+          if (err && err.code !== "ENOENT")
+            awfEmit(err);
+          return;
+        }
+        const now2 = Number(/* @__PURE__ */ new Date());
+        if (prevStat && curStat.size !== prevStat.size) {
+          writes.get(path).lastChange = now2;
+        }
+        const pw = writes.get(path);
+        const df = now2 - pw.lastChange;
+        if (df >= threshold) {
+          writes.delete(path);
+          awfEmit(void 0, curStat);
+        } else {
+          timeoutHandler = setTimeout(awaitWriteFinishFn, pollInterval, curStat);
+        }
+      });
+    }
+    if (!writes.has(path)) {
+      writes.set(path, {
+        lastChange: now,
+        cancelWait: () => {
+          writes.delete(path);
+          clearTimeout(timeoutHandler);
+          return event;
+        }
+      });
+      timeoutHandler = setTimeout(awaitWriteFinishFn, pollInterval);
+    }
+  }
+  /**
+   * Determines whether user has asked to ignore this path.
+   */
+  _isIgnored(path, stats) {
+    if (this.options.atomic && DOT_RE.test(path))
+      return true;
+    if (!this._userIgnored) {
+      const { cwd } = this.options;
+      const ign = this.options.ignored;
+      const ignored = (ign || []).map(normalizeIgnored(cwd));
+      const ignoredPaths = [...this._ignoredPaths];
+      const list = [...ignoredPaths.map(normalizeIgnored(cwd)), ...ignored];
+      this._userIgnored = anymatch(list, void 0);
+    }
+    return this._userIgnored(path, stats);
+  }
+  _isntIgnored(path, stat7) {
+    return !this._isIgnored(path, stat7);
+  }
+  /**
+   * Provides a set of common helpers and properties relating to symlink handling.
+   * @param path file or directory pattern being watched
+   */
+  _getWatchHelpers(path) {
+    return new WatchHelper(path, this.options.followSymlinks, this);
+  }
+  // Directory helpers
+  // -----------------
+  /**
+   * Provides directory tracking objects
+   * @param directory path of the directory
+   */
+  _getWatchedDir(directory) {
+    const dir = sysPath2.resolve(directory);
+    if (!this._watched.has(dir))
+      this._watched.set(dir, new DirEntry(dir, this._boundRemove));
+    return this._watched.get(dir);
+  }
+  // File helpers
+  // ------------
+  /**
+   * Check for read permissions: https://stackoverflow.com/a/11781404/1358405
+   */
+  _hasReadPermissions(stats) {
+    if (this.options.ignorePermissionErrors)
+      return true;
+    return Boolean(Number(stats.mode) & 256);
+  }
+  /**
+   * Handles emitting unlink events for
+   * files and directories, and via recursion, for
+   * files and directories within directories that are unlinked
+   * @param directory within which the following item is located
+   * @param item      base path of item/directory
+   */
+  _remove(directory, item, isDirectory) {
+    const path = sysPath2.join(directory, item);
+    const fullPath = sysPath2.resolve(path);
+    isDirectory = isDirectory != null ? isDirectory : this._watched.has(path) || this._watched.has(fullPath);
+    if (!this._throttle("remove", path, 100))
+      return;
+    if (!isDirectory && this._watched.size === 1) {
+      this.add(directory, item, true);
+    }
+    const wp = this._getWatchedDir(path);
+    const nestedDirectoryChildren = wp.getChildren();
+    nestedDirectoryChildren.forEach((nested) => this._remove(path, nested));
+    const parent = this._getWatchedDir(directory);
+    const wasTracked = parent.has(item);
+    parent.remove(item);
+    if (this._symlinkPaths.has(fullPath)) {
+      this._symlinkPaths.delete(fullPath);
+    }
+    let relPath = path;
+    if (this.options.cwd)
+      relPath = sysPath2.relative(this.options.cwd, path);
+    if (this.options.awaitWriteFinish && this._pendingWrites.has(relPath)) {
+      const event = this._pendingWrites.get(relPath).cancelWait();
+      if (event === EVENTS.ADD)
+        return;
+    }
+    this._watched.delete(path);
+    this._watched.delete(fullPath);
+    const eventName = isDirectory ? EVENTS.UNLINK_DIR : EVENTS.UNLINK;
+    if (wasTracked && !this._isIgnored(path))
+      this._emit(eventName, path);
+    this._closePath(path);
+  }
+  /**
+   * Closes all watchers for a path
+   */
+  _closePath(path) {
+    this._closeFile(path);
+    const dir = sysPath2.dirname(path);
+    this._getWatchedDir(dir).remove(sysPath2.basename(path));
+  }
+  /**
+   * Closes only file-specific watchers
+   */
+  _closeFile(path) {
+    const closers = this._closers.get(path);
+    if (!closers)
+      return;
+    closers.forEach((closer) => closer());
+    this._closers.delete(path);
+  }
+  _addPathCloser(path, closer) {
+    if (!closer)
+      return;
+    let list = this._closers.get(path);
+    if (!list) {
+      list = [];
+      this._closers.set(path, list);
+    }
+    list.push(closer);
+  }
+  _readdirp(root, opts) {
+    if (this.closed)
+      return;
+    const options = { type: EVENTS.ALL, alwaysStat: true, lstat: true, ...opts, depth: 0 };
+    let stream = readdirp(root, options);
+    this._streams.add(stream);
+    stream.once(STR_CLOSE, () => {
+      stream = void 0;
+    });
+    stream.once(STR_END, () => {
+      if (stream) {
+        this._streams.delete(stream);
+        stream = void 0;
+      }
+    });
+    return stream;
+  }
+};
+function watch(paths, options = {}) {
+  const watcher = new FSWatcher(options);
+  watcher.add(paths);
+  return watcher;
+}
+
+// src/dev/dev-watcher.ts
+import { stat as stat6 } from "node:fs/promises";
+import { relative as relative3, sep as sep2 } from "node:path";
+var defaultPollIntervalMs = 1e3;
+function createDevWatcher(input) {
+  const ignorePrefixes = (input.ignore ?? []).map(normalizePrefix).filter(Boolean);
+  const ignored = (path) => shouldIgnoreWatchPath(relative3(input.root, path), ignorePrefixes);
+  const watcher = watch(input.root, {
+    ignoreInitial: true,
+    ignored,
+    atomic: true
+  });
+  watcher.on("all", (_event, path) => {
+    if (!ignored(path)) input.onChange(path);
+  });
+  let readySettled = false;
+  const ready = new Promise((resolve8, reject) => {
+    watcher.once("ready", () => {
+      readySettled = true;
+      resolve8();
+    });
+    watcher.on("error", (error) => {
+      if (readySettled) return;
+      readySettled = true;
+      reject(error instanceof Error ? error : new Error(String(error)));
+    });
+  });
+  let tracked = /* @__PURE__ */ new Map();
+  let trackGeneration = 0;
+  let polling = false;
+  const poll = async () => {
+    if (polling) return;
+    polling = true;
+    const map = tracked;
+    const generation = trackGeneration;
+    try {
+      for (const [path, previous] of [...map]) {
+        if (tracked !== map || generation !== trackGeneration) return;
+        const next = await fingerprint(path);
+        if (tracked !== map || generation !== trackGeneration) return;
+        if (!map.has(path)) continue;
+        if (previous !== null && next !== previous) {
+          if (tracked !== map || generation !== trackGeneration) return;
+          if (input.onChange(path) === false) continue;
+          if (tracked !== map || generation !== trackGeneration) return;
+          map.set(path, next);
+        } else if (previous === null) {
+          map.set(path, next);
+        }
+      }
+    } finally {
+      polling = false;
+    }
+  };
+  const timer = setInterval(() => void poll(), input.pollIntervalMs ?? defaultPollIntervalMs);
+  timer.unref();
+  return {
+    ready,
+    rebaseline: async () => {
+      const generation = ++trackGeneration;
+      const previousTracked = tracked;
+      tracked = /* @__PURE__ */ new Map();
+      const next = /* @__PURE__ */ new Map();
+      for (const path of previousTracked.keys()) {
+        next.set(path, await fingerprint(path));
+        if (generation !== trackGeneration) return;
+      }
+      if (generation !== trackGeneration) return;
+      tracked = next;
+      trackGeneration++;
+    },
+    track: async (paths, options) => {
+      const ignoreChanges = new Set(options?.ignoreChanges ?? []);
+      const generation = ++trackGeneration;
+      const previousTracked = tracked;
+      tracked = /* @__PURE__ */ new Map();
+      const changedDuringBuild = [];
+      const next = /* @__PURE__ */ new Map();
+      for (const path of paths) {
+        if (ignored(path)) continue;
+        const current = await fingerprint(path);
+        if (generation !== trackGeneration) return [];
+        const previous = previousTracked.get(path);
+        if (previous !== void 0 && previous !== null && current !== previous && !ignoreChanges.has(path)) {
+          changedDuringBuild.push(path);
+        }
+        next.set(path, current);
+      }
+      if (generation !== trackGeneration) return [];
+      tracked = next;
+      trackGeneration++;
+      return changedDuringBuild;
+    },
+    close: async () => {
+      clearInterval(timer);
+      trackGeneration++;
+      tracked = /* @__PURE__ */ new Map();
+      await watcher.close();
+    }
+  };
+}
+async function fingerprint(path) {
+  try {
+    const info = await stat6(path);
+    return `${info.ino}:${info.size}:${info.mtimeMs}`;
+  } catch {
+    return "missing";
+  }
+}
+function normalizePrefix(prefix) {
+  return prefix.replace(/^\.\//, "").replace(/\/+$/, "").split("/").join(sep2);
+}
+function shouldIgnoreWatchPath(relativePath, ignorePrefixes = []) {
+  if (!relativePath || relativePath === ".") return false;
+  if (relativePath.startsWith("..")) return true;
+  const segments = relativePath.split(sep2);
+  if (segments.some((segment) => segment === "node_modules" || segment.startsWith("."))) {
+    return true;
+  }
+  if (relativePath.endsWith(".map")) return true;
+  return ignorePrefixes.some(
+    (prefix) => relativePath === prefix || relativePath.startsWith(`${prefix}${sep2}`)
+  );
+}
+
+// src/dev/error-page.ts
+function wantsHtml(req) {
+  const accept = req.headers.accept ?? "";
+  return /\btext\/html\b/.test(accept);
+}
+function sendDevError(req, res, status, view, options = {}) {
+  if (res.headersSent) {
+    res.end();
+    return;
+  }
+  const headers = {
+    "cache-control": "no-store",
+    "x-kody-dev-error": view.kind
+  };
+  if (wantsHtml(req)) {
+    res.writeHead(status, { ...headers, "content-type": "text/html; charset=utf-8" });
+    res.end(renderDevErrorPage(view) + (options.htmlTail ?? ""));
+    return;
+  }
+  res.writeHead(status, { ...headers, "content-type": "text/plain; charset=utf-8" });
+  res.end(`kody dev ${view.kind} error${view.request ? ` (${view.request})` : ""}
+
+${view.detail}
+`);
+}
+function renderDevErrorPage(view) {
+  const label = view.kind === "build" ? "Build error" : "Runtime error";
+  return `<!doctype html>
+<html lang="en">
+<head>
+<meta charset="utf-8">
+<meta name="viewport" content="width=device-width, initial-scale=1">
+<title>${escapeHtml(label)} \xB7 kody dev</title>
+<style>
+	:root { color-scheme: dark; }
+	body { margin: 0; font: 14px/1.5 ui-sans-serif, system-ui, sans-serif; background: #1a1015; color: #f5e9ee; }
+	main { max-width: 960px; margin: 0 auto; padding: 32px 24px; }
+	.label { display: inline-block; font-size: 12px; font-weight: 600; letter-spacing: .04em; text-transform: uppercase; color: #ff8fab; }
+	h1 { font-size: 20px; margin: 8px 0 20px; word-break: break-word; }
+	pre { margin: 0; padding: 16px; overflow: auto; background: #0e080b; border: 1px solid #3a2530; border-radius: 8px; font: 13px/1.55 ui-monospace, SFMono-Regular, Menlo, monospace; white-space: pre; }
+	p { color: #bfa9b3; font-size: 13px; }
+</style>
+</head>
+<body>
+<main>
+<span class="label">${escapeHtml(label)}</span>
+<h1>${escapeHtml(view.title)}</h1>${view.request ? `
+<p>${escapeHtml(view.request)}</p>` : ""}
+<pre>${escapeHtml(view.detail)}</pre>
+<p>Served by <code>kody dev</code> only; published apps never see this page.</p>
+</main>
+</body>
+</html>
+`;
+}
+function escapeHtml(value) {
+  return value.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;").replace(/'/g, "&#39;");
+}
+
+// src/dev/live-reload.ts
+var liveReloadEventsPath = "/__kody/dev/events";
+var liveReloadClientPath = "/__kody/dev/client.js";
+var liveReloadScriptTag = `<script type="module" src="${liveReloadClientPath}"></script>`;
+var keepAliveMs = 15e3;
+function createLiveReloadHub(input) {
+  const clients = /* @__PURE__ */ new Set();
+  const send2 = (res, event, data) => {
+    res.write(`event: ${event}
+data: ${JSON.stringify(data)}
+
+`);
+  };
+  const keepAlive = setInterval(() => {
+    for (const res of clients) res.write(": keep-alive\n\n");
+  }, keepAliveMs);
+  keepAlive.unref();
+  return {
+    handleEvents: (req, res) => {
+      res.writeHead(200, {
+        "content-type": "text/event-stream; charset=utf-8",
+        "cache-control": "no-store",
+        connection: "keep-alive"
+      });
+      res.write("retry: 500\n\n");
+      send2(res, "hello", input.state());
+      clients.add(res);
+      req.on("close", () => clients.delete(res));
+    },
+    broadcast: (message) => {
+      for (const res of clients) send2(res, message.event, message.data);
+    },
+    clientCount: () => clients.size,
+    close: () => {
+      clearInterval(keepAlive);
+      for (const res of clients) res.end();
+      clients.clear();
+    }
+  };
+}
+function injectLiveReloadScript(html) {
+  if (html.includes(liveReloadClientPath)) return html;
+  for (const pattern of [/<\/head\s*>/i, /<\/body\s*>/i]) {
+    const match = pattern.exec(html);
+    if (match) {
+      return `${html.slice(0, match.index)}${liveReloadScriptTag}${html.slice(match.index)}`;
+    }
+  }
+  return `${html}${liveReloadScriptTag}`;
+}
+function shouldInjectLiveReload(input) {
+  if (input.method === "HEAD") return false;
+  if (!/\btext\/html\b/i.test(input.accept ?? "")) return false;
+  if (input.status === 204 || input.status === 304 || input.status < 200) return false;
+  const contentType = String(input.headers["content-type"] ?? "");
+  if (!/^\s*text\/html\b/i.test(contentType)) return false;
+  const encoding = String(input.headers["content-encoding"] ?? "identity").trim().toLowerCase();
+  return encoding === "" || encoding === "identity";
+}
+var liveReloadClientSource = `
+const eventsUrl = ${JSON.stringify(liveReloadEventsPath)};
+let buildId = null;
+let overlay = null;
+
+function hideOverlay() {
+	overlay?.remove();
+	overlay = null;
+}
+
+function showOverlay(view) {
+	if (globalThis.__kodyDevErrorPage) return;
+	hideOverlay();
+	const host = document.createElement('kody-dev-overlay');
+	const root = host.attachShadow({ mode: 'open' });
+	const label = view.kind === 'build' ? 'Build error' : 'Runtime error';
+	// Keep CSS out of the text tree (page-text readers / textContent walkers).
+	const sheet = new CSSStyleSheet();
+	sheet.replaceSync(\`
+	.backdrop { position: fixed; inset: 0; z-index: 2147483647; background: rgba(10, 4, 7, .82); display: flex; align-items: flex-start; justify-content: center; overflow: auto; font: 14px/1.5 ui-sans-serif, system-ui, sans-serif; }
+	.panel { margin: 48px 16px; max-width: 960px; width: 100%; background: #1a1015; color: #f5e9ee; border: 1px solid #3a2530; border-radius: 10px; padding: 20px 24px; box-shadow: 0 20px 60px rgba(0,0,0,.5); }
+	.top { display: flex; align-items: center; justify-content: space-between; gap: 16px; }
+	.label { font-size: 12px; font-weight: 600; letter-spacing: .04em; text-transform: uppercase; color: #ff8fab; }
+	button { all: unset; cursor: pointer; color: #bfa9b3; font-size: 20px; line-height: 1; padding: 4px 8px; border-radius: 6px; }
+	button:hover, button:focus-visible { background: #2a1a22; color: #fff; }
+	h1 { font-size: 18px; margin: 8px 0 4px; word-break: break-word; }
+	.request { color: #bfa9b3; font-size: 13px; margin: 0 0 12px; }
+	pre { margin: 12px 0 0; padding: 14px; overflow: auto; background: #0e080b; border: 1px solid #3a2530; border-radius: 8px; font: 13px/1.55 ui-monospace, SFMono-Regular, Menlo, monospace; white-space: pre; }
+	.hint { color: #bfa9b3; font-size: 12px; margin-top: 12px; }
+\`);
+	root.adoptedStyleSheets = [sheet];
+	root.innerHTML = \`
+<div class="backdrop" role="alertdialog" aria-modal="true" aria-labelledby="kody-dev-title">
+	<div class="panel">
+		<div class="top"><span class="label"></span><button type="button" aria-label="Dismiss">\xD7</button></div>
+		<h1 id="kody-dev-title"></h1>
+		<p class="request"></p>
+		<pre></pre>
+		<p class="hint">Fix it and save. The page reloads on the next good build. Esc dismisses.</p>
+	</div>
+</div>\`;
+	root.querySelector('.label').textContent = label;
+	root.querySelector('h1').textContent = view.title;
+	const request = root.querySelector('.request');
+	if (view.request) request.textContent = view.request;
+	else request.remove();
+	root.querySelector('pre').textContent = view.detail;
+	root.querySelector('button').addEventListener('click', hideOverlay);
+	document.documentElement.appendChild(host);
+	overlay = host;
+	root.querySelector('button').focus();
+}
+
+addEventListener('keydown', (event) => {
+	if (event.key === 'Escape') hideOverlay();
+});
+
+function connect() {
+	const source = new EventSource(eventsUrl);
+	source.addEventListener('hello', (event) => {
+		const state = JSON.parse(event.data);
+		if (buildId !== null && state.buildId !== null && state.buildId !== buildId) {
+			location.reload();
+			return;
+		}
+		buildId = state.buildId;
+		if (state.error) showOverlay(state.error);
+	});
+	source.addEventListener('reload', () => location.reload());
+	source.addEventListener('build_error', (event) => showOverlay(JSON.parse(event.data)));
+	source.addEventListener('runtime_error', (event) => showOverlay(JSON.parse(event.data)));
+}
+
+connect();
+`.trimStart();
+
+// src/dev/prebuild.ts
+import { spawn as spawn2 } from "node:child_process";
+var outputTailLines = 20;
+var PrebuildError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "PrebuildError";
+  }
+};
+async function runPrebuild(input) {
+  if (input.signal?.aborted) {
+    throw new PrebuildError("kody.dev.prebuild aborted before start");
+  }
+  const env = { ...process.env, KODY_DEV: "1" };
+  delete env[apiTokenEnvVar];
+  const child = spawn2("sh", ["-c", input.command], {
+    cwd: input.cwd,
+    env,
+    stdio: ["ignore", "pipe", "pipe"],
+    detached: true
+  });
+  if (child.pid) input.onSpawn?.(child.pid);
+  const tail = [];
+  const collect = (stream) => (line) => {
+    tail.push(line);
+    if (tail.length > outputTailLines) tail.shift();
+    input.onLine?.(line, stream);
+  };
+  forEachLine(child.stdout, collect("stdout"));
+  forEachLine(child.stderr, collect("stderr"));
+  const killChild = () => {
+    if (child.exitCode !== null || child.signalCode !== null) return;
+    const pid = child.pid;
+    if (pid === void 0) return;
+    try {
+      process.kill(-pid, "SIGKILL");
+    } catch {
+      try {
+        child.kill("SIGKILL");
+      } catch {
+      }
+    }
+  };
+  if (input.signal) {
+    if (input.signal.aborted) killChild();
+    else input.signal.addEventListener("abort", killChild, { once: true });
+  }
+  try {
+    const result = await new Promise(
+      (resolve8, reject) => {
+        child.once("error", reject);
+        child.once("close", (code, signal) => resolve8({ code, signal }));
+      }
+    );
+    if (input.signal?.aborted) {
+      throw new PrebuildError("kody.dev.prebuild aborted");
+    }
+    if (result.code === 0) return;
+    const how = result.signal ? `signal ${result.signal}` : `exit ${result.code}`;
+    throw new PrebuildError(
+      [`kody.dev.prebuild failed (${how}): ${input.command}`, ...tail.map((line) => `  ${line}`)].join(
+        "\n"
+      )
+    );
+  } finally {
+    input.signal?.removeEventListener("abort", killChild);
+    if (child.pid) input.onExit?.(child.pid);
+  }
+}
+function forEachLine(stream, onLine) {
+  if (!stream) return;
+  let buffered = "";
+  stream.on("data", (chunk) => {
+    buffered += typeof chunk === "string" ? chunk : chunk.toString("utf8");
+    const lines = buffered.split("\n");
+    buffered = lines.pop() ?? "";
+    for (const line of lines) {
+      if (line.length > 0) onLine(line);
+    }
+  });
+  stream.on("end", () => {
+    if (buffered.length > 0) onLine(buffered);
+    buffered = "";
+  });
+}
+
+// node_modules/@jridgewell/sourcemap-codec/dist/sourcemap-codec.mjs
+var comma = ",".charCodeAt(0);
+var semicolon = ";".charCodeAt(0);
+var chars = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
+var intToChar = new Uint8Array(64);
+var charToInt = new Uint8Array(128);
+for (let i = 0; i < chars.length; i++) {
+  const c = chars.charCodeAt(i);
+  intToChar[i] = c;
+  charToInt[c] = i;
+}
+function decodeInteger(reader) {
+  let value = 0;
+  let shift = 0;
+  let integer = 0;
+  do {
+    const c = reader.next();
+    integer = charToInt[c];
+    value |= (integer & 31) << shift;
+    shift += 5;
+  } while (integer & 32);
+  return value;
+}
+function decodeSign(num) {
+  return num & 1 ? -2147483648 | -(num >>> 1) : num >>> 1;
+}
+function hasMoreVlq(reader, max) {
+  if (reader.pos >= max) return false;
+  return reader.peek() !== comma;
+}
+var bufLength = 1024 * 16;
+var StringReader = class {
+  constructor(buffer) {
+    this.pos = 0;
+    this.buffer = buffer;
+  }
+  next() {
+    return this.buffer.charCodeAt(this.pos++);
+  }
+  peek() {
+    return this.buffer.charCodeAt(this.pos);
+  }
+  indexOf(char) {
+    const { buffer, pos } = this;
+    const idx = buffer.indexOf(char, pos);
+    return idx === -1 ? buffer.length : idx;
+  }
+};
+function decode(mappings) {
+  const { length } = mappings;
+  const reader = new StringReader(mappings);
+  const decoded = [];
+  let genColumn = 0;
+  let sourcesIndex = 0;
+  let sourceLine = 0;
+  let sourceColumn = 0;
+  let namesIndex = 0;
+  do {
+    const semi = reader.indexOf(";");
+    const line = [];
+    let sorted = true;
+    let lastCol = 0;
+    genColumn = 0;
+    while (reader.pos < semi) {
+      let seg;
+      genColumn += decodeSign(decodeInteger(reader));
+      if (genColumn < lastCol) sorted = false;
+      lastCol = genColumn;
+      if (hasMoreVlq(reader, semi)) {
+        sourcesIndex += decodeSign(decodeInteger(reader));
+        sourceLine += decodeSign(decodeInteger(reader));
+        sourceColumn += decodeSign(decodeInteger(reader));
+        if (hasMoreVlq(reader, semi)) {
+          namesIndex += decodeSign(decodeInteger(reader));
+          seg = [genColumn, sourcesIndex, sourceLine, sourceColumn, namesIndex];
+        } else {
+          seg = [genColumn, sourcesIndex, sourceLine, sourceColumn];
+        }
+      } else {
+        seg = [genColumn];
+      }
+      line.push(seg);
+      reader.pos++;
+    }
+    if (!sorted) sort(line);
+    decoded.push(line);
+    reader.pos = semi + 1;
+  } while (reader.pos <= length);
+  return decoded;
+}
+function sort(line) {
+  line.sort(sortComparator);
+}
+function sortComparator(a, b) {
+  return a[0] - b[0];
+}
+
+// node_modules/@jridgewell/resolve-uri/dist/resolve-uri.mjs
+var schemeRegex = /^[\w+.-]+:\/\//;
+var urlRegex = /^([\w+.-]+:)\/\/([^@/#?]*@)?([^:/#?]*)(:\d+)?(\/[^#?]*)?(\?[^#]*)?(#.*)?/;
+var fileRegex = /^file:(?:\/\/((?![a-z]:)[^/#?]*)?)?(\/?[^#?]*)(\?[^#]*)?(#.*)?/i;
+function isAbsoluteUrl(input) {
+  return schemeRegex.test(input);
+}
+function isSchemeRelativeUrl(input) {
+  return input.startsWith("//");
+}
+function isAbsolutePath(input) {
+  return input.startsWith("/");
+}
+function isFileUrl(input) {
+  return input.startsWith("file:");
+}
+function isRelative(input) {
+  return /^[.?#]/.test(input);
+}
+function parseAbsoluteUrl(input) {
+  const match = urlRegex.exec(input);
+  return makeUrl(match[1], match[2] || "", match[3], match[4] || "", match[5] || "/", match[6] || "", match[7] || "");
+}
+function parseFileUrl(input) {
+  const match = fileRegex.exec(input);
+  const path = match[2];
+  return makeUrl("file:", "", match[1] || "", "", isAbsolutePath(path) ? path : "/" + path, match[3] || "", match[4] || "");
+}
+function makeUrl(scheme, user, host, port, path, query, hash) {
+  return {
+    scheme,
+    user,
+    host,
+    port,
+    path,
+    query,
+    hash,
+    type: 7
+  };
+}
+function parseUrl(input) {
+  if (isSchemeRelativeUrl(input)) {
+    const url2 = parseAbsoluteUrl("http:" + input);
+    url2.scheme = "";
+    url2.type = 6;
+    return url2;
+  }
+  if (isAbsolutePath(input)) {
+    const url2 = parseAbsoluteUrl("http://foo.com" + input);
+    url2.scheme = "";
+    url2.host = "";
+    url2.type = 5;
+    return url2;
+  }
+  if (isFileUrl(input))
+    return parseFileUrl(input);
+  if (isAbsoluteUrl(input))
+    return parseAbsoluteUrl(input);
+  const url = parseAbsoluteUrl("http://foo.com/" + input);
+  url.scheme = "";
+  url.host = "";
+  url.type = input ? input.startsWith("?") ? 3 : input.startsWith("#") ? 2 : 4 : 1;
+  return url;
+}
+function stripPathFilename(path) {
+  if (path.endsWith("/.."))
+    return path;
+  const index = path.lastIndexOf("/");
+  return path.slice(0, index + 1);
+}
+function mergePaths(url, base) {
+  normalizePath2(base, base.type);
+  if (url.path === "/") {
+    url.path = base.path;
+  } else {
+    url.path = stripPathFilename(base.path) + url.path;
+  }
+}
+function normalizePath2(url, type) {
+  const rel = type <= 4;
+  const pieces = url.path.split("/");
+  let pointer = 1;
+  let positive = 0;
+  let addTrailingSlash = false;
+  for (let i = 1; i < pieces.length; i++) {
+    const piece = pieces[i];
+    if (!piece) {
+      addTrailingSlash = true;
+      continue;
+    }
+    addTrailingSlash = false;
+    if (piece === ".")
+      continue;
+    if (piece === "..") {
+      if (positive) {
+        addTrailingSlash = true;
+        positive--;
+        pointer--;
+      } else if (rel) {
+        pieces[pointer++] = piece;
+      }
+      continue;
+    }
+    pieces[pointer++] = piece;
+    positive++;
+  }
+  let path = "";
+  for (let i = 1; i < pointer; i++) {
+    path += "/" + pieces[i];
+  }
+  if (!path || addTrailingSlash && !path.endsWith("/..")) {
+    path += "/";
+  }
+  url.path = path;
+}
+function resolve5(input, base) {
+  if (!input && !base)
+    return "";
+  const url = parseUrl(input);
+  let inputType = url.type;
+  if (base && inputType !== 7) {
+    const baseUrl = parseUrl(base);
+    const baseType = baseUrl.type;
+    switch (inputType) {
+      case 1:
+        url.hash = baseUrl.hash;
+      // fall through
+      case 2:
+        url.query = baseUrl.query;
+      // fall through
+      case 3:
+      case 4:
+        mergePaths(url, baseUrl);
+      // fall through
+      case 5:
+        url.user = baseUrl.user;
+        url.host = baseUrl.host;
+        url.port = baseUrl.port;
+      // fall through
+      case 6:
+        url.scheme = baseUrl.scheme;
+    }
+    if (baseType > inputType)
+      inputType = baseType;
+  }
+  normalizePath2(url, inputType);
+  const queryHash = url.query + url.hash;
+  switch (inputType) {
+    // This is impossible, because of the empty checks at the start of the function.
+    // case UrlType.Empty:
+    case 2:
+    case 3:
+      return queryHash;
+    case 4: {
+      const path = url.path.slice(1);
+      if (!path)
+        return queryHash || ".";
+      if (isRelative(base || input) && !isRelative(path)) {
+        return "./" + path + queryHash;
+      }
+      return path + queryHash;
+    }
+    case 5:
+      return url.path + queryHash;
+    default:
+      return url.scheme + "//" + url.user + url.host + url.port + url.path + queryHash;
+  }
+}
+
+// node_modules/@jridgewell/trace-mapping/dist/trace-mapping.mjs
+function stripFilename(path) {
+  if (!path) return "";
+  const index = path.lastIndexOf("/");
+  return path.slice(0, index + 1);
+}
+function resolver(mapUrl, sourceRoot) {
+  const from = stripFilename(mapUrl);
+  const prefix = sourceRoot ? sourceRoot + "/" : "";
+  return (source) => resolve5(prefix + (source || ""), from);
+}
+var COLUMN = 0;
+var SOURCES_INDEX = 1;
+var SOURCE_LINE = 2;
+var SOURCE_COLUMN = 3;
+var NAMES_INDEX = 4;
+function maybeSort(mappings, owned) {
+  const unsortedIndex = nextUnsortedSegmentLine(mappings, 0);
+  if (unsortedIndex === mappings.length) return mappings;
+  if (!owned) mappings = mappings.slice();
+  for (let i = unsortedIndex; i < mappings.length; i = nextUnsortedSegmentLine(mappings, i + 1)) {
+    mappings[i] = sortSegments(mappings[i], owned);
+  }
+  return mappings;
+}
+function nextUnsortedSegmentLine(mappings, start) {
+  for (let i = start; i < mappings.length; i++) {
+    if (!isSorted(mappings[i])) return i;
+  }
+  return mappings.length;
+}
+function isSorted(line) {
+  for (let j = 1; j < line.length; j++) {
+    if (line[j][COLUMN] < line[j - 1][COLUMN]) {
+      return false;
+    }
+  }
+  return true;
+}
+function sortSegments(line, owned) {
+  if (!owned) line = line.slice();
+  return line.sort(sortComparator2);
+}
+function sortComparator2(a, b) {
+  return a[COLUMN] - b[COLUMN];
+}
+var found = false;
+function binarySearch(haystack, needle, low, high) {
+  while (low <= high) {
+    const mid = low + (high - low >> 1);
+    const cmp = haystack[mid][COLUMN] - needle;
+    if (cmp === 0) {
+      found = true;
+      return mid;
+    }
+    if (cmp < 0) {
+      low = mid + 1;
+    } else {
+      high = mid - 1;
+    }
+  }
+  found = false;
+  return low - 1;
+}
+function upperBound(haystack, needle, index) {
+  for (let i = index + 1; i < haystack.length; index = i++) {
+    if (haystack[i][COLUMN] !== needle) break;
+  }
+  return index;
+}
+function lowerBound(haystack, needle, index) {
+  for (let i = index - 1; i >= 0; index = i--) {
+    if (haystack[i][COLUMN] !== needle) break;
+  }
+  return index;
+}
+function memoizedState() {
+  return {
+    lastKey: -1,
+    lastNeedle: -1,
+    lastIndex: -1
+  };
+}
+function memoizedBinarySearch(haystack, needle, state, key) {
+  const { lastKey, lastNeedle, lastIndex } = state;
+  let low = 0;
+  let high = haystack.length - 1;
+  if (key === lastKey) {
+    if (needle === lastNeedle) {
+      found = lastIndex !== -1 && haystack[lastIndex][COLUMN] === needle;
+      return lastIndex;
+    }
+    if (needle >= lastNeedle) {
+      low = lastIndex === -1 ? 0 : lastIndex;
+    } else {
+      high = lastIndex;
+    }
+  }
+  state.lastKey = key;
+  state.lastNeedle = needle;
+  return state.lastIndex = binarySearch(haystack, needle, low, high);
+}
+function parse2(map) {
+  return typeof map === "string" ? JSON.parse(map) : map;
+}
+var LINE_GTR_ZERO = "`line` must be greater than 0 (lines start at line 1)";
+var COL_GTR_EQ_ZERO = "`column` must be greater than or equal to 0 (columns start at column 0)";
+var LEAST_UPPER_BOUND = -1;
+var GREATEST_LOWER_BOUND = 1;
+var TraceMap = class {
+  constructor(map, mapUrl) {
+    const isString = typeof map === "string";
+    if (!isString && map._decodedMemo) return map;
+    const parsed = parse2(map);
+    const { version, file, names, sourceRoot, sources, sourcesContent } = parsed;
+    this.version = version;
+    this.file = file;
+    this.names = names || [];
+    this.sourceRoot = sourceRoot;
+    this.sources = sources;
+    this.sourcesContent = sourcesContent;
+    this.ignoreList = parsed.ignoreList || parsed.x_google_ignoreList || void 0;
+    const resolve8 = resolver(mapUrl, sourceRoot);
+    this.resolvedSources = sources.map(resolve8);
+    const { mappings } = parsed;
+    if (typeof mappings === "string") {
+      this._encoded = mappings;
+      this._decoded = void 0;
+    } else if (Array.isArray(mappings)) {
+      this._encoded = void 0;
+      this._decoded = maybeSort(mappings, isString);
+    } else if (parsed.sections) {
+      throw new Error(`TraceMap passed sectioned source map, please use FlattenMap export instead`);
+    } else {
+      throw new Error(`invalid source map: ${JSON.stringify(parsed)}`);
+    }
+    this._decodedMemo = memoizedState();
+    this._bySources = void 0;
+    this._bySourceMemos = void 0;
+  }
+};
+function cast(map) {
+  return map;
+}
+function decodedMappings(map) {
+  var _a;
+  return (_a = cast(map))._decoded || (_a._decoded = decode(cast(map)._encoded));
+}
+function originalPositionFor(map, needle) {
+  let { line, column, bias } = needle;
+  line--;
+  if (line < 0) throw new Error(LINE_GTR_ZERO);
+  if (column < 0) throw new Error(COL_GTR_EQ_ZERO);
+  const decoded = decodedMappings(map);
+  if (line >= decoded.length) return OMapping(null, null, null, null);
+  const segments = decoded[line];
+  const index = traceSegmentInternal(
+    segments,
+    cast(map)._decodedMemo,
+    line,
+    column,
+    bias || GREATEST_LOWER_BOUND
+  );
+  if (index === -1) return OMapping(null, null, null, null);
+  const segment = segments[index];
+  if (segment.length === 1) return OMapping(null, null, null, null);
+  const { names, resolvedSources } = map;
+  return OMapping(
+    resolvedSources[segment[SOURCES_INDEX]],
+    segment[SOURCE_LINE] + 1,
+    segment[SOURCE_COLUMN],
+    segment.length === 5 ? names[segment[NAMES_INDEX]] : null
+  );
+}
+function OMapping(source, line, column, name) {
+  return { source, line, column, name };
+}
+function traceSegmentInternal(segments, memo, line, column, bias) {
+  let index = memoizedBinarySearch(segments, column, memo, line);
+  if (found) {
+    index = (bias === LEAST_UPPER_BOUND ? upperBound : lowerBound)(segments, column, index);
+  } else if (bias === LEAST_UPPER_BOUND) index++;
+  if (index === -1 || index === segments.length) return -1;
+  return index;
+}
+
+// src/dev/stack-trace.ts
+var internalModules = /* @__PURE__ */ new Set([
+  "__kody_local_entry.js",
+  "kody:runtime",
+  ".__kody_runtime__.js",
+  "runtime.js",
+  "entry.js"
+]);
+var framePattern = /^(\s*at\s+)(?:(.*?)\s+\()?([^()\s]+?):(\d+):(\d+)\)?\s*$/;
+function createStackMapper(input) {
+  let map = null;
+  if (input.sourceMap) {
+    try {
+      map = new TraceMap(input.sourceMap);
+    } catch {
+      map = null;
+    }
+  }
+  return (stack) => {
+    const out = [];
+    for (const line of stack.split("\n")) {
+      if (!/^\s*at\s/.test(line)) {
+        out.push(line);
+        continue;
+      }
+      const match = framePattern.exec(line);
+      if (!match) continue;
+      const [, lead, fn, file, lineText, colText] = match;
+      const module = file.replace(/^file:\/\/\//, "").replace(/^\//, "");
+      if (internalModules.has(module)) continue;
+      const fnPart = fn ? `${fn} (` : "";
+      const close = fn ? ")" : "";
+      if (map && module === input.userModule) {
+        const original = originalPositionFor(map, {
+          line: Number(lineText),
+          column: Number(colText) - 1
+        });
+        if (original.source && original.line !== null) {
+          const name = fn ?? original.name;
+          out.push(
+            `${lead}${name ? `${name} (` : ""}${original.source}:${original.line}:${(original.column ?? 0) + 1}${name ? ")" : ""}`
+          );
+          continue;
+        }
+      }
+      out.push(`${lead}${fnPart}${file}:${lineText}:${colText}${close}`);
+    }
+    return out.join("\n");
+  };
+}
+
+// src/dev/workerd-process.ts
+import { spawn as spawn3 } from "node:child_process";
+import { createInterface } from "node:readline";
+var workerdStartTimeoutMs = 3e4;
+async function startWorkerd(input) {
+  const child = spawn3(input.workerdPath, ["serve", input.configPath, "--control-fd=3"], {
+    cwd: input.cwd,
+    env: input.env,
+    stdio: ["ignore", "pipe", "pipe", "pipe"]
+  });
+  if (child.pid !== void 0) input.onSpawn?.(child.pid);
+  let startupStderr = "";
+  let listening = false;
+  forEachLine2(child.stdout, input.onStdoutLine);
+  forEachLine2(child.stderr, (line) => {
+    if (!listening) startupStderr += `${line}
+`;
+    input.onStderrLine(line);
+  });
+  const exited = new Promise((resolve8) => {
+    child.once("exit", (code, signal) => resolve8(`workerd exit ${signal ?? code}`));
+    child.once("error", (error) => resolve8(`workerd error: ${error.message}`));
+  });
+  const port = await waitForListen(child, exited, () => {
+    const trimmed = redact(startupStderr.trim());
+    return trimmed ? `
+${trimmed}` : "";
+  });
+  listening = true;
+  return {
+    pid: child.pid ?? -1,
+    port,
+    exited,
+    kill: async () => {
+      if (child.exitCode !== null || child.signalCode !== null) return;
+      child.kill("SIGKILL");
+      await Promise.race([exited, new Promise((resolve8) => setTimeout(resolve8, 1e3))]);
+    }
+  };
+}
+function forEachLine2(stream, onLine) {
+  if (!stream) return;
+  const lines = createInterface({ input: stream, crlfDelay: Infinity });
+  lines.on("line", (line) => {
+    if (line.length > 0) onLine(line);
+  });
+}
+function waitForListen(child, exited, stderr) {
+  return new Promise((resolve8, reject) => {
+    const control = child.stdio[3];
+    let buffered = "";
+    let settled = false;
+    const settle = (fn) => {
+      if (settled) return;
+      settled = true;
+      clearTimeout(timer);
+      fn();
+    };
+    const timer = setTimeout(() => {
+      settle(() => {
+        child.kill("SIGKILL");
+        reject(
+          new Error(`workerd did not start within ${workerdStartTimeoutMs / 1e3}s.${stderr()}`)
+        );
+      });
+    }, workerdStartTimeoutMs);
+    control?.on("data", (chunk) => {
+      buffered += chunk.toString("utf8");
+      const lines = buffered.split("\n");
+      buffered = lines.pop() ?? "";
+      for (const line of lines) {
+        const port = parseListenPort(line);
+        if (port !== null) settle(() => resolve8(port));
+      }
+    });
+    void exited.then((detail) => {
+      settle(() => reject(new Error(`workerd failed to start (${detail})${stderr()}`)));
+    });
+  });
+}
+function parseListenPort(line) {
+  if (!line.trim()) return null;
+  try {
+    const event = JSON.parse(line);
+    return event.event === "listen" && event.socket === "http" && typeof event.port === "number" ? event.port : null;
+  } catch {
+    return null;
+  }
+}
+function cleanWorkerdStderrLine(line) {
+  const trimmed = line.trim();
+  if (!trimmed) return null;
+  if (/^stack:(\s+\S+@[0-9a-fx]+)+\s*$/i.test(trimmed)) return null;
+  const prefixed = /^workerd\/\S+:\d+: (?:error|warning|info|debug): (.*)$/.exec(trimmed);
+  const body = prefixed ? prefixed[1] : trimmed;
+  return body.replace(/\S+\.(?:c\+\+|h):\d+: failed: /g, "").replace(/(?:remote\.)?jsg\.(\w*Error)(?=:)/g, "$1");
+}
+
+// src/package-app-dev.ts
+var defaultDebounceMs = 30;
+var prebuildSettleMs = 150;
+var failedPrebuildAbsorbMs = 1500;
+var rebuildGateMs = 1e4;
+var drainTimeoutMs = 1e4;
+async function startPackageAppDev(options) {
+  if (!options.manifest.app?.entry) {
+    throw new Error(
+      'This package has no kody.app.entry. Add `"kody": { "app": { "entry": "./app/router.ts" } }` or use `kody dev job|webhook|emit|check`.'
+    );
+  }
+  assertTokenSafeApiUrl(options.apiUrl);
+  const host = options.host ?? "127.0.0.1";
+  const appBasePath = normalizeBasePath(options.appBasePath ?? "");
+  const root = options.manifest.root;
+  const runSecret = randomBytes(32).toString("hex");
+  const emit = (event) => options.onEvent?.(event);
+  const liveReload = options.liveReload ?? options.watch !== false;
+  const errorPageTail = liveReload ? `<script>globalThis.__kodyDevErrorPage = true</script>${liveReloadScriptTag}` : "";
+  void sweepStaleDevDirs().catch(() => {
+  });
+  const workDir = await mkdtemp(join7(tmpdir2(), devWorkDirPrefix));
+  const reaper = await startProcessReaper({ workDir });
+  const workerdPath = options.workerdPath ?? await ensureWorkerdBinary({
+    onDownload: (url) => options.onStatus?.(`Downloading workerd from ${url}\u2026`)
+  });
+  const client = {
+    apiUrl: options.apiUrl,
+    token: options.token,
+    fetchFn: options.fetchFn,
+    ...options.org ? { org: options.org } : {}
+  };
+  const generations = /* @__PURE__ */ new Set();
+  let active;
+  let buildFailure = null;
+  let generationCounter = 0;
+  let requestCounter = 0;
+  let closed = false;
+  let buildLoop = null;
+  let rebuildAgain = false;
+  const changedFiles = /* @__PURE__ */ new Set();
+  let debouncePending = false;
+  let debounceFlush = null;
+  let resolveDebounceFlush = null;
+  let debounceTimer;
+  const liveReloadHub = createLiveReloadHub({
+    state: () => ({
+      buildId: active?.id ?? null,
+      error: buildFailure ? buildErrorView(buildFailure) : null
+    })
+  });
+  const startedAt = (/* @__PURE__ */ new Date()).toISOString();
+  let lastRebuild = null;
+  let lastRuntimeError = null;
+  let buildFailureAt = startedAt;
+  let markStarted = () => {
+  };
+  const started = new Promise((resolve8) => {
+    markStarted = resolve8;
+  });
+  const killAllSync = () => {
+    for (const generation of generations) {
+      try {
+        process.kill(generation.workerd.pid, "SIGKILL");
+      } catch {
+      }
+    }
+    try {
+      rmSync(workDir, { recursive: true, force: true });
+    } catch {
+    }
+  };
+  process.once("exit", killAllSync);
+  const proxy = createServer((req, res) => {
+    void handleRequest(req, res);
+  });
+  try {
+    await listenDevServer(proxy, {
+      host,
+      port: options.port ?? options.defaultPort ?? 0,
+      explicit: options.port !== void 0
+    });
+  } catch (error) {
+    process.off("exit", killAllSync);
+    reaper.close();
+    await rm3(workDir, { recursive: true, force: true });
+    throw error;
+  }
+  const address = proxy.address();
+  const hostedUrl = `http://${host}:${address.port}`;
+  try {
+    await options.onListening?.({
+      port: address.port,
+      hostedUrl,
+      appBasePath
+    });
+  } catch (error) {
+    process.off("exit", killAllSync);
+    reaper.close();
+    proxy.closeAllConnections();
+    await new Promise((resolve8) => {
+      proxy.close(() => resolve8());
+    });
+    await rm3(workDir, { recursive: true, force: true });
+    throw error;
+  }
+  const contextFor = (client2) => buildLocalPackageContext({
+    kodyId: options.manifest.kodyId,
+    packageId: `local:${options.manifest.kodyId}`,
+    hostedUrl,
+    appBasePath,
+    clientModuleUrl: client2 ? clientModuleUrlFor(client2) : null
+  });
+  const clientModuleUrlFor = (client2) => `${hostedUrl}${appBasePath}/_assets/${client2.name}`;
+  const mockFetchGateway = await resolveMockFetchGateway({
+    target: options.target,
+    packageRoot: root,
+    passthroughHosts: options.passthroughHosts,
+    allowPrivateNetwork: options.allowPrivateNetwork,
+    onStatus: options.onStatus
+  });
+  const bridge = await startLocalRuntimeBridge({
+    runSecret,
+    forwardCall: async (call, signal) => {
+      const mocked = tryHandleMockGatewayFetchCall({
+        gateway: mockFetchGateway,
+        path: call.path,
+        args: call.args,
+        signal
+      });
+      if (mocked) return await mocked;
+      return await callCapabilityProxy({
+        ...client,
+        ...call,
+        signal
+      });
+    },
+    forwardGatewayFetchStream: async ({ request, response, signal }) => {
+      await forwardLocalGatewayFetchStream({
+        request,
+        response,
+        signal,
+        client,
+        ...mockFetchGateway ? { mockFetchGateway } : {}
+      });
+    }
+  });
+  const app = options.manifest.app;
+  const entryPath = resolvePackagePath(options.manifest, app.entry);
+  const bundler = createDevBundler({ entryPath, root });
+  const clientBundler = app.client ? createDevClientBundler({
+    entryPath: resolvePackagePath(options.manifest, app.client),
+    root,
+    externals: app.clientExternals
+  }) : null;
+  const assetsDir = app.assets ? resolve6(root, app.assets) : null;
+  const prebuild = options.manifest.dev?.prebuild;
+  let prebuildRunning = false;
+  let prebuildSettledAt = 0;
+  let ignoreWatcherUntil = 0;
+  let prebuildAbort;
+  const workerdEnv = { ...process.env, [runSecretEnvVar]: runSecret };
+  delete workerdEnv[apiTokenEnvVar];
+  function requestBuild(paths) {
+    if (closed) return Promise.resolve();
+    for (const path of paths) changedFiles.add(path);
+    if (buildLoop) {
+      rebuildAgain = true;
+      return buildLoop;
+    }
+    buildLoop = (async () => {
+      do {
+        rebuildAgain = false;
+        const files = [...changedFiles];
+        changedFiles.clear();
+        await buildOnce(files);
+      } while (rebuildAgain && !closed);
+    })().finally(() => {
+      buildLoop = null;
+    });
+    return buildLoop;
+  }
+  async function buildOnce(files) {
+    const started2 = performance.now();
+    emit({ type: "rebuild_start", files: files.map((file) => relative4(root, file) || file) });
+    const assetsChanged = assetsDir !== null && files.some((file) => file === assetsDir || file.startsWith(`${assetsDir}${sep3}`));
+    try {
+      if (prebuild) {
+        await runPrebuildStep(prebuild);
+      }
+      const [bundle, client2] = await Promise.all([
+        bundler.build(),
+        clientBundler ? clientBundler.build() : Promise.resolve(null)
+      ]);
+      const midBuildEdits = await watcher?.track(
+        [...bundle.inputs, ...client2?.inputs ?? [], options.manifest.packageJsonPath],
+        { ignoreChanges: files }
+      ) ?? [];
+      if (midBuildEdits.length > 0) {
+        for (const path of midBuildEdits) changedFiles.add(path);
+        rebuildAgain = true;
+      }
+      if (active && !buildFailure && bundle.code === active.code && client2?.name === active.client?.name) {
+        lastRebuild = { ms: elapsed(started2), at: (/* @__PURE__ */ new Date()).toISOString() };
+        emit({
+          type: "rebuild_ok",
+          ms: lastRebuild.ms,
+          buildId: active.id,
+          restarted: false
+        });
+        if (assetsChanged || prebuild) {
+          liveReloadHub.broadcast({ event: "reload", data: { buildId: active.id } });
+        }
+        return;
+      }
+      const generation = await startGeneration(bundle, client2);
+      if (closed) {
+        await stopGeneration(generation);
+        return;
+      }
+      const previous = active;
+      active = generation;
+      buildFailure = null;
+      if (previous) retireGeneration(previous);
+      lastRuntimeError = null;
+      lastRebuild = { ms: elapsed(started2), at: (/* @__PURE__ */ new Date()).toISOString() };
+      emit({ type: "rebuild_ok", ms: lastRebuild.ms, buildId: generation.id, restarted: true });
+      liveReloadHub.broadcast({ event: "reload", data: { buildId: generation.id } });
+    } catch (error) {
+      buildFailure = toBuildFailure(error);
+      buildFailureAt = (/* @__PURE__ */ new Date()).toISOString();
+      const [first] = buildFailure.diagnostics;
+      emit({
+        type: "build_error",
+        ms: elapsed(started2),
+        message: buildFailure.message,
+        file: first?.file ?? null,
+        line: first?.line ?? null,
+        col: first?.col ?? null,
+        diagnostics: buildFailure.diagnostics
+      });
+      liveReloadHub.broadcast({ event: "build_error", data: buildErrorView(buildFailure) });
+    }
+  }
+  let clearWatcherPending = null;
+  async function runPrebuildStep(command) {
+    prebuildRunning = true;
+    prebuildAbort = new AbortController();
+    let failed = false;
+    try {
+      await runPrebuild({
+        command,
+        cwd: root,
+        signal: prebuildAbort.signal,
+        onSpawn: (pid) => reaper.trackGroup(pid),
+        onExit: (pid) => reaper.untrackGroup(pid),
+        onLine: (line, stream) => emit({
+          type: "log",
+          source: "prebuild",
+          level: stream === "stderr" ? "warn" : "log",
+          message: redact(line),
+          request: null
+        })
+      });
+    } catch (error) {
+      failed = true;
+      throw error;
+    } finally {
+      prebuildAbort = void 0;
+      prebuildRunning = false;
+      prebuildSettledAt = performance.now();
+      await watcher?.rebaseline();
+      if (failed) {
+        changedFiles.clear();
+        rebuildAgain = false;
+        clearWatcherPending?.();
+        ignoreWatcherUntil = performance.now() + failedPrebuildAbsorbMs;
+      }
+    }
+  }
+  async function startGeneration(bundle, client2) {
+    const id = ++generationCounter;
+    const dir = join7(workDir, `g${id}`);
+    await writeWorkerFiles({
+      workDir: dir,
+      code: bundle.code,
+      packageContext: contextFor(client2),
+      packageRoot: root,
+      mockStorage: options.target === "mock",
+      bridgePort: bridge.port,
+      allowPrivateNetwork: options.allowPrivateNetwork,
+      apiUrl: options.apiUrl,
+      token: options.token,
+      org: options.org,
+      fetchFn: options.fetchFn,
+      depResolve: options.depResolve,
+      mockFetchGateway,
+      onStatus: options.onStatus
+    });
+    let trackedPid;
+    let workerd;
+    try {
+      workerd = await startWorkerd({
+        workerdPath,
+        configPath: join7(dir, "config.capnp"),
+        cwd: dir,
+        env: workerdEnv,
+        onSpawn: (pid) => {
+          trackedPid = pid;
+          reaper.track(pid);
+        },
+        onStdoutLine: (line) => emit(parseWorkerdStdoutLine(line)),
+        onStderrLine: (line) => {
+          const cleaned = cleanWorkerdStderrLine(line);
+          if (cleaned === null) return;
+          emit({
+            type: "log",
+            source: "workerd",
+            level: "error",
+            message: redact(cleaned),
+            request: null
+          });
+        }
+      });
+    } catch (error) {
+      if (trackedPid !== void 0) reaper.untrack(trackedPid);
+      await rm3(dir, { recursive: true, force: true }).catch(() => {
+      });
+      throw error;
+    }
+    const generation = {
+      id,
+      dir,
+      workerd,
+      code: bundle.code,
+      client: client2,
+      mapStack: createStackMapper({
+        sourceMap: bundle.sourceMap,
+        userModule: localWorkerModuleNames.user
+      }),
+      inflight: 0,
+      retired: false,
+      stopped: false
+    };
+    generations.add(generation);
+    void workerd.exited.then((detail) => {
+      reaper.untrack(workerd.pid);
+      if (closed || generation.retired || active !== generation) return;
+      active = void 0;
+      buildFailure = {
+        message: `workerd stopped unexpectedly (${detail}). Save a file to restart it.`,
+        diagnostics: []
+      };
+      options.onError?.(buildFailure.message);
+    });
+    return generation;
+  }
+  function retireGeneration(generation) {
+    generation.retired = true;
+    if (generation.inflight === 0) {
+      void stopGeneration(generation);
+      return;
+    }
+    setTimeout(() => void stopGeneration(generation), drainTimeoutMs).unref();
+  }
+  async function stopGeneration(generation) {
+    if (generation.stopped) return;
+    generation.stopped = true;
+    generation.retired = true;
+    await generation.workerd.kill();
+    reaper.untrack(generation.workerd.pid);
+    generations.delete(generation);
+    await rm3(generation.dir, { recursive: true, force: true });
+  }
+  async function waitForBuild() {
+    const flush = debounceFlush;
+    if (flush) await flush;
+    const pending = buildLoop ?? (active || buildFailure ? null : started);
+    if (!pending) return;
+    await Promise.race([
+      pending.catch(() => {
+      }),
+      new Promise((resolve8) => setTimeout(resolve8, rebuildGateMs).unref())
+    ]);
+  }
+  function status() {
+    const [first] = buildFailure?.diagnostics ?? [];
+    return {
+      ok: buildFailure === null && active !== void 0,
+      state: buildLoop || debouncePending ? "building" : buildFailure ? "build_error" : active ? "ready" : "starting",
+      buildId: active?.id ?? null,
+      url: `${hostedUrl}${appBasePath || "/"}`,
+      port: address.port,
+      basePath: appBasePath,
+      target: options.target,
+      package: {
+        name: options.manifest.name,
+        kodyId: options.manifest.kodyId,
+        root
+      },
+      pid: process.pid,
+      startedAt,
+      lastRebuild,
+      lastError: buildFailure ? {
+        kind: "build",
+        message: buildFailure.message,
+        file: first?.file ?? null,
+        line: first?.line ?? null,
+        col: first?.col ?? null,
+        at: buildFailureAt
+      } : lastRuntimeError
+    };
+  }
+  function handleDevRoute(req, res) {
+    const pathname = stripMount(new URL(req.url ?? "/", hostedUrl).pathname, appBasePath);
+    if (pathname === devStatusPath) {
+      res.writeHead(200, {
+        "content-type": "application/json; charset=utf-8",
+        "cache-control": "no-store"
+      });
+      res.end(`${JSON.stringify(status(), null, 2)}
+`);
+      return true;
+    }
+    if (!liveReload) return false;
+    if (pathname === liveReloadEventsPath) {
+      liveReloadHub.handleEvents(req, res);
+      return true;
+    }
+    if (pathname === liveReloadClientPath) {
+      res.writeHead(200, {
+        "content-type": "text/javascript; charset=utf-8",
+        "cache-control": "no-store"
+      });
+      res.end(liveReloadClientSource);
+      return true;
+    }
+    return false;
+  }
+  async function handleRequest(req, res) {
+    try {
+      if (handleDevRoute(req, res)) return;
+      await waitForBuild();
+      const assetPath = parseDevAssetPath(
+        stripMount(new URL(req.url ?? "/", hostedUrl).pathname, appBasePath)
+      );
+      if (assetPath !== null) {
+        const client2 = active?.client ?? null;
+        await serveDevAsset({
+          req,
+          res,
+          relativePath: assetPath,
+          assetsDir,
+          client: client2,
+          clientModuleUrl: client2 ? clientModuleUrlFor(client2) : null,
+          appBasePath
+        });
+        return;
+      }
+      if (buildFailure) {
+        sendDevError(req, res, 500, buildErrorView(buildFailure), {
+          htmlTail: errorPageTail
+        });
+        return;
+      }
+      const generation = active;
+      if (!generation) {
+        res.writeHead(503, { "content-type": "text/plain; charset=utf-8" });
+        res.end(closed ? "kody dev is shutting down.\n" : "kody dev is still starting.\n");
+        return;
+      }
+      generation.inflight += 1;
+      try {
+        await forwardRequest(generation, req, res);
+      } finally {
+        generation.inflight -= 1;
+        if (generation.retired && generation.inflight === 0) {
+          void stopGeneration(generation);
+        }
+      }
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      options.onError?.(`Dev proxy error: ${message}`);
+      if (!res.headersSent) {
+        res.writeHead(502, { "content-type": "text/plain; charset=utf-8" });
+        res.end(`Dev proxy error: ${message}
+`);
+      } else if (!res.writableEnded) {
+        res.destroy();
+      }
+    }
+  }
+  function forwardRequest(generation, req, res) {
+    const incomingUrl = new URL(req.url ?? "/", hostedUrl);
+    const restPath = stripMount(incomingUrl.pathname, appBasePath);
+    const forwardUrl = new URL(
+      restPath + incomingUrl.search,
+      `http://127.0.0.1:${generation.workerd.port}`
+    );
+    const tag = {
+      id: String(++requestCounter),
+      method: req.method ?? "GET",
+      path: restPath + incomingUrl.search
+    };
+    const headers = {
+      ...req.headers,
+      host: `127.0.0.1:${generation.workerd.port}`,
+      [runSecretHeader]: runSecret,
+      [devRequestIdHeader]: tag.id
+    };
+    return new Promise((resolve8, reject) => {
+      const upstream = httpRequest(
+        forwardUrl,
+        { method: req.method, headers },
+        (upstreamRes) => {
+          if (upstreamRes.headers[devErrorHeader]) {
+            void readStream(upstreamRes).then((raw) => {
+              respondWithRuntimeError(generation, req, res, tag, raw);
+              resolve8();
+            }).catch(reject);
+            return;
+          }
+          const status2 = upstreamRes.statusCode ?? 502;
+          if (status2 >= 500) {
+            emit({
+              type: "log",
+              source: "app",
+              level: "warn",
+              message: `responded HTTP ${status2}`,
+              request: tag
+            });
+          }
+          if (liveReload && shouldInjectLiveReload({
+            method: req.method,
+            accept: req.headers.accept,
+            status: status2,
+            headers: upstreamRes.headers
+          })) {
+            void readStream(upstreamRes).then((html) => {
+              const body = Buffer.from(injectLiveReloadScript(html), "utf8");
+              const headers2 = { ...upstreamRes.headers };
+              delete headers2["transfer-encoding"];
+              headers2["content-length"] = String(body.length);
+              res.writeHead(status2, headers2);
+              res.end(body);
+              resolve8();
+            }).catch(reject);
+            return;
+          }
+          res.writeHead(status2, upstreamRes.headers);
+          upstreamRes.pipe(res);
+          upstreamRes.on("end", () => resolve8());
+          upstreamRes.on("error", reject);
+        }
+      );
+      upstream.on("error", reject);
+      res.on("close", () => {
+        if (!res.writableFinished) upstream.destroy();
+        resolve8();
+      });
+      req.pipe(upstream);
+    });
+  }
+  function respondWithRuntimeError(generation, req, res, tag, raw) {
+    let message = "Uncaught error";
+    let stack = "";
+    try {
+      const parsed = JSON.parse(raw);
+      message = `${parsed.name ?? "Error"}: ${parsed.message ?? ""}`;
+      stack = parsed.stack ?? message;
+    } catch {
+      stack = raw;
+    }
+    const mapped = redact(generation.mapStack(stack));
+    const fix = runtimeErrorFix(message);
+    lastRuntimeError = {
+      kind: "runtime",
+      message: redact(message),
+      stack: mapped,
+      request: tag,
+      ...fix ? { fix } : {},
+      at: (/* @__PURE__ */ new Date()).toISOString()
+    };
+    emit({
+      type: "runtime_error",
+      message: redact(message),
+      stack: mapped,
+      request: tag,
+      ...fix ? { fix } : {}
+    });
+    const view = {
+      kind: "runtime",
+      title: redact(message),
+      detail: fix ? `${mapped}
+
+fix: ${fix}` : mapped,
+      request: `${tag.method} ${tag.path}`
+    };
+    liveReloadHub.broadcast({ event: "runtime_error", data: view });
+    sendDevError(req, res, 500, view, { htmlTail: errorPageTail });
+  }
+  const watcher = options.watch === false ? null : (() => {
+    const pending = /* @__PURE__ */ new Set();
+    clearWatcherPending = () => {
+      pending.clear();
+      clearTimeout(debounceTimer);
+      debouncePending = false;
+      const resolve8 = resolveDebounceFlush;
+      resolveDebounceFlush = null;
+      debounceFlush = null;
+      resolve8?.();
+    };
+    return createDevWatcher({
+      root,
+      ignore: options.manifest.dev?.ignore,
+      onChange: (path) => {
+        if (closed) return;
+        const now = performance.now();
+        if (prebuildRunning || now - prebuildSettledAt < prebuildSettleMs) {
+          return;
+        }
+        if (now < ignoreWatcherUntil) {
+          return false;
+        }
+        if (buildLoop) {
+          changedFiles.add(path);
+          rebuildAgain = true;
+          return;
+        }
+        pending.add(path);
+        debouncePending = true;
+        if (!debounceFlush) {
+          debounceFlush = new Promise((resolve8) => {
+            resolveDebounceFlush = resolve8;
+          });
+        }
+        clearTimeout(debounceTimer);
+        debounceTimer = setTimeout(() => {
+          const paths = [...pending];
+          pending.clear();
+          debouncePending = false;
+          const build = requestBuild(paths);
+          const resolve8 = resolveDebounceFlush;
+          resolveDebounceFlush = null;
+          debounceFlush = null;
+          resolve8?.();
+          void build;
+        }, options.debounceMs ?? defaultDebounceMs);
+      }
+    });
+  })();
+  const close = async () => {
+    if (closed) return;
+    closed = true;
+    process.off("exit", killAllSync);
+    clearTimeout(debounceTimer);
+    debouncePending = false;
+    const resolve8 = resolveDebounceFlush;
+    resolveDebounceFlush = null;
+    debounceFlush = null;
+    resolve8?.();
+    prebuildAbort?.abort();
+    await watcher?.close();
+    await buildLoop?.catch(() => {
+    });
+    await bundler.dispose();
+    await clientBundler?.dispose();
+    await Promise.all([...generations].map((generation) => stopGeneration(generation)));
+    reaper.close();
+    await bridge.close();
+    liveReloadHub.close();
+    proxy.closeAllConnections();
+    await new Promise((resolve9) => {
+      proxy.close(() => resolve9());
+    });
+    await rm3(workDir, { recursive: true, force: true });
+  };
+  try {
+    await Promise.all([requestBuild([]), watcher?.ready]);
+  } catch (error) {
+    await close();
+    throw error;
+  } finally {
+    markStarted();
+  }
+  if (options.watch === false && buildFailure) {
+    const message = buildFailure.message;
+    await close();
+    throw new Error(message);
+  }
+  if (active) options.onStatus?.(`App ready at ${hostedUrl}${appBasePath || "/"}`);
+  const fetchPath = async (path, init2 = {}) => {
+    const url = new URL(joinUrlPath(appBasePath, path), hostedUrl);
+    const response = await fetch(url, {
+      method: init2.method ?? "GET",
+      headers: init2.headers,
+      body: init2.body
+    });
+    const body = await response.text();
+    const headers = {};
+    response.headers.forEach((value, key) => {
+      headers[key] = value;
+    });
+    return { status: response.status, headers, body };
+  };
+  return {
+    url: hostedUrl,
+    port: address.port,
+    hostedUrl,
+    appBasePath,
+    get packageContext() {
+      return contextFor(active?.client ?? null);
+    },
+    fetchPath,
+    status,
+    close
+  };
+}
+function elapsed(started) {
+  return Math.round(performance.now() - started);
+}
+function toBuildFailure(error) {
+  if (error instanceof BundleError) {
+    return { message: error.message, diagnostics: error.diagnostics };
+  }
+  return {
+    message: redact(error instanceof Error ? error.message : String(error)),
+    diagnostics: []
+  };
+}
+function buildErrorView(failure) {
+  const [first] = failure.diagnostics;
+  return {
+    kind: "build",
+    title: first ? `${first.file ?? "bundle"}${first.line !== null ? `:${first.line}:${first.col}` : ""} ${first.message}` : failure.message.split("\n")[0] ?? "Build failed",
+    detail: failure.diagnostics.length > 0 ? failure.diagnostics.map(formatBundleDiagnostic).join("\n\n") : failure.message
+  };
+}
+async function readStream(stream) {
+  const chunks = [];
+  for await (const chunk of stream) {
+    chunks.push(Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk));
+  }
+  return Buffer.concat(chunks).toString("utf8");
+}
+async function writeWorkerFiles(input) {
+  await mkdir2(input.workDir, { recursive: true });
+  const packageGraph = await resolveLocalPackageGraph({
+    code: input.code,
+    apiUrl: input.apiUrl,
+    token: input.token,
+    ...input.org ? { org: input.org } : {},
+    fetchFn: input.fetchFn,
+    ...input.depResolve ? { depResolve: input.depResolve } : {},
+    ...input.packageRoot ? { packageRoot: input.packageRoot } : {},
+    onStatus: input.onStatus
+  });
+  const files = { entry: "entry.js", user: "main.js", runtime: "runtime.js" };
+  let packageModules = await writePackageModuleFiles(
+    input.workDir,
+    packageGraph,
+    writeFile3,
+    join7
+  );
+  let gatewayFetchShimModules = packageGraph.modules.map((module) => module.name).filter((name) => name === localExecuteGatewayFetchShimModuleName);
+  if (input.mockFetchGateway) {
+    const installed = await installMockFetchShimModules({
+      workDir: input.workDir,
+      packageModules
+    });
+    packageModules = installed.packageModules;
+    gatewayFetchShimModules = installed.sideEffectModules;
+  }
+  await writeFile3(
+    join7(input.workDir, files.entry),
+    createPackageAppEntrySource({ sideEffectModules: gatewayFetchShimModules })
+  );
+  await writeFile3(join7(input.workDir, files.user), input.code);
+  await writeFile3(
+    join7(input.workDir, files.runtime),
+    createPackageLocalRuntimeModuleSource({
+      packageContext: input.packageContext,
+      mockStorage: input.mockStorage
+    })
+  );
+  await writeFile3(
+    join7(input.workDir, localWorkerModuleNames.runtimeFlatAlias),
+    createRuntimeFlatAliasSource()
+  );
+  await writeFile3(
+    join7(input.workDir, "config.capnp"),
+    createWorkerdConfig({
+      bridgePort: input.bridgePort,
+      files,
+      packageModules,
+      allowPrivateNetwork: input.allowPrivateNetwork
+    })
+  );
+}
+function normalizeBasePath(value) {
+  const trimmed = value.trim();
+  if (!trimmed || trimmed === "/") return "";
+  const withSlash = trimmed.startsWith("/") ? trimmed : `/${trimmed}`;
+  return withSlash.replace(/\/+$/, "");
+}
+function stripMount(pathname, appBasePath) {
+  if (!appBasePath) return pathname || "/";
+  if (pathname === appBasePath) return "/";
+  if (pathname.startsWith(`${appBasePath}/`)) {
+    return pathname.slice(appBasePath.length) || "/";
+  }
+  return pathname || "/";
+}
+function joinUrlPath(base, path) {
+  const rest = path.startsWith("/") ? path : `/${path}`;
+  if (!base) return rest;
+  return `${base}${rest === "/" ? "" : rest}` || base;
+}
+
+// src/dev-command.ts
+async function resolveDevAuth(input) {
+  if (input.target !== "mock") {
+    return {
+      token: input.token,
+      apiUrl: input.apiUrl,
+      ...input.org ? { org: input.org } : {},
+      ...input.passthroughHosts?.length ? { passthroughHosts: input.passthroughHosts } : {}
+    };
+  }
+  const ensured = await ensureMockTarget({
+    sessionId: input.sessionId,
+    resetStorage: input.resetStorage,
+    packageId: input.packageId,
+    orgSlug: input.orgSlug ?? input.org
+  });
+  let mockClosed = false;
+  return {
+    token: ensured.token,
+    apiUrl: ensured.apiUrl,
+    ...input.org ? { org: input.org } : {},
+    ...input.depResolve ? { depResolve: input.depResolve } : {},
+    ...input.passthroughHosts?.length ? { passthroughHosts: input.passthroughHosts } : {},
+    mockServer: ensured.server,
+    closeMock: ensured.started ? async () => {
+      if (mockClosed) return;
+      mockClosed = true;
+      await ensured.server.close();
+    } : void 0
+  };
+}
+async function runDevServe(input) {
+  const manifest = await loadPackageManifest(input.cwd);
+  if (input.port === void 0) {
+    const running = await findRunningDevServer({ root: manifest.root, target: input.target });
+    if (running) {
+      const { registration } = running;
+      throw new StructuredCliError({
+        code: "dev_already_running",
+        target: input.target,
+        message: `kody dev is already running for ${manifest.name} at ${registration.origin}${registration.basePath || "/"} (pid ${registration.pid}).`,
+        fix: `Reuse it (\`kody dev fetch <path>\` attaches automatically), stop it with \`kill ${registration.pid}\`, or pass --port to start a second server.`
+      });
+    }
+  }
+  const onEvent = input.json ? (event) => writeJsonEvent(input.io, event) : (event) => writeDevEvent(input.io, event);
+  let registered = false;
+  let server;
+  try {
+    server = await startPackageAppDev({
+      manifest,
+      token: input.auth.token,
+      apiUrl: input.auth.apiUrl,
+      target: input.target,
+      port: input.port,
+      defaultPort: defaultDevPort(manifest.kodyId),
+      appBasePath: input.appBasePath,
+      ...input.auth.org ? { org: input.auth.org } : {},
+      ...input.auth.depResolve ? { depResolve: input.auth.depResolve } : {},
+      ...input.passthroughHosts?.length ? { passthroughHosts: input.passthroughHosts } : input.auth.passthroughHosts?.length ? { passthroughHosts: input.auth.passthroughHosts } : {},
+      allowPrivateNetwork: input.allowPrivateNetwork,
+      liveReload: input.liveReload ?? true,
+      onStatus: (message) => input.io.stderr(`${message}
+`),
+      onError: (message) => input.io.stderr(`${message}
+`),
+      onEvent,
+      // Register as soon as the port is bound so a second `kody dev`
+      // during the first build hits `dev_already_running` instead of
+      // stealing the next free port and overwriting the registry.
+      // Explicit `--port` starts a second server on purpose — leave the
+      // primary attach registry alone so fetch keeps talking to it.
+      onListening: async ({ port, hostedUrl, appBasePath }) => {
+        if (input.port !== void 0) return;
+        await writeDevRegistration({
+          pid: process.pid,
+          origin: hostedUrl,
+          port,
+          basePath: appBasePath,
+          target: input.target,
+          root: manifest.root
+        });
+        registered = true;
+      }
+    });
+  } catch (error) {
+    if (registered) {
+      await removeDevRegistration(manifest.root, process.pid, input.target).catch(() => {
+      });
+    }
+    await input.auth.closeMock?.();
+    throw error;
+  }
+  const shutdown = async () => {
+    await server.close();
+    await removeDevRegistration(manifest.root, process.pid, input.target).catch(() => {
+    });
+    if (input.readyFile) await removeOwnedReadyFile(input.readyFile, process.pid);
+    await input.auth.closeMock?.();
+  };
+  try {
+    const status = server.status();
+    const statusUrl = `${server.hostedUrl}${devStatusPath}`;
+    const ready = {
+      url: status.url,
+      port: server.port,
+      basePath: server.appBasePath,
+      pid: process.pid,
+      statusUrl
+    };
+    if (input.readyFile) {
+      await mkdir3(dirname3(input.readyFile), { recursive: true });
+      await writeFile4(input.readyFile, `${JSON.stringify(ready, null, 2)}
+`);
+    }
+    if (input.json) {
+      input.io.stdout(
+        `${JSON.stringify({
+          type: "ready",
+          ts: (/* @__PURE__ */ new Date()).toISOString(),
+          ...ready,
+          target: input.target,
+          package: status.package,
+          buildId: status.buildId,
+          state: status.state
+        })}
+`
+      );
+    } else {
+      input.io.stdout(
+        `kody dev listening on ${status.url}
+target: ${input.target}
+package: ${manifest.name} (${manifest.kodyId})
+status: ${statusUrl}
+Agents: kody dev fetch /path | job <name> | webhook <name> --body file.json | emit <event> --body file.json | check
+`
+      );
+    }
+  } catch (error) {
+    await shutdown().catch(() => {
+    });
+    throw error;
+  }
+  if (input.serveOnce) {
+    await shutdown();
+    return 0;
+  }
+  await new Promise((resolveWait) => {
+    const signals = ["SIGINT", "SIGTERM", "SIGHUP"];
+    const stop = async () => {
+      for (const signal of signals) process.off(signal, onSig);
+      await shutdown();
+      resolveWait();
+    };
+    const onSig = () => {
+      void stop();
+    };
+    for (const signal of signals) process.on(signal, onSig);
+  });
+  return 0;
+}
+async function tryAttachedDevFetch(input) {
+  let root;
+  try {
+    root = (await loadPackageManifest(input.cwd)).root;
+  } catch {
+    return null;
+  }
+  const running = await findRunningDevServer({ root, target: input.target });
+  if (!running) return null;
+  const { registration } = running;
+  const rest = input.path.startsWith("/") ? input.path : `/${input.path}`;
+  const url = new URL(
+    `${registration.basePath}${rest === "/" && registration.basePath ? "" : rest}` || "/",
+    registration.origin
+  );
+  input.io.stderr(`Attached to running kody dev (pid ${registration.pid}) at ${registration.origin}
+`);
+  const response = await fetch(url, {
+    method: input.method ?? "GET",
+    headers: input.body ? { "content-type": "application/json" } : void 0,
+    body: input.body
+  });
+  const body = await response.text();
+  const headers = {};
+  response.headers.forEach((value, key) => {
+    headers[key] = value;
+  });
+  const result = { status: response.status, headers, body };
+  if (input.json) {
+    input.io.stdout(`${JSON.stringify(result, null, 2)}
+`);
+  } else {
+    input.io.stdout(`HTTP ${result.status}
+${result.body}
+`);
+  }
+  return result.status >= 400 ? 1 : 0;
+}
+async function runDevFetch(input) {
+  let server;
+  try {
+    const manifest = await loadPackageManifest(input.cwd);
+    server = await startPackageAppDev({
+      manifest,
+      token: input.auth.token,
+      apiUrl: input.auth.apiUrl,
+      target: input.target,
+      port: input.port,
+      appBasePath: input.appBasePath,
+      ...input.auth.org ? { org: input.auth.org } : {},
+      ...input.auth.depResolve ? { depResolve: input.auth.depResolve } : {},
+      ...input.auth.passthroughHosts?.length ? { passthroughHosts: input.auth.passthroughHosts } : {},
+      allowPrivateNetwork: input.allowPrivateNetwork,
+      watch: false,
+      onStatus: (message) => input.io.stderr(`${message}
+`),
+      onError: (message) => input.io.stderr(`${message}
+`),
+      onEvent: (event) => {
+        if (event.type === "log" || event.type === "runtime_error") {
+          input.io.stderr(`${formatDevEvent(event).text}
+`);
+        }
+      }
+    });
+  } catch (error) {
+    await input.auth.closeMock?.();
+    if (input.json) {
+      const message = error instanceof Error ? error.message : String(error);
+      input.io.stdout(
+        `${JSON.stringify({ type: "build_error", message, ts: (/* @__PURE__ */ new Date()).toISOString() }, null, 2)}
+`
+      );
+    }
+    throw error;
+  }
+  try {
+    const result = await server.fetchPath(input.path, {
+      method: input.method,
+      body: input.body,
+      headers: input.body ? { "content-type": "application/json" } : void 0
+    });
+    if (input.json) {
+      input.io.stdout(`${JSON.stringify(result, null, 2)}
+`);
+    } else {
+      input.io.stdout(`HTTP ${result.status}
+${result.body}
+`);
+    }
+    return result.status >= 400 ? 1 : 0;
+  } finally {
+    await server.close();
+    await input.auth.closeMock?.();
+  }
+}
+async function runDevJob(input) {
+  const manifest = await loadPackageManifest(input.cwd);
+  const job = manifest.jobs[input.jobName];
+  if (!job) {
+    throw new StructuredCliError({
+      code: "dev_surface_missing",
+      message: `No job named ${JSON.stringify(input.jobName)}.`,
+      where: manifest.packageJsonPath,
+      fix: `Known jobs: ${Object.keys(manifest.jobs).join(", ") || "(none)"}.`,
+      target: input.target
+    });
+  }
+  const modulePath = resolvePackagePath(manifest, job.entry);
+  if (input.dryRun) {
+    return printDevDryRun({
+      target: input.target,
+      surface: `job:${input.jobName}`,
+      modulePath,
+      params: void 0,
+      extra: {
+        schedule: job.schedule,
+        scheduleRaw: job.scheduleRaw,
+        timezone: job.timezone ?? null,
+        enabled: job.enabled ?? null
+      },
+      json: input.json,
+      io: input.io,
+      closeMock: input.auth.closeMock
+    });
+  }
+  return await runPackageModuleOnce({
+    manifest,
+    modulePath,
+    params: void 0,
+    target: input.target,
+    auth: input.auth,
+    json: input.json,
+    allowPrivateNetwork: input.allowPrivateNetwork,
+    io: input.io,
+    surface: `job:${input.jobName}`
+  });
+}
+async function runDevWebhook(input) {
+  const manifest = await loadPackageManifest(input.cwd);
+  const webhook = manifest.webhooks[input.webhookName];
+  if (!webhook) {
+    throw new StructuredCliError({
+      code: "dev_surface_missing",
+      message: `No webhook named ${JSON.stringify(input.webhookName)}.`,
+      where: manifest.packageJsonPath,
+      fix: `Known webhooks: ${Object.keys(manifest.webhooks).join(", ") || "(none)"}.`,
+      target: input.target
+    });
+  }
+  const rawBody = await readFile4(resolve7(input.cwd ?? process.cwd(), input.bodyPath), "utf8");
+  let jsonBody = null;
+  try {
+    jsonBody = JSON.parse(rawBody);
+  } catch {
+    jsonBody = null;
+  }
+  const params = webhook.inputMode === "params" ? jsonBody ?? {} : {
+    webhook: {
+      packageKodyId: manifest.kodyId,
+      name: input.webhookName,
+      receivedAt: (/* @__PURE__ */ new Date()).toISOString()
+    },
+    request: {
+      method: "POST",
+      contentType: "application/json",
+      headers: { "content-type": "application/json" },
+      body: rawBody,
+      json: jsonBody
+    },
+    synthetic: true
+  };
+  const modulePath = resolveExportModulePath(manifest, webhook.export);
+  if (input.dryRun) {
+    return printDevDryRun({
+      target: input.target,
+      surface: `webhook:${input.webhookName}`,
+      modulePath,
+      params,
+      extra: { export: webhook.export, bodyPath: input.bodyPath },
+      json: input.json,
+      io: input.io,
+      closeMock: input.auth.closeMock
+    });
+  }
+  return await runPackageModuleOnce({
+    manifest,
+    modulePath,
+    params,
+    target: input.target,
+    auth: input.auth,
+    json: input.json,
+    allowPrivateNetwork: input.allowPrivateNetwork,
+    io: input.io,
+    surface: `webhook:${input.webhookName}`
+  });
+}
+async function runDevEmit(input) {
+  const manifest = await loadPackageManifest(input.cwd);
+  const subscription = manifest.subscriptions[input.event];
+  if (!subscription) {
+    if (input.target !== "mock") {
+      throw new StructuredCliError({
+        code: "dev_surface_missing",
+        message: `No subscription for event ${JSON.stringify(input.event)}.`,
+        where: manifest.packageJsonPath,
+        fix: `Known subscriptions: ${Object.keys(manifest.subscriptions).join(", ") || "(none)"}. On --target mock you can still declare the handler first.`,
+        target: input.target
+      });
+    }
+    throw new StructuredCliError({
+      code: "dev_surface_missing",
+      message: `No subscription for event ${JSON.stringify(input.event)} in package.json#kody.subscriptions.`,
+      where: manifest.packageJsonPath,
+      fix: `Add a handler under kody.subscriptions[${JSON.stringify(input.event)}], then retry. Mock allows any event type once declared.`,
+      target: input.target
+    });
+  }
+  const rawBody = await readFile4(resolve7(input.cwd ?? process.cwd(), input.bodyPath), "utf8");
+  let envelope;
+  try {
+    const parsed = JSON.parse(rawBody);
+    if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) {
+      throw new Error("body must be a JSON object");
+    }
+    envelope = { ...parsed };
+  } catch (error) {
+    throw new StructuredCliError({
+      code: "package_manifest_invalid",
+      message: `Could not parse event body ${input.bodyPath} as a JSON object.`,
+      fix: "Pass --body event.json with the platform delivery envelope fields.",
+      details: { cause: error instanceof Error ? error.message : String(error) },
+      target: input.target
+    });
+  }
+  if (typeof envelope.event !== "string") {
+    envelope.event = input.event;
+  }
+  envelope.synthetic = true;
+  if (envelope.idempotency_key === void 0) {
+    envelope.idempotency_key = `synthetic:local:${Date.now()}`;
+  }
+  const modulePath = resolvePackagePath(manifest, subscription.handler);
+  if (input.dryRun) {
+    return printDevDryRun({
+      target: input.target,
+      surface: `subscription:${input.event}`,
+      modulePath,
+      params: envelope,
+      extra: { handler: subscription.handler, bodyPath: input.bodyPath },
+      json: input.json,
+      io: input.io,
+      closeMock: input.auth.closeMock
+    });
+  }
+  return await runPackageModuleOnce({
+    manifest,
+    modulePath,
+    params: envelope,
+    target: input.target,
+    auth: input.auth,
+    json: input.json,
+    allowPrivateNetwork: input.allowPrivateNetwork,
+    io: input.io,
+    surface: `subscription:${input.event}`
+  });
+}
+async function runDevCheck(input) {
+  const manifest = await loadPackageManifest(input.cwd);
+  const checks = [];
+  const credentialSignals = [];
+  const push = (name, ok, detail) => {
+    checks.push({ name, ok, detail });
+  };
+  const bundleAndScan = async (label, modulePath) => {
+    try {
+      const bundled = await bundleLocalUserModule(modulePath);
+      push(label, true, label.startsWith("app.entry") ? modulePath : void 0);
+      credentialSignals.push(...await detectCredentialedFetchInSource(bundled, label));
+    } catch (error) {
+      push(label, false, error instanceof Error ? error.message : String(error));
+    }
+  };
+  push("package.json", true, manifest.name);
+  push("kody.id", Boolean(manifest.kodyId), manifest.kodyId);
+  try {
+    await readFile4(resolve7(manifest.root, "README.md"));
+    push("README.md", true);
+  } catch {
+    push("README.md", false, "Publish requires README.md");
+  }
+  try {
+    await readFile4(resolve7(manifest.root, "AGENTS.md"));
+    push("AGENTS.md", true);
+  } catch {
+    push("AGENTS.md", false, "Publish requires AGENTS.md");
+  }
+  if (manifest.app?.entry) {
+    await bundleAndScan(
+      "app.entry bundle",
+      resolvePackagePath(manifest, manifest.app.entry)
+    );
+  } else {
+    push("app.entry", true, "none (ok)");
+  }
+  for (const [name, job] of Object.entries(manifest.jobs)) {
+    await bundleAndScan(`job:${name}`, resolvePackagePath(manifest, job.entry));
+  }
+  for (const [name, webhook] of Object.entries(manifest.webhooks)) {
+    await bundleAndScan(
+      `webhook:${name}`,
+      resolveExportModulePath(manifest, webhook.export)
+    );
+  }
+  for (const [topic, sub] of Object.entries(manifest.subscriptions)) {
+    await bundleAndScan(
+      `subscription:${topic}`,
+      resolvePackagePath(manifest, sub.handler)
+    );
+  }
+  for (const [key, rel] of Object.entries(manifest.exports)) {
+    await bundleAndScan(`export:${key}`, resolvePackagePath(manifest, rel));
+  }
+  let hasMocksFile = false;
+  try {
+    await access(join8(manifest.root, packageMocksRelativePath));
+    hasMocksFile = true;
+  } catch {
+    hasMocksFile = false;
+  }
+  const mocksDetail = mocksSuggestionDetail({
+    signals: credentialSignals,
+    hasMocksFile
+  });
+  if (mocksDetail) {
+    push(packageMocksRelativePath, true, mocksDetail);
+  }
+  const failed = checks.filter((check) => !check.ok);
+  if (input.json) {
+    input.io.stdout(
+      `${JSON.stringify(
+        {
+          target: input.target,
+          checks,
+          ok: failed.length === 0,
+          ...credentialSignals.length > 0 ? {
+            credentialedFetch: {
+              detected: true,
+              hasMocksFile,
+              signals: credentialSignals
+            }
+          } : {}
+        },
+        null,
+        2
+      )}
+`
+    );
+  } else {
+    for (const check of checks) {
+      const mark = check.ok ? "ok" : "FAIL";
+      input.io.stdout(
+        `${mark.padEnd(4)} ${check.name}${check.detail ? ` \u2014 ${check.detail}` : ""}
+`
+      );
+    }
+    input.io.stdout(
+      failed.length === 0 ? `kody dev check passed (${checks.length} checks, target ${input.target})
+` : `kody dev check failed: ${failed.length}/${checks.length}
+`
+    );
+  }
+  return failed.length === 0 ? 0 : 1;
+}
+async function runPackageModuleOnce(input) {
+  const packageContext = buildLocalPackageContext({
+    kodyId: input.manifest.kodyId,
+    hostedUrl: input.auth.apiUrl.startsWith("http") ? "http://127.0.0.1:0" : "http://127.0.0.1:0",
+    appBasePath: ""
+  });
+  try {
+    const result = await runLocalPackageModule({
+      modulePath: input.modulePath,
+      params: input.params,
+      token: input.auth.token,
+      apiUrl: input.auth.apiUrl,
+      target: input.target,
+      packageContext,
+      packageRoot: input.manifest.root,
+      ...input.auth.org ? { org: input.auth.org } : {},
+      ...input.auth.depResolve ? { depResolve: input.auth.depResolve } : {},
+      ...input.auth.passthroughHosts?.length ? { passthroughHosts: input.auth.passthroughHosts } : {},
+      allowPrivateNetwork: input.allowPrivateNetwork,
+      onStatus: (message) => input.io.stderr(`${message}
+`)
+    });
+    input.io.stdout(formatToolResult(result, input.json === true));
+    return result.isError ? 1 : 0;
+  } finally {
+    await input.auth.closeMock?.();
+  }
+}
+async function printDevDryRun(input) {
+  try {
+    const plan = {
+      dryRun: true,
+      wouldInvoke: true,
+      target: input.target,
+      surface: input.surface,
+      modulePath: input.modulePath,
+      params: input.params ?? null,
+      ...input.extra ?? {},
+      note: input.target === "prod" ? "No module run and no prod side effects. Drop --dry-run to invoke once against prod CapabilityProxy." : "No module run. Drop --dry-run to invoke against the selected target."
+    };
+    if (input.json) {
+      input.io.stdout(`${JSON.stringify(plan, null, 2)}
+`);
+    } else {
+      input.io.stdout(
+        `dry-run: would invoke ${input.surface} on --target ${input.target}
+module: ${input.modulePath}
+params: ${JSON.stringify(input.params ?? null, null, 2)}
+` + (input.extra ? `detail: ${JSON.stringify(input.extra, null, 2)}
+` : "") + `${plan.note}
+`
+      );
+    }
+    return 0;
+  } finally {
+    await input.closeMock?.();
+  }
+}
+function writeJsonEvent(io, event) {
+  io.stdout(`${JSON.stringify({ ...event, ts: (/* @__PURE__ */ new Date()).toISOString() })}
+`);
+}
+function writeDevEvent(io, event) {
+  const { stream, text } = formatDevEvent(event);
+  io[stream](`${text}
+`);
+}
+function parseDevSubcommand(positionals) {
+  const raw = positionals[0];
+  if (!raw || raw.startsWith("-")) {
+    return { subcommand: "serve", rest: positionals };
+  }
+  switch (raw) {
+    case "serve":
+    case "fetch":
+    case "job":
+    case "webhook":
+    case "emit":
+    case "check":
+      return { subcommand: raw, rest: positionals.slice(1) };
+    default:
+      throw new Error(
+        `Unknown kody dev subcommand ${JSON.stringify(raw)}. Use serve | fetch | job | webhook | emit | check.`
+      );
+  }
+}
+async function removeOwnedReadyFile(path, ownerPid) {
+  try {
+    const parsed = JSON.parse(await readFile4(path, "utf8"));
+    if (parsed.pid !== ownerPid) return;
+    await rm4(path, { force: true });
+  } catch {
+  }
+}
+export {
+  parseDevPort,
+  parseDevSubcommand,
+  removeOwnedReadyFile,
+  resolveDevAuth,
+  runDevCheck,
+  runDevEmit,
+  runDevFetch,
+  runDevJob,
+  runDevServe,
+  runDevWebhook,
+  tryAttachedDevFetch
+};
+/*! Bundled license information:
+
+chokidar/esm/index.js:
+  (*! chokidar - MIT License (c) 2012 Paul Miller (paulmillr.com) *)
+*/
+//# sourceMappingURL=dev-command-3LX234N6.js.map