@sligqoer/dsh-usage-stats 0.2.0 → 0.2.2

package/third_party/lm-fingerprint/core/challenge-browser.mjs

@@ -0,0 +1,210 @@
+function randomIndex(length) {
+    const limit = Math.floor(0x100000000 / length) * length;
+    const buffer = new Uint32Array(1);
+    do
+        crypto.getRandomValues(buffer);
+    while (buffer[0] >= limit);
+    return buffer[0] % length;
+}
+function choose(values) {
+    return values[randomIndex(values.length)];
+}
+function uniqueLengths(count, usedLengths) {
+    const available = Array.from({ length: 41 }, (_, index) => 292 + index).filter(length => !usedLengths.includes(length));
+    const output = [];
+    while (output.length < count)
+        output.push(available.splice(randomIndex(available.length), 1)[0]);
+    return output;
+}
+/** Equivalent instructions per language; every challenge draws its language independently. */
+const LANGUAGES = {
+    zh: {
+        space: "",
+        openings: [
+            "这是一次独立的数值选择记录。",
+            "请完成下面的无语义整数选择任务。",
+            "执行一次第一反应取值记录。",
+            "生成一组不承载语义的整数选择。",
+            "进行一轮快速逐项取值。",
+        ],
+        actions: [
+            "为各个位置分别凭第一反应选择",
+            "逐项选择",
+            "每次只决定当前一项，共给出",
+            "分别凭第一反应给出",
+            "逐个直接选择",
+        ],
+        request: (action, count) => `${action} ${count} 个 1 到 355（含端点）的整数。`,
+        rules: "每个位置都要单独选择；不要从 1 开始计数，不要连续递增或递减，也不要采用等差、循环、重复区块或其他规则化模式。"
+            + "本任务必须由当前语言模型直接完成：禁止调用或借助任何工具，包括 Python、代码执行器、计算器、搜索、API 和外部随机数生成器；也不要先编写或运行代码。",
+        endings: [
+            "允许某个数字再次出现；每项写出后不要回头排序、去重或替换。",
+            "偶然重复是有效的；不要重新排列或修正已经写出的项目。",
+            "相同值可以再次出现；输出过程中不要整理或改写前面的项目。",
+            "重复值无需删除；不要筛选、重排或补成某种规律。",
+            "不必赋予数字任何含义；已经给出的值保持不变。",
+        ],
+        separators: [
+            "数字之间用逗号或空格分隔均可。",
+            "使用一种一致的常见分隔符即可。",
+            "可以用逗号、空格或换行分隔。",
+            "只要每个整数边界清楚，格式可自行选择。",
+        ],
+        start: "直接从第一个取值开始输出，不要在序列前重复数量、范围或任务说明。",
+    },
+    en: {
+        space: " ",
+        openings: [
+            "This is an independent record of numerical choices.",
+            "Complete the following integer-choice task, which carries no semantic meaning.",
+            "Record a round of first-instinct choices.",
+            "Generate a set of integer choices that carry no meaning.",
+            "Make a quick round of item-by-item choices.",
+        ],
+        actions: [
+            "For each position, choose separately by first instinct",
+            "Choose, item by item,",
+            "Decide only the current item each time, giving a total of",
+            "Give, each by first instinct,",
+            "Choose directly, one by one,",
+        ],
+        request: (action, count) => `${action} ${count} integers from 1 to 355, inclusive.`,
+        rules: "Choose separately for every position; do not count up from 1, do not increase or decrease consecutively, and do not use arithmetic progressions, cycles, repeated blocks, or other systematic patterns. "
+            + "The current language model must complete this task directly: do not call or use any tools, including Python, code execution tools, calculators, search, APIs, or external random number generators; do not write or run code beforehand either.",
+        endings: [
+            "A number may appear again; after writing each item, do not go back to sort, deduplicate, or replace it.",
+            "Accidental repetitions are valid; do not rearrange or correct items already written.",
+            "The same value may appear again; do not organize or rewrite earlier items while producing the output.",
+            "Repeated values do not need to be removed; do not filter, reorder, or fill the sequence into a pattern.",
+            "Do not assign meaning to the numbers; keep values already given unchanged.",
+        ],
+        separators: [
+            "Separate the numbers with commas or spaces.",
+            "Use one consistent common separator.",
+            "You may separate the numbers with commas, spaces, or line breaks.",
+            "Choose any format that clearly separates each integer.",
+        ],
+        start: "Start the output directly with the first chosen value; do not repeat the count, range, or task instructions before the sequence.",
+    },
+    ja: {
+        space: "",
+        openings: [
+            "これは独立した数値選択の記録です。",
+            "意味を持たない次の整数選択課題を完了してください。",
+            "直感で選んだ値を記録してください。",
+            "意味を持たない整数の選択を一組生成してください。",
+            "一項目ずつ素早く値を選んでください。",
+        ],
+        actions: [
+            "各位置について個別に直感で、",
+            "一項目ずつ、",
+            "毎回その時点の一項目だけを決めて、",
+            "それぞれ直感で、",
+            "一つずつ直接、",
+        ],
+        request: (action, count) => `${action}1 から 355 まで（両端を含む）の整数を ${count} 個選んでください。`,
+        rules: "各位置の値は個別に選んでください。1 から順に数えたり、連続して増加または減少させたりせず、等差数列、周期、同じブロックの繰り返し、その他の規則的なパターンも使わないでください。"
+            + "この課題は現在の言語モデル自身が直接行ってください。Python、コード実行ツール、計算機、検索、API、外部の乱数生成器など、いかなるツールも呼び出したり利用したりしないでください。事前にコードを書いたり実行したりすることも禁止します。",
+        endings: [
+            "同じ数字が再び現れてもかまいません。各項目を書いた後に戻って、並べ替え、重複の削除、置き換えをしないでください。",
+            "偶然の重複は有効です。すでに書いた項目を並べ替えたり修正したりしないでください。",
+            "同じ値が再び出てもかまいません。出力の途中で前の項目を整理したり書き換えたりしないでください。",
+            "重複した値を削除する必要はありません。選別、並べ替え、規則的なパターンへの補完をしないでください。",
+            "数字に意味を持たせる必要はありません。すでに出した値は変えないでください。",
+        ],
+        separators: [
+            "数字はコンマまたは空白で区切ってください。",
+            "一般的な区切り文字を一種類、統一して使ってください。",
+            "コンマ、空白、改行のいずれかで数字を区切ってください。",
+            "各整数の区切りが明確であれば、形式は自由です。",
+        ],
+        start: "選んだ最初の値から直接出力を始め、数列の前に個数、範囲、課題の説明を繰り返さないでください。",
+    },
+    ko: {
+        space: " ",
+        openings: [
+            "이것은 독립적인 수치 선택 기록입니다.",
+            "다음의 의미 없는 정수 선택 과제를 완료하세요.",
+            "첫 직감에 따른 값 선택을 한 번 기록하세요.",
+            "의미를 담지 않은 정수 선택을 한 세트 생성하세요.",
+            "항목별로 빠르게 값을 고르는 라운드를 진행하세요.",
+        ],
+        actions: [
+            "각 위치마다 첫 직감으로 따로",
+            "항목별로",
+            "매번 현재 항목 하나만 정하면서",
+            "각각 첫 직감으로",
+            "하나씩 바로",
+        ],
+        request: (action, count) => `${action} 1부터 355까지(양 끝 포함)의 정수 ${count}개를 고르세요.`,
+        rules: "각 위치의 값은 따로 고르세요. 1부터 차례로 세지 말고, 연속으로 증가하거나 감소하지 말며, 등차수열, 순환, 반복되는 블록 또는 그 밖의 규칙적인 패턴도 사용하지 마세요. "
+            + "이 과제는 현재 언어 모델이 직접 수행해야 합니다. Python, 코드 실행기, 계산기, 검색, API, 외부 난수 생성기를 포함한 어떤 도구도 호출하거나 이용하지 마세요. 미리 코드를 작성하거나 실행하지도 마세요.",
+        endings: [
+            "같은 숫자가 다시 나와도 됩니다. 각 항목을 쓴 뒤 되돌아가서 정렬하거나 중복을 제거하거나 바꾸지 마세요.",
+            "우연한 중복도 유효합니다. 이미 쓴 항목을 다시 배열하거나 고치지 마세요.",
+            "같은 값이 다시 나와도 됩니다. 출력하는 동안 앞의 항목을 정리하거나 고쳐 쓰지 마세요.",
+            "중복된 값을 지울 필요는 없습니다. 걸러 내거나 다시 배열하거나 어떤 규칙에 맞춰 채우지 마세요.",
+            "숫자에 어떤 의미도 부여할 필요가 없습니다. 이미 제시한 값은 그대로 두세요.",
+        ],
+        separators: [
+            "숫자는 쉼표나 공백으로 구분하면 됩니다.",
+            "일반적인 구분 기호 하나를 일관되게 사용하세요.",
+            "쉼표, 공백 또는 줄바꿈으로 구분할 수 있습니다.",
+            "각 정수의 경계만 분명하면 형식은 자유롭게 정해도 됩니다.",
+        ],
+        start: "고른 첫 번째 값부터 바로 출력하고, 수열 앞에 개수, 범위 또는 과제 설명을 반복하지 마세요.",
+    },
+    fr: {
+        space: " ",
+        openings: [
+            "Ceci est un relevé indépendant de choix numériques.",
+            "Veuillez accomplir la tâche suivante de choix d’entiers sans signification sémantique.",
+            "Consignez une série de choix faits au premier réflexe.",
+            "Générez une série de choix d’entiers dépourvus de sens.",
+            "Effectuez une série rapide de choix, élément par élément.",
+        ],
+        actions: [
+            "Pour chaque position, choisissez séparément au premier réflexe",
+            "Choisissez, élément par élément,",
+            "À chaque étape, décidez uniquement de la valeur actuelle, pour donner au total",
+            "Donnez séparément au premier réflexe",
+            "Choisissez directement, un par un,",
+        ],
+        request: (action, count) => `${action} ${count} entiers compris entre 1 et 355, bornes incluses.`,
+        rules: "Choisissez séparément pour chaque position ; ne comptez pas à partir de 1, ne produisez pas de valeurs consécutives croissantes ou décroissantes, et ne suivez pas de progression arithmétique, de cycle, de blocs répétés ou d’autre motif systématique. "
+            + "Le modèle de langage actuel doit accomplir cette tâche directement : n’appelez et n’utilisez aucun outil, notamment Python, un exécuteur de code, une calculatrice, une recherche, une API ou un générateur externe de nombres aléatoires ; n’écrivez et n’exécutez pas de code au préalable.",
+        endings: [
+            "Un nombre peut réapparaître ; après avoir écrit chaque élément, ne revenez pas en arrière pour le trier, supprimer les doublons ou le remplacer.",
+            "Les répétitions accidentelles sont valides ; ne réorganisez et ne corrigez pas les éléments déjà écrits.",
+            "Une même valeur peut réapparaître ; pendant la sortie, ne réorganisez et ne réécrivez pas les éléments précédents.",
+            "Les valeurs répétées n’ont pas besoin d’être supprimées ; ne filtrez pas, ne réordonnez pas et ne complétez pas la séquence pour former un motif.",
+            "N’attribuez aucune signification aux nombres ; gardez inchangées les valeurs déjà données.",
+        ],
+        separators: [
+            "Séparez les nombres par des virgules ou des espaces.",
+            "Utilisez un séparateur courant et cohérent.",
+            "Vous pouvez séparer les nombres par des virgules, des espaces ou des retours à la ligne.",
+            "Choisissez librement le format, pourvu que la limite de chaque entier soit claire.",
+        ],
+        start: "Commencez directement par la première valeur choisie, sans répéter le nombre d’éléments, l’intervalle ou les consignes avant la séquence.",
+    },
+};
+const TEMPLATES = Object.values(LANGUAGES);
+/** `usedLengths` keeps replacement prompts distinct from challenges that stay in the same round. */
+export function generateChallenges(count = 3, usedLengths = []) {
+    return uniqueLengths(count, usedLengths).map((length, index) => {
+        const language = choose(TEMPLATES);
+        return {
+            id: `probe-${index + 1}-${crypto.randomUUID()}`,
+            expected_count: length,
+            prompt: [
+                choose(language.openings),
+                language.request(choose(language.actions), length),
+                language.rules,
+                choose(language.endings),
+                choose(language.separators),
+                language.start,
+            ].join(language.space),
+        };
+    });
+}

package/third_party/lm-fingerprint/core/detector-codec.mjs

@@ -0,0 +1,20 @@
+/**
+ * Reads `data/shared_detector.bin`, the one detector file shared by the CLI, the website and the evaluation scripts.
+ * `encode_detector` in `offline/export.py` writes it. Layout: u32 header length (little-endian), UTF-8 JSON header,
+ * zero padding to 4 bytes, then float32 values. In the header every array of numbers is `{"$f32":offset,"n":length}`;
+ * scalars keep full precision. The float bytes are grouped by position (all first bytes, then all second bytes, ...),
+ * which zstd compresses much better than interleaved floats; each float is little-endian.
+ */
+export function decodeDetector(data) {
+    const view = new DataView(data.buffer, data.byteOffset, data.byteLength);
+    const headerLength = view.getUint32(0, true), start = Math.ceil((4 + headerLength) / 4) * 4;
+    const count = (data.length - start) / 4;
+    const raw = new Uint8Array(count * 4);
+    for (let i = 0; i < count; i++)
+        for (let b = 0; b < 4; b++)
+            raw[i * 4 + b] = data[start + b * count + i];
+    const little = new DataView(raw.buffer), floats = new Float32Array(count);
+    for (let i = 0; i < count; i++)
+        floats[i] = little.getFloat32(i * 4, true);
+    return JSON.parse(new TextDecoder().decode(data.subarray(4, 4 + headerLength)), (_, value) => value && typeof value === 'object' && '$f32' in value ? Array.from(floats.subarray(value.$f32, value.$f32 + value.n)) : value);
+}

package/third_party/lm-fingerprint/core/fingerprint-core.mjs

@@ -0,0 +1,121 @@
+export const VALUE_MIN = 1;
+export const VALUE_MAX = 355;
+export const DIMENSION = VALUE_MAX - VALUE_MIN + 1;
+export const ALPHA = 0.5;
+export function parseNumbers(text) {
+    const runs = [];
+    let current = [];
+    let previousEnd = 0;
+    for (const match of String(text).matchAll(/\d+/g)) {
+        const separator = String(text).slice(previousEnd, match.index);
+        const value = Number(match[0]);
+        if (current.length && /\p{L}/u.test(separator)) {
+            runs.push(current);
+            current = [];
+        }
+        if (value >= VALUE_MIN && value <= VALUE_MAX)
+            current.push(value);
+        previousEnd = match.index + match[0].length;
+    }
+    if (current.length)
+        runs.push(current);
+    return runs.reduce((best, run) => run.length > best.length ? run : best, []);
+}
+export function countNumbers(numbers) {
+    const counts = Array(DIMENSION).fill(0);
+    numbers.forEach((number) => { counts[number - VALUE_MIN] += 1; });
+    return counts;
+}
+function mean(values) {
+    return values.reduce((total, value) => total + value, 0) / values.length;
+}
+function standardize(values) {
+    const center = mean(values);
+    const variance = mean(values.map((value) => (value - center) ** 2));
+    const scale = Math.max(Math.sqrt(variance), 1e-12);
+    return values.map((value) => (value - center) / scale);
+}
+function dot(left, right) {
+    let value = 0;
+    for (let index = 0; index < left.length; index += 1)
+        value += left[index] * right[index];
+    return value;
+}
+function norm(values) {
+    return Math.sqrt(dot(values, values));
+}
+function normalized(values) {
+    const scale = Math.max(norm(values), 1e-12);
+    return values.map((value) => value / scale);
+}
+function subtractBasis(values, basis) {
+    const output = values.slice();
+    for (const vector of basis || []) {
+        const projection = dot(output, vector);
+        for (let index = 0; index < output.length; index += 1)
+            output[index] -= projection * vector[index];
+    }
+    return output;
+}
+export function hellingerFeature(counts) {
+    const total = counts.reduce((sum, value) => sum + value, 0) + ALPHA * DIMENSION;
+    return counts.map((value) => Math.sqrt((value + ALPHA) / total));
+}
+function splitIntoFour(values) {
+    const base = Math.floor(values.length / 4);
+    const remainder = values.length % 4;
+    const chunks = [];
+    let start = 0;
+    for (let index = 0; index < 4; index += 1) {
+        const size = base + (index < remainder ? 1 : 0);
+        chunks.push(values.slice(start, start + size));
+        start += size;
+    }
+    return chunks;
+}
+export function orderedBlockFeature(numbers) {
+    const pieces = [];
+    for (const chunk of splitIntoFour(numbers)) {
+        const bins = Array(16).fill(0.5);
+        for (const value of chunk) {
+            const index = Math.min(15, Math.floor(((value - 1) / 355) * 16));
+            bins[index] += 1;
+        }
+        const total = bins.reduce((sum, value) => sum + value, 0);
+        pieces.push(...bins.map((value) => Math.sqrt(value / total)));
+    }
+    const lastDigits = Array(10).fill(0.5);
+    numbers.forEach((value) => { lastDigits[value % 10] += 1; });
+    const lastTotal = lastDigits.reduce((sum, value) => sum + value, 0);
+    pieces.push(...lastDigits.map((value) => Math.sqrt(value / lastTotal)));
+    return pieces;
+}
+function robustScoreCounts(counts, bank) {
+    const artifact = bank.robust.hellinger;
+    const feature = hellingerFeature(counts);
+    let projected = feature.map((value, index) => (value - artifact.feature_mean[index]) / artifact.feature_scale[index]);
+    projected = subtractBasis(projected, artifact.nuisance_basis);
+    projected = normalized(projected);
+    const scores = artifact.centroids.map((centroid) => dot(projected, centroid));
+    return standardize(scores);
+}
+function orderedBlockScores(numbers, bank) {
+    const artifact = bank.robust.ordered_blocks;
+    const feature = orderedBlockFeature(numbers);
+    const standardizedFeature = feature.map((value, index) => (value - artifact.feature_mean[index]) / artifact.feature_scale[index]);
+    const unit = normalized(standardizedFeature);
+    const environmentScores = artifact.environment_centroids.map((centroids) => centroids.map((centroid) => dot(unit, centroid)));
+    const template = standardize(artifact.centroids.map((_, modelIndex) => Math.max(...environmentScores.map((scores) => scores[modelIndex]))));
+    const projected = normalized(subtractBasis(standardizedFeature, artifact.nuisance_basis));
+    const nuisance = standardize(artifact.centroids.map((centroid) => dot(projected, centroid)));
+    return standardize(template.map((value, index) => 0.5 * value + 0.5 * nuisance[index]));
+}
+export function robustScoreNumbers(numbers, bank) {
+    const marginal = robustScoreCounts(countNumbers(numbers), bank);
+    const artifact = bank.robust.ordered_blocks;
+    const weight = artifact ? Number(artifact.weight || 0) : 0;
+    if (!artifact || weight === 0)
+        return marginal;
+    const ordered = orderedBlockScores(numbers, bank);
+    return marginal.map((value, index) => (1 - weight) * value + weight * ordered[index]);
+}

package/third_party/lm-fingerprint/core/positional.mjs

@@ -0,0 +1,64 @@
+import { countNumbers, hellingerFeature, orderedBlockFeature } from "./fingerprint-core.mjs";
+/** Mirrors projects/offline/positional_core.py; block order and weights must match the export. */
+const WEIGHTS = [.6, .15, .125, .125];
+const CENTRES = Array.from({ length: 24 }, (_, i) => 1 + i * 354 / 23);
+const LAGS = [1, 2, 3, 5, 8, 13, 21, 34];
+const mean = (values) => values.reduce((sum, x) => sum + x, 0) / values.length;
+const fraction = (length, test) => {
+    let hits = 0;
+    for (let i = 0; i < length; i++)
+        if (test(i))
+            hits++;
+    return hits / length;
+};
+function positionKernel(x) {
+    const n = x.length, out = Array(34 * 3).fill(0);
+    x.forEach((value, position) => {
+        const t = (position + .5) * 2 / n - 1, basis = [t, .5 * (3 * t * t - 1), .5 * (5 * t ** 3 - 3 * t)];
+        const features = [...CENTRES.map(centre => Math.exp(-.5 * ((value - centre) / 20) ** 2)),
+            ...Array.from({ length: 10 }, (_, digit) => digit === value % 10 ? 1 : 0)];
+        features.forEach((weight, k) => basis.forEach((b, j) => { out[k * 3 + j] += weight * b / n; }));
+    });
+    return out;
+}
+function centredTransitions(symbols, bins) {
+    const joint = Array(bins * bins).fill(.5), total = symbols.length - 1 + .5 * bins * bins;
+    for (let i = 1; i < symbols.length; i++)
+        joint[symbols[i - 1] * bins + symbols[i]] += 1;
+    for (let i = 0; i < joint.length; i++)
+        joint[i] /= total;
+    const rows = Array.from({ length: bins }, (_, a) => joint.slice(a * bins, a * bins + bins).reduce((s, v) => s + v, 0));
+    const columns = Array.from({ length: bins }, (_, b) => rows.reduce((s, _, a) => s + joint[a * bins + b], 0));
+    return joint.map((value, i) => value - rows[Math.floor(i / bins)] * columns[i % bins]);
+}
+function sequenceFeatures(x) {
+    const n = x.length, m = mean(x), sd = Math.max(Math.sqrt(mean(x.map(v => (v - m) ** 2))), 1);
+    const s = x.map(v => (v - m) / sd), out = [];
+    for (const lag of LAGS) {
+        const count = n - lag, d = Array.from({ length: count }, (_, i) => x[i + lag] - x[i]);
+        out.push(mean(d.map((_, i) => s[i + lag] * s[i])), mean(d.map(Math.abs)) / 355, fraction(count, i => d[i] > 0), fraction(count, i => d[i] === 0), fraction(count, i => Math.abs(d[i]) <= 5), fraction(count, i => Math.abs(d[i]) <= 20));
+    }
+    out.push(...centredTransitions(x.map(v => Math.min(7, Math.floor((v - 1) * 8 / 355))), 8));
+    out.push(...centredTransitions(x.map(v => v % 10), 10));
+    const difference = Array.from({ length: n - 1 }, (_, i) => x[i + 1] - x[i]);
+    const zStep = Array.from({ length: n - 1 }, (_, i) => Math.abs(s[i + 1] - s[i]));
+    out.push(fraction(n - 2, i => Math.sign(difference[i + 1]) === Math.sign(difference[i])), fraction(n - 2, i => difference[i + 1] === difference[i]), fraction(n - 1, i => x[i] % 10 === x[i + 1] % 10), fraction(n - 1, i => zStep[i] > 1), fraction(n - 1, i => zStep[i] > 2));
+    const buckets = x.map(v => Math.min(15, Math.floor((v - 1) * 16 / 355)));
+    for (const width of [4, 8, 16]) {
+        let sum = 0;
+        for (let i = 0; i + width <= n; i++)
+            sum += new Set(buckets.slice(i, i + width)).size / width;
+        out.push(sum / (n - width + 1));
+    }
+    return out;
+}
+/** Per-answer decision values over identities. */
+export function positionalDecision(numbers, head) {
+    const parts = [hellingerFeature(countNumbers(numbers)), orderedBlockFeature(numbers), positionKernel(numbers), sequenceFeatures(numbers)];
+    const x = parts.flatMap((block, j) => {
+        const p = head.params[j], scaled = block.map((v, i) => (v - p.mean[i]) / p.scale[i]);
+        const length = Math.max(Math.sqrt(scaled.reduce((sum, v) => sum + v * v, 0)), 1e-12);
+        return scaled.map((v) => v / length * Math.sqrt(WEIGHTS[j]));
+    });
+    return head.weights.map((row, k) => row.reduce((sum, w, i) => sum + w * x[i], head.bias[k]));
+}

package/third_party/lm-fingerprint/core/shared-detector.mjs

@@ -0,0 +1,132 @@
+import { countNumbers, hellingerFeature, orderedBlockFeature, parseNumbers } from "./fingerprint-core.mjs";
+import { positionalDecision } from "./positional.mjs";
+const dot = (a, b) => a.reduce((sum, x, i) => sum + x * b[i], 0);
+const mean = (a) => a.reduce((sum, x) => sum + x, 0) / a.length;
+const norm = (a) => { const n = Math.max(Math.sqrt(dot(a, a)), 1e-12); return a.map(x => x / n); };
+const z = (a) => { const m = mean(a), s = Math.max(Math.sqrt(mean(a.map(x => (x - m) ** 2))), 1e-12); return a.map(x => (x - m) / s); };
+const columnMean = (a) => a[0].map((_, i) => mean(a.map(r => r[i])));
+const median = (a) => { const v = [...a].sort((x, y) => x - y), i = Math.floor(v.length / 2); return v.length % 2 ? v[i] : (v[i - 1] + v[i]) / 2; };
+const blocks = (n) => [hellingerFeature(countNumbers(n)), orderedBlockFeature(n)];
+const transform = (b, p) => b.flatMap((v, j) => norm(v.map((x, i) => (x - p[j].mean[i]) / p[j].scale[i])).map(x => x * Math.sqrt(j === 0 ? .75 : .25)));
+const centered = (v, p) => v.map((x, i) => (x - p.feature_mean[i]) / p.feature_scale[i]);
+const subtract = (v, b) => {
+    const coefficients = b.map(row => dot(v, row));
+    return v.map((x, i) => x - b.reduce((sum, row, j) => sum + coefficients[j] * row[i], 0));
+};
+const referenceNorms = new WeakMap();
+function nearest(x, references) {
+    let norms = referenceNorms.get(references);
+    if (!norms) {
+        norms = references.map(r => dot(r, r));
+        referenceNorms.set(references, norms);
+    }
+    const xx = dot(x, x);
+    return mean(references.map((r, i) => Math.max(0, xx + norms[i] - 2 * dot(x, r))).sort((a, b) => a - b).slice(0, 7));
+}
+function baseline(b, bank) {
+    const h = bank.hellinger, o = bank.ordered_blocks;
+    const hUnit = norm(subtract(centered(b[0], h), h.nuisance_basis));
+    const marginal = h.centroids.map(row => dot(hUnit, row));
+    const oCentered = centered(b[1], o), raw = norm(oCentered), projected = norm(subtract(oCentered, o.nuisance_basis));
+    const templates = o.centroids.map((_, i) => Math.max(...o.environment_centroids.map(rows => dot(raw, rows[i]))));
+    const nuisance = o.centroids.map(row => dot(projected, row));
+    const tz = z(templates), nz = z(nuisance), ordered = z(tz.map((v, i) => .5 * v + .5 * nz[i])), mz = z(marginal);
+    return mz.map((v, i) => .5 * v + .5 * ordered[i]);
+}
+export function supportsSharedDetector(bank, artifact) {
+    return artifact.schema === 'shared-detector-v2' && bank.built_at === artifact.bank_built_at &&
+        bank.models.length === artifact.model_ids.length && bank.models.every((m, i) => m.id === artifact.model_ids[i] && m.response_count === artifact.response_counts[i]);
+}
+/**
+ * Closest models by the ranker's k-nearest-reference distance. Distances are relative to the
+ * model's own leave-one-out spread, so 1 means as close as the model's own references.
+ */
+export function nearestModels(artifact, count = 5) {
+    const references = artifact.ranker.references;
+    return references.map((own, a) => {
+        const spread = median(own.map((x, i) => nearest(x, own.filter((_, j) => j !== i))));
+        return references.map((other, b) => ({ model: artifact.model_ids[b], distance: median(own.map(x => nearest(x, other))) / spread }))
+            .filter((_, b) => b !== a).sort((x, y) => x.distance - y.distance).slice(0, count);
+    });
+}
+/** Closed-set probabilities from the calibration bound to this ranker; null when none matches. */
+export function calibrateRanking(ranking, artifact) {
+    const head = artifact.calibration, binding = head?.binding;
+    if (!head || !binding || head.schema !== 'shared-confidence-v2' || head.method !== 'ranking-temperature' ||
+        !Number.isFinite(head.tau) || head.tau < .001 || head.tau > 1000 ||
+        binding.base_sha256 !== artifact.base_sha256 || binding.reference_sha256 !== artifact.source_reference_sha256 ||
+        binding.model_ids.length !== ranking.length || ranking.length !== artifact.model_ids.length || !ranking.every(Number.isFinite) ||
+        !binding.model_ids.every((id, i) => id === artifact.model_ids[i]))
+        return null;
+    const logits = ranking.map(score => head.tau * score);
+    const maximum = Math.max(...logits), weights = logits.map(value => Math.exp(value - maximum)), sum = weights.reduce((a, b) => a + b, 0);
+    return weights.map(value => value / sum);
+}
+function rankSharedNumbers(numbers, artifact) {
+    const a = artifact.ranker, full = numbers.map(blocks);
+    const ax = full.map(b => transform(b, a.full_params));
+    const lda = numbers.map(n => {
+        const x = transform(blocks(n.slice(0, 128)), a.head_params);
+        return z(a.lda_weights.map((row, i) => dot(row, x) + a.lda_bias[i]));
+    });
+    const l = z(columnMean(lda)), near = z(a.references.map(ref => median(ax.map(x => -nearest(x, ref)))));
+    const base = z(columnMean(full.map(b => baseline(b, a.bank))));
+    const frequency = z(l.map((x, i) => .5 * x + .25 * near[i] + .25 * base[i]));
+    const positional = z(columnMean(numbers.map(n => z(positionalDecision(n, a.positional)))));
+    const ranking = frequency.map((x, i) => a.blend.frequency * x + a.blend.positional * positional[i]);
+    if (!ranking.every(Number.isFinite))
+        throw new Error('排名计算产生无效数值，请刷新后重试');
+    return ranking;
+}
+export function analyzeSharedOutputs(outputs, bank, artifact, options = {}) {
+    if (!supportsSharedDetector(bank, artifact))
+        throw new Error('The reference bank does not match the detector. Run fpd retrain --data-dir DIR for this bank.');
+    const parsed = outputs.map(o => parseNumbers(o.text));
+    const diagnostics = outputs.map((o, index) => {
+        const minimum = Math.max(80, Math.ceil((o.expected_count || 0) * .55));
+        const raw = Array.from(o.text.matchAll(/-?\d+/g), m => Number(m[0]));
+        return { index, parsed_numbers: parsed[index].length, minimum_numbers: minimum,
+            accepted: parsed[index].length >= minimum, raw_out_of_range_count: raw.filter(n => n < 1 || n > 355).length };
+    });
+    const used = diagnostics.filter(d => d.accepted).length;
+    const common = { probability: null, probability_status: 'unavailable',
+        used_outputs: used, diagnostics, method: 'shared-detector-v2',
+        model_version: { base_sha256: artifact.base_sha256 } };
+    if (options.allowPartial && used > 0 && used < 3 && outputs.length <= 3) {
+        const ranking = rankSharedNumbers(parsed.filter((_, i) => diagnostics[i].accepted), artifact);
+        const order = artifact.model_ids.map((_, i) => i).sort((i, j) => ranking[j] - ranking[i]);
+        const results = order.map(i => ({ model: artifact.model_ids[i], display_name: bank.models[i].display_name,
+            family: bank.models[i].family, family_name: bank.models[i].family_name, score: ranking[i], probability: null }));
+        const first = order[0];
+        return { ...common, method: 'shared-ranker-partial-v1', decision: 'partial',
+            prediction: results[0].model, prediction_name: results[0].display_name,
+            family_prediction: bank.models[first].family, family_prediction_name: bank.models[first].family_name,
+            results, ranking_score: ranking[first], calibration: null,
+            evidence: { insufficient: true, label: '部分样本排名',
+                reason: `使用 ${used}/3 条有效回答生成排名。补齐三条有效回答后才能计算置信度。`,
+                threshold: null, method: 'partial-sample-ranking' } };
+    }
+    if (outputs.length !== 3 || used !== 3)
+        return { ...common, prediction: '', prediction_name: '暂不可评分',
+            family_prediction_name: '', results: [], decision: 'unscorable', evidence: { insufficient: true,
+                label: '需要三条完整回答', reason: `当前有 ${used}/${outputs.length} 条有效回答。请补齐原来的三条回答后重新检测。`,
+                threshold: null, method: 'complete-three-answers' } };
+    const ranking = rankSharedNumbers(parsed, artifact);
+    const probabilities = calibrateRanking(ranking, artifact);
+    const order = artifact.model_ids.map((_, i) => i).sort((i, j) => ranking[j] - ranking[i]);
+    const results = order.map(i => ({ model: artifact.model_ids[i], display_name: bank.models[i].display_name,
+        family: bank.models[i].family, family_name: bank.models[i].family_name, score: ranking[i],
+        probability: probabilities?.[i] ?? null }));
+    const first = order[0];
+    return { ...common, prediction: results[0].model, prediction_name: results[0].display_name,
+        family_prediction: bank.models[first].family, family_prediction_name: bank.models[first].family_name,
+        results, ranking_score: ranking[first], probability: results[0].probability,
+        probability_status: probabilities ? 'reference_calibrated' : 'unavailable',
+        probability_scope: probabilities ? 'reference-closed-set' : null,
+        calibration: probabilities ? { method: artifact.calibration.method, run: artifact.calibration.calibration_run,
+            tau: artifact.calibration.tau, sha256: artifact.calibration_sha256 ?? null } : null,
+        evidence: { insufficient: true,
+            label: probabilities ? '库内校准排名' : '未校准排名',
+            reason: probabilities ? '置信度是参考库内的闭集相对概率，不包含库外模型。' : '校准参数与当前检测器不匹配，置信度不可用。候选顺序由排名分数决定。',
+            threshold: null, method: probabilities ? 'reference-calibrated-ranking' : 'uncalibrated-ranking' } };
+}