@arronqzy/blueprint-dsl 1.0.15 → 1.0.16

package/dist/index.cjs

@@ -160,18 +160,668 @@ function registerDefaultBehaviors(registry) {
   });
 }
 
+// vendor/dayjs/esm/constant.js
+var SECONDS_A_MINUTE = 60;
+var SECONDS_A_HOUR = SECONDS_A_MINUTE * 60;
+var SECONDS_A_DAY = SECONDS_A_HOUR * 24;
+var SECONDS_A_WEEK = SECONDS_A_DAY * 7;
+var MILLISECONDS_A_SECOND = 1e3;
+var MILLISECONDS_A_MINUTE = SECONDS_A_MINUTE * MILLISECONDS_A_SECOND;
+var MILLISECONDS_A_HOUR = SECONDS_A_HOUR * MILLISECONDS_A_SECOND;
+var MILLISECONDS_A_DAY = SECONDS_A_DAY * MILLISECONDS_A_SECOND;
+var MILLISECONDS_A_WEEK = SECONDS_A_WEEK * MILLISECONDS_A_SECOND;
+var MS = "millisecond";
+var S = "second";
+var MIN = "minute";
+var H = "hour";
+var D = "day";
+var W = "week";
+var M = "month";
+var Q = "quarter";
+var Y = "year";
+var DATE = "date";
+var FORMAT_DEFAULT = "YYYY-MM-DDTHH:mm:ssZ";
+var INVALID_DATE_STRING = "Invalid Date";
+var REGEX_PARSE = /^(\d{4})[-/]?(\d{1,2})?[-/]?(\d{0,2})[Tt\s]*(\d{1,2})?:?(\d{1,2})?:?(\d{1,2})?[.:]?(\d+)?$/;
+var REGEX_FORMAT = /\[([^\]]+)]|YYYY|YY|M{1,4}|D{1,2}|d{1,4}|H{1,2}|h{1,2}|a|A|m{1,2}|s{1,2}|Z{1,2}|SSS/g;
+
+// vendor/dayjs/esm/locale/en.js
+var en_default = {
+  name: "en",
+  weekdays: "Sunday_Monday_Tuesday_Wednesday_Thursday_Friday_Saturday".split("_"),
+  months: "January_February_March_April_May_June_July_August_September_October_November_December".split("_"),
+  ordinal: function ordinal(n) {
+    var s = ["th", "st", "nd", "rd"];
+    var v = n % 100;
+    return "[" + n + (s[(v - 20) % 10] || s[v] || s[0]) + "]";
+  }
+};
+
+// vendor/dayjs/esm/utils.js
+var padStart = function padStart2(string, length, pad) {
+  var s = String(string);
+  if (!s || s.length >= length) return string;
+  return "" + Array(length + 1 - s.length).join(pad) + string;
+};
+var padZoneStr = function padZoneStr2(instance) {
+  var negMinutes = -instance.utcOffset();
+  var minutes = Math.abs(negMinutes);
+  var hourOffset = Math.floor(minutes / 60);
+  var minuteOffset = minutes % 60;
+  return (negMinutes <= 0 ? "+" : "-") + padStart(hourOffset, 2, "0") + ":" + padStart(minuteOffset, 2, "0");
+};
+var monthDiff = function monthDiff2(a, b) {
+  if (a.date() < b.date()) return -monthDiff2(b, a);
+  var wholeMonthDiff = (b.year() - a.year()) * 12 + (b.month() - a.month());
+  var anchor = a.clone().add(wholeMonthDiff, M);
+  var c = b - anchor < 0;
+  var anchor2 = a.clone().add(wholeMonthDiff + (c ? -1 : 1), M);
+  return +(-(wholeMonthDiff + (b - anchor) / (c ? anchor - anchor2 : anchor2 - anchor)) || 0);
+};
+var absFloor = function absFloor2(n) {
+  return n < 0 ? Math.ceil(n) || 0 : Math.floor(n);
+};
+var prettyUnit = function prettyUnit2(u) {
+  var special = {
+    M,
+    y: Y,
+    w: W,
+    d: D,
+    D: DATE,
+    h: H,
+    m: MIN,
+    s: S,
+    ms: MS,
+    Q
+  };
+  return special[u] || String(u || "").toLowerCase().replace(/s$/, "");
+};
+var isUndefined = function isUndefined2(s) {
+  return s === void 0;
+};
+var utils_default = {
+  s: padStart,
+  z: padZoneStr,
+  m: monthDiff,
+  a: absFloor,
+  p: prettyUnit,
+  u: isUndefined
+};
+
+// vendor/dayjs/esm/index.js
+var L = "en";
+var Ls = {};
+Ls[L] = en_default;
+var IS_DAYJS = "$isDayjsObject";
+var isDayjs = function isDayjs2(d) {
+  return d instanceof Dayjs || !!(d && d[IS_DAYJS]);
+};
+var parseLocale = function parseLocale2(preset, object, isLocal) {
+  var l;
+  if (!preset) return L;
+  if (typeof preset === "string") {
+    var presetLower = preset.toLowerCase();
+    if (Ls[presetLower]) {
+      l = presetLower;
+    }
+    if (object) {
+      Ls[presetLower] = object;
+      l = presetLower;
+    }
+    var presetSplit = preset.split("-");
+    if (!l && presetSplit.length > 1) {
+      return parseLocale2(presetSplit[0]);
+    }
+  } else {
+    var name = preset.name;
+    Ls[name] = preset;
+    l = name;
+  }
+  if (!isLocal && l) L = l;
+  return l || !isLocal && L;
+};
+var dayjs = function dayjs2(date, c) {
+  if (isDayjs(date)) {
+    return date.clone();
+  }
+  var cfg = typeof c === "object" ? c : {};
+  cfg.date = date;
+  cfg.args = arguments;
+  return new Dayjs(cfg);
+};
+var wrapper = function wrapper2(date, instance) {
+  return dayjs(date, {
+    locale: instance.$L,
+    utc: instance.$u,
+    x: instance.$x,
+    $offset: instance.$offset
+    // todo: refactor; do not use this.$offset in you code
+  });
+};
+var Utils = utils_default;
+Utils.l = parseLocale;
+Utils.i = isDayjs;
+Utils.w = wrapper;
+var parseDate = function parseDate2(cfg) {
+  var date = cfg.date, utc = cfg.utc;
+  if (date === null) return /* @__PURE__ */ new Date(NaN);
+  if (Utils.u(date)) return /* @__PURE__ */ new Date();
+  if (date instanceof Date) return new Date(date);
+  if (typeof date === "string" && !/Z$/i.test(date)) {
+    var d = date.match(REGEX_PARSE);
+    if (d) {
+      var m = d[2] - 1 || 0;
+      var ms = (d[7] || "0").substring(0, 3);
+      if (utc) {
+        return new Date(Date.UTC(d[1], m, d[3] || 1, d[4] || 0, d[5] || 0, d[6] || 0, ms));
+      }
+      return new Date(d[1], m, d[3] || 1, d[4] || 0, d[5] || 0, d[6] || 0, ms);
+    }
+  }
+  return new Date(date);
+};
+var Dayjs = /* @__PURE__ */ (function() {
+  function Dayjs2(cfg) {
+    this.$L = parseLocale(cfg.locale, null, true);
+    this.parse(cfg);
+    this.$x = this.$x || cfg.x || {};
+    this[IS_DAYJS] = true;
+  }
+  var _proto = Dayjs2.prototype;
+  _proto.parse = function parse(cfg) {
+    this.$d = parseDate(cfg);
+    this.init();
+  };
+  _proto.init = function init() {
+    var $d = this.$d;
+    this.$y = $d.getFullYear();
+    this.$M = $d.getMonth();
+    this.$D = $d.getDate();
+    this.$W = $d.getDay();
+    this.$H = $d.getHours();
+    this.$m = $d.getMinutes();
+    this.$s = $d.getSeconds();
+    this.$ms = $d.getMilliseconds();
+  };
+  _proto.$utils = function $utils() {
+    return Utils;
+  };
+  _proto.isValid = function isValid() {
+    return !(this.$d.toString() === INVALID_DATE_STRING);
+  };
+  _proto.isSame = function isSame(that, units) {
+    var other = dayjs(that);
+    return this.startOf(units) <= other && other <= this.endOf(units);
+  };
+  _proto.isAfter = function isAfter(that, units) {
+    return dayjs(that) < this.startOf(units);
+  };
+  _proto.isBefore = function isBefore(that, units) {
+    return this.endOf(units) < dayjs(that);
+  };
+  _proto.$g = function $g(input, get, set) {
+    if (Utils.u(input)) return this[get];
+    return this.set(set, input);
+  };
+  _proto.unix = function unix() {
+    return Math.floor(this.valueOf() / 1e3);
+  };
+  _proto.valueOf = function valueOf() {
+    return this.$d.getTime();
+  };
+  _proto.startOf = function startOf(units, _startOf) {
+    var _this = this;
+    var isStartOf = !Utils.u(_startOf) ? _startOf : true;
+    var unit = Utils.p(units);
+    var instanceFactory = function instanceFactory2(d, m) {
+      var ins = Utils.w(_this.$u ? Date.UTC(_this.$y, m, d) : new Date(_this.$y, m, d), _this);
+      return isStartOf ? ins : ins.endOf(D);
+    };
+    var instanceFactorySet = function instanceFactorySet2(method, slice) {
+      var argumentStart = [0, 0, 0, 0];
+      var argumentEnd = [23, 59, 59, 999];
+      return Utils.w(_this.toDate()[method].apply(
+        // eslint-disable-line prefer-spread
+        _this.toDate("s"),
+        (isStartOf ? argumentStart : argumentEnd).slice(slice)
+      ), _this);
+    };
+    var $W = this.$W, $M = this.$M, $D = this.$D;
+    var utcPad = "set" + (this.$u ? "UTC" : "");
+    switch (unit) {
+      case Y:
+        return isStartOf ? instanceFactory(1, 0) : instanceFactory(31, 11);
+      case M:
+        return isStartOf ? instanceFactory(1, $M) : instanceFactory(0, $M + 1);
+      case W: {
+        var weekStart = this.$locale().weekStart || 0;
+        var gap = ($W < weekStart ? $W + 7 : $W) - weekStart;
+        return instanceFactory(isStartOf ? $D - gap : $D + (6 - gap), $M);
+      }
+      case D:
+      case DATE:
+        return instanceFactorySet(utcPad + "Hours", 0);
+      case H:
+        return instanceFactorySet(utcPad + "Minutes", 1);
+      case MIN:
+        return instanceFactorySet(utcPad + "Seconds", 2);
+      case S:
+        return instanceFactorySet(utcPad + "Milliseconds", 3);
+      default:
+        return this.clone();
+    }
+  };
+  _proto.endOf = function endOf(arg) {
+    return this.startOf(arg, false);
+  };
+  _proto.$set = function $set(units, _int) {
+    var _C$D$C$DATE$C$M$C$Y$C;
+    var unit = Utils.p(units);
+    var utcPad = "set" + (this.$u ? "UTC" : "");
+    var name = (_C$D$C$DATE$C$M$C$Y$C = {}, _C$D$C$DATE$C$M$C$Y$C[D] = utcPad + "Date", _C$D$C$DATE$C$M$C$Y$C[DATE] = utcPad + "Date", _C$D$C$DATE$C$M$C$Y$C[M] = utcPad + "Month", _C$D$C$DATE$C$M$C$Y$C[Y] = utcPad + "FullYear", _C$D$C$DATE$C$M$C$Y$C[H] = utcPad + "Hours", _C$D$C$DATE$C$M$C$Y$C[MIN] = utcPad + "Minutes", _C$D$C$DATE$C$M$C$Y$C[S] = utcPad + "Seconds", _C$D$C$DATE$C$M$C$Y$C[MS] = utcPad + "Milliseconds", _C$D$C$DATE$C$M$C$Y$C)[unit];
+    var arg = unit === D ? this.$D + (_int - this.$W) : _int;
+    if (unit === M || unit === Y) {
+      var date = this.clone().set(DATE, 1);
+      date.$d[name](arg);
+      date.init();
+      this.$d = date.set(DATE, Math.min(this.$D, date.daysInMonth())).$d;
+    } else if (name) this.$d[name](arg);
+    this.init();
+    return this;
+  };
+  _proto.set = function set(string, _int2) {
+    return this.clone().$set(string, _int2);
+  };
+  _proto.get = function get(unit) {
+    return this[Utils.p(unit)]();
+  };
+  _proto.add = function add(number, units) {
+    var _this2 = this, _C$MIN$C$H$C$S$unit;
+    number = Number(number);
+    var unit = Utils.p(units);
+    var instanceFactorySet = function instanceFactorySet2(n) {
+      var d = dayjs(_this2);
+      return Utils.w(d.date(d.date() + Math.round(n * number)), _this2);
+    };
+    if (unit === M) {
+      return this.set(M, this.$M + number);
+    }
+    if (unit === Y) {
+      return this.set(Y, this.$y + number);
+    }
+    if (unit === D) {
+      return instanceFactorySet(1);
+    }
+    if (unit === W) {
+      return instanceFactorySet(7);
+    }
+    var step = (_C$MIN$C$H$C$S$unit = {}, _C$MIN$C$H$C$S$unit[MIN] = MILLISECONDS_A_MINUTE, _C$MIN$C$H$C$S$unit[H] = MILLISECONDS_A_HOUR, _C$MIN$C$H$C$S$unit[S] = MILLISECONDS_A_SECOND, _C$MIN$C$H$C$S$unit)[unit] || 1;
+    var nextTimeStamp = this.$d.getTime() + number * step;
+    return Utils.w(nextTimeStamp, this);
+  };
+  _proto.subtract = function subtract(number, string) {
+    return this.add(number * -1, string);
+  };
+  _proto.format = function format(formatStr) {
+    var _this3 = this;
+    var locale = this.$locale();
+    if (!this.isValid()) return locale.invalidDate || INVALID_DATE_STRING;
+    var str = formatStr || FORMAT_DEFAULT;
+    var zoneStr = Utils.z(this);
+    var $H = this.$H, $m = this.$m, $M = this.$M;
+    var weekdays = locale.weekdays, months = locale.months, meridiem = locale.meridiem;
+    var getShort = function getShort2(arr, index, full, length) {
+      return arr && (arr[index] || arr(_this3, str)) || full[index].slice(0, length);
+    };
+    var get$H = function get$H2(num) {
+      return Utils.s($H % 12 || 12, num, "0");
+    };
+    var meridiemFunc = meridiem || function(hour, minute, isLowercase) {
+      var m = hour < 12 ? "AM" : "PM";
+      return isLowercase ? m.toLowerCase() : m;
+    };
+    var matches = function matches2(match) {
+      switch (match) {
+        case "YY":
+          return String(_this3.$y).slice(-2);
+        case "YYYY":
+          return Utils.s(_this3.$y, 4, "0");
+        case "M":
+          return $M + 1;
+        case "MM":
+          return Utils.s($M + 1, 2, "0");
+        case "MMM":
+          return getShort(locale.monthsShort, $M, months, 3);
+        case "MMMM":
+          return getShort(months, $M);
+        case "D":
+          return _this3.$D;
+        case "DD":
+          return Utils.s(_this3.$D, 2, "0");
+        case "d":
+          return String(_this3.$W);
+        case "dd":
+          return getShort(locale.weekdaysMin, _this3.$W, weekdays, 2);
+        case "ddd":
+          return getShort(locale.weekdaysShort, _this3.$W, weekdays, 3);
+        case "dddd":
+          return weekdays[_this3.$W];
+        case "H":
+          return String($H);
+        case "HH":
+          return Utils.s($H, 2, "0");
+        case "h":
+          return get$H(1);
+        case "hh":
+          return get$H(2);
+        case "a":
+          return meridiemFunc($H, $m, true);
+        case "A":
+          return meridiemFunc($H, $m, false);
+        case "m":
+          return String($m);
+        case "mm":
+          return Utils.s($m, 2, "0");
+        case "s":
+          return String(_this3.$s);
+        case "ss":
+          return Utils.s(_this3.$s, 2, "0");
+        case "SSS":
+          return Utils.s(_this3.$ms, 3, "0");
+        case "Z":
+          return zoneStr;
+      }
+      return null;
+    };
+    return str.replace(REGEX_FORMAT, function(match, $1) {
+      return $1 || matches(match) || zoneStr.replace(":", "");
+    });
+  };
+  _proto.utcOffset = function utcOffset() {
+    return -Math.round(this.$d.getTimezoneOffset() / 15) * 15;
+  };
+  _proto.diff = function diff(input, units, _float) {
+    var _this4 = this;
+    var unit = Utils.p(units);
+    var that = dayjs(input);
+    var zoneDelta = (that.utcOffset() - this.utcOffset()) * MILLISECONDS_A_MINUTE;
+    var diff2 = this - that;
+    var getMonth = function getMonth2() {
+      return Utils.m(_this4, that);
+    };
+    var result;
+    switch (unit) {
+      case Y:
+        result = getMonth() / 12;
+        break;
+      case M:
+        result = getMonth();
+        break;
+      case Q:
+        result = getMonth() / 3;
+        break;
+      case W:
+        result = (diff2 - zoneDelta) / MILLISECONDS_A_WEEK;
+        break;
+      case D:
+        result = (diff2 - zoneDelta) / MILLISECONDS_A_DAY;
+        break;
+      case H:
+        result = diff2 / MILLISECONDS_A_HOUR;
+        break;
+      case MIN:
+        result = diff2 / MILLISECONDS_A_MINUTE;
+        break;
+      case S:
+        result = diff2 / MILLISECONDS_A_SECOND;
+        break;
+      default:
+        result = diff2;
+        break;
+    }
+    return _float ? result : Utils.a(result);
+  };
+  _proto.daysInMonth = function daysInMonth() {
+    return this.endOf(M).$D;
+  };
+  _proto.$locale = function $locale() {
+    return Ls[this.$L];
+  };
+  _proto.locale = function locale(preset, object) {
+    if (!preset) return this.$L;
+    var that = this.clone();
+    var nextLocaleName = parseLocale(preset, object, true);
+    if (nextLocaleName) that.$L = nextLocaleName;
+    return that;
+  };
+  _proto.clone = function clone() {
+    return Utils.w(this.$d, this);
+  };
+  _proto.toDate = function toDate() {
+    return new Date(this.valueOf());
+  };
+  _proto.toJSON = function toJSON() {
+    return this.isValid() ? this.toISOString() : null;
+  };
+  _proto.toISOString = function toISOString() {
+    return this.$d.toISOString();
+  };
+  _proto.toString = function toString() {
+    return this.$d.toUTCString();
+  };
+  return Dayjs2;
+})();
+var proto = Dayjs.prototype;
+dayjs.prototype = proto;
+[["$ms", MS], ["$s", S], ["$m", MIN], ["$H", H], ["$W", D], ["$M", M], ["$y", Y], ["$D", DATE]].forEach(function(g) {
+  proto[g[1]] = function(input) {
+    return this.$g(input, g[0], g[1]);
+  };
+});
+dayjs.extend = function(plugin, option) {
+  if (!plugin.$i) {
+    plugin(option, Dayjs, dayjs);
+    plugin.$i = true;
+  }
+  return dayjs;
+};
+dayjs.locale = parseLocale;
+dayjs.isDayjs = isDayjs;
+dayjs.unix = function(timestamp) {
+  return dayjs(timestamp * 1e3);
+};
+dayjs.en = Ls[L];
+dayjs.Ls = Ls;
+dayjs.p = {};
+var esm_default = dayjs;
+
+// src/system-root.ts
+var TEMPLATE_ROOT_NAMES = ["scope", "system"];
+var SYSTEM_TIME_METHOD_NAMES = [
+  "add",
+  "subtract",
+  "set",
+  "get",
+  "millisecond",
+  "second",
+  "minute",
+  "hour",
+  "date",
+  "day",
+  "weekday",
+  "isoWeekday",
+  "dayOfYear",
+  "week",
+  "isoWeek",
+  "month",
+  "quarter",
+  "year",
+  "weekYear",
+  "isoWeekYear",
+  "startOf",
+  "endOf",
+  "format",
+  "fromNow",
+  "toNow",
+  "from",
+  "to",
+  "calendar",
+  "diff",
+  "valueOf",
+  "unix",
+  "daysInMonth",
+  "toDate",
+  "toArray",
+  "toJSON",
+  "toISOString",
+  "toObject",
+  "toString",
+  "isBefore",
+  "isSame",
+  "isAfter",
+  "isSameOrBefore",
+  "isSameOrAfter",
+  "isBetween",
+  "isLeapYear",
+  "isValid",
+  "clone",
+  "locale",
+  "utcOffset",
+  "local",
+  "utc",
+  "isUTC"
+];
+var SYSTEM_MATH_KEYS = [
+  "E",
+  "LN10",
+  "LN2",
+  "LOG10E",
+  "LOG2E",
+  "PI",
+  "SQRT1_2",
+  "SQRT2",
+  "abs",
+  "acos",
+  "acosh",
+  "asin",
+  "asinh",
+  "atan",
+  "atan2",
+  "atanh",
+  "cbrt",
+  "ceil",
+  "clz32",
+  "cos",
+  "cosh",
+  "exp",
+  "expm1",
+  "floor",
+  "fround",
+  "hypot",
+  "imul",
+  "log",
+  "log10",
+  "log1p",
+  "log2",
+  "max",
+  "min",
+  "pow",
+  "random",
+  "round",
+  "sign",
+  "sin",
+  "sinh",
+  "sqrt",
+  "tan",
+  "tanh",
+  "trunc"
+];
+var SYSTEM_LOCATION_KEYS = [
+  "href",
+  "protocol",
+  "host",
+  "hostname",
+  "port",
+  "pathname",
+  "search",
+  "hash",
+  "origin",
+  "ancestorOrigins",
+  "assign",
+  "reload",
+  "replace",
+  "toString"
+];
+function createLocationStub() {
+  return {
+    href: "",
+    protocol: "",
+    host: "",
+    hostname: "",
+    port: "",
+    pathname: "",
+    search: "",
+    hash: "",
+    origin: "",
+    assign() {
+    },
+    reload() {
+    },
+    replace() {
+    },
+    toString() {
+      return "";
+    }
+  };
+}
+function createSystemRoot() {
+  const locationValue = typeof globalThis !== "undefined" && "location" in globalThis && globalThis.location ? globalThis.location : createLocationStub();
+  return {
+    time: esm_default(),
+    math: Math,
+    location: locationValue
+  };
+}
+function getSystemAutocompleteTree() {
+  const timeMethods = {};
+  for (const name of SYSTEM_TIME_METHOD_NAMES) {
+    timeMethods[name] = /* @__PURE__ */ Object.create(null);
+  }
+  const mathKeys = {};
+  for (const name of SYSTEM_MATH_KEYS) {
+    mathKeys[name] = /* @__PURE__ */ Object.create(null);
+  }
+  const locationKeys = {};
+  for (const name of SYSTEM_LOCATION_KEYS) {
+    locationKeys[name] = /* @__PURE__ */ Object.create(null);
+  }
+  return {
+    time: timeMethods,
+    math: mathKeys,
+    location: locationKeys
+  };
+}
+function isDayjsValue(value) {
+  return esm_default.isDayjs(value);
+}
+
 // src/scope-template.ts
-var SCOPE_TOKEN_RE = /\{(scope[^}]*)\}/g;
+var TEMPLATE_TOKEN_RE = /\{((?:scope|system)[^}]*)\}/g;
 function hasScopeTemplate(value) {
-  SCOPE_TOKEN_RE.lastIndex = 0;
-  return SCOPE_TOKEN_RE.test(value);
+  TEMPLATE_TOKEN_RE.lastIndex = 0;
+  return TEMPLATE_TOKEN_RE.test(value);
 }
-function evaluateScopeExpression(expression, scope) {
+var hasTemplateExpression = hasScopeTemplate;
+function evaluateScopeExpression(expression, scope, system = createSystemRoot()) {
   const trimmed = expression.trim();
   if (!trimmed) return void 0;
   try {
-    const fn = new Function("scope", `"use strict"; return (${trimmed});`);
-    return fn(scope);
+    const fn = new Function(
+      "scope",
+      "system",
+      `"use strict"; return (${trimmed});`
+    );
+    return fn(scope, system);
   } catch {
     return void 0;
   }
@@ -182,6 +832,9 @@ function stringifyScopeValue(value) {
   if (typeof value === "number" || typeof value === "boolean") {
     return String(value);
   }
+  if (isDayjsValue(value)) {
+    return value.toISOString();
+  }
   try {
     return JSON.stringify(value);
   } catch {
@@ -208,24 +861,30 @@ function isInsideJsonString(before) {
   }
   return inString;
 }
-function replaceScopeTokens(template, scope, replacer) {
-  SCOPE_TOKEN_RE.lastIndex = 0;
+function replaceTemplateTokens(template, scope, system, replacer) {
+  TEMPLATE_TOKEN_RE.lastIndex = 0;
   return template.replace(
-    SCOPE_TOKEN_RE,
-    (_match, rawExpr, offset) => replacer(evaluateScopeExpression(rawExpr, scope), offset)
+    TEMPLATE_TOKEN_RE,
+    (_match, rawExpr, offset) => replacer(evaluateScopeExpression(rawExpr, scope, system), offset)
   );
 }
-function evaluateScopeTemplate(template, scope) {
+function evaluateScopeTemplate(template, scope, system = createSystemRoot()) {
   if (!hasScopeTemplate(template)) return template;
-  return replaceScopeTokens(template, scope, (value) => stringifyScopeValue(value));
+  return replaceTemplateTokens(
+    template,
+    scope,
+    system,
+    (value) => stringifyScopeValue(value)
+  );
 }
-function evaluateScopeTemplateInJson(template, scope) {
+function evaluateScopeTemplateInJson(template, scope, system = createSystemRoot()) {
   if (!hasScopeTemplate(template)) return template;
-  return replaceScopeTokens(template, scope, (value, offset) => {
+  return replaceTemplateTokens(template, scope, system, (value, offset) => {
     if (isInsideJsonString(template.slice(0, offset))) {
       return JSON.stringify(stringifyScopeValue(value)).slice(1, -1);
     }
     if (value === void 0) return "null";
+    if (isDayjsValue(value)) return JSON.stringify(value.toISOString());
     return JSON.stringify(value);
   });
 }
@@ -233,6 +892,9 @@ function looksLikeJsonText(text) {
   const trimmed = text.trim();
   return trimmed.startsWith("{") || trimmed.startsWith("[");
 }
+function preserveTemplateTokensInEncode(value) {
+  return hasScopeTemplate(value);
+}
 
 // src/fetch-config.ts
 var FETCH_HTTP_METHODS = [
@@ -277,7 +939,8 @@ function normalizeFetchRequestConfig(config) {
       ...config?.headers
     },
     headersJson: config?.headersJson,
-    swaggerEndpoints: config?.swaggerEndpoints
+    swaggerEndpoints: config?.swaggerEndpoints,
+    apiCollectionSyncNotice: config?.apiCollectionSyncNotice
   };
 }
 function joinFetchUrl(base, path) {
@@ -425,8 +1088,8 @@ async function executeFetch(config, options) {
 }
 
 // src/scope-autocomplete.ts
-function getValueAtPath(scope, path) {
-  let current = scope;
+function getValueAtPath(root, path) {
+  let current = root;
   for (const part of path) {
     if (current === null || typeof current !== "object") return void 0;
     current = current[part];
@@ -439,63 +1102,193 @@ function listObjectKeys(value) {
   }
   return Object.keys(value);
 }
+function matchRootPrefix(inner) {
+  if (!inner) return "partial";
+  for (const name of TEMPLATE_ROOT_NAMES) {
+    if (inner === name) return name;
+    if (name.startsWith(inner) && !inner.includes("?") && !inner.includes(".")) {
+      return "partial";
+    }
+  }
+  return null;
+}
+function splitPathBody(body) {
+  let depth = 0;
+  let current = "";
+  const segments = [];
+  let i = 0;
+  while (i < body.length) {
+    const ch = body[i];
+    if (ch === "(" || ch === "[" || ch === "{") {
+      depth += 1;
+      current += ch;
+      i += 1;
+      continue;
+    }
+    if (ch === ")" || ch === "]" || ch === "}") {
+      depth = Math.max(0, depth - 1);
+      current += ch;
+      i += 1;
+      continue;
+    }
+    if (depth > 0) {
+      current += ch;
+      i += 1;
+      continue;
+    }
+    if (body.startsWith("?.", i)) {
+      segments.push(current);
+      current = "";
+      i += 2;
+      continue;
+    }
+    if (ch === ".") {
+      segments.push(current);
+      current = "";
+      i += 1;
+      continue;
+    }
+    current += ch;
+    i += 1;
+  }
+  if (depth > 0) return null;
+  const endsWithSeparator = body.endsWith("?.") || body.endsWith(".") && !body.endsWith("?.") && !body.endsWith("..");
+  if (endsWithSeparator) {
+    const path = segments.map((s) => stripCallSuffix(s)).filter((s) => s.length > 0);
+    return { segments: path, endsWithSeparator: true, partialOrComplete: "" };
+  }
+  const cleaned = segments.map((s) => stripCallSuffix(s)).filter((s) => s.length > 0);
+  const lastRaw = current;
+  const lastClean = stripCallSuffix(lastRaw);
+  if (lastRaw.includes("(") && lastRaw.endsWith(")")) {
+    return {
+      segments: [...cleaned, lastClean].filter(Boolean),
+      endsWithSeparator: false,
+      partialOrComplete: lastClean
+    };
+  }
+  return {
+    segments: cleaned,
+    endsWithSeparator: false,
+    partialOrComplete: lastClean
+  };
+}
+function stripCallSuffix(segment) {
+  const idx = segment.indexOf("(");
+  if (idx < 0) return segment.trim();
+  return segment.slice(0, idx).trim();
+}
 function parseScopeAutocomplete(text, cursor, scope) {
   const before = text.slice(0, cursor);
   const templateStart = before.lastIndexOf("{");
   if (templateStart < 0) return null;
   const inner = before.slice(templateStart + 1);
   if (inner.includes("}")) return null;
-  if (!inner.startsWith("scope")) return null;
-  let body = inner.slice("scope".length);
-  if (body === "" || body === "?") {
-    return { templateStart, cursor, path: [], partialKey: "" };
+  const rootMatch = matchRootPrefix(inner);
+  if (rootMatch === "partial" || rootMatch && !inner.includes("?") && !inner.includes(".")) {
+    if (!inner.includes("?") && !inner.includes(".") && !inner.includes("(")) {
+      return {
+        templateStart,
+        cursor,
+        suggestingRoot: true,
+        root: typeof rootMatch === "string" && rootMatch !== "partial" ? rootMatch : null,
+        path: [],
+        partialKey: inner
+      };
+    }
   }
-  if (!body.startsWith("?.")) return null;
-  body = body.slice(2);
-  if (body === "") {
-    return { templateStart, cursor, path: [], partialKey: "" };
+  let root = null;
+  let body = "";
+  if (inner.startsWith("scope")) {
+    root = "scope";
+    body = inner.slice("scope".length);
+  } else if (inner.startsWith("system")) {
+    root = "system";
+    body = inner.slice("system".length);
+  } else {
+    return null;
   }
-  const segments = body.split("?.");
-  const endsWithSeparator = inner.endsWith("?.");
-  if (endsWithSeparator) {
-    const path = segments.filter((segment) => segment.length > 0);
-    return { templateStart, cursor, path, partialKey: "" };
+  if (body === "" || body === "?") {
+    return {
+      templateStart,
+      cursor,
+      suggestingRoot: false,
+      root,
+      path: [],
+      partialKey: ""
+    };
   }
-  const lastSegment = segments[segments.length - 1] ?? "";
-  const prefixSegments = segments.slice(0, -1).filter((segment) => segment.length > 0);
-  const parent = getValueAtPath(scope, prefixSegments);
-  const keys = listObjectKeys(parent);
-  if (lastSegment.length === 0) {
-    return { templateStart, cursor, path: prefixSegments, partialKey: "" };
+  if (body.startsWith("?.")) {
+    body = body.slice(2);
+  } else if (body.startsWith(".")) {
+    body = body.slice(1);
+  } else {
+    return null;
   }
-  if (keys.includes(lastSegment)) {
+  if (body === "") {
     return {
       templateStart,
       cursor,
-      path: [...prefixSegments, lastSegment],
+      suggestingRoot: false,
+      root,
+      path: [],
       partialKey: ""
     };
   }
+  const split = splitPathBody(body);
+  if (!split) return null;
+  if (split.endsWithSeparator) {
+    return {
+      templateStart,
+      cursor,
+      suggestingRoot: false,
+      root,
+      path: split.segments,
+      partialKey: ""
+    };
+  }
+  const lastSegment = split.partialOrComplete;
+  const prefixSegments = split.segments;
   return {
     templateStart,
     cursor,
+    suggestingRoot: false,
+    root,
     path: prefixSegments,
     partialKey: lastSegment
   };
 }
+function resolveAutocompleteRoot(state, scope) {
+  if (state.root === "system") return getSystemAutocompleteTree();
+  return scope;
+}
 function getScopeAutocompleteSuggestions(scope, state) {
-  const parent = state.partialKey.length > 0 ? getValueAtPath(scope, state.path) : state.path.length > 0 ? getValueAtPath(scope, state.path) : scope;
-  const keys = listObjectKeys(parent);
+  if (state.suggestingRoot) {
+    return TEMPLATE_ROOT_NAMES.filter(
+      (name) => name.startsWith(state.partialKey)
+    );
+  }
+  const dataRoot = resolveAutocompleteRoot(state, scope);
+  if (dataRoot === void 0 || dataRoot === null) return [];
+  const parent = state.path.length > 0 ? getValueAtPath(dataRoot, state.path) : dataRoot;
+  let keys = listObjectKeys(parent);
   if (state.partialKey.length === 0) return keys;
-  return keys.filter((key) => key.startsWith(state.partialKey));
+  keys = keys.filter((key) => key.startsWith(state.partialKey));
+  return keys;
 }
-function buildScopeExpression(path, selectedKey) {
-  return `scope?.${[...path, selectedKey].join("?.")}`;
+function buildScopeExpression(path, selectedKey, root = "scope") {
+  return `${root}?.${[...path, selectedKey].join("?.")}`;
 }
 function applyScopeAutocompleteSelection(text, state, selectedKey) {
-  const expr = buildScopeExpression(state.path, selectedKey);
   const before = text.slice(0, state.templateStart + 1);
   const after = text.slice(state.cursor);
+  let expr;
+  if (state.suggestingRoot) {
+    expr = `${selectedKey}?.`;
+  } else {
+    const root = state.root ?? "scope";
+    expr = buildScopeExpression(state.path, selectedKey, root);
+  }
   const value = `${before}${expr}${after}`;
   const cursor = before.length + expr.length;
   return { value, cursor };
@@ -656,13 +1449,13 @@ function resolveFetchBody(body, scope) {
   if (body === void 0) return void 0;
   const trimmed = body.trim();
   if (!trimmed) return body;
-  if (scope !== void 0 && isWholeScopeExpression(trimmed)) {
+  if (isWholeScopeExpression(trimmed)) {
     const value = evaluateScopeExpression(trimmed.slice(1, -1), scope);
     if (value === void 0) return "";
     if (typeof value === "string") return value;
     return stringifyScopeValue(value);
   }
-  if (scope === void 0 || !hasScopeTemplate(body)) return body;
+  if (!hasScopeTemplate(body)) return body;
   if (looksLikeJsonText(trimmed)) {
     return evaluateScopeTemplateInJson(body, scope);
   }
@@ -696,7 +1489,8 @@ function getFetchHeadersValidationError(config, scope) {
 function isWholeScopeExpression(text) {
   const trimmed = text.trim();
   if (!trimmed.startsWith("{") || !trimmed.endsWith("}")) return false;
-  return trimmed.slice(1, -1).trim().startsWith("scope");
+  const inner = trimmed.slice(1, -1).trim();
+  return inner.startsWith("scope") || inner.startsWith("system");
 }
 function asHeaderRecord(value) {
   if (!value || typeof value !== "object" || Array.isArray(value)) return void 0;
@@ -708,7 +1502,6 @@ function asHeaderRecord(value) {
   return headers;
 }
 function applyScopeToHeaderRecord(headers, scope) {
-  if (scope === void 0) return headers;
   return Object.fromEntries(
     Object.entries(headers).map(([key, value]) => [
       evaluateScopeTemplate(String(key), scope),
@@ -720,12 +1513,11 @@ function parseFetchHeadersJson(text, scope) {
   const trimmed = text.trim();
   if (!trimmed) return {};
   if (isWholeScopeExpression(trimmed)) {
-    if (scope === void 0) return void 0;
     const inner = trimmed.slice(1, -1);
     return asHeaderRecord(evaluateScopeExpression(inner, scope));
   }
   let jsonText = trimmed;
-  if (scope !== void 0 && hasScopeTemplate(trimmed) && looksLikeJsonText(trimmed)) {
+  if (hasScopeTemplate(trimmed) && looksLikeJsonText(trimmed)) {
     jsonText = evaluateScopeTemplateInJson(trimmed, scope);
   }
   try {
@@ -759,14 +1551,15 @@ function resolveFetchHeaders(config, scope) {
 function applyFetchConfigScope(config, scope) {
   const headers = resolveFetchHeaders(config, scope);
   const body = resolveFetchBody(config.body, scope);
-  if (scope === void 0) {
-    if (headers === config.headers && body === config.body) return config;
-    return { ...config, headers, body };
+  const url = resolveTemplateString(config.url, scope) ?? "";
+  const apiBaseUrl = resolveTemplateString(config.apiBaseUrl, scope);
+  if (url === (config.url ?? "") && apiBaseUrl === config.apiBaseUrl && headers === config.headers && body === config.body) {
+    return config;
   }
   return {
     ...config,
-    url: resolveTemplateString(config.url, scope) ?? "",
-    apiBaseUrl: resolveTemplateString(config.apiBaseUrl, scope),
+    url,
+    apiBaseUrl,
     body,
     headers
   };
@@ -782,39 +1575,319 @@ function fetchConfigHasScopeTemplate(config) {
   );
 }
 
-// src/json-config.ts
-var DEFAULT_JSON_NODE_CONFIG = {
-  jsonString: "{}"
-};
-function validateJsonString(jsonString) {
-  const raw = jsonString?.trim();
-  if (!raw) {
-    return { ok: false, error: "JSON \u4E0D\u80FD\u4E3A\u7A7A" };
+// src/json-lint.ts
+var SUSPECT_CHAR_RE = /[\u201C\u201D\u2018\u2019\u300C\u300D\u300E\u300F\uFF0C\uFF1A\uFF1B\u3010\u3011\uFF08\uFF09\uFF01\uFF1F\u3001\u3002]/gu;
+function lineColToOffset(text, line, column) {
+  const lines = text.split("\n");
+  let offset = 0;
+  const targetLine = Math.max(1, line) - 1;
+  for (let i = 0; i < targetLine && i < lines.length; i += 1) {
+    offset += lines[i].length + 1;
+  }
+  const col = Math.max(1, column) - 1;
+  const lineText = lines[targetLine] ?? "";
+  return offset + Math.min(col, lineText.length);
+}
+function extractJsonErrorPosition(message, text) {
+  let match = /position\s+(\d+)/i.exec(message);
+  if (match) {
+    const pos = Number(match[1]);
+    if (Number.isFinite(pos) && pos >= 0) {
+      return Math.min(pos, Math.max(0, text.length - 1));
+    }
+  }
+  match = /line\s+(\d+)\s+column\s+(\d+)/i.exec(message);
+  if (match) {
+    const pos = lineColToOffset(text, Number(match[1]), Number(match[2]));
+    return Math.min(pos, Math.max(0, text.length - 1));
   }
+  match = /\bat\s+(\d+):(\d+)\b/.exec(message);
+  if (match) {
+    const pos = lineColToOffset(text, Number(match[1]), Number(match[2]));
+    return Math.min(pos, Math.max(0, text.length - 1));
+  }
+  return null;
+}
+function findJsonSyntaxErrorOffset(text) {
+  const src = text;
+  const len = src.length;
+  let i = 0;
+  const peek = () => i < len ? src[i] : "";
+  const fail = () => i < len ? i : Math.max(0, len - 1);
+  const skipWs = () => {
+    while (i < len && /[ \t\r\n]/.test(src[i])) i += 1;
+  };
+  const parseString = () => {
+    if (peek() !== '"') return false;
+    i += 1;
+    while (i < len) {
+      const c = src[i];
+      if (c === '"') {
+        i += 1;
+        return true;
+      }
+      if (c === "\\") {
+        i += 1;
+        if (i >= len) return false;
+        i += 1;
+        continue;
+      }
+      i += 1;
+    }
+    return false;
+  };
+  const parseNumber = () => {
+    const start = i;
+    if (peek() === "-") i += 1;
+    if (peek() === "0") {
+      i += 1;
+    } else if (/[1-9]/.test(peek())) {
+      while (/[0-9]/.test(peek())) i += 1;
+    } else {
+      i = start;
+      return false;
+    }
+    if (peek() === ".") {
+      i += 1;
+      if (!/[0-9]/.test(peek())) {
+        return false;
+      }
+      while (/[0-9]/.test(peek())) i += 1;
+    }
+    if (peek() === "e" || peek() === "E") {
+      i += 1;
+      if (peek() === "+" || peek() === "-") i += 1;
+      if (!/[0-9]/.test(peek())) return false;
+      while (/[0-9]/.test(peek())) i += 1;
+    }
+    return i > start;
+  };
+  const parseLiteral = (word) => {
+    if (src.startsWith(word, i)) {
+      i += word.length;
+      return true;
+    }
+    return false;
+  };
+  const parseValue = () => {
+    skipWs();
+    if (i >= len) return false;
+    const c = peek();
+    if (c === "{") return parseObject();
+    if (c === "[") return parseArray();
+    if (c === '"') return parseString();
+    if (c === "-" || /[0-9]/.test(c)) return parseNumber();
+    if (parseLiteral("true") || parseLiteral("false") || parseLiteral("null")) {
+      return true;
+    }
+    return false;
+  };
+  const parseObject = () => {
+    if (peek() !== "{") return false;
+    i += 1;
+    skipWs();
+    if (peek() === "}") {
+      i += 1;
+      return true;
+    }
+    while (i < len) {
+      skipWs();
+      if (peek() !== '"') return false;
+      if (!parseString()) return false;
+      skipWs();
+      if (peek() !== ":") return false;
+      i += 1;
+      if (!parseValue()) return false;
+      skipWs();
+      if (peek() === ",") {
+        i += 1;
+        skipWs();
+        if (peek() === "}" || i >= len) return false;
+        continue;
+      }
+      if (peek() === "}") {
+        i += 1;
+        return true;
+      }
+      return false;
+    }
+    return false;
+  };
+  const parseArray = () => {
+    if (peek() !== "[") return false;
+    i += 1;
+    skipWs();
+    if (peek() === "]") {
+      i += 1;
+      return true;
+    }
+    while (i < len) {
+      if (!parseValue()) return false;
+      skipWs();
+      if (peek() === ",") {
+        i += 1;
+        skipWs();
+        if (peek() === "]" || i >= len) return false;
+        continue;
+      }
+      if (peek() === "]") {
+        i += 1;
+        return true;
+      }
+      return false;
+    }
+    return false;
+  };
+  skipWs();
+  if (i >= len) return 0;
+  if (!parseValue()) return fail();
+  skipWs();
+  if (i < len) return i;
+  return null;
+}
+function expandAround(text, pos) {
+  const len = text.length;
+  if (len === 0) return { start: 0, end: 0, kind: "parse" };
+  const clamped = Math.max(0, Math.min(pos, len - 1));
+  const ch = text[clamped];
+  SUSPECT_CHAR_RE.lastIndex = 0;
+  if (SUSPECT_CHAR_RE.test(ch)) {
+    let start = clamped;
+    let end = clamped + 1;
+    while (start > 0) {
+      SUSPECT_CHAR_RE.lastIndex = 0;
+      if (!SUSPECT_CHAR_RE.test(text[start - 1])) break;
+      start -= 1;
+    }
+    while (end < len) {
+      SUSPECT_CHAR_RE.lastIndex = 0;
+      if (!SUSPECT_CHAR_RE.test(text[end])) break;
+      end += 1;
+    }
+    return { start, end, kind: "parse" };
+  }
+  const isTokenChar = (c) => /[A-Za-z0-9_$.+\-]/.test(c);
+  if (isTokenChar(ch)) {
+    let start = clamped;
+    let end = clamped + 1;
+    while (start > 0 && isTokenChar(text[start - 1])) start -= 1;
+    while (end < len && isTokenChar(text[end])) end += 1;
+    return { start, end, kind: "parse" };
+  }
+  return { start: clamped, end: clamped + 1, kind: "parse" };
+}
+function findSuspectCharRanges(text) {
+  const ranges = [];
+  SUSPECT_CHAR_RE.lastIndex = 0;
+  let match;
+  while ((match = SUSPECT_CHAR_RE.exec(text)) !== null) {
+    ranges.push({
+      start: match.index,
+      end: match.index + match[0].length,
+      kind: "suspect"
+    });
+  }
+  return ranges;
+}
+function mergeRanges(ranges) {
+  if (ranges.length === 0) return [];
+  const sorted = [...ranges].sort((a, b) => a.start - b.start || a.end - b.end);
+  const out = [];
+  for (const range of sorted) {
+    const last = out[out.length - 1];
+    if (!last || range.start > last.end) {
+      out.push({ ...range });
+      continue;
+    }
+    last.end = Math.max(last.end, range.end);
+    if (last.kind === "parse" || range.kind === "parse") last.kind = "parse";
+  }
+  return out;
+}
+function lintJsonString(jsonString) {
+  const raw = jsonString ?? "";
+  const trimmed = raw.trim();
+  if (!trimmed) {
+    return { ok: false, error: "JSON \u4E0D\u80FD\u4E3A\u7A7A", ranges: [] };
+  }
+  const suspectRanges = findSuspectCharRanges(raw);
+  const trimStart = raw.indexOf(trimmed);
+  const offset = trimStart >= 0 ? trimStart : 0;
   try {
-    const value = JSON.parse(raw);
+    const value = JSON.parse(trimmed);
     if (value === null || typeof value !== "object") {
-      return { ok: false, error: "JSON \u6839\u8282\u70B9\u5FC5\u987B\u662F object \u6216 array" };
+      return {
+        ok: false,
+        error: "JSON \u6839\u8282\u70B9\u5FC5\u987B\u662F object \u6216 array",
+        ranges: mergeRanges(suspectRanges)
+      };
     }
     return { ok: true, value };
   } catch (error) {
+    const message = error instanceof Error ? error.message : "JSON \u683C\u5F0F\u65E0\u6548";
+    const ranges = [...suspectRanges];
+    const fromEngine = extractJsonErrorPosition(message, trimmed);
+    const fromScan = findJsonSyntaxErrorOffset(trimmed);
+    const pos = fromScan ?? fromEngine;
+    if (pos != null) {
+      ranges.push(expandAround(raw, offset + pos));
+    } else if (ranges.length === 0 && raw.length > 0) {
+      const first = raw.search(/\S/);
+      ranges.push(expandAround(raw, first >= 0 ? first : 0));
+    }
     return {
       ok: false,
-      error: error instanceof Error ? error.message : "JSON \u683C\u5F0F\u65E0\u6548"
+      error: message,
+      ranges: mergeRanges(ranges)
     };
   }
 }
+function renderJsonWithErrorHighlights(text, ranges, markClass = "json-lint-error") {
+  const escape = (s) => s.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;");
+  const source = text ?? "";
+  const merged = mergeRanges(
+    ranges.filter((r) => r.end > r.start && r.start < source.length)
+  );
+  if (merged.length === 0) return escape(source) || "\n";
+  let html = "";
+  let cursor = 0;
+  for (const range of merged) {
+    const start = Math.max(0, range.start);
+    const end = Math.min(source.length, range.end);
+    if (start > cursor) html += escape(source.slice(cursor, start));
+    if (end > start) {
+      html += `<mark class="${markClass}">${escape(source.slice(start, end))}</mark>`;
+    }
+    cursor = Math.max(cursor, end);
+  }
+  if (cursor < source.length) html += escape(source.slice(cursor));
+  return html;
+}
+
+// src/json-config.ts
+var DEFAULT_JSON_NODE_CONFIG = {
+  jsonString: "{}"
+};
+function validateJsonString(jsonString) {
+  const result = lintJsonString(jsonString);
+  if (!result.ok) {
+    return { ok: false, error: result.error, ranges: result.ranges };
+  }
+  return { ok: true, value: result.value };
+}
 function validateJsonStringAllowingScope(jsonString) {
+  const lint = lintJsonString(jsonString ?? "");
+  if (!lint.ok) {
+    return { ok: false, error: lint.error, ranges: lint.ranges };
+  }
   if (hasScopeTemplate(jsonString ?? "")) {
     return { ok: true, deferred: true };
   }
-  const result = validateJsonString(jsonString);
-  if (!result.ok) return result;
-  return { ok: true, value: result.value };
+  return { ok: true, value: lint.value };
 }
 function parseJsonConfig(config, scope) {
   let raw = config.jsonString ?? "";
-  if (scope !== void 0 && hasScopeTemplate(raw)) {
+  if (hasScopeTemplate(raw)) {
     raw = evaluateScopeTemplateInJson(raw, scope);
   }
   const result = validateJsonString(raw);
@@ -1352,16 +2425,16 @@ function parseSwaggerDocument(spec, docsUrl) {
   if (!spec || typeof spec !== "object") {
     throw new Error("Swagger \u6587\u6863\u683C\u5F0F\u65E0\u6548");
   }
-  const document = spec;
-  if (typeof document.openapi === "string") {
-    const parsed = parseOpenApiV3(document, docsUrl);
+  const document2 = spec;
+  if (typeof document2.openapi === "string") {
+    const parsed = parseOpenApiV3(document2, docsUrl);
     if (parsed.endpoints.length === 0) {
       throw new Error("\u672A\u5728 OpenAPI \u6587\u6863\u4E2D\u627E\u5230\u63A5\u53E3");
     }
     return parsed;
   }
-  if (document.swagger === "2.0" || document.swagger === 2) {
-    const parsed = parseSwaggerV2(document, docsUrl);
+  if (document2.swagger === "2.0" || document2.swagger === 2) {
+    const parsed = parseSwaggerV2(document2, docsUrl);
     if (parsed.endpoints.length === 0) {
       throw new Error("\u672A\u5728 Swagger 2.0 \u6587\u6863\u4E2D\u627E\u5230\u63A5\u53E3");
     }
@@ -1396,6 +2469,329 @@ function filterEndpointSuggestions(suggestions, query) {
   );
 }
 
+// src/api-collection.ts
+var API_COLLECTION_DOCUMENT_VERSION = 1;
+var HTTP_METHOD_SET = new Set(FETCH_HTTP_METHODS);
+function isPlainStringRecord(value) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) return false;
+  return Object.values(value).every(
+    (item) => typeof item === "string"
+  );
+}
+function normalizeEndpoint(raw, index) {
+  if (!raw || typeof raw !== "object" || Array.isArray(raw)) {
+    return `apis[${index}] \u5FC5\u987B\u662F\u5BF9\u8C61`;
+  }
+  const item = raw;
+  const name = typeof item.name === "string" ? item.name.trim() : "";
+  if (!name) return `apis[${index}].name \u5FC5\u586B\u4E14\u4E3A\u975E\u7A7A\u5B57\u7B26\u4E32`;
+  const url = typeof item.url === "string" ? item.url.trim() : "";
+  if (!url) return `apis[${index}].url \u5FC5\u586B\u4E14\u4E3A\u975E\u7A7A\u5B57\u7B26\u4E32`;
+  const methodRaw = typeof item.method === "string" ? item.method.trim().toUpperCase() : "";
+  if (!HTTP_METHOD_SET.has(methodRaw)) {
+    return `apis[${index}].method \u5FC5\u987B\u662F ${FETCH_HTTP_METHODS.join(" / ")} \u4E4B\u4E00`;
+  }
+  if (item.params !== void 0 && !isPlainStringRecord(item.params)) {
+    return `apis[${index}].params \u5FC5\u987B\u662F string \u5B57\u5178`;
+  }
+  if (item.headers !== void 0 && !isPlainStringRecord(item.headers)) {
+    return `apis[${index}].headers \u5FC5\u987B\u662F string \u5B57\u5178`;
+  }
+  if (item.body !== void 0 && typeof item.body !== "string") {
+    return `apis[${index}].body \u5FC5\u987B\u662F\u5B57\u7B26\u4E32`;
+  }
+  if (item.description !== void 0 && typeof item.description !== "string") {
+    return `apis[${index}].description \u5FC5\u987B\u662F\u5B57\u7B26\u4E32`;
+  }
+  return {
+    name,
+    url,
+    method: methodRaw,
+    ...item.params ? { params: item.params } : {},
+    ...item.headers ? { headers: item.headers } : {},
+    ...typeof item.body === "string" ? { body: item.body } : {},
+    ...typeof item.description === "string" ? { description: item.description } : {}
+  };
+}
+function validateApiCollectionDocument(input) {
+  if (!input || typeof input !== "object" || Array.isArray(input)) {
+    return { ok: false, error: "\u6839\u8282\u70B9\u5FC5\u987B\u662F\u5BF9\u8C61" };
+  }
+  const root = input;
+  const version = root.version;
+  if (version !== API_COLLECTION_DOCUMENT_VERSION && version !== "1") {
+    return {
+      ok: false,
+      error: `version \u5FC5\u987B\u4E3A ${API_COLLECTION_DOCUMENT_VERSION}`
+    };
+  }
+  const name = typeof root.name === "string" ? root.name.trim() : "";
+  if (!name) return { ok: false, error: "name \u5FC5\u586B\u4E14\u4E3A\u975E\u7A7A\u5B57\u7B26\u4E32" };
+  if (root.baseUrl !== void 0 && typeof root.baseUrl !== "string") {
+    return { ok: false, error: "baseUrl \u5FC5\u987B\u662F\u5B57\u7B26\u4E32" };
+  }
+  if (!Array.isArray(root.apis)) {
+    return { ok: false, error: "apis \u5FC5\u987B\u662F\u6570\u7EC4" };
+  }
+  if (root.apis.length === 0) {
+    return { ok: false, error: "apis \u81F3\u5C11\u5305\u542B\u4E00\u6761\u63A5\u53E3" };
+  }
+  const apis = [];
+  const nameSet = /* @__PURE__ */ new Set();
+  for (let i = 0; i < root.apis.length; i += 1) {
+    const normalized = normalizeEndpoint(root.apis[i], i);
+    if (typeof normalized === "string") {
+      return { ok: false, error: normalized };
+    }
+    if (nameSet.has(normalized.name)) {
+      return { ok: false, error: `\u63A5\u53E3\u540D\u79F0\u91CD\u590D\uFF1A${normalized.name}` };
+    }
+    nameSet.add(normalized.name);
+    apis.push(normalized);
+  }
+  return {
+    ok: true,
+    document: {
+      version: API_COLLECTION_DOCUMENT_VERSION,
+      name,
+      ...typeof root.baseUrl === "string" && root.baseUrl.trim() ? { baseUrl: root.baseUrl.trim() } : {},
+      apis
+    }
+  };
+}
+function parseApiCollectionJson(text) {
+  const trimmed = text.trim();
+  if (!trimmed) return { ok: false, error: "\u5185\u5BB9\u4E3A\u7A7A" };
+  let parsed;
+  try {
+    parsed = JSON.parse(trimmed);
+  } catch (error) {
+    return {
+      ok: false,
+      error: `\u4E0D\u662F\u6709\u6548 JSON\uFF1A${error instanceof Error ? error.message : "\u683C\u5F0F\u65E0\u6548"}`
+    };
+  }
+  const validated = validateApiCollectionDocument(parsed);
+  if (!validated.ok) return validated;
+  return {
+    ok: true,
+    document: validated.document,
+    rawJson: JSON.stringify(validated.document, null, 2)
+  };
+}
+function createApiCollectionId() {
+  return `api_col_${Date.now()}_${Math.random().toString(36).slice(2, 9)}`;
+}
+function apiCollectionToListItem(record) {
+  return {
+    id: record.id,
+    name: record.name,
+    persistLocal: record.persistLocal,
+    apiCount: record.document.apis.length,
+    updatedAt: record.updatedAt
+  };
+}
+function getApiCollectionTemplateDocument() {
+  return {
+    version: API_COLLECTION_DOCUMENT_VERSION,
+    name: "\u793A\u4F8B\u63A5\u53E3\u96C6\u5408",
+    baseUrl: "https://api.example.com",
+    apis: [
+      {
+        name: "\u83B7\u53D6\u7528\u6237\u5217\u8868",
+        method: "GET",
+        url: "/users",
+        params: {
+          page: "{scope?.value?.page}",
+          pageSize: "20",
+          tenant: "{scope?.value?.tenant}"
+        },
+        headers: {
+          Accept: "application/json",
+          Authorization: "Bearer {scope?.value?.token}"
+        },
+        description: "\u5206\u9875\u67E5\u8BE2\u7528\u6237\uFF1Bpage / tenant / token \u53EF\u7528 Scope \u6A21\u7248"
+      },
+      {
+        name: "\u521B\u5EFA\u7528\u6237",
+        method: "POST",
+        url: "/tenants/{scope?.value?.tenant}/users",
+        headers: { "Content-Type": "application/json" },
+        body: '{\n  "name": "{scope?.value?.name}",\n  "role": "member"\n}',
+        description: "\u521B\u5EFA\u7528\u6237\uFF1BURL \u4E0E body \u5747\u652F\u6301 Scope \u6A21\u7248"
+      },
+      {
+        name: "\u83B7\u53D6\u7528\u6237\u8BE6\u60C5",
+        method: "GET",
+        url: "/users/{scope?.value?.id}",
+        headers: { Accept: "application/json" },
+        description: "\u6309 id \u67E5\u8BE2\uFF1B\u8DEF\u5F84\u91CC\u53EF\u76F4\u63A5\u5199 Scope \u6A21\u7248"
+      }
+    ]
+  };
+}
+function getApiCollectionTemplateJson() {
+  return `${JSON.stringify(getApiCollectionTemplateDocument(), null, 2)}
+`;
+}
+function downloadApiCollectionTemplate(filename = "abuilder-api-collection-template.json") {
+  if (typeof document === "undefined") return;
+  const blob = new Blob([getApiCollectionTemplateJson()], {
+    type: "application/json;charset=utf-8"
+  });
+  const url = URL.createObjectURL(blob);
+  const anchor = document.createElement("a");
+  anchor.href = url;
+  anchor.download = filename;
+  anchor.click();
+  URL.revokeObjectURL(url);
+}
+function encodeQueryValuePreservingScope(value) {
+  if (!hasScopeTemplate(value)) return encodeURIComponent(value);
+  const re = /\{((?:scope|system)[^}]*)\}/g;
+  let result = "";
+  let lastIndex = 0;
+  let match;
+  while ((match = re.exec(value)) !== null) {
+    result += encodeURIComponent(value.slice(lastIndex, match.index));
+    result += match[0];
+    lastIndex = match.index + match[0].length;
+  }
+  result += encodeURIComponent(value.slice(lastIndex));
+  return result;
+}
+function buildApiCollectionEndpointUrl(endpoint) {
+  const base = endpoint.url.trim();
+  const params = endpoint.params;
+  if (!params || Object.keys(params).length === 0) return base;
+  const search = Object.entries(params).filter(([, value]) => value !== void 0 && value !== null && String(value).length > 0).map(
+    ([key, value]) => `${encodeURIComponent(key)}=${encodeQueryValuePreservingScope(String(value))}`
+  ).join("&");
+  if (!search) return base;
+  return base.includes("?") ? `${base}&${search}` : `${base}?${search}`;
+}
+function normalizeApiCollectionUrlKey(url) {
+  const trimmed = url.trim();
+  if (!trimmed) return "";
+  const withoutHash = trimmed.split("#")[0] ?? trimmed;
+  const queryIndex = withoutHash.indexOf("?");
+  const pathOnly = queryIndex === -1 ? withoutHash : withoutHash.slice(0, queryIndex);
+  const normalized = pathOnly.replace(/\/+$/, "");
+  return normalized || "/";
+}
+function stableHeadersText(headers) {
+  if (!headers || Object.keys(headers).length === 0) return "";
+  const sorted = Object.keys(headers).sort().reduce((acc, key) => {
+    acc[key] = headers[key] ?? "";
+    return acc;
+  }, {});
+  return JSON.stringify(sorted);
+}
+function diffFetchConfigChanges(prev, next) {
+  const changed = [];
+  const prevUrl = prev?.url?.trim() ?? "";
+  const nextUrl = next.url?.trim() ?? "";
+  if (prevUrl !== nextUrl) changed.push("url");
+  const prevMethod = (prev?.method ?? "GET").toUpperCase();
+  const nextMethod = (next.method ?? "GET").toUpperCase();
+  if (prevMethod !== nextMethod) changed.push("method");
+  if (stableHeadersText(prev?.headers) !== stableHeadersText(next.headers)) {
+    changed.push("headers");
+  }
+  if ((prev?.body ?? "").trim() !== (next.body ?? "").trim()) {
+    changed.push("body");
+  }
+  if ((prev?.apiBaseUrl?.trim() ?? "") !== (next.apiBaseUrl?.trim() ?? "")) {
+    changed.push("apiBaseUrl");
+  }
+  return changed;
+}
+function pickEndpointForNode(node, collectionId, candidates) {
+  if (candidates.length === 0) return null;
+  if (candidates.length === 1) return candidates[0] ?? null;
+  const config = node.fetchConfig;
+  if (config?.apiCollectionId === collectionId && config.apiCollectionEndpointName) {
+    const byName = candidates.find(
+      (item) => item.name === config.apiCollectionEndpointName
+    );
+    if (byName) return byName;
+  }
+  const method = config?.method?.toUpperCase();
+  if (method) {
+    const byMethod = candidates.filter((item) => item.method === method);
+    if (byMethod.length === 1) return byMethod[0] ?? null;
+    if (byMethod.length > 1) return byMethod[0] ?? null;
+  }
+  return candidates[0] ?? null;
+}
+function buildApiCollectionSyncPatches(options) {
+  const { collectionId, document: document2, nodes } = options;
+  const byUrl = /* @__PURE__ */ new Map();
+  for (const endpoint of document2.apis) {
+    const key = normalizeApiCollectionUrlKey(endpoint.url);
+    if (!key) continue;
+    const list = byUrl.get(key) ?? [];
+    list.push(endpoint);
+    byUrl.set(key, list);
+  }
+  const patches = [];
+  const syncedAt = Date.now();
+  for (const node of nodes) {
+    const nodeUrl = node.fetchConfig?.url;
+    if (!nodeUrl?.trim()) continue;
+    const key = normalizeApiCollectionUrlKey(nodeUrl);
+    if (!key) continue;
+    const candidates = byUrl.get(key) ?? [];
+    const endpoint = pickEndpointForNode(node, collectionId, candidates);
+    if (!endpoint) continue;
+    const fetchConfigPatch = applyApiCollectionEndpointToFetchConfig({
+      collectionId,
+      document: document2,
+      endpoint
+    });
+    const changedFields = diffFetchConfigChanges(node.fetchConfig, fetchConfigPatch);
+    fetchConfigPatch.apiCollectionSyncNotice = {
+      source: "api-collection-sync",
+      collectionName: document2.name,
+      endpointName: endpoint.name,
+      changedFields,
+      updatedAt: syncedAt
+    };
+    patches.push({
+      nodeId: node.id,
+      nodeLabel: (node.label ?? "").trim() || node.id,
+      changedFields,
+      fetchConfigPatch
+    });
+  }
+  return patches;
+}
+function toApiCollectionSyncResult(patches) {
+  return {
+    updatedCount: patches.length,
+    nodes: patches.map((patch) => ({
+      id: patch.nodeId,
+      label: patch.nodeLabel,
+      changedFields: patch.changedFields
+    }))
+  };
+}
+function applyApiCollectionEndpointToFetchConfig(options) {
+  const { collectionId, document: document2, endpoint } = options;
+  const headers = endpoint.headers ?? {};
+  return {
+    url: buildApiCollectionEndpointUrl(endpoint),
+    method: endpoint.method,
+    headers,
+    headersJson: Object.keys(headers).length > 0 ? JSON.stringify(headers, null, 2) : "",
+    body: endpoint.body ?? "",
+    apiBaseUrl: document2.baseUrl?.trim() || void 0,
+    urlInputMode: "collection",
+    apiCollectionId: collectionId,
+    apiCollectionEndpointName: endpoint.name
+  };
+}
+
 // src/runtime/execution-trace.ts
 function serializeTraceValue(value) {
   if (value === void 0) return void 0;
@@ -2820,6 +4216,7 @@ var BlueprintGraphRunner = class _BlueprintGraphRunner {
 };
 
 exports.AND_NODE_TYPE = AND_NODE_TYPE;
+exports.API_COLLECTION_DOCUMENT_VERSION = API_COLLECTION_DOCUMENT_VERSION;
 exports.BLUEPRINT_ACTIVATION_INPUT_KEY = BLUEPRINT_ACTIVATION_INPUT_KEY;
 exports.BLUEPRINT_CALL_STACK_KEY = BLUEPRINT_CALL_STACK_KEY;
 exports.BLUEPRINT_NODE_TYPE = BLUEPRINT_NODE_TYPE;
@@ -2851,6 +4248,10 @@ exports.PAGE_LIFECYCLE_LABELS = PAGE_LIFECYCLE_LABELS;
 exports.PAGE_LIFECYCLE_PHASES = PAGE_LIFECYCLE_PHASES;
 exports.STORAGE_KINDS = STORAGE_KINDS;
 exports.STORAGE_NODE_TYPE = STORAGE_NODE_TYPE;
+exports.SYSTEM_LOCATION_KEYS = SYSTEM_LOCATION_KEYS;
+exports.SYSTEM_MATH_KEYS = SYSTEM_MATH_KEYS;
+exports.SYSTEM_TIME_METHOD_NAMES = SYSTEM_TIME_METHOD_NAMES;
+exports.TEMPLATE_ROOT_NAMES = TEMPLATE_ROOT_NAMES;
 exports.UI_EVENT_PAYLOAD_KEY = UI_EVENT_PAYLOAD_KEY;
 exports.VIEW_EVENT_SIGNAL_KEY = VIEW_EVENT_SIGNAL_KEY;
 exports.VIEW_EVENT_TYPES = VIEW_EVENT_TYPES;
@@ -2858,11 +4259,15 @@ exports.VIEW_NODE_TYPE = VIEW_NODE_TYPE;
 exports.abortClockNode = abortClockNode;
 exports.abortClockSession = abortClockSession;
 exports.andLogicNodeDefinition = andLogicNodeDefinition;
+exports.apiCollectionToListItem = apiCollectionToListItem;
 exports.appStorageKey = appStorageKey;
+exports.applyApiCollectionEndpointToFetchConfig = applyApiCollectionEndpointToFetchConfig;
 exports.applyFetchConfigScope = applyFetchConfigScope;
 exports.applyScopeAutocompleteSelection = applyScopeAutocompleteSelection;
 exports.assertNoBlueprintReferenceCycle = assertNoBlueprintReferenceCycle;
 exports.blueprintNodeDefinition = blueprintNodeDefinition;
+exports.buildApiCollectionEndpointUrl = buildApiCollectionEndpointUrl;
+exports.buildApiCollectionSyncPatches = buildApiCollectionSyncPatches;
 exports.buildClockSessionKey = buildClockSessionKey;
 exports.buildClockSignalValue = buildClockSignalValue;
 exports.buildEndpointFullUrl = buildEndpointFullUrl;
@@ -2877,10 +4282,12 @@ exports.collectBlueprintLibraryRefs = collectBlueprintLibraryRefs;
 exports.collectIncomingNodeScopeEntries = collectIncomingNodeScopeEntries;
 exports.collectViewEventBindings = collectViewEventBindings;
 exports.combinePortSignalsOr = combinePortSignalsOr;
+exports.createApiCollectionId = createApiCollectionId;
 exports.createClockOutputValue = createClockOutputValue;
 exports.createFalseSignal = createFalseSignal;
 exports.createIncomingNodeScopeEntry = createIncomingNodeScopeEntry;
 exports.createLifecycleSignal = createLifecycleSignal;
+exports.createSystemRoot = createSystemRoot;
 exports.createTraceEntryId = createTraceEntryId;
 exports.createTrueSignal = createTrueSignal;
 exports.createViewEventSignal = createViewEventSignal;
@@ -2888,6 +4295,7 @@ exports.defaultLogicNodeDefinition = defaultLogicNodeDefinition;
 exports.deserializeStorageValue = deserializeStorageValue;
 exports.detectBlueprintReferenceCycle = detectBlueprintReferenceCycle;
 exports.detectRuntimeBlueprintCycle = detectRuntimeBlueprintCycle;
+exports.downloadApiCollectionTemplate = downloadApiCollectionTemplate;
 exports.draftFetchHeadersText = draftFetchHeadersText;
 exports.evaluateScopeExpression = evaluateScopeExpression;
 exports.evaluateScopeTemplate = evaluateScopeTemplate;
@@ -2895,23 +4303,31 @@ exports.evaluateScopeTemplateInJson = evaluateScopeTemplateInJson;
 exports.executeFetch = executeFetch;
 exports.executeLogicConfig = executeLogicConfig;
 exports.executeStorageConfig = executeStorageConfig;
+exports.extractJsonErrorPosition = extractJsonErrorPosition;
 exports.fetchConfigHasScopeTemplate = fetchConfigHasScopeTemplate;
 exports.fetchNodeDefinition = fetchNodeDefinition;
 exports.filterEndpointSuggestions = filterEndpointSuggestions;
 exports.filterStorageKeySuggestions = filterStorageKeySuggestions;
+exports.findJsonSyntaxErrorOffset = findJsonSyntaxErrorOffset;
+exports.findSuspectCharRanges = findSuspectCharRanges;
 exports.formatBlueprintCycleMessage = formatBlueprintCycleMessage;
 exports.formatClockTime = formatClockTime;
 exports.getActiveClockNodeIds = getActiveClockNodeIds;
+exports.getApiCollectionTemplateDocument = getApiCollectionTemplateDocument;
+exports.getApiCollectionTemplateJson = getApiCollectionTemplateJson;
 exports.getClockTickDelayOffsetMs = getClockTickDelayOffsetMs;
 exports.getClockTickWaitMs = getClockTickWaitMs;
 exports.getFetchBodyValidationError = getFetchBodyValidationError;
 exports.getFetchHeadersValidationError = getFetchHeadersValidationError;
 exports.getNodeDefinition = getNodeDefinition;
 exports.getScopeAutocompleteSuggestions = getScopeAutocompleteSuggestions;
+exports.getSystemAutocompleteTree = getSystemAutocompleteTree;
 exports.hasScopeTemplate = hasScopeTemplate;
+exports.hasTemplateExpression = hasTemplateExpression;
 exports.isClockNodeActive = isClockNodeActive;
 exports.isClockScheduleActive = isClockScheduleActive;
 exports.isClockSessionAborted = isClockSessionAborted;
+exports.isDayjsValue = isDayjsValue;
 exports.isFalseSignal = isFalseSignal;
 exports.isStorageReadConfigured = isStorageReadConfigured;
 exports.isStorageSetConfigured = isStorageSetConfigured;
@@ -2921,20 +4337,25 @@ exports.isWholeScopeExpression = isWholeScopeExpression;
 exports.jsonNodeDefinition = jsonNodeDefinition;
 exports.latestTraceOutputsByNode = latestTraceOutputsByNode;
 exports.lifecycleNodeDefinition = lifecycleNodeDefinition;
+exports.lintJsonString = lintJsonString;
 exports.listBrowserStorageKeys = listBrowserStorageKeys;
 exports.looksLikeJsonText = looksLikeJsonText;
 exports.nodeDefinitionRegistry = nodeDefinitionRegistry;
+exports.normalizeApiCollectionUrlKey = normalizeApiCollectionUrlKey;
 exports.normalizeAppNameSpace = normalizeAppNameSpace;
 exports.normalizeClockConfig = normalizeClockConfig;
 exports.normalizeFetchRequestConfig = normalizeFetchRequestConfig;
 exports.normalizeStorageConfig = normalizeStorageConfig;
 exports.normalizeViewEventConfig = normalizeViewEventConfig;
+exports.parseApiCollectionJson = parseApiCollectionJson;
 exports.parseFetchHeadersJson = parseFetchHeadersJson;
 exports.parseJsonConfig = parseJsonConfig;
 exports.parseJsonText = parseJsonText;
 exports.parseScopeAutocomplete = parseScopeAutocomplete;
 exports.parseSwaggerDocument = parseSwaggerDocument;
+exports.preserveTemplateTokensInEncode = preserveTemplateTokensInEncode;
 exports.registerDefaultBehaviors = registerDefaultBehaviors;
+exports.renderJsonWithErrorHighlights = renderJsonWithErrorHighlights;
 exports.resolveBlueprintCallStack = resolveBlueprintCallStack;
 exports.resolveFetchBody = resolveFetchBody;
 exports.resolveFetchHeaders = resolveFetchHeaders;
@@ -2954,7 +4375,9 @@ exports.stopClockSchedule = stopClockSchedule;
 exports.storageNodeDefinition = storageNodeDefinition;
 exports.stringifyScopeValue = stringifyScopeValue;
 exports.subscribeActiveClockNodes = subscribeActiveClockNodes;
+exports.toApiCollectionSyncResult = toApiCollectionSyncResult;
 exports.uniqueStorageKinds = uniqueStorageKinds;
+exports.validateApiCollectionDocument = validateApiCollectionDocument;
 exports.validateClockScheduleConfig = validateClockScheduleConfig;
 exports.validateFetchJsonText = validateFetchJsonText;
 exports.validateJsonString = validateJsonString;