universal-physics-tensor 0.45.2 → 0.47.0

package/dist/atlas/derive-evidence.d.ts

@@ -0,0 +1,218 @@
+/**
+ * Atlas Phase 1, S1.3 — evidence tags, DERIVED AT READ TIME.
+ *
+ * Design note: `docs/planning/Atlas-Phase-1-Design.md` §3 and §4.
+ *
+ * **The contract of this module: it has no write path.** No record stores an
+ * evidence set; every tag is computed from the artifacts a record actually
+ * carries, each time it is asked for. A tag is emitted ONLY when the artifact
+ * it names is present and passing. There is no default-true tag, no tag
+ * derived from another tag, no tag derived from `reviewStatus`, and no tag
+ * derived from prose. A record carrying no passing witness derives exactly
+ * `{'proposed'}`.
+ *
+ * ## The empty-set trap (design note §3, Adam A1 RED — confirmed by execution)
+ *
+ * `convention-checked` is the ONLY rule in the table whose quantifier is
+ * universal (`every`). Written as "`conventions` is present AND every declared
+ * field is consumed by a witness", it hands the tag to a record with ZERO
+ * witnesses, because `conventions = {}` declares nothing and `[].every(…)` is
+ * vacuously true. {@link deriveEvidence} therefore requires a NON-EMPTY
+ * declaration before the universal runs, and
+ * `tests/atlas/derive-evidence.test.ts` pins the empty-object case.
+ *
+ * **The general rule, for anything added here later:** a universal quantifier
+ * in a tag derivation must be paired with a non-emptiness check, or the tag is
+ * free. The other rules are existentials (`some`), which are false on the
+ * empty set and therefore safe.
+ *
+ * ## What "passing" means, and why the caller supplies it
+ *
+ * `Witness` records an id and the test file that runs it; nothing on the
+ * record says whether that test passed. Proving it is a filesystem act (see
+ * `tests/atlas/evidence-rule.test.ts`, which matches witness ids against test
+ * titles), and this module is pure. So the set of passing witness ids is an
+ * ARGUMENT, and it is REQUIRED — {@link NO_PASSING_WITNESSES} must be passed
+ * explicitly when nothing is verified.
+ *
+ * It used to DEFAULT to empty, which sounds conservative and was in fact a
+ * defect (Eve E1 RED, confirmed by execution). Defaulting the other way, to
+ * "all", would have been the free-tag defect above in a second location — but
+ * defaulting to empty created the mirror-image failure: a forgotten argument
+ * produced an answer identical to a real negative. A catalog-wide check written
+ * that way could only ever report "no row gains evidence", whatever the rows
+ * held, so it could not fail. Requiring the argument makes a vacuous result a
+ * STATED choice, and `tests/atlas/coverage.test.ts` now carries a positive
+ * control so that a negative result carries information.
+ *
+ * @module atlas/derive-evidence
+ * @internal
+ */
+import type { Conventions, EvidenceTag, FormalFidelity } from './types.js';
+/**
+ * The verdict of `adjudicateBridgeEntry` (`src/bridges/membership.ts`),
+ * restated structurally so this module takes no dependency on `src/bridges`
+ * (the dependency must run one way — design note §1).
+ *
+ * `tests/atlas/derive-evidence.test.ts` pins this union against the real
+ * `BridgeVerdict` at compile time AND at runtime over the live catalog, so a
+ * fourth verdict fails the test rather than silently falling through.
+ *
+ * @internal
+ */
+export type MembershipVerdict = 'bridge' | 'not-a-bridge' | 'unadjudicated';
+/**
+ * A witness as this derivation reads it.
+ *
+ * Structural, not an import of `Witness`, for two reasons that are findings in
+ * their own right (both reported to the Lead):
+ *
+ *  - `Witness.kind` is `'symbolic' | 'numeric' | 'formal'` — there is NO
+ *    `'dimensional'` member, so `dimension-checked` has no source on today's
+ *    data. The kind is widened here to include `'dimensional'` so the rule is
+ *    written once and correctly; it simply never fires until such a witness
+ *    exists. Widening it is not inventing evidence: no record carries one.
+ *  - `Witness` records no list of the convention fields a check consumes, so
+ *    `consumes` is optional here. Absent ⇒ the witness consumes nothing ⇒
+ *    `convention-checked` cannot be earned. Conservative by construction.
+ *
+ * @internal
+ */
+export interface WitnessLike {
+    readonly id: string;
+    readonly kind: 'symbolic' | 'numeric' | 'formal' | 'dimensional';
+    /** Convention fields this check actually consumes, when it declares any. */
+    readonly consumes?: readonly (keyof Conventions)[];
+}
+/**
+ * A counterexample as this derivation reads it.
+ *
+ * `Counterexample` (`src/atlas/types.ts`) carries `description` and `witness`
+ * and has NO `resolvedBy` field — so on today's data every counterexample is
+ * unresolved. `resolvedBy` is read here as an optional property rather than
+ * assumed absent, so that adding it later resolves counterexamples without
+ * touching this file. This module adds no field to any type.
+ *
+ * @internal
+ */
+export interface CounterexampleLike {
+    readonly description?: string;
+    readonly witness?: string;
+    /** Present and non-empty ⇒ the counterexample is resolved and does not contradict. */
+    readonly resolvedBy?: string;
+}
+/**
+ * A rejection as this projection reads it — structural, so this module still
+ * imports nothing from `src/bridges`.
+ *
+ * @internal
+ */
+export interface RejectionLike {
+    readonly beId: number;
+    readonly reason: string;
+}
+/**
+ * A row's counterexamples INCLUDING the one its rejection constitutes.
+ *
+ * ROADMAP §7 Phase 1 asks for "a `RejectedBridgeAdjudication` ⇒ `contradicted`
+ * with the counterexample LINKED". The linking half is what matters and was
+ * missing: BE-35 had a counterexample written by hand and earned `contradicted`
+ * honestly, while BE-28, BE-29, BE-32 and BE-40 had none — and an earlier rule
+ * papered over that by FORCING `contradicted` onto every rejected row, which
+ * manufactured a refutation from nothing (Eve E1).
+ *
+ * This is the linking done properly. The rejection's own `reason` IS the
+ * counterexample: a row rejected for being single-regime is refuted AS A BRIDGE
+ * by exactly that argument. Projecting it means `contradicted` is then EARNED
+ * through the ordinary derivation rather than asserted by a special case.
+ *
+ * **It is a projection, not a copy.** The reason string is never duplicated into
+ * a catalog row; `bridges/rejected.ts` remains its single source, which is what
+ * the ROADMAP means by "cross-linked ... rather than duplicating it". The caller
+ * supplies the rejection, so this module still owns no view of WHICH ids are
+ * rejected.
+ *
+ * @internal
+ */
+export declare function counterexamplesWithRejection(record: EvidenceInput, rejection: RejectionLike | undefined): readonly CounterexampleLike[];
+/** The artifacts a record carries, all optional. @internal */
+export interface EvidenceInput {
+    readonly witnesses?: readonly WitnessLike[];
+    readonly conventions?: Conventions;
+    readonly counterexamples?: readonly CounterexampleLike[];
+    /**
+     * The record's formal reference, read ONLY for its fidelity. Structural so a
+     * caller can pass an `AtlasBridge` directly.
+     */
+    readonly formalRef?: {
+        readonly fidelity: FormalFidelity;
+    };
+}
+/**
+ * The empty passing set, for a caller that genuinely has nothing marked passing.
+ *
+ * ⚠ This is EXPORTED and must be passed EXPLICITLY. It used to be a default
+ * parameter value, and that was a defect found by post-implementation review
+ * (Eve, E1) and confirmed by execution: a record carrying three passing
+ * witnesses and a consumed convention derived `{'proposed'}` under the default —
+ * byte-identical to an empty record. A caller who simply forgot the argument got
+ * an answer indistinguishable from a real negative.
+ *
+ * That made a catalog-wide check VACUOUS rather than reassuring. "No row gains
+ * evidence" was the only outcome the call could produce, whatever the rows
+ * contained, so the check could not fail and proved nothing. Requiring the
+ * argument forces the caller to STATE which witnesses were verified, which is
+ * exactly the decision that must never be implicit.
+ */
+export declare const NO_PASSING_WITNESSES: ReadonlySet<string>;
+/**
+ * Derive the evidence set of one record.
+ *
+ * @param record - the artifacts the record carries.
+ * @param passingWitnessIds - ids of witnesses VERIFIED to pass. REQUIRED: pass
+ * {@link NO_PASSING_WITNESSES} explicitly when nothing is verified, so that a
+ * vacuous result is a stated choice rather than a forgotten argument.
+ * @returns a fresh set; never cached, never stored.
+ * @internal
+ */
+export declare function deriveEvidence(record: EvidenceInput, passingWitnessIds: ReadonlySet<string>): ReadonlySet<EvidenceTag>;
+/**
+ * Derive the evidence set of a catalog row, under the adjudication precedence
+ * of design note §4. The verdict is supplied by the caller — it comes from
+ * `adjudicateBridgeEntry`, which owns the rejected-id registry
+ * (`REJECTED_BRIDGE_IDS`). Reading that registry here would make this file a
+ * second source of truth about which ids are rejected.
+ *
+ * | Verdict | Derives |
+ * |---|---|
+ * | `'not-a-bridge'` | {@link deriveEvidence} runs normally — see below |
+ * | `'unadjudicated'` | `{'proposed'}` only — never a refutation, never support |
+ * | `'bridge'` | {@link deriveEvidence} runs normally |
+ *
+ * ## ⚠ `'not-a-bridge'` no longer forces `'contradicted'` (Eve E1, 2026-09-21)
+ *
+ * It used to, "regardless of witnesses", and that rule — written by me in design
+ * note §4 — **violated §3 of the same document.** `contradicted` means THE CLAIM
+ * IS REFUTED. `not-a-bridge` means THE ROW IS NOT A REGIME-CROSSING BRIDGE.
+ * Those are different assertions about different things, and conflating them made
+ * the library report BE-35 as `status: 'established'` and `evidence:
+ * {'contradicted'}` in the same breath — from which a reader cannot tell whether
+ * the equation is a true in-regime identity the bridge graph ignores, or a
+ * refuted statement.
+ *
+ * Measured when the rule was removed: of the five rejected rows, only **BE-35**
+ * carries an actual counterexample, and it derives `{'contradicted'}` NATURALLY
+ * through the normal path. **BE-28, BE-29, BE-32 and BE-40 carry none** — the old
+ * rule was manufacturing a refutation for four rows with no refuting artifact
+ * whatsoever. That is exactly what §3 forbids: a tag is emitted only when the
+ * artifact it names is present and passing.
+ *
+ * Membership already has a single owner — `adjudicateBridgeEntry` — and it does
+ * not need restating in the evidence vocabulary. Removing the case leaves each
+ * fact with exactly one source, which is what §4 was trying to achieve and this
+ * rule was quietly undermining.
+ *
+ * @internal
+ */
+export declare function deriveEvidenceForVerdict(verdict: MembershipVerdict, record: EvidenceInput, passingWitnessIds: ReadonlySet<string>): ReadonlySet<EvidenceTag>;
+//# sourceMappingURL=derive-evidence.d.ts.map

package/dist/atlas/derive-evidence.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"derive-evidence.d.ts","sourceRoot":"","sources":["../../src/atlas/derive-evidence.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAiDG;AAEH,OAAO,KAAK,EAAE,WAAW,EAAE,WAAW,EAAE,cAAc,EAAE,MAAM,YAAY,CAAC;AAE3E;;;;;;;;;;GAUG;AACH,MAAM,MAAM,iBAAiB,GAAG,QAAQ,GAAG,cAAc,GAAG,eAAe,CAAC;AAE5E;;;;;;;;;;;;;;;;GAgBG;AACH,MAAM,WAAW,WAAW;IAC1B,QAAQ,CAAC,EAAE,EAAE,MAAM,CAAC;IACpB,QAAQ,CAAC,IAAI,EAAE,UAAU,GAAG,SAAS,GAAG,QAAQ,GAAG,aAAa,CAAC;IACjE,4EAA4E;IAC5E,QAAQ,CAAC,QAAQ,CAAC,EAAE,SAAS,CAAC,MAAM,WAAW,CAAC,EAAE,CAAC;CACpD;AAED;;;;;;;;;;GAUG;AACH,MAAM,WAAW,kBAAkB;IACjC,QAAQ,CAAC,WAAW,CAAC,EAAE,MAAM,CAAC;IAC9B,QAAQ,CAAC,OAAO,CAAC,EAAE,MAAM,CAAC;IAC1B,sFAAsF;IACtF,QAAQ,CAAC,UAAU,CAAC,EAAE,MAAM,CAAC;CAC9B;AAED;;;;;GAKG;AACH,MAAM,WAAW,aAAa;IAC5B,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;CACzB;AAED;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,wBAAgB,4BAA4B,CAC1C,MAAM,EAAE,aAAa,EACrB,SAAS,EAAE,aAAa,GAAG,SAAS,GACnC,SAAS,kBAAkB,EAAE,CAqB/B;AAED,8DAA8D;AAC9D,MAAM,WAAW,aAAa;IAC5B,QAAQ,CAAC,SAAS,CAAC,EAAE,SAAS,WAAW,EAAE,CAAC;IAC5C,QAAQ,CAAC,WAAW,CAAC,EAAE,WAAW,CAAC;IACnC,QAAQ,CAAC,eAAe,CAAC,EAAE,SAAS,kBAAkB,EAAE,CAAC;IACzD;;;OAGG;IACH,QAAQ,CAAC,SAAS,CAAC,EAAE;QAAE,QAAQ,CAAC,QAAQ,EAAE,cAAc,CAAA;KAAE,CAAC;CAC5D;AAED;;;;;;;;;;;;;;;GAeG;AACH,eAAO,MAAM,oBAAoB,EAAE,WAAW,CAAC,MAAM,CAAqB,CAAC;AAmB3E;;;;;;;;;GASG;AACH,wBAAgB,cAAc,CAC5B,MAAM,EAAE,aAAa,EACrB,iBAAiB,EAAE,WAAW,CAAC,MAAM,CAAC,GACrC,WAAW,CAAC,WAAW,CAAC,CAyC1B;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAqCG;AACH,wBAAgB,wBAAwB,CACtC,OAAO,EAAE,iBAAiB,EAC1B,MAAM,EAAE,aAAa,EACrB,iBAAiB,EAAE,WAAW,CAAC,MAAM,CAAC,GACrC,WAAW,CAAC,WAAW,CAAC,CAY1B"}

package/dist/atlas/derive-evidence.js

@@ -0,0 +1,225 @@
+/**
+ * Atlas Phase 1, S1.3 — evidence tags, DERIVED AT READ TIME.
+ *
+ * Design note: `docs/planning/Atlas-Phase-1-Design.md` §3 and §4.
+ *
+ * **The contract of this module: it has no write path.** No record stores an
+ * evidence set; every tag is computed from the artifacts a record actually
+ * carries, each time it is asked for. A tag is emitted ONLY when the artifact
+ * it names is present and passing. There is no default-true tag, no tag
+ * derived from another tag, no tag derived from `reviewStatus`, and no tag
+ * derived from prose. A record carrying no passing witness derives exactly
+ * `{'proposed'}`.
+ *
+ * ## The empty-set trap (design note §3, Adam A1 RED — confirmed by execution)
+ *
+ * `convention-checked` is the ONLY rule in the table whose quantifier is
+ * universal (`every`). Written as "`conventions` is present AND every declared
+ * field is consumed by a witness", it hands the tag to a record with ZERO
+ * witnesses, because `conventions = {}` declares nothing and `[].every(…)` is
+ * vacuously true. {@link deriveEvidence} therefore requires a NON-EMPTY
+ * declaration before the universal runs, and
+ * `tests/atlas/derive-evidence.test.ts` pins the empty-object case.
+ *
+ * **The general rule, for anything added here later:** a universal quantifier
+ * in a tag derivation must be paired with a non-emptiness check, or the tag is
+ * free. The other rules are existentials (`some`), which are false on the
+ * empty set and therefore safe.
+ *
+ * ## What "passing" means, and why the caller supplies it
+ *
+ * `Witness` records an id and the test file that runs it; nothing on the
+ * record says whether that test passed. Proving it is a filesystem act (see
+ * `tests/atlas/evidence-rule.test.ts`, which matches witness ids against test
+ * titles), and this module is pure. So the set of passing witness ids is an
+ * ARGUMENT, and it is REQUIRED — {@link NO_PASSING_WITNESSES} must be passed
+ * explicitly when nothing is verified.
+ *
+ * It used to DEFAULT to empty, which sounds conservative and was in fact a
+ * defect (Eve E1 RED, confirmed by execution). Defaulting the other way, to
+ * "all", would have been the free-tag defect above in a second location — but
+ * defaulting to empty created the mirror-image failure: a forgotten argument
+ * produced an answer identical to a real negative. A catalog-wide check written
+ * that way could only ever report "no row gains evidence", whatever the rows
+ * held, so it could not fail. Requiring the argument makes a vacuous result a
+ * STATED choice, and `tests/atlas/coverage.test.ts` now carries a positive
+ * control so that a negative result carries information.
+ *
+ * @module atlas/derive-evidence
+ * @internal
+ */
+/**
+ * A row's counterexamples INCLUDING the one its rejection constitutes.
+ *
+ * ROADMAP §7 Phase 1 asks for "a `RejectedBridgeAdjudication` ⇒ `contradicted`
+ * with the counterexample LINKED". The linking half is what matters and was
+ * missing: BE-35 had a counterexample written by hand and earned `contradicted`
+ * honestly, while BE-28, BE-29, BE-32 and BE-40 had none — and an earlier rule
+ * papered over that by FORCING `contradicted` onto every rejected row, which
+ * manufactured a refutation from nothing (Eve E1).
+ *
+ * This is the linking done properly. The rejection's own `reason` IS the
+ * counterexample: a row rejected for being single-regime is refuted AS A BRIDGE
+ * by exactly that argument. Projecting it means `contradicted` is then EARNED
+ * through the ordinary derivation rather than asserted by a special case.
+ *
+ * **It is a projection, not a copy.** The reason string is never duplicated into
+ * a catalog row; `bridges/rejected.ts` remains its single source, which is what
+ * the ROADMAP means by "cross-linked ... rather than duplicating it". The caller
+ * supplies the rejection, so this module still owns no view of WHICH ids are
+ * rejected.
+ *
+ * @internal
+ */
+export function counterexamplesWithRejection(record, rejection) {
+    const own = record.counterexamples ?? [];
+    if (rejection === undefined)
+        return own;
+    // Do not double-count. A row may ALREADY cite the rejection by hand — BE-35
+    // does, with `witness: 'src/bridges/rejected.ts - REJECTED_BRIDGE_ADJUDICATIONS,
+    // beId 35'`. My first predicate matched only the machine key `rejection:<id>`
+    // and so missed it, appending the SAME argument a second time in different
+    // words, which is exactly the duplication the ROADMAP says to avoid. The
+    // predicate therefore accepts either form: the machine key, or any witness
+    // that names the rejection registry together with this beId.
+    const key = `rejection:${rejection.beId}`;
+    const alreadyLinked = own.some((c) => {
+        const w = c.witness ?? '';
+        if (w === key)
+            return true;
+        return w.includes('REJECTED_BRIDGE_ADJUDICATIONS') && w.includes(String(rejection.beId));
+    });
+    if (alreadyLinked)
+        return own;
+    return [
+        ...own,
+        { description: rejection.reason, witness: `rejection:${rejection.beId}` },
+    ];
+}
+/**
+ * The empty passing set, for a caller that genuinely has nothing marked passing.
+ *
+ * ⚠ This is EXPORTED and must be passed EXPLICITLY. It used to be a default
+ * parameter value, and that was a defect found by post-implementation review
+ * (Eve, E1) and confirmed by execution: a record carrying three passing
+ * witnesses and a consumed convention derived `{'proposed'}` under the default —
+ * byte-identical to an empty record. A caller who simply forgot the argument got
+ * an answer indistinguishable from a real negative.
+ *
+ * That made a catalog-wide check VACUOUS rather than reassuring. "No row gains
+ * evidence" was the only outcome the call could produce, whatever the rows
+ * contained, so the check could not fail and proved nothing. Requiring the
+ * argument forces the caller to STATE which witnesses were verified, which is
+ * exactly the decision that must never be implicit.
+ */
+export const NO_PASSING_WITNESSES = new Set();
+/** The fields `Conventions` may declare. Kept in one place so the check is total. */
+const CONVENTION_FIELDS = [
+    'heatWorkSign',
+    'metricSignature',
+    'fourierNormalization',
+    'unitSystem',
+    'capacitorChargeSign',
+];
+/** The convention fields a record actually declares (a `undefined` value declares nothing). */
+function declaredConventionFields(conventions) {
+    if (conventions === undefined)
+        return [];
+    return CONVENTION_FIELDS.filter((field) => conventions[field] !== undefined);
+}
+/**
+ * Derive the evidence set of one record.
+ *
+ * @param record - the artifacts the record carries.
+ * @param passingWitnessIds - ids of witnesses VERIFIED to pass. REQUIRED: pass
+ * {@link NO_PASSING_WITNESSES} explicitly when nothing is verified, so that a
+ * vacuous result is a stated choice rather than a forgotten argument.
+ * @returns a fresh set; never cached, never stored.
+ * @internal
+ */
+export function deriveEvidence(record, passingWitnessIds) {
+    const tags = new Set();
+    const passing = (record.witnesses ?? []).filter((w) => passingWitnessIds.has(w.id));
+    // Existentials over the passing witnesses — false on the empty set.
+    // `symbolically-checked` has exactly ONE derivation: a passing symbolic
+    // witness. Which symbolic witnesses pass is DEFINED by the committed results
+    // artifact (`data/atlas/witness-results.json`, Phase 4 §3) — the caller feeds
+    // it in through `passingWitnessIds` via `artifactPassingWitnessIds`.
+    if (passing.some((w) => w.kind === 'dimensional'))
+        tags.add('dimension-checked');
+    if (passing.some((w) => w.kind === 'symbolic'))
+        tags.add('symbolically-checked');
+    // `formally-proved` iff a formal reference exists AND someone checked that
+    // its statement says what the record says. `'unreviewed'` records a reference
+    // without earning the tag — a proof of the wrong statement proves nothing.
+    if (record.formalRef !== undefined && record.formalRef.fidelity !== 'unreviewed') {
+        tags.add('formally-proved');
+    }
+    if (passing.some((w) => w.kind === 'numeric'))
+        tags.add('numerically-supported');
+    // The ONE universal in the table — guarded by non-emptiness. See §3 above.
+    const declared = declaredConventionFields(record.conventions);
+    if (declared.length > 0 &&
+        declared.every((field) => passing.some((w) => (w.consumes ?? []).includes(field)))) {
+        tags.add('convention-checked');
+    }
+    // Existential: a counterexample with no resolution.
+    if ((record.counterexamples ?? []).some((c) => c.resolvedBy === undefined || c.resolvedBy === '')) {
+        tags.add('contradicted');
+    }
+    if (tags.size === 0)
+        tags.add('proposed');
+    return tags;
+}
+/**
+ * Derive the evidence set of a catalog row, under the adjudication precedence
+ * of design note §4. The verdict is supplied by the caller — it comes from
+ * `adjudicateBridgeEntry`, which owns the rejected-id registry
+ * (`REJECTED_BRIDGE_IDS`). Reading that registry here would make this file a
+ * second source of truth about which ids are rejected.
+ *
+ * | Verdict | Derives |
+ * |---|---|
+ * | `'not-a-bridge'` | {@link deriveEvidence} runs normally — see below |
+ * | `'unadjudicated'` | `{'proposed'}` only — never a refutation, never support |
+ * | `'bridge'` | {@link deriveEvidence} runs normally |
+ *
+ * ## ⚠ `'not-a-bridge'` no longer forces `'contradicted'` (Eve E1, 2026-09-21)
+ *
+ * It used to, "regardless of witnesses", and that rule — written by me in design
+ * note §4 — **violated §3 of the same document.** `contradicted` means THE CLAIM
+ * IS REFUTED. `not-a-bridge` means THE ROW IS NOT A REGIME-CROSSING BRIDGE.
+ * Those are different assertions about different things, and conflating them made
+ * the library report BE-35 as `status: 'established'` and `evidence:
+ * {'contradicted'}` in the same breath — from which a reader cannot tell whether
+ * the equation is a true in-regime identity the bridge graph ignores, or a
+ * refuted statement.
+ *
+ * Measured when the rule was removed: of the five rejected rows, only **BE-35**
+ * carries an actual counterexample, and it derives `{'contradicted'}` NATURALLY
+ * through the normal path. **BE-28, BE-29, BE-32 and BE-40 carry none** — the old
+ * rule was manufacturing a refutation for four rows with no refuting artifact
+ * whatsoever. That is exactly what §3 forbids: a tag is emitted only when the
+ * artifact it names is present and passing.
+ *
+ * Membership already has a single owner — `adjudicateBridgeEntry` — and it does
+ * not need restating in the evidence vocabulary. Removing the case leaves each
+ * fact with exactly one source, which is what §4 was trying to achieve and this
+ * rule was quietly undermining.
+ *
+ * @internal
+ */
+export function deriveEvidenceForVerdict(verdict, record, passingWitnessIds) {
+    switch (verdict) {
+        // 'not-a-bridge' falls through to the normal derivation on purpose: a row
+        // is refuted by a COUNTEREXAMPLE, not by failing a membership test. See the
+        // block comment above for the measurement that forced this change.
+        case 'not-a-bridge':
+            return deriveEvidence(record, passingWitnessIds);
+        case 'unadjudicated':
+            return new Set(['proposed']);
+        case 'bridge':
+            return deriveEvidence(record, passingWitnessIds);
+    }
+}
+//# sourceMappingURL=derive-evidence.js.map

package/dist/atlas/derive-evidence.js.map

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

package/dist/atlas/diffusion/bridges-closure.d.ts

@@ -0,0 +1,63 @@
+/**
+ * Atlas Phase 4 — the five diffusion-family bridges added to close Sprint 4's
+ * "≥ 20 bridges" exit criterion.
+ *
+ * Design note: `docs/planning/Atlas-Phase-4-Design.md` §4 (Sprint 4 closure).
+ *
+ * | Bridge | Relation | Witnesses |
+ * |---|---|---|
+ * | Langevin → Fick | `coarse-graining` | WD4 (convergence), WD4b (ballistic regime) |
+ * | Langevin + Stokes drag → Fick | `derivation`, **hyperedge** | WD5 (canonical + water), WD5s (CAS) |
+ * | telegraph → Fick | `approximation` (singular, τ → 0) | WD6 (convergence), WD6b (oscillatory modes) |
+ * | telegraph → 1-D wave | `approximation` (τDq² → ∞, t ≪ τ) | WD7 (convergence) |
+ * | heat → Laplace | `restriction` (steady state) | WD8 (convergence in time) |
+ *
+ * Every regime inequality keys a `PiGroup.formula` derived from the dimension
+ * matrix. Every `delta` is the EXACT error at its domain edge; every error
+ * function used for it is monotone on the domain, so the edge value is the
+ * supremum.
+ *
+ * @module atlas/diffusion/bridges-closure
+ */
+import type { AtlasBridge } from '../types.js';
+/** τ_p/t ceiling of the Langevin → Fick regime: WD4's fine resolution, t = 100 τ_p. @internal */
+export declare const LANGEVIN_MAX_TAU_RATIO = 0.01;
+/** ε = τDq² ceiling of the telegraph → Fick domain. @internal */
+export declare const TELEGRAPH_FICK_MAX_EPS = 0.05;
+/** ε = τDq² floor of the telegraph → wave domain. @internal */
+export declare const TELEGRAPH_WAVE_MIN_EPS = 25;
+/** Fourier-number floor of the steady-state restriction. @internal */
+export declare const STEADY_MIN_FOURIER = 1;
+/** Bridge: Langevin → Fick, the Einstein coarse-graining D = k_BT/γ. @internal */
+export declare const BRIDGE_LANGEVIN_DIFFUSION: AtlasBridge;
+/**
+ * Bridge: Langevin + Stokes drag → Fick with the Stokes–Einstein coefficient.
+ *
+ * A HYPEREDGE: the Langevin model supplies D = k_BT/γ with γ free; Stokes drag
+ * supplies γ = 6πηa for a sphere. Neither alone gives D in terms of the fluid.
+ *
+ * @internal
+ */
+export declare const BRIDGE_STOKES_EINSTEIN: AtlasBridge;
+/**
+ * Bridge: telegraph → Fick, the SINGULAR limit τ → 0.
+ *
+ * Singular because the highest time derivative is lost: the telegraph equation
+ * needs two initial conditions and diffusion takes one, so a fast mode
+ * `e^{−t/τ}` forms an initial layer. The bound therefore holds only AFTER that
+ * layer, and the machine horizon has a LOWER edge as well as an upper one.
+ *
+ * @internal
+ */
+export declare const BRIDGE_TELEGRAPH_DIFFUSION: AtlasBridge;
+/**
+ * Bridge: telegraph → 1-D wave, for strongly underdamped modes over short times.
+ *
+ * @internal
+ */
+export declare const BRIDGE_TELEGRAPH_WAVE: AtlasBridge;
+/** Bridge: heat → Laplace, the steady-state restriction. @internal */
+export declare const BRIDGE_HEAT_LAPLACE: AtlasBridge;
+/** The diffusion-family closure bridges. @internal */
+export declare const DIFFUSION_CLOSURE_BRIDGES: readonly AtlasBridge[];
+//# sourceMappingURL=bridges-closure.d.ts.map

package/dist/atlas/diffusion/bridges-closure.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"bridges-closure.d.ts","sourceRoot":"","sources":["../../../src/atlas/diffusion/bridges-closure.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;GAoBG;AAMH,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,aAAa,CAAC;AAS/C,iGAAiG;AACjG,eAAO,MAAM,sBAAsB,OAAO,CAAC;AAE3C,iEAAiE;AACjE,eAAO,MAAM,sBAAsB,OAAO,CAAC;AAE3C,+DAA+D;AAC/D,eAAO,MAAM,sBAAsB,KAAK,CAAC;AAEzC,sEAAsE;AACtE,eAAO,MAAM,kBAAkB,IAAI,CAAC;AAwBpC,kFAAkF;AAClF,eAAO,MAAM,yBAAyB,EAAE,WA0DvC,CAAC;AAEF;;;;;;;GAOG;AACH,eAAO,MAAM,sBAAsB,EAAE,WA4DpC,CAAC;AAEF;;;;;;;;;GASG;AACH,eAAO,MAAM,0BAA0B,EAAE,WA0ExC,CAAC;AAEF;;;;GAIG;AACH,eAAO,MAAM,qBAAqB,EAAE,WAkDnC,CAAC;AAEF,sEAAsE;AACtE,eAAO,MAAM,mBAAmB,EAAE,WAsCjC,CAAC;AAEF,sDAAsD;AACtD,eAAO,MAAM,yBAAyB,EAAE,SAAS,WAAW,EAM3D,CAAC"}