@maniclang/workbench 0.1.11

package/examples/derivative-of-ln-x.manic

@@ -0,0 +1,194 @@
+// ============================================================================
+// derivative-of-ln-x.manic — inverse-function derivatives on a turning plane
+// ----------------------------------------------------------------------------
+// The curve is first read as y=e^x. A true 3-D camera turn exchanges the screen
+// roles of world x/y, so the same relationship reads x=e^y. While the graph is
+// hidden for the first plane turn, morph3 exchanges its coordinates; the same
+// geometry can then remain visible through the return turn into y=ln(x).
+// ============================================================================
+
+title("Why the derivative of ln x is 1/x");
+canvas("16:9");
+template("plain");
+// Landscape proof: the upper-right stays clear while the algebra owns the
+// bottom and the vertical axis label owns the top-centre.
+watermark(manicMark, (1135, 30), "Made With Manic");
+
+// Orthographic overhead camera: the continuous pole-safe orbit frame keeps the
+// whole turn smooth, and roll3 controls which world direction is screen-up.
+camera3((0, 0.5, 12), (0, 0.5, 0), 8.5, orthographic);
+
+// ---------------------------------------------------------------------------
+// ONE WORLD PLANE · axes, grid, exponential, tangent and exact slope triangle
+// ---------------------------------------------------------------------------
+
+grid3(grid, (0, 0, 0), 4, 1);
+color(grid, dim); opacity(grid, 0.30); tag(grid, world);
+
+arrow3(xaxis, (-4.05, 0, 0), (4.05, 0, 0));
+arrow3(yaxis, (0, -3.4, 0), (0, 4.05, 0));
+color(xaxis, fg); color(yaxis, fg); thick(xaxis, 0.012); thick(yaxis, 0.012);
+tag(xaxis, world); tag(yaxis, world);
+
+for i in -4..5 {
+  if i != 0 {
+    line3(xtick{i}, (i, -0.07, 0), (i, 0.07, 0));
+    line3(ytick{i}, (-0.07, i, 0), (0.07, i, 0));
+    color(xtick{i}, dim); color(ytick{i}, dim);
+    tag(xtick{i}, world); tag(ytick{i}, world);
+  }
+}
+
+equation(xlab, (0,0), `x`, 31); pin3(xlab, (4.10, -0.18, 0)); tag(xlab, world);
+equation(ylab, (0,0), `y`, 31); pin3(ylab, (-0.18, 4.10, 0)); tag(ylab, world);
+hidden(world);
+
+// Source curve γ(t)=(t,e^t), and its inverse parameterisation γ⁻¹(t)=(e^t,t).
+curve3(curve, "t", "exp(t)", "0", (-3.6, 1.42));
+curve3(curveTarget, "exp(t)", "t", "0", (-3.6, 1.42));
+color(curve, lime); color(curveTarget, lime); thick(curve, 0.024); thick(curveTarget, 0.024);
+untraced(curve); hidden(curveTarget); morph3(curve, curveTarget);
+
+equation(expName, (0,0), `y=e^x`, 31); color(expName, lime); pin3(expName, (-1.45, 2.20, 0)); hidden(expName);
+equation(swappedName, (0,0), `x=e^y`, 31); color(swappedName, lime); pin3(swappedName, (2.65, -1.20, 0)); hidden(swappedName);
+equation(logName, (0,0), `y=\ln(x)`, 31); color(logName, lime); pin3(logName, (2.65, 0.90, 0)); hidden(logName);
+
+// At t=0.6: P=(0.6,e^0.6), and e^0.6 ≈ 1.822. The tangent reaches y=0
+// exactly one unit of run before P, so its slope triangle is rise/run = y/1.
+curve3(tangent, "-0.65+2*t", "-0.455529+3.644238*t", "0", (0,1));
+curve3(tangentTarget, "-0.455529+3.644238*t", "-0.65+2*t", "0", (0,1));
+color(tangent, magenta); color(tangentTarget, magenta); thick(tangent, 0.018); thick(tangentTarget, 0.018);
+untraced(tangent); hidden(tangentTarget); morph3(tangent, tangentTarget);
+
+curve3(runSide, "-0.4+t", "0", "0", (0,1));
+curve3(runTarget, "0", "-0.4+t", "0", (0,1));
+color(runSide, gold); color(runTarget, gold); thick(runSide, 0.024); thick(runTarget, 0.024);
+untraced(runSide); hidden(runTarget); morph3(runSide, runTarget);
+
+curve3(riseSide, "0.6", "1.822119*t", "0", (0,1));
+curve3(riseTarget, "1.822119*t", "0.6", "0", (0,1));
+color(riseSide, cyan); color(riseTarget, cyan); thick(riseSide, 0.024); thick(riseTarget, 0.024);
+untraced(riseSide); hidden(riseTarget); morph3(riseSide, riseTarget);
+
+point3(contact, (0.6, 1.822119, 0), 0.075); color(contact, fg); hidden(contact);
+point3(contactTarget, (1.822119, 0.6, 0), 0.075); color(contactTarget, fg); hidden(contactTarget);
+
+equation(riseY, (0,0), `y`, 28); color(riseY, cyan); pin3(riseY, (0.82, 0.91, 0)); hidden(riseY);
+equation(runOne, (0,0), `1`, 28); color(runOne, gold); pin3(runOne, (0.10, -0.22, 0)); hidden(runOne);
+equation(targetX, (0,0), `x`, 28); color(targetX, cyan); pin3(targetX, (0.91, 0.82, 0)); hidden(targetX);
+equation(targetOne, (0,0), `1`, 28); color(targetOne, gold); pin3(targetOne, (-0.22, 0.10, 0)); hidden(targetOne);
+
+// The diagonal is the hinge / mirror relation during the plane turns.
+for i in -9..10 {
+  line3(diag{i}, (i*0.42, i*0.42, 0.02), (i*0.42+0.24, i*0.42+0.24, 0.02));
+  color(diag{i}, magenta); thick(diag{i}, 0.018); untraced(diag{i}); tag(diag{i}, mirror);
+}
+equation(diagName, (0,0), `y=x`, 27); color(diagName, magenta); pin3(diagName, (2.55, 2.55, 0.02)); hidden(diagName);
+
+// Screen-space algebra. Separate equations keep the camera/geometry generic.
+equation(slopeExp, (cx, 655), `\textcolor{magenta}{\mathrm{slope}}=\textcolor{cyan}{e^x}`, 40); hidden(slopeExp);
+equation(slopeY, (cx, 655), `\textcolor{magenta}{\mathrm{slope}}=\textcolor{cyan}{y}`, 40); hidden(slopeY);
+equation(slopeFracY, (cx, 655), `\textcolor{magenta}{\mathrm{slope}}=\frac{\textcolor{cyan}{y}}{\textcolor{gold}{1}}=\frac{\textcolor{cyan}{\mathrm{rise}}}{\textcolor{gold}{\mathrm{run}}}`, 40); hidden(slopeFracY);
+// Persistent algebra pieces. The unchanged prefix/equality never disappear:
+// only the term being justified moves, fades, or arrives. This is the same
+// object-continuity principle used by matching-transform systems, expressed
+// with ordinary Manic entities rather than replacing a whole equation image.
+equation(slopeWord, (500, 655), `\textcolor{magenta}{\mathrm{slope}}`, 40); hidden(slopeWord); tag(slopeWord, inverseAlgebra);
+equation(mainEquals, (575, 655), `=`, 40); hidden(mainEquals); tag(mainEquals, inverseAlgebra);
+equation(heightTerm, (630, 655), `\textcolor{cyan}{\mathrm{height}}`, 40); hidden(heightTerm); tag(heightTerm, inverseAlgebra);
+equation(xTerm, (630, 655), `\textcolor{cyan}{x}`, 40); hidden(xTerm); tag(xTerm, inverseAlgebra);
+equation(oneTerm, (630, 674), `\textcolor{gold}{1}`, 36); hidden(oneTerm); tag(oneTerm, inverseAlgebra);
+line(termBar, (616, 657), (644, 657)); color(termBar, fg); stroke(termBar, 2); untraced(termBar); tag(termBar, inverseAlgebra);
+equation(ratioEquals, (685, 655), `=`, 40); hidden(ratioEquals); tag(ratioEquals, inverseAlgebra);
+equation(ratioTerm, (780, 655), `\frac{\textcolor{cyan}{\mathrm{rise}}}{\textcolor{gold}{\mathrm{run}}}`, 40); hidden(ratioTerm); tag(ratioTerm, inverseAlgebra);
+equation(derivativeTerm, (475, 655), `\frac{d}{dx}\ln(x)`, 41); hidden(derivativeTerm); tag(derivativeTerm, inverseAlgebra);
+
+// Split glyphs let generic `cycle` retain their identity through xy → yx.
+equation(planeX, (550, 640), `x`, 54); hidden(planeX); tag(planeX, planeLabel);
+equation(planeY, (575, 640), `y`, 54); hidden(planeY); tag(planeY, planeLabel);
+equation(planeWord, (685, 640), `\mathrm{plane}`, 54); hidden(planeWord); tag(planeWord, planeLabel);
+
+// ---------------------------------------------------------------------------
+// TIMELINE · 75.49 seconds including manic's final one-second tail
+// ---------------------------------------------------------------------------
+
+show(world, 1.20);
+draw(curve, 2.40);
+show(expName, 0.60);
+wait(2.50);
+
+show(slopeExp, 0.70);
+wait(2.20);
+par { draw(riseSide, 1.20); show(riseY, 0.45); show(contact, 0.30); }
+par { fade(slopeExp, 0.55); show(slopeY, 0.55); }
+wait(2.00);
+
+par { draw(tangent, 1.20); draw(runSide, 1.00); show(runOne, 0.40); }
+par { fade(slopeY, 0.60); show(slopeFracY, 0.60); }
+wait(7.90);
+
+// First turn: remove the measurement clutter, reveal the mirror hinge, and
+// move from the top of the plane to its underside. Below + -90° roll makes
+// screen-horizontal follow world y and screen-vertical follow world x.
+par {
+  fade(curve, 0.70); fade(expName, 0.70); fade(tangent, 0.70);
+  fade(runSide, 0.70); fade(riseSide, 0.70); fade(contact, 0.70);
+  fade(riseY, 0.70); fade(runOne, 0.70); fade(slopeFracY, 0.70);
+}
+par { draw(mirror, 0.70); show(diagName, 0.50); show(planeLabel, 0.50); }
+par {
+  orbit3(-90, -90, 12, 7.00, smooth);
+  roll3(90, 7.00, smooth);
+  // The graph is hidden here, so exchange its coordinates before it returns.
+  to(curve, morph, 1, 7.00, smooth);
+  to(tangent, morph, 1, 7.00, smooth);
+  to(runSide, morph, 1, 7.00, smooth);
+  to(riseSide, morph, 1, 7.00, smooth);
+  seq { wait(2.80); cycle(planeX, planeY, 1.40, 70, smooth); }
+}
+
+// Same world geometry, now read with exchanged screen axes.
+par {
+  show(curve, 0.70); show(tangent, 0.70); show(runSide, 0.70); show(riseSide, 0.70);
+  show(contactTarget, 0.50); show(swappedName, 0.55); show(targetX, 0.45); show(targetOne, 0.45);
+  fade(diagName, 0.45); erase(mirror, 0.70); fade(planeLabel, 0.45);
+}
+par { show(slopeWord, 0.65); show(mainEquals, 0.65); show(heightTerm, 0.65); }
+wait(3.00);
+par { fade(heightTerm, 0.60); show(xTerm, 0.60); }
+wait(3.00);
+par { show(ratioEquals, 0.60); show(ratioTerm, 0.60); }
+wait(3.00);
+// x becomes x/1 in place: x lifts, the denominator arrives, and the rest of
+// the displayed identity remains untouched.
+par { move(xTerm, (630, 640), 0.60, smooth); show(oneTerm, 0.60); draw(termBar, 0.60); }
+wait(6.20);
+
+// Second turn: return the camera overhead while keeping the transformed curve
+// and triangle visible. The same objects land as an ordinary y=ln(x) graph.
+par {
+  draw(mirror, 0.60); show(diagName, 0.45); show(planeLabel, 0.45);
+  fade(slopeWord, 0.60); fade(mainEquals, 0.60); fade(xTerm, 0.60);
+  fade(oneTerm, 0.60); erase(termBar, 0.60); fade(ratioEquals, 0.60); fade(ratioTerm, 0.60);
+}
+par {
+  orbit3(-90, 90, 12, 7.00, smooth);
+  roll3(0, 7.00, smooth);
+  fade(swappedName, 3.00); show(logName, 3.00);
+  // Prepare the next algebra state invisibly while the plane is turning.
+  move(ratioTerm, (630, 655), 1.20, smooth);
+  move(oneTerm, (630, 640), 1.20, smooth);
+  move(xTerm, (630, 674), 1.20, smooth);
+  seq { wait(2.80); cycle(planeX, planeY, 1.40, -70, smooth); }
+}
+par {
+  fade(planeLabel, 0.45); fade(diagName, 0.45); erase(mirror, 0.70);
+  show(slopeWord, 0.65); show(mainEquals, 0.65); show(ratioTerm, 0.65);
+}
+wait(2.20);
+// Only the right-hand term changes: rise/run becomes 1/x.
+par { fade(ratioTerm, 0.60); show(oneTerm, 0.60); show(xTerm, 0.60); draw(termBar, 0.60); }
+wait(3.00);
+// The proven reciprocal stays; only the name on the left becomes d/dx ln(x).
+par { fade(slopeWord, 0.70); show(derivativeTerm, 0.70); pulse(curve, 0.70); }
+wait(9.89);

package/examples/diagonalise.manic

@@ -0,0 +1,56 @@
+// ============================================================================
+//  diagonalise.manic  —  A = P D P^-1 made visual (a template)
+// ----------------------------------------------------------------------------
+//  The big idea of diagonalisation: every (real-diagonalisable) matrix has a
+//  basis — its EIGENVECTORS — in which it does nothing but STRETCH each axis.
+//  No rotation, no shear: just a diagonal scaling D = diag(lambda1, lambda2).
+//
+//  `diagonalise(id, (cx,cy), unit, a,b,c,d, [color])` draws, for [[a,b],[c,d]]:
+//    * the (generally skewed) eigen-grid   — the coordinate frame of the eigenbasis
+//    * the two eigen-axes  dg.axis1 / dg.axis2
+//    * the unit eigen-cell dg.cell  and its image under A  dg.img
+//    * the eigenvector images as arrows dg.v1 / dg.v2  (+ labels dg.v1l / dg.v2l)
+//  Complex or repeated eigenvalues (no real 2-D eigenbasis) leave a note instead.
+//
+//  TO ADAPT: change the four matrix numbers below. Try a non-symmetric matrix
+//  like (2,1,0,3) to see a SKEWED eigenbasis, or (0,-1,1,0) to see the
+//  "no real eigenbasis" note (a pure rotation).
+// ============================================================================
+
+title("Diagonalisation: a matrix in its own basis");
+canvas("16:9");
+
+let ox = cx - 40;
+let oy = cy + 20;
+
+text(hdr, (cx, 54), "A = P D P^-1  —  in the eigenbasis, A is only a stretch");
+size(hdr, 24); color(hdr, cyan); bold(hdr); display(hdr);
+
+// the matrix [[2,1],[1,2]] — eigenvalues 3 (along (1,1)) and 1 (along (1,-1))
+diagonalise(dg, (ox, oy), 60, 2, 1, 1, 2);
+
+// the faint eigen-grid stays as static context; reveal the rest in beats:
+untraced(dg.axis1); untraced(dg.axis2);   // eigen-axes draw in
+hidden(dg.cell); hidden(dg.img);          // unit cell fades in; image fades to 0.4
+untraced(dg.v1); untraced(dg.v2);         // eigenvector arrows draw in
+hidden(dg.v1l); hidden(dg.v2l);           // lambda labels fade in
+
+text(cap, (cx, h - 50), ""); size(cap, 22); color(cap, dim); display(cap);
+
+// ---- timeline ----
+say(cap, "every matrix has special directions — its eigenvectors", 0.5);
+par { draw(dg.axis1, 0.7); draw(dg.axis2, 0.7); }
+wait(1.2);
+
+say(cap, "build the unit cell from those two directions", 0.5);
+show(dg.cell, 0.6);
+wait(1.4);
+
+say(cap, "apply A: the cell only STRETCHES along each axis — never rotates", 0.5);
+to(dg.img, opacity, 0.4, 0.8);
+par { draw(dg.v1, 0.7); draw(dg.v2, 0.7); }
+wait(1.2);
+
+say(cap, "the stretch factors ARE the eigenvalues — the diagonal of D", 0.5);
+show(dg.v1l, 0.4); show(dg.v2l, 0.4);
+wait(1.6);

package/examples/dijkstra.manic

@@ -0,0 +1,29 @@
+// Dijkstra — single-source shortest paths on a WEIGHTED graph. Give edges a
+// weight with `a-b:w` (drawn as a midpoint label). `dijkstra(g, start)` reads the
+// weights, then runs the classic loop: repeatedly settle the nearest unsettled
+// node (magenta -> lime), relaxing its edges and lowering neighbours' distances.
+// Each node shows its best-known distance (inf -> the final shortest distance),
+// and the shortest-path-tree edges stay lit at the end.
+//
+//   manic examples/dijkstra.manic
+
+title("Dijkstra");
+canvas("16:9");
+
+text(head, (cx, 58), "shortest paths: settle the nearest node, relax its edges");
+display(head);  color(head, cyan);  size(head, 25);  hidden(head);
+text(cap, (cx, 690), "");  color(cap, dim);  size(cap, 24);
+
+graph(g, "a b c d e f",
+      "a-b:2 a-c:5 b-c:1 b-d:4 c-e:3 d-e:1 d-f:2 e-f:6",
+      circular, (cx, 350), 210, 30);
+
+show(head, 0.5);
+say(cap, "each node shows its best distance: start 0, the rest inf");
+wait(0.7);
+
+section("Relax");
+say(cap, "settle the nearest node, then relax every edge leaving it");
+dijkstra(g, a);
+say(cap, "settled distances are final; the lime edges form the shortest-path tree");
+wait(1.4);

package/examples/dimensions-unfold.manic

@@ -0,0 +1,211 @@
+// ============================================================================
+// dimensions-unfold.manic — how a point becomes a line, a plane, then a room
+// ----------------------------------------------------------------------------
+// The geometry never cuts to a replacement scene. One point grows two halves
+// of a wire; that same wire sweeps across y while a grid resolves behind it;
+// the completed sheet then lifts as one tagged roof while a transparent room
+// appears below. The animation is the explanation.
+// ============================================================================
+
+title("How Space Learned to Grow — 1D to 3D");
+canvas("9:16");
+template("neon");
+watermark(manicMark, (238, 108), "Made With Manic");
+
+creator(me, "@anish2good name=Manic_3D tagline=Dimensions_in_motion yt=zarigatongy x=@anish2good web=8gwifi.org/manic accent=cyan secondary=magenta footer=social safe=reels");
+socials(me);
+
+text(kicker, (540, 164), "FROM A POINT TO A WORLD");
+size(kicker, 21); bold(kicker); color(kicker, cyan); hidden(kicker);
+text(headline, (540, 228), "How space learned to grow");
+size(headline, 42); bold(headline); color(headline, fg); hidden(headline);
+text(phase, (540, 300), "PROLOGUE · THE FIRST POINT");
+size(phase, 23); bold(phase); color(phase, gold); hidden(phase);
+
+text(narration, (540, 1330), "In the beginning, there was only one location.");
+size(narration, 27); bold(narration); color(narration, fg); wrap(narration, 860); hidden(narration);
+text(principle, (540, 1390), "No direction. No distance. Just here.");
+size(principle, 20); color(principle, dim); hidden(principle);
+text(progress, (540, 1492), "POINT");
+size(progress, 27); bold(progress); color(progress, cyan); hidden(progress);
+text(takeaway, (540, 1554), "DIMENSIONS ARE MOTIONS THAT LEAVE SPACE BEHIND");
+size(takeaway, 17); bold(takeaway); color(takeaway, gold); hidden(takeaway);
+
+// ---------------------------------------------------------------------------
+// 0D → 1D: one point extends left and right.
+// ---------------------------------------------------------------------------
+
+camera3((0, -11, 4.5), (0, -4, 0), 39);
+
+point3(seed, (0,-4,0), 0.12); color(seed, gold); hidden(seed);
+finish3(seed, "material=glass shading=smooth depth=0.40 shadow=0.25");
+
+line3(leftThread, (0,-4,0), (-0.02,-4,0)); color(leftThread, cyan); thick(leftThread, 0.065); hidden(leftThread); tag(leftThread, wire); tag(leftThread, sheetSkin);
+line3(rightThread, (0,-4,0), (0.02,-4,0)); color(rightThread, cyan); thick(rightThread, 0.065); hidden(rightThread); tag(rightThread, wire); tag(rightThread, sheetSkin);
+
+point3(leftEnd, (-4,-4,0), 0.14); color(leftEnd, fg); hidden(leftEnd);
+point3(rightEnd, (4,-4,0), 0.14); color(rightEnd, fg); hidden(rightEnd);
+point3(leftLabelAnchor, (-3.25,-4,0.58), 0.01); hidden(leftLabelAnchor);
+point3(rightLabelAnchor, (3.25,-4,0.58), 0.01); hidden(rightLabelAnchor);
+text(leftLabel, (0,0), "BACKWARD"); size(leftLabel, 19); bold(leftLabel); color(leftLabel, dim); hidden(leftLabel); pin3(leftLabel, leftLabelAnchor);
+text(rightLabel, (0,0), "FORWARD"); size(rightLabel, 19); bold(rightLabel); color(rightLabel, dim); hidden(rightLabel); pin3(rightLabel, rightLabelAnchor);
+
+arrow3(leftChoice, (0,-4,0.18), (-3.5,-4,0.18)); color(leftChoice, magenta); thick(leftChoice, 0.035); untraced(leftChoice); hidden(leftChoice);
+arrow3(rightChoice, (0,-4,0.18), (3.5,-4,0.18)); color(rightChoice, magenta); thick(rightChoice, 0.035); untraced(rightChoice); hidden(rightChoice);
+
+// ---------------------------------------------------------------------------
+// 2D: the wire sweeps from y=-4 to y=4 and leaves a sheet/grid behind.
+// Every visible grid member joins sheetSkin so the whole plane can later rise.
+// ---------------------------------------------------------------------------
+
+line3(baseEdge, (-4,-4,0), (4,-4,0)); color(baseEdge, cyan); thick(baseEdge, 0.050); hidden(baseEdge); tag(baseEdge, sheetSkin);
+cube3(sheet, (0,0,0), (8,8,0.08)); color(sheet, blue); hidden(sheet); tag(sheet, sheetSkin);
+finish3(sheet, "material=glass shading=flat mesh=0.18 depth=0.24 shadow=0.10");
+
+for i in 1..8 {
+  let p = -4+i;
+  line3(row{i}, (-4,p,0.05), (4,p,0.05));
+  color(row{i}, magenta); thick(row{i}, 0.022); untraced(row{i}); hidden(row{i}); tag(row{i}, sheetGrid); tag(row{i}, sheetSkin);
+  line3(col{i}, (p,-4,0.05), (p,4,0.05));
+  color(col{i}, cyan); thick(col{i}, 0.022); untraced(col{i}); hidden(col{i}); tag(col{i}, sheetGrid); tag(col{i}, sheetSkin);
+}
+
+// ---------------------------------------------------------------------------
+// 3D: the complete sheet becomes the roof. Four pillars and a restrained glass
+// volume make the hollow space below legible without a replacement cut.
+// ---------------------------------------------------------------------------
+
+cube3(room, (0,0,4), (8,8,8)); color(room, blue); hidden(room);
+finish3(room, "material=glass shading=flat mesh=0.42 depth=0.34 shadow=0.16");
+
+line3(pillar0, (-4,-4,0), (-4,-4,8)); color(pillar0, lime); thick(pillar0, 0.060); untraced(pillar0); hidden(pillar0); tag(pillar0, pillars);
+line3(pillar1, (4,-4,0), (4,-4,8)); color(pillar1, lime); thick(pillar1, 0.060); untraced(pillar1); hidden(pillar1); tag(pillar1, pillars);
+line3(pillar2, (-4,4,0), (-4,4,8)); color(pillar2, lime); thick(pillar2, 0.060); untraced(pillar2); hidden(pillar2); tag(pillar2, pillars);
+line3(pillar3, (4,4,0), (4,4,8)); color(pillar3, lime); thick(pillar3, 0.060); untraced(pillar3); hidden(pillar3); tag(pillar3, pillars);
+
+point3(nearCorner, (-4,-4,0), 0.18); color(nearCorner, gold); hidden(nearCorner);
+point3(farCorner, (4,4,8), 0.18); color(farCorner, gold); hidden(farCorner);
+text(nearLabel, (0,0), "NEAR · BOTTOM · LEFT"); size(nearLabel, 18); color(nearLabel, fg); hidden(nearLabel); pin3(nearLabel, nearCorner);
+text(farLabel, (0,0), "FAR · TOP · RIGHT"); size(farLabel, 18); color(farLabel, fg); hidden(farLabel); pin3(farLabel, farCorner);
+
+// ---------------------------------------------------------------------------
+// ONE CONTINUOUS TIMELINE
+// ---------------------------------------------------------------------------
+
+step("the first point") {
+  seq {
+    par {
+      show(kicker, 0.35);
+      show(headline, 0.55);
+      show(phase, 0.40);
+      show(narration, 0.45);
+      show(principle, 0.45);
+      show(progress, 0.40);
+      show(seed, 0.45);
+    }
+    pulse(seed, 0.80);
+    wait(0.65);
+  }
+}
+
+step("the point extends") {
+  seq {
+    par {
+      say(phase, "1D · THE FIRST THREAD", 0.45, smooth);
+      say(narration, "The point stretches itself out and creates the first path.", 0.55, smooth);
+      say(principle, "Length appears — but the world is still trapped on one track.", 0.50, smooth);
+      say(progress, "POINT  →  LENGTH", 0.45, smooth);
+      show(leftThread, 0.15);
+      show(rightThread, 0.15);
+      grow3(leftThread, (-4,-4,0), 2.25, smooth);
+      grow3(rightThread, (4,-4,0), 2.25, smooth);
+      view3(wire, "front", 1.45, smooth, 1.70);
+    }
+    par {
+      fade(seed, 0.35);
+      show(leftEnd, 0.30); show(rightEnd, 0.30);
+      show(leftLabel, 0.35); show(rightLabel, 0.35);
+      show(leftChoice, 0.15); show(rightChoice, 0.15);
+      draw(leftChoice, 0.90, smooth); draw(rightChoice, 0.90, smooth);
+    }
+    wait(0.60);
+  }
+}
+
+step("left or right") {
+  seq {
+    say(narration, "Every journey has only two choices: backward or forward.", 0.50, smooth);
+    par { pulse(leftThread, 0.65); pulse(rightThread, 0.65); }
+    wait(0.80);
+  }
+}
+
+step("the sideways sweep") {
+  seq {
+    par {
+      fade(leftChoice, 0.35); fade(rightChoice, 0.35);
+      fade(leftLabel, 0.35); fade(rightLabel, 0.35);
+      say(phase, "2D · THE UNFOLDING SHEET", 0.45, smooth);
+      say(narration, "The wire shimmers, grabs its whole length, and moves sideways.", 0.55, smooth);
+      say(principle, "Its motion leaves a flat floor behind: width is born.", 0.50, smooth);
+      say(progress, "POINT  →  LENGTH  →  WIDTH", 0.45, smooth);
+    }
+    par {
+      show(baseEdge, 0.18);
+      shift3(wire, (0,8,0), 2.80, smooth);
+      to(sheet, opacity, 0.14, 2.80, smooth);
+      view3(sheet, "isometric", 2.10, smooth, 1.52);
+      stagger(0.075) { for i in 1..8 { show(row{i}, 0.12); show(col{i}, 0.12); } }
+      stagger(0.075) { for i in 1..8 { draw(row{i}, 0.70, smooth); draw(col{i}, 0.70, smooth); } }
+    }
+    wait(0.65);
+  }
+}
+
+step("the flat world") {
+  seq {
+    say(narration, "The old wire is now one edge of an entire plane.", 0.50, smooth);
+    say(principle, "Forward, backward, left, and right — still no above.", 0.45, smooth);
+    pulse(sheetGrid, 0.75);
+    wait(0.80);
+  }
+}
+
+step("the rising room") {
+  seq {
+    par {
+      say(phase, "3D · THE RISING ROOM", 0.45, smooth);
+      say(narration, "The complete sheet catches a breath and lifts straight upward.", 0.55, smooth);
+      say(principle, "The moving surface fills the hollow space below it.", 0.50, smooth);
+      say(progress, "POINT  →  LENGTH  →  WIDTH  →  HEIGHT", 0.50, smooth);
+    }
+    par {
+      shift3(sheetSkin, (0,0,8), 2.85, smooth);
+      to(room, opacity, 0.16, 2.85, smooth);
+      show(pillars, 0.15);
+      draw(pillars, 2.70, smooth);
+      view3(room, "isometric", 2.85, smooth, 1.52);
+    }
+    wait(0.65);
+  }
+}
+
+step("the space within") {
+  seq {
+    par {
+      show(nearCorner, 0.30); show(farCorner, 0.30);
+      show(nearLabel, 0.35); show(farLabel, 0.35);
+      show(takeaway, 0.45);
+      say(phase, "THE SPACE WITHIN", 0.45, smooth);
+      say(narration, "Depth rushes in. Near and far finally have meaning.", 0.55, smooth);
+      say(principle, "A dimension is an old world moving in a new perpendicular direction.", 0.55, smooth);
+      view3(room, "fit", 1.80, smooth, 1.62);
+    }
+    par {
+      pulse(sheetSkin, 0.85);
+      pulse(pillars, 0.85);
+      roll3(3, 1.80, smooth);
+    }
+    wait(2.20);
+  }
+}

package/examples/disc-integration.manic

@@ -0,0 +1,172 @@
+title("Disc Integration");
+canvas(1000, 1000);
+template("black");
+
+// ================= HUD (2D always draws above the 3D world) =================
+text(head, (cx, 60), "Disc Integration"); display(head); cursor(head);
+text(t1, (cx, 122), "1. A region under a curve"); size(t1, 30); color(t1, gold); hidden(t1);
+text(t2, (cx, 122), "2. Spin it - every strip sweeps a disc"); size(t2, 30); color(t2, cyan); hidden(t2);
+text(t3, (cx, 122), "3. Stack the discs - integrate"); size(t3, 30); color(t3, magenta); hidden(t3);
+text(cap, (cx, h - 42), ""); size(cap, 26);
+
+// one living equation: it rewrites its way from the curve to the volume
+equation(eqM, (cx, 190), `y=\sqrt{x}\quad(0\le x\le 4)`, 40); hidden(eqM);
+
+// live volume readout
+counter(vol, (w - 185, 300), 0, 2, "V = ", ""); hidden(vol);
+
+// ================= act 1 cast: the flat 2D region =================
+let gx = cx - 300;
+let gy = 520;
+let s2 = 140;
+
+arrow(xax2, (gx - 30, gy), (gx + 4*s2 + 50, gy)); untraced(xax2); stroke(xax2, 3); tag(xax2, d2);
+arrow(yax2, (gx, gy + 30), (gx, gy - 2.4*s2)); untraced(yax2); stroke(yax2, 3); tag(yax2, d2);
+text(x0b, (gx, gy + 26), "0"); size(x0b, 22); color(x0b, dim); hidden(x0b); tag(x0b, d2);
+text(x4b, (gx + 4*s2, gy + 26), "4"); size(x4b, 22); color(x4b, dim); hidden(x4b); tag(x4b, d2);
+
+plot(rplot, (gx, gy), s2, s2, "sqrt(x)", (0, 4));
+untraced(rplot); stroke(rplot, 4); gradient(rplot, blue, cyan, gold, 270); tag(rplot, d2);
+dot(rider, (gx, gy), 7); color(rider, gold); glow(rider, 8); hidden(rider); tag(rider, d2);
+area(ar2, rplot, 0, 0); color(ar2, cyan); opacity(ar2, 0.3); tag(ar2, d2);
+
+// the one strip we will follow into 3D (x = 2.25 - remember it)
+rect(strip, (gx + 2.25*s2, gy - sqrt(2.25)*s2/2), 66, sqrt(2.25)*s2);
+color(strip, cyan); opacity(strip, 0.75); hidden(strip); tag(strip, d2);
+
+// ================= act 2-3 cast: the 3D world (right-handed, Z-up) ==========
+camera3((8.2, -9.5, 5.0), (0, 0, 1.9), 42);
+axes3(ax3, (0, 0, 0), 4.6, 1); hidden(ax3);
+
+// the spin axis, called out explicitly
+line3(spinax, (0, 0, -0.3), (0, 0, 4.6)); thick(spinax, 0.015); color(spinax, dim); hidden(spinax);
+text(zlab, (cx, cy), "spin axis"); size(zlab, 22); color(zlab, dim); hidden(zlab);
+pin3(zlab, (0, 0, 4.55), (0, -16));
+
+// the profile curve, stood upright: r = sqrt(z)
+curve3(prof, "sqrt(t)", "0", "t", (0, 4)); untraced(prof); thick(prof, 0.04); color(prof, gold);
+
+// ghost of the swept surface: bright wireframe revolve
+revolve3(ghost, (0, 0, 0), "sqrt(t)", (0, 4), 64);
+finish3(ghost, "wire=1"); color(ghost, teal); opacity(ghost, 0.4); untraced(ghost);
+
+// 8 coarse discs (thin cylinders = many-sided prisms), declared low so they RISE
+for i in 0..8 {
+  let zc = (i + 0.5)*0.5;
+  prism3(dc{i}, (0, 0, zc - 0.45), 48, sqrt(zc), 0.48);
+  color(dc{i}, cyan); opacity(dc{i}, 0.85); tag(dc{i}, coarse3);
+}
+hidden(coarse3);
+
+// 20 fine discs
+for i in 0..20 {
+  let zc = (i + 0.5)*0.2;
+  prism3(df{i}, (0, 0, zc - 0.3), 48, sqrt(zc), 0.19);
+  color(df{i}, cyan); opacity(df{i}, 0.9); tag(df{i}, fine3);
+}
+hidden(fine3);
+
+// radius callout for the pulled-out disc (z = 2.25, r = 1.5, pulled to x + 3)
+arrow3(rarr, (3.0, 0, 2.62), (4.5, 0, 2.62)); thick(rarr, 0.03); color(rarr, gold); untraced(rarr);
+text(rlab, (cx, cy), `$r = \sqrt{z}$`); size(rlab, 26); color(rlab, gold); hidden(rlab);
+pin3(rlab, (3.75, 0, 2.62), (0, -30));
+
+// the exact solid, and the vase it will morph into ("any profile, same recipe")
+revolve3(solid, (0, 0, 0), "sqrt(t)", (0, 4), 64);
+finish3(solid, "shading=smooth depth=0.2 shadow=0.2"); color(solid, cyan); hidden(solid);
+revolve3(vase, (0, 0, 0), "1.1+0.55*sin(1.7*t-0.9)", (0, 4), 64); hidden(vase);
+morph3(solid, vase);
+
+// ================= timeline =================
+
+// ---- cold open
+type(head, 1.1);
+
+// ---- act 1: the flat region
+cue(whoosh);
+show(t1, 0.5);
+par { draw(xax2, 0.6); draw(yax2, 0.6); show(x0b, 0.6); show(x4b, 0.6); }
+show(rider, 0.2);
+par { draw(rplot, 1.4); travel(rider, rplot, 1.4, smooth); }
+fade(rider, 0.3);
+show(eqM, 0.6);
+say(cap, "Take the region under the curve...", 0.5);
+to(ar2, x, 4, 1.6, smooth);
+say(cap, "...and keep your eye on this one strip", 0.5);
+show(strip, 0.4);
+pulse(strip, 0.9);
+wait(0.8);
+
+// ---- the pivot: leave flatland
+say(cap, "Now stand the region upright - and SPIN it around the axis", 0.5);
+cue(whoosh);
+fade(d2, 0.8);
+show(t2, 0.5); fade(t1, 0.3);
+par { show(ax3, 0.8); show(spinax, 0.8); show(zlab, 0.8); }
+draw(prof, 1.2);
+flash(spinax, magenta);
+
+// THE MONEY SHOT: the profile curve physically sweeps 360 degrees
+// around the axis while the wireframe surface traces on beneath it
+par {
+  turn3(prof, (0, 0, 2), z, 360, 2.6, smooth);
+  draw(ghost, 2.6);
+  orbit3(-20, 18, 12.0, 2.6, smooth);
+}
+cue(tick);
+rewrite(eqM, `dV \;=\; \pi\,\textcolor{cyan}{r^2}\,dz`, 0.9);
+say(cap, "Every strip of area sweeps a thin DISC of volume", 0.5);
+
+// ---- act 3: the disc stack rises
+show(t3, 0.5); fade(t2, 0.3);
+stagger(0.09) { for i in 0..8 { par { show(dc{i}, 0.3); shift3(dc{i}, (0, 0, 0.45), 0.4, out); } } }
+wait(0.4);
+
+// pull ONE disc out of the stack - the same strip from act 1
+say(cap, "That same strip from before - now a cylinder: radius sqrt(z), thickness dz", 0.5);
+cue(pop);
+shift3(dc4, (3.0, 0, 0), 0.9, smooth);
+par { draw(rarr, 0.5); show(rlab, 0.5); }
+wait(1.2);
+par { fade(rarr, 0.4); fade(rlab, 0.4); shift3(dc4, (-3.0, 0, 0), 0.9, smooth); }
+cue(tick);
+rewrite(eqM, `V \;\approx\; \sum_i \pi\,r(z_i)^2\,\Delta z`, 0.9);
+wait(0.8);
+
+// refine: thinner discs, camera drifts around the stack
+say(cap, "Slice thinner - the stack hugs the surface", 0.5);
+par {
+  fade(coarse3, 0.6);
+  stagger(0.04) { for i in 0..20 { show(df{i}, 0.22); } }
+  orbit3(35, 24, 11.0, 2.2, smooth);
+}
+cue(tick);
+rewrite(eqM, `V \;=\; \pi\!\int_0^{4}(\sqrt{z}\,)^2\,dz \;=\; \pi\!\int_0^{4} z\,dz`, 0.9);
+wait(0.8);
+
+// the limit: discs dissolve into the exact smooth solid, the number climbs
+say(cap, "In the limit: the exact solid of revolution", 0.5);
+show(vol, 0.3);
+par { fade(fine3, 1.2); fade(ghost, 1.2); show(solid, 1.4); to(vol, value, 25.13, 2.2); }
+flash(vol, gold);
+cue(tick);
+rewrite(eqM, `V \;=\; \pi\cdot\tfrac{16}{2} \;=\; 8\pi \;\approx\; 25.13`, 0.9);
+par { orbit3(90, 20, 10.5, 2.6, smooth); }
+wait(0.6);
+
+// ---- flourish: ANY profile, same recipe - the solid becomes a vase
+say(cap, "Any profile, same recipe - just change r(z)", 0.5);
+cue(whoosh);
+par {
+  to(solid, morph, 1, 2.6, smooth);
+  fade(vol, 0.8);
+  rewrite(eqM, `V \;=\; \pi\int_a^b r(z)^2\,dz`, 1.2);
+  orbit3(160, 16, 10.5, 2.6, smooth);
+}
+cue(chime);
+par {
+  breathe(eqM, 3, 0.05, 0, 6);
+  orbit3(200, 14, 11.0, 6, smooth);
+}
+say(cap, "Area swept in a circle - volume, one disc at a time", 0.6);
+wait(2.0);

package/examples/double-incline.manic

@@ -0,0 +1,9 @@
+// double-incline.manic — two blocks on a wedge's two slopes, tied over a pulley
+// at the apex. `doubleincline(id,[center],[angle1],[angle2],[m1],[m2],[unit])`;
+// the right slope is rough. PRE-SIMULATED (RK4); `run(id)` plays it.
+title("Double incline — connected blocks on two slopes");
+canvas("16:9");
+text(hdr, (cx, 42), "Two slopes, one rope over the apex — which way does it slide?"); size(hdr, 22); color(hdr, cyan); bold(hdr); display(hdr);
+doubleincline(di, (cx, 520), 50, 30, 12, 70);
+text(cap, (cx, h - 30), "M₂ (70 kg) on the gentle rough slope beats M₁ (12 kg) on the steep smooth one"); size(cap, 15); color(cap, dim); display(cap);
+run(di, 5);