@maniclang/workbench 0.1.11

package/examples/sine_wave.manic

@@ -0,0 +1,42 @@
+// The Sine Wave — a first taste of the manic math kit.
+//   manic examples/sine_wave.manic
+//   manic examples/sine_wave.manic --still 2.6 --scale 1.5 --crt
+
+title("The Sine Wave");
+canvas(1280, 720);
+
+// --- cast: the world at t = 0 ---
+
+// a coordinate frame centred on the stage
+axes(ax, (640, 380), 520, 240);
+text(xlab, (1180, 410), "x");  color(xlab, dim);  size(xlab, 22);
+text(ylab, (665, 152), "y");   color(ylab, dim);  size(ylab, 22);
+
+// the curve: visible but not yet drawn, so we can trace it on
+plot(wave, (640, 380), 78, 120, sin, 6.6);
+untraced(wave);
+
+// a vector to point at, revealed later
+vector(v1, (640, 380), (122, 108));
+hidden(v1);
+
+// headline + caption
+text(head, (640, 118), "y = sin(x)");
+display(head);  color(head, cyan);  size(head, 40);  hidden(head);
+text(cap, (640, 662), "");  color(cap, dim);  size(cap, 22);
+
+// --- script: beats, top to bottom ---
+
+show(head, 0.5);
+say(cap, "a coordinate frame on the void");
+draw(wave, 1.7);
+say(cap, "y = sin(x), traced on");
+wait(0.6);
+
+section("Vectors");
+say(cap, "a vector from the origin");
+par {
+  show(v1, 0.4);
+  pulse(v1);
+}
+wait(1.2);

package/examples/skew.manic

@@ -0,0 +1,40 @@
+// ============================================================================
+//  skew.manic  —  the shape of a dataset: skewness (stats Tier 1)
+// ----------------------------------------------------------------------------
+//  `skew(id, (cx,cy), "v1 v2 v3 …", [bins], [width], [height], [color])` draws a
+//  histogram with the **mean** (gold) and **median** (magenta) marked and a
+//  labelled skewness. The tell: when the mean sits right of the median, a right
+//  tail is pulling it — the data is right-skewed (positive); left of it, left-
+//  skewed; on top of it, symmetric.
+//
+//  TO ADAPT: paste your numbers. Incomes, wait times and prices are classically
+//  right-skewed (a few big values pull the mean up).
+// ============================================================================
+
+title("Skewness: which way does the tail point?");
+canvas("16:9");
+
+text(hdr, (cx, 66), "monthly salaries (k) — a few big earners pull the mean up");
+size(hdr, 23); color(hdr, cyan); bold(hdr); display(hdr);
+
+skew(sk, (cx, cy - 10),
+  "28 30 32 31 29 33 35 30 31 34 42 38 30 32 31 33 30 36 55 68 90 30 34 31", 14, 560, 240);
+untraced(sk.bars);
+hidden(sk.meanline); hidden(sk.meanlbl);
+hidden(sk.medianline); hidden(sk.medianlbl);
+hidden(sk.skewlbl);
+
+text(cap, (cx, h - 46), ""); size(cap, 22); color(cap, dim); display(cap);
+
+say(cap, "most salaries cluster low, with a long tail of high earners", 0.5);
+stagger(0.05) { for k in 0..14 { draw(sk.bar{k}, 0.3); } }
+wait(1.2);
+
+say(cap, "the median sits in the cluster — but the mean is dragged toward the tail", 0.5);
+show(sk.medianline, 0.4); show(sk.medianlbl, 0.3);
+show(sk.meanline, 0.4); show(sk.meanlbl, 0.3);
+wait(1.6);
+
+say(cap, "mean to the right of median = right-skewed (positive skew)", 0.5);
+show(sk.skewlbl, 0.4);
+wait(1.8);

package/examples/smoke.rs

@@ -0,0 +1,57 @@
+//! Engine smoke test: a neon frame with each primitive + a few verbs.
+//! Renders the visual identity independently of the .manic language.
+//!
+//! Live:   cargo run --example smoke
+//! Still:  cargo run --example smoke -- --still 2.0 --scale 1.5
+//! CRT:    cargo run --example smoke -- --crt
+
+use manic::prelude::*;
+
+fn main() {
+    let mut m = Movie::new("manic", 1280, 720);
+
+    {
+        let mut s = m.scene();
+        s.circle("a", v(360.0, 360.0), 48.0).label("A");
+        s.circle("b", v(920.0, 360.0), 48.0)
+            .color(PANEL)
+            .label("B")
+            .hidden();
+        s.arrow("e", v(408.0, 360.0), v(408.0, 360.0))
+            .color(MAGENTA)
+            .hidden();
+        s.rect("box", v(640.0, 520.0), 120.0, 70.0)
+            .outline_color(LIME)
+            .hidden();
+        s.text("cap", v(640.0, 640.0), "")
+            .size(24.0)
+            .color(DIM)
+            .hidden();
+        s.text("title", v(640.0, 200.0), "NEON TERMINAL")
+            .display()
+            .size(44.0)
+            .color(CYAN)
+            .hidden();
+    }
+
+    m.play(act().fade_in("title").dur(0.5));
+    m.play(act().set_text("cap", "primitives, glowing, on the void"));
+    m.play(act().fade_in("b").dur(0.4));
+    m.play(par![
+        act().fade_in("e").dur(0.15),
+        act()
+            .grow_to("e", v(872.0, 360.0))
+            .dur(0.6)
+            .ease(InOutCubic),
+    ]);
+    m.play(seq![
+        act().highlight("b", MAGENTA),
+        act().pulse("b"),
+        wait(0.4),
+    ]);
+    m.play(act().fade_in("box").dur(0.4));
+    m.play(act().move_to("a", v(360.0, 250.0)).dur(0.6).ease(OutBack));
+    m.wait(1.0);
+
+    manic::run(m);
+}

package/examples/solids3.manic

@@ -0,0 +1,22 @@
+title("3D solids");
+canvas(1280, 720);
+template("terminal");
+
+camera3((9, -11, 7), (0, 0, 1), 45);
+grid3(floor, (0, 0, 0), 6, 1);
+color(floor, dim);
+axes3(world, (0, 0, 0), 3);
+
+// hexagonal prism
+prism3(hex, (-4, 0, 1.2), 6, 1.1, 2.4);
+color(hex, cyan);
+
+// a cone (a pyramid with many sides)
+pyramid3(cone, (0, 0, 1.4), 28, 1.2, 2.8);
+color(cone, magenta);
+
+// a lathed vase: radius profile r(t) swept around the vertical axis
+revolve3(vase, (4, 0, 1.5), "0.7 + 0.45*sin(t*2.4)", (0, 3), 32);
+color(vase, gold);
+
+orbit3(60, 24, 17, 6, smooth);

package/examples/some-story.manic

@@ -0,0 +1,299 @@
+title("Angle Between Two Lines — Visualizing the Problem");
+canvas("16:9");
+template("black");
+
+// --- build-time geometry (pure computation, no answer stated on screen) ---
+let sx = 60;
+let sy = 60;
+let s3 = sqrt(3);
+
+// Given line: sqrt(3)x + y = 1  =>  y = 1 - sqrt(3)*x
+// Candidate line L through (3,-2) with slope sqrt(3): y = sqrt(3)*x - 3*sqrt(3) - 2
+// (This is the configuration that both makes a 60 degree angle with the given
+// line AND actually crosses the x-axis — we only use it to draw the picture.)
+
+let ix = (s3 + 3) / 2;
+let iy = 1 - s3*ix;
+let ipx = cx + ix*sx;
+let ipy = cy - iy*sy;
+
+let aax = -1;
+let aay = 1 - s3*aax;
+let apx = cx + aax*sx;
+let apy = cy - aay*sy;
+
+let ppx = cx + 3*sx;
+let ppy = cy - (-2)*sy;
+
+let xint = 3 + 2/s3;
+let xintpx = cx + xint*sx;
+let xintpy = cy;
+
+// --- cast (constructors): declare entities at t = 0 ---
+text(problem, (cx, 60), "A line $L$ through $(3,-2)$ is inclined at $60^\circ$ to $\sqrt{3}x + y = 1$ and meets the $x$-axis.");
+size(problem, 30);
+color(problem, fg);
+wrap(problem, 1050);
+hidden(problem);
+
+text(question, (cx, h - 50), "What is the equation of line $L$?");
+size(question, 32);
+color(question, gold);
+hidden(question);
+
+axes(axs, (cx, cy), 380, 340, 60);
+hidden(axs);
+
+plot(givenLine, (cx, cy), sx, sy, "1 - sqrt(3)*x", (-2, 3.4));
+color(givenLine, cyan);
+untraced(givenLine);
+
+equation(givenLabel, (apx - 70, apy - 30), `\sqrt{3}x+y=1`, 28);
+color(givenLabel, cyan);
+hidden(givenLabel);
+
+plot(L, (cx, cy), sx, sy, "sqrt(3)*x - 3*sqrt(3) - 2", (1.3, 5.3));
+color(L, magenta);
+dashed(L);
+untraced(L);
+
+text(Llabel, (xintpx + 30, xintpy - 60), "L");
+size(Llabel, 30);
+color(Llabel, magenta);
+hidden(Llabel);
+
+point(I, (ipx, ipy));
+hidden(I);
+
+point(A, (apx, apy));
+hidden(A);
+
+point(Bp, (ppx, ppy), "P(3, -2)");
+color(Bp, gold);
+size(Bp.label, 28);
+hidden(Bp);
+
+point(Q, (xintpx, xintpy), "L meets x-axis");
+color(Q, lime);
+size(Q.label, 26);
+hidden(Q);
+
+anglemark(ang, A, I, Bp);
+color(ang, gold);
+untraced(ang);
+
+equation(angLabel, (ipx - 20, ipy - 60), `60^\circ`, 30);
+color(angLabel, gold);
+hidden(angLabel);
+
+// --- script (timeline): reveal the construction step by step ---
+show(problem, 1);
+wait(0.5);
+
+show(axs, 1);
+wait(0.3);
+
+draw(givenLine, 1.2);
+show(givenLabel, 0.6);
+wait(0.4);
+
+show(Bp, 0.6);
+wait(0.4);
+
+draw(L, 1.2);
+show(Llabel, 0.5);
+wait(0.4);
+
+draw(ang, 0.8);
+show(angLabel, 0.6);
+wait(0.4);
+
+show(Q, 0.6);
+wait(0.6);
+
+show(question, 1);
+wait(1.5);
+
+// =====================================================================
+// PART 2 — Finding the solution
+// =====================================================================
+
+// clear the setup off screen to make room for the algebra
+fade(problem, 0.6);
+fade(question, 0.6);
+par {
+  fade(axs, 0.6);
+  fade(givenLine, 0.6);
+  fade(givenLabel, 0.6);
+  fade(L, 0.6);
+  fade(Llabel, 0.6);
+  fade(ang, 0.6);
+  fade(angLabel, 0.6);
+  fade(Bp, 0.6);
+  fade(Q, 0.6);
+  fade(I, 0.6);
+  fade(A, 0.6);
+}
+wait(0.4);
+
+section("Solving for the Slope of L");
+
+text(step1, (cx, 160), "Let the slope of $L$ be $m$. The given line $\sqrt{3}x+y=1$ has slope $m_1=-\sqrt{3}$.");
+size(step1, 28);
+color(step1, fg);
+wrap(step1, 1050);
+hidden(step1);
+
+equation(tanFormula, (cx, 280), `\tan 60^\circ=\left|\frac{m-m_1}{1+m\,m_1}\right|`, 42);
+hidden(tanFormula);
+
+equation(tanSub, (cx, 380), `\sqrt{3}=\left|\frac{m+\sqrt{3}}{1-\sqrt{3}\,m}\right|`, 42);
+hidden(tanSub);
+
+show(step1, 0.8);
+wait(0.4);
+show(tanFormula, 0.8);
+wait(0.6);
+show(tanSub, 0.8);
+wait(1);
+
+text(caseLabel, (cx, 460), "Removing the modulus gives two possible slopes:");
+size(caseLabel, 26);
+color(caseLabel, fg);
+hidden(caseLabel);
+show(caseLabel, 0.6);
+wait(0.3);
+
+equation(case1, (cx - 260, 540), `m=0`, 40);
+hidden(case1);
+
+text(case1note, (cx - 260, 600), "horizontal — never meets the $x$-axis");
+size(case1note, 22);
+color(case1note, dim);
+wrap(case1note, 340);
+hidden(case1note);
+
+equation(case2, (cx + 260, 540), `m=\sqrt{3}`, 40);
+hidden(case2);
+
+text(case2note, (cx + 260, 600), "meets the $x$-axis — this is $L$");
+size(case2note, 22);
+color(case2note, lime);
+wrap(case2note, 340);
+hidden(case2note);
+
+par {
+  show(case1, 0.6);
+  show(case1note, 0.6);
+}
+wait(0.4);
+par {
+  show(case2, 0.6);
+  show(case2note, 0.6);
+}
+wait(0.8);
+
+par {
+  recolor(case1, dim, 0.5);
+  recolor(case1note, dim, 0.5);
+}
+flash(case2, lime);
+wait(1);
+
+// dismiss the rejected case and the tan-formula scaffolding
+par {
+  fade(step1, 0.5);
+  fade(tanFormula, 0.5);
+  fade(tanSub, 0.5);
+  fade(caseLabel, 0.5);
+  fade(case1, 0.5);
+  fade(case1note, 0.5);
+}
+wait(0.3);
+
+par {
+  move(case2, (cx, 200), 0.8);
+  fade(case2note, 0.4);
+}
+wait(0.6);
+
+text(finalIntro, (cx, 300), "Using point-slope form through $P(3,-2)$ with $m=\sqrt{3}$:");
+size(finalIntro, 28);
+color(finalIntro, fg);
+wrap(finalIntro, 1050);
+hidden(finalIntro);
+show(finalIntro, 0.7);
+wait(0.4);
+
+equation(eqL, (cx, 400), `y-(-2)=\sqrt{3}(x-3)`, 44);
+hidden(eqL);
+show(eqL, 0.8);
+wait(0.9);
+
+rewrite(eqL, `y+2=\sqrt{3}x-3\sqrt{3}`, 1, smooth);
+wait(0.9);
+
+rewrite(eqL, `\sqrt{3}x-y-3\sqrt{3}-2=0`, 1, smooth);
+wait(1);
+
+text(finalLabel, (cx, 500), "Equation of Line L");
+size(finalLabel, 30);
+color(finalLabel, gold);
+hidden(finalLabel);
+show(finalLabel, 0.6);
+wait(0.3);
+
+par {
+  move(eqL, (cx, 560), 0.6);
+  scale(eqL, 1.15, 0.6);
+}
+recolor(eqL, gold, 0.4);
+pulse(eqL, 0.8);
+wait(1.5);
+
+// =====================================================================
+// PART 3 — Reveal the solved line back on the original figure
+// =====================================================================
+
+par {
+  fade(case2, 0.5);
+  fade(finalIntro, 0.5);
+  fade(finalLabel, 0.5);
+  fade(eqL, 0.5);
+}
+wait(0.4);
+
+section("The Solution, Visualized");
+
+par {
+  show(axs, 0.8);
+  show(givenLine, 0.8);
+  show(givenLabel, 0.6);
+}
+wait(0.3);
+
+par {
+  show(Bp, 0.5);
+  show(L, 0.8);
+}
+recolor(L, gold, 0.6);
+show(Q, 0.6);
+wait(0.4);
+
+equation(answer, (xintpx + 40, xintpy - 90), `\sqrt{3}x-y-3\sqrt{3}-2=0`, 32);
+color(answer, gold);
+hidden(answer);
+show(answer, 1);
+wait(0.6);
+
+par {
+  cam((xintpx, cy), 1.3, smooth);
+  zoom(1.3, 1.3, smooth);
+}
+wait(1.4);
+
+par {
+  cam((cx, cy), 1, smooth);
+  zoom(1, 1, smooth);
+}
+wait(1.5);

package/examples/spinning-cylinder-flow.manic

@@ -0,0 +1,87 @@
+// Streamlines of potential flow around a spinning cylinder — the superposition
+// that explains the Magnus effect (why a spun ball curves). Uniform flow (parallel
+// streamlines) + a free vortex (concentric streamlines) superpose into the
+// asymmetric flow around a rotating cylinder: bunched (fast, low-pressure) on one
+// side, spread (slow, high-pressure) on the other → a net Magnus force. The combined
+// streamlines are integrated straight from the velocity field with `trajectory`.
+title("Why a Spinning Ball Curves");
+canvas("16:9");
+template("neon");
+
+let ox = cx;
+let oy = cy + 20;
+let sc = 82;      // px per field unit
+let a = 98;       // cylinder radius (px)
+
+
+// --- stage 1: uniform flow = parallel streamlines ---
+for k in 0..11 {
+  line(uni{k}, (ox-430, oy + (k-5)*44), (ox+430, oy + (k-5)*44));
+  color(uni{k}, cyan); untraced(uni{k}); tag(uni{k}, uniform);
+}
+// --- stage 2: a free vortex = concentric circular streamlines ---
+for k in 0..5 {
+  circle(vor{k}, (ox, oy), 55 + k*52); color(vor{k}, magenta); untraced(vor{k}); tag(vor{k}, vortex);
+}
+
+// --- stage 3: the superposition — streamlines around the spinning cylinder ---
+for i in 0..17 {
+  let y0 = -4.4 + i*0.55;
+  trajectory(fl{i},
+    "1 - 1.44*(x*x-y*y)/((x*x+y*y)^2) - 0.7*y/(x*x+y*y)",
+    "0 - 2.88*x*y/((x*x+y*y)^2) + 0.7*x/(x*x+y*y)",
+    (-4.6, y0), (ox, oy), sc, 520);
+  color(fl{i}, cyan); glow(fl{i}, 0.4); untraced(fl{i}); tag(fl{i}, combo);
+}
+circle(cyl, (ox, oy), a); color(cyl, gold); filled(cyl); hidden(cyl);
+circle(cylo, (ox, oy), a); color(cylo, gold); outline(cylo, gold); hidden(cylo);
+
+// spin arrow (clockwise) + labels + net force + Kutta–Joukowski
+arrow(spinT, (ox-34, oy-a-8), (ox+34, oy-a-8)); color(spinT, gold); hidden(spinT);
+arrow(spinB, (ox+34, oy+a+8), (ox-34, oy+a+8)); color(spinB, gold); hidden(spinB);
+arrow(inflow, (ox-430, oy+230), (ox-330, oy+230)); color(inflow, dim); hidden(inflow);
+text(inl, (ox-360, oy+205), "U"); size(inl, 22); color(inl, dim); hidden(inl);
+arrow(force, (ox+a+70, oy+30), (ox+a+70, oy-90)); color(force, lime); stroke(force, 5); hidden(force);
+text(fl_lab, (ox+a+150, oy-30), "Magnus\nforce"); size(fl_lab, 22); color(fl_lab, lime); hidden(fl_lab);
+text(fast, (ox, oy-a-70), "streamlines bunch → faster → LOW pressure"); size(fast, 20); color(fast, cyan); wrap(fast, 520); hidden(fast);
+text(slow, (ox, oy+a+70), "spread → slower → HIGH pressure"); size(slow, 20); color(slow, magenta); wrap(slow, 520); hidden(slow);
+equation(kj, (cx, h-70), `L=\rho\,U\,\Gamma`, 40); color(kj, lime); hidden(kj);
+
+text(cap, (cx, h-30), ""); size(cap, 22); color(cap, dim); wrap(cap, w*0.8); hidden(cap);
+
+show(cap, 0.3);
+
+// 1 — uniform flow
+say(cap, "uniform flow — parallel streamlines");
+stagger(0.05) { for k in 0..11 { draw(uni{k}, 0.6); } }
+wait(0.6);
+
+// 2 — a free vortex
+say(cap, "a free vortex — concentric streamlines (the spin's circulation)");
+stagger(0.08) { for k in 0..5 { draw(vor{k}, 0.7); } }
+wait(0.7);
+
+// 3 — superpose them
+say(cap, "superpose them → the flow around a spinning cylinder");
+par {
+  fade(uniform, 0.5); fade(vortex, 0.5);
+  show(cyl, 0.4); show(cylo, 0.4);
+}
+stagger(0.04) { for i in 0..17 { draw(fl{i}, 0.9); } }
+wait(0.6);
+
+// 4 — the asymmetry → pressure → force
+say(cap, "the flow is faster on top, slower below — Bernoulli does the rest");
+par {
+  show(spinT, 0.4); show(spinB, 0.4);
+  show(inflow, 0.4); show(inl, 0.4);
+  show(fast, 0.5); show(slow, 0.5);
+}
+wait(0.5);
+par { show(force, 0.6); show(fl_lab, 0.5); show(kj, 0.5); }
+wait(0.6);
+
+// 5 — the payoff
+say(cap, "a pressure difference pushes it sideways — the Magnus force that curls a free kick");
+pulse(force, 0.8);
+wait(1.6);

package/examples/spline.manic

@@ -0,0 +1,21 @@
+title("A smooth curve through the data");
+canvas("16:9");
+
+text(hdr, (cx, 70), "Interpolation: one smooth curve through every point");
+size(hdr, 26); color(hdr, cyan); bold(hdr); display(hdr); hidden(hdr);
+
+// scattered data points — the spline passes through all of them
+spline(s, (300, 620), (520, 340), (760, 560), (1000, 300), (1240, 480), (1500, 260));
+color(s, cyan); stroke(s, 4); untraced(s);
+
+text(cap, (cx, h - 60), "Catmull-Rom — it hits each knot exactly");
+size(cap, 20); color(cap, dim); display(cap); hidden(cap);
+
+// ---- timeline ----
+show(hdr, 0.5);
+// pop the knots in first
+show(s.knots, 0.6);
+wait(0.3);
+// then trace the smooth curve through them
+draw(s, 2.2);
+show(cap, 0.4);

package/examples/spot-diagram.manic

@@ -0,0 +1,32 @@
+// ============================================================================
+//  spot-diagram.manic  —  a blur vs a point (lens quality, real optics)
+// ----------------------------------------------------------------------------
+//  Where does a bundle of rays actually LAND at focus? `spotdiagram` traces the
+//  real spherical surfaces and plots the hits. A fast single lens smears into a
+//  disc — the circle of least confusion from SPHERICAL ABERRATION — while a
+//  cemented doublet collapses to a point. The green dot is the ideal (point)
+//  focus; the RMS read-out is the blur radius. Both drawn to the SAME scale.
+// ============================================================================
+
+title("Spot Diagram — Blur vs Point");
+canvas("16:9");
+
+spotdiagram(bad, (370, 380), "singlet");
+spotdiagram(good, (910, 380), "doublet");
+
+text(cap, (cx, h - 46), ""); color(cap, fg); size(cap, 24); bold(cap); display(cap); sticky(cap);
+
+// ================= THE SCENE =================
+say(cap, "where do the rays actually land at focus?", 0.5);
+wait(0.4);
+
+say(cap, "a fast SINGLE lens → a blur disc (spherical aberration)", 0.3);
+draw(bad.dots, 1.8);
+wait(0.6);
+
+say(cap, "a cemented DOUBLET → very nearly a point", 0.3);
+draw(good.dots, 1.4);
+wait(0.6);
+
+say(cap, "same rays, same scale — RMS 4 px collapses to under 1 px", 0.3);
+wait(1.2);

package/examples/spring-annotated.manic

@@ -0,0 +1,60 @@
+// ============================================================================
+//  spring-annotated.manic  —  ELEVATE a sim: typewriter narration + live data
+// ----------------------------------------------------------------------------
+//  One elevation flavour of several (see pulley-annotated for camera work,
+//  brachistochrone-annotated for kinetic typography). Here the story is told by
+//  a TYPEWRITER lab-note (`type` + `cursor`) and LIVE COUNTERS (`counter` +
+//  `to(_, value, …)`) that tick up — no stage-covering section cards, so the
+//  motion is never hidden. The spring's parts are ordinary entities the whole
+//  language drives directly.
+// ============================================================================
+
+title("Anatomy of a Spring — Hooke's Law & SHM");
+canvas("16:9");
+
+text(hdr, (cx, 40), "Anatomy of a Spring"); size(hdr, 28); color(hdr, cyan); bold(hdr); display(hdr); hidden(hdr);
+
+// ---- the sim + views (staged) ----
+spring(sp, (340, 320), 10, 1.4, 105);
+hidden(sp.wall); hidden(sp.spring); hidden(sp.mass); hidden(sp.overlays);
+untraced(sp.path);
+well(sp, (1015, 230), 112); hidden(sp.well);
+energygraph(sp, (1015, 480), 112); hidden(sp.energy);
+
+// ---- part annotations ----
+line(eq, (340, 268), (340, 372)); color(eq, dim); stroke(eq, 2); untraced(eq);
+text(coilL, (285, 232), "spring, stiffness k"); size(coilL, 16); color(coilL, lime); display(coilL); hidden(coilL);
+text(massL, (520, 272), "mass m"); size(massL, 16); color(massL, cyan); display(massL); hidden(massL);
+bracelabel(xb, (340, 372), (487, 372), "x₀", 22); color(xb, gold); hidden(xb); hidden(xb.label);
+text(hooke, (340, 168), "F = −k·x"); size(hooke, 24); color(hooke, gold); display(hooke); hidden(hooke);
+
+// ---- a TYPEWRITER lab-note with a live cursor (the narration device) ----
+text(note, (cx, h - 44), ""); size(note, 21); color(note, fg); display(note); cursor(note);
+text(kick, (96, 92), ""); size(kick, 17); color(kick, magenta); bold(kick); display(kick);
+
+// ---- LIVE COUNTERS (tick up on reveal) ----
+counter(kC, (150, 470), 0, 1, "k = ", " N/m"); size(kC, 26); color(kC, lime); display(kC); hidden(kC);
+counter(tC, (150, 512), 0, 2, "T = ", " s"); size(tC, 26); color(tC, cyan); display(tC); hidden(tC);
+
+// ============================== SCRIPT ==============================
+show(hdr, 0.5);
+
+say(kick, "SETUP", 0.2);
+say(note, "a wall, a coil of stiffness k, and a mass", 0.1); type(note, 1.4);
+show(sp.wall, 0.4); pulse(sp.wall); show(coilL, 0.4);
+show(sp.spring, 0.4); flash(sp.spring, lime); show(sp.mass, 0.4); pulse(sp.mass); show(massL, 0.4);
+show(kC, 0.3); to(kC, value, 10, 0.8);
+wait(0.5);
+
+say(kick, "HOOKE'S LAW", 0.2);
+say(note, "pull it x₀ from rest — it pulls back, F = −k·x", 0.1); type(note, 1.7);
+draw(eq, 0.4); show(xb, 0.4); show(xb.label, 0.4); show(hooke, 0.4); flash(sp.spring, gold);
+show(tC, 0.3); to(tC, value, 1.99, 0.9);   // period 2π√(m/k)
+wait(0.6);
+fade(coilL, 0.3); fade(massL, 0.3); fade(xb, 0.3); fade(xb.label, 0.3); fade(hooke, 0.3);
+wait(0.2);
+
+say(kick, "MOTION", 0.2);
+say(note, "release — simple harmonic motion; every panel tells the same swing", 0.1); type(note, 1.9);
+show(sp.well, 0.5); show(sp.overlays, 0.4); show(sp.energy, 0.5); draw(sp.path, 0.6);
+run(sp, 10);

package/examples/spring-chain.manic

@@ -0,0 +1,11 @@
+// spring-chain.manic — three blocks joined by two springs on an incline: coupled
+// oscillators / normal modes. `springchain(id,[center],[angle],[unit])`. A uniform
+// gravity component doesn't change the internal motion, so it's shown in the
+// incline's frame (CM held). `energygraph` shows the energy sloshing (beating).
+title("Spring chain on an incline — coupled oscillators");
+canvas("16:9");
+text(hdr, (cx, 44), "Three masses, two springs — the energy sloshs between the modes"); size(hdr, 21); color(hdr, cyan); bold(hdr); display(hdr);
+springchain(sc, (500, 300), 22);
+energygraph(sc, (1010, 340), 120);
+text(cap, (cx, h - 32), "pull one block and the whole chain rings — normal modes / beating (coupled springs)"); size(cap, 15); color(cap, dim); display(cap);
+run(sc, 9);