@lakphy/local-router 0.2.0 → 0.3.0

package/dist/cli.js

@@ -2406,7 +2406,7 @@ var require_codegen = __commonJS((exports) => {
     ADD: new code_1._Code("+")
   };
 
-  class Node {
+  class Node3 {
     optimizeNodes() {
       return this;
     }
@@ -2415,7 +2415,7 @@ var require_codegen = __commonJS((exports) => {
     }
   }
 
-  class Def extends Node {
+  class Def extends Node3 {
     constructor(varKind, name21, rhs) {
       super();
       this.varKind = varKind;
@@ -2439,7 +2439,7 @@ var require_codegen = __commonJS((exports) => {
     }
   }
 
-  class Assign extends Node {
+  class Assign extends Node3 {
     constructor(lhs, rhs, sideEffects) {
       super();
       this.lhs = lhs;
@@ -2471,7 +2471,7 @@ var require_codegen = __commonJS((exports) => {
     }
   }
 
-  class Label extends Node {
+  class Label extends Node3 {
     constructor(label) {
       super();
       this.label = label;
@@ -2482,7 +2482,7 @@ var require_codegen = __commonJS((exports) => {
     }
   }
 
-  class Break extends Node {
+  class Break extends Node3 {
     constructor(label) {
       super();
       this.label = label;
@@ -2494,7 +2494,7 @@ var require_codegen = __commonJS((exports) => {
     }
   }
 
-  class Throw extends Node {
+  class Throw extends Node3 {
     constructor(error48) {
       super();
       this.error = error48;
@@ -2507,7 +2507,7 @@ var require_codegen = __commonJS((exports) => {
     }
   }
 
-  class AnyCode extends Node {
+  class AnyCode extends Node3 {
     constructor(code) {
       super();
       this.code = code;
@@ -2527,7 +2527,7 @@ var require_codegen = __commonJS((exports) => {
     }
   }
 
-  class ParentNode extends Node {
+  class ParentNode extends Node3 {
     constructor(nodes = []) {
       super();
       this.nodes = nodes;
@@ -4935,7 +4935,7 @@ var require_compile = __commonJS((exports) => {
     const schOrFunc = root2.refs[ref];
     if (schOrFunc)
       return schOrFunc;
-    let _sch = resolve3.call(this, root2, ref);
+    let _sch = resolve5.call(this, root2, ref);
     if (_sch === undefined) {
       const schema = (_a21 = root2.localRefs) === null || _a21 === undefined ? undefined : _a21[ref];
       const { schemaId } = this.opts;
@@ -4962,7 +4962,7 @@ var require_compile = __commonJS((exports) => {
   function sameSchemaEnv(s1, s2) {
     return s1.schema === s2.schema && s1.root === s2.root && s1.baseId === s2.baseId;
   }
-  function resolve3(root2, ref) {
+  function resolve5(root2, ref) {
     let sch;
     while (typeof (sch = this.refs[ref]) == "string")
       ref = sch;
@@ -5492,7 +5492,7 @@ var require_fast_uri = __commonJS((exports, module) => {
     }
     return uri;
   }
-  function resolve3(baseURI, relativeURI, options) {
+  function resolve5(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;
@@ -5720,7 +5720,7 @@ var require_fast_uri = __commonJS((exports, module) => {
   var fastUri = {
     SCHEMES,
     normalize,
-    resolve: resolve3,
+    resolve: resolve5,
     resolveComponent,
     equal,
     serialize,
@@ -5857,7 +5857,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 = getLogger(opts.logger);
+      this.logger = getLogger2(opts.logger);
       const formatOpt = opts.validateFormats;
       opts.validateFormats = false;
       this.RULES = (0, rules_1.getRules)();
@@ -6254,7 +6254,7 @@ var require_core = __commonJS((exports) => {
     return metaOpts;
   }
   var noLogs = { log() {}, warn() {}, error() {} };
-  function getLogger(logger) {
+  function getLogger2(logger) {
     if (logger === false)
       return noLogs;
     if (logger === undefined)
@@ -8757,10 +8757,537 @@ var require_2020 = __commonJS((exports, module) => {
   } });
 });
 
+// node_modules/.bun/ajv-formats@3.0.1/node_modules/ajv-formats/dist/formats.js
+var require_formats = __commonJS((exports) => {
+  Object.defineProperty(exports, "__esModule", { value: true });
+  exports.formatNames = exports.fastFormats = exports.fullFormats = undefined;
+  function fmtDef(validate, compare) {
+    return { validate, compare };
+  }
+  exports.fullFormats = {
+    date: fmtDef(date5, compareDate),
+    time: fmtDef(getTime(true), compareTime),
+    "date-time": fmtDef(getDateTime(true), compareDateTime),
+    "iso-time": fmtDef(getTime(), compareIsoTime),
+    "iso-date-time": fmtDef(getDateTime(), compareIsoDateTime),
+    duration: /^P(?!$)((\d+Y)?(\d+M)?(\d+D)?(T(?=\d)(\d+H)?(\d+M)?(\d+S)?)?|(\d+W)?)$/,
+    uri,
+    "uri-reference": /^(?:[a-z][a-z0-9+\-.]*:)?(?:\/?\/(?:(?:[a-z0-9\-._~!$&'()*+,;=:]|%[0-9a-f]{2})*@)?(?:\[(?:(?:(?:(?:[0-9a-f]{1,4}:){6}|::(?:[0-9a-f]{1,4}:){5}|(?:[0-9a-f]{1,4})?::(?:[0-9a-f]{1,4}:){4}|(?:(?:[0-9a-f]{1,4}:){0,1}[0-9a-f]{1,4})?::(?:[0-9a-f]{1,4}:){3}|(?:(?:[0-9a-f]{1,4}:){0,2}[0-9a-f]{1,4})?::(?:[0-9a-f]{1,4}:){2}|(?:(?:[0-9a-f]{1,4}:){0,3}[0-9a-f]{1,4})?::[0-9a-f]{1,4}:|(?:(?:[0-9a-f]{1,4}:){0,4}[0-9a-f]{1,4})?::)(?:[0-9a-f]{1,4}:[0-9a-f]{1,4}|(?:(?:25[0-5]|2[0-4]\d|[01]?\d\d?)\.){3}(?:25[0-5]|2[0-4]\d|[01]?\d\d?))|(?:(?:[0-9a-f]{1,4}:){0,5}[0-9a-f]{1,4})?::[0-9a-f]{1,4}|(?:(?:[0-9a-f]{1,4}:){0,6}[0-9a-f]{1,4})?::)|[Vv][0-9a-f]+\.[a-z0-9\-._~!$&'()*+,;=:]+)\]|(?:(?:25[0-5]|2[0-4]\d|[01]?\d\d?)\.){3}(?:25[0-5]|2[0-4]\d|[01]?\d\d?)|(?:[a-z0-9\-._~!$&'"()*+,;=]|%[0-9a-f]{2})*)(?::\d*)?(?:\/(?:[a-z0-9\-._~!$&'"()*+,;=:@]|%[0-9a-f]{2})*)*|\/(?:(?:[a-z0-9\-._~!$&'"()*+,;=:@]|%[0-9a-f]{2})+(?:\/(?:[a-z0-9\-._~!$&'"()*+,;=:@]|%[0-9a-f]{2})*)*)?|(?:[a-z0-9\-._~!$&'"()*+,;=:@]|%[0-9a-f]{2})+(?:\/(?:[a-z0-9\-._~!$&'"()*+,;=:@]|%[0-9a-f]{2})*)*)?(?:\?(?:[a-z0-9\-._~!$&'"()*+,;=:@/?]|%[0-9a-f]{2})*)?(?:#(?:[a-z0-9\-._~!$&'"()*+,;=:@/?]|%[0-9a-f]{2})*)?$/i,
+    "uri-template": /^(?:(?:[^\x00-\x20"'<>%\\^`{|}]|%[0-9a-f]{2})|\{[+#./;?&=,!@|]?(?:[a-z0-9_]|%[0-9a-f]{2})+(?::[1-9][0-9]{0,3}|\*)?(?:,(?:[a-z0-9_]|%[0-9a-f]{2})+(?::[1-9][0-9]{0,3}|\*)?)*\})*$/i,
+    url: /^(?:https?|ftp):\/\/(?:\S+(?::\S*)?@)?(?:(?!(?:10|127)(?:\.\d{1,3}){3})(?!(?:169\.254|192\.168)(?:\.\d{1,3}){2})(?!172\.(?:1[6-9]|2\d|3[0-1])(?:\.\d{1,3}){2})(?:[1-9]\d?|1\d\d|2[01]\d|22[0-3])(?:\.(?:1?\d{1,2}|2[0-4]\d|25[0-5])){2}(?:\.(?:[1-9]\d?|1\d\d|2[0-4]\d|25[0-4]))|(?:(?:[a-z0-9\u{00a1}-\u{ffff}]+-)*[a-z0-9\u{00a1}-\u{ffff}]+)(?:\.(?:[a-z0-9\u{00a1}-\u{ffff}]+-)*[a-z0-9\u{00a1}-\u{ffff}]+)*(?:\.(?:[a-z\u{00a1}-\u{ffff}]{2,})))(?::\d{2,5})?(?:\/[^\s]*)?$/iu,
+    email: /^[a-z0-9!#$%&'*+/=?^_`{|}~-]+(?:\.[a-z0-9!#$%&'*+/=?^_`{|}~-]+)*@(?:[a-z0-9](?:[a-z0-9-]*[a-z0-9])?\.)+[a-z0-9](?:[a-z0-9-]*[a-z0-9])?$/i,
+    hostname: /^(?=.{1,253}\.?$)[a-z0-9](?:[a-z0-9-]{0,61}[a-z0-9])?(?:\.[a-z0-9](?:[-0-9a-z]{0,61}[0-9a-z])?)*\.?$/i,
+    ipv4: /^(?:(?:25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)\.){3}(?:25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)$/,
+    ipv6: /^((([0-9a-f]{1,4}:){7}([0-9a-f]{1,4}|:))|(([0-9a-f]{1,4}:){6}(:[0-9a-f]{1,4}|((25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)(\.(25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)){3})|:))|(([0-9a-f]{1,4}:){5}(((:[0-9a-f]{1,4}){1,2})|:((25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)(\.(25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)){3})|:))|(([0-9a-f]{1,4}:){4}(((:[0-9a-f]{1,4}){1,3})|((:[0-9a-f]{1,4})?:((25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)(\.(25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)){3}))|:))|(([0-9a-f]{1,4}:){3}(((:[0-9a-f]{1,4}){1,4})|((:[0-9a-f]{1,4}){0,2}:((25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)(\.(25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)){3}))|:))|(([0-9a-f]{1,4}:){2}(((:[0-9a-f]{1,4}){1,5})|((:[0-9a-f]{1,4}){0,3}:((25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)(\.(25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)){3}))|:))|(([0-9a-f]{1,4}:){1}(((:[0-9a-f]{1,4}){1,6})|((:[0-9a-f]{1,4}){0,4}:((25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)(\.(25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)){3}))|:))|(:(((:[0-9a-f]{1,4}){1,7})|((:[0-9a-f]{1,4}){0,5}:((25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)(\.(25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)){3}))|:)))$/i,
+    regex,
+    uuid: /^(?:urn:uuid:)?[0-9a-f]{8}-(?:[0-9a-f]{4}-){3}[0-9a-f]{12}$/i,
+    "json-pointer": /^(?:\/(?:[^~/]|~0|~1)*)*$/,
+    "json-pointer-uri-fragment": /^#(?:\/(?:[a-z0-9_\-.!$&'()*+,;:=@]|%[0-9a-f]{2}|~0|~1)*)*$/i,
+    "relative-json-pointer": /^(?:0|[1-9][0-9]*)(?:#|(?:\/(?:[^~/]|~0|~1)*)*)$/,
+    byte,
+    int32: { type: "number", validate: validateInt32 },
+    int64: { type: "number", validate: validateInt64 },
+    float: { type: "number", validate: validateNumber },
+    double: { type: "number", validate: validateNumber },
+    password: true,
+    binary: true
+  };
+  exports.fastFormats = {
+    ...exports.fullFormats,
+    date: fmtDef(/^\d\d\d\d-[0-1]\d-[0-3]\d$/, compareDate),
+    time: fmtDef(/^(?:[0-2]\d:[0-5]\d:[0-5]\d|23:59:60)(?:\.\d+)?(?:z|[+-]\d\d(?::?\d\d)?)$/i, compareTime),
+    "date-time": fmtDef(/^\d\d\d\d-[0-1]\d-[0-3]\dt(?:[0-2]\d:[0-5]\d:[0-5]\d|23:59:60)(?:\.\d+)?(?:z|[+-]\d\d(?::?\d\d)?)$/i, compareDateTime),
+    "iso-time": fmtDef(/^(?:[0-2]\d:[0-5]\d:[0-5]\d|23:59:60)(?:\.\d+)?(?:z|[+-]\d\d(?::?\d\d)?)?$/i, compareIsoTime),
+    "iso-date-time": fmtDef(/^\d\d\d\d-[0-1]\d-[0-3]\d[t\s](?:[0-2]\d:[0-5]\d:[0-5]\d|23:59:60)(?:\.\d+)?(?:z|[+-]\d\d(?::?\d\d)?)?$/i, compareIsoDateTime),
+    uri: /^(?:[a-z][a-z0-9+\-.]*:)(?:\/?\/)?[^\s]*$/i,
+    "uri-reference": /^(?:(?:[a-z][a-z0-9+\-.]*:)?\/?\/)?(?:[^\\\s#][^\s#]*)?(?:#[^\\\s]*)?$/i,
+    email: /^[a-z0-9.!#$%&'*+/=?^_`{|}~-]+@[a-z0-9](?:[a-z0-9-]{0,61}[a-z0-9])?(?:\.[a-z0-9](?:[a-z0-9-]{0,61}[a-z0-9])?)*$/i
+  };
+  exports.formatNames = Object.keys(exports.fullFormats);
+  function isLeapYear(year) {
+    return year % 4 === 0 && (year % 100 !== 0 || year % 400 === 0);
+  }
+  var DATE = /^(\d\d\d\d)-(\d\d)-(\d\d)$/;
+  var DAYS = [0, 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31];
+  function date5(str) {
+    const matches = DATE.exec(str);
+    if (!matches)
+      return false;
+    const year = +matches[1];
+    const month = +matches[2];
+    const day = +matches[3];
+    return month >= 1 && month <= 12 && day >= 1 && day <= (month === 2 && isLeapYear(year) ? 29 : DAYS[month]);
+  }
+  function compareDate(d1, d2) {
+    if (!(d1 && d2))
+      return;
+    if (d1 > d2)
+      return 1;
+    if (d1 < d2)
+      return -1;
+    return 0;
+  }
+  var TIME = /^(\d\d):(\d\d):(\d\d(?:\.\d+)?)(z|([+-])(\d\d)(?::?(\d\d))?)?$/i;
+  function getTime(strictTimeZone) {
+    return function time3(str) {
+      const matches = TIME.exec(str);
+      if (!matches)
+        return false;
+      const hr = +matches[1];
+      const min = +matches[2];
+      const sec = +matches[3];
+      const tz = matches[4];
+      const tzSign = matches[5] === "-" ? -1 : 1;
+      const tzH = +(matches[6] || 0);
+      const tzM = +(matches[7] || 0);
+      if (tzH > 23 || tzM > 59 || strictTimeZone && !tz)
+        return false;
+      if (hr <= 23 && min <= 59 && sec < 60)
+        return true;
+      const utcMin = min - tzM * tzSign;
+      const utcHr = hr - tzH * tzSign - (utcMin < 0 ? 1 : 0);
+      return (utcHr === 23 || utcHr === -1) && (utcMin === 59 || utcMin === -1) && sec < 61;
+    };
+  }
+  function compareTime(s1, s2) {
+    if (!(s1 && s2))
+      return;
+    const t1 = new Date("2020-01-01T" + s1).valueOf();
+    const t2 = new Date("2020-01-01T" + s2).valueOf();
+    if (!(t1 && t2))
+      return;
+    return t1 - t2;
+  }
+  function compareIsoTime(t1, t2) {
+    if (!(t1 && t2))
+      return;
+    const a1 = TIME.exec(t1);
+    const a2 = TIME.exec(t2);
+    if (!(a1 && a2))
+      return;
+    t1 = a1[1] + a1[2] + a1[3];
+    t2 = a2[1] + a2[2] + a2[3];
+    if (t1 > t2)
+      return 1;
+    if (t1 < t2)
+      return -1;
+    return 0;
+  }
+  var DATE_TIME_SEPARATOR = /t|\s/i;
+  function getDateTime(strictTimeZone) {
+    const time3 = getTime(strictTimeZone);
+    return function date_time(str) {
+      const dateTime = str.split(DATE_TIME_SEPARATOR);
+      return dateTime.length === 2 && date5(dateTime[0]) && time3(dateTime[1]);
+    };
+  }
+  function compareDateTime(dt1, dt2) {
+    if (!(dt1 && dt2))
+      return;
+    const d1 = new Date(dt1).valueOf();
+    const d2 = new Date(dt2).valueOf();
+    if (!(d1 && d2))
+      return;
+    return d1 - d2;
+  }
+  function compareIsoDateTime(dt1, dt2) {
+    if (!(dt1 && dt2))
+      return;
+    const [d1, t1] = dt1.split(DATE_TIME_SEPARATOR);
+    const [d2, t2] = dt2.split(DATE_TIME_SEPARATOR);
+    const res = compareDate(d1, d2);
+    if (res === undefined)
+      return;
+    return res || compareTime(t1, t2);
+  }
+  var NOT_URI_FRAGMENT = /\/|:/;
+  var URI = /^(?:[a-z][a-z0-9+\-.]*:)(?:\/?\/(?:(?:[a-z0-9\-._~!$&'()*+,;=:]|%[0-9a-f]{2})*@)?(?:\[(?:(?:(?:(?:[0-9a-f]{1,4}:){6}|::(?:[0-9a-f]{1,4}:){5}|(?:[0-9a-f]{1,4})?::(?:[0-9a-f]{1,4}:){4}|(?:(?:[0-9a-f]{1,4}:){0,1}[0-9a-f]{1,4})?::(?:[0-9a-f]{1,4}:){3}|(?:(?:[0-9a-f]{1,4}:){0,2}[0-9a-f]{1,4})?::(?:[0-9a-f]{1,4}:){2}|(?:(?:[0-9a-f]{1,4}:){0,3}[0-9a-f]{1,4})?::[0-9a-f]{1,4}:|(?:(?:[0-9a-f]{1,4}:){0,4}[0-9a-f]{1,4})?::)(?:[0-9a-f]{1,4}:[0-9a-f]{1,4}|(?:(?:25[0-5]|2[0-4]\d|[01]?\d\d?)\.){3}(?:25[0-5]|2[0-4]\d|[01]?\d\d?))|(?:(?:[0-9a-f]{1,4}:){0,5}[0-9a-f]{1,4})?::[0-9a-f]{1,4}|(?:(?:[0-9a-f]{1,4}:){0,6}[0-9a-f]{1,4})?::)|[Vv][0-9a-f]+\.[a-z0-9\-._~!$&'()*+,;=:]+)\]|(?:(?:25[0-5]|2[0-4]\d|[01]?\d\d?)\.){3}(?:25[0-5]|2[0-4]\d|[01]?\d\d?)|(?:[a-z0-9\-._~!$&'()*+,;=]|%[0-9a-f]{2})*)(?::\d*)?(?:\/(?:[a-z0-9\-._~!$&'()*+,;=:@]|%[0-9a-f]{2})*)*|\/(?:(?:[a-z0-9\-._~!$&'()*+,;=:@]|%[0-9a-f]{2})+(?:\/(?:[a-z0-9\-._~!$&'()*+,;=:@]|%[0-9a-f]{2})*)*)?|(?:[a-z0-9\-._~!$&'()*+,;=:@]|%[0-9a-f]{2})+(?:\/(?:[a-z0-9\-._~!$&'()*+,;=:@]|%[0-9a-f]{2})*)*)(?:\?(?:[a-z0-9\-._~!$&'()*+,;=:@/?]|%[0-9a-f]{2})*)?(?:#(?:[a-z0-9\-._~!$&'()*+,;=:@/?]|%[0-9a-f]{2})*)?$/i;
+  function uri(str) {
+    return NOT_URI_FRAGMENT.test(str) && URI.test(str);
+  }
+  var BYTE = /^(?:[A-Za-z0-9+/]{4})*(?:[A-Za-z0-9+/]{2}==|[A-Za-z0-9+/]{3}=)?$/gm;
+  function byte(str) {
+    BYTE.lastIndex = 0;
+    return BYTE.test(str);
+  }
+  var MIN_INT32 = -(2 ** 31);
+  var MAX_INT32 = 2 ** 31 - 1;
+  function validateInt32(value) {
+    return Number.isInteger(value) && value <= MAX_INT32 && value >= MIN_INT32;
+  }
+  function validateInt64(value) {
+    return Number.isInteger(value);
+  }
+  function validateNumber() {
+    return true;
+  }
+  var Z_ANCHOR = /[^\\]\\Z/;
+  function regex(str) {
+    if (Z_ANCHOR.test(str))
+      return false;
+    try {
+      new RegExp(str);
+      return true;
+    } catch (e) {
+      return false;
+    }
+  }
+});
+
+// node_modules/.bun/ajv@8.18.0/node_modules/ajv/dist/vocabularies/draft7.js
+var require_draft7 = __commonJS((exports) => {
+  Object.defineProperty(exports, "__esModule", { value: true });
+  var core_1 = require_core2();
+  var validation_1 = require_validation();
+  var applicator_1 = require_applicator();
+  var format_1 = require_format2();
+  var metadata_1 = require_metadata();
+  var draft7Vocabularies = [
+    core_1.default,
+    validation_1.default,
+    (0, applicator_1.default)(),
+    format_1.default,
+    metadata_1.metadataVocabulary,
+    metadata_1.contentVocabulary
+  ];
+  exports.default = draft7Vocabularies;
+});
+
+// node_modules/.bun/ajv@8.18.0/node_modules/ajv/dist/refs/json-schema-draft-07.json
+var require_json_schema_draft_07 = __commonJS((exports, module) => {
+  module.exports = {
+    $schema: "http://json-schema.org/draft-07/schema#",
+    $id: "http://json-schema.org/draft-07/schema#",
+    title: "Core schema meta-schema",
+    definitions: {
+      schemaArray: {
+        type: "array",
+        minItems: 1,
+        items: { $ref: "#" }
+      },
+      nonNegativeInteger: {
+        type: "integer",
+        minimum: 0
+      },
+      nonNegativeIntegerDefault0: {
+        allOf: [{ $ref: "#/definitions/nonNegativeInteger" }, { default: 0 }]
+      },
+      simpleTypes: {
+        enum: ["array", "boolean", "integer", "null", "number", "object", "string"]
+      },
+      stringArray: {
+        type: "array",
+        items: { type: "string" },
+        uniqueItems: true,
+        default: []
+      }
+    },
+    type: ["object", "boolean"],
+    properties: {
+      $id: {
+        type: "string",
+        format: "uri-reference"
+      },
+      $schema: {
+        type: "string",
+        format: "uri"
+      },
+      $ref: {
+        type: "string",
+        format: "uri-reference"
+      },
+      $comment: {
+        type: "string"
+      },
+      title: {
+        type: "string"
+      },
+      description: {
+        type: "string"
+      },
+      default: true,
+      readOnly: {
+        type: "boolean",
+        default: false
+      },
+      examples: {
+        type: "array",
+        items: true
+      },
+      multipleOf: {
+        type: "number",
+        exclusiveMinimum: 0
+      },
+      maximum: {
+        type: "number"
+      },
+      exclusiveMaximum: {
+        type: "number"
+      },
+      minimum: {
+        type: "number"
+      },
+      exclusiveMinimum: {
+        type: "number"
+      },
+      maxLength: { $ref: "#/definitions/nonNegativeInteger" },
+      minLength: { $ref: "#/definitions/nonNegativeIntegerDefault0" },
+      pattern: {
+        type: "string",
+        format: "regex"
+      },
+      additionalItems: { $ref: "#" },
+      items: {
+        anyOf: [{ $ref: "#" }, { $ref: "#/definitions/schemaArray" }],
+        default: true
+      },
+      maxItems: { $ref: "#/definitions/nonNegativeInteger" },
+      minItems: { $ref: "#/definitions/nonNegativeIntegerDefault0" },
+      uniqueItems: {
+        type: "boolean",
+        default: false
+      },
+      contains: { $ref: "#" },
+      maxProperties: { $ref: "#/definitions/nonNegativeInteger" },
+      minProperties: { $ref: "#/definitions/nonNegativeIntegerDefault0" },
+      required: { $ref: "#/definitions/stringArray" },
+      additionalProperties: { $ref: "#" },
+      definitions: {
+        type: "object",
+        additionalProperties: { $ref: "#" },
+        default: {}
+      },
+      properties: {
+        type: "object",
+        additionalProperties: { $ref: "#" },
+        default: {}
+      },
+      patternProperties: {
+        type: "object",
+        additionalProperties: { $ref: "#" },
+        propertyNames: { format: "regex" },
+        default: {}
+      },
+      dependencies: {
+        type: "object",
+        additionalProperties: {
+          anyOf: [{ $ref: "#" }, { $ref: "#/definitions/stringArray" }]
+        }
+      },
+      propertyNames: { $ref: "#" },
+      const: true,
+      enum: {
+        type: "array",
+        items: true,
+        minItems: 1,
+        uniqueItems: true
+      },
+      type: {
+        anyOf: [
+          { $ref: "#/definitions/simpleTypes" },
+          {
+            type: "array",
+            items: { $ref: "#/definitions/simpleTypes" },
+            minItems: 1,
+            uniqueItems: true
+          }
+        ]
+      },
+      format: { type: "string" },
+      contentMediaType: { type: "string" },
+      contentEncoding: { type: "string" },
+      if: { $ref: "#" },
+      then: { $ref: "#" },
+      else: { $ref: "#" },
+      allOf: { $ref: "#/definitions/schemaArray" },
+      anyOf: { $ref: "#/definitions/schemaArray" },
+      oneOf: { $ref: "#/definitions/schemaArray" },
+      not: { $ref: "#" }
+    },
+    default: true
+  };
+});
+
+// node_modules/.bun/ajv@8.18.0/node_modules/ajv/dist/ajv.js
+var require_ajv = __commonJS((exports, module) => {
+  Object.defineProperty(exports, "__esModule", { value: true });
+  exports.MissingRefError = exports.ValidationError = exports.CodeGen = exports.Name = exports.nil = exports.stringify = exports.str = exports._ = exports.KeywordCxt = exports.Ajv = undefined;
+  var core_1 = require_core();
+  var draft7_1 = require_draft7();
+  var discriminator_1 = require_discriminator();
+  var draft7MetaSchema = require_json_schema_draft_07();
+  var META_SUPPORT_DATA = ["/properties"];
+  var META_SCHEMA_ID = "http://json-schema.org/draft-07/schema";
+
+  class Ajv extends core_1.default {
+    _addVocabularies() {
+      super._addVocabularies();
+      draft7_1.default.forEach((v) => this.addVocabulary(v));
+      if (this.opts.discriminator)
+        this.addKeyword(discriminator_1.default);
+    }
+    _addDefaultMetaSchema() {
+      super._addDefaultMetaSchema();
+      if (!this.opts.meta)
+        return;
+      const metaSchema = this.opts.$data ? this.$dataMetaSchema(draft7MetaSchema, META_SUPPORT_DATA) : draft7MetaSchema;
+      this.addMetaSchema(metaSchema, META_SCHEMA_ID, false);
+      this.refs["http://json-schema.org/schema"] = META_SCHEMA_ID;
+    }
+    defaultMeta() {
+      return this.opts.defaultMeta = super.defaultMeta() || (this.getSchema(META_SCHEMA_ID) ? META_SCHEMA_ID : undefined);
+    }
+  }
+  exports.Ajv = Ajv;
+  module.exports = exports = Ajv;
+  module.exports.Ajv = Ajv;
+  Object.defineProperty(exports, "__esModule", { value: true });
+  exports.default = Ajv;
+  var validate_1 = require_validate();
+  Object.defineProperty(exports, "KeywordCxt", { enumerable: true, get: function() {
+    return validate_1.KeywordCxt;
+  } });
+  var codegen_1 = require_codegen();
+  Object.defineProperty(exports, "_", { enumerable: true, get: function() {
+    return codegen_1._;
+  } });
+  Object.defineProperty(exports, "str", { enumerable: true, get: function() {
+    return codegen_1.str;
+  } });
+  Object.defineProperty(exports, "stringify", { enumerable: true, get: function() {
+    return codegen_1.stringify;
+  } });
+  Object.defineProperty(exports, "nil", { enumerable: true, get: function() {
+    return codegen_1.nil;
+  } });
+  Object.defineProperty(exports, "Name", { enumerable: true, get: function() {
+    return codegen_1.Name;
+  } });
+  Object.defineProperty(exports, "CodeGen", { enumerable: true, get: function() {
+    return codegen_1.CodeGen;
+  } });
+  var validation_error_1 = require_validation_error();
+  Object.defineProperty(exports, "ValidationError", { enumerable: true, get: function() {
+    return validation_error_1.default;
+  } });
+  var ref_error_1 = require_ref_error();
+  Object.defineProperty(exports, "MissingRefError", { enumerable: true, get: function() {
+    return ref_error_1.default;
+  } });
+});
+
+// node_modules/.bun/ajv-formats@3.0.1/node_modules/ajv-formats/dist/limit.js
+var require_limit = __commonJS((exports) => {
+  Object.defineProperty(exports, "__esModule", { value: true });
+  exports.formatLimitDefinition = undefined;
+  var ajv_1 = require_ajv();
+  var codegen_1 = require_codegen();
+  var ops = codegen_1.operators;
+  var KWDs = {
+    formatMaximum: { okStr: "<=", ok: ops.LTE, fail: ops.GT },
+    formatMinimum: { okStr: ">=", ok: ops.GTE, fail: ops.LT },
+    formatExclusiveMaximum: { okStr: "<", ok: ops.LT, fail: ops.GTE },
+    formatExclusiveMinimum: { okStr: ">", ok: ops.GT, fail: ops.LTE }
+  };
+  var error48 = {
+    message: ({ keyword, schemaCode }) => (0, codegen_1.str)`should be ${KWDs[keyword].okStr} ${schemaCode}`,
+    params: ({ keyword, schemaCode }) => (0, codegen_1._)`{comparison: ${KWDs[keyword].okStr}, limit: ${schemaCode}}`
+  };
+  exports.formatLimitDefinition = {
+    keyword: Object.keys(KWDs),
+    type: "string",
+    schemaType: "string",
+    $data: true,
+    error: error48,
+    code(cxt) {
+      const { gen, data, schemaCode, keyword, it } = cxt;
+      const { opts, self } = it;
+      if (!opts.validateFormats)
+        return;
+      const fCxt = new ajv_1.KeywordCxt(it, self.RULES.all.format.definition, "format");
+      if (fCxt.$data)
+        validate$DataFormat();
+      else
+        validateFormat();
+      function validate$DataFormat() {
+        const fmts = gen.scopeValue("formats", {
+          ref: self.formats,
+          code: opts.code.formats
+        });
+        const fmt = gen.const("fmt", (0, codegen_1._)`${fmts}[${fCxt.schemaCode}]`);
+        cxt.fail$data((0, codegen_1.or)((0, codegen_1._)`typeof ${fmt} != "object"`, (0, codegen_1._)`${fmt} instanceof RegExp`, (0, codegen_1._)`typeof ${fmt}.compare != "function"`, compareCode(fmt)));
+      }
+      function validateFormat() {
+        const format = fCxt.schema;
+        const fmtDef = self.formats[format];
+        if (!fmtDef || fmtDef === true)
+          return;
+        if (typeof fmtDef != "object" || fmtDef instanceof RegExp || typeof fmtDef.compare != "function") {
+          throw new Error(`"${keyword}": format "${format}" does not define "compare" function`);
+        }
+        const fmt = gen.scopeValue("formats", {
+          key: format,
+          ref: fmtDef,
+          code: opts.code.formats ? (0, codegen_1._)`${opts.code.formats}${(0, codegen_1.getProperty)(format)}` : undefined
+        });
+        cxt.fail$data(compareCode(fmt));
+      }
+      function compareCode(fmt) {
+        return (0, codegen_1._)`${fmt}.compare(${data}, ${schemaCode}) ${KWDs[keyword].fail} 0`;
+      }
+    },
+    dependencies: ["format"]
+  };
+  var formatLimitPlugin = (ajv) => {
+    ajv.addKeyword(exports.formatLimitDefinition);
+    return ajv;
+  };
+  exports.default = formatLimitPlugin;
+});
+
+// node_modules/.bun/ajv-formats@3.0.1/node_modules/ajv-formats/dist/index.js
+var require_dist2 = __commonJS((exports, module) => {
+  Object.defineProperty(exports, "__esModule", { value: true });
+  var formats_1 = require_formats();
+  var limit_1 = require_limit();
+  var codegen_1 = require_codegen();
+  var fullName = new codegen_1.Name("fullFormats");
+  var fastName = new codegen_1.Name("fastFormats");
+  var formatsPlugin = (ajv, opts = { keywords: true }) => {
+    if (Array.isArray(opts)) {
+      addFormats(ajv, opts, formats_1.fullFormats, fullName);
+      return ajv;
+    }
+    const [formats, exportName] = opts.mode === "fast" ? [formats_1.fastFormats, fastName] : [formats_1.fullFormats, fullName];
+    const list = opts.formats || formats_1.formatNames;
+    addFormats(ajv, list, formats, exportName);
+    if (opts.keywords)
+      (0, limit_1.default)(ajv);
+    return ajv;
+  };
+  formatsPlugin.get = (name21, mode = "full") => {
+    const formats = mode === "fast" ? formats_1.fastFormats : formats_1.fullFormats;
+    const f = formats[name21];
+    if (!f)
+      throw new Error(`Unknown format "${name21}"`);
+    return f;
+  };
+  function addFormats(ajv, list, fs, exportName) {
+    var _a21;
+    var _b16;
+    (_a21 = (_b16 = ajv.opts.code).formats) !== null && _a21 !== undefined || (_b16.formats = (0, codegen_1._)`require("ajv-formats/dist/formats").${exportName}`);
+    for (const f of list)
+      ajv.addFormat(f, fs[f]);
+  }
+  module.exports = exports = formatsPlugin;
+  Object.defineProperty(exports, "__esModule", { value: true });
+  exports.default = formatsPlugin;
+});
+
 // src/cli.ts
-import { existsSync as existsSync8, readFileSync as readFileSync6 } from "fs";
+import { existsSync as existsSync8, readFileSync as readFileSync8 } from "fs";
 import { setTimeout as sleep2 } from "timers/promises";
-import { parseArgs as parseArgs2 } from "util";
+import { parseArgs as parseArgs3 } from "util";
 
 // src/config.ts
 import { existsSync, mkdirSync, readFileSync, writeFileSync } from "fs";
@@ -9985,12 +10512,12 @@ function resolveLogBaseDir(logConfig) {
 }
 
 // src/cli/process.ts
-import { closeSync, openSync, readFileSync as readFileSync5, statSync } from "fs";
+import { closeSync, openSync, readFileSync as readFileSync6, statSync } from "fs";
 import { setTimeout as sleep } from "timers/promises";
 import { parseArgs } from "util";
 
 // src/index.ts
-import { readFileSync as readFileSync3 } from "fs";
+import { readFileSync as readFileSync4 } from "fs";
 
 // node_modules/.bun/@ai-sdk+provider@3.0.8/node_modules/@ai-sdk/provider/dist/index.mjs
 var marker = "vercel.ai.error";
@@ -49066,9 +49593,6 @@ var middleware = (options) => async (c2) => {
     `);
 };
 
-// src/index.ts
-var import__2020 = __toESM(require_2020(), 1);
-
 // node_modules/.bun/hono@4.12.5/node_modules/hono/dist/compose.js
 var compose = (middleware2, onError, onNotFound) => {
   return (context2, next) => {
@@ -53919,6 +54443,37 @@ 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}"`);
+      }
+    }
+  }
+}
+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}`);
+  }
+}
+
 // src/index.ts
 var ROUTE_REGISTRY = {
   "openai-completions": {
@@ -54037,10 +54592,8 @@ function createAdminApiRoutes(store, registerCleanup) {
   const cryptoSessions = new Map;
   const CRYPTO_SESSION_TTL_MS = 2 * 60 * 1000;
   const CRYPTO_SESSION_MAX = 512;
-  const ajv = new import__2020.default({ allErrors: true, strict: false });
   const schemaPath = getBundledSchemaPath();
-  const schemaJson = JSON.parse(readFileSync3(schemaPath, "utf-8"));
-  const validateBySchema = ajv.compile(schemaJson);
+  const schemaJson = JSON.parse(readFileSync4(schemaPath, "utf-8"));
   const pruneExpiredCryptoSessions = (now2 = Date.now()) => {
     for (const [id, record2] of Array.from(cryptoSessions.entries())) {
       if (now2 - record2.createdAt > CRYPTO_SESSION_TTL_MS) {
@@ -54134,12 +54687,10 @@ function createAdminApiRoutes(store, registerCleanup) {
       } catch (err) {
         return c2.json({ error: `\u914D\u7F6E\u6821\u9A8C\u5931\u8D25: ${err instanceof Error ? err.message : err}` }, 400);
       }
-      const schemaValid = validateBySchema(candidate);
-      if (!schemaValid) {
-        const firstError = validateBySchema.errors?.[0];
-        const path = firstError?.instancePath || "(root)";
-        const message = firstError?.message ?? "unknown schema validation error";
-        return c2.json({ error: `Schema \u6821\u9A8C\u5931\u8D25: ${path} ${message}` }, 400);
+      try {
+        validateConfigOrThrow(candidate);
+      } catch (err) {
+        return c2.json({ error: `\u914D\u7F6E\u6821\u9A8C\u5931\u8D25: ${err instanceof Error ? err.message : err}` }, 400);
       }
       store.save(candidate);
       return c2.json({ ok: true });
@@ -54674,7 +55225,7 @@ function startServer(options) {
 }
 
 // src/cli/runtime.ts
-import { existsSync as existsSync7, mkdirSync as mkdirSync3, readFileSync as readFileSync4, rmSync, writeFileSync as writeFileSync4 } from "fs";
+import { existsSync as existsSync7, mkdirSync as mkdirSync3, readFileSync as readFileSync5, rmSync, writeFileSync as writeFileSync4 } from "fs";
 import { homedir as homedir2 } from "os";
 import { join as join9, resolve as resolve5 } from "path";
 function getRuntimeDirs() {
@@ -54712,7 +55263,7 @@ function readRuntimeState() {
     return null;
   }
   try {
-    return JSON.parse(readFileSync4(files.state, "utf-8"));
+    return JSON.parse(readFileSync5(files.state, "utf-8"));
   } catch {
     return null;
   }
@@ -54894,7 +55445,7 @@ async function startDaemon(flags) {
   }
   let tail = "";
   try {
-    const content = readFileSync5(files.daemonLog, "utf-8");
+    const content = readFileSync6(files.daemonLog, "utf-8");
     tail = content.split(`
 `).slice(-20).join(`
 `);
@@ -54931,7 +55482,7 @@ function readLogDelta(filePath, offset) {
     if (stats.size <= offset) {
       return { content: "", nextOffset: offset };
     }
-    const full = readFileSync5(filePath, "utf-8");
+    const full = readFileSync6(filePath, "utf-8");
     const content = full.slice(offset);
     return { content, nextOffset: full.length };
   } catch {
@@ -54939,6 +55490,454 @@ function readLogDelta(filePath, offset) {
   }
 }
 
+// src/cli/config-command.ts
+import { createInterface as createInterface4 } from "readline/promises";
+import { mkdirSync as mkdirSync4, readFileSync as readFileSync7, writeFileSync as writeFileSync5 } from "fs";
+import { dirname as dirname2, join as join10 } from "path";
+import { parseArgs as parseArgs2 } from "util";
+function readConfig(configArg) {
+  const path = resolveConfigPath(configArg);
+  return { path, config: loadConfig(path) };
+}
+function saveConfig(path, config2) {
+  validateConfigOrThrow(config2);
+  const backupDir = join10(dirname2(path), ".backups");
+  mkdirSync4(backupDir, { recursive: true });
+  const backupPath = join10(backupDir, `config-${Date.now()}.json5`);
+  writeFileSync5(backupPath, readFileSync7(path, "utf-8"), "utf-8");
+  const content = dist_default.stringify(config2, { space: 2, quote: '"' });
+  writeFileSync5(path, content, "utf-8");
+}
+function maskApiKey(k) {
+  if (k.length <= 8)
+    return "***";
+  return `${k.slice(0, 4)}***${k.slice(-4)}`;
+}
+function providerTypes() {
+  return ["openai-completions", "openai-responses", "anthropic-messages"];
+}
+async function selectFromList(title, items) {
+  if (items.length === 0)
+    throw new Error(`${title}: \u65E0\u53EF\u9009\u9879`);
+  console.log(`${title}:`);
+  items.forEach((item, i) => console.log(`  ${i + 1}) ${item}`));
+  const rl = createInterface4({ input: process.stdin, output: process.stdout });
+  try {
+    const answer = await rl.question("\u8BF7\u8F93\u5165\u5E8F\u53F7: ");
+    const idx = Number.parseInt(answer, 10) - 1;
+    if (!Number.isFinite(idx) || idx < 0 || idx >= items.length) {
+      throw new Error("\u65E0\u6548\u9009\u62E9");
+    }
+    return items[idx];
+  } finally {
+    rl.close();
+  }
+}
+function printConfigHelp() {
+  console.log(`
+local-router config
+
+Commands:
+  config provider list [--json] [--config <path>]
+  config provider show <name> [--show-secrets] [--json] [--config <path>]
+  config provider add <name> --type <type> --base <url> --api-key <key> --model <name> [--image-input] [--reasoning] [--config <path>]
+  config provider set <name> [--base <url>] [--api-key <key>] [--proxy <url>] [--config <path>]
+  config provider remove <name> [--force] [--config <path>]
+  config provider model list <provider> [--json] [--config <path>]
+  config provider model add <provider> <model> [--image-input] [--reasoning] [--config <path>]
+  config provider model set <provider> <model> [--image-input <true|false>] [--reasoning <true|false>] [--config <path>]
+  config provider model remove <provider> <model> [--config <path>]
+
+  config route list [--entry <entry>] [--json] [--config <path>]
+  config route show <entry> [--json] [--config <path>]
+  config route set <entry> <match-model> [--provider <name>] [--model <model>] [--interactive] [--config <path>]
+  config route remove <entry> <match-model> [--allow-remove-fallback] [--config <path>]
+
+  config resolve --entry <entry> --model <request-model> [--json] [--config <path>]
+  config validate [--config <path>]
+  config apply
+`);
+}
+function parseBool(v) {
+  if (v === undefined)
+    return;
+  if (v === "true")
+    return true;
+  if (v === "false")
+    return false;
+  throw new Error(`\u65E0\u6548\u5E03\u5C14\u503C: ${v}`);
+}
+function requireProvider(config2, name21) {
+  const p = config2.providers[name21];
+  if (!p)
+    throw new Error(`provider \u4E0D\u5B58\u5728: ${name21}`);
+  return p;
+}
+async function handleProvider(args) {
+  const [sub, ...rest] = args;
+  if (sub === "list") {
+    const parsed = parseArgs2({ args: rest, options: { json: { type: "boolean", default: false }, config: { type: "string" } }, allowPositionals: true, strict: false });
+    const { config: config2 } = readConfig(parsed.values.config);
+    const rows = Object.entries(config2.providers).map(([name21, p]) => ({ name: name21, type: p.type, base: p.base, models: Object.keys(p.models).length, proxy: p.proxy ?? "" }));
+    if (parsed.values.json)
+      return void console.log(JSON.stringify(rows, null, 2));
+    console.log("NAME\tTYPE\tMODELS\tBASE");
+    rows.forEach((r) => console.log(`${r.name}	${r.type}	${r.models}	${r.base}`));
+    return;
+  }
+  if (sub === "show") {
+    const [name21, ...flagArgs] = rest;
+    if (!name21)
+      throw new Error("\u7528\u6CD5: config provider show <name>");
+    const parsed = parseArgs2({ args: flagArgs, options: { json: { type: "boolean", default: false }, "show-secrets": { type: "boolean", default: false }, config: { type: "string" } }, allowPositionals: true, strict: false });
+    const { config: config2 } = readConfig(parsed.values.config);
+    const p = requireProvider(config2, name21);
+    const out = { ...p, apiKey: parsed.values["show-secrets"] ? p.apiKey : maskApiKey(p.apiKey) };
+    if (parsed.values.json)
+      return void console.log(JSON.stringify(out, null, 2));
+    console.log(JSON.stringify(out, null, 2));
+    return;
+  }
+  if (sub === "add") {
+    const [name21, ...flagArgs] = rest;
+    if (!name21)
+      throw new Error("\u7528\u6CD5: config provider add <name> --type <type> --base <url> --api-key <key> --model <name>");
+    const parsed = parseArgs2({ args: flagArgs, options: { type: { type: "string" }, base: { type: "string" }, "api-key": { type: "string" }, model: { type: "string" }, "image-input": { type: "boolean", default: false }, reasoning: { type: "boolean", default: false }, proxy: { type: "string" }, config: { type: "string" } }, allowPositionals: true, strict: false });
+    const { path, config: config2 } = readConfig(parsed.values.config);
+    if (config2.providers[name21])
+      throw new Error(`provider \u5DF2\u5B58\u5728: ${name21}`);
+    const type = parsed.values.type;
+    if (!type || !providerTypes().includes(type))
+      throw new Error("type \u5FC5\u586B\u4E14\u5FC5\u987B\u662F openai-completions/openai-responses/anthropic-messages");
+    const base = parsed.values.base;
+    const apiKey = parsed.values["api-key"];
+    const firstModel = parsed.values.model;
+    if (!base || !apiKey || !firstModel)
+      throw new Error("base/api-key/model \u5FC5\u586B");
+    config2.providers[name21] = {
+      type,
+      base,
+      apiKey,
+      models: {
+        [firstModel]: {
+          "image-input": parsed.values["image-input"],
+          reasoning: parsed.values.reasoning
+        }
+      },
+      ...parsed.values.proxy ? { proxy: parsed.values.proxy } : {}
+    };
+    saveConfig(path, config2);
+    console.log(`\u5DF2\u6DFB\u52A0 provider: ${name21}`);
+    return;
+  }
+  if (sub === "set") {
+    const [name21, ...flagArgs] = rest;
+    if (!name21)
+      throw new Error("\u7528\u6CD5: config provider set <name> [--base] [--api-key] [--proxy]");
+    const parsed = parseArgs2({ args: flagArgs, options: { base: { type: "string" }, "api-key": { type: "string" }, proxy: { type: "string" }, config: { type: "string" } }, allowPositionals: true, strict: false });
+    const { path, config: config2 } = readConfig(parsed.values.config);
+    const p = requireProvider(config2, name21);
+    if (parsed.values.base)
+      p.base = parsed.values.base;
+    if (parsed.values["api-key"])
+      p.apiKey = parsed.values["api-key"];
+    if (parsed.values.proxy !== undefined)
+      p.proxy = parsed.values.proxy;
+    saveConfig(path, config2);
+    console.log(`\u5DF2\u66F4\u65B0 provider: ${name21}`);
+    return;
+  }
+  if (sub === "remove") {
+    const [name21, ...flagArgs] = rest;
+    if (!name21)
+      throw new Error("\u7528\u6CD5: config provider remove <name> [--force]");
+    const parsed = parseArgs2({ args: flagArgs, options: { force: { type: "boolean", default: false }, config: { type: "string" } }, allowPositionals: true, strict: false });
+    const { path, config: config2 } = readConfig(parsed.values.config);
+    requireProvider(config2, name21);
+    const referencedRoutes = [];
+    for (const [entry, modelMap] of Object.entries(config2.routes)) {
+      for (const [match2, target] of Object.entries(modelMap)) {
+        if (target.provider === name21) {
+          referencedRoutes.push({ entry, match: match2 });
+        }
+      }
+    }
+    if (referencedRoutes.length > 0 && !parsed.values.force) {
+      const first = referencedRoutes[0];
+      throw new Error(`provider ${name21} \u88AB\u8DEF\u7531\u5F15\u7528: ${first?.entry}.${first?.match}\uFF0C\u5982\u9700\u5220\u9664\u5E76\u8054\u52A8\u6E05\u7406\u8DEF\u7531\u8BF7\u52A0 --force`);
+    }
+    if (parsed.values.force) {
+      for (const ref of referencedRoutes) {
+        delete config2.routes[ref.entry]?.[ref.match];
+      }
+      for (const [entry, modelMap] of Object.entries(config2.routes)) {
+        if (Object.keys(modelMap).length === 0) {
+          delete config2.routes[entry];
+        }
+      }
+    }
+    delete config2.providers[name21];
+    saveConfig(path, config2);
+    if (parsed.values.force && referencedRoutes.length > 0) {
+      console.log(`\u5DF2\u5220\u9664 provider: ${name21}\uFF0C\u5E76\u6E05\u7406 ${referencedRoutes.length} \u6761\u5173\u8054\u8DEF\u7531`);
+    } else {
+      console.log(`\u5DF2\u5220\u9664 provider: ${name21}`);
+    }
+    return;
+  }
+  if (sub === "model") {
+    const [action, provider, model, ...flagArgs] = rest;
+    if (!action)
+      throw new Error("\u7528\u6CD5: config provider model <list|add|set|remove> ...");
+    if (!provider)
+      throw new Error("provider \u5FC5\u586B");
+    if (action === "list") {
+      const parsed = parseArgs2({
+        args: flagArgs,
+        options: { config: { type: "string" }, json: { type: "boolean", default: false } },
+        allowPositionals: true,
+        strict: false
+      });
+      const { config: config2 } = readConfig(parsed.values.config);
+      const p = requireProvider(config2, provider);
+      const rows = Object.entries(p.models).map(([name21, caps]) => ({ name: name21, ...caps }));
+      if (parsed.values.json)
+        return void console.log(JSON.stringify(rows, null, 2));
+      rows.forEach((r) => console.log(`${r.name}	image-input=${Boolean(r["image-input"])}	reasoning=${Boolean(r.reasoning)}`));
+      return;
+    }
+    if (!model)
+      throw new Error("model \u5FC5\u586B");
+    if (action === "add") {
+      const parsed = parseArgs2({
+        args: flagArgs,
+        options: {
+          "image-input": { type: "boolean", default: false },
+          reasoning: { type: "boolean", default: false },
+          config: { type: "string" }
+        },
+        allowPositionals: true,
+        strict: false
+      });
+      const { path, config: config2 } = readConfig(parsed.values.config);
+      const p = requireProvider(config2, provider);
+      p.models[model] = {
+        "image-input": parsed.values["image-input"],
+        reasoning: parsed.values.reasoning
+      };
+      saveConfig(path, config2);
+      console.log(`\u5DF2\u6DFB\u52A0 model: ${provider}/${model}`);
+      return;
+    }
+    if (action === "set") {
+      const parsed = parseArgs2({
+        args: flagArgs,
+        options: {
+          "image-input": { type: "string" },
+          reasoning: { type: "string" },
+          config: { type: "string" }
+        },
+        allowPositionals: true,
+        strict: false
+      });
+      const { path, config: config2 } = readConfig(parsed.values.config);
+      const p = requireProvider(config2, provider);
+      if (!p.models[model])
+        throw new Error(`model \u4E0D\u5B58\u5728: ${provider}/${model}`);
+      if (parsed.values["image-input"] !== undefined) {
+        p.models[model]["image-input"] = parseBool(parsed.values["image-input"]);
+      }
+      if (parsed.values.reasoning !== undefined) {
+        p.models[model].reasoning = parseBool(parsed.values.reasoning);
+      }
+      saveConfig(path, config2);
+      console.log(`\u5DF2\u66F4\u65B0 model: ${provider}/${model}`);
+      return;
+    }
+    if (action === "remove") {
+      const parsed = parseArgs2({
+        args: flagArgs,
+        options: { config: { type: "string" } },
+        allowPositionals: true,
+        strict: false
+      });
+      const { path, config: config2 } = readConfig(parsed.values.config);
+      const p = requireProvider(config2, provider);
+      delete p.models[model];
+      saveConfig(path, config2);
+      console.log(`\u5DF2\u5220\u9664 model: ${provider}/${model}`);
+      return;
+    }
+    throw new Error(`\u672A\u77E5\u5B50\u547D\u4EE4: provider model ${action}`);
+  }
+  throw new Error(`\u672A\u77E5\u5B50\u547D\u4EE4: provider ${sub ?? ""}`);
+}
+function renderRouteRows(config2, entry) {
+  const rows = [];
+  for (const [entryName, modelMap] of Object.entries(config2.routes)) {
+    if (entry && entryName !== entry)
+      continue;
+    for (const [match2, target] of Object.entries(modelMap)) {
+      rows.push({ entry: entryName, match: match2, provider: target.provider, model: target.model });
+    }
+  }
+  return rows;
+}
+async function handleRoute(args) {
+  const [sub, ...rest] = args;
+  if (sub === "list") {
+    const parsed = parseArgs2({ args: rest, options: { entry: { type: "string" }, json: { type: "boolean", default: false }, config: { type: "string" } }, allowPositionals: true, strict: false });
+    const { config: config2 } = readConfig(parsed.values.config);
+    const rows = renderRouteRows(config2, parsed.values.entry);
+    if (parsed.values.json)
+      return void console.log(JSON.stringify(rows, null, 2));
+    console.log("ENTRY\tMATCH\tTARGET");
+    rows.forEach((r) => console.log(`${r.entry}	${r.match}	${r.provider}/${r.model}`));
+    return;
+  }
+  if (sub === "show") {
+    const [entry, ...flagArgs] = rest;
+    if (!entry)
+      throw new Error("\u7528\u6CD5: config route show <entry>");
+    const parsed = parseArgs2({ args: flagArgs, options: { json: { type: "boolean", default: false }, config: { type: "string" } }, allowPositionals: true, strict: false });
+    const { config: config2 } = readConfig(parsed.values.config);
+    const modelMap = config2.routes[entry];
+    if (!modelMap)
+      throw new Error(`route entry \u4E0D\u5B58\u5728: ${entry}`);
+    if (parsed.values.json)
+      return void console.log(JSON.stringify(modelMap, null, 2));
+    Object.entries(modelMap).forEach(([match2, target]) => console.log(`${entry}.${match2} -> ${target.provider}/${target.model}`));
+    return;
+  }
+  if (sub === "set") {
+    const [entry, matchModel, ...flagArgs] = rest;
+    if (!entry || !matchModel)
+      throw new Error("\u7528\u6CD5: config route set <entry> <match-model> [--provider] [--model]");
+    const parsed = parseArgs2({ args: flagArgs, options: { provider: { type: "string" }, model: { type: "string" }, interactive: { type: "boolean", default: false }, config: { type: "string" } }, allowPositionals: true, strict: false });
+    const { path, config: config2 } = readConfig(parsed.values.config);
+    let provider = parsed.values.provider;
+    let model = parsed.values.model;
+    const shouldInteractive = parsed.values.interactive || !provider && !model;
+    if (shouldInteractive) {
+      if (!process.stdin.isTTY) {
+        throw new Error("\u8BF7\u5728\u975E\u4EA4\u4E92\u73AF\u5883\u4E0B\u4F7F\u7528 --provider \u4E0E --model\uFF0C\u6216\u5728 TTY \u4E2D\u8FD0\u884C\u4EE5\u542F\u7528\u9009\u62E9\u5668");
+      }
+      const providerNames = Object.keys(config2.providers);
+      if (providerNames.length === 0) {
+        throw new Error("\u5F53\u524D\u6CA1\u6709 provider\uFF0C\u8BF7\u5148\u6267\u884C: local-router config provider add <name> ...");
+      }
+      provider = await selectFromList("\u8BF7\u9009\u62E9 provider", providerNames);
+      const p2 = requireProvider(config2, provider);
+      const models = Object.keys(p2.models);
+      if (models.length === 0) {
+        throw new Error(`provider ${provider} \u6CA1\u6709\u53EF\u9009 model\uFF0C\u8BF7\u5148\u6267\u884C: local-router config provider model add ${provider} <model>`);
+      }
+      model = await selectFromList(`\u8BF7\u9009\u62E9 ${provider} \u7684 model`, models);
+    }
+    if (!provider || !model)
+      throw new Error("provider/model \u5FC5\u586B\uFF1B\u53EF\u901A\u8FC7 --provider/--model \u6307\u5B9A\uFF0C\u6216\u4F7F\u7528\u4EA4\u4E92\u6A21\u5F0F");
+    const p = requireProvider(config2, provider);
+    if (!p.models[model])
+      throw new Error(`model \u4E0D\u5B58\u5728\u4E8E provider: ${provider}/${model}`);
+    if (!config2.routes[entry])
+      config2.routes[entry] = {};
+    config2.routes[entry][matchModel] = { provider, model };
+    saveConfig(path, config2);
+    console.log(`\u5DF2\u8BBE\u7F6E\u8DEF\u7531: ${entry}.${matchModel} -> ${provider}/${model}`);
+    return;
+  }
+  if (sub === "remove") {
+    const [entry, matchModel, ...flagArgs] = rest;
+    if (!entry || !matchModel)
+      throw new Error("\u7528\u6CD5: config route remove <entry> <match-model> [--allow-remove-fallback]");
+    const parsed = parseArgs2({ args: flagArgs, options: { "allow-remove-fallback": { type: "boolean", default: false }, config: { type: "string" } }, allowPositionals: true, strict: false });
+    const { path, config: config2 } = readConfig(parsed.values.config);
+    const modelMap = config2.routes[entry];
+    if (!modelMap || !modelMap[matchModel])
+      throw new Error(`\u8DEF\u7531\u4E0D\u5B58\u5728: ${entry}.${matchModel}`);
+    if (matchModel === "*" && !parsed.values["allow-remove-fallback"]) {
+      throw new Error("\u7981\u6B62\u5220\u9664 * \u515C\u5E95\u89C4\u5219\uFF0C\u5982\u9700\u5220\u9664\u8BF7\u52A0 --allow-remove-fallback");
+    }
+    delete modelMap[matchModel];
+    saveConfig(path, config2);
+    console.log(`\u5DF2\u5220\u9664\u8DEF\u7531: ${entry}.${matchModel}`);
+    return;
+  }
+  throw new Error(`\u672A\u77E5\u5B50\u547D\u4EE4: route ${sub ?? ""}`);
+}
+async function handleResolve(args) {
+  const parsed = parseArgs2({ args, options: { entry: { type: "string" }, model: { type: "string" }, json: { type: "boolean", default: false }, config: { type: "string" } }, allowPositionals: true, strict: false });
+  const entry = parsed.values.entry;
+  const reqModel = parsed.values.model;
+  if (!entry || !reqModel)
+    throw new Error("\u7528\u6CD5: config resolve --entry <entry> --model <request-model>");
+  const { config: config2 } = readConfig(parsed.values.config);
+  const modelMap = config2.routes[entry];
+  if (!modelMap)
+    throw new Error(`route entry \u4E0D\u5B58\u5728: ${entry}`);
+  const hit = modelMap[reqModel] ? reqModel : "*";
+  const target = modelMap[hit];
+  if (!target)
+    throw new Error(`\u672A\u547D\u4E2D\u8DEF\u7531\u4E14\u7F3A\u5C11\u515C\u5E95: ${entry}`);
+  const provider = requireProvider(config2, target.provider);
+  const payload = { matchedRule: `${entry}.${hit}`, provider: target.provider, targetModel: target.model, providerType: provider.type, providerBase: provider.base };
+  if (parsed.values.json)
+    return void console.log(JSON.stringify(payload, null, 2));
+  console.log(`\u5339\u914D\u89C4\u5219: ${payload.matchedRule}`);
+  console.log(`\u547D\u4E2D provider: ${payload.provider}`);
+  console.log(`\u8F6C\u53D1 model: ${payload.targetModel}`);
+  console.log(`provider: ${payload.providerType} ${payload.providerBase}`);
+}
+async function handleValidate(args) {
+  const parsed = parseArgs2({ args, options: { config: { type: "string" } }, allowPositionals: true, strict: false });
+  const { config: config2, path } = readConfig(parsed.values.config);
+  validateConfigOrThrow(config2);
+  console.log(`\u914D\u7F6E\u6821\u9A8C\u901A\u8FC7: ${path}`);
+}
+async function handleApply() {
+  await cleanupIfStale();
+  const state = readRuntimeState();
+  if (!state)
+    throw new Error("\u670D\u52A1\u672A\u8FD0\u884C\uFF0C\u65E0\u6CD5 apply");
+  const res = await fetch(`${state.baseUrl}/api/config/apply`, { method: "POST" });
+  if (!res.ok) {
+    const text2 = await res.text();
+    throw new Error(`apply \u5931\u8D25: ${res.status} ${text2}`);
+  }
+  const healthy = await checkHealth(state.baseUrl);
+  if (!healthy)
+    throw new Error(`apply \u540E\u5065\u5EB7\u68C0\u67E5\u5931\u8D25: ${state.baseUrl}`);
+  console.log(`\u914D\u7F6E\u5DF2\u5E94\u7528: ${state.baseUrl}`);
+}
+async function cmdConfig(args) {
+  const [group, ...rest] = args;
+  switch (group) {
+    case "provider":
+      await handleProvider(rest);
+      return;
+    case "route":
+      await handleRoute(rest);
+      return;
+    case "resolve":
+      await handleResolve(rest);
+      return;
+    case "validate":
+      await handleValidate(rest);
+      return;
+    case "apply":
+      await handleApply();
+      return;
+    case "help":
+    case "--help":
+    case "-h":
+    case undefined:
+      printConfigHelp();
+      return;
+    default:
+      throw new Error(`\u672A\u77E5 config \u547D\u4EE4: ${group}`);
+  }
+}
+
 // src/cli.ts
 function printHelp() {
   console.log(`
@@ -54954,6 +55953,7 @@ Commands:
   status [--json]
   logs [--follow] [--lines <n>]
   init [--config <path>] [--force]
+  config <subcommand> [...args]
   health
   version
 
@@ -54971,7 +55971,7 @@ async function printVersion() {
   }
 }
 async function cmdStart(args) {
-  const parsed = parseArgs2({
+  const parsed = parseArgs3({
     args,
     options: {
       daemon: { type: "boolean", default: false }
@@ -55005,7 +56005,7 @@ async function cmdRestart(args) {
 }
 async function cmdStatus(args) {
   await cleanupIfStale();
-  const parsed = parseArgs2({
+  const parsed = parseArgs3({
     args,
     options: {
       json: { type: "boolean", default: false }
@@ -55063,7 +56063,7 @@ function printLastLines(filePath, lines) {
     console.log(`\u65E5\u5FD7\u6587\u4EF6\u4E0D\u5B58\u5728: ${filePath}`);
     return 0;
   }
-  const full = readFileSync6(filePath, "utf-8");
+  const full = readFileSync8(filePath, "utf-8");
   const rendered = full.split(`
 `).slice(-lines).join(`
 `);
@@ -55073,7 +56073,7 @@ function printLastLines(filePath, lines) {
   return full.length;
 }
 async function cmdLogs(args) {
-  const parsed = parseArgs2({
+  const parsed = parseArgs3({
     args,
     options: {
       follow: { type: "boolean", default: false },
@@ -55100,7 +56100,7 @@ async function cmdLogs(args) {
   }
 }
 async function cmdInit(args) {
-  const parsed = parseArgs2({
+  const parsed = parseArgs3({
     args,
     options: {
       config: { type: "string" },
@@ -55134,7 +56134,7 @@ async function cmdHealth() {
   console.log(`\u5065\u5EB7\u68C0\u67E5\u901A\u8FC7: ${state.baseUrl}`);
 }
 async function cmdRunServer(args) {
-  const parsed = parseArgs2({
+  const parsed = parseArgs3({
     args,
     options: {
       mode: { type: "string" },
@@ -55181,6 +56181,9 @@ async function main() {
     case "health":
       await cmdHealth();
       return;
+    case "config":
+      await cmdConfig(rest);
+      return;
     case "version":
       await printVersion();
       return;