@jeffusion/bungee-core 5.10.0 → 5.12.0

package/dist/plugins/token-stats/control.js

@@ -1,4 +1,24 @@
 // @bun
+// plugins/models-dev/contract.ts
+var MODELS_DEV_SOURCE_URL = "https://models.dev/api.json";
+var MODELS_DEV_CATALOG_SERVICE_ID = "models-dev.catalog.v1";
+var MODELS_DEV_CATALOG_CONTRACT_VERSION = 1;
+var MODELS_DEV_CATALOG_SNAPSHOT_ID = "models-dev.catalog.snapshot.v1";
+var MODELS_DEV_CATALOG_SNAPSHOT_CONTRACT_VERSION = 1;
+var MODELS_DEV_CATALOG_SNAPSHOT_SCHEMA = Object.freeze({
+  type: "object",
+  properties: {
+    version: { type: "number", integer: true, minimum: 1 },
+    fetchedAt: { type: "number", minimum: 0 },
+    catalog: { type: "json", maxBytes: 32 * 1024 * 1024 }
+  }
+});
+var MODELS_DEV_CATALOG_SNAPSHOT_CONTRACT = Object.freeze({
+  id: MODELS_DEV_CATALOG_SNAPSHOT_ID,
+  version: MODELS_DEV_CATALOG_SNAPSHOT_CONTRACT_VERSION,
+  content: MODELS_DEV_CATALOG_SNAPSHOT_SCHEMA
+});
+
 // packages/core/src/token-stats-window.ts
 var HOUR = 3600000;
 var TOKEN_STATS_RETENTION_MS = 31 * 24 * HOUR;
@@ -259,6 +279,41 @@ function withReportingWriteTimeout(db, operation) {
   }
 }
 
+// plugins/token-stats/server/model-mappings.ts
+var PRICE_MODEL_MAPPINGS_KEY = "pricing:model-mappings:v1";
+var MAX_PRICE_MODEL_MAPPINGS = 100;
+async function readPriceModelMappings(storage) {
+  if (!storage.observation)
+    return parsePriceModelMappings(await storage.get(PRICE_MODEL_MAPPINGS_KEY) ?? []);
+  return storage.observation.withDatabase((db) => {
+    const row = db.query("SELECT value, ttl FROM plugin_storage WHERE plugin_name = ? AND key = ?").get("token-stats", PRICE_MODEL_MAPPINGS_KEY);
+    if (!row || row.ttl !== null && row.ttl < Math.floor(Date.now() / 1000))
+      return [];
+    return parsePriceModelMappings(JSON.parse(row.value));
+  });
+}
+function isUnchangedPriceModelMapping(mapping, existing) {
+  return existing.some((item) => item.source === mapping.source && item.provider === mapping.provider && item.model === mapping.model);
+}
+function parsePriceModelMappings(value) {
+  if (!Array.isArray(value) || value.length > MAX_PRICE_MODEL_MAPPINGS)
+    throw new Error("invalid_input");
+  const sources = new Set;
+  return value.map((item) => {
+    if (!item || typeof item !== "object" || Array.isArray(item) || Object.keys(item).some((key) => !["source", "provider", "model"].includes(key)))
+      throw new Error("invalid_input");
+    const { source, provider, model } = item;
+    for (const [text, limit] of [[source, 256], [provider, 128], [model, 256]]) {
+      if (typeof text !== "string" || !text.trim() || text !== text.trim() || text.length > limit || /[\u0000-\u001f\u007f]/.test(text))
+        throw new Error("invalid_input");
+    }
+    if (sources.has(source))
+      throw new Error("invalid_input");
+    sources.add(source);
+    return { source, provider, model };
+  });
+}
+
 // plugins/token-stats/server/repository.ts
 var TOKEN_ACCOUNTING_AUTHORITIES = ["official", "local", "heuristic", "partial", "none"];
 
@@ -271,6 +326,9 @@ class TokenStatsRepositoryError extends Error {
 
 class TokenStatsRepositoryLimitError extends TokenStatsRepositoryError {
 }
+var MAX_CLIENT_MODEL_PAGE_SIZE = 100;
+var MAX_CLIENT_MODEL_PAGE = 400;
+var CLIENT_MODEL_KEYWORD_MAX = 256;
 var REPORTING_INCOMPLETE_KEY = "reporting:incomplete";
 var MAX_PENDING_ATTEMPTS = 256;
 var LOG_INTERVAL_MS = 60000;
@@ -410,296 +468,40 @@ class TokenStatsRepository {
       })).sort(groupBy === "model" ? (a, b) => b.inputTokens + b.outputTokens - a.inputTokens - a.outputTokens || b.upstreamAttempts - a.upstreamAttempts || a.dimension.localeCompare(b.dimension) : (a, b) => a.bucketStartMs - b.bucketStartMs || a.dimension.localeCompare(b.dimension))
     };
   }
-}
-
-// node_modules/@tokenlens/fetch/dist/index.js
-class FetchModelsError extends Error {
-  code;
-  status;
-  constructor(opts) {
-    super(opts.message);
-    this.name = "FetchModelsError";
-    this.code = opts.code;
-    this.status = opts.status;
-  }
-}
-async function fetchModels(opts = {}) {
-  if (typeof opts === "string") {
-    return fetchModels({ provider: opts });
-  }
-  const url = opts.baseUrl ?? "https://models.dev/api.json";
-  const fetchImpl = opts.fetch ?? globalThis.fetch;
-  if (typeof fetchImpl !== "function") {
-    throw new FetchModelsError({
-      code: "UNAVAILABLE",
-      message: "No fetch implementation found. Pass a custom `fetch` in options or run on a platform with global fetch (Node 18+, modern browsers)."
-    });
-  }
-  let res;
-  try {
-    res = await fetchImpl(url, opts.signal ? { signal: opts.signal } : undefined);
-  } catch (err) {
-    const message = err instanceof Error ? err.message : "Unknown network error";
-    throw new FetchModelsError({ code: "NETWORK", message });
-  }
-  if (!res.ok) {
-    let body = "";
-    try {
-      body = await res.text();
-    } catch {}
-    const snippet = body ? ` Body: ${body.slice(0, 256)}${body.length > 256 ? "\u2026" : ""}` : "";
-    throw new FetchModelsError({
-      code: "HTTP",
-      status: res.status,
-      message: `Failed to fetch models.dev API (${res.status} ${res.statusText}).${snippet}`
-    });
-  }
-  let data;
-  try {
-    data = await res.json();
-  } catch (err) {
-    const message = err instanceof Error ? err.message : "Invalid JSON";
-    throw new FetchModelsError({ code: "PARSE", message });
-  }
-  const catalog = data;
-  const { provider, model } = opts;
-  if (!provider && !model)
-    return catalog;
-  if (provider && !model)
-    return catalog[provider];
-  if (provider && model)
-    return catalog[provider]?.models?.[model];
-  const matches = [];
-  if (!model)
-    return matches;
-  for (const [provKey, prov] of Object.entries(catalog)) {
-    const m = prov?.models?.[model];
-    if (m)
-      matches.push({ provider: provKey, model: m });
-  }
-  return matches;
-}
-
-// plugins/token-stats/server/price-catalog.ts
-var PRICE_SETTINGS_KEY = "pricing:settings:v1";
-var PRICE_CACHE_KEY = "pricing:catalog:v1";
-var PRICE_STATUS_KEY = "pricing:status:v1";
-var PRICE_SOURCE = "https://models.dev/api.json";
-var DEFAULT_PRICE_SETTINGS = { autoRefresh: true, intervalMinutes: 60, timeoutSeconds: 15 };
-function parsePriceSettings(value) {
-  if (!value || typeof value !== "object" || Array.isArray(value))
-    throw new Error("invalid_input");
-  const v = value;
-  if (Object.keys(v).some((key) => !["autoRefresh", "intervalMinutes", "timeoutSeconds"].includes(key)) || typeof v.autoRefresh !== "boolean" || !Number.isInteger(v.intervalMinutes) || v.intervalMinutes < 1 || v.intervalMinutes > 1440 || !Number.isInteger(v.timeoutSeconds) || v.timeoutSeconds < 5 || v.timeoutSeconds > 60) {
-    throw new Error("invalid_input");
-  }
-  return { autoRefresh: v.autoRefresh, intervalMinutes: v.intervalMinutes, timeoutSeconds: v.timeoutSeconds };
-}
-function pricedCatalog(value) {
-  if (!value || typeof value !== "object")
-    throw new Error("invalid_catalog");
-  const input = value;
-  const output = {};
-  let count = 0;
-  for (const id of ["openai", "anthropic", "google", "xai"]) {
-    const provider = input[id];
-    if (!provider?.models || typeof provider.models !== "object")
-      continue;
-    const models = {};
-    for (const [modelId, model] of Object.entries(provider.models)) {
-      const cost = model?.cost;
-      if (!cost || typeof cost.input !== "number" || !Number.isFinite(cost.input) || cost.input < 0 || typeof cost.output !== "number" || !Number.isFinite(cost.output) || cost.output < 0)
-        continue;
-      if (++count > 1e4)
-        throw new Error("invalid_catalog");
-      Object.defineProperty(models, modelId, { value: { id: modelId, name: model.name, cost }, enumerable: true });
-    }
-    if (Object.keys(models).length)
-      output[id] = { id, name: provider.name, models };
-  }
-  if (!count)
-    throw new Error("invalid_catalog");
-  return output;
-}
-
-class PriceCatalogManager {
-  storage;
-  options;
-  state = {
-    settings: { ...DEFAULT_PRICE_SETTINGS },
-    source: PRICE_SOURCE,
-    refreshing: false,
-    lastAttemptAt: null,
-    lastSuccessAt: null,
-    nextRefreshAt: null,
-    lastError: null,
-    consecutiveFailures: 0,
-    modelCount: 0,
-    providerCount: 0
-  };
-  timer;
-  controller;
-  inFlight;
-  initialization;
-  stopped = false;
-  now;
-  constructor(storage, options = {}) {
-    this.storage = storage;
-    this.options = options;
-    this.now = options.now ?? Date.now;
-  }
-  async start() {
-    await (this.initialization ??= this.restore());
-  }
-  status() {
-    return structuredClone(this.state);
-  }
-  async restore() {
-    const settings = await this.storage.get(PRICE_SETTINGS_KEY);
-    if (settings !== null) {
-      try {
-        this.state.settings = parsePriceSettings(settings);
-      } catch {}
-    }
-    const previous = await this.storage.get(PRICE_STATUS_KEY);
-    if (previous) {
-      if (typeof previous.lastAttemptAt === "number" && Number.isFinite(previous.lastAttemptAt))
-        this.state.lastAttemptAt = previous.lastAttemptAt;
-      if (["timeout", "network", "invalid_catalog", "storage"].includes(previous.lastError))
-        this.state.lastError = previous.lastError;
-      if (Number.isSafeInteger(previous.consecutiveFailures) && previous.consecutiveFailures >= 0)
-        this.state.consecutiveFailures = previous.consecutiveFailures;
-    }
-    const cache = await this.storage.get(PRICE_CACHE_KEY);
-    if (cache?.version === 1 && Number.isFinite(cache.fetchedAt)) {
-      try {
-        const catalog = pricedCatalog(cache.catalog);
-        this.state.lastSuccessAt = cache.fetchedAt;
-        this.count(catalog);
-      } catch {
-        this.state.lastError = "invalid_catalog";
-      }
+  async listClientModels(input = {}) {
+    const pageSize = Math.max(1, Math.min(MAX_CLIENT_MODEL_PAGE_SIZE, Math.trunc(input.pageSize ?? 50)));
+    const page = Math.max(1, Math.trunc(input.page ?? 1));
+    if (!Number.isSafeInteger(page) || page > MAX_CLIENT_MODEL_PAGE)
+      throw new TokenStatsRepositoryError("invalid token-stats page");
+    const keyword = input.keyword;
+    if (keyword !== undefined && (typeof keyword !== "string" || keyword.length > CLIENT_MODEL_KEYWORD_MAX)) {
+      throw new TokenStatsRepositoryError("invalid token-stats keyword");
     }
-    if (this.stopped)
-      return;
-    this.schedule();
-    await this.persist();
-  }
-  async configure(settings) {
-    await this.start();
-    if (this.stopped)
-      throw new Error("disposed");
-    const parsed = parsePriceSettings(settings);
-    await this.storage.set(PRICE_SETTINGS_KEY, parsed);
-    this.state.settings = parsed;
-    this.schedule();
-    await this.persist();
-    return this.status();
-  }
-  refresh() {
-    if (this.stopped)
-      return Promise.resolve();
-    if (this.inFlight)
-      return this.inFlight;
-    this.clearTimer();
-    this.state.nextRefreshAt = null;
-    this.state.refreshing = true;
-    this.state.lastAttemptAt = this.now();
-    const task = this.load().finally(() => {
-      if (this.inFlight === task)
-        this.inFlight = undefined;
+    const observation = this.storage.observation;
+    if (observation === undefined)
+      throw new TokenStatsRepositoryError("token-stats observation storage is required");
+    const since = Date.now() - TOKEN_STATS_RETENTION_MS;
+    const hasKeyword = keyword !== undefined && keyword.length > 0;
+    const escaped = hasKeyword ? keyword.replace(/[\\%_]/g, (character) => `\\${character}`) : null;
+    return observation.withDatabase((db) => {
+      const countSql = hasKeyword ? "SELECT COUNT(DISTINCT model) AS total FROM token_stats_attempts WHERE finished_at_ms >= ? AND model LIKE ? ESCAPE '\\'" : "SELECT COUNT(DISTINCT model) AS total FROM token_stats_attempts WHERE finished_at_ms >= ?";
+      const totalRow = db.query(countSql).get(...hasKeyword ? [since, `%${escaped}%`] : [since]);
+      const total = Number(totalRow?.total ?? 0);
+      const pageSql = hasKeyword ? "SELECT DISTINCT model FROM token_stats_attempts WHERE finished_at_ms >= ? AND model LIKE ? ESCAPE '\\' ORDER BY model ASC LIMIT ? OFFSET ?" : "SELECT DISTINCT model FROM token_stats_attempts WHERE finished_at_ms >= ? ORDER BY model ASC LIMIT ? OFFSET ?";
+      const rows = db.query(pageSql).all(...hasKeyword ? [since, `%${escaped}%`, pageSize, (page - 1) * pageSize] : [since, pageSize, (page - 1) * pageSize]);
+      return {
+        models: rows.map((row) => String(row.model)),
+        total: Number.isSafeInteger(total) && total >= 0 ? total : 0,
+        page,
+        pageSize
+      };
     });
-    this.inFlight = task;
-    return task;
-  }
-  stop() {
-    this.stopped = true;
-    this.clearTimer();
-    this.controller?.abort();
   }
-  count(catalog) {
-    this.state.providerCount = Object.keys(catalog).length;
-    this.state.modelCount = Object.values(catalog).reduce((total, provider) => total + Object.keys(provider.models).length, 0);
+  async mappings() {
+    return readPriceModelMappings(this.storage);
   }
-  async load() {
-    const controller = new AbortController;
-    this.controller = controller;
-    let timeout;
-    let onAbort;
-    let timedOut = false;
-    let phase = "storage";
-    try {
-      await this.persist();
-      if (this.stopped)
-        return;
-      phase = "network";
-      const failure = new Promise((_, reject) => {
-        onAbort = () => reject(new Error("aborted"));
-        controller.signal.addEventListener("abort", onAbort, { once: true });
-        timeout = setTimeout(() => {
-          timedOut = true;
-          controller.abort();
-        }, this.state.settings.timeoutSeconds * 1000);
-      });
-      const fetched = await Promise.race([
-        fetchModels({ ...this.options.fetch ? { fetch: this.options.fetch } : {}, signal: controller.signal }),
-        failure
-      ]);
-      if (this.stopped)
-        return;
-      phase = "invalid_catalog";
-      const catalog = pricedCatalog(fetched);
-      const fetchedAt = Math.max(this.now(), (this.state.lastSuccessAt ?? -1) + 1);
-      phase = "storage";
-      await this.storage.set(PRICE_CACHE_KEY, { version: 1, fetchedAt, catalog });
-      if (this.stopped)
-        return;
-      this.state.lastSuccessAt = fetchedAt;
-      this.count(catalog);
-      this.state.lastError = null;
-      this.state.consecutiveFailures = 0;
-    } catch {
-      if (this.stopped)
-        return;
-      this.state.lastError = timedOut ? "timeout" : phase;
-      this.state.consecutiveFailures++;
-    } finally {
-      if (timeout !== undefined)
-        clearTimeout(timeout);
-      if (onAbort)
-        controller.signal.removeEventListener("abort", onAbort);
-      if (this.controller === controller)
-        this.controller = undefined;
-      this.state.refreshing = false;
-      if (!this.stopped) {
-        this.schedule();
-        try {
-          await this.persist();
-        } catch {
-          this.state.lastError = "storage";
-        }
-      }
-    }
-  }
-  clearTimer() {
-    if (this.timer !== undefined)
-      (this.options.cancel ?? clearTimeout)(this.timer);
-    this.timer = undefined;
-  }
-  schedule() {
-    this.clearTimer();
-    this.state.nextRefreshAt = null;
-    if (this.stopped || this.state.refreshing || !this.state.settings.autoRefresh)
-      return;
-    const interval = this.state.settings.intervalMinutes * 60000;
-    const due = this.state.consecutiveFailures ? this.now() + Math.min(interval, 60000 * Math.min(15, 2 ** Math.min(this.state.consecutiveFailures - 1, 4))) : this.state.lastSuccessAt === null ? this.now() : Math.max(this.now(), this.state.lastSuccessAt + interval);
-    this.state.nextRefreshAt = due;
-    this.timer = (this.options.schedule ?? setTimeout)(() => {
-      this.refresh();
-    }, Math.max(0, due - this.now()));
-  }
-  persist() {
-    return this.storage.set(PRICE_STATUS_KEY, this.status());
+  async configureMappings(mappings) {
+    await this.storage.set(PRICE_MODEL_MAPPINGS_KEY, mappings);
   }
 }
 
@@ -731,22 +533,22 @@ function jsonResponse(value, status = 200, maxBytes = MAX_RESPONSE_BYTES) {
 }
 function errorResponse(error) {
   const code = error instanceof ControlError ? error.code : error instanceof TokenStatsRepositoryLimitError ? "response_limit" : error instanceof TokenStatsRepositoryError ? "invalid_persisted_value" : "internal_error";
-  const status = code === "request_cancelled" || code === "invalid_input" ? 400 : code === "disposed" ? 409 : 500;
+  const status = code === "request_cancelled" || code === "invalid_input" ? 400 : code === "disposed" ? 409 : code === "catalog_unavailable" || code === "storage_unavailable" ? 503 : 500;
   return jsonResponse({ error: code }, status);
 }
-async function readSettings(request) {
+async function readSettings(request, maxBytes = 4096) {
   const reader = request.body?.getReader();
   if (!reader)
     throw new ControlError("invalid_input");
   const chunks = [];
   let size = 0;
   try {
-    while (true) {
+    for (;; ) {
       const { done, value } = await reader.read();
       if (done)
         break;
       size += value.byteLength;
-      if (size > 4096) {
+      if (size > maxBytes) {
         await reader.cancel();
         throw new ControlError("invalid_input");
       }
@@ -805,19 +607,30 @@ function abortable(promise, requestSignal, hostSignal) {
     });
   });
 }
+function parseModelQuery(request) {
+  const params = new URL(request.url).searchParams;
+  for (const key of ["provider", "search", "page", "pageSize"])
+    if (params.getAll(key).length > 1)
+      return null;
+  const provider = params.get("provider") ?? undefined;
+  const search = params.get("search") ?? undefined;
+  const page = params.get("page") === null ? 1 : Number(params.get("page"));
+  const pageSize = params.get("pageSize") === null ? 50 : Number(params.get("pageSize"));
+  if (!Number.isSafeInteger(page) || page < 1 || !Number.isSafeInteger(pageSize) || pageSize < 1 || pageSize > MAX_CLIENT_MODEL_PAGE_SIZE)
+    return null;
+  return { ...provider === undefined ? {} : { provider }, ...search === undefined ? {} : { search }, page, pageSize };
+}
 
 class TokenStatsControl {
   host;
   api;
   rpc = [];
   repository;
-  pricing;
   disposed = false;
   abortListener;
-  constructor(host, options) {
+  constructor(host) {
     this.host = host;
     this.repository = new TokenStatsRepository(host.storage);
-    this.pricing = new PriceCatalogManager(host.storage.uncached?.() ?? host.storage, options);
     this.abortListener = () => {
       this.dispose();
     };
@@ -833,6 +646,16 @@ class TokenStatsControl {
     if (signal?.aborted)
       throw new ControlError("request_cancelled");
   }
+  catalogService() {
+    const services = this.host.services;
+    if (services === undefined)
+      throw new ControlError("catalog_unavailable");
+    try {
+      return services.consume("models-dev", MODELS_DEV_CATALOG_SERVICE_ID, MODELS_DEV_CATALOG_CONTRACT_VERSION);
+    } catch {
+      throw new ControlError("catalog_unavailable");
+    }
+  }
   buildApi() {
     const invoke = (handler) => async (context) => {
       try {
@@ -883,48 +706,87 @@ class TokenStatsControl {
       methods: ["GET"],
       handler: "getPricing",
       invoke: invoke(async () => {
-        await this.pricing.start();
-        return jsonResponse(this.pricing.status());
+        const status = this.catalogService().status();
+        return jsonResponse({ ...status, source: MODELS_DEV_SOURCE_URL });
+      })
+    }, {
+      path: "/pricing/models",
+      methods: ["GET"],
+      handler: "getPricingModels",
+      invoke: invoke(async (context) => {
+        const query = parseModelQuery(context.request);
+        if (query === null)
+          return jsonResponse({ error: "invalid_input" }, 400);
+        const result = this.catalogService().modelOptions(query);
+        const models = result.models.map((model) => ({
+          provider: model.provider,
+          providerName: model.providerName,
+          model: model.model,
+          name: model.name
+        }));
+        return jsonResponse({ models, total: result.total, page: result.page, pageSize: result.pageSize }, 200, MAX_PAGE_STATS_RESPONSE_BYTES);
       })
     }, {
-      path: "/pricing/settings",
+      path: "/pricing/mappings",
+      methods: ["GET"],
+      handler: "getPricingMappings",
+      invoke: invoke(async () => jsonResponse({ mappings: await this.repository.mappings() }))
+    }, {
+      path: "/pricing/mappings",
       methods: ["PUT"],
-      handler: "configurePricing",
+      handler: "configurePricingMappings",
       invoke: invoke(async (context) => {
-        let settings;
+        let mappings;
         try {
-          settings = parsePriceSettings(await readSettings(context.request));
+          mappings = parsePriceModelMappings(await readSettings(context.request, MAX_RESPONSE_BYTES));
         } catch {
           throw new ControlError("invalid_input");
         }
+        const service = this.catalogService();
+        const existing = await this.repository.mappings();
+        if (mappings.some((mapping) => service.resolveModel({ model: mapping.model, pricingProvider: mapping.provider }) === null && !isUnchangedPriceModelMapping(mapping, existing)))
+          throw new ControlError("invalid_input");
         this.assertAlive(context.requestSignal);
-        return jsonResponse(await this.pricing.configure(settings));
+        await this.repository.configureMappings(mappings);
+        return jsonResponse({ mappings });
       })
     }, {
-      path: "/pricing/refresh",
-      methods: ["POST"],
-      handler: "refreshPricing",
-      invoke: invoke(async () => {
-        await this.pricing.start();
-        this.pricing.refresh();
-        return jsonResponse(this.pricing.status(), 202);
+      path: "/models",
+      methods: ["GET"],
+      handler: "getClientModels",
+      invoke: invoke(async (context) => {
+        const query = parseModelQuery(context.request);
+        if (query === null)
+          return jsonResponse({ error: "invalid_input" }, 400);
+        let page;
+        try {
+          page = await this.repository.listClientModels({
+            ...query.search === undefined ? {} : { keyword: query.search },
+            page: query.page,
+            pageSize: query.pageSize
+          });
+        } catch (error) {
+          if (error instanceof TokenStatsRepositoryError)
+            throw new ControlError("storage_unavailable");
+          throw error;
+        }
+        this.assertAlive(context.requestSignal);
+        return jsonResponse(page);
       })
     }];
   }
   async start() {
     this.assertAlive();
-    await this.pricing.start();
   }
   dispose() {
     if (this.disposed)
       return;
     this.disposed = true;
-    this.pricing.stop();
     this.host.signal.removeEventListener("abort", this.abortListener);
   }
 }
-function createControl(context, options) {
-  return new TokenStatsControl(context, options);
+function createControl(context) {
+  return new TokenStatsControl(context);
 }
 var control_default = { createControl };
 export {
@@ -932,4 +794,4 @@ export {
   control_default as default
 };
 
-//# debugId=A06BDE7344854B3164756E2164756E21
+//# debugId=9E6A0268F9DCEF3464756E2164756E21