@maniclang/workbench 0.1.11

package/examples/pendulum.manic

@@ -0,0 +1,38 @@
+// ============================================================================
+//  pendulum.manic  —  the physics kit's first sim, seen FOUR ways (Layer 1)
+// ----------------------------------------------------------------------------
+//  `pendulum(id, [center], [length], [angle0], [unit], [damping])` builds a
+//  pendulum from its physics — PRE-SIMULATED with RK4 at build time
+//  (deterministic). Only `id` is required. The OPTIONAL, generic view builtins
+//  render the SAME simulation as math panels and all animate together on `swing`:
+//    · phase(id,(cx,cy),[size])       — phase portrait (θ vs ω): a closed loop
+//    · timegraph(id,(cx,cy),[size])   — θ(t) & ω(t) with a sweep line
+//    · well(id,(cx,cy),[size])        — energy well U(θ), bob = ball in a bowl
+//    · energygraph(id,(cx,cy),[size]) — KE / PE / total over time
+//
+//  TO ADAPT: add damping (6th arg) and watch the phase loop spiral inward, the
+//  ball settle to the bottom of the well, and total energy decay — e.g.
+//  `pendulum(p, (250,220), 1.2, 55, 105, 0.5)`.
+// ============================================================================
+
+title("Pendulum — one swing, four views");
+canvas("16:9");
+
+text(hdr, (cx, 40), "One pendulum, four views");
+size(hdr, 24); color(hdr, cyan); bold(hdr); display(hdr);
+
+// the physical sim (left), with velocity arrow + KE/PE bars
+pendulum(p, (250, 220), 1.2, 55, 105);
+untraced(p.path);
+
+// four math views of the SAME simulation, 2×2 on the right
+phase(p, (715, 165), 90);          // θ vs ω — a closed loop
+timegraph(p, (1000, 165), 90);     // θ(t), ω(t) with a sweep line
+well(p, (715, 455), 90);           // U(θ) with the bob as a rolling ball
+energygraph(p, (1000, 455), 90);   // KE / PE / total over time
+
+text(cap, (cx, h - 30), "sim · phase portrait · time series · energy well · energy over time — all from one pre-simulated swing");
+size(cap, 16); color(cap, dim); display(cap);
+
+draw(p.path, 0.8);
+swing(p, 10);                      // every panel animates in lockstep

package/examples/perfect-reel.manic

@@ -0,0 +1,43 @@
+// A production-ready Creator v2 Reel: safe layout, exact pacing, one focal
+// equation, restrained motion, reusable branding, markers, and an end card.
+title("Perfect Reel — Angle Ratio");
+canvas("9:16");
+template("mono");
+watermark(manicMark, (w*0.895-100, h*0.075+24), "Made With Manic");
+
+creator(me, "@anish2good name=Proof_Daily tagline=Think_then_prove yt=zarigatongy x=@anish2good web=8gwifi.org/manic accent=cyan secondary=magenta footer=signature cta=Save_and_share safe=reels");
+
+quiz(q, "Triangle angles: 2:3:4. What is the largest?",
+     "studio layout=media-first reveal=fade density=comfortable motion=calm safe=reels accent=cyan");
+option(q, `$60^\circ$`);
+option(q, `$80^\circ$`, correct);
+option(q, `$90^\circ$`);
+option(q, `$100^\circ$`);
+explain(q, `The parts total $9$, so $x=20^\circ$ and $4x=80^\circ$.`, "Angle sum");
+
+equation(prompt, (cx, 650), `2x+3x+4x=180^\circ`, 70);
+color(prompt, cyan);
+figure(prompt);
+hidden(prompt);
+
+// Exact 10.5-second quiz beat. The timer look can change independently.
+timing(q, "calm ask=1.1 options=1 think=5.5 reveal=0.75 hold=2.15 stagger=0.06");
+timerstyle(q, "look=ring position=below number=inside direction=drain size=medium thickness=1.1 color=cyan track=dim label=THINK font=mono finish=pulse");
+
+socials(me);
+endcard(me, "cta=Save_and_share");
+
+mark("hook");
+par {
+  run(q);
+  show(prompt, 0.5);
+}
+
+mark("endcard");
+par {
+  fade(q.parts, 0.45);
+  fade(prompt, 0.45);
+  fade(me.footer, 0.45);
+}
+show(me.endcard, 0.6);
+wait(1.4);

package/examples/pie.manic

@@ -0,0 +1,41 @@
+// Equal Slices — a circle cut into equal *sectors* (real filled pieces, not
+// just lines) with the math-kit `pie(id, center, r, n)` builtin. Each slice is
+// addressable as p0 … p5, so we can trace them on, then pull two out.
+//
+//   manic examples/pie.manic
+//   manic examples/pie.manic --record out --fps 60
+
+title("Equal Slices");
+canvas(1280, 720);
+
+// six equal sectors centred at (560, 400), radius 230 → p0 … p5, tag `p`
+pie(p, (560, 400), 230, 6);
+untraced(p0);  untraced(p1);  untraced(p2);
+untraced(p3);  untraced(p4);  untraced(p5);
+
+text(head, (560, 120), "six equal slices");
+display(head);  color(head, cyan);  size(head, 38);  hidden(head);
+text(cap, (560, 690), "");  color(cap, dim);  size(cap, 22);
+
+// --- cut the circle equally, one slice at a time ---
+show(head, 0.5);
+say(cap, "cut the circle into six equal sectors");
+stagger(0.12) {
+  draw(p0, 0.4);
+  draw(p1, 0.4);
+  draw(p2, 0.4);
+  draw(p3, 0.4);
+  draw(p4, 0.4);
+  draw(p5, 0.4);
+}
+wait(0.6);
+
+// --- each sector is a real piece: pull two out and recolour them ---
+say(cap, "each sector is a real piece — pull two out");
+par {
+  move(p0, (621, 435), 0.6, overshoot);
+  move(p3, (499, 365), 0.6, overshoot);
+  recolor(p0, magenta, 0.5);
+  recolor(p3, lime, 0.5);
+}
+wait(1.0);

package/examples/pieday.manic

@@ -0,0 +1,113 @@
+title("Pi Day");
+canvas("16:9");
+
+let r = h*0.23;
+let centerY = cy + 25;
+let n = 64;
+let petalsN = 12;
+
+text(head, (cx, 70), "Happy Pi Day");
+text(bigPi, (cx, centerY - 8), "pi");
+text(digits, (cx, h - 92), "3.1415926535897932384626433832795028841971...");
+text(formula, (cx, h - 50), "circumference / diameter = pi");
+
+size(head, 40);
+size(bigPi, 112);
+size(digits, 24);
+size(formula, 26);
+bold(head);
+bold(bigPi);
+color(head, magenta);
+color(bigPi, gold);
+color(digits, cyan);
+color(formula, lime);
+hidden(head);
+hidden(bigPi);
+hidden(digits);
+hidden(formula);
+
+circle(mainCircle, (cx, centerY), r);
+line(diameter, (cx - r, centerY), (cx + r, centerY));
+text(diamLab, (cx, centerY + 34), "diameter");
+text(circLab, (cx, centerY - r - 30), "circumference");
+
+stroke(mainCircle, 5);
+stroke(diameter, 3);
+color(mainCircle, cyan);
+color(diameter, lime);
+color(diamLab, lime);
+color(circLab, cyan);
+size(diamLab, 22);
+size(circLab, 22);
+hidden(diamLab);
+hidden(circLab);
+untraced(mainCircle);
+untraced(diameter);
+
+for i in 0..petalsN {
+circle(petal{i}, (cx + 0.54*r*cos(tau*i/petalsN), centerY + 0.54*r*sin(tau*i/petalsN)), 0.46r);
+stroke(petal{i}, 2);
+hue(petal{i}, 360i/petalsN);
+opacity(petal{i}, 0.34);
+untraced(petal{i});
+tag(petal{i}, petals);
+}
+
+for i in 0..n {
+dot(spark{i}, (cx + 1.23*r*cos(tau*i/n), centerY + 1.23*r*sin(tau*i/n)), 4);
+hue(spark{i}, 360*i/n);
+hidden(spark{i});
+tag(spark{i}, sparks);
+}
+
+for i in 0..24 {
+line(ray{i}, (cx + 1.02*r*cos(tau*i/24), centerY + 1.02*r*sin(tau*i/24)), (cx + 1.18*r*cos(tau*i/24), centerY + 1.18*r*sin(tau*i/24)));
+stroke(ray{i}, 3);
+hue(ray{i}, 360*i/24);
+untraced(ray{i});
+tag(ray{i}, rays);
+}
+
+dot(centerDot, (cx, centerY), 6);
+color(centerDot, gold);
+hidden(centerDot);
+
+show(head, 0.7);
+
+par {
+draw(petals, 1.4);
+draw(mainCircle, 1.2);
+}
+
+par {
+draw(diameter, 0.8);
+show(centerDot, 0.4);
+show(diamLab, 0.5);
+show(circLab, 0.5);
+}
+
+par {
+show(bigPi, 0.9);
+draw(rays, 0.9);
+}
+
+stagger(0.018) {
+for i in 0..n {
+show(spark{i}, 0.25);
+}
+}
+
+par {
+show(digits, 0.7);
+show(formula, 0.7);
+}
+
+pulse(bigPi, 0.8);
+pulse(mainCircle, 0.8);
+
+par {
+spin(petals, 18, 3.0, smooth);
+spin(sparks, -35, 3.0, smooth);
+}
+
+wait(1.2);

package/examples/piston.manic

@@ -0,0 +1,7 @@
+// piston.manic — an engine piston: a spinning crank drives a slider in a cylinder.
+title("Engine piston — the slider-crank");
+canvas("16:9");
+text(hdr,(cx,46),"Slider-crank — a spinning crank becomes up-and-down motion"); size(hdr,23); color(hdr,cyan); bold(hdr); display(hdr);
+piston(eng, (cx, 480), 60);
+text(cap,(cx,h-32),"gold crank sweeps the circle; the rod converts it to the piston's stroke"); size(cap,16); color(cap,dim); display(cap);
+run(eng, 9);

package/examples/popkorn-field.manic

@@ -0,0 +1,38 @@
+// popkorn-field — a 6000-point parametric field for Shorts (9:16). One closed-
+// form formula per point, animated by live time `t`: it blooms out of the centre
+// over the first few seconds (a `tanh` growth envelope), then keeps evolving,
+// while each point cycles its own hue. This is the `cloud` primitive — N points
+// placed by formulas of the index `i` and the clock `t`, re-evaluated every
+// frame, yet still a pure function of t (it scrubs and records exactly).
+//
+// The maths is domain-neutral; `cloud` knows nothing about what it draws. Note
+// `hypot(a,b)`, `mod(...)` for the hue wrap, and the `0.5*(s + abs(s))` idiom for
+// `max(0, s)` (min/max are reductions in manic, not 2-arg functions).
+//
+//   manic examples/popkorn-field.manic
+title("popkorn field — 6000 points, one formula each");
+canvas("9:16");
+template("black");
+
+cloud(dust, 6000, #ffffff, 0.5) {
+  let a = 4 * cos(i / 21);
+  let b = i / 1880 - 20;
+  let k = hypot(a, b);
+  let S = 3 * sin(2 * a) + 0.3 / a
+        + sin(i / 4465) * a * (9 + 2 * sin(b * 14 - k * 3 + 2 * t));
+  // raw field, centred near (200,120) at ~400px scale in the original
+  let fx = S + 50 * cos(k - t) + 200;
+  let fy = S * sin(k - t) + k * 39 - 475;
+  // bloom from the centre: 0.15 → ~1 over the first several seconds, so the
+  // full structure only resolves "after some point", then keeps drifting
+  let grow = tanh(t * 0.35 + 0.15);
+  let x = 540 + (fx - 205) * 3.3 * grow;
+  let y = 960 + (fy - 250) * 3.3 * grow;
+  // radius 1 where a*a>15 else 0.5, scaled up for the taller canvas
+  let s = sign(a * a - 15);
+  let r = (0.5 * (1 + 0.5 * (s + abs(s)))) * (2.5 + grow);
+  // each point its own hue, the whole wheel cycling over time
+  let hue = mod(i * 0.05 + t * 30, 360);
+}
+
+wait(16);

package/examples/prism-cinematic.manic

@@ -0,0 +1,36 @@
+// ============================================================================
+//  prism-cinematic.manic  —  white light into a rainbow (annotated, dark bench)
+// ----------------------------------------------------------------------------
+//  The `prism` sim on a dark optics bench, where the spectrum GLOWS (a rainbow
+//  washes out on paper — light is a dark-background subject). Elevation lens:
+//  KINETIC TYPE — the colour names pop in word-by-word (`wordpop`) as the fan
+//  spreads, plus a camera push toward the exit spectrum.
+// ============================================================================
+
+title("Prism — White Light Splits");
+canvas("16:9");
+
+prism(p, (560, 400), "sf11");
+
+// the colour names, popped in one at a time over the fan
+caption(names, "red  orange  yellow  green  blue  violet", (cx + 40, 150), 26, gold);
+
+text(cap, (cx, h - 46), ""); color(cap, fg); size(cap, 24); bold(cap); display(cap); sticky(cap);
+
+// ================= THE SCENE =================
+say(cap, "one beam of white light, into a prism…", 0.5);
+wait(0.5);
+
+par {
+  run(p, 8);
+  seq {
+    par { cam((820, 430), 2.6, smooth); zoom(1.22, 2.6, smooth); }   // fly toward the spectrum
+    say(cap, "…out as a rainbow — the colours were always hidden inside", 0.3);
+    wordpop(names, 0.22);                                            // the colours pop in
+    wait(1.6);
+    say(cap, "blue bends most, red least — real Sellmeier dispersion", 0.3);
+    wait(1.6);
+  }
+}
+par { cam((cx, 400), 1.2, smooth); zoom(1.0, 1.2, smooth); }
+wait(1.0);

package/examples/prism.manic

@@ -0,0 +1,32 @@
+// ============================================================================
+//  prism.manic  —  white light into a rainbow (real dispersion)
+// ----------------------------------------------------------------------------
+//  The `optics` kit's `prism`: white light enters a triangular prism and splits
+//  into a spectrum. Each colour is traced through both faces with its OWN
+//  refractive index (real Sellmeier dispersion) — blue bends more than red
+//  because glass genuinely slows blue more. `run` sweeps the incidence angle,
+//  so the fan swings and its spread widens.
+// ============================================================================
+
+title("Prism — White Light Splits");
+canvas("16:9");
+
+prism(p, (560, 400), "sf11");   // dense flint — a wide, vivid spectrum
+
+text(cap, (cx, h - 46), ""); color(cap, fg); size(cap, 24); bold(cap); display(cap); sticky(cap);
+
+// ================= THE SCENE =================
+say(cap, "one beam of white light, into a prism…", 0.5);
+wait(0.5);
+
+par {
+  run(p, 7);
+  seq {
+    say(cap, "it comes out as a RAINBOW — the colours were always there", 0.3);
+    wait(2.6);
+    say(cap, "blue bends more than red: glass really does slow blue more", 0.3);
+    wait(2.4);
+    say(cap, "steeper in → the spectrum fans WIDER (real Sellmeier dispersion)", 0.3);
+  }
+}
+wait(1.2);

package/examples/probability.manic

@@ -0,0 +1,57 @@
+// ============================================================================
+//  probability.manic  —  a probability & sampling playground (stats)
+// ----------------------------------------------------------------------------
+//  Four ideas on one stage, chaptered with section():
+//     1. named DISTRIBUTIONS  (uniform / exponential / binomial / poisson)
+//     2. CONFIDENCE intervals (an estimate ± a margin)
+//     3. MONTE-CARLO           (estimate pi by throwing darts)
+//     4. RANDOM WALK           (a path that wanders)
+//  Each chapter reveals with untraced(tag) -> draw(tag) and clears with fade(tag).
+//  The seeded builtins (montecarlo, randomwalk) render identically every time.
+// ============================================================================
+
+title("A probability playground");
+canvas("16:9");
+
+// ---- 1. named distributions (a 2x2 gallery) ----
+distribution(du, (cx - 350, cy - 120), "uniform", 2, 6);       untraced(du);
+distribution(de, (cx + 350, cy - 120), "exponential", 1);       untraced(de);
+distribution(db, (cx - 350, cy + 180), "binomial", 12, 0.4);    untraced(db);
+distribution(dp, (cx + 350, cy + 180), "poisson", 4);           untraced(dp);
+// ---- 2. a confidence interval ----
+confidence(ci, (cx, cy), 50, 8, 25, 95, 620); untraced(ci); hidden(ci.estimate);
+// ---- 3. monte-carlo pi ----
+montecarlo(mc, (cx, cy - 10), 1200, 7, 210); untraced(mc);
+// ---- 4. a random walk ----
+randomwalk(rw, (cx, cy), 500, 4, 12); untraced(rw);
+
+text(cap, (cx, h - 44), ""); size(cap, 22); color(cap, dim); display(cap);
+
+section("Named distributions");
+par { draw(du, 0.9); draw(de, 0.9); draw(db, 0.9); draw(dp, 0.9); }
+say(cap, "flat, decaying, discrete counts — the classic shapes of chance", 0.5);
+wait(2.2);
+par { fade(du, 0.5); fade(de, 0.5); fade(db, 0.5); fade(dp, 0.5); }
+wait(0.3);
+
+say(cap, "", 0.2);
+section("Confidence intervals");
+draw(ci, 0.9); show(ci.estimate, 0.4);
+say(cap, "an estimate is never exact — the interval says how sure we are", 0.5);
+wait(2.2);
+fade(ci, 0.6);
+wait(0.3);
+
+say(cap, "", 0.2);
+section("Monte Carlo");
+draw(mc, 1.2);
+say(cap, "throw darts at random: the fraction landing in the circle gives pi", 0.5);
+wait(2.4);
+fade(mc, 0.6);
+wait(0.3);
+
+say(cap, "", 0.2);
+section("Random walk");
+draw(rw, 1.4);
+say(cap, "each step a random direction — chance draws a wandering path", 0.5);
+wait(2.2);

package/examples/process-branching-dispatch.manic

@@ -0,0 +1,71 @@
+// GENERIC PROCESS BRANCHING — one source, three destinations.
+//
+// The paths carry no service semantics. `branch` only sees a directed acyclic
+// network and makes one deterministic uniform choice at every fork. The same
+// foundation drives the Galton-board example.
+
+title("Process Branching — One Source, Three Destinations");
+canvas("16:9");
+template("blank");
+watermark(mark, (145, 70), "Made With Manic");
+
+text(head, (cx, 72), "One collection · many truthful routes");
+text(sub, (cx, 112),
+  "Every request keeps its identity, destination, step count, and arrival time.");
+size(head, 32); bold(head);
+size(sub, 19); color(sub, dim);
+
+circle(source, (180, 340), 24);
+color(source, panel); outline(source, cyan); stroke(source, 3);
+particles(requests, source, 54, 4, 41);
+color(requests, cyan); glow(requests, 0.7); z(requests, 8);
+
+line(entry, (205, 340), (420, 340)); tag(entry, dispatchRoutes);
+spline(upper, (420, 340), (530, 190), (680, 185)); tag(upper, dispatchRoutes);
+line(middle, (420, 340), (680, 340)); tag(middle, dispatchRoutes);
+spline(lower, (420, 340), (530, 490), (680, 495)); tag(lower, dispatchRoutes);
+color(dispatchRoutes, dim); stroke(dispatchRoutes, 3); untraced(dispatchRoutes);
+
+rect(worker0, (735, 185), 150, 82);
+rect(worker1, (735, 340), 150, 82);
+rect(worker2, (735, 495), 150, 82);
+for i in 0..3 {
+  color(worker{i}, panel); outline(worker{i}, cyan); stroke(worker{i}, 2);
+}
+text(w0, (735, 185), "worker 0");
+text(w1, (735, 340), "worker 1");
+text(w2, (735, 495), "worker 2");
+size(w0, 18); size(w1, 18); size(w2, 18);
+
+livehistogram(destinations, (1030, 350), 0, 3, 3, 330, 300, magenta);
+text(histTitle, (1030, 170), "DESTINATION OUTCOME");
+size(histTitle, 19); bold(histTitle); color(histTitle, dim);
+counter(arrived, (1030, 555), 0, 0, "arrived  ", " / 54");
+size(arrived, 21); color(arrived, dim);
+
+text(caption, (cx, 650),
+  "The diagram and histogram are two views of the same seeded dispatch.");
+size(caption, 21); color(caption, dim);
+
+hidden(requests); hidden(destinations); hidden(arrived); hidden(caption);
+
+step("network") {
+  par {
+    draw(dispatchRoutes, 0.75);
+    show(requests, 0.35);
+    show(destinations, 0.45);
+    show(arrived, 0.35);
+    show(caption, 0.35);
+  }
+}
+wait(0.35);
+
+step("dispatch") {
+  par {
+    branch(requests, dispatchRoutes, 5.0, smooth);
+    observe(destinations, requests, outcome);
+    observe(arrived, requests, arrived);
+    flow(dispatchRoutes, 5.0, forward, continuous);
+  }
+}
+wait(1.0);

package/examples/process-stream-observe.manic

@@ -0,0 +1,54 @@
+// PROCESS FOUNDATION — the smallest complete example.
+// A real persistent collection streams along a path. Both observers read the
+// compiled process measurements; neither is animated with guessed values.
+
+title("A Collection Becomes a Process");
+canvas("16:9");
+template("blank");
+watermark(mark, (170, 58), "Made With Manic");
+
+text(kicker, (640, 52), "MANIC · DETERMINISTIC PROCESS");
+text(headline, (640, 100), "One journey. Two truthful views.");
+size(kicker, 18); color(kicker, dim); bold(kicker);
+size(headline, 34); bold(headline);
+
+rect(source, (170, 300), 210, 230);
+outlined(source); outline(source, dim); stroke(source, 3);
+text(sourceLabel, (170, 440), "persistent collection");
+size(sourceLabel, 18); color(sourceLabel, dim);
+particles(packets, source, 42, 5, 17);
+
+spline(route, (275, 300), (410, 140), (560, 470), (720, 285));
+stroke(route, 4); color(route, fg); untraced(route);
+
+livehistogram(speeds, (980, 335), 0.55, 1.05, 10, 430, 220, cyan);
+text(speedLabel, (980, 190), "normalized speed");
+size(speedLabel, 20); bold(speedLabel);
+
+counter(arrivals, (640, 610), 0, 0, "arrived ", " / 42");
+size(arrivals, 25); color(arrivals, dim);
+text(caption, (640, 665), "stream moves real objects · observe reads the same process");
+size(caption, 20); color(caption, dim);
+
+hidden(packets); hidden(speeds); hidden(arrivals); hidden(caption);
+
+step("introduce") {
+  par {
+    show(packets, 0.45);
+    draw(route, 0.65);
+    show(speeds, 0.45);
+    show(arrivals, 0.35);
+    show(caption, 0.35);
+  }
+}
+wait(0.35);
+
+step("stream-and-observe") {
+  par {
+    stream(packets, route, 4.2, 34, smooth);
+    observe(speeds, packets, speed);
+    observe(arrivals, packets, arrived);
+  }
+}
+wait(1.0);
+

package/examples/projection.manic

@@ -0,0 +1,57 @@
+// ============================================================================
+//  projection.manic  —  projection & least-squares (a template)
+// ----------------------------------------------------------------------------
+//  One idea, two faces. ORTHOGONAL PROJECTION drops a vector onto a subspace;
+//  the shadow p is the closest point, and the error b - p meets the subspace at
+//  a right angle. LEAST-SQUARES fits a line to data the SAME way — the best line
+//  is the one that minimises the (squared) residuals, i.e. the projection of the
+//  data onto the space of lines.
+//
+//  `project(id, (cx,cy), unit, (bx,by), (ax,ay), [color])` draws:
+//    id.line (the subspace = span of a), id.b, id.p (the shadow), id.res (error),
+//    id.rt (right-angle mark), id.blabel / id.plabel.
+//  `leastsquares(id, (cx,cy), unit, "x1 y1  x2 y2 ...", [color])` draws:
+//    id.line (best fit), id.points (dots), id.residuals (verticals), id.eq.
+//
+//  TO ADAPT: change b/a in `project`, or the point list in `leastsquares`.
+// ============================================================================
+
+title("Projection & least-squares");
+canvas("16:9");
+
+text(hdr, (cx, 50), "the closest point is a projection — and so is the best-fit line");
+size(hdr, 23); color(hdr, cyan); bold(hdr); display(hdr);
+
+// ---- LEFT: project vector b onto the line spanned by a ----
+plane(pa, (cx - 330, cy + 10), 150, 210, 40);
+project(pj, (cx - 330, cy + 10), 40, (1, 3), (3, 1));
+untraced(pj.line); untraced(pj.b); untraced(pj.p); untraced(pj.res); untraced(pj.rt);
+hidden(pj.blabel); hidden(pj.plabel);
+
+// ---- RIGHT: fit a line to a point cloud ----
+plane(pb, (cx + 310, cy + 90), 150, 150, 34);
+leastsquares(ls, (cx + 310, cy + 90), 34, "1 2  2 3  3 5  4 4  5 6");
+hidden(ls.points); untraced(ls.line); untraced(ls.residuals); hidden(ls.eq);
+
+text(cap, (cx, h - 46), ""); size(cap, 22); color(cap, dim); display(cap);
+
+// ---- Panel A: the projection ----
+say(cap, "drop b onto the line spanned by a — its shadow is the projection p", 0.5);
+draw(pj.line, 0.6);
+draw(pj.b, 0.6);
+wait(0.6);
+par { draw(pj.p, 0.6); draw(pj.res, 0.6); }
+draw(pj.rt, 0.3);
+show(pj.blabel, 0.3); show(pj.plabel, 0.3);
+wait(1.4);
+say(cap, "the error b - p meets the line at a right angle: p is the nearest point", 0.5);
+wait(1.8);
+
+// ---- Panel B: least-squares is the same idea ----
+say(cap, "fitting a line works the SAME way: minimise the squared residuals", 0.5);
+show(ls.points, 0.5);
+wait(0.7);
+draw(ls.line, 0.7);
+draw(ls.residuals, 0.6);
+show(ls.eq, 0.4);
+wait(2.0);