weifuwu 0.24.2 → 0.24.3

package/dist/index.js

@@ -65,7 +65,8 @@ function isBundled() {
   return true ? true : false;
 }
 function isDev() {
-  return process.env.NODE_ENV === "development";
+  const env2 = process.env.NODE_ENV;
+  return env2 !== "production" && env2 !== "test";
 }
 function isProd() {
   return process.env.NODE_ENV === "production";
@@ -293,20 +294,20 @@ function serve(handler, options) {
         process.off("SIGINT", shutdownHandler);
         shutdownHandler = null;
       }
-      return new Promise((resolve14) => {
+      return new Promise((resolve16) => {
         if (!server.listening) {
-          resolve14();
+          resolve16();
           return;
         }
         server.close();
         server.closeIdleConnections();
         const timer = setTimeout(() => {
           server.closeAllConnections();
-          resolve14();
+          resolve16();
         }, timeoutMs);
         server.on("close", () => {
           clearTimeout(timer);
-          resolve14();
+          resolve16();
         });
       });
     },
@@ -1487,7 +1488,7 @@ function upload(options) {
 }
 
 // rate-limit.ts
-function defaultKey(_req, _ctx) {
+function defaultKey(_req, _ctx2) {
   const forwarded = _req.headers.get("x-forwarded-for");
   if (forwarded) return forwarded.split(",")[0].trim();
   const realIp = _req.headers.get("x-real-ip");
@@ -3317,7 +3318,7 @@ h2{color:#dc2626}.desc{color:#555}</style>
       { status: 400, headers: { "Content-Type": "text/html; charset=utf-8" } }
     );
   }
-  async function authorizeHandler(req, _ctx) {
+  async function authorizeHandler(req, _ctx2) {
     const url = new URL(req.url);
     const clientId = url.searchParams.get("client_id") || "";
     const redirectUri = url.searchParams.get("redirect_uri") || "";
@@ -5590,23 +5591,23 @@ function buildGraphQLHandler(sql2) {
     });
     return Response.json(result, { status: result.errors ? 400 : 200 });
   });
-  r.get("/", async (req, _ctx) => {
+  r.get("/", async (req, _ctx2) => {
     const url = new URL(req.url);
     if (url.searchParams.has("query")) {
-      return handleGET(req, _ctx);
+      return handleGET(req, _ctx2);
     }
     return new Response("GraphQL endpoint. Send POST /graphql with { query, variables }", {
       status: 200,
       headers: { "Content-Type": "text/plain" }
     });
   });
-  async function handleGET(req, _ctx) {
+  async function handleGET(req, _ctx2) {
     const tables = await sql2`
       SELECT * FROM "_user_tables"
-      WHERE tenant_id = ${_ctx.tenant.id}
+      WHERE tenant_id = ${_ctx2.tenant.id}
       ORDER BY created_at ASC
     `;
-    const buildCtx = { sql: sql2, tenantId: _ctx.tenant.id, tables, typeCache: /* @__PURE__ */ new Map() };
+    const buildCtx = { sql: sql2, tenantId: _ctx2.tenant.id, tables, typeCache: /* @__PURE__ */ new Map() };
     const schema = new GraphQLSchema({
       query: new GraphQLObjectType({
         name: "Query",
@@ -5626,7 +5627,7 @@ function buildGraphQLHandler(sql2) {
       source: query,
       variableValues: variables,
       operationName: url.searchParams.get("operationName") || void 0,
-      contextValue: _ctx
+      contextValue: _ctx2
     });
     return Response.json(result, { status: result.errors ? 400 : 200 });
   }
@@ -6653,14 +6654,14 @@ function forkApp(opts) {
   return { child, port: opts.port };
 }
 function stopProcess(mp, timeout = 1e4) {
-  return new Promise((resolve14) => {
+  return new Promise((resolve16) => {
     const timer = setTimeout(() => {
       mp.child.kill("SIGKILL");
-      resolve14();
+      resolve16();
     }, timeout);
     mp.child.on("exit", () => {
       clearTimeout(timer);
-      resolve14();
+      resolve16();
     });
     mp.child.kill("SIGTERM");
   });
@@ -6992,22 +6993,168 @@ import { createOpenAI as createOpenAI3 } from "@ai-sdk/openai";
 
 // ssr.ts
 import { createElement as createElement3 } from "react";
-import { createHash as createHash3 } from "node:crypto";
-import { existsSync as existsSync4, readFileSync as readFileSync4, readdirSync } from "node:fs";
+import { createHash as createHash4 } from "node:crypto";
+import { existsSync as existsSync6, readdirSync } from "node:fs";
 import { readdir, stat } from "node:fs/promises";
-import { dirname as dirname3, join as join5, resolve as resolve6, relative as relative2 } from "node:path";
+import { dirname as dirname4, join as join5, resolve as resolve8, relative as relative3 } from "node:path";
 import { AsyncLocalStorage as AsyncLocalStorage2 } from "node:async_hooks";
 
 // compile.ts
-import * as esbuild from "esbuild";
-import { existsSync, mkdirSync, readFileSync as readFileSync2 } from "node:fs";
-import { join as join2, resolve as resolve3, dirname } from "node:path";
+import * as esbuild2 from "esbuild";
+import { existsSync as existsSync2, mkdirSync, readFileSync as readFileSync3 } from "node:fs";
+import { join as join2, resolve as resolve4, dirname as dirname2 } from "node:path";
 import { pathToFileURL } from "node:url";
 import { createHash } from "node:crypto";
+import { createRequire as createRequire2 } from "node:module";
+
+// server-registry.ts
+import * as esbuild from "esbuild";
+import { existsSync, readFileSync as readFileSync2, statSync } from "node:fs";
+import { resolve as resolve3, dirname } from "node:path";
 import vm from "node:vm";
 import { createRequire } from "node:module";
-var _cjsRequire = createRequire(import.meta.url);
 var _userRequire = null;
+function getUserRequire() {
+  if (!_userRequire) {
+    try {
+      _userRequire = createRequire(resolve3(process.cwd(), "package.json"));
+    } catch {
+      _userRequire = createRequire(import.meta.url);
+    }
+  }
+  return _userRequire;
+}
+var _alias = null;
+function resolveAliases() {
+  if (_alias) return _alias;
+  const configFiles = ["tsconfig.json", "jsconfig.json"];
+  for (const file of configFiles) {
+    const p = resolve3(file);
+    if (existsSync(p)) {
+      try {
+        const config = JSON.parse(readFileSync2(p, "utf-8"));
+        const paths = config.compilerOptions?.paths;
+        if (paths) {
+          const alias = {};
+          for (const [key, values] of Object.entries(paths)) {
+            const cleanKey = key.replace("/*", "");
+            const val = values[0]?.replace("/*", "");
+            if (val) alias[cleanKey] = resolve3(dirname(p), val);
+          }
+          _alias = alias;
+          return alias;
+        }
+      } catch {
+      }
+    }
+  }
+  _alias = {};
+  return {};
+}
+function applyAlias(id2, _moduleDir) {
+  const aliases = resolveAliases();
+  for (const [prefix, target] of Object.entries(aliases)) {
+    if (id2.startsWith(prefix)) {
+      const rest = id2.slice(prefix.length);
+      return target + rest;
+    }
+  }
+  return null;
+}
+var exts = [".tsx", ".ts", ".jsx", ".js"];
+function tryResolve(base) {
+  if (existsSync(base)) {
+    const stat3 = statSync(base);
+    if (stat3.isFile()) return base;
+    if (stat3.isDirectory()) {
+      for (const ext of exts) {
+        const p = resolve3(base, `index${ext}`);
+        if (existsSync(p)) return p;
+      }
+      return null;
+    }
+  }
+  for (const ext of exts) {
+    const p = base + ext;
+    if (existsSync(p)) return p;
+  }
+  return null;
+}
+var registry = /* @__PURE__ */ new Map();
+var _ctx = vm.createContext(Object.create(globalThis));
+function transformToCjs(absPath, source) {
+  const isTsx = absPath.endsWith(".tsx");
+  const result = esbuild.transformSync(source, {
+    loader: isTsx ? "tsx" : "ts",
+    format: "cjs",
+    jsx: isTsx ? "automatic" : void 0,
+    jsxImportSource: isTsx ? "react" : void 0,
+    sourcemap: false
+  });
+  return result.code;
+}
+function makeRequire(modulePath) {
+  const moduleDir = dirname(modulePath);
+  return (id2) => {
+    if (id2.startsWith(".")) {
+      const base = resolve3(moduleDir, id2);
+      const file = tryResolve(base);
+      if (!file) {
+        throw new Error(
+          `[server-registry] Cannot resolve '${id2}' from '${modulePath}'. Tried: ${[base, ...exts.map((e) => base + e)].filter((p) => !p.endsWith(base)).join(", ")}`
+        );
+      }
+      return getServerModule(file);
+    }
+    const aliased = applyAlias(id2, moduleDir);
+    if (aliased) {
+      const file = tryResolve(aliased);
+      if (file) return getServerModule(file);
+    }
+    return getUserRequire()(id2);
+  };
+}
+function evaluateModule(code, modulePath) {
+  const mod = { exports: {} };
+  const require2 = makeRequire(modulePath);
+  const _dirname = dirname(modulePath);
+  const _filename = modulePath;
+  const wrapped = `(function(require,module,exports,__dirname,__filename){
+${code}
+})`;
+  try {
+    new vm.Script(wrapped).runInContext(_ctx)(require2, mod, mod.exports, _dirname, _filename);
+  } catch (err) {
+    const msg = err instanceof Error ? err.message : String(err);
+    const cause = err instanceof Error ? err : void 0;
+    throw new Error(
+      `[server-registry] Error evaluating '${modulePath}': ${msg}`,
+      cause ? { cause } : void 0
+    );
+  }
+  return mod.exports;
+}
+function getServerModule(absPath) {
+  const normalized = resolve3(absPath);
+  if (registry.has(normalized)) return registry.get(normalized).exports;
+  const source = readFileSync2(normalized, "utf-8");
+  const code = transformToCjs(normalized, source);
+  const exports = evaluateModule(code, normalized);
+  registry.set(normalized, { exports });
+  return exports;
+}
+function clearServerModule(absPath) {
+  if (absPath) {
+    const normalized = resolve3(absPath);
+    registry.delete(normalized);
+  } else {
+    registry.clear();
+    _alias = null;
+  }
+}
+
+// compile.ts
+var _userRequire2 = null;
 var OUT_DIR = ".weifuwu/ssr";
 var cache = /* @__PURE__ */ new Map();
 var externals = [
@@ -7020,31 +7167,31 @@ var externals = [
   "@graphql-tools/schema",
   "ai"
 ];
-var _alias = null;
-function resolveAliases() {
-  if (_alias) return _alias;
+var _alias2 = null;
+function resolveAliases2() {
+  if (_alias2) return _alias2;
   const configFiles = ["tsconfig.json", "jsconfig.json"];
   for (const file of configFiles) {
-    const p = resolve3(file);
-    if (existsSync(p)) {
+    const p = resolve4(file);
+    if (existsSync2(p)) {
       try {
-        const config = JSON.parse(readFileSync2(p, "utf-8"));
+        const config = JSON.parse(readFileSync3(p, "utf-8"));
         const paths = config.compilerOptions?.paths;
         if (paths) {
           const alias = {};
           for (const [key, values] of Object.entries(paths)) {
             const cleanKey = key.replace("/*", "");
             const val = values[0]?.replace("/*", "");
-            if (val) alias[cleanKey] = resolve3(dirname(p), val);
+            if (val) alias[cleanKey] = resolve4(dirname2(p), val);
           }
-          _alias = alias;
+          _alias2 = alias;
           return alias;
         }
       } catch {
       }
     }
   }
-  _alias = {};
+  _alias2 = {};
   return {};
 }
 function id(s) {
@@ -7052,16 +7199,17 @@ function id(s) {
 }
 function clearCompileCache() {
   cache.clear();
-  _alias = null;
+  clearServerModule();
+  _alias2 = null;
 }
 async function compileTsx(path2) {
-  const absPath = resolve3(path2);
+  const absPath = resolve4(path2);
   if (cache.has(absPath)) return cache.get(absPath);
-  const outDir = resolve3(OUT_DIR);
+  const outDir = resolve4(OUT_DIR);
   mkdirSync(outDir, { recursive: true });
   const hash = id(absPath);
   const outPath = join2(outDir, hash + ".js");
-  await esbuild.build({
+  await esbuild2.build({
     entryPoints: { [hash]: absPath },
     outdir: outDir,
     format: "esm",
@@ -7070,7 +7218,7 @@ async function compileTsx(path2) {
     jsxImportSource: "react",
     bundle: true,
     external: externals,
-    alias: resolveAliases(),
+    alias: resolveAliases2(),
     write: true,
     allowOverwrite: true
   });
@@ -7078,42 +7226,20 @@ async function compileTsx(path2) {
   cache.set(absPath, mod);
   return mod;
 }
-function loadSSRModule(code) {
-  const ctx = vm.createContext(Object.create(globalThis));
-  const mod = { exports: {} };
-  ctx.require = (name) => _cjsRequire(name);
-  ctx.module = mod;
-  ctx.exports = mod.exports;
-  new vm.Script(code).runInContext(ctx);
-  return mod.exports;
-}
-async function compileTsxDev(path2) {
-  const absPath = resolve3(path2);
-  if (cache.has(absPath)) return cache.get(absPath);
-  const result = await esbuild.build({
-    entryPoints: { [id(absPath)]: absPath },
-    format: "cjs",
-    platform: "node",
-    jsx: "automatic",
-    jsxImportSource: "react",
-    bundle: true,
-    external: externals,
-    alias: resolveAliases(),
-    write: false
-  });
-  const code = new TextDecoder().decode(result.outputFiles[0].contents);
-  const mod = loadSSRModule(code);
+function compileTsxDev(path2) {
+  const absPath = resolve4(path2);
+  const mod = getServerModule(absPath);
   cache.set(absPath, mod);
   return mod;
 }
 function compile(path2) {
-  return isDev() ? compileTsxDev(path2) : compileTsx(path2);
+  return isDev() ? Promise.resolve(compileTsxDev(path2)) : compileTsx(path2);
 }
 var vendorBundle = null;
 var vendorHash = "";
 async function compileVendorBundle() {
   if (vendorBundle) return vendorBundle;
-  if (!_userRequire) _userRequire = createRequire(join2(process.cwd(), "package.json"));
+  if (!_userRequire2) _userRequire2 = createRequire2(join2(process.cwd(), "package.json"));
   const modules = {
     react: [],
     "react-dom": ["react"],
@@ -7121,13 +7247,13 @@ async function compileVendorBundle() {
     "react/jsx-runtime": ["react"]
   };
   for (const request of Object.keys(modules)) {
-    const mod = _userRequire(request);
+    const mod = _userRequire2(request);
     const keys = Object.keys(mod).filter((k) => !k.startsWith("_") && k !== "default");
     modules[request] = keys;
   }
   const baseDir = import.meta.dirname ?? __dirname;
-  const reactAbsPath = isBundled() ? resolve3(baseDir, "react.js") : resolve3(baseDir, "react.ts");
-  const reactSrc = readFileSync2(reactAbsPath, "utf-8");
+  const reactAbsPath = isBundled() ? resolve4(baseDir, "react.js") : resolve4(baseDir, "react.ts");
+  const reactSrc = readFileSync3(reactAbsPath, "utf-8");
   const wfwKeys = [];
   if (reactAbsPath.endsWith(".ts")) {
     for (const line of reactSrc.split("\n")) {
@@ -7158,7 +7284,7 @@ async function compileVendorBundle() {
   const uidWfw = wfwKeys.filter((k) => !used.has(k) && used.add(k));
   if (uidWfw.length > 0)
     stmts.push(`export { ${uidWfw.join(", ")} } from ${JSON.stringify(reactAbsPath)};`);
-  const result = await esbuild.build({
+  const result = await esbuild2.build({
     stdin: { contents: stmts.join("\n"), resolveDir: process.cwd() },
     format: "esm",
     bundle: true,
@@ -7170,95 +7296,6 @@ async function compileVendorBundle() {
   vendorHash = Array.from(new Uint8Array(hashBuffer)).map((b) => b.toString(16).padStart(2, "0")).join("").slice(0, 8);
   return vendorBundle;
 }
-async function compileBrowser(path2, outDir) {
-  const absPath = resolve3(path2);
-  const h = id(absPath);
-  outDir = outDir ?? resolve3(OUT_DIR);
-  const outPath = join2(outDir, h + ".js");
-  if (!isDev() && existsSync(outPath)) return h;
-  mkdirSync(outDir, { recursive: true });
-  const wfwDir = resolve3(import.meta.dirname ?? __dirname);
-  const plugin = {
-    name: "wfw-external",
-    setup(build2) {
-      build2.onResolve({ filter: /./ }, (args) => {
-        if (args.kind === "entry-point") return;
-        const abs = args.path.startsWith(".") ? join2(args.resolveDir, args.path) : args.path;
-        if (abs.startsWith(wfwDir) && !abs.includes("node_modules")) {
-          const rel = abs.slice(wfwDir.length + 1);
-          if (rel.includes("/")) return;
-          return { path: "weifuwu/react", external: true };
-        }
-      });
-    }
-  };
-  await esbuild.build({
-    entryPoints: { [h]: absPath },
-    outdir: outDir,
-    format: "esm",
-    platform: "browser",
-    jsx: "automatic",
-    jsxImportSource: "react",
-    bundle: true,
-    external: [
-      "react",
-      "react-dom",
-      "react-dom/client",
-      "react/jsx-runtime",
-      "weifuwu",
-      "weifuwu/react"
-    ],
-    plugins: [plugin],
-    write: true,
-    allowOverwrite: true
-  });
-  return h;
-}
-async function compileHotComponent(path2) {
-  const absPath = resolve3(path2);
-  const h = id(absPath);
-  const stdin = `import C from ${JSON.stringify(absPath)};
-(window.__WFW_REFRESH||function(){})(C)`;
-  const wfwDir = resolve3(import.meta.dirname ?? __dirname);
-  const plugin = {
-    name: "wfw-external",
-    setup(build2) {
-      build2.onResolve({ filter: /./ }, (args) => {
-        if (args.kind === "entry-point") return;
-        const abs = args.path.startsWith(".") ? join2(args.resolveDir, args.path) : args.path;
-        if (abs.startsWith(wfwDir) && !abs.includes("node_modules")) {
-          const rel = abs.slice(wfwDir.length + 1);
-          if (rel.includes("/")) return;
-          return { path: "weifuwu/react", external: true };
-        }
-      });
-    }
-  };
-  const result = await esbuild.build({
-    stdin: { contents: stdin, loader: "tsx", resolveDir: dirname(absPath) },
-    format: "esm",
-    platform: "browser",
-    jsx: "automatic",
-    jsxImportSource: "react",
-    bundle: true,
-    external: [
-      "react",
-      "react-dom",
-      "react-dom/client",
-      "react/jsx-runtime",
-      "weifuwu",
-      "weifuwu/react"
-    ],
-    plugins: [plugin],
-    write: false
-  });
-  let code = new TextDecoder().decode(result.outputFiles[0].contents);
-  if (code.includes("__require") && (code.includes('"react"') || code.includes("'react'"))) {
-    code = `import * as __r from 'react';
-` + code.replace(/__require\(["']react["']\)/g, "__r");
-  }
-  return { hash: h, code };
-}
 
 // stream.ts
 import { TextDecoder as TextDecoder2, TextEncoder as TextEncoder2 } from "node:util";
@@ -7276,6 +7313,8 @@ function getPublicEnv2() {
 function buildHeadPayload(opts) {
   const { ctx, base, tailwind } = opts;
   let result = "";
+  result += `<script>window.__wfw={_cache:{},_k:function(u){return u.split('?')[0]},h:async function(u){var k=this._k(u);if(this._cache[k])return this._cache[k];var m=await import(u);this._cache[k]=m;return m},_update:function(u,mod){var k=this._k(u);this._cache[k]=mod}}</script>
+`;
   const vUrl = `${base}/__wfw/v/bundle?h=${vendorHash}`;
   result += `<script type="importmap">{
   "imports": {
@@ -7360,26 +7399,37 @@ function streamResponse(reactStream, opts, hydrationScript) {
         if (built) bodyScripts += built;
         if (opts.isDev) {
           const wsUrl = `${opts.base}/__weifuwu/livereload`;
-          const hbUrl = `${opts.base}/__wfw/h/`;
           bodyScripts += `
 <script>
 (function(){
 var ws=new WebSocket((location.protocol==='https:'?'wss:':'ws:')+'//'+location.host+'${wsUrl}');
 var t=0;
+var _w=window;
 ws.onmessage=function(e){
   try{
     var m=JSON.parse(e.data);
-    if(m.type==='component'){
-      import('${hbUrl}'+m.hash+'?t='+Date.now()).catch(function(){location.reload()});
-      if(m.css){
-        var s=document.querySelector('style[data-lr]')||function(){
-          var x=document.createElement('style');
-          x.setAttribute('data-lr','');
-          document.head.appendChild(x);
-          return x
-        }();
-        s.textContent=m.css
-      }
+    if(m.type==='update'&&m.url&&m.code){
+      var blob=new Blob([m.code],{type:'application/javascript'});
+      var blobUrl=URL.createObjectURL(blob);
+      import(blobUrl).then(function(mod){
+        if(_w.__wfw) _w.__wfw._update(m.url,mod);
+        // Re-import page module so it re-evaluates its __wfw.h() imports
+        var pageUrl=_w.__WFW_PAGE_URL;
+        if(pageUrl&&_w.__WFW_REFRESH){
+          import(pageUrl.split('?')[0]+'?t='+Date.now()).then(function(pageMod){
+            if(pageMod.default) _w.__WFW_REFRESH(pageMod.default);
+            if(m.css){
+              var s=document.querySelector('style[data-lr]')||function(){
+                var x=document.createElement('style');
+                x.setAttribute('data-lr','');
+                document.head.appendChild(x);
+                return x
+              }();
+              s.textContent=m.css
+            }
+          });
+        }else{location.reload()}
+      }).catch(function(){location.reload()});
       return
     }
     if(m.type==='css'){
@@ -7430,12 +7480,12 @@ var ssrEntries = /* @__PURE__ */ new Map();
 
 // tailwind.ts
 import { createHash as createHash2 } from "node:crypto";
-import { existsSync as existsSync2, mkdirSync as mkdirSync2, readFileSync as readFileSync3, writeFileSync } from "node:fs";
-import { join as join3, relative, resolve as resolve4 } from "node:path";
+import { existsSync as existsSync3, mkdirSync as mkdirSync2, readFileSync as readFileSync4, writeFileSync } from "node:fs";
+import { join as join3, relative, resolve as resolve5 } from "node:path";
 var extraSources = /* @__PURE__ */ new Set();
 var cssCache = /* @__PURE__ */ new Map();
 function tailwindContext(dir) {
-  const cssDir = resolve4(dir);
+  const cssDir = resolve5(dir);
   const cssPath = join3(cssDir, "app", "globals.css");
   return async (req, ctx, next) => {
     if (!cssCache.has(cssPath)) {
@@ -7449,10 +7499,10 @@ function tailwindContext(dir) {
   };
 }
 function tailwindRouter(dir) {
-  const cssDir = resolve4(dir);
+  const cssDir = resolve5(dir);
   const cssPath = join3(cssDir, "app", "globals.css");
   const r = new Router();
-  r.get("/__wfw/style/:hash.css", async (_req, _ctx) => {
+  r.get("/__wfw/style/:hash.css", async (_req, _ctx2) => {
     if (!cssCache.has(cssPath)) {
       await compileTailwindCss(cssPath, cssDir);
     }
@@ -7466,13 +7516,13 @@ function tailwindRouter(dir) {
 }
 async function compileTailwindCss(cssPath, cssDir) {
   try {
-    if (!existsSync2(cssPath)) {
+    if (!existsSync3(cssPath)) {
       mkdirSync2(cssDir, { recursive: true });
       writeFileSync(cssPath, '@import "tailwindcss"\n', "utf-8");
     }
     const { default: tailwindPlugin } = await import("@tailwindcss/postcss");
     const { default: postcss } = await import("postcss");
-    let src = readFileSync3(cssPath, "utf-8");
+    let src = readFileSync4(cssPath, "utf-8");
     src = `@source "./";
 ${src}`;
     for (const srcDir of extraSources) {
@@ -7492,22 +7542,151 @@ ${src}`;
 
 // live.ts
 import chokidar from "chokidar";
-import { existsSync as existsSync3 } from "node:fs";
-import { dirname as dirname2, join as join4, resolve as resolve5 } from "node:path";
-var clients = /* @__PURE__ */ new Set();
-var hotBundleCache = /* @__PURE__ */ new Map();
-var hotKeys = [];
-var MAX_HOT = 10;
-function setHot(hash, code) {
-  if (!hotBundleCache.has(hash)) {
-    hotKeys.push(hash);
-    if (hotKeys.length > MAX_HOT) {
-      const old = hotKeys.shift();
-      hotBundleCache.delete(old);
-    }
+import { existsSync as existsSync5 } from "node:fs";
+import { join as join4, resolve as resolve7 } from "node:path";
+
+// module-server.ts
+import * as esbuild3 from "esbuild";
+import { existsSync as existsSync4, readFileSync as readFileSync5 } from "node:fs";
+import { resolve as resolve6, dirname as dirname3, relative as relative2 } from "node:path";
+import { createHash as createHash3 } from "node:crypto";
+var moduleCache = /* @__PURE__ */ new Map();
+var hashCache = /* @__PURE__ */ new Map();
+function clearModuleCache(filePath) {
+  if (filePath) {
+    const abs = resolve6(filePath);
+    for (const key of moduleCache.keys()) {
+      if (key.endsWith(abs)) moduleCache.delete(key);
+    }
+    hashCache.delete(abs);
+  } else {
+    moduleCache.clear();
+    hashCache.clear();
   }
-  hotBundleCache.set(hash, code);
 }
+var _importRoots = [];
+function _setImportRoots(roots) {
+  _importRoots = roots;
+}
+function fileHash(absPath) {
+  const cached = hashCache.get(absPath);
+  if (cached) return cached;
+  try {
+    const content = readFileSync5(absPath);
+    const h = createHash3("md5").update(content).digest("hex").slice(0, 8);
+    hashCache.set(absPath, h);
+    return h;
+  } catch {
+    return "00000000";
+  }
+}
+function rewriteImports(code, absPath, mountPath) {
+  const prefix = mountPath ? `${mountPath}/__wfw/m` : "/__wfw/m";
+  let varCounter = 0;
+  return code.replace(
+    /^(import|export)\s+(.+?)\s+from\s+['"]([^'"]+)['"];?\s*$/gm,
+    (_match, keyword, clause, modPath) => {
+      if (!modPath.startsWith(".")) return _match;
+      const isReexport = keyword === "export";
+      const imports = clause.replace(/^type\s+/, "");
+      const resolved = resolve6(dirname3(absPath), modPath);
+      for (const root of _importRoots) {
+        const rel = relative2(root, resolved);
+        if (!rel.startsWith("..") && !rel.startsWith("/")) {
+          const v = fileHash(resolved);
+          const url = `${prefix}/${rel}?v=${v}`;
+          const defaultMatch = imports.match(/^\s*(\w[\w$]*)\s*$/);
+          const namedMatch = imports.match(/^\s*\{\s*([\w$,\s]+)\s*\}\s*$/);
+          const mixedMatch = imports.match(/^\s*(\w[\w$]*)\s*,\s*\{\s*([\w$,\s]+)\s*\}\s*$/);
+          if (defaultMatch) {
+            const name = defaultMatch[1];
+            if (isReexport) {
+              return `const { default: ${name} } = await __wfw.h("${url}");
+export { ${name} as default }`;
+            }
+            return `const { default: ${name} } = await __wfw.h("${url}");`;
+          }
+          if (namedMatch) {
+            const names = namedMatch[1].split(",").map((s) => s.trim()).filter(Boolean);
+            if (isReexport) {
+              const tmp = `__wfw$${varCounter++}`;
+              const lines = [`const ${tmp} = await __wfw.h("${url}");`];
+              for (const n of names) lines.push(`export const ${n} = ${tmp}.${n};`);
+              return lines.join("\n");
+            }
+            const decl = names.map((n) => `${n}`).join(", ");
+            return `const { ${decl} } = await __wfw.h("${url}");`;
+          }
+          if (mixedMatch) {
+            const defaultName = mixedMatch[1];
+            const namedNames = mixedMatch[2].split(",").map((s) => s.trim()).filter(Boolean);
+            const varName = `__wfw$${varCounter++}`;
+            const lines = [
+              `const ${varName} = await __wfw.h("${url}");`,
+              `const ${defaultName} = ${varName}.default;`
+            ];
+            for (const n of namedNames) lines.push(`const { ${n} } = ${varName};`);
+            return lines.join("\n");
+          }
+          return _match;
+        }
+      }
+      return _match;
+    }
+  );
+}
+async function transformModule(absPath, root, mountPath) {
+  const mp = mountPath || "";
+  const cacheKey = mp + absPath;
+  const cached = moduleCache.get(cacheKey);
+  if (cached) return { url: `${mp}/__wfw/m/${relative2(root, absPath)}`, code: cached };
+  const source = readFileSync5(absPath, "utf-8");
+  const isTsx = absPath.endsWith(".tsx");
+  const result = await esbuild3.transform(source, {
+    loader: isTsx ? "tsx" : "ts",
+    jsx: isTsx ? "automatic" : void 0,
+    jsxImportSource: isTsx ? "react" : void 0,
+    sourcemap: false
+  });
+  let code = result.code;
+  code = rewriteImports(code, absPath, mp);
+  moduleCache.set(cacheKey, code);
+  const url = `${mp}/__wfw/m/${relative2(root, absPath)}`;
+  return { url, code };
+}
+function moduleServer(opts) {
+  const roots = Array.isArray(opts.root) ? opts.root : [opts.root];
+  _setImportRoots(roots);
+  const router = new Router();
+  router.get("/__wfw/m/*", (async (req, ctx) => {
+    const reqUrl = new URL(req.url);
+    const filePath = (ctx.params["*"] || "").split("?")[0];
+    const ext = filePath.split(".").pop();
+    if (ext !== "tsx" && ext !== "ts") {
+      return new Response("Not Found", { status: 404 });
+    }
+    const mountPath = ctx.mountPath || "";
+    for (const root of roots) {
+      const absPath = resolve6(root, filePath);
+      if (existsSync4(absPath)) {
+        try {
+          const { code } = await transformModule(absPath, root, mountPath);
+          return new Response(code, {
+            headers: { "content-type": "application/javascript; charset=utf-8" }
+          });
+        } catch (err) {
+          const msg = err instanceof Error ? err.message : String(err);
+          return new Response(`/* Error: ${msg} */`, { status: 500 });
+        }
+      }
+    }
+    return new Response("Not Found", { status: 404 });
+  }));
+  return router;
+}
+
+// live.ts
+var clients = /* @__PURE__ */ new Set();
 function broadcastReload() {
   for (const ws of clients) {
     try {
@@ -7529,7 +7708,7 @@ function broadcastCss(css) {
 }
 function liveWs() {
   return {
-    open(ws) {
+    open(ws, _ctx2) {
       clients.add(ws);
       ws.on("close", () => clients.delete(ws));
       ws.on("error", () => clients.delete(ws));
@@ -7540,78 +7719,52 @@ function liveRouter(_dir) {
   const r = new Router();
   compileVendorBundle().catch(() => {
   });
-  r.get("/__wfw/h/:hash", async (req, ctx) => {
-    const hash = ctx.params.hash.replace(/\.js$/i, "");
-    const code = hotBundleCache.get(hash);
-    if (!code) return new Response("", { status: 404 });
-    return new Response(code, {
-      headers: { "content-type": "application/javascript; charset=utf-8" }
-    });
-  });
   return r;
 }
 function liveWatcher(dir) {
-  const resolved = resolve5(dir);
-  const entryPath = join4(resolved, "page.tsx");
+  const resolved = resolve7(dir);
   const watcher = chokidar.watch(dir, {
     ignored: /(^|[/\\])\.|node_modules|[/\\]\.weifuwu[/\\]/,
     ignoreInitial: true
   });
-  function findEntries(changedPath) {
-    const matched = [];
-    for (const [, entry] of ssrEntries) {
-      if (!entry.path.startsWith(resolved)) continue;
-      if (entry.path === changedPath) {
-        matched.push(entry.path);
-      } else {
-        const ed = dirname2(entry.path);
-        if (changedPath.startsWith(ed)) matched.push(entry.path);
-      }
-    }
-    if (matched.length === 0) {
-      for (const [, entry] of ssrEntries) {
-        if (entry.path.startsWith(resolved)) matched.push(entry.path);
-      }
-    }
-    return matched;
-  }
   watcher.on("change", async (filePath) => {
     if (/\.tsx?$/i.test(filePath)) {
       if (filePath.endsWith("layout.tsx")) {
         return broadcastReload();
       }
       clearCompileCache();
-      const targets = existsSync3(entryPath) ? [entryPath] : findEntries(resolve5(filePath));
-      if (targets.length === 0) return broadcastReload();
+      clearModuleCache();
       try {
-        let css;
-        const cssPath = join4(resolved, "app", "globals.css");
-        if (existsSync3(cssPath)) {
-          css = await compileTailwindCss(cssPath, resolved);
-        }
-        for (const target of targets) {
-          await compileTsxDev(target);
-          const { hash, code } = await compileHotComponent(target);
-          setHot(hash, code);
-          const entry = id(target);
-          const msg = { type: "component", hash, entry };
-          if (css) msg.css = css;
-          const str = JSON.stringify(msg);
-          for (const ws of clients) {
-            try {
-              ws.send(str);
-            } catch {
-              clients.delete(ws);
-            }
+        await compileTsxDev(filePath);
+      } catch (e) {
+        console.error("server-side recompile failed:", e);
+        return broadcastReload();
+      }
+      let css;
+      const cssPath = join4(resolved, "app", "globals.css");
+      if (existsSync5(cssPath)) {
+        css = await compileTailwindCss(cssPath, resolved);
+      }
+      try {
+        const absPath = resolve7(filePath);
+        const { url, code } = await transformModule(absPath, resolved);
+        const msg = { type: "update", url, code };
+        if (css) msg.css = css;
+        const str = JSON.stringify(msg);
+        for (const ws of clients) {
+          try {
+            ws.send(str);
+          } catch {
+            clients.delete(ws);
           }
         }
       } catch (e) {
-        console.error("live reload failed, fallback to full reload:", e);
+        console.error("module transform failed for HMR:", e);
         broadcastReload();
       }
     } else if (/\.css$/i.test(filePath)) {
       const cssPath = join4(resolved, "app", "globals.css");
-      if (existsSync3(cssPath)) {
+      if (existsSync5(cssPath)) {
         const css = await compileTailwindCss(cssPath, resolved);
         if (css) broadcastCss(css);
       }
@@ -7699,7 +7852,7 @@ var isDev2 = isDev();
 var als2 = new AsyncLocalStorage2();
 __registerAls(() => als2.getStore());
 function hashId(s) {
-  return createHash3("md5").update(s).digest("hex").slice(0, 8);
+  return createHash4("md5").update(s).digest("hex").slice(0, 8);
 }
 function serializeLoaderData(ctx) {
   const ld = ctx.loaderData;
@@ -7774,7 +7927,7 @@ async function resolveRoute(ssrDir, segments, routeCache) {
     return null;
   }
   const pageFile = join5(dir, "page.tsx");
-  if (!existsSync4(pageFile)) {
+  if (!existsSync6(pageFile)) {
     routeCache.set(cacheKey, null);
     return null;
   }
@@ -7785,28 +7938,28 @@ async function resolveRoute(ssrDir, segments, routeCache) {
   let d = dir;
   while (d.startsWith(appDir)) {
     const lf = join5(d, "layout.tsx");
-    if (existsSync4(lf)) layoutFiles.unshift(lf);
+    if (existsSync6(lf)) layoutFiles.unshift(lf);
     if (d === appDir) break;
-    d = dirname3(d);
+    d = dirname4(d);
   }
   const errorFiles = [];
   d = dir;
   while (d.startsWith(appDir)) {
     const ef = join5(d, "error.tsx");
-    if (existsSync4(ef)) errorFiles.unshift(ef);
+    if (existsSync6(ef)) errorFiles.unshift(ef);
     if (d === appDir) break;
-    d = dirname3(d);
+    d = dirname4(d);
   }
   let notFoundFile = null;
   d = dir;
   while (d.startsWith(appDir)) {
     const nf = join5(d, "not-found.tsx");
-    if (existsSync4(nf)) {
+    if (existsSync6(nf)) {
       notFoundFile = nf;
       break;
     }
     if (d === appDir) break;
-    d = dirname3(d);
+    d = dirname4(d);
   }
   const result = {
     routePath: "/" + routeParams.join("/"),
@@ -7818,8 +7971,7 @@ async function resolveRoute(ssrDir, segments, routeCache) {
   routeCache.set(cacheKey, result);
   return result;
 }
-function buildHydrationScript(entryId, ctxJson, base) {
-  const ssrPrefix = `${base}/__ssr`;
+function buildHydrationScript(pageUrl, ctxJson) {
   return `
 <script type="module">
 import { setCtx, TsxContext } from 'weifuwu/react';
@@ -7832,10 +7984,11 @@ setCtx(_ctx);
 const _root = document.getElementById('__weifuwu_root');
 
 async function init() {
-  const { default: Page } = await import('${ssrPrefix}/${entryId}.js');
-  const app = createElement(TsxContext.Provider, { value: _ctx },
-    createElement(Page));
+  const { default: Page } = await import('${pageUrl}');
   ${isDev2 ? `
+  // Store page URL for __wfw runtime
+  window.__WFW_PAGE_URL = '${pageUrl}';
+
   // Stable proxy \u2014 same function ref = React preserves fiber + useState state across HMR
   const _pageImpl = { current: Page };
   const _pageProxy = new Proxy(function __wfw_page(){}, {
@@ -7852,14 +8005,22 @@ async function init() {
   }
   renderPage();
 
+  // HMR: re-render page (sub-modules resolved via __wfw.h() pick up changes)
+  window.__WFW_RERENDER = () => {
+    _tick++;
+    reactRoot.render(createElement(TsxContext.Provider, { value: _ctx },
+      createElement(_pageProxy, { __t: _tick })));
+  };
+
+  // Fallback: swap entire page component
   window.__WFW_REFRESH = async (NewComponent) => {
     const store = globalThis.__WEIFUWU_CTX_STORE?._ctx || _ctx;
     _pageImpl.current = NewComponent;
-    _tick++;
-    reactRoot.render(createElement(TsxContext.Provider, { value: store },
-      createElement(_pageProxy, { __t: _tick })));
+    __WFW_RERENDER();
   };
   ` : `
+  const app = createElement(TsxContext.Provider, { value: _ctx },
+    createElement(Page));
   hydrateRoot(_root, app);
   `}
 }
@@ -7867,8 +8028,8 @@ async function init() {
 init();
 </script>`;
 }
-function renderPage(pageFile, outDir) {
-  const absPath = resolve6(pageFile);
+function renderPage(pageFile, projectDir) {
+  const absPath = resolve8(pageFile);
   const entryId = hashId(absPath);
   ssrEntries.set(entryId, { path: absPath });
   return async (req, ctx) => {
@@ -7897,9 +8058,10 @@ function renderPage(pageFile, outDir) {
       loaderData,
       env: ctx.env ?? {}
     };
+    const pageRelative = relative3(projectDir, absPath);
+    const pageUrl = `${base}/__wfw/m/${pageRelative}`;
     return als2.run(ctxValue, async () => {
       setCtx(ctxValue);
-      await compileBrowser(absPath, outDir);
       let element = createElement3(
         "div",
         { id: "__weifuwu_root" },
@@ -7917,7 +8079,7 @@ function renderPage(pageFile, outDir) {
           loaderData,
           tailwind: ctx.tailwind
         },
-        buildHydrationScript(entryId, JSON.stringify(ctxValue), base)
+        buildHydrationScript(pageUrl, JSON.stringify(ctxValue))
       );
     });
   };
@@ -7932,7 +8094,7 @@ function runChain(mws, handler, req, ctx) {
 }
 function discoverRoutes(dir) {
   const appDir = join5(dir, "app");
-  if (!existsSync4(appDir)) return [];
+  if (!existsSync6(appDir)) return [];
   const result = [];
   function walk(currentDir, routePath) {
     let entries;
@@ -7953,7 +8115,7 @@ function discoverRoutes(dir) {
       } else if (entry.name === "page.tsx") {
         result.push({
           path: routePath || "/",
-          file: relative2(appDir, join5(currentDir, entry.name))
+          file: relative3(appDir, join5(currentDir, entry.name))
         });
       }
     }
@@ -7963,28 +8125,19 @@ function discoverRoutes(dir) {
 }
 function ssr(opts) {
   const r = new Router();
-  const dir = resolve6(opts.dir);
-  const outDir = resolve6(OUT_DIR);
+  const dir = resolve8(opts.dir);
   const routeCache = /* @__PURE__ */ new Map();
+  const wfwRoot = resolve8(import.meta.dirname ?? __dirname);
+  r.use("/", moduleServer({ root: [dir, wfwRoot] }));
   compileVendorBundle().catch(() => {
   });
-  r.get("/__ssr/:file", (req, ctx) => {
-    const filePath = join5(outDir, ctx.params.file);
-    if (!filePath.startsWith(outDir) || !existsSync4(filePath)) {
-      return new Response("Not Found", { status: 404 });
-    }
-    const content = readFileSync4(filePath, "utf-8");
-    return new Response(content, {
-      headers: { "content-type": "application/javascript; charset=utf-8" }
-    });
-  });
   r.get("/__wfw/v/bundle", async () => {
     const code = await compileVendorBundle();
     return new Response(code, {
       headers: { "content-type": "application/javascript; charset=utf-8" }
     });
   });
-  if (existsSync4(join5(dir, "app", "globals.css"))) {
+  if (existsSync6(join5(dir, "app", "globals.css"))) {
     r.use("/", tailwindRouter(dir));
   }
   let devWatcher;
@@ -8020,7 +8173,7 @@ function ssr(opts) {
       ...resolved.layoutFiles.map((f) => layout(f)),
       tailwindContext(dir)
     ];
-    const handler = (req2, ctx2) => renderPage(resolved.pageFile, outDir)(req2, ctx2);
+    const handler = (req2, ctx2) => renderPage(resolved.pageFile, dir)(req2, ctx2);
     return runChain(mws, handler, req, ctx);
   });
   const mod = r;
@@ -8272,13 +8425,13 @@ function createBashTool(ctx) {
         return { stdout: "", stderr: "Command denied: potentially dangerous command", exitCode: 1 };
       }
       const cwd = workdir ? `${ctx.workspace}/${workdir}` : ctx.workspace;
-      return new Promise((resolve14) => {
+      return new Promise((resolve16) => {
         const child = exec(
           command,
           { cwd, timeout: timeout * 1e3, maxBuffer: 1024 * 1024 },
           (error, stdout, stderr) => {
             const truncated = stdout.length > 1e6 || stderr.length > 1e6;
-            resolve14({
+            resolve16({
               stdout: stdout.slice(0, 1e6),
               stderr: stderr.slice(0, 1e6),
               exitCode: error?.code ?? 0,
@@ -8295,8 +8448,8 @@ function createBashTool(ctx) {
 // opencode/tools/read.ts
 import { tool as tool4 } from "ai";
 import { z as z6 } from "zod";
-import { readFileSync as readFileSync5 } from "node:fs";
-import { resolve as resolve7 } from "node:path";
+import { readFileSync as readFileSync7 } from "node:fs";
+import { resolve as resolve9 } from "node:path";
 function createReadTool(ctx) {
   return tool4({
     description: "Read file contents. Supports offset and limit for reading specific line ranges.",
@@ -8306,11 +8459,11 @@ function createReadTool(ctx) {
       limit: z6.number().optional().describe("Number of lines to read")
     }),
     execute: async ({ path: path2, offset, limit }) => {
-      const resolved = resolve7(ctx.workspace, path2);
+      const resolved = resolve9(ctx.workspace, path2);
       if (!isPathAllowed(resolved, ctx.workspace, ctx.permissions.permissions)) {
         return { error: "Path not allowed", content: null, totalLines: 0 };
       }
-      const content = readFileSync5(resolved, "utf-8");
+      const content = readFileSync7(resolved, "utf-8");
       const lines = content.split("\n");
       const totalLines = lines.length;
       if (offset !== void 0) {
@@ -8338,7 +8491,7 @@ function createReadTool(ctx) {
 import { tool as tool5 } from "ai";
 import { z as z7 } from "zod";
 import { writeFileSync as writeFileSync2, mkdirSync as mkdirSync3 } from "node:fs";
-import { resolve as resolve8, dirname as dirname4 } from "node:path";
+import { resolve as resolve10, dirname as dirname5 } from "node:path";
 function createWriteTool(ctx) {
   return tool5({
     description: "Create or overwrite a file. Parent directories are created automatically.",
@@ -8347,11 +8500,11 @@ function createWriteTool(ctx) {
       content: z7.string().describe("File content")
     }),
     execute: async ({ path: path2, content }) => {
-      const resolved = resolve8(ctx.workspace, path2);
+      const resolved = resolve10(ctx.workspace, path2);
       if (!isPathAllowed(resolved, ctx.workspace, ctx.permissions.permissions)) {
         return { error: "Path not allowed" };
       }
-      mkdirSync3(dirname4(resolved), { recursive: true });
+      mkdirSync3(dirname5(resolved), { recursive: true });
       writeFileSync2(resolved, content, "utf-8");
       return { path: path2, size: content.length };
     }
@@ -8361,8 +8514,8 @@ function createWriteTool(ctx) {
 // opencode/tools/edit.ts
 import { tool as tool6 } from "ai";
 import { z as z8 } from "zod";
-import { readFileSync as readFileSync6, writeFileSync as writeFileSync3 } from "node:fs";
-import { resolve as resolve9 } from "node:path";
+import { readFileSync as readFileSync8, writeFileSync as writeFileSync3 } from "node:fs";
+import { resolve as resolve11 } from "node:path";
 function createEditTool(ctx) {
   return tool6({
     description: "Perform exact string replacements in a file. If oldString appears multiple times, provide more surrounding context.",
@@ -8373,11 +8526,11 @@ function createEditTool(ctx) {
       replaceAll: z8.boolean().default(false).describe("Replace all occurrences")
     }),
     execute: async ({ path: path2, oldString, newString, replaceAll }) => {
-      const resolved = resolve9(ctx.workspace, path2);
+      const resolved = resolve11(ctx.workspace, path2);
       if (!isPathAllowed(resolved, ctx.workspace, ctx.permissions.permissions)) {
         return { error: "Path not allowed" };
       }
-      const content = readFileSync6(resolved, "utf-8");
+      const content = readFileSync8(resolved, "utf-8");
       if (replaceAll) {
         if (!content.includes(oldString)) {
           return { error: "oldString not found in file", replaced: 0 };
@@ -8409,8 +8562,8 @@ function createEditTool(ctx) {
 import { tool as tool7 } from "ai";
 import { z as z9 } from "zod";
 import { execFileSync } from "node:child_process";
-import { resolve as resolve10 } from "node:path";
-import { existsSync as existsSync5 } from "node:fs";
+import { resolve as resolve12 } from "node:path";
+import { existsSync as existsSync7 } from "node:fs";
 function createGrepTool(ctx) {
   return tool7({
     description: "Search file contents using regex. Supports file type filtering and context lines.",
@@ -8421,10 +8574,10 @@ function createGrepTool(ctx) {
       context: z9.number().default(0).describe("Number of context lines before and after each match")
     }),
     execute: async ({ pattern, include, path: path2, context }) => {
-      const searchDir = path2 ? resolve10(ctx.workspace, path2) : ctx.workspace;
+      const searchDir = path2 ? resolve12(ctx.workspace, path2) : ctx.workspace;
       try {
         let stdout;
-        if (existsSync5("/usr/bin/rg") || existsSync5("/usr/local/bin/rg")) {
+        if (existsSync7("/usr/bin/rg") || existsSync7("/usr/local/bin/rg")) {
           const args = ["-n"];
           if (context > 0) args.push("-C", String(context));
           if (include) args.push("-g", include);
@@ -8457,7 +8610,7 @@ function createGrepTool(ctx) {
 import { tool as tool8 } from "ai";
 import { z as z10 } from "zod";
 import { execFileSync as execFileSync2 } from "node:child_process";
-import { resolve as resolve11 } from "node:path";
+import { resolve as resolve13 } from "node:path";
 function createGlobTool(ctx) {
   return tool8({
     description: "Find files matching a glob pattern.",
@@ -8466,7 +8619,7 @@ function createGlobTool(ctx) {
       path: z10.string().optional().describe("Subdirectory relative to workspace")
     }),
     execute: async ({ pattern, path: path2 }) => {
-      const searchDir = path2 ? resolve11(ctx.workspace, path2) : ctx.workspace;
+      const searchDir = path2 ? resolve13(ctx.workspace, path2) : ctx.workspace;
       try {
         const stdout = execFileSync2(
           "find",
@@ -8492,7 +8645,7 @@ function createGlobTool(ctx) {
 // opencode/tools/web.ts
 import { tool as tool9 } from "ai";
 import { z as z11 } from "zod";
-function createWebTool(_ctx) {
+function createWebTool(_ctx2) {
   return tool9({
     description: "Fetch a URL and return the content as text.",
     inputSchema: z11.object({
@@ -8528,7 +8681,7 @@ function createQuestionTool(ctx) {
       options: z12.array(z12.string()).optional().describe("Optional multiple choice options")
     }),
     execute: async ({ question, options }, { toolCallId }) => {
-      return new Promise((resolve14, reject) => {
+      return new Promise((resolve16, reject) => {
         const timeout = setTimeout(() => {
           ctx.pendingQuestions.delete(toolCallId);
           reject(new Error("Question timed out"));
@@ -8536,7 +8689,7 @@ function createQuestionTool(ctx) {
         ctx.pendingQuestions.set(toolCallId, {
           resolve: (answer) => {
             clearTimeout(timeout);
-            resolve14(answer);
+            resolve16(answer);
           },
           reject: (err) => {
             clearTimeout(timeout);
@@ -8857,7 +9010,7 @@ function createWSHandler2(deps) {
         clients2.delete(ws);
       }
     },
-    error(ws, _ctx, _err) {
+    error(ws, _ctx2, _err) {
       const client = clients2.get(ws);
       if (client) {
         client.abortController?.abort();
@@ -8870,7 +9023,7 @@ function createWSHandler2(deps) {
 // opencode/skills.ts
 import { readFile, glob } from "node:fs/promises";
 import { homedir } from "node:os";
-import { resolve as resolve12 } from "node:path";
+import { resolve as resolve14 } from "node:path";
 import { parse as parseYaml } from "yaml";
 var SEARCH_DIRS = [
   (ws) => `${ws}/.opencode/skills`,
@@ -8908,7 +9061,7 @@ async function scanDir(dir) {
   try {
     const files = [];
     for await (const entry of glob("*/SKILL.md", { cwd: dir })) {
-      const skill = await parseSkillFile(resolve12(dir, entry));
+      const skill = await parseSkillFile(resolve14(dir, entry));
       if (skill) files.push(skill);
     }
     return files;
@@ -9335,7 +9488,7 @@ function theme(options) {
 
 // i18n.ts
 import { readFile as readFile2, stat as stat2 } from "node:fs/promises";
-import { join as join7, resolve as resolve13 } from "node:path";
+import { join as join7, resolve as resolve15 } from "node:path";
 var DEFAULTS2 = {
   default: "en",
   cookie: "locale",
@@ -9353,7 +9506,7 @@ function translate(msgs, key, params, fallback) {
 }
 function i18n(options) {
   const opts = { ...DEFAULTS2, ...options };
-  const dir = opts.dir ? resolve13(opts.dir) : void 0;
+  const dir = opts.dir ? resolve15(opts.dir) : void 0;
   const cache3 = /* @__PURE__ */ new Map();
   function validLocale(locale) {
     return /^[\w-]+$/.test(locale) && !locale.includes("..");
@@ -10245,7 +10398,7 @@ function createWsHandler(deps) {
     return wsToWorkerId.get(ws) || "";
   }
   return {
-    open(_ws, _ctx) {
+    open(_ws, _ctx2) {
     },
     async message(ws, ctx, data) {
       let msg;
@@ -10447,12 +10600,12 @@ function iii(opts = {}) {
     const handler = async (payload) => {
       if (!worker.ws) throw new Error(`Worker "${worker.name}" disconnected`);
       const invocationId = crypto8.randomUUID();
-      return new Promise((resolve14, reject) => {
+      return new Promise((resolve16, reject) => {
         const timer = setTimeout(() => {
           pending.delete(invocationId);
           reject(new Error(`Invocation timed out for "${id2}"`));
         }, 3e4);
-        pending.set(invocationId, { resolve: resolve14, reject, timer });
+        pending.set(invocationId, { resolve: resolve16, reject, timer });
         worker.ws.send(
           JSON.stringify({
             type: "invoke",
@@ -10703,8 +10856,8 @@ function registerWorker(url) {
   function connect() {
     if (intentionalClose) return;
     ws = new WebSocket(url);
-    ready = new Promise((resolve14) => {
-      resolveReady = resolve14;
+    ready = new Promise((resolve16) => {
+      resolveReady = resolve16;
     });
     ws.onopen = () => {
       reconnectAttempt = 0;
@@ -10835,13 +10988,13 @@ function registerWorker(url) {
         }
         return Promise.resolve(fn(request.payload, ctx));
       }
-      return new Promise((resolve14, reject) => {
+      return new Promise((resolve16, reject) => {
         const invocationId = genId();
         const timer = setTimeout(() => {
           pendingInvocations.delete(invocationId);
           reject(new Error(`Invocation timed out for "${request.function_id}"`));
         }, request.timeout_ms || 3e4);
-        pendingInvocations.set(invocationId, { resolve: resolve14, reject, timer });
+        pendingInvocations.set(invocationId, { resolve: resolve16, reject, timer });
         send({
           type: "invoke",
           invocation_id: invocationId,