8 Commits

Author	SHA1	Message	Date
Brummel	45cc1c44c9	feat(trace-charts): ordinal x-axis default + zoom/pan/cursor-sync (viewer Tier-1) ... The served trace chart's x-axis no longer plots against raw timestamps by default — non-trading gaps (nights, weekends) left horizontal blanks that dominated the view. The x spine is now ordinal by default: every recorded slot sits at an even position, so gaps collapse and the signal fills the width. A header toggle flips to continuous (real-time-proportional) spacing and back; default ordinal honours the requested "x-axis should not be continuous", with continuous as the one-click option. Comfort, all on the read/render side (the engine and the Rust serve contract are untouched — window.AURA_TRACES still carries the real xs, the ordinal indices are derived client-side): - ordinal mode keeps the axis honest: ticks and the legend value-readout map a collapsed index back to the real xs[i], never the index itself. - wheel-zoom (x, cursor-anchored), drag-pan, double-click-reset on the plot (uPlot's default drag-box-zoom is disabled so drag pans). - panels share a cursor.sync key, so the crosshair lines up across stacked panels. Confined to chart-viewer.js (buildCharts gains an xMode param + a wheelZoomPlugin factory; mount re-renders on the toggle) and render.rs (CHART_HEAD toggle button + a chart-only style). The two twin node guards (build/gaps) re-point to the ordinal default in lockstep; a new x-mode guard pins ordinal-default / continuous / panel-sync / plugin wiring, and a label-honesty guard (gappy-traces fixture, xs far from the index spine) pins that ordinal ticks report the real timestamp. Verified: cargo test --workspace green (incl. the four chart guards + render inline tests), clippy --all-targets -D warnings clean, e2e (aura run --trace + aura chart) emits a self-contained page defaulting to ordinal with the toggle. Spec docs/specs/0057, plan docs/plans/0057 (boss-signed; grounding-check PASS). Derived-fork decision log in the issue comments. closes #103	2026-06-19 19:00:33 +02:00
Brummel	15ee6d5f4f	feat(trace-charts): serve persisted traces as a web chart (iter 2) ... Iteration 2 (serve half) of the visual face — spec 0056 / plan 0056: read a persisted run's traces and serve them as a self-contained uPlot HTML chart. Completes the goal "tap data from a graph, serve it as a chart in the browser". - chart-viewer.js (first-party): a pure buildCharts(traces, mode) that maps the injected window.AURA_TRACES to uPlot configs (no DOM) — overlay = one plot, every series on its own y-scale over the shared xs; panels = one plot per series, all on the same timestamp x. A browser-only mount() instantiates the vendored global uPlot. Guarded by a node .mjs DOM test (+ a sparse/gaps variant) shelling out exactly like viewer_dot.rs. - render_chart_html + ChartMode/ChartData/Series (aura-cli/render.rs): mirrors render_html — self-contained page, uPlot (1.6.32, vendored d534f10) + chart-viewer.js inlined via include_str!, data injected as window.AURA_TRACES. - emit_chart + build_chart_data (aura-cli/main.rs): the spec-§6 3-step union-spine alignment — xs = sorted-dedup union of every tap's ts; a synthetic empty-payload spine + ALL taps as symmetric join_on_ts sides (no tap privileged, no point dropped); flatten each (tap,column) to a Series of Option<f64>. New arms `aura chart <name> [--panels]`; a missing run is stderr + exit 2 (TraceStoreError::NotFound), never a panic. USAGE advertises the verb in lockstep. Verified by the orchestrator: `cargo test --workspace` green (incl. the node guards, render_chart_html, and the chart e2e); `cargo clippy --workspace --all-targets -D warnings` exit 0; and a real end-to-end — `aura run --trace demo && aura chart demo` emits a 57KB self-contained page (doctype + inlined uPlot + AURA_TRACES carrying the equity/exposure series), `--panels` reflects the panels mode, `aura chart nope` exits 2. Implementer deviation folded in (compiler-prescribed): serde added to aura-cli/Cargo.toml for the Series derive (Cargo.lock updated). refs #101	2026-06-19 00:52:45 +02:00
Brummel	d534f106da	chore(aura-cli): vendor uPlot 1.6.32 for the trace-chart viewer ... Vendors uPlot.iife.min.js (the IIFE bundle exposing the global `uPlot`) + uPlot.min.css under assets/, pinned at uplot@1.6.32 via unpkg, mirroring the existing Graphviz-WASM/pan-zoom vendoring (checked in verbatim so include_str! + the build stay hermetic/offline, C1/C8). refresh-assets.sh gains the matching pinned-fetch lines. Consumed by iteration 2's render_chart_html (serve half of spec 0056). refs #101	2026-06-19 00:20:30 +02:00
Brummel	47e0e605e1	feat(aura): surface bind-bound params in the graph model + viewer signature ... A node built with `.bind(slot, value)` fixes a declared param to a structural constant: the slot correctly leaves the tunable surface (param_space / sweep axes), but it also vanished from the RENDERED signature, because prim_record emitted only schema.params. The cycle-0036 `blend` (a LinComb(3) with weights[2] bound to 0.5) rendered `LinComb[weights[0], weights[1]]` — a 2-arity signature over a 3-port box, with the fixed 0.5 invisible. The signature misrepresented the node. bind now ANNOTATES instead of erasing. All slots are shown; the bound one renders `name=value`, dimmed. The blend renders: blend: LinComb[weights[0], weights[1], weights[2]=0.5] Structurally a twin of cycle 0035's instance-name thread (commit 0ae8320): a conditional field threaded engine -> model -> viewer. - aura-core: a `BoundParam { pos, name, kind, value }` recorded by bind alongside the unchanged closure capture, plus a `bound_params()` accessor (twin of instance_name()). `pos` is the slot's ORIGINAL pre-bind position (the compressed index is mapped back over earlier-bound positions), so the render is faithful for any bind pattern, not just a trailing one. - aura-engine: a conditional `"bound"` field in prim_record (present only when the node has binds, mirroring the conditional "name"), each entry [pos,"name","kind", "value"] via a new scalar_str helper (f64 via {:?} — keeps a decimal point so a bound f64 never reads as an i64). - graph-viewer.js: adaptNodes/genDot carry `bound`; cellLabel merges free + bound params back into slot order by position and renders the bound slot dimmed (reusing the 0035 separator grey #9399b2). Render notation settled with the user (issue #63, reconciliation comment): keep the [...] convention and name=value (not parens, not positional value-only). Render/debug surface only: dropped at lowering (C23 — bind still resolves the name to a fixed position and the compilat is unchanged), model stays deterministic (C14 — the inline no-bind golden is byte-unchanged; only the sample fixture's blend node gains "bound"). The tunable surface is untouched: the eight-param sweep pins stay byte-identical (C12/C19). New unit tests pin the recorded original position and the conditional model field; a new headless render guard pins the dimmed name=value render and slot-order faithfulness for both a trailing and a non-trailing bind. Verified: cargo build/test (0 failed) + clippy -D warnings (0) all green. closes #63	2026-06-13 23:23:29 +02:00
Brummel	0ae8320d14	feat(aura): surface explicit node instance name in the graph viewer ... A leaf primitive built with `.named("fast")` now renders its `aura graph` viewer box head as `fast: SMA[length]` — the instance name as a `:` declaration prefix. An unnamed leaf keeps the bare `SMA[length]`. Engine half: a new raw `PrimitiveBuilder::instance_name() -> Option<&str>` (the explicit name, default not resolved) feeds a conditional leading `"name"` field in prim_record, present only for an explicitly-named node; both golden twins (inline model_golden + sample-model.json) re-captured. Viewer half: adaptNodes carries `name`, the genDot leaf-emit forwards it, and cellLabel prepends the `name: ` prefix when present (composites stay bare). `named()`'s non-empty debug_assert is unchanged, its doc re-grounded to the now load-bearing Some/None invariant (knob-address segment + prefix switch). The name is a render/model-only debug symbol — dropped at lowering (C23), and the model stays deterministic (C14). Parameter ganging (one knob, several nodes) was considered and spun off as an explicit composite-shared-param idea (#61), not via name collision (param_space is injective, C12/C19). closes #58	2026-06-13 19:02:16 +02:00
Brummel	a051571d79	feat(aura-cli): render leaf param signature as TYPE[...] in the graph viewer ... The viewer box head built the param signature in round parens — SMA(length) — which reads as a function call. Switch the brackets to square — SMA[length] — so the head reads as parametrisation, not invocation. cellLabel render-only change in graph-viewer.js; the JSON model surface and both goldens are untouched.	2026-06-13 17:03:28 +02:00
Brummel	776bd5432a	fix(aura-cli): emit valid DOT identifiers for inline-expanded composites ... Observed bug in the graph viewer shipped in 66dff88: clicking `[+]` to inline-expand a composite in `aura graph`'s HTML output renders a broken graph — the interior nodes' edges collapse onto a single phantom node "0" with uncoloured arrows, and the real pin docking is lost. The collapsed view and the body-drill view both render correctly; only inline-expand breaks. Root cause: in graph-viewer.js, genDot's `build` forms a node id by path-joining the model keys (`cid = cpath.join("__")`). The aura model keys interior nodes by numeric index (C23), so an inline-expanded composite yields ids like `0__0`. A DOT identifier that begins with a digit but is not a pure numeral is invalid — Graphviz parses `0__0` as the numeral `0` plus a leftover token, collapsing `0__0`/`0__1`/`0__2` onto one phantom node `0`. The collapsed view survives only because its ids are single-digit numerals (accidentally valid); the prototype survived because it used name keys, never digit-prefixed ones. The bug surfaced only against the real index-keyed model. Fix: letter-prefix the id (`cid = "n" + cpath.join("__")`) so every id is a valid identifier by construction. The fix lives in the viewer (DOT-syntax is its responsibility), not in model_to_json — the model's index keys are correct, and leaking the Graphviz identifier constraint into the model would be a leaky abstraction. RED-first guard (this establishes the project's first JS test infra, since the viewer now carries real logic — normalizeModel + genDot — that the model golden does not cover): - tests/viewer_dot_ids.mjs: a headless node guard that loads the real viewer module, discovers the expandable composites from a collapsed pass, inline- expands them, and asserts every node id in the produced DOT is a valid Graphviz identifier (quoted | pure numeral | bare identifier). Version-independent — it checks the identifier grammar, not a render. The expand keys are DISCOVERED via genDot's `expandable`, never hard-coded, so the guard cannot go vacuously green when the fix reshapes the id (a hard-coded "0" key would stop matching "n0" and silently test only the collapsed view — a false-green this guard refuses). - tests/viewer_dot.rs: a Rust integration test that shells out to `node`, wiring the guard into `cargo test --workspace`. `node` is required: if it is absent the test fails (a skipped guard is not a guard). - tests/fixtures/sample-model.json: the triggering fixture (numeric index keys, a nested composite). - graph-viewer.js: made node-loadable (typeof window/document guards + a module.exports) so the guard can exercise the pure generator headless. This is a test-enabler, behaviour-neutral in the browser — verified by the existing render_html / graph_emits self-containment tests staying green and by the expand re-rendering correctly through the vendored WASM-Graphviz. Verified RED against the unfixed viewer (the guard trips on `0__0`/`0__1`/`0__2` and the Rust test fails), GREEN after the prefix; full `cargo test --workspace` green; clippy clean. Rendered the expanded state through the vendored WASM-Graphviz to confirm the interior wires up correctly (price -> both SMA series, SMA value -> Sub lhs/rhs, Sub -> signal, all f64-blue).	2026-06-10 17:48:49 +02:00
Brummel	66dff88528	feat(aura-cli): render the graph as a self-contained WASM-Graphviz viewer; retire ascii-dag ... Iteration 2 of cycle 0026 (graph render redesign). `aura graph` no longer emits ASCII: it now prints one self-contained `.html` to stdout — the ported prototype pin-graph viewer (drill / inline-expand / styled tooltips / breadcrumb) driven by the deterministic model serializer that shipped in iteration 1, with layout and SVG done in-browser by Graphviz compiled to WebAssembly. Closes the redesign opened by spec 0026; unblocked by cycle 0027 (input ports are now named, so the viewer labels every input pin from the model's real names instead of inventing "a"/"b"). What ships: - crates/aura-cli/assets/: the ported graph-viewer.js (prototype genDot/chrome verbatim + a normalizeModel adapter mapping aura's real model tuple shape — ins = [kind, firing, name], index node keys, `comp` refs, `src_<role>` — into the viewer's native shape), plus the vendored Graphviz-WASM (@viz-js/viz@3.7.0) and svg-pan-zoom@3.6.1 blobs and a refresh-assets.sh provenance script. - crates/aura-cli/src/render.rs: render_html(&Composite) -> String, a read-only (C9) assembly — model_to_json + include_str! of the inlined assets, no eval, no build, no serde (C14). The `["graph"]` arm calls it. - Retired: the ascii-dag adapter (graph.rs), the `ascii-dag` dependency, the `--compiled`/`--macd` graph flag plumbing, render_compiled, the color/terminal plumbing, and the 12 ascii-dag-asserting tests + the now-orphaned helpers. The cli_run integration test now pins the HTML page envelope. - crates/aura-core/src/node.rs: the two last ascii-dag prose justifications re-grounded (single-line label rule kept, re-justified generically; the param-generic rule re-justified on C23, not on a renderer limitation). - docs/design/INDEX.md: the cycle-0026 C9 realization note (both iterations). Vendoring decision (spec deferred it to the plan): the WASM/JS blobs are checked in, not fetched at build time. include_str! needs them at compile time, and a build-time unpkg fetch would make the build non-hermetic/non-offline and let the shipped artifact drift with the registry — against C1 (determinism) and C8 (frozen artifacts). ~1.4 MB is the price of a hermetic, frozen render asset. Three adaptations beyond the plan, each verified: (1) render.rs imports `aura_engine::Composite` (the path model_to_json takes), not aura_core; (2) macd_blueprint is now test-only — removing the `--macd` arm left it used solely by the param-space test, so it took `#[cfg(test)]` rather than removal or an `#[allow]` suppression (the production `aura run --macd` path is intact, verified emitting JSON); (3) the `grep ascii-dag` over crates/ matches only the new contract test, which names the term deliberately to document the retirement — no stale justification prose remains. Invariants held (verified independently, not on agent report): C9 (render path read-only), C10 (viewer is a render asset, no logic/DSL), C4 (four-colour palette = the four scalar base types), C14 (no serde). The iteration-1 model byte golden is unchanged and green. cargo build --workspace: 0 errors. cargo test --workspace: 157 passed, 0 failed (incl. the two new HTML tests + the unchanged model_golden). cargo clippy --workspace --all-targets -- -D warnings: clean. ascii-dag absent from `cargo tree -p aura-cli`. closes #51	2026-06-10 17:09:12 +02:00