@xbghc/warden 0.1.0

package/dist/cli.js

@@ -0,0 +1,4450 @@
+#!/usr/bin/env node
+
+// bin/cli.ts
+import path7 from "path";
+import { spawn } from "child_process";
+import { existsSync } from "fs";
+import { fileURLToPath } from "url";
+
+// packages/server/src/index.ts
+import net from "net";
+
+// node_modules/.pnpm/@hono+node-server@1.19.17_hono@4.13.7/node_modules/@hono/node-server/dist/index.mjs
+import { createServer as createServerHTTP } from "http";
+import { Http2ServerRequest as Http2ServerRequest2, constants as h2constants } from "http2";
+import { Http2ServerRequest } from "http2";
+import { Readable } from "stream";
+import crypto2 from "crypto";
+var RequestError = class extends Error {
+  constructor(message, options) {
+    super(message, options);
+    this.name = "RequestError";
+  }
+};
+var toRequestError = (e) => {
+  if (e instanceof RequestError) {
+    return e;
+  }
+  return new RequestError(e.message, { cause: e });
+};
+var GlobalRequest = global.Request;
+var Request2 = class extends GlobalRequest {
+  constructor(input, options) {
+    if (typeof input === "object" && getRequestCache in input) {
+      input = input[getRequestCache]();
+    }
+    if (typeof options?.body?.getReader !== "undefined") {
+      ;
+      options.duplex ??= "half";
+    }
+    super(input, options);
+  }
+};
+var newHeadersFromIncoming = (incoming) => {
+  const headerRecord = [];
+  const rawHeaders = incoming.rawHeaders;
+  for (let i = 0; i < rawHeaders.length; i += 2) {
+    const { [i]: key, [i + 1]: value } = rawHeaders;
+    if (key.charCodeAt(0) !== /*:*/
+    58) {
+      headerRecord.push([key, value]);
+    }
+  }
+  return new Headers(headerRecord);
+};
+var wrapBodyStream = /* @__PURE__ */ Symbol("wrapBodyStream");
+var newRequestFromIncoming = (method, url, headers, incoming, abortController) => {
+  const init = {
+    method,
+    headers,
+    signal: abortController.signal
+  };
+  if (method === "TRACE") {
+    init.method = "GET";
+    const req = new Request2(url, init);
+    Object.defineProperty(req, "method", {
+      get() {
+        return "TRACE";
+      }
+    });
+    return req;
+  }
+  if (!(method === "GET" || method === "HEAD")) {
+    if ("rawBody" in incoming && incoming.rawBody instanceof Buffer) {
+      init.body = new ReadableStream({
+        start(controller) {
+          controller.enqueue(incoming.rawBody);
+          controller.close();
+        }
+      });
+    } else if (incoming[wrapBodyStream]) {
+      let reader;
+      init.body = new ReadableStream({
+        async pull(controller) {
+          try {
+            reader ||= Readable.toWeb(incoming).getReader();
+            const { done, value } = await reader.read();
+            if (done) {
+              controller.close();
+            } else {
+              controller.enqueue(value);
+            }
+          } catch (error) {
+            controller.error(error);
+          }
+        }
+      });
+    } else {
+      init.body = Readable.toWeb(incoming);
+    }
+  }
+  return new Request2(url, init);
+};
+var getRequestCache = /* @__PURE__ */ Symbol("getRequestCache");
+var requestCache = /* @__PURE__ */ Symbol("requestCache");
+var incomingKey = /* @__PURE__ */ Symbol("incomingKey");
+var urlKey = /* @__PURE__ */ Symbol("urlKey");
+var headersKey = /* @__PURE__ */ Symbol("headersKey");
+var abortControllerKey = /* @__PURE__ */ Symbol("abortControllerKey");
+var getAbortController = /* @__PURE__ */ Symbol("getAbortController");
+var requestPrototype = {
+  get method() {
+    return this[incomingKey].method || "GET";
+  },
+  get url() {
+    return this[urlKey];
+  },
+  get headers() {
+    return this[headersKey] ||= newHeadersFromIncoming(this[incomingKey]);
+  },
+  [getAbortController]() {
+    this[getRequestCache]();
+    return this[abortControllerKey];
+  },
+  [getRequestCache]() {
+    this[abortControllerKey] ||= new AbortController();
+    return this[requestCache] ||= newRequestFromIncoming(
+      this.method,
+      this[urlKey],
+      this.headers,
+      this[incomingKey],
+      this[abortControllerKey]
+    );
+  }
+};
+[
+  "body",
+  "bodyUsed",
+  "cache",
+  "credentials",
+  "destination",
+  "integrity",
+  "mode",
+  "redirect",
+  "referrer",
+  "referrerPolicy",
+  "signal",
+  "keepalive"
+].forEach((k) => {
+  Object.defineProperty(requestPrototype, k, {
+    get() {
+      return this[getRequestCache]()[k];
+    }
+  });
+});
+["arrayBuffer", "blob", "clone", "formData", "json", "text"].forEach((k) => {
+  Object.defineProperty(requestPrototype, k, {
+    value: function() {
+      return this[getRequestCache]()[k]();
+    }
+  });
+});
+Object.defineProperty(requestPrototype, /* @__PURE__ */ Symbol.for("nodejs.util.inspect.custom"), {
+  value: function(depth, options, inspectFn) {
+    const props = {
+      method: this.method,
+      url: this.url,
+      headers: this.headers,
+      nativeRequest: this[requestCache]
+    };
+    return `Request (lightweight) ${inspectFn(props, { ...options, depth: depth == null ? null : depth - 1 })}`;
+  }
+});
+Object.setPrototypeOf(requestPrototype, Request2.prototype);
+var newRequest = (incoming, defaultHostname) => {
+  const req = Object.create(requestPrototype);
+  req[incomingKey] = incoming;
+  const incomingUrl = incoming.url || "";
+  if (incomingUrl[0] !== "/" && // short-circuit for performance. most requests are relative URL.
+  (incomingUrl.startsWith("http://") || incomingUrl.startsWith("https://"))) {
+    if (incoming instanceof Http2ServerRequest) {
+      throw new RequestError("Absolute URL for :path is not allowed in HTTP/2");
+    }
+    try {
+      const url2 = new URL(incomingUrl);
+      req[urlKey] = url2.href;
+    } catch (e) {
+      throw new RequestError("Invalid absolute URL", { cause: e });
+    }
+    return req;
+  }
+  const host = (incoming instanceof Http2ServerRequest ? incoming.authority : incoming.headers.host) || defaultHostname;
+  if (!host) {
+    throw new RequestError("Missing host header");
+  }
+  let scheme;
+  if (incoming instanceof Http2ServerRequest) {
+    scheme = incoming.scheme;
+    if (!(scheme === "http" || scheme === "https")) {
+      throw new RequestError("Unsupported scheme");
+    }
+  } else {
+    scheme = incoming.socket && incoming.socket.encrypted ? "https" : "http";
+  }
+  const url = new URL(`${scheme}://${host}${incomingUrl}`);
+  if (url.hostname.length !== host.length && url.hostname !== host.replace(/:\d+$/, "")) {
+    throw new RequestError("Invalid host header");
+  }
+  req[urlKey] = url.href;
+  return req;
+};
+var responseCache = /* @__PURE__ */ Symbol("responseCache");
+var getResponseCache = /* @__PURE__ */ Symbol("getResponseCache");
+var cacheKey = /* @__PURE__ */ Symbol("cache");
+var GlobalResponse = global.Response;
+var Response2 = class _Response {
+  #body;
+  #init;
+  [getResponseCache]() {
+    delete this[cacheKey];
+    return this[responseCache] ||= new GlobalResponse(this.#body, this.#init);
+  }
+  constructor(body, init) {
+    let headers;
+    this.#body = body;
+    if (init instanceof _Response) {
+      const cachedGlobalResponse = init[responseCache];
+      if (cachedGlobalResponse) {
+        this.#init = cachedGlobalResponse;
+        this[getResponseCache]();
+        return;
+      } else {
+        this.#init = init.#init;
+        headers = new Headers(init.#init.headers);
+      }
+    } else {
+      this.#init = init;
+    }
+    if (typeof body === "string" || typeof body?.getReader !== "undefined" || body instanceof Blob || body instanceof Uint8Array) {
+      ;
+      this[cacheKey] = [init?.status || 200, body, headers || init?.headers];
+    }
+  }
+  get headers() {
+    const cache = this[cacheKey];
+    if (cache) {
+      if (!(cache[2] instanceof Headers)) {
+        cache[2] = new Headers(
+          cache[2] || { "content-type": "text/plain; charset=UTF-8" }
+        );
+      }
+      return cache[2];
+    }
+    return this[getResponseCache]().headers;
+  }
+  get status() {
+    return this[cacheKey]?.[0] ?? this[getResponseCache]().status;
+  }
+  get ok() {
+    const status = this.status;
+    return status >= 200 && status < 300;
+  }
+};
+["body", "bodyUsed", "redirected", "statusText", "trailers", "type", "url"].forEach((k) => {
+  Object.defineProperty(Response2.prototype, k, {
+    get() {
+      return this[getResponseCache]()[k];
+    }
+  });
+});
+["arrayBuffer", "blob", "clone", "formData", "json", "text"].forEach((k) => {
+  Object.defineProperty(Response2.prototype, k, {
+    value: function() {
+      return this[getResponseCache]()[k]();
+    }
+  });
+});
+Object.defineProperty(Response2.prototype, /* @__PURE__ */ Symbol.for("nodejs.util.inspect.custom"), {
+  value: function(depth, options, inspectFn) {
+    const props = {
+      status: this.status,
+      headers: this.headers,
+      ok: this.ok,
+      nativeResponse: this[responseCache]
+    };
+    return `Response (lightweight) ${inspectFn(props, { ...options, depth: depth == null ? null : depth - 1 })}`;
+  }
+});
+Object.setPrototypeOf(Response2, GlobalResponse);
+Object.setPrototypeOf(Response2.prototype, GlobalResponse.prototype);
+async function readWithoutBlocking(readPromise) {
+  return Promise.race([readPromise, Promise.resolve().then(() => Promise.resolve(void 0))]);
+}
+function writeFromReadableStreamDefaultReader(reader, writable, currentReadPromise) {
+  const cancel = (error) => {
+    reader.cancel(error).catch(() => {
+    });
+  };
+  writable.on("close", cancel);
+  writable.on("error", cancel);
+  (currentReadPromise ?? reader.read()).then(flow, handleStreamError);
+  return reader.closed.finally(() => {
+    writable.off("close", cancel);
+    writable.off("error", cancel);
+  });
+  function handleStreamError(error) {
+    if (error) {
+      writable.destroy(error);
+    }
+  }
+  function onDrain() {
+    reader.read().then(flow, handleStreamError);
+  }
+  function flow({ done, value }) {
+    try {
+      if (done) {
+        writable.end();
+      } else if (!writable.write(value)) {
+        writable.once("drain", onDrain);
+      } else {
+        return reader.read().then(flow, handleStreamError);
+      }
+    } catch (e) {
+      handleStreamError(e);
+    }
+  }
+}
+function writeFromReadableStream(stream, writable) {
+  if (stream.locked) {
+    throw new TypeError("ReadableStream is locked.");
+  } else if (writable.destroyed) {
+    return;
+  }
+  return writeFromReadableStreamDefaultReader(stream.getReader(), writable);
+}
+var buildOutgoingHttpHeaders = (headers) => {
+  const res = {};
+  if (!(headers instanceof Headers)) {
+    headers = new Headers(headers ?? void 0);
+  }
+  const cookies = [];
+  for (const [k, v] of headers) {
+    if (k === "set-cookie") {
+      cookies.push(v);
+    } else {
+      res[k] = v;
+    }
+  }
+  if (cookies.length > 0) {
+    res["set-cookie"] = cookies;
+  }
+  res["content-type"] ??= "text/plain; charset=UTF-8";
+  return res;
+};
+var X_ALREADY_SENT = "x-hono-already-sent";
+if (typeof global.crypto === "undefined") {
+  global.crypto = crypto2;
+}
+var outgoingEnded = /* @__PURE__ */ Symbol("outgoingEnded");
+var incomingDraining = /* @__PURE__ */ Symbol("incomingDraining");
+var DRAIN_TIMEOUT_MS = 500;
+var MAX_DRAIN_BYTES = 64 * 1024 * 1024;
+var drainIncoming = (incoming) => {
+  const incomingWithDrainState = incoming;
+  if (incoming.destroyed || incomingWithDrainState[incomingDraining]) {
+    return;
+  }
+  incomingWithDrainState[incomingDraining] = true;
+  if (incoming instanceof Http2ServerRequest2) {
+    try {
+      ;
+      incoming.stream?.close?.(h2constants.NGHTTP2_NO_ERROR);
+    } catch {
+    }
+    return;
+  }
+  let bytesRead = 0;
+  const cleanup = () => {
+    clearTimeout(timer);
+    incoming.off("data", onData);
+    incoming.off("end", cleanup);
+    incoming.off("error", cleanup);
+  };
+  const forceClose = () => {
+    cleanup();
+    const socket = incoming.socket;
+    if (socket && !socket.destroyed) {
+      socket.destroySoon();
+    }
+  };
+  const timer = setTimeout(forceClose, DRAIN_TIMEOUT_MS);
+  timer.unref?.();
+  const onData = (chunk) => {
+    bytesRead += chunk.length;
+    if (bytesRead > MAX_DRAIN_BYTES) {
+      forceClose();
+    }
+  };
+  incoming.on("data", onData);
+  incoming.on("end", cleanup);
+  incoming.on("error", cleanup);
+  incoming.resume();
+};
+var handleRequestError = () => new Response(null, {
+  status: 400
+});
+var handleFetchError = (e) => new Response(null, {
+  status: e instanceof Error && (e.name === "TimeoutError" || e.constructor.name === "TimeoutError") ? 504 : 500
+});
+var handleResponseError = (e, outgoing) => {
+  const err = e instanceof Error ? e : new Error("unknown error", { cause: e });
+  if (err.code === "ERR_STREAM_PREMATURE_CLOSE") {
+    console.info("The user aborted a request.");
+  } else {
+    console.error(e);
+    if (!outgoing.headersSent) {
+      outgoing.writeHead(500, { "Content-Type": "text/plain" });
+    }
+    outgoing.end(`Error: ${err.message}`);
+    outgoing.destroy(err);
+  }
+};
+var flushHeaders = (outgoing) => {
+  if ("flushHeaders" in outgoing && outgoing.writable) {
+    outgoing.flushHeaders();
+  }
+};
+var responseViaCache = async (res, outgoing) => {
+  let [status, body, header] = res[cacheKey];
+  let hasContentLength = false;
+  if (!header) {
+    header = { "content-type": "text/plain; charset=UTF-8" };
+  } else if (header instanceof Headers) {
+    hasContentLength = header.has("content-length");
+    header = buildOutgoingHttpHeaders(header);
+  } else if (Array.isArray(header)) {
+    const headerObj = new Headers(header);
+    hasContentLength = headerObj.has("content-length");
+    header = buildOutgoingHttpHeaders(headerObj);
+  } else {
+    for (const key in header) {
+      if (key.length === 14 && key.toLowerCase() === "content-length") {
+        hasContentLength = true;
+        break;
+      }
+    }
+  }
+  if (!hasContentLength) {
+    if (typeof body === "string") {
+      header["Content-Length"] = Buffer.byteLength(body);
+    } else if (body instanceof Uint8Array) {
+      header["Content-Length"] = body.byteLength;
+    } else if (body instanceof Blob) {
+      header["Content-Length"] = body.size;
+    }
+  }
+  outgoing.writeHead(status, header);
+  if (typeof body === "string" || body instanceof Uint8Array) {
+    outgoing.end(body);
+  } else if (body instanceof Blob) {
+    outgoing.end(new Uint8Array(await body.arrayBuffer()));
+  } else {
+    flushHeaders(outgoing);
+    await writeFromReadableStream(body, outgoing)?.catch(
+      (e) => handleResponseError(e, outgoing)
+    );
+  }
+  ;
+  outgoing[outgoingEnded]?.();
+};
+var isPromise = (res) => typeof res.then === "function";
+var responseViaResponseObject = async (res, outgoing, options = {}) => {
+  if (isPromise(res)) {
+    if (options.errorHandler) {
+      try {
+        res = await res;
+      } catch (err) {
+        const errRes = await options.errorHandler(err);
+        if (!errRes) {
+          return;
+        }
+        res = errRes;
+      }
+    } else {
+      res = await res.catch(handleFetchError);
+    }
+  }
+  if (cacheKey in res) {
+    return responseViaCache(res, outgoing);
+  }
+  const resHeaderRecord = buildOutgoingHttpHeaders(res.headers);
+  if (res.body) {
+    const reader = res.body.getReader();
+    const values = [];
+    let done = false;
+    let currentReadPromise = void 0;
+    if (resHeaderRecord["transfer-encoding"] !== "chunked") {
+      let maxReadCount = 2;
+      for (let i = 0; i < maxReadCount; i++) {
+        currentReadPromise ||= reader.read();
+        const chunk = await readWithoutBlocking(currentReadPromise).catch((e) => {
+          console.error(e);
+          done = true;
+        });
+        if (!chunk) {
+          if (i === 1) {
+            await new Promise((resolve) => setTimeout(resolve));
+            maxReadCount = 3;
+            continue;
+          }
+          break;
+        }
+        currentReadPromise = void 0;
+        if (chunk.value) {
+          values.push(chunk.value);
+        }
+        if (chunk.done) {
+          done = true;
+          break;
+        }
+      }
+      if (done && !("content-length" in resHeaderRecord)) {
+        resHeaderRecord["content-length"] = values.reduce((acc, value) => acc + value.length, 0);
+      }
+    }
+    outgoing.writeHead(res.status, resHeaderRecord);
+    values.forEach((value) => {
+      ;
+      outgoing.write(value);
+    });
+    if (done) {
+      outgoing.end();
+    } else {
+      if (values.length === 0) {
+        flushHeaders(outgoing);
+      }
+      await writeFromReadableStreamDefaultReader(reader, outgoing, currentReadPromise);
+    }
+  } else if (resHeaderRecord[X_ALREADY_SENT]) {
+  } else {
+    outgoing.writeHead(res.status, resHeaderRecord);
+    outgoing.end();
+  }
+  ;
+  outgoing[outgoingEnded]?.();
+};
+var getRequestListener = (fetchCallback, options = {}) => {
+  const autoCleanupIncoming = options.autoCleanupIncoming ?? true;
+  if (options.overrideGlobalObjects !== false && global.Request !== Request2) {
+    Object.defineProperty(global, "Request", {
+      value: Request2
+    });
+    Object.defineProperty(global, "Response", {
+      value: Response2
+    });
+  }
+  return async (incoming, outgoing) => {
+    let res, req;
+    try {
+      req = newRequest(incoming, options.hostname);
+      let incomingEnded = !autoCleanupIncoming || incoming.method === "GET" || incoming.method === "HEAD";
+      if (!incomingEnded) {
+        ;
+        incoming[wrapBodyStream] = true;
+        incoming.on("end", () => {
+          incomingEnded = true;
+        });
+        if (incoming instanceof Http2ServerRequest2) {
+          ;
+          outgoing[outgoingEnded] = () => {
+            if (!incomingEnded) {
+              setTimeout(() => {
+                if (!incomingEnded) {
+                  setTimeout(() => {
+                    drainIncoming(incoming);
+                  });
+                }
+              });
+            }
+          };
+        }
+        outgoing.on("finish", () => {
+          if (!incomingEnded) {
+            drainIncoming(incoming);
+          }
+        });
+      }
+      outgoing.on("close", () => {
+        const abortController = req[abortControllerKey];
+        if (abortController) {
+          if (incoming.errored) {
+            req[abortControllerKey].abort(incoming.errored.toString());
+          } else if (!outgoing.writableFinished) {
+            req[abortControllerKey].abort("Client connection prematurely closed.");
+          }
+        }
+        if (!incomingEnded) {
+          setTimeout(() => {
+            if (!incomingEnded) {
+              setTimeout(() => {
+                drainIncoming(incoming);
+              });
+            }
+          });
+        }
+      });
+      res = fetchCallback(req, { incoming, outgoing });
+      if (cacheKey in res) {
+        return responseViaCache(res, outgoing);
+      }
+    } catch (e) {
+      if (!res) {
+        if (options.errorHandler) {
+          res = await options.errorHandler(req ? e : toRequestError(e));
+          if (!res) {
+            return;
+          }
+        } else if (!req) {
+          res = handleRequestError();
+        } else {
+          res = handleFetchError(e);
+        }
+      } else {
+        return handleResponseError(e, outgoing);
+      }
+    }
+    try {
+      return await responseViaResponseObject(res, outgoing, options);
+    } catch (e) {
+      return handleResponseError(e, outgoing);
+    }
+  };
+};
+var createAdaptorServer = (options) => {
+  const fetchCallback = options.fetch;
+  const requestListener = getRequestListener(fetchCallback, {
+    hostname: options.hostname,
+    overrideGlobalObjects: options.overrideGlobalObjects,
+    autoCleanupIncoming: options.autoCleanupIncoming
+  });
+  const createServer = options.createServer || createServerHTTP;
+  const server = createServer(options.serverOptions || {}, requestListener);
+  return server;
+};
+var serve = (options, listeningListener) => {
+  const server = createAdaptorServer(options);
+  server.listen(options?.port ?? 3e3, options.hostname, () => {
+    const serverInfo = server.address();
+    listeningListener && listeningListener(serverInfo);
+  });
+  return server;
+};
+
+// packages/server/src/app.ts
+import path6 from "path";
+import { randomUUID } from "crypto";
+
+// node_modules/.pnpm/hono@4.13.7/node_modules/hono/dist/compose.js
+var compose = (middleware, onError, onNotFound) => {
+  return (context, next) => {
+    let index = -1;
+    return dispatch(0);
+    async function dispatch(i) {
+      if (i <= index) {
+        throw new Error("next() called multiple times");
+      }
+      index = i;
+      let res;
+      let isError = false;
+      let handler;
+      if (middleware[i]) {
+        handler = middleware[i][0][0];
+        context.req.routeIndex = i;
+      } else {
+        handler = i === middleware.length && next || void 0;
+      }
+      if (handler) {
+        try {
+          res = await handler(context, () => dispatch(i + 1));
+        } catch (err) {
+          if (err instanceof Error && onError) {
+            context.error = err;
+            res = await onError(err, context);
+            isError = true;
+          } else {
+            throw err;
+          }
+        }
+      } else {
+        if (context.finalized === false && onNotFound) {
+          res = await onNotFound(context);
+        }
+      }
+      if (res && (context.finalized === false || isError)) {
+        context.res = res;
+      }
+      return context;
+    }
+  };
+};
+
+// node_modules/.pnpm/hono@4.13.7/node_modules/hono/dist/request/constants.js
+var GET_MATCH_RESULT = /* @__PURE__ */ Symbol();
+
+// node_modules/.pnpm/hono@4.13.7/node_modules/hono/dist/utils/buffer.js
+var bufferToFormData = (arrayBuffer, contentType) => {
+  const response = new Response(arrayBuffer, {
+    headers: {
+      // Normalize the media type (case-insensitive) while keeping parameters like the boundary
+      "Content-Type": contentType.replace(/^[^;]+/, (mediaType) => mediaType.toLowerCase())
+    }
+  });
+  return response.formData();
+};
+
+// node_modules/.pnpm/hono@4.13.7/node_modules/hono/dist/utils/body.js
+var MAX_NESTING_DEPTH = 32;
+var MAX_NESTED_OBJECTS = 1e4;
+var isRawRequest = (request) => "headers" in request;
+var parseBody = async (request, options = /* @__PURE__ */ Object.create(null)) => {
+  const { all = false, dot = false } = options;
+  const headers = isRawRequest(request) ? request.headers : request.raw.headers;
+  const contentType = headers.get("Content-Type");
+  const mediaType = contentType?.split(";")[0].trim().toLowerCase();
+  if (mediaType === "multipart/form-data" || mediaType === "application/x-www-form-urlencoded") {
+    return parseFormData(request, { all, dot });
+  }
+  return {};
+};
+async function parseFormData(request, options) {
+  if (!isRawRequest(request) && request.bodyCache.formData) {
+    return convertFormDataToBodyData(
+      await request.bodyCache.formData,
+      options
+    );
+  }
+  const headers = isRawRequest(request) ? request.headers : request.raw.headers;
+  const arrayBuffer = await request.arrayBuffer();
+  const formDataPromise = bufferToFormData(arrayBuffer, headers.get("Content-Type") || "");
+  if (!isRawRequest(request)) {
+    request.bodyCache.formData = formDataPromise;
+  }
+  const formData = await formDataPromise;
+  if (formData) {
+    return convertFormDataToBodyData(formData, options);
+  }
+  return {};
+}
+function convertFormDataToBodyData(formData, options) {
+  const form = /* @__PURE__ */ Object.create(null);
+  const nestingState = { count: 0 };
+  formData.forEach((value, key) => {
+    const shouldParseAllValues = options.all || key.endsWith("[]");
+    if (!shouldParseAllValues) {
+      form[key] = value;
+    } else {
+      handleParsingAllValues(form, key, value);
+    }
+  });
+  if (options.dot) {
+    Object.entries(form).forEach(([key, value]) => {
+      const shouldParseDotValues = key.includes(".");
+      if (shouldParseDotValues) {
+        handleParsingNestedValues(form, key, value, nestingState);
+        delete form[key];
+      }
+    });
+  }
+  return form;
+}
+var handleParsingAllValues = (form, key, value) => {
+  if (form[key] !== void 0) {
+    if (Array.isArray(form[key])) {
+      ;
+      form[key].push(value);
+    } else {
+      form[key] = [form[key], value];
+    }
+  } else {
+    if (!key.endsWith("[]")) {
+      form[key] = value;
+    } else {
+      form[key] = [value];
+    }
+  }
+};
+var handleParsingNestedValues = (form, key, value, state) => {
+  if (/(?:^|\.)__proto__\./.test(key)) {
+    return;
+  }
+  let nestedForm = form;
+  const keys = key.split(".", MAX_NESTING_DEPTH + 2);
+  if (keys.length > MAX_NESTING_DEPTH + 1) {
+    throwNestingLimitExceeded();
+  }
+  keys.forEach((key2, index) => {
+    if (index === keys.length - 1) {
+      nestedForm[key2] = value;
+    } else {
+      if (!nestedForm[key2] || typeof nestedForm[key2] !== "object" || Array.isArray(nestedForm[key2]) || nestedForm[key2] instanceof File) {
+        if (state.count++ >= MAX_NESTED_OBJECTS) {
+          throwNestingLimitExceeded();
+        }
+        nestedForm[key2] = /* @__PURE__ */ Object.create(null);
+      }
+      nestedForm = nestedForm[key2];
+    }
+  });
+};
+var throwNestingLimitExceeded = () => {
+  throw new Error("Nesting limit exceeded");
+};
+
+// node_modules/.pnpm/hono@4.13.7/node_modules/hono/dist/utils/url.js
+var splitPath = (path8) => {
+  const paths = path8.split("/");
+  if (paths[0] === "") {
+    paths.shift();
+  }
+  return paths;
+};
+var splitRoutingPath = (routePath) => {
+  const { groups, path: path8 } = extractGroupsFromPath(routePath);
+  const paths = splitPath(path8);
+  return replaceGroupMarks(paths, groups);
+};
+var extractGroupsFromPath = (path8) => {
+  const groups = [];
+  path8 = path8.replace(/\{[^}]+\}/g, (match2, index) => {
+    const mark = `@${index}`;
+    groups.push([mark, match2]);
+    return mark;
+  });
+  return { groups, path: path8 };
+};
+var replaceGroupMarks = (paths, groups) => {
+  for (let i = groups.length - 1; i >= 0; i--) {
+    const [mark] = groups[i];
+    for (let j = paths.length - 1; j >= 0; j--) {
+      if (paths[j].includes(mark)) {
+        paths[j] = paths[j].replace(mark, groups[i][1]);
+        break;
+      }
+    }
+  }
+  return paths;
+};
+var patternCache = {};
+var getPattern = (label, next) => {
+  if (label === "*") {
+    return "*";
+  }
+  const match2 = label.match(/^\:([^\{\}]+)(?:\{(.+)\})?$/);
+  if (match2) {
+    const cacheKey2 = `${label}#${next}`;
+    if (!patternCache[cacheKey2]) {
+      if (match2[2]) {
+        patternCache[cacheKey2] = next && next[0] !== ":" && next[0] !== "*" ? [cacheKey2, match2[1], new RegExp(`^${match2[2]}(?=/${next})`)] : [label, match2[1], new RegExp(`^${match2[2]}$`)];
+      } else {
+        patternCache[cacheKey2] = [label, match2[1], true];
+      }
+    }
+    return patternCache[cacheKey2];
+  }
+  return null;
+};
+var tryDecode = (str, decoder) => {
+  try {
+    return decoder(str);
+  } catch {
+    return str.replace(/(?:%[0-9A-Fa-f]{2})+/g, (match2) => {
+      try {
+        return decoder(match2);
+      } catch {
+        return match2;
+      }
+    });
+  }
+};
+var tryDecodeURI = (str) => tryDecode(str, decodeURI);
+var getPath = (request) => {
+  const url = request.url;
+  const start = url.indexOf("/", url.indexOf(":") + 4);
+  let i = start;
+  for (; i < url.length; i++) {
+    const charCode = url.charCodeAt(i);
+    if (charCode === 37) {
+      const queryIndex = url.indexOf("?", i);
+      const hashIndex = url.indexOf("#", i);
+      const end = queryIndex === -1 ? hashIndex === -1 ? void 0 : hashIndex : hashIndex === -1 ? queryIndex : Math.min(queryIndex, hashIndex);
+      const path8 = url.slice(start, end);
+      return tryDecodeURI(path8.includes("%25") ? path8.replace(/%25/g, "%2525") : path8);
+    } else if (charCode === 63 || charCode === 35) {
+      break;
+    }
+  }
+  return url.slice(start, i);
+};
+var getPathNoStrict = (request) => {
+  const result = getPath(request);
+  return result.length > 1 && result.at(-1) === "/" ? result.slice(0, -1) : result;
+};
+var mergePath = (base, sub, ...rest) => {
+  if (rest.length) {
+    sub = mergePath(sub, ...rest);
+  }
+  return `${base?.[0] === "/" ? "" : "/"}${base}${sub === "/" ? "" : `${base?.at(-1) === "/" ? "" : "/"}${sub?.[0] === "/" ? sub.slice(1) : sub}`}`;
+};
+var checkOptionalParameter = (path8) => {
+  if (path8.charCodeAt(path8.length - 1) !== 63 || !path8.includes(":")) {
+    return null;
+  }
+  const segments = path8.split("/");
+  const results = [];
+  let basePath = "";
+  segments.forEach((segment) => {
+    if (segment !== "" && !/\:/.test(segment)) {
+      basePath += "/" + segment;
+    } else if (/\:/.test(segment)) {
+      if (segment.charCodeAt(segment.length - 1) === 63) {
+        if (results.length === 0 && basePath === "") {
+          results.push("/");
+        } else {
+          results.push(basePath);
+        }
+        const optionalSegment = segment.slice(0, -1);
+        basePath += "/" + optionalSegment;
+        results.push(basePath);
+      } else {
+        basePath += "/" + segment;
+      }
+    }
+  });
+  return results.filter((v, i, a) => a.indexOf(v) === i);
+};
+var tryDecodeURIComponent = (str) => str.indexOf("%") !== -1 ? tryDecode(str, decodeURIComponent_) : str;
+var _decodeURI = (value) => {
+  if (value.indexOf("+") !== -1) {
+    value = value.replace(/\+/g, " ");
+  }
+  return tryDecodeURIComponent(value);
+};
+var _getQueryParam = (url, key, multiple) => {
+  const hashIndex = url.indexOf("#", 8);
+  if (hashIndex !== -1) {
+    url = url.slice(0, hashIndex);
+  }
+  let encoded;
+  if (!multiple && key && key.indexOf("%") === -1 && key.indexOf("+") === -1) {
+    let keyIndex2 = url.indexOf("?", 8);
+    if (keyIndex2 === -1) {
+      return void 0;
+    }
+    if (!url.startsWith(key, keyIndex2 + 1)) {
+      keyIndex2 = url.indexOf(`&${key}`, keyIndex2 + 1);
+    }
+    while (keyIndex2 !== -1) {
+      const trailingKeyCode = url.charCodeAt(keyIndex2 + key.length + 1);
+      if (trailingKeyCode === 61) {
+        const valueIndex = keyIndex2 + key.length + 2;
+        const endIndex = url.indexOf("&", valueIndex);
+        return _decodeURI(url.slice(valueIndex, endIndex === -1 ? void 0 : endIndex));
+      } else if (trailingKeyCode == 38 || isNaN(trailingKeyCode)) {
+        return "";
+      }
+      keyIndex2 = url.indexOf(`&${key}`, keyIndex2 + 1);
+    }
+    encoded = /[%+]/.test(url);
+    if (!encoded) {
+      return void 0;
+    }
+  }
+  const results = /* @__PURE__ */ Object.create(null);
+  encoded ??= /[%+]/.test(url);
+  let keyIndex = url.indexOf("?", 8);
+  while (keyIndex !== -1) {
+    const nextKeyIndex = url.indexOf("&", keyIndex + 1);
+    let valueIndex = url.indexOf("=", keyIndex);
+    if (valueIndex > nextKeyIndex && nextKeyIndex !== -1) {
+      valueIndex = -1;
+    }
+    let name = url.slice(
+      keyIndex + 1,
+      valueIndex === -1 ? nextKeyIndex === -1 ? void 0 : nextKeyIndex : valueIndex
+    );
+    if (encoded) {
+      name = _decodeURI(name);
+    }
+    keyIndex = nextKeyIndex;
+    if (name === "") {
+      continue;
+    }
+    let value;
+    if (valueIndex === -1) {
+      value = "";
+    } else {
+      value = url.slice(valueIndex + 1, nextKeyIndex === -1 ? void 0 : nextKeyIndex);
+      if (encoded) {
+        value = _decodeURI(value);
+      }
+    }
+    if (multiple) {
+      if (!(results[name] && Array.isArray(results[name]))) {
+        results[name] = [];
+      }
+      ;
+      results[name].push(value);
+    } else {
+      results[name] ??= value;
+    }
+  }
+  return key ? results[key] : results;
+};
+var getQueryParam = _getQueryParam;
+var getQueryParams = (url, key) => {
+  return _getQueryParam(url, key, true);
+};
+var decodeURIComponent_ = decodeURIComponent;
+
+// node_modules/.pnpm/hono@4.13.7/node_modules/hono/dist/request.js
+var HonoRequest = class {
+  /**
+   * `.raw` can get the raw Request object.
+   *
+   * @see {@link https://hono.dev/docs/api/request#raw}
+   *
+   * @example
+   * ```ts
+   * // For Cloudflare Workers
+   * app.post('/', async (c) => {
+   *   const metadata = c.req.raw.cf?.hostMetadata?
+   *   ...
+   * })
+   * ```
+   */
+  raw;
+  #validatedData;
+  // Short name of validatedData
+  #matchResult;
+  routeIndex = 0;
+  /**
+   * `.path` can get the pathname of the request.
+   *
+   * @see {@link https://hono.dev/docs/api/request#path}
+   *
+   * @example
+   * ```ts
+   * app.get('/about/me', (c) => {
+   *   const pathname = c.req.path // `/about/me`
+   * })
+   * ```
+   */
+  path;
+  bodyCache = {};
+  constructor(request, path8 = "/", matchResult = [[]]) {
+    this.raw = request;
+    this.path = path8;
+    this.#matchResult = matchResult;
+  }
+  param(key) {
+    return key ? this.#getDecodedParam(key) : this.#getAllDecodedParams();
+  }
+  #getDecodedParam(key) {
+    const paramKey = this.#matchResult[0][this.routeIndex]?.[1][key];
+    const param = this.#getParamValue(paramKey);
+    return param && tryDecodeURIComponent(param);
+  }
+  #getAllDecodedParams() {
+    const decoded = {};
+    const keys = Object.keys(this.#matchResult[0][this.routeIndex]?.[1] ?? {});
+    for (const key of keys) {
+      const value = this.#getParamValue(this.#matchResult[0][this.routeIndex][1][key]);
+      if (value !== void 0) {
+        decoded[key] = tryDecodeURIComponent(value);
+      }
+    }
+    return decoded;
+  }
+  #getParamValue(paramKey) {
+    return this.#matchResult[1] ? this.#matchResult[1][paramKey] : paramKey;
+  }
+  query(key) {
+    return getQueryParam(this.url, key);
+  }
+  queries(key) {
+    return getQueryParams(this.url, key);
+  }
+  header(name) {
+    if (name) {
+      return this.raw.headers.get(name) ?? void 0;
+    }
+    const headerData = /* @__PURE__ */ Object.create(null);
+    this.raw.headers.forEach((value, key) => {
+      headerData[key] = value;
+    });
+    return headerData;
+  }
+  async parseBody(options) {
+    return parseBody(this, options);
+  }
+  #cachedBody = (key) => {
+    const { bodyCache, raw: raw2 } = this;
+    const cachedBody = bodyCache[key];
+    if (cachedBody) {
+      return cachedBody;
+    }
+    for (const anyCachedKey in bodyCache) {
+      return bodyCache[anyCachedKey].then((body) => {
+        if (anyCachedKey === "json") {
+          body = JSON.stringify(body);
+        }
+        return new Response(body)[key]();
+      });
+    }
+    return bodyCache[key] = raw2[key]();
+  };
+  /**
+   * `.json()` can parse Request body of type `application/json`
+   *
+   * @see {@link https://hono.dev/docs/api/request#json}
+   *
+   * @example
+   * ```ts
+   * app.post('/entry', async (c) => {
+   *   const body = await c.req.json()
+   * })
+   * ```
+   */
+  json() {
+    return this.#cachedBody("text").then((text) => JSON.parse(text));
+  }
+  /**
+   * `.text()` can parse Request body of type `text/plain`
+   *
+   * @see {@link https://hono.dev/docs/api/request#text}
+   *
+   * @example
+   * ```ts
+   * app.post('/entry', async (c) => {
+   *   const body = await c.req.text()
+   * })
+   * ```
+   */
+  text() {
+    return this.#cachedBody("text");
+  }
+  /**
+   * `.arrayBuffer()` parse Request body as an `ArrayBuffer`
+   *
+   * @see {@link https://hono.dev/docs/api/request#arraybuffer}
+   *
+   * @example
+   * ```ts
+   * app.post('/entry', async (c) => {
+   *   const body = await c.req.arrayBuffer()
+   * })
+   * ```
+   */
+  arrayBuffer() {
+    return this.#cachedBody("arrayBuffer");
+  }
+  /**
+   * `.bytes()` parses the request body as a `Uint8Array`.
+   *
+   * @see {@link https://hono.dev/docs/api/request#bytes}
+   *
+   * @example
+   * ```ts
+   * app.post('/entry', async (c) => {
+   *   const body = await c.req.bytes()
+   * })
+   * ```
+   */
+  bytes() {
+    return this.#cachedBody("arrayBuffer").then((buffer) => new Uint8Array(buffer));
+  }
+  /**
+   * Parses the request body as a `Blob`.
+   * @example
+   * ```ts
+   * app.post('/entry', async (c) => {
+   *   const body = await c.req.blob();
+   * });
+   * ```
+   * @see https://hono.dev/docs/api/request#blob
+   */
+  blob() {
+    return this.#cachedBody("blob");
+  }
+  /**
+   * Parses the request body as `FormData`.
+   * @example
+   * ```ts
+   * app.post('/entry', async (c) => {
+   *   const body = await c.req.formData();
+   * });
+   * ```
+   * @see https://hono.dev/docs/api/request#formdata
+   */
+  formData() {
+    return this.#cachedBody("formData");
+  }
+  /**
+   * Adds validated data to the request.
+   *
+   * @param target - The target of the validation.
+   * @param data - The validated data to add.
+   */
+  addValidatedData(target, data) {
+    ;
+    (this.#validatedData ??= {})[target] = data;
+  }
+  valid(target) {
+    return this.#validatedData?.[target];
+  }
+  /**
+   * `.url()` can get the request url strings.
+   *
+   * @see {@link https://hono.dev/docs/api/request#url}
+   *
+   * @example
+   * ```ts
+   * app.get('/about/me', (c) => {
+   *   const url = c.req.url // `http://localhost:8787/about/me`
+   *   ...
+   * })
+   * ```
+   */
+  get url() {
+    return this.raw.url;
+  }
+  /**
+   * `.method()` can get the method name of the request.
+   *
+   * @see {@link https://hono.dev/docs/api/request#method}
+   *
+   * @example
+   * ```ts
+   * app.get('/about/me', (c) => {
+   *   const method = c.req.method // `GET`
+   * })
+   * ```
+   */
+  get method() {
+    return this.raw.method;
+  }
+  get [GET_MATCH_RESULT]() {
+    return this.#matchResult;
+  }
+  /**
+   * `.matchedRoutes()` can return a matched route in the handler
+   *
+   * @deprecated
+   *
+   * Use matchedRoutes helper defined in "hono/route" instead.
+   *
+   * @see {@link https://hono.dev/docs/api/request#matchedroutes}
+   *
+   * @example
+   * ```ts
+   * app.use('*', async function logger(c, next) {
+   *   await next()
+   *   c.req.matchedRoutes.forEach(({ handler, method, path }, i) => {
+   *     const name = handler.name || (handler.length < 2 ? '[handler]' : '[middleware]')
+   *     console.log(
+   *       method,
+   *       ' ',
+   *       path,
+   *       ' '.repeat(Math.max(10 - path.length, 0)),
+   *       name,
+   *       i === c.req.routeIndex ? '<- respond from here' : ''
+   *     )
+   *   })
+   * })
+   * ```
+   */
+  get matchedRoutes() {
+    return this.#matchResult[0].map(([[, route]]) => route);
+  }
+  /**
+   * `routePath()` can retrieve the path registered within the handler
+   *
+   * @deprecated
+   *
+   * Use routePath helper defined in "hono/route" instead.
+   *
+   * @see {@link https://hono.dev/docs/api/request#routepath}
+   *
+   * @example
+   * ```ts
+   * app.get('/posts/:id', (c) => {
+   *   return c.json({ path: c.req.routePath })
+   * })
+   * ```
+   */
+  get routePath() {
+    return this.#matchResult[0].map(([[, route]]) => route)[this.routeIndex].path;
+  }
+};
+
+// node_modules/.pnpm/hono@4.13.7/node_modules/hono/dist/utils/html.js
+var HtmlEscapedCallbackPhase = {
+  Stringify: 1,
+  BeforeStream: 2,
+  Stream: 3
+};
+var raw = (value, callbacks) => {
+  const escapedString = new String(value);
+  escapedString.isEscaped = true;
+  escapedString.callbacks = callbacks;
+  return escapedString;
+};
+var resolveCallback = async (str, phase, preserveCallbacks, context, buffer) => {
+  if (typeof str === "object" && !(str instanceof String)) {
+    if (!(str instanceof Promise)) {
+      str = str.toString();
+    }
+    if (str instanceof Promise) {
+      str = await str;
+    }
+  }
+  const callbacks = str.callbacks;
+  if (!callbacks?.length) {
+    return Promise.resolve(str);
+  }
+  if (buffer) {
+    buffer[0] += str;
+  } else {
+    buffer = [str];
+  }
+  const resStr = Promise.all(callbacks.map((c) => c({ phase, buffer, context }))).then(
+    (res) => Promise.all(
+      res.filter(Boolean).map((str2) => resolveCallback(str2, phase, false, context, buffer))
+    ).then(() => buffer[0])
+  );
+  if (preserveCallbacks) {
+    return raw(await resStr, callbacks);
+  } else {
+    return resStr;
+  }
+};
+
+// node_modules/.pnpm/hono@4.13.7/node_modules/hono/dist/context.js
+var TEXT_PLAIN = "text/plain; charset=UTF-8";
+var setDefaultContentType = (contentType, headers) => {
+  return {
+    "Content-Type": contentType,
+    ...headers
+  };
+};
+var createResponseInstance = (body, init) => new Response(body, init);
+var Context = class {
+  #rawRequest;
+  #req;
+  /**
+   * `.env` can get bindings (environment variables, secrets, KV namespaces, D1 database, R2 bucket etc.) in Cloudflare Workers.
+   *
+   * @see {@link https://hono.dev/docs/api/context#env}
+   *
+   * @example
+   * ```ts
+   * // Environment object for Cloudflare Workers
+   * app.get('*', async c => {
+   *   const counter = c.env.COUNTER
+   * })
+   * ```
+   */
+  env = {};
+  #var;
+  finalized = false;
+  /**
+   * `.error` can get the error object from the middleware if the Handler throws an error.
+   *
+   * @see {@link https://hono.dev/docs/api/context#error}
+   *
+   * @example
+   * ```ts
+   * app.use('*', async (c, next) => {
+   *   await next()
+   *   if (c.error) {
+   *     // do something...
+   *   }
+   * })
+   * ```
+   */
+  error;
+  #status;
+  #executionCtx;
+  #res;
+  #layout;
+  #renderer;
+  #notFoundHandler;
+  #preparedHeaders;
+  #matchResult;
+  #path;
+  /**
+   * Creates an instance of the Context class.
+   *
+   * @param req - The Request object.
+   * @param options - Optional configuration options for the context.
+   */
+  constructor(req, options) {
+    this.#rawRequest = req;
+    if (options) {
+      this.#executionCtx = options.executionCtx;
+      this.env = options.env;
+      this.#notFoundHandler = options.notFoundHandler;
+      this.#path = options.path;
+      this.#matchResult = options.matchResult;
+    }
+  }
+  /**
+   * `.req` is the instance of {@link HonoRequest}.
+   */
+  get req() {
+    this.#req ??= new HonoRequest(this.#rawRequest, this.#path, this.#matchResult);
+    return this.#req;
+  }
+  /**
+   * @see {@link https://hono.dev/docs/api/context#event}
+   * The FetchEvent associated with the current request.
+   *
+   * @throws Will throw an error if the context does not have a FetchEvent.
+   */
+  get event() {
+    if (this.#executionCtx && "respondWith" in this.#executionCtx) {
+      return this.#executionCtx;
+    } else {
+      throw Error("This context has no FetchEvent");
+    }
+  }
+  /**
+   * @see {@link https://hono.dev/docs/api/context#executionctx}
+   * The ExecutionContext associated with the current request.
+   *
+   * @throws Will throw an error if the context does not have an ExecutionContext.
+   */
+  get executionCtx() {
+    if (this.#executionCtx) {
+      return this.#executionCtx;
+    } else {
+      throw Error("This context has no ExecutionContext");
+    }
+  }
+  /**
+   * @see {@link https://hono.dev/docs/api/context#res}
+   * The Response object for the current request.
+   */
+  get res() {
+    return this.#res ||= createResponseInstance(null, {
+      headers: this.#preparedHeaders ??= new Headers()
+    });
+  }
+  /**
+   * Sets the Response object for the current request.
+   *
+   * @param _res - The Response object to set.
+   */
+  set res(_res) {
+    if (this.#res && _res) {
+      _res = createResponseInstance(_res.body, _res);
+      for (const [k, v] of this.#res.headers.entries()) {
+        if (k === "content-type") {
+          continue;
+        }
+        if (k === "set-cookie") {
+          const cookies = this.#res.headers.getSetCookie();
+          _res.headers.delete("set-cookie");
+          for (const cookie of cookies) {
+            _res.headers.append("set-cookie", cookie);
+          }
+        } else {
+          _res.headers.set(k, v);
+        }
+      }
+    }
+    this.#res = _res;
+    this.finalized = true;
+  }
+  /**
+   * `.render()` can create a response within a layout.
+   *
+   * @see {@link https://hono.dev/docs/api/context#render-setrenderer}
+   *
+   * @example
+   * ```ts
+   * app.get('/', (c) => {
+   *   return c.render('Hello!')
+   * })
+   * ```
+   */
+  render = (...args) => {
+    this.#renderer ??= (content) => this.html(content);
+    return this.#renderer(...args);
+  };
+  /**
+   * Sets the layout for the response.
+   *
+   * @param layout - The layout to set.
+   * @returns The layout function.
+   */
+  setLayout = (layout) => this.#layout = layout;
+  /**
+   * Gets the current layout for the response.
+   *
+   * @returns The current layout function.
+   */
+  getLayout = () => this.#layout;
+  /**
+   * `.setRenderer()` can set the layout in the custom middleware.
+   *
+   * @see {@link https://hono.dev/docs/api/context#render-setrenderer}
+   *
+   * @example
+   * ```tsx
+   * app.use('*', async (c, next) => {
+   *   c.setRenderer((content) => {
+   *     return c.html(
+   *       <html>
+   *         <body>
+   *           <p>{content}</p>
+   *         </body>
+   *       </html>
+   *     )
+   *   })
+   *   await next()
+   * })
+   * ```
+   */
+  setRenderer = (renderer) => {
+    this.#renderer = renderer;
+  };
+  /**
+   * `.header()` can set headers.
+   *
+   * @see {@link https://hono.dev/docs/api/context#header}
+   *
+   * @example
+   * ```ts
+   * app.get('/welcome', (c) => {
+   *   // Set headers
+   *   c.header('X-Message', 'Hello!')
+   *   c.header('Content-Type', 'text/plain')
+   *
+   *   // Append multiple headers using the append option (e.g. Vary)
+   *   c.header('Vary', 'Accept-Encoding', { append: true })
+   *   c.header('Vary', 'User-Agent', { append: true })
+   *
+   *   return c.body('Thank you for coming')
+   * })
+   * ```
+   */
+  header = (name, value, options) => {
+    if (this.finalized) {
+      this.#res = createResponseInstance(this.#res.body, this.#res);
+    }
+    const headers = this.#res ? this.#res.headers : this.#preparedHeaders ??= new Headers();
+    if (value === void 0) {
+      headers.delete(name);
+    } else if (options?.append) {
+      headers.append(name, value);
+    } else {
+      headers.set(name, value);
+    }
+  };
+  status = (status) => {
+    this.#status = status;
+  };
+  /**
+   * `.set()` can set the value specified by the key.
+   *
+   * @see {@link https://hono.dev/docs/api/context#set-get}
+   *
+   * @example
+   * ```ts
+   * app.use('*', async (c, next) => {
+   *   c.set('message', 'Hono is hot!!')
+   *   await next()
+   * })
+   * ```
+   */
+  set = (key, value) => {
+    this.#var ??= /* @__PURE__ */ new Map();
+    this.#var.set(key, value);
+  };
+  /**
+   * `.get()` can use the value specified by the key.
+   *
+   * @see {@link https://hono.dev/docs/api/context#set-get}
+   *
+   * @example
+   * ```ts
+   * app.get('/', (c) => {
+   *   const message = c.get('message')
+   *   return c.text(`The message is "${message}"`)
+   * })
+   * ```
+   */
+  get = (key) => {
+    return this.#var ? this.#var.get(key) : void 0;
+  };
+  /**
+   * `.var` can access the value of a variable.
+   *
+   * @see {@link https://hono.dev/docs/api/context#var}
+   *
+   * @example
+   * ```ts
+   * const result = c.var.client.oneMethod()
+   * ```
+   */
+  // c.var.propName is a read-only
+  get var() {
+    if (!this.#var) {
+      return {};
+    }
+    return Object.fromEntries(this.#var);
+  }
+  #newResponse(data, arg, headers) {
+    let responseHeaders = this.#res ? new Headers(this.#res.headers) : this.#preparedHeaders;
+    if (typeof arg === "object" && arg.headers) {
+      responseHeaders ??= new Headers();
+      for (const [key, value] of new Headers(arg.headers)) {
+        if (key === "set-cookie") {
+          responseHeaders.append(key, value);
+        } else {
+          responseHeaders.set(key, value);
+        }
+      }
+    }
+    if (headers) {
+      if (!responseHeaders) {
+        let count = 0;
+        for (const k in headers) {
+          if (++count > 1 || typeof headers[k] !== "string") {
+            responseHeaders = new Headers();
+            break;
+          }
+        }
+      }
+      if (responseHeaders) {
+        for (const k in headers) {
+          const v = headers[k];
+          if (typeof v === "string") {
+            responseHeaders.set(k, v);
+          } else {
+            responseHeaders.delete(k);
+            for (const v2 of v) {
+              responseHeaders.append(k, v2);
+            }
+          }
+        }
+      }
+    }
+    const status = typeof arg === "number" ? arg : arg?.status ?? this.#status;
+    return createResponseInstance(data, {
+      status,
+      headers: responseHeaders ?? headers
+    });
+  }
+  newResponse = (...args) => this.#newResponse(...args);
+  /**
+   * `.body()` can return the HTTP response.
+   * You can set headers with `.header()` and set HTTP status code with `.status`.
+   * This can also be set in `.text()`, `.json()` and so on.
+   *
+   * @see {@link https://hono.dev/docs/api/context#body}
+   *
+   * @example
+   * ```ts
+   * app.get('/welcome', (c) => {
+   *   // Set headers
+   *   c.header('X-Message', 'Hello!')
+   *   c.header('Content-Type', 'text/plain')
+   *   // Set HTTP status code
+   *   c.status(201)
+   *
+   *   // Return the response body
+   *   return c.body('Thank you for coming')
+   * })
+   * ```
+   */
+  body = (data, arg, headers) => this.#newResponse(data, arg, headers);
+  /**
+   * `.text()` can render text as `Content-Type:text/plain`.
+   *
+   * @see {@link https://hono.dev/docs/api/context#text}
+   *
+   * @example
+   * ```ts
+   * app.get('/say', (c) => {
+   *   return c.text('Hello!')
+   * })
+   * ```
+   */
+  text = (text, arg, headers) => {
+    return !this.#preparedHeaders && !this.#status && !arg && !headers && !this.finalized ? new Response(text) : this.#newResponse(
+      text,
+      arg,
+      setDefaultContentType(TEXT_PLAIN, headers)
+    );
+  };
+  /**
+   * `.json()` can render JSON as `Content-Type:application/json`.
+   *
+   * @see {@link https://hono.dev/docs/api/context#json}
+   *
+   * @example
+   * ```ts
+   * app.get('/api', (c) => {
+   *   return c.json({ message: 'Hello!' })
+   * })
+   * ```
+   */
+  json = (object, arg, headers) => {
+    return this.#newResponse(
+      JSON.stringify(object),
+      arg,
+      setDefaultContentType("application/json", headers)
+    );
+  };
+  html = (html, arg, headers) => {
+    const res = (html2) => this.#newResponse(html2, arg, setDefaultContentType("text/html; charset=UTF-8", headers));
+    return typeof html === "object" ? resolveCallback(html, HtmlEscapedCallbackPhase.Stringify, false, {}).then(res) : res(html);
+  };
+  /**
+   * `.redirect()` can Redirect, default status code is 302.
+   *
+   * @see {@link https://hono.dev/docs/api/context#redirect}
+   *
+   * @example
+   * ```ts
+   * app.get('/redirect', (c) => {
+   *   return c.redirect('/')
+   * })
+   * app.get('/redirect-permanently', (c) => {
+   *   return c.redirect('/', 301)
+   * })
+   * ```
+   */
+  redirect = (location, status) => {
+    const locationString = String(location);
+    this.header(
+      "Location",
+      // Multibyes should be encoded
+      // eslint-disable-next-line no-control-regex
+      !/[^\x00-\xFF]/.test(locationString) ? locationString : encodeURI(locationString)
+    );
+    return this.newResponse(null, status ?? 302);
+  };
+  /**
+   * `.notFound()` can return the Not Found Response.
+   *
+   * @see {@link https://hono.dev/docs/api/context#notfound}
+   *
+   * @example
+   * ```ts
+   * app.get('/notfound', (c) => {
+   *   return c.notFound()
+   * })
+   * ```
+   */
+  notFound = () => {
+    this.#notFoundHandler ??= () => createResponseInstance();
+    return this.#notFoundHandler(this);
+  };
+};
+
+// node_modules/.pnpm/hono@4.13.7/node_modules/hono/dist/router.js
+var METHOD_NAME_ALL = "ALL";
+var METHOD_NAME_ALL_LOWERCASE = "all";
+var METHODS = ["get", "post", "put", "delete", "options", "patch", "query"];
+var MESSAGE_MATCHER_IS_ALREADY_BUILT = "Can not add a route since the matcher is already built.";
+var UnsupportedPathError = class extends Error {
+};
+
+// node_modules/.pnpm/hono@4.13.7/node_modules/hono/dist/utils/constants.js
+var COMPOSED_HANDLER = "__COMPOSED_HANDLER";
+
+// node_modules/.pnpm/hono@4.13.7/node_modules/hono/dist/hono-base.js
+var notFoundHandler = (c) => {
+  return c.text("404 Not Found", 404);
+};
+var errorHandler = (err, c) => {
+  if ("getResponse" in err) {
+    const res = err.getResponse();
+    return c.newResponse(res.body, res);
+  }
+  console.error(err);
+  return c.text("Internal Server Error", 500);
+};
+var Hono = class _Hono {
+  get;
+  post;
+  put;
+  delete;
+  options;
+  patch;
+  query;
+  all;
+  on;
+  use;
+  /*
+    This class is like an abstract class and does not have a router.
+    To use it, inherit the class and implement router in the constructor.
+  */
+  router;
+  getPath;
+  // Cannot use `#` because it requires visibility at JavaScript runtime.
+  _basePath = "/";
+  #path = "/";
+  routes = [];
+  constructor(options = {}) {
+    const allMethods = [...METHODS, METHOD_NAME_ALL_LOWERCASE];
+    allMethods.forEach((method) => {
+      this[method] = (args1, ...args) => {
+        const methodName = method.toUpperCase();
+        if (typeof args1 === "string") {
+          this.#path = args1;
+        } else {
+          this.#addRoute(methodName, this.#path, args1);
+        }
+        args.forEach((handler) => {
+          this.#addRoute(methodName, this.#path, handler);
+        });
+        return this;
+      };
+    });
+    this.on = (method, path8, ...handlers) => {
+      for (const p of [path8].flat()) {
+        this.#path = p;
+        for (const m of [method].flat()) {
+          const methodName = m.toUpperCase();
+          for (const handler of handlers) {
+            this.#addRoute(methodName, this.#path, handler);
+          }
+        }
+      }
+      return this;
+    };
+    this.use = (arg1, ...handlers) => {
+      if (typeof arg1 === "string") {
+        this.#path = arg1;
+      } else {
+        this.#path = "*";
+        handlers.unshift(arg1);
+      }
+      handlers.forEach((handler) => {
+        this.#addRoute(METHOD_NAME_ALL, this.#path, handler);
+      });
+      return this;
+    };
+    const { strict, ...optionsWithoutStrict } = options;
+    Object.assign(this, optionsWithoutStrict);
+    this.getPath = strict ?? true ? options.getPath ?? getPath : getPathNoStrict;
+  }
+  #clone() {
+    const clone = new _Hono({
+      router: this.router,
+      getPath: this.getPath
+    });
+    clone.errorHandler = this.errorHandler;
+    clone.#notFoundHandler = this.#notFoundHandler;
+    clone.routes = this.routes;
+    return clone;
+  }
+  #notFoundHandler = notFoundHandler;
+  // Cannot use `#` because it requires visibility at JavaScript runtime.
+  errorHandler = errorHandler;
+  /**
+   * `.route()` allows grouping other Hono instance in routes.
+   *
+   * @see {@link https://hono.dev/docs/api/routing#grouping}
+   *
+   * @param {string} path - base Path
+   * @param {Hono} app - other Hono instance
+   * @returns {Hono} routed Hono instance
+   *
+   * @example
+   * ```ts
+   * const app = new Hono()
+   * const app2 = new Hono()
+   *
+   * app2.get("/user", (c) => c.text("user"))
+   * app.route("/api", app2) // GET /api/user
+   * ```
+   */
+  route(path8, app) {
+    const subApp = this.basePath(path8);
+    app.routes.map((r) => {
+      let handler;
+      if (app.errorHandler === errorHandler) {
+        handler = r.handler;
+      } else {
+        handler = async (c, next) => (await compose([], app.errorHandler)(c, () => r.handler(c, next))).res;
+        handler[COMPOSED_HANDLER] = r.handler;
+      }
+      subApp.#addRoute(r.method, r.path, handler, r.basePath);
+    });
+    return this;
+  }
+  /**
+   * `.basePath()` allows base paths to be specified.
+   *
+   * @see {@link https://hono.dev/docs/api/routing#base-path}
+   *
+   * @param {string} path - base Path
+   * @returns {Hono} changed Hono instance
+   *
+   * @example
+   * ```ts
+   * const api = new Hono().basePath('/api')
+   * ```
+   */
+  basePath(path8) {
+    const subApp = this.#clone();
+    subApp._basePath = mergePath(this._basePath, path8);
+    return subApp;
+  }
+  /**
+   * `.onError()` handles an error and returns a customized Response.
+   *
+   * @see {@link https://hono.dev/docs/api/hono#error-handling}
+   *
+   * @param {ErrorHandler} handler - request Handler for error
+   * @returns {Hono} changed Hono instance
+   *
+   * @example
+   * ```ts
+   * app.onError((err, c) => {
+   *   console.error(`${err}`)
+   *   return c.text('Custom Error Message', 500)
+   * })
+   * ```
+   */
+  onError = (handler) => {
+    this.errorHandler = handler;
+    return this;
+  };
+  /**
+   * `.notFound()` allows you to customize a Not Found Response.
+   *
+   * @see {@link https://hono.dev/docs/api/hono#not-found}
+   *
+   * @param {NotFoundHandler} handler - request handler for not-found
+   * @returns {Hono} changed Hono instance
+   *
+   * @example
+   * ```ts
+   * app.notFound((c) => {
+   *   return c.text('Custom 404 Message', 404)
+   * })
+   * ```
+   */
+  notFound = (handler) => {
+    this.#notFoundHandler = handler;
+    return this;
+  };
+  /**
+   * `.mount()` allows you to mount applications built with other frameworks into your Hono application.
+   *
+   * @see {@link https://hono.dev/docs/api/hono#mount}
+   *
+   * @param {string} path - base Path
+   * @param {Function} applicationHandler - other Request Handler
+   * @param {MountOptions} [options] - options of `.mount()`
+   * @returns {Hono} mounted Hono instance
+   *
+   * @example
+   * ```ts
+   * import { Router as IttyRouter } from 'itty-router'
+   * import { Hono } from 'hono'
+   * // Create itty-router application
+   * const ittyRouter = IttyRouter()
+   * // GET /itty-router/hello
+   * ittyRouter.get('/hello', () => new Response('Hello from itty-router'))
+   *
+   * const app = new Hono()
+   * app.mount('/itty-router', ittyRouter.handle)
+   * ```
+   *
+   * @example
+   * ```ts
+   * const app = new Hono()
+   * // Send the request to another application without modification.
+   * app.mount('/app', anotherApp, {
+   *   replaceRequest: (req) => req,
+   * })
+   * ```
+   */
+  mount(path8, applicationHandler, options) {
+    let replaceRequest;
+    let optionHandler;
+    if (options) {
+      if (typeof options === "function") {
+        optionHandler = options;
+      } else {
+        optionHandler = options.optionHandler;
+        if (options.replaceRequest === false) {
+          replaceRequest = (request) => request;
+        } else {
+          replaceRequest = options.replaceRequest;
+        }
+      }
+    }
+    const getOptions = optionHandler ? (c) => {
+      const options2 = optionHandler(c);
+      return Array.isArray(options2) ? options2 : [options2];
+    } : (c) => {
+      let executionContext = void 0;
+      try {
+        executionContext = c.executionCtx;
+      } catch {
+      }
+      return [c.env, executionContext];
+    };
+    replaceRequest ||= (() => {
+      const mergedPath = mergePath(this._basePath, path8);
+      const pathPrefixLength = mergedPath === "/" ? 0 : mergedPath.length;
+      return (request) => {
+        const url = new URL(request.url);
+        url.pathname = this.getPath(request).slice(pathPrefixLength) || "/";
+        return new Request(url, request);
+      };
+    })();
+    const handler = async (c, next) => {
+      const res = await applicationHandler(replaceRequest(c.req.raw), ...getOptions(c));
+      if (res) {
+        return res;
+      }
+      await next();
+    };
+    this.#addRoute(METHOD_NAME_ALL, mergePath(path8, "*"), handler);
+    return this;
+  }
+  #addRoute(method, path8, handler, baseRoutePath) {
+    path8 = mergePath(this._basePath, path8);
+    const r = {
+      basePath: baseRoutePath !== void 0 ? mergePath(this._basePath, baseRoutePath) : this._basePath,
+      path: path8,
+      method,
+      handler
+    };
+    this.router.add(method, path8, [handler, r]);
+    this.routes.push(r);
+  }
+  #handleError(err, c) {
+    if (err instanceof Error) {
+      return this.errorHandler(err, c);
+    }
+    throw err;
+  }
+  #dispatch(request, executionCtx, env, method) {
+    if (method === "HEAD") {
+      return (async () => new Response(null, await this.#dispatch(request, executionCtx, env, "GET")))();
+    }
+    const path8 = this.getPath(request, { env });
+    const matchResult = this.router.match(method, path8);
+    const c = new Context(request, {
+      path: path8,
+      matchResult,
+      env,
+      executionCtx,
+      notFoundHandler: this.#notFoundHandler
+    });
+    if (matchResult[0].length === 1) {
+      let res;
+      try {
+        res = matchResult[0][0][0][0](c, async () => {
+          c.res = await this.#notFoundHandler(c);
+        });
+      } catch (err) {
+        return this.#handleError(err, c);
+      }
+      return res instanceof Promise ? res.then(
+        (resolved) => resolved || (c.finalized ? c.res : this.#notFoundHandler(c))
+      ).catch((err) => this.#handleError(err, c)) : res ?? this.#notFoundHandler(c);
+    }
+    const composed = compose(matchResult[0], this.errorHandler, this.#notFoundHandler);
+    return (async () => {
+      try {
+        const context = await composed(c);
+        if (!context.finalized) {
+          throw new Error(
+            "Context is not finalized. Did you forget to return a Response object or `await next()`?"
+          );
+        }
+        return context.res;
+      } catch (err) {
+        return this.#handleError(err, c);
+      }
+    })();
+  }
+  /**
+   * `.fetch()` will be entry point of your app.
+   *
+   * @see {@link https://hono.dev/docs/api/hono#fetch}
+   *
+   * @param {Request} request - request Object of request
+   * @param {Env} env - env Object
+   * @param {ExecutionContext} executionCtx - context of execution
+   * @returns {Response | Promise<Response>} response of request
+   *
+   */
+  fetch = (request, ...rest) => {
+    return this.#dispatch(request, rest[1], rest[0], request.method);
+  };
+  /**
+   * `.request()` is a useful method for testing.
+   * You can pass a URL or pathname to send a GET request.
+   * app will return a Response object.
+   * ```ts
+   * test('GET /hello is ok', async () => {
+   *   const res = await app.request('/hello')
+   *   expect(res.status).toBe(200)
+   * })
+   * ```
+   * @see https://hono.dev/docs/api/hono#request
+   */
+  request = (input, requestInit, Env, executionCtx) => {
+    if (input instanceof Request) {
+      return this.fetch(requestInit ? new Request(input, requestInit) : input, Env, executionCtx);
+    }
+    input = input.toString();
+    return this.fetch(
+      new Request(
+        /^https?:\/\//.test(input) ? input : `http://localhost${mergePath("/", input)}`,
+        requestInit
+      ),
+      Env,
+      executionCtx
+    );
+  };
+  /**
+   * `.fire()` automatically adds a global fetch event listener.
+   * This can be useful for environments that adhere to the Service Worker API, such as non-ES module Cloudflare Workers.
+   * @deprecated
+   * Use `fire` from `hono/service-worker` instead.
+   * ```ts
+   * import { Hono } from 'hono'
+   * import { fire } from 'hono/service-worker'
+   *
+   * const app = new Hono()
+   * // ...
+   * fire(app)
+   * ```
+   * @see https://hono.dev/docs/api/hono#fire
+   * @see https://developer.mozilla.org/en-US/docs/Web/API/Service_Worker_API
+   * @see https://developers.cloudflare.com/workers/reference/migrate-to-module-workers/
+   */
+  fire = () => {
+    addEventListener("fetch", (event) => {
+      event.respondWith(this.#dispatch(event.request, event, void 0, event.request.method));
+    });
+  };
+};
+
+// node_modules/.pnpm/hono@4.13.7/node_modules/hono/dist/router/utils.js
+var createNullObject = () => /* @__PURE__ */ Object.create(null);
+
+// node_modules/.pnpm/hono@4.13.7/node_modules/hono/dist/router/reg-exp-router/matcher.js
+var emptyParam = [];
+function match(method, path8) {
+  const matchers = this.buildAllMatchers();
+  const match2 = ((method2, path22) => {
+    const matcher = matchers[method2] || matchers[METHOD_NAME_ALL];
+    const staticMatch = matcher[2][path22];
+    if (staticMatch) {
+      return staticMatch;
+    }
+    const match3 = path22.match(matcher[0]);
+    if (!match3) {
+      return [[], emptyParam];
+    }
+    const index = match3.indexOf("", 1);
+    return [matcher[1][index], match3];
+  });
+  this.match = match2;
+  return match2(method, path8);
+}
+
+// node_modules/.pnpm/hono@4.13.7/node_modules/hono/dist/router/reg-exp-router/node.js
+var LABEL_REG_EXP_STR = "[^/]+";
+var ONLY_WILDCARD_REG_EXP_STR = ".*";
+var TAIL_WILDCARD_REG_EXP_STR = "(?:|/.*)";
+var PATH_ERROR = /* @__PURE__ */ Symbol();
+var regExpMetaChars = new Set(".\\+*[^]$()");
+function compareKey(a, b) {
+  if (a.length === 1) {
+    return b.length === 1 ? a < b ? -1 : 1 : -1;
+  }
+  if (b.length === 1) {
+    return 1;
+  }
+  if (a === ONLY_WILDCARD_REG_EXP_STR || a === TAIL_WILDCARD_REG_EXP_STR) {
+    return b === TAIL_WILDCARD_REG_EXP_STR ? -1 : 1;
+  } else if (b === ONLY_WILDCARD_REG_EXP_STR || b === TAIL_WILDCARD_REG_EXP_STR) {
+    return -1;
+  }
+  if (a === LABEL_REG_EXP_STR) {
+    return 1;
+  } else if (b === LABEL_REG_EXP_STR) {
+    return -1;
+  }
+  return a.length === b.length ? a < b ? -1 : 1 : b.length - a.length;
+}
+var Node = class _Node {
+  // handler index of a dynamic path, or -1 for a static path terminal
+  #index;
+  #varIndex;
+  #children = createNullObject();
+  insert(tokens, index, paramMap, context, isStatic) {
+    let node = this;
+    for (let i = 0, len = tokens.length; i < len; i++) {
+      const token = tokens[i];
+      const pattern = token.length === 1 ? token === "*" ? i === len - 1 ? ["", "", ONLY_WILDCARD_REG_EXP_STR] : ["", "", LABEL_REG_EXP_STR] : null : token === "/*" ? ["", "", TAIL_WILDCARD_REG_EXP_STR] : token.match(/^\:([^\{\}]+)(?:\{(.+)\})?$/);
+      let nextNode;
+      if (pattern) {
+        const name = pattern[1];
+        let regexpStr = pattern[2] || LABEL_REG_EXP_STR;
+        if (name && pattern[2]) {
+          if (regexpStr === ".*") {
+            throw PATH_ERROR;
+          }
+          regexpStr = regexpStr.replace(/^\((?!\?:)(?=[^)]+\)$)/, "(?:");
+          if (/\((?!\?:)/.test(regexpStr)) {
+            throw PATH_ERROR;
+          }
+          if (regexpStr.length === 1 && regExpMetaChars.has(regexpStr)) {
+            throw PATH_ERROR;
+          }
+        }
+        nextNode = node.#children[regexpStr];
+        if (!nextNode) {
+          if (regexpStr !== ONLY_WILDCARD_REG_EXP_STR && regexpStr !== TAIL_WILDCARD_REG_EXP_STR) {
+            for (const k in node.#children) {
+              if (
+                // a single-char pattern coexists with single-char literals as a literal does
+                (regexpStr.length > 1 || k.length > 1) && k !== ONLY_WILDCARD_REG_EXP_STR && k !== TAIL_WILDCARD_REG_EXP_STR
+              ) {
+                throw PATH_ERROR;
+              }
+            }
+          }
+          nextNode = node.#children[regexpStr] = new _Node();
+        }
+        if (name !== "") {
+          nextNode.#varIndex ??= context.varIndex++;
+          paramMap.push([name, nextNode.#varIndex]);
+        }
+      } else {
+        nextNode = node.#children[token];
+        if (!nextNode) {
+          for (const k in node.#children) {
+            if (k.length > 1 && k !== ONLY_WILDCARD_REG_EXP_STR && k !== TAIL_WILDCARD_REG_EXP_STR) {
+              throw PATH_ERROR;
+            }
+          }
+          nextNode = node.#children[token] = new _Node();
+        }
+      }
+      node = nextNode;
+    }
+    if (node.#index !== void 0) {
+      throw PATH_ERROR;
+    }
+    node.#index = isStatic ? -1 : index;
+  }
+  buildRegExpStr() {
+    const childKeys = Object.keys(this.#children).sort(compareKey);
+    const strList = childKeys.map((k) => {
+      const c = this.#children[k];
+      const childStr = c.buildRegExpStr();
+      return childStr === "" ? "" : (typeof c.#varIndex === "number" ? `(${k})@${c.#varIndex}` : regExpMetaChars.has(k) ? `\\${k}` : k) + childStr;
+    }).filter(Boolean);
+    if (typeof this.#index === "number" && this.#index !== -1) {
+      strList.unshift(`#${this.#index}`);
+    }
+    if (strList.length === 0) {
+      return "";
+    }
+    if (strList.length === 1) {
+      return strList[0];
+    }
+    return "(?:" + strList.join("|") + ")";
+  }
+};
+
+// node_modules/.pnpm/hono@4.13.7/node_modules/hono/dist/router/reg-exp-router/trie.js
+var Trie = class {
+  #context = { varIndex: 0 };
+  #root = new Node();
+  #index = 0;
+  // dynamic path -> [handler index, param assoc]; static paths are not registered
+  paths = createNullObject();
+  insert(path8, isStatic) {
+    if (isStatic) {
+      this.#root.insert(path8.split(""), 0, [], this.#context, true);
+      return;
+    }
+    const paramAssoc = [];
+    const groups = [];
+    let markedPath = path8;
+    for (let i = 0; ; ) {
+      let replaced = false;
+      markedPath = markedPath.replace(/\{[^}]+\}/g, (m) => {
+        const mark = `@\\${i}`;
+        groups[i] = [mark, m];
+        i++;
+        replaced = true;
+        return mark;
+      });
+      if (!replaced) {
+        break;
+      }
+    }
+    const tokens = markedPath.match(/(?::[^\/]+)|(?:\/\*$)|./g) || [];
+    for (let i = groups.length - 1; i >= 0; i--) {
+      const [mark] = groups[i];
+      for (let j = tokens.length - 1; j >= 0; j--) {
+        if (tokens[j].indexOf(mark) !== -1) {
+          tokens[j] = tokens[j].replace(mark, groups[i][1]);
+          break;
+        }
+      }
+    }
+    this.#root.insert(tokens, this.#index, paramAssoc, this.#context, false);
+    this.paths[path8] = [this.#index++, paramAssoc];
+  }
+  buildRegExp() {
+    let regexp = this.#root.buildRegExpStr();
+    if (regexp === "") {
+      return [/^$/, [], []];
+    }
+    let captureIndex = 0;
+    const indexReplacementMap = [];
+    const paramReplacementMap = [];
+    regexp = regexp.replace(/#(\d+)|@(\d+)|\.\*\$/g, (_, handlerIndex, paramIndex) => {
+      if (handlerIndex !== void 0) {
+        indexReplacementMap[++captureIndex] = Number(handlerIndex);
+        return "$()";
+      }
+      if (paramIndex !== void 0) {
+        paramReplacementMap[Number(paramIndex)] = ++captureIndex;
+        return "";
+      }
+      return "";
+    });
+    return [new RegExp(`^${regexp}`), indexReplacementMap, paramReplacementMap];
+  }
+};
+
+// node_modules/.pnpm/hono@4.13.7/node_modules/hono/dist/router/reg-exp-router/router.js
+var wildcardRegExpCache = createNullObject();
+function buildWildcardRegExp(path8) {
+  return wildcardRegExpCache[path8] ??= new RegExp(
+    `^${path8.replace(
+      /\/:[^/{}]+(?:\{\[\^\/]\+})?(?=[/{]|$)|\/?\*$|([.\\+*[^\]$()?{}|])/g,
+      (match2, metaChar) => metaChar ? `\\${metaChar}` : match2 === "/*" ? TAIL_WILDCARD_REG_EXP_STR : match2 === "*" ? ONLY_WILDCARD_REG_EXP_STR : `/:${LABEL_REG_EXP_STR}`
+    )}$`
+  );
+}
+function findMiddleware(middleware, path8) {
+  for (const k of Object.keys(middleware).sort((a, b) => b.length - a.length)) {
+    if (buildWildcardRegExp(k).test(path8)) {
+      return [...middleware[k]];
+    }
+  }
+  return void 0;
+}
+var RegExpRouter = class {
+  name = "RegExpRouter";
+  #middleware;
+  #routes;
+  #tries;
+  constructor() {
+    this.#middleware = { [METHOD_NAME_ALL]: createNullObject() };
+    this.#routes = { [METHOD_NAME_ALL]: createNullObject() };
+    this.#tries = { [METHOD_NAME_ALL]: new Trie() };
+  }
+  #insertPath(method, path8) {
+    try {
+      this.#tries[method].insert(path8, !/\*|\/:/.test(path8));
+    } catch (e) {
+      throw e === PATH_ERROR ? new UnsupportedPathError(path8) : e;
+    }
+  }
+  add(method, path8, handler) {
+    const middleware = this.#middleware;
+    const routes = this.#routes;
+    if (!middleware) {
+      throw new Error(MESSAGE_MATCHER_IS_ALREADY_BUILT);
+    }
+    if (!middleware[method]) {
+      this.#tries[method] = new Trie();
+      for (const handlerMap of [middleware, routes]) {
+        handlerMap[method] = createNullObject();
+        for (const p in handlerMap[METHOD_NAME_ALL]) {
+          handlerMap[method][p] = [...handlerMap[METHOD_NAME_ALL][p]];
+          this.#insertPath(method, p);
+        }
+      }
+    }
+    if (path8 === "/*") {
+      path8 = "*";
+    }
+    const methods = method === METHOD_NAME_ALL ? Object.keys(middleware) : [method];
+    if (/\*$/.test(path8)) {
+      const re = buildWildcardRegExp(path8);
+      for (const m of methods) {
+        if (!middleware[m][path8]) {
+          this.#insertPath(m, path8);
+          middleware[m][path8] = findMiddleware(middleware[m], path8) || findMiddleware(middleware[METHOD_NAME_ALL], path8) || [];
+        }
+      }
+      for (const handlerMap of [middleware, routes]) {
+        for (const m of methods) {
+          for (const p in handlerMap[m]) {
+            re.test(p) && handlerMap[m][p].push([handler, path8]);
+          }
+        }
+      }
+      return;
+    }
+    const paths = checkOptionalParameter(path8) || [path8];
+    for (const path22 of paths) {
+      for (const m of methods) {
+        if (!routes[m][path22]) {
+          this.#insertPath(m, path22);
+          routes[m][path22] = findMiddleware(middleware[m], path22) || findMiddleware(middleware[METHOD_NAME_ALL], path22) || [];
+        }
+        routes[m][path22].push([handler, path22]);
+      }
+    }
+  }
+  match = match;
+  buildAllMatchers() {
+    const matchers = createNullObject();
+    for (const method of Object.keys(this.#routes)) {
+      matchers[method] = this.#buildMatcher(method);
+    }
+    this.#middleware = this.#routes = this.#tries = void 0;
+    wildcardRegExpCache = createNullObject();
+    return matchers;
+  }
+  #buildMatcher(method) {
+    const middleware = this.#middleware[method];
+    const routes = this.#routes[method];
+    const trie = this.#tries[method];
+    const staticMap = createNullObject();
+    const handlerData = [];
+    const [regexp, indexReplacementMap, paramReplacementMap] = trie.buildRegExp();
+    for (const r of [middleware, routes]) {
+      for (const path8 in r) {
+        const handlers = r[path8];
+        const pathData = trie.paths[path8];
+        if (!pathData) {
+          staticMap[path8] = [handlers.map(([h]) => [h, createNullObject()]), emptyParam];
+          continue;
+        }
+        handlerData[pathData[0]] = handlers.map(([h, handlerPath]) => [
+          h,
+          trie.paths[handlerPath][1].reduceRight((map, [key], i) => {
+            map[key] = paramReplacementMap[pathData[1][i][1]];
+            return map;
+          }, createNullObject())
+        ]);
+      }
+    }
+    return [regexp, indexReplacementMap.map((i) => handlerData[i]), staticMap];
+  }
+};
+
+// node_modules/.pnpm/hono@4.13.7/node_modules/hono/dist/router/smart-router/router.js
+var SmartRouter = class {
+  name = "SmartRouter";
+  #routers = [];
+  #routes = [];
+  constructor(init) {
+    this.#routers = init.routers;
+  }
+  add(method, path8, handler) {
+    if (!this.#routes) {
+      throw new Error(MESSAGE_MATCHER_IS_ALREADY_BUILT);
+    }
+    this.#routes.push([method, path8, handler]);
+  }
+  match(method, path8) {
+    if (!this.#routes) {
+      throw new Error("Fatal error");
+    }
+    const routers = this.#routers;
+    const routes = this.#routes;
+    const len = routers.length;
+    let i = 0;
+    let res;
+    for (; i < len; i++) {
+      const router = routers[i];
+      try {
+        for (let i2 = 0, len2 = routes.length; i2 < len2; i2++) {
+          router.add(...routes[i2]);
+        }
+        res = router.match(method, path8);
+      } catch (e) {
+        if (e instanceof UnsupportedPathError) {
+          continue;
+        }
+        throw e;
+      }
+      this.match = router.match.bind(router);
+      this.#routers = [router];
+      this.#routes = void 0;
+      break;
+    }
+    if (i === len) {
+      throw new Error("Fatal error");
+    }
+    this.name = `SmartRouter + ${this.activeRouter.name}`;
+    return res;
+  }
+  get activeRouter() {
+    if (this.#routes || this.#routers.length !== 1) {
+      throw new Error("No active router has been determined yet.");
+    }
+    return this.#routers[0];
+  }
+};
+
+// node_modules/.pnpm/hono@4.13.7/node_modules/hono/dist/router/trie-router/node.js
+var emptyParams = createNullObject();
+var order = 0;
+var Node2 = class _Node2 {
+  #methods = [];
+  #children = createNullObject();
+  #patterns = [];
+  #pattern;
+  #params = emptyParams;
+  insert(method, path8, handler) {
+    let curNode = this;
+    const parts = splitRoutingPath(path8);
+    const possibleKeys = /* @__PURE__ */ new Set();
+    let i = 0;
+    for (const p of parts) {
+      const nextP = parts[++i];
+      const pattern = getPattern(p, nextP) || (nextP === void 0 && p && p.indexOf("*") === p.length - 1 ? p : null);
+      const isParam = Array.isArray(pattern);
+      const key = isParam ? pattern[0] : pattern || p;
+      const child = curNode.#children[key] ||= new _Node2();
+      if (pattern && !child.#pattern) {
+        child.#pattern = pattern;
+        curNode.#patterns.push(child);
+      }
+      curNode = child;
+      if (isParam) {
+        possibleKeys.add(pattern[1]);
+      }
+    }
+    curNode.#methods.push({
+      [method]: {
+        handler,
+        possibleKeys: [...possibleKeys],
+        score: ++order
+      }
+    });
+  }
+  #pushHandlerSets(handlerSets, node, method, nodeParams, params) {
+    for (let i = 0, len = node.#methods.length; i < len; i++) {
+      const m = node.#methods[i];
+      const handlerSet = m[method] || m[METHOD_NAME_ALL];
+      if (handlerSet) {
+        handlerSet.params = createNullObject();
+        handlerSets.push(handlerSet);
+        for (let i2 = 0, len2 = handlerSet.possibleKeys.length; i2 < len2; i2++) {
+          const key = handlerSet.possibleKeys[i2];
+          handlerSet.params[key] = params?.[key] && !i2 ? params[key] : nodeParams[key] ?? params?.[key];
+        }
+      }
+    }
+  }
+  search(method, path8) {
+    const handlerSets = [];
+    this.#params = emptyParams;
+    const curNode = this;
+    let curNodes = [curNode];
+    const parts = splitPath(path8);
+    const curNodesQueue = [];
+    const len = parts.length;
+    let partOffsets = null;
+    for (let i = 0; i < len; i++) {
+      const part = parts[i];
+      const isLast = i === len - 1;
+      const tempNodes = [];
+      for (let j = 0, len2 = curNodes.length; j < len2; j++) {
+        const node = curNodes[j];
+        const nextNode = node.#children[part];
+        if (nextNode) {
+          nextNode.#params = node.#params;
+          if (isLast) {
+            if (nextNode.#children["*"]) {
+              this.#pushHandlerSets(handlerSets, nextNode.#children["*"], method, node.#params);
+            }
+            this.#pushHandlerSets(handlerSets, nextNode, method, node.#params);
+          } else {
+            tempNodes.push(nextNode);
+          }
+        }
+        for (const child of node.#patterns) {
+          const pattern = child.#pattern;
+          const params = node.#params === emptyParams ? {} : { ...node.#params };
+          if (typeof pattern === "string") {
+            if (pattern === "*" || part.startsWith(pattern.slice(0, -1))) {
+              this.#pushHandlerSets(handlerSets, child, method, node.#params);
+              if (pattern === "*") {
+                child.#params = params;
+                tempNodes.push(child);
+              }
+            }
+            continue;
+          }
+          const [, name, matcher] = pattern;
+          if (!part && matcher === true) {
+            continue;
+          }
+          if (matcher !== true) {
+            if (!partOffsets) {
+              partOffsets = [];
+              let offset = path8[0] === "/" ? 1 : 0;
+              for (let p = 0; p < len; p++) {
+                partOffsets[p] = offset;
+                offset += parts[p].length + 1;
+              }
+            }
+            const restPathString = path8.slice(partOffsets[i]);
+            const m = matcher.exec(restPathString);
+            if (m) {
+              params[name] = m[0];
+              this.#pushHandlerSets(handlerSets, child, method, node.#params, params);
+              if (m[0].length === restPathString.length && child.#children["*"]) {
+                this.#pushHandlerSets(
+                  handlerSets,
+                  child.#children["*"],
+                  method,
+                  node.#params,
+                  params
+                );
+              }
+              for (const _ in child.#children) {
+                child.#params = params;
+                const componentCount = m[0].match(/\//g)?.length ?? 0;
+                const targetCurNodes = curNodesQueue[componentCount] ||= [];
+                targetCurNodes.push(child);
+                break;
+              }
+              continue;
+            }
+          }
+          if (matcher === true || matcher.test(part)) {
+            params[name] = part;
+            if (isLast) {
+              this.#pushHandlerSets(handlerSets, child, method, params, node.#params);
+              if (child.#children["*"]) {
+                this.#pushHandlerSets(
+                  handlerSets,
+                  child.#children["*"],
+                  method,
+                  params,
+                  node.#params
+                );
+              }
+            } else {
+              child.#params = params;
+              tempNodes.push(child);
+            }
+          }
+        }
+      }
+      const shifted = curNodesQueue.shift();
+      curNodes = shifted ? tempNodes.concat(shifted) : tempNodes;
+    }
+    if (handlerSets[1]) {
+      handlerSets.sort((a, b) => {
+        return a.score - b.score;
+      });
+    }
+    return [handlerSets.map(({ handler, params }) => [handler, params])];
+  }
+};
+
+// node_modules/.pnpm/hono@4.13.7/node_modules/hono/dist/router/trie-router/router.js
+var TrieRouter = class {
+  name = "TrieRouter";
+  #node = new Node2();
+  add(method, path8, handler) {
+    for (const result of checkOptionalParameter(path8) || [path8]) {
+      this.#node.insert(method, result, handler);
+    }
+  }
+  match(method, path8) {
+    return this.#node.search(method, path8);
+  }
+};
+
+// node_modules/.pnpm/hono@4.13.7/node_modules/hono/dist/hono.js
+var Hono2 = class extends Hono {
+  /**
+   * Creates an instance of the Hono class.
+   *
+   * @param options - Optional configuration options for the Hono instance.
+   */
+  constructor(options = {}) {
+    super(options);
+    this.router = options.router ?? new SmartRouter({
+      routers: [new RegExpRouter(), new TrieRouter()]
+    });
+  }
+};
+
+// packages/shared/src/target.ts
+var TargetKeyError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "TargetKeyError";
+  }
+};
+function isValidRef(ref) {
+  if (!ref || ref.length > 256) return false;
+  if (ref.startsWith("-") || ref.startsWith(".")) return false;
+  if (/[\s\0]/.test(ref)) return false;
+  if (ref.includes("..")) return false;
+  return true;
+}
+function parseSuffix(rest) {
+  if (rest === "working" || rest === "staged" || rest === "all") return { kind: rest };
+  if (rest.startsWith("commit:")) {
+    const sha = rest.slice("commit:".length);
+    if (!isValidRef(sha)) throw new TargetKeyError(`invalid commit ref: ${sha}`);
+    return { kind: "commit", sha };
+  }
+  if (rest.startsWith("range:")) {
+    const spec = rest.slice("range:".length);
+    const idx = spec.indexOf("..");
+    if (idx <= 0) throw new TargetKeyError(`invalid range: ${spec}`);
+    const base = spec.slice(0, idx);
+    const head = spec.slice(idx + 2);
+    if (!isValidRef(base) || !isValidRef(head)) throw new TargetKeyError(`invalid range refs: ${spec}`);
+    return { kind: "range", base, head };
+  }
+  throw new TargetKeyError(`unknown target key: ${rest}`);
+}
+function parseTargetKey(key) {
+  if (typeof key !== "string" || !key) throw new TargetKeyError("empty target key");
+  if (key.startsWith("worktree:")) {
+    const rest = key.slice("worktree:".length);
+    const m = /^(.+):(working|staged|all|commit:.+|range:.+)$/.exec(rest);
+    if (!m || !m[1] || !m[2]) throw new TargetKeyError(`invalid worktree target key: ${key}`);
+    const worktree = m[1];
+    if (!worktree.startsWith("/")) throw new TargetKeyError(`worktree path must be absolute: ${worktree}`);
+    return { ...parseSuffix(m[2]), worktree };
+  }
+  return parseSuffix(key);
+}
+
+// packages/server/src/errors.ts
+var HttpError = class extends Error {
+  constructor(status, message, code) {
+    super(message);
+    this.status = status;
+    this.code = code;
+    this.name = "HttpError";
+  }
+  status;
+  code;
+};
+function badRequest(message, code = "bad_request") {
+  return new HttpError(400, message, code);
+}
+function notFound(message, code = "not_found") {
+  return new HttpError(404, message, code);
+}
+
+// packages/server/src/git.ts
+import { execFile } from "child_process";
+var ALLOWED_SUBCOMMANDS = /* @__PURE__ */ new Set(["rev-parse", "diff", "show", "log", "worktree", "ls-files", "status"]);
+var FORBIDDEN_OPTION_PREFIXES = ["--output", "--ext-diff", "--textconv", "-c", "--config-env", "--exec-path", "--git-dir", "--work-tree"];
+var DEFAULT_GIT_TIMEOUT_MS = 3e4;
+var EMPTY_TREE_SHA = "4b825dc642cb6eb9a060e54bf8d69288fbee4904";
+var GitError = class extends HttpError {
+  constructor(message, exitCode, stderr, status = 500, code = "git_error") {
+    super(status, message, code);
+    this.exitCode = exitCode;
+    this.stderr = stderr;
+    this.name = "GitError";
+  }
+  exitCode;
+  stderr;
+};
+function assertAllowedGitArgs(args) {
+  const sub = args[0];
+  if (!sub || !ALLOWED_SUBCOMMANDS.has(sub)) {
+    throw new GitError(`git sub-command not allowed: ${sub ?? "(none)"}`, null, "", 400, "git_subcommand_forbidden");
+  }
+  if (sub === "worktree" && args[1] !== "list") {
+    throw new GitError(`git worktree ${args[1] ?? ""} is not allowed`, null, "", 400, "git_subcommand_forbidden");
+  }
+  for (const arg of args.slice(1)) {
+    if (arg.includes("\0")) throw new GitError("NUL byte in git argument", null, "", 400, "git_bad_argument");
+    for (const prefix of FORBIDDEN_OPTION_PREFIXES) {
+      if (arg === prefix || arg.startsWith(prefix + "=")) {
+        throw new GitError(`git option not allowed: ${arg}`, null, "", 400, "git_option_forbidden");
+      }
+    }
+  }
+}
+async function runGit(args, opts) {
+  assertAllowedGitArgs(args);
+  const okCodes = opts.okCodes ?? [0];
+  return new Promise((resolve, reject) => {
+    execFile(
+      "git",
+      [...args],
+      {
+        cwd: opts.cwd,
+        timeout: opts.timeoutMs ?? DEFAULT_GIT_TIMEOUT_MS,
+        maxBuffer: opts.maxBuffer ?? 256 * 1024 * 1024,
+        encoding: "utf8",
+        env: {
+          ...process.env,
+          // Never take the index lock / refresh the index as a side effect of diff/status.
+          GIT_OPTIONAL_LOCKS: "0",
+          LC_ALL: "C",
+          GIT_PAGER: "cat",
+          PAGER: "cat",
+          GIT_TERMINAL_PROMPT: "0"
+        },
+        windowsHide: true
+      },
+      (error, stdout, stderr) => {
+        const err = error;
+        if (err) {
+          if (err.killed || err.signal === "SIGTERM") {
+            reject(new GitError(`git ${args[0]} timed out`, null, stderr, 504, "git_timeout"));
+            return;
+          }
+          if (err.code === "ENOENT") {
+            reject(new GitError("git executable not found in PATH", null, "", 500, "git_missing"));
+            return;
+          }
+          const code = typeof err.code === "number" ? err.code : -1;
+          if (okCodes.includes(code)) {
+            resolve({ stdout, stderr, code });
+            return;
+          }
+          const msg = stderr.trim().split("\n")[0] || err.message;
+          reject(new GitError(msg, code, stderr, 500, "git_failed"));
+          return;
+        }
+        resolve({ stdout, stderr, code: 0 });
+      }
+    );
+  });
+}
+async function refExists(cwd, ref) {
+  try {
+    await runGit(["rev-parse", "--verify", "--quiet", `${ref}^{commit}`], { cwd });
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function revParse(cwd, ref) {
+  try {
+    const r = await runGit(["rev-parse", "--verify", "--quiet", ref], { cwd });
+    return r.stdout.trim() || void 0;
+  } catch {
+    return void 0;
+  }
+}
+
+// packages/server/src/repo.ts
+import path from "path";
+import { realpath } from "fs/promises";
+async function safeRealpath(p) {
+  try {
+    return await realpath(p);
+  } catch {
+    return path.resolve(p);
+  }
+}
+async function resolveRepo(dir) {
+  let top;
+  try {
+    const r = await runGit(["rev-parse", "--show-toplevel"], { cwd: dir });
+    top = r.stdout.trim();
+  } catch (e) {
+    throw new HttpError(400, `${dir} is not inside a git repository`, "not_a_repo");
+  }
+  if (!top) throw new HttpError(400, `${dir} is not inside a git worktree (bare repository?)`, "not_a_repo");
+  const root = await safeRealpath(top);
+  const common = await runGit(["rev-parse", "--git-common-dir"], { cwd: root });
+  const commonDir = await safeRealpath(path.resolve(root, common.stdout.trim()));
+  const commonRoot = path.basename(commonDir) === ".git" ? path.dirname(commonDir) : root;
+  return { root, commonRoot };
+}
+async function listWorktrees(ctx) {
+  const r = await runGit(["worktree", "list", "--porcelain"], { cwd: ctx.root });
+  const out = [];
+  let cur = null;
+  const flush = () => {
+    if (cur && cur.path) {
+      out.push({
+        path: cur.path,
+        head: cur.head ?? "",
+        branch: cur.branch,
+        isMain: false,
+        detached: cur.detached ?? false,
+        bare: cur.bare ?? false
+      });
+    }
+    cur = null;
+  };
+  for (const line of r.stdout.split("\n")) {
+    if (!line.trim()) {
+      flush();
+      continue;
+    }
+    if (line.startsWith("worktree ")) {
+      flush();
+      cur = { path: line.slice("worktree ".length) };
+    } else if (!cur) {
+      continue;
+    } else if (line.startsWith("HEAD ")) cur.head = line.slice(5);
+    else if (line.startsWith("branch ")) cur.branch = line.slice(7).replace(/^refs\/heads\//, "");
+    else if (line === "detached") cur.detached = true;
+    else if (line === "bare") cur.bare = true;
+  }
+  flush();
+  for (const wt of out) {
+    wt.path = await safeRealpath(wt.path);
+    wt.isMain = wt.path === ctx.commonRoot;
+  }
+  return out;
+}
+async function getRepoInfo(ctx, defaultTarget) {
+  const [branchRes, headRes, worktrees] = await Promise.all([
+    runGit(["rev-parse", "--abbrev-ref", "HEAD"], { cwd: ctx.root }).catch(() => ({ stdout: "HEAD" })),
+    runGit(["rev-parse", "HEAD"], { cwd: ctx.root }).catch(() => ({ stdout: "" })),
+    listWorktrees(ctx)
+  ]);
+  return {
+    root: ctx.root,
+    commonRoot: ctx.commonRoot,
+    branch: branchRes.stdout.trim(),
+    head: headRes.stdout.trim(),
+    worktrees,
+    defaultTarget
+  };
+}
+
+// packages/server/src/targets.ts
+import path2 from "path";
+import { readFile } from "fs/promises";
+
+// packages/server/src/hash.ts
+import { createHash } from "crypto";
+function sha1(input) {
+  return createHash("sha1").update(input).digest("hex");
+}
+function lineHash(content) {
+  return sha1(content.trimEnd());
+}
+function hunkHash(lineContents) {
+  return sha1(lineContents.map((l) => l.trimEnd()).join("\n").trim());
+}
+
+// packages/server/src/diffparse.ts
+function unquotePath(p) {
+  if (!(p.length >= 2 && p.startsWith('"') && p.endsWith('"'))) return p;
+  const inner = p.slice(1, -1);
+  const bytes = [];
+  for (let i = 0; i < inner.length; i++) {
+    const ch = inner[i];
+    if (ch !== "\\") {
+      const buf = Buffer.from(ch, "utf8");
+      for (const b of buf) bytes.push(b);
+      continue;
+    }
+    const next = inner[i + 1];
+    if (next === void 0) break;
+    if (/[0-7]/.test(next)) {
+      let oct = "";
+      let j = i + 1;
+      while (j < inner.length && oct.length < 3 && /[0-7]/.test(inner[j])) {
+        oct += inner[j];
+        j++;
+      }
+      bytes.push(parseInt(oct, 8));
+      i = j - 1;
+      continue;
+    }
+    const map = { n: 10, t: 9, r: 13, b: 8, f: 12, a: 7, v: 11, "\\": 92, '"': 34 };
+    bytes.push(map[next] ?? next.charCodeAt(0));
+    i++;
+  }
+  return Buffer.from(bytes).toString("utf8");
+}
+function stripPrefix(p, prefix) {
+  const u = unquotePath(p);
+  return u.startsWith(prefix) ? u.slice(2) : u;
+}
+function splitGitHeader(rest) {
+  if (rest.startsWith('"')) {
+    const m = /^("(?:[^"\\]|\\.)*")\s+("(?:[^"\\]|\\.)*")$/.exec(rest);
+    if (m && m[1] && m[2]) return { a: stripPrefix(m[1], "a/"), b: stripPrefix(m[2], "b/") };
+  }
+  for (let i = 0; i < rest.length; i++) {
+    if (rest[i] !== " ") continue;
+    const left = rest.slice(0, i);
+    const right = rest.slice(i + 1);
+    if (left.startsWith("a/") && right.startsWith("b/") && left.slice(2) === right.slice(2)) {
+      return { a: left.slice(2), b: stripPrefix(right, "b/") };
+    }
+  }
+  const idx = rest.indexOf(" b/");
+  if (idx > 0) return { a: stripPrefix(rest.slice(0, idx), "a/"), b: stripPrefix(rest.slice(idx + 1), "b/") };
+  return { a: rest, b: rest };
+}
+var HUNK_RE = /^@@ -(\d+)(?:,(\d+))? \+(\d+)(?:,(\d+))? @@ ?(.*)$/;
+function finalize(p) {
+  let status = "modified";
+  if (p.isNew) status = "added";
+  else if (p.isDeleted) status = "deleted";
+  else if (p.isRename) status = "renamed";
+  let newPath = p.newPath ?? (p.fromPlus && p.fromPlus !== "/dev/null" ? p.fromPlus : void 0) ?? p.b;
+  let oldPath = p.oldPath ?? (p.fromMinus && p.fromMinus !== "/dev/null" ? p.fromMinus : void 0) ?? p.a;
+  if (status === "deleted") newPath = oldPath;
+  if (status === "added") oldPath = newPath;
+  let additions = 0;
+  let deletions = 0;
+  for (const h of p.hunks) {
+    for (const l of h.lines) {
+      if (l.type === "add") additions++;
+      else if (l.type === "del") deletions++;
+    }
+  }
+  const hashInput = [status, oldPath, newPath, p.binary ? "binary" : "text", p.oldMode ?? "", p.newMode ?? "", ...p.raw].join("\n");
+  const file = {
+    path: newPath,
+    status,
+    additions,
+    deletions,
+    binary: p.binary,
+    contentHash: sha1(hashInput),
+    hunks: p.hunks
+  };
+  if (status === "renamed" && oldPath !== newPath) file.oldPath = oldPath;
+  if (p.oldMode) file.oldMode = p.oldMode;
+  if (p.newMode) file.newMode = p.newMode;
+  return file;
+}
+function parseUnifiedDiff(text) {
+  const files = [];
+  const lines = text.split("\n");
+  if (lines.length && lines[lines.length - 1] === "") lines.pop();
+  let cur = null;
+  let hunk = null;
+  let oldNo = 0;
+  let newNo = 0;
+  let lastLine = null;
+  const flush = () => {
+    if (cur) files.push(finalize(cur));
+    cur = null;
+    hunk = null;
+    lastLine = null;
+  };
+  for (let i = 0; i < lines.length; i++) {
+    const line = lines[i];
+    if (line.startsWith("diff --git ")) {
+      flush();
+      const { a, b } = splitGitHeader(line.slice("diff --git ".length));
+      cur = { a, b, isNew: false, isDeleted: false, isRename: false, binary: false, hunks: [], raw: [] };
+      continue;
+    }
+    if (!cur) continue;
+    const c = cur;
+    if (hunk) {
+      const ch = line[0];
+      if (ch === " " || ch === "+" || ch === "-" || line === "") {
+        const content = line === "" ? "" : line.slice(1);
+        let dl;
+        if (ch === "+") dl = { type: "add", newLineNo: newNo++, content };
+        else if (ch === "-") dl = { type: "del", oldLineNo: oldNo++, content };
+        else dl = { type: "context", oldLineNo: oldNo++, newLineNo: newNo++, content };
+        hunk.lines.push(dl);
+        lastLine = dl;
+        c.raw.push(line);
+        continue;
+      }
+      if (line.startsWith("\\")) {
+        if (lastLine) lastLine.noNewline = true;
+        c.raw.push(line);
+        continue;
+      }
+      hunk = null;
+    }
+    const hm = HUNK_RE.exec(line);
+    if (hm) {
+      hunk = {
+        hash: "",
+        oldStart: Number(hm[1]),
+        oldLines: hm[2] === void 0 ? 1 : Number(hm[2]),
+        newStart: Number(hm[3]),
+        newLines: hm[4] === void 0 ? 1 : Number(hm[4]),
+        header: hm[5] ?? "",
+        lines: []
+      };
+      oldNo = hunk.oldStart;
+      newNo = hunk.newStart;
+      c.hunks.push(hunk);
+      c.raw.push(line);
+      continue;
+    }
+    if (line.startsWith("--- ")) {
+      c.fromMinus = stripPrefix(line.slice(4), "a/");
+      continue;
+    }
+    if (line.startsWith("+++ ")) {
+      c.fromPlus = stripPrefix(line.slice(4), "b/");
+      continue;
+    }
+    if (line.startsWith("new file mode ")) {
+      c.isNew = true;
+      c.newMode = line.slice("new file mode ".length);
+      continue;
+    }
+    if (line.startsWith("deleted file mode ")) {
+      c.isDeleted = true;
+      c.oldMode = line.slice("deleted file mode ".length);
+      continue;
+    }
+    if (line.startsWith("old mode ")) {
+      c.oldMode = line.slice("old mode ".length);
+      continue;
+    }
+    if (line.startsWith("new mode ")) {
+      c.newMode = line.slice("new mode ".length);
+      continue;
+    }
+    if (line.startsWith("rename from ")) {
+      c.isRename = true;
+      c.oldPath = unquotePath(line.slice("rename from ".length));
+      continue;
+    }
+    if (line.startsWith("rename to ")) {
+      c.isRename = true;
+      c.newPath = unquotePath(line.slice("rename to ".length));
+      continue;
+    }
+    if (line.startsWith("copy from ")) {
+      c.oldPath = unquotePath(line.slice("copy from ".length));
+      continue;
+    }
+    if (line.startsWith("copy to ")) {
+      c.isNew = true;
+      c.newPath = unquotePath(line.slice("copy to ".length));
+      continue;
+    }
+    if (line.startsWith("Binary files ") || line === "GIT binary patch") {
+      c.binary = true;
+      c.raw.push(line);
+      continue;
+    }
+  }
+  flush();
+  for (const f of files) {
+    for (const h of f.hunks) {
+      h.hash = hunkHash(h.lines.map((l) => l.content));
+    }
+  }
+  return files;
+}
+
+// packages/server/src/targets.ts
+var DIFF_BASE_ARGS = ["diff", "--no-color", "--no-ext-diff", "-U3", "-M", "--find-renames"];
+function resolveTargetContext(repo, worktrees, key) {
+  let target;
+  try {
+    target = parseTargetKey(key);
+  } catch (e) {
+    if (e instanceof TargetKeyError) throw badRequest(e.message, "invalid_target");
+    throw e;
+  }
+  let cwd = repo.root;
+  if (target.worktree) {
+    const wt = worktrees.find((w) => w.path === target.worktree);
+    if (!wt) throw badRequest(`unknown worktree: ${target.worktree}`, "unknown_worktree");
+    cwd = wt.path;
+  }
+  return { key, target, cwd };
+}
+async function hasHead(cwd) {
+  return refExists(cwd, "HEAD");
+}
+async function diffArgs(ctx) {
+  const t = ctx.target;
+  switch (t.kind) {
+    case "working":
+      return [...DIFF_BASE_ARGS];
+    case "staged":
+      return [...DIFF_BASE_ARGS, "--cached"];
+    case "all":
+      return [...DIFF_BASE_ARGS, await hasHead(ctx.cwd) ? "HEAD" : EMPTY_TREE_SHA];
+    case "commit": {
+      if (!await refExists(ctx.cwd, t.sha)) throw badRequest(`unknown commit: ${t.sha}`, "unknown_ref");
+      const parent = await revParse(ctx.cwd, `${t.sha}^`);
+      return [...DIFF_BASE_ARGS, parent ?? EMPTY_TREE_SHA, t.sha];
+    }
+    case "range": {
+      if (!await refExists(ctx.cwd, t.base)) throw badRequest(`unknown ref: ${t.base}`, "unknown_ref");
+      if (!await refExists(ctx.cwd, t.head)) throw badRequest(`unknown ref: ${t.head}`, "unknown_ref");
+      return [...DIFF_BASE_ARGS, `${t.base}...${t.head}`];
+    }
+  }
+}
+function includesUntracked(t) {
+  return t.kind === "working" || t.kind === "all";
+}
+async function listUntracked(cwd) {
+  const r = await runGit(["ls-files", "--others", "--exclude-standard", "-z"], { cwd });
+  return r.stdout.split("\0").filter(Boolean);
+}
+async function isUntracked(cwd, file) {
+  const r = await runGit(["ls-files", "--others", "--exclude-standard", "-z", "--", file], { cwd });
+  return r.stdout.split("\0").filter(Boolean).includes(file);
+}
+async function untrackedDiff(cwd, file) {
+  const r = await runGit(["diff", "--no-color", "--no-ext-diff", "-U3", "--no-index", "--", "/dev/null", file], {
+    cwd,
+    okCodes: [0, 1]
+  });
+  const parsed = parseUnifiedDiff(r.stdout);
+  const f = parsed[0];
+  if (!f) return void 0;
+  f.path = file;
+  f.status = "added";
+  f.untracked = true;
+  delete f.oldPath;
+  return f;
+}
+async function mapLimit(items, limit, fn) {
+  const results = new Array(items.length);
+  let next = 0;
+  const workers = Array.from({ length: Math.min(limit, items.length) }, async () => {
+    while (next < items.length) {
+      const i = next++;
+      results[i] = await fn(items[i]);
+    }
+  });
+  await Promise.all(workers);
+  return results;
+}
+async function listTargetDiffs(ctx) {
+  const args = await diffArgs(ctx);
+  const r = await runGit(args, { cwd: ctx.cwd });
+  const files = parseUnifiedDiff(r.stdout);
+  if (includesUntracked(ctx.target)) {
+    const untracked = await listUntracked(ctx.cwd);
+    const extra = await mapLimit(untracked, 8, (f) => untrackedDiff(ctx.cwd, f).catch(() => void 0));
+    for (const f of extra) if (f) files.push(f);
+    files.sort((a, b) => a.path < b.path ? -1 : a.path > b.path ? 1 : 0);
+  }
+  return files;
+}
+function toSummary(f) {
+  const { hunks: _hunks, ...rest } = f;
+  return rest;
+}
+async function getFileDiff(ctx, filePath, hints = {}) {
+  if (!filePath || filePath.startsWith("/") || filePath.split("/").includes("..")) {
+    throw badRequest(`invalid path: ${filePath}`, "invalid_path");
+  }
+  if (includesUntracked(ctx.target) && (hints.untracked || await isUntracked(ctx.cwd, filePath))) {
+    return untrackedDiff(ctx.cwd, filePath);
+  }
+  const args = await diffArgs(ctx);
+  const pathspec = [filePath];
+  if (hints.oldPath && hints.oldPath !== filePath) pathspec.push(hints.oldPath);
+  const r = await runGit([...args, "--", ...pathspec], { cwd: ctx.cwd });
+  const files = parseUnifiedDiff(r.stdout);
+  return files.find((f) => f.path === filePath) ?? files[0];
+}
+async function refForSide(ctx, side) {
+  const t = ctx.target;
+  switch (t.kind) {
+    case "working":
+      return side === "new" ? void 0 : ":0";
+    case "staged":
+      return side === "new" ? ":0" : "HEAD";
+    case "all":
+      return side === "new" ? void 0 : "HEAD";
+    case "commit":
+      if (side === "new") return t.sha;
+      return await revParse(ctx.cwd, `${t.sha}^`) ?? EMPTY_TREE_SHA;
+    case "range":
+      return side === "new" ? t.head : t.base;
+  }
+}
+async function getFullFile(ctx, filePath, side) {
+  if (!filePath || filePath.startsWith("/") || filePath.split("/").includes("..")) {
+    throw badRequest(`invalid path: ${filePath}`, "invalid_path");
+  }
+  const ref = await refForSide(ctx, side);
+  if (ref === void 0) {
+    try {
+      const buf = await readFile(path2.join(ctx.cwd, filePath));
+      return buf.toString("utf8");
+    } catch {
+      return null;
+    }
+  }
+  try {
+    const r = await runGit(["show", `${ref}:${filePath}`], { cwd: ctx.cwd });
+    return r.stdout;
+  } catch (e) {
+    if (e instanceof HttpError && e.code === "git_failed") return null;
+    throw e;
+  }
+}
+
+// packages/server/src/anchor.ts
+function sideLines(diff, side) {
+  const out = [];
+  diff.hunks.forEach((h, hunkIndex) => {
+    let hunkOffset = 0;
+    for (const l of h.lines) {
+      if (side === "new" && l.type !== "del" && l.newLineNo !== void 0) {
+        out.push({ line: l.newLineNo, hash: lineHash(l.content), content: l.content, hunkIndex, hunkOffset: hunkOffset++ });
+      } else if (side === "old" && l.type !== "add" && l.oldLineNo !== void 0) {
+        out.push({ line: l.oldLineNo, hash: lineHash(l.content), content: l.content, hunkIndex, hunkOffset: hunkOffset++ });
+      }
+    }
+  });
+  return out;
+}
+var CONTEXT = 3;
+function anchorAt(lines, diff, start, count) {
+  const covered = lines.slice(start, start + count);
+  const first = covered[0];
+  const last = covered[covered.length - 1];
+  return {
+    anchor: {
+      hunkHash: diff.hunks[first.hunkIndex].hash,
+      lineHashes: covered.map((l) => l.hash),
+      contextBefore: lines.slice(Math.max(0, start - CONTEXT), start).map((l) => l.hash),
+      contextAfter: lines.slice(start + count, start + count + CONTEXT).map((l) => l.hash),
+      hunkLineOffset: first.hunkOffset
+    },
+    snippet: covered.map((l) => l.content),
+    startLine: first.line,
+    endLine: last.line
+  };
+}
+function buildAnchor(diff, side, startLine, endLine) {
+  if (endLine < startLine) [startLine, endLine] = [endLine, startLine];
+  const lines = sideLines(diff, side);
+  const start = lines.findIndex((l) => l.line === startLine);
+  if (start < 0) return void 0;
+  const count = endLine - startLine + 1;
+  const covered = lines.slice(start, start + count);
+  if (covered.length !== count) return void 0;
+  for (let i = 0; i < count; i++) {
+    const l = covered[i];
+    if (l.line !== startLine + i) return void 0;
+    if (l.hunkIndex !== covered[0].hunkIndex) return void 0;
+  }
+  return anchorAt(lines, diff, start, count);
+}
+function matchesAt(lines, start, hashes) {
+  if (start < 0 || start + hashes.length > lines.length) return false;
+  for (let i = 0; i < hashes.length; i++) {
+    if (lines[start + i].hash !== hashes[i]) return false;
+  }
+  return true;
+}
+function contextScore(lines, start, count, anchor) {
+  let score = 0;
+  const before = anchor.contextBefore;
+  for (let i = 0; i < before.length; i++) {
+    const idx = start - before.length + i;
+    if (idx >= 0 && lines[idx].hash === before[i]) score++;
+  }
+  const after = anchor.contextAfter;
+  for (let i = 0; i < after.length; i++) {
+    const idx = start + count + i;
+    if (idx < lines.length && lines[idx].hash === after[i]) score++;
+  }
+  return score;
+}
+function locateAnchor(diff, side, anchor) {
+  const lines = sideLines(diff, side);
+  const n = anchor.lineHashes.length;
+  if (n === 0) return void 0;
+  for (let hi = 0; hi < diff.hunks.length; hi++) {
+    if (diff.hunks[hi].hash !== anchor.hunkHash) continue;
+    const idx = lines.findIndex((l) => l.hunkIndex === hi && l.hunkOffset === anchor.hunkLineOffset);
+    if (idx >= 0 && matchesAt(lines, idx, anchor.lineHashes)) return idx;
+  }
+  const candidates = [];
+  for (let i = 0; i + n <= lines.length; i++) {
+    if (matchesAt(lines, i, anchor.lineHashes)) candidates.push(i);
+  }
+  if (candidates.length === 0) return void 0;
+  if (candidates.length === 1) return candidates[0];
+  let best = [];
+  let bestScore = -1;
+  for (const c of candidates) {
+    const s = contextScore(lines, c, n, anchor);
+    if (s > bestScore) {
+      bestScore = s;
+      best = [c];
+    } else if (s === bestScore) {
+      best.push(c);
+    }
+  }
+  return best.length === 1 ? best[0] : void 0;
+}
+function reanchorComment(comment, diff, now = (/* @__PURE__ */ new Date()).toISOString()) {
+  const orphan = () => comment.status === "orphaned" ? comment : { ...comment, status: "orphaned", updatedAt: now };
+  if (!diff || diff.binary) return orphan();
+  const idx = locateAnchor(diff, comment.side, comment.anchor);
+  if (idx === void 0) return orphan();
+  const lines = sideLines(diff, comment.side);
+  const res = anchorAt(lines, diff, idx, comment.anchor.lineHashes.length);
+  const status = comment.exportedAt ? "exported" : "active";
+  const unchanged = comment.status === status && comment.startLine === res.startLine && comment.endLine === res.endLine && comment.anchor.hunkHash === res.anchor.hunkHash;
+  if (unchanged) return comment;
+  return {
+    ...comment,
+    startLine: res.startLine,
+    endLine: res.endLine,
+    codeSnippet: res.snippet,
+    anchor: res.anchor,
+    status,
+    updatedAt: now
+  };
+}
+
+// packages/server/src/state.ts
+import os from "os";
+import path3 from "path";
+import { mkdir, open, readFile as readFile2, rename, stat, unlink, writeFile } from "fs/promises";
+function dataDir() {
+  const xdg = process.env.XDG_DATA_HOME;
+  const base = xdg && xdg.trim() ? xdg : path3.join(os.homedir(), ".local", "share");
+  return path3.join(base, "warden");
+}
+function repoHash(repoRoot) {
+  return sha1(repoRoot).slice(0, 12);
+}
+function stateFilePath(repoRoot, baseDir = dataDir()) {
+  return path3.join(baseDir, repoHash(repoRoot), "state.json");
+}
+function defaultPrefs() {
+  return { viewMode: "unified", nvimSocketByRoot: {} };
+}
+function defaultState(repoRoot) {
+  return { schemaVersion: 1, repoRoot, targets: {}, issues: [], prefs: defaultPrefs() };
+}
+function ensureTarget(state, key) {
+  let t = state.targets[key];
+  if (!t) {
+    t = { viewed: {}, comments: [] };
+    state.targets[key] = t;
+  }
+  return t;
+}
+function normalise(raw2, repoRoot) {
+  const base = defaultState(repoRoot);
+  if (!raw2 || typeof raw2 !== "object") return base;
+  const r = raw2;
+  if (r.schemaVersion !== 1) return base;
+  const targets = {};
+  for (const [k, v] of Object.entries(r.targets ?? {})) {
+    if (!v || typeof v !== "object") continue;
+    targets[k] = {
+      viewed: typeof v.viewed === "object" && v.viewed ? v.viewed : {},
+      comments: Array.isArray(v.comments) ? v.comments : []
+    };
+  }
+  return {
+    schemaVersion: 1,
+    repoRoot: r.repoRoot ?? repoRoot,
+    targets,
+    issues: Array.isArray(r.issues) ? r.issues : [],
+    prefs: { ...defaultPrefs(), ...r.prefs ?? {}, nvimSocketByRoot: r.prefs?.nvimSocketByRoot ?? {} }
+  };
+}
+var LOCK_STALE_MS = 5e3;
+var LOCK_WAIT_MS = 5e3;
+async function sleep(ms) {
+  await new Promise((r) => setTimeout(r, ms));
+}
+var StateStore = class {
+  constructor(file, repoRoot) {
+    this.file = file;
+    this.repoRoot = repoRoot;
+  }
+  file;
+  repoRoot;
+  queue = Promise.resolve();
+  async load() {
+    try {
+      const text = await readFile2(this.file, "utf8");
+      return normalise(JSON.parse(text), this.repoRoot);
+    } catch (e) {
+      const err = e;
+      if (err.code === "ENOENT") return defaultState(this.repoRoot);
+      if (e instanceof SyntaxError) {
+        try {
+          await rename(this.file, `${this.file}.corrupt-${Date.now()}`);
+        } catch {
+        }
+        return defaultState(this.repoRoot);
+      }
+      throw e;
+    }
+  }
+  /** Apply a mutation under lock. The callback receives the freshest on-disk state. */
+  update(fn) {
+    const run = async () => {
+      await mkdir(path3.dirname(this.file), { recursive: true });
+      const release = await this.acquireLock();
+      try {
+        const state = await this.load();
+        const result = await fn(state);
+        await this.writeAtomic(state);
+        return result;
+      } finally {
+        await release();
+      }
+    };
+    const p = this.queue.then(run, run);
+    this.queue = p.catch(() => void 0);
+    return p;
+  }
+  async writeAtomic(state) {
+    const tmp = `${this.file}.${process.pid}.${Date.now()}.tmp`;
+    await writeFile(tmp, JSON.stringify(state, null, 2) + "\n", "utf8");
+    await rename(tmp, this.file);
+  }
+  async acquireLock() {
+    const lock = `${this.file}.lock`;
+    const started = Date.now();
+    for (; ; ) {
+      try {
+        const fh = await open(lock, "wx");
+        await fh.writeFile(String(process.pid));
+        await fh.close();
+        return async () => {
+          try {
+            await unlink(lock);
+          } catch {
+          }
+        };
+      } catch (e) {
+        const err = e;
+        if (err.code !== "EEXIST") throw e;
+        try {
+          const st = await stat(lock);
+          if (Date.now() - st.mtimeMs > LOCK_STALE_MS) {
+            await unlink(lock).catch(() => void 0);
+            continue;
+          }
+        } catch {
+          continue;
+        }
+        if (Date.now() - started > LOCK_WAIT_MS) {
+          throw new Error(`timed out waiting for state lock ${lock}`);
+        }
+        await sleep(20);
+      }
+    }
+  }
+};
+
+// packages/server/src/export.ts
+var LANG_BY_EXT = {
+  ts: "ts",
+  tsx: "tsx",
+  js: "js",
+  jsx: "jsx",
+  mjs: "js",
+  cjs: "js",
+  json: "json",
+  css: "css",
+  scss: "scss",
+  less: "less",
+  html: "html",
+  vue: "vue",
+  svelte: "svelte",
+  md: "md",
+  mdx: "mdx",
+  py: "python",
+  rb: "ruby",
+  go: "go",
+  rs: "rust",
+  java: "java",
+  kt: "kotlin",
+  c: "c",
+  h: "c",
+  cc: "cpp",
+  cpp: "cpp",
+  hpp: "cpp",
+  cs: "csharp",
+  php: "php",
+  sh: "bash",
+  bash: "bash",
+  zsh: "bash",
+  yml: "yaml",
+  yaml: "yaml",
+  toml: "toml",
+  sql: "sql",
+  graphql: "graphql",
+  lua: "lua",
+  swift: "swift",
+  dart: "dart"
+};
+function langForPath(filePath) {
+  const m = /\.([A-Za-z0-9]+)$/.exec(filePath);
+  if (!m || !m[1]) return "";
+  return LANG_BY_EXT[m[1].toLowerCase()] ?? m[1].toLowerCase();
+}
+function formatCommentSection(c) {
+  const range = c.startLine === c.endLine ? `${c.startLine}` : `${c.startLine}-${c.endLine}`;
+  const width = String(c.endLine).length;
+  const code = c.codeSnippet.map((line, i) => `${String(c.startLine + i).padStart(width, " ")} | ${line}`).join("\n");
+  const lang = langForPath(c.filePath);
+  const body = c.body.replace(/\r\n/g, "\n").split("\n").map((l) => l ? `> ${l}` : ">").join("\n");
+  const fence = code.includes("```") ? "````" : "```";
+  const orphanNote = c.status === "orphaned" ? " [orphaned: original location no longer exists]" : "";
+  return [`## ${c.filePath}:${range} (${c.side})${orphanNote}`, `${fence}${lang}`, code, fence, body].join("\n");
+}
+function formatCommentsExport({ repoRoot, comments }) {
+  const targets = [...new Set(comments.map((c) => c.targetKey))];
+  const head = ["# Review comments", `Target: ${targets.join(", ") || "-"}`, `Repo: ${repoRoot}`, `Count: ${comments.length}`];
+  const sections = comments.map(formatCommentSection);
+  return [head.join("\n"), ...sections].join("\n\n") + "\n";
+}
+function formatIssueExport({ repoRoot, issue, comments }) {
+  const targets = [...new Set(comments.map((c) => c.targetKey))];
+  const head = [
+    `# Issue: ${issue.title}`,
+    `Status: ${issue.status}`,
+    `Target: ${targets.join(", ") || "-"}`,
+    `Repo: ${repoRoot}`,
+    `Count: ${comments.length}`
+  ];
+  const parts = [head.join("\n")];
+  if (issue.body.trim()) parts.push(issue.body.trim());
+  parts.push(...comments.map(formatCommentSection));
+  return parts.join("\n\n") + "\n";
+}
+
+// packages/server/src/nvim.ts
+import os2 from "os";
+import path4 from "path";
+import { execFile as execFile2 } from "child_process";
+import { readdir, stat as stat2 } from "fs/promises";
+var QUERY_TIMEOUT_MS = 500;
+var CACHE_TTL_MS = 1e4;
+function execNvim(args, timeoutMs) {
+  return new Promise((resolve) => {
+    execFile2("nvim", args, { timeout: timeoutMs, encoding: "utf8", windowsHide: true }, (error, stdout, stderr) => {
+      if (error) {
+        const err = error;
+        resolve({ ok: false, stdout, stderr, missing: err.code === "ENOENT" });
+        return;
+      }
+      resolve({ ok: true, stdout, stderr, missing: false });
+    });
+  });
+}
+function socketDirs(env = process.env) {
+  const dirs = [];
+  if (env.XDG_RUNTIME_DIR) dirs.push(env.XDG_RUNTIME_DIR);
+  const uid = typeof process.getuid === "function" ? process.getuid() : void 0;
+  if (uid !== void 0) dirs.push(`/run/user/${uid}`);
+  let user = env.USER || env.LOGNAME;
+  if (!user) {
+    try {
+      user = os2.userInfo().username;
+    } catch {
+      user = void 0;
+    }
+  }
+  const tmp = env.TMPDIR || "/tmp";
+  if (user) dirs.push(path4.join(tmp, `nvim.${user}`));
+  if (env.NVIM_LISTEN_ADDRESS) dirs.push(path4.dirname(env.NVIM_LISTEN_ADDRESS));
+  return [...new Set(dirs)];
+}
+var SOCKET_NAME = /^nvim\.(\d+)\.\d+$/;
+async function isSocket(p) {
+  try {
+    return (await stat2(p)).isSocket();
+  } catch {
+    return false;
+  }
+}
+async function findSockets(dirs = socketDirs()) {
+  const found = /* @__PURE__ */ new Map();
+  const visit = async (dir, depth) => {
+    let entries;
+    try {
+      entries = await readdir(dir, { withFileTypes: true });
+    } catch {
+      return;
+    }
+    for (const ent of entries) {
+      const full = path4.join(dir, ent.name);
+      const m = SOCKET_NAME.exec(ent.name);
+      if (m && (ent.isSocket() || await isSocket(full))) {
+        found.set(full, Number(m[1]));
+      } else if (ent.isDirectory() && depth < 1) {
+        await visit(full, depth + 1);
+      }
+    }
+  };
+  for (const d of dirs) await visit(d, 0);
+  return [...found.entries()].map(([socket, pid]) => ({ socket, pid }));
+}
+var NvimService = class {
+  constructor(dirs) {
+    this.dirs = dirs;
+  }
+  dirs;
+  cache = null;
+  pending = null;
+  async scan(force = false) {
+    if (!force && this.cache && Date.now() - this.cache.at < CACHE_TTL_MS) return this.cache.result;
+    if (this.pending) return this.pending;
+    this.pending = this.doScan().finally(() => {
+      this.pending = null;
+    });
+    const result = await this.pending;
+    this.cache = { at: Date.now(), result };
+    return result;
+  }
+  async doScan() {
+    const sockets = await findSockets(this.dirs);
+    let nvimAvailable = true;
+    const instances = [];
+    await Promise.all(
+      sockets.map(async ({ socket, pid }) => {
+        const r = await execNvim(["--server", socket, "--remote-expr", "getcwd()"], QUERY_TIMEOUT_MS);
+        if (r.missing) {
+          nvimAvailable = false;
+          return;
+        }
+        if (!r.ok) return;
+        const cwd = r.stdout.trim();
+        if (cwd) instances.push({ socket, cwd, pid });
+      })
+    );
+    instances.sort((a, b) => (a.pid ?? 0) - (b.pid ?? 0));
+    return { nvimAvailable, instances, scannedAt: (/* @__PURE__ */ new Date()).toISOString() };
+  }
+  /** Instances whose cwd is inside `root`. */
+  static matching(instances, root) {
+    const norm = root.replace(/\/+$/, "");
+    return instances.filter((i) => i.cwd === norm || i.cwd.startsWith(norm + "/"));
+  }
+  async open(socket, absPath, line) {
+    const safeLine = Math.max(1, Math.floor(line) || 1);
+    const vimStr = (s) => `'${s.replace(/'/g, "''")}'`;
+    const expr = `execute(['edit +${safeLine} ' . fnameescape(${vimStr(absPath)}), 'normal! zz'])`;
+    const r = await execNvim(["--server", socket, "--remote-expr", expr], 3e3);
+    if (r.missing) throw new Error("nvim executable not found in PATH");
+    if (!r.ok) throw new Error(r.stderr.trim() || "failed to talk to nvim instance");
+    this.cache = null;
+  }
+};
+
+// packages/server/src/static.ts
+import path5 from "path";
+import { readFile as readFile3, stat as stat3 } from "fs/promises";
+var MIME = {
+  ".html": "text/html; charset=utf-8",
+  ".js": "text/javascript; charset=utf-8",
+  ".mjs": "text/javascript; charset=utf-8",
+  ".css": "text/css; charset=utf-8",
+  ".json": "application/json; charset=utf-8",
+  ".svg": "image/svg+xml",
+  ".png": "image/png",
+  ".ico": "image/x-icon",
+  ".woff": "font/woff",
+  ".woff2": "font/woff2",
+  ".wasm": "application/wasm",
+  ".map": "application/json",
+  ".txt": "text/plain; charset=utf-8"
+};
+async function serveStaticFile(c, webDir) {
+  const root = path5.resolve(webDir);
+  let rel;
+  try {
+    rel = decodeURIComponent(c.req.path);
+  } catch {
+    return c.text("Bad Request", 400);
+  }
+  let target = path5.resolve(root, "." + rel);
+  if (target !== root && !target.startsWith(root + path5.sep)) return c.text("Forbidden", 403);
+  try {
+    const st = await stat3(target);
+    if (st.isDirectory()) target = path5.join(target, "index.html");
+  } catch {
+    target = path5.join(root, "index.html");
+  }
+  let body;
+  try {
+    body = await readFile3(target);
+  } catch {
+    return c.text("Not Found", 404);
+  }
+  const ext = path5.extname(target).toLowerCase();
+  const isAsset = rel.startsWith("/assets/");
+  return new Response(new Uint8Array(body), {
+    status: 200,
+    headers: {
+      "content-type": MIME[ext] ?? "application/octet-stream",
+      "cache-control": isAsset ? "public, max-age=31536000, immutable" : "no-cache"
+    }
+  });
+}
+
+// packages/server/src/app.ts
+var LISTING_HINT_TTL_MS = 5 * 6e4;
+function createApp(opts) {
+  const { repo, store } = opts;
+  const nvim = opts.nvim ?? new NvimService();
+  const app = new Hono2();
+  const listings = /* @__PURE__ */ new Map();
+  const changedNotices = /* @__PURE__ */ new Map();
+  let worktreeCache = null;
+  const worktrees = async (force = false) => {
+    if (!force && worktreeCache && Date.now() - worktreeCache.at < 1e4) return worktreeCache.list;
+    const list = await listWorktrees(repo);
+    worktreeCache = { at: Date.now(), list };
+    return list;
+  };
+  const targetCtx = async (key) => {
+    let list = await worktrees();
+    try {
+      return resolveTargetContext(repo, list, key);
+    } catch (e) {
+      if (e instanceof HttpError && e.code === "unknown_worktree") {
+        list = await worktrees(true);
+        return resolveTargetContext(repo, list, key);
+      }
+      throw e;
+    }
+  };
+  const decodeKey = (raw2) => {
+    try {
+      return decodeURIComponent(raw2);
+    } catch {
+      throw badRequest("malformed target key", "invalid_target");
+    }
+  };
+  const fileDiffWithHints = async (ctx, filePath, explicit) => {
+    const cached = listings.get(ctx.key);
+    const hint = cached && Date.now() - cached.at < LISTING_HINT_TTL_MS ? cached.files.find((f) => f.path === filePath) : void 0;
+    return getFileDiff(ctx, filePath, {
+      oldPath: explicit?.oldPath ?? hint?.oldPath,
+      untracked: explicit?.untracked ?? hint?.untracked
+    });
+  };
+  const findComment = (state, id) => {
+    for (const [targetKey, t] of Object.entries(state.targets)) {
+      const index = t.comments.findIndex((c) => c.id === id);
+      if (index >= 0) return { comment: t.comments[index], targetKey, index };
+    }
+    return void 0;
+  };
+  app.onError((err, c) => {
+    if (err instanceof HttpError) {
+      return c.json({ error: err.message, code: err.code }, err.status);
+    }
+    console.error(err);
+    return c.json({ error: err instanceof Error ? err.message : String(err), code: "internal" }, 500);
+  });
+  const api = new Hono2();
+  api.get("/repo", async (c) => {
+    const state = await store.load();
+    const info = await getRepoInfo(repo, state.prefs.lastTarget ?? "working");
+    worktreeCache = { at: Date.now(), list: info.worktrees };
+    return c.json(info);
+  });
+  api.get("/state", async (c) => c.json(await store.load()));
+  api.patch("/prefs", async (c) => {
+    const body = await c.req.json();
+    const prefs = await store.update((s) => {
+      if (body.viewMode === "unified" || body.viewMode === "split") s.prefs.viewMode = body.viewMode;
+      if (typeof body.lastTarget === "string") s.prefs.lastTarget = body.lastTarget;
+      if (body.nvimSocketByRoot && typeof body.nvimSocketByRoot === "object") {
+        s.prefs.nvimSocketByRoot = { ...s.prefs.nvimSocketByRoot, ...body.nvimSocketByRoot };
+      }
+      return s.prefs;
+    });
+    return c.json(prefs);
+  });
+  api.get("/targets/:key/files", async (c) => {
+    const key = decodeKey(c.req.param("key"));
+    const ctx = await targetCtx(key);
+    const diffs = await listTargetDiffs(ctx);
+    listings.set(key, { at: Date.now(), files: diffs });
+    const notices = changedNotices.get(key) ?? /* @__PURE__ */ new Set();
+    changedNotices.set(key, notices);
+    const stale = [];
+    const state = await store.load();
+    const t = state.targets[key];
+    const viewed = t?.viewed ?? {};
+    for (const [p, h] of Object.entries(viewed)) {
+      const f = diffs.find((d) => d.path === p);
+      if (!f || f.contentHash !== h) stale.push(p);
+    }
+    if (stale.length) {
+      await store.update((s) => {
+        const ts = s.targets[key];
+        if (!ts) return;
+        for (const p of stale) {
+          if (ts.viewed[p] === viewed[p]) {
+            delete ts.viewed[p];
+            if (diffs.some((d) => d.path === p)) notices.add(p);
+          }
+        }
+      });
+    }
+    const files = diffs.map((d) => ({
+      ...toSummary(d),
+      viewed: !stale.includes(d.path) && viewed[d.path] === d.contentHash,
+      changed: notices.has(d.path)
+    }));
+    const res = { targetKey: key, root: ctx.cwd, files, comments: t?.comments ?? [] };
+    return c.json(res);
+  });
+  api.get("/targets/:key/file", async (c) => {
+    const key = decodeKey(c.req.param("key"));
+    const filePath = c.req.query("path");
+    if (!filePath) throw badRequest("missing path");
+    const ctx = await targetCtx(key);
+    const oldPath = c.req.query("old") || void 0;
+    const untracked = c.req.query("untracked") === "1" ? true : void 0;
+    const diff = await fileDiffWithHints(ctx, filePath, { oldPath, untracked });
+    if (!diff) throw notFound(`no diff for ${filePath} in ${key}`, "no_diff");
+    return c.json(diff);
+  });
+  api.get("/targets/:key/file/full", async (c) => {
+    const key = decodeKey(c.req.param("key"));
+    const filePath = c.req.query("path");
+    if (!filePath) throw badRequest("missing path");
+    const side = c.req.query("side") === "old" ? "old" : "new";
+    const ctx = await targetCtx(key);
+    const content = await getFullFile(ctx, filePath, side);
+    const res = { path: filePath, side, content };
+    return c.json(res);
+  });
+  api.put("/targets/:key/viewed", async (c) => {
+    const key = decodeKey(c.req.param("key"));
+    await targetCtx(key);
+    const body = await c.req.json();
+    if (!body.path) throw badRequest("missing path");
+    const viewed = await store.update((s) => {
+      const t = ensureTarget(s, key);
+      if (body.viewed && body.contentHash) t.viewed[body.path] = body.contentHash;
+      else delete t.viewed[body.path];
+      return t.viewed;
+    });
+    changedNotices.get(key)?.delete(body.path);
+    return c.json({ viewed });
+  });
+  api.get("/targets/:key/comments", async (c) => {
+    const key = decodeKey(c.req.param("key"));
+    const state = await store.load();
+    return c.json({ comments: state.targets[key]?.comments ?? [] });
+  });
+  api.post("/targets/:key/comments", async (c) => {
+    const key = decodeKey(c.req.param("key"));
+    const ctx = await targetCtx(key);
+    const body = await c.req.json();
+    if (!body.filePath || typeof body.body !== "string" || !body.body.trim()) throw badRequest("filePath and body are required");
+    if (body.side !== "old" && body.side !== "new") throw badRequest("side must be old|new");
+    const start = Number(body.startLine);
+    const end = Number(body.endLine ?? body.startLine);
+    if (!Number.isInteger(start) || !Number.isInteger(end) || start < 1 || end < 1) throw badRequest("invalid line range");
+    const diff = await fileDiffWithHints(ctx, body.filePath);
+    if (!diff) throw badRequest(`file ${body.filePath} is not part of ${key}`, "no_diff");
+    const anchored = buildAnchor(diff, body.side, start, end);
+    if (!anchored) throw badRequest("selection is not fully visible in the diff on that side (must be inside one hunk)", "bad_selection");
+    const now = (/* @__PURE__ */ new Date()).toISOString();
+    const comment = {
+      id: randomUUID(),
+      targetKey: key,
+      filePath: body.filePath,
+      side: body.side,
+      startLine: anchored.startLine,
+      endLine: anchored.endLine,
+      codeSnippet: anchored.snippet,
+      body: body.body,
+      status: "active",
+      anchor: anchored.anchor,
+      createdAt: now,
+      updatedAt: now
+    };
+    await store.update((s) => {
+      ensureTarget(s, key).comments.push(comment);
+    });
+    return c.json(comment, 201);
+  });
+  api.patch("/targets/:key/comments/:id", async (c) => {
+    const key = decodeKey(c.req.param("key"));
+    const id = c.req.param("id");
+    const ctx = await targetCtx(key);
+    const body = await c.req.json();
+    const state = await store.load();
+    const existing = state.targets[key]?.comments.find((x) => x.id === id);
+    if (!existing) throw notFound("comment not found");
+    let patch = {};
+    if (typeof body.body === "string") {
+      if (!body.body.trim()) throw badRequest("body must not be empty");
+      patch.body = body.body;
+    }
+    if (body.startLine !== void 0 || body.side !== void 0) {
+      const side = body.side ?? existing.side;
+      const start = Number(body.startLine ?? existing.startLine);
+      const end = Number(body.endLine ?? body.startLine ?? existing.endLine);
+      if (side !== "old" && side !== "new") throw badRequest("side must be old|new");
+      const diff = await fileDiffWithHints(ctx, existing.filePath);
+      if (!diff) throw badRequest(`file ${existing.filePath} is not part of ${key}`, "no_diff");
+      const anchored = buildAnchor(diff, side, start, end);
+      if (!anchored) throw badRequest("selection is not fully visible in the diff on that side", "bad_selection");
+      patch = {
+        ...patch,
+        side,
+        startLine: anchored.startLine,
+        endLine: anchored.endLine,
+        codeSnippet: anchored.snippet,
+        anchor: anchored.anchor,
+        status: existing.exportedAt ? "exported" : "active"
+      };
+    }
+    const updated = await store.update((s) => {
+      const t = ensureTarget(s, key);
+      const idx = t.comments.findIndex((x) => x.id === id);
+      if (idx < 0) throw notFound("comment not found");
+      const next = { ...t.comments[idx], ...patch, updatedAt: (/* @__PURE__ */ new Date()).toISOString() };
+      t.comments[idx] = next;
+      return next;
+    });
+    return c.json(updated);
+  });
+  api.delete("/targets/:key/comments/:id", async (c) => {
+    const key = decodeKey(c.req.param("key"));
+    const id = c.req.param("id");
+    const removed = await store.update((s) => {
+      const t = s.targets[key];
+      if (!t) return false;
+      const before = t.comments.length;
+      t.comments = t.comments.filter((x) => x.id !== id);
+      for (const issue of s.issues) issue.commentIds = issue.commentIds.filter((x) => x !== id);
+      return t.comments.length !== before;
+    });
+    if (!removed) throw notFound("comment not found");
+    return c.json({ ok: true });
+  });
+  api.post("/targets/:key/comments/reanchor", async (c) => {
+    const key = decodeKey(c.req.param("key"));
+    const ctx = await targetCtx(key);
+    const body = await c.req.json().catch(() => ({})) ?? {};
+    const provided = /* @__PURE__ */ new Map();
+    for (const f of body.files ?? []) if (f && typeof f.path === "string" && Array.isArray(f.hunks)) provided.set(f.path, f);
+    const state = await store.load();
+    const comments = state.targets[key]?.comments ?? [];
+    const paths = [...new Set(comments.map((x) => x.filePath))];
+    const diffs = /* @__PURE__ */ new Map();
+    await Promise.all(
+      paths.map(async (p) => {
+        if (provided.has(p)) {
+          diffs.set(p, provided.get(p));
+          return;
+        }
+        try {
+          diffs.set(p, await fileDiffWithHints(ctx, p));
+        } catch {
+          diffs.set(p, void 0);
+        }
+      })
+    );
+    const now = (/* @__PURE__ */ new Date()).toISOString();
+    const result = await store.update((s) => {
+      const t = ensureTarget(s, key);
+      t.comments = t.comments.map((cm) => reanchorComment(cm, diffs.get(cm.filePath), now));
+      return t.comments;
+    });
+    const res = { comments: result };
+    return c.json(res);
+  });
+  api.post("/comments/export", async (c) => {
+    const body = await c.req.json();
+    if (!Array.isArray(body.commentIds)) throw badRequest("commentIds required");
+    const ids = body.commentIds.filter((x) => typeof x === "string");
+    const res = await store.update((s) => {
+      const now = (/* @__PURE__ */ new Date()).toISOString();
+      const selected = [];
+      for (const id of ids) {
+        const found = findComment(s, id);
+        if (!found) continue;
+        const next = { ...found.comment, exportedAt: now, updatedAt: now };
+        if (next.status === "active") next.status = "exported";
+        s.targets[found.targetKey].comments[found.index] = next;
+        selected.push(next);
+      }
+      return {
+        text: formatCommentsExport({ repoRoot: repo.root, comments: selected }),
+        count: selected.length,
+        commentIds: selected.map((x) => x.id)
+      };
+    });
+    return c.json(res);
+  });
+  api.get("/issues", async (c) => {
+    const s = await store.load();
+    return c.json({ issues: s.issues });
+  });
+  api.post("/issues", async (c) => {
+    const body = await c.req.json();
+    if (!body.title || !body.title.trim()) throw badRequest("title is required");
+    const now = (/* @__PURE__ */ new Date()).toISOString();
+    const issue = {
+      id: randomUUID(),
+      title: body.title.trim(),
+      body: typeof body.body === "string" ? body.body : "",
+      status: "open",
+      commentIds: Array.isArray(body.commentIds) ? body.commentIds.filter((x) => typeof x === "string") : [],
+      createdAt: now,
+      updatedAt: now
+    };
+    await store.update((s) => {
+      s.issues.push(issue);
+    });
+    return c.json(issue, 201);
+  });
+  api.patch("/issues/:id", async (c) => {
+    const id = c.req.param("id");
+    const body = await c.req.json();
+    const updated = await store.update((s) => {
+      const issue = s.issues.find((i) => i.id === id);
+      if (!issue) throw notFound("issue not found");
+      if (typeof body.title === "string" && body.title.trim()) issue.title = body.title.trim();
+      if (typeof body.body === "string") issue.body = body.body;
+      if (body.status === "open" || body.status === "closed") issue.status = body.status;
+      if (Array.isArray(body.commentIds)) issue.commentIds = [...new Set(body.commentIds.filter((x) => typeof x === "string"))];
+      issue.updatedAt = (/* @__PURE__ */ new Date()).toISOString();
+      return issue;
+    });
+    return c.json(updated);
+  });
+  api.delete("/issues/:id", async (c) => {
+    const id = c.req.param("id");
+    const removed = await store.update((s) => {
+      const before = s.issues.length;
+      s.issues = s.issues.filter((i) => i.id !== id);
+      return s.issues.length !== before;
+    });
+    if (!removed) throw notFound("issue not found");
+    return c.json({ ok: true });
+  });
+  api.post("/issues/:id/export", async (c) => {
+    const id = c.req.param("id");
+    const res = await store.update((s) => {
+      const issue = s.issues.find((i) => i.id === id);
+      if (!issue) throw notFound("issue not found");
+      const now = (/* @__PURE__ */ new Date()).toISOString();
+      const comments = [];
+      for (const cid of issue.commentIds) {
+        const found = findComment(s, cid);
+        if (!found) continue;
+        const next = { ...found.comment, exportedAt: now, updatedAt: now };
+        if (next.status === "active") next.status = "exported";
+        s.targets[found.targetKey].comments[found.index] = next;
+        comments.push(next);
+      }
+      return {
+        text: formatIssueExport({ repoRoot: repo.root, issue, comments }),
+        count: comments.length,
+        commentIds: comments.map((x) => x.id)
+      };
+    });
+    return c.json(res);
+  });
+  api.get("/commits", async (c) => {
+    const limitRaw = Number(c.req.query("limit") ?? 200);
+    const limit = Math.min(Math.max(Number.isFinite(limitRaw) ? Math.floor(limitRaw) : 200, 1), 1e3);
+    const before = c.req.query("before") || void 0;
+    const filePath = c.req.query("path") || void 0;
+    const ref = c.req.query("ref") || void 0;
+    const rootParam = c.req.query("root") || void 0;
+    let cwd = repo.root;
+    if (rootParam) {
+      const wt = (await worktrees()).find((w) => w.path === rootParam);
+      if (!wt && rootParam !== repo.root) throw badRequest("unknown root", "unknown_worktree");
+      cwd = rootParam;
+    }
+    if (before && !isValidRef(before)) throw badRequest("invalid before ref");
+    if (ref && !isValidRef(ref)) throw badRequest("invalid ref");
+    if (filePath && (filePath.startsWith("/") || filePath.split("/").includes(".."))) throw badRequest("invalid path");
+    const SEP = "";
+    const args = ["log", `--max-count=${limit + 1}`, `--format=%H${SEP}%h${SEP}%an${SEP}%ae${SEP}%aI${SEP}%P${SEP}%s`];
+    if (before) args.push(before);
+    else if (ref) args.push(ref);
+    if (filePath) args.push("--", filePath);
+    let stdout = "";
+    try {
+      stdout = (await runGit(args, { cwd })).stdout;
+    } catch (e) {
+      if (e instanceof HttpError && e.code === "git_failed") stdout = "";
+      else throw e;
+    }
+    let commits = stdout.split("\n").filter(Boolean).map((line) => {
+      const [sha = "", shortSha = "", author = "", email = "", date = "", parents = "", ...rest] = line.split(SEP);
+      return { sha, shortSha, author, email, date, parents: parents.split(" ").filter(Boolean), subject: rest.join(SEP) };
+    });
+    if (before) commits = commits.filter((x) => x.sha !== before && !x.sha.startsWith(before));
+    const hasMore = commits.length > limit;
+    const res = { commits: commits.slice(0, limit), hasMore };
+    return c.json(res);
+  });
+  api.get("/nvim/instances", async (c) => {
+    const root = c.req.query("root") || repo.root;
+    const force = c.req.query("rescan") === "1";
+    const scan = await nvim.scan(force);
+    const instances = NvimService.matching(scan.instances, root);
+    const state = await store.load();
+    const preferred = state.prefs.nvimSocketByRoot[root];
+    let selected;
+    if (preferred && instances.some((i) => i.socket === preferred)) selected = preferred;
+    else if (instances.length === 1) selected = instances[0].socket;
+    const res = { root, nvimAvailable: scan.nvimAvailable, instances, selected, scannedAt: scan.scannedAt };
+    return c.json(res);
+  });
+  api.post("/nvim/select", async (c) => {
+    const body = await c.req.json();
+    if (!body.root || !body.socket) throw badRequest("root and socket are required");
+    await store.update((s) => {
+      s.prefs.nvimSocketByRoot[body.root] = body.socket;
+    });
+    return c.json({ ok: true });
+  });
+  api.post("/nvim/open", async (c) => {
+    const body = await c.req.json();
+    if (!body.socket || !body.absPath) throw badRequest("socket and absPath are required");
+    if (!path6.isAbsolute(body.absPath)) throw badRequest("absPath must be absolute");
+    const scan = await nvim.scan();
+    if (!scan.instances.some((i) => i.socket === body.socket)) {
+      const fresh = await nvim.scan(true);
+      if (!fresh.instances.some((i) => i.socket === body.socket)) throw badRequest("nvim instance not found (rescan)", "nvim_gone");
+    }
+    try {
+      await nvim.open(body.socket, body.absPath, Number(body.line) || 1);
+    } catch (e) {
+      throw new HttpError(502, e instanceof Error ? e.message : String(e), "nvim_failed");
+    }
+    return c.json({ ok: true });
+  });
+  app.route("/api", api);
+  app.notFound((c) => {
+    if (c.req.path.startsWith("/api/") || c.req.path === "/api") return c.json({ error: "not found", code: "not_found" }, 404);
+    return c.text("Not Found", 404);
+  });
+  if (opts.webDir) {
+    const webDir = opts.webDir;
+    app.get("*", (c) => {
+      if (c.req.path === "/api" || c.req.path.startsWith("/api/")) return c.notFound();
+      return serveStaticFile(c, webDir);
+    });
+  }
+  return app;
+}
+
+// packages/server/src/index.ts
+var HOST = "127.0.0.1";
+var DEFAULT_PORT_START = 4100;
+function isPortFree(port, host = HOST) {
+  return new Promise((resolve) => {
+    const srv = net.createServer();
+    srv.once("error", () => resolve(false));
+    srv.listen(port, host, () => {
+      srv.close(() => resolve(true));
+    });
+  });
+}
+async function findFreePort(start = DEFAULT_PORT_START, host = HOST) {
+  for (let p = start; p < start + 1e3; p++) {
+    if (await isPortFree(p, host)) return p;
+  }
+  throw new Error(`no free port found starting at ${start}`);
+}
+async function startServer(opts) {
+  const repo = await resolveRepo(opts.repoPath);
+  const stateFile = opts.stateFile ?? stateFilePath(repo.commonRoot);
+  const store = new StateStore(stateFile, repo.commonRoot);
+  const app = createApp({ repo, store, nvim: new NvimService(), webDir: opts.webDir });
+  let port;
+  if (opts.port !== void 0) {
+    if (!await isPortFree(opts.port)) throw new Error(`port ${opts.port} is already in use`);
+    port = opts.port;
+  } else {
+    port = await findFreePort();
+  }
+  const server = await new Promise((resolve, reject) => {
+    const s = serve({ fetch: app.fetch, hostname: HOST, port }, () => resolve(s));
+    s.once("error", reject);
+  });
+  return {
+    url: `http://${HOST}:${port}/`,
+    port,
+    repo,
+    stateFile,
+    close: () => new Promise((resolve, reject) => {
+      server.close((err) => err ? reject(err) : resolve());
+    })
+  };
+}
+
+// bin/cli.ts
+var VERSION = true ? "0.1.0" : "dev";
+function parseArgs(argv) {
+  const args = { repoPath: process.cwd(), open: true, help: false, version: false };
+  for (let i = 0; i < argv.length; i++) {
+    const a = argv[i];
+    if (a === "--no-open") args.open = false;
+    else if (a === "--open") args.open = true;
+    else if (a === "--port" || a === "-p") {
+      const v = argv[++i];
+      if (!v || !/^\d+$/.test(v)) throw new Error("--port requires a number");
+      args.port = Number(v);
+    } else if (a.startsWith("--port=")) {
+      const v = a.slice("--port=".length);
+      if (!/^\d+$/.test(v)) throw new Error("--port requires a number");
+      args.port = Number(v);
+    } else if (a === "--help" || a === "-h") args.help = true;
+    else if (a === "--version" || a === "-v") args.version = true;
+    else if (a.startsWith("-")) throw new Error(`unknown option: ${a}`);
+    else args.repoPath = path7.resolve(a);
+  }
+  return args;
+}
+function usage() {
+  return `warden \u2014 local git diff review UI
+
+Usage: warden [repoPath] [options]
+
+Options:
+  --port <n>, -p <n>   Listen on a fixed port (default: first free port from 4100)
+  --no-open            Do not try to open the browser
+  -h, --help           Show this help
+  -v, --version        Print version
+`;
+}
+async function openBrowser(url) {
+  const candidates = [
+    ["wslview", [url]],
+    ["explorer.exe", [url]],
+    ["xdg-open", [url]]
+  ];
+  for (const [cmd, args] of candidates) {
+    const ok = await new Promise((resolve) => {
+      let child;
+      try {
+        child = spawn(cmd, args, { stdio: "ignore", detached: true });
+      } catch {
+        resolve(false);
+        return;
+      }
+      child.once("error", () => resolve(false));
+      child.once("spawn", () => {
+        child.unref();
+        resolve(true);
+      });
+    });
+    if (ok) return true;
+  }
+  return false;
+}
+function resolveWebDir() {
+  const here = path7.dirname(fileURLToPath(import.meta.url));
+  const candidates = [
+    process.env.WARDEN_WEB_DIR,
+    path7.join(here, "web"),
+    // dist/cli.js -> dist/web
+    path7.join(here, "..", "dist", "web")
+    // bin/cli.ts (tsx dev) -> dist/web
+  ].filter((p) => !!p);
+  for (const dir of candidates) {
+    if (existsSync(path7.join(dir, "index.html"))) return dir;
+  }
+  return void 0;
+}
+async function main() {
+  let args;
+  try {
+    args = parseArgs(process.argv.slice(2));
+  } catch (e) {
+    console.error(e.message);
+    console.error(usage());
+    process.exit(2);
+  }
+  if (args.help) {
+    console.log(usage());
+    return;
+  }
+  if (args.version) {
+    console.log(VERSION);
+    return;
+  }
+  const webDir = resolveWebDir();
+  if (!webDir) {
+    console.error("warning: built web assets not found (dist/web). Only the /api endpoints will be served.");
+  }
+  let server;
+  try {
+    server = await startServer({ repoPath: args.repoPath, port: args.port, webDir });
+  } catch (e) {
+    console.error(`warden: ${e.message}`);
+    process.exit(1);
+  }
+  console.log(`warden ${VERSION}`);
+  console.log(`  repo:  ${server.repo.root}`);
+  console.log(`  state: ${server.stateFile}`);
+  console.log(`  url:   ${server.url}`);
+  if (args.open) {
+    const opened = await openBrowser(server.url);
+    if (!opened) console.log("  (could not open a browser automatically; open the URL manually)");
+  }
+  const shutdown = () => {
+    server.close().finally(() => process.exit(0));
+  };
+  process.on("SIGINT", shutdown);
+  process.on("SIGTERM", shutdown);
+}
+main().catch((e) => {
+  console.error(e);
+  process.exit(1);
+});