@maniclang/workbench 0.1.11

package/examples/block-tackle.manic

@@ -0,0 +1,26 @@
+// ============================================================================
+//  block-tackle.manic  —  the compound pulley (mechanical advantage), Layer 1
+// ----------------------------------------------------------------------------
+//  `blocktackle(id, [center], [load], [effort], [strands], [unit])` — a load on a
+//  movable block held by N rope strands and pulled by an effort mass. The N
+//  strands give a MECHANICAL ADVANTAGE of N: an effort of only load/N balances
+//  the load, and the effort end travels N× as far as the load rises. PRE-SIMULATED
+//  with RK4; `run(id,[dur])` replays it. N = 1 is just the Atwood machine.
+//
+//  TO ADAPT: change `strands` (1–4) — more strands lift the same load with less
+//  effort, but the effort mass has to travel that much further.
+// ============================================================================
+
+title("Block & Tackle — a compound pulley's mechanical advantage");
+canvas("16:9");
+
+text(hdr, (cx, 40), "Block & tackle — 3 strands lift 8 kg with 3 kg of effort");
+size(hdr, 22); color(hdr, cyan); bold(hdr); display(hdr);
+
+blocktackle(bt, (500, 130), 8, 3, 3);
+energygraph(bt, (1030, 330), 120);
+
+text(cap, (cx, h - 32), "3 strands ⇒ MA = 3: effort just over load/3 lifts it; the effort end travels 3× as far");
+size(cap, 15); color(cap, dim); display(cap);
+
+run(bt, 5);

package/examples/bloom-scope.manic

@@ -0,0 +1,172 @@
+// bloom-scope — multi-pass bloom, dissected live. A "light scope" (reticle
+// ring + ticks + core + three orbiting emitters + one pulsing probe) rendered
+// in raw GLSL, with the bloom pipeline broken into inspectable passes:
+//   view 0  the crisp scene (no bloom)
+//   view 1  bright-pass: luminance over the threshold tau (ticks vanish!)
+//   view 2  the gaussian stack: N passes, radius DOUBLING each pass
+//   view 3  composite: scene + sum of passes (additive - base stays crisp)
+// manic has no ping-pong buffers - and doesn't need them here: every emitter
+// is an SDF, so each blurred pass exists in closed form exp(-d^2/sigma^2);
+// the mip ladder becomes one constant-bound loop. Five UI sliders bind
+// straight into the shader as u_<name> uniforms. The flicker beat: the probe
+// pulses across tau - hard threshold makes its halo POP; the soft knee fixes it.
+title("Bloom, One Pass at a Time");
+canvas("16:9");
+template("black");
+
+// ---------- HUD ----------
+text(head, (cx, 60), "Bloom, One Pass at a Time"); display(head); cursor(head);
+text(cap, (cx, h - 42), ""); size(cap, 26);
+text(viewlab, (300, h - 100), ""); size(viewlab, 24); color(viewlab, lime);
+equation(eqb, (cx, 150), `\text{bloom} \;=\; \sum_{p=0}^{N} w_p\; G_{2^{p}\sigma}\!\big(\max(L-\tau,\,0)\big)`, 32); hidden(eqb);
+
+// the UI: five sliders, bound into the shader as u_glo/u_rad/u_pas/u_kne/u_vew
+parameter(glo, (w - 180, 140), 0, 0, 2, "intensity", 2);
+parameter(rad, (w - 180, 205), 0.5, 0, 2, "radius", 2);
+parameter(pas, (w - 180, 270), 0, 0, 5, "passes", 1);
+parameter(kne, (w - 180, 335), 0, 0, 1, "knee", 2);
+parameter(vew, (w - 180, 400), 0, 0, 3, "view", 1);
+counter(cnt, (w - 185, 462), 0, 0, "active passes ", ""); color(cnt, gold); hidden(cnt);
+
+// ---------- the shader ----------
+glsl(scope, `
+uniform float u_glo;
+uniform float u_rad;
+uniform float u_pas;
+uniform float u_kne;
+uniform float u_vew;
+
+float sdRing(vec2 p, float R){ return abs(length(p) - R); }
+float sdBox(vec2 p, vec2 b){ vec2 d = abs(p) - b; return length(max(d, vec2(0.0))) + min(max(d.x, d.y), 0.0); }
+
+// bright-pass weight: hard threshold (tau = 0.55) blended toward a soft knee
+float knee(float b){ return mix(step(0.55, b), smoothstep(0.25, 0.70, b), u_kne); }
+
+// the gaussian stack: N passes, sigma doubling each pass, weights decaying -
+// the closed-form mip ladder (no texture taps: d comes from the SDF)
+vec3 halo(float d, vec3 cb, float w){
+  vec3 a = vec3(0.0);
+  for (int pp = 0; pp < 5; pp++) {
+    float on = clamp(u_pas - float(pp), 0.0, 1.0);
+    float s = max(0.02, u_rad * 0.05 * pow(2.0, float(pp)));
+    a += on * w * cb * exp(-(d*d)/(s*s)) * 0.6 / pow(1.6, float(pp));
+  }
+  return a * u_glo;
+}
+
+void mainImage(out vec4 O, in vec2 I){
+  vec2 p = (2.0*I - iResolution.xy)/iResolution.y;
+  // ---- the light scope: reticle ring + folded tick marks + core
+  float dRing = sdRing(p, 0.62);
+  vec2 q = vec2(abs(p.x), abs(p.y));
+  float ticks = min(sdBox(vec2(q.x - 0.62, p.y), vec2(0.055, 0.012)),
+                    sdBox(vec2(p.x, q.y - 0.62), vec2(0.012, 0.055)));
+  float dCore = length(p) - 0.035;
+  // ---- three orbiting emitters + the pulsing probe (the flicker demo)
+  float a1 = 0.7*iTime;
+  vec2 c1 = 0.45*vec2(cos(a1), sin(a1));
+  vec2 c2 = 0.45*vec2(cos(a1 + 2.09), sin(a1 + 2.09));
+  vec2 c3 = 0.45*vec2(cos(a1 + 4.19), sin(a1 + 4.19));
+  float o1 = length(p - c1) - 0.050;
+  float o2 = length(p - c2) - 0.040;
+  float o3 = length(p - c3) - 0.045;
+  float dPr = length(p - vec2(0.0, -0.86)) - 0.055;
+  float bPr = 0.35 + 0.45*(0.5 + 0.5*sin(2.6*iTime));
+  vec3 cRing = vec3(0.30, 0.85, 1.00);
+  vec3 cCore = vec3(1.00, 0.95, 0.80);
+  vec3 cO1 = vec3(1.00, 0.72, 0.25);
+  vec3 cO2 = vec3(1.00, 0.35, 0.80);
+  vec3 cO3 = vec3(0.30, 1.00, 0.75);
+  vec3 cPr = vec3(0.75, 0.85, 1.00);
+  // ---- view 0: the crisp scene
+  float e = 0.006;
+  vec3 scene = vec3(0.0);
+  scene += smoothstep(e, 0.0, dRing) * cRing * 0.77;
+  scene += smoothstep(e, 0.0, ticks) * cRing * 0.50;
+  scene += smoothstep(e, 0.0, dCore) * cCore * 1.00;
+  scene += smoothstep(e, 0.0, o1) * cO1 * 0.95;
+  scene += smoothstep(e, 0.0, o2) * cO2 * 0.90;
+  scene += smoothstep(e, 0.0, o3) * cO3 * 0.90;
+  scene += smoothstep(e, 0.0, dPr) * cPr * bPr;
+  // ---- view 1: bright extraction (the 0.50 reticle ticks fall BELOW tau)
+  vec3 bright = vec3(0.0);
+  bright += smoothstep(e, 0.0, dRing) * cRing * knee(0.77);
+  bright += smoothstep(e, 0.0, dCore) * cCore * knee(1.00);
+  bright += smoothstep(e, 0.0, o1) * cO1 * knee(0.95);
+  bright += smoothstep(e, 0.0, o2) * cO2 * knee(0.90);
+  bright += smoothstep(e, 0.0, o3) * cO3 * knee(0.90);
+  bright += smoothstep(e, 0.0, dPr) * cPr * knee(bPr);
+  // ---- views 2/3: the stacked gaussian passes
+  vec3 bloom = vec3(0.0);
+  bloom += halo(dRing, cRing * 0.77, knee(0.77) * 0.55);
+  bloom += halo(dCore, cCore, knee(1.00));
+  bloom += halo(o1, cO1 * 0.95, knee(0.95));
+  bloom += halo(o2, cO2 * 0.90, knee(0.90));
+  bloom += halo(o3, cO3 * 0.90, knee(0.90));
+  bloom += halo(dPr, cPr * bPr, knee(bPr));
+  // ---- the view dial
+  float vA = 1.0 - clamp(abs(u_vew - 0.0), 0.0, 1.0);
+  float vB = 1.0 - clamp(abs(u_vew - 1.0), 0.0, 1.0);
+  float vC = 1.0 - clamp(abs(u_vew - 2.0), 0.0, 1.0);
+  float vD = 1.0 - clamp(abs(u_vew - 3.0), 0.0, 1.0);
+  vec3 col = vA*scene + vB*bright + vC*bloom + vD*(scene + bloom);
+  float aOut = clamp(1.6*max(col.r, max(col.g, col.b)), 0.0, 1.0);
+  O = vec4(col, aOut);
+}
+`);
+
+// ================= timeline =================
+
+// ---- view 0: honest and dead
+type(head, 1.1);
+say(viewlab, "VIEW 0 - scene, no bloom", 0.3);
+say(cap, "a light scope, rendered honest: crisp, correct - and completely dead", 0.6);
+wait(2.2);
+
+// ---- view 1: the bright-pass
+cue(tick);
+say(viewlab, "VIEW 1 - bright-pass: L > tau", 0.3);
+to(vew, value, 1, 0.8, smooth);
+say(cap, "pass one: keep only what outshines the threshold - the fine ticks vanish", 0.5);
+wait(2.6);
+
+// ---- view 2: stack the gaussian passes, one by one
+cue(whoosh);
+say(viewlab, "VIEW 2 - gaussian stack, radius x2 per pass", 0.3);
+to(vew, value, 2, 0.8, smooth);
+show(eqb, 0.6);
+show(cnt, 0.3);
+to(glo, value, 1, 0.8, smooth);
+say(cap, "now blur it - again and again, radius doubling: the mip ladder", 0.5);
+par { to(pas, value, 1, 0.7, smooth); to(cnt, value, 1, 0.7); }
+wait(0.4);
+par { to(pas, value, 2, 0.7, smooth); to(cnt, value, 2, 0.7); }
+wait(0.4);
+par { to(pas, value, 3, 0.7, smooth); to(cnt, value, 3, 0.7); }
+wait(0.4);
+par { to(pas, value, 5, 1.0, smooth); to(cnt, value, 5, 1.0); }
+say(cap, "no ping-pong buffers: the emitters are SDFs, so every pass exists in closed form", 0.5);
+wait(1.2);
+
+// ---- view 3: the composite
+cue(chime);
+say(viewlab, "VIEW 3 - composite: scene + all passes", 0.3);
+to(vew, value, 3, 0.9, smooth);
+say(cap, "add it back on top: the scope begins to BLEED - but the base layer stays crisp", 0.5);
+wait(2.0);
+
+// ---- the flicker, and the fix
+cue(tick);
+say(cap, "watch the probe at the bottom: a HARD threshold makes its halo pop on and off", 0.5);
+wait(3.4);
+say(cap, "the fix: a soft KNEE - brightness eases across tau, and the halo breathes", 0.5);
+to(kne, value, 1, 1.6, smooth);
+wait(3.0);
+
+// ---- finale: crank it
+cue(whoosh);
+say(cap, "clarity amidst chaos: bloom is additive light, never a blur of the scene", 0.5);
+par { to(glo, value, 1.7, 2.0, smooth); to(rad, value, 1.5, 2.0, smooth); breathe(eqb, 3, 0.05, 0, 6); }
+to(rad, value, 0.9, 1.6, smooth);
+say(cap, "five sliders, one shader, every pass inspectable", 0.6);
+wait(2.5);

package/examples/boolean.manic

@@ -0,0 +1,46 @@
+// Boolean Ops — combine two shapes into a new region: union, intersection,
+// difference, exclusion (xor). Each cell overlaps a square (cyan outline) and
+// a circle (magenta outline); the filled lime shape is the result.
+//
+//   manic examples/boolean.manic
+//   manic examples/boolean.manic --record out --fps 60
+
+title("Boolean Ops");
+canvas(1280, 720);
+
+text(head, (640, 118), "boolean shape ops");
+display(head);  color(head, cyan);  size(head, 36);  hidden(head);
+
+// --- union (top-left) ---
+rect(aS, (330, 300), 130, 130);  outlined(aS);  outline(aS, cyan);     opacity(aS, 0.4);
+circle(aC, (400, 250), 78);      outlined(aC);  outline(aC, magenta);  opacity(aC, 0.4);
+union(aR, aS, aC, lime);         hidden(aR);
+text(aL, (365, 430), "union");   color(aL, dim);  size(aL, 22);
+
+// --- intersection (top-right) ---
+rect(bS, (880, 300), 130, 130);  outlined(bS);  outline(bS, cyan);     opacity(bS, 0.4);
+circle(bC, (950, 250), 78);      outlined(bC);  outline(bC, magenta);  opacity(bC, 0.4);
+intersect(bR, bS, bC, lime);     hidden(bR);
+text(bL, (915, 430), "intersection");  color(bL, dim);  size(bL, 20);
+
+// --- difference (bottom-left): square minus circle ---
+rect(cS, (330, 545), 130, 130);  outlined(cS);  outline(cS, cyan);     opacity(cS, 0.4);
+circle(cC, (400, 495), 78);      outlined(cC);  outline(cC, magenta);  opacity(cC, 0.4);
+difference(cR, cS, cC, lime);    hidden(cR);
+text(cL, (355, 675), "difference (rect - circle)");  color(cL, dim);  size(cL, 18);
+
+// --- exclusion / xor (bottom-right) ---
+rect(dS, (880, 545), 130, 130);  outlined(dS);  outline(dS, cyan);     opacity(dS, 0.4);
+circle(dC, (950, 495), 78);      outlined(dC);  outline(dC, magenta);  opacity(dC, 0.4);
+xor(dR, dS, dC, lime);           hidden(dR);
+text(dL, (915, 675), "exclusion (xor)");  color(dL, dim);  size(dL, 18);
+
+// --- script: reveal each result in turn ---
+show(head, 0.5);
+stagger(0.3) {
+  show(aR, 0.4);
+  show(bR, 0.4);
+  show(cR, 0.4);
+  show(dR, 0.4);
+}
+wait(1.5);

package/examples/boxplot-wave.manic

@@ -0,0 +1,93 @@
+// boxplot-wave — reading a box plot: the seasonal rainfall wave, built by jumps.
+//
+// Eight months of daily-rainfall box plots. They start below the frame and JUMP
+// up (springy `shift`) into their true medians on the mm axis — staggered, so the
+// seasonal wave assembles month by month. A dashed trend line then draws through
+// the medians, and the manic wordmark signs off. Educational (labelled axes, a
+// real seasonal pattern, how to read a box plot) and lively.
+//
+//   manic examples/boxplot-wave.manic
+title("Monthly rainfall through the year");
+canvas(1600, 1000);
+template("paper");
+
+let ybase = 850;   // y of 0 mm
+let sc    = 9;      // pixels per mm
+let start = 1060;   // off-screen below: the boxes launch from here
+
+// headings
+text(hdr, (830, 66), "Monthly rainfall through the year");
+size(hdr, 40); color(hdr, #222222);
+text(sub, (830, 112), "each box = a month of daily rainfall  ·  line = median, box = middle 50% (IQR), whiskers = range, dot = a storm");
+size(sub, 21); color(sub, #7f8aa3);
+
+// ---- y axis (rainfall, mm) ----
+line(yax, (200, 300), (200, ybase)); stroke(yax, 2.5); color(yax, #444444);
+for k in 0..4 {
+  let mm = k * 20;
+  let yv = ybase - mm * sc;
+  line(ytk{k}, (192, yv), (208, yv)); stroke(ytk{k}, 2); color(ytk{k}, #444444);
+  counter(ytl{k}, (160, yv), mm, 0); size(ytl{k}, 22); color(ytl{k}, #555555);
+}
+text(ytit, (205, 270), "mm"); size(ytit, 22); color(ytit, #7f8aa3);
+
+// ---- x axis (month) ----
+line(xax, (220, ybase), (1470, ybase)); stroke(xax, 2.5); color(xax, #444444);
+text(xtit, (845, 958), "month"); size(xtit, 24); color(xtit, #7f8aa3);
+
+// ---- the eight monthly box plots, created OFF-SCREEN BELOW (they jump up) ----
+boxplot(m0, (290,  start), "0 1 2 3 4 5 8",            72);
+boxplot(m1, (450,  start), "1 3 4 5 6 8 11",           72);
+boxplot(m2, (610,  start), "5 8 10 12 14 18 24",       72);
+boxplot(m3, (770,  start), "14 20 26 30 34 40 52",     72);
+boxplot(m4, (930,  start), "18 26 30 35 39 46 60 82",  72);
+boxplot(m5, (1090, start), "10 16 20 22 25 30 40",     72);
+boxplot(m6, (1250, start), "4 7 9 11 13 17 24",        72);
+boxplot(m7, (1410, start), "0 2 3 4 5 7 10",           72);
+
+// month labels
+text(x0, (290, 900), "Jan"); text(x1, (450, 900), "Feb"); text(x2, (610, 900), "Apr");
+text(x3, (770, 900), "Jun"); text(x4, (930, 900), "Jul"); text(x5, (1090, 900), "Sep");
+text(x6, (1250, 900), "Oct"); text(x7, (1410, 900), "Dec");
+size(x0, 22); size(x1, 22); size(x2, 22); size(x3, 22); size(x4, 22); size(x5, 22); size(x6, 22); size(x7, 22);
+color(x0, #555555); color(x1, #555555); color(x2, #555555); color(x3, #555555);
+color(x4, #555555); color(x5, #555555); color(x6, #555555); color(x7, #555555);
+
+// hide each plot's own number labels — the shared axis carries the values now
+hidden(m0.iqr); hidden(m0.lmin); hidden(m0.lmed); hidden(m0.lmax); hidden(m0.lq1); hidden(m0.lq3);
+hidden(m1.iqr); hidden(m1.lmin); hidden(m1.lmed); hidden(m1.lmax); hidden(m1.lq1); hidden(m1.lq3);
+hidden(m2.iqr); hidden(m2.lmin); hidden(m2.lmed); hidden(m2.lmax); hidden(m2.lq1); hidden(m2.lq3);
+hidden(m3.iqr); hidden(m3.lmin); hidden(m3.lmed); hidden(m3.lmax); hidden(m3.lq1); hidden(m3.lq3);
+hidden(m4.iqr); hidden(m4.lmin); hidden(m4.lmed); hidden(m4.lmax); hidden(m4.lq1); hidden(m4.lq3);
+hidden(m5.iqr); hidden(m5.lmin); hidden(m5.lmed); hidden(m5.lmax); hidden(m5.lq1); hidden(m5.lq3);
+hidden(m6.iqr); hidden(m6.lmin); hidden(m6.lmed); hidden(m6.lmax); hidden(m6.lq1); hidden(m6.lq3);
+hidden(m7.iqr); hidden(m7.lmin); hidden(m7.lmed); hidden(m7.lmax); hidden(m7.lq1); hidden(m7.lq3);
+
+// the trend line through the medians (drawn in after the boxes land)
+line(t0, (290,  ybase-3*sc),  (450,  ybase-5*sc));  tag(t0, trend);
+line(t1, (450,  ybase-5*sc),  (610,  ybase-12*sc)); tag(t1, trend);
+line(t2, (610,  ybase-12*sc), (770,  ybase-30*sc)); tag(t2, trend);
+line(t3, (770,  ybase-30*sc), (930,  ybase-35*sc)); tag(t3, trend);
+line(t4, (930,  ybase-35*sc), (1090, ybase-22*sc)); tag(t4, trend);
+line(t5, (1090, ybase-22*sc), (1250, ybase-11*sc)); tag(t5, trend);
+line(t6, (1250, ybase-11*sc), (1410, ybase-4*sc));  tag(t6, trend);
+stroke(trend, 2.5); color(trend, #ff2d95); dashed(trend); untraced(trend);
+
+// the wordmark, waiting for the sign-off
+text(word, (1400, 210), "manic"); size(word, 46); color(word, #ff2d95); hidden(word);
+
+// ---- the show ----
+// 1) each month JUMPS up into place (springy), building the seasonal wave
+stagger(0.26) {
+  shift(m0, (0, -(start - (ybase - 3  * sc))), 1.3, overshoot);
+  shift(m1, (0, -(start - (ybase - 5  * sc))), 1.3, overshoot);
+  shift(m2, (0, -(start - (ybase - 12 * sc))), 1.3, overshoot);
+  shift(m3, (0, -(start - (ybase - 30 * sc))), 1.3, overshoot);
+  shift(m4, (0, -(start - (ybase - 35 * sc))), 1.3, overshoot);
+  shift(m5, (0, -(start - (ybase - 22 * sc))), 1.3, overshoot);
+  shift(m6, (0, -(start - (ybase - 11 * sc))), 1.3, overshoot);
+  shift(m7, (0, -(start - (ybase - 4  * sc))), 1.3, overshoot);
+}
+// 2) draw the seasonal trend, then 3) sign off
+draw(trend, 2.5);
+show(word, 0.9); pulse(word);

package/examples/boxplot.manic

@@ -0,0 +1,43 @@
+// ============================================================================
+//  boxplot.manic  —  the five-number summary (stats Tier 1)
+// ----------------------------------------------------------------------------
+//  `boxplot(id, (cx,cy), "v1 v2 v3 …", [width], [color])` draws a box-and-whisker:
+//  the box spans Q1→Q3 (its width IS the interquartile range), a line marks the
+//  median, whiskers reach the extreme non-outliers (within 1.5·IQR), and points
+//  beyond are flagged as outliers. Pieces: `{id}.box`, `{id}.med`,
+//  `{id}.whiskerlo`/`.whiskerhi` (+ `.caplo`/`.caphi`), `{id}.outliers`,
+//  `{id}.iqr` and the value labels.
+//
+//  TO ADAPT: paste your numbers. A value far from the box (here 40) shows up as
+//  an outlier automatically.
+// ============================================================================
+
+title("Box-and-whisker: the five-number summary");
+canvas("16:9");
+
+text(hdr, (cx, 70), "response times (seconds) — one slow outlier");
+size(hdr, 24); color(hdr, cyan); bold(hdr); display(hdr);
+
+boxplot(bp, (cx, cy), "12 15 14 10 18 16 13 15 14 17 40 11 16 15 14", 700);
+untraced(bp.whiskerlo); untraced(bp.whiskerhi); untraced(bp.caplo); untraced(bp.caphi); untraced(bp.med);
+hidden(bp.box);
+hidden(bp.outliers);
+hidden(bp.iqr); hidden(bp.lmin); hidden(bp.lmax); hidden(bp.lmed); hidden(bp.lq1); hidden(bp.lq3);
+
+text(cap, (cx, h - 46), ""); size(cap, 22); color(cap, dim); display(cap);
+
+say(cap, "the box holds the middle half of the data — Q1 to Q3, the IQR", 0.5);
+to(bp.box, opacity, 0.2, 0.6);
+show(bp.lq1, 0.3); show(bp.lq3, 0.3); show(bp.iqr, 0.3);
+wait(1.5);
+
+say(cap, "the line inside is the median; the whiskers reach the rest", 0.5);
+draw(bp.med, 0.4); show(bp.lmed, 0.3);
+par { draw(bp.whiskerlo, 0.5); draw(bp.whiskerhi, 0.5); }
+draw(bp.caplo, 0.3); draw(bp.caphi, 0.3);
+show(bp.lmin, 0.3); show(bp.lmax, 0.3);
+wait(1.6);
+
+say(cap, "and a value far outside the whiskers is flagged as an outlier", 0.5);
+show(bp.outliers, 0.4); pulse(bp.outliers);
+wait(1.9);

package/examples/brace.manic

@@ -0,0 +1,46 @@
+// Braces — label spans and parts with curly braces, manic's Brace / BraceLabel
+// / BraceBetweenPoints. A length is split into two parts a and b; a brace under
+// each names it, and a brace over the whole names the sum. Every brace here is
+// a BraceBetweenPoints (two points + a depth); bracelabel adds the text.
+//
+//   manic examples/brace.manic
+//   manic examples/brace.manic --record out --fps 60
+
+title("Braces");
+canvas(1280, 720);
+
+text(head, (640, 120), "label a span, or its parts");
+display(head);  color(head, cyan);  size(head, 28);  hidden(head);
+text(cap, (640, 620), "");  color(cap, dim);  size(cap, 24);
+
+// the length, split at x = 680
+line(seg, (300, 360), (980, 360));  color(seg, fg);  stroke(seg, 3);  untraced(seg);
+dot(dl, (300, 360));   dot(dm, (680, 360));   dot(dr, (980, 360));
+color(dl, magenta);  color(dm, lime);  color(dr, cyan);
+hidden(dl);  hidden(dm);  hidden(dr);
+
+// braces under the two parts, and over the whole (bulges up: points go R->L)
+bracelabel(ba, (300, 392), (680, 392), "a", 30);        color(ba, magenta);
+bracelabel(bb, (680, 392), (980, 392), "b", 30);        color(bb, cyan);
+bracelabel(bt, (980, 320), (300, 320), "a + b", 34);    color(bt, lime);
+hidden(ba);  hidden(bb);  hidden(bt);
+
+// --- reveal ---
+show(head, 0.5);
+say(cap, "here is a length");
+draw(seg, 0.7);
+par { show(dl, 0.3);  show(dr, 0.3); }
+wait(0.3);
+
+section("Two parts");
+say(cap, "split it at a point into parts a and b");
+show(dm, 0.3);
+show(ba, 0.5);
+show(bb, 0.5);
+wait(0.5);
+
+section("The whole");
+say(cap, "the whole span is a + b");
+show(bt, 0.6);
+par { pulse(ba.label);  pulse(bb.label);  pulse(bt.label); }
+wait(1.4);

package/examples/brachistochrone-annotated.manic

@@ -0,0 +1,51 @@
+// ============================================================================
+//  brachistochrone-annotated.manic  —  ELEVATE a sim: KINETIC TYPOGRAPHY
+// ----------------------------------------------------------------------------
+//  A third elevation flavour (see spring-annotated for typewriter, pulley-
+//  annotated for camera). Here the text itself performs: `caption` + `wordpop`
+//  pops the question in word-by-word, `caption` + `karaoke` sweeps a highlight
+//  across the four path names as the curves are sketched, and `flash`/`glow`/
+//  `pulse` crown the winner — the same recipe on a multi-body RACE, no section
+//  cards. All base manic over the `brachistochrone` parts.
+// ============================================================================
+
+title("Brachistochrone — Shortest Path, or Fastest?");
+canvas("16:9");
+
+// ---- the sim (curves untraced to sketch on; beads + markers hidden) ----
+brachistochrone(br, (330, 165), 150);
+untraced(br.straight); untraced(br.circle); untraced(br.parabola); untraced(br.cycloid);
+hidden(br.bead_straight); hidden(br.bead_circle); hidden(br.bead_parabola); hidden(br.bead_cycloid);
+hidden(br.markA); hidden(br.labelA); hidden(br.markB); hidden(br.labelB);
+
+// ---- kinetic-typography captions ----
+caption(q, "shortest path — or fastest?", (cx, 62), 34, gold);
+caption(leg, "straight   arc   parabola   cycloid", (cx, h - 66), 26, dim);
+text(cap, (cx, h - 32), ""); size(cap, 19); color(cap, dim); display(cap);
+
+// ============================== SCRIPT ==============================
+say(cap, "a bead slides from A down to B under gravity — same start, same finish", 0.4);
+show(br.markA, 0.4); show(br.labelA, 0.3); pulse(br.markA);
+show(br.markB, 0.4); show(br.labelB, 0.3); pulse(br.markB);
+wait(0.4);
+
+// the question pops in, word by word
+wordpop(q, 0.18);
+wait(0.6);
+
+// sketch the four curves; the legend highlight sweeps across their names
+say(cap, "four paths from A to B — the cycloid dips below the line", 0.4);
+draw(br.straight, 0.5); draw(br.circle, 0.5); draw(br.parabola, 0.5); draw(br.cycloid, 0.6);
+karaoke(leg, 0.5, cyan);
+flash(br.cycloid, magenta);
+wait(0.5);
+
+// the race
+say(cap, "release all four at once …", 0.4);
+show(br.bead_straight, 0.3); show(br.bead_circle, 0.3); show(br.bead_parabola, 0.3); show(br.bead_cycloid, 0.3);
+run(br, 6);
+
+// crown the winner
+say(cap, "the CYCLOID wins — the steep early drop buys speed that repays the longer path", 0.4);
+flash(br.cycloid, lime); glow(br.bead_cycloid, 1.9); pulse(br.bead_cycloid);
+wait(1.0);

package/examples/brachistochrone.manic

@@ -0,0 +1,27 @@
+// ============================================================================
+//  brachistochrone.manic  —  the curve of fastest descent (physics Layer 1)
+// ----------------------------------------------------------------------------
+//  `brachistochrone(id, [center], [unit])` — four beads race under gravity from
+//  A down to B along four curves: a straight line, a circular arc, a parabola,
+//  and a CYCLOID. Each is a full RK4 bead-on-wire integration. The cycloid — the
+//  brachistochrone — wins, even though it dips below and travels farther. The
+//  steep early drop buys speed that more than pays back the extra distance.
+//  `run(id,[dur])` replays the race.
+//
+//  TO ADAPT: raise `dur` to watch the finish order in slow motion.
+// ============================================================================
+
+title("Brachistochrone — the fastest slide is a cycloid");
+canvas("16:9");
+
+text(hdr, (cx, 44), "Which curve is fastest from A to B? Steepness early beats a short path");
+size(hdr, 21); color(hdr, cyan); bold(hdr); display(hdr);
+
+brachistochrone(br, (330, 150), 150);
+
+text(leg, (cx, h - 58), "dim: straight    cyan: arc    gold: parabola    magenta: CYCLOID (winner)");
+size(leg, 16); color(leg, fg); display(leg);
+text(cap, (cx, h - 30), "same start, same finish — the magenta cycloid bead reaches B first");
+size(cap, 16); color(cap, dim); display(cap);
+
+run(br, 5);

package/examples/bubble_sort.manic

@@ -0,0 +1,41 @@
+// Bubble Sort — real sliding swaps. `array` gives fixed slot boxes and value
+// cells; `compare(a, i, j)` flashes the values now in slots i and j, and
+// `swap(a, i, j)` slides them past each other into the swapped slots. `swap`
+// carries the array's occupancy forward, so a whole chain of swaps composes
+// correctly (no `say`). We sort [3, 1, 2] -> [1, 2, 3].
+//
+//   manic examples/bubble_sort.manic
+
+title("Bubble Sort");
+canvas("16:9");
+
+text(head, (cx, 130), "compare neighbours, swap if out of order");
+display(head);  color(head, cyan);  size(head, 26);  hidden(head);
+text(cap, (cx, 560), "");  color(cap, dim);  size(cap, 26);
+
+array(a, "3 1 2", (cx, 360), 100, 100);
+
+show(head, 0.5);
+say(cap, "an unsorted array");
+wait(0.6);
+
+section("Pass 1");
+say(cap, "compare slots 0 and 1:  3 > 1, swap");
+compare(a, 0, 1);
+swap(a, 0, 1);
+
+say(cap, "compare slots 1 and 2:  3 > 2, swap");
+compare(a, 1, 2);
+swap(a, 1, 2);
+
+section("Pass 2");
+say(cap, "compare slots 0 and 1:  1 < 2, ok");
+compare(a, 0, 1, lime);
+say(cap, "compare slots 1 and 2:  2 < 3, ok");
+compare(a, 1, 2, lime);
+
+section("Sorted");
+say(cap, "1  2  3 -- done");
+recolor(a.cells, lime, 0.4);
+par { pulse(a.c0);  pulse(a.c1);  pulse(a.c2); }
+wait(1.4);

package/examples/bullet-block-annotated.manic

@@ -0,0 +1,48 @@
+// ============================================================================
+//  bullet-block-annotated.manic  —  a bullet's journey (inelastic collision)
+// ----------------------------------------------------------------------------
+//  Not the bare lab sim — a scene: a gun fires, a muzzle flash, a glowing bullet
+//  crosses the gap in slow-motion, embeds in the block, and the live speed readout
+//  COLLAPSES from 40 m/s to ~1. The block barely lurches — it soaked up the bullet
+//  but almost none of the speed. Base-manic staging over the `bulletblock` sim.
+// ============================================================================
+
+title("A bullet fired into a block");
+canvas("16:9");
+
+text(hdr, (cx, 44), "A bullet fired into a block"); size(hdr, 30); color(hdr, cyan); bold(hdr); display(hdr); hidden(hdr);
+text(sub, (cx, 80), "perfectly inelastic: the bullet embeds — momentum survives, speed collapses"); size(sub, 17); color(sub, dim); display(sub); hidden(sub);
+
+// the sim (bullet at the muzzle, block at rest, floor, live speed readout, energy)
+bulletblock(bb, (cx, 430), 0.05, 40, 1.95);
+hidden(bb);
+energygraph(bb, (1055, 250), 82);
+
+// the gun (all base-manic shapes), at the bullet's start height
+rect(barrel, (200, 380), 82, 20);  color(barrel, dim); filled(barrel);
+rect(body, (166, 386), 42, 34);    color(body, dim);   filled(body);
+polygon(grip, (150, 404), (176, 404), (170, 442), (146, 438), dim);
+circle(flash, (242, 380), 17);     color(flash, gold); glow(flash, 2.4);
+hidden(barrel); hidden(body); hidden(grip); hidden(flash);
+
+// callouts
+text(cbl, (300, 336), "the bullet — light + fast"); size(cbl, 16); color(cbl, red); display(cbl); hidden(cbl);
+text(cblk, (720, 300), "the block — heavy, at rest"); size(cblk, 16); color(cblk, cyan); display(cblk); hidden(cblk);
+
+text(cap, (cx, h - 38), ""); size(cap, 19); color(cap, fg); display(cap);
+
+// ============================== SCRIPT ==============================
+show(hdr, 0.5); show(sub, 0.4);
+wait(0.3);
+show(bb, 0.5); show(barrel, 0.3); show(body, 0.3); show(grip, 0.3);
+show(cbl, 0.3); show(cblk, 0.3);
+wait(0.4);
+
+say(cap, "a heavy block sits at rest; a fast, light bullet is loaded", 0.4);
+wait(0.5);
+say(cap, "FIRE — 40 m/s across the gap …", 0.4);
+flash(flash, gold); pulse(flash);
+run(bb, 6);
+
+say(cap, "… it embeds. Momentum is conserved, but 40 m/s collapses to ~1 — the energy is gone", 0.4);
+wait(1.0);

package/examples/bullet-block.manic

@@ -0,0 +1,11 @@
+// bullet-block.manic — a bullet fired into a block EMBEDS (perfectly inelastic).
+// `bulletblock(id,[center],[bulletmass],[speed],[blockmass],[unit])`. The combined
+// mass crawls off at m_b·v_b/(m_b+M) — most of the kinetic energy is lost to the
+// collision, so `energygraph`'s total STEPS DOWN at impact. Uses `collide_1d(e=0)`.
+title("Bullet into a block — an inelastic collision");
+canvas("16:9");
+text(hdr, (cx, 70), "The bullet embeds: 40 m/s becomes ~1 m/s — most of the energy is gone"); size(hdr, 21); color(hdr, cyan); bold(hdr); display(hdr);
+bulletblock(bb, (cx, 430), 0.05, 40, 1.95);
+energygraph(bb, (1040, 200), 90);
+text(cap, (cx, h - 36), "momentum is conserved, but kinetic energy is NOT — it drops sharply at impact"); size(cap, 15); color(cap, dim); display(cap);
+run(bb, 6);