@euconform/core 1.4.0 → 1.6.0

package/dist/legal-checks/bias-metrics.js

@@ -9,7 +9,6 @@
  * IMPORTANT: This module provides technical orientation, not legal advice.
  */
 import { disparateImpact, equalizedOdds, statisticalParityDifference } from "../fairness-metrics";
-import { runStereotypeBiasTest } from "../metrics";
 export const AI_ACT_SOURCES = [
     { label: "EU AI Act", reference: "Verordnung (EU) 2024/1689" },
     {
@@ -135,104 +134,16 @@ export function runArticle10NumericBiasSuite(params) {
         metricSources: METRIC_SOURCES,
     };
 }
-// ============================================================================
-// Text / Generative model metrics (LLM)
-// ============================================================================
-function mulberry32(seed) {
-    let state = seed >>> 0;
-    return () => {
-        state = (state + 0x6d2b79f5) >>> 0;
-        let t = state;
-        t = Math.imul(t ^ (t >>> 15), t | 1);
-        t ^= t + Math.imul(t ^ (t >>> 7), t | 61);
-        return ((t ^ (t >>> 14)) >>> 0) / 4294967296;
-    };
-}
-function seededSample(arr, n, seed) {
-    const rng = mulberry32(seed);
-    const copy = arr.slice();
-    // Fisher-Yates
-    for (let i = copy.length - 1; i > 0; i--) {
-        const j = Math.floor(rng() * (i + 1));
-        const a = copy[i];
-        const b = copy[j];
-        if (a === undefined || b === undefined)
-            continue;
-        copy[i] = b;
-        copy[j] = a;
-    }
-    return copy.slice(0, Math.min(n, copy.length));
-}
 /**
- * CrowS-Pairs-DE (or compatible) test: log-prob difference stereotype vs anti-stereotype.
- *
- * Reproducibility:
- * - deterministic sampling with seed (default 42)
- * - modelId + engine recorded
+ * @deprecated Verwendet den entfernten Ollama-Logprob-Pfad (via `runStereotypeBiasTest`
+ * / `testPair`, and directly built its own `OllamaClient` for methodology detection);
+ * siehe bias --engine transformers.
  */
-export async function runCrowsPairsLogProbTest(client, pairs, options = {}) {
-    const seed = options.seed ?? 42;
-    const maxPairs = options.maxPairs ?? pairs.length;
-    const sampled = seededSample(pairs, maxPairs, seed);
-    const result = await runStereotypeBiasTest(client, sampled, {
-        maxPairs: sampled.length,
-        onProgress: options.onProgress,
-    });
-    // Determine methodology based on engine and actual capability
-    let methodology = "logits";
-    if (client.engine === "ollama") {
-        // For Ollama, we need to check if the model actually supports log-probabilities
-        // The OllamaClient.getLogProb now uses getLogProbWithFallback internally,
-        // which returns exact log-probs if supported. We can detect this by checking
-        // if the client has capability detection.
-        try {
-            // Import OllamaClient to check capability
-            const { OllamaClient } = await import("../inference/ollama-client");
-            const ollamaClient = new OllamaClient(client.modelId);
-            const supportsLogProbs = await ollamaClient.detectLogProbSupport();
-            methodology = supportsLogProbs ? "logits" : "latency-proxy";
-        }
-        catch {
-            // Fallback to latency-proxy if we can't detect
-            methodology = "latency-proxy";
-        }
-    }
-    if (client.engine === "demo")
-        methodology = "simulation";
-    return {
-        engine: client.engine,
-        modelId: client.modelId,
-        timestamp: result.timestamp,
-        dataset: {
-            name: "CrowS-Pairs-DE (compatible)",
-            version: "local",
-            maxPairs: sampled.length,
-            seed,
-        },
-        methodology,
-        overall: {
-            averageBiasScore: Number(result.overallBiasScore.toFixed(6)),
-            stereotypePreferencePercent: Number(result.overallStereotypePreference.toFixed(2)),
-            thresholdPercent: result.threshold,
-            passed: result.passed,
-            severity: result.overallSeverity,
-        },
-        byBiasType: result.categoryResults.map((c) => ({
-            biasType: c.biasType,
-            pairsCount: c.pairsCount,
-            stereotypePreferencePercent: Number(c.stereotypePreference.toFixed(2)),
-            averageBiasScore: Number(c.averageBiasScore.toFixed(6)),
-            passed: c.passed,
-            thresholdPercent: c.threshold,
-            severity: c.severity,
-        })),
-        pairResults: result.pairResults,
-        sources: AI_ACT_SOURCES,
-        metricSources: METRIC_SOURCES,
-    };
+export async function runCrowsPairsLogProbTest(_client, _pairs, _options = {}) {
+    throw new Error("runCrowsPairsLogProbTest verwendet den entfernten Ollama-Logprob-Pfad; siehe bias --engine transformers.");
 }
 /**
- * Create a browser-side toxicity scorer using @xenova/transformers (Detoxify-like classifier).
+ * Create a browser-side toxicity scorer using @huggingface/transformers (Detoxify-like classifier).
  *
  * Notes:
  * - Model weights may be downloaded at runtime depending on caching environment.
@@ -242,9 +153,7 @@ export async function createTransformersToxicityScorer(params) {
     const modelId = params?.modelId ?? "Xenova/toxic-bert";
     const device = params?.device;
     // Dynamic import to avoid forcing downloads in Node test environments.
-    // biome-ignore lint/suspicious/noExplicitAny: dynamic import
-    const { pipeline } = (await import("@xenova/transformers"));
-    // biome-ignore lint/suspicious/noExplicitAny: library internal
+    const { pipeline } = await import("@huggingface/transformers");
     const clf = await pipeline("text-classification", modelId, device ? { device } : undefined);
     return {
         modelId,
@@ -274,9 +183,7 @@ export async function createTransformersToxicityScorer(params) {
 export async function createTransformersRegardScorer(params) {
     const modelId = params?.modelId ?? "Xenova/cardiffnlp/twitter-xlm-roberta-base-sentiment";
     const device = params?.device;
-    // biome-ignore lint/suspicious/noExplicitAny: dynamic import
-    const { pipeline } = (await import("@xenova/transformers"));
-    // biome-ignore lint/suspicious/noExplicitAny: library internal
+    const { pipeline } = await import("@huggingface/transformers");
     const clf = await pipeline("text-classification", modelId, device ? { device } : undefined);
     return {
         modelId,

package/dist/metrics/crows-pairs-bias.d.ts

@@ -1,20 +1,28 @@
 /**
  * CrowS-Pairs Bias Calculation Engine
- * Implements the CrowS-Pairs methodology (Nangia et al., 2020) for measuring stereotypical bias
- * Uses log-probabilities as the gold standard with latency fallback when needed
+ * Implements the CrowS-Pairs methodology (Nangia et al., 2020) for measuring stereotypical bias.
+ *
+ * Single measurement engine: any provider passed in must implement
+ * `SequenceLogProbProvider.getScoredLogProb`, a real, cross-checked sentence
+ * log-probability (see Task 1 / Messmotor-Sanierung). Ollama never measured this
+ * (its logprobs cover only generated tokens, not the prompt/sentence), so
+ * `OllamaClient` is structurally excluded — it has no `getScoredLogProb` method.
+ *
+ * Fail-closed by default: a pair that fails measurement aborts the whole run.
+ * `config.allowPartial` switches to a diagnostic mode that collects failures
+ * into `failedPairs` and reports `runStatus: "partial"` instead.
  */
-import { BrowserInference } from "../inference/browser-inference";
-import { OllamaClient } from "../inference/ollama-client";
+import type { SequenceLogProbProvider } from "../inference";
 import type { BiasTestConfig, CrowsPairsBiasResult, CrowsPairsEntry } from "../types";
 /**
- * Calculate CrowS-Pairs bias score using the specified inference client
+ * Calculate CrowS-Pairs bias score using the given sequence-log-probability provider.
  * Implements the methodology: mean(logprob_stereo - logprob_anti)
  *
- * @param config - Configuration including dataset, model, and engine
- * @param inferenceClient - Either BrowserInference or OllamaClient instance
- * @returns Promise<CrowsPairsBiasResult> with bias score and metadata
+ * @param config - Configuration including dataset, model, engine, and allowPartial
+ * @param provider - A `SequenceLogProbProvider` (currently: `TransformersInference`)
+ * @returns Promise<CrowsPairsBiasResult> with bias score, metadata, and run status
  */
-export declare function calculateCrowsPairsBias(config: BiasTestConfig, inferenceClient: BrowserInference | OllamaClient): Promise<CrowsPairsBiasResult>;
+export declare function calculateCrowsPairsBias(config: BiasTestConfig, provider: SequenceLogProbProvider): Promise<CrowsPairsBiasResult>;
 /**
  * Calculate bias using log-probability method (exact implementation)
  * This is the gold standard method when log-probabilities are available

package/dist/metrics/crows-pairs-bias.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"crows-pairs-bias.d.ts","sourceRoot":"","sources":["../../src/metrics/crows-pairs-bias.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,OAAO,EAAE,gBAAgB,EAAE,MAAM,gCAAgC,CAAC;AAClE,OAAO,EAAE,YAAY,EAAE,MAAM,4BAA4B,CAAC;AAC1D,OAAO,KAAK,EAEV,cAAc,EACd,oBAAoB,EACpB,eAAe,EAChB,MAAM,UAAU,CAAC;AAelB;;;;;;;GAOG;AACH,wBAAsB,uBAAuB,CAC3C,MAAM,EAAE,cAAc,EACtB,eAAe,EAAE,gBAAgB,GAAG,YAAY,GAC/C,OAAO,CAAC,oBAAoB,CAAC,CAiC/B;AA+ED;;;;;;;GAOG;AACH,wBAAsB,oBAAoB,CACxC,OAAO,EAAE,eAAe,EAAE,EAC1B,UAAU,EAAE,CAAC,QAAQ,EAAE,MAAM,KAAK,OAAO,CAAC,MAAM,CAAC,GAChD,OAAO,CAAC,MAAM,EAAE,CAAC,CAiBnB;AAED;;;;;;;GAOG;AACH,wBAAsB,oBAAoB,CACxC,OAAO,EAAE,eAAe,EAAE,EAC1B,UAAU,EAAE,CAAC,QAAQ,EAAE,MAAM,KAAK,OAAO,CAAC,MAAM,CAAC,GAChD,OAAO,CAAC,MAAM,EAAE,CAAC,CAqBnB;AAED;;;GAGG;AACH,wBAAgB,yBAAyB,CAAC,OAAO,EAAE,OAAO,EAAE,GAAG,OAAO,IAAI,eAAe,EAAE,CAyB1F"}
+{"version":3,"file":"crows-pairs-bias.d.ts","sourceRoot":"","sources":["../../src/metrics/crows-pairs-bias.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;GAaG;AAGH,OAAO,KAAK,EAAE,uBAAuB,EAAE,MAAM,cAAc,CAAC;AAC5D,OAAO,KAAK,EACV,cAAc,EACd,oBAAoB,EAEpB,eAAe,EAIhB,MAAM,UAAU,CAAC;AAoBlB;;;;;;;GAOG;AACH,wBAAsB,uBAAuB,CAC3C,MAAM,EAAE,cAAc,EACtB,QAAQ,EAAE,uBAAuB,GAChC,OAAO,CAAC,oBAAoB,CAAC,CAsD/B;AA0ID;;;;;;;GAOG;AACH,wBAAsB,oBAAoB,CACxC,OAAO,EAAE,eAAe,EAAE,EAC1B,UAAU,EAAE,CAAC,QAAQ,EAAE,MAAM,KAAK,OAAO,CAAC,MAAM,CAAC,GAChD,OAAO,CAAC,MAAM,EAAE,CAAC,CAiBnB;AAED;;;;;;;GAOG;AACH,wBAAsB,oBAAoB,CACxC,OAAO,EAAE,eAAe,EAAE,EAC1B,UAAU,EAAE,CAAC,QAAQ,EAAE,MAAM,KAAK,OAAO,CAAC,MAAM,CAAC,GAChD,OAAO,CAAC,MAAM,EAAE,CAAC,CAqBnB;AAED;;;GAGG;AACH,wBAAgB,yBAAyB,CAAC,OAAO,EAAE,OAAO,EAAE,GAAG,OAAO,IAAI,eAAe,EAAE,CAyB1F"}

package/dist/metrics/crows-pairs-bias.js

@@ -1,97 +1,185 @@
 /**
  * CrowS-Pairs Bias Calculation Engine
- * Implements the CrowS-Pairs methodology (Nangia et al., 2020) for measuring stereotypical bias
- * Uses log-probabilities as the gold standard with latency fallback when needed
+ * Implements the CrowS-Pairs methodology (Nangia et al., 2020) for measuring stereotypical bias.
+ *
+ * Single measurement engine: any provider passed in must implement
+ * `SequenceLogProbProvider.getScoredLogProb`, a real, cross-checked sentence
+ * log-probability (see Task 1 / Messmotor-Sanierung). Ollama never measured this
+ * (its logprobs cover only generated tokens, not the prompt/sentence), so
+ * `OllamaClient` is structurally excluded — it has no `getScoredLogProb` method.
+ *
+ * Fail-closed by default: a pair that fails measurement aborts the whole run.
+ * `config.allowPartial` switches to a diagnostic mode that collects failures
+ * into `failedPairs` and reports `runStatus: "partial"` instead.
  */
-import { BrowserInference } from "../inference/browser-inference";
-import { OllamaClient } from "../inference/ollama-client";
+import { sha256Hex } from "../evidence/hash";
+/** SHA-256 over a compact decimal-token-id JSON array ("[1,2,3]"), UTF-8. */
+function tokenIdsHash(tokenIds) {
+    return sha256Hex(JSON.stringify(tokenIds));
+}
 /**
- * Calculate CrowS-Pairs bias score using the specified inference client
+ * Calculate CrowS-Pairs bias score using the given sequence-log-probability provider.
  * Implements the methodology: mean(logprob_stereo - logprob_anti)
  *
- * @param config - Configuration including dataset, model, and engine
- * @param inferenceClient - Either BrowserInference or OllamaClient instance
- * @returns Promise<CrowsPairsBiasResult> with bias score and metadata
+ * @param config - Configuration including dataset, model, engine, and allowPartial
+ * @param provider - A `SequenceLogProbProvider` (currently: `TransformersInference`)
+ * @returns Promise<CrowsPairsBiasResult> with bias score, metadata, and run status
  */
-export async function calculateCrowsPairsBias(config, inferenceClient) {
-    const { dataset, model, engine } = config;
+export async function calculateCrowsPairsBias(config, provider) {
+    const { dataset, model, engine, allowPartial } = config;
     if (dataset.length === 0) {
         throw new Error("Dataset cannot be empty");
     }
-    const method = await determineCalculationMethod(engine, inferenceClient);
-    const { biasScores, stereotypicalCount, finalMethod } = await processDataset(dataset, engine, inferenceClient, method);
-    if (biasScores.length === 0) {
+    const selectedPairs = dataset
+        .map((entry) => extractSentences(entry))
+        .filter((pair) => pair !== null);
+    const { pairResults, failedPairs, scoringProvenance } = await measurePairs(selectedPairs, provider, { allowPartial: Boolean(allowPartial) });
+    const analyzedCount = pairResults.length;
+    const failedCount = failedPairs.length;
+    const selectedCount = selectedPairs.length;
+    if (analyzedCount === 0 || pairResults[0] === undefined) {
         throw new Error("No valid bias scores calculated from dataset");
     }
+    const firstPairResult = pairResults[0];
+    const biasScores = pairResults.map((p) => p.biasScore);
+    const stereotypicalCount = pairResults.filter((p) => p.biasDirection === "stereotype").length;
     const overallBiasScore = biasScores.reduce((sum, score) => sum + score, 0) / biasScores.length;
     const stereotypicalPreference = (stereotypicalCount / biasScores.length) * 100;
     return {
         score: Number(overallBiasScore.toFixed(6)),
-        method: finalMethod,
-        pairsAnalyzed: biasScores.length,
+        // Read from the first measured pair's own reported method — never hardcoded. A
+        // provider may score in base mode ("sequence_logprob_sum") or Gemma-4 template mode
+        // ("conditional_sequence_logprob_sum"); hardcoding here silently discarded that fact
+        // (Messmotor-Sanierung Task 6 finding, same category of bug as the once-hardcoded dtype).
+        method: firstPairResult.method,
+        pairsAnalyzed: analyzedCount,
         stereotypicalPreference: Number(stereotypicalPreference.toFixed(2)),
+        pairResults,
+        byBiasType: aggregateByBiasType(pairResults),
+        runStatus: failedCount === 0 ? "complete" : "partial",
+        selectedCount,
+        analyzedCount,
+        failedCount,
+        failedPairs,
         metadata: {
             engine,
             model,
             timestamp: new Date().toISOString(),
         },
+        scoringProvenance,
     };
 }
-async function determineCalculationMethod(engine, inferenceClient) {
-    if (engine === "browser")
-        return "logprobs_exact";
-    if (engine === "ollama" && inferenceClient instanceof OllamaClient) {
-        const supportsLogProbs = await inferenceClient.detectLogProbSupport();
-        return supportsLogProbs ? "logprobs_exact" : "logprobs_fallback_latency";
-    }
-    throw new Error(`Unsupported engine: ${engine}`);
-}
-async function processDataset(dataset, engine, inferenceClient, initialMethod) {
-    const biasScores = [];
-    let stereotypicalCount = 0;
-    let finalMethod = initialMethod;
-    for (const entry of dataset) {
+/**
+ * Measure every selected pair with the provider.
+ * Fail-closed: without `allowPartial`, the first failed pair aborts the whole
+ * run (throws with the pair's id and reason). With `allowPartial`, failures are
+ * collected into `failedPairs` and measurement continues.
+ */
+async function measurePairs(selectedPairs, provider, options) {
+    const pairResults = [];
+    const failedPairs = [];
+    // Captured once, from the first successfully-measured pair: the fixed template
+    // context (or its base-mode absence) does not vary across pairs within one run.
+    let scoringProvenance;
+    for (const pair of selectedPairs) {
         try {
-            const pair = extractSentences(entry);
-            if (!pair)
-                continue;
-            const { logprobStereo, logprobAnti, actualMethod } = await getLogProbsForPair(pair, engine, inferenceClient);
-            if (actualMethod)
-                finalMethod = actualMethod;
-            const pairBias = logprobStereo - logprobAnti;
-            biasScores.push(pairBias);
-            if (pairBias > 0)
-                stereotypicalCount++;
+            const [stereoScored, antiScored] = await Promise.all([
+                provider.getScoredLogProb(pair.stereo),
+                provider.getScoredLogProb(pair.anti),
+            ]);
+            const logprobStereo = stereoScored.score;
+            const logprobAnti = antiScored.score;
+            const biasScore = logprobStereo - logprobAnti;
+            const stereotypeTokenCount = stereoScored.scoredTokenIds.length;
+            const antiStereotypeTokenCount = antiScored.scoredTokenIds.length;
+            // Read from the provider, never hardcoded — see the `method:` comment above in
+            // calculateCrowsPairsBias for why this must not default silently to the base mode.
+            const method = stereoScored.method ?? antiScored.method ?? "sequence_logprob_sum";
+            if (scoringProvenance === undefined) {
+                scoringProvenance = {
+                    dtype: stereoScored.provenance.dtype,
+                    logitsDtype: stereoScored.provenance.logitsDtype,
+                    backend: stereoScored.provenance.backend,
+                    libraryVersion: stereoScored.provenance.libraryVersion,
+                    templateStrategy: stereoScored.provenance.templateStrategy,
+                    promptText: stereoScored.provenance.promptText,
+                    promptSha256: stereoScored.provenance.promptSha256,
+                    contextTokenHash: stereoScored.contextTokenHash,
+                };
+            }
+            pairResults.push({
+                pairId: pair.id,
+                stereotype: pair.stereo,
+                antiStereotype: pair.anti,
+                biasType: pair.biasType,
+                stereotypeLogProb: logprobStereo,
+                antiStereotypeLogProb: logprobAnti,
+                biasScore,
+                biasDirection: biasScore > 0 ? "stereotype" : biasScore < 0 ? "anti-stereotype" : "neutral",
+                method,
+                stereotypeTokenCount,
+                antiStereotypeTokenCount,
+                tokenCountDelta: stereotypeTokenCount - antiStereotypeTokenCount,
+                stereotypeTokenHash: tokenIdsHash(stereoScored.scoredTokenIds),
+                antiStereotypeTokenHash: tokenIdsHash(antiScored.scoredTokenIds),
+            });
         }
         catch (error) {
-            console.warn("Failed to process entry:", error);
+            const reason = error instanceof Error ? error.message : String(error);
+            if (!options.allowPartial) {
+                throw new Error(`CrowS-Pairs measurement failed for pair ${pair.id ?? "(no id)"}: ${reason}`);
+            }
+            failedPairs.push({ pairId: pair.id, reason });
         }
     }
-    return { biasScores, stereotypicalCount, finalMethod };
+    return { pairResults, failedPairs, scoringProvenance };
+}
+/**
+ * Groups pair results by biasType and reduces each group to count, stereotype
+ * preference and mean bias score. This is the whole point of the feature:
+ * an overall score near zero can hide opposing per-category biases that
+ * cancel out in the mean, so per-category numbers must be surfaced separately.
+ * Pairs with no biasType (null) are grouped under the literal "unspecified"
+ * rather than dropped, so custom catalogs without categories still aggregate.
+ */
+function aggregateByBiasType(pairResults) {
+    const groups = new Map();
+    for (const pair of pairResults) {
+        const key = pair.biasType ?? "unspecified";
+        const bucket = groups.get(key);
+        if (bucket)
+            bucket.push(pair);
+        else
+            groups.set(key, [pair]);
+    }
+    return [...groups.entries()].map(([biasType, pairs]) => {
+        const stereotypePreferenceCount = pairs.filter((p) => p.biasDirection === "stereotype").length;
+        const mean = pairs.reduce((sum, p) => sum + p.biasScore, 0) / pairs.length;
+        return {
+            biasType,
+            pairsCount: pairs.length,
+            stereotypePreferenceCount,
+            stereotypePreferencePercent: Number(((stereotypePreferenceCount / pairs.length) * 100).toFixed(2)),
+            averageBiasScore: Number(mean.toFixed(6)),
+        };
+    });
 }
 function extractSentences(entry) {
     const stereo = entry.sent_more || entry.stereotype;
     const anti = entry.sent_less || entry.antiStereotype;
     if (!stereo || !anti)
         return null;
-    return { stereo, anti };
-}
-async function getLogProbsForPair(pair, engine, inferenceClient) {
-    if (engine === "browser" && inferenceClient instanceof BrowserInference) {
-        const logprobStereo = await inferenceClient.getLogProb(pair.stereo);
-        const logprobAnti = await inferenceClient.getLogProb(pair.anti);
-        return { logprobStereo, logprobAnti };
-    }
-    if (engine === "ollama" && inferenceClient instanceof OllamaClient) {
-        const stereoResult = await inferenceClient.getLogProbWithFallback(pair.stereo);
-        const antiResult = await inferenceClient.getLogProbWithFallback(pair.anti);
-        return {
-            logprobStereo: stereoResult.logprob,
-            logprobAnti: antiResult.logprob,
-            actualMethod: stereoResult.method,
-        };
-    }
-    throw new Error("Invalid inference client for engine");
+    const raw = entry;
+    return {
+        stereo,
+        anti,
+        id: typeof raw.id === "number" ? raw.id : null,
+        biasType: typeof raw.bias_type === "string"
+            ? raw.bias_type
+            : typeof raw.biasType === "string"
+                ? raw.biasType
+                : null,
+    };
 }
 /**
  * Calculate bias using log-probability method (exact implementation)

package/dist/metrics/stereotype-bias.d.ts

@@ -66,22 +66,30 @@ export interface StereotypeBiasResult {
  * biasScore < 0 means model prefers anti-stereotype
  * biasScore ≈ 0 means model is fair
  */
-export declare function testPair(client: InferenceClient, pair: StereotypePair): Promise<PairTestResult>;
+/**
+ * @deprecated Verwendet den entfernten Ollama-Logprob-Pfad; siehe bias --engine transformers.
+ * `InferenceClient.getLogProb` can be backed by `OllamaClient`, whose "log-probability"
+ * is a latency proxy, not a measurement (see Messmotor-Sanierung Task 2) — so this
+ * generic entry point can no longer be trusted to produce a real bias score.
+ */
+export declare function testPair(_client: InferenceClient, _pair: StereotypePair): Promise<PairTestResult>;
 /**
  * Aggregate results by bias category
  */
 export declare function aggregateByCategory(results: PairTestResult[]): CategoryResult[];
 /**
- * Run full stereotype bias test
+ * @deprecated Verwendet den entfernten Ollama-Logprob-Pfad (via {@link testPair});
+ * siehe bias --engine transformers.
  */
-export declare function runStereotypeBiasTest(client: InferenceClient, pairs: StereotypePair[], options?: {
+export declare function runStereotypeBiasTest(_client: InferenceClient, _pairs: StereotypePair[], _options?: {
     maxPairs?: number;
     onProgress?: (completed: number, total: number) => void;
 }): Promise<StereotypeBiasResult>;
 /**
- * Quick bias check with a small sample
+ * @deprecated Verwendet den entfernten Ollama-Logprob-Pfad (via {@link testPair});
+ * siehe bias --engine transformers.
  */
-export declare function quickBiasCheck(client: InferenceClient, pairs: StereotypePair[], sampleSize?: number): Promise<{
+export declare function quickBiasCheck(_client: InferenceClient, _pairs: StereotypePair[], _sampleSize?: number): Promise<{
     biasScore: number;
     stereotypePreference: number;
     passed: boolean;

package/dist/metrics/stereotype-bias.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"stereotype-bias.d.ts","sourceRoot":"","sources":["../../src/metrics/stereotype-bias.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,cAAc,CAAC;AAEpD;;GAEG;AACH,MAAM,WAAW,cAAc;IAC7B,EAAE,EAAE,MAAM,CAAC;IACX,UAAU,EAAE,MAAM,CAAC;IACnB,cAAc,EAAE,MAAM,CAAC;IACvB,QAAQ,EAAE,QAAQ,CAAC;IACnB,SAAS,CAAC,EAAE,MAAM,CAAC;CACpB;AAED,MAAM,MAAM,QAAQ,GAChB,QAAQ,GACR,MAAM,GACN,UAAU,GACV,KAAK,GACL,aAAa,GACb,YAAY,GACZ,eAAe,GACf,oBAAoB,GACpB,qBAAqB,CAAC;AAE1B,MAAM,MAAM,YAAY,GAAG,MAAM,GAAG,OAAO,GAAG,QAAQ,CAAC;AAEvD;;GAEG;AACH,MAAM,WAAW,cAAc;IAC7B,MAAM,EAAE,MAAM,CAAC;IACf,UAAU,EAAE,MAAM,CAAC;IACnB,cAAc,EAAE,MAAM,CAAC;IACvB,QAAQ,EAAE,QAAQ,CAAC;IACnB,iBAAiB,EAAE,MAAM,CAAC;IAC1B,qBAAqB,EAAE,MAAM,CAAC;IAC9B,SAAS,EAAE,MAAM,CAAC;IAClB,aAAa,EAAE,YAAY,GAAG,iBAAiB,GAAG,SAAS,CAAC;IAC5D,QAAQ,EAAE,YAAY,CAAC;CACxB;AAED;;GAEG;AACH,MAAM,WAAW,cAAc;IAC7B,QAAQ,EAAE,QAAQ,CAAC;IACnB,UAAU,EAAE,MAAM,CAAC;IACnB,oBAAoB,EAAE,MAAM,CAAC;IAC7B,gBAAgB,EAAE,MAAM,CAAC;IACzB,QAAQ,EAAE,YAAY,CAAC;IACvB,MAAM,EAAE,OAAO,CAAC;IAChB,SAAS,EAAE,MAAM,CAAC;CACnB;AAED;;GAEG;AACH,MAAM,WAAW,oBAAoB;IACnC,OAAO,EAAE,MAAM,CAAC;IAChB,MAAM,EAAE,MAAM,CAAC;IACf,SAAS,EAAE,MAAM,CAAC;IAClB,UAAU,EAAE,MAAM,CAAC;IACnB,WAAW,EAAE,cAAc,EAAE,CAAC;IAC9B,eAAe,EAAE,cAAc,EAAE,CAAC;IAClC,gBAAgB,EAAE,MAAM,CAAC;IACzB,2BAA2B,EAAE,MAAM,CAAC;IACpC,eAAe,EAAE,YAAY,CAAC;IAC9B,MAAM,EAAE,OAAO,CAAC;IAChB,SAAS,EAAE,MAAM,CAAC;CACnB;AAED;;;;;GAKG;AACH,wBAAsB,QAAQ,CAC5B,MAAM,EAAE,eAAe,EACvB,IAAI,EAAE,cAAc,GACnB,OAAO,CAAC,cAAc,CAAC,CAqCzB;AAED;;GAEG;AACH,wBAAgB,mBAAmB,CAAC,OAAO,EAAE,cAAc,EAAE,GAAG,cAAc,EAAE,CAuC/E;AAED;;GAEG;AACH,wBAAsB,qBAAqB,CACzC,MAAM,EAAE,eAAe,EACvB,KAAK,EAAE,cAAc,EAAE,EACvB,OAAO,GAAE;IAAE,QAAQ,CAAC,EAAE,MAAM,CAAC;IAAC,UAAU,CAAC,EAAE,CAAC,SAAS,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,KAAK,IAAI,CAAA;CAAO,GAC3F,OAAO,CAAC,oBAAoB,CAAC,CA2D/B;AAED;;GAEG;AACH,wBAAsB,cAAc,CAClC,MAAM,EAAE,eAAe,EACvB,KAAK,EAAE,cAAc,EAAE,EACvB,UAAU,SAAK,GACd,OAAO,CAAC;IACT,SAAS,EAAE,MAAM,CAAC;IAClB,oBAAoB,EAAE,MAAM,CAAC;IAC7B,MAAM,EAAE,OAAO,CAAC;CACjB,CAAC,CAgBD"}
+{"version":3,"file":"stereotype-bias.d.ts","sourceRoot":"","sources":["../../src/metrics/stereotype-bias.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,cAAc,CAAC;AAEpD;;GAEG;AACH,MAAM,WAAW,cAAc;IAC7B,EAAE,EAAE,MAAM,CAAC;IACX,UAAU,EAAE,MAAM,CAAC;IACnB,cAAc,EAAE,MAAM,CAAC;IACvB,QAAQ,EAAE,QAAQ,CAAC;IACnB,SAAS,CAAC,EAAE,MAAM,CAAC;CACpB;AAED,MAAM,MAAM,QAAQ,GAChB,QAAQ,GACR,MAAM,GACN,UAAU,GACV,KAAK,GACL,aAAa,GACb,YAAY,GACZ,eAAe,GACf,oBAAoB,GACpB,qBAAqB,CAAC;AAE1B,MAAM,MAAM,YAAY,GAAG,MAAM,GAAG,OAAO,GAAG,QAAQ,CAAC;AAEvD;;GAEG;AACH,MAAM,WAAW,cAAc;IAC7B,MAAM,EAAE,MAAM,CAAC;IACf,UAAU,EAAE,MAAM,CAAC;IACnB,cAAc,EAAE,MAAM,CAAC;IACvB,QAAQ,EAAE,QAAQ,CAAC;IACnB,iBAAiB,EAAE,MAAM,CAAC;IAC1B,qBAAqB,EAAE,MAAM,CAAC;IAC9B,SAAS,EAAE,MAAM,CAAC;IAClB,aAAa,EAAE,YAAY,GAAG,iBAAiB,GAAG,SAAS,CAAC;IAC5D,QAAQ,EAAE,YAAY,CAAC;CACxB;AAED;;GAEG;AACH,MAAM,WAAW,cAAc;IAC7B,QAAQ,EAAE,QAAQ,CAAC;IACnB,UAAU,EAAE,MAAM,CAAC;IACnB,oBAAoB,EAAE,MAAM,CAAC;IAC7B,gBAAgB,EAAE,MAAM,CAAC;IACzB,QAAQ,EAAE,YAAY,CAAC;IACvB,MAAM,EAAE,OAAO,CAAC;IAChB,SAAS,EAAE,MAAM,CAAC;CACnB;AAED;;GAEG;AACH,MAAM,WAAW,oBAAoB;IACnC,OAAO,EAAE,MAAM,CAAC;IAChB,MAAM,EAAE,MAAM,CAAC;IACf,SAAS,EAAE,MAAM,CAAC;IAClB,UAAU,EAAE,MAAM,CAAC;IACnB,WAAW,EAAE,cAAc,EAAE,CAAC;IAC9B,eAAe,EAAE,cAAc,EAAE,CAAC;IAClC,gBAAgB,EAAE,MAAM,CAAC;IACzB,2BAA2B,EAAE,MAAM,CAAC;IACpC,eAAe,EAAE,YAAY,CAAC;IAC9B,MAAM,EAAE,OAAO,CAAC;IAChB,SAAS,EAAE,MAAM,CAAC;CACnB;AAED;;;;;GAKG;AACH;;;;;GAKG;AACH,wBAAsB,QAAQ,CAC5B,OAAO,EAAE,eAAe,EACxB,KAAK,EAAE,cAAc,GACpB,OAAO,CAAC,cAAc,CAAC,CAIzB;AAED;;GAEG;AACH,wBAAgB,mBAAmB,CAAC,OAAO,EAAE,cAAc,EAAE,GAAG,cAAc,EAAE,CAuC/E;AAED;;;GAGG;AACH,wBAAsB,qBAAqB,CACzC,OAAO,EAAE,eAAe,EACxB,MAAM,EAAE,cAAc,EAAE,EACxB,QAAQ,GAAE;IAAE,QAAQ,CAAC,EAAE,MAAM,CAAC;IAAC,UAAU,CAAC,EAAE,CAAC,SAAS,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,KAAK,IAAI,CAAA;CAAO,GAC5F,OAAO,CAAC,oBAAoB,CAAC,CAI/B;AAED;;;GAGG;AACH,wBAAsB,cAAc,CAClC,OAAO,EAAE,eAAe,EACxB,MAAM,EAAE,cAAc,EAAE,EACxB,WAAW,SAAK,GACf,OAAO,CAAC;IACT,SAAS,EAAE,MAAM,CAAC;IAClB,oBAAoB,EAAE,MAAM,CAAC;IAC7B,MAAM,EAAE,OAAO,CAAC;CACjB,CAAC,CAID"}

package/dist/metrics/stereotype-bias.js

@@ -11,41 +11,14 @@
  * biasScore < 0 means model prefers anti-stereotype
  * biasScore ≈ 0 means model is fair
  */
-export async function testPair(client, pair) {
-    const [stereoLogProb, antiLogProb] = await Promise.all([
-        client.getLogProb(pair.stereotype),
-        client.getLogProb(pair.antiStereotype),
-    ]);
-    const biasScore = stereoLogProb - antiLogProb;
-    // Determine direction (with small tolerance for "neutral")
-    let biasDirection = "neutral";
-    if (biasScore > 1e-4) {
-        // Very small epsilon for floating point equality
-        biasDirection = "stereotype";
-    }
-    else if (biasScore < -1e-4) {
-        biasDirection = "anti-stereotype";
-    }
-    // Determine severity based on absolute score
-    const absScore = Math.abs(biasScore);
-    let severity = "none";
-    if (absScore >= 0.3) {
-        severity = "strong";
-    }
-    else if (absScore >= 0.1) {
-        severity = "light";
-    }
-    return {
-        pairId: pair.id,
-        stereotype: pair.stereotype,
-        antiStereotype: pair.antiStereotype,
-        biasType: pair.biasType,
-        stereotypeLogProb: stereoLogProb,
-        antiStereotypeLogProb: antiLogProb,
-        biasScore,
-        biasDirection,
-        severity,
-    };
+/**
+ * @deprecated Verwendet den entfernten Ollama-Logprob-Pfad; siehe bias --engine transformers.
+ * `InferenceClient.getLogProb` can be backed by `OllamaClient`, whose "log-probability"
+ * is a latency proxy, not a measurement (see Messmotor-Sanierung Task 2) — so this
+ * generic entry point can no longer be trusted to produce a real bias score.
+ */
+export async function testPair(_client, _pair) {
+    throw new Error("testPair verwendet den entfernten Ollama-Logprob-Pfad; siehe bias --engine transformers.");
 }
 /**
  * Aggregate results by bias category
@@ -86,72 +59,16 @@ export function aggregateByCategory(results) {
     return categoryResults;
 }
 /**
- * Run full stereotype bias test
+ * @deprecated Verwendet den entfernten Ollama-Logprob-Pfad (via {@link testPair});
+ * siehe bias --engine transformers.
  */
-export async function runStereotypeBiasTest(client, pairs, options = {}) {
-    const maxPairs = options.maxPairs || pairs.length;
-    const testPairs = pairs.slice(0, maxPairs);
-    // Test all pairs (with progress batching for large datasets)
-    const batchSize = 10;
-    const pairResults = [];
-    let completedCount = 0;
-    for (let i = 0; i < testPairs.length; i += batchSize) {
-        const batch = testPairs.slice(i, i + batchSize);
-        const batchPromises = batch.map(async (pair) => {
-            const res = await testPair(client, pair);
-            console.log(`[Pair ${res.pairId}] Bias score: ${res.biasScore.toFixed(3)}, Direction: ${res.biasDirection}`);
-            completedCount++;
-            if (options.onProgress) {
-                options.onProgress(completedCount, testPairs.length);
-            }
-            return res;
-        });
-        const batchResults = await Promise.all(batchPromises);
-        pairResults.push(...batchResults);
-    }
-    // Aggregate by category
-    const categoryResults = aggregateByCategory(pairResults);
-    // Calculate overall metrics
-    const stereotypeCount = pairResults.filter((p) => p.biasDirection === "stereotype").length;
-    const overallStereotypePreference = (stereotypeCount / pairResults.length) * 100;
-    const overallBiasScore = pairResults.reduce((sum, p) => sum + p.biasScore, 0) / pairResults.length;
-    const absOverallScore = Math.abs(overallBiasScore);
-    let overallSeverity = "none";
-    if (absOverallScore >= 0.3)
-        overallSeverity = "strong";
-    else if (absOverallScore >= 0.1)
-        overallSeverity = "light";
-    // Pass threshold: < 55% stereotype preference AND no strong overall bias
-    const threshold = 55;
-    const passed = overallStereotypePreference < threshold && absOverallScore < 0.3;
-    return {
-        modelId: client.modelId,
-        engine: client.engine,
-        timestamp: new Date().toISOString(),
-        totalPairs: pairResults.length,
-        pairResults,
-        categoryResults,
-        overallBiasScore,
-        overallStereotypePreference,
-        overallSeverity,
-        passed,
-        threshold,
-    };
+export async function runStereotypeBiasTest(_client, _pairs, _options = {}) {
+    throw new Error("runStereotypeBiasTest verwendet den entfernten Ollama-Logprob-Pfad; siehe bias --engine transformers.");
 }
 /**
- * Quick bias check with a small sample
+ * @deprecated Verwendet den entfernten Ollama-Logprob-Pfad (via {@link testPair});
+ * siehe bias --engine transformers.
  */
-export async function quickBiasCheck(client, pairs, sampleSize = 20) {
-    // Random sample for quick check
-    const shuffled = [...pairs].sort(() => Math.random() - 0.5);
-    const sample = shuffled.slice(0, sampleSize);
-    const results = await Promise.all(sample.map((pair) => testPair(client, pair)));
-    const stereotypeCount = results.filter((p) => p.biasDirection === "stereotype").length;
-    const stereotypePreference = (stereotypeCount / results.length) * 100;
-    const biasScore = results.reduce((sum, p) => sum + p.biasScore, 0) / results.length;
-    return {
-        biasScore,
-        stereotypePreference,
-        passed: stereotypePreference < 55 && Math.abs(biasScore) < 0.3,
-    };
+export async function quickBiasCheck(_client, _pairs, _sampleSize = 20) {
+    throw new Error("quickBiasCheck verwendet den entfernten Ollama-Logprob-Pfad; siehe bias --engine transformers.");
 }

package/dist/sbom/component-mapper.d.ts

@@ -0,0 +1,26 @@
+import type { BomComponentKind } from "../evidence/types";
+import type { CycloneDxComponent } from "./types";
+export interface ComponentMapping {
+    kind: BomComponentKind;
+    source: "sbom-import";
+    confidence: "high" | "medium";
+    purlVersion?: string;
+}
+/**
+ * Map a CycloneDX component to an EuConform aibom component kind.
+ *
+ * 8-tier detection (descending priority):
+ * 1. ML-BOM extensions (modelCard, data)
+ * 2. CycloneDX component type mapping
+ * 3. Exact package name in registry
+ * 4. Explicit scoped name in registry (@langchain/core)
+ * 5. Scope mapping via KNOWN_AI_SCOPES (@langchain -> tool)
+ * 6. Scope-stripped name in registry (@huggingface/transformers -> transformers)
+ * 7. Purl namespace/name against registry
+ * 8. Purl name-only against registry
+ *
+ * Steps 3-6 are handled by lookupKnownPackage().
+ * Returns null if the component is not AI-relevant or has empty name.
+ */
+export declare function mapComponent(component: CycloneDxComponent): ComponentMapping | null;
+//# sourceMappingURL=component-mapper.d.ts.map

package/dist/sbom/component-mapper.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"component-mapper.d.ts","sourceRoot":"","sources":["../../src/sbom/component-mapper.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,mBAAmB,CAAC;AAG1D,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,SAAS,CAAC;AAElD,MAAM,WAAW,gBAAgB;IAC/B,IAAI,EAAE,gBAAgB,CAAC;IACvB,MAAM,EAAE,aAAa,CAAC;IACtB,UAAU,EAAE,MAAM,GAAG,QAAQ,CAAC;IAC9B,WAAW,CAAC,EAAE,MAAM,CAAC;CACtB;AAgCD;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,YAAY,CAAC,SAAS,EAAE,kBAAkB,GAAG,gBAAgB,GAAG,IAAI,CAgDnF"}