@route-forge/core 1.1.0 → 1.2.0

package/dist/route-forge.global.js

@@ -0,0 +1,1094 @@
+var RouteForge = (function (exports) {
+  'use strict';
+
+  // src/cache.ts
+  var KEY_PREFIX = "route-forge:";
+  function pickStorage(storage) {
+    if (storage === "memory") return null;
+    if (typeof globalThis === "undefined") return null;
+    if (storage === "sessionStorage") {
+      return globalThis.sessionStorage ?? null;
+    }
+    if (storage === "localStorage") {
+      return globalThis.localStorage ?? null;
+    }
+    return null;
+  }
+  var RouteCache = class {
+    constructor(opts) {
+      this.memory = /* @__PURE__ */ new Map();
+      this.storage = opts.storage;
+      this.fallbackTtl = opts.ttl;
+      this.backend = pickStorage(opts.storage);
+    }
+    key(level) {
+      return `${KEY_PREFIX}${level}`;
+    }
+    get(level) {
+      if (this.storage === "memory" || !this.backend) {
+        return this.getFromMemory(level);
+      }
+      const raw = this.backend.getItem(this.key(level));
+      if (raw) {
+        try {
+          const entry = JSON.parse(raw);
+          if (this.isExpired(entry)) {
+            this.del(level);
+            return void 0;
+          }
+          return entry;
+        } catch {
+          return void 0;
+        }
+      }
+      return this.getFromMemory(level);
+    }
+    getFromMemory(level) {
+      const entry = this.memory.get(level);
+      if (!entry) return void 0;
+      if (this.isExpired(entry)) {
+        this.memory.delete(level);
+        return void 0;
+      }
+      return entry;
+    }
+    set(resp) {
+      let ttl;
+      if (resp.cache !== void 0 && resp.cache !== null) {
+        ttl = resp.cache > 0 ? Math.min(resp.cache, this.fallbackTtl) : resp.cache;
+      } else {
+        ttl = this.fallbackTtl;
+      }
+      const entry = {
+        level: resp.level,
+        routes: resp.routes,
+        ttl,
+        cachedAt: Date.now()
+      };
+      if (this.storage === "memory" || !this.backend) {
+        this.memory.set(resp.level, entry);
+        return;
+      }
+      try {
+        this.backend.setItem(this.key(resp.level), JSON.stringify(entry));
+      } catch {
+        this.memory.set(resp.level, entry);
+      }
+    }
+    del(level) {
+      this.memory.delete(level);
+      if (this.backend) {
+        try {
+          this.backend.removeItem(this.key(level));
+        } catch {
+        }
+      }
+    }
+    clear() {
+      this.memory.clear();
+      if (this.backend) {
+        try {
+          const toRemove = [];
+          for (let i = 0; i < this.backend.length; i++) {
+            const k = this.backend.key(i);
+            if (k && k.startsWith(KEY_PREFIX)) toRemove.push(k);
+          }
+          for (const k of toRemove) this.backend.removeItem(k);
+        } catch {
+        }
+      }
+    }
+    isExpired(entry) {
+      if (entry.ttl === null) return false;
+      if (entry.ttl === 0) return false;
+      return Date.now() - entry.cachedAt > entry.ttl * 1e3;
+    }
+  };
+
+  // src/errors.ts
+  var ForgeError = class extends Error {
+    constructor(message, opts) {
+      super(message);
+      this.name = this.constructor.name;
+      this.code = opts.code;
+      if (opts.route !== void 0) this.route = opts.route;
+      if (opts.level !== void 0) this.level = opts.level;
+      if (opts.context !== void 0) this.context = opts.context;
+      if (opts.cause !== void 0) this.cause = opts.cause;
+    }
+  };
+  var UnknownRouteError = class extends ForgeError {
+    constructor(route, level) {
+      super(`Route "${route}" not found${level ? ` in level "${level}"` : ""}`, {
+        code: "RF_FE_001",
+        route,
+        level
+      });
+    }
+  };
+  var UnknownLevelError = class extends ForgeError {
+    constructor(level) {
+      super(`Level "${level}" not declared in options.levels`, {
+        code: "RF_FE_002",
+        level
+      });
+    }
+  };
+  var MissingRouteParamError = class extends ForgeError {
+    constructor(route, missingParams) {
+      super(`Missing path parameter(s) ${missingParams.join(", ")} for route "${route}"`, {
+        code: "RF_FE_003",
+        route,
+        context: { missingParams }
+      });
+    }
+  };
+  var AdapterNotFoundError = class extends ForgeError {
+    constructor(adapter) {
+      super(`Adapter "${adapter}" not available; install axios or use 'builtin'`, {
+        code: "RF_FE_005",
+        context: { adapter }
+      });
+    }
+  };
+  var InvalidInterceptorReturnError = class extends ForgeError {
+    constructor(route) {
+      super(`Request interceptor must return a RequestConfig object`, {
+        code: "RF_FE_006",
+        route
+      });
+    }
+  };
+  var NetworkError = class extends ForgeError {
+    constructor(message, route, level, cause) {
+      super(message, { code: "RF_FE_007", route, level, cause });
+    }
+  };
+  var HTTPError = class extends ForgeError {
+    constructor(message, opts) {
+      super(message, {
+        code: "RF_FE_008",
+        route: opts.route,
+        level: opts.level,
+        context: { status: opts.status, url: opts.url, method: opts.method },
+        cause: opts.cause
+      });
+    }
+  };
+  var RequestAbortedError = class extends ForgeError {
+    constructor(route, level, cause) {
+      super(`Request aborted${route ? ` for route "${route}"` : ""}`, {
+        code: "RF_FE_009",
+        route,
+        level,
+        cause
+      });
+    }
+  };
+
+  // src/interceptors.ts
+  var InterceptorManagerImpl = class {
+    constructor() {
+      this.handlers = [];
+      this.nextId = 0;
+    }
+    use(onFulfilled, onRejected) {
+      const id = this.nextId++;
+      this.handlers.push({ id, onFulfilled, onRejected });
+      return id;
+    }
+    eject(id) {
+      const idx = this.handlers.findIndex((h) => h.id === id);
+      if (idx >= 0) this.handlers.splice(idx, 1);
+    }
+    clear() {
+      this.handlers = [];
+    }
+    forEach(fn) {
+      for (const h of this.handlers) fn(h);
+    }
+    /** 测试用：当前注册数量 */
+    get size() {
+      return this.handlers.length;
+    }
+  };
+  async function runRequestInterceptors(manager, initial) {
+    const handlers = [];
+    manager.forEach((h) => handlers.push(h));
+    handlers.reverse();
+    let p = Promise.resolve(initial);
+    for (const h of handlers) {
+      const onF = h.onFulfilled;
+      const onR = h.onRejected;
+      p = p.then(
+        async (v) => {
+          if (!onF) return v;
+          const result = await onF(v);
+          if (result === null || typeof result !== "object") {
+            throw new InvalidInterceptorReturnError();
+          }
+          return result;
+        },
+        (e) => onR ? onR(e) : Promise.reject(e)
+      );
+    }
+    return p;
+  }
+  async function runResponseInterceptors(manager, source) {
+    const handlers = [];
+    manager.forEach((h) => handlers.push(h));
+    let p = source;
+    for (const h of handlers) {
+      const onF = h.onFulfilled;
+      const onR = h.onRejected;
+      p = p.then(
+        (v) => onF ? onF(v) : v,
+        (e) => onR ? onR(e) : Promise.reject(e)
+      );
+    }
+    return p;
+  }
+  function createInterceptorManager() {
+    return new InterceptorManagerImpl();
+  }
+
+  // src/adapters/builtin-http.ts
+  function isPassthroughBody(body) {
+    if (body === null) return false;
+    return typeof FormData !== "undefined" && body instanceof FormData || typeof URLSearchParams !== "undefined" && body instanceof URLSearchParams || typeof Blob !== "undefined" && body instanceof Blob || typeof ArrayBuffer !== "undefined" && (body instanceof ArrayBuffer || ArrayBuffer.isView(body)) || typeof ReadableStream !== "undefined" && body instanceof ReadableStream;
+  }
+  function isAbortError(err) {
+    const e = err;
+    return !!e && e.name === "AbortError";
+  }
+  function combineSignals(...signals) {
+    const valid = signals.filter((s) => !!s);
+    if (valid.length === 0) return void 0;
+    if (valid.length === 1) return valid[0];
+    if (typeof AbortSignal !== "undefined" && typeof AbortSignal.any === "function") {
+      return AbortSignal.any(valid);
+    }
+    const controller = new AbortController();
+    for (const s of valid) {
+      if (s.aborted) {
+        controller.abort(s.reason);
+        return controller.signal;
+      }
+      s.addEventListener("abort", () => controller.abort(s.reason), { once: true });
+    }
+    return controller.signal;
+  }
+  function createBuiltinHttp(forgeInterceptors) {
+    const requestMgr = forgeInterceptors?.request ?? createInterceptorManager();
+    const responseMgr = forgeInterceptors?.response ?? createInterceptorManager();
+    async function request(config) {
+      const finalConfig = await runRequestInterceptors(requestMgr, config);
+      const signal = combineSignals(
+        finalConfig.signal,
+        finalConfig.timeout && finalConfig.timeout > 0 ? AbortSignal.timeout(finalConfig.timeout) : void 0
+      );
+      let url = finalConfig.url;
+      if (finalConfig.paramsSerializer && finalConfig.params) {
+        const qs = finalConfig.paramsSerializer(finalConfig.params);
+        if (qs) {
+          url = url.includes("?") ? `${url}&${qs}` : `${url}?${qs}`;
+        }
+      }
+      const headers = new Headers(finalConfig.headers);
+      const fetchInit = {
+        method: finalConfig.method,
+        headers
+      };
+      if (signal) fetchInit.signal = signal;
+      if (finalConfig.body !== void 0 && !["GET", "HEAD"].includes(finalConfig.method.toUpperCase())) {
+        if (typeof finalConfig.body === "string" || isPassthroughBody(finalConfig.body)) {
+          fetchInit.body = finalConfig.body;
+        } else {
+          fetchInit.body = JSON.stringify(finalConfig.body);
+          if (!headers.has("Content-Type")) {
+            headers.set("Content-Type", "application/json");
+          }
+        }
+      }
+      let res;
+      try {
+        res = await fetch(url, fetchInit);
+      } catch (e) {
+        if (isAbortError(e)) throw e;
+        throw new NetworkError(
+          e instanceof Error ? e.message : String(e),
+          finalConfig.route,
+          finalConfig.level,
+          e
+        );
+      }
+      const text = await res.text();
+      let data = text;
+      const contentType = res.headers.get("content-type") ?? "";
+      if (contentType.includes("application/json")) {
+        try {
+          data = JSON.parse(text);
+        } catch {
+        }
+      }
+      const responseData = {
+        route: finalConfig.route,
+        level: finalConfig.level,
+        method: finalConfig.method,
+        url,
+        status: res.status,
+        headers: res.headers,
+        data,
+        config: finalConfig
+      };
+      const source = res.status >= 200 && res.status < 300 ? Promise.resolve(responseData) : Promise.reject(
+        new HTTPError(
+          `HTTP ${res.status} for route "${finalConfig.route}" (${finalConfig.method} ${url})`,
+          {
+            route: finalConfig.route,
+            level: finalConfig.level,
+            status: res.status,
+            url,
+            method: finalConfig.method
+          }
+        )
+      );
+      return runResponseInterceptors(
+        responseMgr,
+        source
+      );
+    }
+    const get = (url, config) => request({ ...config, url, method: "GET" });
+    const post = (url, config) => request({ ...config, url, method: "POST" });
+    const put = (url, config) => request({ ...config, url, method: "PUT" });
+    const patch = (url, config) => request({ ...config, url, method: "PATCH" });
+    const del = (url, config) => request({ ...config, url, method: "DELETE" });
+    return {
+      request,
+      interceptors: {
+        request: requestMgr,
+        response: responseMgr
+      },
+      runsInterceptors: true,
+      get,
+      post,
+      put,
+      patch,
+      delete: del
+    };
+  }
+
+  // src/adapters/axios.ts
+  function toHeaders(raw) {
+    if (!raw) return new Headers();
+    const init = typeof raw.toJSON === "function" ? raw.toJSON() : raw;
+    try {
+      return new Headers(init);
+    } catch {
+      return new Headers();
+    }
+  }
+  async function wrapAxiosAdapter() {
+    let axios;
+    const axiosModule = "axios";
+    try {
+      const mod = await import(
+        /* @vite-ignore */
+        axiosModule
+      );
+      axios = mod.default ?? mod;
+    } catch {
+      if (typeof globalThis !== "undefined" && globalThis.axios) {
+        axios = globalThis.axios;
+      }
+    }
+    if (!axios || typeof axios.request !== "function") return null;
+    async function request(config) {
+      const headers = { ...config.headers };
+      try {
+        const res = await axios.request({
+          url: config.url,
+          method: config.method,
+          headers,
+          data: config.body,
+          // axios 会处理 baseURL/transformRequest 等 defaults；timeout 透传保证超时语义与 builtin 一致
+          timeout: config.timeout,
+          signal: config.signal
+          // 请求取消信号（AbortSignal）
+        });
+        return {
+          route: config.route,
+          level: config.level,
+          method: config.method,
+          url: config.url,
+          status: res.status,
+          headers: toHeaders(res.headers),
+          data: res.data,
+          config
+        };
+      } catch (e) {
+        if (e && e.response) {
+          const resp = e.response;
+          return {
+            route: config.route,
+            level: config.level,
+            method: config.method,
+            url: config.url,
+            status: resp.status,
+            headers: toHeaders(resp.headers),
+            data: resp.data,
+            config
+          };
+        }
+        throw e;
+      }
+    }
+    return { request, interceptors: void 0 };
+  }
+
+  // src/adapters/index.ts
+  async function resolveAdapter(opts) {
+    const { adapter } = opts;
+    if (adapter && typeof adapter === "object") {
+      return {
+        request: (config) => adapter.request(config),
+        interceptors: adapter.interceptors
+      };
+    }
+    if (adapter === "builtin") {
+      return createBuiltinHttp(opts.forgeInterceptors);
+    }
+    if (adapter === "axios") {
+      const wrapped2 = await wrapAxiosAdapter();
+      if (!wrapped2) throw new AdapterNotFoundError("axios");
+      return wrapped2;
+    }
+    const wrapped = await wrapAxiosAdapter().catch(() => null);
+    if (wrapped) return wrapped;
+    return createBuiltinHttp(opts.forgeInterceptors);
+  }
+
+  // src/loading.ts
+  var LoadingTracker = class {
+    constructor() {
+      /** 当前并发请求计数 */
+      this.count = 0;
+      /** 订阅者集合 */
+      this.subscribers = /* @__PURE__ */ new Set();
+    }
+    /**
+     * 开始一次加载（计数器 +1）
+     */
+    start() {
+      this.count++;
+      this.notify();
+    }
+    /**
+     * 结束一次加载（计数器 -1）
+     */
+    stop() {
+      this.count = Math.max(0, this.count - 1);
+      this.notify();
+    }
+    /**
+     * 查询当前是否处于加载中
+     */
+    isLoading() {
+      return this.count > 0;
+    }
+    /**
+     * 获取当前并发计数
+     */
+    getCount() {
+      return this.count;
+    }
+    /**
+     * 订阅加载状态变更
+     * @returns 取消订阅函数
+     */
+    subscribe(cb) {
+      this.subscribers.add(cb);
+      return () => {
+        this.subscribers.delete(cb);
+      };
+    }
+    /** 通知所有订阅者 */
+    notify() {
+      const event = {
+        loading: this.count > 0,
+        count: this.count
+      };
+      for (const cb of this.subscribers) {
+        try {
+          cb(event);
+        } catch {
+        }
+      }
+    }
+  };
+
+  // src/forge.ts
+  var DEFAULT_TIMEOUT = 3e4;
+  var DEFAULT_CACHE_TTL = 3600;
+  var UNASSIGNED_LEVEL = "unassigned";
+  function createRouteForge(options) {
+    if (!options.endpoint) throw new TypeError("options.endpoint is required");
+    const {
+      adapter = "auto",
+      timeout = DEFAULT_TIMEOUT,
+      baseURL = "",
+      interceptors: declarativeInterceptors,
+      cache: cacheOpts = {}
+    } = options;
+    const loadingTracker = new LoadingTracker();
+    const explicitLevels = options.levels;
+    const explicitEager = options.eager;
+    const explicitStrict = options.strict ?? false;
+    const explicitEndpoint = options.endpoint;
+    let effectiveLevels = explicitLevels ?? [];
+    let effectiveEager = explicitEager ?? [];
+    let effectiveEndpoint = explicitEndpoint;
+    let effectiveUrlPrefix = "";
+    let summaryUnassigned;
+    let backendHasUnassignedLevel = false;
+    const summaryPromise = (async () => {
+      try {
+        const summaryUrl = explicitEndpoint;
+        const resp = await fetch(summaryUrl, { method: "GET" });
+        if (!resp.ok) {
+          console.warn(
+            `[route-forge] summary endpoint ${summaryUrl} unreachable (HTTP ${resp.status}); falling back to explicit options`
+          );
+          return null;
+        }
+        return await resp.json();
+      } catch (e) {
+        if (explicitLevels && explicitLevels.length > 0) {
+          console.warn(
+            `[route-forge] summary endpoint unreachable: ${e.message}; using explicit levels`
+          );
+          return null;
+        }
+        throw new UnknownLevelError("(auto-discovery)");
+      }
+    })();
+    const autoDiscoveryPromise = summaryPromise.then((summary) => {
+      if (summary === null) {
+        return;
+      }
+      const schemaVersion = summary.schemaVersion ?? 1;
+      if (schemaVersion > 1) {
+        console.warn(
+          `[route-forge] backend schemaVersion=${schemaVersion} > client supported 1; some features may be unavailable`
+        );
+      }
+      if (summary.config.endpoint_prefix && summary.config.endpoint_prefix !== explicitEndpoint) {
+        console.warn(
+          `[route-forge] backend endpoint_prefix "${summary.config.endpoint_prefix}" overrides frontend endpoint "${explicitEndpoint}"`
+        );
+        effectiveEndpoint = summary.config.endpoint_prefix;
+      }
+      if (summary.config.url_prefix) {
+        effectiveUrlPrefix = summary.config.url_prefix.endsWith("/") ? summary.config.url_prefix.slice(0, -1) : summary.config.url_prefix;
+      }
+      if (summary.config.strict_mode && !explicitStrict) {
+        console.warn(
+          "[route-forge] backend strict_mode=true overrides frontend strict=false; forcing strict=true"
+        );
+      }
+      const backendLevels = Object.keys(summary.levels);
+      backendHasUnassignedLevel = backendLevels.includes(UNASSIGNED_LEVEL);
+      if (Array.isArray(summary.unassigned) && summary.unassigned.length > 0 && !backendHasUnassignedLevel) {
+        summaryUnassigned = summary.unassigned;
+      }
+      const availableLevels = backendLevels.slice();
+      if (summaryUnassigned && !backendHasUnassignedLevel) {
+        availableLevels.push(UNASSIGNED_LEVEL);
+      }
+      if (explicitLevels && explicitLevels.length > 0) {
+        const intersection = explicitLevels.filter((l) => availableLevels.includes(l));
+        const removed = explicitLevels.filter((l) => !availableLevels.includes(l));
+        if (removed.length > 0) {
+          console.warn(
+            `[route-forge] levels not in backend summary and dropped: ${removed.join(", ")}`
+          );
+        }
+        effectiveLevels = intersection;
+      } else {
+        effectiveLevels = availableLevels;
+      }
+      const backendEager = backendLevels.filter((lvl) => summary.levels[lvl]?.load === "eager");
+      if (!explicitEager) {
+        effectiveEager = backendEager;
+      } else {
+        const union = /* @__PURE__ */ new Set([...backendEager, ...explicitEager]);
+        effectiveEager = [...union];
+      }
+    });
+    let autoDiscoveryError = null;
+    autoDiscoveryPromise.catch((e) => {
+      autoDiscoveryError = e;
+    });
+    let autoDiscoveryCompleted = false;
+    let resolveReady;
+    const readyPromise = new Promise((resolve) => {
+      resolveReady = resolve;
+    });
+    const levelLoadedListeners = /* @__PURE__ */ new Map();
+    const cacheTtl = cacheOpts.ttl ?? DEFAULT_CACHE_TTL;
+    const cacheStorage = cacheOpts.storage ?? "memory";
+    const cache = new RouteCache({ storage: cacheStorage, ttl: cacheTtl });
+    const requestInterceptors = new InterceptorManagerImpl();
+    const responseInterceptors = new InterceptorManagerImpl();
+    if (declarativeInterceptors?.request) {
+      for (const entry of declarativeInterceptors.request) {
+        if (typeof entry === "function") {
+          requestInterceptors.use(entry);
+        } else {
+          const [onFulfilled, onRejected] = entry;
+          requestInterceptors.use(onFulfilled, onRejected);
+        }
+      }
+    }
+    if (declarativeInterceptors?.response) {
+      for (const entry of declarativeInterceptors.response) {
+        if (typeof entry === "function") {
+          responseInterceptors.use(entry);
+        } else {
+          const [onFulfilled, onRejected] = entry;
+          responseInterceptors.use(onFulfilled, onRejected);
+        }
+      }
+    }
+    const adapterPromise = resolveAdapter({
+      adapter,
+      forgeInterceptors: { request: requestInterceptors, response: responseInterceptors }
+    });
+    let adapterResolved = false;
+    let adapterObj = null;
+    async function ensureAdapter() {
+      if (!adapterResolved) {
+        adapterObj = await adapterPromise.catch((e) => {
+          if (e instanceof AdapterNotFoundError) throw e;
+          return resolveAdapter({ adapter: "builtin" });
+        });
+        adapterResolved = true;
+      }
+      return adapterObj;
+    }
+    const inflight = /* @__PURE__ */ new Map();
+    const invalidationGens = /* @__PURE__ */ new Map();
+    function assertLevelDeclared(level) {
+      if (!effectiveLevels.includes(level)) {
+        throw new UnknownLevelError(level);
+      }
+    }
+    function assertDiscoveryReady() {
+      if (!autoDiscoveryCompleted && !explicitLevels?.length) {
+        throw new ForgeError(
+          "Route data not available. Auto-discovery has not completed. Use onSummaryReady callback to mount app, or await forge.ready / forge.load(level) first.",
+          { code: "RF_FE_010" }
+        );
+      }
+    }
+    function buildUrl(level) {
+      const base = baseURL.endsWith("/") ? baseURL.slice(0, -1) : baseURL;
+      const ep = effectiveEndpoint.startsWith("/") ? effectiveEndpoint : `/${effectiveEndpoint}`;
+      return `${base}${ep}/${encodeURIComponent(level)}`;
+    }
+    async function fetchLevel(level) {
+      const adp = await ensureAdapter();
+      const config = {
+        route: `__forge__.load.${level}`,
+        level,
+        method: "GET",
+        url: buildUrl(level),
+        headers: { Accept: "application/json" },
+        params: {},
+        timeout,
+        meta: {
+          name: `__forge__.load.${level}`,
+          uri: buildUrl(level),
+          methods: ["GET"],
+          parameters: [],
+          level
+        }
+      };
+      const resp = await adp.request(config);
+      if (!resp || resp.status < 200 || resp.status >= 300) {
+        throw new HTTPError(
+          `Failed to load level "${level}": HTTP ${resp?.status}`,
+          { level, status: resp?.status, url: buildUrl(level), method: "GET" }
+        );
+      }
+      const data = resp.data;
+      return data;
+    }
+    async function loadOne(level) {
+      if (autoDiscoveryError) throw autoDiscoveryError;
+      assertLevelDeclared(level);
+      if (cache.get(level)) return;
+      const existing = inflight.get(level);
+      if (existing) return existing;
+      const gen = invalidationGens.get(level) ?? 0;
+      const p = (async () => {
+        try {
+          if (level === UNASSIGNED_LEVEL && !backendHasUnassignedLevel && summaryUnassigned) {
+            const routes = {};
+            for (const r of summaryUnassigned) {
+              routes[r.name] = { ...r, level: UNASSIGNED_LEVEL };
+            }
+            cache.set({ level: UNASSIGNED_LEVEL, routes, cache: null });
+            const listeners = levelLoadedListeners.get(level);
+            if (listeners) listeners.forEach((cb) => cb());
+            return;
+          }
+          const resp = await fetchLevel(level);
+          if ((invalidationGens.get(level) ?? 0) === gen) {
+            cache.set(resp);
+            const listeners = levelLoadedListeners.get(level);
+            if (listeners) listeners.forEach((cb) => cb());
+          }
+        } finally {
+          inflight.delete(level);
+        }
+      })();
+      inflight.set(level, p);
+      return p;
+    }
+    async function load(level) {
+      await autoDiscoveryPromise;
+      const list = Array.isArray(level) ? level : [level];
+      await Promise.all(list.map(loadOne));
+    }
+    function route(level, name, params) {
+      assertDiscoveryReady();
+      const meta = findRouteMeta(level, name);
+      if (!meta) {
+        throw new UnknownRouteError(name, level);
+      }
+      return buildRequestUrl(meta, params ?? {});
+    }
+    function buildRequestUrl(meta, params) {
+      const defaults = meta.parameter_defaults ?? {};
+      const missingRequired = [];
+      const values = {};
+      for (const p of meta.parameters) {
+        let v = params[p];
+        if ((v === void 0 || v === null) && p in defaults) {
+          v = defaults[p];
+        }
+        if (v === void 0 || v === null) {
+          if (!meta.uri.includes(`{${p}?}`)) {
+            missingRequired.push(p);
+          }
+        } else {
+          values[p] = v;
+        }
+      }
+      if (missingRequired.length > 0) {
+        throw new MissingRouteParamError(meta.name, missingRequired);
+      }
+      let uri = meta.uri.replace(/\{([^{}]+)\}/g, (match, raw) => {
+        const optional = raw.endsWith("?");
+        const name = optional ? raw.slice(0, -1) : raw;
+        if (values[name] !== void 0) {
+          const val = values[name];
+          if (typeof val === "object") {
+            throw new ForgeError(
+              `Path parameter "${name}" must be a primitive value (string, number, boolean), got ${typeof val}`,
+              { code: "RF_FE_003", route: meta.name, context: { param: name, value: val } }
+            );
+          }
+          return encodeURIComponent(String(val));
+        }
+        return optional ? "" : match;
+      });
+      uri = uri.replace(/\/+/g, "/").replace(/\/$/, "");
+      if (/^[a-zA-Z][a-zA-Z0-9+.-]*:\/\//.test(effectiveUrlPrefix)) {
+        const prefix2 = effectiveUrlPrefix.endsWith("/") ? effectiveUrlPrefix.slice(0, -1) : effectiveUrlPrefix;
+        return uri.startsWith("/") ? `${prefix2}${uri}` : `${prefix2}/${uri}`;
+      }
+      const base = baseURL.endsWith("/") ? baseURL.slice(0, -1) : baseURL;
+      const prefix = effectiveUrlPrefix;
+      return uri.startsWith("/") ? `${base}${prefix}${uri}` : `${base}${prefix}/${uri}`;
+    }
+    function findRouteMeta(level, name) {
+      const entry = cache.get(level);
+      const meta = entry?.routes[name];
+      if (meta) {
+        return { ...meta, level };
+      }
+      return void 0;
+    }
+    async function api(level, name, params = {}) {
+      await autoDiscoveryPromise;
+      await load(level);
+      const meta = findRouteMeta(level, name);
+      if (!meta) {
+        throw new UnknownRouteError(name, level);
+      }
+      return doApiCall(meta, params);
+    }
+    async function doApiCall(meta, params) {
+      const {
+        pathParams,
+        query,
+        body,
+        headers,
+        timeout: perCallTimeout,
+        signal
+      } = resolveApiParams(params);
+      if (signal?.aborted) {
+        throw new RequestAbortedError(meta.name, meta.level, signal.reason);
+      }
+      const method = pickMethod(meta);
+      const urlWithQuery = appendQuery(buildRequestUrl(meta, pathParams), query);
+      const config = {
+        route: meta.name,
+        level: meta.level ?? "",
+        method,
+        url: urlWithQuery,
+        headers: { Accept: "application/json", ...headers ?? {} },
+        body,
+        params: pathParams,
+        timeout: perCallTimeout ?? timeout,
+        signal,
+        meta
+      };
+      const adp = await ensureAdapter();
+      const finalConfig = adp.runsInterceptors ? config : await runRequestInterceptors(requestInterceptors, config);
+      if (finalConfig.signal?.aborted) {
+        throw new RequestAbortedError(meta.name, meta.level, finalConfig.signal.reason);
+      }
+      loadingTracker.start();
+      try {
+        const source = adp.request(finalConfig).then(
+          (resp) => {
+            if (resp.status < 200 || resp.status >= 300) {
+              throw new HTTPError(
+                `HTTP ${resp.status} for route "${resp.route}" (${resp.method} ${resp.url})`,
+                {
+                  route: resp.route,
+                  level: resp.level,
+                  status: resp.status,
+                  url: resp.url,
+                  method: resp.method
+                }
+              );
+            }
+            return resp;
+          },
+          (err) => {
+            if (err instanceof ForgeError) throw err;
+            if (isAbortError2(err, finalConfig.signal)) {
+              throw new RequestAbortedError(meta.name, meta.level, err);
+            }
+            throw new NetworkError(
+              err instanceof Error ? err.message : String(err),
+              meta.name,
+              meta.level,
+              err
+            );
+          }
+        );
+        const result = adp.runsInterceptors ? await source : await runResponseInterceptors(responseInterceptors, source);
+        return result;
+      } finally {
+        loadingTracker.stop();
+      }
+    }
+    function invalidate(level) {
+      if (level === void 0) {
+        cache.clear();
+        inflight.clear();
+        for (const lvl of effectiveLevels) {
+          invalidationGens.set(lvl, (invalidationGens.get(lvl) ?? 0) + 1);
+        }
+      } else if (Array.isArray(level)) {
+        for (const lvl of level) {
+          cache.del(lvl);
+          inflight.delete(lvl);
+          invalidationGens.set(lvl, (invalidationGens.get(lvl) ?? 0) + 1);
+        }
+      } else {
+        cache.del(level);
+        inflight.delete(level);
+        invalidationGens.set(level, (invalidationGens.get(level) ?? 0) + 1);
+      }
+    }
+    function isLoaded(level) {
+      if (level) return cache.get(level) !== void 0;
+      return effectiveLevels.length > 0 && effectiveLevels.every((lvl) => cache.get(lvl) !== void 0);
+    }
+    function hasRoute(level, name) {
+      assertDiscoveryReady();
+      return findRouteMeta(level, name) !== void 0;
+    }
+    function getRoutes(level) {
+      if (level !== void 0) {
+        const entry = cache.get(level);
+        const routes = entry?.routes ?? {};
+        const result2 = {};
+        for (const [k, v] of Object.entries(routes)) {
+          result2[k] = JSON.parse(JSON.stringify(v));
+        }
+        return result2;
+      }
+      const result = {};
+      for (const lvl of effectiveLevels) {
+        const entry = cache.get(lvl);
+        if (entry) {
+          const levelRoutes = {};
+          for (const [k, v] of Object.entries(entry.routes)) {
+            levelRoutes[k] = JSON.parse(JSON.stringify(v));
+          }
+          result[lvl] = levelRoutes;
+        }
+      }
+      return result;
+    }
+    void autoDiscoveryPromise.then(() => {
+      options.onSummaryReady?.();
+      if (effectiveEager.length > 0) {
+        return Promise.all(effectiveEager.map((lvl) => load(lvl))).catch((e) => {
+          console.warn(`[route-forge] eager load failed: ${e.message}`);
+        });
+      }
+    }).then(() => {
+      autoDiscoveryCompleted = true;
+      resolveReady();
+    }).catch(() => {
+    });
+    return {
+      api,
+      load,
+      route,
+      url: route,
+      invalidate,
+      isLoaded,
+      hasRoute,
+      getRoutes,
+      isLoading: () => loadingTracker.isLoading(),
+      onLoadingChange: (cb) => loadingTracker.subscribe(cb),
+      interceptors: {
+        request: requestInterceptors,
+        response: responseInterceptors
+      },
+      ready: readyPromise,
+      onLevelLoaded(level, cb) {
+        if (!levelLoadedListeners.has(level)) {
+          levelLoadedListeners.set(level, /* @__PURE__ */ new Set());
+        }
+        levelLoadedListeners.get(level).add(cb);
+        return () => levelLoadedListeners.get(level)?.delete(cb);
+      }
+    };
+  }
+  function pickMethod(meta) {
+    const m = meta.methods.find((x) => x.toUpperCase() !== "HEAD");
+    return (m ?? meta.methods[0] ?? "GET").toUpperCase();
+  }
+  function appendQuery(url, query) {
+    if (!query) return url;
+    const usp = new URLSearchParams();
+    for (const [k, v] of Object.entries(query)) {
+      if (v === void 0 || v === null) continue;
+      usp.append(k, String(v));
+    }
+    const qs = usp.toString();
+    if (!qs) return url;
+    return url.includes("?") ? `${url}&${qs}` : `${url}?${qs}`;
+  }
+  function resolveApiParams(input) {
+    const {
+      params: explicitParams,
+      query: rawQuery,
+      body: rawBody,
+      headers: rawHeaders,
+      timeout: perCallTimeout,
+      signal,
+      ...flatRest
+    } = input;
+    const pathParams = explicitParams ? { ...explicitParams } : {};
+    for (const [k, v] of Object.entries(flatRest)) {
+      if (!(k in pathParams)) {
+        pathParams[k] = v;
+      }
+    }
+    let query;
+    let body;
+    let headers;
+    if (rawQuery !== void 0) {
+      if (typeof rawQuery === "object" && rawQuery !== null) {
+        query = rawQuery;
+      } else if (!("query" in pathParams)) {
+        pathParams.query = rawQuery;
+      }
+    }
+    if (rawBody !== void 0) {
+      if (typeof rawBody !== "string" && typeof rawBody !== "number") {
+        body = rawBody;
+      } else if (!("body" in pathParams)) {
+        pathParams.body = rawBody;
+      }
+    }
+    if (rawHeaders !== void 0) {
+      if (typeof rawHeaders === "object" && rawHeaders !== null) {
+        headers = rawHeaders;
+      } else if (!("headers" in pathParams)) {
+        pathParams.headers = rawHeaders;
+      }
+    }
+    return { pathParams, query, body, headers, timeout: perCallTimeout, signal };
+  }
+  function isAbortError2(err, signal) {
+    if (signal?.aborted) return true;
+    const e = err;
+    if (!e) return false;
+    if (e.name === "AbortError") return true;
+    if (e.code === "ERR_CANCELED") return true;
+    return false;
+  }
+
+  // src/resolveRouteName.ts
+  async function resolveRouteName(forge, level, prefix, suffix, separator = ".") {
+    if (!suffix) return prefix;
+    const joined = `${prefix}${separator}${suffix}`;
+    if (!suffix.startsWith(`${prefix}${separator}`)) return joined;
+    await forge.load(level);
+    if (forge.hasRoute(level, joined)) return joined;
+    if (forge.hasRoute(level, suffix)) return suffix;
+    throw new UnknownRouteError(joined, level);
+  }
+  function resolveRouteNameSync(forge, level, prefix, suffix, separator = ".") {
+    if (!suffix) return prefix;
+    const joined = `${prefix}${separator}${suffix}`;
+    if (!suffix.startsWith(`${prefix}${separator}`)) return joined;
+    if (forge.hasRoute(level, joined)) return joined;
+    if (forge.hasRoute(level, suffix)) return suffix;
+    throw new UnknownRouteError(joined, level);
+  }
+
+  exports.AdapterNotFoundError = AdapterNotFoundError;
+  exports.ForgeError = ForgeError;
+  exports.HTTPError = HTTPError;
+  exports.InterceptorManagerImpl = InterceptorManagerImpl;
+  exports.InvalidInterceptorReturnError = InvalidInterceptorReturnError;
+  exports.LoadingTracker = LoadingTracker;
+  exports.MissingRouteParamError = MissingRouteParamError;
+  exports.NetworkError = NetworkError;
+  exports.RequestAbortedError = RequestAbortedError;
+  exports.RouteCache = RouteCache;
+  exports.UnknownLevelError = UnknownLevelError;
+  exports.UnknownRouteError = UnknownRouteError;
+  exports.createInterceptorManager = createInterceptorManager;
+  exports.createRouteForge = createRouteForge;
+  exports.resolveRouteName = resolveRouteName;
+  exports.resolveRouteNameSync = resolveRouteNameSync;
+
+  return exports;
+
+})({});
+//# sourceMappingURL=route-forge.global.js.map
+//# sourceMappingURL=route-forge.global.js.map