@maniclang/workbench 0.1.11

package/examples/spring-damped.manic

@@ -0,0 +1,33 @@
+// ============================================================================
+//  spring-damped.manic  —  the same four views, now with friction
+// ----------------------------------------------------------------------------
+//  Identical to `spring.manic` but with `damping` (the 6th arg) turned on, so the
+//  oscillation loses energy. Watch every panel respond together:
+//    · sim          — the coil's swing SHRINKS each cycle (settles to rest)
+//    · phase        — the ellipse becomes an INWARD SPIRAL
+//    · well          — the ball SETTLES to the bottom of the parabola U(x)=½kx²
+//    · energygraph  — the TOTAL (gold) line DECAYS (KE↔PE trade, sum drops)
+//
+//  Set damping = 0 (or drop the 6th arg) for the frictionless version, where the
+//  ellipse stays closed and the total-energy line stays flat (conservation).
+// ============================================================================
+
+title("Damped spring — energy bleeds away");
+canvas("16:9");
+
+text(hdr, (cx, 44), "Add friction: the oscillation decays, every view follows");
+size(hdr, 24); color(hdr, cyan); bold(hdr); display(hdr);
+
+// the mass–spring (left) — 6th arg 0.6 is the damping
+spring(s, (330, 300), 10, 1.4, 110, 0.6);
+
+// the same generic views of the SAME (now damped) simulation
+phase(s, (760, 175), 90);          // ellipse → inward spiral
+timegraph(s, (1010, 175), 90);     // x(t), v(t) — envelope shrinks
+well(s, (760, 460), 90);           // ball settles to the bottom of the parabola
+energygraph(s, (1010, 460), 90);   // total energy decays
+
+text(cap, (cx, h - 32), "damping = 0.6 · the spiral, settling ball, and decaying total energy all show the same loss");
+size(cap, 16); color(cap, dim); display(cap);
+
+run(s, 10);

package/examples/spring-incline.manic

@@ -0,0 +1,10 @@
+// spring-incline.manic — a mass on a spring on an inclined plane.
+title("Spring on an incline");
+canvas("16:9");
+text(hdr,(cx,44),"Spring on an incline — gravity's along-ramp pull shifts equilibrium"); size(hdr,22); color(hdr,cyan); bold(hdr); display(hdr);
+springincline(si, (360,180), 32);
+untraced(si.path);
+phase(si, (960,200), 100);
+energygraph(si, (960,470), 100);
+text(cap,(cx,h-32),"the bob oscillates along the ramp about its stretched rest point"); size(cap,16); color(cap,dim); display(cap);
+par { run(si, 10); draw(si.path, 10); }

package/examples/spring-paper.manic

@@ -0,0 +1,46 @@
+// ============================================================================
+//  spring-paper.manic  —  an ANIMATED sim in textbook paper style
+// ----------------------------------------------------------------------------
+//  The `spring` sim (mass on a spring, SHM), dressed as a textbook figure AND run:
+//  `template("paper")` inks it automatically, a hatched `support` wall, the coil
+//  in forest green, an outlined mass box, plus a base-manic reveal (Hooke's law,
+//  equilibrium, x₀) — then `run` plays the oscillation. The companion to
+//  pulley-paper: the paper/support treatment on another live sim.
+// ============================================================================
+
+title("Mass on a spring — textbook style");
+canvas("16:9");
+template("paper");
+
+text(hdr, (cx, 46), "Mass on a spring — Hooke's law"); color(hdr, fg); size(hdr, 26); bold(hdr); display(hdr); hidden(hdr);
+
+// the sim, restyled to textbook ink (parts hidden, revealed in order)
+spring(sp, (380, 300), 10, 1.3, 110);
+outlined(sp.mass); outline(sp.mass, fg);
+hidden(sp.wall); hidden(sp.spring); hidden(sp.mass); hidden(sp.overlays);
+untraced(sp.path);
+
+// a hatched wall stands in for the sim's plain anchor; equilibrium reference
+support(wall, (177, 300), 150, "right"); untraced(wall);
+line(eq, (380, 246), (380, 354)); color(eq, dim); stroke(eq, 2); untraced(eq);
+
+text(eqL, (380, 232), "equilibrium"); color(eqL, dim); size(eqL, 15); display(eqL); hidden(eqL);
+text(coilL, (300, 214), "spring, stiffness k"); color(coilL, fg); size(coilL, 17); display(coilL); hidden(coilL);
+text(massL, (548, 258), "mass m"); color(massL, fg); size(massL, 17); display(massL); hidden(massL);
+bracelabel(xb, (380, 360), (523, 360), "x₀", 22); color(xb, fg); hidden(xb); hidden(xb.label);
+text(hooke, (380, 152), "F = −k·x"); color(hooke, fg); size(hooke, 24); display(hooke); hidden(hooke);
+text(cap, (cx, h - 40), ""); color(cap, fg); size(cap, 20); display(cap);
+
+// ============================== SCRIPT ==============================
+show(hdr, 0.5);
+say(cap, "a coil of stiffness k fixed to a wall, with a mass on the end", 0.4);
+draw(wall, 0.4); show(sp.spring, 0.4); show(coilL, 0.4); show(sp.mass, 0.4); show(massL, 0.3);
+wait(0.4);
+
+say(cap, "pull it x₀ from equilibrium — it pulls straight back, F = −k·x", 0.4);
+draw(eq, 0.4); show(eqL, 0.3); show(xb, 0.4); show(xb.label, 0.4); show(hooke, 0.5);
+wait(0.7);
+fade(coilL, 0.3); fade(massL, 0.3); fade(xb, 0.3); fade(xb.label, 0.3); fade(hooke, 0.3);
+
+say(cap, "release — simple harmonic motion", 0.4);
+run(sp, 9);

package/examples/spring-pendulum.manic

@@ -0,0 +1,14 @@
+// spring-pendulum.manic — the elastic pendulum: swings AND bounces.
+//   springpendulum(id,[center],[angle0],[stretch0],[unit],[damping]) — a bob on a
+//   springy rod (drawn as a stretching coil). Energy sloshes between the swing and
+//   the bounce, so the phase portrait and energy graph are richer than a rigid rod.
+title("Elastic pendulum — swing meets bounce");
+canvas("16:9");
+text(hdr,(cx,44),"Spring pendulum — energy sloshes between swing and bounce");
+size(hdr,23); color(hdr,cyan); bold(hdr); display(hdr);
+springpendulum(sp, (380,230), 35, 0.5, 105);
+untraced(sp.path);
+phase(sp, (900,190), 95);           // θ vs ω
+energygraph(sp, (900,470), 95);     // KE / PE / total (~conserved, lightly damped)
+text(cap,(cx,h-32),"the coil stretches as it swings — a two-mode system"); size(cap,16); color(cap,dim); display(cap);
+par { run(sp, 11); draw(sp.path, 11); }

package/examples/spring.manic

@@ -0,0 +1,33 @@
+// ============================================================================
+//  spring.manic  —  the physics kit's SECOND sim (Layer 1)
+// ----------------------------------------------------------------------------
+//  `spring(id, [center], [stiffness], [x0], [unit], [damping])` — a mass on a
+//  spring, PRE-SIMULATED with RK4 (deterministic). Only `id` is required. It's a
+//  different system from the pendulum, yet it inherits the SAME generic views for
+//  free — note the energy well here is a PARABOLA U(x)=½kx² (the pendulum's is a
+//  cosine). `run(id, [dur])` replays the motion (alias: `swing`).
+//
+//  TO ADAPT: add damping (6th arg) — the phase ellipse spirals in, the ball
+//  settles to the bottom of the parabola, and total energy decays:
+//  `spring(s, (360,320), 10, 1.4, 110, 0.6)`.
+// ============================================================================
+
+title("Mass on a spring — four views");
+canvas("16:9");
+
+text(hdr, (cx, 44), "A different sim — same four views (well is a parabola)");
+size(hdr, 24); color(hdr, cyan); bold(hdr); display(hdr);
+
+// the mass–spring on the left
+spring(s, (330, 300), 10, 1.4, 110);
+
+// the same generic views of the SAME simulation, 2×2 on the right
+phase(s, (760, 175), 90);          // x vs v — an ellipse
+timegraph(s, (1010, 175), 90);     // x(t), v(t) with a sweep line
+well(s, (760, 460), 90);           // parabolic energy well U(x)=½kx²
+energygraph(s, (1010, 460), 90);   // KE / PE / total over time
+
+text(cap, (cx, h - 32), "one mass–spring, seen as motion · phase ellipse · time series · parabolic well · energy");
+size(cap, 16); color(cap, dim); display(cap);
+
+run(s, 10);                        // every panel animates in lockstep

package/examples/sqrt-tanx.manic

@@ -0,0 +1,217 @@
+// ============================================================================
+//  sqrt-tanx.manic — √(tan x) by PURE GEOMETRY (3B1B-style)
+// ----------------------------------------------------------------------------
+//  THE PROBLEM: √(tan θ) looks like algebra. It is geometry.
+//
+//  THE PROOF, in three pictures:
+//   1. On the unit circle, tan θ IS the length of the vertical tangent segment.
+//   2. √a is the geometric mean of 1 and a — Euclid: semicircle on diameter
+//      1+a, erect a perpendicular at the "1" mark; its height is √a.
+//   3. Set a = tan θ. The altitude IS √(tan θ). No algebra required.
+//
+//  Then we sweep θ and watch the construction's height paint the curve —
+//  teal → violet → coral — using the expanded semantic palette.
+//
+//    manic examples/sqrt-tanx.manic
+//    manic examples/sqrt-tanx.manic --still 22
+// ============================================================================
+
+title("√(tan x) — Pure Geometry");
+canvas("16:9");
+template("blank");
+
+// ---- stage ----
+circle(well, (cx, 400), 340);
+filled(well);
+gradient(well, panel, void, radial);
+opacity(well, 0.55);
+
+// ============================================================================
+//  LEFT — the unit circle, where tan θ is a length
+// ============================================================================
+let ox = 250;
+let oy = 430;
+let R = 145;
+// a friendly angle: θ = 0.95 rad ≈ 54.4°, tan ≈ 1.40, √tan ≈ 1.18
+let th = 0.95;
+let Px = ox + R*cos(th);
+let Py = oy - R*sin(th);
+let Ty = oy - R*tan(th);
+
+circle(O, (ox, oy), 7); outlined(O); color(O, fg); stroke(O, 1.5); hidden(O);
+dot(A, (ox + R, oy), 5); color(A, dim); hidden(A);          // (1, 0)
+// contact points: open dashed rings (filled dots hide the circle + tangent)
+circle(P, (Px, Py), 11);
+outlined(P); color(P, mint); stroke(P, 2); dashed(P, 3.5, 2.8); untraced(P); hidden(P);
+circle(T, (ox + R, Ty), 11);
+outlined(T); color(T, coral); stroke(T, 2); dashed(T, 3.5, 2.8); untraced(T); hidden(T);
+
+// ray as a line (not arrow) so the filled arrowhead doesn't cover P
+line(ray, (ox, oy), (Px, Py));
+color(ray, mint); stroke(ray, 2.5); untraced(ray); hidden(ray);
+
+// the tangent SEGMENT — its length IS tan θ (in radii)
+line(tanseg, (ox + R, oy), (ox + R, Ty));
+color(tanseg, coral); stroke(tanseg, 5); untraced(tanseg); hidden(tanseg);
+
+// angle mark — textbook style: a thin ARC, never a filled wedge (fills hide the diagram)
+arc(wedge, (ox, oy), R*0.42, 0, -th*180/pi);
+color(wedge, violet); stroke(wedge, 2.5); untraced(wedge); hidden(wedge);
+
+circle(uc, (ox, oy), R);
+outlined(uc); outline(uc, teal); stroke(uc, 3); untraced(uc); hidden(uc);
+
+line(axX, (ox - R - 30, oy), (ox + R + 100, oy));
+color(axX, dim); stroke(axX, 1.5); untraced(axX); hidden(axX);
+line(axY, (ox, oy + R + 40), (ox, oy - R - 50));
+color(axY, dim); stroke(axY, 1.5); untraced(axY); hidden(axY);
+
+line(tline, (ox + R, oy + R + 50), (ox + R, oy - R - 90));
+color(tline, dim); stroke(tline, 1.5); dashed(tline, 10, 8); untraced(tline); hidden(tline);
+
+text(labP, (Px + 14, Py - 14), "P"); size(labP, 20); color(labP, mint); hidden(labP);
+text(labO, (ox - 18, oy + 22), "O"); size(labO, 18); color(labO, dim); hidden(labO);
+text(labA, (ox + R + 14, oy + 22), "1"); size(labA, 18); color(labA, dim); hidden(labA);
+text(labT, (ox + R + 18, Ty), "tan θ"); size(labT, 20); color(labT, coral); hidden(labT);
+text(labTh, (ox + 48, oy - 28), "θ"); size(labTh, 22); color(labTh, violet); hidden(labTh);
+
+// ============================================================================
+//  RIGHT — Euclid's geometric mean: √a from 1 and a
+// ============================================================================
+let gx = 620;
+let gy = 500;
+let u = 110;                         // px per unit
+let a = tan(th);                     // ≈ 1.40
+let root = sqrt(a);                  // ≈ 1.18
+let G0x = gx;
+let G1x = gx + u;                    // the "1" mark
+let G2x = gx + u*(1 + a);            // the "1+a" mark
+let mid = (G0x + G2x)*0.5;
+let rad = u*(1 + a)*0.5;
+
+dot(G0, (G0x, gy), 5); color(G0, dim); hidden(G0);
+dot(G1, (G1x, gy), 6); color(G1, teal); glow(G1, 0.4); hidden(G1);
+dot(G2, (G2x, gy), 5); color(G2, coral); hidden(G2);
+line(base, (G0x, gy), (G2x, gy));
+color(base, fg); stroke(base, 3); untraced(base); hidden(base);
+
+// upper semicircle on diameter [0, 1+a]
+// screen angles: 0° right, 90° down, 270° up — from left through UP: start 180, sweep +180
+arc(semi, (mid, gy), rad, 180, 180);
+color(semi, indigo); stroke(semi, 3); untraced(semi); hidden(semi);
+
+// altitude at the "1" mark — height = √(1·a) = √(tan θ)
+line(alt, (G1x, gy), (G1x, gy - root*u));
+color(alt, violet); stroke(alt, 5); untraced(alt); hidden(alt);
+dot(H, (G1x, gy - root*u), 8); color(H, violet); glow(H, 0.7); hidden(H);
+
+text(lab0, (G0x, gy + 28), "0"); size(lab0, 18); color(lab0, dim); hidden(lab0);
+text(lab1, (G1x, gy + 28), "1"); size(lab1, 18); color(lab1, teal); hidden(lab1);
+text(labA2, (G2x, gy + 28), "1+tanθ"); size(labA2, 18); color(labA2, coral); hidden(labA2);
+text(labH, (G1x + 16, gy - root*u - 8), "√(tan θ)"); size(labH, 22); color(labH, violet); hidden(labH);
+
+// brace / connector: coral tan length → feeds the geometric mean
+arrow(feed, (ox + R + 36, (oy + Ty)*0.5), (G2x - 10, gy - 40));
+color(feed, coral); stroke(feed, 2); dashed(feed, 8, 6); untraced(feed); hidden(feed);
+
+// ============================================================================
+//  BOTTOM — the curve itself, colored by the new palette
+// ============================================================================
+axes(ax, (920, 400), 280, 220);
+hidden(ax);
+plot(curve, (920, 400), 95, 85, "sqrt(tan(x))", (0.25, 1.35));
+stroke(curve, 5); untraced(curve); hidden(curve);
+gradient(curve, teal, violet, coral, 270);
+// low x → small √tan (teal); high x → large (coral), via height = truth
+
+// ============================================================================
+//  TYPOGRAPHY
+// ============================================================================
+caption(q, "what IS the square root of a tangent?", (cx, 58), 32, gold);
+equation(law, (cx, 110), `\sqrt{\tan\theta}`, 44);
+color(law, violet); hidden(law);
+equation(mean, (900, 160), `\sqrt{a}=\sqrt{1\cdot a}`, 28);
+color(mean, teal); hidden(mean);
+text(cap, (cx, h - 36), ""); size(cap, 20); color(cap, dim); display(cap);
+
+// ============================================================================
+//  SCRIPT
+// ============================================================================
+
+// 1 — HOOK
+say(cap, "an expression that looks like algebra — but it is a length", 0.4);
+wordpop(q, 0.16);
+wait(0.3);
+show(law, 0.5);
+wait(0.6);
+
+// 2 — UNIT CIRCLE
+say(cap, "start with the unit circle and an angle θ", 0.4);
+par { show(axX, 0.05); show(axY, 0.05); show(uc, 0.05); show(tline, 0.05); }
+par {
+  draw(axX, 0.5); draw(axY, 0.5);
+  draw(uc, 1.0);
+}
+par { show(O, 0.3); show(labO, 0.3); }
+draw(tline, 0.5);
+show(A, 0.3); show(labA, 0.3);
+wait(0.3);
+
+// 3 — THE ANGLE AND THE RAY
+say(cap, "draw the ray at angle θ — it meets the circle at P", 0.4);
+show(wedge, 0.05); draw(wedge, 0.5); show(labTh, 0.3);
+show(ray, 0.05); draw(ray, 0.7);
+show(P, 0.05); draw(P, 0.35); show(labP, 0.3);
+pulse(P);
+wait(0.4);
+
+// 4 — TAN θ IS A LENGTH
+say(cap, "extend to the vertical tangent line — that segment's length IS tan θ", 0.4);
+show(tanseg, 0.05); draw(tanseg, 0.9);
+show(T, 0.05); draw(T, 0.35); show(labT, 0.3);
+flash(tanseg, coral);
+wait(0.7);
+
+// 5 — GEOMETRIC MEAN
+say(cap, "now forget the circle — Euclid: √a is the geometric mean of 1 and a", 0.4);
+show(mean, 0.5);
+par {
+  show(G0, 0.3); show(G1, 0.3); show(G2, 0.3);
+  show(lab0, 0.3); show(lab1, 0.3); show(labA2, 0.3);
+  show(base, 0.05);
+}
+draw(base, 0.6);
+wait(0.3);
+
+say(cap, "semicircle on diameter 1 + tan θ — then erect a perpendicular at 1", 0.4);
+show(semi, 0.05); draw(semi, 1.2);
+show(alt, 0.05); draw(alt, 0.9);
+show(H, 0.3); show(labH, 0.3);
+flash(alt, violet);
+wait(0.5);
+
+say(cap, "by Thales + similar triangles, that height equals √(1 · tan θ)", 0.4);
+show(feed, 0.05); draw(feed, 0.7);
+pulse(H); pulse(T);
+wait(0.8);
+
+// 6 — THE IDENTITY
+recolor(cap, violet);
+say(cap, "so the altitude IS √(tan θ) — the symbol was a length all along", 0.4);
+rewrite(law, `\sqrt{\tan\theta}=h`, 0.8, smooth);
+wait(0.9);
+
+// 7 — THE CURVE
+recolor(cap, dim);
+say(cap, "every such height, for every θ, paints the curve √(tan x)", 0.4);
+show(ax, 0.5);
+show(curve, 0.05); draw(curve, 2.2);
+wait(0.4);
+say(cap, "teal near zero, coral as tan θ climbs toward the asymptote at π/2", 0.4);
+flash(curve, violet);
+wait(0.8);
+
+// 8 — POINT
+recolor(cap, teal);
+say(cap, "√(tan θ) is not a formula to memorize — it is a geometric construction", 0.4);
+wait(1.6);

package/examples/ssl-handshake-sdf.manic

@@ -0,0 +1,116 @@
+// ssl-handshake-sdf — a TLS 1.3 handshake rendered as a raymarched SDF scene.
+// Four scene parameters are the "reactive shader variables"; the timeline
+// replays the handshake by driving them, and the SDF reads them by name:
+//   ent - cryptographic entropy      -> surface displacement (the boil)
+//   mrg - x25519 key agreement       -> the two endpoint solids smin-FUSE
+//   grw - HKDF key-schedule          -> a key TREE grows from the shared secret
+//   tun - the encrypted channel      -> rep()-tiled cipher rings, an endless tunnel
+// Honesty note: manic is a pure function of t - no live sockets. This is a
+// deterministic replay of one captured handshake; the hex in the transcript is
+// that capture, not live traffic. The marcher is fully GPU-transpilable (scalar
+// SDF, no vec lets), so it previews and records smoothly.
+title("The Handshake, Made Visible");
+canvas("16:9");
+template("black");
+
+// ---------- HUD ----------
+text(head, (cx, 60), "The Handshake, Made Visible"); display(head); cursor(head);
+text(cap, (cx, h - 42), ""); size(cap, 26);
+equation(eqk, (cx, 170), `(g^{a})^{b} \;=\; (g^{b})^{a}`, 36); hidden(eqk);
+
+// the transcript, typed line by line (terminal-green, top left)
+text(tl1, (330, 150), "ClientHello    random: 9f3a c241 77d0 8e5b"); size(tl1, 24); color(tl1, lime); cursor(tl1); hidden(tl1);
+text(tl2, (330, 190), "ServerHello    random: 4be7 01cc a913 f2d6"); size(tl2, 24); color(tl2, lime); cursor(tl2); hidden(tl2);
+text(tl3, (330, 230), "KeyShare       x25519: e5a2 39f8 1b44 c07e"); size(tl3, 24); color(tl3, lime); cursor(tl3); hidden(tl3);
+text(tl4, (330, 270), "HKDF-Expand    client + server traffic keys"); size(tl4, 24); color(tl4, lime); cursor(tl4); hidden(tl4);
+text(tl5, (330, 310), "Finished       cipher: CHACHA20-POLY1305"); size(tl5, 24); color(tl5, lime); cursor(tl5); hidden(tl5);
+
+// entropy readouts (the visible reactive variable + a bit counter)
+counter(bits, (w - 185, 118), 0, 0, "entropy bits ", ""); color(bits, gold); hidden(bits);
+parameter(ent, (w - 180, 168), 0.02, 0, 1, "entropy", 2);
+parameter(mrg, (w - 180, 238), 0, 0, 1, "key-mix", 2); hidden(mrg);
+parameter(grw, (w - 180, 308), 0, 0, 1, "hkdf", 2); hidden(grw);
+parameter(tun, (w - 180, 378), 0, 0, 1, "tunnel", 2); hidden(tun);
+
+// ---------- the scene ----------
+camera3((4.5, -5.5, 3.4), (0, 0, 1.1), 44);
+
+raymarch(hs) {
+  // entropy boils every surface: high-frequency displacement scaled by `ent`
+  let wob = ent * 0.13 * sin(6*x + 2*t) * sin(6*y + 1.7*t) * sin(6*z + 1.3*t);
+  // the two endpoints: browser (sphere) and server (octahedron), pulled
+  // together as the key-mix parameter rises
+  let ox = 1.25 - 0.95*mrg;
+  let c = sdsphere(x + ox, y, z - 0.85, 0.55) + wob;
+  let s = sdoctahedron(x - ox, y, z - 0.85, 0.62) + wob;
+  let duo = smin(c, s, 0.12 + 0.55*mrg);
+  // the HKDF key tree: trunk + branches, growing out of the fused secret as `grw`
+  // rises. Branch tilts are SCALAR component rotations (not vec2/rot2) so the whole
+  // marcher transpiles to GLSL and runs on the GPU instead of the heavy CPU fallback.
+  //   rot(a,b,θ) = (a·cosθ − b·sinθ,  a·sinθ + b·cosθ)
+  let zt = z - 0.85;
+  let tr = sdcapsule(x, y, zt, 1.05*grw, 0.12);
+  let za = zt - 1.0*grw;    let ca = cos(0.65);  let sa = sin(0.65);
+  let zb = zt - 1.55*grw;   let cb = cos(0.8);   let sb = sin(0.8);
+  let b1 = sdcapsule(x*ca - za*sa, y,  x*sa + za*ca, 0.7*grw, 0.085);
+  let b2 = sdcapsule(x*ca + za*sa, y, 0 - x*sa + za*ca, 0.7*grw, 0.085);
+  let b3 = sdcapsule(x, y*cb - zb*sb,  y*sb + zb*cb, 0.5*grw, 0.06);
+  let b4 = sdcapsule(x, y*cb + zb*sb, 0 - y*sb + zb*cb, 0.5*grw, 0.06);
+  let tree0 = smin(smin(tr, smin(b1, b2, 0.1), 0.12), smin(b3, b4, 0.1), 0.12);
+  let tree = tree0 + 0.6*wob + (1 - smoothstep(0.02, 0.12, grw))*9;
+  // the encrypted tunnel: an endless procession of cipher rings along y
+  let ry = rep(y, 1.05);
+  let ring = sdtorus(x, z - 0.85, ry, 0.8, 0.05 + 0.03*sin(3*t + y)) + (1 - smoothstep(0.02, 0.2, tun))*9;
+  let d = smin(smin(duo, tree, 0.14), ring, 0.1);
+  // colour: cool protocol teal, warmed and destabilized by entropy
+  let hue = 165 + 55*nz + 30*sin(2*hz + 0.5*t) + 50*ent;
+  let sat = 0.7;
+  let val = 0.85 + 0.15*nz;
+  let alpha = 1;
+}
+
+// ================= timeline: the handshake, message by message ==============
+type(head, 1.1);
+say(cap, "a TLS 1.3 handshake - captured once, replayed as geometry", 0.6);
+wait(0.8);
+say(cap, "two strangers: your browser, and a server it has never met", 0.5);
+wait(1.4);
+
+// ---- ClientHello: 32 bytes of randomness leave home
+cue(tick);
+show(tl1, 0.1); type(tl1, 1.0);
+show(bits, 0.3);
+say(cap, "ClientHello: 32 bytes of pure randomness leave home - the surface begins to boil", 0.5);
+par { to(ent, value, 0.55, 1.6, smooth); to(bits, value, 256, 1.6); orbit3(-35, 20, 7.4, 1.6, smooth); }
+wait(0.8);
+
+// ---- ServerHello: chaos answers chaos
+cue(tick);
+show(tl2, 0.1); type(tl2, 1.0);
+say(cap, "ServerHello: the server answers with chaos of its own", 0.5);
+par { to(ent, value, 0.85, 1.4, smooth); to(bits, value, 512, 1.4); }
+wait(0.8);
+
+// ---- x25519: the fusion - a secret neither of them ever sent
+cue(whoosh);
+show(tl3, 0.1); type(tl3, 1.0);
+show(eqk, 0.6);
+say(cap, "x25519: the shapes fuse into a secret that NEITHER side ever transmitted", 0.5);
+par { to(mrg, value, 1, 2.4, smooth); orbit3(15, 24, 6.8, 2.4, smooth); }
+wait(0.9);
+
+// ---- HKDF: the key tree
+cue(pop);
+show(tl4, 0.1); type(tl4, 1.0);
+say(cap, "HKDF: one shared secret sprouts a whole tree of session keys", 0.5);
+par { to(grw, value, 1, 2.6, smooth); orbit3(60, 26, 6.6, 2.6, smooth); }
+wait(0.9);
+
+// ---- Finished: the tunnel opens
+cue(chime);
+show(tl5, 0.1); type(tl5, 1.0);
+say(cap, "Finished: from here on, every byte travels dressed in noise", 0.5);
+par { to(tun, value, 1, 2.2, smooth); to(ent, value, 1, 2.2, smooth); orbit3(110, 18, 7.2, 4.5, smooth); }
+disintegrate(eqk, 0.8);
+say(cap, "the invisible negotiation, rendered visible", 0.6);
+wait(2.5);

package/examples/stack_queue.manic

@@ -0,0 +1,53 @@
+// Stack & Queue — dynamic structures, with carets marking WHERE each op acts.
+// `push`/`pop` (stack, LIFO, grows up) and `enqueue`/`dequeue` (queue, FIFO,
+// grows right) are mutating verbs: they add a cell and animate it in, tracking
+// occupancy so a chain of ops composes. A `caret` marks the action point and is
+// `move`d in step with each op so it rides the changing top / back.
+//
+//   manic examples/stack_queue.manic
+
+title("Stack & Queue");
+canvas("16:9");
+
+let sx = 300;   let sy = 500;    // stack anchor (bottom cell centre)
+let qx = 780;   let qy = 300;    // queue anchor (front cell centre)
+let cw = 84;    let ch = 64;     // cell size
+let stx = sx + 62;               // stack "top" caret sits right of the column
+
+text(head, (cx, 80), "LIFO stack, FIFO queue");
+display(head);  color(head, cyan);  size(head, 28);  hidden(head);
+text(cap, (cx, 660), "");  color(cap, dim);  size(cap, 24);
+
+text(sl, (sx, sy + 66), "stack: push / pop");  color(sl, lime);  size(sl, 22);
+text(ql, (qx + cw, qy - 118), "queue: enqueue / dequeue");  color(ql, cyan);  size(ql, 22);
+
+stack(st, (sx, sy), cw, ch);
+queue(qu, (qx, qy), cw, ch);
+
+// action-point markers
+caret(top, (stx, sy), "top", left);        // rides the top of the stack
+caret(front, (qx, qy - 52), "front", down); // fixed: dequeue leaves here
+caret(back, (qx, qy + 52), "back", up);     // rides the back of the queue
+
+show(head, 0.5);
+
+section("Stack");
+say(cap, "push 5, 3, 8 — each lands on top, the top caret rises");
+push(st, "5");
+par { push(st, "3");  move(top, (stx, sy - ch)); }
+par { push(st, "8");  move(top, (stx, sy - 2*ch)); }
+say(cap, "pop — the top value (8) leaves, the caret drops back");
+par { pop(st);  move(top, (stx, sy - ch)); }
+wait(0.5);
+
+section("Queue");
+say(cap, "enqueue A, B, C — they join at the back caret");
+enqueue(qu, "A");
+par { enqueue(qu, "B");  move(back, (qx + cw, qy + 52)); }
+par { enqueue(qu, "C");  move(back, (qx + 2*cw, qy + 52)); }
+say(cap, "dequeue — the front leaves, the rest advance, back shifts in");
+par { dequeue(qu);  move(back, (qx + cw, qy + 52)); }
+par { dequeue(qu);  move(back, (qx, qy + 52)); }
+
+say(cap, "stack: in and out at the top.  queue: in at back, out at front.");
+wait(1.2);

package/examples/statistics.manic

@@ -0,0 +1,60 @@
+// ============================================================================
+//  statistics.manic  —  Statistics, from data to the bell (a lesson)
+// ----------------------------------------------------------------------------
+//  The stats-rung capstone, companion to linear-algebra.manic. Three chapters on
+//  one stage, chaptered with section():
+//     1. DESCRIBE   — any dataset has a shape, a centre, a spread   (histogram)
+//     2. THE BELL   — measurements often pile into a normal curve   (bellcurve)
+//     3. WHY (CLT)  — averages of anything become a bell            (clt)
+//
+//  Each chapter reveals its whole builtin with `untraced(tag)` → `draw(tag)`
+//  (preserving faint band opacities) and clears with `fade(tag)`.
+// ============================================================================
+
+title("Statistics: from data to the bell");
+canvas("16:9");
+
+let sy = cy + 30;
+
+// 1. a real dataset (exam scores, already roughly bell-shaped)
+histogram(hg, (cx, sy),
+  "68 72 75 71 74 77 73 70 76 72 74 78 71 73 75 69 74 72 76 73 71 75 70 74 72 73 74 71 75 73", 12, 620, 230);
+untraced(hg);
+// 2. the idealised normal curve
+bellcurve(bc, (cx, sy - 24), 100, 15, 78);
+untraced(bc);
+// 3. why the bell is everywhere — the Central Limit Theorem
+clt(ct, (cx, sy), 5, 1000, 7, 620, 250);
+untraced(ct);
+
+text(cap, (cx, h - 44), ""); size(cap, 22); color(cap, dim); display(cap);
+
+// ---- 1. describe ----
+section("Describe the data");
+draw(hg, 1.3);
+say(cap, "any dataset has a shape, a centre, and a spread", 0.5);
+wait(1.8);
+say(cap, "these exam scores cluster around the middle, tailing off either side", 0.5);
+wait(2.0);
+fade(hg, 0.6);
+wait(0.3);
+
+// ---- 2. the bell ----
+say(cap, "", 0.2);
+section("The normal curve");
+draw(bc, 1.3);
+say(cap, "so many measurements pile into the same bell — the normal distribution", 0.5);
+wait(2.0);
+say(cap, "68% within one standard deviation, 95% within two, 99.7% within three", 0.5);
+wait(2.2);
+fade(bc, 0.6);
+wait(0.3);
+
+// ---- 3. why ----
+say(cap, "", 0.2);
+section("Why? The Central Limit Theorem");
+draw(ct, 1.4);
+say(cap, "average five dice, a thousand times — however flat one die is…", 0.5);
+wait(2.0);
+say(cap, "…the averages form a bell. THAT is why the normal is everywhere", 0.5);
+wait(2.4);

package/examples/story-addressable-asset-cues.manic

@@ -0,0 +1,71 @@
+title("An Asset Becomes a Story");
+canvas("9:16");
+template("mono");
+
+watermark(mark, (w*0.16, h*0.055), "Made With Manic");
+text(kicker, (cx, h*0.085), "ENGINE FOUNDATION · ASSETS, LABELS & CUES");
+text(headline, (cx, h*0.15), "An imported object should still be explainable");
+text(caption, (cx, h*0.82), "Groups become addressable parts—then motion, notation, sound, and effects compose normally.");
+size(kicker,18); color(kicker,dim); bold(kicker); hidden(kicker);
+size(headline,34); bold(headline); wrap(headline,w*0.84); hidden(headline);
+size(caption,21); color(caption,dim); wrap(caption,w*0.82); hidden(caption);
+
+camera3((16,-22,15),(0,0,0),46);
+assembly3(console,"asset:models/manic-console.obj",(0,0,0),1.35);
+color(console.base,dim);
+color(console.screen,cyan);
+color(console.key,magenta);
+text(screenNote,(0,0),"world-sized display");
+text(keyNote,(0,0),"addressable input");
+size(screenNote,22); color(screenNote,cyan); hidden(screenNote);
+size(keyNote,22); color(keyNote,magenta); hidden(keyNote);
+label3(screenNote,console.screen,0.82);
+label3(keyNote,console.key,0.82);
+hidden(console);
+
+circle(effectBox,(cx,h*0.70),72);
+particles(sparks,effectBox,34,4,19);
+color(sparks,gold);
+hidden(effectBox); hidden(sparks);
+
+step("import") {
+  show(kicker,0.35);
+  show(headline,0.45);
+  show(caption,0.40);
+  show(console,0.75);
+  cue(whoosh);
+}
+wait(0.35);
+
+step("address-the-parts") {
+  seq {
+    show(screenNote,0.35);
+    pulse(console.screen,0.65);
+    fade(screenNote,0.25);
+    show(keyNote,0.35);
+    pulse(console.key,0.65);
+  }
+  say(caption,"OBJ groups arrive as console.base, console.screen, and console.key.",0.42);
+  cue(tick);
+}
+wait(0.35);
+
+step("compose-the-explanation") {
+  par {
+    turn3(console,(0,0,0),z,22,1.4,smooth);
+    orbit3(30,28,30,1.4,smooth);
+    say(caption,"Depth-scaled labels remain crisp while the grouped asset moves.",0.40);
+  }
+}
+wait(0.30);
+
+step("finish-with-a-beat") {
+  show(sparks,0.15);
+  par {
+    burst(sparks,0.9);
+    pulse(console.key,0.65);
+    say(caption,"A reusable cue and the existing generic burst add the final editorial beat.",0.40);
+  }
+  cue(pop);
+}
+wait(1.2);