Brummel
47e0e605e1
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
73 lines
3.3 KiB
JavaScript
73 lines
3.3 KiB
JavaScript
// Headless render guard for the `aura graph` viewer (graph-viewer.js).
|
|
//
|
|
// Property protected: a bind-bound param slot renders in the node signature as a
|
|
// DIMMED `name=value`, in TRUE slot order (by original position), with the free
|
|
// slots in their type colour — never dropped. Covers a trailing bind (the
|
|
// cycle-0036 showcase shape) AND a non-trailing (middle) bind, which an
|
|
// append-after-free design would render in the wrong order.
|
|
//
|
|
// It loads the real viewer module and drives the exported pure `genDot`. `node`
|
|
// is REQUIRED: a skipped guard is not a guard.
|
|
|
|
import { createRequire } from "node:module";
|
|
import { fileURLToPath } from "node:url";
|
|
import { dirname, join } from "node:path";
|
|
|
|
const require = createRequire(import.meta.url);
|
|
const here = dirname(fileURLToPath(import.meta.url));
|
|
|
|
// Load the viewer once with an empty model; normalizeModel/genDot are pure and
|
|
// take the model/def explicitly, so each case is rendered by passing its own.
|
|
global.window = { AURA_MODEL: { root: { nodes: {}, edges: [] }, composites: {} } };
|
|
const { normalizeModel, genDot } = require(join(here, "..", "assets", "graph-viewer.js"));
|
|
const dotFor = (model) => genDot(normalizeModel(model).root, "root", new Set(), false).dot;
|
|
|
|
const fail = (msg, dot) => {
|
|
console.error(msg + "\n--- dot ---\n" + dot);
|
|
process.exit(1);
|
|
};
|
|
|
|
// --- Model A: trailing bind (the cycle-0036 showcase shape) ---
|
|
const trailing = {
|
|
root: { nodes: { "0": { prim: {
|
|
name: "blend", type: "LinComb", role: "node",
|
|
params: [["weights[0]", "f64"], ["weights[1]", "f64"]],
|
|
bound: [[2, "weights[2]", "f64", "0.5"]],
|
|
ins: [["f64", "any", "term[0]"], ["f64", "any", "term[1]"], ["f64", "any", "term[2]"]],
|
|
outs: [["value", "f64"]],
|
|
} } }, edges: [] },
|
|
composites: {},
|
|
};
|
|
const dotA = dotFor(trailing);
|
|
|
|
const BOUND = '<font color="#9399b2">weights[2]=0.5</font>';
|
|
const FREE0 = '<font color="#89b4fa">weights[0]</font>';
|
|
const FREE1 = '<font color="#89b4fa">weights[1]</font>';
|
|
if (!dotA.includes(BOUND)) fail("trailing: bound slot weights[2]=0.5 not rendered dimmed", dotA);
|
|
if (!dotA.includes(FREE0) || !dotA.includes(FREE1)) fail("trailing: a free weight slot is missing or not type-coloured", dotA);
|
|
const a0 = dotA.indexOf(FREE0), a1 = dotA.indexOf(FREE1), ab = dotA.indexOf(BOUND);
|
|
if (!(a0 < a1 && a1 < ab)) fail("trailing: slot order is not weights[0] < weights[1] < weights[2]=0.5", dotA);
|
|
|
|
// --- Model B: NON-TRAILING (middle) bind — pins slot-order faithfulness ---
|
|
const middle = {
|
|
root: { nodes: { "0": { prim: {
|
|
name: "mid", type: "Probe", role: "node",
|
|
params: [["a", "f64"], ["c", "f64"]],
|
|
bound: [[1, "b", "f64", "9.0"]],
|
|
ins: [["f64", "any", "t0"], ["f64", "any", "t1"], ["f64", "any", "t2"]],
|
|
outs: [["value", "f64"]],
|
|
} } }, edges: [] },
|
|
composites: {},
|
|
};
|
|
const dotB = dotFor(middle);
|
|
|
|
const MA = '<font color="#89b4fa">a</font>';
|
|
const MB = '<font color="#9399b2">b=9.0</font>';
|
|
const MC = '<font color="#89b4fa">c</font>';
|
|
if (!dotB.includes(MA) || !dotB.includes(MB) || !dotB.includes(MC)) fail("middle: a free or bound slot is missing", dotB);
|
|
const ba = dotB.indexOf(MA), bb = dotB.indexOf(MB), bc = dotB.indexOf(MC);
|
|
if (!(ba < bb && bb < bc)) fail("middle: bound slot b=9.0 not placed between free a and c (append-only bug)", dotB);
|
|
|
|
console.log("OK — bound slot renders dimmed name=value in true slot order (trailing + middle bind).");
|
|
process.exit(0);
|