@euconform/core 1.5.0 → 1.6.0

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;
+}

package/dist/inference/transformers-inference.d.ts

@@ -0,0 +1,124 @@
+/**
+ * Browser-based inference using transformers.js
+ * For small models (≤3B params) that can run via WebGPU
+ *
+ * STRICT MODE: Real inference only. No demo data.
+ */
+import type { DataType } from "@huggingface/transformers";
+import type { ScoredLogProb } from "./scored-log-prob-types";
+/** Numeric precision for model weights — re-exported so callers don't need to import from
+ * @huggingface/transformers directly. See DATA_TYPES in that package for the full list
+ * (includes quantization schemes like "q4", "bnb4"); the scoring path must use "fp32". */
+export type TransformersDType = DataType;
+export type { ScoredLogProb, ScoredLogProbProvenance } from "./scored-log-prob-types";
+export interface BrowserModel {
+    id: string;
+    name: string;
+    size: string;
+    supported: boolean;
+}
+export declare const BROWSER_MODELS: BrowserModel[];
+/**
+ * Check if WebGPU is available in the browser
+ */
+export declare function checkWebGPU(): Promise<boolean>;
+/**
+ * Check if transformers.js is available
+ */
+export declare function checkTransformersAvailable(): Promise<boolean>;
+/**
+ * Browser/Node inference engine using transformers.js — the single measurement
+ * engine for bias log-probabilities (see Messmotor-Sanierung: Ollama's logprobs
+ * only cover generated tokens, never prompt/sentence log-probability).
+ * STRICT MODE: Throws error if package not installed.
+ *
+ * Named `TransformersInference` (formerly `BrowserInference`); the old name is
+ * re-exported from `browser-inference.ts` for backward compatibility.
+ */
+export declare class TransformersInference {
+    readonly modelId: string;
+    private model;
+    private tokenizer;
+    private loadingPromise;
+    private loadError;
+    private statusCallback;
+    private readonly revision;
+    /**
+     * Public (not private) so callers building their own provenance/artifact records (e.g.
+     * the CLI's `run-bias-test.ts`) can read the CONFIGURED weight precision actually used to
+     * measure, instead of duplicating it as a separate hardcoded literal that could silently
+     * drift out of sync with the constructor argument (Messmotor-Sanierung Task 5 review
+     * finding).
+     */
+    readonly dtype: TransformersDType;
+    /**
+     * Selected from the loaded TOKENIZER's chat template (`hasChatTemplate`), never from the
+     * model's architecture name and never from `modelId` — see `hasChatTemplate`
+     * (Messmotor-Sanierung Task 6c; supersedes the architecture-keyed detection from Task 5,
+     * which missed instruction-tuned `*ForCausalLM` models). `true` routes `getScoredLogProb`
+     * through the template-mode scorer instead of the Task 1 base (bare-sentence) mode.
+     *
+     * Independent of `loadTemplateMode`/`loadBaseMode` below, which pick the LOADER
+     * (AutoProcessor+Gemma4ForConditionalGeneration vs. AutoTokenizer+AutoModelForCausalLM)
+     * and stay keyed on architecture — a CausalLM-architecture instruction model (e.g.
+     * Llama-3.2-1B-Instruct) uses the base-mode loader but the template-mode scorer.
+     */
+    private isTemplateMode;
+    constructor(modelId?: string, statusCallback?: ((status: string) => void) | null, options?: {
+        revision?: string;
+        dtype?: TransformersDType;
+    });
+    /**
+     * Check if browser inference is available
+     */
+    isAvailable(): Promise<boolean>;
+    /**
+     * Load the model (lazy loading)
+     * Handles concurrency with loadingPromise
+     */
+    load(): Promise<void>;
+    private notifyStatus;
+    private resolveDevice;
+    /**
+     * Conditional-generation/multimodal architecture (e.g. Gemma-4): AutoProcessor +
+     * Gemma4ForConditionalGeneration, per Task 5. `Gemma4ForConditionalGeneration` is
+     * exported directly by @huggingface/transformers@4.2.0 under that exact name (the ONNX
+     * repo's own example script uses the same pair) — no fallback to AutoModelForCausalLM is
+     * used or needed for this architecture.
+     */
+    private loadTemplateMode;
+    /** Base mode (Task 1): classic causal LM, unchanged behavior. */
+    private loadBaseMode;
+    private performLoad;
+    /**
+     * Generate text.
+     *
+     * v4 note: previously this called a `pipeline("text-generation", ...)` built from the
+     * already-loaded model/tokenizer, which transformers.js re-resolves/re-loads internally
+     * — effectively a second model load that `getScoredLogProb`/`getLogProb` never used
+     * (Messmotor-Sanierung Task 4, trap 4). Calling `model.generate()` directly avoids that.
+     */
+    generate(prompt: string, maxTokens?: number): Promise<string>;
+    /**
+     * Score a sentence's log-probability with full provenance.
+     * This is the "Gold Standard" for bias testing.
+     *
+     * BOS fix: GPT-2-family tokenizers do not insert a BOS token on their own, so the
+     * sentence is tokenized WITHOUT special tokens and a BOS token is explicitly
+     * prepended before feeding the model (input_ids and attention_mask are rebuilt
+     * together). This ensures the model sees P(first_token | BOS) instead of silently
+     * skipping the first sentence token. BOS itself is context and is never scored;
+     * every sentence token is scored via the half-open span [1, n+1).
+     */
+    getScoredLogProb(text: string): Promise<ScoredLogProb>;
+    /**
+     * Calculate Log-Probability for a given text (score only).
+     * Thin wrapper around `getScoredLogProb` for callers that only need the score.
+     */
+    getLogProb(text: string): Promise<number>;
+    /**
+     * Get list of supported browser models
+     */
+    static getSupportedModels(): BrowserModel[];
+}
+//# sourceMappingURL=transformers-inference.d.ts.map

package/dist/inference/transformers-inference.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"transformers-inference.d.ts","sourceRoot":"","sources":["../../src/inference/transformers-inference.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,OAAO,KAAK,EACV,QAAQ,EAIT,MAAM,2BAA2B,CAAC;AACnC,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,yBAAyB,CAAC;AAY7D;;0FAE0F;AAC1F,MAAM,MAAM,iBAAiB,GAAG,QAAQ,CAAC;AAKzC,YAAY,EAAE,aAAa,EAAE,uBAAuB,EAAE,MAAM,yBAAyB,CAAC;AAiDtF,MAAM,WAAW,YAAY;IAC3B,EAAE,EAAE,MAAM,CAAC;IACX,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,EAAE,MAAM,CAAC;IACb,SAAS,EAAE,OAAO,CAAC;CACpB;AAGD,eAAO,MAAM,cAAc,EAAE,YAAY,EAyBxC,CAAC;AAEF;;GAEG;AACH,wBAAsB,WAAW,IAAI,OAAO,CAAC,OAAO,CAAC,CAcpD;AAED;;GAEG;AACH,wBAAsB,0BAA0B,IAAI,OAAO,CAAC,OAAO,CAAC,CAQnE;AAED;;;;;;;;GAQG;AACH,qBAAa,qBAAqB;IAChC,SAAgB,OAAO,EAAE,MAAM,CAAC;IAChC,OAAO,CAAC,KAAK,CAAgC;IAC7C,OAAO,CAAC,SAAS,CAAoC;IACrD,OAAO,CAAC,cAAc,CAA8B;IACpD,OAAO,CAAC,SAAS,CAAsB;IACvC,OAAO,CAAC,cAAc,CAA2C;IACjE,OAAO,CAAC,QAAQ,CAAC,QAAQ,CAAS;IAClC;;;;;;OAMG;IACH,SAAgB,KAAK,EAAE,iBAAiB,CAAC;IACzC;;;;;;;;;;;OAWG;IACH,OAAO,CAAC,cAAc,CAAS;gBAG7B,OAAO,SAAsB,EAC7B,cAAc,GAAE,CAAC,CAAC,MAAM,EAAE,MAAM,KAAK,IAAI,CAAC,GAAG,IAAW,EACxD,OAAO,GAAE;QAAE,QAAQ,CAAC,EAAE,MAAM,CAAC;QAAC,KAAK,CAAC,EAAE,iBAAiB,CAAA;KAAO;IAahE;;OAEG;IACG,WAAW,IAAI,OAAO,CAAC,OAAO,CAAC;IAKrC;;;OAGG;IACG,IAAI,IAAI,OAAO,CAAC,IAAI,CAAC;IAY3B,OAAO,CAAC,YAAY;YAIN,aAAa;IAU3B;;;;;;OAMG;YACW,gBAAgB;IAyB9B,iEAAiE;YACnD,YAAY;YAsBZ,WAAW;IAkDzB;;;;;;;OAOG;IACG,QAAQ,CAAC,MAAM,EAAE,MAAM,EAAE,SAAS,SAAK,GAAG,OAAO,CAAC,MAAM,CAAC;IA4B/D;;;;;;;;;;OAUG;IACG,gBAAgB,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,aAAa,CAAC;IAoF5D;;;OAGG;IACG,UAAU,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC;IAK/C;;OAEG;IACH,MAAM,CAAC,kBAAkB,IAAI,YAAY,EAAE;CAG5C"}