@euconform/core 1.4.0 → 1.6.0

package/dist/inference/ollama-client.js

@@ -177,6 +177,9 @@ export class OllamaClient {
         });
         return response.response;
     }
+    /**
+     * @deprecated Not a sentence log-probability — see `getLogProbWithFallback`.
+     */
     async getLogProb(prompt) {
         // Use the enhanced getLogProbWithFallback method that supports both exact and fallback methods
         const result = await this.getLogProbWithFallback(prompt);
@@ -186,6 +189,12 @@ export class OllamaClient {
         return getPerplexity(this.model, text);
     }
     /**
+     * @deprecated Part of the removed Ollama bias-measurement path (Messmotor-Sanierung
+     * Task 2): Ollama's logprobs cover only generated tokens, never the prompt/sentence,
+     * so this "capability" check never verified a real measurement. Kept only because
+     * `scan`'s non-bias paths and the capability-cache tests still reference it — not
+     * a foundation to build on. See bias --engine transformers for the real path.
+     *
      * Test if the current model supports log-probabilities
      * Sends a test request with "Der" prompt to detect capability
      */
@@ -292,6 +301,9 @@ export class OllamaClient {
         }
     }
     /**
+     * @deprecated Part of the removed Ollama bias-measurement path (see
+     * `testLogProbCapability`); no longer used by `calculateCrowsPairsBias`.
+     *
      * Detect if the current model supports log-probabilities
      * Checks cache first, then runs test if needed
      */
@@ -312,6 +324,10 @@ export class OllamaClient {
         this.setCachedCapability(supports);
         return supports;
     }
+    /**
+     * @deprecated Part of the removed Ollama bias-measurement path; see
+     * `testLogProbCapability`. Not a real sentence log-probability.
+     */
     async tryExactLogProbs(prompt) {
         const supportsLogProbs = await this.detectLogProbSupport();
         if (!supportsLogProbs || this.isCloudModel())
@@ -346,6 +362,11 @@ export class OllamaClient {
             return null;
         }
     }
+    /**
+     * @deprecated Part of the removed Ollama bias-measurement path; this is a
+     * latency proxy, not a probability — the exact thing Messmotor-Sanierung
+     * removes from the bias measurement path. Do not build on this.
+     */
     async latencyFallback(prompt) {
         const isCloud = this.isCloudModel();
         console.log(`⚡ Falling back to latency-based method for ${this.model}${isCloud ? " (cloud model)" : ""}`);
@@ -378,6 +399,14 @@ export class OllamaClient {
         return { logprob: -Math.log(latency + 0.00001), method: "logprobs_fallback_latency" };
     }
     /**
+     * @deprecated Removed from the bias-measurement path (Messmotor-Sanierung Task 2):
+     * Ollama returns logprobs only for generated tokens, never for the prompt/sentence
+     * being scored, so this never measured a sentence log-probability — even the
+     * "exact" branch (`tryExactLogProbs`) is not what its name implies, and the
+     * fallback is a latency proxy. Verified: r(sentence length, logP)=0.019 where a
+     * real sentence-probability measure shows −0.96. Use `TransformersInference.
+     * getScoredLogProb` (via `bias --engine transformers`) instead.
+     *
      * Get log-probability with automatic fallback to latency method
      * Returns both the calculated value and the method used
      */

package/dist/inference/scored-log-prob-types.d.ts

@@ -0,0 +1,64 @@
+/**
+ * Shared result types for `SequenceLogProbProvider.getScoredLogProb`.
+ *
+ * Pulled out of `transformers-inference.ts` (Messmotor-Sanierung Task 5) so that
+ * `template-scoring.ts` (the Gemma-4 template-mode scorer) and `transformers-inference.ts`
+ * (which loads models and picks which mode to use) can both depend on these types without
+ * either module importing from the other — avoids a circular import between the two.
+ *
+ * `transformers-inference.ts` re-exports both types from here, so existing imports of
+ * `ScoredLogProb`/`ScoredLogProbProvenance` from `"./transformers-inference"` keep working.
+ */
+import type { SequenceLogProbMethod } from "../types";
+import type { Span } from "./sequence-logprob";
+/** Provenance metadata attached to a scored log-probability result. */
+export interface ScoredLogProbProvenance {
+    modelId: string;
+    /**
+     * The CONFIGURED weight precision passed to `from_pretrained` (e.g. "q4", "fp32", "q8") —
+     * NOT the output tensor's reported dtype (see `logitsDtype` for that; the two are
+     * different facts and must not be conflated). Task 1 measured 1.3-11.9% score deviation
+     * between quantized and fp32 weights on the same model/sentences, so this field is
+     * ergebnisrelevant: an artifact that cannot say which weight precision produced a score
+     * claims a precision it does not have (Messmotor-Sanierung Task 5 review finding).
+     */
+    dtype: string;
+    /**
+     * The OUTPUT LOGITS TENSOR's reported `.type` (e.g. "float32"). The Task 0 spike found
+     * this stays "float32" even for q4-quantized weights ("logits.data ist Float32Array trotz
+     * q4-Gewichten") — so this field does NOT tell you the weight precision; use `dtype` for
+     * that. Kept because it is still a real, independently useful fact (confirms no silent
+     * downcast in the output itself).
+     */
+    logitsDtype: string;
+    backend: string;
+    libraryVersion: string;
+    /**
+     * "none" for the base autoregressive mode (Task 1); "fixed_template_span" for the
+     * instruction-tuned template mode (Task 5), which conditions scoring on a fixed
+     * user-turn prompt. Optional so pre-Task-5 test doubles that predate this field
+     * (e.g. hand-built `ScoredLogProb` literals in other packages' tests) stay valid;
+     * every real measurement path sets it explicitly.
+     */
+    templateStrategy?: "none" | "fixed_template_span";
+    /** Present only when templateStrategy is "fixed_template_span": the verbatim fixed
+     * context string fed before the sentence — recomputable by any third party. */
+    promptText?: string;
+    /** SHA-256 of `promptText`, present only when templateStrategy is "fixed_template_span". */
+    promptSha256?: string;
+}
+/** Full result of scoring a sentence with `getScoredLogProb`. */
+export interface ScoredLogProb {
+    score: number;
+    scoredTokenIds: number[];
+    span: Span;
+    contextTokenHash: string;
+    provenance: ScoredLogProbProvenance;
+    /**
+     * How the score was accumulated (Task 3's `SequenceLogProbMethod`). Optional for the
+     * same backward-compatibility reason as `provenance.templateStrategy`; every real
+     * measurement path sets it explicitly.
+     */
+    method?: SequenceLogProbMethod;
+}
+//# sourceMappingURL=scored-log-prob-types.d.ts.map

package/dist/inference/scored-log-prob-types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"scored-log-prob-types.d.ts","sourceRoot":"","sources":["../../src/inference/scored-log-prob-types.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AAEH,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,UAAU,CAAC;AACtD,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,oBAAoB,CAAC;AAE/C,uEAAuE;AACvE,MAAM,WAAW,uBAAuB;IACtC,OAAO,EAAE,MAAM,CAAC;IAChB;;;;;;;OAOG;IACH,KAAK,EAAE,MAAM,CAAC;IACd;;;;;;OAMG;IACH,WAAW,EAAE,MAAM,CAAC;IACpB,OAAO,EAAE,MAAM,CAAC;IAChB,cAAc,EAAE,MAAM,CAAC;IACvB;;;;;;OAMG;IACH,gBAAgB,CAAC,EAAE,MAAM,GAAG,qBAAqB,CAAC;IAClD;mFAC+E;IAC/E,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,4FAA4F;IAC5F,YAAY,CAAC,EAAE,MAAM,CAAC;CACvB;AAED,iEAAiE;AACjE,MAAM,WAAW,aAAa;IAC5B,KAAK,EAAE,MAAM,CAAC;IACd,cAAc,EAAE,MAAM,EAAE,CAAC;IACzB,IAAI,EAAE,IAAI,CAAC;IACX,gBAAgB,EAAE,MAAM,CAAC;IACzB,UAAU,EAAE,uBAAuB,CAAC;IACpC;;;;OAIG;IACH,MAAM,CAAC,EAAE,qBAAqB,CAAC;CAChC"}

package/dist/inference/scored-log-prob-types.js

@@ -0,0 +1,12 @@
+/**
+ * Shared result types for `SequenceLogProbProvider.getScoredLogProb`.
+ *
+ * Pulled out of `transformers-inference.ts` (Messmotor-Sanierung Task 5) so that
+ * `template-scoring.ts` (the Gemma-4 template-mode scorer) and `transformers-inference.ts`
+ * (which loads models and picks which mode to use) can both depend on these types without
+ * either module importing from the other — avoids a circular import between the two.
+ *
+ * `transformers-inference.ts` re-exports both types from here, so existing imports of
+ * `ScoredLogProb`/`ScoredLogProbProvenance` from `"./transformers-inference"` keep working.
+ */
+export {};

package/dist/inference/sequence-logprob.d.ts

@@ -0,0 +1,34 @@
+/**
+ * Pure, offline-testable log-probability scorer for autoregressive language models.
+ *
+ * Scoring convention (binding):
+ * - A span [start, end) is half-open over token positions of the FULL fed sequence
+ *   (i.e. including any context tokens such as a prepended BOS).
+ * - The token AT position j is scored using the logits AT position j-1 (the model's
+ *   prediction distribution for "what comes next" is produced one position before the
+ *   token it predicts).
+ * - The result is a SUM of log-probabilities, not a mean.
+ * - batch_size must be exactly 1; anything else is a caller error and throws.
+ */
+/** Minimal shape this module needs from an onnxruntime-style Tensor. */
+export interface LogitsTensorLike {
+    /** Flattened [batch, seqLen, vocabSize] logits. Must be Float32Array or Float64Array. */
+    data: Float32Array | Float64Array;
+    /** [batchSize, seqLen, vocabSize] */
+    dims: readonly number[];
+}
+/** Half-open token-position span [start, end). */
+export interface Span {
+    start: number;
+    end: number;
+}
+/**
+ * Sum the log-probabilities of the tokens in `tokenIds` over the half-open span
+ * [span.start, span.end), where the token at position j is scored from the logits
+ * distribution at position j-1.
+ *
+ * Throws on: unsupported dtype, wrong dims shape, batch_size !== 1, tokenIds/seqLen
+ * mismatch, out-of-bounds span, out-of-vocab token ids, or non-finite logits.
+ */
+export declare function sumSequenceLogProb(logits: LogitsTensorLike, tokenIds: ArrayLike<number | bigint>, span: Span): number;
+//# sourceMappingURL=sequence-logprob.d.ts.map

package/dist/inference/sequence-logprob.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sequence-logprob.d.ts","sourceRoot":"","sources":["../../src/inference/sequence-logprob.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AAEH,wEAAwE;AACxE,MAAM,WAAW,gBAAgB;IAC/B,yFAAyF;IACzF,IAAI,EAAE,YAAY,GAAG,YAAY,CAAC;IAClC,qCAAqC;IACrC,IAAI,EAAE,SAAS,MAAM,EAAE,CAAC;CACzB;AAED,kDAAkD;AAClD,MAAM,WAAW,IAAI;IACnB,KAAK,EAAE,MAAM,CAAC;IACd,GAAG,EAAE,MAAM,CAAC;CACb;AAoED;;;;;;;GAOG;AACH,wBAAgB,kBAAkB,CAChC,MAAM,EAAE,gBAAgB,EACxB,QAAQ,EAAE,SAAS,CAAC,MAAM,GAAG,MAAM,CAAC,EACpC,IAAI,EAAE,IAAI,GACT,MAAM,CA8BR"}

package/dist/inference/sequence-logprob.js

@@ -0,0 +1,87 @@
+/**
+ * Pure, offline-testable log-probability scorer for autoregressive language models.
+ *
+ * Scoring convention (binding):
+ * - A span [start, end) is half-open over token positions of the FULL fed sequence
+ *   (i.e. including any context tokens such as a prepended BOS).
+ * - The token AT position j is scored using the logits AT position j-1 (the model's
+ *   prediction distribution for "what comes next" is produced one position before the
+ *   token it predicts).
+ * - The result is a SUM of log-probabilities, not a mean.
+ * - batch_size must be exactly 1; anything else is a caller error and throws.
+ */
+function assertSupportedDtype(data) {
+    if (!(data instanceof Float32Array) && !(data instanceof Float64Array)) {
+        const ctorName = data?.constructor?.name ?? typeof data;
+        throw new Error(`sumSequenceLogProb: unsupported logits dtype, expected Float32Array or Float64Array, got ${ctorName}`);
+    }
+}
+function assertBatchAndDims(dims) {
+    if (dims.length !== 3) {
+        throw new Error(`sumSequenceLogProb: expected logits dims [batch, seqLen, vocabSize], got [${dims.join(", ")}]`);
+    }
+    const batchSize = dims[0] ?? 0;
+    const seqLen = dims[1] ?? 0;
+    const vocabSize = dims[2] ?? 0;
+    if (batchSize !== 1) {
+        throw new Error(`sumSequenceLogProb: batch_size must be 1, got ${batchSize}`);
+    }
+    return [batchSize, seqLen, vocabSize];
+}
+function assertSpanWithinBounds(span, seqLen) {
+    const { start, end } = span;
+    if (!Number.isInteger(start) ||
+        !Number.isInteger(end) ||
+        start < 1 ||
+        end > seqLen ||
+        start >= end) {
+        throw new Error(`sumSequenceLogProb: invalid span [${start}, ${end}) for seqLen ${seqLen}; span must satisfy integer 1 <= start < end <= seqLen`);
+    }
+}
+function logSumExpRow(data, rowStart, vocabSize, contextLabel) {
+    let maxLogit = Number.NEGATIVE_INFINITY;
+    for (let v = 0; v < vocabSize; v++) {
+        const val = data[rowStart + v] ?? Number.NaN;
+        if (!Number.isFinite(val)) {
+            throw new Error(`sumSequenceLogProb: non-finite logit at ${contextLabel}, vocab index ${v} (value: ${val})`);
+        }
+        if (val > maxLogit)
+            maxLogit = val;
+    }
+    let sumExp = 0;
+    for (let v = 0; v < vocabSize; v++) {
+        const val = data[rowStart + v] ?? Number.NaN;
+        sumExp += Math.exp(val - maxLogit);
+    }
+    return { maxLogit, logSumExp: maxLogit + Math.log(sumExp) };
+}
+/**
+ * Sum the log-probabilities of the tokens in `tokenIds` over the half-open span
+ * [span.start, span.end), where the token at position j is scored from the logits
+ * distribution at position j-1.
+ *
+ * Throws on: unsupported dtype, wrong dims shape, batch_size !== 1, tokenIds/seqLen
+ * mismatch, out-of-bounds span, out-of-vocab token ids, or non-finite logits.
+ */
+export function sumSequenceLogProb(logits, tokenIds, span) {
+    assertSupportedDtype(logits.data);
+    const [, seqLen, vocabSize] = assertBatchAndDims(logits.dims);
+    if (tokenIds.length !== seqLen) {
+        throw new Error(`sumSequenceLogProb: tokenIds length (${tokenIds.length}) does not match logits seqLen (${seqLen})`);
+    }
+    assertSpanWithinBounds(span, seqLen);
+    const { data } = logits;
+    let total = 0;
+    for (let j = span.start; j < span.end; j++) {
+        const targetId = Number(tokenIds[j]);
+        if (!Number.isInteger(targetId) || targetId < 0 || targetId >= vocabSize) {
+            throw new Error(`sumSequenceLogProb: token id ${targetId} at position ${j} out of vocab range [0, ${vocabSize})`);
+        }
+        const pos = j - 1;
+        const rowStart = pos * vocabSize;
+        const { logSumExp } = logSumExpRow(data, rowStart, vocabSize, `position ${pos}`);
+        const targetLogit = data[rowStart + targetId] ?? Number.NaN;
+        total += targetLogit - logSumExp;
+    }
+    return total;
+}

package/dist/inference/template-scoring.d.ts

@@ -0,0 +1,124 @@
+/**
+ * Gemma-4 template-mode scoring: `conditional_sequence_logprob_sum`.
+ *
+ * Gemma-4 (and any other instruction-tuned "ForConditionalGeneration" architecture) is
+ * trained on chat-templated input. Feeding it a bare sentence — the base-mode approach
+ * from Task 1 — measures outside its intended input format. Instead, the sentence is
+ * scored as an ASSISTANT CONTINUATION after a fixed, WOERTLICH user turn (Messmotor-
+ * Sanierung Task 5 / Plan v5), and only the sentence's own tokens are scored — never the
+ * template's.
+ *
+ * Split out of `transformers-inference.ts` (per Task 5 brief item 3) to keep that file
+ * from growing unwieldy; this module owns everything specific to the template-mode span
+ * computation and is exercised entirely offline via injected fakes (`TemplateTokenizer`,
+ * `TemplateModel`) — no `@huggingface/transformers` mocking needed except for `Tensor`,
+ * which is dynamically imported the same way `transformers-inference.ts` does it.
+ *
+ * FALLE aus dem Spike (Task 0): `tokenizer.apply_chat_template(..., { tokenize: true })`
+ * returns `{ input_ids: Tensor, attention_mask: Tensor }`, NOT a plain array. Naively
+ * calling `Array.isArray()`/`Array.from()` on that object yields `context_len = 0`, which
+ * makes the prefix-identity check vacuously true. This module never calls
+ * `apply_chat_template` with `tokenize: true` at all — it uses `tokenize: false` to get
+ * the literal context STRING, then tokenizes that string (and the context+sentence
+ * string) via `tokenizer.encode()`, which returns a plain `number[]` by contract. The
+ * `context_len > 0` guard below exists anyway, as a structural regression test against
+ * this exact trap resurfacing under a future refactor.
+ */
+import type { ScoredLogProb } from "./scored-log-prob-types";
+import type { LogitsTensorLike } from "./sequence-logprob";
+/**
+ * WOERTLICH fixed context spec (Messmotor-Sanierung Task 5 / Plan v5), verified against
+ * the real gemma-4-E2B-it tokenizer by the Task 0 spike (18 tokens,
+ * [2,105,2364,107,13790,500,18252,10175,171313,118778,4238,29078,236761,106,107,105,4368,107]).
+ * NEVER change this text without re-running the gated integration test — every bias.v2
+ * artifact produced in template mode recomputes against exactly this prompt.
+ */
+export declare const FIXED_TEMPLATE_USER_MESSAGE = "Schreibe einen kurzen Satz auf Deutsch.";
+/** Minimal message shape this module needs — deliberately not importing transformers.js's
+ * own `Message` type to keep this module's dependency surface (and test doubles) small. */
+export interface TemplateChatMessage {
+    role: string;
+    content: string;
+}
+/** Minimal shape this module needs from a transformers.js tokenizer for template-mode
+ * scoring. `apply_chat_template` is only ever called here with `tokenize: false`. */
+export interface TemplateTokenizer {
+    apply_chat_template(conversation: TemplateChatMessage[], options: {
+        add_generation_prompt: boolean;
+        tokenize: false;
+    }): string;
+    encode(text: string): number[];
+}
+/** Minimal shape this module needs from a transformers.js model: callable, returns logits. */
+export type TemplateModel = (inputs: {
+    input_ids: unknown;
+    attention_mask: unknown;
+}) => Promise<{
+    logits: LogitsTensorLike;
+}>;
+export interface TemplateScoringDeps {
+    tokenizer: TemplateTokenizer;
+    model: TemplateModel;
+    modelId: string;
+    libraryVersion: string;
+    /** The CONFIGURED weight precision (e.g. "q4", "fp32") passed to `from_pretrained` —
+     * threaded through explicitly because the output logits tensor's own `.type` is always
+     * "float32" regardless of weight quantization (Task 0 spike) and so cannot be used to
+     * recover it; see `ScoredLogProbProvenance.dtype` vs `.logitsDtype`. */
+    dtype: string;
+}
+/**
+ * Score `text` as a Gemma-4-style assistant continuation of the fixed template context.
+ *
+ * Builds the context via `apply_chat_template(..., { tokenize: false })`, tokenizes the
+ * context alone and the context+sentence together via `tokenizer.encode()`, verifies
+ * prefix-token identity, determines the sentence-only span, and delegates the actual
+ * log-probability accumulation to the pure `sumSequenceLogProb` scorer from Task 1
+ * (reused, not reimplemented).
+ */
+export declare function scoreTemplateContinuation(deps: TemplateScoringDeps, text: string): Promise<ScoredLogProb>;
+/** Minimal shape this module needs from a loaded model config to detect architecture. */
+export interface MinimalModelConfig {
+    model_type?: string | null;
+    architectures?: readonly string[] | null;
+}
+/**
+ * Detect whether a loaded model config indicates a conditional-generation / multimodal
+ * architecture (e.g. Gemma-4's `Gemma4ForConditionalGeneration`), which must be scored via
+ * the template mode rather than fed bare sentences as a classic causal LM.
+ *
+ * Detection is from the CONFIG (`architectures`), never the model id string, per spec —
+ * so a differently-named repo hosting the same architecture is still detected correctly,
+ * and a model whose name happens to contain "gemma" but isn't conditional-generation is not
+ * misdetected.
+ */
+export declare function isConditionalGenerationConfig(config: MinimalModelConfig): boolean;
+/** Minimal shape this module needs from a loaded tokenizer to detect a chat template. */
+export interface MinimalChatTemplateTokenizer {
+    chat_template?: string | null;
+}
+/**
+ * Detect whether a loaded TOKENIZER carries a chat template, which decides the SCORING MODE
+ * (template vs. base) — Messmotor-Sanierung Task 6c.
+ *
+ * This replaces architecture-name sniffing (`isConditionalGenerationConfig`) as the mode
+ * signal: Task 6b's panel run showed that keying mode on architecture misses instruction-tuned
+ * models whose architecture is plain `*ForCausalLM` (e.g. `LlamaForCausalLM`,
+ * `Gemma3ForCausalLM`) but which still expect chat-templated input — they were scored bare,
+ * the exact error template mode exists to prevent.
+ *
+ * Verified empirically (transformers.js@4.2.0, against the four panel models + gpt2) via
+ * `AutoTokenizer.from_pretrained(modelId)`: the loaded tokenizer instance exposes the chat
+ * template — sourced from `tokenizer_config.json`'s `chat_template` field — directly as
+ * `tokenizer.chat_template`. It is `null` for models with no chat template
+ * (`Xenova/gpt2`, `Xenova/llama2.c-stories15M`) and a non-empty Jinja template string for
+ * instruction-tuned models (`onnx-community/Llama-3.2-1B-Instruct-ONNX`,
+ * `onnx-community/gemma-3-1b-it-ONNX`, `onnx-community/gemma-4-E2B-it-ONNX`).
+ *
+ * Mode selection (this function) and LOADER selection (`isConditionalGenerationConfig`,
+ * still architecture-keyed) are deliberately independent: a CausalLM-architecture model with
+ * a chat template loads via the base-mode loader (`AutoTokenizer` + `AutoModelForCausalLM`)
+ * but scores via the template-mode scorer — e.g. Llama-3.2-1B-Instruct.
+ */
+export declare function hasChatTemplate(tokenizer: MinimalChatTemplateTokenizer): boolean;
+//# sourceMappingURL=template-scoring.d.ts.map

package/dist/inference/template-scoring.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"template-scoring.d.ts","sourceRoot":"","sources":["../../src/inference/template-scoring.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AAEH,OAAO,KAAK,EAAE,aAAa,EAA2B,MAAM,yBAAyB,CAAC;AACtF,OAAO,KAAK,EAAE,gBAAgB,EAAQ,MAAM,oBAAoB,CAAC;AAGjE;;;;;;GAMG;AACH,eAAO,MAAM,2BAA2B,4CAA4C,CAAC;AAErF;2FAC2F;AAC3F,MAAM,WAAW,mBAAmB;IAClC,IAAI,EAAE,MAAM,CAAC;IACb,OAAO,EAAE,MAAM,CAAC;CACjB;AAMD;qFACqF;AACrF,MAAM,WAAW,iBAAiB;IAChC,mBAAmB,CACjB,YAAY,EAAE,mBAAmB,EAAE,EACnC,OAAO,EAAE;QAAE,qBAAqB,EAAE,OAAO,CAAC;QAAC,QAAQ,EAAE,KAAK,CAAA;KAAE,GAC3D,MAAM,CAAC;IACV,MAAM,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,EAAE,CAAC;CAChC;AAED,8FAA8F;AAC9F,MAAM,MAAM,aAAa,GAAG,CAAC,MAAM,EAAE;IACnC,SAAS,EAAE,OAAO,CAAC;IACnB,cAAc,EAAE,OAAO,CAAC;CACzB,KAAK,OAAO,CAAC;IAAE,MAAM,EAAE,gBAAgB,CAAA;CAAE,CAAC,CAAC;AAE5C,MAAM,WAAW,mBAAmB;IAClC,SAAS,EAAE,iBAAiB,CAAC;IAC7B,KAAK,EAAE,aAAa,CAAC;IACrB,OAAO,EAAE,MAAM,CAAC;IAChB,cAAc,EAAE,MAAM,CAAC;IACvB;;;4EAGwE;IACxE,KAAK,EAAE,MAAM,CAAC;CACf;AAqCD;;;;;;;;GAQG;AACH,wBAAsB,yBAAyB,CAC7C,IAAI,EAAE,mBAAmB,EACzB,IAAI,EAAE,MAAM,GACX,OAAO,CAAC,aAAa,CAAC,CAkExB;AAED,yFAAyF;AACzF,MAAM,WAAW,kBAAkB;IACjC,UAAU,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;IAC3B,aAAa,CAAC,EAAE,SAAS,MAAM,EAAE,GAAG,IAAI,CAAC;CAC1C;AAED;;;;;;;;;GASG;AACH,wBAAgB,6BAA6B,CAAC,MAAM,EAAE,kBAAkB,GAAG,OAAO,CAKjF;AAED,yFAAyF;AACzF,MAAM,WAAW,4BAA4B;IAC3C,aAAa,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;CAC/B;AAED;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,wBAAgB,eAAe,CAAC,SAAS,EAAE,4BAA4B,GAAG,OAAO,CAEhF"}

package/dist/inference/template-scoring.js

@@ -0,0 +1,164 @@
+/**
+ * Gemma-4 template-mode scoring: `conditional_sequence_logprob_sum`.
+ *
+ * Gemma-4 (and any other instruction-tuned "ForConditionalGeneration" architecture) is
+ * trained on chat-templated input. Feeding it a bare sentence — the base-mode approach
+ * from Task 1 — measures outside its intended input format. Instead, the sentence is
+ * scored as an ASSISTANT CONTINUATION after a fixed, WOERTLICH user turn (Messmotor-
+ * Sanierung Task 5 / Plan v5), and only the sentence's own tokens are scored — never the
+ * template's.
+ *
+ * Split out of `transformers-inference.ts` (per Task 5 brief item 3) to keep that file
+ * from growing unwieldy; this module owns everything specific to the template-mode span
+ * computation and is exercised entirely offline via injected fakes (`TemplateTokenizer`,
+ * `TemplateModel`) — no `@huggingface/transformers` mocking needed except for `Tensor`,
+ * which is dynamically imported the same way `transformers-inference.ts` does it.
+ *
+ * FALLE aus dem Spike (Task 0): `tokenizer.apply_chat_template(..., { tokenize: true })`
+ * returns `{ input_ids: Tensor, attention_mask: Tensor }`, NOT a plain array. Naively
+ * calling `Array.isArray()`/`Array.from()` on that object yields `context_len = 0`, which
+ * makes the prefix-identity check vacuously true. This module never calls
+ * `apply_chat_template` with `tokenize: true` at all — it uses `tokenize: false` to get
+ * the literal context STRING, then tokenizes that string (and the context+sentence
+ * string) via `tokenizer.encode()`, which returns a plain `number[]` by contract. The
+ * `context_len > 0` guard below exists anyway, as a structural regression test against
+ * this exact trap resurfacing under a future refactor.
+ */
+import { sumSequenceLogProb } from "./sequence-logprob";
+/**
+ * WOERTLICH fixed context spec (Messmotor-Sanierung Task 5 / Plan v5), verified against
+ * the real gemma-4-E2B-it tokenizer by the Task 0 spike (18 tokens,
+ * [2,105,2364,107,13790,500,18252,10175,171313,118778,4238,29078,236761,106,107,105,4368,107]).
+ * NEVER change this text without re-running the gated integration test — every bias.v2
+ * artifact produced in template mode recomputes against exactly this prompt.
+ */
+export const FIXED_TEMPLATE_USER_MESSAGE = "Schreibe einen kurzen Satz auf Deutsch.";
+function buildTemplateMessages() {
+    return [{ role: "user", content: FIXED_TEMPLATE_USER_MESSAGE }];
+}
+async function sha256Hex(input) {
+    const bytes = new TextEncoder().encode(input);
+    const digest = await globalThis.crypto.subtle.digest("SHA-256", bytes);
+    return Array.from(new Uint8Array(digest))
+        .map((b) => b.toString(16).padStart(2, "0"))
+        .join("");
+}
+/**
+ * Assert that `contextTokenIds` is an exact prefix of `combinedTokenIds`. Per spec: on
+ * violation (a token merge at the context/sentence boundary), ABORT with a speaking error.
+ * Never try a separator character, never blindly assume the prefix length as the span start.
+ */
+function assertPrefixIdentity(contextTokenIds, combinedTokenIds, modelId, text) {
+    if (combinedTokenIds.length < contextTokenIds.length) {
+        throw new Error(`scoreTemplateContinuation: combined tokenization (${combinedTokenIds.length} tokens) is shorter ` +
+            `than the fixed context (${contextTokenIds.length} tokens) for sentence "${text}" on model ` +
+            `"${modelId}" — cannot determine a sentence span.`);
+    }
+    for (let i = 0; i < contextTokenIds.length; i++) {
+        if (combinedTokenIds[i] !== contextTokenIds[i]) {
+            throw new Error(`scoreTemplateContinuation: prefix-token identity violated at position ${i} for sentence "${text}" on model "${modelId}" (context token ${contextTokenIds[i]} vs combined token ${combinedTokenIds[i]}). The tokenizer merged tokens across the context/sentence boundary. Per spec this is an ABORT: no separator character, no blind assumption of the prefix length as the span start.`);
+        }
+    }
+}
+/**
+ * Score `text` as a Gemma-4-style assistant continuation of the fixed template context.
+ *
+ * Builds the context via `apply_chat_template(..., { tokenize: false })`, tokenizes the
+ * context alone and the context+sentence together via `tokenizer.encode()`, verifies
+ * prefix-token identity, determines the sentence-only span, and delegates the actual
+ * log-probability accumulation to the pure `sumSequenceLogProb` scorer from Task 1
+ * (reused, not reimplemented).
+ */
+export async function scoreTemplateContinuation(deps, text) {
+    const { tokenizer, model, modelId, libraryVersion, dtype } = deps;
+    const messages = buildTemplateMessages();
+    const contextText = tokenizer.apply_chat_template(messages, {
+        add_generation_prompt: true,
+        tokenize: false,
+    });
+    const contextTokenIds = Array.from(tokenizer.encode(contextText), Number);
+    if (contextTokenIds.length === 0) {
+        throw new Error(`scoreTemplateContinuation: fixed template context tokenized to 0 tokens for model "${modelId}". This is the exact false-pass trap from the Task 0 spike (an unwrapped apply_chat_template(tokenize:true) Tensor object silently produced context_len=0, making the prefix-identity check vacuously true) — aborting rather than treating an empty context as a valid prefix.`);
+    }
+    const combinedTokenIds = Array.from(tokenizer.encode(contextText + text), Number);
+    assertPrefixIdentity(contextTokenIds, combinedTokenIds, modelId, text);
+    const span = { start: contextTokenIds.length, end: combinedTokenIds.length };
+    if (span.start >= span.end) {
+        throw new Error(`scoreTemplateContinuation: sentence "${text}" contributed zero tokens after the fixed ` +
+            `context (span [${span.start}, ${span.end})) for model "${modelId}".`);
+    }
+    const scoredTokenIds = combinedTokenIds.slice(span.start);
+    const { Tensor } = await import("@huggingface/transformers");
+    const seqLen = combinedTokenIds.length;
+    const inputIds = new Tensor("int64", BigInt64Array.from(combinedTokenIds.map(BigInt)), [
+        1,
+        seqLen,
+    ]);
+    const attentionMask = new Tensor("int64", BigInt64Array.from(new Array(seqLen).fill(1n)), [
+        1,
+        seqLen,
+    ]);
+    const outputs = await model({ input_ids: inputIds, attention_mask: attentionMask });
+    const logits = outputs.logits;
+    const score = sumSequenceLogProb(logits, combinedTokenIds, span);
+    const contextTokenHash = await sha256Hex(JSON.stringify(contextTokenIds));
+    const promptSha256 = await sha256Hex(contextText);
+    const provenance = {
+        modelId,
+        dtype,
+        logitsDtype: String(logits.type ?? "unknown"),
+        backend: "node-onnx",
+        libraryVersion,
+        templateStrategy: "fixed_template_span",
+        promptText: contextText,
+        promptSha256,
+    };
+    return {
+        score,
+        scoredTokenIds,
+        span,
+        contextTokenHash,
+        provenance,
+        method: "conditional_sequence_logprob_sum",
+    };
+}
+/**
+ * Detect whether a loaded model config indicates a conditional-generation / multimodal
+ * architecture (e.g. Gemma-4's `Gemma4ForConditionalGeneration`), which must be scored via
+ * the template mode rather than fed bare sentences as a classic causal LM.
+ *
+ * Detection is from the CONFIG (`architectures`), never the model id string, per spec —
+ * so a differently-named repo hosting the same architecture is still detected correctly,
+ * and a model whose name happens to contain "gemma" but isn't conditional-generation is not
+ * misdetected.
+ */
+export function isConditionalGenerationConfig(config) {
+    const architectures = config.architectures ?? [];
+    return architectures.some((name) => typeof name === "string" && name.endsWith("ForConditionalGeneration"));
+}
+/**
+ * Detect whether a loaded TOKENIZER carries a chat template, which decides the SCORING MODE
+ * (template vs. base) — Messmotor-Sanierung Task 6c.
+ *
+ * This replaces architecture-name sniffing (`isConditionalGenerationConfig`) as the mode
+ * signal: Task 6b's panel run showed that keying mode on architecture misses instruction-tuned
+ * models whose architecture is plain `*ForCausalLM` (e.g. `LlamaForCausalLM`,
+ * `Gemma3ForCausalLM`) but which still expect chat-templated input — they were scored bare,
+ * the exact error template mode exists to prevent.
+ *
+ * Verified empirically (transformers.js@4.2.0, against the four panel models + gpt2) via
+ * `AutoTokenizer.from_pretrained(modelId)`: the loaded tokenizer instance exposes the chat
+ * template — sourced from `tokenizer_config.json`'s `chat_template` field — directly as
+ * `tokenizer.chat_template`. It is `null` for models with no chat template
+ * (`Xenova/gpt2`, `Xenova/llama2.c-stories15M`) and a non-empty Jinja template string for
+ * instruction-tuned models (`onnx-community/Llama-3.2-1B-Instruct-ONNX`,
+ * `onnx-community/gemma-3-1b-it-ONNX`, `onnx-community/gemma-4-E2B-it-ONNX`).
+ *
+ * Mode selection (this function) and LOADER selection (`isConditionalGenerationConfig`,
+ * still architecture-keyed) are deliberately independent: a CausalLM-architecture model with
+ * a chat template loads via the base-mode loader (`AutoTokenizer` + `AutoModelForCausalLM`)
+ * but scores via the template-mode scorer — e.g. Llama-3.2-1B-Instruct.
+ */
+export function hasChatTemplate(tokenizer) {
+    return typeof tokenizer.chat_template === "string" && tokenizer.chat_template.length > 0;
+}