@maniclang/workbench 0.1.11

package/examples/orthocenter.manic

@@ -0,0 +1,63 @@
+// Altitudes & Orthocenter — the three altitudes of a triangle meet at one
+// point, the orthocenter H. Each altitude drops perpendicular to a side.
+// Dynamic: drag a vertex and the altitudes still concur.
+//
+//   manic examples/orthocenter.manic
+//   manic examples/orthocenter.manic --record out --fps 60
+
+title("Altitudes & Orthocenter");
+canvas(1280, 720);
+
+text(head, (640, 120), "the three altitudes concur");
+display(head);  color(head, cyan);  size(head, 28);  hidden(head);
+text(cap, (640, 668), "");  color(cap, dim);  size(cap, 22);
+
+point(A, (330, 540), "A");
+point(B, (980, 560), "B");
+point(C, (700, 190), "C");
+hidden(A);  hidden(B);  hidden(C);
+
+segment(ab, A, B);  segment(bc, B, C);  segment(ca, C, A);
+untraced(ab);  untraced(bc);  untraced(ca);
+
+// feet of the three altitudes
+foot(fA, A, B, C);  foot(fB, B, C, A);  foot(fC, C, A, B);
+color(fA, magenta);  color(fB, magenta);  color(fC, magenta);
+hidden(fA);  hidden(fB);  hidden(fC);
+
+// the altitudes themselves
+segment(hA, A, fA);  segment(hB, B, fB);  segment(hC, C, fC);
+color(hA, lime);  color(hB, lime);  color(hC, lime);
+untraced(hA);  untraced(hB);  untraced(hC);
+rightangle(qA, A, fA, B);  rightangle(qB, B, fB, C);  rightangle(qC, C, fC, A);
+untraced(qA);  untraced(qB);  untraced(qC);
+
+orthocenter(H, A, B, C);  color(H, cyan);  label(H, "H", (16, -14));  hidden(H);
+
+show(head, 0.5);
+say(cap, "a triangle");
+par { show(A);  show(B);  show(C); }
+par { draw(ab, 0.5);  draw(bc, 0.5);  draw(ca, 0.5); }
+wait(0.3);
+
+section("Drop the altitudes");
+say(cap, "from each vertex, perpendicular to the opposite side");
+seq {
+  par { draw(hA, 0.5);  draw(qA, 0.4);  show(fA); }
+  par { draw(hB, 0.5);  draw(qB, 0.4);  show(fB); }
+  par { draw(hC, 0.5);  draw(qC, 0.4);  show(fC); }
+}
+wait(0.3);
+
+section("Orthocenter");
+say(cap, "all three meet at the orthocenter H");
+show(H, 0.4);
+flash(H, magenta);
+wait(0.6);
+
+section("Drag a vertex");
+say(cap, "move C — the altitudes still concur");
+move(C, (520, 230), 1.2, smooth);
+move(C, (820, 250), 1.2, smooth);
+move(C, (700, 190), 1.0, smooth);
+wait(1.0);

package/examples/param3.manic

@@ -0,0 +1,43 @@
+// param3 — general parametric surfaces x(u,v), y(u,v), z(u,v). Unlike surface3
+// (a height field z=f(x,y)) these can wrap and close, so a torus and a Möbius
+// strip are just three formulas each.
+//
+//   manic examples/param3.manic
+//   manic examples/param3.manic --record out --fps 60
+
+title("parametric surfaces");
+canvas("16:9");
+template("terminal");
+
+camera3((11, -13, 8.5), (0, 0, 1.4), 42);
+grid3(floor, (0, 0, 0), 7, 1);
+color(floor, dim);
+
+// torus (left)
+param3(torus,
+  "0 - 4.8 + (2 + 0.7*cos(v))*cos(u)",
+  "(2 + 0.7*cos(v))*sin(u)",
+  "1.5 + 0.7*sin(v)",
+  (0, 6.283), (0, 6.283), 40);
+color(torus, cyan);
+
+// parametric sphere (centre)
+param3(ball,
+  "1.3*sin(v)*cos(u)",
+  "1.3*sin(v)*sin(u)",
+  "1.6 + 1.3*cos(v)",
+  (0, 6.283), (0, 3.1416), 28);
+color(ball, magenta);
+
+// Möbius strip (right)
+param3(mobius,
+  "4.8 + (1.7 + v*cos(u/2))*cos(u)",
+  "(1.7 + v*cos(u/2))*sin(u)",
+  "1.6 + v*sin(u/2)",
+  (0, 6.283), (0 - 0.6, 0.6), 60);
+color(mobius, gold);
+
+show(floor, 0.3);
+par { show(torus, 0.7); show(ball, 0.7); show(mobius, 0.7); }
+orbit3(60, 24, 15, 5.0, smooth);
+wait(0.4);

package/examples/parameter-journeys.manic

@@ -0,0 +1,154 @@
+// ============================================================================
+// parameter-journeys.manic — one value, several continuous representations
+// ----------------------------------------------------------------------------
+// `parameter` creates the visible control. `bind` connects it once to the
+// changing plot, tangent/slope, a geometric position, scale, and p² readout.
+// The named steps only animate the parameter; the visual world reacts smoothly.
+// Try every format with: manic check examples/parameter-journeys.manic --canvas all
+// ============================================================================
+
+title("Parameter Journeys");
+canvas("9:16");
+template("mono");
+
+creator(me, "@anish2good name=Manic_Creator_Lab tagline=One_value_many_worlds yt=zarigatongy x=@anish2good web=8gwifi.org/manic footer=none accent=cyan safe=clean");
+
+let u = (w+h-abs(w-h)) / 2160;
+watermark(manicMark, (w*0.955-100, h*0.045+24), "Made With Manic");
+
+if h > 1.45*w {
+  text(kicker, (cx, 120*u), "PARAMETER JOURNEY");
+  text(headline, (cx, 200*u), "Change one idea. Keep the world.");
+  equation(rule, (cx, 315*u), `y=\textcolor{cyan}{a}x^2`, 58*u);
+
+  rect(stage, (cx, 770*u), 920*u, 720*u);
+  axes(ax, (cx, 790*u), 400*u, 270*u, 1);
+  plot(curve, (cx, 790*u), 112*u, 61*u, "0.22*x*x", (-3.3,3.3));
+  tangent(tan, curve, 1.15, 230*u);
+  slope(rate, curve, 1.15, (24*u,-34*u));
+
+  parameter(a, (cx, 1215*u), -1.2, -1.5, 1.5, "a", 2);
+  text(positionLabel, (cx, 1365*u), "THE SAME VALUE ALSO MOVES A POINT");
+  line(path, (w*0.18, 1450*u), (w*0.82, 1450*u));
+  dot(leftEnd, (w*0.18, 1450*u), 5*u);
+  dot(rightEnd, (w*0.82, 1450*u), 5*u);
+  circle(mover, (cx, 1450*u), 22*u);
+  bind(a, mover, x, w*0.18, w*0.82);
+  counter(magnitude, (cx, 1570*u), 0, 2, "a² = ", "");
+  text(caption, (cx, 1690*u), "Negative, zero, positive — every connected view stays in sync.");
+  wrap(caption, w*0.76);
+}
+else if w > 1.25*h {
+  text(kicker, (w*0.24, h*0.12), "PARAMETER JOURNEY");
+  text(headline, (w*0.25, h*0.22), "Change one idea. Keep the world.");
+  equation(rule, (w*0.25, h*0.34), `y=\textcolor{cyan}{a}x^2`, 55*u);
+
+  parameter(a, (w*0.25, h*0.49), -1.2, -1.5, 1.5, "a", 2);
+  text(positionLabel, (w*0.25, h*0.64), "THE SAME VALUE MOVES A POINT");
+  line(path, (w*0.09, h*0.72), (w*0.41, h*0.72));
+  dot(leftEnd, (w*0.09, h*0.72), 5*u);
+  dot(rightEnd, (w*0.41, h*0.72), 5*u);
+  circle(mover, (w*0.25, h*0.72), 22*u);
+  bind(a, mover, x, w*0.09, w*0.41);
+  counter(magnitude, (w*0.25, h*0.82), 0, 2, "a² = ", "");
+
+  rect(stage, (w*0.72, h*0.48), w*0.49, h*0.72);
+  axes(ax, (w*0.72, h*0.53), 345*u, 250*u, 1);
+  plot(curve, (w*0.72, h*0.53), 92*u, 51*u, "0.22*x*x", (-3.3,3.3));
+  tangent(tan, curve, 1.15, 195*u);
+  slope(rate, curve, 1.15, (20*u,-28*u));
+  text(caption, (w*0.72, h*0.88), "Every connected view stays in sync.");
+  wrap(caption, w*0.42);
+}
+else {
+  text(kicker, (cx, h*0.08), "PARAMETER JOURNEY");
+  text(headline, (cx, h*0.15), "Change one idea. Keep the world.");
+  equation(rule, (cx, h*0.24), `y=\textcolor{cyan}{a}x^2`, 53*u);
+
+  rect(stage, (cx, h*0.50), w*0.86, h*0.40);
+  axes(ax, (cx, h*0.52), 350*u, 225*u, 1);
+  plot(curve, (cx, h*0.52), 94*u, 46*u, "0.22*x*x", (-3.3,3.3));
+  tangent(tan, curve, 1.15, 190*u);
+  slope(rate, curve, 1.15, (20*u,-26*u));
+
+  parameter(a, (cx, h*0.75), -1.2, -1.5, 1.5, "a", 2);
+  text(positionLabel, (cx, h*0.80), "ONE VALUE · PLOT · POSITION · MAGNITUDE");
+  line(path, (w*0.20, h*0.85), (w*0.80, h*0.85));
+  dot(leftEnd, (w*0.20, h*0.85), 5*u);
+  dot(rightEnd, (w*0.80, h*0.85), 5*u);
+  circle(mover, (cx, h*0.85), 20*u);
+  bind(a, mover, x, w*0.20, w*0.80);
+  counter(magnitude, (cx, h*0.875), 0, 2, "a² = ", "");
+  text(caption, (cx, h*0.925), "Every view stays in sync.");
+  wrap(caption, w*0.78);
+}
+
+// One declaration per relationship. `p` is the live parameter and `x` is the
+// plot coordinate only inside a plot-formula binding.
+bind(a, curve, formula, "0.22*p*x*x");
+bind(a, mover, scale, "0.78+0.22*abs(p)");
+bind(a, magnitude, value, "p*p");
+
+size(kicker, 21*u); color(kicker, dim); bold(kicker); hidden(kicker);
+size(headline, 37*u); bold(headline); hidden(headline);
+size(positionLabel, 22*u); color(positionLabel, dim); bold(positionLabel); hidden(positionLabel);
+size(caption, 23*u); color(caption, dim); hidden(caption);
+color(rule, cyan); hidden(rule);
+color(stage, panel); outline(stage, dim); opacity(stage, 0.68); hidden(stage);
+color(ax, dim); opacity(ax, 0.48); untraced(ax);
+color(curve, cyan); stroke(curve, 6*u); glow(curve, 0.75); untraced(curve);
+color(tan, gold); stroke(tan, 4*u); hidden(tan);
+color(rate, gold); hidden(rate);
+color(path, dim); stroke(path, 3*u); untraced(path);
+color(leftEnd, dim); color(rightEnd, dim); hidden(leftEnd); hidden(rightEnd);
+color(mover, cyan); outline(mover, fg); hidden(mover);
+color(magnitude, fg); bold(magnitude); hidden(magnitude);
+hidden(a.widget);
+
+socials(me);
+
+step("opens-down") {
+  show(kicker, 0.30);
+  show(headline, 0.40);
+  show(rule, 0.45);
+  show(stage, 0.35);
+  draw(ax, 0.70);
+  draw(curve, 1.10);
+  show(tan, 0.35);
+  show(rate, 0.35);
+  show(a.widget, 0.45);
+  show(positionLabel, 0.35);
+  draw(path, 0.55);
+  show(leftEnd, 0.25);
+  show(rightEnd, 0.25);
+  show(mover, 0.35);
+  show(magnitude, 0.35);
+  show(caption, 0.40);
+}
+wait(0.65);
+
+step("flatten") {
+  to(a, value, 0, 2.20, smooth);
+  say(caption, "At zero the quadratic, tangent slope, position and magnitude settle together.", 0.40);
+}
+wait(0.55);
+
+step("opens-up") {
+  to(a, value, 1.25, 2.40, smooth);
+  say(caption, "One authored parameter now carries the whole visual family upward.", 0.40);
+}
+wait(0.60);
+
+step("compare") {
+  to(a, value, -0.65, 2.10, smooth);
+  say(caption, "Try another case without rebuilding the plot, diagram or readouts.", 0.40);
+}
+wait(0.55);
+
+step("takeaway") {
+  to(a, value, 1.5, 2.30, smooth);
+  pulse(rule, 0.70);
+  pulse(mover, 0.70);
+  say(caption, "Declare the relationship once. Animate only what the idea means.", 0.40);
+}
+wait(1.60);

package/examples/parameterized-field-advection.manic

@@ -0,0 +1,57 @@
+// PARAMETERIZED VECTOR FIELD — one value changes the whole field.
+// The same settled field then moves a persistent tracer collection. No frame
+// callbacks and no manually authored particle paths are involved.
+
+title("From Wind to Vortex");
+canvas("16:9");
+template("mono");
+watermark(mark, (170, 55), "Made With Manic");
+
+text(kicker, (640, 48), "MANIC · PARAMETERIZED FIELD");
+text(headline, (640, 94), "One parameter reshapes every arrow");
+size(kicker, 18); color(kicker, dim); bold(kicker);
+size(headline, 34); bold(headline);
+
+rect(chamber, (640, 365), 780, 410);
+outlined(chamber); outline(chamber, dim); stroke(chamber, 3);
+
+// The initial named field supplies a clear first state. `bind` then gives it
+// formula components where x,y are field coordinates and p is the parameter.
+vectorfield(flow, (640, 365), 375, 190, uniform, 17);
+parameter(mix, (640, 610), 0, 0, 1, "vortex mix", 2);
+bind(mix, flow, formula, "(1-p)*1.15-p*y", "p*x");
+
+circle(seed, (640, 365), 128);
+outlined(seed); outline(seed, dim); dashed(seed, 10, 9);
+particles(tracers, seed, 32, 5, 31, "random");
+color(tracers, fg); glow(tracers, 0.55);
+
+text(caption, (640, 678), "p = 0: steady wind");
+size(caption, 20); color(caption, dim);
+
+untraced(flow); hidden(seed); hidden(tracers);
+
+step("reveal-the-field") {
+  par {
+    draw(flow, 0.9);
+    show(seed, 0.4);
+    show(tracers, 0.55);
+  }
+}
+wait(0.5);
+
+step("wind-becomes-vortex") {
+  par {
+    to(mix, value, 1, 2.5, smooth);
+    say(caption, "p = 1: the same field turns into a vortex", 0.4);
+  }
+}
+wait(0.55);
+
+step("release-tracers") {
+  par {
+    advect(tracers, flow, 4.4, 0.78);
+    say(caption, "The dots follow the settled field — their paths were never drawn.", 0.4);
+  }
+}
+wait(1.2);

package/examples/parameterized-generated-families3.manic

@@ -0,0 +1,83 @@
+// PARAMETERIZED GENERATED FAMILIES — one ordinary parameter, three stable 3-D
+// objects. `p` changes sampled points; ids, materials, transforms, and sample
+// topology stay intact. No per-vertex scripting or snapshot replacement.
+
+title("Parameterized Generated Families");
+canvas("16:9");
+template("mono");
+watermark(mark, (170, 55), "Made With Manic");
+
+text(kicker, (640, 48), "MANIC · GENERATED 3-D FAMILIES");
+text(headline, (640, 92), "One parameter · three continuous shapes");
+text(caption, (640, 664), "curve3(t,p)  ·  surface3(x,y,p)  ·  param3(u,v,p)");
+size(kicker, 18); color(kicker, dim); bold(kicker);
+size(headline, 34); bold(headline);
+size(caption, 19); color(caption, dim);
+
+parameter(shape, (640, 612), 0, 0, 1, "shape", 2);
+
+if h > 1.45*w {
+  camera3((0, -36, 8), (0, 0, 0.4), 40);
+}
+else {
+  camera3((10, -17, 9), (0, 0, 0.4), 40);
+}
+grid3(floor, (0, 0, -2.2), 8, 1);
+color(floor, dim); opacity(floor, 0.14);
+
+// A widening helix at the left.
+curve3(helix,
+  "-4 + cos(t)",
+  "sin(t)",
+  "-1.7 + 0.55*t",
+  (0, 6.2832));
+bind(shape, helix, formula,
+  "-4 + (1+0.45*p)*cos(t)",
+  "(1+0.45*p)*sin(t)",
+  "-1.7 + 0.55*t");
+color(helix, cyan); thick(helix, 0.065); untraced(helix);
+tag(helix, family);
+
+// A bowl that becomes a rippling field in the middle.
+surface3(land, "0.15*(x*x+y*y)", (-1.7,1.7), (-1.7,1.7), 28);
+bind(shape, land, formula,
+  "(1-p)*0.15*(x*x+y*y) + p*0.72*sin(1.7*x)*cos(1.7*y)");
+color(land, gold);
+finish3(land, "material=glass shading=smooth mesh=0.30 depth=0.28 shadow=0.12");
+tag(land, family);
+
+// A torus whose tube inflates at the right.
+param3(ring,
+  "4+(1.15+0.20*cos(v))*cos(u)",
+  "(1.15+0.20*cos(v))*sin(u)",
+  "0.20*sin(v)",
+  (0,6.2832), (0,6.2832), 28);
+bind(shape, ring, formula,
+  "4+(1.15+(0.20+0.52*p)*cos(v))*cos(u)",
+  "(1.15+(0.20+0.52*p)*cos(v))*sin(u)",
+  "(0.20+0.52*p)*sin(v)");
+color(ring, magenta);
+finish3(ring, "material=metal shading=smooth mesh=0.22 depth=0.30 shadow=0.16");
+tag(ring, family);
+
+hidden(helix); hidden(land); hidden(ring);
+
+step("reveal one stable family") {
+  par {
+    view3(family, "fit", 0.9, smooth, 1.55);
+    stagger(0.16) {
+      show(helix, 0.45);
+      show(land, 0.45);
+      show(ring, 0.45);
+    }
+  }
+}
+wait(0.45);
+
+step("change the shared parameter") {
+  par {
+    to(shape, value, 1, 3.4, smooth);
+    say(caption, "The same three objects are resampled smoothly from p = 0 to p = 1.", 0.45);
+  }
+}
+wait(1.2);

package/examples/particles-flow.manic

@@ -0,0 +1,61 @@
+// Generic contained motion: the ids give the dots their meaning.
+// The same four words work for bubbles, dust, stars, data, or molecules.
+
+title("Three bodies, one relation");
+canvas("9:16");
+watermark(manicMark, (w*0.955-100, h*0.045+24), "Made With Manic");
+// No template call: black is the full-colour exact-black default.
+
+circle(A, (540, 390), 105);
+circle(B, (260, 760), 105);
+circle(C, (820, 760), 105);
+stroke(A, 5); stroke(B, 5); stroke(C, 5);
+
+particles(insideA, A, 24, 5, 7);
+particles(insideB, B, 24, 5, 17);
+particles(insideC, C, 24, 5, 27);
+
+equation(labelA, (540, 390), `A`, 64);
+equation(labelB, (260, 760), `B`, 64);
+equation(labelC, (820, 760), `C`, 64);
+
+link(ab, A, B, -48);
+link(bc, B, C, -56);
+link(ac, A, C, 48);
+stroke(ab, 5); stroke(bc, 5); stroke(ac, 5);
+untraced(ab); untraced(bc); untraced(ac);
+
+equation(relAB, (310, 445), `A\sim B`, 34);
+equation(relBC, (540, 690), `B\sim C`, 34);
+equation(relAC, (770, 445), `A\sim C`, 34);
+color(relAB, dim); color(relBC, dim); color(relAC, dim);
+
+hidden(A); hidden(B); hidden(C);
+hidden(labelA); hidden(labelB); hidden(labelC);
+hidden(insideA); hidden(insideB); hidden(insideC);
+hidden(relAB); hidden(relBC); hidden(relAC);
+
+par {
+  wander(insideA, 9);
+  wander(insideB, 9);
+  wander(insideC, 9);
+
+  seq {
+    par { show(A, 0.35); show(labelA, 0.35); show(insideA, 0.45); }
+    wait(0.25);
+    par { show(B, 0.35); show(labelB, 0.35); show(insideB, 0.45); }
+    show(relAB, 0.25);
+    par { draw(ab, 0.75); recolor(relAB, fg, 0.75); }
+    flow(ab, 0.9);
+
+    par { show(C, 0.35); show(labelC, 0.35); show(insideC, 0.45); }
+    show(relBC, 0.25);
+    par { draw(bc, 0.75); recolor(relBC, fg, 0.75); }
+    flow(bc, 0.9);
+
+    show(relAC, 0.25);
+    par { draw(ac, 0.75); recolor(relAC, fg, 0.75); }
+    par { flow(ab, 1.1); flow(bc, 1.1); flow(ac, 1.1); }
+    wait(0.55);
+  }
+}

package/examples/pascal-triangle.manic

@@ -0,0 +1,92 @@
+// Pascal's Triangle — a real Creator v2 Short that shows off Manic's range: the
+// numbers are COMPUTED live (a `prod` reduction per cell), a hidden fractal is
+// revealed, and the close reframes it as "one script — Manic does math, physics,
+// algorithms & more." 9:16 shorts template, branded identity + socials + end card.
+title("Pascal's Triangle");
+canvas("9:16");
+template("shorts");
+
+creator(me, "@anish2good name=Manic tagline=Turn_plain_text_into_amazing_math_videos yt=zarigatongy x=@anish2good web=8gwifi.org/manic accent=cyan secondary=magenta footer=signature cta=Try_it_free safe=reels");
+watermark(manicMark, (w*0.955-100, h*0.045+24), "Made With Manic");
+
+let N = 8;
+let cw = w*0.112;
+let rh = w*0.112;
+let top = h*0.21;
+let rad = w*0.048;
+
+// Build the triangle from the computation layer: each cell's binomial coefficient
+// C(n,k) is a `prod` reduction on a filled disc. Tag by row (for the reveal) and
+// by parity (for the fractal finale).
+for n in 0..N {
+  for k in 0..n+1 {
+    let px = w*0.5 + (k - n*0.5)*cw;
+    let py = top + n*rh;
+    let val = prod(i in 1..k+1 : (n-k+i)/i);
+    dot(d{n}_{k}, (px, py), rad); color(d{n}_{k}, panel); tag(d{n}_{k}, discs); tag(d{n}_{k}, prow{n});
+    counter(v{n}_{k}, (px, py), val, 0); tag(v{n}_{k}, nums); tag(v{n}_{k}, prow{n});
+    let odd = round(val - 2*floor(val/2));
+    if odd > 0.5 { tag(d{n}_{k}, oddcells); } else { tag(d{n}_{k}, evencells); }
+  }
+}
+
+text(kicker, (cx, h*0.135), "This triangle of numbers hides a fractal");
+size(kicker, 32); color(kicker, dim); bold(kicker); wrap(kicker, w*0.82);
+text(cap, (cx, h*0.775), "every number here is computed, not typed");
+size(cap, 33); color(cap, dim); wrap(cap, w*0.82);
+
+socials(me);
+endcard(me, "title=Try_Manic cta=8gwifi.org/manic");
+
+hidden(discs); hidden(nums); hidden(cap);
+untraced(kicker); cursor(kicker);   // opening hook types on, letter by letter
+
+// 1 — HOOK: type the question, then build the triangle. The caption's promise —
+// "computed, not typed" — is Manic's real pitch: the numbers come from a formula.
+mark("hook");
+type(kicker, 1.4);
+show(cap, 0.4);
+for n in 0..N { show(prow{n}, 0.26); wait(0.09); }
+wait(0.4);
+
+// 2 — THE RULE: 3 + 3 = 6, every cell is the sum of its two parents.
+step("rule") {
+  seq {
+    say(cap, "each cell = the two above it   (3 + 3 = 6)");
+    par { flash(d3_1, gold); flash(d3_2, gold); }
+    flash(d4_2, cyan);
+  }
+}
+wait(0.5);
+
+// 3 — THE TWIST: colour the odd numbers and Sierpinski's triangle appears.
+step("fractal") {
+  par {
+    say(cap, "colour the ODD numbers — and a fractal appears");
+    recolor(oddcells, magenta);
+  }
+}
+wait(0.9);
+
+// 4 — THE POINT: this whole thing was one short script — and Manic's range is
+// the real story. Reframe the demo as evidence of what Manic can do.
+step("power") {
+  seq {
+    say(cap, "one short script did all of this");
+    par { pulse(discs, 0.7); recolor(cap, cyan); }
+    say(cap, "Manic animates math, physics, algorithms & more — from plain text");
+  }
+}
+wait(1.3);
+
+// 5 — END CARD: the brand CTA.
+mark("endcard");
+par {
+  fade(kicker, 0.4);
+  fade(cap, 0.4);
+  fade(me.footer, 0.4);
+  fade(discs, 0.4);
+  fade(nums, 0.4);
+}
+show(me.endcard, 0.6);
+wait(1.6);

package/examples/pendulum-annotated.manic

@@ -0,0 +1,72 @@
+// ============================================================================
+//  pendulum-annotated.manic  —  a guided lesson: physics + base manic compose
+// ----------------------------------------------------------------------------
+//  Proof that a sim's parts (`{id}.pivot/.rod/.bob/.path/…`) are ORDINARY manic
+//  entities. This whole lesson is built from BASE std vocabulary — `section`
+//  chapters, `text` labels, leader `arrow`s, a reference `line`, a `bracelabel`,
+//  and `show`/`fade`/`recolor`/`flash`/`pulse`/`draw`/`say` — wrapped around the
+//  physics `pendulum` + `energygraph` view + `swing`. No special "physics mode":
+//  every std verb/modifier/annotation addresses the physics entities directly.
+// ============================================================================
+
+title("Anatomy of a Pendulum");
+canvas("16:9");
+
+text(hdr, (cx, 44), "Anatomy of a Pendulum");
+size(hdr, 30); color(hdr, cyan); bold(hdr); display(hdr); hidden(hdr);
+
+// ---- the physics sim + one math view (parts start hidden; path untraced) ----
+pendulum(p, (440, 210), 1.6, 50, 110);
+hidden(p.pivot); hidden(p.rod); hidden(p.bob); hidden(p.overlays);
+untraced(p.path);                       // trace 0 but keep opacity (reveal later)
+energygraph(p, (1030, 250), 105);       // built now (its sweep joins `swing`)
+hidden(p.energy);
+
+// ---- base annotations, all hidden to reveal in order ----
+line(vref, (440, 210), (440, 386));                         // vertical reference
+color(vref, dim); stroke(vref, 2); hidden(vref);
+bracelabel(Lb, (440, 210), (575, 323), "L = 1.6 m", 26);    // rod length
+color(Lb, gold); hidden(Lb); hidden(Lb.label);
+text(pivL, (330, 200), "pivot (fixed)"); size(pivL, 18); color(pivL, dim); display(pivL); hidden(pivL);
+arrow(pivA, (388, 205), (428, 209)); color(pivA, dim); stroke(pivA, 2); hidden(pivA);
+text(bobL, (600, 355), "bob — mass m"); size(bobL, 18); color(bobL, magenta); display(bobL); hidden(bobL);
+arrow(bobA, (628, 345), (585, 330)); color(bobA, dim); stroke(bobA, 2); hidden(bobA);
+text(angL, (472, 300), "θ₀ = 50°"); size(angL, 18); color(angL, lime); display(angL); hidden(angL);
+
+text(cap, (cx, h - 42), ""); size(cap, 20); color(cap, dim); display(cap);
+
+// ============================== SCRIPT ==============================
+show(hdr, 0.5);
+
+section("Anatomy");
+say(cap, "a fixed pivot …", 0.4);
+show(p.pivot, 0.4); pulse(p.pivot); show(pivL, 0.4); draw(pivA, 0.3);
+wait(0.5);
+say(cap, "… a rigid rod of length L …", 0.4);
+show(p.rod, 0.4); show(Lb, 0.4); show(Lb.label, 0.4);
+wait(0.6);
+say(cap, "… and a bob of mass m at the end", 0.4);
+show(p.bob, 0.5); recolor(p.bob, magenta, 0.3); pulse(p.bob); show(bobL, 0.4); draw(bobA, 0.3);
+wait(0.5);
+say(cap, "all one group — a base broadcast flashes every part at once", 0.4);
+flash(p.parts, lime);                    // std broadcast over the whole sim
+wait(0.7);
+
+section("Release");
+say(cap, "held at θ₀ from the vertical, then let go", 0.4);
+show(vref, 0.4); show(angL, 0.4); flash(p.rod, cyan);
+wait(0.9);
+// clear the static annotations before the motion
+fade(Lb, 0.3); fade(Lb.label, 0.3); fade(pivA, 0.3); fade(bobA, 0.3);
+fade(pivL, 0.3); fade(bobL, 0.3); fade(angL, 0.3); fade(vref, 0.3);
+wait(0.3);
+
+section("Swing");
+say(cap, "gravity pulls it back — velocity arrow + energy bars ride along", 0.4);
+show(p.overlays, 0.4);                   // reveal the velocity arrow + KE/PE bars
+draw(p.path, 0.8);                       // trace the arc it will follow
+
+section("Energy");
+say(cap, "and the SAME swing, read as energy over time", 0.4);
+show(p.energy, 0.5);                     // reveal the energy graph, then run it all
+swing(p, 10);                            // every panel + annotation-free scene animates

package/examples/pendulum-damped.manic

@@ -0,0 +1,35 @@
+// ============================================================================
+//  pendulum-damped.manic  —  the SAME four views, now with friction
+// ----------------------------------------------------------------------------
+//  Identical to `pendulum.manic` but with `damping` (the 6th arg) turned on, so
+//  the swing loses energy. Watch every panel respond together:
+//    · sim         — the amplitude shrinks each swing (slows toward rest)
+//    · phase        — the closed loop becomes an INWARD SPIRAL
+//    · well         — the ball SETTLES toward the bottom of the bowl
+//    · 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
+//  loop stays closed and the total-energy line stays flat (conservation).
+// ============================================================================
+
+title("Damped pendulum — energy bleeds away");
+canvas("16:9");
+
+text(hdr, (cx, 40), "Add friction: the swing decays, and every view follows");
+size(hdr, 24); color(hdr, cyan); bold(hdr); display(hdr);
+
+// the physical sim (left) — 6th arg 0.6 is the damping
+pendulum(p, (250, 220), 1.2, 55, 105, 0.6);
+untraced(p.path);
+
+// the same four math views of the SAME (now damped) simulation
+phase(p, (715, 165), 90);          // loop → inward spiral
+timegraph(p, (1000, 165), 90);     // θ(t), ω(t) — envelope shrinks
+well(p, (715, 455), 90);           // ball settles to the bottom
+energygraph(p, (1000, 455), 90);   // total energy decays
+
+text(cap, (cx, h - 30), "damping = 0.6 · the phase spiral, settling ball, and decaying total energy all show the same loss");
+size(cap, 16); color(cap, dim); display(cap);
+
+draw(p.path, 0.8);
+swing(p, 10);