weifuwu 0.17.13 → 0.17.17

package/dist/index.js

@@ -571,12 +571,15 @@ import { pathToFileURL } from "node:url";
 import { createHash } from "node:crypto";
 import vm from "node:vm";
 import { createRequire } from "node:module";
+import { AsyncLocalStorage } from "node:async_hooks";
 import chokidar from "chokidar";
 
 // tsx-context.ts
 import { useSyncExternalStore, createContext } from "react";
 var fallbackT = (key, _params, fallback) => fallback ?? key;
-var _ctx = { params: {}, query: {}, parsed: {}, prefs: {}, env: {}, t: fallbackT, user: {} };
+var DEFAULT_CTX = { params: {}, query: {}, parsed: {}, prefs: {}, env: {}, t: fallbackT, user: {} };
+var _ctx = DEFAULT_CTX;
+var _snapshot = { params: _ctx.params, query: _ctx.query, user: _ctx.user, parsed: _ctx.parsed, prefs: _ctx.prefs, env: _ctx.env };
 var _listeners = /* @__PURE__ */ new Set();
 var subscribe = (cb) => {
   _listeners.add(cb);
@@ -584,16 +587,26 @@ var subscribe = (cb) => {
     _listeners.delete(cb);
   };
 };
-var getSnapshot = () => ({ params: _ctx.params, query: _ctx.query, user: _ctx.user, parsed: _ctx.parsed, prefs: _ctx.prefs, env: _ctx.env });
+var getSnapshot = () => _snapshot;
 var getServerSnapshot = getSnapshot;
+var _alsGetStore = null;
+function __registerAls(getStore) {
+  _alsGetStore = getStore;
+}
 function setCtx(value) {
   _ctx = { ..._ctx, ...value };
+  _snapshot = { params: _ctx.params, query: _ctx.query, user: _ctx.user, parsed: _ctx.parsed, prefs: _ctx.prefs, env: _ctx.env };
   _listeners.forEach((fn) => fn());
 }
+var _cachedT = null;
 function _buildT() {
+  if (_cachedT) return _cachedT;
   const messages2 = typeof window !== "undefined" ? window.__LOCALE_DATA__ : globalThis.__LOCALE_DATA__;
-  if (!messages2) return fallbackT;
-  return (key, params, fallback) => {
+  if (!messages2) {
+    _cachedT = fallbackT;
+    return fallbackT;
+  }
+  _cachedT = (key, params, fallback) => {
     const msg = key.split(".").reduce((o, k) => o?.[k], messages2);
     if (msg === void 0 || msg === null) return fallback ?? key;
     if (!params) return String(msg);
@@ -601,16 +614,27 @@ function _buildT() {
     for (const [k, v] of Object.entries(params)) result = result.replace(`{${k}}`, v);
     return result;
   };
+  return _cachedT;
+}
+function _readCtx() {
+  const alsStore = _alsGetStore?.();
+  const base = alsStore ?? _ctx;
+  const data = typeof window !== "undefined" ? window.__WEIFUWU_CTX : null;
+  const t = typeof base.t === "function" && base.t !== fallbackT ? base.t : _buildT();
+  return { ...base, ...data, t };
 }
 function useCtx() {
   useSyncExternalStore(subscribe, getSnapshot, getServerSnapshot);
-  const data = typeof window !== "undefined" ? window.__WEIFUWU_CTX : null;
-  const t = _ctx.t !== fallbackT ? _ctx.t : _buildT();
-  return { ..._ctx, ...data, t };
+  return _readCtx();
+}
+function getCtx() {
+  return _readCtx();
 }
-var TsxContext = createContext({ params: {}, query: {}, parsed: {}, prefs: {}, env: {}, t: fallbackT, user: {} });
+var TsxContext = createContext(DEFAULT_CTX);
 
 // tsx-instance.ts
+var als = new AsyncLocalStorage();
+__registerAls(() => als.getStore());
 var liveReloadClients = /* @__PURE__ */ new Set();
 function broadcastReload() {
   for (const ws of liveReloadClients) {
@@ -625,13 +649,13 @@ var isDev = process.env.NODE_ENV !== "production";
 var _tailwindPlugin = null;
 var _postcss = null;
 var _cjsRequire = createRequire(import.meta.url);
-var _vmCtx = vm.createContext(Object.create(globalThis));
 function loadSSRModule(code) {
+  const ctx = vm.createContext(Object.create(globalThis));
   const mod = { exports: {} };
-  _vmCtx.require = (name) => _cjsRequire(name);
-  _vmCtx.module = mod;
-  _vmCtx.exports = mod.exports;
-  new vm.Script(code).runInContext(_vmCtx);
+  ctx.require = (name) => _cjsRequire(name);
+  ctx.module = mod;
+  ctx.exports = mod.exports;
+  new vm.Script(code).runInContext(ctx);
   return mod.exports;
 }
 function id(s) {
@@ -794,6 +818,10 @@ var TsxInstance = class {
   clientBundleCache = /* @__PURE__ */ new Map();
   clientBuildParams = /* @__PURE__ */ new Map();
   clientRouteLog = /* @__PURE__ */ new Set();
+  // file watchers (dev mode, stored for cleanup)
+  watcher = null;
+  twWatcher = null;
+  debounceTimer = null;
   constructor(options) {
     this.uiDir = resolve2(options.dir);
     this.pagesDir = existsSync2(join(this.uiDir, "pages")) ? join(this.uiDir, "pages") : this.uiDir;
@@ -802,7 +830,7 @@ var TsxInstance = class {
   }
   async build() {
     const pages = scanPages(this.pagesDir);
-    if (pages.length === 0) return this.router;
+    if (pages.length === 0) return attachStop(this.router, this);
     const allFiles = /* @__PURE__ */ new Set();
     for (const p of pages) {
       if (p.entryPath) allFiles.add(p.entryPath);
@@ -892,28 +920,35 @@ var TsxInstance = class {
         const nfMod = this.pageModules.get(nfPath);
         if (!nfMod) return new Response("Not Found", { status: 404 });
         const NfComponent = nfMod.default;
-        setCtx({
+        const ctxValue = {
           params: ctx.params,
           query: ctx.query,
-          user: ctx.user,
-          parsed: ctx.parsed,
-          prefs: ctx.prefs,
-          t: ctx.t,
-          env: ctx.env
-        });
-        let element = createElement(NfComponent, { params: ctx.params, query: ctx.query });
-        for (let i = rootLayouts.length - 1; i >= 0; i--) {
-          const LMod = this.layoutModules.get(rootLayouts[i]);
-          if (!LMod) continue;
-          element = createElement(LMod.default, { children: element });
-        }
-        const stream = await renderToReadableStream(element);
-        return streamResponse(stream, {
-          ctx,
-          base,
-          compiledTailwindCss: this.compiledTailwindCss,
-          isDev,
-          status: 404
+          user: ctx.user ?? {},
+          parsed: ctx.parsed ?? {},
+          prefs: ctx.prefs ?? {},
+          t: ctx.t ?? ((key) => key),
+          env: ctx.env ?? {}
+        };
+        return als.run(ctxValue, async () => {
+          setCtx(ctxValue);
+          let element = createElement(
+            TsxContext.Provider,
+            { value: ctxValue },
+            createElement(NfComponent, { params: ctx.params, query: ctx.query })
+          );
+          for (let i = rootLayouts.length - 1; i >= 0; i--) {
+            const LMod = this.layoutModules.get(rootLayouts[i]);
+            if (!LMod) continue;
+            element = createElement(LMod.default, { children: element });
+          }
+          const stream = await renderToReadableStream(element);
+          return streamResponse(stream, {
+            ctx,
+            base,
+            compiledTailwindCss: this.compiledTailwindCss,
+            isDev,
+            status: 404
+          });
         });
       };
       this.router.all("/*", handler);
@@ -935,7 +970,17 @@ var TsxInstance = class {
       });
       this.startFileWatcher();
     }
-    return this.router;
+    return attachStop(this.router, this);
+  }
+  /**
+   * Clean up file watchers and pending timers. Call when shutting down
+   * to prevent resource leaks.
+   */
+  stop() {
+    this.watcher?.close();
+    this.twWatcher?.close();
+    if (this.debounceTimer) clearTimeout(this.debounceTimer);
+    this.debounceTimer = null;
   }
   // ── Tailwind CSS ──────────────────────────────────────────────────────────
   async compileTailwind() {
@@ -972,7 +1017,8 @@ ${src}`;
     }));
     if (isDev) {
       const inputFile = resolve2(this.uiDir, "app.css");
-      chokidar.watch(inputFile, { persistent: false }).on("change", async () => {
+      this.twWatcher = chokidar.watch(inputFile, { persistent: false });
+      this.twWatcher.on("change", async () => {
         this.compiledTailwindCss = "";
         await this.compileTailwind();
         broadcastReload();
@@ -1068,77 +1114,84 @@ ${src}`;
       const pageMod = this.pageModules.get(entryPath);
       if (!pageMod) return new Response("", { status: 500 });
       const Component = pageMod.default;
-      const loadMod = loadPath ? this.loadModules.get(loadPath) : void 0;
-      const loadFn = loadMod?.default;
-      const loadProps = loadFn ? await loadFn({ params: ctx.params, query: ctx.query }) : {};
-      const allProps = { ...loadProps, params: ctx.params, query: ctx.query };
-      setCtx({
+      const ctxValue = {
         params: ctx.params,
         query: ctx.query,
-        user: ctx.user,
-        parsed: ctx.parsed,
-        prefs: ctx.prefs,
-        t: ctx.t,
-        env: ctx.env
-      });
-      let element = createElement(
-        "div",
-        { id: "__weifuwu_root" },
-        createElement(Component, allProps)
-      );
-      if (layoutPaths.length === 0) {
-        element = createElement(
-          "html",
-          { lang: "en" },
+        user: ctx.user ?? {},
+        parsed: ctx.parsed ?? {},
+        prefs: ctx.prefs ?? {},
+        t: ctx.t ?? ((key) => key),
+        env: ctx.env ?? {}
+      };
+      return als.run(ctxValue, async () => {
+        setCtx(ctxValue);
+        const loadMod = loadPath ? this.loadModules.get(loadPath) : void 0;
+        const loadFn = loadMod?.default;
+        const loadProps = loadFn ? await loadFn({ params: ctx.params, query: ctx.query }) : {};
+        const allProps = { ...loadProps, params: ctx.params, query: ctx.query };
+        let element = createElement(
+          TsxContext.Provider,
+          { value: ctxValue },
           createElement(
-            "head",
-            null,
-            createElement("meta", { charSet: "utf-8" }),
-            createElement("meta", { name: "viewport", content: "width=device-width, initial-scale=1" }),
-            createElement("title", null, "weifuwu")
-          ),
-          createElement("body", null, element)
+            "div",
+            { id: "__weifuwu_root" },
+            createElement(Component, allProps)
+          )
         );
-      } else {
-        for (let i = layoutPaths.length - 1; i >= 0; i--) {
-          const lp = layoutPaths[i];
-          const LMod = this.layoutModules.get(lp);
-          if (!LMod) continue;
-          const Layout = LMod.default;
-          const isRoot = i === 0;
+        if (layoutPaths.length === 0) {
           element = createElement(
-            Layout,
-            isRoot ? { children: element, req } : { children: element }
+            "html",
+            { lang: "en" },
+            createElement(
+              "head",
+              null,
+              createElement("meta", { charSet: "utf-8" }),
+              createElement("meta", { name: "viewport", content: "width=device-width, initial-scale=1" }),
+              createElement("title", null, "weifuwu")
+            ),
+            createElement("body", null, element)
           );
+        } else {
+          for (let i = layoutPaths.length - 1; i >= 0; i--) {
+            const lp = layoutPaths[i];
+            const LMod = this.layoutModules.get(lp);
+            if (!LMod) continue;
+            const Layout = LMod.default;
+            const isRoot = i === 0;
+            element = createElement(
+              Layout,
+              isRoot ? { children: element, req } : { children: element }
+            );
+          }
         }
-      }
-      const bundle = await this.getOrBuildClientBundle(entryPath, layoutPaths, this.pagesDir);
-      const stream = await renderToReadableStream(element);
-      return streamResponse(stream, {
-        ctx,
-        base,
-        compiledTailwindCss: this.compiledTailwindCss,
-        isDev,
-        bundle,
-        allProps
+        const bundle = await this.getOrBuildClientBundle(entryPath, layoutPaths, this.pagesDir);
+        const stream = await renderToReadableStream(element);
+        return streamResponse(stream, {
+          ctx,
+          base,
+          compiledTailwindCss: this.compiledTailwindCss,
+          isDev,
+          bundle,
+          allProps
+        });
       });
     };
   }
   // ── dev file watcher ──────────────────────────────────────────────────────
   startFileWatcher() {
-    let timeout = null;
     const pending = /* @__PURE__ */ new Set();
-    chokidar.watch(this.uiDir, {
+    this.watcher = chokidar.watch(this.uiDir, {
       ignored: /(^|[/\\])\.(?!\.)|node_modules|[/\\]\.weifuwu[/\\]|[/\\]dist[/\\]/,
       persistent: false,
       ignoreInitial: true
-    }).on("all", async (event, filePath) => {
+    });
+    this.watcher.on("all", async (event, filePath) => {
       if (event !== "change" && event !== "add") return;
       if (!/\.tsx?$/.test(filePath)) return;
       pending.add(filePath);
-      if (timeout) clearTimeout(timeout);
-      timeout = setTimeout(async () => {
-        timeout = null;
+      if (this.debounceTimer) clearTimeout(this.debounceTimer);
+      this.debounceTimer = setTimeout(async () => {
+        this.debounceTimer = null;
         const files = [...pending];
         pending.clear();
         const exists = files.filter((f) => existsSync2(f));
@@ -1286,6 +1339,11 @@ ${src}`;
     }
   }
 };
+function attachStop(router, instance) {
+  ;
+  router.stop = () => instance.stop();
+  return router;
+}
 function streamResponse(reactStream, opts) {
   const decoder = new TextDecoder();
   const encoder2 = new TextEncoder();
@@ -1295,47 +1353,54 @@ function streamResponse(reactStream, opts) {
   let extractedHead = "";
   const output = new ReadableStream({
     async start(controller) {
-      const reader = reactStream.getReader();
-      async function push(chunk) {
-        buffer += decoder.decode(chunk, { stream: true });
-        if (!extractedHead) {
-          const m = buffer.match(/<template id="__wfw_head">([\s\S]*?)<\/template>/);
-          if (m) {
-            extractedHead = m[1];
-            buffer = buffer.replace(m[0], "");
+      try {
+        const reader = reactStream.getReader();
+        async function push(chunk) {
+          buffer += decoder.decode(chunk, { stream: true });
+          if (!extractedHead) {
+            const m = buffer.match(/<template id="__wfw_head">([\s\S]*?)<\/template>/);
+            if (m) {
+              extractedHead = m[1];
+              buffer = buffer.replace(m[0], "");
+            }
           }
-        }
-        if (!headFlushed) {
-          const idx = buffer.indexOf("</head>");
-          if (idx !== -1) {
-            const before = buffer.slice(0, idx);
-            let injection = "";
-            if (extractedHead) injection += "\n" + extractedHead;
-            injection += headPayload;
-            controller.enqueue(encoder2.encode(before + injection));
-            buffer = buffer.slice(idx);
-            headFlushed = true;
+          if (!headFlushed) {
+            const idx = buffer.indexOf("</head>");
+            if (idx !== -1) {
+              const before = buffer.slice(0, idx);
+              let injection = "";
+              if (extractedHead) injection += "\n" + extractedHead;
+              injection += headPayload;
+              controller.enqueue(encoder2.encode(before + injection));
+              buffer = buffer.slice(idx);
+              headFlushed = true;
+            }
+            return;
           }
-          return;
+          controller.enqueue(encoder2.encode(buffer));
+          buffer = "";
         }
-        controller.enqueue(encoder2.encode(buffer));
-        buffer = "";
-      }
-      while (true) {
-        const { done, value } = await reader.read();
-        if (done) break;
-        await push(value);
-      }
-      if (buffer) controller.enqueue(encoder2.encode(buffer));
-      const body = buildBodyScripts(opts);
-      if (body) controller.enqueue(encoder2.encode("\n" + body));
-      if (opts.isDev) {
-        controller.enqueue(encoder2.encode(
-          `
+        while (true) {
+          const { done, value } = await reader.read();
+          if (done) break;
+          await push(value);
+        }
+        buffer = buffer.replace(/<template id="__wfw_head">[\s\S]*?<\/template>/g, "");
+        if (buffer) controller.enqueue(encoder2.encode(buffer));
+        const body = buildBodyScripts(opts);
+        if (body) controller.enqueue(encoder2.encode("\n" + body));
+        if (opts.isDev) {
+          controller.enqueue(encoder2.encode(
+            `
 <script>(function(){var ws=new WebSocket((location.protocol==='https:'?'wss:':'ws:')+'//'+location.host+'${opts.base}/__weifuwu/livereload');ws.onmessage=function(e){if(e.data==='reload')location.reload()};ws.onclose=function(){setTimeout(function(){location.reload()},500)}})()</script>`
-        ));
+          ));
+        }
+      } catch (err) {
+        const fallback = `<!DOCTYPE html><html lang="en"><head><meta charset="utf-8"><title>500</title></head><body><h1>500 - Internal Server Error</h1></body></html>`;
+        controller.enqueue(encoder2.encode(fallback));
+      } finally {
+        controller.close();
       }
-      controller.close();
     }
   });
   return new Response(output, {
@@ -1343,6 +1408,17 @@ function streamResponse(reactStream, opts) {
     headers: { "content-type": "text/html; charset=utf-8" }
   });
 }
+var _publicEnv = null;
+function getPublicEnv() {
+  if (_publicEnv) return _publicEnv;
+  _publicEnv = {};
+  for (const key of Object.keys(process.env)) {
+    if (key.startsWith("WEIFUWU_PUBLIC_")) {
+      _publicEnv[key] = process.env[key];
+    }
+  }
+  return _publicEnv;
+}
 function buildHeadPayload(opts) {
   const { ctx, base, compiledTailwindCss } = opts;
   let result = "";
@@ -1354,7 +1430,7 @@ function buildHeadPayload(opts) {
     result += `<link rel="stylesheet" href="${base}/__wfw/style.css" />
 `;
   }
-  const localeData = globalThis.__LOCALE_DATA__;
+  const localeData = ctx.parsed?.__localeData;
   if (localeData && Object.keys(localeData).length > 0) {
     result += `<script>window.__LOCALE_DATA__=${JSON.stringify(localeData)}</script>
 `;
@@ -1366,12 +1442,7 @@ function buildHeadPayload(opts) {
     parsed: ctx.parsed,
     prefs: ctx.prefs
   };
-  const publicEnv = {};
-  for (const key of Object.keys(process.env)) {
-    if (key.startsWith("WEIFUWU_PUBLIC_")) {
-      publicEnv[key] = process.env[key];
-    }
-  }
+  const publicEnv = getPublicEnv();
   if (Object.keys(publicEnv).length > 0) {
     ctxData.env = publicEnv;
   }
@@ -1400,14 +1471,20 @@ function logger(options) {
   return async (req, ctx, next) => {
     const start = Date.now();
     const url = new URL(req.url);
-    const res = await next(req, ctx);
-    const ms = Date.now() - start;
-    if (options?.format === "combined") {
-      console.log(`${req.method} ${url.pathname}${url.search} ${res.status} ${ms}ms`);
-    } else {
-      console.log(`${req.method} ${url.pathname} ${res.status} ${ms}ms`);
+    try {
+      const res = await next(req, ctx);
+      const ms = Date.now() - start;
+      if (options?.format === "combined") {
+        console.log(`${req.method} ${url.pathname}${url.search} ${res.status} ${ms}ms`);
+      } else {
+        console.log(`${req.method} ${url.pathname} ${res.status} ${ms}ms`);
+      }
+      return res;
+    } catch (err) {
+      const ms = Date.now() - start;
+      console.log(`${req.method} ${url.pathname} 500 ${ms}ms`);
+      throw err;
     }
-    return res;
   };
 }
 function cors(options) {
@@ -1547,6 +1624,7 @@ function auth(options) {
 import { createHash as createHash2 } from "node:crypto";
 import { open, realpath } from "node:fs/promises";
 import { extname, resolve as resolve3, normalize, sep as sep2 } from "node:path";
+import { Readable } from "node:stream";
 function serveStatic(root, options) {
   const rootDir = resolve3(root);
   const opts = options ?? {};
@@ -1602,8 +1680,13 @@ function serveStatic(root, options) {
         "Last-Modified": stat.mtime.toUTCString(),
         "Cache-Control": opts.immutable ? `public, max-age=${opts.maxAge ?? 31536e3}, immutable` : `public, max-age=${opts.maxAge ?? 0}`
       };
-      const stream = fileHandle.readableWebStream();
-      return new Response(stream, { headers });
+      const readStream = fileHandle.createReadStream();
+      const cleanup = () => fileHandle.close().catch(() => {
+      });
+      readStream.on("close", cleanup);
+      readStream.on("error", cleanup);
+      const webStream = Readable.toWeb(readStream);
+      return new Response(webStream, { headers });
     } catch (err) {
       if (fileHandle) await fileHandle.close().catch(() => {
       });
@@ -1900,20 +1983,26 @@ function rateLimit(options) {
     return req.headers.get("x-forwarded-for") || req.headers.get("x-real-ip") || "global";
   });
   const message = options?.message ?? "Too Many Requests";
+  const MAX_ENTRIES = 1e4;
   const hits = /* @__PURE__ */ new Map();
   const interval = setInterval(() => {
     const now = Date.now();
     for (const [key, entry] of hits) {
       if (entry.reset < now) hits.delete(key);
     }
-  }, window2);
+    if (hits.size > MAX_ENTRIES) {
+      const toDelete = [...hits.entries()].sort((a, b) => a[1].reset - b[1].reset).slice(0, hits.size - MAX_ENTRIES);
+      for (const [k] of toDelete) hits.delete(k);
+    }
+  }, Math.min(window2, 3e4));
   if (interval.unref) interval.unref();
   const mw = async (req, ctx, next) => {
     const key = getKey(req);
     const now = Date.now();
-    const entry = hits.get(key);
+    let entry = hits.get(key);
     if (!entry || entry.reset < now) {
       hits.set(key, { count: 1, reset: now + window2 });
+      entry = { count: 1, reset: now + window2 };
       const res2 = await next(req, ctx);
       const headers2 = new Headers(res2.headers);
       headers2.set("X-RateLimit-Limit", String(max));
@@ -1949,24 +2038,19 @@ function rateLimit(options) {
 }
 
 // compress.ts
-import { gzipSync, brotliCompressSync, deflateSync, constants } from "node:zlib";
+import { constants, gzipSync, brotliCompressSync, deflateSync } from "node:zlib";
 function compress(options) {
   const level = options?.level ?? 6;
   const threshold = options?.threshold ?? 1024;
   return async (req, ctx, next) => {
     const accept = req.headers.get("accept-encoding") ?? "";
-    const useBrotli = accept.includes("br");
-    const useGzip = !useBrotli && accept.includes("gzip");
-    const useDeflate = !useBrotli && !useGzip && accept.includes("deflate");
-    if (!useBrotli && !useGzip && !useDeflate) {
-      return next(req, ctx);
-    }
+    const encoding = accept.includes("br") ? "br" : accept.includes("gzip") ? "gzip" : accept.includes("deflate") ? "deflate" : "";
+    if (!encoding) return next(req, ctx);
     const res = await next(req, ctx);
     if (res.status === 304 || res.status === 204 || res.status === 206 || res.status < 200 || res.status >= 300) {
       return res;
     }
-    const ce = res.headers.get("content-encoding");
-    if (ce) return res;
+    if (res.headers.get("content-encoding")) return res;
     const ct = res.headers.get("content-type") ?? "";
     if (!ct || ct.startsWith("audio/") || ct.startsWith("video/") || ct.startsWith("image/") || ct === "application/zip") {
       return res;
@@ -1974,21 +2058,19 @@ function compress(options) {
     const body = await res.bytes();
     if (body.byteLength < threshold) return res;
     let compressed;
-    let encoding;
-    if (useBrotli) {
-      compressed = brotliCompressSync(body, {
-        params: { [constants.BROTLI_PARAM_QUALITY]: Math.min(level, 11) }
-      });
-      encoding = "br";
-    } else if (useGzip) {
+    let enc;
+    if (encoding === "br") {
+      compressed = brotliCompressSync(body, { params: { [constants.BROTLI_PARAM_QUALITY]: Math.min(level, 11) } });
+      enc = "br";
+    } else if (encoding === "gzip") {
       compressed = gzipSync(body, { level: Math.min(level, 9) });
-      encoding = "gzip";
+      enc = "gzip";
     } else {
       compressed = deflateSync(body, { level: Math.min(level, 9) });
-      encoding = "deflate";
+      enc = "deflate";
     }
     const headers = new Headers(res.headers);
-    headers.set("Content-Encoding", encoding);
+    headers.set("Content-Encoding", enc);
     headers.set("Content-Length", String(compressed.byteLength));
     headers.delete("Content-Range");
     const existingVary = headers.get("Vary");
@@ -2155,7 +2237,7 @@ async function executeQuery(schema, params, options, req, ctx) {
     variableValues: params.variables,
     operationName: params.operationName
   });
-  return Response.json(result, { status: result.errors ? 200 : 200 });
+  return Response.json(result, { status: result.errors ? 400 : 200 });
 }
 function graphiqlHTML(endpoint) {
   const safeEndpoint = endpoint.replace(/\\/g, "\\\\").replace(/"/g, '\\"').replace(/</g, "\\x3C");
@@ -3596,8 +3678,7 @@ function redis(opts) {
   const options = typeof opts === "string" ? { url: opts } : opts ?? {};
   const url = options.url ?? process.env.REDIS_URL ?? "redis://localhost:6379";
   const client = new IORedis(url, options);
-  client.on("error", () => {
-  });
+  client.on("error", (err) => console.error("[redis]", err.message));
   const mw = ((req, ctx, next) => {
     ctx.redis = client;
     return next(req, ctx);
@@ -3610,7 +3691,8 @@ function redis(opts) {
 // hub.ts
 function createHub(opts) {
   const prefix = opts?.prefix ?? "hub:";
-  const channels2 = /* @__PURE__ */ new Map();
+  const channels = /* @__PURE__ */ new Map();
+  const wsKeys = /* @__PURE__ */ new Map();
   let redisPub;
   let redisSub = null;
   if (opts?.redis) {
@@ -3619,7 +3701,7 @@ function createHub(opts) {
     redisSub.on("message", (rawChannel, rawData) => {
       if (!rawChannel.startsWith(prefix)) return;
       const key = rawChannel.slice(prefix.length);
-      const members = channels2.get(key);
+      const members = channels.get(key);
       if (!members) return;
       for (const ws of members) {
         try {
@@ -3630,20 +3712,30 @@ function createHub(opts) {
     });
   }
   function join5(key, ws) {
-    if (!channels2.has(key)) {
-      channels2.set(key, /* @__PURE__ */ new Set());
+    if (!channels.has(key)) {
+      channels.set(key, /* @__PURE__ */ new Set());
       redisSub?.subscribe(`${prefix}${key}`);
     }
-    channels2.get(key).add(ws);
+    channels.get(key).add(ws);
+    let keys = wsKeys.get(ws);
+    if (!keys) {
+      keys = /* @__PURE__ */ new Set();
+      wsKeys.set(ws, keys);
+    }
+    keys.add(key);
   }
   function leave(ws) {
-    for (const [, members] of channels2) {
-      members.delete(ws);
+    const keys = wsKeys.get(ws);
+    if (keys) {
+      for (const key of keys) {
+        channels.get(key)?.delete(ws);
+      }
+      wsKeys.delete(ws);
     }
   }
   function broadcast(key, data) {
     const msg = JSON.stringify(data);
-    const members = channels2.get(key);
+    const members = channels.get(key);
     if (members) {
       for (const ws of members) {
         try {
@@ -3655,7 +3747,7 @@ function createHub(opts) {
     redisPub?.publish(`${prefix}${key}`, msg);
   }
   async function close() {
-    channels2.clear();
+    channels.clear();
     if (redisSub) {
       await redisSub.quit();
     }
@@ -3725,17 +3817,40 @@ function queue(opts) {
   const handlers = /* @__PURE__ */ new Map();
   let running = false;
   let pollTimer = null;
+  let epoch = 0;
   const jobKey = `${prefix}:jobs`;
   const mw = ((req, ctx, next) => {
     ctx.queue = q;
     return next(req, ctx);
   });
   const q = mw;
+  const MAX_CONCURRENT = 16;
+  let inflight = 0;
+  async function processJob(job, jobHandler) {
+    inflight++;
+    try {
+      await jobHandler(job);
+    } catch (e) {
+      console.error("[queue] handler error:", e.message);
+    } finally {
+      inflight--;
+    }
+    if (job.schedule) {
+      try {
+        const nextRun = cronNext(job.schedule);
+        const nextJob = { ...job, id: crypto4.randomUUID(), runAt: nextRun, createdAt: Date.now() };
+        await redis2.zadd(jobKey, nextRun, JSON.stringify(nextJob));
+      } catch (e) {
+        console.error("[queue] cron re-queue failed:", e.message);
+      }
+    }
+  }
   async function poll() {
+    const currentEpoch = epoch;
     if (!running) return;
     try {
       const now = Date.now();
-      while (true) {
+      while (running && inflight < MAX_CONCURRENT) {
         const result = await redis2.zpopmin(jobKey);
         if (result.length < 2) break;
         const raw = result[0];
@@ -3750,26 +3865,15 @@ function queue(opts) {
         } catch {
           continue;
         }
-        const handler = handlers.get(job.type);
-        if (handler) {
-          handler(job).then(() => {
-            if (job.schedule) {
-              try {
-                const nextRun = cronNext(job.schedule);
-                const nextJob = { ...job, id: crypto4.randomUUID(), runAt: nextRun, createdAt: Date.now() };
-                redis2.zadd(jobKey, nextRun, JSON.stringify(nextJob)).catch(() => {
-                });
-              } catch {
-              }
-            }
-          }).catch((e) => {
-            console.error("[queue] handler error:", e);
-          });
+        const jobHandler = handlers.get(job.type);
+        if (jobHandler) {
+          processJob(job, jobHandler);
         }
       }
-    } catch {
+    } catch (e) {
+      console.error("[queue] poll error:", e.message);
     }
-    if (running) {
+    if (running && currentEpoch === epoch) {
       pollTimer = setTimeout(poll, pollInterval);
     }
   }
@@ -3797,6 +3901,7 @@ function queue(opts) {
   };
   mw.stop = function stop() {
     running = false;
+    epoch++;
     if (pollTimer) {
       clearTimeout(pollTimer);
       pollTimer = null;
@@ -3804,6 +3909,7 @@ function queue(opts) {
   };
   mw.close = async function close() {
     mw.stop();
+    while (inflight > 0) await new Promise((r) => setTimeout(r, 50));
     redis2.disconnect();
   };
   return q;
@@ -4375,9 +4481,8 @@ function graphqlType(field, required) {
 function inputGraphqlType(field) {
   return graphqlType(field, false);
 }
-var typeCache = /* @__PURE__ */ new Map();
 function buildObjectType(table, ctx) {
-  const cached = typeCache.get(table.id);
+  const cached = ctx.typeCache.get(table.id);
   if (cached) return cached;
   const typeName = pascalCase(table.slug);
   const fieldsThunk = () => {
@@ -4453,7 +4558,7 @@ function buildObjectType(table, ctx) {
     return fields;
   };
   const type = new GraphQLObjectType({ name: typeName, fields: fieldsThunk });
-  typeCache.set(table.id, type);
+  ctx.typeCache.set(table.id, type);
   return type;
 }
 function buildInputType(table, prefix) {
@@ -4569,7 +4674,7 @@ function buildGraphQLHandler(sql2) {
       WHERE tenant_id = ${ctx.tenant.id}
       ORDER BY created_at ASC
     `;
-    const buildCtx = { sql: sql2, tenantId: ctx.tenant.id, tables };
+    const buildCtx = { sql: sql2, tenantId: ctx.tenant.id, tables, typeCache: /* @__PURE__ */ new Map() };
     const schema = new GraphQLSchema({
       query: new GraphQLObjectType({
         name: "Query",
@@ -4609,7 +4714,7 @@ function buildGraphQLHandler(sql2) {
       WHERE tenant_id = ${_ctx2.tenant.id}
       ORDER BY created_at ASC
     `;
-    const buildCtx = { sql: sql2, tenantId: _ctx2.tenant.id, tables };
+    const buildCtx = { sql: sql2, tenantId: _ctx2.tenant.id, tables, typeCache: /* @__PURE__ */ new Map() };
     const schema = new GraphQLSchema({
       query: new GraphQLObjectType({
         name: "Query",
@@ -4957,16 +5062,12 @@ function agent(options) {
   const model = options.model;
   const embeddingModel = options.embeddingModel;
   const dimension = options.embeddingDimension ?? 1024;
-  let defaultModels = null;
+  const defaultModels = !model || !embeddingModel ? createModelsFromEnv() : null;
   function getModel() {
-    if (model) return model;
-    if (!defaultModels) defaultModels = createModelsFromEnv();
-    return defaultModels.model;
+    return model ?? defaultModels.model;
   }
   function getEmbeddingModel() {
-    if (embeddingModel) return embeddingModel;
-    if (!defaultModels) defaultModels = createModelsFromEnv();
-    return defaultModels.embeddingModel;
+    return embeddingModel ?? defaultModels.embeddingModel;
   }
   const agentsTable = pg.table("_agents", {
     id: serial("id").primaryKey(),
@@ -5006,127 +5107,151 @@ function agent(options) {
   };
 }
 
+// messager/agent.ts
+async function runAgentRouting(sql2, messages2, agents, hub, channelId, content) {
+  if (!agents) return;
+  const agentMembers = await sql2`
+    SELECT member_id FROM "_channel_members"
+    WHERE channel_id = ${channelId} AND member_type = 'agent'
+  `;
+  for (const am of agentMembers) {
+    agents.run(am.member_id, { input: content, stream: false }).then((result) => {
+      if ("output" in result && result.output) {
+        messages2.insert({
+          channel_id: channelId,
+          sender_id: am.member_id,
+          sender_type: "agent",
+          content: result.output
+        }).then((r) => {
+          hub.broadcast(`messager:${channelId}`, { type: "message", data: r });
+        }).catch((e) => {
+          console.error("[messager] agent reply insert failed:", e);
+        });
+      }
+    }).catch((e) => {
+      console.error("[messager] agent run failed:", e);
+    });
+  }
+}
+
 // messager/ws.ts
-var userConnections = /* @__PURE__ */ new Map();
-var hub;
-function broadcastToChannel(channelId, data) {
+function broadcastToChannel(hub, channelId, data) {
   hub?.broadcast(`messager:${channelId}`, data);
 }
 function createWSHandler(deps) {
   const { sql: sql2, agents } = deps;
-  hub = createHub({
+  const hub = createHub({
     redis: deps.redis,
     prefix: "messager:"
   });
+  const userConnections = /* @__PURE__ */ new Map();
+  function trackConnection(userId, ws) {
+    let conns = userConnections.get(userId);
+    if (!conns) {
+      conns = /* @__PURE__ */ new Set();
+      userConnections.set(userId, conns);
+    }
+    conns.add(ws);
+  }
+  function untrackConnection(ws) {
+    for (const [userId, conns] of userConnections) {
+      conns.delete(ws);
+      if (conns.size === 0) userConnections.delete(userId);
+    }
+  }
   return {
-    open(ws, ctx) {
-      const userId = ctx.user?.id;
-      if (!userId) {
-        ws.close(4001, "Unauthorized");
-        return;
-      }
-    },
-    async message(ws, ctx, data) {
-      const userId = ctx.user?.id;
-      if (!userId) return;
-      let msg;
-      try {
-        msg = JSON.parse(data.toString());
-      } catch {
-        ws.send(JSON.stringify({ type: "error", message: "Invalid JSON" }));
-        return;
-      }
-      const { type, channel_id, content, is_typing, last_message_id } = msg;
-      switch (type) {
-        case "message": {
-          if (!content || !channel_id) return;
-          const [row] = await sql2`
-            INSERT INTO "_messages" ("channel_id", "sender_id", "sender_type", "content")
-            VALUES (${channel_id}, ${userId}, 'user', ${content})
-            RETURNING *
-          `;
-          const message = row;
-          hub.join(`messager:${channel_id}`, ws);
-          if (!userConnections.has(userId)) userConnections.set(userId, /* @__PURE__ */ new Set());
-          userConnections.get(userId).add(ws);
-          broadcastToChannel(channel_id, { type: "message", data: message });
-          if (agents) {
-            const agentMembers = await sql2`
-              SELECT member_id FROM "_channel_members"
-              WHERE channel_id = ${channel_id} AND member_type = 'agent'
+    handler: {
+      open(ws, ctx) {
+        const userId = ctx.user?.id;
+        if (!userId) {
+          ws.close(4001, "Unauthorized");
+          return;
+        }
+      },
+      async message(ws, ctx, data) {
+        const userId = ctx.user?.id;
+        if (!userId) return;
+        let msg;
+        try {
+          msg = JSON.parse(data.toString());
+        } catch {
+          ws.send(JSON.stringify({ type: "error", message: "Invalid JSON" }));
+          return;
+        }
+        const { type, channel_id, content, is_typing, last_message_id } = msg;
+        switch (type) {
+          case "message": {
+            if (!content || !channel_id) return;
+            const [row] = await sql2`
+              INSERT INTO "_messages" ("channel_id", "sender_id", "sender_type", "content")
+              VALUES (${channel_id}, ${userId}, 'user', ${content})
+              RETURNING *
             `;
-            for (const am of agentMembers) {
-              agents.run(am.member_id, { input: content, stream: false }).then((result) => {
-                if ("output" in result && result.output) {
-                  sql2`
-                    INSERT INTO "_messages" ("channel_id", "sender_id", "sender_type", "content")
-                    VALUES (${channel_id}, ${am.member_id}, 'agent', ${result.output})
-                  `.then(([r]) => {
-                    broadcastToChannel(channel_id, { type: "message", data: r });
-                  }).catch((e) => {
-                    console.error("[messager] agent reply insert failed:", e);
-                  });
-                }
-              }).catch((e) => {
-                console.error("[messager] agent run failed:", e);
-              });
+            const message = row;
+            hub.join(`messager:${channel_id}`, ws);
+            trackConnection(userId, ws);
+            broadcastToChannel(hub, channel_id, { type: "message", data: message });
+            if (agents) {
+              const insertMsg = (data2) => sql2`
+              INSERT INTO "_messages" ("channel_id", "sender_id", "sender_type", "content")
+              VALUES (${data2.channel_id}, ${data2.sender_id}, ${data2.sender_type}, ${data2.content})
+              RETURNING *
+            `.then(([r]) => r);
+              runAgentRouting(sql2, { insert: insertMsg }, agents, hub, channel_id, content);
             }
+            break;
           }
-          break;
-        }
-        case "typing": {
-          if (channel_id) {
+          case "typing": {
+            if (channel_id) {
+              hub.join(`messager:${channel_id}`, ws);
+            }
+            broadcastToChannel(hub, channel_id, {
+              type: "typing",
+              channel_id,
+              user_id: userId,
+              is_typing: is_typing ?? false
+            });
+            break;
+          }
+          case "read": {
+            if (!channel_id || !last_message_id) return;
             hub.join(`messager:${channel_id}`, ws);
+            await sql2`
+              UPDATE "_channel_members"
+              SET last_read_id = ${last_message_id}, last_read_at = NOW()
+              WHERE channel_id = ${channel_id} AND member_id = ${userId} AND member_type = 'user'
+            `;
+            broadcastToChannel(hub, channel_id, {
+              type: "read",
+              channel_id,
+              user_id: userId,
+              last_message_id
+            });
+            break;
           }
-          broadcastToChannel(channel_id, {
-            type: "typing",
-            channel_id,
-            user_id: userId,
-            is_typing: is_typing ?? false
-          });
-          break;
         }
-        case "read": {
-          if (!channel_id || !last_message_id) return;
-          hub.join(`messager:${channel_id}`, ws);
-          await sql2`
-            UPDATE "_channel_members"
-            SET last_read_id = ${last_message_id}, last_read_at = NOW()
-            WHERE channel_id = ${channel_id} AND member_id = ${userId} AND member_type = 'user'
-          `;
-          broadcastToChannel(channel_id, {
-            type: "read",
-            channel_id,
-            user_id: userId,
-            last_message_id
-          });
-          break;
-        }
-      }
-    },
-    close(ws) {
-      hub?.leave(ws);
-      for (const [, conns] of userConnections) {
-        conns.delete(ws);
+      },
+      close(ws) {
+        hub.leave(ws);
+        untrackConnection(ws);
+      },
+      error(ws) {
+        hub.leave(ws);
+        untrackConnection(ws);
       }
     },
-    error(ws) {
-      hub?.leave(ws);
-      for (const [, conns] of userConnections) {
-        conns.delete(ws);
-      }
-    }
+    hub
   };
 }
 
 // messager/rest.ts
 function buildRouter3(deps) {
-  const { sql: sql2, channels: channels2, members, messages: messages2, agents } = deps;
+  const { sql: sql2, channels, members, messages: messages2, agents, hub } = deps;
   const r = new Router();
   r.post("/channels", async (req) => {
     const body = await req.json();
     if (!body.name) return Response.json({ error: "name is required" }, { status: 400 });
-    const channel = await channels2.insert({
+    const channel = await channels.insert({
       name: body.name,
       type: body.type || "channel",
       created_by: body.created_by || 1
@@ -5169,14 +5294,14 @@ function buildRouter3(deps) {
   });
   r.get("/channels/:id", async (_req, ctx) => {
     const id2 = parseInt(ctx.params.id, 10);
-    const ch = await channels2.read(id2);
+    const ch = await channels.read(id2);
     if (!ch) return Response.json({ error: "Channel not found" }, { status: 404 });
     const { data: memberRows } = await members.readMany({ channel_id: id2 });
     return Response.json({ channel: ch, members: memberRows });
   });
   r.delete("/channels/:id", async (_req, ctx) => {
     const id2 = parseInt(ctx.params.id, 10);
-    await channels2.delete(id2);
+    await channels.delete(id2);
     return Response.json({ ok: true });
   });
   r.post("/channels/:id/members", async (req, ctx) => {
@@ -5228,31 +5353,8 @@ function buildRouter3(deps) {
       type: body.type || "text",
       content: body.content
     });
-    broadcastToChannel(channelId, { type: "message", data: msg });
-    if (agents) {
-      const agentMembers = await sql2`
-        SELECT member_id FROM "_channel_members"
-        WHERE channel_id = ${channelId} AND member_type = 'agent'
-      `;
-      for (const am of agentMembers) {
-        agents.run(am.member_id, { input: body.content, stream: false }).then((result) => {
-          if ("output" in result && result.output) {
-            messages2.insert({
-              channel_id: channelId,
-              sender_id: am.member_id,
-              sender_type: "agent",
-              content: result.output
-            }).then((r2) => {
-              broadcastToChannel(channelId, { type: "message", data: r2 });
-            }).catch((e) => {
-              console.error("[messager] agent reply insert failed:", e);
-            });
-          }
-        }).catch((e) => {
-          console.error("[messager] agent run failed:", e);
-        });
-      }
-    }
+    broadcastToChannel(hub, channelId, { type: "message", data: msg });
+    runAgentRouting(sql2, messages2, agents, hub, channelId, body.content);
     return Response.json(msg, { status: 201 });
   });
   r.post("/channels/:id/read", async (req, ctx) => {
@@ -5279,7 +5381,9 @@ function messager(options) {
   const agents = options.agents;
   const redis2 = options.redis;
   const base = new PgModule(pg);
-  const channels2 = pg.table("_channels", {
+  const wsResult = createWSHandler({ sql: sql2, agents, redis: redis2 });
+  const hub = wsResult.hub;
+  const channels = pg.table("_channels", {
     id: serial("id").primaryKey(),
     tenant_id: text("tenant_id"),
     name: text("name").notNull().default(""),
@@ -5311,16 +5415,16 @@ function messager(options) {
   });
   return {
     migrate: async () => {
-      await channels2.create();
-      await channels2.createIndex("tenant_id");
+      await channels.create();
+      await channels.createIndex("tenant_id");
       await members.create();
       await members.createIndex("member_id");
       await members.createIndex(["channel_id", "member_id", "member_type"], { unique: true });
       await messages2.create();
       await messages2.createIndex(["channel_id", "created_at"], { desc: true });
     },
-    router: () => buildRouter3({ sql: sql2, channels: channels2, members, messages: messages2, agents }),
-    wsHandler: () => createWSHandler({ sql: sql2, agents, redis: redis2 }),
+    router: () => buildRouter3({ sql: sql2, channels, members, messages: messages2, agents, hub }),
+    wsHandler: () => wsResult.handler,
     async send(channelId, content, opts) {
       const msg = await messages2.insert({
         channel_id: channelId,
@@ -5329,7 +5433,7 @@ function messager(options) {
         type: opts?.type ?? "text",
         content
       });
-      broadcastToChannel(channelId, { type: "message", data: msg });
+      broadcastToChannel(hub, channelId, { type: "message", data: msg });
       return msg;
     },
     close: () => base.close()
@@ -5429,6 +5533,56 @@ function createGateway(config, getPort) {
 
 // deploy/manager.ts
 import crypto5 from "node:crypto";
+
+// deploy/process.ts
+import { fork } from "node:child_process";
+function forkApp(opts) {
+  const child = fork(opts.entry, [], {
+    cwd: opts.cwd,
+    env: {
+      ...process.env,
+      ...opts.env,
+      PORT: String(opts.port)
+    },
+    stdio: ["pipe", "pipe", "pipe", "ipc"]
+  });
+  child.stdout?.on("data", (chunk) => {
+    for (const line of chunk.toString().split("\n").filter(Boolean)) {
+      opts.onLog?.(line);
+    }
+  });
+  child.stderr?.on("data", (chunk) => {
+    for (const line of chunk.toString().split("\n").filter(Boolean)) {
+      opts.onLog?.(`[error] ${line}`);
+    }
+  });
+  return { child, port: opts.port };
+}
+function stopProcess(mp, timeout = 1e4) {
+  return new Promise((resolve11) => {
+    const timer = setTimeout(() => {
+      mp.child.kill("SIGKILL");
+      resolve11();
+    }, timeout);
+    mp.child.on("exit", () => {
+      clearTimeout(timer);
+      resolve11();
+    });
+    mp.child.kill("SIGTERM");
+  });
+}
+async function healthCheck(port, path2 = "/") {
+  try {
+    const res = await fetch(`http://127.0.0.1:${port}${path2}`, {
+      signal: AbortSignal.timeout(5e3)
+    });
+    return res.ok;
+  } catch {
+    return false;
+  }
+}
+
+// deploy/manager.ts
 function createManager(config, apps, manager) {
   const router = new Router();
   const auth2 = (req, ctx, next) => {
@@ -5477,7 +5631,7 @@ function createManager(config, apps, manager) {
     const app = apps.get(ctx.params.name);
     if (!app) return new Response("Not Found", { status: 404 });
     if (app.process) {
-      app.process.kill("SIGTERM");
+      await stopProcess({ child: app.process, port: app.currentPort });
       app.process = null;
     }
     app.status = { ...app.status, status: "stopped", pid: void 0 };
@@ -5567,54 +5721,6 @@ function createManager(config, apps, manager) {
   return router;
 }
 
-// deploy/process.ts
-import { fork } from "node:child_process";
-function forkApp(opts) {
-  const child = fork(opts.entry, [], {
-    cwd: opts.cwd,
-    env: {
-      ...process.env,
-      ...opts.env,
-      PORT: String(opts.port)
-    },
-    stdio: ["pipe", "pipe", "pipe", "ipc"]
-  });
-  child.stdout?.on("data", (chunk) => {
-    for (const line of chunk.toString().split("\n").filter(Boolean)) {
-      opts.onLog?.(line);
-    }
-  });
-  child.stderr?.on("data", (chunk) => {
-    for (const line of chunk.toString().split("\n").filter(Boolean)) {
-      opts.onLog?.(`[error] ${line}`);
-    }
-  });
-  return { child, port: opts.port };
-}
-function stopProcess(mp, timeout = 1e4) {
-  return new Promise((resolve11) => {
-    const timer = setTimeout(() => {
-      mp.child.kill("SIGKILL");
-      resolve11();
-    }, timeout);
-    mp.child.on("exit", () => {
-      clearTimeout(timer);
-      resolve11();
-    });
-    mp.child.kill("SIGTERM");
-  });
-}
-async function healthCheck(port, path2 = "/") {
-  try {
-    const res = await fetch(`http://127.0.0.1:${port}${path2}`, {
-      signal: AbortSignal.timeout(5e3)
-    });
-    return res.ok;
-  } catch {
-    return false;
-  }
-}
-
 // deploy/config.ts
 function defineConfig(config) {
   if (!config.domain) throw new Error("deploy: domain is required");
@@ -6254,7 +6360,7 @@ function createEditTool(ctx) {
 // opencode/tools/grep.ts
 import { tool as tool7 } from "ai";
 import { z as z9 } from "zod";
-import { execSync as execSync2 } from "node:child_process";
+import { execFileSync } from "node:child_process";
 import { resolve as resolve7 } from "node:path";
 import { existsSync as existsSync3 } from "node:fs";
 function createGrepTool(ctx) {
@@ -6268,15 +6374,21 @@ function createGrepTool(ctx) {
     }),
     execute: async ({ pattern, include, path: path2, context }) => {
       const searchDir = path2 ? resolve7(ctx.workspace, path2) : ctx.workspace;
-      const contextArg = context > 0 ? `-C ${context}` : "";
-      let cmd;
-      if (existsSync3("/usr/bin/rg") || existsSync3("/usr/local/bin/rg")) {
-        cmd = `rg -n ${contextArg} ${include ? `-g '${include}'` : ""} '${pattern.replace(/'/g, "'\\''")}' '${searchDir}'`;
-      } else {
-        cmd = `grep -rn ${contextArg} ${include ? `--include='${include}'` : ""} '${pattern.replace(/'/g, "'\\''")}' '${searchDir}'`;
-      }
       try {
-        const stdout = execSync2(cmd, { timeout: 15e3, maxBuffer: 1024 * 1024 }).toString();
+        let stdout;
+        if (existsSync3("/usr/bin/rg") || existsSync3("/usr/local/bin/rg")) {
+          const args = ["-n"];
+          if (context > 0) args.push("-C", String(context));
+          if (include) args.push("-g", include);
+          args.push(pattern, searchDir);
+          stdout = execFileSync("rg", args, { timeout: 15e3, maxBuffer: 1024 * 1024 }).toString();
+        } else {
+          const args = ["-rn"];
+          if (context > 0) args.push("-C", String(context));
+          if (include) args.push("--include", include);
+          args.push(pattern, searchDir);
+          stdout = execFileSync("grep", args, { timeout: 15e3, maxBuffer: 1024 * 1024 }).toString();
+        }
         const lines = stdout.split("\n").filter(Boolean);
         return { matches: lines.length, results: lines.slice(0, 200), truncated: lines.length > 200 };
       } catch (e) {
@@ -6292,7 +6404,7 @@ function createGrepTool(ctx) {
 // opencode/tools/glob.ts
 import { tool as tool8 } from "ai";
 import { z as z10 } from "zod";
-import { execSync as execSync3 } from "node:child_process";
+import { execFileSync as execFileSync2 } from "node:child_process";
 import { resolve as resolve8 } from "node:path";
 function createGlobTool(ctx) {
   return tool8({
@@ -6304,12 +6416,19 @@ function createGlobTool(ctx) {
     execute: async ({ pattern, path: path2 }) => {
       const searchDir = path2 ? resolve8(ctx.workspace, path2) : ctx.workspace;
       try {
-        const stdout = execSync3(`find '${searchDir}' -name '${pattern.replace(/'/g, "'\\''")}' -not -path '*/node_modules/*' 2>/dev/null | head -200`, {
+        const stdout = execFileSync2("find", [
+          searchDir,
+          "-name",
+          pattern,
+          "-not",
+          "-path",
+          "*/node_modules/*"
+        ], {
           timeout: 1e4,
           maxBuffer: 1024 * 1024
         }).toString();
-        const files = stdout.split("\n").filter(Boolean);
-        return { files, total: files.length, truncated: files.length >= 200 };
+        const lines = stdout.split("\n").filter(Boolean).slice(0, 200);
+        return { files: lines, total: lines.length, truncated: stdout.split("\n").filter(Boolean).length > 200 };
       } catch {
         return { files: [], total: 0, truncated: false };
       }
@@ -6799,10 +6918,20 @@ function health(options) {
 
 // analytics.ts
 var DEFAULT_EXCLUDED = ["/__analytics", "/__wfw", "/static"];
+var MAX_MEM_ENTRIES = 1e4;
 var MemStore = class {
   days = /* @__PURE__ */ new Map();
   pages = /* @__PURE__ */ new Map();
   refs = /* @__PURE__ */ new Map();
+  evict() {
+    if (this.days.size <= MAX_MEM_ENTRIES) return;
+    const sorted = [...this.days.keys()].sort();
+    const toDelete = sorted.slice(0, this.days.size - MAX_MEM_ENTRIES);
+    for (const d of toDelete) {
+      this.days.delete(d);
+      this.refs.delete(d);
+    }
+  }
   record(path2, date, refDomain, mobile) {
     let day = this.days.get(date);
     if (!day) {
@@ -6827,6 +6956,7 @@ var MemStore = class {
       }
       refs.set(refDomain, (refs.get(refDomain) || 0) + 1);
     }
+    this.evict();
   }
   query(days) {
     const since = /* @__PURE__ */ new Date();
@@ -7062,8 +7192,12 @@ function preferences(options) {
   const localeOpts = { ...defaults.locale, ...options.locale };
   const themeOpts = { ...defaults.theme, ...options.theme };
   const cache = /* @__PURE__ */ new Map();
+  function validLocale(locale) {
+    return /^[\w-]+$/.test(locale) && !locale.includes("..");
+  }
   async function load(locale) {
     if (!dir) return {};
+    if (!validLocale(locale)) return {};
     const cached = cache.get(locale);
     if (cached) return cached;
     const filePath = join4(dir, `${locale}.json`);
@@ -7093,7 +7227,7 @@ function preferences(options) {
     if (dir) {
       const msgs = await load(locale);
       ctx.t = (key, params, fallback) => translate(msgs, key, params, fallback);
-      globalThis.__LOCALE_DATA__ = msgs;
+      ctx.parsed = { ...ctx.parsed, __localeData: msgs };
     }
     ctx.setPref = (name, value) => {
       const cookieOpts = [`${name}=${encodeURIComponent(value)}`, "Path=/", "SameSite=Lax"];
@@ -7311,7 +7445,7 @@ function mailer(options) {
     await transporter.sendMail({ ...opts, from: opts.from ?? from });
   }
   async function close() {
-    if (transporter) transporter.close();
+    transporter?.close();
   }
   return { send, close };
 }
@@ -7345,11 +7479,11 @@ function csrf(options) {
       return res;
     }
     const cookieToken = getCookies(req)[cookieName];
-    let headerToken = req.headers.get(headerName);
-    if (!headerToken) {
+    let headerToken = req.headers.get(headerName) ?? req.headers.get("x-xsrf-token") ?? "";
+    if (!headerToken && (req.method === "POST" || req.method === "PUT" || req.method === "PATCH" || req.method === "DELETE")) {
       try {
         const body = await req.clone().json();
-        headerToken = body[bodyKey];
+        headerToken = body[bodyKey] ?? "";
       } catch {
       }
     }
@@ -7361,6 +7495,15 @@ function csrf(options) {
 }
 
 // logdb/rest.ts
+function parseMetadata(row) {
+  if (typeof row.metadata === "string") {
+    try {
+      row.metadata = JSON.parse(row.metadata);
+    } catch {
+    }
+  }
+  return row;
+}
 function createHandler(entries) {
   return async (req, ctx) => {
     const body = await req.json();
@@ -7377,13 +7520,7 @@ function createHandler(entries) {
       message: body.message,
       metadata
     });
-    if (typeof row.metadata === "string") {
-      try {
-        row.metadata = JSON.parse(row.metadata);
-      } catch {
-      }
-    }
-    return Response.json(row, { status: 201 });
+    return Response.json(parseMetadata(row), { status: 201 });
   };
 }
 function listHandler(entries) {
@@ -7409,15 +7546,7 @@ function listHandler(entries) {
       conditions.length > 0 ? conditions : void 0,
       { orderBy: { created_at: "desc" }, limit, offset }
     );
-    for (const row of data) {
-      if (typeof row.metadata === "string") {
-        try {
-          row.metadata = JSON.parse(row.metadata);
-        } catch {
-        }
-      }
-    }
-    return Response.json({ entries: data, total: count });
+    return Response.json({ entries: data.map(parseMetadata), total: count });
   };
 }
 function getHandler(entries) {
@@ -7426,13 +7555,7 @@ function getHandler(entries) {
     if (!id2) return Response.json({ error: "id is required" }, { status: 400 });
     const row = await entries.read(parseInt(id2));
     if (!row) return Response.json({ error: "not found" }, { status: 404 });
-    if (typeof row.metadata === "string") {
-      try {
-        row.metadata = JSON.parse(row.metadata);
-      } catch {
-      }
-    }
-    return Response.json(row);
+    return Response.json(parseMetadata(row));
   };
 }
 
@@ -7522,7 +7645,8 @@ function logdb(options) {
       await ensurePartitions(sql2, tableName);
     },
     clean,
-    close: () => pg.close()
+    close: async () => {
+    }
   };
 }
 
@@ -7530,8 +7654,7 @@ function logdb(options) {
 import crypto6 from "node:crypto";
 
 // iii/stream.ts
-var channels = /* @__PURE__ */ new Map();
-function notify(stream, group, item, event, data) {
+function notify(channels, stream, group, item, event, data) {
   const keys = [
     `${stream}`,
     `${stream}:${group}`,
@@ -7583,7 +7706,7 @@ function applyOps(value, ops) {
   }
   return current;
 }
-function createMemoryStore() {
+function createMemoryStore(channels) {
   const store = /* @__PURE__ */ new Map();
   function key(stream, group, item) {
     return `${stream}:${group}:${item}`;
@@ -7593,7 +7716,7 @@ function createMemoryStore() {
       const k = key(stream, group, item);
       const old = store.get(k) ?? null;
       store.set(k, deepClone(data));
-      notify(stream, group, item, "set", data);
+      notify(channels, stream, group, item, "set", data);
       return { old_value: old, new_value: deepClone(data) };
     },
     async get(stream, group, item) {
@@ -7604,7 +7727,7 @@ function createMemoryStore() {
       const k = key(stream, group, item);
       const old = store.get(k) ?? null;
       store.delete(k);
-      notify(stream, group, item, "delete", null);
+      notify(channels, stream, group, item, "delete", null);
       return { old_value: old };
     },
     async list(stream, group) {
@@ -7648,19 +7771,19 @@ function createMemoryStore() {
       return { streams, count: streams.length };
     },
     async send(stream, group, type, data, id2) {
-      notify(stream, group, id2 ?? "", "send", { type, data });
+      notify(channels, stream, group, id2 ?? "", "send", { type, data });
     },
     async update(stream, group, item, ops) {
       const k = key(stream, group, item);
       const old = deepClone(store.get(k) ?? null);
       const newVal = applyOps(old, ops);
       store.set(k, deepClone(newVal));
-      notify(stream, group, item, "update", newVal);
+      notify(channels, stream, group, item, "update", newVal);
       return { old_value: old, new_value: deepClone(newVal) };
     }
   };
 }
-function createPgStore(pg) {
+function createPgStore(channels, pg) {
   const sql2 = pg.sql;
   return {
     async set(stream, group, item, data) {
@@ -7671,7 +7794,7 @@ function createPgStore(pg) {
         DO UPDATE SET data = ${data}, updated_at = NOW()
         RETURNING data
       `;
-      notify(stream, group, item, "set", data);
+      notify(channels, stream, group, item, "set", data);
       return { old_value: null, new_value: data };
     },
     async get(stream, group, item) {
@@ -7691,7 +7814,7 @@ function createPgStore(pg) {
         RETURNING data
       `;
       const old = rows[0]?.data ?? null;
-      notify(stream, group, item, "delete", null);
+      notify(channels, stream, group, item, "delete", null);
       return { old_value: old };
     },
     async list(stream, group) {
@@ -7729,7 +7852,7 @@ function createPgStore(pg) {
       return { streams, count: streams.length };
     },
     async send(stream, group, type, data, id2) {
-      notify(stream, group, id2 ?? "", "send", { type, data });
+      notify(channels, stream, group, id2 ?? "", "send", { type, data });
     },
     async update(stream, group, item, ops) {
       const { value: oldVal } = await this.get(stream, group, item);
@@ -7740,12 +7863,12 @@ function createPgStore(pg) {
         ON CONFLICT (stream_name, group_id, item_id)
         DO UPDATE SET data = ${newVal}, updated_at = NOW()
       `;
-      notify(stream, group, item, "update", newVal);
+      notify(channels, stream, group, item, "update", newVal);
       return { old_value: oldVal, new_value: deepClone(newVal) };
     }
   };
 }
-function createRedisStore(redis2, ttl) {
+function createRedisStore(channels, redis2, ttl) {
   function hashKey(stream, group) {
     return `iii:stream:${stream}:${group}`;
   }
@@ -7760,7 +7883,7 @@ function createRedisStore(redis2, ttl) {
       await redis2.hset(hk, item, JSON.stringify(data));
       setTTL(hk);
       await redis2.publish(`iii:stream:${stream}`, JSON.stringify({ event: "set", group, item, data }));
-      notify(stream, group, item, "set", data);
+      notify(channels, stream, group, item, "set", data);
       return { old_value: old, new_value: deepClone(data) };
     },
     async get(stream, group, item) {
@@ -7775,7 +7898,7 @@ function createRedisStore(redis2, ttl) {
       const remaining = await redis2.hlen(hk);
       if (remaining === 0) await redis2.del(hk);
       await redis2.publish(`iii:stream:${stream}`, JSON.stringify({ event: "delete", group, item }));
-      notify(stream, group, item, "delete", null);
+      notify(channels, stream, group, item, "delete", null);
       return { old_value: old };
     },
     async list(stream, group) {
@@ -7826,7 +7949,7 @@ function createRedisStore(redis2, ttl) {
       return { streams, count: streams.length };
     },
     async send(stream, group, type, data, id2) {
-      notify(stream, group, id2 ?? "", "send", { type, data });
+      notify(channels, stream, group, id2 ?? "", "send", { type, data });
     },
     async update(stream, group, item, ops) {
       const hk = hashKey(stream, group);
@@ -7836,13 +7959,14 @@ function createRedisStore(redis2, ttl) {
       await redis2.hset(hk, item, JSON.stringify(newVal));
       setTTL(hk);
       await redis2.publish(`iii:stream:${stream}`, JSON.stringify({ event: "update", group, item, data: newVal }));
-      notify(stream, group, item, "update", newVal);
+      notify(channels, stream, group, item, "update", newVal);
       return { old_value: old, new_value: deepClone(newVal) };
     }
   };
 }
 function createStream(opts) {
-  const store = opts?.pg ? createPgStore(opts.pg) : opts?.redis ? createRedisStore(opts.redis, opts.streamTTL ?? 3600) : createMemoryStore();
+  const channels = /* @__PURE__ */ new Map();
+  const store = opts?.pg ? createPgStore(channels, opts.pg) : opts?.redis ? createRedisStore(channels, opts.redis, opts.streamTTL ?? 3600) : createMemoryStore(channels);
   let redisSub = null;
   if (opts?.redis) {
     redisSub = opts.redis.duplicate();
@@ -7852,9 +7976,9 @@ function createStream(opts) {
       try {
         const msg = JSON.parse(rawData);
         if (msg.event === "set" || msg.event === "update") {
-          notify(stream, msg.group, msg.item, msg.event, msg.data);
+          notify(channels, stream, msg.group, msg.item, msg.event, msg.data);
         } else if (msg.event === "delete") {
-          notify(stream, msg.group, msg.item, "delete", null);
+          notify(channels, stream, msg.group, msg.item, "delete", null);
         }
       } catch {
       }
@@ -7888,6 +8012,9 @@ function createStream(opts) {
         `;
         await sql2`CREATE INDEX IF NOT EXISTS idx_iii_stream_group ON "_iii_stream" (stream_name, group_id)`;
       }
+    },
+    async close() {
+      if (redisSub) await redisSub.quit();
     }
   };
 }
@@ -8207,60 +8334,12 @@ function iii(opts = {}) {
       });
     }
   });
-  function doTrigger(request) {
-    const fn = functions.get(request.function_id);
-    if (!fn) throw new Error(`Function "${request.function_id}" not found`);
-    const ctx = { engine: module, functionId: request.function_id, workerName: fn.workerName };
-    if (request.action === "void") {
-      queueMicrotask(() => fn.handler(request.payload, ctx));
-      return Promise.resolve(void 0);
-    }
-    return Promise.resolve(fn.handler(request.payload, ctx));
-  }
-  const router = buildRouter5({
-    listWorkers: () => Array.from(workers.values()).map((w) => ({
-      id: w.id,
-      name: w.name,
-      status: "connected",
-      connectedAt: Date.now(),
-      functionCount: w.functions.length,
-      triggerCount: w.triggers.length
-    })),
-    listFunctions: () => Array.from(functions.values()).map((f) => ({
-      id: f.id,
-      workerId: f.workerId,
-      workerName: f.workerName,
-      triggers: f.triggers
-    })),
-    listTriggers: () => Array.from(triggers.values()).map((t) => ({
-      id: t.id,
-      type: t.type,
-      function_id: t.function_id,
-      config: t.config,
-      workerId: t.workerId
-    })),
-    trigger: doTrigger,
-    addWorker: addLocalWorker,
-    removeWorker: (worker) => {
-      for (const [wid, reg] of workers) {
-        if (reg.name === worker.name) {
-          removeWorker(wid);
-          return;
-        }
-      }
-    },
-    shutdown: async () => {
-      for (const [, reg] of workers) reg.ws?.close();
-      workers.clear();
-      functions.clear();
-      triggers.clear();
-    },
-    migrate: async () => {
-      await stream.migrate();
-    }
-  }, wsHandler);
   const module = {
-    router: () => router,
+    router: () => {
+      const r = buildRouter5(module, wsHandler);
+      module.router = () => r;
+      return r;
+    },
     wsHandler: () => wsHandler,
     addWorker: addLocalWorker,
     removeWorker: (worker) => {
@@ -8271,7 +8350,16 @@ function iii(opts = {}) {
         }
       }
     },
-    trigger: doTrigger,
+    trigger(request) {
+      const fn = functions.get(request.function_id);
+      if (!fn) throw new Error(`Function "${request.function_id}" not found`);
+      const ctx = { engine: module, functionId: request.function_id, workerName: fn.workerName };
+      if (request.action === "void") {
+        queueMicrotask(() => fn.handler(request.payload, ctx));
+        return Promise.resolve(void 0);
+      }
+      return Promise.resolve(fn.handler(request.payload, ctx));
+    },
     listWorkers: () => Array.from(workers.values()).map((w) => ({
       id: w.id,
       name: w.name,
@@ -8297,10 +8385,16 @@ function iii(opts = {}) {
       await stream.migrate();
     },
     shutdown: async () => {
+      for (const [, p] of pending) {
+        clearTimeout(p.timer);
+        p.reject(new Error("Engine shutting down"));
+      }
+      pending.clear();
       for (const [, reg] of workers) reg.ws?.close();
       workers.clear();
       functions.clear();
       triggers.clear();
+      await stream.close();
     }
   };
   return module;
@@ -8467,7 +8561,16 @@ function registerWorker(url) {
       send({ type: "register_trigger", function_id: input.function_id, trigger_type: input.type, config: input.config });
     },
     unregisterTrigger(functionId) {
-      registeredTriggers.clear();
+      for (const key of registeredTriggers) {
+        try {
+          const parsed = JSON.parse(key);
+          if (parsed.function_id === functionId) {
+            registeredTriggers.delete(key);
+            break;
+          }
+        } catch {
+        }
+      }
       send({ type: "unregister_trigger", function_id: functionId });
     },
     trigger(request) {
@@ -8531,6 +8634,7 @@ export {
   generateObject,
   generateText2 as generateText,
   getCookies,
+  getCtx,
   graphql,
   health,
   helmet,