universal-physics-tensor 10.0.0 → 11.0.0

package/dist/composition/algebraic-equivalence.d.ts

@@ -0,0 +1,43 @@
+/**
+ * Equality of two scalar expressions up to a dimensionless constant, decided
+ * by MathTS `simplify` (proposal 2).
+ *
+ * `normalForm` is the cheap structural key: it flattens products and drops
+ * dimensionless constants, but `a/(b/c)` and `a·c/b`, or `a·a` and `a²`, hash
+ * differently, and a chain that recovers a known law in another spelling was
+ * filed as provisional. This module answers the question the hash cannot: it
+ * renders both sides to the gensym string `expr-simplify.ts` uses (one gensym
+ * per leaf NAME, shared by both sides, so the same leaf cancels; a
+ * dimensionless registered constant becomes its number, as the hash drops
+ * it), asks `simplify` for `(A)/(B)`, and reads a constant node as "equal up
+ * to that constant". Anything else, a symbol left over, an arm the renderer
+ * does not carry, a throw inside the simplifier, is NOT SHOWN EQUAL: a
+ * negative answer here is an absence of proof, never a proof of difference.
+ *
+ * MathTS `symbolicEqual` is not used. Before `@danielsimonjr/mathts-functions`
+ * 0.68.4 it passed an empty rule list and compared every pair false; from
+ * 0.68.4 it simplifies with the default rules, and it is the same simplifier
+ * this step calls, so it would be the same method, not a second one.
+ *
+ * The first use runs inside the one console-silencing window
+ * `mathts-quiet.ts` describes, as `mathts-scalar-symbols.ts` does for its
+ * first parse; every later call runs with the console untouched.
+ *
+ * @module composition/algebraic-equivalence
+ */
+import type { ExprNode } from '../dimensional/validator.js';
+/** The outcome: equal with the constant `A/B`, or not shown equal. @internal */
+export type AlgebraicEquivalence = {
+    readonly equal: true;
+    readonly constant: number;
+} | {
+    readonly equal: false;
+};
+/**
+ * Whether `a` and `b` are equal up to a dimensionless constant, and that
+ * constant (`a/b`). See the module docs for what a negative answer means.
+ *
+ * @internal
+ */
+export declare function equalUpToConstant(a: ExprNode, b: ExprNode): AlgebraicEquivalence;
+//# sourceMappingURL=algebraic-equivalence.d.ts.map

package/dist/composition/algebraic-equivalence.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"algebraic-equivalence.d.ts","sourceRoot":"","sources":["../../src/composition/algebraic-equivalence.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AAGH,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,6BAA6B,CAAC;AAQ5D,gFAAgF;AAChF,MAAM,MAAM,oBAAoB,GAAG;IAAE,QAAQ,CAAC,KAAK,EAAE,IAAI,CAAC;IAAC,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAA;CAAE,GAAG;IAAE,QAAQ,CAAC,KAAK,EAAE,KAAK,CAAA;CAAE,CAAC;AAuEnH;;;;;GAKG;AACH,wBAAgB,iBAAiB,CAAC,CAAC,EAAE,QAAQ,EAAE,CAAC,EAAE,QAAQ,GAAG,oBAAoB,CAqBhF"}

package/dist/composition/algebraic-equivalence.js

@@ -0,0 +1,115 @@
+/**
+ * Equality of two scalar expressions up to a dimensionless constant, decided
+ * by MathTS `simplify` (proposal 2).
+ *
+ * `normalForm` is the cheap structural key: it flattens products and drops
+ * dimensionless constants, but `a/(b/c)` and `a·c/b`, or `a·a` and `a²`, hash
+ * differently, and a chain that recovers a known law in another spelling was
+ * filed as provisional. This module answers the question the hash cannot: it
+ * renders both sides to the gensym string `expr-simplify.ts` uses (one gensym
+ * per leaf NAME, shared by both sides, so the same leaf cancels; a
+ * dimensionless registered constant becomes its number, as the hash drops
+ * it), asks `simplify` for `(A)/(B)`, and reads a constant node as "equal up
+ * to that constant". Anything else, a symbol left over, an arm the renderer
+ * does not carry, a throw inside the simplifier, is NOT SHOWN EQUAL: a
+ * negative answer here is an absence of proof, never a proof of difference.
+ *
+ * MathTS `symbolicEqual` is not used. Before `@danielsimonjr/mathts-functions`
+ * 0.68.4 it passed an empty rule list and compared every pair false; from
+ * 0.68.4 it simplifies with the default rules, and it is the same simplifier
+ * this step calls, so it would be the same method, not a second one.
+ *
+ * The first use runs inside the one console-silencing window
+ * `mathts-quiet.ts` describes, as `mathts-scalar-symbols.ts` does for its
+ * first parse; every later call runs with the console untouched.
+ *
+ * @module composition/algebraic-equivalence
+ */
+import { parse as mathtsParse, simplify as mathtsSimplify } from '@danielsimonjr/mathts-functions';
+import { mapScalarLeaves } from '../dimensional/ast-leaves.js';
+import { equals } from '../dimensional/algebra.js';
+import { DIMENSIONLESS } from '../dimensional/types.js';
+import { CONSTANTS, isRegisteredConstant, piMultipleValue } from '../dimensional/symbolic-constants.js';
+import { renderGensym } from './expr-simplify.js';
+import { quietlySync } from './mathts-quiet.js';
+const NOT_EQUAL = { equal: false };
+let cached;
+/**
+ * `simplify ∘ parse`, bound once, after a smoke test that it CANCELS
+ * (`(g0*g1)/(g1*g0)` must come back as the constant 1). A simplifier that
+ * fails the smoke is `null`, and every answer is then "not shown equal".
+ */
+function simplifier() {
+    if (cached !== undefined)
+        return cached;
+    cached = quietlySync(() => {
+        try {
+            const run = (text) => mathtsSimplify(mathtsParse(text));
+            const smoke = run('(g0*g1)/(g1*g0)');
+            return isConstant(smoke) && smoke.value === 1 ? run : null;
+        }
+        catch {
+            return null;
+        }
+    });
+    return cached;
+}
+/** A finite numeric constant node. */
+function isConstant(node) {
+    return ((node.isConstantNode === true || node.type === 'ConstantNode') &&
+        typeof node.value === 'number' &&
+        Number.isFinite(node.value));
+}
+/**
+ * The number a dimensionless leaf stands for when `normalForm` would drop it
+ * as a constant: a registered dimensionless constant, a spelled multiple of
+ * π, or BE-16's `ln_2_constant`. Undefined for every other leaf.
+ */
+function droppableConstantValue(name) {
+    if (name === 'ln_2_constant')
+        return Math.LN2;
+    if (isRegisteredConstant(name)) {
+        const c = CONSTANTS[name];
+        return equals(c.dim, DIMENSIONLESS) ? c.value : undefined;
+    }
+    return piMultipleValue(name);
+}
+/** Dimensionless named constants become literals, so the ratio of two forms that differ by one is a number. */
+function constantsAsLiterals(expr) {
+    return mapScalarLeaves(expr, (leaf) => {
+        const value = droppableConstantValue(leaf.name);
+        return value === undefined ? leaf : { kind: 'symbol', name: String(value), dim: DIMENSIONLESS };
+    }, {});
+}
+/**
+ * Whether `a` and `b` are equal up to a dimensionless constant, and that
+ * constant (`a/b`). See the module docs for what a negative answer means.
+ *
+ * @internal
+ */
+export function equalUpToConstant(a, b) {
+    const run = simplifier();
+    if (run === null)
+        return NOT_EQUAL;
+    const gensymOf = new Map();
+    const meta = new Map();
+    let text;
+    try {
+        // One gensym table for both sides: the same leaf name is the same symbol.
+        const left = renderGensym(constantsAsLiterals(a), gensymOf, meta);
+        const right = renderGensym(constantsAsLiterals(b), gensymOf, meta);
+        text = `(${left})/(${right})`;
+    }
+    catch {
+        return NOT_EQUAL; // an arm the renderer does not carry
+    }
+    let node;
+    try {
+        node = run(text);
+    }
+    catch {
+        return NOT_EQUAL; // the simplifier threw: not shown equal
+    }
+    return isConstant(node) ? { equal: true, constant: node.value } : NOT_EQUAL;
+}
+//# sourceMappingURL=algebraic-equivalence.js.map

package/dist/composition/algebraic-equivalence.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"algebraic-equivalence.js","sourceRoot":"","sources":["../../src/composition/algebraic-equivalence.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * Equality of two scalar expressions up to a dimensionless constant, decided\n * by MathTS `simplify` (proposal 2).\n *\n * `normalForm` is the cheap structural key: it flattens products and drops\n * dimensionless constants, but `a/(b/c)` and `a·c/b`, or `a·a` and `a²`, hash\n * differently, and a chain that recovers a known law in another spelling was\n * filed as provisional. This module answers the question the hash cannot: it\n * renders both sides to the gensym string `expr-simplify.ts` uses (one gensym\n * per leaf NAME, shared by both sides, so the same leaf cancels; a\n * dimensionless registered constant becomes its number, as the hash drops\n * it), asks `simplify` for `(A)/(B)`, and reads a constant node as \"equal up\n * to that constant\". Anything else, a symbol left over, an arm the renderer\n * does not carry, a throw inside the simplifier, is NOT SHOWN EQUAL: a\n * negative answer here is an absence of proof, never a proof of difference.\n *\n * MathTS `symbolicEqual` is not used. Before `@danielsimonjr/mathts-functions`\n * 0.68.4 it passed an empty rule list and compared every pair false; from\n * 0.68.4 it simplifies with the default rules, and it is the same simplifier\n * this step calls, so it would be the same method, not a second one.\n *\n * The first use runs inside the one console-silencing window\n * `mathts-quiet.ts` describes, as `mathts-scalar-symbols.ts` does for its\n * first parse; every later call runs with the console untouched.\n *\n * @module composition/algebraic-equivalence\n */\n\nimport { parse as mathtsParse, simplify as mathtsSimplify } from '@danielsimonjr/mathts-functions';\nimport type { ExprNode } from '../dimensional/validator.js';\nimport { mapScalarLeaves } from '../dimensional/ast-leaves.js';\nimport { equals } from '../dimensional/algebra.js';\nimport { DIMENSIONLESS } from '../dimensional/types.js';\nimport { CONSTANTS, isRegisteredConstant, piMultipleValue } from '../dimensional/symbolic-constants.js';\nimport { renderGensym, type LeafMeta } from './expr-simplify.js';\nimport { quietlySync } from './mathts-quiet.js';\n\n/** The outcome: equal with the constant `A/B`, or not shown equal. @internal */\nexport type AlgebraicEquivalence = { readonly equal: true; readonly constant: number } | { readonly equal: false };\n\n/** The bits of a simplified MathTS node this module reads. */\ninterface MathNode {\n  readonly type?: string;\n  readonly isConstantNode?: boolean;\n  readonly value?: unknown;\n}\n\ninterface Simplifier {\n  (text: string): MathNode;\n}\n\nconst NOT_EQUAL: AlgebraicEquivalence = { equal: false };\n\nlet cached: Simplifier | null | undefined;\n\n/**\n * `simplify ∘ parse`, bound once, after a smoke test that it CANCELS\n * (`(g0*g1)/(g1*g0)` must come back as the constant 1). A simplifier that\n * fails the smoke is `null`, and every answer is then \"not shown equal\".\n */\nfunction simplifier(): Simplifier | null {\n  if (cached !== undefined) return cached;\n  cached = quietlySync(() => {\n    try {\n      const run: Simplifier = (text) => mathtsSimplify(mathtsParse(text)) as unknown as MathNode;\n      const smoke = run('(g0*g1)/(g1*g0)');\n      return isConstant(smoke) && smoke.value === 1 ? run : null;\n    } catch {\n      return null;\n    }\n  });\n  return cached;\n}\n\n/** A finite numeric constant node. */\nfunction isConstant(node: MathNode): node is MathNode & { readonly value: number } {\n  return (\n    (node.isConstantNode === true || node.type === 'ConstantNode') &&\n    typeof node.value === 'number' &&\n    Number.isFinite(node.value)\n  );\n}\n\n/**\n * The number a dimensionless leaf stands for when `normalForm` would drop it\n * as a constant: a registered dimensionless constant, a spelled multiple of\n * π, or BE-16's `ln_2_constant`. Undefined for every other leaf.\n */\nfunction droppableConstantValue(name: string): number | undefined {\n  if (name === 'ln_2_constant') return Math.LN2;\n  if (isRegisteredConstant(name)) {\n    const c = CONSTANTS[name]!;\n    return equals(c.dim, DIMENSIONLESS) ? c.value : undefined;\n  }\n  return piMultipleValue(name);\n}\n\n/** Dimensionless named constants become literals, so the ratio of two forms that differ by one is a number. */\nfunction constantsAsLiterals(expr: ExprNode): ExprNode {\n  return mapScalarLeaves(\n    expr,\n    (leaf) => {\n      const value = droppableConstantValue(leaf.name);\n      return value === undefined ? leaf : { kind: 'symbol', name: String(value), dim: DIMENSIONLESS };\n    },\n    {},\n  );\n}\n\n/**\n * Whether `a` and `b` are equal up to a dimensionless constant, and that\n * constant (`a/b`). See the module docs for what a negative answer means.\n *\n * @internal\n */\nexport function equalUpToConstant(a: ExprNode, b: ExprNode): AlgebraicEquivalence {\n  const run = simplifier();\n  if (run === null) return NOT_EQUAL;\n  const gensymOf = new Map<string, string>();\n  const meta = new Map<string, LeafMeta>();\n  let text: string;\n  try {\n    // One gensym table for both sides: the same leaf name is the same symbol.\n    const left = renderGensym(constantsAsLiterals(a), gensymOf, meta);\n    const right = renderGensym(constantsAsLiterals(b), gensymOf, meta);\n    text = `(${left})/(${right})`;\n  } catch {\n    return NOT_EQUAL; // an arm the renderer does not carry\n  }\n  let node: MathNode;\n  try {\n    node = run(text);\n  } catch {\n    return NOT_EQUAL; // the simplifier threw: not shown equal\n  }\n  return isConstant(node) ? { equal: true, constant: node.value } : NOT_EQUAL;\n}\n"]}

package/dist/composition/axes.d.ts

@@ -34,14 +34,8 @@ export type StatisticsAxis = 'bosonic' | 'fermionic' | 'anyonic' | 'parastatisti
 export declare const SCALE_AXIS_VALUES: readonly ScaleAxis[];
 /** The force values. @internal */
 export declare const FORCE_AXIS_VALUES: readonly ForceAxis[];
-/** The information-measure values. @internal */
-export declare const INFORMATION_AXIS_VALUES: readonly InformationAxis[];
 /** The symmetry values. @internal */
 export declare const SYMMETRY_AXIS_VALUES: readonly SymmetryAxis[];
-/** The topology values. @internal */
-export declare const TOPOLOGY_AXIS_VALUES: readonly TopologyAxis[];
-/** The statistics values. @internal */
-export declare const STATISTICS_AXIS_VALUES: readonly StatisticsAxis[];
 /** A classification-axis specification. @internal */
 export interface AxisSpec {
     /** The axis key, matching the `RegimeAttributes` field name. */

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

@@ -1 +1 @@
-{"version":3,"file":"axes.d.ts","sourceRoot":"","sources":["../../src/composition/axes.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;GAmBG;AAEH,4CAA4C;AAC5C,MAAM,MAAM,SAAS,GAAG,SAAS,GAAG,YAAY,GAAG,WAAW,GAAG,cAAc,CAAC;AAChF,yCAAyC;AACzC,MAAM,MAAM,SAAS,GACjB,eAAe,GACf,iBAAiB,GACjB,MAAM,GACN,QAAQ,GACR,UAAU,CAAC;AACf,qCAAqC;AACrC,MAAM,MAAM,eAAe,GAAG,aAAa,GAAG,SAAS,GAAG,YAAY,GAAG,SAAS,CAAC;AACnF,gCAAgC;AAChC,MAAM,MAAM,YAAY,GAAG,UAAU,GAAG,OAAO,GAAG,WAAW,GAAG,MAAM,GAAG,UAAU,CAAC;AACpF,6DAA6D;AAC7D,MAAM,MAAM,YAAY,GAAG,SAAS,GAAG,OAAO,GAAG,SAAS,GAAG,IAAI,GAAG,OAAO,CAAC;AAC5E,iFAAiF;AACjF,MAAM,MAAM,cAAc,GAAG,SAAS,GAAG,WAAW,GAAG,SAAS,GAAG,eAAe,CAAC;AAEnF,+FAA+F;AAC/F,eAAO,MAAM,iBAAiB,EAAE,SAAS,SAAS,EAA2D,CAAC;AAC9G,kCAAkC;AAClC,eAAO,MAAM,iBAAiB,EAAE,SAAS,SAAS,EAAuE,CAAC;AAC1H,gDAAgD;AAChD,eAAO,MAAM,uBAAuB,EAAE,SAAS,eAAe,EAAwD,CAAC;AACvH,qCAAqC;AACrC,eAAO,MAAM,oBAAoB,EAAE,SAAS,YAAY,EAA2D,CAAC;AACpH,qCAAqC;AACrC,eAAO,MAAM,oBAAoB,EAAE,SAAS,YAAY,EAAmD,CAAC;AAC5G,uCAAuC;AACvC,eAAO,MAAM,sBAAsB,EAAE,SAAS,cAAc,EAAyD,CAAC;AAEtH,qDAAqD;AACrD,MAAM,WAAW,QAAQ;IACvB,gEAAgE;IAChE,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,mFAAmF;IACnF,QAAQ,CAAC,MAAM,EAAE,SAAS,MAAM,EAAE,CAAC;IACnC;;;;OAIG;IACH,QAAQ,CAAC,KAAK,EAAE,OAAO,CAAC;IACxB,QAAQ,CAAC,WAAW,EAAE,MAAM,CAAC;CAC9B;AAED;;;;;;GAMG;AACH,eAAO,MAAM,IAAI,EAAE,SAAS,QAAQ,EAqCnC,CAAC;AAEF,6FAA6F;AAC7F,eAAO,MAAM,SAAS,EAAE,SAAS,MAAM,EAAmD,CAAC"}
+{"version":3,"file":"axes.d.ts","sourceRoot":"","sources":["../../src/composition/axes.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;GAmBG;AAEH,4CAA4C;AAC5C,MAAM,MAAM,SAAS,GAAG,SAAS,GAAG,YAAY,GAAG,WAAW,GAAG,cAAc,CAAC;AAChF,yCAAyC;AACzC,MAAM,MAAM,SAAS,GACjB,eAAe,GACf,iBAAiB,GACjB,MAAM,GACN,QAAQ,GACR,UAAU,CAAC;AACf,qCAAqC;AACrC,MAAM,MAAM,eAAe,GAAG,aAAa,GAAG,SAAS,GAAG,YAAY,GAAG,SAAS,CAAC;AACnF,gCAAgC;AAChC,MAAM,MAAM,YAAY,GAAG,UAAU,GAAG,OAAO,GAAG,WAAW,GAAG,MAAM,GAAG,UAAU,CAAC;AACpF,6DAA6D;AAC7D,MAAM,MAAM,YAAY,GAAG,SAAS,GAAG,OAAO,GAAG,SAAS,GAAG,IAAI,GAAG,OAAO,CAAC;AAC5E,iFAAiF;AACjF,MAAM,MAAM,cAAc,GAAG,SAAS,GAAG,WAAW,GAAG,SAAS,GAAG,eAAe,CAAC;AAEnF,+FAA+F;AAC/F,eAAO,MAAM,iBAAiB,EAAE,SAAS,SAAS,EAA2D,CAAC;AAC9G,kCAAkC;AAClC,eAAO,MAAM,iBAAiB,EAAE,SAAS,SAAS,EAAuE,CAAC;AAG1H,qCAAqC;AACrC,eAAO,MAAM,oBAAoB,EAAE,SAAS,YAAY,EAA2D,CAAC;AAMpH,qDAAqD;AACrD,MAAM,WAAW,QAAQ;IACvB,gEAAgE;IAChE,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,mFAAmF;IACnF,QAAQ,CAAC,MAAM,EAAE,SAAS,MAAM,EAAE,CAAC;IACnC;;;;OAIG;IACH,QAAQ,CAAC,KAAK,EAAE,OAAO,CAAC;IACxB,QAAQ,CAAC,WAAW,EAAE,MAAM,CAAC;CAC9B;AAED;;;;;;GAMG;AACH,eAAO,MAAM,IAAI,EAAE,SAAS,QAAQ,EAqCnC,CAAC;AAEF,6FAA6F;AAC7F,eAAO,MAAM,SAAS,EAAE,SAAS,MAAM,EAAmD,CAAC"}

package/dist/composition/axes.js

@@ -22,14 +22,14 @@
 export const SCALE_AXIS_VALUES = ['quantum', 'mesoscopic', 'classical', 'cosmological'];
 /** The force values. @internal */
 export const FORCE_AXIS_VALUES = ['gravitational', 'electromagnetic', 'weak', 'strong', 'emergent'];
-/** The information-measure values. @internal */
-export const INFORMATION_AXIS_VALUES = ['von-neumann', 'shannon', 'kolmogorov', 'discord'];
+/** The information-measure values; read by its `AXES` row alone, so not exported. */
+const INFORMATION_AXIS_VALUES = ['von-neumann', 'shannon', 'kolmogorov', 'discord'];
 /** The symmetry values. @internal */
 export const SYMMETRY_AXIS_VALUES = ['poincare', 'gauge', 'conformal', 'susy', 'emergent'];
-/** The topology values. @internal */
-export const TOPOLOGY_AXIS_VALUES = ['trivial', 'chern', 'winding', 'z2', 'berry'];
-/** The statistics values. @internal */
-export const STATISTICS_AXIS_VALUES = ['bosonic', 'fermionic', 'anyonic', 'parastatistic'];
+/** The topology values; read by its `AXES` row alone, so not exported. */
+const TOPOLOGY_AXIS_VALUES = ['trivial', 'chern', 'winding', 'z2', 'berry'];
+/** The statistics values; read by its `AXES` row alone, so not exported. */
+const STATISTICS_AXIS_VALUES = ['bosonic', 'fermionic', 'anyonic', 'parastatistic'];
 /**
  * The classification-axis registry. `gated` reflects measured discrimination:
  * scale/force fire on the current catalog; the rest abstain (too little attribute

package/dist/composition/axes.js.map

@@ -1 +1 @@
-{"version":3,"file":"axes.js","sourceRoot":"","sources":["../../src/composition/axes.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;GAmBG;AAoBH,+FAA+F;AAC/F,MAAM,CAAC,MAAM,iBAAiB,GAAyB,CAAC,SAAS,EAAE,YAAY,EAAE,WAAW,EAAE,cAAc,CAAC,CAAC;AAC9G,kCAAkC;AAClC,MAAM,CAAC,MAAM,iBAAiB,GAAyB,CAAC,eAAe,EAAE,iBAAiB,EAAE,MAAM,EAAE,QAAQ,EAAE,UAAU,CAAC,CAAC;AAC1H,gDAAgD;AAChD,MAAM,CAAC,MAAM,uBAAuB,GAA+B,CAAC,aAAa,EAAE,SAAS,EAAE,YAAY,EAAE,SAAS,CAAC,CAAC;AACvH,qCAAqC;AACrC,MAAM,CAAC,MAAM,oBAAoB,GAA4B,CAAC,UAAU,EAAE,OAAO,EAAE,WAAW,EAAE,MAAM,EAAE,UAAU,CAAC,CAAC;AACpH,qCAAqC;AACrC,MAAM,CAAC,MAAM,oBAAoB,GAA4B,CAAC,SAAS,EAAE,OAAO,EAAE,SAAS,EAAE,IAAI,EAAE,OAAO,CAAC,CAAC;AAC5G,uCAAuC;AACvC,MAAM,CAAC,MAAM,sBAAsB,GAA8B,CAAC,SAAS,EAAE,WAAW,EAAE,SAAS,EAAE,eAAe,CAAC,CAAC;AAiBtH;;;;;;GAMG;AACH,MAAM,CAAC,MAAM,IAAI,GAAwB;IACvC;QACE,IAAI,EAAE,OAAO;QACb,MAAM,EAAE,iBAAiB;QACzB,KAAK,EAAE,IAAI;QACX,WAAW,EAAE,sDAAsD;KACpE;IACD;QACE,IAAI,EAAE,OAAO;QACb,MAAM,EAAE,iBAAiB;QACzB,KAAK,EAAE,IAAI;QACX,WAAW,EAAE,kDAAkD;KAChE;IACD;QACE,IAAI,EAAE,aAAa;QACnB,MAAM,EAAE,uBAAuB;QAC/B,KAAK,EAAE,KAAK;QACZ,WAAW,EAAE,kFAAkF;KAChG;IACD;QACE,IAAI,EAAE,UAAU;QAChB,MAAM,EAAE,oBAAoB;QAC5B,KAAK,EAAE,KAAK;QACZ,WAAW,EAAE,iFAAiF;KAC/F;IACD;QACE,IAAI,EAAE,UAAU;QAChB,MAAM,EAAE,oBAAoB;QAC5B,KAAK,EAAE,KAAK;QACZ,WAAW,EAAE,uFAAuF;KACrG;IACD;QACE,IAAI,EAAE,YAAY;QAClB,MAAM,EAAE,sBAAsB;QAC9B,KAAK,EAAE,KAAK;QACZ,WAAW,EAAE,qJAAqJ;KACnK;CACF,CAAC;AAEF,6FAA6F;AAC7F,MAAM,CAAC,MAAM,SAAS,GAAsB,IAAI,CAAC,MAAM,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,KAAK,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC","sourcesContent":["/**\n * The extensible tensor-axis registry — the single source for UPT's classification\n * axes (the regime/attribute layer the discovery funnel and quantities use).\n *\n * Each axis is BOTH a typed union (compile-time safety) AND an {@link AxisSpec}\n * registry entry (runtime — drives the discovery falsifier and the discrimination\n * audit). Adding an axis is one union + one registry line + tagging quantities;\n * enabling its falsifier gate is a one-line `gated: true` flip — but only after the\n * discrimination audit (`axis-audit.ts`) shows it actually fires. Rank grows on\n * measured physics, not vision — an axis that only ever abstains stays ungated.\n *\n * NOTE: the SI `Dimension` axis is deliberately NOT here — it is the complete 7-base\n * system in `dimensional/` (conflating it would break Buckingham-π). The tensor-config\n * types in `core/types.ts` (`PhysicalScale`/`Force`/… consumed by `UniversalTensor`)\n * are a separate concern; this registry is the discovery/attribute layer.\n *\n * Leaf module — no intra-`composition` imports (keeps the type-only cycle count at 0).\n *\n * @module composition/axes\n */\n\n/** Length/energy scale regime. @internal */\nexport type ScaleAxis = 'quantum' | 'mesoscopic' | 'classical' | 'cosmological';\n/** Fundamental interaction. @internal */\nexport type ForceAxis =\n  | 'gravitational'\n  | 'electromagnetic'\n  | 'weak'\n  | 'strong'\n  | 'emergent';\n/** Information measure. @internal */\nexport type InformationAxis = 'von-neumann' | 'shannon' | 'kolmogorov' | 'discord';\n/** Symmetry class. @internal */\nexport type SymmetryAxis = 'poincare' | 'gauge' | 'conformal' | 'susy' | 'emergent';\n/** Topological classification (invariant type). @internal */\nexport type TopologyAxis = 'trivial' | 'chern' | 'winding' | 'z2' | 'berry';\n/** Quantum statistics (the 7th axis — orthogonal to the other six). @internal */\nexport type StatisticsAxis = 'bosonic' | 'fermionic' | 'anyonic' | 'parastatistic';\n\n/** The scale values, the one list the registry row and every typed consumer read. @internal */\nexport const SCALE_AXIS_VALUES: readonly ScaleAxis[] = ['quantum', 'mesoscopic', 'classical', 'cosmological'];\n/** The force values. @internal */\nexport const FORCE_AXIS_VALUES: readonly ForceAxis[] = ['gravitational', 'electromagnetic', 'weak', 'strong', 'emergent'];\n/** The information-measure values. @internal */\nexport const INFORMATION_AXIS_VALUES: readonly InformationAxis[] = ['von-neumann', 'shannon', 'kolmogorov', 'discord'];\n/** The symmetry values. @internal */\nexport const SYMMETRY_AXIS_VALUES: readonly SymmetryAxis[] = ['poincare', 'gauge', 'conformal', 'susy', 'emergent'];\n/** The topology values. @internal */\nexport const TOPOLOGY_AXIS_VALUES: readonly TopologyAxis[] = ['trivial', 'chern', 'winding', 'z2', 'berry'];\n/** The statistics values. @internal */\nexport const STATISTICS_AXIS_VALUES: readonly StatisticsAxis[] = ['bosonic', 'fermionic', 'anyonic', 'parastatistic'];\n\n/** A classification-axis specification. @internal */\nexport interface AxisSpec {\n  /** The axis key, matching the `RegimeAttributes` field name. */\n  readonly name: string;\n  /** The axis's allowed values at runtime (must equal the typed union's members). */\n  readonly values: readonly string[];\n  /**\n   * Whether the discovery axis-falsifier gates on this axis. Flipped to `true`\n   * ONLY when `auditAxisDiscrimination` shows the axis actually clashes on real\n   * candidates — never on vision alone.\n   */\n  readonly gated: boolean;\n  readonly description: string;\n}\n\n/**\n * The classification-axis registry. `gated` reflects measured discrimination:\n * scale/force fire on the current catalog; the rest abstain (too little attribute\n * coverage yet) and stay ungated until the branch expansion + audit earn them a gate.\n *\n * @internal\n */\nexport const AXES: readonly AxisSpec[] = [\n  {\n    name: 'scale',\n    values: SCALE_AXIS_VALUES,\n    gated: true,\n    description: 'Length/energy-scale regime (quantum → cosmological).',\n  },\n  {\n    name: 'force',\n    values: FORCE_AXIS_VALUES,\n    gated: true,\n    description: 'Fundamental (or emergent effective) interaction.',\n  },\n  {\n    name: 'information',\n    values: INFORMATION_AXIS_VALUES,\n    gated: false,\n    description: 'Information measure — authored, not gated (see discovery precision calibration).',\n  },\n  {\n    name: 'symmetry',\n    values: SYMMETRY_AXIS_VALUES,\n    gated: false,\n    description: 'Symmetry class — first-class attribute; ungated until coverage + audit earn it.',\n  },\n  {\n    name: 'topology',\n    values: TOPOLOGY_AXIS_VALUES,\n    gated: false,\n    description: 'Topological invariant type — populates the rank-6 Topology axis; ungated until audit.',\n  },\n  {\n    name: 'statistics',\n    values: STATISTICS_AXIS_VALUES,\n    gated: false,\n    description: 'Quantum statistics (the 7th axis). NOTE: spin-statistics ties it to symmetry — the audit must confirm it discriminates independently before gating.',\n  },\n];\n\n/** The axis names the discovery falsifier gates on (derived from the registry). @internal */\nexport const GATE_AXES: readonly string[] = AXES.filter((a) => a.gated).map((a) => a.name);\n"]}
+{"version":3,"file":"axes.js","sourceRoot":"","sources":["../../src/composition/axes.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;GAmBG;AAoBH,+FAA+F;AAC/F,MAAM,CAAC,MAAM,iBAAiB,GAAyB,CAAC,SAAS,EAAE,YAAY,EAAE,WAAW,EAAE,cAAc,CAAC,CAAC;AAC9G,kCAAkC;AAClC,MAAM,CAAC,MAAM,iBAAiB,GAAyB,CAAC,eAAe,EAAE,iBAAiB,EAAE,MAAM,EAAE,QAAQ,EAAE,UAAU,CAAC,CAAC;AAC1H,qFAAqF;AACrF,MAAM,uBAAuB,GAA+B,CAAC,aAAa,EAAE,SAAS,EAAE,YAAY,EAAE,SAAS,CAAC,CAAC;AAChH,qCAAqC;AACrC,MAAM,CAAC,MAAM,oBAAoB,GAA4B,CAAC,UAAU,EAAE,OAAO,EAAE,WAAW,EAAE,MAAM,EAAE,UAAU,CAAC,CAAC;AACpH,0EAA0E;AAC1E,MAAM,oBAAoB,GAA4B,CAAC,SAAS,EAAE,OAAO,EAAE,SAAS,EAAE,IAAI,EAAE,OAAO,CAAC,CAAC;AACrG,4EAA4E;AAC5E,MAAM,sBAAsB,GAA8B,CAAC,SAAS,EAAE,WAAW,EAAE,SAAS,EAAE,eAAe,CAAC,CAAC;AAiB/G;;;;;;GAMG;AACH,MAAM,CAAC,MAAM,IAAI,GAAwB;IACvC;QACE,IAAI,EAAE,OAAO;QACb,MAAM,EAAE,iBAAiB;QACzB,KAAK,EAAE,IAAI;QACX,WAAW,EAAE,sDAAsD;KACpE;IACD;QACE,IAAI,EAAE,OAAO;QACb,MAAM,EAAE,iBAAiB;QACzB,KAAK,EAAE,IAAI;QACX,WAAW,EAAE,kDAAkD;KAChE;IACD;QACE,IAAI,EAAE,aAAa;QACnB,MAAM,EAAE,uBAAuB;QAC/B,KAAK,EAAE,KAAK;QACZ,WAAW,EAAE,kFAAkF;KAChG;IACD;QACE,IAAI,EAAE,UAAU;QAChB,MAAM,EAAE,oBAAoB;QAC5B,KAAK,EAAE,KAAK;QACZ,WAAW,EAAE,iFAAiF;KAC/F;IACD;QACE,IAAI,EAAE,UAAU;QAChB,MAAM,EAAE,oBAAoB;QAC5B,KAAK,EAAE,KAAK;QACZ,WAAW,EAAE,uFAAuF;KACrG;IACD;QACE,IAAI,EAAE,YAAY;QAClB,MAAM,EAAE,sBAAsB;QAC9B,KAAK,EAAE,KAAK;QACZ,WAAW,EAAE,qJAAqJ;KACnK;CACF,CAAC;AAEF,6FAA6F;AAC7F,MAAM,CAAC,MAAM,SAAS,GAAsB,IAAI,CAAC,MAAM,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,KAAK,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC","sourcesContent":["/**\n * The extensible tensor-axis registry — the single source for UPT's classification\n * axes (the regime/attribute layer the discovery funnel and quantities use).\n *\n * Each axis is BOTH a typed union (compile-time safety) AND an {@link AxisSpec}\n * registry entry (runtime — drives the discovery falsifier and the discrimination\n * audit). Adding an axis is one union + one registry line + tagging quantities;\n * enabling its falsifier gate is a one-line `gated: true` flip — but only after the\n * discrimination audit (`axis-audit.ts`) shows it actually fires. Rank grows on\n * measured physics, not vision — an axis that only ever abstains stays ungated.\n *\n * NOTE: the SI `Dimension` axis is deliberately NOT here — it is the complete 7-base\n * system in `dimensional/` (conflating it would break Buckingham-π). The tensor-config\n * types in `core/types.ts` (`PhysicalScale`/`Force`/… consumed by `UniversalTensor`)\n * are a separate concern; this registry is the discovery/attribute layer.\n *\n * Leaf module — no intra-`composition` imports (keeps the type-only cycle count at 0).\n *\n * @module composition/axes\n */\n\n/** Length/energy scale regime. @internal */\nexport type ScaleAxis = 'quantum' | 'mesoscopic' | 'classical' | 'cosmological';\n/** Fundamental interaction. @internal */\nexport type ForceAxis =\n  | 'gravitational'\n  | 'electromagnetic'\n  | 'weak'\n  | 'strong'\n  | 'emergent';\n/** Information measure. @internal */\nexport type InformationAxis = 'von-neumann' | 'shannon' | 'kolmogorov' | 'discord';\n/** Symmetry class. @internal */\nexport type SymmetryAxis = 'poincare' | 'gauge' | 'conformal' | 'susy' | 'emergent';\n/** Topological classification (invariant type). @internal */\nexport type TopologyAxis = 'trivial' | 'chern' | 'winding' | 'z2' | 'berry';\n/** Quantum statistics (the 7th axis — orthogonal to the other six). @internal */\nexport type StatisticsAxis = 'bosonic' | 'fermionic' | 'anyonic' | 'parastatistic';\n\n/** The scale values, the one list the registry row and every typed consumer read. @internal */\nexport const SCALE_AXIS_VALUES: readonly ScaleAxis[] = ['quantum', 'mesoscopic', 'classical', 'cosmological'];\n/** The force values. @internal */\nexport const FORCE_AXIS_VALUES: readonly ForceAxis[] = ['gravitational', 'electromagnetic', 'weak', 'strong', 'emergent'];\n/** The information-measure values; read by its `AXES` row alone, so not exported. */\nconst INFORMATION_AXIS_VALUES: readonly InformationAxis[] = ['von-neumann', 'shannon', 'kolmogorov', 'discord'];\n/** The symmetry values. @internal */\nexport const SYMMETRY_AXIS_VALUES: readonly SymmetryAxis[] = ['poincare', 'gauge', 'conformal', 'susy', 'emergent'];\n/** The topology values; read by its `AXES` row alone, so not exported. */\nconst TOPOLOGY_AXIS_VALUES: readonly TopologyAxis[] = ['trivial', 'chern', 'winding', 'z2', 'berry'];\n/** The statistics values; read by its `AXES` row alone, so not exported. */\nconst STATISTICS_AXIS_VALUES: readonly StatisticsAxis[] = ['bosonic', 'fermionic', 'anyonic', 'parastatistic'];\n\n/** A classification-axis specification. @internal */\nexport interface AxisSpec {\n  /** The axis key, matching the `RegimeAttributes` field name. */\n  readonly name: string;\n  /** The axis's allowed values at runtime (must equal the typed union's members). */\n  readonly values: readonly string[];\n  /**\n   * Whether the discovery axis-falsifier gates on this axis. Flipped to `true`\n   * ONLY when `auditAxisDiscrimination` shows the axis actually clashes on real\n   * candidates — never on vision alone.\n   */\n  readonly gated: boolean;\n  readonly description: string;\n}\n\n/**\n * The classification-axis registry. `gated` reflects measured discrimination:\n * scale/force fire on the current catalog; the rest abstain (too little attribute\n * coverage yet) and stay ungated until the branch expansion + audit earn them a gate.\n *\n * @internal\n */\nexport const AXES: readonly AxisSpec[] = [\n  {\n    name: 'scale',\n    values: SCALE_AXIS_VALUES,\n    gated: true,\n    description: 'Length/energy-scale regime (quantum → cosmological).',\n  },\n  {\n    name: 'force',\n    values: FORCE_AXIS_VALUES,\n    gated: true,\n    description: 'Fundamental (or emergent effective) interaction.',\n  },\n  {\n    name: 'information',\n    values: INFORMATION_AXIS_VALUES,\n    gated: false,\n    description: 'Information measure — authored, not gated (see discovery precision calibration).',\n  },\n  {\n    name: 'symmetry',\n    values: SYMMETRY_AXIS_VALUES,\n    gated: false,\n    description: 'Symmetry class — first-class attribute; ungated until coverage + audit earn it.',\n  },\n  {\n    name: 'topology',\n    values: TOPOLOGY_AXIS_VALUES,\n    gated: false,\n    description: 'Topological invariant type — populates the rank-6 Topology axis; ungated until audit.',\n  },\n  {\n    name: 'statistics',\n    values: STATISTICS_AXIS_VALUES,\n    gated: false,\n    description: 'Quantum statistics (the 7th axis). NOTE: spin-statistics ties it to symmetry — the audit must confirm it discriminates independently before gating.',\n  },\n];\n\n/** The axis names the discovery falsifier gates on (derived from the registry). @internal */\nexport const GATE_AXES: readonly string[] = AXES.filter((a) => a.gated).map((a) => a.name);\n"]}

package/dist/composition/axis-audit.d.ts

@@ -1,23 +1,36 @@
+import type { BridgeEdge } from './edge.js';
+import type { RegimeAttributes } from './quantity.js';
+import type { QuantityIdentification } from './compose.js';
+import type { DiscoveryOptions } from './discovery.js';
 /**
- * Axis-discrimination audit — the anti-inert-metadata gate for the extensible
- * axis registry (`axes.ts`).
- *
- * A classification axis is only load-bearing when it actually SEPARATES real
- * candidates. This audit runs the discovery link-candidate enumeration and, for
- * EVERY registry axis (gated or not), measures how often the axis FIRES (both
- * endpoints carry the attribute and they differ → an axis-clash), ABSTAINS (at
- * least one endpoint lacks the attribute), and is CHECKED (both carry it).
+ * The level at which an axis is `earned`: 0.05, the conventional two-sided level, fixed before
+ * any table was read. Six axes are audited at once, so a reader who wants a family-wise level
+ * divides by six (0.0083); the flag is per axis and says so here rather than hiding a
+ * correction. Small tables (about twenty magnitude clashes on the catalog) are why the test is
+ * exact and not a χ².
  *
- * Use: an axis stays `gated: false` in the registry until this audit shows it
- * fires; an axis that only ever abstains is inert and must not be gated. As the
- * catalog grows into new branches of physics, re-run this and flip the gates the
- * measurement earns. Rank grows on evidence, not vision.
+ * @internal
+ */
+export declare const AUDIT_ALPHA = 0.05;
+/**
+ * Fisher's exact evidence of one axis against the magnitude falsifier, over the candidates
+ * where BOTH gates ran (both endpoints carry the axis, and both have a magnitude).
  *
- * @module composition/axis-audit
+ * @internal
  */
-import type { BridgeEdge } from './edge.js';
-import type { RegimeAttributes } from './quantity.js';
-import type { QuantityIdentification } from './compose.js';
+export interface AxisEvidence {
+    /**
+     * `[[fires ∧ clash, fires ∧ no clash], [silent ∧ clash, silent ∧ no clash]]`: rows are the
+     * axis's verdict, columns the magnitude falsifier's.
+     */
+    readonly table: readonly [readonly [number, number], readonly [number, number]];
+    /** Sample odds ratio `ad/bc`, as MathTS reports it; `null` when a zero cell leaves it undefined. */
+    readonly oddsRatio: number | null;
+    /** Two-sided Fisher exact p; 1 when a margin is zero (only one table is possible). */
+    readonly pValue: number;
+    /** Candidates where both gates ran (the table's total). */
+    readonly n: number;
+}
 /** Per-axis discrimination measurement over the candidate funnel. @internal */
 export interface AxisDiscrimination {
     readonly axis: string;
@@ -32,15 +45,29 @@ export interface AxisDiscrimination {
     /** fires / checked (0 when nothing is checked). */
     readonly clashRate: number;
     /**
-     * A gate is EARNED when the axis fires at all. `false` here on an ungated axis
-     * = inert (do not gate); `false` on a gated axis = a regression to investigate.
+     * The registry's criterion: a gate is EARNED when the axis fires at all. `false` here on an
+     * ungated axis = inert (do not gate); `false` on a gated axis = a regression to investigate.
+     * Not changed by `evidence`.
      */
     readonly discriminates: boolean;
+    /** Fisher's exact test of the axis's fires against the magnitude falsifier's clashes. */
+    readonly evidence: AxisEvidence;
+    /**
+     * The axis's fires coincide with the independent falsifier's clashes more often than chance:
+     * `evidence.pValue < AUDIT_ALPHA` AND the association is positive (`a·d > b·c`; an axis whose
+     * fires avoid the clashes is not earned, however small its p). Reported beside
+     * `discriminates`; it changes no gate.
+     */
+    readonly earned: boolean;
 }
+/** The inputs of the magnitude gate an audit may override (a synthetic table for a test). @internal */
+export type AxisAuditOptions = Pick<DiscoveryOptions, 'representativeValues' | 'groundTruth' | 'maxOrdersOfMagnitude'>;
 /**
- * Audit every registry axis's discrimination over the discovery candidate funnel.
+ * Audit every registry axis's discrimination over the discovery candidate funnel, with Fisher
+ * evidence against the magnitude falsifier. The magnitude gate runs once per candidate from one
+ * discovery context (`buildDiscoveryContext`), not the whole funnel.
  *
  * @internal
  */
-export declare function auditAxisDiscrimination(edges: readonly BridgeEdge[], attributesByName?: ReadonlyMap<string, RegimeAttributes>, identifications?: readonly QuantityIdentification[]): AxisDiscrimination[];
+export declare function auditAxisDiscrimination(edges: readonly BridgeEdge[], attributesByName?: ReadonlyMap<string, RegimeAttributes>, identifications?: readonly QuantityIdentification[], options?: AxisAuditOptions): AxisDiscrimination[];
 //# sourceMappingURL=axis-audit.d.ts.map

package/dist/composition/axis-audit.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"axis-audit.d.ts","sourceRoot":"","sources":["../../src/composition/axis-audit.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;GAgBG;AACH,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,WAAW,CAAC;AAC5C,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,eAAe,CAAC;AACtD,OAAO,KAAK,EAAE,sBAAsB,EAAE,MAAM,cAAc,CAAC;AAM3D,+EAA+E;AAC/E,MAAM,WAAW,kBAAkB;IACjC,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,sDAAsD;IACtD,QAAQ,CAAC,KAAK,EAAE,OAAO,CAAC;IACxB,gEAAgE;IAChE,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;IACzB,wEAAwE;IACxE,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;IACvB,iFAAiF;IACjF,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC;IAC1B,mDAAmD;IACnD,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAC;IAC3B;;;OAGG;IACH,QAAQ,CAAC,aAAa,EAAE,OAAO,CAAC;CACjC;AAED;;;;GAIG;AACH,wBAAgB,uBAAuB,CACrC,KAAK,EAAE,SAAS,UAAU,EAAE,EAC5B,gBAAgB,GAAE,WAAW,CAAC,MAAM,EAAE,gBAAgB,CAA+B,EACrF,eAAe,GAAE,SAAS,sBAAsB,EAA6B,GAC5E,kBAAkB,EAAE,CAkCtB"}
+{"version":3,"file":"axis-audit.d.ts","sourceRoot":"","sources":["../../src/composition/axis-audit.ts"],"names":[],"mappings":"AAyBA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,WAAW,CAAC;AAC5C,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,eAAe,CAAC;AACtD,OAAO,KAAK,EAAE,sBAAsB,EAAE,MAAM,cAAc,CAAC;AAK3D,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,gBAAgB,CAAC;AAEvD;;;;;;;;GAQG;AACH,eAAO,MAAM,WAAW,OAAO,CAAC;AAEhC;;;;;GAKG;AACH,MAAM,WAAW,YAAY;IAC3B;;;OAGG;IACH,QAAQ,CAAC,KAAK,EAAE,SAAS,CAAC,SAAS,CAAC,MAAM,EAAE,MAAM,CAAC,EAAE,SAAS,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC,CAAC;IAChF,oGAAoG;IACpG,QAAQ,CAAC,SAAS,EAAE,MAAM,GAAG,IAAI,CAAC;IAClC,sFAAsF;IACtF,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;IACxB,2DAA2D;IAC3D,QAAQ,CAAC,CAAC,EAAE,MAAM,CAAC;CACpB;AAED,+EAA+E;AAC/E,MAAM,WAAW,kBAAkB;IACjC,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,sDAAsD;IACtD,QAAQ,CAAC,KAAK,EAAE,OAAO,CAAC;IACxB,gEAAgE;IAChE,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;IACzB,wEAAwE;IACxE,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;IACvB,iFAAiF;IACjF,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC;IAC1B,mDAAmD;IACnD,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAC;IAC3B;;;;OAIG;IACH,QAAQ,CAAC,aAAa,EAAE,OAAO,CAAC;IAChC,yFAAyF;IACzF,QAAQ,CAAC,QAAQ,EAAE,YAAY,CAAC;IAChC;;;;;OAKG;IACH,QAAQ,CAAC,MAAM,EAAE,OAAO,CAAC;CAC1B;AAED,uGAAuG;AACvG,MAAM,MAAM,gBAAgB,GAAG,IAAI,CAAC,gBAAgB,EAAE,sBAAsB,GAAG,aAAa,GAAG,sBAAsB,CAAC,CAAC;AAavH;;;;;;GAMG;AACH,wBAAgB,uBAAuB,CACrC,KAAK,EAAE,SAAS,UAAU,EAAE,EAC5B,gBAAgB,GAAE,WAAW,CAAC,MAAM,EAAE,gBAAgB,CAA+B,EACrF,eAAe,GAAE,SAAS,sBAAsB,EAA6B,EAC7E,OAAO,GAAE,gBAAqB,GAC7B,kBAAkB,EAAE,CAuDtB"}

package/dist/composition/axis-audit.js

@@ -1,31 +1,102 @@
+/**
+ * Axis-discrimination audit — the anti-inert-metadata gate for the extensible
+ * axis registry (`axes.ts`).
+ *
+ * A classification axis is only load-bearing when it actually SEPARATES real
+ * candidates. This audit runs the discovery link-candidate enumeration and, for
+ * EVERY registry axis (gated or not), measures how often the axis FIRES (both
+ * endpoints carry the attribute and they differ → an axis-clash), ABSTAINS (at
+ * least one endpoint lacks the attribute), and is CHECKED (both carry it).
+ *
+ * Beside the firing count, each axis carries EVIDENCE: Fisher's exact test (MathTS
+ * `fisherExact`) of its fires against the clashes of the INDEPENDENT magnitude falsifier
+ * (`discovery.ts`, `magnitudeGate`) over the candidates where both gates ran, and an `earned`
+ * flag at {@link AUDIT_ALPHA}. Firing is activity; agreeing with an independent falsifier more
+ * often than chance is evidence. The `discriminates` flag (fires > 0) is the registry's current
+ * criterion and is not changed by the evidence; `GATE_AXES` reads the registry, not this audit.
+ *
+ * Use: an axis stays `gated: false` in the registry until this audit shows it
+ * fires; an axis that only ever abstains is inert and must not be gated. As the
+ * catalog grows into new branches of physics, re-run this and flip the gates the
+ * measurement earns. Rank grows on evidence, not vision.
+ *
+ * @module composition/axis-audit
+ */
+import { fisherExact } from '@danielsimonjr/mathts-functions';
 import { AXES } from './axes.js';
 import { proposeLinkCandidates } from './bridge-analysis.js';
 import { effectiveAttributes, QUANTITY_IDENTIFICATIONS } from './compose.js';
-import { REGISTRY_ATTRIBUTES_BY_NAME } from './discovery.js';
+import { buildDiscoveryContext, magnitudeGate, REGISTRY_ATTRIBUTES_BY_NAME } from './discovery.js';
+/**
+ * The level at which an axis is `earned`: 0.05, the conventional two-sided level, fixed before
+ * any table was read. Six axes are audited at once, so a reader who wants a family-wise level
+ * divides by six (0.0083); the flag is per axis and says so here rather than hiding a
+ * correction. Small tables (about twenty magnitude clashes on the catalog) are why the test is
+ * exact and not a χ².
+ *
+ * @internal
+ */
+export const AUDIT_ALPHA = 0.05;
+/** The one Fisher call, read back for what MathTS returns: a number or `null` odds ratio, a number p. */
+function fisher(table) {
+    const r = fisherExact([[...table[0]], [...table[1]]]);
+    const oddsRatio = r.oddsRatio;
+    const pValue = r.pValue;
+    if (typeof pValue !== 'number' || !(pValue >= 0 && pValue <= 1)) {
+        throw new TypeError(`fisherExact returned p = ${String(pValue)} for ${JSON.stringify(table)}`);
+    }
+    return { oddsRatio: typeof oddsRatio === 'number' && Number.isFinite(oddsRatio) ? oddsRatio : null, pValue };
+}
 /**
- * Audit every registry axis's discrimination over the discovery candidate funnel.
+ * Audit every registry axis's discrimination over the discovery candidate funnel, with Fisher
+ * evidence against the magnitude falsifier. The magnitude gate runs once per candidate from one
+ * discovery context (`buildDiscoveryContext`), not the whole funnel.
  *
  * @internal
  */
-export function auditAxisDiscrimination(edges, attributesByName = REGISTRY_ATTRIBUTES_BY_NAME, identifications = QUANTITY_IDENTIFICATIONS) {
+export function auditAxisDiscrimination(edges, attributesByName = REGISTRY_ATTRIBUTES_BY_NAME, identifications = QUANTITY_IDENTIFICATIONS, options = {}) {
     const candidates = proposeLinkCandidates(edges);
+    const ctx = buildDiscoveryContext(edges, { ...options, identifications, quantityAttributes: attributesByName });
+    const magnitudes = candidates.map((c) => magnitudeGate(c, ctx));
     return AXES.map((spec) => {
         let checked = 0;
         let fires = 0;
         let abstains = 0;
-        for (const c of candidates) {
-            const attrsA = effectiveAttributes(c.a, attributesByName, identifications);
-            const attrsB = effectiveAttributes(c.b, attributesByName, identifications);
+        // The 2×2 table over candidates where both gates ran.
+        let a = 0; // fires ∧ clash
+        let b = 0; // fires ∧ no clash
+        let c = 0; // silent ∧ clash
+        let d = 0; // silent ∧ no clash
+        candidates.forEach((cand, i) => {
+            const attrsA = effectiveAttributes(cand.a, attributesByName, identifications);
+            const attrsB = effectiveAttributes(cand.b, attributesByName, identifications);
             const av = attrsA[spec.name];
             const bv = attrsB[spec.name];
             if (av === undefined || bv === undefined) {
                 abstains++;
-                continue;
+                return;
             }
             checked++;
-            if (av !== bv)
+            const fired = av !== bv;
+            if (fired)
                 fires++;
-        }
+            const gate = magnitudes[i];
+            if (!gate.checked)
+                return; // the falsifier abstained: no row for this candidate
+            if (fired && gate.clash)
+                a++;
+            else if (fired)
+                b++;
+            else if (gate.clash)
+                c++;
+            else
+                d++;
+        });
+        const table = [
+            [a, b],
+            [c, d],
+        ];
+        const { oddsRatio, pValue } = fisher(table);
         return {
             axis: spec.name,
             gated: spec.gated,
@@ -34,6 +105,8 @@ export function auditAxisDiscrimination(edges, attributesByName = REGISTRY_ATTRI
             abstains,
             clashRate: checked > 0 ? fires / checked : 0,
             discriminates: fires > 0,
+            evidence: { table, oddsRatio, pValue, n: a + b + c + d },
+            earned: pValue < AUDIT_ALPHA && a * d > b * c,
         };
     });
 }

package/dist/composition/axis-audit.js.map

@@ -1 +1 @@
-{"version":3,"file":"axis-audit.js","sourceRoot":"","sources":["../../src/composition/axis-audit.ts"],"names":[],"mappings":"AAoBA,OAAO,EAAE,IAAI,EAAE,MAAM,WAAW,CAAC;AACjC,OAAO,EAAE,qBAAqB,EAAE,MAAM,sBAAsB,CAAC;AAC7D,OAAO,EAAE,mBAAmB,EAAE,wBAAwB,EAAE,MAAM,cAAc,CAAC;AAC7E,OAAO,EAAE,2BAA2B,EAAE,MAAM,gBAAgB,CAAC;AAsB7D;;;;GAIG;AACH,MAAM,UAAU,uBAAuB,CACrC,KAA4B,EAC5B,gBAAgB,GAA0C,2BAA2B,EACrF,eAAe,GAAsC,wBAAwB;IAE7E,MAAM,UAAU,GAAG,qBAAqB,CAAC,KAAK,CAAC,CAAC;IAChD,OAAO,IAAI,CAAC,GAAG,CAAC,CAAC,IAAI,EAAE,EAAE;QACvB,IAAI,OAAO,GAAG,CAAC,CAAC;QAChB,IAAI,KAAK,GAAG,CAAC,CAAC;QACd,IAAI,QAAQ,GAAG,CAAC,CAAC;QACjB,KAAK,MAAM,CAAC,IAAI,UAAU,EAAE,CAAC;YAC3B,MAAM,MAAM,GAAG,mBAAmB,CAAC,CAAC,CAAC,CAAC,EAAE,gBAAgB,EAAE,eAAe,CAGxE,CAAC;YACF,MAAM,MAAM,GAAG,mBAAmB,CAAC,CAAC,CAAC,CAAC,EAAE,gBAAgB,EAAE,eAAe,CAGxE,CAAC;YACF,MAAM,EAAE,GAAG,MAAM,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;YAC7B,MAAM,EAAE,GAAG,MAAM,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;YAC7B,IAAI,EAAE,KAAK,SAAS,IAAI,EAAE,KAAK,SAAS,EAAE,CAAC;gBACzC,QAAQ,EAAE,CAAC;gBACX,SAAS;YACX,CAAC;YACD,OAAO,EAAE,CAAC;YACV,IAAI,EAAE,KAAK,EAAE;gBAAE,KAAK,EAAE,CAAC;QACzB,CAAC;QACD,OAAO;YACL,IAAI,EAAE,IAAI,CAAC,IAAI;YACf,KAAK,EAAE,IAAI,CAAC,KAAK;YACjB,OAAO;YACP,KAAK;YACL,QAAQ;YACR,SAAS,EAAE,OAAO,GAAG,CAAC,CAAC,CAAC,CAAC,KAAK,GAAG,OAAO,CAAC,CAAC,CAAC,CAAC;YAC5C,aAAa,EAAE,KAAK,GAAG,CAAC;SACzB,CAAC;IACJ,CAAC,CAAC,CAAC;AACL,CAAC","sourcesContent":["/**\n * Axis-discrimination audit — the anti-inert-metadata gate for the extensible\n * axis registry (`axes.ts`).\n *\n * A classification axis is only load-bearing when it actually SEPARATES real\n * candidates. This audit runs the discovery link-candidate enumeration and, for\n * EVERY registry axis (gated or not), measures how often the axis FIRES (both\n * endpoints carry the attribute and they differ → an axis-clash), ABSTAINS (at\n * least one endpoint lacks the attribute), and is CHECKED (both carry it).\n *\n * Use: an axis stays `gated: false` in the registry until this audit shows it\n * fires; an axis that only ever abstains is inert and must not be gated. As the\n * catalog grows into new branches of physics, re-run this and flip the gates the\n * measurement earns. Rank grows on evidence, not vision.\n *\n * @module composition/axis-audit\n */\nimport type { BridgeEdge } from './edge.js';\nimport type { RegimeAttributes } from './quantity.js';\nimport type { QuantityIdentification } from './compose.js';\nimport { AXES } from './axes.js';\nimport { proposeLinkCandidates } from './bridge-analysis.js';\nimport { effectiveAttributes, QUANTITY_IDENTIFICATIONS } from './compose.js';\nimport { REGISTRY_ATTRIBUTES_BY_NAME } from './discovery.js';\n\n/** Per-axis discrimination measurement over the candidate funnel. @internal */\nexport interface AxisDiscrimination {\n  readonly axis: string;\n  /** The registry's current gate flag for this axis. */\n  readonly gated: boolean;\n  /** Candidate pairs where BOTH endpoints carry the attribute. */\n  readonly checked: number;\n  /** Of the checked pairs, how many DIFFER (the axis fires → a clash). */\n  readonly fires: number;\n  /** Pairs where at least one endpoint lacks the attribute (the axis abstains). */\n  readonly abstains: number;\n  /** fires / checked (0 when nothing is checked). */\n  readonly clashRate: number;\n  /**\n   * A gate is EARNED when the axis fires at all. `false` here on an ungated axis\n   * = inert (do not gate); `false` on a gated axis = a regression to investigate.\n   */\n  readonly discriminates: boolean;\n}\n\n/**\n * Audit every registry axis's discrimination over the discovery candidate funnel.\n *\n * @internal\n */\nexport function auditAxisDiscrimination(\n  edges: readonly BridgeEdge[],\n  attributesByName: ReadonlyMap<string, RegimeAttributes> = REGISTRY_ATTRIBUTES_BY_NAME,\n  identifications: readonly QuantityIdentification[] = QUANTITY_IDENTIFICATIONS,\n): AxisDiscrimination[] {\n  const candidates = proposeLinkCandidates(edges);\n  return AXES.map((spec) => {\n    let checked = 0;\n    let fires = 0;\n    let abstains = 0;\n    for (const c of candidates) {\n      const attrsA = effectiveAttributes(c.a, attributesByName, identifications) as Record<\n        string,\n        string | undefined\n      >;\n      const attrsB = effectiveAttributes(c.b, attributesByName, identifications) as Record<\n        string,\n        string | undefined\n      >;\n      const av = attrsA[spec.name];\n      const bv = attrsB[spec.name];\n      if (av === undefined || bv === undefined) {\n        abstains++;\n        continue;\n      }\n      checked++;\n      if (av !== bv) fires++;\n    }\n    return {\n      axis: spec.name,\n      gated: spec.gated,\n      checked,\n      fires,\n      abstains,\n      clashRate: checked > 0 ? fires / checked : 0,\n      discriminates: fires > 0,\n    };\n  });\n}\n"]}
+{"version":3,"file":"axis-audit.js","sourceRoot":"","sources":["../../src/composition/axis-audit.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * Axis-discrimination audit — the anti-inert-metadata gate for the extensible\n * axis registry (`axes.ts`).\n *\n * A classification axis is only load-bearing when it actually SEPARATES real\n * candidates. This audit runs the discovery link-candidate enumeration and, for\n * EVERY registry axis (gated or not), measures how often the axis FIRES (both\n * endpoints carry the attribute and they differ → an axis-clash), ABSTAINS (at\n * least one endpoint lacks the attribute), and is CHECKED (both carry it).\n *\n * Beside the firing count, each axis carries EVIDENCE: Fisher's exact test (MathTS\n * `fisherExact`) of its fires against the clashes of the INDEPENDENT magnitude falsifier\n * (`discovery.ts`, `magnitudeGate`) over the candidates where both gates ran, and an `earned`\n * flag at {@link AUDIT_ALPHA}. Firing is activity; agreeing with an independent falsifier more\n * often than chance is evidence. The `discriminates` flag (fires > 0) is the registry's current\n * criterion and is not changed by the evidence; `GATE_AXES` reads the registry, not this audit.\n *\n * Use: an axis stays `gated: false` in the registry until this audit shows it\n * fires; an axis that only ever abstains is inert and must not be gated. As the\n * catalog grows into new branches of physics, re-run this and flip the gates the\n * measurement earns. Rank grows on evidence, not vision.\n *\n * @module composition/axis-audit\n */\nimport { fisherExact } from '@danielsimonjr/mathts-functions';\nimport type { BridgeEdge } from './edge.js';\nimport type { RegimeAttributes } from './quantity.js';\nimport type { QuantityIdentification } from './compose.js';\nimport { AXES } from './axes.js';\nimport { proposeLinkCandidates } from './bridge-analysis.js';\nimport { effectiveAttributes, QUANTITY_IDENTIFICATIONS } from './compose.js';\nimport { buildDiscoveryContext, magnitudeGate, REGISTRY_ATTRIBUTES_BY_NAME } from './discovery.js';\nimport type { DiscoveryOptions } from './discovery.js';\n\n/**\n * The level at which an axis is `earned`: 0.05, the conventional two-sided level, fixed before\n * any table was read. Six axes are audited at once, so a reader who wants a family-wise level\n * divides by six (0.0083); the flag is per axis and says so here rather than hiding a\n * correction. Small tables (about twenty magnitude clashes on the catalog) are why the test is\n * exact and not a χ².\n *\n * @internal\n */\nexport const AUDIT_ALPHA = 0.05;\n\n/**\n * Fisher's exact evidence of one axis against the magnitude falsifier, over the candidates\n * where BOTH gates ran (both endpoints carry the axis, and both have a magnitude).\n *\n * @internal\n */\nexport interface AxisEvidence {\n  /**\n   * `[[fires ∧ clash, fires ∧ no clash], [silent ∧ clash, silent ∧ no clash]]`: rows are the\n   * axis's verdict, columns the magnitude falsifier's.\n   */\n  readonly table: readonly [readonly [number, number], readonly [number, number]];\n  /** Sample odds ratio `ad/bc`, as MathTS reports it; `null` when a zero cell leaves it undefined. */\n  readonly oddsRatio: number | null;\n  /** Two-sided Fisher exact p; 1 when a margin is zero (only one table is possible). */\n  readonly pValue: number;\n  /** Candidates where both gates ran (the table's total). */\n  readonly n: number;\n}\n\n/** Per-axis discrimination measurement over the candidate funnel. @internal */\nexport interface AxisDiscrimination {\n  readonly axis: string;\n  /** The registry's current gate flag for this axis. */\n  readonly gated: boolean;\n  /** Candidate pairs where BOTH endpoints carry the attribute. */\n  readonly checked: number;\n  /** Of the checked pairs, how many DIFFER (the axis fires → a clash). */\n  readonly fires: number;\n  /** Pairs where at least one endpoint lacks the attribute (the axis abstains). */\n  readonly abstains: number;\n  /** fires / checked (0 when nothing is checked). */\n  readonly clashRate: number;\n  /**\n   * The registry's criterion: a gate is EARNED when the axis fires at all. `false` here on an\n   * ungated axis = inert (do not gate); `false` on a gated axis = a regression to investigate.\n   * Not changed by `evidence`.\n   */\n  readonly discriminates: boolean;\n  /** Fisher's exact test of the axis's fires against the magnitude falsifier's clashes. */\n  readonly evidence: AxisEvidence;\n  /**\n   * The axis's fires coincide with the independent falsifier's clashes more often than chance:\n   * `evidence.pValue < AUDIT_ALPHA` AND the association is positive (`a·d > b·c`; an axis whose\n   * fires avoid the clashes is not earned, however small its p). Reported beside\n   * `discriminates`; it changes no gate.\n   */\n  readonly earned: boolean;\n}\n\n/** The inputs of the magnitude gate an audit may override (a synthetic table for a test). @internal */\nexport type AxisAuditOptions = Pick<DiscoveryOptions, 'representativeValues' | 'groundTruth' | 'maxOrdersOfMagnitude'>;\n\n/** The one Fisher call, read back for what MathTS returns: a number or `null` odds ratio, a number p. */\nfunction fisher(table: AxisEvidence['table']): Pick<AxisEvidence, 'oddsRatio' | 'pValue'> {\n  const r = fisherExact([[...table[0]], [...table[1]]]);\n  const oddsRatio: unknown = r.oddsRatio;\n  const pValue: unknown = r.pValue;\n  if (typeof pValue !== 'number' || !(pValue >= 0 && pValue <= 1)) {\n    throw new TypeError(`fisherExact returned p = ${String(pValue)} for ${JSON.stringify(table)}`);\n  }\n  return { oddsRatio: typeof oddsRatio === 'number' && Number.isFinite(oddsRatio) ? oddsRatio : null, pValue };\n}\n\n/**\n * Audit every registry axis's discrimination over the discovery candidate funnel, with Fisher\n * evidence against the magnitude falsifier. The magnitude gate runs once per candidate from one\n * discovery context (`buildDiscoveryContext`), not the whole funnel.\n *\n * @internal\n */\nexport function auditAxisDiscrimination(\n  edges: readonly BridgeEdge[],\n  attributesByName: ReadonlyMap<string, RegimeAttributes> = REGISTRY_ATTRIBUTES_BY_NAME,\n  identifications: readonly QuantityIdentification[] = QUANTITY_IDENTIFICATIONS,\n  options: AxisAuditOptions = {},\n): AxisDiscrimination[] {\n  const candidates = proposeLinkCandidates(edges);\n  const ctx = buildDiscoveryContext(edges, { ...options, identifications, quantityAttributes: attributesByName });\n  const magnitudes = candidates.map((c) => magnitudeGate(c, ctx));\n  return AXES.map((spec) => {\n    let checked = 0;\n    let fires = 0;\n    let abstains = 0;\n    // The 2×2 table over candidates where both gates ran.\n    let a = 0; // fires ∧ clash\n    let b = 0; // fires ∧ no clash\n    let c = 0; // silent ∧ clash\n    let d = 0; // silent ∧ no clash\n    candidates.forEach((cand, i) => {\n      const attrsA = effectiveAttributes(cand.a, attributesByName, identifications) as Record<\n        string,\n        string | undefined\n      >;\n      const attrsB = effectiveAttributes(cand.b, attributesByName, identifications) as Record<\n        string,\n        string | undefined\n      >;\n      const av = attrsA[spec.name];\n      const bv = attrsB[spec.name];\n      if (av === undefined || bv === undefined) {\n        abstains++;\n        return;\n      }\n      checked++;\n      const fired = av !== bv;\n      if (fired) fires++;\n      const gate = magnitudes[i];\n      if (!gate.checked) return; // the falsifier abstained: no row for this candidate\n      if (fired && gate.clash) a++;\n      else if (fired) b++;\n      else if (gate.clash) c++;\n      else d++;\n    });\n    const table: AxisEvidence['table'] = [\n      [a, b],\n      [c, d],\n    ];\n    const { oddsRatio, pValue } = fisher(table);\n    return {\n      axis: spec.name,\n      gated: spec.gated,\n      checked,\n      fires,\n      abstains,\n      clashRate: checked > 0 ? fires / checked : 0,\n      discriminates: fires > 0,\n      evidence: { table, oddsRatio, pValue, n: a + b + c + d },\n      earned: pValue < AUDIT_ALPHA && a * d > b * c,\n    };\n  });\n}\n"]}

package/dist/composition/bridge-analysis.d.ts

@@ -30,6 +30,21 @@ import type { BridgeEdge } from './edge.js';
  * dimensionless statement (monomial or decoy); k = monomial × F(k ratios).
  */
 export declare function dimensionalFreedom(e: BridgeEdge): number;
+/**
+ * The exact form of a clean dimensionless prefactor, or `undefined` when
+ * the number is not one. A prefactor `r` is clean when `r = p / (π^a · ln2^b)`
+ * for `a ∈ −2..2`, `b ∈ −1..1` and a rational `p` with denominator at most
+ * 720, and numerator at most 720, that reproduces it to the relative 1e-9 the
+ * derivation fit uses; or
+ * when `r²` is, which names `√π`, `√(2π)` and their kin. The simplest
+ * `(a, b)` that fits is the one reported, so `2` is `2` and not `2π/π`.
+ * The rule replaces a list of seventeen constants matched at 1e-3; `9/8`
+ * (be-80) and `π/ln 2` (be-84) were not on it, and `π²/60`, the
+ * Stefan–Boltzmann closed form, is a hit under this rule.
+ *
+ * @internal
+ */
+export declare function cleanPrefactorForm(p: number): string | undefined;
 /**
  * The outcome of trying to derive a bridge dimensionally + verify it.
  * `not-a-monomial` means the encoded formula adds dimensionful terms, so a
@@ -43,6 +58,8 @@ interface DerivationResult {
     readonly prefactor?: number;
     /** True when derived AND the prefactor is a recognizable constant. */
     readonly cleanPrefactor?: boolean;
+    /** The exact form of a clean prefactor (`9/8`, `π/ln 2`); absent when it is not clean. */
+    readonly prefactorForm?: string;
 }
 /**
  * Attempt to derive a bridge: the first constant-subset that dimensionally

package/dist/composition/bridge-analysis.d.ts.map

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