universal-physics-tensor 10.0.0 → 12.0.0

package/dist/composition/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/composition/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AAGH,OAAO,EAAE,aAAa,EAAE,MAAM,eAAe,CAAC;AAG9C,iGAAiG;AACjG,OAAO,EACL,qBAAqB,EACrB,qBAAqB,EACrB,yBAAyB,EACzB,wBAAwB,EACxB,yBAAyB,EACzB,YAAY,GACb,MAAM,WAAW,CAAC;AACnB,oFAAoF;AACpF,OAAO,EACL,oBAAoB,EACpB,mBAAmB,EACnB,cAAc,EACd,iBAAiB,EACjB,mBAAmB,EACnB,iBAAiB,GAClB,MAAM,iCAAiC,CAAC;AAGzC,OAAO,EACL,YAAY,EACZ,aAAa,EACb,wBAAwB,EACxB,yBAAyB,GAC1B,MAAM,cAAc,CAAC;AAGtB,OAAO,EAAE,gBAAgB,EAAE,MAAM,kBAAkB,CAAC;AAEpD,OAAO,EAAE,QAAQ,EAAE,MAAM,sBAAsB,CAAC;AAChD,uDAAuD;AACvD,OAAO,EAAE,WAAW,EAAE,aAAa,EAAE,MAAM,oBAAoB,CAAC;AAEhE,OAAO,EACL,eAAe,EACf,gBAAgB,EAChB,mBAAmB,GACpB,MAAM,sBAAsB,CAAC;AAM9B,OAAO,EACL,qBAAqB,EACrB,0BAA0B,GAC3B,MAAM,gBAAgB,CAAC;AAGxB,OAAO,EAAE,oBAAoB,EAAE,MAAM,kBAAkB,CAAC;AAOxD,OAAO,EACL,uBAAuB,EACvB,WAAW,EACX,cAAc,GACf,MAAM,sBAAsB,CAAC;AAW9B,OAAO,EAAE,SAAS,EAAE,aAAa,EAAE,MAAM,mBAAmB,CAAC;AAO7D,OAAO,EAAE,eAAe,EAAE,MAAM,cAAc,CAAC;AAG/C,6HAA6H;AAC7H,OAAO,EAAE,gBAAgB,EAAE,MAAM,wBAAwB,CAAC;AAG1D,OAAO,EAAE,eAAe,EAAE,wBAAwB,EAAE,MAAM,uBAAuB,CAAC;AAClF,OAAO,EAAE,iBAAiB,EAAE,MAAM,gBAAgB,CAAC;AAUnD,OAAO,EAAE,aAAa,EAAE,cAAc,EAAE,MAAM,gBAAgB,CAAC;AAC/D,OAAO,EAAE,cAAc,EAAE,2BAA2B,EAAE,MAAM,oBAAoB,CAAC;AAEjF,OAAO,EAAE,kBAAkB,EAAE,MAAM,0BAA0B,CAAC;AAG9D,OAAO,EACL,iBAAiB,EACjB,iBAAiB,EACjB,kBAAkB,EAClB,eAAe,EACf,mBAAmB,EACnB,iBAAiB,GAClB,MAAM,oBAAoB,CAAC;AAC5B,0IAA0I;AAC1I,OAAO,EAAE,mBAAmB,EAAE,wBAAwB,EAAE,MAAM,iCAAiC,CAAC;AAChG,sEAAsE","sourcesContent":["/**\n * Composition graph (v0.8.0) — graph-lite `Quantity` / `BridgeEdge` /\n * `composeEdges()` beside the catalog (NOT replacing it; the catalog\n * in `src/bridges/index.ts` stays authoritative).\n *\n * See docs/planning/v0.8.0-Design.md for the design. The catalog edges are\n * projected from `data/bridge-catalog.json` by `./catalog-graph.js`; the\n * pre-registered CT-* composed ids are `REGISTERED_COMPOSITION_IDS` in\n * `./enumerate.js`.\n *\n * @module composition\n */\n\nexport type { Quantity, RegimeAttributes } from './quantity.js';\nexport { regimesDiffer } from './quantity.js';\n\nexport type { BridgeEdge, EdgeConfidence, ValidityDomain } from './edge.js';\n/** Edge evaluation and the errors it throws. An unset coefficient is `CoefficientUnsetError`. */\nexport {\n  CoefficientUnsetError,\n  CompositionAliasError,\n  CompositionDimensionError,\n  CompositionJunctionError,\n  UndefinedCompositionError,\n  evaluateEdge,\n} from './edge.js';\n/** The errors one evaluation throws: the input checks, then the validity domain. */\nexport {\n  DomainViolationError,\n  DuplicateInputError,\n  InputTypeError,\n  MissingInputError,\n  NonFiniteInputError,\n  UnknownInputError,\n} from '../bridges/evaluation-errors.js';\n\nexport type { ComposeOptions, QuantityIdentification } from './compose.js';\nexport {\n  composeEdges,\n  minConfidence,\n  QUANTITY_IDENTIFICATIONS,\n  SOURCE_ALIAS_DISPOSITIONS,\n} from './compose.js';\nexport type { AliasDisposition } from './compose.js';\n\nexport { consistencyRatio } from './consistency.js';\n\nexport { M_SUN_KG } from '../core/constants.js';\n/** The catalog graph and the edge for one graph id. */\nexport { catalogEdge, CATALOG_GRAPH } from './catalog-graph.js';\n\nexport {\n  CANONICAL_GRAPH,\n  canonicalToEdges,\n  CANONICAL_CONSTANTS,\n} from './canonical-graph.js';\n\nexport type {\n  CompositionCandidate,\n  EnumerationReport,\n} from './enumerate.js';\nexport {\n  enumerateCompositions,\n  REGISTERED_COMPOSITION_IDS,\n} from './enumerate.js';\n\nexport type { UncertaintyResult } from './uncertainty.js';\nexport { propagateUncertainty } from './uncertainty.js';\n\nexport type {\n  IdentifiabilityVerdict,\n  IdentifiabilityResult,\n  IdentifiabilityOptions,\n} from './identifiability.js';\nexport {\n  classifyIdentifiability,\n  classifyAll,\n  forwardClosure,\n} from './identifiability.js';\n\n/** The retrodiction harness's result, prediction, refusal, report and option types. */\nexport type {\n  RetrodictionOutcome,\n  RetrodictionPrediction,\n  RetrodictionResult,\n  RetrodictionRefusal,\n  RetrodictionReport,\n  RetrodictionOptions,\n} from './retrodiction.js';\nexport { retrodict, retrodictNode } from './retrodiction.js';\n\nexport type {\n  DerivationExplanation,\n  ExplainOptions,\n  QuantityExplanation,\n} from './explain.js';\nexport { explainQuantity } from './explain.js';\n/** The result of {@link evaluateRelation}. A value carries a dimension. An unset coefficient carries the formula. */\nexport type { Evaluation } from './evaluate-relation.js';\n/** Evaluate a catalog id or a canonical id. A sourced number is `kind: 'value'`. An unset coefficient is `kind: 'unset'`. */\nexport { evaluateRelation } from './evaluate-relation.js';\n\nexport type { Observable, ComposeSymbolicOptions } from './compose-symbolic.js';\nexport { composeSymbolic, SymbolicCompositionError } from './compose-symbolic.js';\nexport { SymbolicEvalError } from './expr-eval.js';\n\nexport type {\n  VizStatus,\n  VizJunction,\n  VizCluster,\n  VizOptions,\n  VizModel,\n  VizFilterStats,\n} from './graph-viz.js';\nexport { buildVizModel, edgeToJunction } from './graph-viz.js';\nexport { renderDotToSvg, SvgRendererUnavailableError } from './graph-viz-svg.js';\nexport type { DimensionAdjacency } from './dimension-adjacency.js';\nexport { dimensionAdjacency } from './dimension-adjacency.js';\nexport type { UserEquation, EquationLanding } from './user-equation.js';\nexport type { EquationAnalysis, EquationHint } from './user-equation.js';\nexport {\n  parseUserEquation,\n  suggestQuantities,\n  suggestByDimension,\n  equationLanding,\n  analyzeUserEquation,\n  UserEquationError,\n} from './user-equation.js';\n/** The catalog or parameter name a spelling means. Two spellings of one quantity that disagree throw {@link SynonymDisagreementError}. */\nexport { resolveQuantityName, SynonymDisagreementError } from '../dimensional/formula-names.js';\n// formatConnectedSummary stays internal — CLI reaches it via cli-api."]}
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/composition/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AAGH,OAAO,EAAE,aAAa,EAAE,MAAM,eAAe,CAAC;AAG9C,iGAAiG;AACjG,OAAO,EACL,qBAAqB,EACrB,qBAAqB,EACrB,yBAAyB,EACzB,wBAAwB,EACxB,yBAAyB,EACzB,YAAY,EACZ,cAAc,GACf,MAAM,WAAW,CAAC;AACnB,oFAAoF;AACpF,OAAO,EACL,oBAAoB,EACpB,mBAAmB,EACnB,cAAc,EACd,iBAAiB,EACjB,mBAAmB,EACnB,iBAAiB,GAClB,MAAM,iCAAiC,CAAC;AAKzC,OAAO,EACL,YAAY,EACZ,aAAa,EACb,wBAAwB,EACxB,yBAAyB,GAC1B,MAAM,cAAc,CAAC;AAGtB,OAAO,EAAE,gBAAgB,EAAE,MAAM,kBAAkB,CAAC;AAEpD,OAAO,EAAE,QAAQ,EAAE,MAAM,sBAAsB,CAAC;AAChD,uDAAuD;AACvD,OAAO,EAAE,WAAW,EAAE,aAAa,EAAE,MAAM,oBAAoB,CAAC;AAEhE,OAAO,EACL,eAAe,EACf,gBAAgB,EAChB,mBAAmB,GACpB,MAAM,sBAAsB,CAAC;AAM9B,OAAO,EACL,qBAAqB,EACrB,0BAA0B,GAC3B,MAAM,gBAAgB,CAAC;AAGxB,OAAO,EAAE,oBAAoB,EAAE,MAAM,kBAAkB,CAAC;AASxD,iHAAiH;AACjH,OAAO,EACL,uBAAuB,EACvB,WAAW,EACX,cAAc,EACd,qBAAqB,GACtB,MAAM,sBAAsB,CAAC;AAW9B,OAAO,EAAE,SAAS,EAAE,aAAa,EAAE,MAAM,mBAAmB,CAAC;AAO7D,OAAO,EAAE,eAAe,EAAE,MAAM,cAAc,CAAC;AAG/C,6HAA6H;AAC7H,OAAO,EAAE,gBAAgB,EAAE,MAAM,wBAAwB,CAAC;AAG1D,OAAO,EAAE,eAAe,EAAE,wBAAwB,EAAE,MAAM,uBAAuB,CAAC;AAClF,OAAO,EAAE,iBAAiB,EAAE,MAAM,gBAAgB,CAAC;AAUnD,OAAO,EAAE,aAAa,EAAE,cAAc,EAAE,MAAM,gBAAgB,CAAC;AAC/D,OAAO,EAAE,cAAc,EAAE,2BAA2B,EAAE,MAAM,oBAAoB,CAAC;AAEjF,OAAO,EAAE,kBAAkB,EAAE,MAAM,0BAA0B,CAAC;AAG9D,OAAO,EACL,iBAAiB,EACjB,iBAAiB,EACjB,kBAAkB,EAClB,eAAe,EACf,mBAAmB,EACnB,iBAAiB,GAClB,MAAM,oBAAoB,CAAC;AAC5B,0IAA0I;AAC1I,OAAO,EAAE,mBAAmB,EAAE,wBAAwB,EAAE,MAAM,iCAAiC,CAAC;AAChG,sEAAsE","sourcesContent":["/**\n * Composition graph (v0.8.0) — graph-lite `Quantity` / `BridgeEdge` /\n * `composeEdges()` beside the catalog (NOT replacing it; the catalog\n * in `src/bridges/index.ts` stays authoritative).\n *\n * See docs/planning/v0.8.0-Design.md for the design. The catalog edges are\n * projected from `data/bridge-catalog.json` by `./catalog-graph.js`; the\n * pre-registered CT-* composed ids are `REGISTERED_COMPOSITION_IDS` in\n * `./enumerate.js`.\n *\n * @module composition\n */\n\nexport type { Quantity, RegimeAttributes } from './quantity.js';\nexport { regimesDiffer } from './quantity.js';\n\nexport type { BridgeEdge, EdgeConfidence, ValidityDomain } from './edge.js';\n/** Edge evaluation and the errors it throws. An unset coefficient is `CoefficientUnsetError`. */\nexport {\n  CoefficientUnsetError,\n  CompositionAliasError,\n  CompositionDimensionError,\n  CompositionJunctionError,\n  UndefinedCompositionError,\n  evaluateEdge,\n  validityDomain,\n} from './edge.js';\n/** The errors one evaluation throws: the input checks, then the validity domain. */\nexport {\n  DomainViolationError,\n  DuplicateInputError,\n  InputTypeError,\n  MissingInputError,\n  NonFiniteInputError,\n  UnknownInputError,\n} from '../bridges/evaluation-errors.js';\n/** A failed validity condition and the inputs it read, as `DomainViolationError.violations` lists them. */\nexport type { DomainInput, DomainViolation } from '../bridges/evaluation-errors.js';\n\nexport type { ComposeOptions, QuantityIdentification } from './compose.js';\nexport {\n  composeEdges,\n  minConfidence,\n  QUANTITY_IDENTIFICATIONS,\n  SOURCE_ALIAS_DISPOSITIONS,\n} from './compose.js';\nexport type { AliasDisposition } from './compose.js';\n\nexport { consistencyRatio } from './consistency.js';\n\nexport { M_SUN_KG } from '../core/constants.js';\n/** The catalog graph and the edge for one graph id. */\nexport { catalogEdge, CATALOG_GRAPH } from './catalog-graph.js';\n\nexport {\n  CANONICAL_GRAPH,\n  canonicalToEdges,\n  CANONICAL_CONSTANTS,\n} from './canonical-graph.js';\n\nexport type {\n  CompositionCandidate,\n  EnumerationReport,\n} from './enumerate.js';\nexport {\n  enumerateCompositions,\n  REGISTERED_COMPOSITION_IDS,\n} from './enumerate.js';\n\nexport type { UncertaintyResult } from './uncertainty.js';\nexport { propagateUncertainty } from './uncertainty.js';\n\n/** The classifier's verdict, result and option types, and the rank instrument's report. */\nexport type {\n  IdentifiabilityVerdict,\n  IdentifiabilityResult,\n  IdentifiabilityOptions,\n  RankIdentifiability,\n} from './identifiability.js';\n/** The forward closure, the per-target classifier, the sweep, and the log-space rank over the monomial edges. */\nexport {\n  classifyIdentifiability,\n  classifyAll,\n  forwardClosure,\n  identifiabilityByRank,\n} from './identifiability.js';\n\n/** The retrodiction harness's result, prediction, refusal, report and option types. */\nexport type {\n  RetrodictionOutcome,\n  RetrodictionPrediction,\n  RetrodictionResult,\n  RetrodictionRefusal,\n  RetrodictionReport,\n  RetrodictionOptions,\n} from './retrodiction.js';\nexport { retrodict, retrodictNode } from './retrodiction.js';\n\nexport type {\n  DerivationExplanation,\n  ExplainOptions,\n  QuantityExplanation,\n} from './explain.js';\nexport { explainQuantity } from './explain.js';\n/** The result of {@link evaluateRelation}. A value carries a dimension. An unset coefficient carries the formula. */\nexport type { Evaluation, ExtraOutput } from './evaluate-relation.js';\n/** Evaluate a catalog id or a canonical id. A sourced number is `kind: 'value'`. An unset coefficient is `kind: 'unset'`. */\nexport { evaluateRelation } from './evaluate-relation.js';\n\nexport type { Observable, ComposeSymbolicOptions } from './compose-symbolic.js';\nexport { composeSymbolic, SymbolicCompositionError } from './compose-symbolic.js';\nexport { SymbolicEvalError } from './expr-eval.js';\n\nexport type {\n  VizStatus,\n  VizJunction,\n  VizCluster,\n  VizOptions,\n  VizModel,\n  VizFilterStats,\n} from './graph-viz.js';\nexport { buildVizModel, edgeToJunction } from './graph-viz.js';\nexport { renderDotToSvg, SvgRendererUnavailableError } from './graph-viz-svg.js';\nexport type { DimensionAdjacency } from './dimension-adjacency.js';\nexport { dimensionAdjacency } from './dimension-adjacency.js';\nexport type { UserEquation, EquationLanding } from './user-equation.js';\nexport type { EquationAnalysis, EquationHint } from './user-equation.js';\nexport {\n  parseUserEquation,\n  suggestQuantities,\n  suggestByDimension,\n  equationLanding,\n  analyzeUserEquation,\n  UserEquationError,\n} from './user-equation.js';\n/** The catalog or parameter name a spelling means. Two spellings of one quantity that disagree throw {@link SynonymDisagreementError}. */\nexport { resolveQuantityName, SynonymDisagreementError } from '../dimensional/formula-names.js';\n// formatConnectedSummary stays internal — CLI reaches it via cli-api."]}

package/dist/composition/mathts-quiet.d.ts

@@ -1,21 +1,22 @@
 /**
- * Load the MathTS peer without its console chatter reaching stderr.
+ * Load the MathTS dependency without its console chatter reaching stderr.
  *
  * MathTS writes with `console.warn`/`console.error` directly (its `warnOnce`,
  * the factorisation fallbacks, the WASM-integrity notice) and offers no option
  * to route or silence them: `ImportOptions.silent` is for importing user
  * functions, not for logging. The only way to keep that text out of a CLI's
  * stderr is to replace the three process-global sinks for the duration of the
- * call, which is what the two helpers here do, and nothing else in `src/` may
+ * call, which is what the helper here does, and nothing else in `src/` may
  * do.
  *
  * THE INVARIANT: the replacement is process-global, so a concurrent caller in
  * the same process (a worker pool thread, a vitest worker sharing a process)
  * loses its console for the window. The window is therefore confined to the
- * peer's ONE-TIME load and first-use smoke in `expr-simplify.ts` and
- * `mathts-scalar-symbols.ts`: both cache the loaded module, so the sinks are
- * replaced once per process, and never around a per-call parse or simplify.
- * Both helpers restore the sinks in `finally`, so a throw inside the window
+ * dependency's ONE-TIME load and first-use smoke in `expr-simplify.ts`,
+ * `mathts-scalar-symbols.ts` and `algebraic-equivalence.ts`: each caches the
+ * loaded function, so the sinks are replaced once per process, and never
+ * around a per-call parse or simplify.
+ * The helper restores the sinks in `finally`, so a throw inside the window
  * cannot leave them replaced. `tests/composition/mathts-quiet.test.ts` scans
  * `src/` for any other reassignment and traps the sinks during a call.
  *
@@ -23,6 +24,4 @@
  */
 /** Run `fn` with the console sinks replaced, restoring them in `finally`. @internal */
 export declare function quietlySync<T>(fn: () => T): T;
-/** The asynchronous form of {@link quietlySync}: the window spans the awaited promise. @internal */
-export declare function quietly<T>(fn: () => Promise<T>): Promise<T>;
 //# sourceMappingURL=mathts-quiet.d.ts.map

package/dist/composition/mathts-quiet.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"mathts-quiet.d.ts","sourceRoot":"","sources":["../../src/composition/mathts-quiet.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;GAsBG;AAsBH,uFAAuF;AACvF,wBAAgB,WAAW,CAAC,CAAC,EAAE,EAAE,EAAE,MAAM,CAAC,GAAG,CAAC,CAO7C;AAED,oGAAoG;AACpG,wBAAsB,OAAO,CAAC,CAAC,EAAE,EAAE,EAAE,MAAM,OAAO,CAAC,CAAC,CAAC,GAAG,OAAO,CAAC,CAAC,CAAC,CAOjE"}
+{"version":3,"file":"mathts-quiet.d.ts","sourceRoot":"","sources":["../../src/composition/mathts-quiet.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AAsBH,uFAAuF;AACvF,wBAAgB,WAAW,CAAC,CAAC,EAAE,EAAE,EAAE,MAAM,CAAC,GAAG,CAAC,CAO7C"}

package/dist/composition/mathts-quiet.js

@@ -1,21 +1,22 @@
 /**
- * Load the MathTS peer without its console chatter reaching stderr.
+ * Load the MathTS dependency without its console chatter reaching stderr.
  *
  * MathTS writes with `console.warn`/`console.error` directly (its `warnOnce`,
  * the factorisation fallbacks, the WASM-integrity notice) and offers no option
  * to route or silence them: `ImportOptions.silent` is for importing user
  * functions, not for logging. The only way to keep that text out of a CLI's
  * stderr is to replace the three process-global sinks for the duration of the
- * call, which is what the two helpers here do, and nothing else in `src/` may
+ * call, which is what the helper here does, and nothing else in `src/` may
  * do.
  *
  * THE INVARIANT: the replacement is process-global, so a concurrent caller in
  * the same process (a worker pool thread, a vitest worker sharing a process)
  * loses its console for the window. The window is therefore confined to the
- * peer's ONE-TIME load and first-use smoke in `expr-simplify.ts` and
- * `mathts-scalar-symbols.ts`: both cache the loaded module, so the sinks are
- * replaced once per process, and never around a per-call parse or simplify.
- * Both helpers restore the sinks in `finally`, so a throw inside the window
+ * dependency's ONE-TIME load and first-use smoke in `expr-simplify.ts`,
+ * `mathts-scalar-symbols.ts` and `algebraic-equivalence.ts`: each caches the
+ * loaded function, so the sinks are replaced once per process, and never
+ * around a per-call parse or simplify.
+ * The helper restores the sinks in `finally`, so a throw inside the window
  * cannot leave them replaced. `tests/composition/mathts-quiet.test.ts` scans
  * `src/` for any other reassignment and traps the sinks during a call.
  *
@@ -43,14 +44,4 @@ export function quietlySync(fn) {
         restore(saved);
     }
 }
-/** The asynchronous form of {@link quietlySync}: the window spans the awaited promise. @internal */
-export async function quietly(fn) {
-    const saved = silence();
-    try {
-        return await fn();
-    }
-    finally {
-        restore(saved);
-    }
-}
 //# sourceMappingURL=mathts-quiet.js.map

package/dist/composition/mathts-quiet.js.map

@@ -1 +1 @@
-{"version":3,"file":"mathts-quiet.js","sourceRoot":"","sources":["../../src/composition/mathts-quiet.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;GAsBG;AAQH,SAAS,OAAO;IACd,MAAM,KAAK,GAAU,EAAE,IAAI,EAAE,OAAO,CAAC,IAAI,EAAE,KAAK,EAAE,OAAO,CAAC,KAAK,EAAE,KAAK,EAAE,OAAO,CAAC,MAAM,CAAC,KAAK,EAAE,CAAC;IAC/F,OAAO,CAAC,IAAI,GAAG,GAAG,EAAE,GAAE,CAAC,CAAC;IACxB,OAAO,CAAC,KAAK,GAAG,GAAG,EAAE,GAAE,CAAC,CAAC;IACxB,OAAO,CAAC,MAA6B,CAAC,KAAK,GAAG,GAAG,EAAE,CAAC,IAAI,CAAC;IAC1D,OAAO,KAAK,CAAC;AACf,CAAC;AAED,SAAS,OAAO,CAAC,KAAY;IAC3B,OAAO,CAAC,IAAI,GAAG,KAAK,CAAC,IAAI,CAAC;IAC1B,OAAO,CAAC,KAAK,GAAG,KAAK,CAAC,KAAK,CAAC;IAC3B,OAAO,CAAC,MAA6B,CAAC,KAAK,GAAG,KAAK,CAAC,KAAK,CAAC;AAC7D,CAAC;AAED,uFAAuF;AACvF,MAAM,UAAU,WAAW,CAAI,EAAW;IACxC,MAAM,KAAK,GAAG,OAAO,EAAE,CAAC;IACxB,IAAI,CAAC;QACH,OAAO,EAAE,EAAE,CAAC;IACd,CAAC;YAAS,CAAC;QACT,OAAO,CAAC,KAAK,CAAC,CAAC;IACjB,CAAC;AACH,CAAC;AAED,oGAAoG;AACpG,MAAM,CAAC,KAAK,UAAU,OAAO,CAAI,EAAoB;IACnD,MAAM,KAAK,GAAG,OAAO,EAAE,CAAC;IACxB,IAAI,CAAC;QACH,OAAO,MAAM,EAAE,EAAE,CAAC;IACpB,CAAC;YAAS,CAAC;QACT,OAAO,CAAC,KAAK,CAAC,CAAC;IACjB,CAAC;AACH,CAAC","sourcesContent":["/**\n * Load the MathTS peer without its console chatter reaching stderr.\n *\n * MathTS writes with `console.warn`/`console.error` directly (its `warnOnce`,\n * the factorisation fallbacks, the WASM-integrity notice) and offers no option\n * to route or silence them: `ImportOptions.silent` is for importing user\n * functions, not for logging. The only way to keep that text out of a CLI's\n * stderr is to replace the three process-global sinks for the duration of the\n * call, which is what the two helpers here do, and nothing else in `src/` may\n * do.\n *\n * THE INVARIANT: the replacement is process-global, so a concurrent caller in\n * the same process (a worker pool thread, a vitest worker sharing a process)\n * loses its console for the window. The window is therefore confined to the\n * peer's ONE-TIME load and first-use smoke in `expr-simplify.ts` and\n * `mathts-scalar-symbols.ts`: both cache the loaded module, so the sinks are\n * replaced once per process, and never around a per-call parse or simplify.\n * Both helpers restore the sinks in `finally`, so a throw inside the window\n * cannot leave them replaced. `tests/composition/mathts-quiet.test.ts` scans\n * `src/` for any other reassignment and traps the sinks during a call.\n *\n * @module composition/mathts-quiet\n */\n\ntype Sinks = {\n  readonly warn: typeof console.warn;\n  readonly error: typeof console.error;\n  readonly write: typeof process.stderr.write;\n};\n\nfunction silence(): Sinks {\n  const saved: Sinks = { warn: console.warn, error: console.error, write: process.stderr.write };\n  console.warn = () => {};\n  console.error = () => {};\n  (process.stderr as { write: unknown }).write = () => true;\n  return saved;\n}\n\nfunction restore(saved: Sinks): void {\n  console.warn = saved.warn;\n  console.error = saved.error;\n  (process.stderr as { write: unknown }).write = saved.write;\n}\n\n/** Run `fn` with the console sinks replaced, restoring them in `finally`. @internal */\nexport function quietlySync<T>(fn: () => T): T {\n  const saved = silence();\n  try {\n    return fn();\n  } finally {\n    restore(saved);\n  }\n}\n\n/** The asynchronous form of {@link quietlySync}: the window spans the awaited promise. @internal */\nexport async function quietly<T>(fn: () => Promise<T>): Promise<T> {\n  const saved = silence();\n  try {\n    return await fn();\n  } finally {\n    restore(saved);\n  }\n}\n"]}
+{"version":3,"file":"mathts-quiet.js","sourceRoot":"","sources":["../../src/composition/mathts-quiet.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AAQH,SAAS,OAAO;IACd,MAAM,KAAK,GAAU,EAAE,IAAI,EAAE,OAAO,CAAC,IAAI,EAAE,KAAK,EAAE,OAAO,CAAC,KAAK,EAAE,KAAK,EAAE,OAAO,CAAC,MAAM,CAAC,KAAK,EAAE,CAAC;IAC/F,OAAO,CAAC,IAAI,GAAG,GAAG,EAAE,GAAE,CAAC,CAAC;IACxB,OAAO,CAAC,KAAK,GAAG,GAAG,EAAE,GAAE,CAAC,CAAC;IACxB,OAAO,CAAC,MAA6B,CAAC,KAAK,GAAG,GAAG,EAAE,CAAC,IAAI,CAAC;IAC1D,OAAO,KAAK,CAAC;AACf,CAAC;AAED,SAAS,OAAO,CAAC,KAAY;IAC3B,OAAO,CAAC,IAAI,GAAG,KAAK,CAAC,IAAI,CAAC;IAC1B,OAAO,CAAC,KAAK,GAAG,KAAK,CAAC,KAAK,CAAC;IAC3B,OAAO,CAAC,MAA6B,CAAC,KAAK,GAAG,KAAK,CAAC,KAAK,CAAC;AAC7D,CAAC;AAED,uFAAuF;AACvF,MAAM,UAAU,WAAW,CAAI,EAAW;IACxC,MAAM,KAAK,GAAG,OAAO,EAAE,CAAC;IACxB,IAAI,CAAC;QACH,OAAO,EAAE,EAAE,CAAC;IACd,CAAC;YAAS,CAAC;QACT,OAAO,CAAC,KAAK,CAAC,CAAC;IACjB,CAAC;AACH,CAAC","sourcesContent":["/**\n * Load the MathTS dependency without its console chatter reaching stderr.\n *\n * MathTS writes with `console.warn`/`console.error` directly (its `warnOnce`,\n * the factorisation fallbacks, the WASM-integrity notice) and offers no option\n * to route or silence them: `ImportOptions.silent` is for importing user\n * functions, not for logging. The only way to keep that text out of a CLI's\n * stderr is to replace the three process-global sinks for the duration of the\n * call, which is what the helper here does, and nothing else in `src/` may\n * do.\n *\n * THE INVARIANT: the replacement is process-global, so a concurrent caller in\n * the same process (a worker pool thread, a vitest worker sharing a process)\n * loses its console for the window. The window is therefore confined to the\n * dependency's ONE-TIME load and first-use smoke in `expr-simplify.ts`,\n * `mathts-scalar-symbols.ts` and `algebraic-equivalence.ts`: each caches the\n * loaded function, so the sinks are replaced once per process, and never\n * around a per-call parse or simplify.\n * The helper restores the sinks in `finally`, so a throw inside the window\n * cannot leave them replaced. `tests/composition/mathts-quiet.test.ts` scans\n * `src/` for any other reassignment and traps the sinks during a call.\n *\n * @module composition/mathts-quiet\n */\n\ntype Sinks = {\n  readonly warn: typeof console.warn;\n  readonly error: typeof console.error;\n  readonly write: typeof process.stderr.write;\n};\n\nfunction silence(): Sinks {\n  const saved: Sinks = { warn: console.warn, error: console.error, write: process.stderr.write };\n  console.warn = () => {};\n  console.error = () => {};\n  (process.stderr as { write: unknown }).write = () => true;\n  return saved;\n}\n\nfunction restore(saved: Sinks): void {\n  console.warn = saved.warn;\n  console.error = saved.error;\n  (process.stderr as { write: unknown }).write = saved.write;\n}\n\n/** Run `fn` with the console sinks replaced, restoring them in `finally`. @internal */\nexport function quietlySync<T>(fn: () => T): T {\n  const saved = silence();\n  try {\n    return fn();\n  } finally {\n    restore(saved);\n  }\n}\n"]}

package/dist/composition/mathts-scalar-symbols.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"mathts-scalar-symbols.d.ts","sourceRoot":"","sources":["../../src/composition/mathts-scalar-symbols.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;GAaG;AAIH,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,6BAA6B,CAAC;AAC5D,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,yBAAyB,CAAC;AAEzD,yEAAyE;AACzE,MAAM,WAAW,YAAY;IAC3B,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,GAAG,EAAE,SAAS,CAAC;CACzB;AAED,UAAU,QAAQ;IAChB,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,GAAG,EAAE,SAAS,CAAC;CACzB;AAeD;;;;;;GAMG;AACH,wBAAgB,gBAAgB,CAC9B,IAAI,EAAE;IAAE,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IAAC,QAAQ,CAAC,GAAG,EAAE,SAAS,CAAA;CAAE,EACxD,QAAQ,EAAE,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,EAC7B,IAAI,EAAE,GAAG,CAAC,MAAM,EAAE,QAAQ,CAAC,GAC1B,MAAM,CASR;AAsFD;;;;;;;;GAQG;AACH,wBAAgB,uBAAuB,CAAC,IAAI,EAAE,QAAQ,GAAG,YAAY,EAAE,CAetE"}
+{"version":3,"file":"mathts-scalar-symbols.d.ts","sourceRoot":"","sources":["../../src/composition/mathts-scalar-symbols.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;GAaG;AAKH,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,6BAA6B,CAAC;AAC5D,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,yBAAyB,CAAC;AAEzD,yEAAyE;AACzE,MAAM,WAAW,YAAY;IAC3B,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,GAAG,EAAE,SAAS,CAAC;CACzB;AAED,UAAU,QAAQ;IAChB,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,GAAG,EAAE,SAAS,CAAC;CACzB;AAeD;;;;;;GAMG;AACH,wBAAgB,gBAAgB,CAC9B,IAAI,EAAE;IAAE,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IAAC,QAAQ,CAAC,GAAG,EAAE,SAAS,CAAA;CAAE,EACxD,QAAQ,EAAE,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,EAC7B,IAAI,EAAE,GAAG,CAAC,MAAM,EAAE,QAAQ,CAAC,GAC1B,MAAM,CASR;AAsFD;;;;;;;;GAQG;AACH,wBAAgB,uBAAuB,CAAC,IAAI,EAAE,QAAQ,GAAG,YAAY,EAAE,CAetE"}

package/dist/composition/mathts-scalar-symbols.js

@@ -14,7 +14,8 @@
  */
 import { parse as mathtsParse } from '@danielsimonjr/mathts-functions';
 import { quietlySync } from './mathts-quiet.js';
-const isLiteral = (name) => Number.isFinite(Number(name));
+import { isDecimalLiteral } from '../dimensional/ast-leaves.js';
+const isLiteral = isDecimalLiteral;
 /**
  * Render one symbol the way `expr-simplify.ts` does: a numeric literal stays
  * a number, and every other name becomes `gN`. Repeated names share one

package/dist/composition/mathts-scalar-symbols.js.map

@@ -1 +1 @@
-{"version":3,"file":"mathts-scalar-symbols.js","sourceRoot":"","sources":["../../src/composition/mathts-scalar-symbols.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * Scalar leaves of an `ExprNode`, read from a MathTS AST.\n *\n * `governingOf` and the free-leaf list in `compose-symbolic.ts` both call\n * {@link scalarSymbolsFromMathTs}. The names come from that node's symbol\n * filter. This module does not walk `ExprNode` to collect them.\n *\n * The rendered text uses the same gensym as `expr-simplify.ts`: a bare `e`\n * is `gN`, never the identifier MathTS reads as Euler's number. Mapped back,\n * the name is the elementary charge. `exp(1)` does not introduce `e`.\n * Tensor and curvature kinds contribute no symbol.\n *\n * @module composition/mathts-scalar-symbols\n */\n\nimport { parse as mathtsParse } from '@danielsimonjr/mathts-functions';\nimport { quietlySync } from './mathts-quiet.js';\nimport type { ExprNode } from '../dimensional/validator.js';\nimport type { Dimension } from '../dimensional/types.js';\n\n/** One scalar leaf and the dimension stored on that symbol. @internal */\nexport interface ScalarSymbol {\n  readonly name: string;\n  readonly dim: Dimension;\n}\n\ninterface LeafMeta {\n  readonly name: string;\n  readonly dim: Dimension;\n}\n\n/** The bits of a MathTS node this reader uses. */\ninterface MathNode {\n  filter(predicate: (node: MathNode) => boolean): MathNode[];\n  readonly isSymbolNode?: boolean;\n  readonly name?: string;\n}\n\ninterface MathtsFunctionsModule {\n  parse(expr: string): MathNode;\n}\n\nconst isLiteral = (name: string): boolean => Number.isFinite(Number(name));\n\n/**\n * Render one symbol the way `expr-simplify.ts` does: a numeric literal stays\n * a number, and every other name becomes `gN`. Repeated names share one\n * gensym, so MathTS never sees the physics spelling of `e`.\n *\n * @internal\n */\nexport function renderScalarLeaf(\n  expr: { readonly name: string; readonly dim: Dimension },\n  gensymOf: Map<string, string>,\n  meta: Map<string, LeafMeta>,\n): string {\n  if (isLiteral(expr.name)) return String(Number(expr.name));\n  let g = gensymOf.get(expr.name);\n  if (g === undefined) {\n    g = `g${gensymOf.size}`;\n    gensymOf.set(expr.name, g);\n    meta.set(g, { name: expr.name, dim: expr.dim });\n  }\n  return g;\n}\n\n/**\n * A MathTS expression whose symbol nodes are the scalar leaves.\n * Integral bounds are omitted: the previous leaf list did not include them.\n * A curvature or tensor kind returns null.\n */\nfunction renderSymbolQuery(\n  expr: ExprNode,\n  gensymOf: Map<string, string>,\n  meta: Map<string, LeafMeta>,\n): string | null {\n  switch (expr.kind) {\n    case 'symbol':\n      return renderScalarLeaf(expr, gensymOf, meta);\n    case 'op': {\n      const parts: string[] = [];\n      for (const arg of expr.args) {\n        const part = renderSymbolQuery(arg, gensymOf, meta);\n        if (part !== null) parts.push(part);\n      }\n      return joinParts(parts, expr.op);\n    }\n    case 'transcendental':\n    case 'abs':\n    case 'dirac-delta':\n      return renderSymbolQuery(expr.arg, gensymOf, meta);\n    case 'integral':\n      return joinParts(\n        [\n          renderSymbolQuery(expr.over, gensymOf, meta),\n          renderSymbolQuery(expr.integrand, gensymOf, meta),\n        ].filter((part): part is string => part !== null),\n        '+',\n      );\n    case 'derivative':\n      return joinParts(\n        [\n          renderSymbolQuery(expr.of, gensymOf, meta),\n          renderSymbolQuery(expr.wrt, gensymOf, meta),\n        ].filter((part): part is string => part !== null),\n        '+',\n      );\n    case 'variational-derivative':\n      return joinParts(\n        [\n          renderSymbolQuery(expr.functional, gensymOf, meta),\n          renderSymbolQuery(expr.field, gensymOf, meta),\n          renderSymbolQuery(expr.over, gensymOf, meta),\n        ].filter((part): part is string => part !== null),\n        '+',\n      );\n    default:\n      return null;\n  }\n}\n\nfunction joinParts(parts: readonly string[], op: string): string | null {\n  if (parts.length === 0) return null;\n  if (parts.length === 1) return parts[0] ?? null;\n  return `(${parts.map((part) => `(${part})`).join(op)})`;\n}\n\nlet cachedParse: MathtsFunctionsModule['parse'] | undefined;\n\n/**\n * `parse`, bound once. The package is a required dependency and `quadrature.ts`\n * already imports it statically, so this module imports it the same way (a\n * `createRequire` of the ESM package once stood here, which needs Node 22.12 or\n * 20.19 while `engines` says 18; Tom's second round). The first parse runs\n * inside the one console-silencing window this module opens (`mathts-quiet.ts`\n * states the invariant): the peer's WASM-fallback chatter fires lazily on first\n * use, so the smoke parse is that first use, and every later parse runs with the\n * console untouched.\n */\nfunction mathTsParse(): MathtsFunctionsModule['parse'] {\n  if (cachedParse !== undefined) return cachedParse;\n  const parse = quietlySync(() => {\n    const bound = (mathtsParse as MathtsFunctionsModule['parse']).bind(undefined);\n    bound('g0');\n    return bound;\n  });\n  cachedParse = parse;\n  return cachedParse;\n}\n\n/**\n * Distinct scalar leaves of `expr`, in first-seen order.\n *\n * The MathTS symbol filter supplies the names. A gensym that this renderer\n * did not issue is dropped, so a function callee such as `exp` is not a leaf.\n * Tensor and curvature kinds return an empty list.\n *\n * @internal\n */\nexport function scalarSymbolsFromMathTs(expr: ExprNode): ScalarSymbol[] {\n  const gensymOf = new Map<string, string>();\n  const meta = new Map<string, LeafMeta>();\n  const rendered = renderSymbolQuery(expr, gensymOf, meta);\n  if (rendered === null) return [];\n  const node = mathTsParse()(rendered);\n  const seen = new Set<string>();\n  const leaves: ScalarSymbol[] = [];\n  for (const symbol of node.filter((candidate) => candidate.isSymbolNode === true)) {\n    const issued = symbol.name !== undefined ? meta.get(symbol.name) : undefined;\n    if (issued === undefined || seen.has(issued.name)) continue;\n    seen.add(issued.name);\n    leaves.push(issued);\n  }\n  return leaves;\n}\n"]}
+{"version":3,"file":"mathts-scalar-symbols.js","sourceRoot":"","sources":["../../src/composition/mathts-scalar-symbols.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * Scalar leaves of an `ExprNode`, read from a MathTS AST.\n *\n * `governingOf` and the free-leaf list in `compose-symbolic.ts` both call\n * {@link scalarSymbolsFromMathTs}. The names come from that node's symbol\n * filter. This module does not walk `ExprNode` to collect them.\n *\n * The rendered text uses the same gensym as `expr-simplify.ts`: a bare `e`\n * is `gN`, never the identifier MathTS reads as Euler's number. Mapped back,\n * the name is the elementary charge. `exp(1)` does not introduce `e`.\n * Tensor and curvature kinds contribute no symbol.\n *\n * @module composition/mathts-scalar-symbols\n */\n\nimport { parse as mathtsParse } from '@danielsimonjr/mathts-functions';\nimport { quietlySync } from './mathts-quiet.js';\nimport { isDecimalLiteral } from '../dimensional/ast-leaves.js';\nimport type { ExprNode } from '../dimensional/validator.js';\nimport type { Dimension } from '../dimensional/types.js';\n\n/** One scalar leaf and the dimension stored on that symbol. @internal */\nexport interface ScalarSymbol {\n  readonly name: string;\n  readonly dim: Dimension;\n}\n\ninterface LeafMeta {\n  readonly name: string;\n  readonly dim: Dimension;\n}\n\n/** The bits of a MathTS node this reader uses. */\ninterface MathNode {\n  filter(predicate: (node: MathNode) => boolean): MathNode[];\n  readonly isSymbolNode?: boolean;\n  readonly name?: string;\n}\n\ninterface MathtsFunctionsModule {\n  parse(expr: string): MathNode;\n}\n\nconst isLiteral = isDecimalLiteral;\n\n/**\n * Render one symbol the way `expr-simplify.ts` does: a numeric literal stays\n * a number, and every other name becomes `gN`. Repeated names share one\n * gensym, so MathTS never sees the physics spelling of `e`.\n *\n * @internal\n */\nexport function renderScalarLeaf(\n  expr: { readonly name: string; readonly dim: Dimension },\n  gensymOf: Map<string, string>,\n  meta: Map<string, LeafMeta>,\n): string {\n  if (isLiteral(expr.name)) return String(Number(expr.name));\n  let g = gensymOf.get(expr.name);\n  if (g === undefined) {\n    g = `g${gensymOf.size}`;\n    gensymOf.set(expr.name, g);\n    meta.set(g, { name: expr.name, dim: expr.dim });\n  }\n  return g;\n}\n\n/**\n * A MathTS expression whose symbol nodes are the scalar leaves.\n * Integral bounds are omitted: the previous leaf list did not include them.\n * A curvature or tensor kind returns null.\n */\nfunction renderSymbolQuery(\n  expr: ExprNode,\n  gensymOf: Map<string, string>,\n  meta: Map<string, LeafMeta>,\n): string | null {\n  switch (expr.kind) {\n    case 'symbol':\n      return renderScalarLeaf(expr, gensymOf, meta);\n    case 'op': {\n      const parts: string[] = [];\n      for (const arg of expr.args) {\n        const part = renderSymbolQuery(arg, gensymOf, meta);\n        if (part !== null) parts.push(part);\n      }\n      return joinParts(parts, expr.op);\n    }\n    case 'transcendental':\n    case 'abs':\n    case 'dirac-delta':\n      return renderSymbolQuery(expr.arg, gensymOf, meta);\n    case 'integral':\n      return joinParts(\n        [\n          renderSymbolQuery(expr.over, gensymOf, meta),\n          renderSymbolQuery(expr.integrand, gensymOf, meta),\n        ].filter((part): part is string => part !== null),\n        '+',\n      );\n    case 'derivative':\n      return joinParts(\n        [\n          renderSymbolQuery(expr.of, gensymOf, meta),\n          renderSymbolQuery(expr.wrt, gensymOf, meta),\n        ].filter((part): part is string => part !== null),\n        '+',\n      );\n    case 'variational-derivative':\n      return joinParts(\n        [\n          renderSymbolQuery(expr.functional, gensymOf, meta),\n          renderSymbolQuery(expr.field, gensymOf, meta),\n          renderSymbolQuery(expr.over, gensymOf, meta),\n        ].filter((part): part is string => part !== null),\n        '+',\n      );\n    default:\n      return null;\n  }\n}\n\nfunction joinParts(parts: readonly string[], op: string): string | null {\n  if (parts.length === 0) return null;\n  if (parts.length === 1) return parts[0] ?? null;\n  return `(${parts.map((part) => `(${part})`).join(op)})`;\n}\n\nlet cachedParse: MathtsFunctionsModule['parse'] | undefined;\n\n/**\n * `parse`, bound once. The package is a required dependency and `quadrature.ts`\n * already imports it statically, so this module imports it the same way (a\n * `createRequire` of the ESM package once stood here, which needs Node 22.12 or\n * 20.19 while `engines` says 18; Tom's second round). The first parse runs\n * inside the one console-silencing window this module opens (`mathts-quiet.ts`\n * states the invariant): the peer's WASM-fallback chatter fires lazily on first\n * use, so the smoke parse is that first use, and every later parse runs with the\n * console untouched.\n */\nfunction mathTsParse(): MathtsFunctionsModule['parse'] {\n  if (cachedParse !== undefined) return cachedParse;\n  const parse = quietlySync(() => {\n    const bound = (mathtsParse as MathtsFunctionsModule['parse']).bind(undefined);\n    bound('g0');\n    return bound;\n  });\n  cachedParse = parse;\n  return cachedParse;\n}\n\n/**\n * Distinct scalar leaves of `expr`, in first-seen order.\n *\n * The MathTS symbol filter supplies the names. A gensym that this renderer\n * did not issue is dropped, so a function callee such as `exp` is not a leaf.\n * Tensor and curvature kinds return an empty list.\n *\n * @internal\n */\nexport function scalarSymbolsFromMathTs(expr: ExprNode): ScalarSymbol[] {\n  const gensymOf = new Map<string, string>();\n  const meta = new Map<string, LeafMeta>();\n  const rendered = renderSymbolQuery(expr, gensymOf, meta);\n  if (rendered === null) return [];\n  const node = mathTsParse()(rendered);\n  const seen = new Set<string>();\n  const leaves: ScalarSymbol[] = [];\n  for (const symbol of node.filter((candidate) => candidate.isSymbolNode === true)) {\n    const issued = symbol.name !== undefined ? meta.get(symbol.name) : undefined;\n    if (issued === undefined || seen.has(issued.name)) continue;\n    seen.add(issued.name);\n    leaves.push(issued);\n  }\n  return leaves;\n}\n"]}

package/dist/composition/own-equation-magnitude.d.ts

@@ -0,0 +1,95 @@
+/**
+ * A magnitude for a quantity from its own equation, for the discovery magnitude gate.
+ *
+ * The gate (`discovery.ts`, `magnitudeGate`) reads a quantity's magnitude from the sourced
+ * representative-value table, else from the value the graph fixes with no anchor input (the
+ * target of a source-less equation), else from the anchor. A quantity none of those reach (the
+ * Hubble distance, c/H0, whose input the table states but the anchor does not reach) made the gate
+ * abstain. This module evaluates such a quantity from an edge into it whose every source is
+ * valued: a table value, a registered constant, a no-anchor constant, or a value this module
+ * already derived, iterated to a fixed point. It is seeded from the table and the constants only,
+ * never from the anchor, so a derived magnitude is not anchor-derived.
+ *
+ * Three guards, each a refusal the caller sees (`DerivedMagnitudes.refusals`):
+ *   - precision: a derived value carries σ in decades of log10|value|, propagated from its inputs
+ *     through the edge's log-elasticities, σ = √(Σ (∂log f/∂log xᵢ)² σᵢ²) (σᵢ is the table row's
+ *     σ, 0 for a constant, the derived σ for a derived input). The gate uses a value only when σ is
+ *     at most {@link DEFAULT_SIGMA_DECADES}, the table's own "good to about one order". The FRET
+ *     efficiency from two 5 nm order-of-magnitude scales is exactly 0.5 and carries 3√2 decades: a
+ *     number with no magnitude information, which this guard refuses.
+ *   - agreement: two edges that derive one quantity and differ by more than a relative
+ *     {@link DERIVED_AGREEMENT} give it no value; no edge wins by its place in the list.
+ *   - the edge's own evaluation (`evaluateEdge`): a domain refusal, an unset coefficient or a
+ *     non-finite or zero result gives no value.
+ *
+ * Seeds are SI (the table's unit) and are converted into each quantity's evaluator convention
+ * (`conventionScaleToSI`; `planck-mass-energy` and `vacuum-expectation-value` speak GeV), and every
+ * result is converted back to SI.
+ *
+ * INTERNAL — read by `discovery.ts`; surfaced through `upt discover` and `upt ground`.
+ *
+ * @module composition/own-equation-magnitude
+ */
+import type { BridgeEdge } from './edge.js';
+import type { QuantityIdentification } from './compose.js';
+import type { RepresentativeValue } from './representative-values.js';
+/**
+ * Relative difference above which two edges deriving one quantity disagree. Two encodings of one
+ * equation agree to rounding; a factor that differs (2 against 1) is far above it.
+ * @internal
+ */
+export declare const DERIVED_AGREEMENT = 1e-9;
+/** A magnitude derived from a quantity's own equation. @internal */
+export interface DerivedMagnitude {
+    /** The value in SI (the table's unit), converted back from the evaluator's convention. */
+    readonly value: number;
+    /** σ in decades of log10|value|, propagated through the edge's log-elasticities. */
+    readonly sigmaDecades: number;
+    /** The edge that produced it (`identification:<from>` for a registered identification's copy). */
+    readonly edge: string;
+    /** The names the edge read, sorted. */
+    readonly inputs: readonly string[];
+}
+/** Why a quantity reached by an equation has no derived magnitude. @internal */
+export interface DerivedMagnitudeRefusal {
+    readonly name: string;
+    /**
+     * `imprecise`: the propagated σ is above the guard. `disagreeing-edges`: two edges that derive it
+     * differ by more than {@link DERIVED_AGREEMENT}. `precision-unknown`: the edge fired at the point
+     * but not at the points the elasticity reads, so σ could not be measured.
+     */
+    readonly reason: 'imprecise' | 'disagreeing-edges' | 'precision-unknown';
+    /** The edges involved, sorted. */
+    readonly edges: readonly string[];
+    /** The propagated σ, for `imprecise`. */
+    readonly sigmaDecades?: number;
+    /** One sentence for a reader. */
+    readonly detail: string;
+}
+/** The magnitudes the graph derives from the table and the constants, and the refusals. @internal */
+export interface DerivedMagnitudes {
+    /** Derived magnitudes the gate may use (σ within the guard), by quantity name. */
+    readonly values: ReadonlyMap<string, DerivedMagnitude>;
+    /** Every quantity an equation reached that has no usable derived magnitude, sorted by name. */
+    readonly refusals: readonly DerivedMagnitudeRefusal[];
+}
+/** What the caller supplies: the sourced table and the no-anchor constants. @internal */
+export interface OwnEquationSeeds {
+    /** The sourced representative values, in SI. */
+    readonly representativeValues: Readonly<Record<string, RepresentativeValue>>;
+    /** The values the graph fixes with no anchor input, in the evaluator's convention (`forwardEvaluate(edges, {}, …)`). */
+    readonly constantValues: ReadonlyMap<string, number>;
+    /** Identifications honoured as copies, as `forwardEvaluate` honours them. */
+    readonly identifications: readonly QuantityIdentification[];
+}
+/**
+ * The magnitudes `edges` derive from the sourced table and the constants, with the refusals. A
+ * quantity the table or a constant states is a seed and is never derived. Each round fires every
+ * edge from the values of the round before, so the edge list's order decides nothing; a quantity
+ * that two edges value differently is withdrawn with everything derived from it, and the fixed
+ * point is recomputed without it. A value is assigned from the first of its agreeing edges by id.
+ *
+ * @internal
+ */
+export declare function deriveOwnEquationMagnitudes(edges: readonly BridgeEdge[], seeds: OwnEquationSeeds, maxSigmaDecades?: number): DerivedMagnitudes;
+//# sourceMappingURL=own-equation-magnitude.d.ts.map

package/dist/composition/own-equation-magnitude.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"own-equation-magnitude.d.ts","sourceRoot":"","sources":["../../src/composition/own-equation-magnitude.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+BG;AAEH,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,WAAW,CAAC;AAE5C,OAAO,KAAK,EAAE,sBAAsB,EAAE,MAAM,cAAc,CAAC;AAG3D,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,4BAA4B,CAAC;AAOtE;;;;GAIG;AACH,eAAO,MAAM,iBAAiB,OAAO,CAAC;AAgBtC,oEAAoE;AACpE,MAAM,WAAW,gBAAgB;IAC/B,0FAA0F;IAC1F,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;IACvB,oFAAoF;IACpF,QAAQ,CAAC,YAAY,EAAE,MAAM,CAAC;IAC9B,kGAAkG;IAClG,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,uCAAuC;IACvC,QAAQ,CAAC,MAAM,EAAE,SAAS,MAAM,EAAE,CAAC;CACpC;AAED,gFAAgF;AAChF,MAAM,WAAW,uBAAuB;IACtC,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB;;;;OAIG;IACH,QAAQ,CAAC,MAAM,EAAE,WAAW,GAAG,mBAAmB,GAAG,mBAAmB,CAAC;IACzE,kCAAkC;IAClC,QAAQ,CAAC,KAAK,EAAE,SAAS,MAAM,EAAE,CAAC;IAClC,yCAAyC;IACzC,QAAQ,CAAC,YAAY,CAAC,EAAE,MAAM,CAAC;IAC/B,iCAAiC;IACjC,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;CACzB;AAED,qGAAqG;AACrG,MAAM,WAAW,iBAAiB;IAChC,kFAAkF;IAClF,QAAQ,CAAC,MAAM,EAAE,WAAW,CAAC,MAAM,EAAE,gBAAgB,CAAC,CAAC;IACvD,+FAA+F;IAC/F,QAAQ,CAAC,QAAQ,EAAE,SAAS,uBAAuB,EAAE,CAAC;CACvD;AAiBD,yFAAyF;AACzF,MAAM,WAAW,gBAAgB;IAC/B,gDAAgD;IAChD,QAAQ,CAAC,oBAAoB,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,mBAAmB,CAAC,CAAC,CAAC;IAC7E,wHAAwH;IACxH,QAAQ,CAAC,cAAc,EAAE,WAAW,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IACrD,6EAA6E;IAC7E,QAAQ,CAAC,eAAe,EAAE,SAAS,sBAAsB,EAAE,CAAC;CAC7D;AAkGD;;;;;;;;GAQG;AACH,wBAAgB,2BAA2B,CACzC,KAAK,EAAE,SAAS,UAAU,EAAE,EAC5B,KAAK,EAAE,gBAAgB,EACvB,eAAe,GAAE,MAA8B,GAC9C,iBAAiB,CAkFnB"}

package/dist/composition/own-equation-magnitude.js

@@ -0,0 +1,270 @@
+/**
+ * A magnitude for a quantity from its own equation, for the discovery magnitude gate.
+ *
+ * The gate (`discovery.ts`, `magnitudeGate`) reads a quantity's magnitude from the sourced
+ * representative-value table, else from the value the graph fixes with no anchor input (the
+ * target of a source-less equation), else from the anchor. A quantity none of those reach (the
+ * Hubble distance, c/H0, whose input the table states but the anchor does not reach) made the gate
+ * abstain. This module evaluates such a quantity from an edge into it whose every source is
+ * valued: a table value, a registered constant, a no-anchor constant, or a value this module
+ * already derived, iterated to a fixed point. It is seeded from the table and the constants only,
+ * never from the anchor, so a derived magnitude is not anchor-derived.
+ *
+ * Three guards, each a refusal the caller sees (`DerivedMagnitudes.refusals`):
+ *   - precision: a derived value carries σ in decades of log10|value|, propagated from its inputs
+ *     through the edge's log-elasticities, σ = √(Σ (∂log f/∂log xᵢ)² σᵢ²) (σᵢ is the table row's
+ *     σ, 0 for a constant, the derived σ for a derived input). The gate uses a value only when σ is
+ *     at most {@link DEFAULT_SIGMA_DECADES}, the table's own "good to about one order". The FRET
+ *     efficiency from two 5 nm order-of-magnitude scales is exactly 0.5 and carries 3√2 decades: a
+ *     number with no magnitude information, which this guard refuses.
+ *   - agreement: two edges that derive one quantity and differ by more than a relative
+ *     {@link DERIVED_AGREEMENT} give it no value; no edge wins by its place in the list.
+ *   - the edge's own evaluation (`evaluateEdge`): a domain refusal, an unset coefficient or a
+ *     non-finite or zero result gives no value.
+ *
+ * Seeds are SI (the table's unit) and are converted into each quantity's evaluator convention
+ * (`conventionScaleToSI`; `planck-mass-energy` and `vacuum-expectation-value` speak GeV), and every
+ * result is converted back to SI.
+ *
+ * INTERNAL — read by `discovery.ts`; surfaced through `upt discover` and `upt ground`.
+ *
+ * @module composition/own-equation-magnitude
+ */
+import { evaluateEdge } from './edge.js';
+import { evaluationInputs, refusesThePoint } from './retrodiction.js';
+import { DEFAULT_SIGMA_DECADES, sigmaDecadesOf } from './representative-values.js';
+import { conventionFactor, conventionScaleToSI } from '../dimensional/unit-convention.js';
+import { CONSTANT_REGISTRY } from '../dimensional/symbolic-constants.js';
+import { centralPartial } from '../numerical/finite-difference.js';
+import { byKey, compareCodepoint } from '../core/compare.js';
+import { formatQuantity } from '../core/format.js';
+/**
+ * Relative difference above which two edges deriving one quantity disagree. Two encodings of one
+ * equation agree to rounding; a factor that differs (2 against 1) is far above it.
+ * @internal
+ */
+export const DERIVED_AGREEMENT = 1e-9;
+/**
+ * The half-step, in decades of an input, of the central difference that measures a
+ * log-elasticity. A power law's elasticity is exact at any step; for another form the truncation
+ * error is of order the step squared.
+ */
+const ELASTICITY_STEP_DECADES = 1e-3;
+/**
+ * Decades by which a propagated σ may exceed the guard and still pass: room for the central
+ * difference's rounding, so a power law of elasticity 1 on a one-decade input is not refused for a
+ * last-bit excess (the Hubble distance's σ measures exactly 1). Far below any σ the guard refuses.
+ */
+const SIGMA_GUARD_SLACK = 1e-9;
+/** The seeds: the table (SI → evaluator unit), then a registered constant that is a graph quantity, then a no-anchor constant. */
+function seedsOf(edges, seeds) {
+    const known = new Map();
+    for (const [name, rv] of Object.entries(seeds.representativeValues)) {
+        if (!(Number.isFinite(rv.value) && rv.value !== 0))
+            continue;
+        known.set(name, { value: rv.value / conventionScaleToSI(name), sigmaDecades: sigmaDecadesOf(rv) });
+    }
+    const names = new Set(edges.flatMap((e) => [e.target.name, ...e.sources.map((s) => s.name)]));
+    for (const record of CONSTANT_REGISTRY) {
+        const name = record.quantity;
+        if (name === undefined || !names.has(name) || known.has(name))
+            continue;
+        known.set(name, { value: record.value / conventionScaleToSI(name), sigmaDecades: 0 });
+    }
+    for (const [name, value] of seeds.constantValues) {
+        if (known.has(name) || !(Number.isFinite(value) && value !== 0))
+            continue;
+        known.set(name, { value, sigmaDecades: 0 });
+    }
+    return known;
+}
+/** log10|f| as a function of log10|x_key|, the other inputs held. NaN when the edge refuses. */
+function logResponse(edge, inputs, key) {
+    const sign = Math.sign(inputs[key]);
+    return (point) => {
+        try {
+            return Math.log10(Math.abs(evaluateEdge(edge, { ...inputs, [key]: sign * 10 ** point['u'] })));
+        }
+        catch (err) {
+            if (!refusesThePoint(err))
+                throw err;
+            return Number.NaN;
+        }
+    };
+}
+/** σ of an edge's value from its inputs' σ, through the log-elasticities; undefined when one is not finite. */
+function propagatedSigma(edge, inputs, known) {
+    let sum = 0;
+    for (const key of Object.keys(inputs).sort(compareCodepoint)) {
+        const sigma = known.get(key)?.sigmaDecades ?? 0;
+        if (sigma === 0)
+            continue;
+        const x = inputs[key];
+        if (!(Number.isFinite(x) && x !== 0))
+            return undefined;
+        const elasticity = centralPartial(logResponse(edge, inputs, key), { u: Math.log10(Math.abs(x)) }, 'u', ELASTICITY_STEP_DECADES);
+        if (!Number.isFinite(elasticity))
+            return undefined;
+        sum += elasticity * elasticity * sigma * sigma;
+    }
+    return Math.sqrt(sum);
+}
+/** Every edge and identification that fires for an unvalued, unblocked target, from `known` as it stands. */
+function firings(edges, idents, known, skip) {
+    const out = new Map();
+    const push = (target, f) => {
+        const list = out.get(target);
+        if (list === undefined)
+            out.set(target, [f]);
+        else
+            list.push(f);
+    };
+    for (const id of idents) {
+        const from = known.get(id.from);
+        if (from === undefined || skip(id.to))
+            continue;
+        const value = from.value * conventionFactor(id.from, id.to);
+        if (Number.isFinite(value) && value !== 0) {
+            push(id.to, { edge: `identification:${id.from}`, value, sigmaDecades: from.sigmaDecades, inputs: [id.from] });
+        }
+    }
+    const values = new Map([...known].map(([name, k]) => [name, k.value]));
+    for (const e of edges) {
+        if (skip(e.target.name))
+            continue;
+        if (!e.sources.every((s) => known.has(s.name)))
+            continue;
+        const inputs = evaluationInputs(e, values);
+        let value;
+        try {
+            value = evaluateEdge(e, inputs);
+        }
+        catch (err) {
+            if (!refusesThePoint(err))
+                throw err;
+            continue;
+        }
+        if (!(Number.isFinite(value) && value !== 0))
+            continue;
+        push(e.target.name, { edge: e.id, value, sigmaDecades: propagatedSigma(e, inputs, known), inputs: Object.keys(inputs).sort(compareCodepoint) });
+    }
+    return out;
+}
+/** The firings sorted by edge id; and whether any two differ by more than {@link DERIVED_AGREEMENT}. */
+function agreement(list) {
+    const sorted = [...list].sort(byKey((f) => f.edge));
+    const agree = sorted.every((f) => Math.abs(f.value - sorted[0].value) <= DERIVED_AGREEMENT * Math.max(Math.abs(f.value), Math.abs(sorted[0].value)));
+    return { sorted, agree };
+}
+/**
+ * The magnitudes `edges` derive from the sourced table and the constants, with the refusals. A
+ * quantity the table or a constant states is a seed and is never derived. Each round fires every
+ * edge from the values of the round before, so the edge list's order decides nothing; a quantity
+ * that two edges value differently is withdrawn with everything derived from it, and the fixed
+ * point is recomputed without it. A value is assigned from the first of its agreeing edges by id.
+ *
+ * @internal
+ */
+export function deriveOwnEquationMagnitudes(edges, seeds, maxSigmaDecades = DEFAULT_SIGMA_DECADES) {
+    const seeded = seedsOf(edges, seeds);
+    const disagreeing = new Map();
+    for (;;) {
+        const unmeasured = new Map();
+        const known = new Map(seeded);
+        const derived = new Map();
+        const skip = (name) => known.has(name) || disagreeing.has(name) || unmeasured.has(name);
+        for (;;) {
+            const round = firings(edges, seeds.identifications, known, skip);
+            if (round.size === 0)
+                break;
+            for (const target of [...round.keys()].sort(compareCodepoint)) {
+                const { sorted, agree } = agreement(round.get(target));
+                const edgeIds = sorted.map((f) => f.edge);
+                if (!agree) {
+                    disagreeing.set(target, disagreement(target, sorted));
+                    continue;
+                }
+                const chosen = sorted[0];
+                if (chosen.sigmaDecades === undefined) {
+                    unmeasured.set(target, {
+                        name: target,
+                        reason: 'precision-unknown',
+                        edges: edgeIds,
+                        detail: `${chosen.edge} fires at the point but not at the points its log-elasticity reads, so σ was not measured`,
+                    });
+                    continue;
+                }
+                derived.set(target, chosen);
+                known.set(target, { value: chosen.value, sigmaDecades: chosen.sigmaDecades });
+            }
+        }
+        // An edge whose sources were valued only after its target was: it must agree with that value.
+        const late = [];
+        const values = new Map([...known].map(([name, k]) => [name, k.value]));
+        for (const [target, chosen] of derived) {
+            const all = [chosen];
+            for (const e of edges) {
+                if (e.target.name !== target || e.id === chosen.edge)
+                    continue;
+                if (!e.sources.every((s) => known.has(s.name)))
+                    continue;
+                try {
+                    const value = evaluateEdge(e, evaluationInputs(e, values));
+                    if (Number.isFinite(value) && value !== 0)
+                        all.push({ edge: e.id, value, sigmaDecades: undefined, inputs: [] });
+                }
+                catch (err) {
+                    if (!refusesThePoint(err))
+                        throw err;
+                }
+            }
+            for (const id of seeds.identifications) {
+                if (id.to !== target || `identification:${id.from}` === chosen.edge)
+                    continue;
+                const from = known.get(id.from);
+                if (from === undefined)
+                    continue;
+                const value = from.value * conventionFactor(id.from, id.to);
+                if (Number.isFinite(value) && value !== 0)
+                    all.push({ edge: `identification:${id.from}`, value, sigmaDecades: undefined, inputs: [] });
+            }
+            const { sorted, agree } = agreement(all);
+            if (!agree) {
+                disagreeing.set(target, disagreement(target, sorted));
+                late.push(target);
+            }
+        }
+        if (late.length > 0)
+            continue;
+        const usable = new Map();
+        const refusals = [...disagreeing.values(), ...unmeasured.values()];
+        for (const [name, f] of derived) {
+            const sigma = f.sigmaDecades;
+            if (sigma > maxSigmaDecades + SIGMA_GUARD_SLACK) {
+                refusals.push({
+                    name,
+                    reason: 'imprecise',
+                    edges: [f.edge],
+                    sigmaDecades: sigma,
+                    detail: `${f.edge} gives ${name} from ${f.inputs.join(', ')} at σ = ${formatQuantity(sigma, 3)} decades, ` +
+                        `above the ${maxSigmaDecades}-decade precision the gate requires`,
+                });
+                continue;
+            }
+            usable.set(name, { value: f.value * conventionScaleToSI(name), sigmaDecades: sigma, edge: f.edge, inputs: f.inputs });
+        }
+        refusals.sort(byKey((r) => r.name));
+        return { values: usable, refusals };
+    }
+}
+/** The refusal record of two or more edges that value one quantity differently. */
+function disagreement(name, sorted) {
+    return {
+        name,
+        reason: 'disagreeing-edges',
+        edges: sorted.map((f) => f.edge),
+        detail: `${sorted.map((f) => `${f.edge} gives ${formatQuantity(f.value, 4)}`).join(', ')}: ` +
+            `they differ by more than a relative ${DERIVED_AGREEMENT}, so no edge is taken`,
+    };
+}
+//# sourceMappingURL=own-equation-magnitude.js.map