@discretion/core 0.1.0

package/dist/src/exposure/index.js

@@ -0,0 +1,134 @@
+/**
+ * The EXPOSURE SCORE.
+ *
+ * SPEC.md: "A document-level, user-facing sensitivity summary, computed in
+ * core … EXPLAINABLE BY CONSTRUCTION: a deterministic aggregation of
+ * calibrated confidence × category severity weight × per-type factors, and the
+ * report decomposes the total into named contributions. A score that cannot
+ * show its work is not acceptable."
+ *
+ * MONOTONICITY IS STRUCTURAL, NOT INCIDENTAL. SPEC requires that adding a
+ * detected entity never lowers the score and removing one never raises it. The
+ * aggregation below is a sum of non-negative per-entity contributions passed
+ * through a saturating transform that is strictly increasing. Both halves
+ * matter: if a contribution could be negative, or the transform could
+ * decrease, the property would fail. It is therefore not something to test for
+ * and hope — it holds because of the shape of the arithmetic, and the test
+ * exists to catch a future change that breaks the shape.
+ *
+ * WHY SATURATION AT ALL. A raw sum is unbounded and unreadable: a document
+ * with forty identifiers would score in the thousands and mean nothing to a
+ * user. The score is mapped into 0–100 by a saturating curve so that "how
+ * exposed is this document" stays comparable between a short message and a
+ * long one. Saturation is strictly increasing, so monotonicity survives it —
+ * a fortieth entity adds less than the first, but it never adds less than
+ * nothing.
+ *
+ * THE LIMITATION, which SPEC requires be stated wherever the score is shown,
+ * travels with the report itself rather than living only in the UI: see
+ * `ExposureReport.limitation`.
+ */
+import { CATEGORY_OF, SEVERITY_WEIGHTS, TYPE_FACTORS } from '@discretion/data';
+/** The minimum an entity needs to contribute anything at all. */
+const MIN_CONFIDENCE = 0.05;
+/**
+ * Sum at which the score reaches ~63 of 100.
+ *
+ * Chosen so that ONE maximally severe, fully confident entity — a certain
+ * national identity number, contributing 100 — already lands near 63, i.e.
+ * "seriously exposed". A document does not need to be full of identifiers to
+ * read as dangerous, because it is not: one leaked identity number is the
+ * whole problem.
+ */
+const SATURATION_SCALE = 100;
+export const EXPOSURE_LIMITATION = 'This score summarizes what detection found. It inherits every detection ' +
+    'limitation, and a low score is not a guarantee of safety.';
+/** How many contributors the report highlights. */
+const TOP_N = 5;
+function contributionFor(entity) {
+    const confidence = Math.min(1, Math.max(0, entity.calibratedConfidence));
+    if (confidence < MIN_CONFIDENCE)
+        return undefined;
+    const category = CATEGORY_OF[entity.type];
+    if (category === undefined)
+        return undefined;
+    const weight = SEVERITY_WEIGHTS[category].weight;
+    const factor = TYPE_FACTORS[entity.type]?.factor ?? 1;
+    const points = confidence * weight * factor;
+    return {
+        type: entity.type,
+        category,
+        confidence,
+        weight,
+        factor,
+        points,
+        detail: `${entity.type} at ${(confidence * 100).toFixed(0)}% confidence × ${weight} (${category})${factor === 1 ? '' : ` × ${factor}`}`,
+    };
+}
+/**
+ * Saturating map from an unbounded points sum to 0–100.
+ *
+ * `1 - e^(-x/scale)` is strictly increasing on x ≥ 0 and asymptotic to 1, so
+ * it bounds the score without ever letting an added entity reduce it. Strict
+ * increase is the property monotonicity depends on; a curve that plateaued
+ * exactly would satisfy "never lowers" but would stop distinguishing
+ * documents, and one that overshot would break it.
+ */
+function saturate(points) {
+    return 100 * (1 - Math.exp(-points / SATURATION_SCALE));
+}
+/**
+ * Compute a document's exposure.
+ *
+ * Deterministic: the same entities in any order produce the same score, which
+ * matters because the report is shown to a user and must not flicker as
+ * detection order changes.
+ */
+export function computeExposure(entities) {
+    const contributions = entities
+        .map(contributionFor)
+        .filter((c) => c !== undefined);
+    const rawPoints = contributions.reduce((sum, c) => sum + c.points, 0);
+    const byCategoryMap = new Map();
+    for (const c of contributions) {
+        const acc = byCategoryMap.get(c.category) ?? { entities: 0, points: 0 };
+        acc.entities += 1;
+        acc.points += c.points;
+        byCategoryMap.set(c.category, acc);
+    }
+    const byCategory = [...byCategoryMap.entries()]
+        .map(([category, acc]) => ({
+        category,
+        entities: acc.entities,
+        points: acc.points,
+        share: rawPoints === 0 ? 0 : acc.points / rawPoints,
+    }))
+        .sort((a, b) => b.points - a.points || a.category.localeCompare(b.category));
+    const topContributors = [...contributions]
+        .sort((a, b) => b.points - a.points || a.type.localeCompare(b.type))
+        .slice(0, TOP_N);
+    return {
+        score: saturate(rawPoints),
+        rawPoints,
+        byCategory,
+        topContributors,
+        contributions,
+        limitation: EXPOSURE_LIMITATION,
+    };
+}
+/**
+ * A band for presentation. Thresholds are presentational only — every decision
+ * the pipeline makes uses calibrated confidence, never this label.
+ */
+export function exposureBand(score) {
+    if (score <= 0)
+        return 'none';
+    if (score < 20)
+        return 'low';
+    if (score < 45)
+        return 'moderate';
+    if (score < 70)
+        return 'high';
+    return 'severe';
+}
+//# sourceMappingURL=index.js.map

package/dist/src/exposure/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../src/exposure/index.ts"],"names":[],"mappings":"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"}

package/dist/src/fuse/calibrate.d.ts

@@ -0,0 +1,95 @@
+/**
+ * Stage 4 — CALIBRATION.
+ *
+ * SPEC.md: "Combine scores from all stages into a single calibrated confidence
+ * per candidate. Calibrate against the eval corpus so that a confidence of 0.8
+ * empirically means roughly 80% precision. Document the calibration method and
+ * the resulting reliability curve."
+ *
+ * THE METHOD: ISOTONIC REGRESSION, fitted per entity type.
+ *
+ * Isotonic rather than Platt scaling (a fitted logistic) for two reasons that
+ * matter here. First, the raw scores are not a logistic function of the truth
+ * and there is no reason to expect them to be: they are a base confidence plus
+ * a handful of additive Stage 3 contributions, so the shape of the mapping is
+ * unknown and a two-parameter family would impose one. Second, isotonic
+ * regression is EXPLAINABLE — the fitted model is a step function over score
+ * bins whose steps are empirical precisions, so "0.8 means 80%" can be read
+ * directly off the table rather than inferred from coefficients.
+ *
+ * What isotonic buys over raw binned precision is MONOTONICITY. A bin with few
+ * samples can easily show lower precision than the bin below it, which would
+ * make calibrated confidence non-monotonic in the evidence and produce the
+ * absurd result that adding evidence lowers confidence. Pool-adjacent-
+ * violators merges such bins, so the mapping never decreases.
+ *
+ * PER TYPE, because the types are not comparable. A validated IBAN and a
+ * shape-only postal code can carry the same raw score and mean entirely
+ * different things — that non-comparability is stated in the eval's own
+ * header and is exactly what calibration exists to remove. Types with too few
+ * samples to fit fall back to a pooled curve rather than to an overfitted one.
+ *
+ * FITTED AND EVALUATED ON DISJOINT DOCUMENTS. A curve fitted and scored on the
+ * same corpus measures nothing; the split is stated in BENCHMARKS.md.
+ */
+import type { EntityType } from '../types.js';
+/** One step of a fitted curve: scores in [from, to) map to `precision`. */
+export interface CalibrationBin {
+    readonly from: number;
+    readonly to: number;
+    /** Empirical precision of candidates whose raw score fell in this bin. */
+    readonly precision: number;
+    /** How many candidates the step was fitted on, for reporting weight. */
+    readonly samples: number;
+}
+export interface CalibrationCurve {
+    readonly bins: readonly CalibrationBin[];
+    readonly samples: number;
+}
+export interface CalibrationModel {
+    /** Per-type curves. Types absent here use `pooled`. */
+    readonly perType: Readonly<Partial<Record<EntityType, CalibrationCurve>>>;
+    /** Fallback for types with too little data to fit their own curve. */
+    readonly pooled: CalibrationCurve;
+    /** Documents the model was fitted on, for the split statement. */
+    readonly fittedOn: string;
+}
+/** One observation: a candidate's raw score and whether it was correct. */
+export interface CalibrationSample {
+    readonly type: EntityType;
+    readonly score: number;
+    readonly correct: boolean;
+}
+/** Fit a calibration model from labelled observations. */
+export declare function fitCalibration(samples: readonly CalibrationSample[], fittedOn: string): CalibrationModel;
+/**
+ * Map a raw score to a calibrated probability.
+ *
+ * PIECEWISE CONSTANT — the containing step's empirical precision, which is the
+ * standard prediction for an isotonic fit. An earlier revision interpolated
+ * between step midpoints to smooth the output, and that was an embellishment
+ * with no justification behind it: because the step function is coarse where
+ * data is sparse, interpolating systematically pulled predictions toward the
+ * step below and left the model under-confident through 0.7-0.8. Returning the
+ * step's own measured precision is both the standard method and the one whose
+ * meaning is readable — "candidates in this band were right this often".
+ */
+export declare function calibrate(model: CalibrationModel, type: EntityType, score: number): number;
+/** A reliability-curve row: what the model promised versus what happened. */
+export interface ReliabilityPoint {
+    readonly bucket: string;
+    readonly predicted: number;
+    readonly observed: number;
+    readonly samples: number;
+}
+/**
+ * Measure a fitted model against HELD-OUT observations.
+ *
+ * This is the number that means something: a curve scored on the documents it
+ * was fitted on measures memorisation, not calibration.
+ */
+export declare function reliability(model: CalibrationModel, heldOut: readonly CalibrationSample[], buckets?: number): {
+    readonly points: readonly ReliabilityPoint[];
+    readonly expectedCalibrationError: number;
+};
+//# sourceMappingURL=calibrate.d.ts.map

package/dist/src/fuse/calibrate.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"calibrate.d.ts","sourceRoot":"","sources":["../../../src/fuse/calibrate.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAiCG;AAEH,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,aAAa,CAAC;AAE9C,2EAA2E;AAC3E,MAAM,WAAW,cAAc;IAC7B,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,EAAE,EAAE,MAAM,CAAC;IACpB,0EAA0E;IAC1E,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAC;IAC3B,wEAAwE;IACxE,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;CAC1B;AAED,MAAM,WAAW,gBAAgB;IAC/B,QAAQ,CAAC,IAAI,EAAE,SAAS,cAAc,EAAE,CAAC;IACzC,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;CAC1B;AAED,MAAM,WAAW,gBAAgB;IAC/B,uDAAuD;IACvD,QAAQ,CAAC,OAAO,EAAE,QAAQ,CAAC,OAAO,CAAC,MAAM,CAAC,UAAU,EAAE,gBAAgB,CAAC,CAAC,CAAC,CAAC;IAC1E,sEAAsE;IACtE,QAAQ,CAAC,MAAM,EAAE,gBAAgB,CAAC;IAClC,kEAAkE;IAClE,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC;CAC3B;AAED,2EAA2E;AAC3E,MAAM,WAAW,iBAAiB;IAChC,QAAQ,CAAC,IAAI,EAAE,UAAU,CAAC;IAC1B,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;IACvB,QAAQ,CAAC,OAAO,EAAE,OAAO,CAAC;CAC3B;AAqED,0DAA0D;AAC1D,wBAAgB,cAAc,CAC5B,OAAO,EAAE,SAAS,iBAAiB,EAAE,EACrC,QAAQ,EAAE,MAAM,GACf,gBAAgB,CAclB;AAED;;;;;;;;;;;GAWG;AACH,wBAAgB,SAAS,CAAC,KAAK,EAAE,gBAAgB,EAAE,IAAI,EAAE,UAAU,EAAE,KAAK,EAAE,MAAM,GAAG,MAAM,CAQ1F;AAED,6EAA6E;AAC7E,MAAM,WAAW,gBAAgB;IAC/B,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;IACxB,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAC;IAC3B,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC;IAC1B,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;CAC1B;AAED;;;;;GAKG;AACH,wBAAgB,WAAW,CACzB,KAAK,EAAE,gBAAgB,EACvB,OAAO,EAAE,SAAS,iBAAiB,EAAE,EACrC,OAAO,SAAK,GACX;IAAE,QAAQ,CAAC,MAAM,EAAE,SAAS,gBAAgB,EAAE,CAAC;IAAC,QAAQ,CAAC,wBAAwB,EAAE,MAAM,CAAA;CAAE,CA4B7F"}

package/dist/src/fuse/calibrate.js

@@ -0,0 +1,165 @@
+/**
+ * Stage 4 — CALIBRATION.
+ *
+ * SPEC.md: "Combine scores from all stages into a single calibrated confidence
+ * per candidate. Calibrate against the eval corpus so that a confidence of 0.8
+ * empirically means roughly 80% precision. Document the calibration method and
+ * the resulting reliability curve."
+ *
+ * THE METHOD: ISOTONIC REGRESSION, fitted per entity type.
+ *
+ * Isotonic rather than Platt scaling (a fitted logistic) for two reasons that
+ * matter here. First, the raw scores are not a logistic function of the truth
+ * and there is no reason to expect them to be: they are a base confidence plus
+ * a handful of additive Stage 3 contributions, so the shape of the mapping is
+ * unknown and a two-parameter family would impose one. Second, isotonic
+ * regression is EXPLAINABLE — the fitted model is a step function over score
+ * bins whose steps are empirical precisions, so "0.8 means 80%" can be read
+ * directly off the table rather than inferred from coefficients.
+ *
+ * What isotonic buys over raw binned precision is MONOTONICITY. A bin with few
+ * samples can easily show lower precision than the bin below it, which would
+ * make calibrated confidence non-monotonic in the evidence and produce the
+ * absurd result that adding evidence lowers confidence. Pool-adjacent-
+ * violators merges such bins, so the mapping never decreases.
+ *
+ * PER TYPE, because the types are not comparable. A validated IBAN and a
+ * shape-only postal code can carry the same raw score and mean entirely
+ * different things — that non-comparability is stated in the eval's own
+ * header and is exactly what calibration exists to remove. Types with too few
+ * samples to fit fall back to a pooled curve rather than to an overfitted one.
+ *
+ * FITTED AND EVALUATED ON DISJOINT DOCUMENTS. A curve fitted and scored on the
+ * same corpus measures nothing; the split is stated in BENCHMARKS.md.
+ */
+/** Bins per curve. Ten keeps each step readable and populated. */
+const BIN_COUNT = 10;
+/**
+ * Minimum samples before a type gets its own curve.
+ *
+ * Below this the per-type curve would be fitted on noise, and a confidently
+ * wrong calibration is worse than an honest pooled one.
+ */
+const MIN_SAMPLES_PER_TYPE = 200;
+/**
+ * Pool adjacent violators: the isotonic regression fit.
+ *
+ * Walks left to right merging any bin whose precision is below its left
+ * neighbour, which yields the closest non-decreasing sequence in least
+ * squares. The merge is sample-weighted, so a large well-measured bin is not
+ * dragged by a tiny noisy one.
+ */
+function poolAdjacentViolators(raw) {
+    const stack = [];
+    for (const bin of raw) {
+        if (bin.total === 0)
+            continue;
+        stack.push({ ...bin });
+        // Merge backwards while the sequence decreases.
+        while (stack.length > 1) {
+            const right = stack[stack.length - 1];
+            const left = stack[stack.length - 2];
+            if (left.correct / left.total <= right.correct / right.total)
+                break;
+            stack.splice(stack.length - 2, 2, {
+                from: left.from,
+                to: right.to,
+                correct: left.correct + right.correct,
+                total: left.total + right.total,
+            });
+        }
+    }
+    return stack.map((b) => ({
+        from: b.from,
+        to: b.to,
+        precision: b.correct / b.total,
+        samples: b.total,
+    }));
+}
+function fitCurve(samples) {
+    const raw = Array.from({ length: BIN_COUNT }, (_, i) => ({
+        from: i / BIN_COUNT,
+        to: (i + 1) / BIN_COUNT,
+        correct: 0,
+        total: 0,
+    }));
+    for (const s of samples) {
+        const index = Math.min(BIN_COUNT - 1, Math.max(0, Math.floor(s.score * BIN_COUNT)));
+        const bin = raw[index];
+        bin.total += 1;
+        if (s.correct)
+            bin.correct += 1;
+    }
+    return { bins: poolAdjacentViolators(raw), samples: samples.length };
+}
+/** Fit a calibration model from labelled observations. */
+export function fitCalibration(samples, fittedOn) {
+    const byType = new Map();
+    for (const s of samples) {
+        const list = byType.get(s.type) ?? [];
+        list.push(s);
+        byType.set(s.type, list);
+    }
+    const perType = {};
+    for (const [type, list] of byType) {
+        if (list.length >= MIN_SAMPLES_PER_TYPE)
+            perType[type] = fitCurve(list);
+    }
+    return { perType, pooled: fitCurve(samples), fittedOn };
+}
+/**
+ * Map a raw score to a calibrated probability.
+ *
+ * PIECEWISE CONSTANT — the containing step's empirical precision, which is the
+ * standard prediction for an isotonic fit. An earlier revision interpolated
+ * between step midpoints to smooth the output, and that was an embellishment
+ * with no justification behind it: because the step function is coarse where
+ * data is sparse, interpolating systematically pulled predictions toward the
+ * step below and left the model under-confident through 0.7-0.8. Returning the
+ * step's own measured precision is both the standard method and the one whose
+ * meaning is readable — "candidates in this band were right this often".
+ */
+export function calibrate(model, type, score) {
+    const curve = model.perType[type] ?? model.pooled;
+    if (curve.bins.length === 0)
+        return score;
+    const clamped = Math.min(1, Math.max(0, score));
+    const index = curve.bins.findIndex((b) => clamped < b.to);
+    const bin = curve.bins[index === -1 ? curve.bins.length - 1 : index];
+    return bin.precision;
+}
+/**
+ * Measure a fitted model against HELD-OUT observations.
+ *
+ * This is the number that means something: a curve scored on the documents it
+ * was fitted on measures memorisation, not calibration.
+ */
+export function reliability(model, heldOut, buckets = 10) {
+    const acc = Array.from({ length: buckets }, () => ({ predicted: 0, correct: 0, total: 0 }));
+    for (const s of heldOut) {
+        const p = calibrate(model, s.type, s.score);
+        const index = Math.min(buckets - 1, Math.max(0, Math.floor(p * buckets)));
+        const bucket = acc[index];
+        bucket.predicted += p;
+        bucket.total += 1;
+        if (s.correct)
+            bucket.correct += 1;
+    }
+    const points = [];
+    let error = 0;
+    for (const [i, b] of acc.entries()) {
+        if (b.total === 0)
+            continue;
+        const predicted = b.predicted / b.total;
+        const observed = b.correct / b.total;
+        points.push({
+            bucket: `${(i / buckets).toFixed(1)}–${((i + 1) / buckets).toFixed(1)}`,
+            predicted,
+            observed,
+            samples: b.total,
+        });
+        error += (b.total / heldOut.length) * Math.abs(predicted - observed);
+    }
+    return { points, expectedCalibrationError: error };
+}
+//# sourceMappingURL=calibrate.js.map

package/dist/src/fuse/calibrate.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"calibrate.js","sourceRoot":"","sources":["../../../src/fuse/calibrate.ts"],"names":[],"mappings":"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"}

package/dist/src/fuse/defaultCalibration.d.ts

@@ -0,0 +1,52 @@
+/**
+ * defaultCalibration.ts — the shipped calibration model, checked rather than cast.
+ *
+ * ─────────────────────────────────────────────────────────────────────────
+ * THE CAST THIS REPLACES
+ *
+ * `@discretion/data` types the fitted model's `perType` as
+ * `Record<string, CalibrationCurveData>`, because it is generated from an eval
+ * run and the generator has no access to the `EntityType` union. Core's
+ * `CalibrationModel` wants `Partial<Record<EntityType, CalibrationCurve>>`.
+ *
+ * Every consumer so far bridged that with `as unknown as CalibrationModel`.
+ * The cast is not merely ugly: it asserts the keys are valid `EntityType`
+ * members without checking, so a model fitted before a type was renamed would
+ * carry a key that matches nothing. `calibrate()` would then fall through to
+ * the pooled curve for that type, forever, with no error and no warning — the
+ * numbers would just be quietly worse than the published ones.
+ *
+ * Converting with a check turns that into something observable.
+ */
+import type { CalibrationCurve, CalibrationModel } from './calibrate.js';
+/**
+ * The generated shape, restated so this module does not depend on data's types.
+ *
+ * Exported because it is `toCalibrationModel`'s parameter type: a consumer who
+ * fits their own model needs to name what the function accepts. It was local
+ * when this file was written, and `public-api.test.ts` caught it on its first
+ * run - which is the whole reason that test exists.
+ */
+export interface GeneratedCalibrationModel {
+    readonly perType: Readonly<Record<string, CalibrationCurve>>;
+    readonly pooled: CalibrationCurve;
+    readonly fittedOn: string;
+}
+export interface CalibrationConversion {
+    readonly model: CalibrationModel;
+    /**
+     * Keys in the generated model that are not `EntityType` members.
+     *
+     * Non-empty means the committed model and the union have drifted apart. The
+     * conversion still succeeds — dropping an unusable curve is better than
+     * refusing to calibrate anything — but the caller can now see it, and
+     * `calibration-model.test.ts` asserts it is empty.
+     */
+    readonly unknownTypes: readonly string[];
+}
+/**
+ * Convert a generated calibration model to core's typed one, reporting any key
+ * that is not a known entity type instead of assuming there are none.
+ */
+export declare function toCalibrationModel(generated: GeneratedCalibrationModel): CalibrationConversion;
+//# sourceMappingURL=defaultCalibration.d.ts.map

package/dist/src/fuse/defaultCalibration.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"defaultCalibration.d.ts","sourceRoot":"","sources":["../../../src/fuse/defaultCalibration.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;GAmBG;AAIH,OAAO,KAAK,EAAE,gBAAgB,EAAE,gBAAgB,EAAE,MAAM,gBAAgB,CAAC;AAEzE;;;;;;;GAOG;AACH,MAAM,WAAW,yBAAyB;IACxC,QAAQ,CAAC,OAAO,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,gBAAgB,CAAC,CAAC,CAAC;IAC7D,QAAQ,CAAC,MAAM,EAAE,gBAAgB,CAAC;IAClC,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC;CAC3B;AAED,MAAM,WAAW,qBAAqB;IACpC,QAAQ,CAAC,KAAK,EAAE,gBAAgB,CAAC;IACjC;;;;;;;OAOG;IACH,QAAQ,CAAC,YAAY,EAAE,SAAS,MAAM,EAAE,CAAC;CAC1C;AAED;;;GAGG;AACH,wBAAgB,kBAAkB,CAAC,SAAS,EAAE,yBAAyB,GAAG,qBAAqB,CAc9F"}

package/dist/src/fuse/defaultCalibration.js

@@ -0,0 +1,41 @@
+/**
+ * defaultCalibration.ts — the shipped calibration model, checked rather than cast.
+ *
+ * ─────────────────────────────────────────────────────────────────────────
+ * THE CAST THIS REPLACES
+ *
+ * `@discretion/data` types the fitted model's `perType` as
+ * `Record<string, CalibrationCurveData>`, because it is generated from an eval
+ * run and the generator has no access to the `EntityType` union. Core's
+ * `CalibrationModel` wants `Partial<Record<EntityType, CalibrationCurve>>`.
+ *
+ * Every consumer so far bridged that with `as unknown as CalibrationModel`.
+ * The cast is not merely ugly: it asserts the keys are valid `EntityType`
+ * members without checking, so a model fitted before a type was renamed would
+ * carry a key that matches nothing. `calibrate()` would then fall through to
+ * the pooled curve for that type, forever, with no error and no warning — the
+ * numbers would just be quietly worse than the published ones.
+ *
+ * Converting with a check turns that into something observable.
+ */
+import { ALL_ENTITY_TYPES } from '../entityTypes.js';
+/**
+ * Convert a generated calibration model to core's typed one, reporting any key
+ * that is not a known entity type instead of assuming there are none.
+ */
+export function toCalibrationModel(generated) {
+    const known = new Set(ALL_ENTITY_TYPES);
+    const perType = {};
+    const unknownTypes = [];
+    for (const [key, curve] of Object.entries(generated.perType)) {
+        if (known.has(key))
+            perType[key] = curve;
+        else
+            unknownTypes.push(key);
+    }
+    return {
+        model: { perType, pooled: generated.pooled, fittedOn: generated.fittedOn },
+        unknownTypes,
+    };
+}
+//# sourceMappingURL=defaultCalibration.js.map

package/dist/src/fuse/defaultCalibration.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"defaultCalibration.js","sourceRoot":"","sources":["../../../src/fuse/defaultCalibration.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;GAmBG;AAEH,OAAO,EAAE,gBAAgB,EAAE,MAAM,mBAAmB,CAAC;AA+BrD;;;GAGG;AACH,MAAM,UAAU,kBAAkB,CAAC,SAAoC;IACrE,MAAM,KAAK,GAAG,IAAI,GAAG,CAAS,gBAAgB,CAAC,CAAC;IAChD,MAAM,OAAO,GAAkD,EAAE,CAAC;IAClE,MAAM,YAAY,GAAa,EAAE,CAAC;IAElC,KAAK,MAAM,CAAC,GAAG,EAAE,KAAK,CAAC,IAAI,MAAM,CAAC,OAAO,CAAC,SAAS,CAAC,OAAO,CAAC,EAAE,CAAC;QAC7D,IAAI,KAAK,CAAC,GAAG,CAAC,GAAG,CAAC;YAAE,OAAO,CAAC,GAAiB,CAAC,GAAG,KAAK,CAAC;;YAClD,YAAY,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC;IAC9B,CAAC;IAED,OAAO;QACL,KAAK,EAAE,EAAE,OAAO,EAAE,MAAM,EAAE,SAAS,CAAC,MAAM,EAAE,QAAQ,EAAE,SAAS,CAAC,QAAQ,EAAE;QAC1E,YAAY;KACb,CAAC;AACJ,CAAC"}

package/dist/src/fuse/explain.d.ts

@@ -0,0 +1,55 @@
+/**
+ * Stage 4 — EXPLANATIONS.
+ *
+ * SPEC.md: "Every emitted entity carries an EXPLANATION: which stages fired,
+ * which triggers were found, which validator passed. This drives the review UI
+ * and makes failures diagnosable."
+ *
+ * The last clause is the one that shapes this module. An explanation is not
+ * decoration for the UI — it is how a wrong detection gets diagnosed without
+ * re-running the pipeline under a debugger. So it records what actually
+ * happened rather than a summary of it: which stages contributed, which named
+ * Stage 3 signals fired and with what sign, and what the profile decided.
+ *
+ * NO PLAINTEXT IN EXPLANATIONS, which is why triggers are lexicon terms and
+ * signal names rather than document text. Explanations flow into eval reports,
+ * the review panel, and the popup; a value that reached any of those would
+ * breach SPEC's third non-negotiable. The one exception is the entity's own
+ * text, which the caller already holds and which `DetectedEntity` carries in
+ * its own field.
+ */
+import type { DetectedEntity, EntityExplanation, EntityType } from '../types.js';
+import type { ContextScoredCandidate } from '../context/types.js';
+import type { ProfileDecision } from './profiles.js';
+/** What Stage 4 knows about one candidate as it becomes an entity. */
+export interface FusionInput {
+    readonly scored: ContextScoredCandidate;
+    /** Confidence after calibration; comparable across types. */
+    readonly calibratedConfidence: number;
+    /** Whether the entity's span was widened by overlap resolution. */
+    readonly absorbedOverlap?: boolean;
+    /** Types this candidate won an overlap against. */
+    readonly wonAgainst?: readonly EntityType[];
+}
+/**
+ * Build the explanation for one entity.
+ *
+ * `triggers` carries the Stage 3 signal names rather than only lexicon
+ * matches, because "why was this reported" is answered as much by
+ * `structure:key-names-API_KEY` as by a trigger word — and a reviewer chasing
+ * a false positive needs the negative signals too, which is why suppression
+ * and penalty signals appear with their sign rather than being filtered out.
+ */
+export declare function explain(input: FusionInput): EntityExplanation;
+/** Assemble the entity a consumer actually receives. */
+export declare function toDetectedEntity(input: FusionInput): DetectedEntity;
+/**
+ * A one-line reason a candidate was NOT reported.
+ *
+ * SPEC's explanation requirement covers emitted entities, but the review UI
+ * has to answer "why did you miss this?" too, and a suppression with no
+ * recorded reason is exactly the failure D18 was written about. Kept in the
+ * same module so the two stay consistent.
+ */
+export declare function explainOmission(scored: ContextScoredCandidate, decision?: ProfileDecision): string;
+//# sourceMappingURL=explain.d.ts.map

package/dist/src/fuse/explain.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"explain.d.ts","sourceRoot":"","sources":["../../../src/fuse/explain.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;GAmBG;AAEH,OAAO,KAAK,EAAE,cAAc,EAAkB,iBAAiB,EAAE,UAAU,EAAE,MAAM,aAAa,CAAC;AACjG,OAAO,KAAK,EAAE,sBAAsB,EAAE,MAAM,qBAAqB,CAAC;AAClE,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,eAAe,CAAC;AAErD,sEAAsE;AACtE,MAAM,WAAW,WAAW;IAC1B,QAAQ,CAAC,MAAM,EAAE,sBAAsB,CAAC;IACxC,6DAA6D;IAC7D,QAAQ,CAAC,oBAAoB,EAAE,MAAM,CAAC;IACtC,mEAAmE;IACnE,QAAQ,CAAC,eAAe,CAAC,EAAE,OAAO,CAAC;IACnC,mDAAmD;IACnD,QAAQ,CAAC,UAAU,CAAC,EAAE,SAAS,UAAU,EAAE,CAAC;CAC7C;AAED;;;;;;;;GAQG;AACH,wBAAgB,OAAO,CAAC,KAAK,EAAE,WAAW,GAAG,iBAAiB,CA4B7D;AAED,wDAAwD;AACxD,wBAAgB,gBAAgB,CAAC,KAAK,EAAE,WAAW,GAAG,cAAc,CAUnE;AAED;;;;;;;GAOG;AACH,wBAAgB,eAAe,CAC7B,MAAM,EAAE,sBAAsB,EAC9B,QAAQ,CAAC,EAAE,eAAe,GACzB,MAAM,CAcR"}