universal-physics-tensor 0.45.1 → 0.46.0

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

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

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

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

package/dist/atlas/composition-table.js

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

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

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

package/dist/atlas/conventions.d.ts

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

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

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

package/dist/atlas/conventions.js

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

package/dist/atlas/conventions.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"conventions.js","sourceRoot":"","sources":["../../src/atlas/conventions.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;GAoBG;AAOH;;;;;GAKG;AACH,MAAM,eAAe,GAA6B;IAChD,cAAc;IACd,iBAAiB;IACjB,sBAAsB;IACtB,YAAY;IACZ,qBAAqB;CACtB,CAAC;AAEF;;;;;;;;;;;;;;;;;;;GAmBG;AACH,MAAM,UAAU,gBAAgB,CAC9B,CAA0B,EAC1B,CAA0B;IAE1B,IAAI,CAAC,KAAK,SAAS,IAAI,CAAC,KAAK,SAAS;QAAE,OAAO,EAAE,CAAC;IAClD,OAAO,eAAe,CAAC,MAAM,CAAC,CAAC,CAAC,EAAE,EAAE;QAClC,MAAM,EAAE,GAAG,CAAC,CAAC,CAAC,CAAC,CAAC;QAChB,MAAM,EAAE,GAAG,CAAC,CAAC,CAAC,CAAC,CAAC;QAChB,kDAAkD;QAClD,IAAI,EAAE,KAAK,SAAS,IAAI,EAAE,KAAK,SAAS;YAAE,OAAO,KAAK,CAAC;QACvD,OAAO,EAAE,KAAK,EAAE,CAAC;IACnB,CAAC,CAAC,CAAC;AACL,CAAC;AAED;;;;;;;;;;;;;;;GAeG;AACH,MAAM,UAAU,qBAAqB,CACnC,CAA0B,EAC1B,CAA0B;IAE1B,MAAM,EAAE,GAAG,CAAC,IAAI,EAAE,CAAC;IACnB,MAAM,EAAE,GAAG,CAAC,IAAI,EAAE,CAAC;IACnB,OAAO,eAAe,CAAC,MAAM,CAAC,CAAC,CAAC,EAAE,EAAE;QAClC,MAAM,CAAC,GAAG,EAAE,CAAC,CAAC,CAAC,CAAC;QAChB,MAAM,CAAC,GAAG,EAAE,CAAC,CAAC,CAAC,CAAC;QAChB,gFAAgF;QAChF,OAAO,CAAC,CAAC,KAAK,SAAS,CAAC,KAAK,CAAC,CAAC,KAAK,SAAS,CAAC,CAAC;IACjD,CAAC,CAAC,CAAC;AACL,CAAC"}

package/dist/atlas/coverage.d.ts

@@ -0,0 +1,93 @@
+/**
+ * Atlas Phase 1, S1.3 — evidence coverage, counted BY TAG.
+ *
+ * Design note `docs/planning/Atlas-Phase-1-Design.md` §3: *"Any future commit
+ * that appears to raise a row's evidence without adding a witness is a bug,
+ * and the coverage report is what makes it visible: it reports counts BY TAG,
+ * so a jump is legible."*
+ *
+ * A single "how many records have evidence" total would hide exactly the
+ * movement this report exists to expose — one tag inflating while another
+ * drains reads as no change at all. So the report is per tag, every tag is
+ * present with an explicit zero, and `records` is reported beside the counts
+ * (the counts do not sum to it: a record carries several tags).
+ *
+ * Pure: no I/O, no catalog import, no caching — every function here takes
+ * what it counts as an argument, so it can never disagree with a registry.
+ *
+ * @module atlas/coverage
+ * @internal
+ */
+import type { EvidenceTag } from './types.js';
+export { ALL_EVIDENCE_TAGS } from './types.js';
+/** Counts by tag over a set of records. @internal */
+export interface EvidenceCoverage {
+    /** How many records were counted. */
+    readonly records: number;
+    /** One entry per `EvidenceTag`, zero included. Counts overlap by design. */
+    readonly byTag: Readonly<Record<EvidenceTag, number>>;
+}
+/**
+ * Count derived evidence sets by tag.
+ *
+ * @param evidenceSets - one derived set per record, e.g. the output of
+ * `deriveEvidence` mapped over a catalog. Deriving is the caller's job; this
+ * function never derives, so it cannot disagree with the derivation.
+ * @internal
+ */
+export declare function summarizeEvidence(evidenceSets: Iterable<ReadonlySet<EvidenceTag>>): EvidenceCoverage;
+/**
+ * How much of the catalog carries the Phase 1 overlay.
+ *
+ * `summarizeEvidence` above answers "what support do these records have";
+ * this answers the different question "how much has anyone LOOKED at". The two
+ * must not be conflated: a row can be `verified` (its derived tag set is
+ * non-empty, which a machine check produces) while nobody has recorded a
+ * `relation` for it at all.
+ *
+ * - `schema` — the denominator: the 55 catalog rows plus the canonical
+ *   registry. The atlas families are NOT in it; they are reported separately,
+ *   because a nine-model pilot would otherwise dilute a catalog-wide fraction.
+ * - `audited` — a HUMAN set `relation` or `conventions` on the record.
+ * - `verified` — a derived evidence tag set is non-empty. Passed IN, never
+ *   derived here, for the same reason `summarizeEvidence` never derives.
+ * - `notYetAudited` — `schema − audited`, stated rather than left to arithmetic.
+ *
+ * @internal
+ */
+export interface OverlayCoverage {
+    readonly schema: number;
+    readonly audited: number;
+    readonly verified: number;
+    readonly notYetAudited: number;
+    /** The atlas pilot, reported beside the catalog and never mixed into it. */
+    readonly atlas: {
+        readonly bridges: number;
+        readonly reviewed: number;
+    };
+}
+/** A record that may carry the Phase 1 overlay. Structural, so this module
+ * imports no registry and cannot become a second source of truth. @internal */
+export interface OverlayBearing {
+    readonly relation?: unknown;
+    readonly conventions?: unknown;
+}
+/** An atlas bridge, reduced to the one field this report reads. @internal */
+export interface ReviewStatusBearing {
+    readonly reviewStatus: 'proposed' | 'reviewed';
+}
+/**
+ * Count overlay coverage over the catalog rows and canonical entries.
+ *
+ * Every input is PASSED IN. The module stays pure and importless, so it can
+ * never disagree with the registries — the caller states which registries it
+ * counted, exactly as `summarizeEvidence` requires its caller to state which
+ * evidence sets it derived.
+ *
+ * @param schemaRecords - the catalog rows and canonical entries, concatenated.
+ * @param verifiedCount - how many of them have a non-empty derived tag set.
+ * @param atlasBridges - the atlas pilot's bridges, reported separately.
+ * @internal
+ */
+export declare function overlayCoverage(schemaRecords: readonly OverlayBearing[], verifiedCount: number, atlasBridges: readonly ReviewStatusBearing[]): OverlayCoverage;
+//# sourceMappingURL=coverage.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"coverage.d.ts","sourceRoot":"","sources":["../../src/atlas/coverage.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;GAmBG;AAGH,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,YAAY,CAAC;AAI9C,OAAO,EAAE,iBAAiB,EAAE,MAAM,YAAY,CAAC;AAE/C,qDAAqD;AACrD,MAAM,WAAW,gBAAgB;IAC/B,qCAAqC;IACrC,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;IACzB,4EAA4E;IAC5E,QAAQ,CAAC,KAAK,EAAE,QAAQ,CAAC,MAAM,CAAC,WAAW,EAAE,MAAM,CAAC,CAAC,CAAC;CACvD;AAED;;;;;;;GAOG;AACH,wBAAgB,iBAAiB,CAC/B,YAAY,EAAE,QAAQ,CAAC,WAAW,CAAC,WAAW,CAAC,CAAC,GAC/C,gBAAgB,CAWlB;AAMD;;;;;;;;;;;;;;;;;;GAkBG;AACH,MAAM,WAAW,eAAe;IAC9B,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;IACxB,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;IACzB,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC;IAC1B,QAAQ,CAAC,aAAa,EAAE,MAAM,CAAC;IAC/B,4EAA4E;IAC5E,QAAQ,CAAC,KAAK,EAAE;QAAE,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;QAAC,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAA;KAAE,CAAC;CACzE;AAED;+EAC+E;AAC/E,MAAM,WAAW,cAAc;IAC7B,QAAQ,CAAC,QAAQ,CAAC,EAAE,OAAO,CAAC;IAC5B,QAAQ,CAAC,WAAW,CAAC,EAAE,OAAO,CAAC;CAChC;AAED,6EAA6E;AAC7E,MAAM,WAAW,mBAAmB;IAClC,QAAQ,CAAC,YAAY,EAAE,UAAU,GAAG,UAAU,CAAC;CAChD;AAED;;;;;;;;;;;;GAYG;AACH,wBAAgB,eAAe,CAC7B,aAAa,EAAE,SAAS,cAAc,EAAE,EACxC,aAAa,EAAE,MAAM,EACrB,YAAY,EAAE,SAAS,mBAAmB,EAAE,GAC3C,eAAe,CAcjB"}

package/dist/atlas/coverage.js

@@ -0,0 +1,69 @@
+/**
+ * Atlas Phase 1, S1.3 — evidence coverage, counted BY TAG.
+ *
+ * Design note `docs/planning/Atlas-Phase-1-Design.md` §3: *"Any future commit
+ * that appears to raise a row's evidence without adding a witness is a bug,
+ * and the coverage report is what makes it visible: it reports counts BY TAG,
+ * so a jump is legible."*
+ *
+ * A single "how many records have evidence" total would hide exactly the
+ * movement this report exists to expose — one tag inflating while another
+ * drains reads as no change at all. So the report is per tag, every tag is
+ * present with an explicit zero, and `records` is reported beside the counts
+ * (the counts do not sum to it: a record carries several tags).
+ *
+ * Pure: no I/O, no catalog import, no caching — every function here takes
+ * what it counts as an argument, so it can never disagree with a registry.
+ *
+ * @module atlas/coverage
+ * @internal
+ */
+import { ALL_EVIDENCE_TAGS } from './types.js';
+// Moved to `types.ts`: the derived-tag literals may appear under `src/atlas/`
+// only there and in `derive-evidence.ts`. Re-exported so callers are unchanged.
+export { ALL_EVIDENCE_TAGS } from './types.js';
+/**
+ * Count derived evidence sets by tag.
+ *
+ * @param evidenceSets - one derived set per record, e.g. the output of
+ * `deriveEvidence` mapped over a catalog. Deriving is the caller's job; this
+ * function never derives, so it cannot disagree with the derivation.
+ * @internal
+ */
+export function summarizeEvidence(evidenceSets) {
+    const byTag = Object.fromEntries(ALL_EVIDENCE_TAGS.map((t) => [t, 0]));
+    let records = 0;
+    for (const set of evidenceSets) {
+        records += 1;
+        for (const tag of set)
+            byTag[tag] += 1;
+    }
+    return { records, byTag };
+}
+/**
+ * Count overlay coverage over the catalog rows and canonical entries.
+ *
+ * Every input is PASSED IN. The module stays pure and importless, so it can
+ * never disagree with the registries — the caller states which registries it
+ * counted, exactly as `summarizeEvidence` requires its caller to state which
+ * evidence sets it derived.
+ *
+ * @param schemaRecords - the catalog rows and canonical entries, concatenated.
+ * @param verifiedCount - how many of them have a non-empty derived tag set.
+ * @param atlasBridges - the atlas pilot's bridges, reported separately.
+ * @internal
+ */
+export function overlayCoverage(schemaRecords, verifiedCount, atlasBridges) {
+    const audited = schemaRecords.filter((r) => r.relation !== undefined || r.conventions !== undefined).length;
+    return {
+        schema: schemaRecords.length,
+        audited,
+        verified: verifiedCount,
+        notYetAudited: schemaRecords.length - audited,
+        atlas: {
+            bridges: atlasBridges.length,
+            reviewed: atlasBridges.filter((b) => b.reviewStatus === 'reviewed').length,
+        },
+    };
+}
+//# sourceMappingURL=coverage.js.map

package/dist/atlas/coverage.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"coverage.js","sourceRoot":"","sources":["../../src/atlas/coverage.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;GAmBG;AAEH,OAAO,EAAE,iBAAiB,EAAE,MAAM,YAAY,CAAC;AAG/C,8EAA8E;AAC9E,gFAAgF;AAChF,OAAO,EAAE,iBAAiB,EAAE,MAAM,YAAY,CAAC;AAU/C;;;;;;;GAOG;AACH,MAAM,UAAU,iBAAiB,CAC/B,YAAgD;IAEhD,MAAM,KAAK,GAAG,MAAM,CAAC,WAAW,CAAC,iBAAiB,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,CAGpE,CAAC;IACF,IAAI,OAAO,GAAG,CAAC,CAAC;IAChB,KAAK,MAAM,GAAG,IAAI,YAAY,EAAE,CAAC;QAC/B,OAAO,IAAI,CAAC,CAAC;QACb,KAAK,MAAM,GAAG,IAAI,GAAG;YAAE,KAAK,CAAC,GAAG,CAAC,IAAI,CAAC,CAAC;IACzC,CAAC;IACD,OAAO,EAAE,OAAO,EAAE,KAAK,EAAE,CAAC;AAC5B,CAAC;AA8CD;;;;;;;;;;;;GAYG;AACH,MAAM,UAAU,eAAe,CAC7B,aAAwC,EACxC,aAAqB,EACrB,YAA4C;IAE5C,MAAM,OAAO,GAAG,aAAa,CAAC,MAAM,CAClC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,QAAQ,KAAK,SAAS,IAAI,CAAC,CAAC,WAAW,KAAK,SAAS,CAC/D,CAAC,MAAM,CAAC;IACT,OAAO;QACL,MAAM,EAAE,aAAa,CAAC,MAAM;QAC5B,OAAO;QACP,QAAQ,EAAE,aAAa;QACvB,aAAa,EAAE,aAAa,CAAC,MAAM,GAAG,OAAO;QAC7C,KAAK,EAAE;YACL,OAAO,EAAE,YAAY,CAAC,MAAM;YAC5B,QAAQ,EAAE,YAAY,CAAC,MAAM,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,YAAY,KAAK,UAAU,CAAC,CAAC,MAAM;SAC3E;KACF,CAAC;AACJ,CAAC"}