@hashgraphonline/standards-sdk 0.1.189 → 0.1.191

package/dist/es/standards-sdk.es138.js

@@ -1,5 +1,1333 @@
-const sleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
+import { readString, readSubjectAdditional, isJsonObject } from "./standards-sdk.es201.js";
+import "./standards-sdk.es184.js";
+import "./standards-sdk.es198.js";
+import "./standards-sdk.es199.js";
+import "./standards-sdk.es200.js";
+import "./standards-sdk.es183.js";
+import { stripTrailingSlashes, requestJson, requestText, Hcs25CollectorHttpError, isTimeoutError } from "./standards-sdk.es122.js";
+const HF_API_BASE = "https://huggingface.co/api";
+const HF_DATASETS_BASE = "https://huggingface.co/datasets";
+const OPENROUTER_API_BASE = "https://openrouter.ai/api/v1";
+const OPENROUTER_FRONTEND_BASE = "https://openrouter.ai/api/frontend";
+const OPENLM_ARENA_URL = "https://openlm.ai/chatbot-arena/";
+const OPENLLM_DATASET_ID = "open-llm-leaderboard/results";
+const OPENLLM_DATASET_BRANCH = "main";
+const DEFAULT_MODEL_REGISTRIES = ["openrouter", "near-ai"];
+const OPENROUTER_CATEGORY_SOURCE = "openrouter:category-rankings";
+const HUGGINGFACE_MODEL_INDEX_SOURCE = "huggingface:model-index";
+const HUGGINGFACE_POPULARITY_SOURCE = "huggingface:popularity";
+const CHATBOT_ARENA_SOURCE = "chatbot-arena:leaderboard";
+const OPENLLM_EVAL_SOURCES = ["openllm-leaderboard"];
+const MODEL_ID_KEYS = [
+  "openrouterModelId",
+  "huggingFaceModelId",
+  "openrouterHuggingFaceId",
+  "modelId",
+  "model",
+  "name"
+];
+function resolveModelId(subject) {
+  const additional = readSubjectAdditional(subject);
+  for (const key of MODEL_ID_KEYS) {
+    const value = readString(additional, key);
+    if (value) {
+      return value;
+    }
+  }
+  const metadata = subject.metadata ?? {};
+  for (const key of MODEL_ID_KEYS) {
+    const value = readString(metadata, key);
+    if (value) {
+      return value;
+    }
+  }
+  return subject.id || null;
+}
+function modelIdMatches(candidate, wanted) {
+  const a = candidate.trim().toLowerCase();
+  const b = wanted.trim().toLowerCase();
+  if (a === b) {
+    return true;
+  }
+  const stripOrg = (id) => id.includes("/") ? id.slice(id.lastIndexOf("/") + 1) : id;
+  return stripOrg(a) === stripOrg(b);
+}
+function statusFromError(error) {
+  return isTimeoutError(error) ? "timeout" : "error";
+}
+function asRecord(value) {
+  return isJsonObject(value) ? value : void 0;
+}
+function parseNumber(value) {
+  if (typeof value === "number" && Number.isFinite(value)) {
+    return value;
+  }
+  if (typeof value === "string" && value.trim()) {
+    const parsed = Number(value.trim());
+    return Number.isFinite(parsed) ? parsed : null;
+  }
+  return null;
+}
+const encodeModelIdForPath = (modelId) => modelId.split("/").map((segment) => encodeURIComponent(segment)).join("/");
+const METRIC_EXCLUDE_TOKENS = [
+  "loss",
+  "perplexity",
+  "ppl",
+  "error",
+  "rmse",
+  "mae",
+  "wer",
+  "cer",
+  "bits"
+];
+const METRIC_INCLUDE_TOKENS = [
+  "accuracy",
+  "acc",
+  "exact",
+  "em",
+  "f1",
+  "precision",
+  "recall",
+  "score",
+  "pass",
+  "win",
+  "bleu",
+  "rouge",
+  "mmlu",
+  "gsm",
+  "arc",
+  "hellaswag",
+  "truthfulqa",
+  "gpqa",
+  "humaneval",
+  "mbpp",
+  "swe",
+  "math",
+  "bbh",
+  "ceval"
+];
+const hasToken = (input, tokens) => tokens.some((token) => input.includes(token));
+function shouldIncludeMetric(name) {
+  const normalized = name.trim().toLowerCase();
+  if (!normalized) {
+    return false;
+  }
+  if (hasToken(normalized, METRIC_EXCLUDE_TOKENS)) {
+    return false;
+  }
+  return hasToken(normalized, METRIC_INCLUDE_TOKENS);
+}
+function normalizeMetricValue(raw) {
+  if (!Number.isFinite(raw)) {
+    return null;
+  }
+  if (raw <= 1) {
+    return Math.min(100, Math.max(0, raw * 100));
+  }
+  if (raw <= 100) {
+    return Math.min(100, Math.max(0, raw));
+  }
+  return null;
+}
+function normalizeLogScore(value, max) {
+  if (!Number.isFinite(value) || value <= 0 || !Number.isFinite(max) || max <= 0) {
+    return null;
+  }
+  const numerator = Math.log10(value + 1);
+  const denominator = Math.log10(max + 1);
+  if (!Number.isFinite(numerator) || !Number.isFinite(denominator) || denominator <= 0) {
+    return null;
+  }
+  return Math.min(100, Math.max(0, numerator / denominator * 100));
+}
+function computePopularityScore(downloads, likes, downloadsCap = 1e7, likesCap = 1e5) {
+  const downloadsScore = downloads !== null ? normalizeLogScore(downloads, downloadsCap) : null;
+  const likesScore = likes !== null ? normalizeLogScore(likes, likesCap) : null;
+  if (downloadsScore === null) {
+    return likesScore;
+  }
+  if (likesScore === null) {
+    return downloadsScore;
+  }
+  return downloadsScore * 0.7 + likesScore * 0.3;
+}
+function extractModelIndexMetrics(payload, maxMetrics = 60) {
+  const modelIndex = payload?.["model-index"] ?? payload?.model_index ?? payload?.modelIndex ?? payload?.cardData?.["model-index"];
+  if (!Array.isArray(modelIndex)) {
+    return [];
+  }
+  const metrics = [];
+  for (const entry of modelIndex) {
+    const results = asRecord(entry)?.results;
+    if (!Array.isArray(results)) {
+      continue;
+    }
+    for (const result of results) {
+      const block = asRecord(result)?.metrics;
+      const push = (name, rawValue) => {
+        const rawName = typeof name === "string" && name.trim() ? name.trim() : null;
+        const parsed = parseNumber(rawValue);
+        if (!rawName || parsed === null || !shouldIncludeMetric(rawName)) {
+          return;
+        }
+        const normalized = normalizeMetricValue(parsed);
+        if (normalized === null) {
+          return;
+        }
+        metrics.push({ name: rawName, value: normalized });
+      };
+      if (Array.isArray(block)) {
+        for (const metric of block) {
+          const record = asRecord(metric);
+          if (!record) {
+            continue;
+          }
+          const name = record.name ?? record.metric ?? record.type ?? null;
+          push(name, record.value);
+          if (metrics.length >= maxMetrics) {
+            return metrics;
+          }
+        }
+      } else if (block && typeof block === "object") {
+        for (const [name, value] of Object.entries(
+          block
+        )) {
+          push(name, value);
+          if (metrics.length >= maxMetrics) {
+            return metrics;
+          }
+        }
+      }
+    }
+  }
+  return metrics;
+}
+async function resolveHuggingFaceModelId(modelId, context, options = {}) {
+  const normalized = modelId.trim().toLowerCase();
+  if (!normalized) {
+    return null;
+  }
+  try {
+    const payload = await requestJson(`${options.openrouterApiBase ?? OPENROUTER_API_BASE}/models`, {
+      fetch: context.fetch,
+      timeoutMs: context.timeoutMs,
+      signal: context.signal
+    });
+    if (Array.isArray(payload.data)) {
+      const match = payload.data.find((entry) => {
+        const id = typeof entry.id === "string" ? entry.id.trim() : "";
+        return id.toLowerCase() === normalized;
+      });
+      const hfId = match && typeof match.hugging_face_id === "string" ? match.hugging_face_id.trim() : "";
+      if (hfId) {
+        return hfId;
+      }
+    }
+  } catch {
+  }
+  try {
+    const headers = options.token ? { authorization: `Bearer ${options.token}` } : {};
+    const payload = await requestJson(
+      `${options.huggingFaceApiBase ?? HF_API_BASE}/models?search=${encodeURIComponent(normalized)}`,
+      {
+        fetch: context.fetch,
+        headers,
+        timeoutMs: context.timeoutMs,
+        signal: context.signal
+      }
+    );
+    if (Array.isArray(payload)) {
+      const match = payload.find((entry) => {
+        const id2 = asRecord(entry)?.id;
+        return typeof id2 === "string" && modelIdMatches(id2, normalized);
+      });
+      const id = asRecord(match)?.id;
+      if (typeof id === "string" && id.trim()) {
+        return id.trim();
+      }
+    }
+  } catch {
+  }
+  return null;
+}
+function createOpenRouterEvalsHttpSource(options) {
+  return async (subject, context) => {
+    const url = typeof options.url === "function" ? options.url(subject) : options.url;
+    if (!url) {
+      return null;
+    }
+    const data = await requestJson(url, {
+      fetch: context.fetch,
+      timeoutMs: context.timeoutMs,
+      signal: context.signal
+    });
+    if (!data || !Array.isArray(data.rows)) {
+      return null;
+    }
+    return data;
+  };
+}
+const stripDateSuffix = (value) => {
+  const trimmed = value.trim().toLowerCase();
+  const match = trimmed.match(/^(.*?)-(\d{8}|\d{4}-\d{2}-\d{2}|\d{2}-\d{4})$/);
+  return match?.[1]?.trim() || null;
+};
+const buildBenchmarkCandidates = (normalizedId) => {
+  const candidates = /* @__PURE__ */ new Set([normalizedId, `${normalizedId}:free`]);
+  if (normalizedId.endsWith(":free")) {
+    candidates.add(normalizedId.slice(0, -":free".length));
+  }
+  return [...candidates];
+};
+function createOpenRouterBenchmarksSource(options = {}) {
+  const frontendBase = stripTrailingSlashes(
+    options.openrouterFrontendBaseUrl ?? OPENROUTER_FRONTEND_BASE
+  );
+  const apiBase = stripTrailingSlashes(
+    options.openrouterApiBaseUrl ?? OPENROUTER_API_BASE
+  );
+  const hfBase = stripTrailingSlashes(
+    options.huggingFaceApiBase ?? HF_API_BASE
+  );
+  const cacheTtlMs = options.cacheTtlMs ?? 24 * 60 * 60 * 1e3;
+  const preferHuggingFace = options.preferHuggingFace ?? true;
+  let cache = null;
+  const loadBenchmarks = async (context) => {
+    if (cache && Date.now() - cache.fetchedAt < cacheTtlMs) {
+      return cache;
+    }
+    const payload = await requestJson(`${frontendBase}/models/find?q=benchmarks`, {
+      fetch: context.fetch,
+      timeoutMs: context.timeoutMs,
+      signal: context.signal
+    });
+    const categories = payload.data?.categories;
+    if (!categories || typeof categories !== "object") {
+      return null;
+    }
+    const byModel = /* @__PURE__ */ new Map();
+    const categoryMaxRank = /* @__PURE__ */ new Map();
+    for (const [model, entries] of Object.entries(categories)) {
+      if (!Array.isArray(entries) || entries.length === 0) {
+        continue;
+      }
+      const normalizedModel = model.trim().toLowerCase();
+      if (!normalizedModel) {
+        continue;
+      }
+      const registerAlias = (alias) => {
+        const candidate = alias?.trim().toLowerCase() ?? "";
+        if (candidate && !byModel.has(candidate)) {
+          byModel.set(candidate, entries);
+        }
+      };
+      byModel.set(normalizedModel, entries);
+      const noFree = normalizedModel.endsWith(":free") ? normalizedModel.slice(0, -":free".length) : null;
+      registerAlias(noFree);
+      registerAlias(stripDateSuffix(normalizedModel));
+      registerAlias(noFree ? stripDateSuffix(noFree) : null);
+      for (const entry of entries) {
+        const category = typeof entry.category === "string" ? entry.category.trim().toLowerCase() : null;
+        const rank = parseNumber(entry.rank);
+        if (!category || rank === null) {
+          continue;
+        }
+        const currentMax = categoryMaxRank.get(category) ?? 0;
+        if (rank > currentMax) {
+          categoryMaxRank.set(category, rank);
+        }
+      }
+    }
+    cache = { fetchedAt: Date.now(), byModel, categoryMaxRank };
+    return cache;
+  };
+  return async (subject, context) => {
+    const modelId = resolveModelId(subject);
+    if (!modelId) {
+      return null;
+    }
+    const normalizedId = modelId.trim().toLowerCase();
+    let huggingFaceId = null;
+    if (preferHuggingFace) {
+      huggingFaceId = await resolveHuggingFaceModelId(modelId, context, {
+        openrouterApiBase: apiBase,
+        huggingFaceApiBase: hfBase
+      }).catch(() => null);
+      if (huggingFaceId) {
+        try {
+          const payload = await requestJson(
+            `${hfBase}/models/${encodeModelIdForPath(huggingFaceId)}`,
+            {
+              fetch: context.fetch,
+              timeoutMs: context.timeoutMs,
+              signal: context.signal
+            }
+          );
+          const metrics = extractModelIndexMetrics(payload);
+          if (metrics.length > 0) {
+            const score = metrics.reduce((sum, m) => sum + m.value, 0) / metrics.length;
+            return {
+              rows: [
+                {
+                  model: modelId,
+                  score,
+                  weight: metrics.length
+                }
+              ],
+              coverageWeight: metrics.length,
+              sources: [HUGGINGFACE_MODEL_INDEX_SOURCE],
+              huggingFaceId
+            };
+          }
+        } catch {
+        }
+      }
+    }
+    const snapshot = await loadBenchmarks(context);
+    if (!snapshot) {
+      return null;
+    }
+    let entries;
+    for (const candidate of buildBenchmarkCandidates(normalizedId)) {
+      entries = snapshot.byModel.get(candidate);
+      if (entries?.length) {
+        break;
+      }
+    }
+    if (!entries?.length) {
+      return null;
+    }
+    const rows = [];
+    for (const entry of entries) {
+      const category = typeof entry.category === "string" ? entry.category.trim().toLowerCase() : void 0;
+      const rank = parseNumber(entry.rank);
+      if (!category || rank === null) {
+        continue;
+      }
+      const maxRank = snapshot.categoryMaxRank.get(category);
+      if (!maxRank || maxRank <= 0) {
+        continue;
+      }
+      const volume = parseNumber(entry.volume);
+      const count = parseNumber(entry.count);
+      rows.push({
+        model: modelId,
+        category,
+        rank,
+        outOf: maxRank,
+        score: (maxRank - rank + 1) / maxRank * 100,
+        weight: volume && volume > 0 ? volume : count && count > 0 ? count : 1
+      });
+    }
+    if (rows.length === 0) {
+      return null;
+    }
+    return {
+      rows,
+      coverageWeight: rows.reduce((sum, row) => sum + (row.weight ?? 1), 0),
+      sources: [OPENROUTER_CATEGORY_SOURCE],
+      huggingFaceId: huggingFaceId ?? void 0
+    };
+  };
+}
+function createOpenRouterEvalsSignalAdapter(options = {}) {
+  const lowCoverageThreshold = options.lowCoverageThreshold ?? 5;
+  const minCategoryCount = options.minCategoryCount ?? 1;
+  const source = options.source ?? createOpenRouterBenchmarksSource();
+  const collect = async (subject, context) => {
+    const now = context.now.toISOString();
+    const modelId = resolveModelId(subject);
+    let data = null;
+    try {
+      data = await source(subject, context);
+    } catch (error) {
+      if (error instanceof Hcs25CollectorHttpError && error.status === 404) {
+        data = null;
+      } else {
+        return [
+          {
+            signalId: "openrouter.evals",
+            status: statusFromError(error),
+            fields: [
+              {
+                scope: "additional",
+                values: {
+                  openrouterEvalStatus: "error",
+                  openrouterEvalUpdatedAt: now
+                }
+              }
+            ]
+          }
+        ];
+      }
+    }
+    const rows = data && modelId ? data.rows.filter((row) => modelIdMatches(row.model, modelId)) : [];
+    if (!data || rows.length === 0) {
+      return [
+        {
+          signalId: "openrouter.evals",
+          status: "missing",
+          fields: [
+            {
+              scope: "additional",
+              values: {
+                openrouterEvalStatus: "missing",
+                openrouterEvalUpdatedAt: now,
+                openrouterEvalMetricsCount: 0
+              }
+            }
+          ]
+        }
+      ];
+    }
+    let weightedSum = 0;
+    let totalWeight = 0;
+    const categoryStats = /* @__PURE__ */ new Map();
+    for (const row of rows) {
+      const score2 = typeof row.score === "number" ? row.score : typeof row.rank === "number" && typeof row.outOf === "number" && row.outOf > 0 ? (row.outOf - row.rank + 1) / row.outOf * 100 : null;
+      if (score2 === null) {
+        continue;
+      }
+      const weight = row.weight ?? 1;
+      weightedSum += score2 * weight;
+      totalWeight += weight;
+      if (row.category) {
+        const existing = categoryStats.get(row.category) ?? {
+          scoreSum: 0,
+          weightSum: 0
+        };
+        existing.scoreSum += score2 * weight;
+        existing.weightSum += weight;
+        categoryStats.set(row.category, existing);
+      }
+    }
+    if (totalWeight <= 0) {
+      return [
+        {
+          signalId: "openrouter.evals",
+          status: "missing",
+          fields: [
+            {
+              scope: "additional",
+              values: {
+                openrouterEvalStatus: "missing",
+                openrouterEvalUpdatedAt: now
+              }
+            }
+          ]
+        }
+      ];
+    }
+    const score = Math.min(100, Math.max(0, weightedSum / totalWeight));
+    const coverageWeight = data.coverageWeight ?? (data.totalCategories && data.totalCategories > 0 ? categoryStats.size / data.totalCategories : totalWeight);
+    const status = categoryStats.size < minCategoryCount || coverageWeight < lowCoverageThreshold ? "low-coverage" : "ok";
+    const topCategories = [...categoryStats.entries()].map(([category, stats]) => ({
+      category,
+      score: (stats.weightSum > 0 ? Math.min(100, Math.max(0, stats.scoreSum / stats.weightSum)) : 0) * Math.min(1, Math.max(0, stats.weightSum / lowCoverageThreshold)),
+      weight: stats.weightSum
+    })).sort((a, b) => b.score - a.score || b.weight - a.weight).slice(0, 5).map((entry) => entry.category);
+    return [
+      {
+        signalId: "openrouter.evals",
+        status: "ok",
+        value: score,
+        fields: [
+          {
+            scope: "additional",
+            values: {
+              openrouterEvalScore: Math.round(score * 100) / 100,
+              openrouterEvalStatus: status,
+              openrouterEvalUpdatedAt: now,
+              openrouterEvalSources: data.sources && data.sources.length > 0 ? [...data.sources] : [OPENROUTER_CATEGORY_SOURCE],
+              openrouterEvalMetricsCount: rows.length,
+              openrouterEvalCategoryCount: categoryStats.size,
+              openrouterEvalCoverageWeight: Math.round(coverageWeight * 1e3) / 1e3,
+              ...topCategories.length > 0 ? { openrouterEvalCategories: topCategories } : {},
+              ...data.huggingFaceId ? { openrouterHuggingFaceId: data.huggingFaceId } : {}
+            }
+          }
+        ],
+        provenance: {
+          source: "openrouter",
+          subjectId: modelId,
+          fetchedAt: now
+        }
+      }
+    ];
+  };
+  return {
+    id: "openrouter-evals",
+    produces: ["openrouter.evals"],
+    timeoutMs: options.timeoutMs,
+    includeRegistries: options.includeRegistries ?? DEFAULT_MODEL_REGISTRIES,
+    appliesTo: options.appliesTo,
+    collect
+  };
+}
+function createJsonLeaderboardSource(options) {
+  const modelKey = options.modelKey ?? "model";
+  const scoreKey = options.scoreKey ?? "score";
+  const votesKey = options.votesKey ?? "votes";
+  return async (_subject, context) => {
+    const data = await requestJson(options.url, {
+      fetch: context.fetch,
+      timeoutMs: context.timeoutMs,
+      signal: context.signal
+    });
+    const record = asRecord(data);
+    const rows = Array.isArray(data) ? data : record?.entries ?? record?.rows ?? record?.leaderboard;
+    if (!Array.isArray(rows)) {
+      return null;
+    }
+    const entries = [];
+    for (const row of rows) {
+      const rowRecord = asRecord(row);
+      if (!rowRecord) {
+        continue;
+      }
+      const model = readString(rowRecord, modelKey);
+      const score = rowRecord[scoreKey];
+      const votes = rowRecord[votesKey];
+      if (!model || typeof score !== "number" || !Number.isFinite(score)) {
+        continue;
+      }
+      entries.push({
+        model,
+        score,
+        votes: typeof votes === "number" ? votes : void 0
+      });
+    }
+    return entries;
+  };
+}
+const stripHtmlTags = (html) => {
+  let current = html;
+  for (; ; ) {
+    const next = current.replace(/<[^<>]*>/g, "");
+    if (next === current) {
+      return next;
+    }
+    current = next;
+  }
+};
+const decodeHtmlEntities = (html) => html.replace(/&nbsp;/gi, " ").replace(/&lt;/gi, "<").replace(/&gt;/gi, ">").replace(/&quot;/gi, '"').replace(/&#39;/g, "'").replace(/&#(\d+);/g, (_match, codepoint) => {
+  const parsed = Number(codepoint);
+  if (!Number.isFinite(parsed) || parsed <= 0) {
+    return "";
+  }
+  try {
+    return String.fromCodePoint(parsed);
+  } catch {
+    return "";
+  }
+}).replace(/&amp;/gi, "&");
+const normalizeArenaLabel = (value) => {
+  const trimmed = value.trim();
+  const open = trimmed.lastIndexOf("(");
+  const base = open > 0 && trimmed.endsWith(")") ? trimmed.slice(0, open).trim() : trimmed;
+  const suffix = open > 0 && trimmed.endsWith(")") ? trimmed.slice(open + 1, -1).trim() : null;
+  const compactSuffix = suffix?.split(/\s+/).join("") ?? "";
+  const isDate = suffix !== null && (/^20\d{2}-\d{2}-\d{2}$/.test(suffix) || /^20\d{2}\d{2}\d{2}$/.test(compactSuffix));
+  const combined = !isDate && suffix ? `${base} ${suffix}` : base;
+  const slugged = combined.toLowerCase().replace(/[^a-z0-9]+/g, "-");
+  let start = 0;
+  let end = slugged.length;
+  while (start < end && slugged.charCodeAt(start) === 45) {
+    start += 1;
+  }
+  while (end > start && slugged.charCodeAt(end - 1) === 45) {
+    end -= 1;
+  }
+  return slugged.slice(start, end);
+};
+const normalizeAlphaNum = (value) => value.toLowerCase().replace(/[^a-z0-9]+/g, "");
+const stripTrailingDateSuffix = (value) => {
+  const match = value.trim().toLowerCase().match(/^(.*?)-(20\d{2}-\d{2}-\d{2})$/) ?? value.trim().toLowerCase().match(/^(.*?)-(20\d{2}\d{2})$/);
+  return match?.[1]?.trim() || null;
+};
+function buildArenaMatchKeys(label, organization) {
+  const normalized = normalizeArenaLabel(label);
+  const keys = /* @__PURE__ */ new Set();
+  if (!normalized) {
+    return [];
+  }
+  const pushKey = (value) => {
+    const candidate = value?.trim() ?? "";
+    if (!candidate) {
+      return;
+    }
+    keys.add(candidate);
+    keys.add(normalizeAlphaNum(candidate));
+  };
+  const expandChatGptAliases = (value) => {
+    if (value.startsWith("chatgpt-")) {
+      pushKey(`gpt-${value.slice("chatgpt-".length)}`);
+    }
+    if (value.startsWith("gpt-")) {
+      const rest = value.slice("gpt-".length);
+      pushKey(`chatgpt-${rest}`);
+      pushKey(`chatgpt-${rest}-latest`);
+    }
+  };
+  const expandDateAliases = (value) => {
+    const stripped = stripTrailingDateSuffix(value);
+    if (stripped) {
+      pushKey(stripped);
+      expandChatGptAliases(stripped);
+    }
+  };
+  pushKey(normalized);
+  const org = normalizeArenaLabel(organization ?? "");
+  if (org) {
+    pushKey(`${org}-${normalized}`);
+    pushKey(`${org}/${normalized}`);
+  }
+  expandChatGptAliases(normalized);
+  expandDateAliases(normalized);
+  if (normalized.endsWith("-latest")) {
+    const without = normalized.slice(0, -"-latest".length);
+    pushKey(without);
+    expandChatGptAliases(without);
+    expandDateAliases(without);
+  }
+  return [...keys].filter(Boolean);
+}
+const arenaCandidateKeys = (modelId) => {
+  const base = modelId.trim().toLowerCase().replace(/:free$/i, "");
+  const candidates = /* @__PURE__ */ new Set();
+  const add = (value) => {
+    const trimmed = value.trim();
+    if (trimmed) {
+      candidates.add(normalizeArenaLabel(trimmed));
+      candidates.add(normalizeAlphaNum(trimmed));
+    }
+  };
+  add(base);
+  add(base.replace(/\//g, "-"));
+  const withoutFast = base.replace(/-fast$/i, "");
+  if (withoutFast !== base) {
+    add(withoutFast);
+  }
+  const stripped = stripTrailingDateSuffix(base);
+  if (stripped) {
+    add(stripped);
+  }
+  if (base.startsWith("gpt-")) {
+    add(`chatgpt-${base.slice(4)}`);
+  }
+  if (base.startsWith("chatgpt-")) {
+    add(`gpt-${base.slice(8)}`);
+  }
+  if (base.endsWith("-latest")) {
+    add(base.slice(0, -"-latest".length));
+  }
+  const orgPrefix = base.includes("/") ? base.split("/")[0] : null;
+  if (orgPrefix) {
+    const model = base.slice(orgPrefix.length + 1);
+    add(`${orgPrefix}-${model}`);
+    add(`${orgPrefix}/${model}`);
+  }
+  return [...candidates].filter(Boolean);
+};
+function createOpenLmArenaSource(options = {}) {
+  const url = options.url ?? OPENLM_ARENA_URL;
+  const cacheTtlMs = options.cacheTtlMs ?? 24 * 60 * 60 * 1e3;
+  let cache = null;
+  return async (_subject, context) => {
+    if (cache && Date.now() - cache.fetchedAt < cacheTtlMs) {
+      return cache.entries;
+    }
+    const html = await requestText(url, {
+      fetch: context.fetch,
+      timeoutMs: context.timeoutMs,
+      signal: context.signal,
+      headers: { accept: "text/html" }
+    });
+    const tableMatch = html.match(
+      /<table[^>]*class=sortable[^>]*>.*?<\/table>/is
+    );
+    if (!tableMatch) {
+      return null;
+    }
+    const tbodyMatch = tableMatch[0].match(/<tbody[^>]*>(.*?)<\/tbody>/is);
+    const tbody = tbodyMatch?.[1];
+    if (!tbody) {
+      return null;
+    }
+    const entries = [];
+    for (const rowMatch of tbody.matchAll(/<tr[^>]*>(.*?)<\/tr>/gis)) {
+      const rowHtml = rowMatch[1] ?? "";
+      if (!rowHtml) {
+        continue;
+      }
+      const cells = Array.from(rowHtml.matchAll(/<td[^>]*>(.*?)<\/td>/gis)).map(
+        (match) => match[1] ?? ""
+      );
+      const rawLabelCell = cells[1];
+      const rawScoreCell = cells[2];
+      const rawOrgCell = cells[8];
+      const modelLabel = decodeHtmlEntities(
+        stripHtmlTags(rawLabelCell ?? "")
+      ).trim();
+      if (!modelLabel) {
+        continue;
+      }
+      const score = parseNumber(
+        decodeHtmlEntities(stripHtmlTags(rawScoreCell ?? "")).trim()
+      );
+      if (score === null) {
+        continue;
+      }
+      const organization = decodeHtmlEntities(stripHtmlTags(rawOrgCell ?? "")).trim() || void 0;
+      entries.push({ model: modelLabel, score, organization });
+    }
+    if (entries.length === 0) {
+      return null;
+    }
+    cache = { fetchedAt: Date.now(), entries };
+    return entries;
+  };
+}
+function createChatbotArenaSignalAdapter(options = {}) {
+  const source = options.source ?? createOpenLmArenaSource();
+  const collect = async (subject, context) => {
+    const now = context.now.toISOString();
+    const modelId = resolveModelId(subject);
+    const wanted = /* @__PURE__ */ new Set();
+    for (const id of [modelId, ...options.aliases ?? []]) {
+      if (!id) {
+        continue;
+      }
+      for (const key of arenaCandidateKeys(id)) {
+        wanted.add(key);
+      }
+      wanted.add(id.trim().toLowerCase());
+    }
+    let entries = null;
+    try {
+      entries = await source(subject, context);
+    } catch (error) {
+      return [
+        {
+          signalId: "chatbot-arena.eval",
+          status: statusFromError(error)
+        }
+      ];
+    }
+    const entry = entries?.find((candidate) => {
+      if (wanted.has(candidate.model.trim().toLowerCase()) || [...wanted].some((id) => modelIdMatches(candidate.model, id))) {
+        return true;
+      }
+      const keys = buildArenaMatchKeys(
+        candidate.model,
+        candidate.organization
+      );
+      return keys.some((key) => wanted.has(key));
+    }) ?? null;
+    if (!entries || entries.length === 0 || !entry) {
+      return [
+        {
+          signalId: "chatbot-arena.eval",
+          status: "missing",
+          fields: [
+            {
+              scope: "additional",
+              values: {
+                chatbotArenaEvalStatus: "missing",
+                chatbotArenaEvalUpdatedAt: now
+              }
+            }
+          ]
+        }
+      ];
+    }
+    const scores = entries.map((e) => e.score);
+    const min = Math.min(...scores);
+    const max = Math.max(...scores);
+    const normalized = max > min ? 100 * (entry.score - min) / (max - min) : 50;
+    return [
+      {
+        signalId: "chatbot-arena.eval",
+        status: "ok",
+        value: Math.round(normalized * 100) / 100,
+        fields: [
+          {
+            scope: "additional",
+            values: {
+              chatbotArenaEvalScore: Math.round(normalized * 100) / 100,
+              chatbotArenaEvalElo: entry.score,
+              chatbotArenaEvalVotes: entry.votes ?? null,
+              chatbotArenaEvalStatus: "ok",
+              chatbotArenaEvalUpdatedAt: now,
+              chatbotArenaEvalSources: [CHATBOT_ARENA_SOURCE]
+            }
+          }
+        ],
+        provenance: {
+          source: "chatbot-arena",
+          subjectId: entry.model,
+          fetchedAt: now
+        }
+      }
+    ];
+  };
+  return {
+    id: "chatbot-arena",
+    produces: ["chatbot-arena.eval"],
+    timeoutMs: options.timeoutMs,
+    includeRegistries: options.includeRegistries ?? DEFAULT_MODEL_REGISTRIES,
+    appliesTo: options.appliesTo,
+    collect
+  };
+}
+function createHuggingFaceSignalAdapter(options = {}) {
+  const apiBase = stripTrailingSlashes(options.apiBase ?? HF_API_BASE);
+  const collect = async (subject, context) => {
+    const now = context.now.toISOString();
+    const additional = readSubjectAdditional(subject);
+    const storedHfId = readString(additional, "huggingFaceModelId") ?? readString(additional, "openrouterHuggingFaceId");
+    const modelId = resolveModelId(subject);
+    if (!modelId && !storedHfId) {
+      return [
+        {
+          signalId: "huggingface.model_index",
+          status: "missing",
+          fields: [
+            {
+              scope: "additional",
+              values: {
+                huggingFaceEvalStatus: "missing",
+                huggingFaceEvalUpdatedAt: now
+              }
+            }
+          ]
+        }
+      ];
+    }
+    try {
+      const headers = options.token ? { authorization: `Bearer ${options.token}` } : {};
+      let huggingFaceId = storedHfId ?? modelId;
+      let resolvedViaOpenRouter = false;
+      if (!storedHfId && options.resolveHuggingFaceId !== false && modelId) {
+        const resolved = await resolveHuggingFaceModelId(modelId, context, {
+          huggingFaceApiBase: apiBase,
+          openrouterApiBase: options.openrouterApiBase,
+          token: options.token
+        }).catch(() => null);
+        if (resolved) {
+          huggingFaceId = resolved;
+          resolvedViaOpenRouter = true;
+        }
+      }
+      const data = await requestJson(
+        `${apiBase}/models/${encodeModelIdForPath(huggingFaceId)}`,
+        {
+          fetch: context.fetch,
+          headers,
+          timeoutMs: context.timeoutMs,
+          signal: context.signal
+        }
+      );
+      const metrics = extractModelIndexMetrics(data, options.maxMetrics ?? 60);
+      const modelIndexScore = metrics.length > 0 ? metrics.reduce((sum, m) => sum + m.value, 0) / metrics.length : null;
+      const downloads = parseNumber(data.downloads);
+      const likes = parseNumber(data.likes);
+      const popularityScore = computePopularityScore(
+        downloads,
+        likes,
+        options.downloadsCap ?? 1e7,
+        options.likesCap ?? 1e5
+      );
+      let score = null;
+      let mode;
+      if (modelIndexScore !== null && popularityScore !== null) {
+        score = modelIndexScore * 0.8 + popularityScore * 0.2;
+        mode = "mixed";
+      } else if (modelIndexScore !== null) {
+        score = modelIndexScore;
+        mode = "model-index";
+      } else if (popularityScore !== null) {
+        score = popularityScore;
+        mode = "popularity";
+      } else {
+        mode = "missing";
+      }
+      const normalized = score === null ? null : Math.round(Math.min(100, Math.max(0, score)) * 100) / 100;
+      const sources = [];
+      if (modelIndexScore !== null) {
+        sources.push(HUGGINGFACE_MODEL_INDEX_SOURCE);
+      }
+      if (popularityScore !== null) {
+        sources.push(HUGGINGFACE_POPULARITY_SOURCE);
+      }
+      return [
+        {
+          signalId: "huggingface.model_index",
+          status: normalized === null ? "missing" : "ok",
+          value: normalized,
+          fields: [
+            {
+              scope: "additional",
+              values: {
+                huggingFaceModelId: typeof data.id === "string" && data.id.trim() ? data.id : huggingFaceId,
+                huggingFaceEvalScore: normalized,
+                huggingFaceSignalScore: normalized,
+                huggingFaceEvalMetricsCount: metrics.length,
+                huggingFaceDownloads: downloads,
+                huggingFaceLikes: likes,
+                huggingFaceEvalMode: mode,
+                huggingFaceEvalStatus: normalized === null ? "missing" : "ok",
+                huggingFaceEvalUpdatedAt: now,
+                huggingFaceEvalSources: sources,
+                ...resolvedViaOpenRouter ? { openrouterHuggingFaceId: huggingFaceId } : {}
+              }
+            }
+          ],
+          provenance: {
+            source: "huggingface",
+            sourceUrl: `${apiBase}/models/${encodeModelIdForPath(huggingFaceId)}`,
+            subjectId: huggingFaceId,
+            fetchedAt: now
+          }
+        }
+      ];
+    } catch (error) {
+      const missing = error instanceof Hcs25CollectorHttpError && error.status === 404;
+      return [
+        {
+          signalId: "huggingface.model_index",
+          status: missing ? "missing" : statusFromError(error),
+          fields: [
+            {
+              scope: "additional",
+              values: {
+                huggingFaceEvalStatus: missing ? "missing" : "error",
+                huggingFaceEvalUpdatedAt: now
+              }
+            }
+          ]
+        }
+      ];
+    }
+  };
+  return {
+    id: "huggingface-model-index",
+    produces: ["huggingface.model_index"],
+    timeoutMs: options.timeoutMs,
+    includeRegistries: options.includeRegistries ?? DEFAULT_MODEL_REGISTRIES,
+    appliesTo: options.appliesTo,
+    collect
+  };
+}
+function createOpenLlmJsonSource(options) {
+  const modelKey = options.modelKey ?? "model";
+  return async (_subject, context) => {
+    const data = await requestJson(options.url, {
+      fetch: context.fetch,
+      timeoutMs: context.timeoutMs,
+      signal: context.signal
+    });
+    const record = asRecord(data);
+    const rows = Array.isArray(data) ? data : record?.rows;
+    if (!Array.isArray(rows)) {
+      return null;
+    }
+    const out = [];
+    for (const row of rows) {
+      const rowRecord = asRecord(row);
+      if (!rowRecord) {
+        continue;
+      }
+      const model = readString(rowRecord, modelKey);
+      if (!model) {
+        continue;
+      }
+      const metrics = {};
+      for (const [key, value] of Object.entries(rowRecord)) {
+        const parsed = parseNumber(value);
+        if (key !== modelKey && parsed !== null) {
+          metrics[key] = parsed;
+        }
+      }
+      out.push({ model, metrics });
+    }
+    return out;
+  };
+}
+const tokenizeForSimilarity = (value) => new Set(
+  value.toLowerCase().split(/[^a-z0-9]+/).filter((token) => token.length > 1)
+);
+const jaccardSimilarity = (a, b) => {
+  if (a.size === 0 || b.size === 0) {
+    return 0;
+  }
+  let intersection = 0;
+  for (const token of a) {
+    if (b.has(token)) {
+      intersection += 1;
+    }
+  }
+  return intersection / (a.size + b.size - intersection);
+};
+function createOpenLlmHuggingFaceSource(options = {}) {
+  const apiBase = stripTrailingSlashes(
+    options.huggingFaceApiBase ?? HF_API_BASE
+  );
+  const datasetsBase = stripTrailingSlashes(
+    options.huggingFaceDatasetsBase ?? HF_DATASETS_BASE
+  );
+  const datasetId = options.datasetId ?? OPENLLM_DATASET_ID;
+  const branch = options.datasetBranch ?? OPENLLM_DATASET_BRANCH;
+  const cacheTtlMs = options.cacheTtlMs ?? 24 * 60 * 60 * 1e3;
+  const minSimilarity = options.minSimilarity ?? 0.6;
+  const pathCache = /* @__PURE__ */ new Map();
+  const orgCache = /* @__PURE__ */ new Map();
+  const listTree = async (context, path) => {
+    const url = `${apiBase}/datasets/${datasetId}/tree/${branch}/${encodeModelIdForPath(path)}`;
+    const payload = await requestJson(url, {
+      fetch: context.fetch,
+      timeoutMs: context.timeoutMs,
+      signal: context.signal
+    });
+    return Array.isArray(payload) ? payload : [];
+  };
+  const latestResultsPath = async (context, dir) => {
+    const candidates = (await listTree(context, dir)).map((entry) => typeof entry.path === "string" ? entry.path : "").filter((path) => path.includes("results_") && path.endsWith(".json"));
+    return candidates.length > 0 ? candidates.sort().at(-1) ?? null : null;
+  };
+  const resolveViaOrg = async (context, huggingFaceId) => {
+    const slashIndex = huggingFaceId.indexOf("/");
+    if (slashIndex <= 0 || slashIndex === huggingFaceId.length - 1) {
+      return null;
+    }
+    const org = huggingFaceId.slice(0, slashIndex);
+    const repo = huggingFaceId.slice(slashIndex + 1);
+    if (!org || !repo) {
+      return null;
+    }
+    const orgKey = org.toLowerCase();
+    let paths;
+    const cached = orgCache.get(orgKey);
+    if (cached && Date.now() - cached.fetchedAt < cacheTtlMs) {
+      paths = cached.paths;
+    } else {
+      try {
+        paths = (await listTree(context, org)).map((entry) => typeof entry.path === "string" ? entry.path : "").filter(
+          (path) => path.startsWith(`${org}/`) && !path.slice(org.length + 1).includes("/") && path.slice(org.length + 1).length > 0
+        );
+      } catch {
+        return null;
+      }
+      orgCache.set(orgKey, { paths, fetchedAt: Date.now() });
+    }
+    if (paths.length === 0) {
+      return null;
+    }
+    const targetTokens = tokenizeForSimilarity(repo);
+    let bestPath = null;
+    let bestSimilarity = 0;
+    for (const path of paths) {
+      const candidateRepo = path.slice(org.length + 1);
+      const similarity = jaccardSimilarity(
+        targetTokens,
+        tokenizeForSimilarity(candidateRepo)
+      );
+      if (similarity > bestSimilarity) {
+        bestSimilarity = similarity;
+        bestPath = path;
+      }
+    }
+    if (!bestPath || bestSimilarity < minSimilarity) {
+      return null;
+    }
+    try {
+      return await latestResultsPath(context, bestPath);
+    } catch {
+      return null;
+    }
+  };
+  const resolveResultsPath = async (context, huggingFaceId) => {
+    const key = huggingFaceId.toLowerCase();
+    const cached = pathCache.get(key);
+    if (cached && Date.now() - cached.fetchedAt < cacheTtlMs) {
+      return cached.path;
+    }
+    let path = null;
+    try {
+      path = await latestResultsPath(context, huggingFaceId);
+    } catch {
+      path = null;
+    }
+    if (!path) {
+      path = await resolveViaOrg(context, huggingFaceId);
+    }
+    pathCache.set(key, { path, fetchedAt: Date.now() });
+    return path;
+  };
+  return async (subject, context) => {
+    const additional = readSubjectAdditional(subject);
+    const huggingFaceId = readString(additional, "huggingFaceModelId") ?? readString(additional, "openrouterHuggingFaceId") ?? resolveModelId(subject);
+    if (!huggingFaceId) {
+      return null;
+    }
+    const resultPath = await resolveResultsPath(context, huggingFaceId);
+    if (!resultPath) {
+      return null;
+    }
+    const url = `${datasetsBase}/${datasetId}/resolve/${branch}/${resultPath}`;
+    const payload = await requestJson(url, {
+      fetch: context.fetch,
+      timeoutMs: context.timeoutMs,
+      signal: context.signal
+    });
+    const results = asRecord(payload)?.results;
+    if (!isJsonObject(results)) {
+      return null;
+    }
+    const metrics = {};
+    for (const groupValue of Object.values(
+      results
+    )) {
+      if (!isJsonObject(groupValue)) {
+        continue;
+      }
+      for (const [name, rawValue] of Object.entries(
+        groupValue
+      )) {
+        const normalizedName = name.trim().toLowerCase();
+        if (!normalizedName || normalizedName.includes("stderr") || normalizedName === "alias") {
+          continue;
+        }
+        const value = parseNumber(rawValue);
+        if (value === null || !shouldIncludeMetric(normalizedName)) {
+          continue;
+        }
+        metrics[name] = value;
+      }
+    }
+    if (Object.keys(metrics).length === 0) {
+      return null;
+    }
+    return [{ model: huggingFaceId, metrics }];
+  };
+}
+function createOpenLlmSignalAdapter(options = {}) {
+  const source = options.source ?? createOpenLlmHuggingFaceSource();
+  const collect = async (subject, context) => {
+    const now = context.now.toISOString();
+    const modelId = resolveModelId(subject);
+    if (!modelId) {
+      return [
+        {
+          signalId: "openllm.leaderboard",
+          status: "missing",
+          fields: [
+            {
+              scope: "additional",
+              values: {
+                openLlmEvalStatus: "missing",
+                openLlmEvalUpdatedAt: now
+              }
+            }
+          ]
+        }
+      ];
+    }
+    let rows = null;
+    try {
+      rows = await source(subject, context);
+    } catch (error) {
+      return [
+        {
+          signalId: "openllm.leaderboard",
+          status: statusFromError(error),
+          fields: [
+            {
+              scope: "additional",
+              values: {
+                openLlmEvalStatus: "error",
+                openLlmEvalUpdatedAt: now
+              }
+            }
+          ]
+        }
+      ];
+    }
+    const row = rows?.find((candidate) => modelIdMatches(candidate.model, modelId)) ?? (rows?.length === 1 ? rows[0] : null);
+    if (!row) {
+      return [
+        {
+          signalId: "openllm.leaderboard",
+          status: "missing",
+          fields: [
+            {
+              scope: "additional",
+              values: {
+                openLlmEvalStatus: "missing",
+                openLlmEvalUpdatedAt: now
+              }
+            }
+          ]
+        }
+      ];
+    }
+    const values = Object.values(row.metrics).map(normalizeMetricValue).filter((value) => value !== null);
+    const score = values.length > 0 ? Math.round(
+      values.reduce((sum, v) => sum + v, 0) / values.length * 100
+    ) / 100 : null;
+    return [
+      {
+        signalId: "openllm.leaderboard",
+        status: score === null ? "missing" : "ok",
+        value: score,
+        fields: [
+          {
+            scope: "additional",
+            values: {
+              openLlmEvalScore: score,
+              openLlmEvalMetricsCount: values.length,
+              openLlmEvalStatus: score === null ? "missing" : "ok",
+              openLlmEvalUpdatedAt: now,
+              openLlmEvalSources: [...OPENLLM_EVAL_SOURCES]
+            }
+          }
+        ],
+        provenance: {
+          source: "openllm-leaderboard",
+          subjectId: row.model,
+          fetchedAt: now
+        }
+      }
+    ];
+  };
+  return {
+    id: "openllm-leaderboard",
+    produces: ["openllm.leaderboard"],
+    timeoutMs: options.timeoutMs,
+    includeRegistries: options.includeRegistries ?? DEFAULT_MODEL_REGISTRIES,
+    appliesTo: options.appliesTo,
+    collect
+  };
+}
 export {
-  sleep
+  buildArenaMatchKeys,
+  computePopularityScore,
+  createChatbotArenaSignalAdapter,
+  createHuggingFaceSignalAdapter,
+  createJsonLeaderboardSource,
+  createOpenLlmHuggingFaceSource,
+  createOpenLlmJsonSource,
+  createOpenLlmSignalAdapter,
+  createOpenLmArenaSource,
+  createOpenRouterBenchmarksSource,
+  createOpenRouterEvalsHttpSource,
+  createOpenRouterEvalsSignalAdapter,
+  extractModelIndexMetrics,
+  modelIdMatches,
+  normalizeLogScore,
+  normalizeMetricValue,
+  resolveHuggingFaceModelId,
+  resolveModelId,
+  shouldIncludeMetric
 };
 //# sourceMappingURL=standards-sdk.es138.js.map