universal-physics-tensor 0.45.1 → 0.46.0

package/README.md

@@ -45,41 +45,41 @@ Think of this as:
 git clone https://github.com/danielsimonjr/universal-physics-tensor.git
 cd universal-physics-tensor
 
-# Install dependencies
-npm install
+# Install dependencies (Bun is the local/CI package manager; Node ≥ 18 is the runtime)
+bun install
 
 # Build the project
-npm run build
+bun run build
 
 # Run the smoke test
 node test-example.js
 
 # Bridge-inference CLI (no TypeScript needed) — `upt` subcommands:
-npm run upt -- explain hawking-temperature mass=1.989e30   # explain a built-in quantity
-npm run upt -- priority                                    # triage speculative bridges
-npm run upt -- audit                                       # derive the bridges by dimensions
-npm run upt -- predict                                     # empty regime cells as link hypotheses
-npm run upt -- discover                                    # vet link candidates (merge/unlock/consistency)
-npm run upt -- discover --source=canonical                 # run the funnel on standard physics ALONE (no bridges)
-npm run upt -- discover --derive                           # surface machine-derived identity consequences (--max-orders / --anchor flags available)
-npm run upt -- probe scan                                  # experimental expression/residual frontier (Product B; not `upt discover`)
-npm run upt -- probe run --problem=tests/fixtures/discovery/pendulum-scaling/public/problem.json
-npm run upt -- connectors                                  # which isolated bridges can connect to the core
-npm run upt -- coverage                                    # audit each bridge's empirical grounding
-npm run upt -- canonical                                   # the standard-physics L-layer registry (answer key)
-npm run upt -- recover                                     # validate bridges against standard physics
-npm run upt -- symbolic --simplify                         # compose + fold bridges' SYMBOLIC forms (MathTS simplify)
-npm run upt -- confront                                    # run the catalog's committed real-data confrontations (predicted vs observed)
-npm run upt -- map --source=both --format=mermaid          # VISUAL map of the graph (Mermaid; also --format=dot|svg, --proposed, --out=PATH)
-npm run upt -- map --equation "period = 2*pi*sqrt(length/gravity)"   # drop YOUR OWN equation onto the map: dimensional check + where it lands
+bun run upt -- explain hawking-temperature mass=1.989e30   # explain a built-in quantity
+bun run upt -- priority                                    # triage speculative bridges
+bun run upt -- audit                                       # derive the bridges by dimensions
+bun run upt -- predict                                     # empty regime cells as link hypotheses
+bun run upt -- discover                                    # vet link candidates (merge/unlock/consistency)
+bun run upt -- discover --source=canonical                 # run the funnel on standard physics ALONE (no bridges)
+bun run upt -- discover --derive                           # surface machine-derived identity consequences (--max-orders / --anchor flags available)
+bun run upt -- probe scan                                  # experimental expression/residual frontier (Product B; not `upt discover`)
+bun run upt -- probe run --problem=tests/fixtures/discovery/pendulum-scaling/public/problem.json
+bun run upt -- connectors                                  # which isolated bridges can connect to the core
+bun run upt -- coverage                                    # audit each bridge's empirical grounding
+bun run upt -- canonical                                   # the standard-physics L-layer registry (answer key)
+bun run upt -- recover                                     # validate bridges against standard physics
+bun run upt -- symbolic --simplify                         # compose + fold bridges' SYMBOLIC forms (MathTS simplify)
+bun run upt -- confront                                    # run the catalog's committed real-data confrontations (predicted vs observed)
+bun run upt -- map --source=both --format=mermaid          # VISUAL map of the graph (Mermaid; also --format=dot|svg, --proposed, --out=PATH)
+bun run upt -- map --equation "period = 2*pi*sqrt(length/gravity)"   # drop YOUR OWN equation onto the map: dimensional check + where it lands
 # ...and YOUR OWN equations:
-npm run upt -- eval "hbar*c^3/(8*pi*G*M*k_B)" hbar=1.054571817e-34 c=299792458 G=6.6743e-11 M=1.989e30 k_B=1.380649e-23
-npm run upt -- derive period:time length:length gravity:acceleration --formula "2*pi*sqrt(length/gravity)"
+bun run upt -- eval "hbar*c^3/(8*pi*G*M*k_B)" hbar=1.054571817e-34 c=299792458 G=6.6743e-11 M=1.989e30 k_B=1.380649e-23
+bun run upt -- derive period:time length:length gravity:acceleration --formula "2*pi*sqrt(length/gravity)"
 #   → period ∝ length^0.5·gravity^-0.5 ; formula dimension: [time] ✓ matches target ;
 #     formula MATCHES, recovered prefactor ≈ 6.2832 (2π)
-npm run upt -- help
+bun run upt -- help
 # Once published, the same commands run via `npx universal-physics-tensor <cmd>`.
-# (`npm run explain` and `npm run bridge-priority` remain as aliases.)
+# (`bun run explain` and `bun run bridge-priority` remain as aliases.)
 ```
 
 `eval`/`derive --formula` use the MathTS expression engine
@@ -226,6 +226,7 @@ for how the documents evolved.
 - **Supplements** - [Part VII: Tensor Algebra](docs/specification/Part-VII-Tensor-Algebra.md) · [Part VIII: Metric Layer](docs/specification/Part-VIII-Metric-Layer.md) · [Part IX: Composition](docs/specification/Part-IX-Composition.md) · [Part X: Curvature & Field Equations](docs/specification/Part-X-Curvature-and-Field-Equations.md) · [Part XI: Proposed Equations](docs/specification/Part-XI-Proposed-Equations.md) (non-normative; machine-derived identity consequences, unadjudicated)
 
 ### Planning & Development
+- **[ROADMAP.md](ROADMAP.md)** - Strategic direction: from bridge catalog to a verified, regime-aware physics atlas (phased, with exit criteria)
 - **[Development Plan](docs/planning/Development-Plan.md)** - Phased implementation roadmap
 - **[Implementation Plan](docs/planning/Implementation-Plan.md)** - Technical architecture
 - **[System Requirements](docs/planning/System-Requirements.md)** - Functional requirements
@@ -282,7 +283,7 @@ The current machine-checked state is:
 | Bridge catalog | **55 entries (BE-11…65)**: 19 established, 33 speculative, 3 highly speculative; the JSON artifact is freshness-tested against the TypeScript registry |
 | Empirical spine | **19 committed confrontations**, exposed through `upt confront` with rigor/caveat metadata |
 | Composition layer | **41 bridge edges** plus the canonical L-layer graph; dimensional, symbolic, discovery, consequence, and visualization tooling |
-| Canonical reference layer | **103 canonical equations** used as the non-speculative answer-key layer for bridge recovery/linkage |
+| Canonical reference layer | **107 canonical equations** used as the non-speculative answer-key layer for bridge recovery/linkage |
 | Architecture | Generated dependency graph reports **0 circular dependencies** and a clean unused-analysis report; `npm run docs:deps` is CI freshness-gated |
 | Quality gates | Build, strict source+test TypeScript checks, full Vitest suite, active-plan audit, package-content smoke test, and nightly long-horizon GL4/Shapiro accuracy tests |
 
@@ -298,7 +299,7 @@ external evidence/domain review before promotion.
 - Longer-horizon production ideas are explicitly non-blocking and live in
   [`docs/planning/Future-Production-Hardening.md`](docs/planning/Future-Production-Hardening.md).
 - Historical implementation plans are preserved as records; the live code-completion
-  ledger is [`docs/planning/ACTIVE.md`](docs/planning/ACTIVE.md) and is what
+  ledger is [`ACTIVE.md`](ACTIVE.md) and is what
   `npm run audit:plans` gates.
 
 ## Contributing
@@ -334,7 +335,7 @@ This is an **engineer's approach to theoretical physics** — systematic, organi
 
 ## License
 
-MIT License - see [LICENSE](LICENSE) for details.
+Code: MIT License - see [LICENSE](LICENSE). Exported atlas data (`data/atlas/`): CC BY 4.0 - see [LICENSE-DATA](LICENSE-DATA).
 
 ## Author
 

package/dist/atlas/applicability.d.ts

@@ -0,0 +1,108 @@
+/**
+ * Atlas Phase 4, S4.1 — the applicability checker.
+ *
+ * Design note: `docs/planning/Atlas-Phase-4-Design.md` §1.
+ *
+ * **This module answers "what about this bridge is not checked?", and it
+ * returns FINDINGS rather than a boolean.** A boolean would have to choose
+ * between "unchecked" and "wrong", and those are the two states the module
+ * exists to keep apart. Every finding therefore carries a
+ * {@link ApplicabilitySeverity}:
+ *
+ *  - `'blocking'` — the data CONTRADICTS ITSELF. A dimensional failure, two
+ *    records declaring opposite conventions, a literal zero divisor.
+ *  - `'question'` — the data is SILENT. A divisor nobody guarded, a convention
+ *    only one side declares, two premise models whose relationship is
+ *    unrecorded.
+ *
+ * `src/atlas/conventions.ts` already argues this asymmetry at length for the
+ * convention comparison: absence is not disagreement. The same reasoning
+ * governs every rule here. Collapsing the two severities would report "four
+ * findings" for a record whose only defect is that nobody wrote something
+ * down, and would bury a genuine contradiction among them.
+ *
+ * **Nothing here mutates a record and nothing here is a verdict.** The checker
+ * has no authority to promote or reject: it produces the list a reviewer reads.
+ * That is the same firewall the rest of the repo keeps — no machine verdict
+ * mutates a catalog.
+ *
+ * @module atlas/applicability
+ * @internal
+ */
+import type { ExprNode } from '../dimensional/ast-types.js';
+import type { AtlasModel } from './model.js';
+import type { Conventions } from './types.js';
+/** Whether a finding is a contradiction in the data or a silence in it. @internal */
+export type ApplicabilitySeverity = 'blocking' | 'question';
+/**
+ * The rule that produced a finding. A closed union so a caller can filter by
+ * rule without matching on prose.
+ *
+ * @internal
+ */
+export type ApplicabilityFindingKind = 'dimensional-inconsistency' | 'convention-mismatch' | 'convention-undeclared' | 'division-unguarded' | 'division-by-zero' | 'squaring-adds-solutions' | 'model-incompatibility';
+/** One thing a reviewer must resolve before believing the record. @internal */
+export interface ApplicabilityFinding {
+    readonly kind: ApplicabilityFindingKind;
+    readonly severity: ApplicabilitySeverity;
+    /** Human-readable statement of what is unresolved. */
+    readonly detail: string;
+    /**
+     * Where it was found: an AST path (`'args[1]'`), a convention key, or a
+     * model id. Absent when the finding is about the record as a whole.
+     */
+    readonly where?: string;
+}
+/**
+ * What the checker is given. Every field is optional EXCEPT the side
+ * conditions, which are required so that "this record states none" is a
+ * written choice (`[]`) rather than a forgotten argument — the same reasoning
+ * that made `passingWitnessIds` required in `derive-evidence.ts`.
+ *
+ * @internal
+ */
+export interface ApplicabilityInput {
+    /** The transformation's AST, when the record encodes one. */
+    readonly ast?: ExprNode;
+    /** The record's stated side conditions, as free prose. REQUIRED; `[]` is a statement. */
+    readonly sideConditions: readonly string[];
+    /** The premise records' declared conventions. */
+    readonly premiseConventions?: Conventions;
+    /** The conclusion record's declared conventions. */
+    readonly conclusionConventions?: Conventions;
+    /** The premise models (many). */
+    readonly premises?: readonly AtlasModel[];
+    /** The conclusion model (one). */
+    readonly conclusion?: AtlasModel;
+    /**
+     * Family pairs already bridged, so a genuine cross-family step is not
+     * reported as unrecorded. Unordered: `['a','b']` covers `['b','a']`.
+     */
+    readonly declaredBridges?: readonly (readonly [string, string])[];
+}
+/**
+ * Every unresolved question and contradiction the checker can see in a record.
+ *
+ * An EMPTY result means "no rule fired", which is weaker than "this bridge is
+ * valid" and must not be reported as the latter. The rules in hand cover
+ * dimensions, declared conventions, division guards, even-power equating and
+ * model families; a bridge can be wrong in ways none of them reaches.
+ *
+ * @param input - the record's checkable parts. `sideConditions` is required.
+ * @returns findings in rule order (dimensions, conventions, AST, models);
+ * never `null`, never throws on a malformed AST.
+ * @internal
+ */
+export declare function checkApplicability(input: ApplicabilityInput): readonly ApplicabilityFinding[];
+/**
+ * The `'blocking'` subset of {@link checkApplicability}.
+ *
+ * Offered because the two severities are read by different callers — a report
+ * shows both, a gate looks only at contradictions — and filtering on the
+ * severity string at every call site is how one of them eventually filters on
+ * the wrong one.
+ *
+ * @internal
+ */
+export declare function blockingFindings(findings: readonly ApplicabilityFinding[]): readonly ApplicabilityFinding[];
+//# sourceMappingURL=applicability.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"applicability.d.ts","sourceRoot":"","sources":["../../src/atlas/applicability.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8BG;AAEH,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,6BAA6B,CAAC;AAE5D,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,YAAY,CAAC;AAC7C,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,YAAY,CAAC;AAG9C,qFAAqF;AACrF,MAAM,MAAM,qBAAqB,GAAG,UAAU,GAAG,UAAU,CAAC;AAE5D;;;;;GAKG;AACH,MAAM,MAAM,wBAAwB,GAChC,2BAA2B,GAC3B,qBAAqB,GACrB,uBAAuB,GACvB,oBAAoB,GACpB,kBAAkB,GAClB,yBAAyB,GACzB,uBAAuB,CAAC;AAE5B,+EAA+E;AAC/E,MAAM,WAAW,oBAAoB;IACnC,QAAQ,CAAC,IAAI,EAAE,wBAAwB,CAAC;IACxC,QAAQ,CAAC,QAAQ,EAAE,qBAAqB,CAAC;IACzC,sDAAsD;IACtD,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;IACxB;;;OAGG;IACH,QAAQ,CAAC,KAAK,CAAC,EAAE,MAAM,CAAC;CACzB;AAED;;;;;;;GAOG;AACH,MAAM,WAAW,kBAAkB;IACjC,6DAA6D;IAC7D,QAAQ,CAAC,GAAG,CAAC,EAAE,QAAQ,CAAC;IACxB,yFAAyF;IACzF,QAAQ,CAAC,cAAc,EAAE,SAAS,MAAM,EAAE,CAAC;IAC3C,iDAAiD;IACjD,QAAQ,CAAC,kBAAkB,CAAC,EAAE,WAAW,CAAC;IAC1C,oDAAoD;IACpD,QAAQ,CAAC,qBAAqB,CAAC,EAAE,WAAW,CAAC;IAC7C,iCAAiC;IACjC,QAAQ,CAAC,QAAQ,CAAC,EAAE,SAAS,UAAU,EAAE,CAAC;IAC1C,kCAAkC;IAClC,QAAQ,CAAC,UAAU,CAAC,EAAE,UAAU,CAAC;IACjC;;;OAGG;IACH,QAAQ,CAAC,eAAe,CAAC,EAAE,SAAS,CAAC,SAAS,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC,EAAE,CAAC;CACnE;AAoLD;;;;;;;;;;;;GAYG;AACH,wBAAgB,kBAAkB,CAChC,KAAK,EAAE,kBAAkB,GACxB,SAAS,oBAAoB,EAAE,CAkFjC;AAED;;;;;;;;;GASG;AACH,wBAAgB,gBAAgB,CAC9B,QAAQ,EAAE,SAAS,oBAAoB,EAAE,GACxC,SAAS,oBAAoB,EAAE,CAEjC"}

package/dist/atlas/applicability.js

@@ -0,0 +1,301 @@
+/**
+ * Atlas Phase 4, S4.1 — the applicability checker.
+ *
+ * Design note: `docs/planning/Atlas-Phase-4-Design.md` §1.
+ *
+ * **This module answers "what about this bridge is not checked?", and it
+ * returns FINDINGS rather than a boolean.** A boolean would have to choose
+ * between "unchecked" and "wrong", and those are the two states the module
+ * exists to keep apart. Every finding therefore carries a
+ * {@link ApplicabilitySeverity}:
+ *
+ *  - `'blocking'` — the data CONTRADICTS ITSELF. A dimensional failure, two
+ *    records declaring opposite conventions, a literal zero divisor.
+ *  - `'question'` — the data is SILENT. A divisor nobody guarded, a convention
+ *    only one side declares, two premise models whose relationship is
+ *    unrecorded.
+ *
+ * `src/atlas/conventions.ts` already argues this asymmetry at length for the
+ * convention comparison: absence is not disagreement. The same reasoning
+ * governs every rule here. Collapsing the two severities would report "four
+ * findings" for a record whose only defect is that nobody wrote something
+ * down, and would bury a genuine contradiction among them.
+ *
+ * **Nothing here mutates a record and nothing here is a verdict.** The checker
+ * has no authority to promote or reject: it produces the list a reviewer reads.
+ * That is the same firewall the rest of the repo keeps — no machine verdict
+ * mutates a catalog.
+ *
+ * @module atlas/applicability
+ * @internal
+ */
+import { validate } from '../dimensional/validator.js';
+import { checkConventions, unknownConventionKeys } from './conventions.js';
+/**
+ * Non-vanishing markers a side condition may use. Matched case-insensitively
+ * against the side-condition prose.
+ *
+ * ⚠ **Shallow by design, and the asymmetry is the point** (design note §1.3).
+ * A side condition is free text and no parser exists for it. The failure mode
+ * is a FALSE QUESTION — a genuinely guarded divisor phrased in words this list
+ * does not know — never a false clearance, because a divisor absent from the
+ * prose cannot match any marker. The check over-asks rather than over-clears.
+ */
+const NONVANISHING_MARKERS = [
+    '≠ 0',
+    '≠0',
+    '!= 0',
+    '!=0',
+    '<> 0',
+    '<>0',
+    'nonzero',
+    'non-zero',
+    'non zero',
+    '> 0',
+    '>0',
+    'positive',
+];
+/** Free symbol names appearing anywhere in a subtree. */
+function symbolNames(node, into = new Set()) {
+    if (node.kind === 'symbol') {
+        into.add(node.name);
+        return into;
+    }
+    for (const child of childNodes(node))
+        symbolNames(child, into);
+    return into;
+}
+/**
+ * The `ExprNode` children of a node, for the scalar grammar this checker
+ * reasons about. Tensor and curvature node families have no children here and
+ * return `[]`: the side-condition and squaring rules are statements about
+ * scalar algebra, and silently descending into a tensor node would invite
+ * findings whose `where` path means nothing to a reader.
+ */
+function childNodes(node) {
+    switch (node.kind) {
+        case 'op':
+            return node.args;
+        case 'integral':
+            return [node.over, node.integrand, ...(node.lower ? [node.lower] : []),
+                ...(node.upper ? [node.upper] : [])];
+        case 'derivative':
+            return [node.of, node.wrt];
+        case 'dirac-delta':
+            return [node.arg];
+        case 'variational-derivative':
+            return [node.functional, node.field, node.over];
+        case 'transcendental':
+            return [node.arg];
+        case 'abs':
+            return [node.arg];
+        default:
+            return [];
+    }
+}
+/**
+ * The numeric value of a leaf that IS a literal, or `null`.
+ *
+ * Literals are `symbol` leaves whose `name` parses as a number — the same
+ * convention `validator.ts` uses to recognise a literal exponent, so the two
+ * cannot disagree about what a literal is.
+ */
+function literalValue(node) {
+    if (node.kind !== 'symbol')
+        return null;
+    if (node.name.trim() === '')
+        return null;
+    const v = Number(node.name);
+    return Number.isFinite(v) ? v : null;
+}
+/** Is `name` guarded as non-vanishing by any of the stated side conditions? */
+function isGuarded(name, sideConditions) {
+    const needle = name.toLowerCase();
+    return sideConditions.some((raw) => {
+        const s = raw.toLowerCase();
+        if (!s.includes(needle))
+            return false;
+        return NONVANISHING_MARKERS.some((m) => s.includes(m));
+    });
+}
+/** An even, integer literal exponent, or `null` when the exponent is anything else. */
+function evenLiteralExponent(node) {
+    if (node.kind !== 'op' || node.op !== '^')
+        return null;
+    const exp = node.args[1];
+    if (exp === undefined)
+        return null;
+    const v = literalValue(exp);
+    if (v === null || !Number.isInteger(v) || v === 0)
+        return null;
+    return v % 2 === 0 ? v : null;
+}
+/** Walk the AST, applying the side-condition and squaring rules. */
+function checkAst(node, sideConditions, path, out) {
+    if (node.kind === 'op' && node.op === '/') {
+        const divisor = node.args[1];
+        if (divisor !== undefined) {
+            const lit = literalValue(divisor);
+            if (lit === 0) {
+                out.push({
+                    kind: 'division-by-zero',
+                    severity: 'blocking',
+                    detail: 'Division by the literal 0.',
+                    where: `${path}args[1]`,
+                });
+            }
+            else if (lit === null) {
+                // Not a literal: it needs a stated non-vanishing side condition.
+                const names = [...symbolNames(divisor)];
+                const unguarded = names.filter((n) => !isGuarded(n, sideConditions));
+                // Every name guarded ⇒ nothing to ask. A divisor with NO symbols and no
+                // literal value (a tensor leaf, say) is reported, because nothing about
+                // it can be checked and silence there would read as clearance.
+                if (names.length === 0 || unguarded.length > 0) {
+                    const subject = names.length === 0 ? 'the divisor' : unguarded.join(', ');
+                    out.push({
+                        kind: 'division-unguarded',
+                        severity: 'question',
+                        detail: `Division whose divisor (${subject}) has no stated non-vanishing side ` +
+                            'condition. This is a question, not a defect: the divisor may well be ' +
+                            'non-zero and simply unstated.',
+                        where: `${path}args[1]`,
+                    });
+                }
+            }
+        }
+    }
+    // Difference (or sum) of two equal even powers ⇒ the relation was obtained by
+    // squaring, which admits the sign-flipped branch. See design note §1.4 for why
+    // an isolated even power is NOT reported.
+    if (node.kind === 'op' && (node.op === '-' || node.op === '+')) {
+        const exps = node.args.map(evenLiteralExponent);
+        for (let i = 0; i < exps.length; i += 1) {
+            for (let j = i + 1; j < exps.length; j += 1) {
+                const a = exps[i];
+                if (a !== null && a !== undefined && a === exps[j]) {
+                    out.push({
+                        kind: 'squaring-adds-solutions',
+                        severity: 'question',
+                        detail: `Two terms raised to the same even power (${a}) are equated. Raising a ` +
+                            'relation to an even power admits the sign-flipped branch, so a side ' +
+                            'condition fixing the sign is needed for the step to be reversible.',
+                        where: `${path}args[${i}]`,
+                    });
+                }
+            }
+        }
+    }
+    const children = childNodes(node);
+    for (let i = 0; i < children.length; i += 1) {
+        const child = children[i];
+        if (child !== undefined)
+            checkAst(child, sideConditions, `${path}args[${i}].`, out);
+    }
+}
+/** Is this family pair recorded as already bridged? Unordered. */
+function bridgeDeclared(a, b, declared) {
+    return declared.some(([x, y]) => (x === a && y === b) || (x === b && y === a));
+}
+/**
+ * Every unresolved question and contradiction the checker can see in a record.
+ *
+ * An EMPTY result means "no rule fired", which is weaker than "this bridge is
+ * valid" and must not be reported as the latter. The rules in hand cover
+ * dimensions, declared conventions, division guards, even-power equating and
+ * model families; a bridge can be wrong in ways none of them reaches.
+ *
+ * @param input - the record's checkable parts. `sideConditions` is required.
+ * @returns findings in rule order (dimensions, conventions, AST, models);
+ * never `null`, never throws on a malformed AST.
+ * @internal
+ */
+export function checkApplicability(input) {
+    const out = [];
+    // 1. Dimensions — the existing validator, unchanged.
+    if (input.ast !== undefined) {
+        const result = validate(input.ast);
+        for (const v of result.violations) {
+            // A warning-severity violation does not make the record inconsistent;
+            // reporting it as blocking would contradict `validate`'s own verdict.
+            const severity = (v.severity ?? 'error') === 'error' ? 'blocking' : 'question';
+            out.push({
+                kind: 'dimensional-inconsistency',
+                severity,
+                detail: v.note,
+                where: v.location === '' ? undefined : v.location,
+            });
+        }
+        if (result.inferredDimension === null && result.violations.length === 0) {
+            out.push({
+                kind: 'dimensional-inconsistency',
+                severity: 'blocking',
+                detail: 'No dimension could be inferred for the transformation AST.',
+            });
+        }
+    }
+    // 2. Conventions — mismatches block, asymmetric declarations are questions.
+    const mismatches = checkConventions(input.premiseConventions, input.conclusionConventions);
+    for (const key of mismatches) {
+        out.push({
+            kind: 'convention-mismatch',
+            severity: 'blocking',
+            detail: `Premise and conclusion declare different values for '${key}'. Two records ` +
+                'that disagree on a sign or unit choice are not directly comparable.',
+            where: key,
+        });
+    }
+    for (const key of unknownConventionKeys(input.premiseConventions, input.conclusionConventions)) {
+        out.push({
+            kind: 'convention-undeclared',
+            severity: 'question',
+            detail: `Exactly one side declares '${key}'. Silence is not agreement: the other ` +
+                'record may use the opposite choice and simply never said.',
+            where: key,
+        });
+    }
+    // 3. Side conditions over the AST.
+    if (input.ast !== undefined)
+        checkAst(input.ast, input.sideConditions, '', out);
+    // 4. Model compatibility.
+    const premises = input.premises ?? [];
+    const declared = input.declaredBridges ?? [];
+    const conclusionFamily = input.conclusion?.family;
+    const families = new Set(premises.map((m) => m.family));
+    if (conclusionFamily !== undefined)
+        families.add(conclusionFamily);
+    const familyList = [...families];
+    for (let i = 0; i < familyList.length; i += 1) {
+        for (let j = i + 1; j < familyList.length; j += 1) {
+            const a = familyList[i];
+            const b = familyList[j];
+            if (a === undefined || b === undefined)
+                continue;
+            if (bridgeDeclared(a, b, declared))
+                continue;
+            out.push({
+                kind: 'model-incompatibility',
+                severity: 'question',
+                detail: `Models span families '${a}' and '${b}' with no declared bridge between ` +
+                    'them. An unrecorded cross-family step is exactly what the atlas exists ' +
+                    'to make visible.',
+                where: `${a}|${b}`,
+            });
+        }
+    }
+    return out;
+}
+/**
+ * The `'blocking'` subset of {@link checkApplicability}.
+ *
+ * Offered because the two severities are read by different callers — a report
+ * shows both, a gate looks only at contradictions — and filtering on the
+ * severity string at every call site is how one of them eventually filters on
+ * the wrong one.
+ *
+ * @internal
+ */
+export function blockingFindings(findings) {
+    return findings.filter((f) => f.severity === 'blocking');
+}
+//# sourceMappingURL=applicability.js.map

package/dist/atlas/applicability.js.map

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

package/dist/atlas/association.d.ts

@@ -0,0 +1,92 @@
+/**
+ * Atlas Phase 1 — the association registry.
+ *
+ * An `Association` records that two things SHARE something: a constant, a
+ * symbol, a structure, or a line of historical influence. That is the whole of
+ * its meaning. It asserts **no relation** between the two, makes **no
+ * composite claim**, and is explicitly NOT a graph edge — design note §5: *"No
+ * `Association` semantics beyond a registry of typed pairs — the registry is a
+ * container in Sprint 1, and it makes no composite claims."*
+ *
+ * The distinction is the point. `CATALOG_GRAPH` edges are claims that one
+ * quantity DETERMINES another. An association is the opposite epistemic act:
+ * it is where the atlas writes down a resemblance it has already decided is
+ * NOT a link, so the resemblance stops being re-surfaced as if it were fresh.
+ * An association that also appeared as an edge would be a contradiction, and
+ * `tests/atlas/association.test.ts` pins that it never does.
+ *
+ * **The seed is the `'decoy'` half of the adjudication ledger.** A `decoy`
+ * verdict means a physicist looked at `a ≟ b` and found a coincidence with no
+ * mechanism — precisely a shared appearance with no relation behind it. Every
+ * `'decoy'` row in `ADJUDICATIONS` (`src/composition/adjudication.ts`) gets
+ * one entry here, id-linked, with its `grounds` copied VERBATIM as the `note`.
+ *
+ * **No new physics is added by this module**, and two deliberate choices keep
+ * it that way:
+ *
+ *   - `note` is the adjudicator's own prose, never a restatement. Verbatimness
+ *     is pinned by test against the live ledger, so a re-worded ledger entry
+ *     fails rather than silently diverging from its copy here.
+ *   - `kind` is assigned MECHANICALLY, not per pair. Every seed is
+ *     `'shared-structure'` because every one of them reached the ledger the
+ *     same way: the identification funnel pairs quantities that share a
+ *     dimensional signature. Choosing a different `kind` per row would be a
+ *     fresh physics judgement about each pair, which is exactly the claim this
+ *     registry exists not to make.
+ *
+ * **Why the seed is written out rather than derived from `ADJUDICATIONS` at
+ * import time.** `src/composition/` may import atlas TYPES only, never the
+ * barrel, because a value import in the other direction closes a cycle
+ * `docs:deps` reports (`compose.ts` already imports `atlas/composition-table`).
+ * An `atlas → composition/adjudication → discovery → …` value import risks the
+ * same cycle from the other side. So this module stays a leaf, and the
+ * drift protection moves into the test, which is free to import both.
+ *
+ * @module atlas/association
+ */
+/**
+ * What two records share. Each value names an observable resemblance, not a
+ * relation: none of them implies that either record determines, derives,
+ * approximates or restricts the other.
+ *
+ * @internal
+ */
+export type AssociationKind = 'shared-constant' | 'shared-symbol' | 'shared-structure' | 'historical-influence';
+/**
+ * One recorded resemblance between two named things.
+ *
+ * A container, deliberately. It has no `relation`, no `bound`, no `regime` and
+ * no `evidence` — the fields that would let it make a claim are absent because
+ * it makes none.
+ *
+ * @internal
+ */
+export interface Association {
+    /**
+     * Stable identity. For a seeded entry this is the `CandidateAdjudication.id`
+     * it came from — `candidateId(a, b)`, the two names sorted and joined with
+     * `~` — so the association and the verdict that produced it share a key.
+     */
+    readonly id: string;
+    readonly kind: AssociationKind;
+    /** The two names, in the order `id` encodes them (sorted, `~`-split). */
+    readonly between: readonly [string, string];
+    /** Why the resemblance is only a resemblance. Adjudicator's prose, verbatim. */
+    readonly note: string;
+    /** Repo-relative path of the record this note was copied from. */
+    readonly citation: string;
+}
+/**
+ * The seeded registry: one entry per `'decoy'` adjudication, in ledger order.
+ *
+ * Kept in step with `ADJUDICATIONS` by
+ * `tests/atlas/association.test.ts`, which re-derives this array from the live
+ * ledger and deep-equals it. Adding a `'decoy'` verdict without adding its
+ * association here fails that test.
+ *
+ * @internal
+ */
+export declare const ASSOCIATIONS: readonly Association[];
+/** Look up an association by its `candidateId`-shaped key. @internal */
+export declare function associationFor(id: string): Association | undefined;
+//# sourceMappingURL=association.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"association.d.ts","sourceRoot":"","sources":["../../src/atlas/association.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6CG;AAEH;;;;;;GAMG;AACH,MAAM,MAAM,eAAe,GACvB,iBAAiB,GACjB,eAAe,GACf,kBAAkB,GAClB,sBAAsB,CAAC;AAE3B;;;;;;;;GAQG;AACH,MAAM,WAAW,WAAW;IAC1B;;;;OAIG;IACH,QAAQ,CAAC,EAAE,EAAE,MAAM,CAAC;IACpB,QAAQ,CAAC,IAAI,EAAE,eAAe,CAAC;IAC/B,yEAAyE;IACzE,QAAQ,CAAC,OAAO,EAAE,SAAS,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IAC5C,gFAAgF;IAChF,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,kEAAkE;IAClE,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC;CAC3B;AAED;;;;;;;;;GASG;AACH,eAAO,MAAM,YAAY,EAAE,SAAS,WAAW,EAyD9C,CAAC;AAEF,wEAAwE;AACxE,wBAAgB,cAAc,CAAC,EAAE,EAAE,MAAM,GAAG,WAAW,GAAG,SAAS,CAElE"}