@maniclang/workbench 0.1.11

package/examples/asymptote-tiling-reference.manic

@@ -0,0 +1,65 @@
+// The recurring structure behind Asymptote's tiling examples:
+// author one motif, then arrange it as a hex field, grid, radial ring, or a
+// repeated composition. Every generated tile remains a normal Manic entity.
+
+title("One Motif, Four Tiling Systems");
+canvas("16:9");
+template("mono");
+
+watermark(mark, (w*0.11, h*0.075), "Made With Manic");
+text(kicker, (cx, h*0.07), "GENERATIVE GEOMETRY · REPEAT");
+text(headline, (cx, h*0.13), "Build the motif once. Compose the field.");
+size(kicker, 19); bold(kicker); color(kicker, dim);
+size(headline, 34); bold(headline);
+
+let lx = w*0.27;
+let rx = w*0.73;
+let uy = h*0.37;
+let ly = h*0.73;
+
+// Hex rings: a small two-part diamond becomes a honeycomb field.
+polygon(hexBody, (lx,uy-16), (lx+15,uy), (lx,uy+16), (lx-15,uy));
+circle(hexCore, (lx,uy), 4);
+color(hexBody, cyan); color(hexCore, gold);
+tag(hexBody, hexMotif); tag(hexCore, hexMotif);
+repeat(hexField, hexMotif, "layout=hex rings=4 spacing=30 rotate=30 scale=0.82");
+hidden(hexMotif); untraced(hexField);
+
+// Grid: a deliberately asymmetric motif proves orientation is retained.
+line(gridStem, (rx-15,uy+12), (rx+14,uy-12));
+circle(gridTip, (rx+14,uy-12), 5);
+color(gridStem, magenta); color(gridTip, lime);
+stroke(gridStem, 3);
+tag(gridStem, gridMotif); tag(gridTip, gridMotif);
+repeat(gridField, gridMotif, "layout=grid rows=5 cols=7 gapx=48 gapy=42 rotate=-8");
+hidden(gridMotif); untraced(gridField);
+
+// Radial: each arrow-shaped wedge faces away from the common centre.
+polygon(ray, (lx,ly-22), (lx+9,ly-5), (lx,ly+4), (lx-9,ly-5));
+color(ray, gold); tag(ray, rayMotif);
+repeat(sun, rayMotif, "layout=radial count=18 radius=112 face=out rotate=10 scale=0.85");
+hidden(rayMotif); untraced(sun);
+
+// Nested composition: repeat a 2x2 micro-pattern as one larger radial motif.
+polygon(seed, (rx-7,ly+7), (rx+7,ly+7), (rx,ly-8));
+color(seed, cyan);
+repeat(micro, seed, "layout=grid rows=2 cols=2 gapx=20 gapy=20 scale=0.70");
+repeat(nested, micro, "layout=radial count=10 radius=105 face=out rotate=18 scale=0.82");
+hidden(seed); hidden(micro); untraced(nested);
+
+text(l1, (lx,h*0.205), "HEX RINGS · 37 MOTIFS");
+text(l2, (rx,h*0.205), "ROTATED GRID · 35 MOTIFS");
+text(l3, (lx,h*0.565), "RADIAL · FACE OUT");
+text(l4, (rx,h*0.565), "NESTED · MOTIFS OF MOTIFS");
+size(l1,17); size(l2,17); size(l3,17); size(l4,17);
+bold(l1); bold(l2); bold(l3); bold(l4);
+color(l1,cyan); color(l2,magenta); color(l3,gold); color(l4,lime);
+
+step("hexagonal rings") { draw(hexField, 1.40, smooth); }
+wait(0.25);
+step("rectangular repetition") { draw(gridField, 1.40, smooth); }
+wait(0.25);
+step("radial orientation") { draw(sun, 1.20, smooth); }
+wait(0.25);
+step("composition remains reusable") { draw(nested, 1.60, smooth); }
+wait(1.30);

package/examples/aws-clustered-web-services.manic

@@ -0,0 +1,186 @@
+title("Clustered Web Services on AWS");
+canvas("16:9");
+template("neon");
+
+let u = (w+h-abs(w-h))/1440;
+watermark(mark, (w*0.15, h*0.025), "Made With Manic");
+text(kicker, (cx, h*0.055), "AWS ARCHITECTURE · CLUSTERED WEB SERVICES");
+text(headline, (cx, h*0.115), "Requests in. Responses back.");
+text(caption, (cx, h*0.935), "Dashed paths describe what is connected—not what is moving now.");
+size(kicker, 16*u); color(kicker, dim); bold(kicker);
+size(headline, 29*u); bold(headline); wrap(headline, w*0.88);
+size(caption, 18*u); color(caption, dim); wrap(caption, w*0.86);
+
+if h > 1.25*w {
+  architecture(clusteredWeb, (cx, h*0.51), w*0.84, h*0.70);
+  text(requestKey, (w*0.36, h*0.225), "REQUEST");
+  arrow(requestSample, (w*0.48, h*0.225), (w*0.64, h*0.225));
+  text(responseKey, (w*0.36, h*0.265), "RESPONSE");
+  arrow(responseSample, (w*0.48, h*0.265), (w*0.64, h*0.265));
+}
+else {
+  architecture(clusteredWeb, (cx, h*0.51), w*0.94, h*0.69);
+  text(requestKey, (w*0.105, h*0.205), "REQUEST");
+  arrow(requestSample, (w*0.15, h*0.205), (w*0.205, h*0.205));
+  text(responseKey, (w*0.105, h*0.245), "RESPONSE");
+  arrow(responseSample, (w*0.15, h*0.245), (w*0.205, h*0.245));
+}
+size(requestKey, 15*u); color(requestKey, fg); bold(requestKey);
+size(responseKey, 15*u); hue(responseKey, 328, 0.90, 0.62); bold(responseKey);
+color(requestSample, fg); stroke(requestSample, 3*u);
+hue(responseSample, 328, 0.90, 0.62); dashed(responseSample, 10*u, 7*u);
+stroke(responseSample, 4*u); glow(responseSample, 0.85);
+hidden(requestKey); hidden(requestSample);
+hidden(responseKey); hidden(responseSample);
+
+node(dns, clusteredWeb, "aws:route53", "dns");
+node(lb, clusteredWeb, "aws:elb", "lb");
+
+cluster(services, clusteredWeb, "SERVICES");
+node(web1, services, "aws:ecs", "web1");
+node(web2, services, "aws:ecs", "web2");
+node(web3, services, "aws:ecs", "web3");
+
+cluster(database, clusteredWeb, "DB CLUSTER");
+node(dbPrimary, database, "aws:rds", "userdb");
+node(dbReplica, database, "aws:rds", "userdb ro");
+
+node(memcached, clusteredWeb, "aws:elasticache", "memcached");
+
+connect(dnsToLb, dns, lb);
+connect(lbToServices, lb, services);
+connect(servicesToDb, services, dbPrimary);
+connect(servicesToCache, services, memcached, 145*u);
+connect(dbToServices, dbPrimary, services, 42*u);
+connect(servicesToLb, services, lb, 42*u);
+connect(cacheToWeb2, memcached, web2, 145*u);
+hue(dbToServices.hot, 328, 0.90, 0.62);
+hue(servicesToLb.hot, 328, 0.90, 0.62);
+hue(cacheToWeb2.hot, 328, 0.90, 0.62);
+dashed(dbToServices.hot, 10*u, 7*u);
+dashed(servicesToLb.hot, 10*u, 7*u);
+dashed(cacheToWeb2.hot, 10*u, 7*u);
+stroke(dbToServices.hot, 4.5*u); glow(dbToServices.hot, 0.95);
+stroke(servicesToLb.hot, 4.5*u); glow(servicesToLb.hot, 0.95);
+stroke(cacheToWeb2.hot, 4.5*u); glow(cacheToWeb2.hot, 0.95);
+link(replication, dbPrimary.card, dbReplica.card);
+dashed(replication); color(replication, dim); stroke(replication, 2.5*u);
+
+message(pageRequest, dns, "GET");
+message(cacheRead, web2, "READ");
+
+hidden(clusteredWeb.nodes);
+hidden(services.parts); hidden(database.parts);
+hidden(pageRequest.parts); hidden(cacheRead.parts);
+untraced(dnsToLb); untraced(lbToServices);
+untraced(servicesToDb); untraced(servicesToCache);
+untraced(dbToServices); untraced(servicesToLb); untraced(cacheToWeb2);
+untraced(replication);
+
+step("entry") {
+  par {
+    show(dns, 0.40);
+    show(lb, 0.40);
+    say(caption, "Route 53 and the load balancer form the public entry into the design.", 0.40);
+  }
+}
+wait(0.20);
+
+step("service-pool") {
+  par {
+    show(services.parts, 0.45);
+    stagger(0.10) {
+      show(web1, 0.35);
+      show(web2, 0.35);
+      show(web3, 0.35);
+    }
+    say(caption, "Three ECS services share one ownership boundary; no runtime choice is implied yet.", 0.40);
+  }
+}
+wait(0.20);
+
+step("state") {
+  par {
+    show(database.parts, 0.45);
+    show(dbPrimary, 0.40);
+    show(dbReplica, 0.40);
+    show(memcached, 0.40);
+    say(caption, "The database cluster and cache complete the static architecture.", 0.40);
+  }
+}
+wait(0.20);
+
+step("possible-topology") {
+  par {
+    draw(dnsToLb, 0.40);
+    draw(lbToServices, 0.60);
+    draw(servicesToDb, 0.60);
+    draw(servicesToCache, 0.60);
+    draw(replication, 0.45);
+    show(requestKey, 0.35); show(requestSample, 0.35);
+    show(responseKey, 0.35); show(responseSample, 0.35);
+    say(caption, "Every dashed lane is possible. The next moving object will identify the path actually used.", 0.40);
+  }
+}
+wait(0.30);
+
+step("request-to-database") {
+  par {
+    seq {
+      show(pageRequest.parts, 0.20);
+      route(pageRequest, dnsToLb, 0.65, smooth);
+      route(pageRequest, lbToServices, 0.90, smooth);
+      route(pageRequest, servicesToDb, 0.90, smooth);
+    }
+    say(caption, "This request follows one authored lane: dns → lb → web1 → userdb.", 0.40);
+  }
+}
+wait(0.35);
+
+step("database-response") {
+  par {
+    seq {
+      par {
+        say(pageRequest.label, "200 OK", 0.25);
+        to(pageRequest.parts, hue, 328, 0.25, smooth);
+      }
+      route(pageRequest, dbToServices, 0.90, smooth);
+      route(pageRequest, servicesToLb, 0.90, smooth);
+    }
+    say(caption, "The same identity returns userdb → web1 → lb. DNS resolved the name; it is not the HTTP response path.", 0.40);
+  }
+}
+wait(0.35);
+
+step("cache-round-trip") {
+  par {
+    seq {
+      show(cacheRead.parts, 0.20);
+      route(cacheRead, servicesToCache, 1.05, smooth);
+      par {
+        say(cacheRead.label, "HIT", 0.25);
+        to(cacheRead.parts, hue, 328, 0.25, smooth);
+      }
+      route(cacheRead, cacheToWeb2, 1.05, smooth);
+    }
+    say(caption, "A separate cache read travels web2 → memcached, becomes HIT, and returns to that same service.", 0.40);
+  }
+}
+wait(0.35);
+
+step("replica-relationship") {
+  par {
+    flow(replication, 3.20, both, continuous);
+    say(caption, "The neutral database link can carry a two-way visual pulse only because the creator asked for it.", 0.40);
+  }
+}
+wait(0.35);
+
+step("takeaway") {
+  par {
+    pulse(services.parts, 0.70);
+    pulse(database.parts, 0.70);
+    say(caption, "Architecture stays readable; objects, paths, timing, and composition tell the runtime story.", 0.45);
+  }
+}
+wait(1.40);

package/examples/aws-event-processing-clusters-poc.manic

@@ -0,0 +1,97 @@
+title("Event Processing on AWS — From Topology to Hot Path");
+canvas("16:9");
+template("mono");
+
+let u = (w+h-abs(w-h))/1440;
+watermark(mark, (w*0.15, h*0.055), "Made With Manic");
+text(kicker, (cx, h*0.055), "AWS ARCHITECTURE · EVENT PROCESSING");
+text(headline, (cx, h*0.115), "One topology. One event. One visible hot path.");
+text(caption, (cx, h*0.935), "Dashed relationships show every route the architecture allows.");
+size(kicker, 16*u); color(kicker, dim); bold(kicker);
+size(headline, 29*u); bold(headline); wrap(headline, w*0.88);
+size(caption, 18*u); color(caption, dim); wrap(caption, w*0.86);
+
+if h > 1.25*w {
+  architecture(eventProcessing, (cx, h*0.51), w*0.82, h*0.70);
+}
+else {
+  architecture(eventProcessing, (cx, h*0.51), w*0.92, h*0.69);
+}
+
+node(source, eventProcessing, "aws:eks", "K8s Source");
+cluster(flows, eventProcessing, "EVENT FLOWS");
+cluster(workers, flows, "EVENT WORKERS");
+node(worker1, workers, "aws:ecs", "Worker 1");
+node(worker2, workers, "aws:ecs", "Worker 2");
+node(worker3, workers, "aws:ecs", "Worker 3");
+node(queue, flows, "aws:sqs", "Event Queue");
+cluster(processing, flows, "PROCESSING");
+node(proc1, processing, "aws:lambda", "Processor 1");
+node(proc2, processing, "aws:lambda", "Processor 2");
+node(proc3, processing, "aws:lambda", "Processor 3");
+node(store, eventProcessing, "aws:s3", "Events Store");
+node(warehouse, eventProcessing, "aws:redshift", "Analytics");
+
+connect(toWorkers, source, workers);
+connect(toQueue, workers, queue);
+connect(toHandlers, queue, processing);
+connect(toStore, processing, store);
+connect(toAnalytics, processing, warehouse);
+
+message(event, source, "EVENT");
+
+hidden(eventProcessing.nodes);
+hidden(flows.parts); hidden(workers.parts); hidden(processing.parts);
+hidden(event.parts);
+untraced(toWorkers); untraced(toQueue); untraced(toHandlers);
+untraced(toStore); untraced(toAnalytics);
+
+step("source") {
+  par {
+    show(source, 0.45);
+    say(caption, "EKS is the source; the rest of the system is still only structure.", 0.40);
+  }
+}
+wait(0.25);
+
+step("ownership") {
+  par {
+    show(flows.parts, 0.50);
+    show(workers.parts, 0.45);
+    stagger(0.10) { show(worker1, 0.35); show(worker2, 0.35); show(worker3, 0.35); }
+    show(queue, 0.40);
+    show(processing.parts, 0.45);
+    stagger(0.10) { show(proc1, 0.35); show(proc2, 0.35); show(proc3, 0.35); }
+    show(store, 0.40); show(warehouse, 0.40);
+    say(caption, "Nested boundaries reveal ownership without hiding the individual services.", 0.40);
+  }
+}
+wait(0.20);
+
+step("possible-topology") {
+  par {
+    draw(toWorkers, 0.55);
+    draw(toQueue, 0.55);
+    draw(toHandlers, 0.55);
+    draw(toStore, 0.55); draw(toAnalytics, 0.55);
+    say(caption, "Every dashed edge is a possible relationship—not a claim that data is flowing.", 0.40);
+  }
+}
+wait(0.35);
+
+step("runtime-hot-path") {
+  par {
+    show(event.parts, 0.25);
+    hotpath(event, 6.20, 27);
+    say(caption, "The event now chooses valid branches and travels end-to-end as one continuous hot path.", 0.40);
+  }
+}
+wait(0.35);
+
+step("takeaway") {
+  par {
+    pulse(event.parts, 0.70);
+    say(caption, "Cold topology explains relationships. The moving dot proves what happened now.", 0.45);
+  }
+}
+wait(1.40);

package/examples/aws-three-tier-web-application.manic

@@ -0,0 +1,134 @@
+title("Designing and Building a Three-Tier Web Application Architecture on AWS");
+canvas("16:9");
+template("mono");
+
+let u = (w+h-abs(w-h))/1440;
+watermark(mark, (w*0.15, h*0.06), "Made With Manic");
+text(kicker, (cx, h*0.065), "AWS ARCHITECTURE · THREE TIERS");
+text(headline, (cx, h*0.145), "Designing a Three-Tier Web Application");
+text(caption, (cx, h*0.91), "Each tier has one responsibility—and the request keeps moving.");
+size(kicker, 17*u); color(kicker, dim); bold(kicker);
+size(headline, 32*u); bold(headline); wrap(headline, w*0.86);
+size(caption, 18*u); color(caption, dim); wrap(caption, w*0.84);
+
+if h > 1.25*w {
+  architecture(presentation, (cx, h*0.30), w*0.72, h*0.18);
+  architecture(application, (cx, h*0.52), w*0.72, h*0.18);
+  architecture(dataTier, (cx, h*0.74), w*0.72, h*0.18);
+  text(presentationLabel, (w*0.13, h*0.30), "1 · PRESENTATION");
+  text(applicationLabel, (w*0.13, h*0.52), "2 · APPLICATION");
+  text(dataLabel, (w*0.13, h*0.74), "3 · DATA");
+}
+else {
+  architecture(presentation, (w*0.20, h*0.50), w*0.27, h*0.55);
+  architecture(application, (w*0.50, h*0.50), w*0.27, h*0.55);
+  architecture(dataTier, (w*0.80, h*0.50), w*0.27, h*0.55);
+  text(presentationLabel, (w*0.20, h*0.235), "1 · PRESENTATION");
+  text(applicationLabel, (w*0.50, h*0.235), "2 · APPLICATION");
+  text(dataLabel, (w*0.80, h*0.235), "3 · DATA");
+}
+
+size(presentationLabel, 16*u); color(presentationLabel, cyan); bold(presentationLabel);
+size(applicationLabel, 16*u); color(applicationLabel, magenta); bold(applicationLabel);
+size(dataLabel, 16*u); color(dataLabel, gold); bold(dataLabel);
+
+node(dns, presentation, "aws:route53", "Route 53");
+node(cdn, presentation, "aws:cloudfront", "CloudFront");
+node(balancer, application, "aws:elb", "Load Balancer");
+node(app, application, "aws:ecs", "ECS Service");
+node(cache, dataTier, "aws:elasticache", "ElastiCache");
+node(database, dataTier, "aws:rds", "Amazon RDS");
+
+connect(resolvePath, dns, cdn);
+connect(toApplication, cdn, balancer);
+connect(toService, balancer, app);
+connect(toCache, app, cache);
+connect(toDatabase, cache, database);
+request(webRequest, dns, "GET /checkout");
+
+hidden(presentation.nodes); hidden(application.nodes); hidden(dataTier.nodes);
+untraced(resolvePath); untraced(toApplication); untraced(toService);
+untraced(toCache); untraced(toDatabase);
+hidden(webRequest.parts);
+
+step("three-responsibilities") {
+  par {
+    show(presentation.nodes, 0.55);
+    say(caption, "Presentation receives users, resolves DNS, and serves content from the edge.", 0.40);
+  }
+}
+wait(0.20);
+
+step("application-tier") {
+  par {
+    show(application.nodes, 0.55);
+    say(caption, "Application distributes traffic and runs stateless business logic.", 0.40);
+  }
+}
+wait(0.20);
+
+step("data-tier") {
+  par {
+    show(dataTier.nodes, 0.55);
+    say(caption, "Data accelerates repeated reads and persists durable records.", 0.40);
+  }
+}
+wait(0.25);
+
+step("connect-the-tiers") {
+  par {
+    stagger(0.10) {
+      draw(resolvePath, 0.35); draw(toApplication, 0.35); draw(toService, 0.35);
+      draw(toCache, 0.35); draw(toDatabase, 0.35);
+    }
+    show(webRequest.parts, 0.30);
+    say(caption, "Now follow one checkout request through the complete design.", 0.40);
+  }
+}
+wait(0.20);
+
+step("presentation-flow") {
+  par {
+    route(webRequest, resolvePath, 0.80, smooth);
+    say(caption, "Route 53 resolves the domain; CloudFront brings the experience closer to users.", 0.40);
+  }
+}
+
+step("load-balance") {
+  par {
+    route(webRequest, toApplication, 0.95, smooth);
+    say(caption, "The load balancer is the controlled entry into the application tier.", 0.40);
+  }
+}
+
+step("run-the-application") {
+  par {
+    route(webRequest, toService, 0.80, smooth);
+    say(caption, "ECS runs replicated application tasks without mixing them with stored data.", 0.40);
+  }
+}
+
+step("read-fast") {
+  par {
+    route(webRequest, toCache, 0.95, smooth);
+    say(caption, "ElastiCache answers hot reads quickly and protects the database from repeated work.", 0.40);
+  }
+}
+
+step("persist-safely") {
+  par {
+    route(webRequest, toDatabase, 0.80, smooth);
+    say(caption, "Amazon RDS remains the durable source of truth for the transaction.", 0.40);
+  }
+}
+wait(0.30);
+
+step("takeaway") {
+  par {
+    pulse(presentation.nodes, 0.70);
+    pulse(application.nodes, 0.70);
+    pulse(dataTier.nodes, 0.70);
+    say(caption, "Three tiers isolate delivery, computation, and state—so each can scale and evolve independently.", 0.45);
+  }
+}
+wait(1.40);

package/examples/band.manic

@@ -0,0 +1,43 @@
+title("The area between two curves");
+canvas("16:9");
+
+let ox = cx - 460;
+let oy = cy + 40;
+
+text(hdr, (cx, 58), "The region trapped between two curves");
+size(hdr, 26); color(hdr, cyan); bold(hdr); display(hdr); hidden(hdr);
+
+axes(ax, (ox, oy), 900, 260, 1);
+color(ax, dim); untraced(ax);
+
+// two curves over the same stretch of x
+plot(upper, (ox, oy), 140, 90, "0.4*x + 1.4", (0, 6.3));
+color(upper, cyan); stroke(upper, 3); untraced(upper);
+
+plot(lower, (ox, oy), 140, 90, "sin(x)", (0, 6.3));
+stroke(lower, 3);
+color(lower, magenta);
+untraced(lower);
+
+
+// the band between them
+band(gap, upper, lower);
+color(gap, lime); hidden(gap);
+
+text(cap, (cx + 405 - 383 - 21, h - 56 - 53 + 37 - 7), "band(top, bottom) fills the space between");
+size(cap, 20);
+display(cap);
+color(cap, dim);
+hidden(cap, center);
+
+
+// ---- timeline ----
+show(hdr, 0.6);
+draw(ax, 0.7);
+par {
+  draw(upper, 1.4);
+  draw(lower, 1.4);
+}
+wait(0.3);
+to(gap, opacity, 0.3, 0.6);   // fade in to translucent (so the curves read through)
+show(cap, 0.4);

package/examples/banner.manic

@@ -0,0 +1,37 @@
+// The manic banner & watermark (à la ManimBanner). "create" draws the icon
+// trio on; "expand" reveals the wordmark; the watermark persists in the corner.
+//
+//   manic examples/banner.manic
+//   manic examples/banner.manic --record out --fps 60
+
+title("manic");
+canvas(1280, 720);
+
+banner(logo, (600, 360), 1.1);
+untraced(logo.icon);     // icon shapes drawn on
+hidden(logo.word);       // wordmark revealed on "expand"
+
+// a persistent, screen-fixed watermark, bottom-right
+watermark(wm, (1120, 690), "manic // synthwave");
+
+text(cap, (640, 560), "");  color(cap, dim);  size(cap, 22);
+
+// --- create: trace the icon trio on (staggered) ---
+say(cap, "create");
+stagger(0.2) {
+  draw(logo.dot, 0.6);
+  draw(logo.sq, 0.6);
+  draw(logo.tri, 0.6);
+}
+par { pulse(logo.dot);  pulse(logo.sq);  pulse(logo.tri); }
+wait(0.4);
+
+// --- expand: reveal the wordmark ---
+say(cap, "expand");
+show(logo.word, 0.6);
+wait(1.2);
+
+// --- unwrite: fade the whole banner ---
+say(cap, "");
+par { fade(logo.icon, 0.5);  fade(logo.word, 0.5); }
+wait(0.8);

package/examples/bayes.manic

@@ -0,0 +1,27 @@
+// ============================================================================
+//  bayes.manic  —  Bayesian updating (stats Tier 5)
+// ----------------------------------------------------------------------------
+//  `bayes(id, (cx,cy), heads, tails, [width], [height])` — belief about a coin's
+//  bias: a mild PRIOR, the LIKELIHOOD from the data, and the POSTERIOR that
+//  combines them (pulled toward the data, sharpening as evidence grows). Pieces:
+//  `{id}.prior`, `{id}.likelihood`, `{id}.posterior`, `{id}.mean`.
+// ============================================================================
+
+title("Bayes: updating a belief with data");
+canvas("16:9");
+
+bayes(by, (cx, cy + 10), 7, 2, 640, 250);
+untraced(by.prior); untraced(by.likelihood); untraced(by.posterior);
+hidden(by.mean); hidden(by.priorlbl); hidden(by.postlbl); hidden(by.datalbl);
+
+text(cap, (cx, h - 46), ""); size(cap, 22); color(cap, dim); display(cap);
+
+say(cap, "before any flips, a mild belief: the coin is probably fair-ish (the prior)", 0.5);
+draw(by.prior, 0.8); show(by.priorlbl, 0.3);
+wait(1.4);
+say(cap, "then we flip: 7 heads, 2 tails — the data favours a biased coin (likelihood)", 0.5);
+draw(by.likelihood, 0.8); show(by.datalbl, 0.3);
+wait(1.6);
+say(cap, "combine them and the posterior lands between: p about 0.69", 0.5);
+draw(by.posterior, 0.8); show(by.mean, 0.4); show(by.postlbl, 0.3);
+wait(2.0);

package/examples/bellcurve.manic

@@ -0,0 +1,41 @@
+// ============================================================================
+//  normal.manic  —  the bell curve & the 68-95-99.7 rule (stats Tier 2)
+// ----------------------------------------------------------------------------
+//  `bellcurve(id, (cx,cy), mu, sigma, [unit], [color])` (alias `gaussian`) draws
+//  bell curve and shades the ±1σ/±2σ/±3σ bands — the 68-95-99.7 rule. Pieces:
+//  `{id}.curve` (the bell), `{id}.band1/2/3` (tagged `{id}.bands`), `{id}.mean`,
+//  `{id}.p1/p2/p3` (the percentages), `{id}.t{-3..3}` (value ticks).
+//  `unit` = pixels per σ; the bell is standardised, μ/σ set the axis values.
+//
+//  TO ADAPT: change mu/sigma to your distribution (heights, IQ, measurement
+//  error…). The 68-95-99.7 rule holds for every normal.
+// ============================================================================
+
+title("The bell curve & the 68-95-99.7 rule");
+canvas("16:9");
+
+// IQ scores: mean 100, standard deviation 15
+bellcurve(nd, (cx, cy + 10), 100, 15, 95);
+untraced(nd.curve);                // the bell draws in
+hidden(nd.mean);
+hidden(nd.bands);                  // the three σ-bands reveal one at a time
+hidden(nd.p1); hidden(nd.p2); hidden(nd.p3);
+
+text(cap, (cx, h - 46), ""); size(cap, 22); color(cap, dim); display(cap);
+
+say(cap, "IQ scores: mean 100, standard deviation 15 — the classic bell", 0.5);
+draw(nd.curve, 1.1);
+show(nd.mean, 0.4);
+wait(1.2);
+
+say(cap, "68% of values fall within ONE standard deviation of the mean", 0.5);
+to(nd.band1, opacity, 0.16, 0.6); show(nd.p1, 0.4);
+wait(1.7);
+
+say(cap, "95% fall within two — almost everyone", 0.5);
+to(nd.band2, opacity, 0.16, 0.6); show(nd.p2, 0.4);
+wait(1.7);
+
+say(cap, "and 99.7% within three: the tails are tiny", 0.5);
+to(nd.band3, opacity, 0.16, 0.6); show(nd.p3, 0.4);
+wait(1.9);

package/examples/bfs_dfs.manic

@@ -0,0 +1,35 @@
+// Graph Traversal — BFS vs DFS, the classic side-by-side. They're the SAME
+// algorithm; only the frontier differs: BFS uses a QUEUE (explore level by
+// level), DFS uses a STACK (dive deep first). `bfs(g, start)` / `dfs(g, start)`
+// read the graph's adjacency, run the traversal, and animate the textbook
+// states — discovered (cyan) -> current (magenta) -> done (lime) — with tree
+// edges lighting up and live `queue:` / `stack:` + `visited:` readouts.
+//
+//   manic examples/bfs_dfs.manic
+
+title("Graph Traversal");
+canvas("16:9");
+
+text(head, (cx, 56), "BFS vs DFS: same graph, queue vs stack");
+display(head);  color(head, cyan);  size(head, 26);  hidden(head);
+text(cap, (cx, 690), "");  color(cap, dim);  size(cap, 24);
+
+graph(gr, "a b c d e f g", "a-b a-c b-d b-e c-f c-g", circular, (cx, 320), 200, 30);
+
+show(head, 0.5);
+wait(0.4);
+
+section("BFS");
+say(cap, "BFS explores level by level, using a QUEUE");
+bfs(gr, a);
+say(cap, "queue order: a, then b c, then d e f g");
+wait(0.8);
+
+section("DFS");
+par { recolor(gr.nodes, panel, 0.4);  recolor(gr.edges, dim, 0.4); }
+say(gr.frontier, "stack:");
+say(gr.visited, "visited:");
+say(cap, "DFS dives deep down one branch, using a STACK");
+dfs(gr, a);
+say(cap, "the stack drove it depth-first before backtracking");
+wait(1.2);