@maniclang/workbench 0.1.11

package/examples/hilbert-curve3-space-filling.manic

@@ -0,0 +1,117 @@
+// Engine Test 7 — a 3D Hilbert curve refines from 7 to 32,767 segments.
+// One generated path keeps its identity while become3, draw, and orbit3 tell
+// the story. The curve is exact: each order visits every lattice cell once.
+
+title("Hilbert Curve in 3D");
+canvas("16:9");
+template("black");
+
+creator(me,"@anish2good name=Manic_Math tagline=Space_filling_curves_made_visible yt=zarigatongy x=@anish2good web=8gwifi.org/manic accent=magenta secondary=cyan footer=compact cta=Animate_the_infinite safe=clean");
+watermark(mark,(105,52),"Made With Manic");
+endcard(me,"title=Make_Fractals_Move cta=Create_with_Manic");
+
+text(kicker,(cx,46),"HILBERT CURVE IN 3D");
+text(head,(cx,86),"How can one line fill a cube?");
+text(caption,(cx,626),"Begin with one continuous route through all eight octants.");
+text(orderLabel,(cx,668),"ORDER 1  ·  7 SEGMENTS");
+size(kicker,20); bold(kicker); color(kicker,magenta);
+size(head,34); bold(head);
+size(caption,21); color(caption,dim);
+size(orderLabel,19); bold(orderLabel);
+
+camera3((13,-15,11),(0,0,0),42);
+
+// A quiet wireframe establishes the volume before the curve enters it.
+line3(e0,(-3,-3,-3),(3,-3,-3)); line3(e1,(3,-3,-3),(3,3,-3));
+line3(e2,(3,3,-3),(-3,3,-3)); line3(e3,(-3,3,-3),(-3,-3,-3));
+line3(e4,(-3,-3,3),(3,-3,3)); line3(e5,(3,-3,3),(3,3,3));
+line3(e6,(3,3,3),(-3,3,3)); line3(e7,(-3,3,3),(-3,-3,3));
+line3(e8,(-3,-3,-3),(-3,-3,3)); line3(e9,(3,-3,-3),(3,-3,3));
+line3(e10,(3,3,-3),(3,3,3)); line3(e11,(-3,3,-3),(-3,3,3));
+tag(e0,bounds); tag(e1,bounds); tag(e2,bounds); tag(e3,bounds);
+tag(e4,bounds); tag(e5,bounds); tag(e6,bounds); tag(e7,bounds);
+tag(e8,bounds); tag(e9,bounds); tag(e10,bounds); tag(e11,bounds);
+color(bounds,dim); opacity(bounds,0.34); thick(bounds,0.012);
+hidden(bounds); untraced(bounds);
+
+// The five exact refinements. Hidden curves are blueprints for become3.
+hilbert3(curve,(0,0,0),5.65,1);
+hilbert3(order2,(0,0,0),5.65,2);
+hilbert3(order3,(0,0,0),5.65,3);
+hilbert3(order4,(0,0,0),5.65,4);
+hilbert3(order5,(0,0,0),5.65,5);
+hidden(curve); untraced(curve);
+hidden(order2); hidden(order3); hidden(order4); hidden(order5);
+
+hidden(kicker); hidden(head); hidden(caption); hidden(orderLabel);
+
+step("pose the question") {
+  par {
+    show(kicker,0.30);
+    show(head,0.45);
+    show(caption,0.40);
+    show(orderLabel,0.35);
+    show(bounds,0.35);
+    draw(bounds,1.25,smooth);
+  }
+}
+wait(0.45);
+
+step("visit the eight octants") {
+  par {
+    show(curve,0.30);
+    draw(curve,1.65,smooth);
+    orbit3(54,25,16.2,1.65,smooth);
+  }
+}
+wait(0.45);
+
+step("refine the route") {
+  par {
+    seq {
+      par {
+        become3(curve,order2,1.30,smooth);
+        say(orderLabel,"ORDER 2  ·  63 SEGMENTS",0.35,smooth);
+        say(caption,"Replace every visit with a smaller, rotated copy—without breaking the line.",0.45,smooth);
+      }
+      wait(0.35);
+      par {
+        become3(curve,order3,1.55,smooth);
+        say(orderLabel,"ORDER 3  ·  511 SEGMENTS",0.35,smooth);
+        say(caption,"The gaps shrink while continuity survives every refinement.",0.45,smooth);
+      }
+      wait(0.35);
+      par {
+        become3(curve,order4,1.90,smooth);
+        say(orderLabel,"ORDER 4  ·  4,095 SEGMENTS",0.35,smooth);
+        say(caption,"One path now threads through thousands of cells in the cube.",0.45,smooth);
+      }
+      wait(0.35);
+      par {
+        become3(curve,order5,2.40,smooth);
+        say(orderLabel,"ORDER 5  ·  32,767 SEGMENTS",0.35,smooth);
+        say(caption,"In the limit, the continuous curve reaches every point in the volume.",0.50,smooth);
+      }
+    }
+    orbit3(186,31,17.8,8.55,linear);
+  }
+}
+wait(0.80);
+
+step("takeaway") {
+  par {
+    pulse(curve,0.80);
+    say(head,"A one-dimensional path can fill 3D space.",0.50,smooth);
+    say(caption,"Refinement adds detail—not disconnected pieces.",0.45,smooth);
+  }
+}
+wait(1.35);
+
+step("cta") {
+  par {
+    fade(kicker,0.30); fade(head,0.30); fade(caption,0.30);
+    fade(orderLabel,0.30); fade(bounds,0.40); fade(curve,0.45);
+    show(me.endcard,0.60);
+  }
+}
+wait(2.00);

package/examples/hill_run.manic

@@ -0,0 +1,71 @@
+// Uphill / Downhill — a rate x time = distance word problem.
+// "Up a hill at 4 mph, back down the same path at 6 mph, round trip = 1 hour.
+//  Total distance?"  Answer: one-way d = 2.4 mi, round trip = 4.8 mi.
+//
+// The distance is SOLVED in-language: d = 1 / (1/4 + 1/6) = 2.4, total = 2d.
+// The runner climbs slowly, descends faster (3s vs 2s ~ the real 0.6h : 0.4h),
+// then the equation is derived and the answer counts up on a live readout.
+//
+//   manic examples/hill_run.manic
+//   manic examples/hill_run.manic --record out --fps 60
+
+title("Uphill / Downhill");
+canvas("16:9");
+
+// --- the numbers, computed the same way you'd reason it out ---
+let up   = 4;                      // mph, uphill
+let down = 6;                      // mph, downhill
+let d     = 1 / (1/up + 1/down);   // one-way distance = 2.4 mi  (from d/4 + d/6 = 1)
+let total = 2 * d;                 // round trip        = 4.8 mi
+
+text(head, (cx, 84), "up at 4 mph, down at 6 mph -- round trip takes 1 hour");
+display(head);  color(head, cyan);  size(head, 24);  hidden(head);
+text(cap, (cx, 668), "");  color(cap, dim);  size(cap, 23);
+
+// --- the hill (a single path, run up then down) ---
+line(ground, (150, 560), (700, 560));   color(ground, dim);   stroke(ground, 2);   untraced(ground);
+line(path,   (200, 560), (620, 210));    color(path, cyan);    stroke(path, 4);      untraced(path);
+text(flag, (628, 196), "top");           color(flag, dim);     size(flag, 18);       hidden(flag);
+dot(runner, (200, 560), 16);             color(runner, lime);  glow(runner, 1.7);    hidden(runner);
+
+text(uplbl,   (300, 470), "4 mph");      color(uplbl, cyan);      size(uplbl, 24);   hidden(uplbl);
+text(downlbl, (520, 320), "6 mph");      color(downlbl, magenta); size(downlbl, 24); hidden(downlbl);
+
+// --- the derivation, on the right ---
+text(e1, (960, 230), "time = distance / rate");   color(e1, dim);  size(e1, 22);  hidden(e1);
+text(e2, (960, 300), "d/4 + d/6 = 1");            display(e2);  color(e2, fg);      size(e2, 30);  hidden(e2);
+text(e3, (960, 360), "5d/12 = 1   ->   d = 2.4");  display(e3);  color(e3, cyan);    size(e3, 26);  hidden(e3);
+counter(ans, (960, 450), 0, 1, "round trip = 2d = ", " mi");  display(ans);  color(ans, lime);  size(ans, 30);  hidden(ans);
+
+// --- script ---
+show(head, 0.5);
+say(cap, "an athlete runs up a hill, then back down the same path");
+par { draw(ground, 0.5);  draw(path, 0.7); }
+par { show(flag, 0.3);  show(runner, 0.3); }
+wait(0.3);
+
+section("Up the hill");
+say(cap, "uphill at 4 mph -- the slow leg");
+show(uplbl, 0.3);
+move(runner, (620, 210), 3.0, linear);
+
+section("Back down");
+say(cap, "downhill at 6 mph -- faster, so less time");
+show(downlbl, 0.3);
+move(runner, (200, 560), 2.0, linear);
+wait(0.3);
+
+section("Set up the equation");
+say(cap, "let d = the one-way distance; time = distance / rate");
+show(e1, 0.4);
+show(e2, 0.4);
+say(cap, "combine the fractions: 5d/12 = 1, so d = 2.4 miles");
+show(e3, 0.5);
+flash(e3, lime);
+
+section("Total distance");
+say(cap, "the round trip is 2d");
+show(ans, 0.3);
+to(ans, value, total, 1.4);
+pulse(ans);
+wait(1.6);

package/examples/histogram.manic

@@ -0,0 +1,43 @@
+// ============================================================================
+//  histogram.manic  —  the shape of a dataset (stats Tier 1)
+// ----------------------------------------------------------------------------
+//  `histogram(id, (cx,cy), "v1 v2 v3 ...", [bins], [width], [height], [color])`
+//  bins a list of numbers into bars — the SHAPE of the data. Bars are
+//  `{id}.bar{k}` (tagged `{id}.bars`) so they stagger in and recolour as a
+//  group; `{id}.meanline` + `{id}.mean` mark the mean, `{id}.min`/`{id}.max`
+//  label the range. Default bin count ≈ √n.
+//
+//  TO ADAPT: paste your own numbers into the data string (grades, prices,
+//  heights, times…). More `bins` = finer shape; fewer = smoother. Pass a colour
+//  as the last argument, or `rainbow` to give every bar its own hue (below).
+// ============================================================================
+
+title("The shape of a dataset");
+canvas("16:9");
+
+let n = 14;
+
+text(hdr, (cx, 60), "35 exam scores — where do they cluster?");
+size(hdr, 24); color(hdr, cyan); bold(hdr); display(hdr);
+
+// `rainbow` colours each bar across the spectrum — no loop needed
+histogram(hg, (cx, cy + 10),
+  "72 85 90 68 95 88 76 91 83 79 84 60 97 81 78 86 74 89 82 93 71 87 80 77 92 85 83 88 75 90 66 82 84 79 88",
+  n, 640, 300, rainbow);
+untraced(hg.bars);                 // bars sketch in one at a time
+hidden(hg.meanline); hidden(hg.mean);
+
+text(cap, (cx, h - 46), ""); size(cap, 22); color(cap, dim); display(cap);
+
+// ---- bars build up, left to right ----
+say(cap, "each bar counts how many scores fall in that range", 0.5);
+stagger(0.06) { for k in 0..n { draw(hg.bar{k}, 0.35); } }
+wait(1.0);
+say(cap, "the shape emerges: most scores cluster in the 80s, tailing off below", 0.5);
+wait(1.6);
+
+// ---- reveal the mean ----
+say(cap, "and the average sits right in the thick of it", 0.5);
+show(hg.meanline, 0.5); show(hg.mean, 0.4);
+pulse(hg.mean);
+wait(1.8);

package/examples/hotdog-taco.manic

@@ -0,0 +1,147 @@
+title("A Hotdog Is a Taco");
+canvas("16:9");
+template("black");
+
+// ================= HUD =================
+text(head, (cx, 60), "A Hotdog Is a Taco"); display(head); cursor(head);
+caption(sub, "a rigorous proof, with condiments", (cx, 104), 24, dim); hidden(sub);
+text(a1, (cx, 148), "Rule of the game: it's all rubber"); size(a1, 28); color(a1, cyan); hidden(a1);
+text(a2, (cx, 148), "The deformation"); size(a2, 28); color(a2, gold); hidden(a2);
+text(a3, (cx, 148), "The counterexample: the bagel"); size(a3, 28); color(a3, violet); hidden(a3);
+text(cap, (cx, h - 42), ""); size(cap, 26);
+
+// THE claim, stated up front - it earns its QED square at the end
+equation(eqT, (cx, 200), `\textbf{Theorem.}\;\;\text{hotdog} \;\cong\; \text{taco}`, 42); hidden(eqT); z(eqT, 10);
+
+// textbook callouts: the DEFINITION (act 1) and the INVARIANT (coda) that make
+// the proof rigorous, not just tasty
+equation(eqHomeo, (cx, 285), `\text{taco}\;\cong\;\text{hotdog}\ \Longleftrightarrow\ \exists\,f,\ f^{-1}\ \text{continuous}`, 28); hidden(eqHomeo); z(eqHomeo, 10);
+equation(eqGenus, (cx, 285), `g(\text{bagel})=1\;\ne\;0=g(\text{taco}),\quad \chi = 2-2g`, 28); hidden(eqGenus); z(eqGenus, 10);
+
+// confetti ring for the QED moment
+circle(confbox, (cx, 200), 80); hidden(confbox);
+particles(conf, confbox, 22, 4, 9, "ring"); color(conf, gold); hidden(conf);
+
+// act wipe
+line(wipe1, (-40, 140), (-40, h - 90)); stroke(wipe1, 4); color(wipe1, gold); glow(wipe1, 14);
+
+// ================= act 1 cast: rubber-sheet geometry (2D) =================
+circle(blob, (cx, cy + 50), 120); outlined(blob); stroke(blob, 4); color(blob, cyan); untraced(blob); tag(blob, rub);
+polygon(btar, (cx + 150, cy + 60), (cx + 90, cy - 60), (cx - 20, cy - 30), (cx - 150, cy - 10), (cx - 130, cy + 120), (cx - 20, cy + 170), (cx + 100, cy + 150));
+outlined(btar); hidden(btar);
+morph(blob, btar);
+
+text(rule1, (cx - 340, cy + 50), "stretch / bend / squish : ALLOWED"); size(rule1, 26); color(rule1, lime); hidden(rule1); tag(rule1, rub);
+text(rule2, (cx + 340, cy + 50), "cut / glue : FORBIDDEN"); size(rule2, 26); color(rule2, red); hidden(rule2); tag(rule2, rub);
+
+// ================= act 2 cast: the 3D kitchen (right-handed, Z-up) =========
+camera3((7.8, -8.8, 4.4), (0, 0, 0.7), 42);
+grid3(floor, (0, 0, 0), 3, 1); color(floor, dim); opacity(floor, 0.3); hidden(floor);
+
+// the tortilla: a flat disc-like sheet...
+param3(sheet, "u", "v", "0", (-1.4, 1.4), (-1.8, 1.8), 40);
+color(sheet, gold); finish3(sheet, "shading=smooth depth=0.2");
+
+// ...driven by ONE knob. The fold angle grows with p; arc length is preserved
+// (tortillas bend, they do not stretch) - this IS the homeomorphism, live:
+parameter(fold, (w - 180, 610), 0.05, 0.05, 1, "fold", 2); hidden(fold);
+bind(fold, sheet, formula, "sin(2.2*p*u)/(2.2*p)", "v", "(1-cos(2.2*p*u))/(2.2*p)");
+
+// the filling: one sausage, dropped in from above
+param3(saus, "0.34*cos(u)", "v", "2.6+0.34*sin(u)", (0, tau), (-2.2, 2.2), 28);
+color(saus, coral); finish3(saus, "shading=smooth"); hidden(saus);
+
+// the unreachable bagel: genus 1, parked stage right
+param3(torus, "2.9+(0.85+0.32*cos(v))*cos(u)", "(0.85+0.32*cos(v))*sin(u)", "0.62+0.32*sin(v)", (0, tau), (0, tau), 32);
+color(torus, violet); finish3(torus, "shading=smooth"); hidden(torus);
+
+// pinned labels that live in the 3D world
+text(ltaco, (cx, cy), "TACO"); size(ltaco, 32); color(ltaco, lime); hidden(ltaco);
+pin3(ltaco, (0, -2.3, 0.9), (0, -14));
+text(lhot, (cx, cy), "HOTDOG"); size(lhot, 32); color(lhot, coral); hidden(lhot);
+pin3(lhot, (0, -2.3, 0.9), (0, -14));
+text(g0, (cx, cy), "genus 0 - no holes"); size(g0, 24); color(g0, lime); hidden(g0);
+pin3(g0, (-1.7, 0, 1.9), (0, -12));
+text(g1, (cx, cy), "genus 1 - one hole"); size(g1, 24); color(g1, violet); hidden(g1);
+pin3(g1, (2.9, 0, 1.6), (0, -14));
+
+// ================= timeline =================
+
+// ---- cold open: state the theorem with a straight face
+type(head, 1.1);
+wordpop(sub, 0.06);
+show(eqT, 0.7); cue(tick);
+wait(0.9);
+
+// ---- act 1: the rules (rubber-sheet geometry)
+cue(whoosh);
+show(a1, 0.5);
+draw(blob, 1.0);
+show(rule1, 0.5); cue(tick);
+show(rule2, 0.5); shake(rule2, 0.7);
+say(cap, "Topology keeps only what survives stretching - distance is negotiable, holes are not", 0.5);
+show(eqHomeo, 0.6);
+to(blob, morph, 1, 1.5, smooth);
+say(cap, "To a topologist these are the SAME shape - and every move must run backwards too", 0.5);
+to(blob, morph, 0, 1.2, smooth);
+wait(0.4);
+par { shift(wipe1, (w + 80, 0), 0.7, linear); fade(rub, 0.6); fade(a1, 0.5); fade(eqHomeo, 0.5); }
+fade(wipe1, 0.2);   // park the wipe fully off-stage so it can't streak act 2
+
+// ---- act 2: the deformation (the actual proof)
+cue(whoosh);
+show(a2, 0.5);
+par { show(floor, 0.8); show(sheet, 1.0); }
+say(cap, "Exhibit A: the tortilla. A disc - genus 0, no holes", 0.5);
+show(g0, 0.5);
+show(fold, 0.4);
+wait(0.6);
+
+// one knob, turned continuously: disc -> taco
+say(cap, "One knob: FOLD. No cutting, no gluing - just bending", 0.5);
+par { to(fold, value, 0.55, 2.4, smooth); orbit3(-18, 20, 10.5, 2.4, smooth); }
+show(ltaco, 0.5);
+flash(sheet, lime);
+cue(pop);
+show(saus, 0.2);
+shift3(saus, (0, 0, -2.2), 0.9, bounce);
+say(cap, "Add filling: TACO", 0.4);
+wait(0.7);
+
+// keep turning the SAME knob: taco -> hotdog
+say(cap, "Keep folding. Nothing tears, nothing sticks", 0.5);
+par { to(fold, value, 1.0, 2.6, smooth); orbit3(25, 16, 10.0, 2.6, smooth); fade(ltaco, 0.6); }
+show(lhot, 0.5);
+flash(sheet, coral);
+say(cap, "HOTDOG. Same disc - just more fold", 0.4);
+wait(0.6);
+
+// homeomorphism runs both ways: rewind it before their eyes
+say(cap, "And back again... a homeomorphism must run both directions", 0.5);
+to(fold, value, 0.55, 1.6, smooth);
+to(fold, value, 1.0, 1.6, smooth);
+
+// ---- QED
+cue(chime);
+rewrite(eqT, `\textbf{Theorem.}\;\;\text{hotdog} \;\cong\; \text{taco}\quad\blacksquare`, 0.9);
+seq { show(conf, 0.1); burst(conf, 1.4); }
+par { orbit3(115, 18, 10.0, 3.0, smooth); }
+say(cap, "No cuts, no glue - QED, with mustard", 0.6);
+wait(0.8);
+
+// ---- coda: what a hotdog is NOT
+cue(whoosh);
+show(a3, 0.5); fade(a2, 0.4);
+par { show(torus, 0.8); look3((1.3, 0, 0.7), 1.0, smooth); show(g1, 0.6); }
+show(eqGenus, 0.6);
+say(cap, "The bagel stays forever out of reach: making a hole needs a CUT", 0.5);
+say(cap, "Genus is a topological invariant - it can never change under bending", 0.5);
+flash(torus, red);
+pulse(torus, 0.8);
+wait(0.9);
+par { fade(torus, 0.7); fade(g1, 0.5); fade(a3, 0.4); fade(eqGenus, 0.5); look3((0, 0, 0.7), 1.0, smooth); }
+
+// ---- end card: the theorem breathes over a slow orbit of lunch
+par { breathe(eqT, 3, 0.05, 0, 6); orbit3(160, 14, 10.5, 6, smooth); }
+say(cap, "Lunch, rigorously", 0.6);
+wait(12.0);

package/examples/hue_wave.manic

@@ -0,0 +1,35 @@
+// Hue Wave — a ring of dots, each with its own starting hue, all advancing
+// their hue at the same rate so the rainbow *rotates* around the ring. Shows
+// off `hue` as an animatable track: `to(id, hue, degrees)` cycles colour over
+// time (unlike `recolor`, it travels around the colour wheel, not through grey).
+//
+//   manic examples/hue_wave.manic
+//   manic examples/hue_wave.manic --record out --fps 60
+
+title("Hue Wave");
+canvas(1280, 720);
+
+text(head, (640, 110), "an animated hue track — colour that cycles");
+display(head);  color(head, cyan);  size(head, 26);  hidden(head);
+
+let n = 36;   let cx = 640;   let cy = 400;   let r = 210;
+
+// a ring of dots, rainbow-coloured by angle
+for i in 0..n {
+  let a = tau * i / n;
+  dot(d{i}, (cx + r*cos(a), cy + r*sin(a)), 18);
+  hue(d{i}, 360 * i / n);
+  glow(d{i}, 1.4);
+  tag(d{i}, ring);
+}
+
+// --- script ---
+show(head, 0.5);
+
+// spin the whole rainbow: every dot advances its hue by 720 deg (two full
+// cycles) over 6s, in parallel — the pattern rotates around the ring
+par {
+  for i in 0..n {
+    to(d{i}, hue, 360*i/n + 720, 6.0, linear);
+  }
+}

package/examples/hypothesis.manic

@@ -0,0 +1,32 @@
+// ============================================================================
+//  hypothesis.manic  —  a significance test & the p-value (stats Tier 5)
+// ----------------------------------------------------------------------------
+//  `hypothesis(id, (cx,cy), z, [alpha], [unit])` — under the null hypothesis the
+//  test statistic is standard-normal; the observed z cuts off tails whose area is
+//  the p-value. If that area is smaller than alpha, the result is too surprising
+//  to be chance — reject. Pieces: `{id}.curve`, `{id}.tails`, `{id}.zline`,
+//  `{id}.p`, `{id}.verdict`.
+// ============================================================================
+
+title("Hypothesis testing: is this surprising?");
+canvas("16:9");
+
+hypothesis(hy, (cx, cy - 10), 2.3, 0.05, 92);
+untraced(hy.curve);
+hidden(hy.tails); hidden(hy.zline); hidden(hy.zlbl);
+hidden(hy.p); hidden(hy.verdict);
+
+text(cap, (cx, h - 46), ""); size(cap, 22); color(cap, dim); display(cap);
+
+say(cap, "if nothing's going on, the test statistic follows this bell", 0.5);
+draw(hy.curve, 1.0);
+wait(1.2);
+say(cap, "we observed z = 2.3 — out here in the tails", 0.5);
+show(hy.zline, 0.4); show(hy.zlbl, 0.3);
+wait(1.4);
+say(cap, "the shaded tail area is the p-value: how likely a result this extreme is", 0.5);
+to(hy.tails, opacity, 0.5, 0.6); show(hy.p, 0.4);
+wait(1.6);
+say(cap, "p = 0.021 < 0.05, so it's too surprising for chance — reject the null", 0.5);
+show(hy.verdict, 0.4);
+wait(1.9);

package/examples/image.manic

@@ -0,0 +1,29 @@
+// ============================================================================
+//  image.manic  —  embed a raster image (PNG/JPG) in a scene
+// ----------------------------------------------------------------------------
+//  `image(id, (x,y), "asset:name.png"|"path", [w], [h])` loads a bundled or
+//  user-provisioned image file and draws it
+//  centred at (x,y), w×h px — and it's an ordinary entity, so every verb
+//  (`show`/`move`/`fade`/`pulse`/`spin`/…) animates it. Here a bundled logo
+//  slides + fades in, pulses, then a caption types beside it. A missing ordinary
+//  path draws a crossed placeholder; a missing bundled asset is an error.
+//
+//  (This unlocks real logos, avatars and photo backdrops for creator templates —
+//  a creator drops their brand image into a slot.)
+// ============================================================================
+
+title("Raster Images");
+canvas("16:9");
+
+image(logo, (cx, 340), "asset:manic-logo.png", 300, 300); hidden(logo);
+text(cap, (cx, 600), "any PNG/JPG — and it animates like anything else");
+color(cap, fg); size(cap, 34); bold(cap); untraced(cap);
+
+// ================= THE SCENE =================
+show(logo, 0.6); pulse(logo);
+wait(0.4);
+spin(logo, 1.0);
+type(cap, 2.0);
+wait(0.6);
+par { move(logo, (cx, 320), 0.8, smooth); pulse(logo); }
+wait(1.0);

package/examples/incircle_tangents.manic

@@ -0,0 +1,64 @@
+// The Incircle & Contact Triangle — the incircle touches each side at the foot
+// of the perpendicular from the incenter, and each radius meets the side at a
+// right angle. The three touch points form the contact triangle.
+//
+//   manic examples/incircle_tangents.manic
+//   manic examples/incircle_tangents.manic --record out --fps 60
+
+title("The Incircle");
+canvas(1280, 720);
+
+text(head, (640, 120), "tangent to all three sides");
+display(head);  color(head, cyan);  size(head, 28);  hidden(head);
+text(cap, (640, 668), "");  color(cap, dim);  size(cap, 22);
+
+point(A, (300, 560), "A");
+point(B, (1000, 560), "B");
+point(C, (640, 160), "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);
+
+incenter(I, A, B, C);   color(I, cyan);   label(I, "I", (16, -14));  hidden(I);
+incircle(ic, A, B, C);  untraced(ic);
+
+// touch points = feet of perpendiculars from I to each side
+foot(tBC, I, B, C);  foot(tCA, I, C, A);  foot(tAB, I, A, B);
+color(tBC, magenta);  color(tCA, magenta);  color(tAB, magenta);
+hidden(tBC);  hidden(tCA);  hidden(tAB);
+
+// radii to the touch points, with right-angle marks
+segment(rBC, I, tBC);  segment(rCA, I, tCA);  segment(rAB, I, tAB);
+color(rBC, lime);  color(rCA, lime);  color(rAB, lime);
+untraced(rBC);  untraced(rCA);  untraced(rAB);
+rightangle(qBC, I, tBC, B);  rightangle(qCA, I, tCA, C);  rightangle(qAB, I, tAB, A);
+untraced(qBC);  untraced(qCA);  untraced(qAB);
+
+// the contact triangle
+segment(k1, tBC, tCA);  segment(k2, tCA, tAB);  segment(k3, tAB, tBC);
+untraced(k1);  untraced(k2);  untraced(k3);
+
+show(head, 0.5);
+say(cap, "a triangle and its incentre I");
+par { show(A);  show(B);  show(C); }
+par { draw(ab, 0.5);  draw(bc, 0.5);  draw(ca, 0.5); }
+show(I, 0.3);
+wait(0.3);
+
+section("Inscribed circle");
+say(cap, "the incircle touches each side once");
+draw(ic, 1.0);
+stagger(0.15) { show(tBC);  show(tCA);  show(tAB); }
+wait(0.3);
+
+section("Radii ⟂ sides");
+say(cap, "each radius meets its side at a right angle");
+par { draw(rBC, 0.5);  draw(rCA, 0.5);  draw(rAB, 0.5); }
+par { draw(qBC, 0.4);  draw(qCA, 0.4);  draw(qAB, 0.4); }
+wait(0.4);
+
+section("Contact triangle");
+say(cap, "the three touch points form the contact triangle");
+par { draw(k1, 0.5);  draw(k2, 0.5);  draw(k3, 0.5); }
+wait(1.2);

package/examples/incline-bumper.manic

@@ -0,0 +1,11 @@
+// incline-bumper.manic — a block slides down an incline into a spring bumper at
+// the base, compresses it, and launches back up (one-sided contact).
+// `inclinebumper(id,[center],[angle],[mass],[stiffness],[unit])`. PRE-SIMULATED
+// (RK4); `energygraph` shows gravity PE ↔ kinetic ↔ spring PE (conserved).
+title("Incline + spring bumper — slide, compress, launch");
+canvas("16:9");
+text(hdr, (cx, 44), "A block slides down and compresses a spring at the base, then launches back"); size(hdr, 21); color(hdr, cyan); bold(hdr); display(hdr);
+inclinebumper(ib, (300, 500), 40, 2, 500);
+energygraph(ib, (1010, 320), 120);
+text(cap, (cx, h - 32), "gravity PE → kinetic → spring PE → back: one-sided contact, energy conserved"); size(cap, 15); color(cap, dim); display(cap);
+run(ib, 6);

package/examples/incline-pulley.manic

@@ -0,0 +1,11 @@
+// incline-pulley.manic — the incline-Atwood: a block on an incline tied over a
+// pulley at the top to a hanging mass. `inclinepulley(id,[center],[angle],[m1],
+// [m2],[unit])`. PRE-SIMULATED (RK4); `run(id)` plays it; `energygraph` shows the
+// KE↔PE trade. Matches the classic textbook figure.
+title("Incline + pulley — the incline-Atwood");
+canvas("16:9");
+text(hdr, (cx, 44), "Block on an incline, tied over a pulley to a hanging mass"); size(hdr, 22); color(hdr, cyan); bold(hdr); display(hdr);
+inclinepulley(ip, (280, 500), 30, 3, 2);
+energygraph(ip, (1010, 320), 120);
+text(cap, (cx, h - 32), "m₂ (2 kg) hanging outpulls m₁·sinθ, so m₁ climbs the incline and m₂ descends"); size(cap, 15); color(cap, dim); display(cap);
+run(ip, 4);

package/examples/incline-showcase.manic

@@ -0,0 +1,55 @@
+// ============================================================================
+//  incline-showcase.manic  —  four incline problems, one paper page, all live
+// ----------------------------------------------------------------------------
+//  A single annotated lesson that puts ALL FOUR animated incline sims on one
+//  `template("paper")` page and runs them together — real base-manic composition
+//  (staged reveal with `hidden`/`show`, `say` narration, per-quadrant labels),
+//  not a physics dump. Each sim's bare id broadcasts, so `hidden(rp)`/`show(rp)`
+//  address a whole sim at once. Finishes with all four running in parallel.
+// ============================================================================
+
+title("Four inclined-plane problems — one page");
+canvas("16:9");
+template("paper");
+
+text(hdr, (cx, 34), "Four inclined-plane problems, one page"); color(hdr, fg); size(hdr, 26); bold(hdr); display(hdr); hidden(hdr);
+
+// the four sims (each hidden; the bare id broadcasts to all its parts)
+ramp(rp, (110, 340), 28, 5, 0, 45);            hidden(rp);
+inclinepulley(ip, (690, 340), 30, 3, 2, 42);   hidden(ip);
+doubleincline(dw, (300, 660), 50, 30, 12, 70, 34); hidden(dw);
+inclinebumper(ib, (720, 660), 38, 2, 500, 42); hidden(ib);
+
+// quadrant labels
+text(l1, (150, 175), "① friction on a ramp");     color(l1, dim); size(l1, 17); display(l1); hidden(l1);
+text(l2, (770, 175), "② incline + pulley");        color(l2, dim); size(l2, 17); display(l2); hidden(l2);
+text(l3, (150, 505), "③ two-slope wedge");         color(l3, dim); size(l3, 17); display(l3); hidden(l3);
+text(l4, (770, 505), "④ spring bumper");           color(l4, dim); size(l4, 17); display(l4); hidden(l4);
+
+text(cap, (cx, h - 26), ""); color(cap, fg); size(cap, 19); display(cap);
+
+// ============================== SCRIPT ==============================
+show(hdr, 0.5);
+say(cap, "one page, four classic incline problems — all real, pre-simulated physics", 0.4);
+wait(0.5);
+
+say(cap, "① a block sliding down a rough ramp", 0.4);
+show(rp, 0.5); show(l1, 0.3);
+wait(0.5);
+say(cap, "② a block on an incline, tied over a pulley to a hanging mass", 0.4);
+show(ip, 0.5); show(l2, 0.3);
+wait(0.5);
+say(cap, "③ two blocks on a wedge, connected over the apex", 0.4);
+show(dw, 0.5); show(l3, 0.3);
+wait(0.5);
+say(cap, "④ a block sliding into a spring bumper at the base", 0.4);
+show(ib, 0.5); show(l4, 0.3);
+wait(0.6);
+
+say(cap, "…and they all run — same page, same physics engine, four different motions", 0.4);
+par {
+  run(rp, 7);
+  run(ip, 7);
+  run(dw, 7);
+  run(ib, 7);
+}

package/examples/inline-math.manic

@@ -0,0 +1,16 @@
+// Inline LaTeX everywhere: wrap math in `$…$` (backtick raw string) inside ANY
+// text/caption/kit label. Plain text (no `$`) is unchanged. Mixed lines wrap.
+title("Inline math");
+canvas("16:9");
+
+text(t1, (cx, 110), `The area of a circle is $A = \pi r^2$`);
+color(t1, cyan);
+
+// mixed text + math that WRAPS across lines
+text(t2, (cx, 300), `By the Pythagorean theorem, if $a^2 + b^2 = c^2$ then the triangle with sides a, b, c is right-angled`);
+wrap(t2, 760);
+color(t2, lime);
+
+// a whole-formula label (auto-typeset, centred)
+equation(eq, (cx, 470), `\int_0^{1} x^2 \, dx = \tfrac{1}{3}`, 60);
+color(eq, gold);