@computesdk/loops 0.0.0-stage → 0.1.0

package/dist/server.mjs

@@ -0,0 +1,4787 @@
+// server/index.ts
+import fs7 from "node:fs";
+import { randomBytes } from "node:crypto";
+import http from "node:http";
+import path7 from "node:path";
+import { fileURLToPath } from "node:url";
+import { execFile, execFileSync as execFileSync2, spawn as spawn5 } from "node:child_process";
+
+// ../../node_modules/.pnpm/hono@4.13.14/node_modules/hono/dist/request/constants.js
+var GET_MATCH_RESULT = /* @__PURE__ */ Symbol();
+
+// ../../node_modules/.pnpm/hono@4.13.14/node_modules/hono/dist/utils/buffer.js
+var bufferToFormData = (arrayBuffer, contentType) => {
+  return new Response(arrayBuffer, { headers: { "Content-Type": contentType.replace(/^[^;]+/, (mediaType) => mediaType.toLowerCase()) } }).formData();
+};
+
+// ../../node_modules/.pnpm/hono@4.13.14/node_modules/hono/dist/utils/body.js
+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 mediaType = (isRawRequest(request) ? request.headers : request.raw.headers).get("Content-Type")?.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) => {
+    if (!(options.all || key.endsWith("[]"))) form[key] = value;
+    else handleParsingAllValues(form, key, value);
+  });
+  if (options.dot) Object.entries(form).forEach(([key, value]) => {
+    if (key.includes(".")) {
+      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(".", 34);
+  if (keys.length > 33) 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.14/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) {
+    const queryIndex = url.indexOf("?", 8);
+    let keyIndex2 = queryIndex;
+    if (keyIndex2 === -1) return;
+    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 || trailingKeyCode === 38 || isNaN(trailingKeyCode)) {
+        if (keyIndex2 > queryIndex && /(?:^|&)[^=&]*[%+]/.test(url.slice(queryIndex + 1, keyIndex2))) break;
+        if (trailingKeyCode === 61) {
+          const valueIndex = keyIndex2 + key.length + 2;
+          const endIndex = url.indexOf("&", valueIndex);
+          return _decodeURI(url.slice(valueIndex, endIndex === -1 ? void 0 : endIndex));
+        }
+        return "";
+      }
+      keyIndex2 = url.indexOf(`&${key}`, keyIndex2 + 1);
+    }
+    encoded = /[%+]/.test(url);
+    if (!encoded) return;
+  }
+  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.14/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;
+  #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);
+      const contentType = anyCachedKey === "formData" ? void 0 : raw2.headers.get("content-type");
+      return new Response(body, { headers: contentType ? { "Content-Type": contentType } : void 0 })[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.14/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.14/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()
+  * ```
+  */
+  get var() {
+    if (!this.#var) return {};
+    return Object.fromEntries(this.#var);
+  }
+  #newResponse(data, arg2, headers) {
+    let responseHeaders = this.#res ? new Headers(this.#res.headers) : this.#preparedHeaders;
+    if (typeof arg2 === "object" && arg2.headers) {
+      responseHeaders ??= new Headers();
+      for (const [key, value] of new Headers(arg2.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 arg2 === "number" ? arg2 : arg2?.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, arg2, headers) => this.#newResponse(data, arg2, 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, arg2, headers) => {
+    return !this.#preparedHeaders && !this.#status && !arg2 && !headers && !this.finalized ? new Response(text) : this.#newResponse(text, arg2, 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, arg2, headers) => {
+    return this.#newResponse(JSON.stringify(object), arg2, setDefaultContentType("application/json", headers));
+  };
+  html = (html, arg2, headers) => {
+    const res = (html2) => this.#newResponse(html2, arg2, 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", !/[^\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.14/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.14/node_modules/hono/dist/router.js
+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.14/node_modules/hono/dist/utils/constants.js
+var COMPOSED_HANDLER = "__COMPOSED_HANDLER";
+
+// ../../node_modules/.pnpm/hono@4.13.14/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 Hono2 {
+  get;
+  post;
+  put;
+  delete;
+  options;
+  patch;
+  query;
+  all;
+  on;
+  use;
+  router;
+  getPath;
+  _basePath = "/";
+  #path = "/";
+  routes = [];
+  constructor(options = {}) {
+    [...METHODS, "all"].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("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 Hono2({
+      router: this.router,
+      getPath: this.getPath
+    });
+    clone.errorHandler = this.errorHandler;
+    clone.#notFoundHandler = this.#notFoundHandler;
+    clone.routes = this.routes;
+    return clone;
+  }
+  #notFoundHandler = notFoundHandler;
+  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, app2) {
+    const subApp = this.basePath(path8);
+    app2.routes.map((r) => {
+      let handler;
+      if (app2.errorHandler === errorHandler) handler = r.handler;
+      else {
+        handler = async (c, next) => (await compose([], app2.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.
+  *
+  * @deprecated Use `mount()` from `hono/mount` instead. `.mount()` will be removed in v5.
+  *
+  * @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("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.14/node_modules/hono/dist/router/utils.js
+var createNullObject = () => /* @__PURE__ */ Object.create(null);
+
+// ../../node_modules/.pnpm/hono@4.13.14/node_modules/hono/dist/router/reg-exp-router/matcher.js
+var emptyParam = [];
+function match(method, path8) {
+  const matchers = this.buildAllMatchers();
+  const match2 = ((method2, path9) => {
+    const matcher = matchers[method2] || matchers["ALL"];
+    const staticMatch = matcher[2][path9];
+    if (staticMatch) return staticMatch;
+    const match3 = path9.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.14/node_modules/hono/dist/router/reg-exp-router/node.js
+var LABEL_REG_EXP_STR = "[^/]+";
+var TAIL_WILDCARD_REG_EXP_STR = "(?:|/.*)";
+var PATH_ERROR = /* @__PURE__ */ Symbol();
+var regExpMetaChars = /* @__PURE__ */ 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 === ".*" || a === "(?:|/.*)") return b === "(?:|/.*)" ? -1 : 1;
+  else if (b === ".*" || b === "(?:|/.*)") return -1;
+  if (a === "[^/]+") return 1;
+  else if (b === "[^/]+") return -1;
+  return a.length === b.length ? a < b ? -1 : 1 : b.length - a.length;
+}
+var Node = class Node2 {
+  #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 ? [
+        "",
+        "",
+        ".*"
+      ] : [
+        "",
+        "",
+        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] || "[^/]+";
+        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 !== ".*" && regexpStr !== "(?:|/.*)") {
+            for (const k in node.#children) if ((regexpStr.length > 1 || k.length > 1) && k !== ".*" && k !== "(?:|/.*)") throw PATH_ERROR;
+          }
+          nextNode = node.#children[regexpStr] = new Node2();
+        }
+        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 !== ".*" && k !== "(?:|/.*)") throw PATH_ERROR;
+          nextNode = node.#children[token] = new Node2();
+        }
+      }
+      node = nextNode;
+    }
+    if (node.#index !== void 0) throw PATH_ERROR;
+    node.#index = isStatic ? -1 : index;
+  }
+  buildRegExpStr() {
+    const strList = Object.keys(this.#children).sort(compareKey).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.14/node_modules/hono/dist/router/reg-exp-router/trie.js
+var Trie = class {
+  #context = { varIndex: 0 };
+  #root = new Node();
+  #index = 0;
+  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.14/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 === "*" ? ".*" : `/:${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]];
+}
+var RegExpRouter = class {
+  name = "RegExpRouter";
+  #middleware;
+  #routes;
+  #tries;
+  constructor() {
+    this.#middleware = { ["ALL"]: createNullObject() };
+    this.#routes = { ["ALL"]: createNullObject() };
+    this.#tries = { ["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["ALL"]) {
+          handlerMap[method][p] = [...handlerMap["ALL"][p]];
+          this.#insertPath(method, p);
+        }
+      }
+    }
+    if (path8 === "/*") path8 = "*";
+    const methods = method === "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["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 path9 of paths) for (const m of methods) {
+      if (!routes[m][path9]) {
+        this.#insertPath(m, path9);
+        routes[m][path9] = findMiddleware(middleware[m], path9) || findMiddleware(middleware["ALL"], path9) || [];
+      }
+      routes[m][path9].push([handler, path9]);
+    }
+  }
+  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.14/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.14/node_modules/hono/dist/router/trie-router/node.js
+var emptyParams = createNullObject();
+var order = 0;
+var Node3 = class Node4 {
+  #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 Node4();
+      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["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;
+    let curNodes = [this];
+    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) {
+              if (!Object.hasOwn(params, name)) 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;
+                (curNodesQueue[componentCount] ||= []).push(child);
+                break;
+              }
+              continue;
+            }
+          }
+          if (matcher === true || matcher.test(part)) {
+            if (!Object.hasOwn(params, name)) 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.14/node_modules/hono/dist/router/trie-router/router.js
+var TrieRouter = class {
+  name = "TrieRouter";
+  #node = new Node3();
+  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.14/node_modules/hono/dist/hono.js
+var Hono3 = 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()] });
+  }
+};
+
+// ../../node_modules/.pnpm/hono@4.13.14/node_modules/hono/dist/utils/stream.js
+var StreamingApi = class {
+  writer;
+  encoder;
+  writable;
+  abortSubscribers = [];
+  responseReadable;
+  /**
+  * Whether the stream has been aborted.
+  */
+  aborted = false;
+  /**
+  * Whether the stream has been closed normally.
+  */
+  closed = false;
+  constructor(writable, _readable) {
+    this.writable = writable;
+    this.writer = writable.getWriter();
+    this.encoder = new TextEncoder();
+    const reader = _readable.getReader();
+    this.abortSubscribers.push(async () => {
+      await reader.cancel();
+    });
+    this.responseReadable = new ReadableStream({
+      async pull(controller) {
+        const { done, value } = await reader.read();
+        done ? controller.close() : controller.enqueue(value);
+      },
+      cancel: () => {
+        if (!this.closed) this.abort();
+      }
+    });
+  }
+  async write(input) {
+    try {
+      if (typeof input === "string") input = this.encoder.encode(input);
+      await this.writer.write(input);
+    } catch {
+    }
+    return this;
+  }
+  async writeln(input) {
+    await this.write(input + "\n");
+    return this;
+  }
+  sleep(ms) {
+    return new Promise((res) => setTimeout(res, ms));
+  }
+  async close() {
+    this.closed = true;
+    try {
+      await this.writer.close();
+    } catch {
+    }
+  }
+  async pipe(body) {
+    this.writer.releaseLock();
+    try {
+      await body.pipeTo(this.writable, {
+        preventClose: true,
+        preventAbort: true
+      });
+    } finally {
+      this.writer = this.writable.getWriter();
+    }
+  }
+  onAbort(listener) {
+    this.abortSubscribers.push(listener);
+  }
+  /**
+  * Abort the stream.
+  * You can call this method when stream is aborted by external event.
+  */
+  abort() {
+    if (!this.aborted) {
+      this.aborted = true;
+      this.abortSubscribers.forEach((subscriber) => {
+        try {
+          Promise.resolve(subscriber()).catch(() => {
+          });
+        } catch {
+        }
+      });
+    }
+  }
+};
+
+// ../../node_modules/.pnpm/hono@4.13.14/node_modules/hono/dist/helper/streaming/utils.js
+var isOldBunVersion = () => {
+  const version = typeof Bun !== "undefined" ? Bun.version : void 0;
+  if (version === void 0) return false;
+  const result = version.startsWith("1.1") || version.startsWith("1.0") || version.startsWith("0.");
+  isOldBunVersion = () => result;
+  return result;
+};
+
+// ../../node_modules/.pnpm/hono@4.13.14/node_modules/hono/dist/helper/streaming/sse.js
+var SSEStreamingApi = class extends StreamingApi {
+  constructor(writable, readable) {
+    super(writable, readable);
+  }
+  async writeSSE(message) {
+    const dataLines = (await resolveCallback(message.data, HtmlEscapedCallbackPhase.Stringify, false, {})).split(/\r\n|\r|\n/).map((line) => {
+      return `data: ${line}`;
+    }).join("\n");
+    for (const key of ["event", "id"]) {
+      const value = message[key];
+      if (value && /[\r\n]/.test(value)) throw new Error(`${key} must not contain "\\r" or "\\n"`);
+    }
+    const sseData = [
+      message.event && `event: ${message.event}`,
+      dataLines,
+      message.id !== void 0 && `id: ${message.id}`,
+      message.retry !== void 0 && `retry: ${message.retry}`
+    ].filter(Boolean).join("\n") + "\n\n";
+    await this.write(sseData);
+  }
+};
+var run = async (stream2, cb, onError) => {
+  try {
+    await cb(stream2);
+  } catch (e) {
+    if (e instanceof Error && onError) {
+      await onError(e, stream2);
+      await stream2.writeSSE({
+        event: "error",
+        data: e.message
+      });
+    } else console.error(e);
+  } finally {
+    stream2.close();
+  }
+};
+var contextStash = /* @__PURE__ */ new WeakMap();
+var streamSSE = (c, cb, onError) => {
+  const { readable, writable } = new TransformStream();
+  const stream2 = new SSEStreamingApi(writable, readable);
+  if (isOldBunVersion()) c.req.raw.signal.addEventListener("abort", () => {
+    if (!stream2.closed) stream2.abort();
+  });
+  contextStash.set(stream2.responseReadable, c);
+  c.header("Transfer-Encoding", "chunked");
+  c.header("Content-Type", "text/event-stream");
+  c.header("Cache-Control", "no-cache");
+  c.header("Connection", "keep-alive");
+  run(stream2, cb, onError);
+  return c.newResponse(stream2.responseReadable);
+};
+
+// ../../node_modules/.pnpm/@hono+node-server@1.19.17_hono@4.13.14/node_modules/@hono/node-server/dist/index.mjs
+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(stream2, writable) {
+  if (stream2.locked) {
+    throw new TypeError("ReadableStream is locked.");
+  } else if (writable.destroyed) {
+    return;
+  }
+  return writeFromReadableStreamDefaultReader(stream2.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);
+    }
+  };
+};
+
+// server/chats.ts
+import fs2 from "node:fs";
+import path2 from "node:path";
+
+// server/pi-rpc.ts
+import { spawn } from "node:child_process";
+var PiRpc = class {
+  proc = null;
+  buffer = "";
+  seq = 0;
+  pending = /* @__PURE__ */ new Map();
+  listeners = /* @__PURE__ */ new Set();
+  uiListeners = /* @__PURE__ */ new Set();
+  exitListeners = /* @__PURE__ */ new Set();
+  stderr = "";
+  exited = null;
+  options;
+  constructor(options) {
+    this.options = options;
+  }
+  get running() {
+    return !!this.proc && !this.exited;
+  }
+  get stderrText() {
+    return this.stderr;
+  }
+  get cwd() {
+    return this.options.cwd;
+  }
+  async start() {
+    if (this.proc) return;
+    const proc = spawn(this.options.command ?? "pi", ["--mode", "rpc", ...this.options.args ?? []], {
+      cwd: this.options.cwd,
+      env: { ...process.env, ...this.options.env },
+      stdio: ["pipe", "pipe", "pipe"]
+    });
+    this.proc = proc;
+    proc.stdout.setEncoding("utf8");
+    proc.stdout.on("data", (chunk) => {
+      this.buffer += chunk;
+      let i;
+      while ((i = this.buffer.indexOf("\n")) >= 0) {
+        const line = this.buffer.slice(0, i).replace(/\r$/, "");
+        this.buffer = this.buffer.slice(i + 1);
+        if (!line.trim()) continue;
+        let record;
+        try {
+          record = JSON.parse(line);
+        } catch {
+          continue;
+        }
+        this.dispatch(record);
+      }
+    });
+    proc.stderr.setEncoding("utf8");
+    proc.stderr.on("data", (chunk) => {
+      this.stderr = (this.stderr + chunk).slice(-8e3);
+    });
+    const done = (code) => {
+      if (this.exited) return;
+      this.exited = { code };
+      for (const [, p] of this.pending) p.reject(new Error(`pi exited (code ${code})${this.stderr ? `: ${this.stderr.slice(-400)}` : ""}`));
+      this.pending.clear();
+      for (const fn of this.exitListeners) {
+        try {
+          fn(code, this.stderr);
+        } catch {
+        }
+      }
+    };
+    proc.on("exit", done);
+    proc.on("error", (e) => {
+      this.stderr += `
+spawn error: ${e.message}`;
+      done(null);
+    });
+  }
+  dispatch(record) {
+    if (record.type === "response") {
+      const p = this.pending.get(record.id);
+      if (p) {
+        this.pending.delete(record.id);
+        if (record.success === false) p.reject(new Error(record.error ?? `${record.command} failed`));
+        else p.resolve(record.data);
+      } else if (!record.id) this.emit({ type: "parse_error", error: record.error });
+      return;
+    }
+    if (record.type === "extension_ui_request") {
+      for (const fn of this.uiListeners) {
+        try {
+          fn(record);
+        } catch {
+        }
+      }
+      this.emit(record);
+      return;
+    }
+    this.emit(record);
+  }
+  emit(event) {
+    for (const fn of this.listeners) {
+      try {
+        fn(event);
+      } catch {
+      }
+    }
+  }
+  onEvent(fn) {
+    this.listeners.add(fn);
+    return () => {
+      this.listeners.delete(fn);
+    };
+  }
+  onUiRequest(fn) {
+    this.uiListeners.add(fn);
+    return () => {
+      this.uiListeners.delete(fn);
+    };
+  }
+  onExit(fn) {
+    this.exitListeners.add(fn);
+    return () => {
+      this.exitListeners.delete(fn);
+    };
+  }
+  /** Send one command and resolve with its `data`; rejects when the agent reports failure. */
+  send(command, timeoutMs = 0) {
+    if (!this.proc || this.exited) return Promise.reject(new Error("pi is not running"));
+    const id = `c${++this.seq}`;
+    const payload = JSON.stringify({ ...command, id }) + "\n";
+    return new Promise((resolve, reject) => {
+      this.pending.set(id, { resolve, reject });
+      const timer = timeoutMs ? setTimeout(() => {
+        if (this.pending.delete(id)) reject(new Error(`${command.type} timed out`));
+      }, timeoutMs) : null;
+      const settle = (fn) => {
+        if (timer) clearTimeout(timer);
+        fn();
+      };
+      const entry = this.pending.get(id);
+      this.pending.set(id, { resolve: (d) => settle(() => resolve(d)), reject: (e) => settle(() => reject(e)) });
+      try {
+        this.proc.stdin.write(payload);
+      } catch (e) {
+        this.pending.delete(id);
+        settle(() => reject(e));
+      }
+    });
+  }
+  /** Answer an extension dialog. Without an answer the extension's tool call waits forever. */
+  async respondUi(id, response) {
+    if (!this.proc || this.exited) return;
+    const record = { type: "extension_ui_response", id, ...response };
+    try {
+      this.proc.stdin.write(JSON.stringify(record) + "\n");
+    } catch {
+    }
+  }
+  prompt(message, behavior) {
+    return this.send({ type: "prompt", message, ...behavior ? { streamingBehavior: behavior } : {} });
+  }
+  async stop() {
+    const proc = this.proc;
+    if (!proc) return;
+    try {
+      proc.stdin.end();
+    } catch {
+    }
+    await new Promise((resolve) => {
+      if (this.exited) return resolve();
+      const t = setTimeout(() => {
+        try {
+          proc.kill("SIGKILL");
+        } catch {
+        }
+        resolve();
+      }, 3e3);
+      proc.once("exit", () => {
+        clearTimeout(t);
+        resolve();
+      });
+    });
+    this.proc = null;
+  }
+};
+
+// server/runs.ts
+import fs from "node:fs";
+import path from "node:path";
+var pretty = (spec) => {
+  const id = (spec ?? "").split("/").pop() ?? "";
+  if (/deepseek/i.test(id)) return "DeepSeek";
+  if (/kimi/i.test(id)) return "Kimi";
+  if (/glm/i.test(id)) return "GLM";
+  if (/qwen/i.test(id)) return "Qwen";
+  return id || "model";
+};
+var letters = ["A", "B", "C", "D"];
+var STATE_DIR = path.join(".pi", "loops");
+var stateFile = (cwd, id) => path.join(cwd, STATE_DIR, `${id}.json`);
+function readState(cwd, id) {
+  try {
+    return JSON.parse(fs.readFileSync(stateFile(cwd, id), "utf8"));
+  } catch {
+    return null;
+  }
+}
+var STATE_ENTRY = "loops-state";
+var roundOfEntry = (data) => {
+  const judge = data?.judge ?? (data?.pick ? { pick: data.pick, why: data.why ?? null, human: !!data.human, scores: data.scores ?? {}, reasons: data.reasons ?? {} } : null);
+  const pick = data?.pick ?? judge?.pick ?? null;
+  return {
+    ...data,
+    attempts: data?.attempts ?? [],
+    ...judge ? {
+      judge,
+      ...pick ? { pick, why: data?.why ?? judge?.why ?? null, human: data?.human ?? judge?.human ?? false, scores: data?.scores ?? judge?.scores ?? {}, reasons: data?.reasons ?? judge?.reasons ?? {}, ...data?.byModel ?? judge?.byModel ? { byModel: data?.byModel ?? judge?.byModel } : {} } : {}
+    } : {},
+    ...data?.archived ? { archived: data.archived } : data?.shots && !Array.isArray(data.shots) ? { archived: data.shots } : {}
+  };
+};
+function stateFromEntries(entries, id) {
+  const custom = entries.filter((e) => e.type === "custom");
+  const snap = [...custom].reverse().find((e) => e.customType === STATE_ENTRY && (e.data?.run === id || e.data?.state?.id === id));
+  if (!snap) return null;
+  const base = snap.data?.state ?? snap.data;
+  if (!base || typeof base !== "object" || Array.isArray(base)) return null;
+  const snapAt = Number(snap.data?.at ?? 0);
+  const rounds = /* @__PURE__ */ new Map();
+  const consider = (round, at) => {
+    const n = Number(round?.n);
+    if (!n) return;
+    const seen = rounds.get(n);
+    if (!seen || at >= seen.at) rounds.set(n, { round, at });
+  };
+  for (const r of Array.isArray(base?.rounds) ? base.rounds : []) consider(roundOfEntry(r), snapAt);
+  for (const e of custom) if (e.customType === "loops-round" && e.data?.run === id) consider(roundOfEntry(e.data), Number(e.data?.at ?? 0));
+  const rebuilt = [...rounds.values()].sort((a, b) => a.round.n - b.round.n).map((c) => c.round);
+  const newer = custom.filter((e) => e.customType === "loops-round" && e.data?.run === id && Number(e.data?.at ?? 0) > snapAt);
+  const latest = newer.at(-1)?.data?.best;
+  const winner = latest?.label && latest.round != null ? { ...base.best ?? {}, ...Object.fromEntries(Object.entries(latest).filter(([, v]) => v != null)) } : null;
+  return {
+    ...base,
+    ...winner ? { best: winner } : {},
+    id: String(base?.id ?? id),
+    rounds: rebuilt
+  };
+}
+var shotUrl = (runId, attemptName, file) => `/api/shot?run=${encodeURIComponent(runId)}&attempt=${encodeURIComponent(attemptName)}&f=${encodeURIComponent(file)}`;
+var archivedUrl = (runId, label, file) => file ? shotUrl(runId, label, file) : void 0;
+function runIds(entries) {
+  const seen = [];
+  for (const e of entries) {
+    if (e.type !== "custom") continue;
+    const id = e.customType === STATE_ENTRY ? e.data?.run ?? e.data?.state?.id : e.customType === "loops-run" ? e.data?.id : null;
+    if (id && !seen.includes(String(id))) seen.push(String(id));
+  }
+  return seen;
+}
+function questionsOf(entries, now = Date.now()) {
+  const answers = /* @__PURE__ */ new Map();
+  for (const e of entries) if (e.type === "custom" && e.customType === "loops-answer" && e.data?.id) answers.set(String(e.data.id), { choice: String(e.data.choice ?? ""), at: Number(e.data.answeredAt ?? 0) });
+  const byRun = /* @__PURE__ */ new Map();
+  for (const e of entries) {
+    if (e.type !== "custom" || e.customType !== "loops-question" || !e.data?.id) continue;
+    const d = e.data;
+    const answer = answers.get(String(d.id));
+    const renamed = { "close-call": "close", veto: "veto", stall: "stall", apply: "apply", ask: "ask" };
+    const q = {
+      id: String(d.id),
+      t: Number(d.createdAt ?? 0),
+      round: d.round ?? void 0,
+      kind: renamed[d.kind] ?? "ask",
+      source: "loop",
+      text: String(d.title ?? ""),
+      detail: d.body ?? void 0,
+      ...d.label ? { label: String(d.label) } : {},
+      options: (d.options ?? []).map((o) => ({ label: typeof o === "string" ? o : String(o.label ?? "") })),
+      ...answer ? { answered: { i: Math.max(0, (d.options ?? []).findIndex((o) => (typeof o === "string" ? o : o.label) === answer.choice)), t: answer.at } } : {},
+      ...d.expiresAt && d.expiresAt < now && !answer ? { expired: true } : {}
+    };
+    const run3 = String(d.run ?? "");
+    byRun.set(run3, [...byRun.get(run3) ?? [], q]);
+  }
+  return byRun;
+}
+function progressOf(entries, now = Date.now()) {
+  const out = /* @__PURE__ */ new Map();
+  for (const e of entries) {
+    if (e.type !== "custom" || e.customType !== "loops-progress" || !e.data?.run) continue;
+    const d = e.data;
+    if (now - Number(d.at ?? 0) > 10 * 6e4) continue;
+    out.set(String(d.run), { run: String(d.run), kind: String(d.kind ?? "visual"), round: d.round ?? null, phase: String(d.phase ?? ""), attempts: d.attempts ?? [], judge: d.judge ?? null, startedAt: Number(d.at ?? now) });
+  }
+  return out;
+}
+function buildRun({ cwd, id, entries, live }) {
+  const mine = entries.filter((e) => e.type === "custom" && e.data?.run === id);
+  const head = [...mine].reverse().find((e) => e.customType === "loops-run")?.data ?? {};
+  const state = stateFromEntries(entries, id) ?? readState(cwd, id);
+  const roundEntries = state?.rounds?.length ? state.rounds.map(roundOfEntry) : (() => {
+    const byN = /* @__PURE__ */ new Map();
+    for (const e of mine) if (e.customType === "loops-round" && e.data?.n) byN.set(Number(e.data.n), e.data);
+    return [...byN.values()].sort((a, b) => (a.n ?? 0) - (b.n ?? 0));
+  })();
+  const shots = state?.shots ?? roundEntries.at(-1)?.shots ?? head.shots ?? [];
+  const archived = {};
+  for (const r of roundEntries) for (const [label, paths] of Object.entries(r.archived ?? {})) if (Array.isArray(paths) && paths.length) archived[label] = paths;
+  for (const r of roundEntries) for (const a of r.attempts ?? []) if (a.shots?.length) archived[a.label] = a.shots;
+  const unit = state?.metric?.unit ?? roundEntries.at(-1)?.metric?.unit ?? (head.kind === "bench" ? "ms" : "");
+  const better = state?.metric?.better ?? roundEntries.at(-1)?.metric?.better ?? "lower";
+  const baseCommit = state?.baseCommit ?? roundEntries.at(-1)?.baseCommit ?? head.baseCommit;
+  const rules = state?.rules ?? roundEntries.at(-1)?.rules ?? [];
+  const chosen = state?.best ?? {};
+  const rounds = roundEntries.map((r) => {
+    const attempts = (r.attempts ?? []).map((a, i) => {
+      const score = r.scores?.[a.label] ?? a.bench?.value ?? void 0;
+      const pick = chosen.round === r.n && chosen.label ? chosen.label : r.pick;
+      const kept = pick === a.label;
+      return {
+        id: `${id}:${a.label}`,
+        name: a.label,
+        label: letters[i] ?? String(i + 1),
+        model: pretty(a.model),
+        style: a.style,
+        status: a.status ?? "done",
+        score,
+        kept,
+        humanPick: !!(kept && (r.human || chosen.round === r.n && !!chosen.label && chosen.label !== r.pick)),
+        summary: a.summary || void 0,
+        reason: r.reasons?.[a.label] || void 0,
+        shot: archivedUrl(id, a.label, a.shots?.[0]) ?? archivedUrl(id, a.label, archived[a.label]?.[0]) ?? (shots.length && a.dir ? shotUrl(id, a.label, shots[0]) : void 0),
+        tokens: a.tokens ?? void 0,
+        cost: a.cost ?? void 0,
+        hasSession: !!a.session,
+        bench: a.bench ?? void 0,
+        review: a.review ?? void 0,
+        vetoed: a.review?.ok === false,
+        unscored: !!(r.unseen ?? []).includes(a.label),
+        dir: a.dir ?? void 0,
+        commit: a.commit ?? void 0
+      };
+    });
+    const current = r.scores?.CURRENT;
+    const from = r.n > 1 ? { round: r.n - 1, label: "CURRENT" } : { round: 0, label: "baseline" };
+    return {
+      n: r.n,
+      from,
+      attempts,
+      current: current != null || r.reasons?.CURRENT ? { score: current ?? void 0, reason: r.reasons?.CURRENT ?? void 0, shot: archivedUrl(id, "CURRENT", r.archived?.CURRENT?.[0]) ?? (shots.length ? shotUrl(id, "CURRENT", shots[0]) : void 0) } : void 0,
+      pick: (chosen.round === r.n && chosen.label ? chosen.label : r.pick) ?? void 0,
+      why: r.why ?? void 0,
+      inProgress: false,
+      shots: archived,
+      sheet: r.sheet ? `/api/sheet?run=${encodeURIComponent(id)}&f=${encodeURIComponent(r.sheet)}` : void 0,
+      judgeTokens: r.judgeTokens ?? void 0,
+      judgeCost: r.judgeCost ?? void 0,
+      startedAt: r.startedAt ?? void 0,
+      endedAt: r.endedAt ?? void 0,
+      inconclusive: !!r.inconclusive,
+      unseen: r.unseen ?? [],
+      ...r.escaped ? { escaped: r.escaped } : {}
+    };
+  });
+  const lastStatus = state?.status ?? head.status ?? "done";
+  let alive = false;
+  if (live && live.run === id && lastStatus === "running") {
+    alive = true;
+    const n = live.round ?? rounds.length + 1;
+    const attempts = (live.attempts ?? []).map((a, i) => ({
+      id: `${id}:R${n}-${a.style}`,
+      name: `R${n}-${a.style}`,
+      label: letters[i] ?? String(i + 1),
+      model: pretty(state?.models?.[a.style] ?? head.models?.[a.style]),
+      style: a.style,
+      status: a.status ?? "running",
+      summary: a.text || void 0,
+      hasSession: false,
+      tokens: a.tokens || void 0
+    }));
+    const round = { n, from: { round: n - 1, label: "CURRENT" }, attempts, inProgress: true, judging: /judg/.test(live.phase ?? ""), why: void 0 };
+    const at = rounds.findIndex((r) => r.n === n);
+    if (at >= 0) rounds[at] = { ...rounds[at], inProgress: true, judging: round.judging };
+    else rounds.push(round);
+  }
+  const bestRound = state?.best?.round ?? roundEntries.filter((r) => r.pick && r.pick !== "CURRENT").at(-1)?.n ?? 0;
+  const bestEntry = roundEntries.filter((r) => r.n === bestRound).at(-1);
+  const bestLabel = state?.best?.label ?? bestEntry?.best?.label ?? head.best ?? null;
+  const bestScore = state?.best?.score ?? (bestLabel ? bestEntry?.scores?.[bestLabel] : void 0) ?? void 0;
+  const scores = roundEntries.map((r) => (r.pick && r.pick !== "CURRENT" ? r.scores?.[r.pick] : r.scores?.CURRENT) ?? (r.scores?.CURRENT ?? null)).map((v) => typeof v === "number" ? v : null).filter((v) => v != null);
+  const baseline = roundEntries[0]?.scores?.CURRENT ?? void 0;
+  const log = [];
+  const firstT = Number(roundEntries[0]?.startedAt ?? Date.parse(head.at ?? "") ?? Date.now());
+  log.push({ t: Number.isFinite(firstT) ? firstT : Date.now(), kind: "start", text: `Started ${head.goal ?? state?.goal ?? ""}`.trim() });
+  for (const r of roundEntries) {
+    log.push({ t: Number(r.endedAt ?? r.at ?? Date.now()), kind: "judged", text: "", round: r.n, pick: r.pick ?? void 0, why: r.why ?? void 0, scores: r.scores ?? void 0 });
+  }
+  const wrote = state?.status ?? head.status ?? "done";
+  const stalled = !alive && wrote === "running";
+  const status = alive ? "running" : stalled ? "stalled" : wrote;
+  if (!alive && (wrote === "done" || wrote === "aborted") && roundEntries.length) log.push({ t: Number(roundEntries.at(-1)?.endedAt ?? Date.now()), kind: "done", text: `finished after ${roundEntries.length} round(s)` });
+  const tokens = roundEntries.reduce((sum, r) => sum + (r.attempts ?? []).reduce((s, a) => s + (a.tokens ?? 0), 0) + (r.judgeTokens ?? 0), 0) + (live ? (live.attempts ?? []).reduce((s, a) => s + (a.tokens ?? 0), 0) : 0);
+  return {
+    id,
+    chat: head.chat ?? "",
+    kind: head.kind ?? state?.kind ?? "visual",
+    metric: unit ? { key: state?.metric?.key ?? "ms", unit, better } : void 0,
+    baseline,
+    name: head.name ?? goalName(state?.goal ?? head.goal ?? id),
+    goal: state?.goal ?? head.goal ?? "",
+    status: status === "aborted" ? "done" : status,
+    alive,
+    stopReason: stalled ? "no signal from the round \u2014 the process went away" : status === "aborted" ? "aborted" : void 0,
+    rules: rules.map((text) => ({ text, source: "config" })),
+    rounds,
+    best: { round: bestRound, label: bestLabel ?? "base", score: bestScore, shot: bestLabel && shots.length ? shotUrl(id, bestLabel, shots[0]) : void 0, byHuman: !!(bestEntry && bestLabel && bestEntry.pick && bestEntry.pick !== bestLabel) || !!state?.best?.human },
+    scores,
+    maxRounds: Math.max(rounds.length, 1),
+    tokens,
+    log,
+    pendingSteer: 0,
+    pending: [],
+    questions: [],
+    cwd,
+    baseCommit,
+    editedBaseline: !!state?.editedBaseline,
+    winnerFiles: state?.winner?.files ?? null
+  };
+}
+function summarize(cwd, entries) {
+  const ids = runIds(entries);
+  const questions = questionsOf(entries);
+  let open = 0, question, running = 0, lastT = 0, latest;
+  for (const id of ids) {
+    const mine = entries.filter((e) => e.type === "custom" && e.data?.run === id);
+    const head = [...mine].reverse().find((e) => e.customType === "loops-run")?.data ?? {};
+    const state = stateFromEntries(entries, id) ?? readState(cwd, id);
+    const rounds = state?.rounds?.length ? state.rounds.map(roundOfEntry) : [...new Map(mine.filter((e) => e.customType === "loops-round" && e.data?.n).map((e) => [Number(e.data.n), e.data])).values()];
+    const status = state?.status ?? head.status ?? "done";
+    const seen = mine.filter((e) => e.customType === "loops-progress").map((e) => Number(e.data?.at ?? 0)).sort((a, b) => a - b).at(-1) ?? 0;
+    const fresh = Date.now() - seen < 5 * 6e4;
+    const alive = status === "running" && fresh;
+    const stalled = status === "running" && !alive;
+    if (alive) running++;
+    const qs = (questions.get(id) ?? []).filter((q) => !q.answered && !q.expired);
+    open += qs.length;
+    if (qs.length && !question) question = { kind: qs[0].kind, round: qs[0].round, title: qs[0].text };
+    const t = Number(rounds.at(-1)?.endedAt ?? rounds.at(-1)?.at ?? 0);
+    if (t >= lastT) {
+      lastT = t;
+      const bestRound = state?.best?.round ?? rounds.filter((r) => r.pick && r.pick !== "CURRENT").at(-1)?.n;
+      const bestEntry = rounds.find((r) => r.n === bestRound);
+      latest = { name: goalName(state?.goal ?? head.goal ?? id), status: stalled ? "stalled" : status, kind: head.kind ?? state?.kind ?? "visual", score: state?.best?.score ?? (bestEntry?.pick ? bestEntry.scores?.[bestEntry.pick] : void 0), unit: state?.metric?.unit ?? rounds.at(-1)?.metric?.unit ?? "", rounds: rounds.length };
+    }
+  }
+  return { loops: ids.length, running, open, question, lastT, latest };
+}
+function goalName(goal) {
+  const words = goal.replace(/\s+/g, " ").trim().split(" ").slice(0, 4).join(" ");
+  return words.length > 34 ? words.slice(0, 33) + "\u2026" : words || "loop";
+}
+function buildRuns({ cwd, entries, live }) {
+  const questions = questionsOf(entries);
+  const progress = progressOf(entries);
+  return runIds(entries).map((id) => {
+    const run3 = buildRun({ cwd, id, entries, live: live?.get(id) ?? progress.get(id) ?? null });
+    run3.questions = questions.get(id) ?? [];
+    return run3;
+  });
+}
+
+// server/chats.ts
+var toolLine = (name, args) => {
+  const a = args ?? {};
+  if (name === "bash") return `bash \xB7 ${String(a.command ?? "").split("\n")[0].slice(0, 90)}`;
+  if (name === "read" || name === "write" || name === "edit") return `${name} \xB7 ${String(a.path ?? "").replace(process.cwd(), "")}`;
+  if (name === "loop") return `loop \xB7 ${a.from ? `continue ${a.from}` : String(a.goal ?? "").slice(0, 70)}`;
+  const first = Object.values(a).find((v) => typeof v === "string");
+  return first ? `${name} \xB7 ${first.slice(0, 70)}` : name;
+};
+function autoNameFor(runs, sessionName, already) {
+  if (already || sessionName || !runs.length) return null;
+  const name = String(runs[0]?.name ?? "").trim();
+  return name || null;
+}
+function itemsFromMessages(messages) {
+  const items = [];
+  const open = /* @__PURE__ */ new Map();
+  for (const m of messages ?? []) {
+    const ts = Number(m.timestamp ?? Date.now());
+    if (m.role === "user") {
+      const text = typeof m.content === "string" ? m.content : (m.content ?? []).filter((c) => c.type === "text").map((c) => c.text).join("\n");
+      if (text?.trim()) items.push({ t: "user", ts, text: text.trim() });
+    } else if (m.role === "assistant") {
+      for (const c of m.content ?? []) {
+        if (c.type === "text" && c.text?.trim()) items.push({ t: "text", ts, text: c.text.trim() });
+        else if (c.type === "toolCall") {
+          const item = { t: "tool", ts, cmd: toolLine(c.name, c.arguments) };
+          items.push(item);
+          if (c.id) open.set(c.id, item);
+        }
+      }
+    } else if (m.role === "toolResult") {
+      const item = open.get(m.toolCallId);
+      if (item && item.t === "tool" && !item.out) {
+        const text = (m.content ?? []).filter((c) => c.type === "text").map((c) => c.text).join("\n").trim();
+        if (text) item.out = text.split("\n").find((l) => l.trim())?.slice(0, 140);
+      }
+    }
+  }
+  return items;
+}
+var Chat = class {
+  id;
+  options;
+  pi;
+  entries = [];
+  cursor;
+  items = [];
+  live = null;
+  liveLoops = /* @__PURE__ */ new Map();
+  dialogs = [];
+  notices = [];
+  runs = [];
+  model = null;
+  started = false;
+  refreshing = null;
+  lastBroadcast = 0;
+  stderr = "";
+  file = null;
+  sessionName = null;
+  autoNamed = false;
+  constructor(id, options) {
+    this.id = id;
+    this.options = options;
+    this.model = options.model ?? null;
+    this.pi = new PiRpc({
+      command: options.piCommand,
+      args: ["--session-dir", options.sessionDir, "--session-id", id, ...options.args ?? [], ...options.model ? ["--model", options.model] : []],
+      cwd: options.cwd,
+      onEvent: (event) => this.onEvent(event),
+      onExit: (code) => {
+        this.stderr = this.pi.stderrText;
+        this.live = null;
+        this.broadcast(true);
+        if (code != null) this.touch();
+      }
+    });
+  }
+  get isUp() {
+    return this.pi.running;
+  }
+  /** The newest session entry id: the cursor a client resumes from. */
+  get entryCursor() {
+    return this.cursor;
+  }
+  /** The repo this chat runs in. */
+  get workspacePath() {
+    return this.options.cwd;
+  }
+  /** The session file pi is writing, once it has one. */
+  get sessionFile() {
+    return this.file;
+  }
+  get busy() {
+    return !!this.live?.busy;
+  }
+  touch() {
+    try {
+      this.options.onUpdate?.(this);
+    } catch {
+    }
+  }
+  async start() {
+    if (this.started) return;
+    this.started = true;
+    await this.pi.start();
+    this.pi.onUiRequest((request) => {
+      if (["select", "confirm", "input", "editor"].includes(request.method)) this.dialogs.push(request);
+      else if (request.method === "notify") {
+        console.log(`[${this.id}] ${request.level ?? "info"}: ${request.message ?? ""}`);
+        this.notices.push({ t: Date.now(), level: String(request.level ?? "info"), message: String(request.message ?? "") });
+        this.notices = this.notices.slice(-20);
+      }
+      void this.refresh();
+      this.broadcast(true);
+    });
+    if (!this.pi.running) {
+      this.stderr = this.pi.stderrText;
+      return;
+    }
+    await this.refresh(true);
+  }
+  async stop() {
+    await this.pi.stop();
+  }
+  /** Re-read the session's entries (cursor-based) and messages, then rebuild the runs. */
+  async refresh(full = false) {
+    if (this.refreshing) return this.refreshing;
+    this.refreshing = (async () => {
+      try {
+        if (full) this.cursor = void 0;
+        const entries = await this.pi.send({ type: "get_entries", ...this.cursor ? { since: this.cursor } : {} });
+        const got = entries.entries ?? [];
+        if (this.cursor) this.entries = got.length ? [...this.entries, ...got] : this.entries;
+        else this.entries = got;
+        this.cursor = got.at(-1)?.id ?? this.cursor;
+        const messages = await this.pi.send({ type: "get_messages" });
+        if (process.env.LOOPS_UI_DEBUG) console.error(`[${this.id}] refresh: ${got.length} new entries, ${(messages.messages ?? []).map((m) => `${m.role}[${Array.isArray(m.content) ? m.content.map((c) => c.type).join("+") : typeof m.content}]`).join(" ")}`);
+        this.items = itemsFromMessages(messages.messages ?? []);
+        const state = await this.pi.send({ type: "get_state" }).catch(() => ({}));
+        const st = state;
+        if (st?.sessionName) this.sessionName = String(st.sessionName);
+        if (st?.model?.id) this.model = `${st.model.provider ?? ""}/${st.model.id}`.replace(/^\//, "");
+        this.runs = buildRuns({ cwd: this.options.cwd, entries: this.entries, live: this.liveLoops });
+        const auto = autoNameFor(this.runs, this.sessionName, this.autoNamed);
+        if (auto) {
+          this.autoNamed = true;
+          await this.rename(auto).catch(() => {
+          });
+        }
+      } catch (e) {
+        console.error(`[${this.id}] refresh failed:`, e.message ?? e);
+        this.stderr = String(e.message ?? e);
+      } finally {
+        this.refreshing = null;
+        this.broadcast(true);
+      }
+    })();
+    return this.refreshing;
+  }
+  /** Rebuild just the runs (cheap): used while a round streams progress, so the canvas moves without re-reading messages. */
+  rebuildRuns() {
+    try {
+      this.runs = buildRuns({ cwd: this.options.cwd, entries: this.entries, live: this.liveLoops });
+    } catch {
+    }
+  }
+  onEvent(event) {
+    const type = event.type;
+    if (type === "message_start" && event.message?.role === "assistant") {
+      this.live = { busy: true, chat: this.id, startedAt: Date.now(), user: "", text: "", tools: [] };
+      this.broadcast();
+    } else if (type === "message_update") {
+      const u = event.assistantMessageEvent;
+      if (u?.type === "text_delta") {
+        if (!this.live) this.live = { busy: true, chat: this.id, startedAt: Date.now(), user: "", text: "", tools: [] };
+        this.live.text = (this.live.text ?? "") + (u.delta ?? "");
+        this.broadcast();
+      }
+    } else if (type === "tool_execution_start") {
+      if (!this.live) this.live = { busy: true, chat: this.id, startedAt: Date.now(), user: "", text: "", tools: [] };
+      this.live.tools.push({ id: event.toolCallId, cmd: toolLine(event.toolName, event.args), done: false });
+      if (event.toolName === "loop") this.live.text = "";
+      this.broadcast();
+    } else if (type === "tool_execution_update") {
+      const details = event.partialResult?.details;
+      if (event.toolName === "loop" && details?.run) {
+        this.liveLoops.set(details.run, { run: details.run, kind: details.kind, round: details.round ?? null, phase: details.phase ?? "starting", attempts: details.attempts ?? [], judge: details.judge, spec: details.spec, startedAt: this.liveLoops.get(details.run)?.startedAt ?? Date.now() });
+        this.rebuildRuns();
+        this.broadcast();
+      }
+    } else if (type === "tool_execution_end") {
+      const tool = this.live?.tools.find((t) => t.id === event.toolCallId);
+      if (tool) tool.done = true;
+      if (event.toolName === "loop") {
+        this.liveLoops.clear();
+        void this.refresh();
+      }
+      this.broadcast();
+    } else if (type === "message_end") {
+      void this.refresh();
+      this.broadcast();
+    } else if (type === "agent_settled" || type === "turn_end") {
+      if (type === "agent_settled") this.live = null;
+      void this.refresh();
+      this.broadcast(true);
+    } else if (type === "extension_ui_request") {
+    } else if (type.startsWith("session_") || type === "compaction_start" || type === "compaction_end") {
+      if (type === "session_idle" || type === "session_start") void this.refresh(true);
+    }
+  }
+  /** Event + state push to every subscriber, coalesced: a streaming round emits hundreds of updates a second. */
+  broadcast(force = false) {
+    const now = Date.now();
+    if (!force && now - this.lastBroadcast < 120) return;
+    this.lastBroadcast = now;
+    this.touch();
+  }
+  async prompt(text, behavior) {
+    if (!this.live) this.live = { busy: true, chat: this.id, startedAt: Date.now(), user: text, text: "", tools: [] };
+    this.broadcast(true);
+    const r = await this.pi.prompt(text, behavior);
+    setTimeout(() => void this.refresh(), 400);
+    return r?.disposition ?? "started";
+  }
+  /** The child's own view of "am I busy": a turn that settled with no event reaching us must not strand the UI. */
+  async settleIfIdle() {
+    if (!this.live) return;
+    try {
+      const st = await this.pi.send({ type: "get_state" }, 5e3);
+      if (st?.isStreaming === false && !st?.pendingMessageCount) {
+        this.live = null;
+        await this.refresh();
+      }
+    } catch {
+    }
+  }
+  async answerUi(id, response) {
+    this.dialogs = this.dialogs.filter((d) => d.id !== id);
+    await this.pi.respondUi(id, response);
+    this.broadcast(true);
+  }
+  async abort() {
+    await this.pi.send({ type: "abort" }).catch(() => {
+    });
+    this.live = null;
+    this.broadcast(true);
+  }
+  /** The newest session entry of a kind (`loops-doctor`, `loops-run`, …), for read-only views. */
+  custom(type) {
+    for (let i = this.entries.length - 1; i >= 0; i--) {
+      const e = this.entries[i];
+      if (e.type === "custom" && e.customType === type) return e.data ?? null;
+    }
+    return null;
+  }
+  /** Does this chat's session mention a run? Used to find a run's repo without the state-file index. */
+  hasRun(run3) {
+    return this.entries.some((e) => e.type === "custom" && (e.data?.run === run3 || e.customType === "loops-run" && e.data?.id === run3));
+  }
+  /** A run rebuilt from this chat's durable entries: the snapshot plus its rounds. */
+  stateFor(run3) {
+    return stateFromEntries(this.entries, run3);
+  }
+  /** The models this chat could run, and what each one can take (text only, or images too). */
+  async availableModels() {
+    try {
+      const list = await this.pi.send({ type: "get_available_models" });
+      return (list.models ?? []).map((m) => ({ id: `${m.provider}/${m.id}`, provider: m.provider, model: m.id, images: Array.isArray(m.input) ? m.input.includes("image") : null }));
+    } catch {
+      return [];
+    }
+  }
+  async setModel(provider, model) {
+    await this.pi.send({ type: "set_model", provider, modelId: model });
+    this.model = `${provider}/${model}`;
+    this.broadcast(true);
+  }
+  /** An attempt's transcript, straight from the session file the attempt forked into. */
+  sessionItems(file) {
+    try {
+      const lines = fs2.readFileSync(file, "utf8").split("\n").filter(Boolean).map((l) => JSON.parse(l));
+      const messages = lines.filter((e) => e.type === "message" && e.message).map((e) => e.message);
+      return itemsFromMessages(messages);
+    } catch {
+      return [];
+    }
+  }
+  /** Rename this chat: Pi stores it on the session, so it survives reloads and shows up in the TUI too. */
+  async rename(name) {
+    const clean = String(name ?? "").replace(/\s+/g, " ").trim().slice(0, 80);
+    if (!clean) return;
+    await this.pi.send({ type: "set_session_name", name: clean });
+    this.sessionName = clean;
+    this.broadcast(true);
+  }
+  get title() {
+    if (this.sessionName) return this.sessionName;
+    const name = [...this.entries].reverse().find((e) => e.type === "session_name" || e.type === "name");
+    if (name?.name) return String(name.name);
+    const firstUser = this.items.find((i) => i.t === "user");
+    return firstUser ? firstUser.text.replace(/\s+/g, " ").slice(0, 46) : "New chat";
+  }
+  snapshot() {
+    const runs = this.runs;
+    return {
+      chat: this.id,
+      title: this.title,
+      chats: [],
+      items: this.items,
+      live: this.live,
+      runs,
+      model: this.model,
+      error: this.pi.running ? void 0 : this.stderr || void 0,
+      questions: runs.flatMap((r) => r.questions),
+      dialogs: this.dialogs,
+      notices: this.notices.slice(-6),
+      stderr: this.stderr || void 0
+    };
+  }
+};
+function listChats(sessionDir, cwd = process.cwd()) {
+  let files = [];
+  try {
+    files = fs2.readdirSync(sessionDir).filter((f) => f.endsWith(".jsonl")).map((f) => {
+      let summary;
+      const full = path2.join(sessionDir, f);
+      let title;
+      let firstUser;
+      const entries = [];
+      try {
+        for (const line of fs2.readFileSync(full, "utf8").split("\n")) {
+          if (!line.trim()) continue;
+          const e = JSON.parse(line);
+          entries.push(e);
+          if ((e.type === "session_name" || e.type === "name") && e.name) title = String(e.name);
+          if (!firstUser && e.type === "message" && e.message?.role === "user") {
+            const c = e.message.content;
+            firstUser = typeof c === "string" ? c : (c ?? []).filter((x) => x.type === "text").map((x) => x.text).join(" ");
+          }
+        }
+      } catch {
+      }
+      summary = summarize(cwd, entries);
+      return { id: path2.basename(f, ".jsonl").replace(/^.*_/, ""), last: fs2.statSync(full).mtimeMs, title: title ?? (firstUser ? firstUser.replace(/\s+/g, " ").slice(0, 46) : void 0), summary };
+    });
+  } catch {
+    return [];
+  }
+  return files.filter((f) => /^chat-/.test(f.id)).sort((a, b) => b.last - a.last).map((f) => ({ id: f.id, title: f.title ?? goalName("New chat"), ts: f.last, last: f.last, summary: f.summary }));
+}
+var ChatManager = class {
+  chats = /* @__PURE__ */ new Map();
+  listeners = /* @__PURE__ */ new Set();
+  base;
+  /** Where a chat lives. Set by the server from the workspace registry, which owns the persistence. */
+  bind;
+  constructor(options) {
+    const { bind, ...base } = options;
+    this.base = base;
+    this.bind = bind;
+  }
+  onChange(fn) {
+    this.listeners.add(fn);
+    return () => {
+      this.listeners.delete(fn);
+    };
+  }
+  /** Chats in one workspace (or all of them, when no workspace is named). */
+  list(ws) {
+    const chats = listChats(ws?.sessionDir ?? "", ws?.path ?? process.cwd());
+    return chats.map((c) => ({ ...c, ws: ws?.id }));
+  }
+  get(id) {
+    return this.chats.get(id) ?? null;
+  }
+  async open(id) {
+    const existing = this.chats.get(id);
+    if (existing?.isUp) {
+      await existing.start();
+      return existing;
+    }
+    const where = this.bind(id);
+    const chat = new Chat(id, { ...this.base, ...where, onUpdate: (c) => {
+      for (const fn of this.listeners) {
+        try {
+          fn(c);
+        } catch {
+        }
+      }
+    } });
+    this.chats.set(id, chat);
+    await chat.start();
+    return chat;
+  }
+  async close(id) {
+    const chat = this.chats.get(id);
+    this.chats.delete(id);
+    await chat?.stop();
+  }
+  async closeAll() {
+    await Promise.all([...this.chats.values()].map((c) => c.stop()));
+    this.chats.clear();
+  }
+  openChats() {
+    return [...this.chats.values()];
+  }
+  /** The workspace a live chat is running in (for artifact routes that only know the chat). */
+  cwdOf(chat) {
+    return this.chats.get(chat)?.workspacePath ?? null;
+  }
+  /** The open chat whose session mentions this run, for routes that only get a run id. */
+  findRun(run3) {
+    for (const chat of this.chats.values()) if (chat.hasRun(run3)) return chat;
+    return null;
+  }
+};
+
+// server/live.ts
+import fs3 from "node:fs";
+import net from "node:net";
+import path3 from "node:path";
+import { spawn as spawn2 } from "node:child_process";
+var lives = /* @__PURE__ */ new Map();
+var IDLE_MS = 10 * 6e4;
+function serveCommand(cwd, agentDir2 = process.env.PI_AGENT_DIR ?? path3.join(process.env.HOME ?? "", ".pi", "agent")) {
+  for (const f of [path3.join(cwd, ".pi", "loops.json"), path3.join(agentDir2, "loops.json")]) {
+    try {
+      const j = JSON.parse(fs3.readFileSync(f, "utf8"));
+      if (typeof j?.serve === "string" && j.serve.trim()) return j.serve.trim();
+    } catch {
+    }
+  }
+  return null;
+}
+var freePort = () => new Promise((resolve, reject) => {
+  const s = net.createServer();
+  s.unref();
+  s.on("error", reject);
+  s.listen(0, "127.0.0.1", () => {
+    const addr = s.address();
+    const port = typeof addr === "object" && addr ? addr.port : 0;
+    s.close(() => resolve(port));
+  });
+});
+var reachable = (port, timeout = 700) => new Promise((resolve) => {
+  const sock = net.connect({ port, host: "127.0.0.1" });
+  const done = (ok) => {
+    sock.destroy();
+    resolve(ok);
+  };
+  sock.setTimeout(timeout);
+  sock.on("connect", () => done(true));
+  sock.on("timeout", () => done(false));
+  sock.on("error", () => done(false));
+});
+var kill = (live) => {
+  const pid = live.child.pid;
+  if (pid) {
+    try {
+      process.kill(-pid, "SIGTERM");
+    } catch {
+      try {
+        live.child.kill("SIGTERM");
+      } catch {
+      }
+    }
+  }
+  setTimeout(() => {
+    if (pid) {
+      try {
+        process.kill(-pid, "SIGKILL");
+      } catch {
+      }
+    }
+  }, 1500).unref();
+};
+var liveUrl = (run3) => {
+  const live = lives.get(run3);
+  if (live) live.usedAt = Date.now();
+  return live?.url;
+};
+async function startLive({ cwd, run: run3, state: given }) {
+  const existing = lives.get(run3);
+  if (existing) {
+    existing.usedAt = Date.now();
+    return { url: existing.url, reused: true };
+  }
+  const state = given ?? readState(cwd, run3);
+  if (!state) throw new Error(`no run ${run3}`);
+  const dir = state.best?.dir ?? null;
+  if (!dir) throw new Error(`${state.best?.label ?? "the winner"} has no worktree left (the run was cleaned up) \u2014 nothing to serve`);
+  const serve = serveCommand(cwd);
+  if (!serve) throw new Error("this repo has no `serve` in .pi/loops.json \u2014 there is no app to run (visual loops that only write files are judged on their screenshots)");
+  const workdir = path3.join(cwd, dir);
+  if (!fs3.existsSync(workdir)) throw new Error(`${dir} is gone \u2014 the run was cleaned up`);
+  const port = await freePort();
+  const log = path3.join(cwd, ".pi", "loops-ui", `live-${port}.log`);
+  fs3.mkdirSync(path3.dirname(log), { recursive: true });
+  const fd = fs3.openSync(log, "a");
+  const child = spawn2("sh", ["-c", serve], { cwd: workdir, env: { ...process.env, PORT: String(port), HOST: "127.0.0.1" }, stdio: ["ignore", fd, fd], detached: true });
+  fs3.closeSync(fd);
+  const live = { run: run3, port, url: `http://localhost:${port}/`, child, startedAt: Date.now(), usedAt: Date.now() };
+  lives.set(run3, live);
+  let dead = false;
+  child.on("exit", () => {
+    dead = true;
+  });
+  const deadline = Date.now() + 6e4;
+  while (Date.now() < deadline) {
+    if (dead) break;
+    if (await reachable(port)) return { url: live.url };
+    await new Promise((r) => setTimeout(r, 400));
+  }
+  lives.delete(run3);
+  kill(live);
+  let tail = "";
+  try {
+    tail = fs3.readFileSync(log, "utf8").split("\n").filter(Boolean).slice(-3).join(" \xB7 ").slice(-300);
+  } catch {
+  }
+  throw new Error(dead || !tail ? `\`${serve}\` did not come up on :${port}${tail ? ` \u2014 ${tail}` : ""}` : `\`${serve}\` is running but nothing answered on :${port} yet`);
+}
+function stopLive(run3) {
+  const live = lives.get(run3);
+  if (!live) return false;
+  kill(live);
+  lives.delete(run3);
+  return true;
+}
+function stopAllLive() {
+  for (const [run3] of lives) stopLive(run3);
+}
+setInterval(() => {
+  for (const [run3, live] of lives) if (Date.now() - live.usedAt > IDLE_MS) stopLive(run3);
+}, 6e4).unref();
+for (const sig of ["SIGINT", "SIGTERM"]) process.on(sig, () => {
+  stopAllLive();
+  process.exit(0);
+});
+process.on("exit", () => stopAllLive());
+
+// ../pi-loops/lib/config.ts
+import fs5 from "node:fs";
+import os2 from "node:os";
+import net2 from "node:net";
+import path5 from "node:path";
+import { spawn as spawn4 } from "node:child_process";
+
+// ../pi-loops/lib/shot.ts
+import { spawn as spawn3 } from "node:child_process";
+import fs4 from "node:fs";
+import os from "node:os";
+import path4 from "node:path";
+var NAMES = [
+  "google-chrome",
+  "google-chrome-stable",
+  "chromium",
+  "chromium-browser",
+  "chrome",
+  "brave-browser",
+  "microsoft-edge",
+  "chrome-headless-shell",
+  "headless-shell",
+  "headless_shell"
+];
+var PATHS = [
+  "/Applications/Google Chrome.app/Contents/MacOS/Google Chrome",
+  "/Applications/Chromium.app/Contents/MacOS/Chromium",
+  "/Applications/Brave Browser.app/Contents/MacOS/Brave Browser",
+  "/Applications/Microsoft Edge.app/Contents/MacOS/Microsoft Edge",
+  "/headless-shell/headless-shell",
+  // exe.dev VMs ship the headless shell Shelley drives here
+  "/usr/lib/chromium/chromium",
+  "/snap/bin/chromium",
+  "/opt/google/chrome/chrome"
+];
+var which = (cmd) => {
+  for (const dir of (process.env.PATH ?? "").split(path4.delimiter)) {
+    const p = path4.join(dir, cmd);
+    if (fs4.existsSync(p)) return p;
+  }
+  return null;
+};
+var isPath = (c) => c.includes("/");
+function playwrightShells() {
+  const root = process.env.PLAYWRIGHT_BROWSERS_PATH || path4.join(os.homedir(), ".cache", "ms-playwright");
+  let entries;
+  try {
+    entries = fs4.readdirSync(root);
+  } catch {
+    return [];
+  }
+  const found = [];
+  for (const e of entries.sort().reverse()) {
+    if (e.startsWith("chromium_headless_shell-")) found.push(path4.join(root, e, "chrome-headless-shell-linux64", "chrome-headless-shell"), path4.join(root, e, "chrome-headless-shell-mac-arm64", "chrome-headless-shell"), path4.join(root, e, "chrome-headless-shell-mac-x64", "chrome-headless-shell"));
+    else if (e.startsWith("chromium-")) found.push(path4.join(root, e, "chrome-linux", "chrome"), path4.join(root, e, "chrome-mac", "Chromium.app", "Contents", "MacOS", "Chromium"));
+  }
+  return found;
+}
+function chromeCandidates(explicit) {
+  const named = [explicit, process.env.LOOPS_CHROME, process.env.CHROME, process.env.PUPPETEER_EXECUTABLE_PATH].filter((c) => !!c);
+  const fromNames = NAMES.map(which).filter((p) => !!p);
+  return [...named, ...fromNames, ...PATHS, ...playwrightShells()];
+}
+function findChrome(explicit) {
+  for (const c of chromeCandidates(explicit)) {
+    if (isPath(c)) {
+      if (fs4.existsSync(c)) return c;
+      continue;
+    }
+    const p = which(c);
+    if (p) return p;
+  }
+  throw new Error("no Chrome/Chromium found \u2014 visual mode screenshots routes with headless Chrome. Any Chromium works: install one, `npx playwright install chromium-headless-shell` puts one where loops looks (~/.cache/ms-playwright), or point LOOPS_CHROME at a binary, e.g. LOOPS_CHROME=/usr/bin/chromium");
+}
+async function connect(wsUrl) {
+  const sock = new WebSocket(wsUrl);
+  const pending = /* @__PURE__ */ new Map();
+  const listeners = /* @__PURE__ */ new Map();
+  let id = 0;
+  sock.addEventListener("message", (e) => {
+    const m = JSON.parse(String(e.data));
+    if (m.id) {
+      const p = pending.get(m.id);
+      if (!p) return;
+      pending.delete(m.id);
+      if (m.error) p.fail(new Error(m.error.message));
+      else p.ok(m.result);
+      return;
+    }
+    for (const fn of listeners.get(m.method) ?? []) {
+      try {
+        fn(m.params);
+      } catch {
+      }
+    }
+  });
+  await new Promise((res, rej) => {
+    sock.addEventListener("open", () => res());
+    sock.addEventListener("error", () => rej(new Error("could not connect to the browser's DevTools endpoint")));
+  });
+  const send = (method, params = {}, sessionId) => new Promise((ok, fail) => {
+    const n = ++id;
+    pending.set(n, { ok, fail });
+    sock.send(JSON.stringify({ id: n, method, params, ...sessionId ? { sessionId } : {} }));
+  });
+  return {
+    send,
+    close: () => {
+      try {
+        sock.close();
+      } catch {
+      }
+    },
+    on: (method, fn) => {
+      const s = listeners.get(method) ?? /* @__PURE__ */ new Set();
+      s.add(fn);
+      listeners.set(method, s);
+      return () => {
+        s.delete(fn);
+      };
+    }
+  };
+}
+function launch(bin) {
+  const child = spawn3(bin, [
+    "--headless=new",
+    "--no-sandbox",
+    "--disable-gpu",
+    "--hide-scrollbars",
+    "--disable-dev-shm-usage",
+    "--remote-debugging-port=0",
+    "about:blank"
+  ], { stdio: ["ignore", "ignore", "pipe"], detached: true });
+  const endpoint = new Promise((res, rej) => {
+    let buf = "";
+    const t = setTimeout(() => rej(new Error(`the browser did not open a DevTools endpoint: ${buf.split("\n").filter((l) => !/dbus|gpu|vulkan|fontconfig/i.test(l)).slice(-2).join(" ").slice(0, 240)}`)), 3e4);
+    child.stderr?.on("data", (d) => {
+      buf += String(d);
+      const m = buf.match(/DevTools listening on (ws:\/\/\S+)/);
+      if (m) {
+        clearTimeout(t);
+        res(m[1]);
+      }
+    });
+    child.on("exit", (code) => {
+      clearTimeout(t);
+      rej(new Error(`the browser exited (${code}) before it was ready`));
+    });
+  });
+  return { child, endpoint };
+}
+var kill2 = (child) => {
+  const pid = child.pid;
+  if (!pid) return;
+  try {
+    process.kill(-pid, "SIGTERM");
+  } catch {
+    try {
+      child.kill("SIGTERM");
+    } catch {
+    }
+  }
+  setTimeout(() => {
+    try {
+      process.kill(-pid, "SIGKILL");
+    } catch {
+    }
+  }, 1500).unref();
+};
+async function boxOf(to, selector) {
+  await to("DOM.enable");
+  const { root } = await to("DOM.getDocument", { depth: -1 });
+  const { nodeId } = await to("DOM.querySelector", { nodeId: root.nodeId, selector });
+  if (!nodeId) throw new Error(`no element matches ${selector}`);
+  const { model } = await to("DOM.getBoxModel", { nodeId });
+  const [x1, y1, , , x2, , , y2] = model.border;
+  return { x: x1, y: y1, width: Math.max(x2 - x1, 1), height: Math.max(y2 - y1, 1) };
+}
+var MAX_HEIGHT = 12e3;
+async function capture({ url, out, width = 1440, height = 900, wait = 1500, loadTimeout = 30, viewport = false, selector, chrome, cwd = process.cwd() }) {
+  const bin = findChrome(chrome);
+  const { child, endpoint } = launch(bin);
+  let cdp = null;
+  try {
+    cdp = await connect(await endpoint);
+    const { targetId } = await cdp.send("Target.createTarget", { url: "about:blank" });
+    const { sessionId } = await cdp.send("Target.attachToTarget", { targetId, flatten: true });
+    const to = (method, params = {}) => cdp.send(method, params, sessionId);
+    await to("Page.enable");
+    await to("Network.enable");
+    await to("Emulation.setDeviceMetricsOverride", { width, height, deviceScaleFactor: 1, mobile: false });
+    const failures = [];
+    let loaded = false;
+    cdp.on("Page.loadEventFired", () => {
+      loaded = true;
+    });
+    cdp.on("Network.loadingFailed", (p) => {
+      if (p?.type === "Document") failures.push(p.errorText ?? "the document failed to load");
+    });
+    cdp.on("Network.responseReceived", (p) => {
+      if (p?.type === "Document" && p.response?.status >= 400) failures.push(`HTTP ${p.response.status}`);
+    });
+    const nav = await to("Page.navigate", { url });
+    if (nav?.errorText) failures.push(nav.errorText);
+    for (const t0 = Date.now(); !loaded && !failures.length && Date.now() - t0 < loadTimeout * 1e3; ) await new Promise((r) => setTimeout(r, 100));
+    if (wait) await new Promise((r) => setTimeout(r, wait));
+    if (failures.length) throw new Error(`${url}: ${failures[0]}`);
+    const layout = await to("Page.getLayoutMetrics");
+    const pageSize = layout.cssContentSize ?? layout.contentSize;
+    const clip = selector ? await boxOf(to, selector) : viewport ? { x: 0, y: 0, width, height } : { x: 0, y: 0, width: Math.max(Math.ceil(pageSize.width), width), height: Math.min(Math.max(Math.ceil(pageSize.height), height), MAX_HEIGHT) };
+    const { data } = await to("Page.captureScreenshot", { format: "png", captureBeyondViewport: true, fromSurface: true, clip: { ...clip, scale: 1 } });
+    const file = path4.resolve(cwd, out);
+    fs4.mkdirSync(path4.dirname(file), { recursive: true });
+    fs4.writeFileSync(file, Buffer.from(data, "base64"));
+    return file;
+  } finally {
+    cdp?.close();
+    kill2(child);
+  }
+}
+var CANARY_ALPHABET = "ACDEFGHJKLPRTUVWXY34679";
+function canaryCode(random = Math.random, len = 4) {
+  let out = "";
+  for (let i = 0; i < len; i++) out += CANARY_ALPHABET[Math.floor(random() * CANARY_ALPHABET.length)] ?? "A";
+  return out;
+}
+async function canaryImage({ code, out, chrome, cwd = process.cwd() }) {
+  const html = `<!doctype html><meta charset="utf-8"><style>
+    html,body{margin:0;width:360px;height:140px;background:#fff;display:flex;align-items:center;justify-content:center}
+    p{margin:0;font:800 64px/1 ui-monospace,SFMono-Regular,monospace;letter-spacing:10px;color:#111}
+  </style><p>${code}</p>`;
+  return capture({ url: `data:text/html;charset=utf-8,${encodeURIComponent(html)}`, out, width: 360, height: 140, wait: 100, chrome, cwd });
+}
+if (false) {
+  shot({ ...parseArgs(process.argv.slice(2)), log: (m) => console.error(m) }).then((f) => {
+    console.log(f);
+  }).catch((e) => {
+    console.error(`shot: ${e.message}`);
+    process.exit(1);
+  });
+}
+
+// ../pi-loops/lib/judge.ts
+var normCode = (v) => String(v ?? "").toUpperCase().replace(/[^A-Z0-9]/g, "");
+function sameCode(expected, said) {
+  const a = normCode(expected), b = normCode(said);
+  if (!a || !b) return false;
+  if (a === b) return true;
+  if (a.length < 4 || Math.abs(a.length - b.length) > 1) return false;
+  let edits = 0;
+  for (let i = 0, j = 0; (i < a.length || j < b.length) && edits <= 1; ) {
+    if (a[i] === b[j]) {
+      i++;
+      j++;
+      continue;
+    }
+    edits++;
+    if (a.length > b.length) i++;
+    else if (b.length > a.length) j++;
+    else {
+      i++;
+      j++;
+    }
+  }
+  return edits <= 1;
+}
+
+// ../pi-loops/lib/config.ts
+var CONFIG_DEFAULTS = { attempts: 3, rounds: 1, timeoutMin: 15, tokenBudget: null, repeat: 2, minGain: 0.05, judgeSamples: 3, judgePairs: 2, judgePanel: true, council: true, models: {} };
+var SETUP = ["serve", "check", "bench", "metric", "protect"];
+var readJson = (f) => {
+  try {
+    return JSON.parse(fs5.readFileSync(f, "utf8"));
+  } catch {
+    return null;
+  }
+};
+var agentDir = () => process.env.PI_AGENT_DIR ?? path5.join(os2.homedir(), ".pi", "agent");
+var configFiles = (cwd, dir = agentDir()) => ({ user: path5.join(dir, "loops.json"), project: path5.join(cwd, ".pi", "loops.json") });
+function settingsWithSources({ cwd, pi, agentDir: dir }) {
+  const dirAbs = dir ?? agentDir();
+  const out = {};
+  for (const [k, v] of Object.entries(CONFIG_DEFAULTS)) out[k] = { value: v, source: "default" };
+  const apply = (j, source) => {
+    for (const [k, v] of Object.entries(j ?? {})) {
+      if (k === "models") {
+        out.models = { value: { ...out.models?.value ?? {}, ...v ?? {} }, source };
+        continue;
+      }
+      out[k] = { value: v, source };
+    }
+  };
+  for (const f of [path5.join(dirAbs, "settings.json"), path5.join(cwd, ".pi", "settings.json")]) {
+    try {
+      apply(readJson(f)?.loops ?? {}, "settings.json:loops");
+    } catch {
+    }
+  }
+  try {
+    apply(pi?.getSettings?.()?.loops ?? {}, "settings.json:loops");
+  } catch {
+  }
+  const { user, project } = configFiles(cwd, dirAbs);
+  try {
+    apply(readJson(user) ?? {}, "~/.pi/agent/loops.json");
+  } catch {
+  }
+  try {
+    apply(readJson(project) ?? {}, ".pi/loops.json");
+  } catch {
+  }
+  return out;
+}
+function effectiveConfig(cwd, dir = agentDir(), pi) {
+  const sourced = settingsWithSources({ cwd, pi, agentDir: dir });
+  const project = configFiles(cwd, dir).project;
+  return Object.entries(sourced).map(([key, s]) => {
+    const source = s.source === "default" ? "default" : s.source === ".pi/loops.json" ? "project" : "user";
+    return { key, value: s.value, source, ...s.source === "default" ? {} : { file: s.source === project ? path5.relative(cwd, project) : s.source } };
+  }).sort((a, b) => SETUP.indexOf(a.key) - SETUP.indexOf(b.key) || a.key.localeCompare(b.key));
+}
+var selfWriting = false;
+var isSelfWriting = () => selfWriting;
+var lastSelfWrite = null;
+var isSelfWrite = (raw2) => lastSelfWrite !== null && raw2 === lastSelfWrite;
+var writeRaw = (file, json) => {
+  const raw2 = JSON.stringify(json, null, 2) + "\n";
+  selfWriting = true;
+  try {
+    fs5.mkdirSync(path5.dirname(file), { recursive: true });
+    fs5.writeFileSync(file, raw2);
+    lastSelfWrite = raw2;
+  } finally {
+    setTimeout(() => {
+      selfWriting = false;
+    }, 80);
+  }
+};
+function writeSetting(cwd, key, value) {
+  if (!/^[a-zA-Z][\w-]*$/.test(key) || key === "models") throw new Error(`cannot set "${key}" from here${key === "models" ? " \u2014 use /loop models" : ""}`);
+  const file = configFiles(cwd).project;
+  const cur = readJson(file) ?? {};
+  const next = { ...cur, [key]: value === "" ? null : value };
+  for (const k of Object.keys(next)) if (next[k] === null) delete next[k];
+  writeRaw(file, next);
+}
+var WATCHED_KEYS = ["serve", "check", "bench", "metric", "protect", "attempts", "rounds", "judgeSamples", "judgePairs", "tokenBudget", "models"];
+var short = (v) => v === void 0 ? "none" : JSON.stringify(v);
+function diffConfig(before, after) {
+  const keys = [.../* @__PURE__ */ new Set([...Object.keys(before ?? {}), ...Object.keys(after ?? {})])].filter((k) => k === "models" || WATCHED_KEYS.includes(k));
+  return keys.map((key) => ({ key, from: short(before?.[key]), to: short(after?.[key]) })).filter((c) => c.from !== c.to);
+}
+function restoreConfig(cwd, before) {
+  const file = configFiles(cwd).project;
+  if (before && Object.keys(before).length) {
+    writeRaw(file, before);
+    return;
+  }
+  selfWriting = true;
+  try {
+    fs5.rmSync(file, { force: true });
+    lastSelfWrite = "";
+  } finally {
+    setTimeout(() => {
+      selfWriting = false;
+    }, 80);
+  }
+}
+function acceptConfig(cwd, after) {
+  writeRaw(configFiles(cwd).project, after);
+}
+var freePort2 = () => new Promise((resolve, reject) => {
+  const s = net2.createServer();
+  s.unref();
+  s.on("error", reject);
+  s.listen(0, "127.0.0.1", () => {
+    const a = s.address();
+    const port = typeof a === "object" && a ? a.port : 0;
+    s.close(() => resolve(port));
+  });
+});
+var reachable2 = (port, timeout = 600) => new Promise((resolve) => {
+  const sock = net2.connect({ port, host: "127.0.0.1" });
+  const done = (ok) => {
+    sock.destroy();
+    resolve(ok);
+  };
+  sock.setTimeout(timeout);
+  sock.on("connect", () => done(true));
+  sock.on("timeout", () => done(false));
+  sock.on("error", () => done(false));
+});
+var run2 = (cmd, args, opts) => new Promise((resolve) => {
+  const started = Date.now();
+  const limit = opts.timeout ?? 12e4;
+  const child = spawn4(cmd, args, { cwd: opts.cwd, env: { ...process.env, ...opts.env ?? {} }, stdio: ["ignore", "pipe", "pipe"], detached: false });
+  let out = "";
+  let timedOut = false;
+  const timer = setTimeout(() => {
+    timedOut = true;
+    try {
+      child.kill("SIGKILL");
+    } catch {
+    }
+  }, limit);
+  child.stdout?.on("data", (d) => {
+    out += d.toString();
+    if (out.length > 1 << 23) out = out.slice(-(1 << 23));
+  });
+  child.stderr?.on("data", (d) => {
+    out += d.toString();
+    if (out.length > 1 << 23) out = out.slice(-(1 << 23));
+  });
+  child.on("error", (e) => {
+    clearTimeout(timer);
+    resolve({ code: 1, out: `${out}
+${String(e)}`.trim(), timedOut });
+  });
+  child.on("close", (code) => {
+    clearTimeout(timer);
+    resolve({ code: code ?? 1, out: out.trim(), timedOut: timedOut || Date.now() - started >= limit });
+  });
+});
+async function serveCheck(cwd, serve) {
+  const t0 = Date.now();
+  const port = await freePort2();
+  const child = spawn4("sh", ["-c", serve], { cwd, env: { ...process.env, PORT: String(port) }, stdio: ["ignore", "pipe", "pipe"], detached: true });
+  let log = "";
+  child.stdout?.on("data", (d) => {
+    log += d.toString();
+  });
+  child.stderr?.on("data", (d) => {
+    log += d.toString();
+  });
+  let dead = false;
+  child.on("exit", () => {
+    dead = true;
+  });
+  const deadline = Date.now() + 45e3;
+  let ok = false;
+  while (!dead && Date.now() < deadline) {
+    if (await reachable2(port)) {
+      ok = true;
+      break;
+    }
+    await new Promise((r) => setTimeout(r, 400));
+  }
+  if (child.pid) {
+    try {
+      process.kill(-child.pid, "SIGTERM");
+    } catch {
+    }
+    setTimeout(() => {
+      try {
+        process.kill(-child.pid, "SIGKILL");
+      } catch {
+      }
+    }, 800).unref();
+  }
+  const tail = log.split("\n").filter(Boolean).slice(-2).join(" \xB7 ").slice(-160);
+  return { name: "serve", ok, detail: ok ? `booted on :${port}` : dead ? `exited \u2014 ${tail || "no output"}` : `nothing answered on :${port} in 45s${tail ? ` \u2014 ${tail}` : ""}`, ms: Date.now() - t0, fatal: true };
+}
+async function checkCheck(cwd, check) {
+  const t0 = Date.now();
+  const r = await run2("sh", ["-c", check], { cwd, timeout: 18e4 });
+  const tail = r.out.split("\n").filter((l) => l.trim()).slice(-2).join(" \xB7 ").slice(-200);
+  return {
+    name: "check",
+    ok: r.code === 0,
+    ms: Date.now() - t0,
+    fatal: true,
+    detail: r.timedOut ? `did not finish in 180s` : r.code === 0 ? `passes (${tail || "no output"})` : `fails (exit ${r.code}) \u2014 ${tail}`
+  };
+}
+async function visionCheck(cwd, spec) {
+  const t0 = Date.now();
+  const code = canaryCode();
+  const dir = path5.join(cwd, ".pi", "loops", ".canary");
+  const file = path5.join(dir, `canary-${code}.png`);
+  try {
+    fs5.mkdirSync(dir, { recursive: true });
+    await canaryImage({ code, out: file, cwd });
+    const r = await run2("pi", ["--print", "--no-session", "--model", spec, `Reply with JSON only: {"code":"<the 4-character code printed in this image>"} @${file}`], { cwd, timeout: 75e3 });
+    const said = (r.out.match(/"code"\s*:\s*"([^"]*)"/) ?? [])[1] ?? "";
+    if (sameCode(code, said)) return { name: `judge sees images (${spec})`, ok: true, detail: `read the code ${code} back`, ms: Date.now() - t0, fatal: false };
+    const why = r.out.split("\n").filter((l) => l.trim() && !/reflection fetch failed/.test(l)).slice(-2).join(" \xB7 ").slice(-160);
+    return {
+      name: `judge sees images (${spec})`,
+      ok: false,
+      fatal: true,
+      ms: Date.now() - t0,
+      detail: r.timedOut ? `no answer in 75s \u2014 the model or provider stalled (an unavailable judge cannot score screenshots)` : said ? `said "${said}", expected ${code}` : `did not read the code \u2014 ${why || "no answer"}`
+    };
+  } catch (e) {
+    return { name: `judge sees images (${spec})`, ok: false, detail: String(e.message ?? e).slice(0, 200), ms: Date.now() - t0, fatal: true };
+  } finally {
+    try {
+      fs5.rmSync(file, { force: true });
+    } catch {
+    }
+  }
+}
+async function doctor(cwd) {
+  const cfg = Object.fromEntries(effectiveConfig(cwd).map((c) => [c.key, c.value]));
+  const models = cfg.models ?? {};
+  const [serve, tests, vision] = await Promise.all([
+    cfg.serve ? serveCheck(cwd, String(cfg.serve)) : Promise.resolve({ name: "serve", ok: false, detail: "not set \u2014 visual loops that screenshot need it, and `run it` needs it", ms: 0, fatal: false }),
+    cfg.check ? checkCheck(cwd, String(cfg.check)) : Promise.resolve({ name: "check", ok: false, detail: "not set \u2014 attempts are judged without tests passing", ms: 0, fatal: false }),
+    models.judge ? visionCheck(cwd, String(models.judge)) : Promise.resolve({ name: "judge model", ok: false, detail: "not set \u2014 falls back to whatever model the session is on", ms: 0, fatal: true })
+  ]);
+  const checks = [serve, tests, vision];
+  for (const role of ["safe", "bold"]) {
+    const spec = models[role];
+    checks.push(spec ? { name: `${role} model`, ok: true, detail: String(spec), ms: 0 } : { name: `${role} model`, ok: false, detail: "not set \u2014 falls back to the session's model", ms: 0 });
+  }
+  const fatal = checks.filter((c) => c.fatal && !c.ok).length;
+  return { checks, verdict: fatal ? "will-fail" : checks.every((c) => c.ok) ? "ready" : "incomplete" };
+}
+
+// server/workspaces.ts
+import fs6 from "node:fs";
+import path6 from "node:path";
+import { execFileSync } from "node:child_process";
+var slug = (p) => path6.basename(p).replace(/[^a-z0-9._-]+/gi, "-").toLowerCase() || "repo";
+var Workspaces = class {
+  /** Where workspaces.json and the per-repo session dirs live. */
+  root;
+  file;
+  data;
+  byId = /* @__PURE__ */ new Map();
+  chatMap;
+  constructor({ root, cwd }) {
+    this.root = root;
+    this.file = path6.join(root, "workspaces.json");
+    fs6.mkdirSync(root, { recursive: true });
+    let data = { workspaces: [], chats: {} };
+    if (fs6.existsSync(this.file)) {
+      try {
+        data = JSON.parse(fs6.readFileSync(this.file, "utf8"));
+      } catch {
+        try {
+          fs6.renameSync(this.file, `${this.file}.corrupt-${Date.now()}`);
+        } catch {
+        }
+        console.error(`[workspaces] could not read ${this.file}; kept a copy and rebuilding from sessions`);
+      }
+    }
+    this.data = { workspaces: data.workspaces ?? [], chats: data.chats ?? {}, default: data.default };
+    this.chatMap = new Map(Object.entries(this.data.chats));
+    const first = this.add(cwd, { persist: false });
+    this.restore();
+    if (!this.data.default || !this.byId.has(this.data.default)) this.data.default = first.id;
+    this.save();
+  }
+  save() {
+    this.data.chats = Object.fromEntries(this.chatMap);
+    try {
+      const tmp = `${this.file}.tmp`;
+      fs6.writeFileSync(tmp, JSON.stringify(this.data, null, 2) + "\n");
+      fs6.renameSync(tmp, this.file);
+    } catch {
+    }
+  }
+  get defaultId() {
+    return this.data.default ?? [...this.byId.keys()][0] ?? "";
+  }
+  list() {
+    return [...this.byId.values()];
+  }
+  get(id) {
+    return this.byId.get(id ?? "") ?? this.byId.get(this.defaultId) ?? null;
+  }
+  /** Add (or re-find) a repo. `persist: false` is used for the startup cwd. */
+  add(dir, { persist = true } = {}) {
+    const abs = path6.resolve(dir);
+    const existing = [...this.byId.values()].find((w) => w.path === abs);
+    if (existing) return existing;
+    if (!fs6.existsSync(abs) || !fs6.statSync(abs).isDirectory()) throw new Error(`${abs} is not a directory`);
+    const st = fs6.statSync(abs);
+    if (!st.isDirectory()) throw new Error(`${abs} is not a directory`);
+    let id = slug(abs);
+    for (let i = 2; this.byId.has(id); i++) id = `${slug(abs)}-${i}`;
+    const legacy = path6.join(abs, ".pi", "loops-ui", "sessions");
+    const sessionDir = fs6.existsSync(legacy) ? legacy : path6.join(this.root, "workspaces", id, "sessions");
+    const ws = { id, path: abs, sessionDir, title: path6.basename(abs) || abs };
+    fs6.mkdirSync(ws.sessionDir, { recursive: true });
+    this.byId.set(id, ws);
+    if (persist) {
+      this.data.workspaces = [...this.data.workspaces.filter((w) => w.path !== abs), { id, path: abs }];
+      this.save();
+    }
+    return ws;
+  }
+  /** Register the persisted workspaces (their paths may have been deleted since), then rebuild from Pi sessions. */
+  restore() {
+    for (const w of this.data.workspaces) {
+      try {
+        this.add(w.path);
+      } catch {
+      }
+    }
+    this.recoverSessions();
+    this.save();
+  }
+  /**
+   * Chat -> repo is recoverable from Pi itself: each session header carries `cwd`, and the session dir names the
+   * workspace. This runs on startup, so a lost or stale `workspaces.json` is a cache miss, not lost history.
+   */
+  recoverSessions() {
+    const root = path6.join(this.root, "workspaces");
+    let ids = [];
+    try {
+      ids = fs6.readdirSync(root);
+    } catch {
+      return;
+    }
+    for (const id of ids) {
+      const dir = path6.join(root, id, "sessions");
+      let files = [];
+      try {
+        files = fs6.readdirSync(dir).filter((f) => f.endsWith(".jsonl"));
+      } catch {
+        continue;
+      }
+      let cwd = null;
+      for (const f of files) {
+        try {
+          const head = JSON.parse(fs6.readFileSync(path6.join(dir, f), "utf8").split("\n")[0]);
+          if (typeof head?.cwd === "string" && head.cwd) {
+            cwd = head.cwd;
+            break;
+          }
+        } catch {
+        }
+      }
+      let ws = this.byId.get(id) ?? null;
+      if (!ws && cwd) {
+        try {
+          ws = this.add(cwd);
+          if (ws.id !== id) ws.sessionDir = dir;
+        } catch {
+        }
+      }
+      if (!ws) continue;
+      for (const f of files) {
+        const chat = f.replace(/\.jsonl$/, "").replace(/^.*_/, "");
+        if (/^chat-/.test(chat) && !this.chatMap.has(chat)) this.chatMap.set(chat, ws.id);
+      }
+    }
+  }
+  remove(id) {
+    if (id === this.defaultId) throw new Error("cannot remove the workspace this app was started in");
+    this.byId.delete(id);
+    this.data.workspaces = this.data.workspaces.filter((w) => w.id !== id);
+    for (const [chat, ws] of this.chatMap) if (ws === id) this.chatMap.delete(chat);
+    this.save();
+  }
+  /** Which workspace a chat belongs to. Unknown ids fall back to the default (older chats predate the registry). */
+  ofChat(chat) {
+    return this.get(this.chatMap.get(chat)) ?? this.get();
+  }
+  bindChat(chat, ws) {
+    if (this.byId.has(ws)) {
+      this.chatMap.set(chat, ws);
+      this.save();
+    }
+  }
+  unbindChat(chat) {
+    if (this.chatMap.delete(chat)) this.save();
+  }
+  /** A repo is loopable when git can name a commit in it; that is what the sidebar shows. */
+  static loopable(dir) {
+    try {
+      execFileSync("git", ["rev-parse", "HEAD"], { cwd: dir, stdio: "pipe" });
+      return true;
+    } catch {
+      return false;
+    }
+  }
+};
+
+// server/index.ts
+var HERE = path7.dirname(fileURLToPath(import.meta.url));
+var APP_ROOT = path7.resolve(HERE, "..");
+var arg = (name, fallback) => {
+  const i = process.argv.indexOf(`--${name}`);
+  return i >= 0 ? process.argv[i + 1] : process.env[`LOOPS_UI_${name.toUpperCase().replace(/-/g, "_")}`] ?? fallback;
+};
+var PORT = Number(arg("port", "8001"));
+var HOST = arg("host", "127.0.0.1");
+var LOOPBACK = ["127.0.0.1", "localhost", "::1"].includes(HOST);
+var CWD = path7.resolve(arg("cwd", process.cwd()));
+var DEV = process.argv.includes("--dev") || process.env.NODE_ENV === "development";
+var VITE = arg("vite", "http://localhost:5173");
+var PI = arg("pi", "pi");
+var DATA = path7.resolve(arg("data", process.env.LOOPS_UI_DATA ?? path7.join(process.env.HOME ?? process.cwd(), ".pi", "loops-ui")));
+var MODEL = arg("model", void 0) || null;
+var EXTENSIONS = (arg("extensions", path7.resolve(APP_ROOT, "../pi-loops/extensions/loop.ts")) ?? "").split(",").filter(Boolean);
+function prerequisites() {
+  const out = [];
+  const onPath = PI.includes("/") || /^[A-Za-z]:\\/.test(PI) ? fs7.existsSync(PI) : (() => {
+    try {
+      execFileSync2(process.platform === "win32" ? "where" : "which", [PI], { stdio: ["ignore", "pipe", "ignore"] });
+      return true;
+    } catch {
+      return false;
+    }
+  })();
+  if (!onPath) out.push({ name: "pi", detail: `\`${PI}\` is not on PATH`, fix: "install Pi, or pass --pi <path to the pi binary>" });
+  for (const e of EXTENSIONS) {
+    if (!fs7.existsSync(e)) out.push({ name: "extension", detail: `${e} does not exist`, fix: "pi install npm:@computesdk/pi-loops, or pass --extensions <path to extensions/loop.ts>" });
+  }
+  return out;
+}
+var PROBLEMS = prerequisites();
+fs7.mkdirSync(DATA, { recursive: true });
+var TOKEN = (() => {
+  const explicit = arg("token", void 0);
+  const file = path7.join(DATA, "token");
+  const stored = (() => {
+    try {
+      return fs7.readFileSync(file, "utf8").trim() || null;
+    } catch {
+      return null;
+    }
+  })();
+  if (explicit) {
+    if (!LOOPBACK) {
+      try {
+        fs7.writeFileSync(file, explicit + "\n", { mode: 384 });
+      } catch {
+      }
+    }
+    return explicit;
+  }
+  if (stored) return stored;
+  if (LOOPBACK) return null;
+  const made = randomBytes(24).toString("base64url");
+  fs7.writeFileSync(file, made + "\n", { mode: 384 });
+  return made;
+})();
+if (!LOOPBACK && !TOKEN) {
+  console.error(`refusing to listen on ${HOST} without a token: this UI drives an agent that has bash. Pass --token <secret> (or let it generate one in ${DATA}/token).`);
+  process.exit(2);
+}
+var workspaces = new Workspaces({ root: DATA, cwd: CWD });
+var manager = new ChatManager({
+  piCommand: PI,
+  args: EXTENSIONS.flatMap((e) => ["-e", e]),
+  model: MODEL,
+  // a chat's repo comes from the registry: the browser never hands us a path
+  bind: (chat) => {
+    const ws = workspaces.ofChat(chat);
+    return { cwd: ws.path, sessionDir: ws.sessionDir };
+  }
+});
+var wsOf = (chat) => chat ? workspaces.ofChat(chat) : workspaces.get();
+var wsOfRun = (run3) => {
+  const byIndex = workspaces.list().find((w) => fs7.existsSync(path7.join(w.path, STATE_DIR, `${run3}.json`)));
+  if (byIndex) return byIndex;
+  const chat = manager.findRun(run3);
+  return chat ? workspaces.ofChat(chat.id) : workspaces.get();
+};
+var chatsOf = (wsId) => wsId ? manager.list(workspaces.get(wsId)) : workspaces.list().flatMap((w) => manager.list(w));
+var withLive = (state) => {
+  for (const run3 of state.runs ?? []) {
+    const url = liveUrl(run3.id);
+    if (url && run3.best) run3.best.live = url;
+  }
+  return state;
+};
+var streams = /* @__PURE__ */ new Set();
+var snapshotOf = (chat, wsId) => withLive({ ...chat.snapshot(), chats: chatsOf(wsId), workspaces: workspaces.list(), ws: wsId, proposals });
+manager.onChange((chat) => {
+  const space = workspaces.ofChat(chat.id);
+  const state = snapshotOf(chat, space.id);
+  for (const s of streams) if (s.chat === chat.id) s.send("state", state, chat.entryCursor);
+});
+var watches = /* @__PURE__ */ new Map();
+var proposals = [];
+var watchOf = (wsId) => {
+  const ws = workspaces.get(wsId);
+  let w = watches.get(ws.id);
+  if (!w) {
+    const read = () => {
+      try {
+        return JSON.parse(fs7.readFileSync(path7.join(ws.path, ".pi", "loops.json"), "utf8"));
+      } catch {
+        return {};
+      }
+    };
+    w = { cwd: ws.path, accepted: read() };
+    watches.set(ws.id, w);
+    try {
+      fs7.watch(path7.join(ws.path, ".pi"), (_e, name) => {
+        if (name && name !== "loops.json") return;
+        clearTimeout(watchTimers.get(ws.id));
+        watchTimers.set(ws.id, setTimeout(() => checkConfig(ws.id), 120));
+      });
+    } catch {
+    }
+  }
+  return w;
+};
+var watchTimers = /* @__PURE__ */ new Map();
+function notifyProposals() {
+  const payload = JSON.stringify({ type: "proposals", proposals });
+  for (const s of streams) {
+    try {
+      s.send("proposals", proposals);
+    } catch {
+    }
+  }
+}
+function checkConfig(wsId) {
+  const w = watchOf(wsId);
+  const CONFIG = path7.join(w.cwd, ".pi", "loops.json");
+  const raw2 = (() => {
+    try {
+      return fs7.readFileSync(CONFIG, "utf8");
+    } catch {
+      return "";
+    }
+  })();
+  if (isSelfWriting() || isSelfWrite(raw2)) {
+    w.accepted = raw2.trim() ? JSON.parse(raw2) : {};
+    return;
+  }
+  const next = raw2.trim() ? JSON.parse(raw2) : {};
+  const changes = diffConfig(w.accepted, next);
+  if (!changes.length) {
+    w.accepted = next;
+    return;
+  }
+  restoreConfig(w.cwd, w.accepted);
+  proposals.push({ id: `p-${Date.now().toString(36)}`, at: Date.now(), file: `${w.cwd}/.pi/loops.json`, changes, before: w.accepted, after: next, ws: wsId });
+  console.log(`[config] proposed: ${changes.map((c) => `${c.key}: ${c.from} \u2192 ${c.to}`).join("; ")} (held; file restored)`);
+  notifyProposals();
+}
+var inside = (root, p) => {
+  const abs = path7.resolve(root, p);
+  return abs === root || abs.startsWith(root + path7.sep) ? abs : null;
+};
+var stateOf = (run3) => manager.findRun(run3)?.stateFor(run3) ?? readState(wsOfRun(run3).path, run3);
+var app = new Hono3();
+var ALLOWED_ORIGINS = (arg("allow-origin", "") ?? "").split(",").map((o) => o.trim()).filter(Boolean);
+var originAllowed = (origin) => !ALLOWED_ORIGINS.length || ALLOWED_ORIGINS.includes(origin) || ALLOWED_ORIGINS.includes("*");
+app.use("*", async (c, next) => {
+  const origin = c.req.header("origin");
+  if (origin && originAllowed(origin)) {
+    c.header("access-control-allow-origin", origin);
+    c.header("access-control-allow-headers", "authorization, content-type, last-event-id");
+    c.header("access-control-allow-methods", "GET, POST, OPTIONS");
+    c.header("vary", "origin");
+  }
+  if (c.req.method === "OPTIONS") return c.body(null, 204);
+  await next();
+});
+app.use("/api/*", async (c, next) => {
+  if (!TOKEN || c.req.path === "/api/health") return next();
+  const given = c.req.header("authorization")?.replace(/^Bearer\s+/i, "") ?? c.req.query("token") ?? "";
+  if (given !== TOKEN) return c.json({ error: "unauthorized" }, 401);
+  await next();
+});
+app.use("/api/v1/*", async (c, next) => {
+  if (!TOKEN) return next();
+  const given = c.req.header("authorization")?.replace(/^Bearer\s+/i, "") ?? c.req.query("token") ?? "";
+  if (given !== TOKEN) return c.json({ error: "unauthorized" }, 401);
+  await next();
+});
+var api = new Hono3();
+api.get("/health", (c) => c.json({ ok: PROBLEMS.length === 0, problems: PROBLEMS, cwd: CWD, data: DATA, pi: PI, extensions: EXTENSIONS, workspaces: workspaces.list() }));
+api.get("/chats", (c) => c.json(chatsOf(c.req.query("ws"))));
+api.get("/chats/:id/events", async (c) => {
+  const id = c.req.param("id");
+  const chat = await manager.open(id);
+  const space = workspaces.ofChat(id);
+  return streamSSE(c, async (stream2) => {
+    const send = (event, data, cursor) => stream2.writeSSE({ event, data: JSON.stringify(data), ...cursor ? { id: cursor } : {} }).catch(() => {
+    });
+    await send("state", snapshotOf(chat, space.id), chat.entryCursor);
+    const entry = { chat: id, send };
+    streams.add(entry);
+    const ping = setInterval(() => {
+      void stream2.writeSSE({ event: "ping", data: "{}" }).catch(() => {
+      });
+    }, 2e4);
+    await new Promise((resolve) => stream2.onAbort(resolve));
+    clearInterval(ping);
+    streams.delete(entry);
+  });
+});
+api.get("/state", async (c) => {
+  const id = c.req.query("chat");
+  if (!id) return c.json({ error: "chat required" }, 400);
+  const chat = await manager.open(id);
+  const ws = workspaces.ofChat(id);
+  return c.json(withLive({ ...chat.snapshot(), chats: chatsOf(ws.id), workspaces: workspaces.list(), ws: ws.id, proposals }));
+});
+api.post("/chat", async (c) => {
+  const body = await c.req.json().catch(() => ({}));
+  const ws = workspaces.get(body.ws) ?? workspaces.get();
+  const id = String(body.id ?? `chat-${Date.now().toString(36)}`).replace(/[^a-zA-Z0-9._-]/g, "").slice(0, 60);
+  workspaces.bindChat(id, ws.id);
+  watchOf(ws.id);
+  await manager.open(id);
+  return c.json({ chat: id, ws: ws.id, chats: chatsOf(ws.id) });
+});
+api.post("/chat/delete", async (c) => {
+  const { chat: id } = await c.req.json();
+  const chat = manager.get(String(id));
+  const file = chat?.sessionFile ?? null;
+  await manager.close(String(id));
+  workspaces.unbindChat(String(id));
+  if (file && fs7.existsSync(file)) {
+    try {
+      fs7.rmSync(file);
+    } catch {
+    }
+  }
+  return c.json({ ok: true });
+});
+api.get("/workspaces", (c) => c.json(workspaces.list()));
+api.post("/workspaces", async (c) => {
+  const body = await c.req.json().catch(() => ({}));
+  try {
+    const dir = path7.resolve(String(body.path ?? "").replace(/^~(?=\/|$)/, process.env.HOME ?? "~"));
+    if (!dir || dir === "/") throw new Error("a path is required");
+    if (!fs7.existsSync(dir) || !fs7.statSync(dir).isDirectory()) throw new Error(`${dir} is not a directory`);
+    const ws = workspaces.add(dir);
+    watchOf(ws.id);
+    return c.json({ ok: true, workspace: ws, loopable: Workspaces.loopable(ws.path) });
+  } catch (e) {
+    return c.json({ ok: false, error: String(e.message ?? e) }, 400);
+  }
+});
+api.post("/workspaces/remove", async (c) => {
+  const { id } = await c.req.json();
+  try {
+    workspaces.remove(String(id));
+    return c.json({ ok: true });
+  } catch (e) {
+    return c.json({ ok: false, error: String(e.message ?? e) }, 400);
+  }
+});
+api.post("/prompt", async (c) => {
+  const { chat: id, text, behavior } = await c.req.json();
+  const chat = await manager.open(String(id));
+  const disposition = await chat.prompt(String(text), behavior === "steer" || behavior === "followUp" ? behavior : void 0);
+  return c.json({ disposition });
+});
+api.post("/rename", async (c) => {
+  const { chat: id, name } = await c.req.json();
+  const chat = await manager.open(String(id));
+  await chat.rename(String(name ?? ""));
+  return c.json({ ok: true, title: chat.title });
+});
+api.post("/abort", async (c) => {
+  const { chat: id } = await c.req.json();
+  const chat = await manager.open(String(id));
+  await chat.abort();
+  return c.json({ ok: true });
+});
+api.post("/ui", async (c) => {
+  const { chat: id, id: dialogId, response } = await c.req.json();
+  const chat = await manager.open(String(id));
+  await chat.answerUi(String(dialogId), response ?? {});
+  return c.json({ ok: true });
+});
+api.post("/answer", async (c) => {
+  const { chat: id, question, choice } = await c.req.json();
+  const chat = await manager.open(String(id));
+  await chat.prompt(`/loop answer ${String(question)} ${String(choice)}`);
+  return c.json({ ok: true });
+});
+api.post("/steer", async (c) => {
+  const { chat: id, run: run3, action, rule, attempt, text } = await c.req.json();
+  const chat = await manager.open(String(id));
+  const slash = (cmd) => chat.prompt(cmd);
+  switch (String(action)) {
+    case "pick":
+    case "take":
+      return c.json({ ok: true, sent: await slash(`/loop take ${attempt} ${run3}`) });
+    case "apply":
+      return c.json({ ok: true, sent: await slash(`/loop apply`) });
+    case "stop":
+      return c.json({ ok: true, sent: await slash(`/loop stop`) });
+    case "clean":
+      return c.json({ ok: true, sent: await slash(`/loop clean ${run3}`) });
+    case "rule":
+      return c.json({ ok: true, sent: await slash(`/loop rule ${run3} ${rule}`) });
+    case "talk":
+      return c.json({ ok: true, sent: await slash(`/loop talk ${attempt} ${text}`) });
+    // everything else is a decision only the agent can make (another round, a different direction)
+    case "more":
+      return c.json({ ok: true, sent: await slash(`Continue loop ${run3} with ${Number(text) || 2} more rounds. Check loop_status first, then call loop({ from: "${run3}", rounds: ${Number(text) || 2} }).`) });
+    default:
+      return c.json({ error: `unknown action ${action}` }, 400);
+  }
+});
+api.get("/ui", async (c) => {
+  const id = c.req.query("chat");
+  if (!id) return c.json([]);
+  const chat = await manager.open(id);
+  return c.json(chat.snapshot().dialogs ?? []);
+});
+api.get("/session", async (c) => {
+  const run3 = c.req.query("run");
+  const name = c.req.query("name");
+  if (!run3 || !name) return c.json([]);
+  const state = stateOf(run3);
+  const file = state?.rounds?.flatMap((r) => r.attempts).find((a) => a.label === name)?.session ?? state?.rounds?.flatMap((r) => r.attempts).find((a) => a.label?.toLowerCase() === name.toLowerCase())?.session;
+  if (!file || !fs7.existsSync(file)) return c.json([]);
+  const chat = await manager.open(c.req.query("chat") ?? manager.list()[0]?.id ?? "");
+  return c.json(chat.sessionItems(file));
+});
+api.post("/talk", async (c) => {
+  const { chat: id, run: run3, name, text } = await c.req.json();
+  const chat = await manager.open(String(id));
+  await chat.prompt(`/loop talk ${name} ${String(text)}`);
+  return c.json({ ok: true });
+});
+api.get("/talk", (c) => c.json([]));
+api.get("/shot", (c) => {
+  const run3 = c.req.query("run") ?? "";
+  const attempt = c.req.query("attempt") ?? "";
+  const file = c.req.query("f") ?? "";
+  const state = stateOf(run3);
+  const repo = wsOfRun(run3).path;
+  if (file.startsWith(STATE_DIR)) {
+    const abs2 = inside(repo, file);
+    if (!abs2 || !fs7.existsSync(abs2)) return c.notFound();
+    return new Response(fs7.readFileSync(abs2), { headers: { "content-type": abs2.endsWith(".jpg") || abs2.endsWith(".jpeg") ? "image/jpeg" : "image/png", "cache-control": "no-cache" } });
+  }
+  const dir = attempt === "CURRENT" ? state?.best?.dir ?? null : state?.rounds?.flatMap((r) => r.attempts).find((a) => a.label === attempt || a.label?.toLowerCase() === attempt.toLowerCase())?.dir;
+  if (!dir) return c.notFound();
+  const abs = inside(repo, path7.join(dir, file));
+  if (!abs || !fs7.existsSync(abs)) return c.notFound();
+  return new Response(fs7.readFileSync(abs), { headers: { "content-type": abs.endsWith(".jpg") || abs.endsWith(".jpeg") ? "image/jpeg" : "image/png", "cache-control": "no-cache" } });
+});
+api.get("/sheet", (c) => {
+  const file = c.req.query("f") ?? "";
+  const ws = workspaces.list().find((w) => fs7.existsSync(path7.join(w.path, file))) ?? workspaces.get();
+  const abs = inside(ws.path, file);
+  if (!abs || !abs.includes(STATE_DIR) || !fs7.existsSync(abs)) return c.notFound();
+  return new Response(fs7.readFileSync(abs), { headers: { "content-type": "image/png", "cache-control": "no-cache" } });
+});
+api.get("/diff", async (c) => {
+  const run3 = c.req.query("run") ?? "";
+  const name = c.req.query("name") ?? "";
+  const state = stateOf(run3);
+  if (!state) return c.text("");
+  const attempts = (state.rounds ?? []).flatMap((r) => r.attempts);
+  const attempt = attempts.find((a) => a.label === name || a.label?.toLowerCase() === name.toLowerCase() || a.style === name.toLowerCase());
+  const to = attempt?.commit ?? state.best?.commit;
+  const from = state.baseCommit;
+  if (!to || !from) return c.text("");
+  return c.text(await new Promise((resolve) => {
+    execFile("git", ["diff", "--stat", `${from}..${to}`], { cwd: wsOfRun(run3).path, maxBuffer: 1 << 26 }, (_e, stat) => {
+      execFile("git", ["diff", `${from}..${to}`], { cwd: wsOfRun(run3).path, maxBuffer: 1 << 26 }, (_e2, diff) => resolve(`${stat}
+${diff}`.slice(0, 4e5)));
+    });
+  }));
+});
+api.post("/live", async (c) => {
+  const { run: run3 } = await c.req.json();
+  try {
+    const cwd = wsOfRun(String(run3)).path;
+    const { url, reused } = await startLive({ cwd, run: String(run3), state: stateOf(String(run3)) });
+    return c.json({ ok: true, url, reused: !!reused });
+  } catch (e) {
+    return c.json({ ok: false, error: String(e.message ?? e) }, 400);
+  }
+});
+api.post("/live/stop", async (c) => {
+  const { run: run3 } = await c.req.json();
+  return c.json({ ok: true, stopped: stopLive(String(run3)) });
+});
+api.get("/proposals", (c) => c.json(proposals));
+api.post("/proposals/:id/apply", (c) => {
+  const p = proposals.find((x) => x.id === c.req.param("id"));
+  if (!p) return c.json({ ok: false, error: "no such proposal" }, 404);
+  const cwd = p.ws ? workspaces.get(p.ws).path : CWD;
+  acceptConfig(cwd, p.after);
+  const w = p.ws ? watches.get(p.ws) : null;
+  if (w) w.accepted = p.after;
+  proposals.splice(proposals.indexOf(p), 1);
+  notifyProposals();
+  return c.json({ ok: true });
+});
+api.post("/proposals/:id/keep", (c) => {
+  const i = proposals.findIndex((x) => x.id === c.req.param("id"));
+  if (i < 0) return c.json({ ok: false, error: "no such proposal" }, 404);
+  proposals.splice(i, 1);
+  notifyProposals();
+  return c.json({ ok: true });
+});
+api.get("/config", (c) => {
+  const ws = wsOf(c.req.query("chat"));
+  watchOf(ws.id);
+  return c.json({ cwd: ws.path, ws: ws.id, keys: effectiveConfig(ws.path) });
+});
+api.post("/config", async (c) => {
+  const { key, value, chat } = await c.req.json();
+  const ws = wsOf(chat);
+  try {
+    writeSetting(ws.path, String(key), value);
+    const w = watchOf(ws.id);
+    try {
+      w.accepted = JSON.parse(fs7.readFileSync(path7.join(ws.path, ".pi", "loops.json"), "utf8"));
+    } catch {
+    }
+    return c.json({ ok: true });
+  } catch (e) {
+    return c.json({ ok: false, error: String(e.message ?? e) }, 400);
+  }
+});
+api.post("/doctor", async (c) => {
+  const body = await c.req.json().catch(() => ({}));
+  return c.json(await doctor(wsOf(body.chat).path));
+});
+api.get("/size", async (c) => {
+  const run3 = c.req.query("run") ?? "";
+  const state = stateOf(run3);
+  if (!state) return c.json({ bytes: 0, dirs: 0 });
+  const dirs = (state.rounds ?? []).flatMap((r) => r.attempts).map((a) => a.dir).filter(Boolean);
+  const bytes = await new Promise((resolve) => execFile("du", ["-sk", ...dirs], { cwd: wsOfRun(run3).path }, (_e, out) => resolve(Number(String(out ?? "").split("\n").map((l) => Number(l.split(/\s+/)[0]) || 0).reduce((a, b) => a + b, 0)) * 1024)));
+  return c.json({ bytes, dirs: dirs.length });
+});
+api.get("/files", (c) => {
+  const run3 = c.req.query("run") ?? "";
+  const state = stateOf(run3);
+  if (!state) return c.json({ files: [] });
+  try {
+    const out = execFileSync2("git", ["diff", "--name-only", `${state.baseCommit}..${state.best?.commit ?? state.baseCommit}`], { cwd: wsOfRun(run3).path, encoding: "utf8", maxBuffer: 1 << 26 });
+    return c.json({ files: out.split("\n").filter(Boolean) });
+  } catch {
+    return c.json({ files: [] });
+  }
+});
+api.get("/chats/:id/runs", async (c) => {
+  const chat = await manager.open(c.req.param("id"));
+  return c.json(withLive(chat.snapshot()).runs);
+});
+api.get("/meta", (c) => c.json({
+  name: "pi-loops-ui",
+  api: 1,
+  version: process.env.npm_package_version ?? "0.1.0",
+  cwd: CWD,
+  data: DATA,
+  host: HOST,
+  token: !!TOKEN,
+  workspaces: workspaces.list()
+}));
+app.route("/api", api);
+app.route("/api/v1", api);
+var DIST = path7.join(APP_ROOT, "dist");
+app.get("*", async (c) => {
+  const url = c.req.path;
+  if (DEV) {
+    const res = await fetch(VITE + url).catch(() => null);
+    if (!res) return c.text("vite dev server is not up yet", 503);
+    return new Response(res.body, { status: res.status, headers: { "content-type": res.headers.get("content-type") ?? "text/html" } });
+  }
+  const abs = inside(DIST, url === "/" ? "index.html" : url.replace(/^\//, ""));
+  if (abs && fs7.existsSync(abs) && fs7.statSync(abs).isFile()) {
+    const ext = path7.extname(abs);
+    const type = ext === ".js" ? "text/javascript" : ext === ".css" ? "text/css" : ext === ".woff2" ? "font/woff2" : ext === ".svg" ? "image/svg+xml" : ext === ".png" ? "image/png" : "text/html";
+    return new Response(fs7.readFileSync(abs), { headers: { "content-type": type } });
+  }
+  const index = path7.join(DIST, "index.html");
+  if (!fs7.existsSync(index)) return c.text("run `npm run build` first", 500);
+  return new Response(fs7.readFileSync(index), { headers: { "content-type": "text/html" } });
+});
+var server = http.createServer(getRequestListener(app.fetch));
+setInterval(() => {
+  for (const chat of manager.openChats()) void chat.settleIfIdle();
+}, 4e3);
+function openBrowser(url) {
+  if (process.argv.includes("--no-open") || process.env.LOOPS_UI_OPEN === "0") return;
+  const [cmd, args] = process.platform === "darwin" ? ["open", [url]] : process.platform === "win32" ? ["cmd", ["/c", "start", "", url]] : ["xdg-open", [url]];
+  try {
+    const p = spawn5(cmd, args, { stdio: "ignore", detached: true });
+    p.on("error", () => {
+    });
+    p.unref();
+  } catch {
+  }
+}
+server.listen(PORT, HOST, () => {
+  const reach = HOST === "0.0.0.0" ? "127.0.0.1" : HOST;
+  const shown = reach.includes(":") ? `[${reach}]` : reach;
+  const base = `http://${shown}:${PORT}`;
+  const url = TOKEN ? `${base}/?server=${encodeURIComponent(base)}&token=${encodeURIComponent(TOKEN)}` : base;
+  console.log(`
+  open  ${url}`);
+  console.log(`  ${HOST === "0.0.0.0" ? "all interfaces" : "loopback only"}${TOKEN ? " \xB7 token required" : ""}
+`);
+  console.log(`  data       ${DATA}`);
+  console.log(`  repos      ${workspaces.list().map((w) => w.path).join(", ") || "(none \u2014 add one in the app)"}`);
+  console.log(`  extensions ${EXTENSIONS.join(", ") || "(none)"}`);
+  if (PROBLEMS.length) {
+    console.log(`
+  !! a loop cannot run here yet:`);
+    for (const p of PROBLEMS) console.log(`     ${p.name.padEnd(10)} ${p.detail}
+                ${p.fix}`);
+    console.log(`     the app still serves; \`loops doctor\` checks the rest (serve, check, judge).`);
+  }
+  console.log();
+  openBrowser(url);
+});
+var shutdown = async () => {
+  stopAllLive();
+  await manager.closeAll();
+  server.close(() => process.exit(0));
+  setTimeout(() => process.exit(0), 1500);
+};
+process.on("SIGINT", shutdown);
+process.on("SIGTERM", shutdown);