universal-physics-tensor 0.7.2 → 0.14.0

package/dist/composition/consistency.d.ts

@@ -0,0 +1,24 @@
+/**
+ * Composition graph — shared-source consistency relations (v0.8.0
+ * CT-2, per docs/planning/v0.8.0-Design.md §2).
+ *
+ * `consistencyRatio` is a PARALLEL graph operation, honestly distinct
+ * from sequential composition: two edges that share source quantities
+ * are evaluated on the same inputs and their quotient taken. When the
+ * shared quantities cancel algebraically (as G, M, c do between BE-51
+ * lensing and BE-52 perihelion precession), the ratio is a
+ * parameter-free consistency relation — varying the shared inputs must
+ * leave it invariant.
+ *
+ * @module composition/consistency
+ */
+import type { BridgeEdge } from './edge.js';
+/**
+ * Domain-checked quotient `a(inputs) / b(inputs)` of two edges sharing
+ * source quantities. Throws {@link DomainViolationError} if either
+ * edge's validity domain rejects the inputs.
+ *
+ * @public
+ */
+export declare function consistencyRatio(a: BridgeEdge, b: BridgeEdge, inputs: Record<string, number>): number;
+//# sourceMappingURL=consistency.d.ts.map

package/dist/composition/consistency.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"consistency.d.ts","sourceRoot":"","sources":["../../src/composition/consistency.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;GAaG;AAEH,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,WAAW,CAAC;AAG5C;;;;;;GAMG;AACH,wBAAgB,gBAAgB,CAC9B,CAAC,EAAE,UAAU,EACb,CAAC,EAAE,UAAU,EACb,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,GAC7B,MAAM,CAER"}

package/dist/composition/consistency.js

@@ -0,0 +1,26 @@
+/**
+ * Composition graph — shared-source consistency relations (v0.8.0
+ * CT-2, per docs/planning/v0.8.0-Design.md §2).
+ *
+ * `consistencyRatio` is a PARALLEL graph operation, honestly distinct
+ * from sequential composition: two edges that share source quantities
+ * are evaluated on the same inputs and their quotient taken. When the
+ * shared quantities cancel algebraically (as G, M, c do between BE-51
+ * lensing and BE-52 perihelion precession), the ratio is a
+ * parameter-free consistency relation — varying the shared inputs must
+ * leave it invariant.
+ *
+ * @module composition/consistency
+ */
+import { evaluateEdge } from './edge.js';
+/**
+ * Domain-checked quotient `a(inputs) / b(inputs)` of two edges sharing
+ * source quantities. Throws {@link DomainViolationError} if either
+ * edge's validity domain rejects the inputs.
+ *
+ * @public
+ */
+export function consistencyRatio(a, b, inputs) {
+    return evaluateEdge(a, inputs) / evaluateEdge(b, inputs);
+}
+//# sourceMappingURL=consistency.js.map

package/dist/composition/consistency.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"consistency.js","sourceRoot":"","sources":["../../src/composition/consistency.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;GAaG;AAGH,OAAO,EAAE,YAAY,EAAE,MAAM,WAAW,CAAC;AAEzC;;;;;;GAMG;AACH,MAAM,UAAU,gBAAgB,CAC9B,CAAa,EACb,CAAa,EACb,MAA8B;IAE9B,OAAO,YAAY,CAAC,CAAC,EAAE,MAAM,CAAC,GAAG,YAAY,CAAC,CAAC,EAAE,MAAM,CAAC,CAAC;AAC3D,CAAC"}

package/dist/composition/discovery.d.ts

@@ -0,0 +1,104 @@
+/**
+ * Discovery loop — vet link candidates through the verification primitives
+ * (Direction 2).
+ *
+ * `proposeLinkCandidates` surfaces cross-cluster quantity pairs that share a
+ * dimension (132 → 36 → ~3) and hands the raw coincidences to a human. This
+ * module closes the loop: it HYPOTHESIZES each candidate identification
+ * `a ≡ b` and tests it with the machinery that already exists —
+ *
+ *   - mergesComponents      — does identifying a≡b connect two previously
+ *                             disconnected parts of the graph? (structural
+ *                             significance)
+ *   - unlocksFromAnchor     — what becomes determinable from an anchor input
+ *                             set WITH the identification that was not before?
+ *                             (`forwardClosure`)
+ *   - numericallyConsistent — does retrodiction over the graph stay
+ *                             all-consistent once the identification is
+ *                             added, or does it introduce a contradiction?
+ *                             (`retrodict` — the STRONG filter)
+ *
+ * so the physicist adjudicates a handful of VETTED, provenance-traced
+ * candidates instead of dimensional noise.
+ *
+ * ⚠ Still a REVIEW SURFACE, never automated discovery (Part-VI §XXVII-B). A
+ * shared dimension is a weak prior; the weight is on the numeric and
+ * structural signals, and the numeric check only exercises the part of the
+ * graph reachable from the anchor. `promising` means "worth a physicist's
+ * minute", not "true".
+ *
+ * INTERNAL — not on the public surface (mirrors bridge-analysis.ts);
+ * surfaced via `upt discover`.
+ *
+ * @module composition/discovery
+ */
+import type { BridgeEdge } from './edge.js';
+import type { QuantityIdentification } from './compose.js';
+import type { LinkCandidate } from './bridge-analysis.js';
+/** A candidate after vetting against the inference suite. @hypothesis */
+export interface VettedCandidate {
+    readonly a: string;
+    readonly b: string;
+    /** Shared SI dimension (from the proposer). */
+    readonly dim: string;
+    /** One endpoint is in the anchored (established) cluster. */
+    readonly touchesCore: boolean;
+    /** The names share a word token (same physical KIND). */
+    readonly sameKind: boolean;
+    /**
+     * Identifying a≡b merges two distinct connected components of the
+     * quantity graph — it connects physics the catalog keeps separate.
+     */
+    readonly mergesComponents: boolean;
+    /**
+     * Quantities newly determinable from the anchor known-set once the
+     * identification is added (structural unlock). Sorted.
+     */
+    readonly unlocksFromAnchor: readonly string[];
+    /**
+     * Retrodiction over the graph WITH the hypothesized identification stays
+     * all-consistent (introduces no numerical contradiction in the
+     * anchor-reachable subgraph). The strong filter.
+     */
+    readonly numericallyConsistent: boolean;
+    /** Nodes that became inconsistent under the identification (the
+     *  falsification, when `numericallyConsistent` is false). Sorted. */
+    readonly inconsistentNodes: readonly string[];
+    /**
+     * - `contradictory` — breaks numerical consistency (a falsification).
+     * - `promising`     — consistent AND connects disconnected physics AND
+     *                     unlocks ≥1 quantity. Worth physicist review.
+     * - `inert`         — consistent but structurally/numerically idle (a
+     *                     dimensional coincidence with no consequence).
+     */
+    readonly verdict: 'promising' | 'inert' | 'contradictory';
+    /** Composite ranking score (higher = more worth review). */
+    readonly score: number;
+}
+/** Options for the discovery loop. @internal */
+export interface DiscoveryOptions {
+    /**
+     * Numeric anchor for the consistency check (and the closure unlock).
+     * Default `{ mass: M_sun }` — the pre-registered retrodiction anchor.
+     */
+    readonly groundTruth?: Readonly<Record<string, number>>;
+    /** Extra identifications honored as the baseline (default registered). */
+    readonly identifications?: readonly QuantityIdentification[];
+}
+/**
+ * Vet one link candidate by hypothesizing the identification a≡b and
+ * measuring its structural and numerical consequences. See module docs.
+ *
+ * @internal
+ */
+export declare function vetLinkCandidate(edges: readonly BridgeEdge[], candidate: LinkCandidate, opts?: DiscoveryOptions): VettedCandidate;
+/**
+ * Run the full discovery funnel: propose cross-cluster candidates, vet each
+ * against the inference suite, and rank — `promising` first, then by score.
+ * The output is the physicist's worklist (vetted, provenance-traced), not a
+ * list of discoveries.
+ *
+ * @internal
+ */
+export declare function rankDiscoveries(edges: readonly BridgeEdge[], opts?: DiscoveryOptions): VettedCandidate[];
+//# sourceMappingURL=discovery.d.ts.map

package/dist/composition/discovery.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"discovery.d.ts","sourceRoot":"","sources":["../../src/composition/discovery.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAiCG;AAEH,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,WAAW,CAAC;AAC5C,OAAO,KAAK,EAAE,sBAAsB,EAAE,MAAM,cAAc,CAAC;AAK3D,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,sBAAsB,CAAC;AAG1D,yEAAyE;AACzE,MAAM,WAAW,eAAe;IAC9B,QAAQ,CAAC,CAAC,EAAE,MAAM,CAAC;IACnB,QAAQ,CAAC,CAAC,EAAE,MAAM,CAAC;IACnB,+CAA+C;IAC/C,QAAQ,CAAC,GAAG,EAAE,MAAM,CAAC;IACrB,6DAA6D;IAC7D,QAAQ,CAAC,WAAW,EAAE,OAAO,CAAC;IAC9B,yDAAyD;IACzD,QAAQ,CAAC,QAAQ,EAAE,OAAO,CAAC;IAC3B;;;OAGG;IACH,QAAQ,CAAC,gBAAgB,EAAE,OAAO,CAAC;IACnC;;;OAGG;IACH,QAAQ,CAAC,iBAAiB,EAAE,SAAS,MAAM,EAAE,CAAC;IAC9C;;;;OAIG;IACH,QAAQ,CAAC,qBAAqB,EAAE,OAAO,CAAC;IACxC;yEACqE;IACrE,QAAQ,CAAC,iBAAiB,EAAE,SAAS,MAAM,EAAE,CAAC;IAC9C;;;;;;OAMG;IACH,QAAQ,CAAC,OAAO,EAAE,WAAW,GAAG,OAAO,GAAG,eAAe,CAAC;IAC1D,4DAA4D;IAC5D,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;CACxB;AAED,gDAAgD;AAChD,MAAM,WAAW,gBAAgB;IAC/B;;;OAGG;IACH,QAAQ,CAAC,WAAW,CAAC,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC,CAAC;IACxD,0EAA0E;IAC1E,QAAQ,CAAC,eAAe,CAAC,EAAE,SAAS,sBAAsB,EAAE,CAAC;CAC9D;AAoCD;;;;;GAKG;AACH,wBAAgB,gBAAgB,CAC9B,KAAK,EAAE,SAAS,UAAU,EAAE,EAC5B,SAAS,EAAE,aAAa,EACxB,IAAI,GAAE,gBAAqB,GAC1B,eAAe,CAkEjB;AAED;;;;;;;GAOG;AACH,wBAAgB,eAAe,CAC7B,KAAK,EAAE,SAAS,UAAU,EAAE,EAC5B,IAAI,GAAE,gBAAqB,GAC1B,eAAe,EAAE,CAgBnB"}

package/dist/composition/discovery.js

@@ -0,0 +1,165 @@
+/**
+ * Discovery loop — vet link candidates through the verification primitives
+ * (Direction 2).
+ *
+ * `proposeLinkCandidates` surfaces cross-cluster quantity pairs that share a
+ * dimension (132 → 36 → ~3) and hands the raw coincidences to a human. This
+ * module closes the loop: it HYPOTHESIZES each candidate identification
+ * `a ≡ b` and tests it with the machinery that already exists —
+ *
+ *   - mergesComponents      — does identifying a≡b connect two previously
+ *                             disconnected parts of the graph? (structural
+ *                             significance)
+ *   - unlocksFromAnchor     — what becomes determinable from an anchor input
+ *                             set WITH the identification that was not before?
+ *                             (`forwardClosure`)
+ *   - numericallyConsistent — does retrodiction over the graph stay
+ *                             all-consistent once the identification is
+ *                             added, or does it introduce a contradiction?
+ *                             (`retrodict` — the STRONG filter)
+ *
+ * so the physicist adjudicates a handful of VETTED, provenance-traced
+ * candidates instead of dimensional noise.
+ *
+ * ⚠ Still a REVIEW SURFACE, never automated discovery (Part-VI §XXVII-B). A
+ * shared dimension is a weak prior; the weight is on the numeric and
+ * structural signals, and the numeric check only exercises the part of the
+ * graph reachable from the anchor. `promising` means "worth a physicist's
+ * minute", not "true".
+ *
+ * INTERNAL — not on the public surface (mirrors bridge-analysis.ts);
+ * surfaced via `upt discover`.
+ *
+ * @module composition/discovery
+ */
+import { QUANTITY_IDENTIFICATIONS } from './compose.js';
+import { forwardClosure } from './identifiability.js';
+import { retrodict } from './retrodiction.js';
+import { proposeLinkCandidates } from './bridge-analysis.js';
+import { M_SUN_KG } from './edges/calibration.js';
+/** Union-find over quantity names; merges each edge's endpoints and every
+ *  identification's from↔to. Returns name → component-root. */
+function quantityComponents(edges, idents) {
+    const parent = new Map();
+    const find = (x) => {
+        if (!parent.has(x))
+            parent.set(x, x);
+        let r = x;
+        while (parent.get(r) !== r)
+            r = parent.get(r);
+        let cur = x;
+        while (parent.get(cur) !== r) {
+            const next = parent.get(cur);
+            parent.set(cur, r);
+            cur = next;
+        }
+        return r;
+    };
+    const union = (a, b) => {
+        parent.set(find(a), find(b));
+    };
+    for (const e of edges) {
+        const names = [...e.sources.map((s) => s.name), e.target.name];
+        for (let i = 1; i < names.length; i++)
+            union(names[0], names[i]);
+    }
+    for (const id of idents)
+        union(id.from, id.to);
+    const roots = new Map();
+    for (const name of parent.keys())
+        roots.set(name, find(name));
+    return roots;
+}
+const ANCHOR_DEFAULT = { mass: M_SUN_KG };
+/**
+ * Vet one link candidate by hypothesizing the identification a≡b and
+ * measuring its structural and numerical consequences. See module docs.
+ *
+ * @internal
+ */
+export function vetLinkCandidate(edges, candidate, opts = {}) {
+    const baseIdents = opts.identifications ?? QUANTITY_IDENTIFICATIONS;
+    const groundTruth = opts.groundTruth ?? ANCHOR_DEFAULT;
+    const anchor = Object.keys(groundTruth);
+    // The hypothesized identification, added in both directions so a≡b is a
+    // full merge (identifications are directional in the engine).
+    const rationale = `HYPOTHESIS (unadjudicated): ${candidate.a} ≡ ${candidate.b} — same dimension ${candidate.dim}`;
+    const hypothesis = [
+        { from: candidate.a, to: candidate.b, rationale },
+        { from: candidate.b, to: candidate.a, rationale },
+    ];
+    const withHyp = [...baseIdents, ...hypothesis];
+    // Structural: does a≡b merge two components?
+    const comps = quantityComponents(edges, baseIdents);
+    const mergesComponents = comps.has(candidate.a) &&
+        comps.has(candidate.b) &&
+        comps.get(candidate.a) !== comps.get(candidate.b);
+    // Closure unlock: forward closure from the anchor, with vs without.
+    const closureBase = forwardClosure(edges, anchor, baseIdents);
+    const closureHyp = forwardClosure(edges, anchor, withHyp);
+    const unlocksFromAnchor = [...closureHyp]
+        .filter((q) => !closureBase.has(q))
+        .sort();
+    // Numeric: retrodiction must stay all-consistent under the hypothesis.
+    const report = retrodict(edges, groundTruth, { identifications: withHyp });
+    const numericallyConsistent = report.allConsistent;
+    const inconsistentNodes = report.results
+        .filter((r) => r.outcome === 'inconsistent')
+        .map((r) => r.target)
+        .sort();
+    let verdict;
+    if (!numericallyConsistent)
+        verdict = 'contradictory';
+    else if (mergesComponents && unlocksFromAnchor.length > 0)
+        verdict = 'promising';
+    else
+        verdict = 'inert';
+    // Score: contradictory sinks to the bottom; otherwise reward structural
+    // merges, unlocks, and the proposer's weak priors.
+    let score = 0;
+    if (numericallyConsistent) {
+        score += mergesComponents ? 4 : 0;
+        score += Math.min(unlocksFromAnchor.length, 4);
+        score += candidate.touchesCore ? 1 : 0;
+        score += candidate.sameKind ? 1 : 0;
+    }
+    else {
+        score = -1;
+    }
+    return {
+        a: candidate.a,
+        b: candidate.b,
+        dim: candidate.dim,
+        touchesCore: candidate.touchesCore,
+        sameKind: candidate.sameKind,
+        mergesComponents,
+        unlocksFromAnchor,
+        numericallyConsistent,
+        inconsistentNodes,
+        verdict,
+        score,
+    };
+}
+/**
+ * Run the full discovery funnel: propose cross-cluster candidates, vet each
+ * against the inference suite, and rank — `promising` first, then by score.
+ * The output is the physicist's worklist (vetted, provenance-traced), not a
+ * list of discoveries.
+ *
+ * @internal
+ */
+export function rankDiscoveries(edges, opts = {}) {
+    const VERDICT_RANK = {
+        promising: 0,
+        inert: 1,
+        contradictory: 2,
+    };
+    const candidates = proposeLinkCandidates(edges);
+    const vetted = candidates.map((c) => vetLinkCandidate(edges, c, opts));
+    vetted.sort((x, y) => VERDICT_RANK[x.verdict] - VERDICT_RANK[y.verdict] ||
+        y.score - x.score ||
+        x.a.localeCompare(y.a) ||
+        x.b.localeCompare(y.b));
+    return vetted;
+}
+//# sourceMappingURL=discovery.js.map

package/dist/composition/discovery.js.map

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

package/dist/composition/edge.d.ts

@@ -0,0 +1,139 @@
+/**
+ * Composition graph — edges (bridges and laws) + validity domains
+ * (v0.8.0 T1+T2+T3, per docs/planning/v0.8.0-Design.md §3).
+ *
+ * A `BridgeEdge` is an edge in the composition graph: n-ary source
+ * quantities → one target quantity, carrying a closed-form evaluator,
+ * a first-class validity domain (G-8), a confidence grade, and a
+ * literature citation. `kind: 'law'` marks diagonal-law edges (P-1) —
+ * edges whose endpoints share regime attributes, serving as the
+ * connective tissue composition chains pass through.
+ *
+ * @module composition/edge
+ */
+import type { Quantity } from './quantity.js';
+import type { ExprNode } from '../dimensional/validator.js';
+/**
+ * First-class validity domain (v0.8.0 G-8). The predicate receives the
+ * same keyed inputs as `evaluate` and returns whether the edge's
+ * formula applies there (e.g. weak-field, positive mass, bound orbit).
+ *
+ * @public
+ */
+export interface ValidityDomain {
+    /** Human-readable statement, e.g. 'M > 0 and b ≫ r_s (weak field)'. */
+    readonly description: string;
+    /** Machine-checkable form of the same statement. */
+    readonly predicate: (inputs: Record<string, number>) => boolean;
+}
+/**
+ * Confidence grade — mirrors the catalog's status taxonomy. Composition
+ * demotes via {@link minConfidence}; it never promotes.
+ *
+ * @public
+ */
+export type EdgeConfidence = 'established' | 'speculative' | 'highly-speculative';
+/**
+ * An edge in the composition graph.
+ *
+ * `evaluate` is keyed by source-quantity `name`s. For catalog-backed
+ * edges, `beId` cross-references `BRIDGE_EQUATIONS`; diagonal-law
+ * edges have `beId: null` (BE-1–10 are not individually catalogued).
+ *
+ * @public
+ */
+export interface BridgeEdge {
+    /** Graph id, e.g. 'be-42', 'law-schwarzschild-radius'. */
+    readonly id: string;
+    /** Catalog cross-reference; null for diagonal laws. */
+    readonly beId: number | null;
+    /** Bridge (endpoints differ in regime) vs law (endpoints share regime). */
+    readonly kind: 'bridge' | 'law';
+    /** Human-readable label. */
+    readonly label: string;
+    /** Input quantities (n-ary). */
+    readonly sources: readonly Quantity[];
+    /** Output quantity. */
+    readonly target: Quantity;
+    readonly confidence: EdgeConfidence;
+    readonly domain: ValidityDomain;
+    /** Closed-form evaluator; keys are source-quantity names. */
+    readonly evaluate: (inputs: Record<string, number>) => number;
+    /**
+     * OPTIONAL symbolic form of the target (v0.12 symbolic composition): an
+     * `ExprNode` whose leaf symbols are EITHER this edge's source-quantity
+     * NAMES (graph vocabulary, e.g. `'mass'`) or registered constant symbols
+     * (`hbar`, `c`, `G`, `k_B`, `8pi`, `ln2`, …). When present, `composeSymbolic`
+     * can thread it through a junction by AST substitution; a drift-guard test
+     * binds it to `evaluate`. Absent on numeric-only edges (the default).
+     */
+    readonly symbolic?: ExprNode;
+    readonly citation: string;
+    /**
+     * Provenance: the quantity identification the junction used, when a
+     * composed edge was formed via `QUANTITY_IDENTIFICATIONS` rather than
+     * a name match. Absent on primitive edges and name-matched
+     * compositions. (v0.8.0 punch-list: surfaced from the previously
+     * unused `findJunction` return.)
+     */
+    readonly identificationUsed?: {
+        readonly from: string;
+        readonly to: string;
+        readonly rationale: string;
+        readonly citation?: string;
+    };
+    /**
+     * Provenance: alias dispositions consumed at composition (v0.11
+     * Option D) — which duplicate-name collisions were resolved, and how.
+     */
+    readonly aliasDispositionsUsed?: ReadonlyArray<{
+        readonly name: string;
+        readonly treatAs: 'shared' | {
+            readonly renameSecond: string;
+        };
+        readonly rationale: string;
+        readonly citation?: string;
+    }>;
+}
+/** Composition failed: no junction quantity matched. @public */
+export declare class CompositionJunctionError extends Error {
+    constructor(message: string);
+}
+/** Composition failed: junction dimensions are not exactly equal. @public */
+export declare class CompositionDimensionError extends Error {
+    constructor(message: string);
+}
+/**
+ * Evaluation refused: inputs fall outside an edge's validity domain.
+ *
+ * Honest deviation from design D-3's "domain-incompatible at compose
+ * time": domain predicates are opaque functions, so incompatibility is
+ * detectable only at evaluation — this error is thrown by
+ * {@link evaluateEdge} (and by composed edges internally), not by
+ * `composeEdges`.
+ *
+ * @public
+ */
+export declare class DomainViolationError extends Error {
+    constructor(message: string);
+}
+/**
+ * Composition refused: the composed sources would contain a duplicate
+ * quantity NAME across operands without a recorded disposition (v0.11
+ * namespacing gate, Option D — pure name-collision rule per the Adam
+ * vet A-1: object identity cannot distinguish wrong-physics aliasing
+ * from deliberate sharing).
+ *
+ * @public
+ */
+export declare class CompositionAliasError extends Error {
+    constructor(message: string);
+}
+/**
+ * Domain-checked evaluation: throws {@link DomainViolationError} when
+ * `inputs` violate `edge.domain`, otherwise returns `edge.evaluate`.
+ *
+ * @public
+ */
+export declare function evaluateEdge(edge: BridgeEdge, inputs: Record<string, number>): number;
+//# sourceMappingURL=edge.d.ts.map

package/dist/composition/edge.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"edge.d.ts","sourceRoot":"","sources":["../../src/composition/edge.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AAEH,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,eAAe,CAAC;AAC9C,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,6BAA6B,CAAC;AAE5D;;;;;;GAMG;AACH,MAAM,WAAW,cAAc;IAC7B,uEAAuE;IACvE,QAAQ,CAAC,WAAW,EAAE,MAAM,CAAC;IAC7B,oDAAoD;IACpD,QAAQ,CAAC,SAAS,EAAE,CAAC,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,KAAK,OAAO,CAAC;CACjE;AAED;;;;;GAKG;AACH,MAAM,MAAM,cAAc,GACtB,aAAa,GACb,aAAa,GACb,oBAAoB,CAAC;AAEzB;;;;;;;;GAQG;AACH,MAAM,WAAW,UAAU;IACzB,0DAA0D;IAC1D,QAAQ,CAAC,EAAE,EAAE,MAAM,CAAC;IACpB,uDAAuD;IACvD,QAAQ,CAAC,IAAI,EAAE,MAAM,GAAG,IAAI,CAAC;IAC7B,2EAA2E;IAC3E,QAAQ,CAAC,IAAI,EAAE,QAAQ,GAAG,KAAK,CAAC;IAChC,4BAA4B;IAC5B,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;IACvB,gCAAgC;IAChC,QAAQ,CAAC,OAAO,EAAE,SAAS,QAAQ,EAAE,CAAC;IACtC,uBAAuB;IACvB,QAAQ,CAAC,MAAM,EAAE,QAAQ,CAAC;IAC1B,QAAQ,CAAC,UAAU,EAAE,cAAc,CAAC;IACpC,QAAQ,CAAC,MAAM,EAAE,cAAc,CAAC;IAChC,6DAA6D;IAC7D,QAAQ,CAAC,QAAQ,EAAE,CAAC,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,KAAK,MAAM,CAAC;IAC9D;;;;;;;OAOG;IACH,QAAQ,CAAC,QAAQ,CAAC,EAAE,QAAQ,CAAC;IAC7B,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC;IAC1B;;;;;;OAMG;IACH,QAAQ,CAAC,kBAAkB,CAAC,EAAE;QAC5B,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;QACtB,QAAQ,CAAC,EAAE,EAAE,MAAM,CAAC;QACpB,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAC;QAC3B,QAAQ,CAAC,QAAQ,CAAC,EAAE,MAAM,CAAC;KAC5B,CAAC;IACF;;;OAGG;IACH,QAAQ,CAAC,qBAAqB,CAAC,EAAE,aAAa,CAAC;QAC7C,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;QACtB,QAAQ,CAAC,OAAO,EAAE,QAAQ,GAAG;YAAE,QAAQ,CAAC,YAAY,EAAE,MAAM,CAAA;SAAE,CAAC;QAC/D,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAC;QAC3B,QAAQ,CAAC,QAAQ,CAAC,EAAE,MAAM,CAAC;KAC5B,CAAC,CAAC;CACJ;AAED,gEAAgE;AAChE,qBAAa,wBAAyB,SAAQ,KAAK;gBACrC,OAAO,EAAE,MAAM;CAI5B;AAED,6EAA6E;AAC7E,qBAAa,yBAA0B,SAAQ,KAAK;gBACtC,OAAO,EAAE,MAAM;CAI5B;AAED;;;;;;;;;;GAUG;AACH,qBAAa,oBAAqB,SAAQ,KAAK;gBACjC,OAAO,EAAE,MAAM;CAI5B;AAED;;;;;;;;GAQG;AACH,qBAAa,qBAAsB,SAAQ,KAAK;gBAClC,OAAO,EAAE,MAAM;CAI5B;AAED;;;;;GAKG;AACH,wBAAgB,YAAY,CAC1B,IAAI,EAAE,UAAU,EAChB,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,GAC7B,MAAM,CAOR"}

package/dist/composition/edge.js

@@ -0,0 +1,72 @@
+/**
+ * Composition graph — edges (bridges and laws) + validity domains
+ * (v0.8.0 T1+T2+T3, per docs/planning/v0.8.0-Design.md §3).
+ *
+ * A `BridgeEdge` is an edge in the composition graph: n-ary source
+ * quantities → one target quantity, carrying a closed-form evaluator,
+ * a first-class validity domain (G-8), a confidence grade, and a
+ * literature citation. `kind: 'law'` marks diagonal-law edges (P-1) —
+ * edges whose endpoints share regime attributes, serving as the
+ * connective tissue composition chains pass through.
+ *
+ * @module composition/edge
+ */
+/** Composition failed: no junction quantity matched. @public */
+export class CompositionJunctionError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = 'CompositionJunctionError';
+    }
+}
+/** Composition failed: junction dimensions are not exactly equal. @public */
+export class CompositionDimensionError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = 'CompositionDimensionError';
+    }
+}
+/**
+ * Evaluation refused: inputs fall outside an edge's validity domain.
+ *
+ * Honest deviation from design D-3's "domain-incompatible at compose
+ * time": domain predicates are opaque functions, so incompatibility is
+ * detectable only at evaluation — this error is thrown by
+ * {@link evaluateEdge} (and by composed edges internally), not by
+ * `composeEdges`.
+ *
+ * @public
+ */
+export class DomainViolationError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = 'DomainViolationError';
+    }
+}
+/**
+ * Composition refused: the composed sources would contain a duplicate
+ * quantity NAME across operands without a recorded disposition (v0.11
+ * namespacing gate, Option D — pure name-collision rule per the Adam
+ * vet A-1: object identity cannot distinguish wrong-physics aliasing
+ * from deliberate sharing).
+ *
+ * @public
+ */
+export class CompositionAliasError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = 'CompositionAliasError';
+    }
+}
+/**
+ * Domain-checked evaluation: throws {@link DomainViolationError} when
+ * `inputs` violate `edge.domain`, otherwise returns `edge.evaluate`.
+ *
+ * @public
+ */
+export function evaluateEdge(edge, inputs) {
+    if (!edge.domain.predicate(inputs)) {
+        throw new DomainViolationError(`${edge.id}: inputs violate validity domain (${edge.domain.description})`);
+    }
+    return edge.evaluate(inputs);
+}
+//# sourceMappingURL=edge.js.map

package/dist/composition/edge.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"edge.js","sourceRoot":"","sources":["../../src/composition/edge.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AA2FH,gEAAgE;AAChE,MAAM,OAAO,wBAAyB,SAAQ,KAAK;IACjD,YAAY,OAAe;QACzB,KAAK,CAAC,OAAO,CAAC,CAAC;QACf,IAAI,CAAC,IAAI,GAAG,0BAA0B,CAAC;IACzC,CAAC;CACF;AAED,6EAA6E;AAC7E,MAAM,OAAO,yBAA0B,SAAQ,KAAK;IAClD,YAAY,OAAe;QACzB,KAAK,CAAC,OAAO,CAAC,CAAC;QACf,IAAI,CAAC,IAAI,GAAG,2BAA2B,CAAC;IAC1C,CAAC;CACF;AAED;;;;;;;;;;GAUG;AACH,MAAM,OAAO,oBAAqB,SAAQ,KAAK;IAC7C,YAAY,OAAe;QACzB,KAAK,CAAC,OAAO,CAAC,CAAC;QACf,IAAI,CAAC,IAAI,GAAG,sBAAsB,CAAC;IACrC,CAAC;CACF;AAED;;;;;;;;GAQG;AACH,MAAM,OAAO,qBAAsB,SAAQ,KAAK;IAC9C,YAAY,OAAe;QACzB,KAAK,CAAC,OAAO,CAAC,CAAC;QACf,IAAI,CAAC,IAAI,GAAG,uBAAuB,CAAC;IACtC,CAAC;CACF;AAED;;;;;GAKG;AACH,MAAM,UAAU,YAAY,CAC1B,IAAgB,EAChB,MAA8B;IAE9B,IAAI,CAAC,IAAI,CAAC,MAAM,CAAC,SAAS,CAAC,MAAM,CAAC,EAAE,CAAC;QACnC,MAAM,IAAI,oBAAoB,CAC5B,GAAG,IAAI,CAAC,EAAE,qCAAqC,IAAI,CAAC,MAAM,CAAC,WAAW,GAAG,CAC1E,CAAC;IACJ,CAAC;IACD,OAAO,IAAI,CAAC,QAAQ,CAAC,MAAM,CAAC,CAAC;AAC/B,CAAC"}