@danielsimonjr/mathts-functions 0.71.0 → 0.73.0

package/dist/numeric/quadrature-extra.d.ts

@@ -0,0 +1,64 @@
+/**
+ * Additional quadrature rules and multiple integrals.
+ *
+ * - {@link tanhSinh}: double-exponential (tanh-sinh) quadrature. Handles
+ *   endpoint singularities well. Abscissae are computed from the distance to
+ *   the nearer endpoint, so the nodes stay strictly inside `(a, b)`.
+ * - {@link clenshawCurtis}: Clenshaw–Curtis rule on Chebyshev extreme points.
+ * - {@link dblquad} / {@link tplquad}: iterated adaptive integration built on
+ *   {@link quad}. The argument order matches SciPy: `f(y, x)` and `f(z, y, x)`.
+ *
+ * Infinite limits are rejected with a `RangeError` in this version.
+ *
+ * @packageDocumentation
+ */
+import { type QuadOptions, type QuadResult } from './adaptive-quad.js';
+/** Options for {@link tanhSinh}. */
+export interface TanhSinhOptions {
+    /** Relative tolerance between successive levels (default 1e-12). */
+    tol?: number;
+    /** Maximum refinement level; level k uses step `2^{-k}` (default 10). */
+    maxLevel?: number;
+}
+/** A limit that is either a constant or a function of the outer variables. */
+export type Limit1 = number | ((x: number) => number);
+/** A limit that is either a constant or a function of two outer variables. */
+export type Limit2 = number | ((x: number, y: number) => number);
+/**
+ * Tanh-sinh (double-exponential) quadrature of `f` over `[a, b]`.
+ *
+ * Substitution `x = m + h·tanh(π/2 · sinh t)` (`m` midpoint, `h` half-width),
+ * trapezoid rule in `t` with step `2^{-k}`. Each level's error estimate is the
+ * change from the previous level.
+ *
+ * @example
+ * tanhSinh((x) => 1 / Math.sqrt(1 - x * x), -1, 1).value // ~π
+ */
+export declare function tanhSinh(f: (x: number) => number, a: number, b: number, opts?: TanhSinhOptions): QuadResult;
+/**
+ * Clenshaw–Curtis quadrature of `f` over `[a, b]` with `n` intervals on the
+ * Chebyshev extreme points (exact for polynomials of degree `n`). An odd `n`
+ * is rounded up to the next even value.
+ *
+ * @example
+ * clenshawCurtis((x) => x ** 4, -1, 1, 8) // 0.4
+ */
+export declare function clenshawCurtis(f: (x: number) => number, a: number, b: number, n: number): number;
+/**
+ * Iterated integral `∫_{ax}^{bx} ∫_{gy(x)}^{hy(x)} f(y, x) dy dx`, with both
+ * levels integrated by {@link quad}. Returns the outer `error` estimate, and
+ * the value is the sum of the outer integrals of the inner results.
+ *
+ * @example
+ * dblquad((y, x) => x * y, 0, 1, 0, 1).value // 0.25
+ */
+export declare function dblquad(f: (y: number, x: number) => number, ax: number, bx: number, gy: Limit1, hy: Limit1, opts?: QuadOptions): QuadResult;
+/**
+ * Triple iterated integral `∫_{ax}^{bx} ∫_{gy(x)}^{hy(x)} ∫_{qz(x,y)}^{rz(x,y)}
+ * f(z, y, x) dz dy dx`, each level integrated by {@link quad}.
+ *
+ * @example
+ * tplquad((z, y, x) => x * y * z, 0, 1, 0, 1, 0, 1).value // 0.125
+ */
+export declare function tplquad(f: (z: number, y: number, x: number) => number, ax: number, bx: number, gy: Limit1, hy: Limit1, qz: Limit2, rz: Limit2, opts?: QuadOptions): QuadResult;
+//# sourceMappingURL=quadrature-extra.d.ts.map

package/dist/numeric/quadrature-extra.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"quadrature-extra.d.ts","sourceRoot":"","sources":["../../src/numeric/quadrature-extra.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;GAaG;AACH,OAAO,EAAQ,KAAK,WAAW,EAAE,KAAK,UAAU,EAAE,MAAM,oBAAoB,CAAC;AAE7E,oCAAoC;AACpC,MAAM,WAAW,eAAe;IAC9B,oEAAoE;IACpE,GAAG,CAAC,EAAE,MAAM,CAAC;IACb,yEAAyE;IACzE,QAAQ,CAAC,EAAE,MAAM,CAAC;CACnB;AAED,8EAA8E;AAC9E,MAAM,MAAM,MAAM,GAAG,MAAM,GAAG,CAAC,CAAC,CAAC,EAAE,MAAM,KAAK,MAAM,CAAC,CAAC;AACtD,8EAA8E;AAC9E,MAAM,MAAM,MAAM,GAAG,MAAM,GAAG,CAAC,CAAC,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,KAAK,MAAM,CAAC,CAAC;AAUjE;;;;;;;;;GASG;AACH,wBAAgB,QAAQ,CACtB,CAAC,EAAE,CAAC,CAAC,EAAE,MAAM,KAAK,MAAM,EACxB,CAAC,EAAE,MAAM,EACT,CAAC,EAAE,MAAM,EACT,IAAI,GAAE,eAAoB,GACzB,UAAU,CA0CZ;AAED;;;;;;;GAOG;AACH,wBAAgB,cAAc,CAAC,CAAC,EAAE,CAAC,CAAC,EAAE,MAAM,KAAK,MAAM,EAAE,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,GAAG,MAAM,CAqBhG;AAMD;;;;;;;GAOG;AACH,wBAAgB,OAAO,CACrB,CAAC,EAAE,CAAC,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,KAAK,MAAM,EACnC,EAAE,EAAE,MAAM,EACV,EAAE,EAAE,MAAM,EACV,EAAE,EAAE,MAAM,EACV,EAAE,EAAE,MAAM,EACV,IAAI,CAAC,EAAE,WAAW,GACjB,UAAU,CASZ;AAED;;;;;;GAMG;AACH,wBAAgB,OAAO,CACrB,CAAC,EAAE,CAAC,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,KAAK,MAAM,EAC9C,EAAE,EAAE,MAAM,EACV,EAAE,EAAE,MAAM,EACV,EAAE,EAAE,MAAM,EACV,EAAE,EAAE,MAAM,EACV,EAAE,EAAE,MAAM,EACV,EAAE,EAAE,MAAM,EACV,IAAI,CAAC,EAAE,WAAW,GACjB,UAAU,CAoBZ"}

package/dist/numeric/rational-nullspace.d.ts

@@ -37,7 +37,7 @@ export interface RationalNullspaceResult {
  *
  * Numbers are converted with {@link Fraction.fromNumber} (continued fraction,
  * denominator at most 10^6). Pass {@link Fraction} entries when the exponent
- * is already an exact ratio, such as `1/3`.
+ * is already an exact ratio, such as `1/3`. A `bigint` entry is exact.
  *
  * The numeric {@link nullspace} is unchanged. This function does not replace it.
  *
@@ -55,5 +55,5 @@ export interface RationalNullspaceResult {
  * // { rank: 2, basis: [[2, -1, 1]] }
  * ```
  */
-export declare function rationalNullspace(matrix: ReadonlyArray<ReadonlyArray<number | Fraction>>, options?: RationalNullspaceOptions): RationalNullspaceResult;
+export declare function rationalNullspace(matrix: ReadonlyArray<ReadonlyArray<number | bigint | Fraction>>, options?: RationalNullspaceOptions): RationalNullspaceResult;
 //# sourceMappingURL=rational-nullspace.d.ts.map

package/dist/numeric/rational-nullspace.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"rational-nullspace.d.ts","sourceRoot":"","sources":["../../src/numeric/rational-nullspace.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AAEH,OAAO,EAAE,QAAQ,EAAc,MAAM,4BAA4B,CAAC;AAElE,6CAA6C;AAC7C,MAAM,WAAW,wBAAwB;IACvC;;;;;OAKG;IACH,OAAO,CAAC,EAAE,MAAM,CAAC;CAClB;AAED,uDAAuD;AACvD,MAAM,WAAW,uBAAuB;IACtC;;;OAGG;IACH,QAAQ,CAAC,KAAK,EAAE,QAAQ,EAAE,EAAE,CAAC;IAC7B,uEAAuE;IACvE,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;CACvB;AAqFD;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,wBAAgB,iBAAiB,CAC/B,MAAM,EAAE,aAAa,CAAC,aAAa,CAAC,MAAM,GAAG,QAAQ,CAAC,CAAC,EACvD,OAAO,CAAC,EAAE,wBAAwB,GACjC,uBAAuB,CAgDzB"}
+{"version":3,"file":"rational-nullspace.d.ts","sourceRoot":"","sources":["../../src/numeric/rational-nullspace.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AAEH,OAAO,EAAE,QAAQ,EAAc,MAAM,4BAA4B,CAAC;AAElE,6CAA6C;AAC7C,MAAM,WAAW,wBAAwB;IACvC;;;;;OAKG;IACH,OAAO,CAAC,EAAE,MAAM,CAAC;CAClB;AAED,uDAAuD;AACvD,MAAM,WAAW,uBAAuB;IACtC;;;OAGG;IACH,QAAQ,CAAC,KAAK,EAAE,QAAQ,EAAE,EAAE,CAAC;IAC7B,uEAAuE;IACvE,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;CACvB;AAsFD;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,wBAAgB,iBAAiB,CAC/B,MAAM,EAAE,aAAa,CAAC,aAAa,CAAC,MAAM,GAAG,MAAM,GAAG,QAAQ,CAAC,CAAC,EAChE,OAAO,CAAC,EAAE,wBAAwB,GACjC,uBAAuB,CAgDzB"}

package/dist/scalar-batch-parallel.d.ts

@@ -14,14 +14,15 @@ import type { ScalarNode } from '@danielsimonjr/mathts-expression';
 import { WorkerPool } from '@danielsimonjr/mathts-parallel';
 import { type CompileScalarOptions, type ScalarBatchResult } from './scalar-compile.js';
 /**
- * Smallest row count that is sent to workers. 100 is the `n` from which the M3 tape beats
- * the per-row interpreter in every run of the `scalar` benchmark (`docs/BENCHMARK_RESULTS.md`,
- * section "`evaluateScalar` vs `compileScalar` (M3 batch evaluator) - 2026-10-25"). That
- * table compares the two evaluators on the caller thread; it did not time a worker round
- * trip, so this is the plan's floor for using the pool and not a measured break-even. The
- * pool is opt-in, and nothing here claims a speed-up.
+ * Smallest row count that is sent to workers when `parallel` is set. **10_000** is the
+ * SR-14 break-even on a reused `WorkerPool` (the lifetime `searchScalars` uses): case (3)
+ * of `tools/benchmark/scalar-search/` with one pool for warmup and samples, twice on Node
+ * and twice on Bun (2026-11-05, `docs/BENCHMARK_RESULTS.md`, section SR-14). At n = 1_000
+ * the reused-pool median is above 0.95× serial in at least one Bun run; at n = 10_000 all
+ * four runs are at or below 0.95×. The M3 caller-thread table at n = 100 is unrelated; a
+ * cold pool per call is not a valid threshold for the search driver.
  */
-export declare const SCALAR_PARALLEL_MIN_ROWS = 100;
+export declare const SCALAR_PARALLEL_MIN_ROWS = 10000;
 /** Timeout applied to every worker call when the caller does not choose one. */
 export declare const DEFAULT_SCALAR_PARALLEL_TIMEOUT_MS = 30000;
 /** URL of the built worker, a sibling of the module that contains this code. */
@@ -31,9 +32,12 @@ export declare function createScalarBatchPool(): WorkerPool;
 /** How to run a population on workers. */
 export interface ScalarPopulationParallelOptions {
     /**
-     * Milliseconds a worker call may take, queueing included, before it is cancelled, the
+     * Milliseconds a worker task may take, queueing included, before it is cancelled, the
      * worker replaced and the evaluation rejected. Must be positive: `0` would switch the
-     * pool's timeout off. Default 30000.
+     * pool's timeout off. Default 30000. The limit applies per {@link WorkerPool.execute}
+     * call; when several islands score in one generation, later island chunks queue behind
+     * earlier submissions on the same pool, so callers with many `populations` should scale
+     * this value.
      */
     readonly timeoutMs?: number;
     /** A pool to use, which the caller owns and terminates. Default: one for the call. */
@@ -56,6 +60,8 @@ export interface ScalarPopulationEvalResult {
 }
 /** Positive, finite timeout, or a `RangeError`: a zero would silently disable the guard. */
 export declare function resolveParallelTimeout(timeoutMs: number | undefined): number;
+/** @internal Worker chunk count for {@link evaluateScalarPopulation}; not on the barrel. */
+export declare function scalarParallelWorkerCount(): number;
 /**
  * Evaluates every item over `columns`, in the order given.
  *

package/dist/scalar-batch-parallel.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"scalar-batch-parallel.d.ts","sourceRoot":"","sources":["../src/scalar-batch-parallel.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AAEH,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,kCAAkC,CAAC;AACnE,OAAO,EAAE,UAAU,EAAE,MAAM,gCAAgC,CAAC;AAC5D,OAAO,EAGL,KAAK,oBAAoB,EACzB,KAAK,iBAAiB,EACvB,MAAM,qBAAqB,CAAC;AAQ7B;;;;;;;GAOG;AACH,eAAO,MAAM,wBAAwB,MAAM,CAAC;AAE5C,gFAAgF;AAChF,eAAO,MAAM,kCAAkC,QAAS,CAAC;AAEzD,gFAAgF;AAChF,wBAAgB,8BAA8B,IAAI,MAAM,CAEvD;AAED,2FAA2F;AAC3F,wBAAgB,qBAAqB,IAAI,UAAU,CAElD;AAED,0CAA0C;AAC1C,MAAM,WAAW,+BAA+B;IAC9C;;;;OAIG;IACH,QAAQ,CAAC,SAAS,CAAC,EAAE,MAAM,CAAC;IAC5B,sFAAsF;IACtF,QAAQ,CAAC,IAAI,CAAC,EAAE,IAAI,CAAC,UAAU,EAAE,SAAS,CAAC,CAAC;CAC7C;AAED,MAAM,WAAW,wBAAwB;IACvC,0CAA0C;IAC1C,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;IACvB,QAAQ,CAAC,IAAI,EAAE,UAAU,CAAC;IAC1B,QAAQ,CAAC,MAAM,CAAC,EAAE,SAAS,CAAC,MAAM,CAAC,CAAC;CACrC;AAED,MAAM,WAAW,+BAAgC,SAAQ,oBAAoB;IAC3E,QAAQ,CAAC,OAAO,EAAE,SAAS,YAAY,EAAE,CAAC;IAC1C,QAAQ,CAAC,KAAK,EAAE,SAAS,wBAAwB,EAAE,CAAC;IACpD,QAAQ,CAAC,QAAQ,CAAC,EAAE,+BAA+B,CAAC;CACrD;AAED,MAAM,WAAW,0BAA0B;IACzC,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;IACvB,QAAQ,CAAC,KAAK,EAAE,iBAAiB,CAAC;CACnC;AAED,4FAA4F;AAC5F,wBAAgB,sBAAsB,CAAC,SAAS,EAAE,MAAM,GAAG,SAAS,GAAG,MAAM,CAM5E;AAqGD;;;;;;;;;;GAUG;AACH,wBAAsB,wBAAwB,CAC5C,OAAO,EAAE,+BAA+B,GACvC,OAAO,CAAC,0BAA0B,EAAE,CAAC,CAsBvC"}
+{"version":3,"file":"scalar-batch-parallel.d.ts","sourceRoot":"","sources":["../src/scalar-batch-parallel.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AAEH,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,kCAAkC,CAAC;AACnE,OAAO,EAAE,UAAU,EAAE,MAAM,gCAAgC,CAAC;AAC5D,OAAO,EAGL,KAAK,oBAAoB,EACzB,KAAK,iBAAiB,EACvB,MAAM,qBAAqB,CAAC;AAQ7B;;;;;;;;GAQG;AACH,eAAO,MAAM,wBAAwB,QAAS,CAAC;AAE/C,gFAAgF;AAChF,eAAO,MAAM,kCAAkC,QAAS,CAAC;AAEzD,gFAAgF;AAChF,wBAAgB,8BAA8B,IAAI,MAAM,CAEvD;AAED,2FAA2F;AAC3F,wBAAgB,qBAAqB,IAAI,UAAU,CAElD;AAED,0CAA0C;AAC1C,MAAM,WAAW,+BAA+B;IAC9C;;;;;;;OAOG;IACH,QAAQ,CAAC,SAAS,CAAC,EAAE,MAAM,CAAC;IAC5B,sFAAsF;IACtF,QAAQ,CAAC,IAAI,CAAC,EAAE,IAAI,CAAC,UAAU,EAAE,SAAS,CAAC,CAAC;CAC7C;AAED,MAAM,WAAW,wBAAwB;IACvC,0CAA0C;IAC1C,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;IACvB,QAAQ,CAAC,IAAI,EAAE,UAAU,CAAC;IAC1B,QAAQ,CAAC,MAAM,CAAC,EAAE,SAAS,CAAC,MAAM,CAAC,CAAC;CACrC;AAED,MAAM,WAAW,+BAAgC,SAAQ,oBAAoB;IAC3E,QAAQ,CAAC,OAAO,EAAE,SAAS,YAAY,EAAE,CAAC;IAC1C,QAAQ,CAAC,KAAK,EAAE,SAAS,wBAAwB,EAAE,CAAC;IACpD,QAAQ,CAAC,QAAQ,CAAC,EAAE,+BAA+B,CAAC;CACrD;AAED,MAAM,WAAW,0BAA0B;IACzC,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;IACvB,QAAQ,CAAC,KAAK,EAAE,iBAAiB,CAAC;CACnC;AAED,4FAA4F;AAC5F,wBAAgB,sBAAsB,CAAC,SAAS,EAAE,MAAM,GAAG,SAAS,GAAG,MAAM,CAM5E;AASD,4FAA4F;AAC5F,wBAAgB,yBAAyB,IAAI,MAAM,CAElD;AA8FD;;;;;;;;;;GAUG;AACH,wBAAsB,wBAAwB,CAC5C,OAAO,EAAE,+BAA+B,GACvC,OAAO,CAAC,0BAA0B,EAAE,CAAC,CAsBvC"}

package/dist/scalar-batch-parallel.js

@@ -0,0 +1,108 @@
+import { i as compileScalar, r as buildTape, t as SCALAR_BATCH_MESSAGE_PREFIX } from "./scalar-batch-task-CL8ex21e.js";
+import { WorkerPool } from "@danielsimonjr/mathts-parallel";
+//#region src/scalar-batch-parallel.ts
+const SCALAR_PARALLEL_MIN_ROWS = 1e4;
+const DEFAULT_SCALAR_PARALLEL_TIMEOUT_MS = 3e4;
+function resolveScalarBatchWorkerScript() {
+	return new URL("./scalar-batch.worker.js", import.meta.url).href;
+}
+function createScalarBatchPool() {
+	return new WorkerPool(resolveScalarBatchWorkerScript());
+}
+function resolveParallelTimeout(timeoutMs) {
+	const value = timeoutMs ?? 3e4;
+	if (!(Number.isFinite(value) && value > 0)) throw new RangeError(`parallel.timeoutMs must be a finite number > 0, got ${value}`);
+	return value;
+}
+function defaultWorkerCount() {
+	if (typeof navigator !== "undefined" && navigator.hardwareConcurrency) return Math.max(2, navigator.hardwareConcurrency - 1);
+	return 4;
+}
+function scalarParallelWorkerCount() {
+	return defaultWorkerCount();
+}
+function partition(items, chunks) {
+	const k = Math.min(Math.max(1, chunks), items.length);
+	const base = Math.floor(items.length / k);
+	let extra = items.length % k;
+	const out = [];
+	let start = 0;
+	for (let c = 0; c < k; c += 1) {
+		const size = base + (extra > 0 ? 1 : 0);
+		extra -= extra > 0 ? 1 : 0;
+		out.push(items.slice(start, start + size));
+		start += size;
+	}
+	return out;
+}
+function evaluateSerial(options) {
+	const compileOptions = {
+		variables: options.variables,
+		parameters: options.parameters,
+		constants: options.constants
+	};
+	return options.items.map((item) => ({
+		index: item.index,
+		batch: compileScalar(item.node, compileOptions).evaluate(options.columns, item.params)
+	}));
+}
+function taskItem(item, position, compileOptions) {
+	const { tape, rootReg, nRegs, parameters } = buildTape(item.node, compileOptions, SCALAR_BATCH_MESSAGE_PREFIX);
+	return {
+		candidateIndex: position,
+		tape,
+		rootReg,
+		nRegs,
+		params: item.params === void 0 ? [] : Array.from(item.params),
+		parameters
+	};
+}
+async function evaluateOnPool(pool, timeoutMs, options, rows) {
+	const compileOptions = {
+		variables: options.variables,
+		parameters: options.parameters,
+		constants: options.constants
+	};
+	const items = options.items.map((item, position) => taskItem(item, position, compileOptions));
+	const variables = options.variables.slice();
+	const replies = await Promise.all(partition(items, defaultWorkerCount()).map((chunk) => {
+		const task = {
+			items: chunk,
+			columns: options.columns,
+			variables
+		};
+		return pool.execute(task, void 0, timeoutMs);
+	}));
+	const byPosition = /* @__PURE__ */ new Map();
+	for (const reply of replies) for (const row of reply.rows) {
+		if (row.values.length !== rows || row.valid.length !== rows) throw new Error(`evaluateScalarPopulation: worker returned ${row.values.length} values for ${rows} rows`);
+		byPosition.set(row.candidateIndex, {
+			values: row.values,
+			valid: row.valid,
+			allValid: row.allValid
+		});
+	}
+	return options.items.map((item, position) => {
+		const batch = byPosition.get(position);
+		if (batch === void 0) throw new Error(`evaluateScalarPopulation: no worker result for item ${position}`);
+		return {
+			index: item.index,
+			batch
+		};
+	});
+}
+async function evaluateScalarPopulation(options) {
+	const timeoutMs = options.parallel === void 0 ? 0 : resolveParallelTimeout(options.parallel.timeoutMs);
+	const matched = options.columns.length === options.variables.length;
+	const rows = options.variables.length === 0 ? 1 : options.columns[0]?.length ?? 0;
+	if (options.parallel === void 0 || !matched || rows < 1e4 || options.items.length === 0) return evaluateSerial(options);
+	const given = options.parallel.pool;
+	const pool = given ?? createScalarBatchPool();
+	try {
+		return await evaluateOnPool(pool, timeoutMs, options, rows);
+	} finally {
+		if (given === void 0) await pool.terminate();
+	}
+}
+//#endregion
+export { DEFAULT_SCALAR_PARALLEL_TIMEOUT_MS, SCALAR_PARALLEL_MIN_ROWS, createScalarBatchPool, evaluateScalarPopulation, resolveParallelTimeout, resolveScalarBatchWorkerScript, scalarParallelWorkerCount };

package/dist/{scalar-batch-task-CZd6LPg9.js → scalar-batch-task-CL8ex21e.js}

@@ -1669,18 +1669,16 @@ const fsum = mathTyped("fsum", {
 });
 const sum = mathTyped("sum", {
 	Array: (arr) => pairwiseSum(arr),
-	Float64Array: async (a) => {
-		return (await computePool.sum(a)).result;
-	}
+	Float64Array: (a) => pairwiseSum(a),
+	Float32Array: (a) => pairwiseSum(a)
 });
 const mean = mathTyped("mean", {
 	Array: (arr) => {
 		if (arr.length === 0) return NaN;
 		return pairwiseSum(arr) / arr.length;
 	},
-	Float64Array: async (a) => {
-		return (await computePool.mean(a)).result;
-	}
+	Float64Array: (a) => a.length === 0 ? NaN : pairwiseSum(a) / a.length,
+	Float32Array: (a) => a.length === 0 ? NaN : pairwiseSum(a) / a.length
 });
 function varianceFromM2(m2, n, norm) {
 	if (n === 0) return NaN;
@@ -1696,24 +1694,18 @@ function m2OfArray(arr) {
 const variance = mathTyped("variance", {
 	Array: (arr) => varianceFromM2(m2OfArray(arr), arr.length, "unbiased"),
 	"Array, string": (arr, norm) => varianceFromM2(m2OfArray(arr), arr.length, norm),
-	Float64Array: async (a) => {
-		return varianceFromM2((await computePool.variance(a)).result.variance * a.length, a.length, "unbiased");
-	},
-	"Float64Array, string": async (a, norm) => {
-		return varianceFromM2((await computePool.variance(a)).result.variance * a.length, a.length, norm);
-	}
+	Float64Array: (a) => varianceFromM2(sumSquaredDeviations(a), a.length, "unbiased"),
+	Float32Array: (a) => varianceFromM2(sumSquaredDeviations(a), a.length, "unbiased"),
+	"Float64Array, string": (a, norm) => varianceFromM2(sumSquaredDeviations(a), a.length, norm),
+	"Float32Array, string": (a, norm) => varianceFromM2(sumSquaredDeviations(a), a.length, norm)
 });
 const std = mathTyped("std", {
 	Array: (arr) => Math.sqrt(varianceFromM2(m2OfArray(arr), arr.length, "unbiased")),
 	"Array, string": (arr, norm) => Math.sqrt(varianceFromM2(m2OfArray(arr), arr.length, norm)),
-	Float64Array: async (a) => {
-		const result = await computePool.variance(a);
-		return Math.sqrt(varianceFromM2(result.result.variance * a.length, a.length, "unbiased"));
-	},
-	"Float64Array, string": async (a, norm) => {
-		const result = await computePool.variance(a);
-		return Math.sqrt(varianceFromM2(result.result.variance * a.length, a.length, norm));
-	}
+	Float64Array: (a) => Math.sqrt(varianceFromM2(sumSquaredDeviations(a), a.length, "unbiased")),
+	Float32Array: (a) => Math.sqrt(varianceFromM2(sumSquaredDeviations(a), a.length, "unbiased")),
+	"Float64Array, string": (a, norm) => Math.sqrt(varianceFromM2(sumSquaredDeviations(a), a.length, norm)),
+	"Float32Array, string": (a, norm) => Math.sqrt(varianceFromM2(sumSquaredDeviations(a), a.length, norm))
 });
 const dot = mathTyped("dot", {
 	"Array, Array": (a, b) => {
@@ -2021,11 +2013,21 @@ const UNARY = {
 	sinh,
 	cosh,
 	tanh,
-	abs
+	abs,
+	sqrt,
+	atan
 };
 const NUMERIC_LITERAL = /^[+-]?(?:\d+\.?\d*|\.\d+)(?:[eE][+-]?\d+)?$/;
+function nonFiniteDetail(value) {
+	if (typeof value === "number") {
+		if (Number.isNaN(value)) return "NaN";
+		if (value === Number.POSITIVE_INFINITY) return "Infinity";
+		if (value === Number.NEGATIVE_INFINITY) return "-Infinity";
+	}
+	return "non-finite";
+}
 function requireFinite(value, label) {
-	if (typeof value !== "number" || !Number.isFinite(value)) throw new ScalarEvalError(`evaluateScalar: '${label}' produced a non-finite value (${String(value)}).`);
+	if (typeof value !== "number" || !Number.isFinite(value)) throw new ScalarEvalError(`evaluateScalar: '${label}' produced a non-finite value (${nonFiniteDetail(value)}).`);
 	return value;
 }
 function resolveSymbol(name, scope) {
@@ -2104,7 +2106,9 @@ const LOWERED_UNARY_RULES = {
 	sinh: DUAL_UNARY_RULES.sinh,
 	cosh: DUAL_UNARY_RULES.cosh,
 	tanh: DUAL_UNARY_RULES.tanh,
-	abs: DUAL_UNARY_RULES.abs
+	abs: DUAL_UNARY_RULES.abs,
+	sqrt: DUAL_UNARY_RULES.sqrt,
+	atan: DUAL_UNARY_RULES.atan
 };
 function isScalarNode(value) {
 	if (typeof value !== "object" || value === null || Array.isArray(value)) return false;
@@ -2217,20 +2221,16 @@ function runRow(tape, scratch, rootReg, columns, params, row, grad, nParams) {
 						if (dl !== 0) {
 							const factor = powBasePartial(exp, base);
 							if (!Number.isFinite(factor)) {
-								valid = false;
-								scratch[instr.dest] = NaN;
-								setRegisterGradNaN(grad, instr.dest, nParams);
-								break;
+								grad[destBase + p] = NaN;
+								continue;
 							}
 							g += dl * factor;
 						}
 						if (dr !== 0) {
 							const factor = powExpPartial(val, base);
 							if (!Number.isFinite(factor)) {
-								valid = false;
-								scratch[instr.dest] = NaN;
-								setRegisterGradNaN(grad, instr.dest, nParams);
-								break;
+								grad[destBase + p] = NaN;
+								continue;
 							}
 							g += dr * factor;
 						}
@@ -2285,10 +2285,8 @@ function runRow(tape, scratch, rootReg, columns, params, row, grad, nParams) {
 					}
 					const d = rule.deriv(x, y);
 					if (!Number.isFinite(d)) {
-						valid = false;
-						scratch[instr.dest] = NaN;
-						setRegisterGradNaN(grad, instr.dest, nParams);
-						break;
+						grad[destBase + p] = NaN;
+						continue;
 					}
 					grad[destBase + p] = al * d;
 				}

package/dist/scalar-batch.worker.js

@@ -1,4 +1,4 @@
-import { n as runScalarBatchTask } from "./scalar-batch-task-CZd6LPg9.js";
+import { n as runScalarBatchTask } from "./scalar-batch-task-CL8ex21e.js";
 //#region src/scalar-batch.worker.ts
 const isNode = typeof process !== "undefined" && process.versions?.node !== void 0;
 let nodeParentPort = null;

package/dist/scalar-compile.d.ts

@@ -161,10 +161,10 @@ export interface CompiledScalarGradient {
     readonly parameters: readonly string[];
     /**
      * Evaluate every row. Invalid rows store `NaN` in `values` and every
-     * gradient entry for that row. The mask matches {@link compileScalar} except
-     * when a consumed `^` partial is not finite (a live child lane of `0^0`, or
-     * `ln` of a negative base with a live exponent): those rows are extra-invalid.
-     * Throws {@link ScalarEvalError} for binding mismatches or bad `out` lengths.
+     * gradient entry for that row. The `valid` mask matches {@link compileScalar}
+     * (primal evaluation only). When a parameter partial is not finite the row
+     * stays valid and the affected gradient entries are `NaN`; the fitter treats
+     * non-finite Jacobian entries as a failed step.
      *
      * @example
      * ```ts

package/dist/scalar-compile.d.ts.map

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

package/dist/scalar-dimension.d.ts

@@ -28,6 +28,14 @@ export type ParameterDimensionResult = {
 } | {
     readonly inconsistent: true;
 };
+declare function validateDimensionVector(vector: RationalDimension, label?: string): void;
+/**
+ * @internal Exported for `scalar-search.ts`'s option validation, not the package
+ * barrel. The same length-and-`Fraction` check the inference entry points run.
+ */
+export { validateDimensionVector };
+/** Exact equality of two {@link RationalDimension} vectors. */
+export declare function rationalDimensionsEqual(a: RationalDimension, b: RationalDimension): boolean;
 /**
  * Infer the SI dimension of a scalar tree, or report a structural violation.
  */
@@ -51,4 +59,28 @@ export declare function inferScalarDimension(node: ScalarNode, dims: Readonly<Re
 export declare function solveParameterDimensions(node: ScalarNode, dims: Readonly<Record<string, RationalDimension>>, target: RationalDimension, parameters: readonly string[], options?: {
     readonly dimensionlessOnly?: boolean;
 }): ParameterDimensionResult;
+/** Options for {@link unitToRationalDimension}. */
+export interface UnitDimensionOptions {
+    /** Caller map from a unit name to its seven-axis dimension. Set: no `Unit` is built and the information axis is not read. */
+    readonly mapUnit?: (unitName: string) => RationalDimension;
+}
+/**
+ * The SI dimension of a unit name as a {@link RationalDimension}.
+ *
+ * Builds `new Unit(1, unitName)` and maps its length-10 exponent vector through
+ * {@link toSiDimensionVector}. Supplementary angle and solid-angle exponents
+ * (`rad`, `deg`, `sr`, …) map to a dimensionless 7-vector. Information units
+ * (`bit`, `byte`, …) are not representable in the seven SI base dimensions and
+ * throw {@link UnitParseError}. An unknown unit name throws the same
+ * {@link UnitParseError} `Unit` already throws. `unitName` must be a string.
+ *
+ * With `options.mapUnit` the caller's map gives the dimension, so a unit such as `bit` can map to a caller-chosen vector.
+ *
+ * @example
+ * ```ts
+ * import { unitToRationalDimension } from '@danielsimonjr/mathts-functions';
+ * unitToRationalDimension('m')[0].toString(); // '1'
+ * ```
+ */
+export declare function unitToRationalDimension(unitName: string, options?: UnitDimensionOptions): RationalDimension;
 //# sourceMappingURL=scalar-dimension.d.ts.map

package/dist/scalar-dimension.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"scalar-dimension.d.ts","sourceRoot":"","sources":["../src/scalar-dimension.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAEH,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,kCAAkC,CAAC;AACnE,OAAO,EAAiC,KAAK,iBAAiB,EAAE,MAAM,4BAA4B,CAAC;AAInG,iEAAiE;AACjE,MAAM,MAAM,iBAAiB,GAAG,iBAAiB,CAAC;AAElD,8CAA8C;AAC9C,MAAM,MAAM,kBAAkB,GAC1B;IAAE,QAAQ,CAAC,EAAE,EAAE,IAAI,CAAC;IAAC,QAAQ,CAAC,SAAS,EAAE,iBAAiB,CAAA;CAAE,GAC5D;IACE,QAAQ,CAAC,EAAE,EAAE,KAAK,CAAC;IACnB,QAAQ,CAAC,SAAS,EACd,cAAc,GACd,sCAAsC,GACtC,0CAA0C,GAC1C,gBAAgB,CAAC;IACrB,QAAQ,CAAC,IAAI,EAAE,SAAS,MAAM,EAAE,CAAC;CAClC,CAAC;AAEN,kDAAkD;AAClD,MAAM,MAAM,wBAAwB,GAChC;IAAE,QAAQ,CAAC,MAAM,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,iBAAiB,CAAC,CAAC,CAAA;CAAE,GAChE;IAAE,QAAQ,CAAC,eAAe,EAAE,SAAS,MAAM,EAAE,CAAA;CAAE,GAC/C;IAAE,QAAQ,CAAC,YAAY,EAAE,IAAI,CAAA;CAAE,CAAC;AAwVpC;;GAEG;AACH,wBAAgB,oBAAoB,CAClC,IAAI,EAAE,UAAU,EAChB,IAAI,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,iBAAiB,CAAC,CAAC,GAChD,kBAAkB,CASpB;AA2ED;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,wBAAwB,CACtC,IAAI,EAAE,UAAU,EAChB,IAAI,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,iBAAiB,CAAC,CAAC,EACjD,MAAM,EAAE,iBAAiB,EACzB,UAAU,EAAE,SAAS,MAAM,EAAE,EAC7B,OAAO,CAAC,EAAE;IAAE,QAAQ,CAAC,iBAAiB,CAAC,EAAE,OAAO,CAAA;CAAE,GACjD,wBAAwB,CA+D1B"}
+{"version":3,"file":"scalar-dimension.d.ts","sourceRoot":"","sources":["../src/scalar-dimension.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAEH,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,kCAAkC,CAAC;AACnE,OAAO,EAML,KAAK,iBAAiB,EACvB,MAAM,4BAA4B,CAAC;AAIpC,iEAAiE;AACjE,MAAM,MAAM,iBAAiB,GAAG,iBAAiB,CAAC;AAElD,8CAA8C;AAC9C,MAAM,MAAM,kBAAkB,GAC1B;IAAE,QAAQ,CAAC,EAAE,EAAE,IAAI,CAAC;IAAC,QAAQ,CAAC,SAAS,EAAE,iBAAiB,CAAA;CAAE,GAC5D;IACE,QAAQ,CAAC,EAAE,EAAE,KAAK,CAAC;IACnB,QAAQ,CAAC,SAAS,EACd,cAAc,GACd,sCAAsC,GACtC,0CAA0C,GAC1C,gBAAgB,CAAC;IACrB,QAAQ,CAAC,IAAI,EAAE,SAAS,MAAM,EAAE,CAAC;CAClC,CAAC;AAEN,kDAAkD;AAClD,MAAM,MAAM,wBAAwB,GAChC;IAAE,QAAQ,CAAC,MAAM,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,iBAAiB,CAAC,CAAC,CAAA;CAAE,GAChE;IAAE,QAAQ,CAAC,eAAe,EAAE,SAAS,MAAM,EAAE,CAAA;CAAE,GAC/C;IAAE,QAAQ,CAAC,YAAY,EAAE,IAAI,CAAA;CAAE,CAAC;AAiEpC,iBAAS,uBAAuB,CAAC,MAAM,EAAE,iBAAiB,EAAE,KAAK,SAAqB,GAAG,IAAI,CAQ5F;AAED;;;GAGG;AACH,OAAO,EAAE,uBAAuB,EAAE,CAAC;AAEnC,+DAA+D;AAC/D,wBAAgB,uBAAuB,CAAC,CAAC,EAAE,iBAAiB,EAAE,CAAC,EAAE,iBAAiB,GAAG,OAAO,CAS3F;AAsRD;;GAEG;AACH,wBAAgB,oBAAoB,CAClC,IAAI,EAAE,UAAU,EAChB,IAAI,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,iBAAiB,CAAC,CAAC,GAChD,kBAAkB,CASpB;AA2ED;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,wBAAwB,CACtC,IAAI,EAAE,UAAU,EAChB,IAAI,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,iBAAiB,CAAC,CAAC,EACjD,MAAM,EAAE,iBAAiB,EACzB,UAAU,EAAE,SAAS,MAAM,EAAE,EAC7B,OAAO,CAAC,EAAE;IAAE,QAAQ,CAAC,iBAAiB,CAAC,EAAE,OAAO,CAAA;CAAE,GACjD,wBAAwB,CAoE1B;AAED,mDAAmD;AACnD,MAAM,WAAW,oBAAoB;IACnC,6HAA6H;IAC7H,QAAQ,CAAC,OAAO,CAAC,EAAE,CAAC,QAAQ,EAAE,MAAM,KAAK,iBAAiB,CAAC;CAC5D;AAED;;;;;;;;;;;;;;;;;GAiBG;AACH,wBAAgB,uBAAuB,CACrC,QAAQ,EAAE,MAAM,EAChB,OAAO,CAAC,EAAE,oBAAoB,GAC7B,iBAAiB,CAsBnB"}

package/dist/scalar-eval.d.ts

@@ -14,8 +14,10 @@
  * arguments and calls MathTS `pow`. One-argument `-` does not negate; a
  * unary minus is `(-1) * x`.
  *
- * A non-finite operator or call result throws {@link ScalarEvalError}. A bare
- * symbol or number is returned as stored, including a non-finite value.
+ * A non-finite operator or call result throws {@link ScalarEvalError}. That
+ * includes `sqrt` of a negative argument (complex-valued in MathTS), and
+ * `sqrt(Infinity)` / `sqrt(NaN)`. A bare symbol or number is returned as
+ * stored, including a non-finite value.
  *
  * @packageDocumentation
  */

package/dist/scalar-eval.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"scalar-eval.d.ts","sourceRoot":"","sources":["../src/scalar-eval.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;GAoBG;AA0BH,gFAAgF;AAChF,MAAM,MAAM,WAAW,GAAG,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC,CAAC;AAE3D,wFAAwF;AACxF,eAAO,MAAM,MAAM,0DAAwB,CAAC;AAE5C,4CAA4C;AAC5C,qBAAa,eAAgB,SAAQ,KAAK;IACxC,YAAY,OAAO,EAAE,MAAM,EAG1B;CACF;AAgBD;;;;;GAKG;AACH,eAAO,MAAM,eAAe,QAAgD,CAAC;AAuF7E;;;;;GAKG;AACH,wBAAgB,cAAc,CAAC,IAAI,EAAE,OAAO,EAAE,KAAK,GAAE,WAAgB,GAAG,MAAM,CAU7E"}
+{"version":3,"file":"scalar-eval.d.ts","sourceRoot":"","sources":["../src/scalar-eval.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;GAsBG;AA2BH,gFAAgF;AAChF,MAAM,MAAM,WAAW,GAAG,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC,CAAC;AAE3D,wFAAwF;AACxF,eAAO,MAAM,MAAM,0DAAwB,CAAC;AAE5C,4CAA4C;AAC5C,qBAAa,eAAgB,SAAQ,KAAK;IACxC,YAAY,OAAO,EAAE,MAAM,EAG1B;CACF;AAkBD;;;;;GAKG;AACH,eAAO,MAAM,eAAe,QAAgD,CAAC;AAuG7E;;;;;GAKG;AACH,wBAAgB,cAAc,CAAC,IAAI,EAAE,OAAO,EAAE,KAAK,GAAE,WAAgB,GAAG,MAAM,CAU7E"}

package/dist/scalar-node-bridge.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"scalar-node-bridge.d.ts","sourceRoot":"","sources":["../src/scalar-node-bridge.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,OAAO,KAAK,EAEV,QAAQ,EACR,UAAU,EACV,aAAa,EACd,MAAM,kCAAkC,CAAC;AAE1C,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,mBAAmB,CAAC;AASzD,YAAY,EAAE,QAAQ,EAAE,aAAa,EAAE,eAAe,EAAE,CAAC;AAmCzD,KAAK,YAAY,GAAG,KAAK,KAAK,EAAE,MAAM,KAAK,QAAQ,CAAC;AACpD,KAAK,UAAU,GAAG,KAAK,IAAI,EAAE,MAAM,KAAK,QAAQ,CAAC;AACjD,KAAK,YAAY,GAAG,KAClB,EAAE,EAAE,MAAM,EACV,EAAE,EAAE,MAAM,EACV,IAAI,EAAE,QAAQ,EAAE,EAChB,QAAQ,CAAC,EAAE,OAAO,EAClB,YAAY,CAAC,EAAE,OAAO,KACnB,QAAQ,CAAC;AACd,KAAK,YAAY,GAAG,KAAK,EAAE,EAAE,MAAM,EAAE,IAAI,EAAE,QAAQ,EAAE,KAAK,QAAQ,CAAC;AAEnE,MAAM,WAAW,oBAAoB;IACnC,YAAY,EAAE,YAAY,CAAC;IAC3B,UAAU,EAAE,UAAU,CAAC;IACvB,YAAY,EAAE,YAAY,CAAC;IAC3B,YAAY,EAAE,YAAY,CAAC;IAC3B,QAAQ,EAAE,CAAC,IAAI,EAAE,QAAQ,EAAE,GAAG,IAAI,EAAE,OAAO,EAAE,KAAK,QAAQ,CAAC;CAC5D;AAwMD;;;GAGG;AACH,wBAAgB,sBAAsB,CAAC,IAAI,EAAE,oBAAoB;yBAenC,UAAU,KAAG,QAAQ;yBAiBrB,QAAQ,KAAG,UAAU;2BAsBnB,UAAU,YAAY,eAAe,KAAG,UAAU;wBA+BrD,UAAU,YAAY,aAAa,KAAG,MAAM;EAMxE"}
+{"version":3,"file":"scalar-node-bridge.d.ts","sourceRoot":"","sources":["../src/scalar-node-bridge.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,OAAO,KAAK,EAEV,QAAQ,EACR,UAAU,EACV,aAAa,EACd,MAAM,kCAAkC,CAAC;AAE1C,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,mBAAmB,CAAC;AASzD,YAAY,EAAE,QAAQ,EAAE,aAAa,EAAE,eAAe,EAAE,CAAC;AAwBzD,KAAK,YAAY,GAAG,KAAK,KAAK,EAAE,MAAM,KAAK,QAAQ,CAAC;AACpD,KAAK,UAAU,GAAG,KAAK,IAAI,EAAE,MAAM,KAAK,QAAQ,CAAC;AACjD,KAAK,YAAY,GAAG,KAClB,EAAE,EAAE,MAAM,EACV,EAAE,EAAE,MAAM,EACV,IAAI,EAAE,QAAQ,EAAE,EAChB,QAAQ,CAAC,EAAE,OAAO,EAClB,YAAY,CAAC,EAAE,OAAO,KACnB,QAAQ,CAAC;AACd,KAAK,YAAY,GAAG,KAAK,EAAE,EAAE,MAAM,EAAE,IAAI,EAAE,QAAQ,EAAE,KAAK,QAAQ,CAAC;AAEnE,MAAM,WAAW,oBAAoB;IACnC,YAAY,EAAE,YAAY,CAAC;IAC3B,UAAU,EAAE,UAAU,CAAC;IACvB,YAAY,EAAE,YAAY,CAAC;IAC3B,YAAY,EAAE,YAAY,CAAC;IAC3B,QAAQ,EAAE,CAAC,IAAI,EAAE,QAAQ,EAAE,GAAG,IAAI,EAAE,OAAO,EAAE,KAAK,QAAQ,CAAC;CAC5D;AAwMD;;;GAGG;AACH,wBAAgB,sBAAsB,CAAC,IAAI,EAAE,oBAAoB;yBAenC,UAAU,KAAG,QAAQ;yBAiBrB,QAAQ,KAAG,UAAU;2BAsBnB,UAAU,YAAY,eAAe,KAAG,UAAU;wBA+BrD,UAAU,YAAY,aAAa,KAAG,MAAM;EAMxE"}