universal-physics-tensor 0.45.2 → 0.47.0

package/dist/atlas/witness-numeric.js

@@ -0,0 +1,105 @@
+/**
+ * Atlas Phase 4, S4.2 — the numeric witness runner.
+ *
+ * Design note: `docs/planning/Atlas-Phase-4-Design.md` §2.3.
+ *
+ * A numeric witness evaluates a claim at TWO resolutions and reports whether
+ * refinement moved the answer toward the target. Two resolutions are the
+ * minimum that can say anything at all: one number agreeing with a target is
+ * consistent with a scheme that is simply wrong by an amount the tolerance
+ * happens to admit.
+ *
+ * ## The ratio is REPORTED, never compared against an expected order
+ *
+ * `convergence.ratio = |coarse − target| / |fine − target|` is the factor by
+ * which refinement reduced the error. A second-order scheme halving its step
+ * should give ≈ 4; a first-order one ≈ 2. **Nothing here asserts which.** The
+ * witnesses in hand do not all record their scheme's order, and asserting an
+ * order nobody wrote down would be fabrication of exactly the kind this sprint
+ * forbids. The number goes into the results artifact; a reviewer reads it.
+ *
+ * What the runner DOES decide is the weaker, checkable thing: a ratio at or
+ * below 1 means refinement did NOT improve the answer, and that earns
+ * `'unresolved'` rather than `'checked'` — a fine value that happens to land
+ * inside the tolerance while refinement is not converging is agreement by
+ * accident, and the tolerance alone cannot tell the two apart.
+ *
+ * @module atlas/witness-numeric
+ * @internal
+ */
+/**
+ * Run one numeric witness at two resolutions.
+ *
+ * @param spec - the claim and its two resolutions.
+ * @returns a result carrying `convergence`; **never throws** — an evaluation
+ * that throws is `'unresolved'` with `'parse-error'`, because a scheme that
+ * blew up has not refuted the physics it was evaluating.
+ * @internal
+ */
+export function runNumericWitness(spec) {
+    const started = Date.now();
+    const base = { witnessId: spec.id, kind: 'numeric' };
+    const elapsed = () => Date.now() - started;
+    let coarseValue;
+    let fineValue;
+    try {
+        coarseValue = spec.evaluate(spec.coarseResolution);
+        fineValue = spec.evaluate(spec.fineResolution);
+    }
+    catch (err) {
+        return {
+            ...base,
+            status: 'unresolved',
+            reason: 'parse-error',
+            detail: `Evaluation threw rather than producing a number: ${String(err)}.`,
+            elapsedMs: elapsed(),
+        };
+    }
+    if (!Number.isFinite(coarseValue) || !Number.isFinite(fineValue)) {
+        return {
+            ...base,
+            status: 'unresolved',
+            reason: 'parse-error',
+            detail: `Evaluation produced a non-finite value (coarse ${coarseValue}, fine ` +
+                `${fineValue}). Nothing is concluded from it.`,
+            elapsedMs: elapsed(),
+        };
+    }
+    const coarse = Math.abs(coarseValue - spec.target);
+    const fine = Math.abs(fineValue - spec.target);
+    // fine === 0 ⇒ an exact scheme. Infinity is the honest ratio there, and the
+    // comparisons below treat it as "refinement helped", which it did.
+    const ratio = fine === 0 ? (coarse === 0 ? 1 : Infinity) : coarse / fine;
+    const convergence = { coarse, fine, ratio };
+    if (fine > spec.tolerance) {
+        return {
+            ...base,
+            status: 'refuted',
+            convergence,
+            detail: `The fine evaluation misses the target by ${fine}, outside the stated ` +
+                `tolerance ${spec.tolerance}.`,
+            elapsedMs: elapsed(),
+        };
+    }
+    if (ratio <= 1) {
+        return {
+            ...base,
+            status: 'unresolved',
+            reason: 'no-convergence',
+            convergence,
+            detail: `Refinement did not reduce the error (ratio ${ratio}). The fine value is ` +
+                'inside tolerance, but agreement that does not improve with refinement is ' +
+                'not evidence that the scheme converges to the target.',
+            elapsedMs: elapsed(),
+        };
+    }
+    return {
+        ...base,
+        status: 'checked',
+        convergence,
+        detail: `Fine error ${fine} is within tolerance ${spec.tolerance}, and refinement ` +
+            `reduced the error by a factor of ${ratio}.`,
+        elapsedMs: elapsed(),
+    };
+}
+//# sourceMappingURL=witness-numeric.js.map

package/dist/atlas/witness-numeric.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"witness-numeric.js","sourceRoot":"","sources":["../../src/atlas/witness-numeric.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4BG;AA+CH;;;;;;;;GAQG;AACH,MAAM,UAAU,iBAAiB,CAAC,IAAwB;IACxD,MAAM,OAAO,GAAG,IAAI,CAAC,GAAG,EAAE,CAAC;IAC3B,MAAM,IAAI,GAAG,EAAE,SAAS,EAAE,IAAI,CAAC,EAAE,EAAE,IAAI,EAAE,SAAkB,EAAE,CAAC;IAC9D,MAAM,OAAO,GAAG,GAAW,EAAE,CAAC,IAAI,CAAC,GAAG,EAAE,GAAG,OAAO,CAAC;IAEnD,IAAI,WAAmB,CAAC;IACxB,IAAI,SAAiB,CAAC;IACtB,IAAI,CAAC;QACH,WAAW,GAAG,IAAI,CAAC,QAAQ,CAAC,IAAI,CAAC,gBAAgB,CAAC,CAAC;QACnD,SAAS,GAAG,IAAI,CAAC,QAAQ,CAAC,IAAI,CAAC,cAAc,CAAC,CAAC;IACjD,CAAC;IAAC,OAAO,GAAG,EAAE,CAAC;QACb,OAAO;YACL,GAAG,IAAI;YACP,MAAM,EAAE,YAAY;YACpB,MAAM,EAAE,aAAa;YACrB,MAAM,EAAE,oDAAoD,MAAM,CAAC,GAAG,CAAC,GAAG;YAC1E,SAAS,EAAE,OAAO,EAAE;SACrB,CAAC;IACJ,CAAC;IAED,IAAI,CAAC,MAAM,CAAC,QAAQ,CAAC,WAAW,CAAC,IAAI,CAAC,MAAM,CAAC,QAAQ,CAAC,SAAS,CAAC,EAAE,CAAC;QACjE,OAAO;YACL,GAAG,IAAI;YACP,MAAM,EAAE,YAAY;YACpB,MAAM,EAAE,aAAa;YACrB,MAAM,EACJ,kDAAkD,WAAW,SAAS;gBACtE,GAAG,SAAS,kCAAkC;YAChD,SAAS,EAAE,OAAO,EAAE;SACrB,CAAC;IACJ,CAAC;IAED,MAAM,MAAM,GAAG,IAAI,CAAC,GAAG,CAAC,WAAW,GAAG,IAAI,CAAC,MAAM,CAAC,CAAC;IACnD,MAAM,IAAI,GAAG,IAAI,CAAC,GAAG,CAAC,SAAS,GAAG,IAAI,CAAC,MAAM,CAAC,CAAC;IAC/C,4EAA4E;IAC5E,mEAAmE;IACnE,MAAM,KAAK,GAAG,IAAI,KAAK,CAAC,CAAC,CAAC,CAAC,CAAC,MAAM,KAAK,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,QAAQ,CAAC,CAAC,CAAC,CAAC,MAAM,GAAG,IAAI,CAAC;IACzE,MAAM,WAAW,GAAgB,EAAE,MAAM,EAAE,IAAI,EAAE,KAAK,EAAE,CAAC;IAEzD,IAAI,IAAI,GAAG,IAAI,CAAC,SAAS,EAAE,CAAC;QAC1B,OAAO;YACL,GAAG,IAAI;YACP,MAAM,EAAE,SAAS;YACjB,WAAW;YACX,MAAM,EACJ,4CAA4C,IAAI,uBAAuB;gBACvE,aAAa,IAAI,CAAC,SAAS,GAAG;YAChC,SAAS,EAAE,OAAO,EAAE;SACrB,CAAC;IACJ,CAAC;IAED,IAAI,KAAK,IAAI,CAAC,EAAE,CAAC;QACf,OAAO;YACL,GAAG,IAAI;YACP,MAAM,EAAE,YAAY;YACpB,MAAM,EAAE,gBAAgB;YACxB,WAAW;YACX,MAAM,EACJ,8CAA8C,KAAK,uBAAuB;gBAC1E,2EAA2E;gBAC3E,uDAAuD;YACzD,SAAS,EAAE,OAAO,EAAE;SACrB,CAAC;IACJ,CAAC;IAED,OAAO;QACL,GAAG,IAAI;QACP,MAAM,EAAE,SAAS;QACjB,WAAW;QACX,MAAM,EACJ,cAAc,IAAI,wBAAwB,IAAI,CAAC,SAAS,mBAAmB;YAC3E,oCAAoC,KAAK,GAAG;QAC9C,SAAS,EAAE,OAAO,EAAE;KACrB,CAAC;AACJ,CAAC"}

package/dist/atlas/witness-result.d.ts

@@ -0,0 +1,77 @@
+/**
+ * Atlas Phase 4, S4.2 — the shape a witness run reports.
+ *
+ * Design note: `docs/planning/Atlas-Phase-4-Design.md` §2.2.
+ *
+ * **The load-bearing distinction in this file: a check that DID NOT RUN is not
+ * a check that FAILED.** Peer absent, budget exhausted, and parser throw are
+ * all `'unresolved'`, each carrying the reason it could not answer. Only a
+ * check that COMPLETES and finds a disagreement is `'refuted'`.
+ *
+ * This repo has been bitten by exactly that conflation more than once — a
+ * checker that discarded its own stderr manufactured a false negative
+ * indistinguishable from a clean pass. Folding "could not run" into "failed"
+ * is the same defect with the sign flipped: it turns a missing optional peer
+ * into a refutation of the physics.
+ *
+ * Nothing here throws. A runner that threw would force every caller into a
+ * `try`/`catch` whose `catch` arm cannot tell which of the three outcomes it
+ * is looking at.
+ *
+ * @module atlas/witness-result
+ * @internal
+ */
+/**
+ * What a witness run concluded.
+ *
+ * - `'checked'` — the check RAN and the claim held.
+ * - `'refuted'` — the check RAN and the claim did not hold.
+ * - `'unresolved'` — the check did not run, or ran and could not decide.
+ *
+ * @internal
+ */
+export type WitnessStatus = 'checked' | 'refuted' | 'unresolved';
+/**
+ * Why a witness is `'unresolved'`. Required on that status so a reader never
+ * has to guess which of four very different situations produced it.
+ *
+ * @internal
+ */
+export type UnresolvedReason = 
+/** The optional peer that performs the check is not installed. */
+'peer-absent'
+/** The wall-clock budget elapsed before an answer arrived. */
+ | 'timeout'
+/** The input could not be parsed or evaluated at all. */
+ | 'parse-error'
+/** The check ran to completion and neither confirmed nor refuted. */
+ | 'not-simplified'
+/** Refinement did not improve the answer, so nothing is concluded. */
+ | 'no-convergence';
+/** What one witness run produced. @internal */
+export interface WitnessRunResult {
+    /** The `Witness.id` this run corresponds to (`'W7b'`). */
+    readonly witnessId: string;
+    readonly kind: 'symbolic' | 'numeric';
+    readonly status: WitnessStatus;
+    /** REQUIRED when `status === 'unresolved'`, absent otherwise. */
+    readonly reason?: UnresolvedReason;
+    /** Human-readable note — never the discriminator, always the explanation. */
+    readonly detail: string;
+    /** Milliseconds the runner waited. */
+    readonly elapsedMs: number;
+}
+/**
+ * The ids of runs that CHECKED, as `deriveEvidence` wants its
+ * `passingWitnessIds` argument.
+ *
+ * A convenience with one purpose: keep the mapping from run results to
+ * "passing" in ONE place. Writing `results.filter(r => r.status !== 'refuted')`
+ * at a call site would hand `symbolically-checked` to every unresolved run —
+ * the free-tag defect `derive-evidence.ts` documents at length, reintroduced
+ * one layer up.
+ *
+ * @internal
+ */
+export declare function passingWitnessIds(results: readonly WitnessRunResult[]): ReadonlySet<string>;
+//# sourceMappingURL=witness-result.d.ts.map

package/dist/atlas/witness-result.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"witness-result.d.ts","sourceRoot":"","sources":["../../src/atlas/witness-result.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;GAsBG;AAEH;;;;;;;;GAQG;AACH,MAAM,MAAM,aAAa,GAAG,SAAS,GAAG,SAAS,GAAG,YAAY,CAAC;AAEjE;;;;;GAKG;AACH,MAAM,MAAM,gBAAgB;AAC1B,kEAAkE;AAChE,aAAa;AACf,8DAA8D;GAC5D,SAAS;AACX,yDAAyD;GACvD,aAAa;AACf,qEAAqE;GACnE,gBAAgB;AAClB,sEAAsE;GACpE,gBAAgB,CAAC;AAErB,+CAA+C;AAC/C,MAAM,WAAW,gBAAgB;IAC/B,0DAA0D;IAC1D,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAC;IAC3B,QAAQ,CAAC,IAAI,EAAE,UAAU,GAAG,SAAS,CAAC;IACtC,QAAQ,CAAC,MAAM,EAAE,aAAa,CAAC;IAC/B,iEAAiE;IACjE,QAAQ,CAAC,MAAM,CAAC,EAAE,gBAAgB,CAAC;IACnC,6EAA6E;IAC7E,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;IACxB,sCAAsC;IACtC,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAC;CAC5B;AAED;;;;;;;;;;;GAWG;AACH,wBAAgB,iBAAiB,CAC/B,OAAO,EAAE,SAAS,gBAAgB,EAAE,GACnC,WAAW,CAAC,MAAM,CAAC,CAErB"}

package/dist/atlas/witness-result.js

@@ -0,0 +1,39 @@
+/**
+ * Atlas Phase 4, S4.2 — the shape a witness run reports.
+ *
+ * Design note: `docs/planning/Atlas-Phase-4-Design.md` §2.2.
+ *
+ * **The load-bearing distinction in this file: a check that DID NOT RUN is not
+ * a check that FAILED.** Peer absent, budget exhausted, and parser throw are
+ * all `'unresolved'`, each carrying the reason it could not answer. Only a
+ * check that COMPLETES and finds a disagreement is `'refuted'`.
+ *
+ * This repo has been bitten by exactly that conflation more than once — a
+ * checker that discarded its own stderr manufactured a false negative
+ * indistinguishable from a clean pass. Folding "could not run" into "failed"
+ * is the same defect with the sign flipped: it turns a missing optional peer
+ * into a refutation of the physics.
+ *
+ * Nothing here throws. A runner that threw would force every caller into a
+ * `try`/`catch` whose `catch` arm cannot tell which of the three outcomes it
+ * is looking at.
+ *
+ * @module atlas/witness-result
+ * @internal
+ */
+/**
+ * The ids of runs that CHECKED, as `deriveEvidence` wants its
+ * `passingWitnessIds` argument.
+ *
+ * A convenience with one purpose: keep the mapping from run results to
+ * "passing" in ONE place. Writing `results.filter(r => r.status !== 'refuted')`
+ * at a call site would hand `symbolically-checked` to every unresolved run —
+ * the free-tag defect `derive-evidence.ts` documents at length, reintroduced
+ * one layer up.
+ *
+ * @internal
+ */
+export function passingWitnessIds(results) {
+    return new Set(results.filter((r) => r.status === 'checked').map((r) => r.witnessId));
+}
+//# sourceMappingURL=witness-result.js.map

package/dist/atlas/witness-result.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"witness-result.js","sourceRoot":"","sources":["../../src/atlas/witness-result.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;GAsBG;AA6CH;;;;;;;;;;;GAWG;AACH,MAAM,UAAU,iBAAiB,CAC/B,OAAoC;IAEpC,OAAO,IAAI,GAAG,CAAC,OAAO,CAAC,MAAM,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,MAAM,KAAK,SAAS,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,SAAS,CAAC,CAAC,CAAC;AACxF,CAAC"}

package/dist/atlas/witness-specs.d.ts

@@ -0,0 +1,110 @@
+/**
+ * Atlas Phase 4, S4.3 — the EXECUTABLE witness registry.
+ *
+ * Design note: `docs/planning/Atlas-Phase-4-Design.md` §3.
+ *
+ * A `Witness` record names a check and the test file that runs it; it carries
+ * nothing a runner can execute. This module holds the executable form of every
+ * witness the results artifact covers, keyed by the record it supports. The
+ * Lead-run `scripts/emit-witness-results.mjs` runs exactly this list, and
+ * `tests/atlas/witness-results.test.ts` deep-equals the committed artifact
+ * against a fresh run of it.
+ *
+ * ## The symbolic specs apply the bridge's DICTIONARY, they do not restate it
+ *
+ * Writing `lhs` and `rhs` as two hand-typed ASTs that happen to be equal would
+ * check nothing but the typist. Each spec below starts from the PREMISE
+ * model's expression and pushes it through the bridge's variable dictionary
+ * with `substitute`; the CAS then has to show that the result equals the
+ * CONCLUSION model's expression. What is checked is the dictionary.
+ *
+ * @module atlas/witness-specs
+ * @internal
+ */
+import type { HeatFixture, LangevinFixture, SteadyStateFixture, WickFixture } from './diffusion/numerics.js';
+import type { AcousticFixture, DalembertFixture, StringFixture } from './waves/numerics.js';
+import type { NumericWitnessSpec } from './witness-numeric.js';
+import type { SymbolicWitnessSpec } from './witness-symbolic.js';
+/** A symbolic spec bound to the record it supports. @internal */
+export interface RegisteredSymbolicWitness {
+    /** The `AtlasBridge.id` (or other record id) the witness belongs to. */
+    readonly recordId: string;
+    readonly kind: 'symbolic';
+    readonly spec: SymbolicWitnessSpec;
+}
+/** A numeric spec bound to the record it supports. @internal */
+export interface RegisteredNumericWitness {
+    readonly recordId: string;
+    readonly kind: 'numeric';
+    readonly spec: NumericWitnessSpec;
+}
+/** One entry of the registry. @internal */
+export type RegisteredWitness = RegisteredSymbolicWitness | RegisteredNumericWitness;
+/** WD1 fixture: D and t, fixed while the walk is refined. @internal */
+export declare const WD1_FIXTURE: {
+    readonly D: 0.5;
+    readonly t: 2;
+};
+/**
+ * WD2 fixture. κ, ρ and c_p are chosen so the heat equation's own variables
+ * are all different from 1 while κ/(ρ c_p) = 1: a dictionary that dropped or
+ * inverted a factor would move the answer.
+ *
+ * @internal
+ */
+export declare const WD2_FIXTURE: HeatFixture;
+/** WD3 fixture: an off-centre point, so no symmetry zeroes a derivative. @internal */
+export declare const WD3_FIXTURE: WickFixture;
+/** WS1 fixture: F and μ both ≠ 1 while c = √(F/μ) = 2. @internal */
+export declare const WS1_FIXTURE: StringFixture;
+/** WS2 fixture: an off-centre point where both profiles contribute. @internal */
+export declare const WS2_FIXTURE: DalembertFixture;
+/** WS3 fixture: γ = 1.4 with nondimensional p₀ = 1, ρ₀ = 1.2. @internal */
+export declare const WS3_FIXTURE: AcousticFixture;
+/** WS4 fixture: ω₀ = c = 1, base wavenumber k₀ = 10 (the domain edge ω₀/(ck) = 0.1). @internal */
+export declare const WS4_FIXTURE: {
+    readonly omega0: 1;
+    readonly c: 1;
+    readonly k0: 10;
+};
+/** WD4 fixture: m, γ, k_BT all ≠ 1; τ_p = m/γ = 4. @internal */
+export declare const WD4_FIXTURE: LangevinFixture;
+/** WD6 base: τ₀ = 0.1 with D = q = 1, so ε = τ at the resolution's τ = τ₀/resolution. @internal */
+export declare const WD6_FIXTURE: {
+    readonly tau0: 0.1;
+    readonly D: 1;
+    readonly q: 1;
+};
+/** WD7 base: ε = 25 · resolution with D = q = 1. @internal */
+export declare const WD7_FIXTURE: {
+    readonly eps0: 25;
+    readonly D: 1;
+    readonly q: 1;
+};
+/** WD8 fixture: a unit rod held at 2 and 5, base time 0.1 (Fourier number 0.1 per unit). @internal */
+export declare const WD8_FIXTURE: SteadyStateFixture;
+/** WS5 base: x₀ = ck/ω₀ = 0.1, halved per resolution step. @internal */
+export declare const WS5_FIXTURE: {
+    readonly x0: 0.1;
+};
+/** WS6 fixture: c = 1, ω₀ = 2, t = 3; resolution = time steps. @internal */
+export declare const WS6_FIXTURE: {
+    readonly c: 1;
+    readonly omega0: 2;
+    readonly tEnd: 3;
+};
+/** WS7 fixture: F = 100, μ = 0.01 (so √(F/μ) = 100), EI = 0.01, k₀ = 10 (β = 0.01 at res 1). @internal */
+export declare const WS7_FIXTURE: {
+    readonly F: 100;
+    readonly mu: 0.01;
+    readonly EI: 0.01;
+    readonly k0: 10;
+};
+/**
+ * Every witness the results artifact covers, in a fixed order (the artifact is
+ * emitted in this order, so reordering is a reviewable diff, not churn).
+ *
+ * @internal
+ */
+export declare const WITNESS_REGISTRY: readonly RegisteredWitness[];
+//# sourceMappingURL=witness-specs.d.ts.map

package/dist/atlas/witness-specs.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"witness-specs.d.ts","sourceRoot":"","sources":["../../src/atlas/witness-specs.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;GAsBG;AAwBH,OAAO,KAAK,EACV,WAAW,EACX,eAAe,EACf,kBAAkB,EAClB,WAAW,EACZ,MAAM,yBAAyB,CAAC;AAajC,OAAO,KAAK,EAAE,eAAe,EAAE,gBAAgB,EAAE,aAAa,EAAE,MAAM,qBAAqB,CAAC;AAC5F,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,sBAAsB,CAAC;AAC/D,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,uBAAuB,CAAC;AAEjE,iEAAiE;AACjE,MAAM,WAAW,yBAAyB;IACxC,wEAAwE;IACxE,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC;IAC1B,QAAQ,CAAC,IAAI,EAAE,UAAU,CAAC;IAC1B,QAAQ,CAAC,IAAI,EAAE,mBAAmB,CAAC;CACpC;AAED,gEAAgE;AAChE,MAAM,WAAW,wBAAwB;IACvC,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC;IAC1B,QAAQ,CAAC,IAAI,EAAE,SAAS,CAAC;IACzB,QAAQ,CAAC,IAAI,EAAE,kBAAkB,CAAC;CACnC;AAED,2CAA2C;AAC3C,MAAM,MAAM,iBAAiB,GAAG,yBAAyB,GAAG,wBAAwB,CAAC;AA4CrF,uEAAuE;AACvE,eAAO,MAAM,WAAW;aAAK,CAAC,EAAE,GAAG;aAAE,CAAC,EAAE,CAAC;CAAW,CAAC;AAErD;;;;;;GAMG;AACH,eAAO,MAAM,WAAW,EAAE,WAOzB,CAAC;AAEF,sFAAsF;AACtF,eAAO,MAAM,WAAW,EAAE,WAAoE,CAAC;AAU/F,oEAAoE;AACpE,eAAO,MAAM,WAAW,EAAE,aAAkD,CAAC;AAE7E,iFAAiF;AACjF,eAAO,MAAM,WAAW,EAAE,gBAAsD,CAAC;AAEjF,2EAA2E;AAC3E,eAAO,MAAM,WAAW,EAAE,eAA8D,CAAC;AAEzF,kGAAkG;AAClG,eAAO,MAAM,WAAW;aAAK,MAAM,EAAE,CAAC;aAAE,CAAC,EAAE,CAAC;aAAE,EAAE,EAAE,EAAE;CAAW,CAAC;AAIhE,gEAAgE;AAChE,eAAO,MAAM,WAAW,EAAE,eAA+C,CAAC;AAE1E,mGAAmG;AACnG,eAAO,MAAM,WAAW;aAAK,IAAI,EAAE,GAAG;aAAE,CAAC,EAAE,CAAC;aAAE,CAAC,EAAE,CAAC;CAAW,CAAC;AAE9D,8DAA8D;AAC9D,eAAO,MAAM,WAAW;aAAK,IAAI,EAAE,EAAE;aAAE,CAAC,EAAE,CAAC;aAAE,CAAC,EAAE,CAAC;CAAW,CAAC;AAE7D,sGAAsG;AACtG,eAAO,MAAM,WAAW,EAAE,kBAOzB,CAAC;AAEF,wEAAwE;AACxE,eAAO,MAAM,WAAW;aAAK,EAAE,EAAE,GAAG;CAAW,CAAC;AAEhD,4EAA4E;AAC5E,eAAO,MAAM,WAAW;aAAK,CAAC,EAAE,CAAC;aAAE,MAAM,EAAE,CAAC;aAAE,IAAI,EAAE,CAAC;CAAW,CAAC;AAEjE,0GAA0G;AAC1G,eAAO,MAAM,WAAW;aAAK,CAAC,EAAE,GAAG;aAAE,EAAE,EAAE,IAAI;aAAE,EAAE,EAAE,IAAI;aAAE,EAAE,EAAE,EAAE;CAAW,CAAC;AAQ3E;;;;;GAKG;AACH,eAAO,MAAM,gBAAgB,EAAE,SAAS,iBAAiB,EAwPxD,CAAC"}