universal-physics-tensor 0.45.2 → 0.47.0

package/dist/atlas/benchmark/study.js

@@ -0,0 +1,192 @@
+/**
+ * Atlas Phase 6, S6.1 — scoring a benchmark condition against the answer key.
+ *
+ * Design note: `docs/planning/Atlas-Phase-5-Design.md` §9.
+ *
+ * This module receives the answer key as an ARGUMENT. It never reads the scorer
+ * half of the fixture tree itself: the import guard forbids any `src/` path into
+ * it. The orchestration script (`scripts/run-atlas-study.mjs`) loads the labels
+ * and passes them in.
+ *
+ * **An empty item set produces NO metrics, not zero metrics.** `scoreCondition`
+ * throws on it: a table of zeros and NaNs from an empty set is indistinguishable,
+ * at a glance, from a condition that failed everything.
+ *
+ * @module atlas/benchmark/study
+ * @internal
+ */
+import { FAILURE_KINDS } from './types.js';
+import { mcnemar, pairedDifferenceInterval, wilsonInterval } from './stats.js';
+const KNOWN_FAILURES = new Set(FAILURE_KINDS);
+/**
+ * Check an answer key against the item ids it must cover: exactly one label per
+ * item, no label for an unknown item, a known failure kind on every invalid
+ * label and none on a valid one. Takes the key as an ARGUMENT, like everything
+ * here, because no `src/` file may read the scorer half.
+ *
+ * @param itemIds - the ids of the frozen items.
+ * @param labels - the answer key.
+ * @returns every problem found, labels first in key order, then missing labels
+ * in item order; empty means the key fits.
+ * @internal
+ */
+export function validateLabels(itemIds, labels) {
+    const problems = [];
+    const ids = new Set(itemIds);
+    const seen = new Set();
+    for (const l of labels) {
+        const p = (problem) => {
+            problems.push({ id: l.itemId, problem });
+        };
+        if (seen.has(l.itemId))
+            p('duplicate label');
+        seen.add(l.itemId);
+        if (!ids.has(l.itemId))
+            p('label for an item not in the set');
+        if (l.kind === 'invalid') {
+            if (l.failureKind === undefined)
+                p('an invalid label must name its failureKind');
+            else if (!KNOWN_FAILURES.has(l.failureKind))
+                p(`unknown failureKind '${l.failureKind}'`);
+        }
+        else if (l.failureKind !== undefined) {
+            p('a valid label must not carry a failureKind');
+        }
+    }
+    for (const id of itemIds)
+        if (!seen.has(id))
+            problems.push({ id, problem: 'no label' });
+    return problems;
+}
+/**
+ * Score one condition against the answer key.
+ *
+ * @throws Error when the key is empty (no measurement exists), or when an answer
+ * names an item the key does not contain.
+ * @internal
+ */
+export function scoreCondition(condition, answers, labels) {
+    if (labels.length === 0) {
+        throw new Error(`scoreCondition(${condition}): the answer key is empty — there is nothing to measure`);
+    }
+    const byId = new Map(answers.map((a) => [a.itemId, a]));
+    const labelIds = new Set(labels.map((l) => l.itemId));
+    for (const a of answers) {
+        if (!labelIds.has(a.itemId))
+            throw new Error(`scoreCondition(${condition}): answer for unknown item ${a.itemId}`);
+    }
+    let nValid = 0;
+    let nInvalid = 0;
+    let invalidRejected = 0;
+    let kindNamedCorrectly = 0;
+    let wrongAccepts = 0;
+    let validAccepted = 0;
+    let falseRejects = 0;
+    let abstentions = 0;
+    let unanswered = 0;
+    for (const label of labels) {
+        const answer = byId.get(label.itemId);
+        if (answer === undefined)
+            unanswered++;
+        else if (answer.outcome === 'abstain')
+            abstentions++;
+        if (label.kind === 'valid') {
+            nValid++;
+            if (answer?.outcome === 'accept')
+                validAccepted++;
+            if (answer?.outcome === 'reject')
+                falseRejects++;
+        }
+        else {
+            nInvalid++;
+            if (answer?.outcome === 'accept')
+                wrongAccepts++;
+            if (answer?.outcome === 'reject') {
+                invalidRejected++;
+                if (answer.detectedFailure !== undefined && answer.detectedFailure === label.failureKind) {
+                    kindNamedCorrectly++;
+                }
+            }
+        }
+    }
+    return {
+        condition,
+        nValid,
+        nInvalid,
+        invalidRejected,
+        invalidRejectionInterval: nInvalid === 0 ? { lower: Number.NaN, upper: Number.NaN } : wilsonInterval(invalidRejected, nInvalid),
+        kindNamedCorrectly,
+        wrongAccepts,
+        validAccepted,
+        falseRejects,
+        abstentions,
+        unanswered,
+    };
+}
+/**
+ * Compare two conditions on the SAME invalid items. An item counts as "right"
+ * for a condition when it was rejected; an unanswered item is "wrong", not dropped.
+ *
+ * @throws Error when there are no invalid items.
+ * @internal
+ */
+export function pairedRejection(conditionA, answersA, conditionB, answersB, labels) {
+    const invalid = labels.filter((l) => l.kind === 'invalid');
+    if (invalid.length === 0)
+        throw new Error('pairedRejection: no invalid items to compare on');
+    const rejectedBy = (answers) => new Set(answers.filter((x) => x.outcome === 'reject').map((x) => x.itemId));
+    const ra = rejectedBy(answersA);
+    const rb = rejectedBy(answersB);
+    let a = 0;
+    let b = 0;
+    let c = 0;
+    let d = 0;
+    for (const l of invalid) {
+        const x = ra.has(l.itemId);
+        const y = rb.has(l.itemId);
+        if (x && y)
+            a++;
+        else if (x)
+            b++;
+        else if (y)
+            c++;
+        else
+            d++;
+    }
+    const table = { a, b, c, d };
+    const difference = pairedDifferenceInterval(table);
+    return {
+        conditionA,
+        conditionB,
+        table,
+        difference,
+        mcnemar: mcnemar(table),
+        aBetterExcludingZero: difference.lower > 0,
+    };
+}
+/**
+ * Score a sequence of named condition runs as an ablation: each row is scored,
+ * and each row after the first is compared, paired on the same invalid items,
+ * against the row before it — so the table shows what each added layer bought.
+ *
+ * @internal
+ */
+export function scoreAblation(runs, labels) {
+    const rows = [];
+    for (let i = 0; i < runs.length; i++) {
+        const [name, answers] = runs[i];
+        const metrics = scoreCondition(name, answers, labels);
+        if (i === 0)
+            rows.push({ configuration: name, metrics });
+        else {
+            const [prevName, prevAnswers] = runs[i - 1];
+            rows.push({
+                configuration: name,
+                metrics,
+                stepOverPrevious: pairedRejection(name, answers, prevName, prevAnswers, labels),
+            });
+        }
+    }
+    return rows;
+}
+//# sourceMappingURL=study.js.map

package/dist/atlas/benchmark/study.js.map

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

package/dist/atlas/benchmark/types.d.ts

@@ -0,0 +1,79 @@
+/**
+ * Atlas Phase 5, S5.1 — the invalid-bridge benchmark's item schema.
+ *
+ * Design note: `docs/planning/Atlas-Phase-5-Design.md` §2.
+ *
+ * ⚠ **No agent authors a frozen item** (design note §0). This file defines the
+ * SHAPE an independent author fills in; it contains no items.
+ *
+ * @module atlas/benchmark/types
+ * @internal
+ */
+import type { ExprNode } from '../../dimensional/ast-types.js';
+import type { Conventions, RegimeInequality, RelationType } from '../types.js';
+/** The eight failure kinds, sampled evenly (ROADMAP Phase 5). @internal */
+export declare const FAILURE_KINDS: readonly ['omitted-premise', 'domain-violation', 'convention-mismatch', 'notation-collision', 'dimensional-coincidence', 'non-uniform-limit', 'false-inverse', 'analogy-promoted'];
+/** One failure kind. @internal */
+export type FailureKind = (typeof FAILURE_KINDS)[number];
+/**
+ * Who wrote an item. Only `'independent'` may be frozen; `'contested-draft'`
+ * is what an agent may produce, into `contested/`, and nothing else.
+ *
+ * @internal
+ */
+export type Authorship = 'independent' | 'contested-draft';
+/** Which split an item scores in. @internal */
+export type BenchmarkSplit = 'in-distribution' | 'held-out';
+/**
+ * The held-out family. Corrected from the plan's "first-order relaxation",
+ * which Phase 0 already encodes as `model-first-order` (design note §4).
+ *
+ * @internal
+ */
+export declare const HELD_OUT_FAMILY = "fluid-statics";
+/**
+ * Markers that identify the held-out family in model ids, dynamics and bridge
+ * ids. `tests/atlas/benchmark.test.ts` scans the atlas for them, and proves the
+ * scan can fire with the ORIGINAL family's markers as a positive control.
+ *
+ * @internal
+ */
+export declare const HELD_OUT_MARKERS: readonly string[];
+/**
+ * One benchmark item, as its PUBLIC half carries it — never the answer. Whether
+ * the item is valid, and which failure kind it has, live only in the scorer
+ * half (`ItemLabel` in `study.ts`), so a condition that reads the public file
+ * cannot read the key.
+ *
+ * @internal
+ */
+export interface BenchmarkItem {
+    readonly id: string;
+    readonly premises: readonly string[];
+    readonly conclusion: string;
+    readonly claimedRelation: RelationType;
+    readonly family: string;
+    readonly split: BenchmarkSplit;
+    /** The claimed relation as an AST, so the leakage check can run. */
+    readonly expr: ExprNode;
+    /** The id of the item this one renames, when it is a renamed-variable variant. */
+    readonly renamedVariant?: string;
+    readonly authorship: Authorship;
+    /** Where the item came from: an erratum, a documented misconception, a textbook. */
+    readonly source: string;
+    /** The claim's stated side conditions, as prose. `[]` states "none". */
+    readonly sideConditions?: readonly string[];
+    /** Conventions declared by the premises and by the conclusion. */
+    readonly conventions?: {
+        readonly premise?: Conventions;
+        readonly conclusion?: Conventions;
+    };
+    /** When the claim is a CHAIN: the two relations composed to reach `claimedRelation`. */
+    readonly composedFrom?: readonly [RelationType, RelationType];
+    /** The regime the claim is used in: its inequalities and the π-group values at the use site. */
+    readonly regime?: {
+        readonly inequalities: readonly RegimeInequality[];
+        readonly values: Readonly<Record<string, number>>;
+    };
+}
+//# sourceMappingURL=types.d.ts.map

package/dist/atlas/benchmark/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../../src/atlas/benchmark/types.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AAEH,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,gCAAgC,CAAC;AAC/D,OAAO,KAAK,EAAE,WAAW,EAAE,gBAAgB,EAAE,YAAY,EAAE,MAAM,aAAa,CAAC;AAE/E,2EAA2E;AAC3E,eAAO,MAAM,aAAa,YACxB,iBAAiB,EACjB,kBAAkB,EAClB,qBAAqB,EACrB,oBAAoB,EACpB,yBAAyB,EACzB,mBAAmB,EACnB,eAAe,EACf,kBAAkB,CACV,CAAC;AAEX,kCAAkC;AAClC,MAAM,MAAM,WAAW,GAAG,CAAC,OAAO,aAAa,CAAC,CAAC,MAAM,CAAC,CAAC;AAEzD;;;;;GAKG;AACH,MAAM,MAAM,UAAU,GAAG,aAAa,GAAG,iBAAiB,CAAC;AAE3D,+CAA+C;AAC/C,MAAM,MAAM,cAAc,GAAG,iBAAiB,GAAG,UAAU,CAAC;AAE5D;;;;;GAKG;AACH,eAAO,MAAM,eAAe,kBAAkB,CAAC;AAE/C;;;;;;GAMG;AACH,eAAO,MAAM,gBAAgB,EAAE,SAAS,MAAM,EAQ7C,CAAC;AAEF;;;;;;;GAOG;AACH,MAAM,WAAW,aAAa;IAC5B,QAAQ,CAAC,EAAE,EAAE,MAAM,CAAC;IACpB,QAAQ,CAAC,QAAQ,EAAE,SAAS,MAAM,EAAE,CAAC;IACrC,QAAQ,CAAC,UAAU,EAAE,MAAM,CAAC;IAC5B,QAAQ,CAAC,eAAe,EAAE,YAAY,CAAC;IACvC,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;IACxB,QAAQ,CAAC,KAAK,EAAE,cAAc,CAAC;IAC/B,oEAAoE;IACpE,QAAQ,CAAC,IAAI,EAAE,QAAQ,CAAC;IACxB,kFAAkF;IAClF,QAAQ,CAAC,cAAc,CAAC,EAAE,MAAM,CAAC;IACjC,QAAQ,CAAC,UAAU,EAAE,UAAU,CAAC;IAChC,oFAAoF;IACpF,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;IAMxB,wEAAwE;IACxE,QAAQ,CAAC,cAAc,CAAC,EAAE,SAAS,MAAM,EAAE,CAAC;IAC5C,kEAAkE;IAClE,QAAQ,CAAC,WAAW,CAAC,EAAE;QACrB,QAAQ,CAAC,OAAO,CAAC,EAAE,WAAW,CAAC;QAC/B,QAAQ,CAAC,UAAU,CAAC,EAAE,WAAW,CAAC;KACnC,CAAC;IACF,wFAAwF;IACxF,QAAQ,CAAC,YAAY,CAAC,EAAE,SAAS,CAAC,YAAY,EAAE,YAAY,CAAC,CAAC;IAC9D,gGAAgG;IAChG,QAAQ,CAAC,MAAM,CAAC,EAAE;QAChB,QAAQ,CAAC,YAAY,EAAE,SAAS,gBAAgB,EAAE,CAAC;QACnD,QAAQ,CAAC,MAAM,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC,CAAC;KACnD,CAAC;CACH"}

package/dist/atlas/benchmark/types.js

@@ -0,0 +1,46 @@
+/**
+ * Atlas Phase 5, S5.1 — the invalid-bridge benchmark's item schema.
+ *
+ * Design note: `docs/planning/Atlas-Phase-5-Design.md` §2.
+ *
+ * ⚠ **No agent authors a frozen item** (design note §0). This file defines the
+ * SHAPE an independent author fills in; it contains no items.
+ *
+ * @module atlas/benchmark/types
+ * @internal
+ */
+/** The eight failure kinds, sampled evenly (ROADMAP Phase 5). @internal */
+export const FAILURE_KINDS = [
+    'omitted-premise',
+    'domain-violation',
+    'convention-mismatch',
+    'notation-collision',
+    'dimensional-coincidence',
+    'non-uniform-limit',
+    'false-inverse',
+    'analogy-promoted',
+];
+/**
+ * The held-out family. Corrected from the plan's "first-order relaxation",
+ * which Phase 0 already encodes as `model-first-order` (design note §4).
+ *
+ * @internal
+ */
+export const HELD_OUT_FAMILY = 'fluid-statics';
+/**
+ * Markers that identify the held-out family in model ids, dynamics and bridge
+ * ids. `tests/atlas/benchmark.test.ts` scans the atlas for them, and proves the
+ * scan can fire with the ORIGINAL family's markers as a positive control.
+ *
+ * @internal
+ */
+export const HELD_OUT_MARKERS = [
+    'hydrostat',
+    'buoyan',
+    'archimed',
+    'pascal',
+    'barometric',
+    'fluid-static',
+    'fluid statics',
+];
+//# sourceMappingURL=types.js.map

package/dist/atlas/benchmark/types.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.js","sourceRoot":"","sources":["../../../src/atlas/benchmark/types.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AAKH,2EAA2E;AAC3E,MAAM,CAAC,MAAM,aAAa,GAAG;IAC3B,iBAAiB;IACjB,kBAAkB;IAClB,qBAAqB;IACrB,oBAAoB;IACpB,yBAAyB;IACzB,mBAAmB;IACnB,eAAe;IACf,kBAAkB;CACV,CAAC;AAgBX;;;;;GAKG;AACH,MAAM,CAAC,MAAM,eAAe,GAAG,eAAe,CAAC;AAE/C;;;;;;GAMG;AACH,MAAM,CAAC,MAAM,gBAAgB,GAAsB;IACjD,WAAW;IACX,QAAQ;IACR,UAAU;IACV,QAAQ;IACR,YAAY;IACZ,cAAc;IACd,eAAe;CAChB,CAAC"}

package/dist/atlas/composition-table.d.ts

@@ -0,0 +1,55 @@
+/**
+ * The composition table for `RelationType` — a literal 8×8 matrix.
+ *
+ * `composeRelation(first, second)` answers: if one bridge asserts `first` and a
+ * second bridge asserts `second`, what relation does the chain assert? The
+ * argument order is the `First ∘ Second` column order of design note
+ * `docs/planning/Atlas-Phase-1-Design.md` §2.1.
+ *
+ * **The table is a deliberate UNDER-approximation of Blueprint v2 §4.2.** Every
+ * cell not named in §2.1 is `'no-composite-claim'`, because a wrong composite
+ * type is a false physical claim while silence is only silence. Eight of the
+ * sixty-four cells are defined; the remaining fifty-six are silent, and the
+ * reasons for the notable silences are §2.2.
+ *
+ * Two cells the implementation plan asserts are NOT defined here, on the
+ * authority of the design note (§0 and §2.2 item 5):
+ *
+ * - `exact-equivalence ∘ approximation`, either order. An exact equivalence
+ *   contributes `IDENTITY_BOUND` only *in the norm a given bridge states* (see
+ *   `./error-algebra.ts`), and no field in Sprint 1 records a norm, so
+ *   norm-compatibility cannot be checked. A `norm?` field unblocks it in
+ *   Phase 2.
+ * - `structural-analogy ∘ structural-analogy`. Analogy is not transitive: the
+ *   shared structure can dilute to nothing across a chain.
+ *
+ * Widening this table is a reviewed act — `tests/atlas/composition-table.test.ts`
+ * pins the count of silent cells.
+ *
+ * Pure: no I/O, no registry reads, and no import from `src/composition/`.
+ *
+ * @module atlas/composition-table
+ */
+import type { RelationType } from './types.js';
+/** What `composeRelation` returns when the chain asserts nothing. @public */
+export type NoCompositeClaim = 'no-composite-claim';
+/** The result of composing two relations. @public */
+export type CompositionResult = RelationType | NoCompositeClaim;
+/** @public */
+export declare const NO_COMPOSITE_CLAIM: NoCompositeClaim;
+/**
+ * Every row of every column, written out. `Record<RelationType, …>` makes the
+ * exhaustiveness structural: a ninth `RelationType` member fails to compile
+ * here rather than silently acquiring a row of `'no-composite-claim'`.
+ *
+ * @public
+ */
+export declare const COMPOSITION_TABLE: Readonly<Record<RelationType, Readonly<Record<RelationType, CompositionResult>>>>;
+/**
+ * The relation a chain of two bridges asserts, or `'no-composite-claim'` when
+ * this sprint declines to assert one. A table lookup — no rules, no inference.
+ *
+ * @public
+ */
+export declare function composeRelation(first: RelationType, second: RelationType): CompositionResult;
+//# sourceMappingURL=composition-table.d.ts.map

package/dist/atlas/composition-table.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"composition-table.d.ts","sourceRoot":"","sources":["../../src/atlas/composition-table.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+BG;AAEH,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,YAAY,CAAC;AAE/C,6EAA6E;AAC7E,MAAM,MAAM,gBAAgB,GAAG,oBAAoB,CAAC;AAEpD,qDAAqD;AACrD,MAAM,MAAM,iBAAiB,GAAG,YAAY,GAAG,gBAAgB,CAAC;AAEhE,cAAc;AACd,eAAO,MAAM,kBAAkB,EAAE,gBAAuC,CAAC;AAEzE;;;;;;GAMG;AACH,eAAO,MAAM,iBAAiB,EAAE,QAAQ,CACtC,MAAM,CAAC,YAAY,EAAE,QAAQ,CAAC,MAAM,CAAC,YAAY,EAAE,iBAAiB,CAAC,CAAC,CAAC,CAkFxE,CAAC;AAEF;;;;;GAKG;AACH,wBAAgB,eAAe,CAC7B,KAAK,EAAE,YAAY,EACnB,MAAM,EAAE,YAAY,GACnB,iBAAiB,CAEnB"}

package/dist/atlas/composition-table.js

@@ -0,0 +1,133 @@
+/**
+ * The composition table for `RelationType` — a literal 8×8 matrix.
+ *
+ * `composeRelation(first, second)` answers: if one bridge asserts `first` and a
+ * second bridge asserts `second`, what relation does the chain assert? The
+ * argument order is the `First ∘ Second` column order of design note
+ * `docs/planning/Atlas-Phase-1-Design.md` §2.1.
+ *
+ * **The table is a deliberate UNDER-approximation of Blueprint v2 §4.2.** Every
+ * cell not named in §2.1 is `'no-composite-claim'`, because a wrong composite
+ * type is a false physical claim while silence is only silence. Eight of the
+ * sixty-four cells are defined; the remaining fifty-six are silent, and the
+ * reasons for the notable silences are §2.2.
+ *
+ * Two cells the implementation plan asserts are NOT defined here, on the
+ * authority of the design note (§0 and §2.2 item 5):
+ *
+ * - `exact-equivalence ∘ approximation`, either order. An exact equivalence
+ *   contributes `IDENTITY_BOUND` only *in the norm a given bridge states* (see
+ *   `./error-algebra.ts`), and no field in Sprint 1 records a norm, so
+ *   norm-compatibility cannot be checked. A `norm?` field unblocks it in
+ *   Phase 2.
+ * - `structural-analogy ∘ structural-analogy`. Analogy is not transitive: the
+ *   shared structure can dilute to nothing across a chain.
+ *
+ * Widening this table is a reviewed act — `tests/atlas/composition-table.test.ts`
+ * pins the count of silent cells.
+ *
+ * Pure: no I/O, no registry reads, and no import from `src/composition/`.
+ *
+ * @module atlas/composition-table
+ */
+/** @public */
+export const NO_COMPOSITE_CLAIM = 'no-composite-claim';
+/**
+ * Every row of every column, written out. `Record<RelationType, …>` makes the
+ * exhaustiveness structural: a ninth `RelationType` member fails to compile
+ * here rather than silently acquiring a row of `'no-composite-claim'`.
+ *
+ * @public
+ */
+export const COMPOSITION_TABLE = {
+    derivation: {
+        derivation: 'derivation',
+        'exact-equivalence': 'derivation',
+        restriction: NO_COMPOSITE_CLAIM,
+        approximation: NO_COMPOSITE_CLAIM,
+        'coarse-graining': NO_COMPOSITE_CLAIM,
+        'analytic-continuation': NO_COMPOSITE_CLAIM,
+        'structural-analogy': NO_COMPOSITE_CLAIM,
+        'deformation-quantization': NO_COMPOSITE_CLAIM,
+    },
+    'exact-equivalence': {
+        derivation: 'derivation',
+        'exact-equivalence': 'exact-equivalence',
+        restriction: 'restriction',
+        approximation: NO_COMPOSITE_CLAIM,
+        'coarse-graining': NO_COMPOSITE_CLAIM,
+        'analytic-continuation': NO_COMPOSITE_CLAIM,
+        'structural-analogy': NO_COMPOSITE_CLAIM,
+        'deformation-quantization': NO_COMPOSITE_CLAIM,
+    },
+    restriction: {
+        derivation: NO_COMPOSITE_CLAIM,
+        'exact-equivalence': 'restriction',
+        restriction: 'restriction',
+        approximation: NO_COMPOSITE_CLAIM,
+        'coarse-graining': NO_COMPOSITE_CLAIM,
+        'analytic-continuation': NO_COMPOSITE_CLAIM,
+        'structural-analogy': NO_COMPOSITE_CLAIM,
+        'deformation-quantization': NO_COMPOSITE_CLAIM,
+    },
+    approximation: {
+        derivation: NO_COMPOSITE_CLAIM,
+        'exact-equivalence': NO_COMPOSITE_CLAIM,
+        restriction: NO_COMPOSITE_CLAIM,
+        approximation: NO_COMPOSITE_CLAIM,
+        'coarse-graining': NO_COMPOSITE_CLAIM,
+        'analytic-continuation': NO_COMPOSITE_CLAIM,
+        'structural-analogy': NO_COMPOSITE_CLAIM,
+        'deformation-quantization': NO_COMPOSITE_CLAIM,
+    },
+    'coarse-graining': {
+        derivation: NO_COMPOSITE_CLAIM,
+        'exact-equivalence': NO_COMPOSITE_CLAIM,
+        restriction: NO_COMPOSITE_CLAIM,
+        approximation: NO_COMPOSITE_CLAIM,
+        'coarse-graining': 'coarse-graining',
+        'analytic-continuation': NO_COMPOSITE_CLAIM,
+        'structural-analogy': NO_COMPOSITE_CLAIM,
+        'deformation-quantization': NO_COMPOSITE_CLAIM,
+    },
+    'analytic-continuation': {
+        derivation: NO_COMPOSITE_CLAIM,
+        'exact-equivalence': NO_COMPOSITE_CLAIM,
+        restriction: NO_COMPOSITE_CLAIM,
+        approximation: NO_COMPOSITE_CLAIM,
+        'coarse-graining': NO_COMPOSITE_CLAIM,
+        'analytic-continuation': NO_COMPOSITE_CLAIM,
+        'structural-analogy': NO_COMPOSITE_CLAIM,
+        'deformation-quantization': NO_COMPOSITE_CLAIM,
+    },
+    'structural-analogy': {
+        derivation: NO_COMPOSITE_CLAIM,
+        'exact-equivalence': NO_COMPOSITE_CLAIM,
+        restriction: NO_COMPOSITE_CLAIM,
+        approximation: NO_COMPOSITE_CLAIM,
+        'coarse-graining': NO_COMPOSITE_CLAIM,
+        'analytic-continuation': NO_COMPOSITE_CLAIM,
+        'structural-analogy': NO_COMPOSITE_CLAIM,
+        'deformation-quantization': NO_COMPOSITE_CLAIM,
+    },
+    'deformation-quantization': {
+        derivation: NO_COMPOSITE_CLAIM,
+        'exact-equivalence': NO_COMPOSITE_CLAIM,
+        restriction: NO_COMPOSITE_CLAIM,
+        approximation: NO_COMPOSITE_CLAIM,
+        'coarse-graining': NO_COMPOSITE_CLAIM,
+        'analytic-continuation': NO_COMPOSITE_CLAIM,
+        'structural-analogy': NO_COMPOSITE_CLAIM,
+        'deformation-quantization': NO_COMPOSITE_CLAIM,
+    },
+};
+/**
+ * The relation a chain of two bridges asserts, or `'no-composite-claim'` when
+ * this sprint declines to assert one. A table lookup — no rules, no inference.
+ *
+ * @public
+ */
+export function composeRelation(first, second) {
+    return COMPOSITION_TABLE[first][second];
+}
+//# sourceMappingURL=composition-table.js.map

package/dist/atlas/composition-table.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"composition-table.js","sourceRoot":"","sources":["../../src/atlas/composition-table.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+BG;AAUH,cAAc;AACd,MAAM,CAAC,MAAM,kBAAkB,GAAqB,oBAAoB,CAAC;AAEzE;;;;;;GAMG;AACH,MAAM,CAAC,MAAM,iBAAiB,GAE1B;IACF,UAAU,EAAE;QACV,UAAU,EAAE,YAAY;QACxB,mBAAmB,EAAE,YAAY;QACjC,WAAW,EAAE,kBAAkB;QAC/B,aAAa,EAAE,kBAAkB;QACjC,iBAAiB,EAAE,kBAAkB;QACrC,uBAAuB,EAAE,kBAAkB;QAC3C,oBAAoB,EAAE,kBAAkB;QACxC,0BAA0B,EAAE,kBAAkB;KAC/C;IACD,mBAAmB,EAAE;QACnB,UAAU,EAAE,YAAY;QACxB,mBAAmB,EAAE,mBAAmB;QACxC,WAAW,EAAE,aAAa;QAC1B,aAAa,EAAE,kBAAkB;QACjC,iBAAiB,EAAE,kBAAkB;QACrC,uBAAuB,EAAE,kBAAkB;QAC3C,oBAAoB,EAAE,kBAAkB;QACxC,0BAA0B,EAAE,kBAAkB;KAC/C;IACD,WAAW,EAAE;QACX,UAAU,EAAE,kBAAkB;QAC9B,mBAAmB,EAAE,aAAa;QAClC,WAAW,EAAE,aAAa;QAC1B,aAAa,EAAE,kBAAkB;QACjC,iBAAiB,EAAE,kBAAkB;QACrC,uBAAuB,EAAE,kBAAkB;QAC3C,oBAAoB,EAAE,kBAAkB;QACxC,0BAA0B,EAAE,kBAAkB;KAC/C;IACD,aAAa,EAAE;QACb,UAAU,EAAE,kBAAkB;QAC9B,mBAAmB,EAAE,kBAAkB;QACvC,WAAW,EAAE,kBAAkB;QAC/B,aAAa,EAAE,kBAAkB;QACjC,iBAAiB,EAAE,kBAAkB;QACrC,uBAAuB,EAAE,kBAAkB;QAC3C,oBAAoB,EAAE,kBAAkB;QACxC,0BAA0B,EAAE,kBAAkB;KAC/C;IACD,iBAAiB,EAAE;QACjB,UAAU,EAAE,kBAAkB;QAC9B,mBAAmB,EAAE,kBAAkB;QACvC,WAAW,EAAE,kBAAkB;QAC/B,aAAa,EAAE,kBAAkB;QACjC,iBAAiB,EAAE,iBAAiB;QACpC,uBAAuB,EAAE,kBAAkB;QAC3C,oBAAoB,EAAE,kBAAkB;QACxC,0BAA0B,EAAE,kBAAkB;KAC/C;IACD,uBAAuB,EAAE;QACvB,UAAU,EAAE,kBAAkB;QAC9B,mBAAmB,EAAE,kBAAkB;QACvC,WAAW,EAAE,kBAAkB;QAC/B,aAAa,EAAE,kBAAkB;QACjC,iBAAiB,EAAE,kBAAkB;QACrC,uBAAuB,EAAE,kBAAkB;QAC3C,oBAAoB,EAAE,kBAAkB;QACxC,0BAA0B,EAAE,kBAAkB;KAC/C;IACD,oBAAoB,EAAE;QACpB,UAAU,EAAE,kBAAkB;QAC9B,mBAAmB,EAAE,kBAAkB;QACvC,WAAW,EAAE,kBAAkB;QAC/B,aAAa,EAAE,kBAAkB;QACjC,iBAAiB,EAAE,kBAAkB;QACrC,uBAAuB,EAAE,kBAAkB;QAC3C,oBAAoB,EAAE,kBAAkB;QACxC,0BAA0B,EAAE,kBAAkB;KAC/C;IACD,0BAA0B,EAAE;QAC1B,UAAU,EAAE,kBAAkB;QAC9B,mBAAmB,EAAE,kBAAkB;QACvC,WAAW,EAAE,kBAAkB;QAC/B,aAAa,EAAE,kBAAkB;QACjC,iBAAiB,EAAE,kBAAkB;QACrC,uBAAuB,EAAE,kBAAkB;QAC3C,oBAAoB,EAAE,kBAAkB;QACxC,0BAA0B,EAAE,kBAAkB;KAC/C;CACF,CAAC;AAEF;;;;;GAKG;AACH,MAAM,UAAU,eAAe,CAC7B,KAAmB,EACnB,MAAoB;IAEpB,OAAO,iBAAiB,CAAC,KAAK,CAAC,CAAC,MAAM,CAAC,CAAC;AAC1C,CAAC"}

package/dist/atlas/conventions.d.ts

@@ -0,0 +1,63 @@
+/**
+ * Atlas Phase 1 — convention comparison.
+ *
+ * `Conventions` (`src/atlas/types.ts`) records the sign and unit choices a
+ * record depends on. Two records that disagree on one of those choices are not
+ * directly comparable, and this module says WHICH keys disagree.
+ *
+ * **`undefined` is "unknown", never "mismatch", and that asymmetry is the
+ * whole design.** A record that declares nothing about the metric signature
+ * has not chosen `'+---'`; it has not said. Reporting the absence as a
+ * disagreement would manufacture conflicts out of missing data — and because
+ * almost every record in the repo declares nothing today, it would manufacture
+ * them at scale. The same reasoning that makes design note §3 require a
+ * NON-EMPTY `conventions` before `convention-checked` can be derived applies
+ * in the mirror here: absence earns neither a tag nor an accusation.
+ *
+ * A mismatch is therefore reported only when BOTH sides declare the key and
+ * the declared values differ.
+ *
+ * @module atlas/conventions
+ */
+import type { Conventions } from './types.js';
+/** The keys `checkConventions` compares. @internal */
+export type ConventionKey = keyof Conventions;
+/**
+ * The convention keys on which `a` and `b` DECLARE different values.
+ *
+ * Returns an empty list when they agree, when either side is absent, and when
+ * neither declares a key in common.
+ *
+ * ⚠ **An empty list is NOT a statement that the two are compatible** — it means
+ * no DECLARED pair disagrees. Eve (E1, 2026-09-21) flagged that this conflates
+ * the safe case with the dangerous one: record A declaring `metricSignature:
+ * '-+++'` while B simply never declared it returns `[]`, exactly like genuine
+ * agreement, and a caller printing nothing leads a reader to infer "checked, no
+ * conflict". Silence is not agreement. Use {@link unknownConventionKeys} to
+ * surface that case, and prefer reporting the two together.
+ *
+ * @param a - one record's conventions, or `undefined` when it declares none.
+ * @param b - the other record's conventions, or `undefined`.
+ * @returns the mismatched keys, in `Conventions` declaration order.
+ *
+ * @internal
+ */
+export declare function checkConventions(a: Conventions | undefined, b: Conventions | undefined): readonly ConventionKey[];
+/**
+ * The convention keys where exactly ONE side declares a value — the cases
+ * {@link checkConventions} deliberately does not call mismatches.
+ *
+ * This exists because "no declared pair disagrees" and "these two are
+ * compatible" are different claims, and only the first is checkable from the
+ * data. A key listed here is a question, not a conflict: the records MIGHT use
+ * opposite sign conventions and one simply never said. Reporting it separately
+ * lets a reader distinguish *verified agreement* from *nobody wrote it down*,
+ * which is the distinction an empty mismatch list destroys.
+ *
+ * Both sides absent is NOT unknown — it is simply a key nobody uses, so it is
+ * omitted. Only an asymmetric declaration is reported.
+ *
+ * @internal
+ */
+export declare function unknownConventionKeys(a: Conventions | undefined, b: Conventions | undefined): readonly ConventionKey[];
+//# sourceMappingURL=conventions.d.ts.map

package/dist/atlas/conventions.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"conventions.d.ts","sourceRoot":"","sources":["../../src/atlas/conventions.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;GAoBG;AAEH,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,YAAY,CAAC;AAE9C,sDAAsD;AACtD,MAAM,MAAM,aAAa,GAAG,MAAM,WAAW,CAAC;AAgB9C;;;;;;;;;;;;;;;;;;;GAmBG;AACH,wBAAgB,gBAAgB,CAC9B,CAAC,EAAE,WAAW,GAAG,SAAS,EAC1B,CAAC,EAAE,WAAW,GAAG,SAAS,GACzB,SAAS,aAAa,EAAE,CAS1B;AAED;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,qBAAqB,CACnC,CAAC,EAAE,WAAW,GAAG,SAAS,EAC1B,CAAC,EAAE,WAAW,GAAG,SAAS,GACzB,SAAS,aAAa,EAAE,CAS1B"}