@maniclang/workbench 0.1.11

package/examples/complex-flowchart.manic

@@ -0,0 +1,196 @@
+title("Deployment Pipeline — Many Decisions & Loops");
+// Stress test: 7 decisions and several back-edges — some loop to an earlier step,
+// one loops all the way back to `start`. `flowchart` still auto-wraps into
+// side-by-side columns; forward edges are clean elbows, backward edges (loops,
+// column wraps) arc as curves. No coordinates.
+canvas("16:9");
+template("mono");
+
+let u = (w+h-abs(w-h))/1440;
+watermark(mark, (w*0.15, h*0.04), "Made With Manic");
+text(kicker, (cx, h*0.055), "DIAGRAMS · FLOWCHART · DECISIONS & LOOPS");
+text(headline, (cx, h*0.12), "Seven decisions, five loops, one chart");
+size(kicker, 15*u); color(kicker, dim); bold(kicker);
+size(headline, 23*u); bold(headline); wrap(headline, w*0.86);
+
+flowchart(cd, auto, 40);
+node(start, cd, "terminator", "start");
+node(checkout, cd, "io", "checkout");
+node(install, cd, "process", "install deps");
+node(build, cd, "process", "build");
+node(bok, cd, "decision", "build ok?");
+node(fix, cd, "process", "fix build");
+node(unit, cd, "process", "unit tests");
+node(uok, cd, "decision", "tests pass?");
+node(debug, cd, "process", "debug");
+node(integ, cd, "process", "integration");
+node(iok, cd, "decision", "integ ok?");
+node(scan, cd, "process", "security scan");
+node(sok, cd, "decision", "scan clean?");
+node(patch, cd, "process", "patch deps");
+node(stage, cd, "process", "deploy staging");
+node(smoke, cd, "process", "smoke test");
+node(smok, cd, "decision", "smoke ok?");
+node(approve, cd, "decision", "approve prod?");
+node(hold, cd, "terminator", "held");
+node(roll, cd, "process", "rollback");
+node(prod, cd, "process", "deploy prod");
+node(health, cd, "decision", "healthy?");
+node(notify, cd, "process", "notify team");
+node(done, cd, "terminator", "shipped");
+
+connect(e1, start, checkout);
+connect(e2, checkout, install);
+connect(e3, install, build);
+connect(e4, build, bok);
+connect(e5, bok, unit);            // yes
+connect(e6, bok, fix);             // no
+connect(e7, fix, build);           // loop -> build
+connect(e8, unit, uok);
+connect(e9, uok, integ);           // yes
+connect(e10, uok, debug);          // no
+connect(e11, debug, build);        // loop -> build
+connect(e12, integ, iok);
+connect(e13, iok, scan);           // yes
+connect(e14, iok, debug);          // no -> debug (which loops to build)
+connect(e15, scan, sok);
+connect(e16, sok, stage);          // yes
+connect(e17, sok, patch);          // no
+connect(e18, patch, scan);         // loop -> scan
+connect(e19, stage, smoke);
+connect(e20, smoke, smok);
+connect(e21, smok, approve);       // yes
+connect(e22, smok, roll);          // no
+connect(e23, roll, start);         // loop -> start (all the way back)
+connect(e24, approve, prod);       // yes
+connect(e25, approve, hold);       // no
+connect(e26, prod, health);
+connect(e27, health, notify);      // yes
+connect(e28, health, roll);        // no -> rollback
+connect(e29, notify, done);
+
+// forward = proceed, back-edges = loops/failures
+color(e6, magenta);  color(e6.hot, magenta);
+color(e10, magenta); color(e10.hot, magenta);
+color(e14, magenta); color(e14.hot, magenta);
+color(e17, magenta); color(e17.hot, magenta);
+color(e22, magenta); color(e22.hot, magenta);
+color(e28, magenta); color(e28.hot, magenta);
+color(e7, gold);  color(e7.hot, gold);
+color(e11, gold); color(e11.hot, gold);
+color(e18, gold); color(e18.hot, gold);
+color(e23, gold); color(e23.hot, gold);
+annotate(e5, "yes");  annotate(e6, "no");
+annotate(e9, "yes");  annotate(e10, "no");
+annotate(e16, "yes"); annotate(e17, "no");
+annotate(e21, "yes"); annotate(e22, "no");
+annotate(e24, "yes"); annotate(e25, "no");
+annotate(e27, "yes"); annotate(e28, "no");
+
+text(k1, (w*0.36, h*0.94), "— proceed"); size(k1, 13*u); color(k1, fg); bold(k1);
+text(k2, (w*0.52, h*0.94), "— reject"); size(k2, 13*u); color(k2, magenta); bold(k2);
+text(k3, (w*0.66, h*0.94), "— loop back"); size(k3, 13*u); color(k3, gold); bold(k3);
+
+// Two tokens per round, released together — they share the pipeline, then split
+// at a decision and reach different ends. Two rounds, then done.
+request(a1, start, "PR-A"); request(b1, start, "PR-B");   // round 1
+request(a2, start, "PR-C"); request(b2, start, "PR-D");   // round 2
+hidden(cd.nodes);
+untraced(cd.connections);   // edges start undrawn — we draw them as we build
+hidden(a1.parts); hidden(b1.parts); hidden(a2.parts); hidden(b2.parts);
+
+// Build the chart the way you'd draw it: each box appears in flow order and the
+// edge into it draws first, so you watch the whole pipeline take shape — then the
+// tokens run it. Best way to learn how a flowchart is put together.
+step("build-chart") {
+  seq {
+    show(start, 0.3);
+    draw(e1, 0.14);  show(checkout, 0.18);
+    draw(e2, 0.14);  show(install, 0.18);
+    draw(e3, 0.14);  show(build, 0.18);
+    draw(e4, 0.14);  show(bok, 0.18);
+    draw(e5, 0.14);  show(unit, 0.18);
+    draw(e6, 0.14);  show(fix, 0.18);
+    draw(e8, 0.14);  show(uok, 0.18);
+    draw(e9, 0.14);  show(integ, 0.18);
+    draw(e10, 0.14); show(debug, 0.18);
+    draw(e12, 0.14); show(iok, 0.18);
+    draw(e13, 0.14); show(scan, 0.18);
+    draw(e14, 0.14);                       // iok no → debug (already shown)
+    draw(e15, 0.14); show(sok, 0.18);
+    draw(e16, 0.14); show(stage, 0.18);
+    draw(e17, 0.14); show(patch, 0.18);
+    draw(e19, 0.14); show(smoke, 0.18);
+    draw(e20, 0.14); show(smok, 0.18);
+    draw(e21, 0.14); show(approve, 0.18);
+    draw(e22, 0.14); show(roll, 0.18);
+    draw(e24, 0.14); show(prod, 0.18);
+    draw(e25, 0.14); show(hold, 0.18);
+    draw(e26, 0.14); show(health, 0.18);
+    draw(e27, 0.14); show(notify, 0.18);
+    draw(e28, 0.14);                       // health no → roll (already shown)
+    draw(e29, 0.14); show(done, 0.18);
+    // feedback loops complete the picture last
+    draw(e7, 0.22); draw(e11, 0.22); draw(e18, 0.22); draw(e23, 0.35);
+  }
+}
+wait(0.5);
+
+// Round 1 — two PRs race the pipeline in parallel. They ride together until the
+// smoke test, where A ships and B fails and rolls back around to the start.
+step("round-1") {
+  par {
+    seq {
+      show(a1.parts, 0.2);
+      route(a1, e1, 0.22, smooth); route(a1, e2, 0.22, smooth); route(a1, e3, 0.22, smooth);
+      route(a1, e4, 0.22, smooth); route(a1, e5, 0.22, smooth); route(a1, e8, 0.22, smooth);
+      route(a1, e9, 0.22, smooth); route(a1, e12, 0.22, smooth); route(a1, e13, 0.22, smooth);
+      route(a1, e15, 0.22, smooth); route(a1, e16, 0.22, smooth); route(a1, e19, 0.22, smooth);
+      route(a1, e20, 0.22, smooth); route(a1, e21, 0.22, smooth); route(a1, e24, 0.22, smooth);
+      route(a1, e26, 0.22, smooth); route(a1, e27, 0.22, smooth); route(a1, e29, 0.3, smooth);
+    }
+    seq {
+      show(b1.parts, 0.2);
+      route(b1, e1, 0.22, smooth); route(b1, e2, 0.22, smooth); route(b1, e3, 0.22, smooth);
+      route(b1, e4, 0.22, smooth); route(b1, e5, 0.22, smooth); route(b1, e8, 0.22, smooth);
+      route(b1, e9, 0.22, smooth); route(b1, e12, 0.22, smooth); route(b1, e13, 0.22, smooth);
+      route(b1, e15, 0.22, smooth); route(b1, e16, 0.22, smooth); route(b1, e19, 0.22, smooth);
+      route(b1, e20, 0.22, smooth);
+      route(b1, e22, 0.35, smooth);  // smoke ok? no → rollback
+      route(b1, e23, 0.8, smooth);   // rollback → start (around the perimeter)
+    }
+  }
+}
+wait(0.6);
+step("clear-1") {
+  par { fade(a1.parts, 0.3); fade(b1.parts, 0.3); to(cd.hotpaths, trace, 0, 0.4); }
+}
+wait(0.3);
+
+// Round 2 — another pair. They split at the unit-test gate: C carries on but is
+// held at approval, while D fails its tests and loops back to rebuild.
+step("round-2") {
+  par {
+    seq {
+      show(a2.parts, 0.2);
+      route(a2, e1, 0.22, smooth); route(a2, e2, 0.22, smooth); route(a2, e3, 0.22, smooth);
+      route(a2, e4, 0.22, smooth); route(a2, e5, 0.22, smooth); route(a2, e8, 0.22, smooth);
+      route(a2, e9, 0.22, smooth); route(a2, e12, 0.22, smooth); route(a2, e13, 0.22, smooth);
+      route(a2, e15, 0.22, smooth); route(a2, e16, 0.22, smooth); route(a2, e19, 0.22, smooth);
+      route(a2, e20, 0.22, smooth); route(a2, e21, 0.25, smooth);
+      route(a2, e25, 0.35, smooth);  // approve prod? no → held
+    }
+    seq {
+      show(b2.parts, 0.2);
+      route(b2, e1, 0.22, smooth); route(b2, e2, 0.22, smooth); route(b2, e3, 0.22, smooth);
+      route(b2, e4, 0.22, smooth); route(b2, e5, 0.22, smooth); route(b2, e8, 0.22, smooth);
+      route(b2, e10, 0.35, smooth);  // tests pass? no → debug
+      route(b2, e11, 0.6, smooth);   // debug → build (loop back)
+    }
+  }
+}
+wait(0.6);
+step("clear-2") {
+  par { fade(a2.parts, 0.3); fade(b2.parts, 0.3); to(cd.hotpaths, trace, 0, 0.4); }
+}
+wait(1.0);

package/examples/compound-pulley.manic

@@ -0,0 +1,25 @@
+// ============================================================================
+//  compound-pulley.manic  —  fixed + movable pulley, three masses (physics L1)
+// ----------------------------------------------------------------------------
+//  `compoundpulley(id, [center], [mA], [mB], [mC], [unit])` — a fixed top pulley
+//  carries mass A on one side and a MOVABLE lower pulley on the other; the movable
+//  pulley carries masses B and C. The string constraints link them: a_A = −a_P and
+//  a_B + a_C = 2·a_P (the massless movable pulley gives T₁ = 2·T₂). Static exactly
+//  when mA = mB + mC. PRE-SIMULATED with RK4; `run(id,[dur])` replays it.
+//
+//  TO ADAPT: set mA = mB + mC and it balances; make A heavier and it hauls B, C up.
+// ============================================================================
+
+title("Compound pulley — fixed + movable, masses A, B, C");
+canvas("16:9");
+
+text(hdr, (cx, 40), "Compound pulley — heavier A hauls B and C upward");
+size(hdr, 23); color(hdr, cyan); bold(hdr); display(hdr);
+
+compoundpulley(cp, (470, 120), 5, 2, 2);
+energygraph(cp, (1010, 330), 120);
+
+text(cap, (cx, h - 32), "A (5 kg) > B+C (4 kg): A sinks, the movable pulley rises, B and C are pulled up together");
+size(cap, 15); color(cap, dim); display(cap);
+
+run(cp, 4);

package/examples/conics.manic

@@ -0,0 +1,46 @@
+// The Conic Sections — the three curves you get by slicing a cone: the ellipse,
+// the parabola, and the hyperbola. Each is a geo-kit primitive; they reveal one
+// at a time with the defining property.
+//
+//   manic examples/conics.manic
+//   manic examples/conics.manic --template blueprint
+
+title("The Conic Sections");
+canvas("16:9");
+
+text(head, (cx, 80), "three curves from slicing a cone");
+display(head);  color(head, cyan);  size(head, 26);  hidden(head);
+text(cap, (cx, 662), "");  color(cap, dim);  size(cap, 23);
+
+// --- ellipse (left) ---
+ellipse(el, (300, 400), 165, 100);  color(el, cyan);  stroke(el, 3);  untraced(el);
+text(ell, (300, 250), "ellipse");   color(ell, cyan);  size(ell, 26);  hidden(ell);
+
+// --- parabola (centre) ---
+parabola(pa, (660, 540), 150, 270);  color(pa, lime);  stroke(pa, 3);  untraced(pa);
+text(pal, (660, 235), "parabola");   color(pal, lime);  size(pal, 26);  hidden(pal);
+
+// --- hyperbola (right) — two branches, tagged `hy` ---
+hyperbola(hy, (1010, 400), 55, 120);  color(hy, magenta);  stroke(hy, 3);  untraced(hy);
+text(hyl, (1010, 205), "hyperbola");  color(hyl, magenta);  size(hyl, 26);  hidden(hyl);
+
+// --- reveal ---
+show(head, 0.5);
+
+section("Ellipse");
+say(cap, "ellipse -- the sum of distances to two foci stays constant");
+draw(el, 0.9);
+show(ell, 0.4);
+wait(0.5);
+
+section("Parabola");
+say(cap, "parabola -- every point is equidistant from a focus and a line");
+draw(pa, 0.9);
+show(pal, 0.4);
+wait(0.5);
+
+section("Hyperbola");
+say(cap, "hyperbola -- two branches; the difference of distances stays constant");
+draw(hy, 0.9);
+show(hyl, 0.4);
+wait(1.4);

package/examples/coordinates.manic

@@ -0,0 +1,52 @@
+// Coordinate Systems — a guided tour of manic's four coordinate frames:
+// Axes (ticks + labels), NumberPlane, PolarPlane, and ComplexPlane. Each frame
+// fades in, holds, then clears before the next — one centre, four lenses.
+//
+//   manic examples/coordinates.manic
+//   manic examples/coordinates.manic --record out --fps 60
+
+title("Coordinate Systems");
+canvas(1280, 720);
+
+text(head, (640, 120), "four ways to draw a plane");
+display(head);  color(head, cyan);  size(head, 28);  hidden(head);
+text(cap, (640, 640), "");  color(cap, dim);  size(cap, 24);
+
+// --- the four systems, all centred; each starts hidden ---
+axes(ax, (640, 384), 540, 210, 45);          // + tick marks and integer labels
+plot(wave, (640, 384), 45, 45, sin, 7);       // y = sin(x) drawn on the axes
+color(wave, magenta);  untraced(wave);  hidden(ax);
+
+plane(pl, (640, 384), 560, 230, 56);   hidden(pl);
+polarplane(pp, (640, 384), 230, 5, 16);   hidden(pp);
+complexplane(cp, (640, 384), 560, 230, 56);   hidden(cp);
+
+// --- 1. Axes ---
+show(head, 0.5);
+section("Axes");
+say(cap, "a numbered cross — tick marks every unit");
+show(ax, 0.7);
+say(cap, "plot y = sin(x) on it");
+draw(wave, 1.1);
+wait(0.9);
+par { fade(ax, 0.4);  fade(wave, 0.4); }
+
+// --- 2. NumberPlane ---
+section("Number Plane");
+say(cap, "a full cartesian grid");
+show(pl, 0.7);
+wait(1.0);
+fade(pl, 0.4);
+
+// --- 3. PolarPlane ---
+section("Polar Plane");
+say(cap, "concentric rings and radial spokes — angle and radius");
+show(pp, 0.7);
+wait(1.0);
+fade(pp, 0.4);
+
+// --- 4. ComplexPlane ---
+section("Complex Plane");
+say(cap, "the same grid, read as real and imaginary parts");
+show(cp, 0.7);
+wait(1.4);

package/examples/correlation.manic

@@ -0,0 +1,35 @@
+// ============================================================================
+//  correlation.manic  —  how strongly two variables move together (stats T3)
+// ----------------------------------------------------------------------------
+//  `correlation(id, (cx,cy), unit, "x1 y1  x2 y2 …", [color])` scatters the
+//  points, fits the best line, and reports the **Pearson correlation r** with a
+//  strong/moderate/weak · positive/negative reading. `unit` = pixels per data
+//  unit (x and y share it, so use data with comparable ranges). Points
+//  `{id}.p{k}` (tagged `{id}.points`), the fit `{id}.line`, and `{id}.r`.
+//
+//  TO ADAPT: paste your paired data. r near ±1 = a tight line; near 0 = a blob.
+// ============================================================================
+
+title("Correlation: do they move together?");
+canvas("16:9");
+
+text(hdr, (cx, 70), "hours studied vs grade (out of 10)");
+size(hdr, 24); color(hdr, cyan); bold(hdr); display(hdr);
+
+correlation(co, (cx, cy - 10), 42,
+  "1 3  2 4  3 4  4 6  5 6  6 7  7 8  8 8  9 10  10 9");
+hidden(co.points); untraced(co.line); hidden(co.r);
+
+text(cap, (cx, h - 46), ""); size(cap, 22); color(cap, dim); display(cap);
+
+say(cap, "each dot is one student: hours studied, and the grade they got", 0.5);
+show(co.points, 0.6);
+wait(1.3);
+
+say(cap, "the cloud slopes up — more study tends to mean a higher grade", 0.5);
+draw(co.line, 0.9);
+wait(1.3);
+
+say(cap, "r measures how tightly the points track that line: near +1 is strong", 0.5);
+show(co.r, 0.4); pulse(co.r);
+wait(1.8);

package/examples/covariance.manic

@@ -0,0 +1,30 @@
+// ============================================================================
+//  covariance.manic  —  covariance as signed area (stats Tier 5)
+// ----------------------------------------------------------------------------
+//  `covariance(id, (cx,cy), unit, "x1 y1 x2 y2 …", [color])` — a cross at the
+//  means splits the plane into quadrants; each point draws a rectangle to the
+//  mean-corner, cyan where (x-x̄)(y-ȳ) > 0 (agreeing) and magenta where negative.
+//  Their signed-area balance IS the covariance. `{id}.points`, `{id}.rects`,
+//  `{id}.cross`, `{id}.cov`.
+// ============================================================================
+
+title("Covariance: signed area about the mean");
+canvas("16:9");
+
+covariance(cv, (cx, cy - 10), 34, "1 2  2 1  3 4  4 3  5 6  6 5  7 8  8 7  9 9");
+hidden(cv.points); hidden(cv.rects);
+untraced(cv.crossv); untraced(cv.crossh);
+hidden(cv.cov);
+
+text(cap, (cx, h - 46), ""); size(cap, 22); color(cap, dim); display(cap);
+
+say(cap, "mark each point, then draw the cross at the mean of x and the mean of y", 0.5);
+show(cv.points, 0.5);
+par { draw(cv.crossv, 0.5); draw(cv.crossh, 0.5); }
+wait(1.4);
+say(cap, "each point makes a rectangle to the centre — cyan if x and y agree", 0.5);
+to(cv.rects, opacity, 0.13, 0.7);
+wait(1.6);
+say(cap, "more agreeing (cyan) area than disagreeing = positive covariance", 0.5);
+show(cv.cov, 0.4);
+wait(1.9);

package/examples/creator-affine-fern-growth.manic

@@ -0,0 +1,72 @@
+// Existing-Manic treatment of fractales/fig0040.asy.
+// Problem: how can one stem become a fern? Solution: reuse one recursive rule.
+
+title("One Rule Grows a Fern");
+canvas("9:16");
+template("black");
+creator(me,"@anish2good name=Manic_Generative tagline=Rules_made_visible yt=zarigatongy x=@anish2good web=8gwifi.org/manic accent=cyan secondary=lime footer=compact cta=Grow_your_own safe=clean");
+socials(me);
+watermark(mark,(w*0.16,h*0.055),"Made With Manic");
+endcard(me,"title=Turn_Rules_Into_Stories cta=8gwifi.org/manic");
+
+let u=(w+h-abs(w-h))/1080;
+text(kicker,(cx,h*0.11),"MANIC · RECURSIVE GEOMETRY");
+text(head,(cx,h*0.17),"How can one stem grow a fern?");
+text(caption,(cx,h*0.79),"Start with one segment. At every tip, keep growing and add two leaves.");
+text(rule,(cx,h*0.72),"stem → stem + left leaf + right leaf");
+size(kicker,20*u); bold(kicker); color(kicker,cyan);
+size(head,27*u); bold(head); wrap(head,w*0.76);
+size(caption,20*u); bold(caption); wrap(caption,w*0.74); color(caption,dim);
+size(rule,21*u); bold(rule); wrap(rule,w*0.76); color(rule,gold);
+
+def fern(k,x,y,ang,len,depth) {
+  if depth > 0 && len > 3 {
+    let x2=x+len*cos(ang);
+    let y2=y-len*sin(ang);
+    line(stem{k},(x,y),(x2,y2));
+    stroke(stem{k},1+depth*0.34);
+    hue(stem{k},118+depth*7);
+    tag(stem{k},fernAll);
+    fern(3*k,x2,y2,ang+0.08,len*0.83,depth-1);
+    fern(3*k+1,x2,y2,ang+0.92,len*0.43,depth-2);
+    fern(3*k+2,x2,y2,ang-0.92,len*0.43,depth-2);
+  }
+}
+
+fern(1,cx,h*0.67,1.5708,112*u,9);
+untraced(fernAll); hidden(kicker); hidden(head); hidden(rule); hidden(caption);
+
+step("pose the problem") {
+  par { show(kicker,0.35); show(head,0.45); show(rule,0.45); show(caption,0.40); }
+}
+wait(0.85);
+step("grow the recursive solution") {
+  par {
+    draw(fernAll,3.2,smooth);
+    say(caption,"Each new segment is smaller and slightly turned, so the same rule creates organic detail.",0.45,smooth);
+  }
+}
+wait(0.95);
+step("read the repeated structure") {
+  par {
+    pulse(fernAll,0.90);
+    say(caption,"Zoom in anywhere: a branch resembles the whole fern because every generation reuses the same three choices.",0.60,smooth);
+  }
+}
+wait(1.0);
+step("connect rule to shape") {
+  say(rule,"shorter length + limited turning → a bounded self-similar fern",0.60,smooth);
+}
+wait(0.9);
+step("answer") {
+  par {
+    say(head,"One local rule creates the whole fern.",0.45,smooth);
+    say(caption,"Recursion supplies complexity; Manic keeps the story readable.",0.40,smooth);
+    pulse(fernAll,0.85);
+  }
+}
+wait(1.25);
+step("cta") {
+  par { fade(kicker,0.3); fade(head,0.3); fade(rule,0.3); fade(caption,0.3); fade(fernAll,0.45); fade(me.footer,0.3); show(me.endcard,0.6); }
+}
+wait(2.2);

package/examples/creator-bowl-to-saddle.manic

@@ -0,0 +1,86 @@
+// CREATOR SHORT — a real calculus problem told through one continuously
+// deforming surface. The shape is not replaced between the bowl, threshold,
+// and saddle states.
+
+title("When Does a Bowl Become a Saddle?");
+canvas("9:16");
+template("paper");
+
+creator(me, "@anish2good name=Manic_Math tagline=Equations_that_move yt=zarigatongy x=@anish2good web=8gwifi.org/manic accent=cyan secondary=magenta footer=signature cta=Create_your_own safe=reels");
+socials(me);
+watermark(mark, (w*0.955-100, h*0.045+24), "Made With Manic");
+
+text(kicker, (540, 164), "A 20-SECOND CALCULUS STORY");
+text(headline, (540, 226), "When does a bowl stop being a bowl?");
+text(problem, (540, 292), "Find the exact value of p where one curvature disappears.");
+size(kicker, 21); bold(kicker); color(kicker, cyan); hidden(kicker);
+size(headline, 38); bold(headline); wrap(headline, 880); hidden(headline);
+size(problem, 22); color(problem, dim); wrap(problem, 840); hidden(problem);
+
+equation(rule, (540, 378), `z=0.22x^2+0.22(1-2p)y^2`, 39);
+hidden(rule);
+
+parameter(mix, (540, 1270), 0, 0, 1, "p", 2);
+
+camera3((8.5, -11.5, 7.5), (0, 0, 0), 41);
+surface3(world, "0.22*(x*x+y*y)", (-3,3), (-3,3), 34);
+bind(mix, world, formula, "0.22*x*x + 0.22*(1-2*p)*y*y");
+color(world, cyan);
+finish3(world, "material=glass shading=smooth mesh=0.34 depth=0.34 shadow=0.16");
+hidden(world);
+
+text(chapter, (540, 1352), "p = 0 · positive curvature in both directions");
+text(insight, (540, 1422), "Watch the coefficient of y².");
+text(cta, (540, 1398), "Build the transformation, not the keyframes.");
+text(link, (540, 1452), "TRY MANIC → 8gwifi.org/manic");
+size(chapter, 23); bold(chapter); color(chapter, fg); wrap(chapter, 850); hidden(chapter);
+size(insight, 21); color(insight, dim); hidden(insight);
+size(cta, 23); bold(cta); hidden(cta);
+size(link, 20); bold(link); color(link, cyan); hidden(link);
+
+step("pose the problem") {
+  par {
+    show(kicker, 0.35);
+    show(headline, 0.50);
+    show(problem, 0.45);
+    show(rule, 0.55);
+    show(world, 0.65);
+    show(chapter, 0.40);
+    show(insight, 0.40);
+    view3(world, "isometric", 0.9, smooth, 1.62);
+  }
+}
+wait(0.65);
+
+step("reach the turning point") {
+  par {
+    to(mix, value, 0.5, 2.8, smooth);
+    say(chapter, "p = ½ · the y² coefficient becomes zero", 0.45);
+    say(insight, "At this instant the bowl becomes a one-directional trough.", 0.45);
+    rewrite(rule, `p=\frac12\quad\Longrightarrow\quad z=0.22x^2`, 1.10, smooth);
+    orbit3(-45, 28, 16.2, 2.8, smooth);
+  }
+}
+wait(0.75);
+
+step("cross into a saddle") {
+  par {
+    to(mix, value, 1, 2.8, smooth);
+    say(chapter, "p > ½ · one curvature turns negative", 0.45);
+    say(insight, "The same persistent surface is now a saddle.", 0.45);
+    rewrite(rule, `p=1\quad\Longrightarrow\quad z=0.22(x^2-y^2)`, 1.10, smooth);
+    orbit3(-62, 25, 16.2, 2.8, smooth);
+  }
+}
+wait(0.65);
+
+step("answer and invite") {
+  par {
+    say(problem, "Answer: p = ½ is the exact transition.", 0.50);
+    fade(chapter, 0.35);
+    fade(insight, 0.35);
+    show(cta, 0.45);
+    show(link, 0.45);
+  }
+}
+wait(1.8);

package/examples/creator-branch-counting-tree3.manic

@@ -0,0 +1,77 @@
+// Existing-Manic treatment of animations/fig0140.asy.
+// `tree3` replaces a general 3D grammar with one meaningful creator question.
+
+title("Counting a Fractal Tree");
+canvas("9:16");
+template("black");
+creator(me,"@anish2good name=Manic_Generative tagline=Growth_made_visible yt=zarigatongy x=@anish2good web=8gwifi.org/manic accent=lime secondary=cyan footer=compact cta=Grow_the_rule safe=clean");
+socials(me);
+watermark(mark,(w*0.16,h*0.055),"Made With Manic");
+endcard(me,"title=Animate_Recursive_Growth cta=8gwifi.org/manic");
+
+let u=(w+h-abs(w-h))/1080;
+text(kicker,(cx,h*0.10),"BINARY GROWTH · DEPTH 10");
+text(head,(cx,h*0.17),"How many branches will appear?");
+text(caption,(cx,h*0.80),"Every branch creates two children. Count generations, not individual lines.");
+equation(eq,(cx,h*0.73),`1+2+4+\cdots+2^9=2^{10}-1`,31*u);
+size(kicker,20*u); bold(kicker); color(kicker,lime);
+size(head,27*u); bold(head); wrap(head,w*0.76);
+size(caption,19*u); bold(caption); wrap(caption,w*0.72); color(caption,dim);
+
+tree3(tree,(0,0,-3.0),2.0,27,0.72,10,42);
+for i in 0..10 {
+  color(tree.d{i},lime);
+  untraced(tree.d{i});
+  hidden(tree.d{i});
+}
+color(tree.leaves,cyan); hidden(tree.leaves);
+camera3((9,9,6),(0,0,1.4),42,perspective);
+hidden(kicker); hidden(head); hidden(caption); hidden(eq);
+
+step("pose") {
+  par {
+    show(kicker,0.3); show(head,0.45); show(caption,0.35);
+    view3(tree,"isometric",0.75,smooth,1.45);
+  }
+}
+wait(0.85);
+step("grow generation by generation") {
+  par {
+    stagger(0.16) {
+      for i in 0..10 {
+        par { show(tree.d{i},0.12); draw(tree.d{i},0.52,smooth); }
+      }
+    }
+    seq {
+      wait(0.55);
+      orbit3(60,24,17,2.8,smooth);
+    }
+    say(caption,"Each generation appears from the previous one: split, turn, shrink.",0.40);
+  }
+}
+wait(0.95);
+step("show the canopy and sum") {
+  par {
+    show(tree.leaves,0.55);
+    show(eq,0.5);
+    say(caption,"Now count generations with one geometric series.",0.4);
+  }
+}
+wait(0.9);
+step("read the recurrence") {
+  par {
+    pulse(tree,0.90);
+    say(caption,"Generation k contains 2ᵏ branches; adding generations 0 through 9 produces a geometric sum.",0.65,smooth);
+  }
+}
+wait(1.0);
+step("solve") { par { rewrite(eq,`\boxed{1023\text{ branches}}`,0.8,smooth); pulse(tree.leaves,0.85); say(head,"Depth 10 produces 1,023 branches.",0.45,smooth); } }
+wait(1.25);
+step("cta") {
+  par {
+    fade(kicker,0.3); fade(head,0.3); fade(caption,0.3); fade(eq,0.3);
+    for i in 0..10 { fade(tree.d{i},0.40); }
+    fade(tree.leaves,0.40); fade(me.footer,0.3); show(me.endcard,0.6);
+  }
+}
+wait(2.2);