@lakphy/local-router 0.4.1 → 0.5.0

package/dist/entry.js

@@ -4934,7 +4934,7 @@ var require_compile = __commonJS((exports) => {
     const schOrFunc = root2.refs[ref];
     if (schOrFunc)
       return schOrFunc;
-    let _sch = resolve6.call(this, root2, ref);
+    let _sch = resolve4.call(this, root2, ref);
     if (_sch === undefined) {
       const schema = (_a21 = root2.localRefs) === null || _a21 === undefined ? undefined : _a21[ref];
       const { schemaId } = this.opts;
@@ -4961,7 +4961,7 @@ var require_compile = __commonJS((exports) => {
   function sameSchemaEnv(s1, s2) {
     return s1.schema === s2.schema && s1.root === s2.root && s1.baseId === s2.baseId;
   }
-  function resolve6(root2, ref) {
+  function resolve4(root2, ref) {
     let sch;
     while (typeof (sch = this.refs[ref]) == "string")
       ref = sch;
@@ -5491,7 +5491,7 @@ var require_fast_uri = __commonJS((exports, module) => {
     }
     return uri;
   }
-  function resolve6(baseURI, relativeURI, options) {
+  function resolve4(baseURI, relativeURI, options) {
     const schemelessOptions = options ? Object.assign({ scheme: "null" }, options) : { scheme: "null" };
     const resolved = resolveComponent(parse7(baseURI, schemelessOptions), parse7(relativeURI, schemelessOptions), schemelessOptions, true);
     schemelessOptions.skipEscape = true;
@@ -5719,7 +5719,7 @@ var require_fast_uri = __commonJS((exports, module) => {
   var fastUri = {
     SCHEMES,
     normalize,
-    resolve: resolve6,
+    resolve: resolve4,
     resolveComponent,
     equal,
     serialize,
@@ -5856,7 +5856,7 @@ var require_core = __commonJS((exports) => {
       opts = this.opts = { ...opts, ...requiredOptions(opts) };
       const { es5, lines } = this.opts.code;
       this.scope = new codegen_2.ValueScope({ scope: {}, prefixes: EXT_SCOPE_NAMES, es5, lines });
-      this.logger = getLogger2(opts.logger);
+      this.logger = getLogger(opts.logger);
       const formatOpt = opts.validateFormats;
       opts.validateFormats = false;
       this.RULES = (0, rules_1.getRules)();
@@ -6253,7 +6253,7 @@ var require_core = __commonJS((exports) => {
     return metaOpts;
   }
   var noLogs = { log() {}, warn() {}, error() {} };
-  function getLogger2(logger) {
+  function getLogger(logger) {
     if (logger === false)
       return noLogs;
     if (logger === undefined)
@@ -40602,6 +40602,267 @@ function createOpenAICompatible(options) {
   provider.imageModel = createImageModel;
   return provider;
 }
+
+// node_modules/.bun/hono@4.12.5/node_modules/hono/dist/utils/html.js
+var HtmlEscapedCallbackPhase = {
+  Stringify: 1,
+  BeforeStream: 2,
+  Stream: 3
+};
+var raw = (value, callbacks) => {
+  const escapedString = new String(value);
+  escapedString.isEscaped = true;
+  escapedString.callbacks = callbacks;
+  return escapedString;
+};
+var escapeRe = /[&<>'"]/;
+var stringBufferToString = async (buffer, callbacks) => {
+  let str = "";
+  callbacks ||= [];
+  const resolvedBuffer = await Promise.all(buffer);
+  for (let i = resolvedBuffer.length - 1;; i--) {
+    str += resolvedBuffer[i];
+    i--;
+    if (i < 0) {
+      break;
+    }
+    let r = resolvedBuffer[i];
+    if (typeof r === "object") {
+      callbacks.push(...r.callbacks || []);
+    }
+    const isEscaped = r.isEscaped;
+    r = await (typeof r === "object" ? r.toString() : r);
+    if (typeof r === "object") {
+      callbacks.push(...r.callbacks || []);
+    }
+    if (r.isEscaped ?? isEscaped) {
+      str += r;
+    } else {
+      const buf = [str];
+      escapeToBuffer(r, buf);
+      str = buf[0];
+    }
+  }
+  return raw(str, callbacks);
+};
+var escapeToBuffer = (str, buffer) => {
+  const match = str.search(escapeRe);
+  if (match === -1) {
+    buffer[0] += str;
+    return;
+  }
+  let escape2;
+  let index;
+  let lastIndex = 0;
+  for (index = match;index < str.length; index++) {
+    switch (str.charCodeAt(index)) {
+      case 34:
+        escape2 = "&quot;";
+        break;
+      case 39:
+        escape2 = "&#39;";
+        break;
+      case 38:
+        escape2 = "&amp;";
+        break;
+      case 60:
+        escape2 = "&lt;";
+        break;
+      case 62:
+        escape2 = "&gt;";
+        break;
+      default:
+        continue;
+    }
+    buffer[0] += str.substring(lastIndex, index) + escape2;
+    lastIndex = index + 1;
+  }
+  buffer[0] += str.substring(lastIndex, index);
+};
+var resolveCallbackSync = (str) => {
+  const callbacks = str.callbacks;
+  if (!callbacks?.length) {
+    return str;
+  }
+  const buffer = [str];
+  const context = {};
+  callbacks.forEach((c) => c({ phase: HtmlEscapedCallbackPhase.Stringify, buffer, context }));
+  return buffer[0];
+};
+var resolveCallback = async (str, phase, preserveCallbacks, context, buffer) => {
+  if (typeof str === "object" && !(str instanceof String)) {
+    if (!(str instanceof Promise)) {
+      str = str.toString();
+    }
+    if (str instanceof Promise) {
+      str = await str;
+    }
+  }
+  const callbacks = str.callbacks;
+  if (!callbacks?.length) {
+    return Promise.resolve(str);
+  }
+  if (buffer) {
+    buffer[0] += str;
+  } else {
+    buffer = [str];
+  }
+  const resStr = Promise.all(callbacks.map((c) => c({ phase, buffer, context }))).then((res) => Promise.all(res.filter(Boolean).map((str2) => resolveCallback(str2, phase, false, context, buffer))).then(() => buffer[0]));
+  if (preserveCallbacks) {
+    return raw(await resStr, callbacks);
+  } else {
+    return resStr;
+  }
+};
+
+// node_modules/.bun/hono@4.12.5/node_modules/hono/dist/helper/html/index.js
+var html = (strings, ...values) => {
+  const buffer = [""];
+  for (let i = 0, len = strings.length - 1;i < len; i++) {
+    buffer[0] += strings[i];
+    const children = Array.isArray(values[i]) ? values[i].flat(Infinity) : [values[i]];
+    for (let i2 = 0, len2 = children.length;i2 < len2; i2++) {
+      const child = children[i2];
+      if (typeof child === "string") {
+        escapeToBuffer(child, buffer);
+      } else if (typeof child === "number") {
+        buffer[0] += child;
+      } else if (typeof child === "boolean" || child === null || child === undefined) {
+        continue;
+      } else if (typeof child === "object" && child.isEscaped) {
+        if (child.callbacks) {
+          buffer.unshift("", child);
+        } else {
+          const tmp = child.toString();
+          if (tmp instanceof Promise) {
+            buffer.unshift("", tmp);
+          } else {
+            buffer[0] += tmp;
+          }
+        }
+      } else if (child instanceof Promise) {
+        buffer.unshift("", child);
+      } else {
+        escapeToBuffer(child.toString(), buffer);
+      }
+    }
+  }
+  buffer[0] += strings.at(-1);
+  return buffer.length === 1 ? "callbacks" in buffer ? raw(resolveCallbackSync(raw(buffer[0], buffer.callbacks))) : raw(buffer[0]) : stringBufferToString(buffer, buffer.callbacks);
+};
+
+// node_modules/.bun/@hono+swagger-ui@0.5.3+bac6debbfb5ded19/node_modules/@hono/swagger-ui/dist/index.js
+var RENDER_TYPE = {
+  STRING_ARRAY: "string_array",
+  STRING: "string",
+  JSON_STRING: "json_string",
+  RAW: "raw"
+};
+var RENDER_TYPE_MAP = {
+  configUrl: RENDER_TYPE.STRING,
+  deepLinking: RENDER_TYPE.RAW,
+  presets: RENDER_TYPE.STRING_ARRAY,
+  plugins: RENDER_TYPE.STRING_ARRAY,
+  spec: RENDER_TYPE.JSON_STRING,
+  url: RENDER_TYPE.STRING,
+  urls: RENDER_TYPE.JSON_STRING,
+  layout: RENDER_TYPE.STRING,
+  docExpansion: RENDER_TYPE.STRING,
+  maxDisplayedTags: RENDER_TYPE.RAW,
+  operationsSorter: RENDER_TYPE.RAW,
+  requestInterceptor: RENDER_TYPE.RAW,
+  responseInterceptor: RENDER_TYPE.RAW,
+  persistAuthorization: RENDER_TYPE.RAW,
+  defaultModelsExpandDepth: RENDER_TYPE.RAW,
+  defaultModelExpandDepth: RENDER_TYPE.RAW,
+  defaultModelRendering: RENDER_TYPE.STRING,
+  displayRequestDuration: RENDER_TYPE.RAW,
+  filter: RENDER_TYPE.RAW,
+  showExtensions: RENDER_TYPE.RAW,
+  showCommonExtensions: RENDER_TYPE.RAW,
+  queryConfigEnabled: RENDER_TYPE.RAW,
+  displayOperationId: RENDER_TYPE.RAW,
+  tagsSorter: RENDER_TYPE.RAW,
+  onComplete: RENDER_TYPE.RAW,
+  syntaxHighlight: RENDER_TYPE.JSON_STRING,
+  tryItOutEnabled: RENDER_TYPE.RAW,
+  requestSnippetsEnabled: RENDER_TYPE.RAW,
+  requestSnippets: RENDER_TYPE.JSON_STRING,
+  oauth2RedirectUrl: RENDER_TYPE.STRING,
+  showMutabledRequest: RENDER_TYPE.RAW,
+  request: RENDER_TYPE.JSON_STRING,
+  supportedSubmitMethods: RENDER_TYPE.JSON_STRING,
+  validatorUrl: RENDER_TYPE.STRING,
+  withCredentials: RENDER_TYPE.RAW,
+  modelPropertyMacro: RENDER_TYPE.RAW,
+  parameterMacro: RENDER_TYPE.RAW
+};
+var renderSwaggerUIOptions = (options) => {
+  return Object.entries(options).map(([k, v]) => {
+    const key = k;
+    if (!RENDER_TYPE_MAP[key] || v === undefined)
+      return "";
+    switch (RENDER_TYPE_MAP[key]) {
+      case RENDER_TYPE.STRING:
+        return `${key}: '${v}'`;
+      case RENDER_TYPE.STRING_ARRAY:
+        if (!Array.isArray(v))
+          return "";
+        return `${key}: [${v.map((ve) => `${ve}`).join(",")}]`;
+      case RENDER_TYPE.JSON_STRING:
+        return `${key}: ${JSON.stringify(v)}`;
+      case RENDER_TYPE.RAW:
+        return `${key}: ${v}`;
+      default:
+        return "";
+    }
+  }).filter((item) => item !== "").join(",");
+};
+var remoteAssets = ({ version: version2 }) => {
+  const url2 = `https://cdn.jsdelivr.net/npm/swagger-ui-dist${version2 !== undefined ? `@${version2}` : ""}`;
+  return {
+    css: [`${url2}/swagger-ui.css`],
+    js: [`${url2}/swagger-ui-bundle.js`]
+  };
+};
+var SwaggerUI = (options) => {
+  const asset = remoteAssets({ version: options?.version });
+  delete options.version;
+  if (options.manuallySwaggerUIHtml)
+    return options.manuallySwaggerUIHtml(asset);
+  const optionsStrings = renderSwaggerUIOptions(options);
+  return `
+    <div>
+      <div id="swagger-ui"></div>
+      ${asset.css.map((url2) => html`<link rel="stylesheet" href="${url2}" />`)}
+      ${asset.js.map((url2) => html`<script src="${url2}" crossorigin="anonymous"><\/script>`)}
+      <script>
+        window.onload = () => {
+          window.ui = SwaggerUIBundle({
+            dom_id: '#swagger-ui',${optionsStrings},
+          })
+        }
+      </script>
+    </div>
+  `;
+};
+var middleware = (options) => async (c) => {
+  const title = options?.title ?? "SwaggerUI";
+  return c.html(`
+      <!doctype html>
+      <html lang="en">
+        <head>
+          <meta charset="utf-8" />
+          <meta name="viewport" content="width=device-width, initial-scale=1" />
+          <meta name="description" content="SwaggerUI" />
+          <title>${title}</title>
+        </head>
+        <body>
+          ${SwaggerUI(options)}
+        </body>
+      </html>
+    `);
+};
 // node_modules/.bun/@ai-sdk+gateway@3.0.66+3c5d820c62823f0b/node_modules/@ai-sdk/gateway/dist/index.mjs
 var import_oidc = __toESM(require_dist(), 1);
 var import_oidc2 = __toESM(require_dist(), 1);
@@ -48100,267 +48361,6 @@ var _a20;
 _a20 = symbol20;
 var defaultDownload2 = createDownload();
 
-// node_modules/.bun/hono@4.12.5/node_modules/hono/dist/utils/html.js
-var HtmlEscapedCallbackPhase = {
-  Stringify: 1,
-  BeforeStream: 2,
-  Stream: 3
-};
-var raw = (value, callbacks) => {
-  const escapedString = new String(value);
-  escapedString.isEscaped = true;
-  escapedString.callbacks = callbacks;
-  return escapedString;
-};
-var escapeRe = /[&<>'"]/;
-var stringBufferToString = async (buffer, callbacks) => {
-  let str = "";
-  callbacks ||= [];
-  const resolvedBuffer = await Promise.all(buffer);
-  for (let i = resolvedBuffer.length - 1;; i--) {
-    str += resolvedBuffer[i];
-    i--;
-    if (i < 0) {
-      break;
-    }
-    let r = resolvedBuffer[i];
-    if (typeof r === "object") {
-      callbacks.push(...r.callbacks || []);
-    }
-    const isEscaped = r.isEscaped;
-    r = await (typeof r === "object" ? r.toString() : r);
-    if (typeof r === "object") {
-      callbacks.push(...r.callbacks || []);
-    }
-    if (r.isEscaped ?? isEscaped) {
-      str += r;
-    } else {
-      const buf = [str];
-      escapeToBuffer(r, buf);
-      str = buf[0];
-    }
-  }
-  return raw(str, callbacks);
-};
-var escapeToBuffer = (str, buffer) => {
-  const match = str.search(escapeRe);
-  if (match === -1) {
-    buffer[0] += str;
-    return;
-  }
-  let escape2;
-  let index;
-  let lastIndex = 0;
-  for (index = match;index < str.length; index++) {
-    switch (str.charCodeAt(index)) {
-      case 34:
-        escape2 = "&quot;";
-        break;
-      case 39:
-        escape2 = "&#39;";
-        break;
-      case 38:
-        escape2 = "&amp;";
-        break;
-      case 60:
-        escape2 = "&lt;";
-        break;
-      case 62:
-        escape2 = "&gt;";
-        break;
-      default:
-        continue;
-    }
-    buffer[0] += str.substring(lastIndex, index) + escape2;
-    lastIndex = index + 1;
-  }
-  buffer[0] += str.substring(lastIndex, index);
-};
-var resolveCallbackSync = (str) => {
-  const callbacks = str.callbacks;
-  if (!callbacks?.length) {
-    return str;
-  }
-  const buffer = [str];
-  const context2 = {};
-  callbacks.forEach((c) => c({ phase: HtmlEscapedCallbackPhase.Stringify, buffer, context: context2 }));
-  return buffer[0];
-};
-var resolveCallback = async (str, phase, preserveCallbacks, context2, buffer) => {
-  if (typeof str === "object" && !(str instanceof String)) {
-    if (!(str instanceof Promise)) {
-      str = str.toString();
-    }
-    if (str instanceof Promise) {
-      str = await str;
-    }
-  }
-  const callbacks = str.callbacks;
-  if (!callbacks?.length) {
-    return Promise.resolve(str);
-  }
-  if (buffer) {
-    buffer[0] += str;
-  } else {
-    buffer = [str];
-  }
-  const resStr = Promise.all(callbacks.map((c) => c({ phase, buffer, context: context2 }))).then((res) => Promise.all(res.filter(Boolean).map((str2) => resolveCallback(str2, phase, false, context2, buffer))).then(() => buffer[0]));
-  if (preserveCallbacks) {
-    return raw(await resStr, callbacks);
-  } else {
-    return resStr;
-  }
-};
-
-// node_modules/.bun/hono@4.12.5/node_modules/hono/dist/helper/html/index.js
-var html = (strings, ...values) => {
-  const buffer = [""];
-  for (let i = 0, len = strings.length - 1;i < len; i++) {
-    buffer[0] += strings[i];
-    const children = Array.isArray(values[i]) ? values[i].flat(Infinity) : [values[i]];
-    for (let i2 = 0, len2 = children.length;i2 < len2; i2++) {
-      const child = children[i2];
-      if (typeof child === "string") {
-        escapeToBuffer(child, buffer);
-      } else if (typeof child === "number") {
-        buffer[0] += child;
-      } else if (typeof child === "boolean" || child === null || child === undefined) {
-        continue;
-      } else if (typeof child === "object" && child.isEscaped) {
-        if (child.callbacks) {
-          buffer.unshift("", child);
-        } else {
-          const tmp = child.toString();
-          if (tmp instanceof Promise) {
-            buffer.unshift("", tmp);
-          } else {
-            buffer[0] += tmp;
-          }
-        }
-      } else if (child instanceof Promise) {
-        buffer.unshift("", child);
-      } else {
-        escapeToBuffer(child.toString(), buffer);
-      }
-    }
-  }
-  buffer[0] += strings.at(-1);
-  return buffer.length === 1 ? "callbacks" in buffer ? raw(resolveCallbackSync(raw(buffer[0], buffer.callbacks))) : raw(buffer[0]) : stringBufferToString(buffer, buffer.callbacks);
-};
-
-// node_modules/.bun/@hono+swagger-ui@0.5.3+bac6debbfb5ded19/node_modules/@hono/swagger-ui/dist/index.js
-var RENDER_TYPE = {
-  STRING_ARRAY: "string_array",
-  STRING: "string",
-  JSON_STRING: "json_string",
-  RAW: "raw"
-};
-var RENDER_TYPE_MAP = {
-  configUrl: RENDER_TYPE.STRING,
-  deepLinking: RENDER_TYPE.RAW,
-  presets: RENDER_TYPE.STRING_ARRAY,
-  plugins: RENDER_TYPE.STRING_ARRAY,
-  spec: RENDER_TYPE.JSON_STRING,
-  url: RENDER_TYPE.STRING,
-  urls: RENDER_TYPE.JSON_STRING,
-  layout: RENDER_TYPE.STRING,
-  docExpansion: RENDER_TYPE.STRING,
-  maxDisplayedTags: RENDER_TYPE.RAW,
-  operationsSorter: RENDER_TYPE.RAW,
-  requestInterceptor: RENDER_TYPE.RAW,
-  responseInterceptor: RENDER_TYPE.RAW,
-  persistAuthorization: RENDER_TYPE.RAW,
-  defaultModelsExpandDepth: RENDER_TYPE.RAW,
-  defaultModelExpandDepth: RENDER_TYPE.RAW,
-  defaultModelRendering: RENDER_TYPE.STRING,
-  displayRequestDuration: RENDER_TYPE.RAW,
-  filter: RENDER_TYPE.RAW,
-  showExtensions: RENDER_TYPE.RAW,
-  showCommonExtensions: RENDER_TYPE.RAW,
-  queryConfigEnabled: RENDER_TYPE.RAW,
-  displayOperationId: RENDER_TYPE.RAW,
-  tagsSorter: RENDER_TYPE.RAW,
-  onComplete: RENDER_TYPE.RAW,
-  syntaxHighlight: RENDER_TYPE.JSON_STRING,
-  tryItOutEnabled: RENDER_TYPE.RAW,
-  requestSnippetsEnabled: RENDER_TYPE.RAW,
-  requestSnippets: RENDER_TYPE.JSON_STRING,
-  oauth2RedirectUrl: RENDER_TYPE.STRING,
-  showMutabledRequest: RENDER_TYPE.RAW,
-  request: RENDER_TYPE.JSON_STRING,
-  supportedSubmitMethods: RENDER_TYPE.JSON_STRING,
-  validatorUrl: RENDER_TYPE.STRING,
-  withCredentials: RENDER_TYPE.RAW,
-  modelPropertyMacro: RENDER_TYPE.RAW,
-  parameterMacro: RENDER_TYPE.RAW
-};
-var renderSwaggerUIOptions = (options) => {
-  return Object.entries(options).map(([k, v]) => {
-    const key = k;
-    if (!RENDER_TYPE_MAP[key] || v === undefined)
-      return "";
-    switch (RENDER_TYPE_MAP[key]) {
-      case RENDER_TYPE.STRING:
-        return `${key}: '${v}'`;
-      case RENDER_TYPE.STRING_ARRAY:
-        if (!Array.isArray(v))
-          return "";
-        return `${key}: [${v.map((ve) => `${ve}`).join(",")}]`;
-      case RENDER_TYPE.JSON_STRING:
-        return `${key}: ${JSON.stringify(v)}`;
-      case RENDER_TYPE.RAW:
-        return `${key}: ${v}`;
-      default:
-        return "";
-    }
-  }).filter((item) => item !== "").join(",");
-};
-var remoteAssets = ({ version: version2 }) => {
-  const url2 = `https://cdn.jsdelivr.net/npm/swagger-ui-dist${version2 !== undefined ? `@${version2}` : ""}`;
-  return {
-    css: [`${url2}/swagger-ui.css`],
-    js: [`${url2}/swagger-ui-bundle.js`]
-  };
-};
-var SwaggerUI = (options) => {
-  const asset = remoteAssets({ version: options?.version });
-  delete options.version;
-  if (options.manuallySwaggerUIHtml)
-    return options.manuallySwaggerUIHtml(asset);
-  const optionsStrings = renderSwaggerUIOptions(options);
-  return `
-    <div>
-      <div id="swagger-ui"></div>
-      ${asset.css.map((url2) => html`<link rel="stylesheet" href="${url2}" />`)}
-      ${asset.js.map((url2) => html`<script src="${url2}" crossorigin="anonymous"><\/script>`)}
-      <script>
-        window.onload = () => {
-          window.ui = SwaggerUIBundle({
-            dom_id: '#swagger-ui',${optionsStrings},
-          })
-        }
-      </script>
-    </div>
-  `;
-};
-var middleware = (options) => async (c) => {
-  const title = options?.title ?? "SwaggerUI";
-  return c.html(`
-      <!doctype html>
-      <html lang="en">
-        <head>
-          <meta charset="utf-8" />
-          <meta name="viewport" content="width=device-width, initial-scale=1" />
-          <meta name="description" content="SwaggerUI" />
-          <title>${title}</title>
-        </head>
-        <body>
-          ${SwaggerUI(options)}
-        </body>
-      </html>
-    `);
-};
-
 // node_modules/.bun/hono@4.12.5/node_modules/hono/dist/compose.js
 var compose = (middleware2, onError, onNotFound) => {
   return (context2, next) => {
@@ -51277,6 +51277,14 @@ var DEFAULT_CONFIG = `{
     // },
   },
 
+  // \u901A\u7528\u670D\u52A1\u8BBE\u7F6E
+  server: {
+    // \u9ED8\u8BA4\u5173\u95ED\u5C40\u57DF\u7F51\u8BBF\u95EE\u3002\u5F00\u542F\u540E\uFF0C\u5C40\u57DF\u7F51\u5185\u5176\u4ED6\u8BBE\u5907\u53EF\u8BBF\u95EE\u672C\u670D\u52A1\u3002
+    lanAccess: {
+      enabled: false,
+    },
+  },
+
   // \u65E5\u5FD7\u914D\u7F6E\uFF08\u53EF\u9009\uFF0C\u4E0D\u914D\u7F6E\u5219\u4E0D\u542F\u7528\u65E5\u5FD7\u8BB0\u5F55\uFF09
   // log: {
   //   enabled: true,
@@ -51347,8 +51355,8 @@ function resolveLogBaseDir(logConfig) {
 }
 
 // src/config-store.ts
-import { resolve as resolve3 } from "path";
 import { writeFileSync as writeFileSync2 } from "fs";
+import { resolve as resolve3 } from "path";
 class ConfigStore {
   config;
   absolutePath;
@@ -51384,6 +51392,51 @@ class ConfigStore {
   }
 }
 
+// src/config-validate.ts
+var import__2020 = __toESM(require_2020(), 1);
+var import_ajv_formats = __toESM(require_dist2(), 1);
+import { readFileSync as readFileSync2 } from "fs";
+
+// src/runtime-assets.ts
+import { fileURLToPath } from "url";
+function resolveBundledAssetPath(relativePath) {
+  return fileURLToPath(new URL(relativePath, import.meta.url));
+}
+function getBundledSchemaPath() {
+  return resolveBundledAssetPath("../config.schema.json");
+}
+function getBundledWebRoot() {
+  return resolveBundledAssetPath("../dist/web/");
+}
+
+// src/config-validate.ts
+function validateBusinessRules(config2) {
+  for (const [routeType, modelMap] of Object.entries(config2.routes)) {
+    if (!modelMap["*"]) {
+      throw new Error(`\u8DEF\u7531 "${routeType}" \u7F3A\u5C11 "*" \u515C\u5E95\u89C4\u5219`);
+    }
+    for (const target of Object.values(modelMap)) {
+      if (!config2.providers[target.provider]) {
+        throw new Error(`\u8DEF\u7531 "${routeType}" \u5F15\u7528\u4E86\u4E0D\u5B58\u5728\u7684 provider "${target.provider}"`);
+      }
+    }
+  }
+}
+function validateConfigOrThrow(config2) {
+  validateBusinessRules(config2);
+  const ajv = new import__2020.default({ allErrors: true, strict: false });
+  import_ajv_formats.default(ajv);
+  const schemaJson = JSON.parse(readFileSync2(getBundledSchemaPath(), "utf-8"));
+  const validateBySchema = ajv.compile(schemaJson);
+  const valid = validateBySchema(config2);
+  if (!valid) {
+    const firstError = validateBySchema.errors?.[0];
+    const path = firstError?.instancePath || "(root)";
+    const message = firstError?.message ?? "unknown schema validation error";
+    throw new Error(`Schema \u6821\u9A8C\u5931\u8D25: ${path} ${message}`);
+  }
+}
+
 // src/crypto.ts
 var ECDH_PARAMS = { name: "ECDH", namedCurve: "P-256" };
 function base64Encode(buf) {
@@ -51736,10 +51789,23 @@ async function getLogMetrics(options) {
 }
 
 // src/log-query.ts
-import { createReadStream as createReadStream2, existsSync as existsSync3, readFileSync as readFileSync2 } from "fs";
-import { join as join4, resolve as resolve4 } from "path";
+import { createReadStream as createReadStream3, existsSync as existsSync4, readFileSync as readFileSync3 } from "fs";
+import { join as join5, resolve as resolve4 } from "path";
 import { createInterface as createInterface2 } from "readline";
 
+// src/log-index.ts
+import { Database } from "bun:sqlite";
+import {
+  closeSync,
+  createReadStream as createReadStream2,
+  existsSync as existsSync3,
+  mkdirSync as mkdirSync2,
+  openSync,
+  readSync,
+  statSync
+} from "fs";
+import { join as join4 } from "path";
+
 // src/log-session-identity.ts
 var USER_SESSION_DELIMITER = "_account__session_";
 function toRecord(value) {
@@ -51816,6 +51882,824 @@ function resolveLogSessionIdentity(requestBody) {
   };
 }
 
+// src/log-index.ts
+var SCHEMA_VERSION = 1;
+var MAX_INDEX_QUEUE = 20000;
+var INDEX_BATCH_SIZE = 250;
+var INDEX_FLUSH_DELAY_MS = 50;
+var LIKE_SEARCH_THRESHOLD = 2;
+var FTS_TOKEN_PATTERN = /[\p{L}\p{N}_-]+/gu;
+var singleton = null;
+function encodeBase64Url(value) {
+  return Buffer.from(value, "utf-8").toString("base64url");
+}
+function decodeBase64Url(value) {
+  return Buffer.from(value, "base64url").toString("utf-8");
+}
+function encodeOffsetLogEventId(date5, offset) {
+  return encodeBase64Url(JSON.stringify({ v: 2, d: date5, o: offset }));
+}
+function decodeOffsetLogEventId(id) {
+  try {
+    const parsed = JSON.parse(decodeBase64Url(id));
+    if (parsed.v !== 2 || typeof parsed.d !== "string" || !Number.isInteger(parsed.o)) {
+      return null;
+    }
+    const offset = Number(parsed.o);
+    if (offset < 0)
+      return null;
+    return { v: 2, date: parsed.d, offset };
+  } catch {
+    return null;
+  }
+}
+function encodeCursor(data) {
+  return encodeBase64Url(JSON.stringify(data));
+}
+function decodeCursor(raw2) {
+  const parsed = JSON.parse(decodeBase64Url(raw2));
+  if (parsed.v !== 2 || parsed.sort !== "time_desc" && parsed.sort !== "time_asc" || typeof parsed.id !== "string" || typeof parsed.queryHash !== "string" || !Number.isFinite(parsed.tsMs)) {
+    throw new Error("cursor \u975E\u6CD5");
+  }
+  return parsed;
+}
+function toDayStart2(ms) {
+  const date5 = new Date(ms);
+  return Date.UTC(date5.getUTCFullYear(), date5.getUTCMonth(), date5.getUTCDate());
+}
+function listDateStrings2(fromMs, toMs) {
+  const result = [];
+  for (let day = toDayStart2(fromMs);day <= toDayStart2(toMs); day += 24 * 60 * 60 * 1000) {
+    result.push(new Date(day).toISOString().slice(0, 10));
+  }
+  return result;
+}
+function getStatusClass2(event) {
+  if (event.error_type)
+    return "network_error";
+  const status = event.upstream_status ?? 0;
+  if (status >= 200 && status < 300)
+    return "2xx";
+  if (status >= 400 && status < 500)
+    return "4xx";
+  if (status >= 500)
+    return "5xx";
+  return "network_error";
+}
+function isErrorEvent2(event) {
+  if (event.error_type)
+    return true;
+  const status = event.upstream_status ?? 0;
+  return status < 200 || status >= 400;
+}
+function getLevel(event) {
+  return isErrorEvent2(event) ? "error" : "info";
+}
+function buildMessage(event) {
+  if (event.error_message)
+    return event.error_message;
+  if (event.error_type)
+    return event.error_type;
+  const status = event.upstream_status ?? 0;
+  return `${event.method} ${event.path} -> ${status}`;
+}
+function toPercent2(numerator, denominator) {
+  if (denominator <= 0)
+    return 0;
+  return Number((numerator / denominator * 100).toFixed(2));
+}
+function hashQuery(query) {
+  const stable = {
+    fromMs: query.fromMs,
+    toMs: query.toMs,
+    levels: [...query.levels].sort(),
+    providers: [...query.providers].sort(),
+    routeTypes: [...query.routeTypes].sort(),
+    models: [...query.models].sort(),
+    modelIns: [...query.modelIns].sort(),
+    modelOuts: [...query.modelOuts].sort(),
+    users: [...query.users].sort(),
+    sessions: [...query.sessions].sort(),
+    statusClasses: [...query.statusClasses].sort(),
+    hasError: query.hasError,
+    q: query.q
+  };
+  return Bun.hash(JSON.stringify(stable)).toString(36);
+}
+function buildSearchText(event) {
+  const identity = resolveLogSessionIdentity(event.request_body);
+  return [
+    event.request_id,
+    event.path,
+    event.provider,
+    event.model_in,
+    event.model_out,
+    event.route_type,
+    identity.userIdRaw ?? "",
+    identity.userKey ?? "",
+    identity.sessionId ?? "",
+    event.error_type ?? "",
+    event.error_message ?? "",
+    buildMessage(event)
+  ].join(" ").toLowerCase();
+}
+function buildFtsQuery(q) {
+  const tokens = q.match(FTS_TOKEN_PATTERN)?.map((token2) => token2.trim()).filter(Boolean) ?? [];
+  if (tokens.length === 0)
+    return null;
+  return tokens.map((token2) => `"${token2.replaceAll('"', '""')}"`).join(" AND ");
+}
+function shouldUseFts(q) {
+  return q.trim().length >= LIKE_SEARCH_THRESHOLD && buildFtsQuery(q) !== null;
+}
+function escapeLikePattern(value) {
+  return value.replaceAll("\\", "\\\\").replaceAll("%", "\\%").replaceAll("_", "\\_");
+}
+function eventToRow(input) {
+  const { event } = input;
+  if (!event.ts_start)
+    return null;
+  const tsMs = Date.parse(event.ts_start);
+  if (!Number.isFinite(tsMs))
+    return null;
+  const identity = resolveLogSessionIdentity(event.request_body);
+  const level = getLevel(event);
+  const statusClass = getStatusClass2(event);
+  const latencyMs = Math.max(0, event.latency_ms ?? 0);
+  const model = event.model_out || event.model_in;
+  return {
+    id: input.id,
+    ts_ms: tsMs,
+    ts_start: event.ts_start,
+    level,
+    provider: event.provider,
+    route_type: event.route_type,
+    model,
+    model_in: event.model_in,
+    model_out: event.model_out,
+    path: event.path,
+    request_id: event.request_id,
+    latency_ms: latencyMs,
+    upstream_status: event.upstream_status ?? 0,
+    status_class: statusClass,
+    has_error: level === "error" ? 1 : 0,
+    message: buildMessage(event),
+    error_type: event.error_type,
+    has_metadata: identity.hasMetadata ? 1 : 0,
+    user_id_raw: identity.userIdRaw,
+    user_key: identity.userKey,
+    session_id: identity.sessionId,
+    source_date: input.date,
+    source_file: input.filePath,
+    line_number: input.lineNumber,
+    byte_offset: input.offset,
+    byte_length: input.byteLength,
+    search_text: buildSearchText(event)
+  };
+}
+function rowToSummary(row) {
+  return {
+    id: row.id,
+    ts: row.ts_start,
+    level: row.level,
+    provider: row.provider,
+    routeType: row.route_type,
+    model: row.model,
+    modelIn: row.model_in,
+    modelOut: row.model_out,
+    path: row.path,
+    requestId: row.request_id,
+    latencyMs: row.latency_ms,
+    upstreamStatus: row.upstream_status,
+    statusClass: row.status_class,
+    hasError: row.has_error === 1,
+    message: row.message,
+    errorType: row.error_type,
+    hasMetadata: row.has_metadata === 1,
+    userIdRaw: row.user_id_raw,
+    userKey: row.user_key,
+    sessionId: row.session_id
+  };
+}
+async function* readJsonlLinesWithOffsets(filePath) {
+  const stream = createReadStream2(filePath);
+  let buffer2 = Buffer.alloc(0);
+  let bufferOffset = 0;
+  let lineNumber = 0;
+  for await (const chunk of stream) {
+    const chunkBuffer = Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk);
+    buffer2 = buffer2.length === 0 ? chunkBuffer : Buffer.concat([buffer2, chunkBuffer]);
+    let newlineIndex = buffer2.indexOf(10);
+    while (newlineIndex !== -1) {
+      const lineBuffer = buffer2.subarray(0, newlineIndex);
+      const byteLength = newlineIndex + 1;
+      const lineOffset = bufferOffset;
+      lineNumber += 1;
+      yield {
+        line: lineBuffer.toString("utf-8").replace(/\r$/, ""),
+        offset: lineOffset,
+        lineNumber,
+        byteLength
+      };
+      buffer2 = buffer2.subarray(byteLength);
+      bufferOffset += byteLength;
+      newlineIndex = buffer2.indexOf(10);
+    }
+  }
+  if (buffer2.length > 0) {
+    lineNumber += 1;
+    yield {
+      line: buffer2.toString("utf-8").replace(/\r$/, ""),
+      offset: bufferOffset,
+      lineNumber,
+      byteLength: buffer2.length
+    };
+  }
+}
+function readLineAtOffset(filePath, offset) {
+  const fd = openSync(filePath, "r");
+  try {
+    const chunks = [];
+    const buffer2 = Buffer.allocUnsafe(64 * 1024);
+    let position = offset;
+    while (true) {
+      const bytesRead = readSync(fd, buffer2, 0, buffer2.length, position);
+      if (bytesRead <= 0)
+        break;
+      const readable = buffer2.subarray(0, bytesRead);
+      const newline = readable.indexOf(10);
+      if (newline >= 0 && newline < bytesRead) {
+        chunks.push(Buffer.from(readable.subarray(0, newline)));
+        break;
+      }
+      chunks.push(Buffer.from(readable));
+      position += bytesRead;
+    }
+    if (chunks.length === 0)
+      return null;
+    return Buffer.concat(chunks).toString("utf-8").replace(/\r$/, "");
+  } finally {
+    closeSync(fd);
+  }
+}
+function createEmptyStats() {
+  return {
+    total: 0,
+    errorCount: 0,
+    errorRate: 0,
+    avgLatencyMs: 0,
+    p95LatencyMs: 0
+  };
+}
+function createEmptyQueryResult(query, meta3 = {}) {
+  return {
+    items: [],
+    nextCursor: null,
+    hasMore: false,
+    stats: createEmptyStats(),
+    meta: {
+      scannedFiles: 0,
+      scannedLines: 0,
+      parseErrors: 0,
+      truncated: false,
+      indexUsed: true,
+      indexFresh: true,
+      usesFts: shouldUseFts(query.q),
+      queryMs: 0,
+      rowsReturned: 0,
+      statsMode: "exact",
+      ...meta3
+    }
+  };
+}
+function appendInClause(clauses, params, column2, values) {
+  if (values.length === 0)
+    return;
+  clauses.push(`${column2} IN (${values.map(() => "?").join(", ")})`);
+  params.push(...values);
+}
+function buildWhereClause(query, options = {}) {
+  const clauses = ["e.ts_ms >= ?", "e.ts_ms <= ?"];
+  const params = [query.fromMs, query.toMs];
+  const usesFts = !options.forceLikeSearch && shouldUseFts(query.q);
+  appendInClause(clauses, params, "e.level", query.levels);
+  appendInClause(clauses, params, "e.provider", query.providers);
+  appendInClause(clauses, params, "e.route_type", query.routeTypes);
+  appendInClause(clauses, params, "e.model", query.models);
+  appendInClause(clauses, params, "e.model_in", query.modelIns);
+  appendInClause(clauses, params, "e.model_out", query.modelOuts);
+  appendInClause(clauses, params, "e.status_class", query.statusClasses);
+  if (query.users.length > 0) {
+    clauses.push(`(e.user_id_raw IN (${query.users.map(() => "?").join(", ")}) OR e.user_key IN (${query.users.map(() => "?").join(", ")}))`);
+    params.push(...query.users, ...query.users);
+  }
+  appendInClause(clauses, params, "e.session_id", query.sessions);
+  if (query.hasError !== null) {
+    clauses.push("e.has_error = ?");
+    params.push(query.hasError ? 1 : 0);
+  }
+  if (query.q) {
+    if (usesFts) {
+      const ftsQuery = buildFtsQuery(query.q);
+      clauses.push("e.id IN (SELECT event_id FROM log_events_fts WHERE log_events_fts MATCH ?)");
+      params.push(ftsQuery);
+    } else {
+      clauses.push("e.search_text LIKE ? ESCAPE '\\'");
+      params.push(`%${escapeLikePattern(query.q.toLowerCase())}%`);
+    }
+  }
+  return {
+    whereSql: clauses.length > 0 ? `WHERE ${clauses.join(" AND ")}` : "",
+    params,
+    usesFts
+  };
+}
+
+class LogIndex {
+  baseDir;
+  config;
+  db;
+  queue = [];
+  flushTimer = null;
+  disposed = false;
+  rebuildingFiles = new Set;
+  dirtyFiles = new Set;
+  insertEventStmt;
+  insertFtsStmt;
+  deleteFtsStmt;
+  upsertFileStmt;
+  constructor(baseDir, config2) {
+    this.baseDir = baseDir;
+    this.config = config2;
+    mkdirSync2(baseDir, { recursive: true });
+    const dbPath = join4(baseDir, "logs-index.sqlite");
+    this.db = new Database(dbPath, { create: true, strict: true });
+    this.configure();
+    this.migrate();
+    this.insertEventStmt = this.db.prepare(`
+      INSERT OR REPLACE INTO log_events (
+        id, ts_ms, ts_start, level, provider, route_type, model, model_in, model_out,
+        path, request_id, latency_ms, upstream_status, status_class, has_error,
+        message, error_type, has_metadata, user_id_raw, user_key, session_id,
+        source_date, source_file, line_number, byte_offset, byte_length, search_text
+      ) VALUES (
+        $id, $ts_ms, $ts_start, $level, $provider, $route_type, $model, $model_in, $model_out,
+        $path, $request_id, $latency_ms, $upstream_status, $status_class, $has_error,
+        $message, $error_type, $has_metadata, $user_id_raw, $user_key, $session_id,
+        $source_date, $source_file, $line_number, $byte_offset, $byte_length, $search_text
+      )
+    `);
+    this.deleteFtsStmt = this.db.prepare("DELETE FROM log_events_fts WHERE event_id = ?");
+    this.insertFtsStmt = this.db.prepare("INSERT INTO log_events_fts(event_id, search_text) VALUES (?, ?)");
+    this.upsertFileStmt = this.db.prepare(`
+      INSERT INTO log_index_files(file_path, source_date, size_bytes, mtime_ms, indexed_at)
+      VALUES (?, ?, ?, ?, ?)
+      ON CONFLICT(file_path) DO UPDATE SET
+        source_date = excluded.source_date,
+        size_bytes = excluded.size_bytes,
+        mtime_ms = excluded.mtime_ms,
+        indexed_at = excluded.indexed_at
+    `);
+  }
+  dispose() {
+    if (this.flushTimer) {
+      clearTimeout(this.flushTimer);
+      this.flushTimer = null;
+    }
+    this.queue = [];
+    this.disposed = true;
+    this.db.close();
+  }
+  enqueue(item) {
+    if (this.disposed)
+      return;
+    if (this.queue.length >= MAX_INDEX_QUEUE) {
+      const dropped = this.queue.shift();
+      if (dropped) {
+        this.dirtyFiles.add(dropped.filePath);
+      }
+    }
+    this.queue.push(item);
+    if (!this.flushTimer) {
+      this.flushTimer = setTimeout(() => {
+        this.flushTimer = null;
+        this.flushQueue();
+      }, INDEX_FLUSH_DELAY_MS);
+      this.flushTimer.unref?.();
+    }
+  }
+  async ensureRangeIndexed(fromMs, toMs) {
+    let scannedFiles = 0;
+    let scannedLines = 0;
+    let parseErrors = 0;
+    const eventsDir = join4(this.baseDir, "events");
+    const dates = listDateStrings2(fromMs, toMs);
+    for (const date5 of dates) {
+      const filePath = join4(eventsDir, `${date5}.jsonl`);
+      if (!existsSync3(filePath))
+        continue;
+      const stats = statSync(filePath);
+      const fileRow = this.db.query("SELECT size_bytes, mtime_ms FROM log_index_files WHERE file_path = ?").get(filePath);
+      const sizeBytes = stats.size;
+      const mtimeMs = Math.trunc(stats.mtimeMs);
+      if (!this.dirtyFiles.has(filePath) && fileRow && fileRow.size_bytes === sizeBytes && fileRow.mtime_ms === mtimeMs) {
+        continue;
+      }
+      const result = await this.rebuildFile(filePath, date5, sizeBytes, mtimeMs);
+      scannedFiles += 1;
+      scannedLines += result.scannedLines;
+      parseErrors += result.parseErrors;
+    }
+    return { scannedFiles, scannedLines, parseErrors };
+  }
+  queryEvents(query, options = {}) {
+    const startedAt = performance.now();
+    const queryHash = hashQuery(query);
+    const decodedCursor = query.cursor ? decodeCursor(query.cursor) : null;
+    if (decodedCursor) {
+      if (decodedCursor.sort !== query.sort || decodedCursor.queryHash !== queryHash) {
+        throw new Error("cursor \u4E0E\u5F53\u524D\u67E5\u8BE2\u6761\u4EF6\u4E0D\u5339\u914D");
+      }
+    }
+    const { whereSql, params, usesFts } = buildWhereClause(query, options);
+    const cursorClause = decodedCursor ? query.sort === "time_desc" ? "AND (e.ts_ms < ? OR (e.ts_ms = ? AND e.id < ?))" : "AND (e.ts_ms > ? OR (e.ts_ms = ? AND e.id > ?))" : "";
+    const cursorParams = decodedCursor ? [decodedCursor.tsMs, decodedCursor.tsMs, decodedCursor.id] : [];
+    const orderSql = query.sort === "time_desc" ? "ORDER BY e.ts_ms DESC, e.id DESC" : "ORDER BY e.ts_ms ASC, e.id ASC";
+    const limit = Math.max(1, query.limit);
+    let rows;
+    try {
+      rows = this.db.query(`
+          SELECT
+            e.id, e.ts_start, e.level, e.provider, e.route_type, e.model, e.model_in,
+            e.model_out, e.path, e.request_id, e.latency_ms, e.upstream_status,
+            e.status_class, e.has_error, e.message, e.error_type, e.has_metadata,
+            e.user_id_raw, e.user_key, e.session_id, e.ts_ms
+          FROM log_events e
+          ${whereSql}
+          ${cursorClause}
+          ${orderSql}
+          LIMIT ?
+        `).all(...params, ...cursorParams, limit + 1);
+    } catch (err) {
+      if (!usesFts)
+        throw err;
+      const fallback = this.queryEvents(query, { forceLikeSearch: true });
+      return {
+        ...fallback,
+        meta: {
+          ...fallback.meta,
+          usesFts: false,
+          fallbackReason: `FTS \u67E5\u8BE2\u5931\u8D25\uFF0C\u5DF2\u9000\u56DE\u7D22\u5F15 LIKE/\u5185\u5B58\u8FC7\u6EE4: ${err instanceof Error ? err.message : String(err)}`
+        }
+      };
+    }
+    const pageRows = rows.slice(0, limit);
+    const hasMore = rows.length > limit;
+    const lastRow = pageRows[pageRows.length - 1];
+    const stats = this.queryStats(whereSql, params);
+    return {
+      items: pageRows.map(rowToSummary),
+      nextCursor: hasMore && lastRow ? encodeCursor({
+        v: 2,
+        sort: query.sort,
+        tsMs: lastRow.ts_ms,
+        id: lastRow.id,
+        queryHash
+      }) : null,
+      hasMore,
+      stats,
+      meta: {
+        scannedFiles: 0,
+        scannedLines: 0,
+        parseErrors: 0,
+        truncated: false,
+        indexUsed: true,
+        indexFresh: true,
+        usesFts,
+        queryMs: Math.round((performance.now() - startedAt) * 100) / 100,
+        rowsReturned: pageRows.length,
+        statsMode: "exact"
+      }
+    };
+  }
+  getEventRecordByOffsetId(id) {
+    const parsedId = decodeOffsetLogEventId(id);
+    if (!parsedId)
+      return null;
+    const row = this.db.query("SELECT source_date, source_file, line_number, byte_offset FROM log_events WHERE id = ?").get(id);
+    const filePath = row?.source_file ?? join4(this.baseDir, "events", `${parsedId.date}.jsonl`);
+    if (!existsSync3(filePath))
+      return null;
+    const line2 = readLineAtOffset(filePath, row?.byte_offset ?? parsedId.offset);
+    if (!line2?.trim())
+      return null;
+    const event = JSON.parse(line2);
+    return {
+      event,
+      location: {
+        id,
+        date: row?.source_date ?? parsedId.date,
+        file: filePath,
+        line: row?.line_number ?? null,
+        offset: row?.byte_offset ?? parsedId.offset
+      }
+    };
+  }
+  configure() {
+    this.db.exec(`
+      PRAGMA journal_mode = WAL;
+      PRAGMA synchronous = NORMAL;
+      PRAGMA temp_store = MEMORY;
+      PRAGMA busy_timeout = 3000;
+      PRAGMA foreign_keys = ON;
+    `);
+  }
+  migrate() {
+    this.db.exec(`
+      CREATE TABLE IF NOT EXISTS log_index_meta (
+        key TEXT PRIMARY KEY,
+        value TEXT NOT NULL
+      );
+
+      CREATE TABLE IF NOT EXISTS log_index_files (
+        file_path TEXT PRIMARY KEY,
+        source_date TEXT NOT NULL,
+        size_bytes INTEGER NOT NULL,
+        mtime_ms INTEGER NOT NULL,
+        indexed_at INTEGER NOT NULL
+      );
+
+      CREATE TABLE IF NOT EXISTS log_events (
+        id TEXT PRIMARY KEY,
+        ts_ms INTEGER NOT NULL,
+        ts_start TEXT NOT NULL,
+        level TEXT NOT NULL,
+        provider TEXT NOT NULL,
+        route_type TEXT NOT NULL,
+        model TEXT NOT NULL,
+        model_in TEXT NOT NULL,
+        model_out TEXT NOT NULL,
+        path TEXT NOT NULL,
+        request_id TEXT NOT NULL,
+        latency_ms INTEGER NOT NULL,
+        upstream_status INTEGER NOT NULL,
+        status_class TEXT NOT NULL,
+        has_error INTEGER NOT NULL,
+        message TEXT NOT NULL,
+        error_type TEXT,
+        has_metadata INTEGER NOT NULL,
+        user_id_raw TEXT,
+        user_key TEXT,
+        session_id TEXT,
+        source_date TEXT NOT NULL,
+        source_file TEXT NOT NULL,
+        line_number INTEGER,
+        byte_offset INTEGER NOT NULL,
+        byte_length INTEGER NOT NULL,
+        search_text TEXT NOT NULL
+      );
+
+      CREATE VIRTUAL TABLE IF NOT EXISTS log_events_fts
+      USING fts5(event_id UNINDEXED, search_text);
+
+      CREATE INDEX IF NOT EXISTS idx_log_events_time_desc ON log_events(ts_ms DESC, id DESC);
+      CREATE INDEX IF NOT EXISTS idx_log_events_time_asc ON log_events(ts_ms ASC, id ASC);
+      CREATE INDEX IF NOT EXISTS idx_log_events_level_time ON log_events(level, ts_ms DESC);
+      CREATE INDEX IF NOT EXISTS idx_log_events_provider_time ON log_events(provider, ts_ms DESC);
+      CREATE INDEX IF NOT EXISTS idx_log_events_route_time ON log_events(route_type, ts_ms DESC);
+      CREATE INDEX IF NOT EXISTS idx_log_events_model_time ON log_events(model, ts_ms DESC);
+      CREATE INDEX IF NOT EXISTS idx_log_events_status_time ON log_events(status_class, ts_ms DESC);
+      CREATE INDEX IF NOT EXISTS idx_log_events_error_time ON log_events(has_error, ts_ms DESC);
+      CREATE INDEX IF NOT EXISTS idx_log_events_user_time ON log_events(user_key, ts_ms DESC);
+      CREATE INDEX IF NOT EXISTS idx_log_events_session_time ON log_events(session_id, ts_ms DESC);
+      CREATE INDEX IF NOT EXISTS idx_log_events_file ON log_events(source_file);
+    `);
+    this.db.prepare(`
+        INSERT INTO log_index_meta(key, value)
+        VALUES ('schema_version', ?)
+        ON CONFLICT(key) DO UPDATE SET value = excluded.value
+      `).run(String(SCHEMA_VERSION));
+  }
+  flushQueue() {
+    if (this.queue.length === 0 || this.disposed)
+      return;
+    const batch = this.queue.splice(0, INDEX_BATCH_SIZE);
+    const transaction = this.db.transaction((items) => {
+      for (const item of items) {
+        this.insertQueueItem(item);
+      }
+    });
+    try {
+      transaction(batch);
+    } catch (err) {
+      console.error("[log-index] \u589E\u91CF\u7D22\u5F15\u5199\u5165\u5931\u8D25:", err);
+    }
+    if (this.queue.length > 0 && !this.flushTimer) {
+      this.flushTimer = setTimeout(() => {
+        this.flushTimer = null;
+        this.flushQueue();
+      }, INDEX_FLUSH_DELAY_MS);
+      this.flushTimer.unref?.();
+    }
+  }
+  insertQueueItem(item) {
+    if (this.rebuildingFiles.has(item.filePath))
+      return;
+    const id = encodeOffsetLogEventId(item.date, item.offset);
+    const row = eventToRow({
+      id,
+      date: item.date,
+      filePath: item.filePath,
+      lineNumber: null,
+      offset: item.offset,
+      byteLength: item.byteLength,
+      event: item.event
+    });
+    if (!row)
+      return;
+    this.insertEventStmt.run(row);
+    this.deleteFtsStmt.run(id);
+    this.insertFtsStmt.run(id, row.search_text);
+    if (!this.dirtyFiles.has(item.filePath)) {
+      try {
+        const stats = statSync(item.filePath);
+        const indexedThrough = item.offset + item.byteLength;
+        this.upsertFileStmt.run(item.filePath, item.date, Math.min(indexedThrough, stats.size), Math.trunc(stats.mtimeMs), Date.now());
+      } catch {}
+    }
+  }
+  async rebuildFile(filePath, date5, sizeBytes, mtimeMs) {
+    if (this.rebuildingFiles.has(filePath)) {
+      return { scannedLines: 0, parseErrors: 0 };
+    }
+    this.rebuildingFiles.add(filePath);
+    let scannedLines = 0;
+    let parseErrors = 0;
+    const rows = [];
+    try {
+      for await (const item of readJsonlLinesWithOffsets(filePath)) {
+        scannedLines += 1;
+        if (!item.line.trim())
+          continue;
+        let event;
+        try {
+          event = JSON.parse(item.line);
+        } catch {
+          parseErrors += 1;
+          continue;
+        }
+        const row = eventToRow({
+          id: encodeOffsetLogEventId(date5, item.offset),
+          date: date5,
+          filePath,
+          lineNumber: item.lineNumber,
+          offset: item.offset,
+          byteLength: item.byteLength,
+          event
+        });
+        if (row)
+          rows.push(row);
+      }
+      const transaction = this.db.transaction((eventRows) => {
+        this.db.prepare("DELETE FROM log_events_fts WHERE event_id IN (SELECT id FROM log_events WHERE source_file = ?)").run(filePath);
+        this.db.prepare("DELETE FROM log_events WHERE source_file = ?").run(filePath);
+        for (const row of eventRows) {
+          this.insertEventStmt.run(row);
+          this.insertFtsStmt.run(row.id, row.search_text);
+        }
+        this.upsertFileStmt.run(filePath, date5, sizeBytes, mtimeMs, Date.now());
+      });
+      transaction(rows);
+      this.dirtyFiles.delete(filePath);
+      return { scannedLines, parseErrors };
+    } finally {
+      this.rebuildingFiles.delete(filePath);
+    }
+  }
+  queryStats(whereSql, params) {
+    const aggregate = this.db.query(`
+        SELECT
+          COUNT(*) AS total,
+          COALESCE(SUM(has_error), 0) AS errorCount,
+          COALESCE(AVG(latency_ms), 0) AS avgLatencyMs
+        FROM log_events e
+        ${whereSql}
+      `).get(...params);
+    const total = Number(aggregate.total) || 0;
+    if (total <= 0)
+      return createEmptyStats();
+    const p95Offset = Math.max(0, Math.ceil(total * 0.95) - 1);
+    const p95Row = this.db.query(`
+        SELECT latency_ms
+        FROM log_events e
+        ${whereSql}
+        ORDER BY latency_ms ASC
+        LIMIT 1 OFFSET ?
+      `).get(...params, p95Offset);
+    const errorCount = Number(aggregate.errorCount) || 0;
+    return {
+      total,
+      errorCount,
+      errorRate: toPercent2(errorCount, total),
+      avgLatencyMs: Math.round(Number(aggregate.avgLatencyMs) || 0),
+      p95LatencyMs: Math.round(p95Row?.latency_ms ?? 0)
+    };
+  }
+}
+function initLogIndex(baseDir, config2) {
+  disposeLogIndex();
+  if (config2?.enabled === false)
+    return;
+  try {
+    singleton = new LogIndex(baseDir, config2);
+  } catch (err) {
+    singleton = null;
+    console.error("[log-index] SQLite \u7D22\u5F15\u521D\u59CB\u5316\u5931\u8D25\uFF0C\u5C06\u9000\u56DE JSONL \u626B\u63CF:", err);
+  }
+}
+function disposeLogIndex() {
+  if (!singleton)
+    return;
+  try {
+    singleton.dispose();
+  } catch (err) {
+    console.error("[log-index] SQLite \u7D22\u5F15\u5173\u95ED\u5931\u8D25:", err);
+  } finally {
+    singleton = null;
+  }
+}
+function getLogIndex(baseDir) {
+  if (!singleton)
+    return null;
+  if (baseDir && singleton.baseDir !== baseDir)
+    return null;
+  return singleton;
+}
+function enqueueLogEventForIndex(input) {
+  const index = getLogIndex(input.baseDir);
+  index?.enqueue(input);
+}
+async function queryIndexedLogEvents(logConfig, query) {
+  if (!logConfig || logConfig.enabled === false)
+    return createEmptyQueryResult(query);
+  const baseDir = resolveLogBaseDir(logConfig);
+  const index = getLogIndex(baseDir);
+  if (!index)
+    return null;
+  try {
+    const freshness = await index.ensureRangeIndexed(query.fromMs, query.toMs);
+    const result = index.queryEvents(query);
+    return {
+      ...result,
+      meta: {
+        ...result.meta,
+        scannedFiles: freshness.scannedFiles,
+        scannedLines: freshness.scannedLines,
+        parseErrors: freshness.parseErrors
+      }
+    };
+  } catch (err) {
+    if (err instanceof Error && err.message.includes("cursor")) {
+      throw err;
+    }
+    return {
+      ...createEmptyQueryResult(query, {
+        indexUsed: false,
+        indexFresh: false,
+        fallbackReason: err instanceof Error ? err.message : String(err),
+        statsMode: "none"
+      })
+    };
+  }
+}
+function getIndexedLogEventDetail(logConfig, id) {
+  if (!logConfig || logConfig.enabled === false)
+    return null;
+  const baseDir = resolveLogBaseDir(logConfig);
+  const indexed = getLogIndex(baseDir)?.getEventRecordByOffsetId(id);
+  if (indexed)
+    return indexed;
+  const parsedId = decodeOffsetLogEventId(id);
+  if (!parsedId)
+    return null;
+  const filePath = join4(baseDir, "events", `${parsedId.date}.jsonl`);
+  if (!existsSync3(filePath))
+    return null;
+  const line2 = readLineAtOffset(filePath, parsedId.offset);
+  if (!line2?.trim())
+    return null;
+  return {
+    event: JSON.parse(line2),
+    location: {
+      id,
+      date: parsedId.date,
+      file: filePath,
+      line: null,
+      offset: parsedId.offset
+    }
+  };
+}
+
 // src/log-query.ts
 var WINDOW_MS2 = {
   "1h": 60 * 60 * 1000,
@@ -51827,49 +52711,57 @@ var MAX_QUERY_LIMIT = 200;
 var DEFAULT_QUERY_LIMIT = 50;
 var MAX_EXPORT_ROWS = 5000;
 var MAX_Q_LENGTH = 200;
-function encodeBase64Url(value) {
+function encodeBase64Url2(value) {
   return Buffer.from(value, "utf-8").toString("base64url");
 }
-function decodeBase64Url(value) {
+function decodeBase64Url2(value) {
   return Buffer.from(value, "base64url").toString("utf-8");
 }
-function encodeCursor(data) {
-  return encodeBase64Url(JSON.stringify(data));
+function encodeCursor2(data) {
+  return encodeBase64Url2(JSON.stringify(data));
 }
-function decodeCursor(raw2) {
-  const parsed = JSON.parse(decodeBase64Url(raw2));
+function decodeCursor2(raw2) {
+  const parsed = JSON.parse(decodeBase64Url2(raw2));
   if (!Number.isInteger(parsed.offset) || parsed.offset < 0) {
     throw new Error("cursor \u975E\u6CD5");
   }
   return parsed;
 }
+function isLegacyOffsetCursor(raw2) {
+  try {
+    const parsed = JSON.parse(decodeBase64Url2(raw2));
+    return Number.isInteger(parsed.offset) && Number(parsed.offset) >= 0;
+  } catch {
+    return false;
+  }
+}
 function encodeEventId(date5, line2) {
-  return encodeBase64Url(JSON.stringify({ d: date5, l: line2 }));
+  return encodeBase64Url2(JSON.stringify({ d: date5, l: line2 }));
 }
 function decodeEventId(id) {
-  const parsed = JSON.parse(decodeBase64Url(id));
+  const parsed = JSON.parse(decodeBase64Url2(id));
   if (typeof parsed.d !== "string" || !Number.isInteger(parsed.l) || Number(parsed.l) <= 0) {
     throw new Error("id \u975E\u6CD5");
   }
   return { date: parsed.d, line: Number(parsed.l) };
 }
-function toPercent2(numerator, denominator) {
+function toPercent3(numerator, denominator) {
   if (denominator <= 0)
     return 0;
   return Number((numerator / denominator * 100).toFixed(2));
 }
-function toDayStart2(ms) {
+function toDayStart3(ms) {
   const date5 = new Date(ms);
   return Date.UTC(date5.getUTCFullYear(), date5.getUTCMonth(), date5.getUTCDate());
 }
-function listDateStrings2(fromMs, toMs) {
+function listDateStrings3(fromMs, toMs) {
   const result = [];
-  for (let day = toDayStart2(fromMs);day <= toDayStart2(toMs); day += 24 * 60 * 60 * 1000) {
+  for (let day = toDayStart3(fromMs);day <= toDayStart3(toMs); day += 24 * 60 * 60 * 1000) {
     result.push(new Date(day).toISOString().slice(0, 10));
   }
   return result;
 }
-function getStatusClass2(event) {
+function getStatusClass3(event) {
   if (event.error_type)
     return "network_error";
   const status = event.upstream_status ?? 0;
@@ -51881,16 +52773,16 @@ function getStatusClass2(event) {
     return "5xx";
   return "network_error";
 }
-function isErrorEvent2(event) {
+function isErrorEvent3(event) {
   if (event.error_type)
     return true;
   const status = event.upstream_status ?? 0;
   return status < 200 || status >= 400;
 }
-function getLevel(event) {
-  return isErrorEvent2(event) ? "error" : "info";
+function getLevel2(event) {
+  return isErrorEvent3(event) ? "error" : "info";
 }
-function buildMessage(event) {
+function buildMessage2(event) {
   if (event.error_message)
     return event.error_message;
   if (event.error_type)
@@ -51915,7 +52807,7 @@ function containsKeyword(event, q) {
     identity.sessionId ?? "",
     event.error_type ?? "",
     event.error_message ?? "",
-    buildMessage(event)
+    buildMessage2(event)
   ].join(" ").toLowerCase();
   return haystack.includes(keyword);
 }
@@ -51964,7 +52856,7 @@ function finalizeStats(stats) {
   return {
     total: stats.total,
     errorCount: stats.errorCount,
-    errorRate: toPercent2(stats.errorCount, stats.total),
+    errorRate: toPercent3(stats.errorCount, stats.total),
     avgLatencyMs: Math.round(stats.latencySum / stats.total),
     p95LatencyMs: percentileFromCounts(stats.latencyCounts, stats.total, 0.95)
   };
@@ -51984,17 +52876,17 @@ function insertBoundedEvent(items, item, sort, maxKeep) {
     items.pop();
   }
 }
-function clampLimit(limit) {
+function clampLimit(limit, maxLimit = MAX_QUERY_LIMIT) {
   if (!Number.isFinite(limit))
     return DEFAULT_QUERY_LIMIT;
   const integer2 = Math.floor(limit);
   if (integer2 <= 0)
     return DEFAULT_QUERY_LIMIT;
-  return Math.min(MAX_QUERY_LIMIT, integer2);
+  return Math.min(maxLimit, integer2);
 }
-function normalizeQuery(input) {
+function normalizeQuery(input, maxLimit = MAX_QUERY_LIMIT) {
   const sort = input.sort ?? "time_desc";
-  const limit = clampLimit(input.limit);
+  const limit = clampLimit(input.limit, maxLimit);
   const qRaw = (input.q ?? "").trim();
   const q = qRaw.length > MAX_Q_LENGTH ? qRaw.slice(0, MAX_Q_LENGTH) : qRaw;
   return {
@@ -52034,7 +52926,7 @@ function eventToSummary(item) {
     upstreamStatus: event.upstream_status ?? 0,
     statusClass: item.statusClass,
     hasError: item.level === "error",
-    message: buildMessage(event),
+    message: buildMessage2(event),
     errorType: event.error_type,
     hasMetadata: identity.hasMetadata,
     userIdRaw: identity.userIdRaw,
@@ -52042,6 +52934,57 @@ function eventToSummary(item) {
     sessionId: identity.sessionId
   };
 }
+function createLogEventSummaryFromEvent(event, location) {
+  const ts = Date.parse(event.ts_start);
+  return eventToSummary({
+    id: location.id,
+    date: location.date,
+    line: location.line ?? 0,
+    ts: Number.isFinite(ts) ? ts : 0,
+    level: getLevel2(event),
+    statusClass: getStatusClass3(event),
+    event
+  });
+}
+function logEventMatchesQuery(event, query) {
+  if (!event.ts_start)
+    return false;
+  const ts = Date.parse(event.ts_start);
+  if (!Number.isFinite(ts) || ts < query.fromMs || ts > query.toMs)
+    return false;
+  const level = getLevel2(event);
+  const statusClass = getStatusClass3(event);
+  if (query.levels.length > 0 && !query.levels.includes(level))
+    return false;
+  if (query.providers.length > 0 && !query.providers.includes(event.provider))
+    return false;
+  if (query.routeTypes.length > 0 && !query.routeTypes.includes(event.route_type))
+    return false;
+  const eventModel = event.model_out || event.model_in;
+  if (query.models.length > 0 && !query.models.includes(eventModel))
+    return false;
+  if (query.modelIns.length > 0 && !query.modelIns.includes(event.model_in))
+    return false;
+  if (query.modelOuts.length > 0 && !query.modelOuts.includes(event.model_out))
+    return false;
+  const identity = resolveLogSessionIdentity(event.request_body);
+  if (query.users.length > 0) {
+    const matchedByRaw = identity.userIdRaw ? query.users.includes(identity.userIdRaw) : false;
+    const matchedByUserKey = identity.userKey ? query.users.includes(identity.userKey) : false;
+    if (!matchedByRaw && !matchedByUserKey)
+      return false;
+  }
+  if (query.sessions.length > 0) {
+    if (!identity.sessionId || !query.sessions.includes(identity.sessionId))
+      return false;
+  }
+  if (query.statusClasses.length > 0 && !query.statusClasses.includes(statusClass))
+    return false;
+  const hasError = level === "error";
+  if (query.hasError !== null && query.hasError !== hasError)
+    return false;
+  return containsKeyword(event, query.q);
+}
 function detectBodyPolicy(event) {
   const hasRequestBody = event.request_body !== undefined;
   const hasResponseBody = event.response_body !== undefined;
@@ -52095,17 +53038,17 @@ function readStreamContent(baseDir, streamFile) {
     if (!looksLikeStreamFile) {
       return { content: null, warning: "stream_file \u4E0D\u662F .sse.raw \u6587\u4EF6\uFF0C\u5DF2\u8DF3\u8FC7\u8BFB\u53D6\u3002" };
     }
-    if (existsSync3(resolvedFromFile)) {
-      return { content: readFileSync2(resolvedFromFile, "utf-8"), warning: null };
+    if (existsSync4(resolvedFromFile)) {
+      return { content: readFileSync3(resolvedFromFile, "utf-8"), warning: null };
     }
     const fallbackPath = resolve4(resolvedBase, streamFile);
     if (!fallbackPath.startsWith(`${resolvedBase}/`) && fallbackPath !== resolvedBase) {
       return { content: null, warning: "stream_file \u8DEF\u5F84\u975E\u6CD5\uFF0C\u5DF2\u62D2\u7EDD\u8BFB\u53D6\u3002" };
     }
-    if (!existsSync3(fallbackPath)) {
+    if (!existsSync4(fallbackPath)) {
       return { content: null, warning: "stream_file \u4E0D\u5B58\u5728\uFF0C\u53EF\u80FD\u5DF2\u88AB\u6E05\u7406\u3002" };
     }
-    return { content: readFileSync2(fallbackPath, "utf-8"), warning: null };
+    return { content: readFileSync3(fallbackPath, "utf-8"), warning: null };
   } catch (err) {
     return {
       content: null,
@@ -52115,8 +53058,8 @@ function readStreamContent(baseDir, streamFile) {
 }
 async function buildLogEventDetail(id, parsed, location, context2) {
   const event = parsed;
-  const level = getLevel(event);
-  const statusClass = getStatusClass2(event);
+  const level = getLevel2(event);
+  const statusClass = getStatusClass3(event);
   const bodyPolicy = detectBodyPolicy(event);
   const requestBodyAvailable = event.request_body !== undefined;
   const responseBodyAvailable = event.response_body !== undefined;
@@ -52188,8 +53131,8 @@ async function buildLogEventDetail(id, parsed, location, context2) {
   };
 }
 async function scanEvents(baseDir, query) {
-  const eventsDir = join4(baseDir, "events");
-  if (!existsSync3(eventsDir)) {
+  const eventsDir = join5(baseDir, "events");
+  if (!existsSync4(eventsDir)) {
     return {
       items: [],
       stats: {
@@ -52207,8 +53150,8 @@ async function scanEvents(baseDir, query) {
       }
     };
   }
-  const dates = listDateStrings2(query.fromMs, query.toMs);
-  const offset = query.cursor ? decodeCursor(query.cursor).offset : 0;
+  const dates = listDateStrings3(query.fromMs, query.toMs);
+  const offset = query.cursor ? decodeCursor2(query.cursor).offset : 0;
   const maxKeep = offset + query.limit;
   const items = [];
   const runningStats = createRunningStats();
@@ -52221,11 +53164,11 @@ async function scanEvents(baseDir, query) {
       truncated = true;
       break;
     }
-    const filePath = join4(eventsDir, `${date5}.jsonl`);
-    if (!existsSync3(filePath))
+    const filePath = join5(eventsDir, `${date5}.jsonl`);
+    if (!existsSync4(filePath))
       continue;
     scannedFiles += 1;
-    const stream = createReadStream2(filePath, { encoding: "utf-8" });
+    const stream = createReadStream3(filePath, { encoding: "utf-8" });
     const rl = createInterface2({ input: stream, crlfDelay: Number.POSITIVE_INFINITY });
     let lineNumber = 0;
     for await (const line2 of rl) {
@@ -52251,8 +53194,8 @@ async function scanEvents(baseDir, query) {
       const ts = Date.parse(event.ts_start);
       if (!Number.isFinite(ts) || ts < query.fromMs || ts > query.toMs)
         continue;
-      const level = getLevel(event);
-      const statusClass = getStatusClass2(event);
+      const level = getLevel2(event);
+      const statusClass = getStatusClass3(event);
       if (query.levels.length > 0 && !query.levels.includes(level))
         continue;
       if (query.providers.length > 0 && !query.providers.includes(event.provider))
@@ -52342,6 +53285,9 @@ function validateSort(value) {
   return value === "time_desc" || value === "time_asc";
 }
 async function queryLogEvents(context2, input) {
+  return queryLogEventsInternal(context2, input, MAX_QUERY_LIMIT);
+}
+async function queryLogEventsInternal(context2, input, maxLimit) {
   const logEnabled = !!context2.logConfig && context2.logConfig.enabled !== false;
   if (!logEnabled) {
     return {
@@ -52364,30 +53310,51 @@ async function queryLogEvents(context2, input) {
     };
   }
   const baseDir = resolveLogBaseDir(context2.logConfig);
-  const query = normalizeQuery(input);
-  const offset = query.cursor ? decodeCursor(query.cursor).offset : 0;
+  const query = normalizeQuery(input, maxLimit);
+  const indexed = await queryIndexedLogEvents(context2.logConfig, query);
+  if (indexed?.meta.indexUsed) {
+    return indexed;
+  }
+  if (query.cursor && !isLegacyOffsetCursor(query.cursor)) {
+    throw new Error(`\u7D22\u5F15\u67E5\u8BE2\u5931\u8D25\uFF0C\u65E0\u6CD5\u4F7F\u7528\u7D22\u5F15 cursor \u56DE\u9000\u5230 JSONL\uFF0C\u8BF7\u91CD\u65B0\u67E5\u8BE2\u7B2C\u4E00\u9875${indexed?.meta.fallbackReason ? `: ${indexed.meta.fallbackReason}` : ""}`);
+  }
+  const offset = query.cursor ? decodeCursor2(query.cursor).offset : 0;
   const scanned = await scanEvents(baseDir, query);
   const pageItems = scanned.items.slice(offset, offset + query.limit);
   const hasMore = scanned.stats.total > offset + query.limit;
   const nextOffset = offset + pageItems.length;
   return {
     items: pageItems.map(eventToSummary),
-    nextCursor: hasMore ? encodeCursor({ offset: nextOffset }) : null,
+    nextCursor: hasMore ? encodeCursor2({ offset: nextOffset }) : null,
     hasMore,
     stats: scanned.stats,
-    meta: scanned.meta
+    meta: {
+      ...scanned.meta,
+      indexUsed: false,
+      indexFresh: false,
+      fallbackReason: indexed?.meta.fallbackReason,
+      statsMode: "exact"
+    }
   };
 }
 async function getLogEventDetailById(context2, id) {
   const logEnabled = !!context2.logConfig && context2.logConfig.enabled !== false;
   if (!logEnabled)
     return null;
+  const indexed = getIndexedLogEventDetail(context2.logConfig, id);
+  if (indexed) {
+    return buildLogEventDetail(id, indexed.event, {
+      date: indexed.location.date,
+      line: indexed.location.line ?? 0,
+      file: indexed.location.file
+    }, context2);
+  }
   const { date: date5, line: line2 } = decodeEventId(id);
   const baseDir = resolveLogBaseDir(context2.logConfig);
-  const filePath = join4(baseDir, "events", `${date5}.jsonl`);
-  if (!existsSync3(filePath))
+  const filePath = join5(baseDir, "events", `${date5}.jsonl`);
+  if (!existsSync4(filePath))
     return null;
-  const stream = createReadStream2(filePath, { encoding: "utf-8" });
+  const stream = createReadStream3(filePath, { encoding: "utf-8" });
   const rl = createInterface2({ input: stream, crlfDelay: Number.POSITIVE_INFINITY });
   let lineNumber = 0;
   for await (const lineText of rl) {
@@ -52497,11 +53464,11 @@ function createJsonExportStream(data) {
   });
 }
 async function exportLogEvents(context2, input, format) {
-  const data = await queryLogEvents(context2, {
+  const data = await queryLogEventsInternal(context2, {
     ...input,
     cursor: null,
     limit: MAX_EXPORT_ROWS
-  });
+  }, MAX_EXPORT_ROWS);
   const now2 = new Date().toISOString().replace(/[:.]/g, "-");
   if (format === "csv") {
     return {
@@ -52540,18 +53507,18 @@ function parseBooleanFlag(value) {
 }
 
 // src/log-sessions.ts
-import { createReadStream as createReadStream3, existsSync as existsSync4 } from "fs";
-import { join as join5 } from "path";
+import { createReadStream as createReadStream4, existsSync as existsSync5 } from "fs";
+import { join as join6 } from "path";
 import { createInterface as createInterface3 } from "readline";
 var MAX_LINES_SCANNED3 = 250000;
 var MAX_Q_LENGTH2 = 200;
-function toDayStart3(ms) {
+function toDayStart4(ms) {
   const date5 = new Date(ms);
   return Date.UTC(date5.getUTCFullYear(), date5.getUTCMonth(), date5.getUTCDate());
 }
-function listDateStrings3(fromMs, toMs) {
+function listDateStrings4(fromMs, toMs) {
   const result = [];
-  for (let day = toDayStart3(fromMs);day <= toDayStart3(toMs); day += 24 * 60 * 60 * 1000) {
+  for (let day = toDayStart4(fromMs);day <= toDayStart4(toMs); day += 24 * 60 * 60 * 1000) {
     result.push(new Date(day).toISOString().slice(0, 10));
   }
   return result;
@@ -52662,8 +53629,8 @@ async function queryLogSessions(context2, input) {
     return createEmptyResult(normalized.fromMs, normalized.toMs);
   }
   const baseDir = resolveLogBaseDir(context2.logConfig);
-  const eventsDir = join5(baseDir, "events");
-  if (!existsSync4(eventsDir)) {
+  const eventsDir = join6(baseDir, "events");
+  if (!existsSync5(eventsDir)) {
     return createEmptyResult(normalized.fromMs, normalized.toMs);
   }
   const usersMap = new Map;
@@ -52675,17 +53642,17 @@ async function queryLogSessions(context2, input) {
   let scannedLines = 0;
   let parseErrors = 0;
   let truncated = false;
-  const dateStrings = listDateStrings3(normalized.fromMs, normalized.toMs);
+  const dateStrings = listDateStrings4(normalized.fromMs, normalized.toMs);
   for (const date5 of dateStrings) {
     if (scannedLines >= MAX_LINES_SCANNED3) {
       truncated = true;
       break;
     }
-    const filePath = join5(eventsDir, `${date5}.jsonl`);
-    if (!existsSync4(filePath))
+    const filePath = join6(eventsDir, `${date5}.jsonl`);
+    if (!existsSync5(filePath))
       continue;
     scannedFiles += 1;
-    const stream = createReadStream3(filePath, { encoding: "utf-8" });
+    const stream = createReadStream4(filePath, { encoding: "utf-8" });
     const rl = createInterface3({ input: stream, crlfDelay: Number.POSITIVE_INFINITY });
     for await (const line2 of rl) {
       if (scannedLines >= MAX_LINES_SCANNED3) {
@@ -52790,8 +53757,8 @@ async function queryLogSessions(context2, input) {
 }
 
 // src/log-storage.ts
-import { existsSync as existsSync5, promises as fsPromises } from "fs";
-import { join as join6 } from "path";
+import { existsSync as existsSync6, promises as fsPromises } from "fs";
+import { join as join7 } from "path";
 var cachedStorage = null;
 var calculationPromise = null;
 var lastCalculationTime = 0;
@@ -52799,7 +53766,7 @@ var CACHE_TTL_MS2 = 60 * 60 * 1000;
 var CALCULATION_INTERVAL_MS = 60 * 60 * 1000;
 var MIN_CALCULATION_INTERVAL_MS = 5 * 60 * 1000;
 async function calculateDirSize(dirPath) {
-  if (!existsSync5(dirPath)) {
+  if (!existsSync6(dirPath)) {
     return { bytes: 0, fileCount: 0 };
   }
   let bytes = 0;
@@ -52808,7 +53775,7 @@ async function calculateDirSize(dirPath) {
     try {
       const entries = await fsPromises.readdir(currentPath, { withFileTypes: true });
       for (const entry of entries) {
-        const fullPath = join6(currentPath, entry.name);
+        const fullPath = join7(currentPath, entry.name);
         if (entry.isDirectory()) {
           await walk(fullPath);
         } else if (entry.isFile()) {
@@ -52831,6 +53798,7 @@ async function doCalculateStorage(logConfig) {
       totalBytes: 0,
       eventsBytes: 0,
       streamsBytes: 0,
+      indexBytes: 0,
       fileCount: 0,
       lastUpdatedAt: new Date().toISOString(),
       isCalculating: false
@@ -52838,18 +53806,40 @@ async function doCalculateStorage(logConfig) {
   }
   const baseDir = resolveLogBaseDir(logConfig);
   const [eventsResult, streamsResult] = await Promise.all([
-    calculateDirSize(join6(baseDir, "events")),
-    calculateDirSize(join6(baseDir, "streams"))
+    calculateDirSize(join7(baseDir, "events")),
+    calculateDirSize(join7(baseDir, "streams"))
   ]);
+  const indexResult = await calculateIndexSize(baseDir);
   return {
-    totalBytes: eventsResult.bytes + streamsResult.bytes,
+    totalBytes: eventsResult.bytes + streamsResult.bytes + indexResult.bytes,
     eventsBytes: eventsResult.bytes,
     streamsBytes: streamsResult.bytes,
-    fileCount: eventsResult.fileCount + streamsResult.fileCount,
+    indexBytes: indexResult.bytes,
+    fileCount: eventsResult.fileCount + streamsResult.fileCount + indexResult.fileCount,
     lastUpdatedAt: new Date().toISOString(),
     isCalculating: false
   };
 }
+async function calculateIndexSize(baseDir) {
+  if (!existsSync6(baseDir)) {
+    return { bytes: 0, fileCount: 0 };
+  }
+  let bytes = 0;
+  let fileCount = 0;
+  try {
+    const entries = await fsPromises.readdir(baseDir, { withFileTypes: true });
+    for (const entry of entries) {
+      if (!entry.isFile() || !entry.name.startsWith("logs-index.sqlite"))
+        continue;
+      const stats = await fsPromises.stat(join7(baseDir, entry.name));
+      bytes += stats.size;
+      fileCount += 1;
+    }
+  } catch {
+    return { bytes, fileCount };
+  }
+  return { bytes, fileCount };
+}
 async function getLogStorageInfo(options) {
   const { logConfig, forceRefresh = false, nowMs = Date.now() } = options;
   if (!forceRefresh && cachedStorage && cachedStorage.expiresAt > nowMs) {
@@ -52892,10 +53882,25 @@ function startLogStorageBackgroundTask(logConfig) {
   };
 }
 
-// src/logger.ts
-import { appendFileSync, existsSync as existsSync6, mkdirSync as mkdirSync2, writeFileSync as writeFileSync3 } from "fs";
-import { join as join7 } from "path";
+// src/log-tail.ts
+var subscribers = new Set;
+function publishLogEvent(event) {
+  for (const subscriber of subscribers) {
+    try {
+      subscriber(event);
+    } catch {}
+  }
+}
+function subscribeLogEvents(subscriber) {
+  subscribers.add(subscriber);
+  return () => {
+    subscribers.delete(subscriber);
+  };
+}
 
+// src/logger.ts
+import { appendFileSync, existsSync as existsSync7, mkdirSync as mkdirSync3, statSync as statSync2, writeFileSync as writeFileSync3 } from "fs";
+import { join as join8 } from "path";
 class Logger {
   baseDir;
   eventsDir;
@@ -52910,8 +53915,8 @@ class Logger {
     this._bodyPolicy = config2.bodyPolicy ?? "off";
     this._streamsEnabled = config2.streams?.enabled !== false;
     this.maxStreamBytes = config2.streams?.maxBytesPerRequest ?? 10 * 1024 * 1024;
-    this.eventsDir = join7(baseDir, "events");
-    this.streamsDir = join7(baseDir, "streams");
+    this.eventsDir = join8(baseDir, "events");
+    this.streamsDir = join8(baseDir, "streams");
     if (this._enabled)
       this.ensureDirs();
   }
@@ -52923,14 +53928,14 @@ class Logger {
   }
   ensureDirs() {
     for (const dir of [this.baseDir, this.eventsDir, this.streamsDir]) {
-      if (!existsSync6(dir))
-        mkdirSync2(dir, { recursive: true });
+      if (!existsSync7(dir))
+        mkdirSync3(dir, { recursive: true });
     }
   }
   ensureStreamDateDir(dateStr) {
-    const dir = join7(this.streamsDir, dateStr);
-    if (!existsSync6(dir))
-      mkdirSync2(dir, { recursive: true });
+    const dir = join8(this.streamsDir, dateStr);
+    if (!existsSync7(dir))
+      mkdirSync3(dir, { recursive: true });
     return dir;
   }
   writeEvent(event) {
@@ -52939,9 +53944,21 @@ class Logger {
     try {
       this.ensureDirs();
       const dateStr = event.ts_start.slice(0, 10);
-      const filePath = join7(this.eventsDir, `${dateStr}.jsonl`);
-      appendFileSync(filePath, `${JSON.stringify(event)}
-`);
+      const filePath = join8(this.eventsDir, `${dateStr}.jsonl`);
+      const offset = existsSync7(filePath) ? statSync2(filePath).size : 0;
+      const line2 = `${JSON.stringify(event)}
+`;
+      appendFileSync(filePath, line2);
+      const id = encodeOffsetLogEventId(dateStr, offset);
+      enqueueLogEventForIndex({
+        baseDir: this.baseDir,
+        filePath,
+        date: dateStr,
+        offset,
+        byteLength: Buffer.byteLength(line2),
+        event
+      });
+      publishLogEvent({ id, date: dateStr, filePath, offset, event });
     } catch (err) {
       console.error("[logger] \u4E8B\u4EF6\u65E5\u5FD7\u5199\u5165\u5931\u8D25:", err);
     }
@@ -52951,7 +53968,7 @@ class Logger {
       return null;
     try {
       const dir = this.ensureStreamDateDir(dateStr);
-      const filePath = join7(dir, `${requestId}.sse.raw`);
+      const filePath = join8(dir, `${requestId}.sse.raw`);
       const toWrite = content.length > this.maxStreamBytes ? `${content.slice(0, this.maxStreamBytes)}
 [TRUNCATED]` : content;
       writeFileSync3(filePath, toWrite);
@@ -52965,6 +53982,7 @@ class Logger {
 var instance = null;
 function initLogger(baseDir, config2) {
   instance = new Logger(baseDir, config2);
+  initLogIndex(baseDir, config2);
   if (instance.enabled) {
     console.log(`[logger] \u65E5\u5FD7\u7CFB\u7EDF\u5DF2\u521D\u59CB\u5316: ${baseDir}`);
   }
@@ -52974,6 +53992,7 @@ function getLogger() {
 }
 function resetLogger() {
   instance = null;
+  disposeLogIndex();
 }
 function collectHeaders(headers) {
   const result = {};
@@ -52994,6 +54013,85 @@ function normalizeUrl(rawUrl) {
   return rawUrl;
 }
 
+// src/network-access.ts
+var REMOTE_ADDRESS_ENV_KEY = "LOCAL_ROUTER_REMOTE_ADDRESS";
+function parseIpv4(address) {
+  const parts = address.split(".");
+  if (parts.length !== 4)
+    return null;
+  const octets = parts.map((part) => {
+    if (!/^\d{1,3}$/.test(part))
+      return Number.NaN;
+    const value = Number.parseInt(part, 10);
+    return value >= 0 && value <= 255 ? value : Number.NaN;
+  });
+  return octets.every(Number.isFinite) ? octets : null;
+}
+function normalizeIpAddress(raw2) {
+  let address = raw2.trim().toLowerCase();
+  if (address.startsWith("[")) {
+    const end = address.indexOf("]");
+    if (end !== -1)
+      address = address.slice(1, end);
+  }
+  const mappedIpv4 = address.match(/^::ffff:(\d{1,3}(?:\.\d{1,3}){3})$/);
+  if (mappedIpv4) {
+    return mappedIpv4[1];
+  }
+  return address;
+}
+function isLoopbackAddress(raw2) {
+  if (!raw2)
+    return false;
+  const address = normalizeIpAddress(raw2);
+  const ipv43 = parseIpv4(address);
+  if (ipv43)
+    return ipv43[0] === 127;
+  return address === "::1";
+}
+function isLanAddress(raw2) {
+  if (!raw2)
+    return false;
+  const address = normalizeIpAddress(raw2);
+  const ipv43 = parseIpv4(address);
+  if (ipv43) {
+    const [a, b] = ipv43;
+    return a === 10 || a === 172 && b >= 16 && b <= 31 || a === 192 && b === 168 || a === 169 && b === 254;
+  }
+  return address.startsWith("fc") || address.startsWith("fd") || /^fe[89ab]/.test(address);
+}
+function decideNetworkAccess(serverConfig, rawRemoteAddress) {
+  const remoteAddress = rawRemoteAddress ? normalizeIpAddress(rawRemoteAddress) : null;
+  if (!remoteAddress || isLoopbackAddress(remoteAddress)) {
+    return { allowed: true, remoteAddress };
+  }
+  const lanEnabled = serverConfig?.lanAccess?.enabled === true;
+  if (!lanEnabled) {
+    return { allowed: false, remoteAddress, reason: "lan-disabled" };
+  }
+  if (!isLanAddress(remoteAddress)) {
+    return { allowed: false, remoteAddress, reason: "non-lan-address" };
+  }
+  return { allowed: true, remoteAddress };
+}
+function getRemoteAddressFromContext(c2) {
+  const env = c2.env;
+  const value = env?.[REMOTE_ADDRESS_ENV_KEY];
+  return typeof value === "string" && value.trim() ? value : null;
+}
+function createNetworkAccessMiddleware(store) {
+  return async (c2, next) => {
+    const decision = decideNetworkAccess(store.get().server, getRemoteAddressFromContext(c2));
+    if (!decision.allowed) {
+      return c2.json({
+        error: decision.reason === "lan-disabled" ? "\u5C40\u57DF\u7F51\u670D\u52A1\u672A\u5F00\u542F\uFF0C\u5DF2\u62D2\u7EDD\u975E\u672C\u673A\u8BF7\u6C42" : "\u4EC5\u5141\u8BB8\u672C\u673A\u6216\u5C40\u57DF\u7F51\u6765\u6E90\u8BBF\u95EE",
+        remoteAddress: decision.remoteAddress
+      }, 403);
+    }
+    await next();
+  };
+}
+
 // src/openapi.ts
 var openAPISpec = {
   openapi: "3.0.0",
@@ -53442,7 +54540,9 @@ var openAPISpec = {
                           type: "object",
                           additionalProperties: { type: "string" }
                         },
-                        requestBody: { type: ["object", "array", "string", "number", "boolean", "null"] }
+                        requestBody: {
+                          type: ["object", "array", "string", "number", "boolean", "null"]
+                        }
                       }
                     },
                     response: {
@@ -54096,9 +55196,9 @@ var openAPISpec = {
 };
 
 // src/plugin-loader.ts
-import { resolve as resolve5, join as join8 } from "path";
+import { mkdtemp, rm, writeFile } from "fs/promises";
 import { tmpdir } from "os";
-import { mkdtemp, writeFile, rm } from "fs/promises";
+import { join as join9, resolve as resolve5 } from "path";
 function isLocalPath(pkg) {
   return pkg.startsWith("./") || pkg.startsWith("../") || pkg.startsWith("/") || /^[A-Za-z]:[\\/]/.test(pkg);
 }
@@ -54121,7 +55221,7 @@ var remoteTmpDir = null;
 var remoteTmpFiles = [];
 async function ensureRemoteTmpDir() {
   if (!remoteTmpDir) {
-    remoteTmpDir = await mkdtemp(join8(tmpdir(), "local-router-plugins-"));
+    remoteTmpDir = await mkdtemp(join9(tmpdir(), "local-router-plugins-"));
   }
   return remoteTmpDir;
 }
@@ -54134,7 +55234,7 @@ async function fetchRemotePlugin(url2) {
   const ext = inferExtension(url2, response.headers.get("content-type"));
   const dir = await ensureRemoteTmpDir();
   const fileName = `plugin_${Date.now()}_${Math.random().toString(36).slice(2, 8)}${ext}`;
-  const filePath = join8(dir, fileName);
+  const filePath = join9(dir, fileName);
   await writeFile(filePath, content, "utf-8");
   remoteTmpFiles.push(filePath);
   return filePath;
@@ -54173,13 +55273,17 @@ class PluginManager {
   constructor(configDir) {
     this.configDir = configDir;
   }
-  async loadPluginsForProvider(providerName, pluginConfigs) {
+  async loadPluginsForProvider(providerName, providerConfig, pluginConfigs) {
     const loaded = [];
     const failures = [];
     for (const config2 of pluginConfigs) {
       try {
         const definition = await importPlugin(config2.package, this.configDir);
-        const instance2 = await definition.create(config2.params ?? {});
+        const params = { ...config2.params ?? {} };
+        if (definition.name === "protocol-adapter" && params.targetFormat === undefined) {
+          params.targetFormat = providerConfig.type;
+        }
+        const instance2 = await definition.create(params);
         loaded.push({ config: config2, definition, instance: instance2 });
       } catch (err) {
         const errorMsg = err instanceof Error ? err.message : String(err);
@@ -54195,7 +55299,7 @@ class PluginManager {
     const oldPluginsToDispose = [];
     for (const [providerName, providerConfig] of Object.entries(providers)) {
       if (providerConfig.plugins && providerConfig.plugins.length > 0) {
-        const { loaded, failures } = await this.loadPluginsForProvider(providerName, providerConfig.plugins);
+        const { loaded, failures } = await this.loadPluginsForProvider(providerName, providerConfig, providerConfig.plugins);
         allFailures.push(...failures);
         if (failures.length > 0) {
           console.warn(`[plugin] provider "${providerName}" \u6709\u63D2\u4EF6\u52A0\u8F7D\u5931\u8D25\uFF0C\u4FDD\u7559\u65E7\u63D2\u4EF6\u94FE`);
@@ -54264,19 +55368,12 @@ class PluginManager {
       }
     }
   }
-  async disposePluginMap(pluginMap) {
-    const allPlugins = [];
-    for (const [, loadedPlugins] of pluginMap) {
-      allPlugins.push(...loadedPlugins);
-    }
-    await this.disposePluginList(allPlugins);
-  }
 }
 
 // src/proxy.ts
 import { appendFile, readFile, unlink } from "fs/promises";
-import { join as join9 } from "path";
 import { tmpdir as tmpdir2 } from "os";
+import { join as join10 } from "path";
 
 // src/plugin-engine.ts
 async function executeRequestPlugins(plugins, ctx, url2, headers, body) {
@@ -54468,7 +55565,7 @@ function buildLogEvent(logMeta, targetUrl, proxyUrl, tsEnd, overrides) {
   };
 }
 function createTempStreamCapturePath(requestId) {
-  return join9(tmpdir2(), `local-router-stream-${requestId}-${Date.now()}.sse.raw`);
+  return join10(tmpdir2(), `local-router-stream-${requestId}-${Date.now()}.sse.raw`);
 }
 async function appendTempStreamCapture(filePath, chunk) {
   await appendFile(filePath, chunk);
@@ -54787,47 +55884,34 @@ function createOpenaiResponsesRoutes(routeType, store, pluginManager) {
   return routes;
 }
 
-// src/runtime-assets.ts
-import { fileURLToPath } from "url";
-function resolveBundledAssetPath(relativePath) {
-  return fileURLToPath(new URL(relativePath, import.meta.url));
-}
-function getBundledSchemaPath() {
-  return resolveBundledAssetPath("../config.schema.json");
-}
-function getBundledWebRoot() {
-  return resolveBundledAssetPath("../dist/web/");
-}
-
-// src/config-validate.ts
-var import__2020 = __toESM(require_2020(), 1);
-var import_ajv_formats = __toESM(require_dist2(), 1);
-import { readFileSync as readFileSync3 } from "fs";
-function validateBusinessRules(config2) {
-  for (const [routeType, modelMap] of Object.entries(config2.routes)) {
-    if (!modelMap["*"]) {
-      throw new Error(`\u8DEF\u7531 "${routeType}" \u7F3A\u5C11 "*" \u515C\u5E95\u89C4\u5219`);
-    }
-    for (const target of Object.values(modelMap)) {
-      if (!config2.providers[target.provider]) {
-        throw new Error(`\u8DEF\u7531 "${routeType}" \u5F15\u7528\u4E86\u4E0D\u5B58\u5728\u7684 provider "${target.provider}"`);
-      }
-    }
+// src/server-address.ts
+function formatUrlHost(host) {
+  const trimmed = host.trim();
+  if (trimmed.startsWith("[") && trimmed.endsWith("]")) {
+    return trimmed;
   }
+  return trimmed.includes(":") ? `[${trimmed}]` : trimmed;
 }
-function validateConfigOrThrow(config2) {
-  validateBusinessRules(config2);
-  const ajv = new import__2020.default({ allErrors: true, strict: false });
-  import_ajv_formats.default(ajv);
-  const schemaJson = JSON.parse(readFileSync3(getBundledSchemaPath(), "utf-8"));
-  const validateBySchema = ajv.compile(schemaJson);
-  const valid = validateBySchema(config2);
-  if (!valid) {
-    const firstError = validateBySchema.errors?.[0];
-    const path = firstError?.instancePath || "(root)";
-    const message = firstError?.message ?? "unknown schema validation error";
-    throw new Error(`Schema \u6821\u9A8C\u5931\u8D25: ${path} ${message}`);
+function resolveLocalAccessHost(listenHost) {
+  const host = listenHost.trim().toLowerCase();
+  if (host === "0.0.0.0" || host === "") {
+    return "127.0.0.1";
   }
+  if (host === "::" || host === "[::]") {
+    return "::1";
+  }
+  return listenHost.trim();
+}
+function createServerAddressInfo(listenHost, port) {
+  const normalizedListenHost = listenHost.trim() || "0.0.0.0";
+  const localHost = resolveLocalAccessHost(normalizedListenHost);
+  return {
+    listenHost: normalizedListenHost,
+    localHost,
+    port,
+    listenUrl: `http://${formatUrlHost(normalizedListenHost)}:${port}`,
+    localUrl: `http://${formatUrlHost(localHost)}:${port}`
+  };
 }
 
 // src/index.ts
@@ -54869,13 +55953,18 @@ var ROUTE_REGISTRY = {
     create: createAnthropicMessagesRoutes
   }
 };
-function printIntegrationGuide(config2) {
-  const host = process.env.HOST ?? "127.0.0.1";
-  const port = process.env.PORT ?? "4099";
-  const baseUrl = `http://${host}:${port}`;
+function printIntegrationGuide(config2, listen = {}) {
+  const host = listen.host ?? process.env.HOST ?? "0.0.0.0";
+  const parsedPort = listen.port ?? Number.parseInt(process.env.PORT ?? "4099", 10);
+  const address = createServerAddressInfo(host, Number.isFinite(parsedPort) ? parsedPort : 4099);
+  const baseUrl = address.localUrl;
   console.log(`
 ================ local-router \u63A5\u5165\u6307\u5357 ================`);
-  console.log(`\u672C\u5730\u670D\u52A1\u5730\u5740: ${baseUrl}`);
+  console.log(`\u670D\u52A1\u76D1\u542C\u5730\u5740: ${address.listenUrl}`);
+  console.log(`\u672C\u673A\u8BBF\u95EE\u5730\u5740: ${address.localUrl}`);
+  if (address.listenHost === "0.0.0.0" || address.listenHost === "::" || address.listenHost === "[::]") {
+    console.log("\u5C40\u57DF\u7F51\u8BBF\u95EE: \u5F00\u542F\u5C40\u57DF\u7F51\u670D\u52A1\u540E\uFF0C\u4F7F\u7528\u672C\u673A\u5C40\u57DF\u7F51 IP \u66FF\u6362\u4E0A\u9762\u7684\u672C\u673A\u5730\u5740\u3002");
+  }
   console.log("\u5065\u5EB7\u68C0\u67E5: GET /");
   console.log(`API \u6587\u6863: ${baseUrl}/api/docs`);
   console.log(`\u7BA1\u7406\u9762\u677F: ${baseUrl}/admin`);
@@ -55302,7 +56391,6 @@ function createAdminApiRoutes(store, pluginManager, registerCleanup) {
     }
   });
   api2.get("/logs/tail", async (c2) => {
-    const config2 = store.get();
     const target = c2.req.raw;
     const windowRaw = c2.req.query("window") ?? "1h";
     if (!isLogQueryWindow(windowRaw)) {
@@ -55330,11 +56418,15 @@ function createAdminApiRoutes(store, pluginManager, registerCleanup) {
     }
     const encoder = new TextEncoder;
     let closed = false;
-    let lastSeenTs = Date.now() - 60 * 1000;
+    const maxPendingItems = 500;
     let closeStream = null;
     const stream = new ReadableStream({
       start(controller) {
-        let timer = null;
+        let heartbeatTimer = null;
+        let unsubscribe = null;
+        let flushQueued = false;
+        let droppedItems = 0;
+        const pending = [];
         const push2 = (event, payload) => {
           if (closed)
             return;
@@ -55348,60 +56440,106 @@ function createAdminApiRoutes(store, pluginManager, registerCleanup) {
           if (closed)
             return;
           closed = true;
-          if (timer) {
-            clearInterval(timer);
-            timer = null;
+          if (heartbeatTimer) {
+            clearInterval(heartbeatTimer);
+            heartbeatTimer = null;
           }
+          unsubscribe?.();
+          unsubscribe = null;
           target.signal.removeEventListener("abort", close);
           try {
             controller.close();
           } catch {}
         };
         closeStream = close;
-        push2("ready", { ok: true, now: new Date().toISOString() });
-        timer = setInterval(async () => {
+        const buildTailQuery = () => ({
+          ...resolveLogQueryRange({
+            window: windowRaw,
+            from: c2.req.query("from"),
+            to: c2.req.query("to")
+          }),
+          levels,
+          providers: parseCommaSeparated(c2.req.query("provider")),
+          routeTypes: parseCommaSeparated(c2.req.query("routeType")),
+          models: parseCommaSeparated(c2.req.query("model")),
+          modelIns: parseCommaSeparated(c2.req.query("modelIn")),
+          modelOuts: parseCommaSeparated(c2.req.query("modelOut")),
+          users: parseCommaSeparated(c2.req.query("user")),
+          sessions: parseCommaSeparated(c2.req.query("session")),
+          statusClasses,
+          hasError,
+          q: c2.req.query("q") ?? "",
+          sort: sortRaw,
+          limit: 100,
+          cursor: null
+        });
+        const flush = () => {
+          flushQueued = false;
+          if (closed || pending.length === 0)
+            return;
+          const items = pending.splice(0, pending.length);
+          const overflowMessage = droppedItems > 0 ? `\u5B9E\u65F6\u8FFD\u8E2A\u961F\u5217\u5DF2\u4E22\u5F03 ${droppedItems} \u6761\u4E8B\u4EF6\uFF0C\u8BF7\u91CD\u65B0\u67E5\u8BE2\u4EE5\u8865\u9F50\u3002` : undefined;
+          droppedItems = 0;
+          push2("events", {
+            items,
+            nextCursor: null,
+            hasMore: false,
+            stats: {
+              total: 0,
+              errorCount: 0,
+              errorRate: 0,
+              avgLatencyMs: 0,
+              p95LatencyMs: 0
+            },
+            meta: {
+              scannedFiles: 0,
+              scannedLines: 0,
+              parseErrors: 0,
+              truncated: false,
+              indexUsed: true,
+              indexFresh: true,
+              usesFts: false,
+              queryMs: 0,
+              rowsReturned: items.length,
+              fallbackReason: overflowMessage,
+              statsMode: "none"
+            }
+          });
+        };
+        const queueFlush = () => {
+          if (flushQueued)
+            return;
+          flushQueued = true;
+          queueMicrotask(flush);
+        };
+        unsubscribe = subscribeLogEvents((published) => {
           if (closed)
             return;
           try {
-            const toMs = Date.now();
-            const data = await queryLogEvents({ logConfig: config2.log }, {
-              fromMs: Math.max(lastSeenTs, toMs - 60 * 60 * 1000),
-              toMs,
-              levels,
-              providers: parseCommaSeparated(c2.req.query("provider")),
-              routeTypes: parseCommaSeparated(c2.req.query("routeType")),
-              models: parseCommaSeparated(c2.req.query("model")),
-              modelIns: parseCommaSeparated(c2.req.query("modelIn")),
-              modelOuts: parseCommaSeparated(c2.req.query("modelOut")),
-              users: parseCommaSeparated(c2.req.query("user")),
-              sessions: parseCommaSeparated(c2.req.query("session")),
-              statusClasses,
-              hasError,
-              q: c2.req.query("q") ?? "",
-              sort: sortRaw,
-              limit: 100
-            });
-            if (closed)
+            const query = buildTailQuery();
+            if (!logEventMatchesQuery(published.event, query))
               return;
-            if (data.items.length > 0) {
-              const maxTs = Math.max(...data.items.map((item) => Date.parse(item.ts)).filter(Number.isFinite));
-              if (Number.isFinite(maxTs)) {
-                lastSeenTs = Math.max(lastSeenTs, maxTs + 1);
-              }
-              push2("events", {
-                items: data.items,
-                stats: data.stats,
-                meta: data.meta
-              });
-            } else {
-              push2("heartbeat", { ts: new Date().toISOString() });
+            if (pending.length >= maxPendingItems) {
+              pending.shift();
+              droppedItems += 1;
             }
+            pending.push(createLogEventSummaryFromEvent(published.event, {
+              id: published.id,
+              date: published.date,
+              line: null
+            }));
+            queueFlush();
           } catch (err) {
-            if (closed)
-              return;
             push2("error", { error: err instanceof Error ? err.message : String(err) });
           }
-        }, 3000);
+        });
+        push2("ready", { ok: true, now: new Date().toISOString() });
+        heartbeatTimer = setInterval(() => {
+          if (closed)
+            return;
+          push2("heartbeat", { ts: new Date().toISOString() });
+        }, 15000);
+        heartbeatTimer.unref?.();
         target.signal.addEventListener("abort", close);
       },
       cancel() {
@@ -55514,8 +56652,9 @@ async function createApp(store, options) {
   options?.registerCleanup?.(() => {
     pluginManager.disposeAll().catch(() => {});
   });
-  printIntegrationGuide(config2);
+  printIntegrationGuide(config2, options?.listen);
   const app = new Hono2;
+  app.use("*", createNetworkAccessMiddleware(store));
   app.get("/", (c2) => c2.text("local-router is running"));
   for (const [routeType, entry] of Object.entries(ROUTE_REGISTRY)) {
     const subApp = entry.create(routeType, store, pluginManager);
@@ -55554,12 +56693,26 @@ async function createApp(store, options) {
 async function createDefaultAppFromProcessArgs() {
   const configPath = parseConfigPath();
   const store = new ConfigStore(configPath);
-  return createApp(store);
+  return createApp(store, {
+    listen: {
+      host: process.env.HOST ?? "0.0.0.0",
+      port: Number.parseInt(process.env.PORT ?? "4099", 10)
+    }
+  });
 }
 
 // src/entry.ts
 var app = await createDefaultAppFromProcessArgs();
-var entry_default = app;
+var entry_default = {
+  hostname: process.env.HOST ?? "0.0.0.0",
+  port: Number.parseInt(process.env.PORT ?? "4099", 10),
+  fetch(request, server) {
+    const remoteAddress = server.requestIP(request)?.address ?? null;
+    return app.fetch(request, {
+      [REMOTE_ADDRESS_ENV_KEY]: remoteAddress
+    });
+  }
+};
 export {
   entry_default as default
 };