@maniclang/workbench 0.1.11

package/examples/flow-lorenz.manic

@@ -0,0 +1,47 @@
+// flow-lorenz — the Lorenz attractor seen through an artist's lens, via the new
+// `cloud … from flow(...)` bridge. `flow` integrates the 3-D Lorenz ODE (a
+// STATEFUL system clouds alone can't do); each of 30,000 points receives the
+// i-th integrated state as hx/hy/hz, and the cloud's own formulas project that
+// state to the screen — here a polar lens fanned into 9 layers (mod(i,9)). So one
+// primitive now visualises ANY dynamical system through ANY projection you write.
+//
+// Original idea by @yuruyurau (https://x.com/yuruyurau); our hue'd, annotated,
+// bloomed take on a 9:16 Short. The maths is the real Lorenz flow, not a picture.
+//
+//   manic examples/flow-lorenz.manic
+title("A chaotic flow, projected");
+canvas("9:16");
+template("black");
+
+cloud(art, 30000, #ffffff, 0.55)
+  from flow("9*(y - x)", "x*(28 - z) - y", "x*y - 2*z", (9, 9, 9), 0.0005) {
+  // hx, hy, hz = the i-th integrated Lorenz state; project it through the lens
+  let e = sin(t*pi/20 - hx*hx/99 + mod(i, 9)) + 1;
+  let q = hx*e + 89;
+  let k = hz/59 - e/29 + t*pi/480 + mod(i, 9)*8;
+  let px = q*cos(k);
+  let py = (q + 60*cos(k/2)) * sin(k);
+  let grow = tanh(t*0.5 + 0.12);            // bloom from the centre
+  let x = 540 + px * 2.2 * grow;
+  let y = 960 - py * 2.2 * grow;
+  let hue = mod(mod(i, 9)*40 + hz*3 + t*14, 360);   // colour by layer + depth
+}
+
+// ---- textbook annotations ----
+caption(head, "A chaotic flow, projected", (540, 140), 36);
+caption(sub, "integrate the Lorenz system, then project it", (540, 208), 22);
+hidden(head);
+hidden(sub);
+equation(eq, (540, 1706),
+  `\dot x=\sigma(y{-}x),\;\; \dot y=x(\rho{-}z){-}y,\;\; \dot z=xy-\beta z`, 24);
+caption(lab, "the state → your own lens, per point", (540, 1786), 20);
+hidden(eq);
+hidden(lab);
+
+show(head);
+wait(1.4);
+show(sub);
+wait(2.6);
+show(eq);
+show(lab);
+wait(25);

package/examples/fourier-series-live-wave.manic

@@ -0,0 +1,114 @@
+// A focused Fourier story: every orbit and every partial sum is generated from
+// the same live collection. The circles move; their histories become the wave.
+
+title("A Wave Drawn by Rotating Circles");
+canvas("9:16");
+template("blank");
+
+watermark(mark,(w*0.15,h*0.045),"Made With Manic");
+text(kicker,(cx,h*0.075),"FOURIER SERIES · LIVE DERIVED HISTORY");
+text(headline,(cx,h*0.115),"Can rotating circles draw a wave?");
+text(caption,(cx,h*0.18),"Every coloured trace is the real history of one moving endpoint.");
+text(cta,(cx,h*0.925),"BUILD YOUR OWN VISUAL STORY → 8gwifi.org/manic");
+size(kicker,18); color(kicker,dim); bold(kicker); hidden(kicker);
+size(headline,31); bold(headline); wrap(headline,w*0.84); hidden(headline);
+size(caption,20); color(caption,dim); wrap(caption,w*0.84); hidden(caption);
+size(cta,21); color(cta,cyan); bold(cta); hidden(cta);
+
+camera3((-29,-25,43),(1,-2,0),42,orthographic);
+
+collection3(harmonics,(-3,5,0),12,(0,0,0),11,0.065);
+line3(sweep,(-3,5,0),(10,5,0)); hidden(sweep);
+links3(arms,harmonics,chain);
+child3(tip,harmonics,11,0.13);
+
+arrow3(chainX,(-11,5,0),(7,5,0));
+arrow3(chainY,(-3,-2,0),(-3,10.5,0));
+arrow3(plotX,(-7,-10.5,0),(12,-10.5,0));
+arrow3(plotY,(-7,-10.5,0),(-7,-4.2,0));
+
+point3(shotA,(-7.5,-11,0),0.01);
+point3(shotB,(8.5,10.5,0),0.01);
+tag(shotA,shot); tag(shotB,shot);
+hidden(shotA); hidden(shotB);
+
+tag(harmonics,construction); tag(arms,construction); tag(tip,construction);
+tag(chainX,construction); tag(chainY,construction);
+tag(plotX,construction); tag(plotY,construction);
+
+for i in 0..12 {
+  ring3(orbit{i},harmonics,i,72);
+  historyplot3(partial{i},harmonics,i,y,(-7,-10.5,0),(19,6));
+  thick(orbit{i},0.030);
+  thick(partial{i},0.020);
+  tag(orbit{i},construction);
+  tag(partial{i},construction);
+}
+
+equation(formula,(0,0),`f(t)=\sum_{n=1}^{12}\frac{2(-1)^{n+1}}{\pi n}\sin(nt)`,25);
+label3(formula,(-4,-2.7,0),0.82);
+tag(formula,construction);
+
+color(harmonics,fg); color(arms,fg); color(tip,fg);
+color(chainX,fg); color(chainY,fg); color(plotX,fg); color(plotY,fg);
+color(formula,fg);
+thick(chainX,0.016); thick(chainY,0.016);
+thick(plotX,0.016); thick(plotY,0.016);
+
+color(orbit0,lime);      color(partial0,lime);
+color(orbit1,gold);      color(partial1,gold);
+color(orbit2,orange);    color(partial2,orange);
+color(orbit3,coral);     color(partial3,coral);
+color(orbit4,red);       color(partial4,red);
+color(orbit5,magenta);   color(partial5,magenta);
+color(orbit6,violet);    color(partial6,violet);
+color(orbit7,indigo);    color(partial7,indigo);
+color(orbit8,blue);      color(partial8,blue);
+color(orbit9,cyan);      color(partial9,cyan);
+color(orbit10,mint);     color(partial10,mint);
+color(orbit11,fg);       color(partial11,fg);
+
+hidden(construction);
+
+step("ask the visual question") {
+  show(kicker,0.30);
+  show(headline,0.42);
+  show(caption,0.38);
+}
+wait(0.35);
+
+step("reveal one connected machine") {
+  par {
+    show(construction,0.85);
+    view3(shot,"top",1.35,smooth,1.08);
+    say(caption,"Each circle starts where the previous circle ends.",0.38);
+  }
+}
+wait(0.30);
+
+step("let motion become data") {
+  par {
+    // Doubling every angular rate makes the base harmonic complete exactly
+    // two revolutions while preserving all relative frequencies.
+    chain3(harmonics,"2.0372 -1.0186 0.6791 -0.5093 0.4074 -0.3395 0.2910 -0.2546 0.2264 -0.2037 0.1852 -0.1698","2 4 6 8 10 12 14 16 18 20 22 24",16.0);
+    travel3(harmonics,sweep,16.0,linear);
+    seq {
+      say(caption,"Cycle one: the broad motion appears, then smaller circles restore its detail.",0.40);
+      wait(6.10);
+      say(caption,"Cycle two: the same relationships repeat continuously—without a reset or jump.",0.40);
+      wait(5.20);
+      say(caption,"The endpoint histories now contain two complete periods of the signal.",0.40);
+    }
+  }
+}
+wait(0.35);
+
+step("create with Manic") {
+  par {
+    pulse(tip,0.75);
+    pulse(partial11,0.75);
+    show(cta,0.45);
+    say(caption,"Describe the relationship. Manic keeps the circles, histories, motion, and camera together.",0.42);
+  }
+}
+wait(1.45);

package/examples/fourier-square-wave-live.manic

@@ -0,0 +1,114 @@
+// Odd harmonics build a square wave. Every partial sum is a live history of
+// the corresponding endpoint, so the corners emerge from the geometry itself.
+
+title("How Odd Harmonics Build a Square Wave");
+canvas("9:16");
+template("paper");
+
+watermark(mark,(w*0.15,h*0.045),"Made With Manic");
+text(kicker,(cx,h*0.075),"FOURIER · ODD HARMONICS");
+text(headline,(cx,h*0.115),"Watch a square wave find its corners");
+text(caption,(cx,h*0.18),"Start with n = 1. Then add 3, 5, 7 … all the way to 25.");
+text(cta,(cx,h*0.925),"TURN IDEAS INTO ANIMATION → 8gwifi.org/manic");
+size(kicker,18); color(kicker,dim); bold(kicker); hidden(kicker);
+size(headline,31); bold(headline); wrap(headline,w*0.84); hidden(headline);
+size(caption,20); color(caption,dim); wrap(caption,w*0.84); hidden(caption);
+size(cta,21); color(cta,cyan); bold(cta); hidden(cta);
+
+camera3((-29,-25,43),(1,-2,0),42,orthographic);
+
+collection3(series,(-3,5,0),13,(0,0,0),11,0.065);
+line3(sweep,(-3,5,0),(10,5,0)); hidden(sweep);
+links3(arms,series,chain);
+child3(tip,series,12,0.13);
+
+arrow3(chainX,(-11,5,0),(7,5,0));
+arrow3(chainY,(-3,-2,0),(-3,10.5,0));
+arrow3(plotX,(-7,-10.5,0),(12,-10.5,0));
+arrow3(plotY,(-7,-10.5,0),(-7,-4.2,0));
+
+point3(shotA,(-7.5,-11,0),0.01);
+point3(shotB,(8.5,10.5,0),0.01);
+tag(shotA,shot); tag(shotB,shot);
+hidden(shotA); hidden(shotB);
+
+tag(series,construction); tag(arms,construction); tag(tip,construction);
+tag(chainX,construction); tag(chainY,construction);
+tag(plotX,construction); tag(plotY,construction);
+
+for i in 0..13 {
+  ring3(orbit{i},series,i,72);
+  historyplot3(partial{i},series,i,y,(-7,-10.5,0),(19,6));
+  thick(orbit{i},0.030);
+  thick(partial{i},0.020);
+  tag(orbit{i},construction);
+  tag(partial{i},construction);
+}
+
+equation(formula,(0,0),`S_{13}(t)=\sum_{k=0}^{12}\frac{4}{\pi(2k+1)}\sin((2k+1)t)`,24);
+label3(formula,(-4,-2.7,0),0.80);
+tag(formula,construction);
+
+color(series,fg); color(arms,fg); color(tip,fg);
+color(chainX,fg); color(chainY,fg); color(plotX,fg); color(plotY,fg);
+color(formula,fg);
+thick(chainX,0.016); thick(chainY,0.016);
+thick(plotX,0.016); thick(plotY,0.016);
+
+color(orbit0,lime);      color(partial0,lime);
+color(orbit1,gold);      color(partial1,gold);
+color(orbit2,orange);    color(partial2,orange);
+color(orbit3,coral);     color(partial3,coral);
+color(orbit4,red);       color(partial4,red);
+color(orbit5,magenta);   color(partial5,magenta);
+color(orbit6,violet);    color(partial6,violet);
+color(orbit7,indigo);    color(partial7,indigo);
+color(orbit8,blue);      color(partial8,blue);
+color(orbit9,cyan);      color(partial9,cyan);
+color(orbit10,mint);     color(partial10,mint);
+color(orbit11,lime);     color(partial11,lime);
+color(orbit12,fg);       color(partial12,fg);
+
+hidden(construction);
+
+step("begin with one sine wave") {
+  show(kicker,0.30);
+  show(headline,0.42);
+  show(caption,0.38);
+}
+wait(0.35);
+
+step("reveal the odd-harmonic chain") {
+  par {
+    show(construction,0.85);
+    view3(shot,"top",1.35,smooth,1.08);
+    say(caption,"Every smaller orbit contributes the next odd frequency.",0.38);
+  }
+}
+wait(0.30);
+
+step("build the corners live") {
+  par {
+    // Two complete base cycles: all odd harmonic rates are doubled together.
+    chain3(series,"4.0744 1.3581 0.8149 0.5821 0.4527 0.3704 0.3134 0.2716 0.2397 0.2144 0.1940 0.1771 0.1630","2 6 10 14 18 22 26 30 34 38 42 46 50",16.0);
+    travel3(series,sweep,16.0,linear);
+    seq {
+      say(caption,"Cycle one: odd harmonics flatten the plateaus and steepen both sides.",0.40);
+      wait(6.10);
+      say(caption,"Cycle two: every orbit closes and the square-wave pattern returns continuously.",0.40);
+      wait(5.20);
+      say(caption,"Two complete periods make the repeating structure impossible to miss.",0.40);
+    }
+  }
+}
+wait(0.35);
+
+step("create with Manic") {
+  par {
+    pulse(tip,0.75);
+    pulse(partial12,0.75);
+    show(cta,0.45);
+    say(caption,"One declarative chain becomes circles, partial sums, a live waveform, and a complete visual story.",0.42);
+  }
+}
+wait(1.45);

package/examples/fractal_tree.manic

@@ -0,0 +1,39 @@
+// Fractal Tree — a recursive `def` macro draws a branching tree. Each branch
+// splits into two shorter branches at a fixed angle; `if depth > 0` is the base
+// case that stops the recursion. Branches are keyed by a binary-heap index
+// (k -> 2k, 2k+1) so every segment gets a unique id, hued and thinned by depth.
+//
+// Showcases the Phase-2 language layer: `def`, recursion, `if`, comparisons.
+//
+//   manic examples/fractal_tree.manic
+//   manic examples/fractal_tree.manic --record out --fps 60
+
+title("Fractal Tree");
+canvas(1280, 720);
+
+text(head, (640, 92), "one recursive rule, drawn to depth 9");
+display(head);  color(head, cyan);  size(head, 26);  hidden(head);
+
+// draw a branch, then recurse into two children (unless we've bottomed out)
+def branch(k, x, y, ang, len, depth) {
+  // stop at the base depth OR once a branch is too short to see — so even a
+  // large `depth` self-limits (the tree is bounded by branch length)
+  if depth > 0 && len > 2 {
+    let x2 = x + len * cos(ang);
+    let y2 = y - len * sin(ang);          // screen y grows downward
+    line(seg{k}, (x, y), (x2, y2));
+    stroke(seg{k}, 1 + depth * 0.8);
+    hue(seg{k}, 120 + depth * 15);        // trunk bluish -> tips green
+    untraced(seg{k});  tag(seg{k}, tree);
+    branch(2*k,     x2, y2, ang + 0.42, len * 0.72, depth - 1);
+    branch(2*k + 1, x2, y2, ang - 0.42, len * 0.72, depth - 1);
+  }
+}
+
+// grow from the bottom centre, pointing up (angle pi/2)
+branch(1, 640, 700, 1.5708, 150, 20);
+
+// --- script ---
+show(head, 0.5);
+draw(tree, 1.8);
+wait(1.6);

package/examples/frame3-grid-policies.manic

@@ -0,0 +1,48 @@
+// Review file for the six Asymptote grid3 policies that motivated frame3.
+// Each chapter is a normal frame3 declaration, not a renderer special case.
+
+title("Scientific Grid Planes — Asymptote Parity");
+canvas("16:9");
+template("mono");
+watermark(manicMark,(170,70),"Made With Manic");
+
+text(titleText,(640,68),"One frame vocabulary · six grid policies"); size(titleText,30); bold(titleText);
+text(caption,(640,670),"Three lower walls"); size(caption,24); bold(caption); color(caption,gold);
+
+camera3((10,-12,8),(0,0,0),15,orthographic);
+
+frame3(walls,(0,0,0),(8,8,6),"x=-2..2 y=-2..2 z=-1..3 planes=xy:min,xz:min,yz:min major=1 mode=textbook");
+frame3(logWalls,(0,0,0),(8,8,6),"x=0..4 y=0..4 z=0.1..100 planes=xy:min,xz:min zscale=log major=1 mode=textbook");
+frame3(positioned,(0,0,0),(8,8,6),"x=-2..2 y=-2..2 z=-2..2 planes=xy:max,xz:0 major=1 mode=textbook");
+frame3(parallel,(0,0,0),(8,8,6),"x=-2..2 y=-2..2 z=-2..2 planes=xy:-0.5@cyan,xy:1.5@magenta major=1 mode=textbook");
+frame3(majorMinor,(0,0,0),(8,8,6),"x=-2..2 y=-2..2 z=-1..2 planes=xy:min major=1 minor=0.5 mode=textbook");
+frame3(axisPolicy,(0,0,0),(8,8,6),"x=-2..2 y=-2..2 z=-2..2 planes=xy:min,yz:min xmajor=0.5 ymajor=1 zmajor=2 mode=textbook");
+
+hidden(logWalls); hidden(positioned); hidden(parallel); hidden(majorMinor); hidden(axisPolicy);
+
+step("three lower walls") {
+  show(walls,0.65);
+  wait(0.70);
+}
+step("linear floor with logarithmic height") {
+  par { fade(walls,0.45); show(logWalls,0.60); say(caption,"Linear floor · logarithmic z",0.40,smooth); }
+  wait(0.70);
+}
+step("top and explicit-position planes") {
+  par { fade(logWalls,0.45); show(positioned,0.60); say(caption,"XY at max · XZ at y=0",0.40,smooth); }
+  wait(0.70);
+}
+step("parallel colored sections") {
+  par { fade(positioned,0.45); show(parallel,0.60); say(caption,"Two parallel XY sections",0.40,smooth); }
+  wait(0.70);
+}
+step("major and minor lines") {
+  par { fade(parallel,0.45); show(majorMinor,0.60); say(caption,"Major ticks derive the major grid",0.40,smooth); }
+  wait(0.70);
+}
+step("independent axis policy") {
+  par { fade(majorMinor,0.45); show(axisPolicy,0.60); say(caption,"Each axis chooses its own interval",0.40,smooth); }
+  present3(axisPolicy,spatial,0.70,smooth);
+  orbit3(118,30,12,2.10,smooth);
+  wait(1.40);
+}

package/examples/ftc.manic

@@ -0,0 +1,54 @@
+title("The Fundamental Theorem of Calculus");
+canvas("16:9");
+
+let ox = cx - 460;   // math x=0 maps here
+let oy = cy + 20;
+
+text(hdr, (cx, 52), "Differentiate the area — and the function comes back");
+size(hdr, 26); color(hdr, cyan); bold(hdr); display(hdr); hidden(hdr);
+
+axes(ax, (ox, oy), 900, 200, 1);
+color(ax, dim); untraced(ax);
+
+// f(x) = cos x
+plot(f, (ox, oy), 140, 150, "cos(x)", (0, 6.3));
+color(f, cyan); stroke(f, 4); untraced(f);
+
+// F(x) = area under f from 0 to x  =  sin x
+accum(bigF, f);
+color(bigF, lime); stroke(bigF, 3); untraced(bigF);
+
+// F'(x): differentiate the area function — it lands right back on f
+deriv(dF, bigF);
+color(dF, gold); stroke(dF, 3); untraced(dF);
+
+// legend
+text(lf, (cx + 300, 150), "f(x) = cos x");
+size(lf, 20); color(lf, cyan); display(lf); hidden(lf);
+text(lF, (cx + 300, 190), "F(x) = area so far");
+size(lF, 20); color(lF, lime); display(lF); hidden(lF);
+text(ld, (cx + 300, 230), "F'(x) = f(x)");
+size(ld, 20); color(ld, gold); bold(ld); display(ld); hidden(ld);
+
+text(cap, (cx, h - 52), "the slope of the area-so-far IS the original curve");
+size(cap, 20); color(cap, dim); display(cap); hidden(cap);
+
+// ================= timeline =================
+show(hdr, 0.6);
+draw(ax, 0.7);
+
+// 1. the function
+draw(f, 1.3);
+show(lf, 0.4);
+wait(0.3);
+
+// 2. its accumulated area, as a new curve (this is sin x)
+draw(bigF, 1.6);
+show(lF, 0.4);
+wait(0.4);
+
+// 3. differentiate that area function — it traces back onto f
+draw(dF, 1.6);
+show(ld, 0.4);
+flash(dF, gold);
+show(cap, 0.5);

package/examples/function_graph.manic

@@ -0,0 +1,54 @@
+// Function Graphs — plot ANY formula, not just a named curve. manic's answer to
+// Manim's FunctionGraph(lambda t: ...): pass a formula string in x (alias t) and
+// plot() samples it. This reproduces Manim's ExampleFunctionGraph — two
+// Fourier-style packets and a domain-clipped, lifted copy of the second.
+//
+//   manic examples/function_graph.manic
+//   manic examples/function_graph.manic --record out --fps 60
+
+title("Function Graphs");
+canvas(1280, 720);
+
+text(head, (640, 92), "plot any formula — y = f(x)");
+display(head);  color(head, cyan);  size(head, 26);  hidden(head);
+text(cap, (640, 656), "");  color(cap, dim);  size(cap, 22);
+
+// a faint frame to read the curves against (unit = 70 px)
+plane(pl, (640, 384), 620, 300, 70);
+hidden(pl.grid);  untraced(pl.x);  untraced(pl.y);
+
+// a cosine packet: cos t + 1/2 cos 7t + 1/7 cos 14t, over x in [-7, 7]
+plot(cosf, (640, 384), 70, 70, "cos(x) + 0.5*cos(7*x) + (1/7)*cos(14*x)", 7);
+color(cosf, magenta);  untraced(cosf);
+
+// the sine version of the same packet
+plot(sinf, (640, 384), 70, 70, "sin(x) + 0.5*sin(7*x) + (1/7)*sin(14*x)", 7);
+color(sinf, cyan);  untraced(sinf);
+
+// same formula, clipped to x in [-4, 4] and lifted one unit (centre y - 70)
+plot(sinf2, (640, 314), 70, 70, "sin(x) + 0.5*sin(7*x) + (1/7)*sin(14*x)", 4);
+color(sinf2, lime);  untraced(sinf2);
+
+// --- reveal ---
+show(head, 0.5);
+section("The plane");
+say(cap, "a grid to read against — arrows on the axes");
+show(pl.grid, 0.6);
+par { draw(pl.x, 0.5);  draw(pl.y, 0.5); }
+wait(0.3);
+
+section("A cosine packet");
+say(cap, "y = cos t + 1/2 cos 7t + 1/7 cos 14t");
+draw(cosf, 1.3);
+wait(0.6);
+
+section("A sine packet");
+say(cap, "same shape, sin for cos");
+draw(sinf, 1.3);
+wait(0.6);
+
+section("Clip the domain");
+say(cap, "same formula, but only x in [-4, 4], lifted one unit");
+draw(sinf2, 1.1);
+par { pulse(cosf);  pulse(sinf);  pulse(sinf2); }
+wait(1.4);

package/examples/galton-board-process.manic

@@ -0,0 +1,150 @@
+// GALTON BOARD — RANDOM LOCALLY, PREDICTABLE GLOBALLY
+//
+// This is a probability story built from generic process vocabulary. Ordinary
+// tagged lines form the board; `branch` preserves each ball through eight
+// choices; `collect` and `observe` build the distribution from real arrivals.
+
+title("How Random Choices Become a Bell Curve");
+canvas("9:16");
+template("blank");
+
+watermark(mark,(w*0.16,h*0.042),"Made With Manic");
+text(kicker,(cx,h*0.070),"PROBABILITY · RANDOM LOCALLY, ORDERED GLOBALLY");
+text(headline,(cx,h*0.115),"Can random choices create a predictable shape?");
+text(chapter,(cx,h*0.195),"1 · BEGIN WITH ONE FORK");
+text(caption,(cx,h*0.855),"One ball can land almost anywhere.");
+text(insight,(cx,h*0.815),"MORE ROUTES LEAD TO THE CENTER");
+text(cta,(cx,h*0.930),"MAKE PROBABILITY VISIBLE → 8gwifi.org/manic");
+
+size(kicker,18); color(kicker,dim); bold(kicker); hidden(kicker);
+size(headline,31); bold(headline); wrap(headline,w*0.84); hidden(headline);
+size(chapter,19); color(chapter,cyan); bold(chapter); hidden(chapter);
+size(caption,21); color(caption,dim); wrap(caption,w*0.84); hidden(caption);
+size(insight,19); color(insight,lime); bold(insight); hidden(insight);
+size(cta,21); color(cta,cyan); bold(cta); hidden(cta);
+
+equation(law,(cx,h*0.158),`X\sim\operatorname{Binomial}\!\left(8,\frac12\right)`,29);
+hidden(law);
+
+let levels = 8;
+let boardX = cx;
+let topY = h*0.235;
+let dx = w*0.065;
+let dy = h*0.034;
+
+// Every directed edge joins one row to the next. Converging endpoints create
+// the ordinary rooted DAG followed by `branch`.
+for r in 0..levels {
+  for k in 0..r+1 {
+    let x1 = boardX + (k-r*0.5)*dx;
+    let y1 = topY + r*dy;
+    let xl = boardX + (k-(r+1)*0.5)*dx;
+    let xr = boardX + (k+1-(r+1)*0.5)*dx;
+    let y2 = topY + (r+1)*dy;
+
+    line(left{r}_{k},(x1,y1),(xl,y2));
+    line(right{r}_{k},(x1,y1),(xr,y2));
+    tag(left{r}_{k},boardRoutes); tag(right{r}_{k},boardRoutes);
+    color(left{r}_{k},dim); color(right{r}_{k},dim);
+    stroke(left{r}_{k},1.7); stroke(right{r}_{k},1.7);
+    opacity(left{r}_{k},0.30); opacity(right{r}_{k},0.30);
+
+    dot(peg{r}_{k},(x1,y1),4.8);
+    color(peg{r}_{k},fg); glow(peg{r}_{k},0.36); tag(peg{r}_{k},pegs);
+  }
+}
+untraced(boardRoutes);
+
+for k in 0..levels+1 {
+  let tx = boardX + (k-levels*0.5)*dx;
+  let ty = topY + levels*dy;
+  dot(exit{k},(tx,ty),5);
+  color(exit{k},gold); glow(exit{k},0.45); tag(exit{k},exits);
+  counter(bin{k},(tx,ty+28),k,0);
+  size(bin{k},15); color(bin{k},dim); tag(bin{k},exitLabels);
+}
+
+text(leftChoice,(boardX-dx*0.72,topY+dy*0.72),"LEFT");
+text(rightChoice,(boardX+dx*0.72,topY+dy*0.72),"RIGHT");
+size(leftChoice,15); size(rightChoice,15);
+color(leftChoice,cyan); color(rightChoice,magenta);
+hidden(leftChoice); hidden(rightChoice);
+
+circle(source,(boardX,topY),13);
+opacity(source,0);
+particles(balls,source,180,4.0,73);
+color(balls,cyan); glow(balls,0.78); z(balls,9);
+
+let histY = h*0.695;
+livehistogram(outcomes,(cx,histY),0,9,9,w*0.76,h*0.155,magenta);
+text(histTitle,(cx,h*0.595),"WHERE 180 BALLS ACTUALLY LANDED");
+size(histTitle,18); bold(histTitle); color(histTitle,dim);
+counter(landed,(cx,h*0.785),0,0,"landed  "," / 180");
+size(landed,21); color(landed,dim);
+
+hidden(pegs); hidden(exits); hidden(exitLabels);
+hidden(balls); hidden(outcomes); hidden(histTitle); hidden(landed);
+
+step("introduce one uncertain choice") {
+  par {
+    show(kicker,0.30);
+    show(headline,0.45);
+    show(law,0.45);
+    show(chapter,0.35);
+    show(caption,0.40);
+    draw(boardRoutes,0.90);
+    show(pegs,0.55);
+    show(exits,0.45);
+    show(exitLabels,0.45);
+    show(leftChoice,0.35);
+    show(rightChoice,0.35);
+  }
+}
+wait(0.60);
+
+step("repeat the choice eight times") {
+  par {
+    show(outcomes,0.50);
+    show(histTitle,0.35);
+    show(landed,0.35);
+    say(chapter,"2 · REPEAT LEFT OR RIGHT EIGHT TIMES",0.38);
+    say(caption,"At every peg, each ball makes another equally likely left-or-right choice.",0.44);
+  }
+}
+wait(0.55);
+
+step("let the crowd reveal the pattern") {
+  par {
+    branch(balls,boardRoutes,8.20,smooth);
+    collect(outcomes,balls,outcome,0.34,smooth);
+    observe(outcomes,balls,outcome);
+    observe(landed,balls,arrived);
+    show(balls,0.15);
+    seq {
+      say(chapter,"3 · WATCH 180 INDIVIDUAL JOURNEYS",0.38);
+      say(caption,"One route is unpredictable. The crowd begins to expose a stable pattern.",0.44);
+      wait(3.40);
+      say(caption,"Every bar is measured from the same balls you see falling—not animated separately.",0.44);
+    }
+  }
+}
+wait(0.65);
+
+step("explain why the center wins") {
+  par {
+    pulse(outcomes.bars,0.80);
+    show(insight,0.45);
+    say(chapter,"4 · ORDER EMERGES FROM MANY CHOICES",0.38);
+    say(caption,"Extreme bins need nearly all-left or all-right. Many more mixed sequences end near the center.",0.48);
+  }
+}
+wait(0.75);
+
+step("create with Manic") {
+  par {
+    pulse(outcomes.bars,0.75);
+    show(cta,0.45);
+    say(caption,"Describe the choices once. Manic keeps every route, arrival, count, and live distribution connected.",0.45);
+  }
+}
+wait(1.45);