@maniclang/workbench 0.1.11

package/examples/map-attractor.manic

@@ -0,0 +1,45 @@
+// map-attractor — a discrete 2-D strange attractor, via the new `cloud … from
+// map(...)` source: the discrete twin of `from flow`. `map` ITERATES a 2-D map
+// (x,y) -> (x',y') 40,000 times (a stateful recurrence clouds alone can't do) and
+// hands each point the i-th state as hx/hy; the cloud's formulas project it.
+// Covers the whole Gumowski-Mira / Clifford / de Jong / Hénon family. Most maps
+// take both formulas from the OLD state (clean); THIS one is sequential
+// (y' uses x'), so x' is inlined into y' below.
+//
+// Original idea by @yuruyurau (https://x.com/yuruyurau). Our hue'd, annotated,
+// bloomed take on a 9:16 Short — pure in (i, t), so it scrubs and records.
+//
+//   manic examples/map-attractor.manic
+title("A strange attractor from one map");
+canvas("9:16");
+template("black");
+
+cloud(atr, 40000, #ffffff, 0.5)
+  from map("(y+(1-0.06*y*y)*0.003*y-0.8*x+3.6*x*x/(1+x*x))", "-0.8*(y+(1-0.06*y*y)*0.003*y-0.8*x+3.6*x*x/(1+x*x))+3.6*(y+(1-0.06*y*y)*0.003*y-0.8*x+3.6*x*x/(1+x*x))*(y+(1-0.06*y*y)*0.003*y-0.8*x+3.6*x*x/(1+x*x))/(1+(y+(1-0.06*y*y)*0.003*y-0.8*x+3.6*x*x/(1+x*x))*(y+(1-0.06*y*y)*0.003*y-0.8*x+3.6*x*x/(1+x*x)))-x", (1, 1)) {
+  // hx, hy = the i-th iterated state; project it through a polar lens
+  let c = t - hypot(hx, hy)/4;
+  let px = hy*(5*sin(c) + 11);
+  let py = hx*(2*cos(c) + 7) + 9*sin(hy/4 + t);
+  let grow = tanh(t*0.5 + 0.12);
+  let x = 540 + px * 2.3 * grow;
+  let y = 980 + py * 2.3 * grow;
+  let hue = mod(hypot(hx, hy)*24 + t*14, 360);
+}
+
+// ---- textbook annotations ----
+caption(head, "A strange attractor from one map", (540, 140), 34);
+caption(sub, "40,000 iterations, no simulation loop", (540, 208), 22);
+hidden(head);
+hidden(sub);
+equation(eq, (540, 1706), `(x,y)\;\to\;(x',\,y')`, 38);
+caption(lab, "iterate a discrete map, then project it", (540, 1786), 20);
+hidden(eq);
+hidden(lab);
+
+show(head);
+wait(1.4);
+show(sub);
+wait(2.6);
+show(eq);
+show(lab);
+wait(30);

package/examples/mask-lens.manic

@@ -0,0 +1,33 @@
+// mask-lens.manic — T2 arbitrary-shape mask: reveal-through-any-shape.
+//
+// `mask(id, region)` composites `id` through another entity's SILHOUETTE — any
+// shape (circle, polygon, star, an imported svg outline) masks any content. The
+// general cousin of `clip` (which is rectangle-only). The mask follows `region`
+// every frame, so a circular lens glides across a big vector like a magnifier.
+//
+//   manic examples/mask-lens.manic
+title("Mask — reveal through any shape");
+canvas("16:9");
+template("blank");
+
+// a big imported vector to peer into
+svg(art, (cx, cy), "asset:svg/flags/br.svg", 940);
+
+// a circular lens — its shape is the mask (declared BEFORE the mask call)
+circle(lens, (cx - 340, cy), 150); outlined(lens); outline(lens, fg); stroke(lens, 5); glow(lens, 0.8);
+
+// mask the whole vector to the lens — art shows only inside the circle
+mask(art, lens);
+
+text(cap, (cx, h*0.9), "mask(id, region) — any shape masks any content");
+size(cap, 26); color(cap, dim); display(cap);
+
+// glide the lens across → the flag is revealed only inside the moving circle
+seq {
+  wait(0.4);
+  move(lens, (cx + 340, cy), 2.4, smooth);
+  wait(0.3);
+  move(lens, (cx, cy), 1.0, smooth);
+  pulse(lens);
+  wait(0.6);
+}

package/examples/matrix.manic

@@ -0,0 +1,37 @@
+// Matrix — a bracketed grid of entries, addressable by row and column via tag
+// broadcast (à la Manim's Matrix + set_row_colors / set_column_colors).
+//
+//   manic examples/matrix.manic
+//   manic examples/matrix.manic --record out --fps 60
+//
+// Rows are separated by ';', entries by spaces/commas. Entry ids m.r{i}c{j};
+// tags m.row{i} / m.col{j} / m.entries.
+
+title("Matrix");
+canvas(1280, 720);
+
+text(head, (640, 130), "rows and columns you can address");
+display(head);  color(head, cyan);  size(head, 28);  hidden(head);
+text(cap, (640, 620), "");  color(cap, dim);  size(cap, 22);
+
+matrix(m, "2 0 4; -1 1 5; 3 -2 0", (640, 370));
+untraced(m.lbrack);  untraced(m.rbrack);
+hidden(m.entries);
+
+show(head, 0.5);
+say(cap, "a 3x3 matrix");
+par { draw(m.lbrack, 0.5);  draw(m.rbrack, 0.5); }
+seq { show(m.row0, 0.35);  show(m.row1, 0.35);  show(m.row2, 0.35); }
+wait(0.5);
+
+section("Columns");
+say(cap, "colour a column — set_column_colors");
+recolor(m.col1, magenta, 0.4);
+flash(m.col2, cyan);
+wait(0.5);
+
+section("Rows");
+say(cap, "and highlight a row — set_row_colors");
+recolor(m.row0, lime, 0.4);
+par { pulse(m.r0c0);  pulse(m.r0c1);  pulse(m.r0c2); }
+wait(1.2);

package/examples/matrix3.manic

@@ -0,0 +1,101 @@
+// A 3 × 3 × 3 block of 27 cubes, then a matrix operation: a 3×3 matrix is a
+// linear map of space. We apply a shear M to every cell, then its inverse
+// M^-1 — which sends the block back exactly, because M^-1 M = I.
+//
+//   manic examples/matrix3.manic
+//   manic examples/matrix3.manic --record out --fps 60
+
+title("3 × 3 × 3  ·  M and M^-1");
+canvas("16:9");
+template("terminal");
+
+camera3((7.5, -9, 6), (2.4, 0, 2.1), 42);
+grid3(floor, (0, 0, 0), 6, 1);
+color(floor, dim);
+
+let s = 1.3;    // cell spacing (cubes are 1 wide → 0.3 gaps)
+let zc = 2.1;   // height of the block's centre
+let a = 0.7;    // shear amount: M sends x → x + a·z
+
+text(cap, (cx, h - 42), "");
+display(cap);  color(cap, fg);  size(cap, 21);  hidden(cap);
+
+// --- 27 cubes, three x-slices coloured cyan / magenta / lime ---
+for j in 0..3 { for k in 0..3 {
+  cube3(xa{j}{k}, (0 - s, (j - 1)*s, zc + (k - 1)*s), (1, 1, 1));
+  color(xa{j}{k}, cyan);  hidden(xa{j}{k});
+} }
+for j in 0..3 { for k in 0..3 {
+  cube3(xb{j}{k}, (0, (j - 1)*s, zc + (k - 1)*s), (1, 1, 1));
+  color(xb{j}{k}, magenta);  hidden(xb{j}{k});
+} }
+for j in 0..3 { for k in 0..3 {
+  cube3(xc{j}{k}, (s, (j - 1)*s, zc + (k - 1)*s), (1, 1, 1));
+  color(xc{j}{k}, lime);  hidden(xc{j}{k});
+} }
+
+// --- the matrices, as monospace text on the right ---
+text(mLabel, (995, 232), "M =");
+text(m0, (1035, 274), "[ 1  0   0.7 ]");
+text(m1, (1035, 310), "[ 0  1    0  ]");
+text(m2, (1035, 346), "[ 0  0    1  ]");
+text(iLabel, (995, 446), "M^-1 =");
+text(i0, (1035, 488), "[ 1  0  -0.7 ]");
+text(i1, (1035, 524), "[ 0  1    0  ]");
+text(i2, (1035, 560), "[ 0  0    1  ]");
+display(mLabel); display(m0); display(m1); display(m2);
+display(iLabel); display(i0); display(i1); display(i2);
+color(mLabel, cyan);  color(m0, cyan);  color(m1, cyan);  color(m2, cyan);
+color(iLabel, gold);  color(i0, gold);  color(i1, gold);  color(i2, gold);
+size(mLabel, 24); size(m0, 22); size(m1, 22); size(m2, 22);
+size(iLabel, 24); size(i0, 22); size(i1, 22); size(i2, 22);
+hidden(mLabel); hidden(m0); hidden(m1); hidden(m2);
+hidden(iLabel); hidden(i0); hidden(i1); hidden(i2);
+
+// ------------------------------ script ------------------------------
+show(floor, 0.3);
+show(cap, 0.3);
+say(cap, "A 3 by 3 by 3 block — 27 cells.", 0.7);
+stagger(0.04) {
+  for j in 0..3 { for k in 0..3 { show(xa{j}{k}, 0.3); } }
+  for j in 0..3 { for k in 0..3 { show(xb{j}{k}, 0.3); } }
+  for j in 0..3 { for k in 0..3 { show(xc{j}{k}, 0.3); } }
+}
+orbit3(38, 22, 13, 1.6, smooth);
+
+say(cap, "A 3×3 matrix M is a linear map of space. This M shears x by height z.", 1.0);
+stagger(0.12) { show(mLabel, 0.3); show(m0, 0.3); show(m1, 0.3); show(m2, 0.3); }
+
+// apply M: x' = x + a·(z - zc)
+par {
+  for j in 0..3 { for k in 0..3 {
+    move3(xa{j}{k}, (0 - s + a*(k - 1)*s, (j - 1)*s, zc + (k - 1)*s), 1.8, smooth);
+  } }
+  for j in 0..3 { for k in 0..3 {
+    move3(xb{j}{k}, (a*(k - 1)*s, (j - 1)*s, zc + (k - 1)*s), 1.8, smooth);
+  } }
+  for j in 0..3 { for k in 0..3 {
+    move3(xc{j}{k}, (s + a*(k - 1)*s, (j - 1)*s, zc + (k - 1)*s), 1.8, smooth);
+  } }
+}
+say(cap, "Applying M slants the whole block — the higher a cell, the more it shifts.", 1.0);
+
+stagger(0.12) { show(iLabel, 0.3); show(i0, 0.3); show(i1, 0.3); show(i2, 0.3); }
+say(cap, "The inverse M^-1 just negates the shear.", 0.8);
+
+// apply M^-1: sends every cell back to where it started
+par {
+  for j in 0..3 { for k in 0..3 {
+    move3(xa{j}{k}, (0 - s, (j - 1)*s, zc + (k - 1)*s), 1.8, smooth);
+  } }
+  for j in 0..3 { for k in 0..3 {
+    move3(xb{j}{k}, (0, (j - 1)*s, zc + (k - 1)*s), 1.8, smooth);
+  } }
+  for j in 0..3 { for k in 0..3 {
+    move3(xc{j}{k}, (s, (j - 1)*s, zc + (k - 1)*s), 1.8, smooth);
+  } }
+}
+say(cap, "M^-1 sends every cell home: M^-1 M = I, the identity.", 1.0);
+
+orbit3(70, 26, 13, 2.4, smooth);
+wait(0.6);

package/examples/matrix_addition.manic

@@ -0,0 +1,66 @@
+// Matrix Addition — A + B = C, computed entry by entry. Each matching pair of
+// entries flashes, then their sum pops into the result matrix. A teaching
+// animation: it shows *why* matrix addition is element-wise.
+//
+//   manic examples/matrix_addition.manic
+//   manic examples/matrix_addition.manic --record out --fps 60
+
+title("Matrix Addition");
+canvas(1280, 720);
+
+text(head, (640, 120), "add two matrices, entry by entry");
+display(head);  color(head, cyan);  size(head, 28);  hidden(head);
+text(cap, (640, 600), "");  color(cap, dim);  size(cap, 26);
+
+//        A            +            B            =            C
+matrix(A, "2 1; 0 3", (280, 350), 74, 66);
+matrix(B, "1 4; 5 2", (640, 350), 74, 66);
+matrix(C, "3 5; 5 5", (1000, 350), 74, 66);
+
+text(plus, (460, 350), "+");  display(plus);  color(plus, magenta);  size(plus, 44);  hidden(plus);
+text(eq, (820, 350), "=");    display(eq);    color(eq, magenta);    size(eq, 44);    hidden(eq);
+
+// A and B trace/fade in; C is built up during the sweep
+untraced(A.lbrack);  untraced(A.rbrack);
+untraced(B.lbrack);  untraced(B.rbrack);
+untraced(C.lbrack);  untraced(C.rbrack);
+hidden(A.entries);  hidden(B.entries);  hidden(C.entries);
+
+// --- reveal the two matrices ---
+show(head, 0.5);
+say(cap, "two matrices, A and B");
+par { draw(A.lbrack, 0.4);  draw(A.rbrack, 0.4);  draw(B.lbrack, 0.4);  draw(B.rbrack, 0.4); }
+par { show(A.entries, 0.4);  show(B.entries, 0.4); }
+show(plus, 0.3);
+wait(0.5);
+
+// --- add entry by entry ---
+section("Entry by entry");
+say(cap, "add matching entries, position by position");
+par { show(eq, 0.3);  draw(C.lbrack, 0.4);  draw(C.rbrack, 0.4); }
+
+seq {
+  par { flash(A.r0c0, lime);  flash(B.r0c0, lime); }
+  say(cap, "2 + 1 = 3");
+  par { show(C.r0c0, 0.3);  pulse(C.r0c0); }
+
+  par { flash(A.r0c1, lime);  flash(B.r0c1, lime); }
+  say(cap, "1 + 4 = 5");
+  par { show(C.r0c1, 0.3);  pulse(C.r0c1); }
+
+  par { flash(A.r1c0, lime);  flash(B.r1c0, lime); }
+  say(cap, "0 + 5 = 5");
+  par { show(C.r1c0, 0.3);  pulse(C.r1c0); }
+
+  par { flash(A.r1c1, lime);  flash(B.r1c1, lime); }
+  say(cap, "3 + 2 = 5");
+  par { show(C.r1c1, 0.3);  pulse(C.r1c1); }
+}
+wait(0.4);
+
+// --- the result ---
+section("Result");
+say(cap, "A + B — every entry, all at once");
+recolor(C.entries, cyan, 0.4);
+par { pulse(C.r0c0);  pulse(C.r0c1);  pulse(C.r1c0);  pulse(C.r1c1); }
+wait(1.5);

package/examples/matrix_addition_plane.manic

@@ -0,0 +1,91 @@
+// Matrix Addition, Geometrically — a 2x1 matrix IS a vector. Adding two of them
+//
+//     [3]   [1]   [4]
+//     [1] + [2] = [3]
+//
+// is the same as sliding one arrow onto the tip of the other (tip-to-tail) and
+// reading off where you land. The column matrices at the top stay in lockstep
+// with the arrows on the plane, so you see the algebra and the geometry at once.
+//
+//   manic examples/matrix_addition_plane.manic
+//   manic examples/matrix_addition_plane.manic --record out --fps 60
+
+title("Matrix Addition on the Plane");
+canvas(1280, 720);
+
+text(head, (640, 96), "a 2x1 matrix is a vector — adding them is tip-to-tail");
+display(head);  color(head, cyan);  size(head, 26);  hidden(head);
+text(cap, (640, 686), "");  color(cap, dim);  size(cap, 24);
+
+// --- the equation, as column matrices across the top ---
+matrix(MA, "3; 1", (452, 186), 44, 42);   color(MA, cyan);
+text(plus, (528, 186), "+");   display(plus);   color(plus, dim);   size(plus, 40);   hidden(plus);
+matrix(MB, "1; 2", (600, 186), 44, 42);   color(MB, magenta);
+text(eq,  (676, 186), "=");    display(eq);     color(eq, dim);     size(eq, 40);     hidden(eq);
+matrix(MC, "4; 3", (748, 186), 44, 42);   color(MC, lime);
+
+// --- the plane, centred low so the arrows have room to climb ---
+plane(pl, (640, 438), 560, 250, 48);
+
+// vectors from the plane's origin (dy is up); unit = 48 px
+vector(va, (640, 438), (144, 48),  cyan);      // a = (3, 1) -> tip (784, 390)
+vector(vb, (640, 438), (48, 96),   magenta);   // b = (1, 2) -> tip (688, 342)
+vector(vs, (640, 438), (192, 144), lime);      // a+b = (4, 3) -> tip (832, 294)
+
+// the two translated copies that build the parallelogram
+arrow(vb2, (784, 390), (832, 294));   color(vb2, magenta);   glow(vb2, 0);
+arrow(va2, (688, 342), (832, 294));   color(va2, cyan);      glow(va2, 0);
+
+// everything but the plane grid starts hidden / untraced
+untraced(pl.x);  untraced(pl.y);  hidden(pl.grid);
+untraced(va);  untraced(vb);  untraced(vs);  untraced(vb2);  untraced(va2);
+untraced(MA.lbrack);  untraced(MA.rbrack);  hidden(MA);
+untraced(MB.lbrack);  untraced(MB.rbrack);  hidden(MB);
+untraced(MC.lbrack);  untraced(MC.rbrack);  hidden(MC);
+
+// --- reveal the plane ---
+show(head, 0.5);
+section("The plane");
+say(cap, "a cartesian grid, arrows pinned to the origin");
+show(pl.grid, 0.6);
+par { draw(pl.x, 0.5);  draw(pl.y, 0.5); }
+wait(0.3);
+
+// --- vector a ---
+section("Vector a");
+say(cap, "a = [3, 1] — three right, one up");
+par { draw(MA.lbrack, 0.3);  draw(MA.rbrack, 0.3); }
+par { show(MA, 0.3);  draw(va, 0.6); }
+wait(0.4);
+
+// --- vector b ---
+section("Vector b");
+say(cap, "b = [1, 2] — one right, two up");
+show(plus, 0.3);
+par { draw(MB.lbrack, 0.3);  draw(MB.rbrack, 0.3); }
+par { show(MB, 0.3);  draw(vb, 0.6); }
+wait(0.4);
+
+// --- tip to tail ---
+section("Tip to tail");
+say(cap, "slide b so its tail sits on the tip of a");
+draw(vb2, 0.7);
+wait(0.5);
+
+// --- the sum ---
+section("The sum");
+say(cap, "the arrow to that new point is a + b = [4, 3]");
+show(eq, 0.3);
+par { draw(MC.lbrack, 0.3);  draw(MC.rbrack, 0.3); }
+par { show(MC, 0.3);  draw(vs, 0.8); }
+par { pulse(vs);  flash(MC, lime); }
+wait(0.6);
+
+// --- parallelogram ---
+section("Either order");
+say(cap, "slide a onto b instead — same point. a + b = b + a");
+draw(va2, 0.7);
+wait(0.4);
+say(cap, "the two paths frame a parallelogram; a + b is its diagonal");
+par { pulse(va);  pulse(vb);  pulse(vs); }
+wait(1.4);

package/examples/maxwell-boltzmann-effusion-v2.manic

@@ -0,0 +1,142 @@
+// EXPRESSIVE PROCESS V2 — MAXWELL–BOLTZMANN EFFUSION
+//
+// A polished 2.5D acceptance story inspired by engine-test-6.mov. The
+// apparatus is a bundled native SVG, while every molecule, detector bin,
+// arrival count, and empirical distribution remains a normal Manic entity.
+// `emit`, `collect`, and `observe` all read one deterministic process.
+
+title("Maxwell–Boltzmann Effusion — Motion Becomes Evidence");
+canvas("9:16");
+template("blank");
+watermark(mark, (150, 90), "Made With Manic");
+
+text(kicker, (540, 84), "STATISTICAL MECHANICS · EXPRESSIVE PROCESS V2");
+text(headline, (540, 142), "A distribution you can watch forming");
+size(kicker, 18); color(kicker, dim); bold(kicker);
+size(headline, 34); bold(headline);
+
+equation(law, (540, 242),
+  `f(v)=4\pi\left(\frac{m}{2\pi k_BT}\right)^{3/2}v^2e^{-mv^2/(2k_BT)}`, 34);
+
+// The decorative shell is an asset; the changing evidence stays native.
+svg(apparatus, (240, 540), "asset:svg/physics/effusion-reservoir.svg", 330);
+text(reservoirLabel, (225, 705), "THERMAL RESERVOIR");
+size(reservoirLabel, 17); bold(reservoirLabel); color(reservoirLabel, gold);
+
+rect(detectorPanel, (730, 560), 570, 300);
+filled(detectorPanel); color(detectorPanel, panel); opacity(detectorPanel, 0.92);
+outlined(detectorPanel); outline(detectorPanel, dim); stroke(detectorPanel, 3);
+
+text(detectorTitle, (730, 382), "PARTICLE SPEED  v");
+size(detectorTitle, 18); bold(detectorTitle); color(detectorTitle, dim);
+
+// The invisible source is precisely at the SVG nozzle.
+circle(source, (348, 540), 20);
+opacity(source, 0);
+particles(molecules, source, 180, 3.2, 73);
+color(molecules, magenta); glow(molecules, 0.8); z(molecules, 8);
+
+// Individual lanes diverge around this authored route before being collected.
+spline(flight, (350, 540), (415, 500), (465, 515), (500, 545));
+hidden(flight);
+
+livehistogram(empirical, (730, 560), 0, 2.2, 14, 540, 240, cyan);
+z(empirical, 3); hidden(empirical.count);
+
+// Same horizontal range as the live histogram: 0 .. 4*scale = 2.2.
+distribution(theory, (730, 560), "maxwell", 0.55, 0, gold);
+hidden(theory.axis); hidden(theory.name);
+untraced(theory.curve); z(theory, 7);
+
+text(empiricalKey, (610, 750), "● empirical arrivals");
+text(theoryKey, (850, 750), "— theoretical curve");
+size(empiricalKey, 17); color(empiricalKey, cyan);
+size(theoryKey, 17); color(theoryKey, gold);
+
+counter(arrivals, (540, 850), 0, 0, "detected molecules  ", " / 180");
+size(arrivals, 24); color(arrivals, dim);
+
+text(caption, (540, 920),
+  "A thermal source emits many molecular speeds—not one average speed.");
+size(caption, 23); wrap(caption, 880); color(caption, dim);
+
+rect(evidencePanel, (540, 1110), 880, 230);
+filled(evidencePanel); color(evidencePanel, panel); opacity(evidencePanel, 0.95);
+outlined(evidencePanel); outline(evidencePanel, dim); stroke(evidencePanel, 2);
+text(evidenceTitle, (540, 1030), "ONE PROCESS · THREE VIEWS");
+size(evidenceTitle, 18); bold(evidenceTitle); color(evidenceTitle, dim);
+equation(processLaw, (540, 1100),
+  `\text{motion}\;\longrightarrow\;\text{arrival bin}\;\longrightarrow\;\hat f(v)`, 32);
+text(truth, (540, 1190),
+  "The dots, bars, and count are derived from the same seeded experiment.");
+size(truth, 20); color(truth, dim); wrap(truth, 790);
+
+hidden(apparatus); hidden(reservoirLabel); hidden(detectorPanel);
+hidden(detectorTitle); hidden(molecules); hidden(empirical);
+hidden(empiricalKey); hidden(theoryKey); hidden(arrivals);
+hidden(caption); hidden(evidencePanel); hidden(evidenceTitle);
+hidden(processLaw); hidden(truth);
+
+step("build-the-apparatus") {
+  par {
+    show(apparatus, 0.65);
+    show(reservoirLabel, 0.45);
+    show(detectorPanel, 0.55);
+    show(detectorTitle, 0.35);
+    show(empirical.axis, 0.55);
+    show(empirical.bars, 0.55);
+    show(empirical.min, 0.35);
+    show(empirical.max, 0.35);
+    show(empiricalKey, 0.35);
+    show(theoryKey, 0.35);
+    show(arrivals, 0.35);
+    show(caption, 0.40);
+  }
+}
+wait(0.45);
+
+step("the-prediction") {
+  par {
+    draw(theory.curve, 0.9, smooth);
+    say(caption,
+      "Maxwell predicts a characteristic spread with a most probable speed.",
+      0.40);
+    par {
+      cam((cx, cy), 0.75, smooth);
+      zoom(1.025, 0.75, smooth);
+    }
+  }
+}
+wait(0.35);
+
+step("run-the-experiment") {
+  par {
+    emit(molecules, flight, maxwell, 7.0, 48, smooth);
+    collect(empirical, molecules, speed, 0.48, smooth);
+    observe(empirical, molecules, speed);
+    observe(arrivals, molecules, arrived);
+    show(molecules, 0.15);
+    say(caption,
+      "Each molecule keeps its sampled speed. Faster molecules cross the apparatus sooner.",
+      0.45);
+  }
+}
+wait(0.55);
+
+step("motion-becomes-evidence") {
+  par {
+    pulse(empirical.bars, 0.8);
+    show(evidencePanel, 0.40);
+    show(evidenceTitle, 0.35);
+    show(processLaw, 0.45);
+    show(truth, 0.40);
+    say(caption,
+      "Collection does not fake the chart: every arrival lands in the bin selected by its speed.",
+      0.45);
+    par {
+      cam((cx, cy), 0.65, smooth);
+      zoom(1.0, 0.65, smooth);
+    }
+  }
+}
+wait(1.4);

package/examples/maxwell-boltzmann-process.manic

@@ -0,0 +1,86 @@
+// MAXWELL–BOLTZMANN PROCESS FOUNDATION
+// First acceptance story for deterministic evolving collections. The emitted
+// particles, arrival count, and speed histogram all come from one compiled
+// process. The formula is authored truth; Manic is not pretending to be a CAS.
+
+title("Maxwell–Boltzmann — From Motion to Distribution");
+canvas("9:16");
+template("blank");
+watermark(mark, (155, 92), "Made With Manic");
+
+text(kicker, (540, 80), "STATISTICAL MECHANICS · PROCESS VIEW");
+text(headline, (540, 145), "How does molecular motion become a distribution?");
+size(kicker, 19); color(kicker, dim); bold(kicker);
+size(headline, 33); bold(headline); wrap(headline, 850);
+
+equation(law, (540, 245),
+  `f(v)=4\pi\left(\frac{m}{2\pi k_BT}\right)^{3/2}v^2e^{-mv^2/(2k_BT)}`, 36);
+
+rect(reservoir, (410, 500), 560, 330);
+outlined(reservoir); outline(reservoir, dim); stroke(reservoir, 4);
+line(divider, (630, 340), (630, 660));
+color(divider, dim); stroke(divider, 3);
+text(gasLabel, (330, 685), "seeded molecules");
+size(gasLabel, 20); color(gasLabel, dim);
+particles(molecules, reservoir, 72, 5, 29);
+
+// The route starts at the aperture and bends into the measurement region.
+spline(nozzle, (630, 500), (735, 430), (850, 570), (900, 735));
+stroke(nozzle, 4); color(nozzle, fg); untraced(nozzle);
+text(nozzleLabel, (850, 395), "effusive path");
+size(nozzleLabel, 19); color(nozzleLabel, dim);
+
+livehistogram(speedBins, (540, 1160), 0.35, 0.95, 14, 760, 300, cyan);
+text(histTitle, (540, 970), "EMPIRICAL SPEEDS");
+size(histTitle, 23); bold(histTitle);
+text(axisUnit, (540, 1355), "normalized path lengths per second");
+size(axisUnit, 18); color(axisUnit, dim);
+
+counter(arrived, (540, 1460), 0, 0, "detected molecules  ", " / 72");
+size(arrived, 24); color(arrived, dim);
+text(caption, (540, 1545),
+  "Each bar grows only when a molecule from the same process arrives.");
+size(caption, 22); color(caption, dim); wrap(caption, 820);
+
+hidden(molecules); hidden(speedBins); hidden(arrived); hidden(caption);
+hidden(nozzleLabel);
+
+step("reservoir") {
+  par {
+    show(molecules, 0.55);
+    show(speedBins, 0.45);
+    show(arrived, 0.35);
+    show(caption, 0.35);
+  }
+}
+wait(0.45);
+
+step("open-the-aperture") {
+  par {
+    draw(nozzle, 0.55);
+    show(nozzleLabel, 0.35);
+  }
+}
+wait(0.25);
+
+step("motion-becomes-data") {
+  par {
+    stream(molecules, nozzle, 5.2, 42, smooth);
+    observe(speedBins, molecules, speed);
+    observe(arrived, molecules, arrived);
+    say(caption,
+      "The motion and the distribution are two views of one deterministic experiment.",
+      0.45);
+  }
+}
+wait(0.7);
+
+step("takeaway") {
+  par {
+    pulse(speedBins.bars, 0.8);
+    say(caption,
+      "Manic can now connect a changing collection to measurements without frame callbacks.",
+      0.45);
+  }
+}
+wait(1.2);