universal-physics-tensor 0.45.2 → 0.46.0

package/dist/atlas/statement.d.ts

@@ -0,0 +1,165 @@
+/**
+ * Atlas Phase 3 — `Statement`, `Context`, and the CHECKED context union.
+ *
+ * A `Statement` is a claim IN A CONTEXT, not a string. Design note
+ * `docs/planning/Atlas-Phase-3-Design.md` §1: two statements that render
+ * identically can be claims about different things when their gauge, frame or
+ * assumption set differs, and the poster index will place exactly such pairs
+ * next to each other. `context` is therefore the reason this type exists at
+ * all rather than reusing `CanonicalEquation`.
+ *
+ * ## `ast?` is optional ON PURPOSE
+ *
+ * The poster's hidden supporting nodes — the action principle, Noether, the
+ * full Maxwell set, the Lorentz group, the central limit theorem — are
+ * valuable because they are NAMED and LINKED, not because they are evaluable.
+ * Requiring an `ast` would force either a fabricated encoding or their
+ * exclusion, and both are worse than an honest `sourceExpression` with no
+ * `ast` (design note §1). Do not make it required.
+ *
+ * ## The union is CHECKED, never computed
+ *
+ * {@link contextUnion} does not MERGE contexts. It asks whether a union
+ * EXISTS, and returns an explicit refusal when it does not. Two refusals
+ * matter, and neither is an error condition:
+ *
+ * 1. **Convention conflict** — delegated to `checkConventions`, whose contract
+ *    is that `undefined` means UNKNOWN and is never a mismatch. An absent
+ *    declaration must not read as agreement, so the asymmetry is preserved
+ *    here rather than re-derived.
+ * 2. **Contradictory assumptions** — Blueprint v2 §5.2 step 2: incompatible
+ *    assumptions are NEVER POOLED. A derivation whose premises assume mutually
+ *    exclusive conditions has no context union, therefore no composite.
+ *
+ * The result is a DISCRIMINATED UNION, mirroring `boundPath`'s no-claim
+ * (`./path-bound.ts`): a caller cannot read `.context` off a refusal, because
+ * a refusal has no `.context`. That is the whole point — the refusal is
+ * enforced by the type, so no caller can read a conclusion off a union that
+ * was never formed.
+ *
+ * Pure: no I/O, no registry reads.
+ *
+ * @module atlas/statement
+ */
+import type { Conventions } from './types.js';
+import type { ModelId } from './model.js';
+import type { ExprNode } from '../dimensional/ast-types.js';
+/** A {@link Statement} id — `'statement-noether'`, … . @internal */
+export type StatementId = string;
+/**
+ * The context a claim is made in: what it quantifies over, which choices it
+ * fixes, and what it assumes.
+ *
+ * Every field but `assumptions` and `excludes` is optional, and the SAME
+ * asymmetry `checkConventions` documents applies to each: a context that
+ * declares no `gauge` has not chosen the Lorenz gauge, it has not said.
+ * Absence is unknown, never disagreement.
+ *
+ * `assumptions` and `excludes` are required (possibly empty) because they are
+ * the pair that decides poolability, and an optional one would let a caller
+ * omit the field that makes a refusal possible.
+ *
+ * @internal
+ */
+export interface Context {
+    /** Canonical quantity types the claim ranges over — `['energy', 'time']`. */
+    readonly quantityTypes?: readonly string[];
+    /** `'Lorenz'`, `'Coulomb'` — a fixed gauge choice, when the claim depends on one. */
+    readonly gauge?: string;
+    /** `'comoving'`, `'lab'` — a fixed frame choice, when the claim depends on one. */
+    readonly frame?: string;
+    /** Sign and unit choices. Compared by `checkConventions`. */
+    readonly conventions?: Conventions;
+    /** Stated assumptions — `'isolated system'`, `'weak field'`. */
+    readonly assumptions: readonly string[];
+    /**
+     * Assumption strings this context is INCOMPATIBLE with.
+     *
+     * Declared per context rather than inferred, because no rule in this repo
+     * can decide that `'weak field'` and `'strong field'` exclude each other
+     * from the strings alone. A guess here would manufacture refusals out of
+     * vocabulary rather than physics.
+     *
+     * Matching is exact string equality against another context's
+     * `assumptions`, and it is SYMMETRIC in effect: it is enough for one side
+     * to declare the exclusion.
+     */
+    readonly excludes: readonly string[];
+}
+/**
+ * A claim in a context.
+ *
+ * @internal
+ */
+export interface Statement {
+    /** `'statement-noether'`, `'statement-l1-maxwell'`, … */
+    readonly id: StatementId;
+    /** The load-bearing field — see the module note. */
+    readonly context: Context;
+    readonly model: ModelId;
+    /** OPTIONAL BY DESIGN — see the module note. Absent ⇒ named-and-linked only. */
+    readonly ast?: ExprNode;
+    /** `'dS = 0'` — the source form, always present even when `ast` is not. */
+    readonly sourceExpression: string;
+    /** Rendered form for the poster index. */
+    readonly display: string;
+}
+/** Why a set of contexts has NO union. @internal */
+export type NoUnionReason = 
+/** Two contexts DECLARE different values for a convention key. */
+'convention-conflict'
+/** One context excludes an assumption another one states. */
+ | 'contradictory-assumptions'
+/** Two contexts DECLARE different gauges or frames. */
+ | 'choice-conflict';
+/** The contexts DO pool, and this is the pooled context. @internal */
+export interface ContextUnionFormed {
+    readonly kind: 'union';
+    readonly context: Context;
+}
+/** The contexts do NOT pool, and this is why. @internal */
+export interface ContextUnionRefused {
+    readonly kind: 'no-union';
+    readonly reason: NoUnionReason;
+    /** Human-readable specifics: which key, which assumption. */
+    readonly detail: string;
+}
+/**
+ * The result of {@link contextUnion}: a pooled context, or an explicit refusal.
+ *
+ * @internal
+ */
+export type ContextUnionResult = ContextUnionFormed | ContextUnionRefused;
+/**
+ * The union of `contexts`, or an explicit refusal.
+ *
+ * Three gates, in this order; the FIRST refusal found is the one reported.
+ *
+ * 1. **Conventions.** Every PAIR is compared with `checkConventions`. Pairwise
+ *    rather than folded, because folding would compare each context against a
+ *    running merge and a merge has already lost which side declared what —
+ *    the exact information the `undefined`-is-unknown rule needs.
+ * 2. **Assumptions.** A context's `excludes` entry matching any context's
+ *    stated `assumption` refuses the pool. Blueprint v2 §5.2 step 2.
+ * 3. **Gauge / frame.** Two DECLARED and different values refuse; one declared
+ *    and one absent does not, mirroring gate 1's asymmetry.
+ *
+ * An empty list has no union: a union over nothing would be a context
+ * asserted about no claim, the same reason `boundPath` throws on an empty
+ * path. It is a `RangeError`, not a refusal, because it is a caller bug rather
+ * than a physical incompatibility.
+ *
+ * @throws RangeError when `contexts` is empty.
+ * @internal
+ */
+export declare function contextUnion(contexts: readonly Context[]): ContextUnionResult;
+/**
+ * The context union of a set of STATEMENTS, by id, resolved through `registry`.
+ *
+ * @throws RangeError if an id does not resolve. An unresolved id silently
+ *   dropped would narrow the union and could turn a refusal into a pool —
+ *   precisely the direction that manufactures a false claim.
+ * @internal
+ */
+export declare function statementContextUnion(ids: readonly StatementId[], registry: ReadonlyMap<StatementId, Statement>): ContextUnionResult;
+//# sourceMappingURL=statement.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"statement.d.ts","sourceRoot":"","sources":["../../src/atlas/statement.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA0CG;AAIH,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,YAAY,CAAC;AAC9C,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,YAAY,CAAC;AAC1C,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,6BAA6B,CAAC;AAE5D,oEAAoE;AACpE,MAAM,MAAM,WAAW,GAAG,MAAM,CAAC;AAEjC;;;;;;;;;;;;;;GAcG;AACH,MAAM,WAAW,OAAO;IACtB,6EAA6E;IAC7E,QAAQ,CAAC,aAAa,CAAC,EAAE,SAAS,MAAM,EAAE,CAAC;IAC3C,qFAAqF;IACrF,QAAQ,CAAC,KAAK,CAAC,EAAE,MAAM,CAAC;IACxB,mFAAmF;IACnF,QAAQ,CAAC,KAAK,CAAC,EAAE,MAAM,CAAC;IACxB,6DAA6D;IAC7D,QAAQ,CAAC,WAAW,CAAC,EAAE,WAAW,CAAC;IACnC,gEAAgE;IAChE,QAAQ,CAAC,WAAW,EAAE,SAAS,MAAM,EAAE,CAAC;IACxC;;;;;;;;;;;OAWG;IACH,QAAQ,CAAC,QAAQ,EAAE,SAAS,MAAM,EAAE,CAAC;CACtC;AAED;;;;GAIG;AACH,MAAM,WAAW,SAAS;IACxB,yDAAyD;IACzD,QAAQ,CAAC,EAAE,EAAE,WAAW,CAAC;IACzB,oDAAoD;IACpD,QAAQ,CAAC,OAAO,EAAE,OAAO,CAAC;IAC1B,QAAQ,CAAC,KAAK,EAAE,OAAO,CAAC;IACxB,gFAAgF;IAChF,QAAQ,CAAC,GAAG,CAAC,EAAE,QAAQ,CAAC;IACxB,2EAA2E;IAC3E,QAAQ,CAAC,gBAAgB,EAAE,MAAM,CAAC;IAClC,0CAA0C;IAC1C,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;CAC1B;AAED,oDAAoD;AACpD,MAAM,MAAM,aAAa;AACvB,kEAAkE;AAChE,qBAAqB;AACvB,6DAA6D;GAC3D,2BAA2B;AAC7B,uDAAuD;GACrD,iBAAiB,CAAC;AAEtB,sEAAsE;AACtE,MAAM,WAAW,kBAAkB;IACjC,QAAQ,CAAC,IAAI,EAAE,OAAO,CAAC;IACvB,QAAQ,CAAC,OAAO,EAAE,OAAO,CAAC;CAC3B;AAED,2DAA2D;AAC3D,MAAM,WAAW,mBAAmB;IAClC,QAAQ,CAAC,IAAI,EAAE,UAAU,CAAC;IAC1B,QAAQ,CAAC,MAAM,EAAE,aAAa,CAAC;IAC/B,6DAA6D;IAC7D,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;CACzB;AAED;;;;GAIG;AACH,MAAM,MAAM,kBAAkB,GAAG,kBAAkB,GAAG,mBAAmB,CAAC;AAe1E;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,wBAAgB,YAAY,CAAC,QAAQ,EAAE,SAAS,OAAO,EAAE,GAAG,kBAAkB,CAwF7E;AAED;;;;;;;GAOG;AACH,wBAAgB,qBAAqB,CACnC,GAAG,EAAE,SAAS,WAAW,EAAE,EAC3B,QAAQ,EAAE,WAAW,CAAC,WAAW,EAAE,SAAS,CAAC,GAC5C,kBAAkB,CAUpB"}

package/dist/atlas/statement.js

@@ -0,0 +1,176 @@
+/**
+ * Atlas Phase 3 — `Statement`, `Context`, and the CHECKED context union.
+ *
+ * A `Statement` is a claim IN A CONTEXT, not a string. Design note
+ * `docs/planning/Atlas-Phase-3-Design.md` §1: two statements that render
+ * identically can be claims about different things when their gauge, frame or
+ * assumption set differs, and the poster index will place exactly such pairs
+ * next to each other. `context` is therefore the reason this type exists at
+ * all rather than reusing `CanonicalEquation`.
+ *
+ * ## `ast?` is optional ON PURPOSE
+ *
+ * The poster's hidden supporting nodes — the action principle, Noether, the
+ * full Maxwell set, the Lorentz group, the central limit theorem — are
+ * valuable because they are NAMED and LINKED, not because they are evaluable.
+ * Requiring an `ast` would force either a fabricated encoding or their
+ * exclusion, and both are worse than an honest `sourceExpression` with no
+ * `ast` (design note §1). Do not make it required.
+ *
+ * ## The union is CHECKED, never computed
+ *
+ * {@link contextUnion} does not MERGE contexts. It asks whether a union
+ * EXISTS, and returns an explicit refusal when it does not. Two refusals
+ * matter, and neither is an error condition:
+ *
+ * 1. **Convention conflict** — delegated to `checkConventions`, whose contract
+ *    is that `undefined` means UNKNOWN and is never a mismatch. An absent
+ *    declaration must not read as agreement, so the asymmetry is preserved
+ *    here rather than re-derived.
+ * 2. **Contradictory assumptions** — Blueprint v2 §5.2 step 2: incompatible
+ *    assumptions are NEVER POOLED. A derivation whose premises assume mutually
+ *    exclusive conditions has no context union, therefore no composite.
+ *
+ * The result is a DISCRIMINATED UNION, mirroring `boundPath`'s no-claim
+ * (`./path-bound.ts`): a caller cannot read `.context` off a refusal, because
+ * a refusal has no `.context`. That is the whole point — the refusal is
+ * enforced by the type, so no caller can read a conclusion off a union that
+ * was never formed.
+ *
+ * Pure: no I/O, no registry reads.
+ *
+ * @module atlas/statement
+ */
+import { checkConventions } from './conventions.js';
+/** Distinct declared values of one optional choice field, across contexts. */
+function declaredChoices(contexts, key) {
+    const seen = new Set();
+    for (const c of contexts) {
+        const v = c[key];
+        if (v !== undefined)
+            seen.add(v);
+    }
+    return [...seen];
+}
+/**
+ * The union of `contexts`, or an explicit refusal.
+ *
+ * Three gates, in this order; the FIRST refusal found is the one reported.
+ *
+ * 1. **Conventions.** Every PAIR is compared with `checkConventions`. Pairwise
+ *    rather than folded, because folding would compare each context against a
+ *    running merge and a merge has already lost which side declared what —
+ *    the exact information the `undefined`-is-unknown rule needs.
+ * 2. **Assumptions.** A context's `excludes` entry matching any context's
+ *    stated `assumption` refuses the pool. Blueprint v2 §5.2 step 2.
+ * 3. **Gauge / frame.** Two DECLARED and different values refuse; one declared
+ *    and one absent does not, mirroring gate 1's asymmetry.
+ *
+ * An empty list has no union: a union over nothing would be a context
+ * asserted about no claim, the same reason `boundPath` throws on an empty
+ * path. It is a `RangeError`, not a refusal, because it is a caller bug rather
+ * than a physical incompatibility.
+ *
+ * @throws RangeError when `contexts` is empty.
+ * @internal
+ */
+export function contextUnion(contexts) {
+    if (contexts.length === 0) {
+        throw new RangeError('contextUnion: no contexts; a union over nothing states nothing');
+    }
+    // ── Gate 1: no DECLARED convention pair may disagree ──────────────────────
+    for (let i = 0; i < contexts.length; i++) {
+        for (let j = i + 1; j < contexts.length; j++) {
+            const clash = checkConventions(contexts[i].conventions, contexts[j].conventions);
+            if (clash.length > 0) {
+                return {
+                    kind: 'no-union',
+                    reason: 'convention-conflict',
+                    detail: `contexts ${i} and ${j} declare different values for ` +
+                        `${clash.map((k) => `'${k}'`).join(', ')}; they do not pool`,
+                };
+            }
+        }
+    }
+    // ── Gate 2: incompatible assumptions are NEVER pooled ─────────────────────
+    const stated = new Map();
+    for (let i = 0; i < contexts.length; i++) {
+        for (const a of contexts[i].assumptions) {
+            if (!stated.has(a))
+                stated.set(a, i);
+        }
+    }
+    for (let i = 0; i < contexts.length; i++) {
+        for (const x of contexts[i].excludes) {
+            const at = stated.get(x);
+            if (at !== undefined) {
+                return {
+                    kind: 'no-union',
+                    reason: 'contradictory-assumptions',
+                    detail: `context ${i} excludes '${x}', which context ${at} assumes; ` +
+                        'incompatible assumptions are never pooled',
+                };
+            }
+        }
+    }
+    // ── Gate 3: a declared gauge or frame may not be contradicted ─────────────
+    for (const key of ['gauge', 'frame']) {
+        const values = declaredChoices(contexts, key);
+        if (values.length > 1) {
+            return {
+                kind: 'no-union',
+                reason: 'choice-conflict',
+                detail: `the contexts declare ${values.length} different ${key}s ` +
+                    `(${values.map((v) => `'${v}'`).join(', ')}); they do not pool`,
+            };
+        }
+    }
+    // ── The pool ──────────────────────────────────────────────────────────────
+    // Conventions merge by KEY rather than by object, so a context silent on a
+    // key inherits another's declaration instead of erasing it. Gate 1 has
+    // already proved no two declarations disagree, so the order of assignment
+    // cannot change the result.
+    const conventions = {};
+    for (const c of contexts) {
+        for (const [k, v] of Object.entries(c.conventions ?? {})) {
+            if (v !== undefined)
+                conventions[k] = v;
+        }
+    }
+    const quantityTypes = [...new Set(contexts.flatMap((c) => c.quantityTypes ?? []))];
+    const gauge = declaredChoices(contexts, 'gauge')[0];
+    const frame = declaredChoices(contexts, 'frame')[0];
+    return {
+        kind: 'union',
+        context: {
+            ...(quantityTypes.length > 0 ? { quantityTypes } : {}),
+            ...(gauge !== undefined ? { gauge } : {}),
+            ...(frame !== undefined ? { frame } : {}),
+            ...(Object.keys(conventions).length > 0
+                ? { conventions: conventions }
+                : {}),
+            assumptions: [...stated.keys()],
+            excludes: [...new Set(contexts.flatMap((c) => c.excludes))],
+        },
+    };
+}
+/**
+ * The context union of a set of STATEMENTS, by id, resolved through `registry`.
+ *
+ * @throws RangeError if an id does not resolve. An unresolved id silently
+ *   dropped would narrow the union and could turn a refusal into a pool —
+ *   precisely the direction that manufactures a false claim.
+ * @internal
+ */
+export function statementContextUnion(ids, registry) {
+    const contexts = [];
+    for (const id of ids) {
+        const s = registry.get(id);
+        if (s === undefined) {
+            throw new RangeError(`statementContextUnion: unknown statement '${id}'`);
+        }
+        contexts.push(s.context);
+    }
+    return contextUnion(contexts);
+}
+//# sourceMappingURL=statement.js.map

package/dist/atlas/statement.js.map

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

package/dist/atlas/types.d.ts

@@ -0,0 +1,308 @@
+/**
+ * Atlas Phase 0 pilot types (oscillator pilot).
+ *
+ * Fixed by `docs/planning/Atlas-Phase-0-Design.md` §2 and the implementation
+ * plan's §"S0 types" block, implemented here verbatim.
+ *
+ * **These are throwaway pilot types** (design note §4). If Phase 1's
+ * relation-contract work disagrees with any of them, the Phase 0 type is
+ * replaced, not adapted: nothing atlas-side is public before Phase 6 and the
+ * only consumers are Phase 0's own tests.
+ *
+ * Name note: the probe's `RelationKind` and `AuditState` are NOT shadowed —
+ * this sprint uses `RelationType` and defines no `AuditState`.
+ * `src/composition/bridge-prediction.ts` has a module-local, unexported
+ * `interface Regime` for tensor-cell placement; different concept, no
+ * import collision.
+ *
+ * @module atlas/types
+ */
+import type { PiGroup } from '../dimensional/buckingham.js';
+/** The relation a bridge asserts between its premises and its conclusion. @public */
+export type RelationType = 'derivation' | 'exact-equivalence' | 'restriction' | 'approximation' | 'coarse-graining' | 'analytic-continuation' | 'structural-analogy' | 'deformation-quantization';
+/** What kind of support a record carries. Carried only if its witness passes. @public */
+export type EvidenceTag = 'proposed' | 'reviewed' | 'dimension-checked' | 'convention-checked' | 'symbolically-checked' | 'numerically-supported' | 'formally-proved' | 'empirically-supported' | 'contradicted' | 'unresolved';
+/**
+ * Every `EvidenceTag`, in declaration order, so a report can name all of them.
+ *
+ * Lives HERE, not in `coverage.ts` (which re-exports it), because
+ * `tests/atlas/derived-tag-literals.test.ts` allows the literals
+ * `'formally-proved'` and `'symbolically-checked'` under `src/atlas/` in
+ * exactly two files: this one and `derive-evidence.ts`. A tag that can only be
+ * DERIVED must not be spellable anywhere a record could hand-set it.
+ *
+ * @internal
+ */
+export declare const ALL_EVIDENCE_TAGS: readonly ["proposed", "reviewed", "dimension-checked", "convention-checked", "symbolically-checked", "numerically-supported", "formally-proved", "empirically-supported", "contradicted", "unresolved"];
+/**
+ * How a formal reference's statement was checked against the physics it claims
+ * to state (Phase 4 design note §3).
+ *
+ * - `'two-formalizers'` — two people formalized it independently and agreed.
+ * - `'back-translation'` — a reviewer who had not seen the source translated
+ *   the formal statement back to prose and it matched.
+ * - `'sanity-lemmas'` — the statement was instantiated on known cases in
+ *   `tests/atlas/formal-sanity.test.ts`.
+ * - `'unreviewed'` — recorded, not checked. **Earns no tag, by construction.**
+ *
+ * @internal
+ */
+export type FormalFidelity = 'two-formalizers' | 'back-translation' | 'sanity-lemmas' | 'unreviewed';
+/**
+ * A machine-checked counterpart of a record's claim in a proof assistant.
+ *
+ * A proof of the WRONG statement proves nothing about the physics, so the
+ * reference carries its `fidelity` — how anyone knows the formal statement says
+ * what the bridge says. `formally-proved` is derived from it and never set.
+ *
+ * @internal
+ */
+export interface FormalRef {
+    readonly system: 'lean4-physlib' | 'other';
+    /** The formal statement's name or text, as it appears in `system`. */
+    readonly statement: string;
+    /** The library version or commit the statement was checked against. */
+    readonly version: string;
+    /** Axioms the proof depends on beyond the system's core. */
+    readonly axioms: readonly string[];
+    readonly fidelity: FormalFidelity;
+}
+/** Whether the limit a bridge takes is regular or singular. @public */
+export type LimitCharacter = 'regular' | 'singular' | 'unknown';
+/**
+ * One inequality on a regime coordinate. The coordinate is either a π-group
+ * `buckinghamPi` produced from the family's dimensioned parameters (keyed by
+ * `PiGroup.formula`), or a dimensionless INPUT of the model (an initial datum
+ * such as θ0, a wavenumber-lattice product qa) declared as a
+ * `DimensionalVariable` with the zero dimension, which is its own trivial
+ * group. Derived quantities such as ζ = ½ (m k / b²)^(−½) are NOT groups:
+ * write the inequality on the group (`m k / b² > 1/4`) and record the display
+ * alias in `alias`.
+ *
+ * @public
+ */
+export interface RegimeInequality {
+    /** `PiGroup.formula`, or the dimensionless input's name. */
+    readonly group: string;
+    readonly op: '<' | '<=' | '>' | '>=';
+    readonly bound: number;
+    /** `'ζ < 1'` — for display only, never evaluated. */
+    readonly alias?: string;
+}
+/** Where in parameter space a model or bridge is claimed to apply. @public */
+export interface Regime {
+    /** `'oscillators'`. */
+    readonly family: string;
+    readonly inequalities: readonly RegimeInequality[];
+    /** Traceability back to the dimension matrix, keyed by `PiGroup.formula`. */
+    readonly groupDefinitions: Readonly<Record<string, PiGroup>>;
+}
+/** A Lipschitz-plus-offset error bound with a mandatory horizon. @public */
+export interface ApproximationBound {
+    /** Lipschitz constant of the map, in the stated norm. */
+    readonly K: number;
+    /**
+     * Uniform error, same norm: the SUPREMUM OF THE BOUND OVER THE WHOLE
+     * DECLARED DOMAIN (`domain` / `parameterRange`), never a sample of it at
+     * one convenient fixture point.
+     *
+     * A parameter-dependent bound evaluated at a fixture is not a bound on the
+     * domain it claims: the record would read as covering every admissible
+     * parameter while holding only at the one point it was measured. When the
+     * supremum is approached but not attained at an open edge of the domain,
+     * `delta` is that supremum, and `deltaAt` is what a caller uses to get the
+     * tighter value at its own point.
+     */
+    readonly delta: number;
+    /** `'relative period'`, `'sup |x − x_reduced| for t ≥ 5 m/b'`, … */
+    readonly norm: string;
+    /** Where the bound holds. */
+    readonly domain: string;
+    /** MANDATORY prose horizon: `'t ≪ 16 T0/θ0²'`. */
+    readonly horizon: string;
+    /** MANDATORY machine form of `horizon`: true while the bound is claimed to hold. */
+    readonly horizonHolds: (t: number, params: Readonly<Record<string, number>>) => boolean;
+    /**
+     * MACHINE FORM OF `delta`, mirroring what `horizonHolds` is to `horizon`:
+     * the bound AT A POINT of the declared domain, in the same norm.
+     *
+     * `horizon` had a machine counterpart and `delta` had none, so an
+     * implementer holding a correct parameter-dependent bound could only freeze
+     * it at a single point and hope the reader noticed. `deltaAt` is where that
+     * dependence goes; `delta` stays the supremum over the domain, and
+     * `deltaAt(p) <= delta` for every admissible `p`.
+     *
+     * Optional on the interface so a genuinely constant bound need not restate
+     * itself, and so `coarse-graining` bounds are unaffected; MANDATORY for an
+     * `approximation`, enforced at admission by `admitApproximation`.
+     */
+    readonly deltaAt?: (params: Readonly<Record<string, number>>) => number;
+    /** `'θ0 ≤ 0.5 rad'`. */
+    readonly parameterRange?: string;
+    readonly limitCharacter: LimitCharacter;
+    /**
+     * What the error is uniform in.
+     *
+     * `null` means NOT YET ANALYSED. That is a legitimate recorded state:
+     * `makeApproximation` accepts it, and the check lives at use (`boundPath`),
+     * not at construction. An empty array means the same thing — a universal
+     * over nothing must not count as analysed. A non-empty array names the
+     * scopes the error is uniform in. A variable a side condition says the
+     * error is NOT uniform in is not listed.
+     */
+    readonly uniformity: readonly string[] | null;
+}
+/** A named check that supports a record, and the test file that runs it. @public */
+export interface Witness {
+    /** `'W7b'`. */
+    readonly id: string;
+    readonly kind: 'symbolic' | 'numeric' | 'formal';
+    /** Test file path. */
+    readonly test: string;
+    /** As stated in the brief. */
+    readonly tolerance?: string;
+}
+/**
+ * `AtlasModel` MOVED to `./model.ts` in Phase 3, where it gained
+ * `boundaryData?`, `initialData?` and `symmetryGroup?`. It is NOT re-exported
+ * from here: `model.ts` imports `Regime` from this module, so a re-export
+ * would close a cycle `bun run docs:deps` reports. Import it from
+ * `./model.js`.
+ */
+/** A case a bridge does NOT cover, and the witness that shows it. @public */
+export interface Counterexample {
+    readonly description: string;
+    /** `'W2b'`. */
+    readonly witness: string;
+}
+/** Field set = Blueprint v2 §3.1 Bridge record + citations. @internal */
+export interface AtlasBridge {
+    /** `'ab-spring-lc'`. */
+    readonly id: string;
+    readonly relation: RelationType;
+    /** Model ids (many). */
+    readonly premises: readonly string[];
+    /** Model id (one). */
+    readonly conclusion: string;
+    /** `'u = x/x0 (or q/q0), τ = ω0 t'`. */
+    readonly transformation: string;
+    /** `'x = x0 u, t = τ/ω0'` — required for `exact-equivalence`. */
+    readonly inverse?: string;
+    readonly preserves: readonly string[];
+    readonly doesNotPreserve: readonly string[];
+    readonly sideConditions: readonly string[];
+    /** Required iff `relation === 'approximation'`. */
+    readonly bound?: ApproximationBound;
+    readonly regime: Regime;
+    readonly counterexamples: readonly Counterexample[];
+    readonly evidence: ReadonlySet<EvidenceTag>;
+    readonly witnesses: readonly Witness[];
+    readonly citations: readonly string[];
+    readonly reviewStatus: 'proposed' | 'reviewed';
+    /**
+     * A machine-checked counterpart, when one genuinely exists (Phase 4, S4.6).
+     * Absent is the honest default: a statement with no checked counterpart gets
+     * no reference rather than an `'unreviewed'` placeholder.
+     */
+    readonly formalRef?: FormalRef;
+}
+/** A claimed bridge the atlas records as REJECTED, with the reason. @public */
+export interface AtlasRejection {
+    /** `'ax-cubic-spring-lc'`. */
+    readonly id: string;
+    readonly claimed: RelationType;
+    readonly premises: readonly string[];
+    readonly conclusion: string;
+    readonly reason: string;
+    /** `'beta·x0²·k⁻¹'`. */
+    readonly survivingGroup: string;
+    readonly witnesses: readonly Witness[];
+}
+/**
+ * The relation a record asserts, as a DISCRIMINATED UNION over `RelationType`.
+ *
+ * This is the Phase 1 overlay (design note §1.2, "One overlay, not two"). Its
+ * purpose is to move `AtlasBridge`'s two CONDITIONAL requirements — written
+ * there only as doc comments — into the type system:
+ *
+ *   - `approximation` REQUIRES `bound`, and `ApproximationBound` itself
+ *     mandates `horizon` + `horizonHolds`. So an approximation without a
+ *     machine horizon is a COMPILE error, not a runtime one.
+ *   - `exact-equivalence` REQUIRES `inverse`.
+ *
+ * Deliberately conservative elsewhere. The design note §2.2 names the fields
+ * the other members WOULD need (an analyticity domain, a checkable
+ * `preserves` set, an ħ-order) and records that none of them exists before
+ * Phase 2. Inventing them here would encode claims the data cannot support,
+ * so every other member carries only `transformation`.
+ *
+ * @internal
+ */
+export type RelationContract = {
+    readonly type: 'derivation';
+    readonly transformation: string;
+} | {
+    readonly type: 'exact-equivalence';
+    readonly transformation: string;
+    /** REQUIRED: `'x = x0 u, t = τ/ω0'`. An equivalence without an inverse is not one. */
+    readonly inverse: string;
+} | {
+    readonly type: 'restriction';
+    readonly transformation: string;
+} | {
+    readonly type: 'approximation';
+    readonly transformation: string;
+    /** REQUIRED, and mandates its own machine horizon. */
+    readonly bound: ApproximationBound;
+} | {
+    readonly type: 'coarse-graining';
+    readonly transformation: string;
+    /** Optional: errors accumulate through `composeBounds` when present. */
+    readonly bound?: ApproximationBound;
+} | {
+    readonly type: 'analytic-continuation';
+    readonly transformation: string;
+} | {
+    readonly type: 'structural-analogy';
+    readonly transformation: string;
+} | {
+    readonly type: 'deformation-quantization';
+    readonly transformation: string;
+};
+/**
+ * Sign and unit choices a record depends on. Every field is optional, and a
+ * field is only meaningful when the record actually depends on that choice.
+ *
+ * Non-emptiness matters downstream: design note §3 requires `conventions` to
+ * declare AT LEAST ONE field before `convention-checked` can be derived,
+ * because `[].every(…)` is vacuously true and would hand out a free tag.
+ *
+ * @internal
+ */
+export interface Conventions {
+    /** First law as `dU = Q − W` or `dU = Q + W`. */
+    readonly heatWorkSign?: 'Q-W' | 'Q+W';
+    readonly metricSignature?: '-+++' | '+---';
+    readonly fourierNormalization?: 'unitary' | 'physics' | 'none';
+    readonly unitSystem?: 'SI' | 'gaussian' | 'natural';
+    readonly capacitorChargeSign?: '+' | '-';
+}
+/** Thrown when an `ApproximationBound` is built without its machine horizon. @public */
+export declare class MissingHorizonError extends Error {
+}
+/**
+ * Thrown when an `approximation` bound is built without the machine form of
+ * its `delta`.
+ *
+ * A distinct type rather than a reuse of `MissingHorizonError`: the horizon of
+ * such a record is present and correct, and reporting a missing horizon for it
+ * would send the next reader to the one field that is not the defect.
+ *
+ * @internal
+ */
+export declare class MissingDeltaAtError extends Error {
+}
+/** Thrown when a bound path has no Lipschitz constant anywhere but at its end. @public */
+export declare class MissingLipschitzError extends Error {
+}
+//# sourceMappingURL=types.d.ts.map