@maniclang/workbench 0.1.11

package/examples/k8s-cluster-components.manic

@@ -0,0 +1,82 @@
+title("Kubernetes Cluster Components");
+canvas("16:9");
+template("neon");
+
+// ---- boxes (drawn first, behind; hollow-ish so icons read on top) ----
+rect(clusterBox, (800, 380), 880, 560);   outline(clusterBox, dim); opacity(clusterBox, 0.22);
+rect(cpBox,      (575, 440), 400, 430);    outline(cpBox, cyan);    opacity(cpBox, 0.28);
+rect(node1Box,   (1000, 320), 400, 150);   outline(node1Box, dim);  opacity(node1Box, 0.35);
+rect(node2Box,   (1000, 520), 400, 150);   outline(node2Box, dim);  opacity(node2Box, 0.35);
+
+text(clusterLabel, (470, 130), "Kubernetes cluster"); size(clusterLabel, 26); bold(clusterLabel);
+text(cpLabel, (490, 250), "Control Plane"); size(cpLabel, 20); color(cpLabel, cyan); bold(cpLabel);
+text(n1Label, (855, 268), "Node"); size(n1Label, 18); color(n1Label, dim); bold(n1Label);
+text(n2Label, (855, 468), "Node"); size(n2Label, 18); color(n2Label, dim); bold(n2Label);
+
+// ---- cloud provider API (outside the cluster, left) ----
+ellipse(cloud, (165, 360), 210, 120); outline(cloud, blue); opacity(cloud, 0.30);
+text(cloudLabel, (165, 360), "Cloud provider\nAPI"); size(cloudLabel, 20); color(cloudLabel, blue); bold(cloudLabel);
+
+// ---- control-plane connections (api is the hub) ----
+line(lCm,   (615, 400), (615, 320));   stroke(lCm, 3);
+line(lSched,(615, 485), (615, 560));   stroke(lSched, 3);
+line(lEtcd, (590, 465), (505, 500));   stroke(lEtcd, 3);
+line(lCcmApi, (505, 375), (580, 425)); stroke(lCcmApi, 3); dashed(lCcmApi, 9, 7);
+arrow(aCloud, (440, 360), (270, 360)); stroke(aCloud, 3);
+line(lN1, (800, 320), (660, 425));     stroke(lN1, 3);
+line(lN2, (800, 520), (660, 450));     stroke(lN2, 3);
+
+// ---- component icons (placed at the reference positions) ----
+image(api,   (615, 440), "asset:diagrams/k8s/controlplane/api.png", 62, 62);
+image(cm,    (615, 285), "asset:diagrams/k8s/controlplane/c-m.png", 58, 58);
+image(sched, (615, 590), "asset:diagrams/k8s/controlplane/sched.png", 58, 58);
+image(ccm,   (470, 360), "asset:diagrams/k8s/controlplane/c-c-m.png", 58, 58);
+image(etcd,  (470, 510), "asset:diagrams/k8s/infra/etcd.png", 58, 58);
+image(kubelet1, (890, 335), "asset:diagrams/k8s/controlplane/kubelet.png", 54, 54);
+image(kproxy1,  (1100, 335), "asset:diagrams/k8s/controlplane/k-proxy.png", 54, 54);
+image(kubelet2, (890, 535), "asset:diagrams/k8s/controlplane/kubelet.png", 54, 54);
+image(kproxy2,  (1100, 535), "asset:diagrams/k8s/controlplane/k-proxy.png", 54, 54);
+
+// ---- icon captions ----
+text(tApi, (615, 478), "api"); size(tApi, 15);
+text(tCm, (615, 320), "c-m"); size(tCm, 15);
+text(tSched, (615, 625), "sched"); size(tSched, 15);
+text(tCcm, (470, 395), "c-c-m"); size(tCcm, 15);
+text(tEtcd, (470, 545), "etcd"); size(tEtcd, 15);
+text(tKl1, (890, 370), "kubelet"); size(tKl1, 14);
+text(tKp1, (1100, 370), "k-proxy"); size(tKp1, 14);
+text(tKl2, (890, 570), "kubelet"); size(tKl2, 14);
+text(tKp2, (1100, 570), "k-proxy"); size(tKp2, 14);
+
+// ---- data flow: ordinary manic verbs on the hand-drawn wires (NO systems kit) ----
+text(cap, (cx, h*0.95), "Every component talks through the API server."); size(cap, 20); color(cap, dim); wrap(cap, w*0.8);
+dot(packet, (800, 320), 11); color(packet, lime); hidden(packet);
+
+wait(0.5);
+par {
+  flow(lN1, 1.0); flow(lN2, 1.0);
+  say(cap, "kubelets report node and pod status up to the API server", 0.4);
+}
+par {
+  flow(lCm, 1.0); flow(lSched, 1.0);
+  say(cap, "the scheduler and controllers act only through the API server", 0.4);
+}
+par {
+  flow(lEtcd, 1.0);
+  say(cap, "the API server reads and writes all cluster state in etcd", 0.4);
+}
+par {
+  flow(aCloud, 1.0);
+  say(cap, "the cloud-controller-manager provisions infrastructure via the cloud API", 0.4);
+}
+wait(0.2);
+par {
+  show(packet, 0.2);
+  say(cap, "one node update: kubelet -> API server -> etcd", 0.4);
+}
+seq {
+  travel(packet, lN1, 0.9, smooth);
+  travel(packet, lEtcd, 0.9, smooth);
+}
+pulse(api, 0.7);
+wait(1.4);

package/examples/k8s-stateful-architecture.manic

@@ -0,0 +1,134 @@
+title("A Stateful Set on Kubernetes — Pods, Claims, and Volumes");
+canvas("16:9");
+template("neon");
+
+let u = (w+h-abs(w-h))/1440;
+watermark(mark, (w*0.15, h*0.045), "Made With Manic");
+text(kicker, (cx, h*0.05), "KUBERNETES · STATEFUL ARCHITECTURE");
+text(headline, (cx, h*0.11), "Every replica keeps its own storage.");
+text(caption, (cx, h*0.94), "Dashed relationships show every route the architecture allows.");
+size(kicker, 15*u); color(kicker, dim); bold(kicker);
+size(headline, 26*u); bold(headline); wrap(headline, w*0.88);
+size(caption, 17*u); color(caption, dim); wrap(caption, w*0.86);
+
+architecture(stateful, (cx, h*0.52), w*0.94, h*0.72);
+
+cluster(apps, stateful, "APPS");
+node(svc, apps, "k8s:svc", "svc");
+node(sts, apps, "k8s:sts", "sts");
+
+cluster(pods, stateful, "PODS");
+for i in 0..3 {
+  node(pod{i}, pods, "k8s:pod", "pod");
+}
+
+cluster(claims, stateful, "CLAIMS");
+for i in 0..3 {
+  node(pvc{i}, claims, "k8s:pvc", "pvc");
+}
+
+cluster(storage, stateful, "STORAGE");
+node(pv, storage, "k8s:pv", "pv");
+node(sc, storage, "k8s:sc", "sc");
+
+// topology: svc >> pod >> pvc, pod - sts - pvc, and sc >> pv >> pvc (provisioning)
+for i in 0..3 {
+  connect(svcPod{i}, svc, pod{i});
+  connect(podPvc{i}, pod{i}, pvc{i});
+  connect(podSts{i}, pod{i}, sts);
+  connect(stsPvc{i}, sts, pvc{i});
+  connect(pvPvc{i}, pv, pvc{i});
+}
+connect(scPv, sc, pv);
+
+// --- colour every path by its RELATIONSHIP (cold dashed line + hot overlay) ---
+for i in 0..3 {
+  color(svcPod{i}, cyan);      // ACCESS
+  color(podPvc{i}, cyan);
+  color(podSts{i}, magenta);   // OWNERSHIP
+  color(stsPvc{i}, magenta);
+  color(pvPvc{i}, gold);       // PROVISIONING
+}
+color(scPv, gold); color(scPv.hot, gold);
+text(legAcc, (w*0.30, h*0.175), "ACCESS"); size(legAcc, 13); color(legAcc, cyan); bold(legAcc);
+text(legOwn, (w*0.46, h*0.175), "OWNERSHIP"); size(legOwn, 13); color(legOwn, magenta); bold(legOwn);
+text(legProv, (w*0.64, h*0.175), "PROVISIONING"); size(legProv, 13); color(legProv, gold); bold(legProv);
+hidden(legAcc); hidden(legOwn); hidden(legProv);
+
+hidden(stateful.nodes);
+hidden(apps.parts); hidden(pods.parts); hidden(claims.parts); hidden(storage.parts);
+for i in 0..3 {
+  untraced(svcPod{i}); untraced(podPvc{i}); untraced(podSts{i});
+  untraced(stsPvc{i}); untraced(pvPvc{i});
+}
+untraced(scPv);
+
+step("apps") {
+  par {
+    show(apps.parts, 0.5);
+    show(svc, 0.4); show(sts, 0.4);
+    show(pods.parts, 0.4);
+    stagger(0.08) { show(pod0, 0.35); show(pod1, 0.35); show(pod2, 0.35); }
+    show(claims.parts, 0.4);
+    stagger(0.08) { show(pvc0, 0.35); show(pvc1, 0.35); show(pvc2, 0.35); }
+    say(caption, "A Service fronts three pods; a StatefulSet gives each pod a stable identity and claim.", 0.40);
+  }
+}
+wait(0.20);
+
+step("storage") {
+  par {
+    show(storage.parts, 0.45);
+    show(pv, 0.4); show(sc, 0.4);
+    say(caption, "A StorageClass provisions PersistentVolumes that back each PersistentVolumeClaim.", 0.40);
+  }
+}
+wait(0.25);
+
+step("possible-topology") {
+  par {
+    stagger(0.05) {
+      draw(svcPod0, 0.35); draw(svcPod1, 0.35); draw(svcPod2, 0.35);
+      draw(podPvc0, 0.35); draw(podPvc1, 0.35); draw(podPvc2, 0.35);
+      draw(podSts0, 0.35); draw(podSts1, 0.35); draw(podSts2, 0.35);
+      draw(stsPvc0, 0.35); draw(stsPvc1, 0.35); draw(stsPvc2, 0.35);
+      draw(scPv, 0.35);
+      draw(pvPvc0, 0.35); draw(pvPvc1, 0.35); draw(pvPvc2, 0.35);
+    }
+    show(legAcc, 0.3); show(legOwn, 0.3); show(legProv, 0.3);
+    say(caption, "Every dashed edge is a relationship: routing, ownership, and storage binding together.", 0.40);
+  }
+}
+wait(0.30);
+
+step("app-access") {
+  par {
+    stagger(0.12) {
+      seq { flow(svcPod0, 0.7); flow(podPvc0, 0.7); }
+      seq { flow(svcPod1, 0.7); flow(podPvc1, 0.7); }
+      seq { flow(svcPod2, 0.7); flow(podPvc2, 0.7); }
+    }
+    say(caption, "Traffic: the Service reaches a pod, which reads and writes its own claim.", 0.40);
+  }
+}
+wait(0.25);
+
+step("provisioning") {
+  par {
+    seq {
+      flow(scPv, 0.8);
+      par { flow(pvPvc0, 0.8); flow(pvPvc1, 0.8); flow(pvPvc2, 0.8); }
+    }
+    say(caption, "Provisioning: the StorageClass creates PVs that bind to each claim.", 0.40);
+  }
+}
+wait(0.30);
+
+step("takeaway") {
+  par {
+    pulse(apps.parts, 0.7);
+    pulse(storage.parts, 0.7);
+    say(caption, "Stateful means identity plus durable storage—one claim and volume per replica.", 0.45);
+  }
+}
+wait(1.40);

package/examples/k8s-three-tier.manic

@@ -0,0 +1,146 @@
+title("A Three-Tier Application on Kubernetes — Following One Request");
+canvas("16:9");
+template("neon");
+
+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), "KUBERNETES · THREE TIERS · ONE DATA FLOW");
+text(headline, (cx, h*0.145), "A Three-Tier App on Kubernetes");
+text(caption, (cx, h*0.91), "Ingress in, pods compute, state persists — 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(ingress, presentation, "k8s:ing", "Ingress");
+node(web, presentation, "k8s:deploy", "web Deployment x3");
+node(apisvc, application, "k8s:svc", "api Service");
+node(api, application, "k8s:deploy", "api Deployment x3");
+node(cache, dataTier, "onprem:redis", "Redis");
+node(database, dataTier, "onprem:postgresql", "PostgreSQL (StatefulSet)");
+
+connect(toWeb, ingress, web);
+connect(toApiSvc, web, apisvc);
+connect(toApi, apisvc, api);
+connect(toCache, api, cache);
+connect(toDatabase, cache, database);
+request(userRequest, ingress, "GET /checkout");
+
+// --- colour every path by its RELATIONSHIP (cold dashed line + hot overlay) ---
+color(toWeb, cyan);        color(toWeb.hot, cyan);
+color(toApiSvc, cyan);     color(toApiSvc.hot, cyan);
+color(toApi, cyan);        color(toApi.hot, cyan);
+color(toCache, magenta);   color(toCache.hot, magenta);
+color(toDatabase, gold);   color(toDatabase.hot, gold);
+// legend
+text(legReq, (w*0.30, h*0.175), "REQUEST"); size(legReq, 13); color(legReq, cyan); bold(legReq);
+text(legCache, (w*0.48, h*0.175), "CACHE"); size(legCache, 13); color(legCache, magenta); bold(legCache);
+text(legDb, (w*0.62, h*0.175), "PERSIST"); size(legDb, 13); color(legDb, gold); bold(legDb);
+hidden(legReq); hidden(legCache); hidden(legDb);
+hidden(presentation.nodes); hidden(application.nodes); hidden(dataTier.nodes);
+untraced(toWeb); untraced(toApiSvc); untraced(toApi);
+untraced(toCache); untraced(toDatabase);
+hidden(userRequest.parts);
+
+step("presentation-tier") {
+  par {
+    show(presentation.nodes, 0.55);
+    say(caption, "Presentation: the Ingress terminates traffic and routes it to the web pods.", 0.40);
+  }
+}
+wait(0.20);
+
+step("application-tier") {
+  par {
+    show(application.nodes, 0.55);
+    say(caption, "Application: a Service load-balances across stateless api pods that scale on demand.", 0.40);
+  }
+}
+wait(0.20);
+
+step("data-tier") {
+  par {
+    show(dataTier.nodes, 0.55);
+    say(caption, "Data: Redis serves hot reads; a PostgreSQL StatefulSet holds durable state.", 0.40);
+  }
+}
+wait(0.25);
+
+step("connect-the-tiers") {
+  par {
+    stagger(0.10) {
+      draw(toWeb, 0.35); draw(toApiSvc, 0.35); draw(toApi, 0.35);
+      draw(toCache, 0.35); draw(toDatabase, 0.35);
+    }
+    show(userRequest.parts, 0.30);
+    show(legReq, 0.3); show(legCache, 0.3); show(legDb, 0.3);
+    say(caption, "Now follow one checkout request through the whole cluster.", 0.40);
+  }
+}
+wait(0.20);
+
+step("ingress-to-web") {
+  par {
+    route(userRequest, toWeb, 0.85, smooth);
+    say(caption, "The Ingress forwards the request to a web pod via the Service.", 0.40);
+  }
+}
+
+step("web-to-api") {
+  par {
+    route(userRequest, toApiSvc, 0.90, smooth);
+    say(caption, "The web tier calls the api Service — one controlled entry into business logic.", 0.40);
+  }
+}
+
+step("into-a-pod") {
+  par {
+    route(userRequest, toApi, 0.80, smooth);
+    say(caption, "The Service load-balances into one replicated api pod.", 0.40);
+  }
+}
+
+step("read-fast") {
+  par {
+    route(userRequest, toCache, 0.90, smooth);
+    say(caption, "Redis answers the hot read first, shielding the database from repeated work.", 0.40);
+  }
+}
+
+step("persist-safely") {
+  par {
+    route(userRequest, toDatabase, 0.85, smooth);
+    say(caption, "On a miss, the PostgreSQL StatefulSet is the durable source of truth.", 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, "Ingress, Services, Deployments and a StatefulSet keep delivery, compute, and state independent.", 0.45);
+  }
+}
+wait(1.40);

package/examples/kapitza.manic

@@ -0,0 +1,11 @@
+// kapitza.manic — vibrate the pivot fast enough and the pendulum stands UP.
+//   kapitza(id,[center],[angle0deg],[vibeamp],[unit]) — a driven (Kapitza) pendulum;
+//   with a strong enough vibration the INVERTED position becomes stable.
+title("Kapitza pendulum — stable upside-down");
+canvas("16:9");
+text(hdr,(cx,44),"Kapitza pendulum — fast pivot vibration stabilises 'up'");
+size(hdr,23); color(hdr,cyan); bold(hdr); display(hdr);
+kapitza(kp, (640,430), 165, 240, 150);   // start near inverted, strong vibration
+untraced(kp.path);
+text(cap,(cx,h-32),"the gold pivot bobs fast; the bob hovers near the top (inverted)"); size(cap,16); color(cap,dim); display(cap);
+par { run(kp, 9); draw(kp.path, 9); }

package/examples/latex-disintegration.manic

@@ -0,0 +1,123 @@
+// A semantic LaTeX story: notation changes, meaning becomes position, and the
+// final symbols may disappear without taking the mathematical result with them.
+
+title("The Equation Disappears. The Roots Remain.");
+canvas("9:16");
+template("blank");
+
+watermark(mark,(w*0.16,h*0.050),"Made With Manic");
+text(kicker,(cx,h*0.085),"ALGEBRA · SYMBOLS → STRUCTURE");
+text(headline,(cx,h*0.145),"What survives when an equation disappears?");
+text(caption,(cx,h*0.77),"Two solutions are hiding inside one quadratic.");
+text(cta,(cx,h*0.90),"MAKE MEANING MOVE → 8gwifi.org/manic");
+size(kicker,19); color(kicker,dim); bold(kicker); hidden(kicker);
+size(headline,33); bold(headline); wrap(headline,w*0.84); hidden(headline);
+size(caption,22); color(caption,dim); wrap(caption,w*0.82); hidden(caption);
+size(cta,22); color(cta,cyan); bold(cta); hidden(cta);
+
+text(symbolLabel,(w*0.18,h*0.29),"THE SYMBOLS");
+text(meaningLabel,(w*0.18,h*0.54),"THE MEANING");
+size(symbolLabel,18); color(symbolLabel,dim); bold(symbolLabel); hidden(symbolLabel);
+size(meaningLabel,18); color(meaningLabel,dim); bold(meaningLabel); hidden(meaningLabel);
+
+equation(work,(cx,h*0.39),`x^2-5x+6=0`,66);
+hidden(work);
+
+let axisY = h*0.63;
+let axisLeft = w*0.16;
+let axisRight = w*0.84;
+let x0 = w*0.20;
+let dx = w*0.15;
+
+arrow(numberAxis,(axisLeft,axisY),(axisRight,axisY));
+color(numberAxis,dim); stroke(numberAxis,3);
+tag(numberAxis,numberLine);
+
+for i in 0..5 {
+  line(tick{i},(x0+i*dx,axisY-13),(x0+i*dx,axisY+13));
+  color(tick{i},dim); stroke(tick{i},3);
+  tag(tick{i},numberLine);
+}
+
+text(n0,(x0,axisY+42),"0");
+text(n1,(x0+dx,axisY+42),"1");
+text(n2,(x0+2*dx,axisY+42),"2");
+text(n3,(x0+3*dx,axisY+42),"3");
+text(n4,(x0+4*dx,axisY+42),"4");
+size(n0,18); size(n1,18); size(n2,18); size(n3,18); size(n4,18);
+color(n0,dim); color(n1,dim); color(n2,dim); color(n3,dim); color(n4,dim);
+tag(n0,numberLine); tag(n1,numberLine); tag(n2,numberLine);
+tag(n3,numberLine); tag(n4,numberLine);
+
+circle(root2,(x0+2*dx,axisY),15);
+circle(root3,(x0+3*dx,axisY),15);
+filled(root2); filled(root3);
+color(root2,cyan); color(root3,orange);
+glow(root2,0.72); glow(root3,0.72);
+tag(root2,solutions); tag(root3,solutions);
+
+equation(root2Label,(x0+2*dx,axisY-62),`x=2`,30);
+equation(root3Label,(x0+3*dx,axisY-62),`x=3`,30);
+color(root2Label,cyan); color(root3Label,orange);
+tag(root2Label,solutions); tag(root3Label,solutions);
+
+hidden(numberLine);
+hidden(solutions);
+
+step("find what is hiding") {
+  par {
+    show(kicker,0.30);
+    show(headline,0.45);
+    show(symbolLabel,0.35);
+    show(caption,0.40);
+    show(work,0.55);
+  }
+}
+wait(0.55);
+
+step("expose the two conditions") {
+  par {
+    rewrite(work,`\textcolor{cyan}{(x-2)}\textcolor{orange}{(x-3)}=0`,1.15,smooth);
+    say(caption,"Factoring reveals two independent ways for the product to become zero.",0.45);
+  }
+}
+wait(0.55);
+
+step("turn answers into positions") {
+  par {
+    rewrite(work,`\textcolor{cyan}{x=2}\qquad\text{or}\qquad\textcolor{orange}{x=3}`,1.05,smooth);
+    seq {
+      show(meaningLabel,0.30);
+      show(numberLine,0.55);
+      show(root2,0.35);
+      show(root2Label,0.30);
+      wait(0.18);
+      show(root3,0.35);
+      show(root3Label,0.30);
+    }
+    say(caption,"The answers are no longer only symbols—they now occupy exact locations.",0.45);
+  }
+}
+wait(0.70);
+
+step("remove the notation, keep the result") {
+  par {
+    disintegrate(work,1.60);
+    seq {
+      wait(0.35);
+      pulse(root2,0.60);
+      pulse(root3,0.60);
+    }
+    say(caption,"The notation can turn to dust. The two solutions remain exactly where they belong.",0.45);
+  }
+}
+wait(0.75);
+
+step("create explanations that preserve meaning") {
+  par {
+    pulse(solutions,0.75);
+    show(cta,0.45);
+    say(caption,"Great visual explanations do more than move symbols—they reveal what those symbols mean.",0.45);
+  }
+}
+wait(1.45);

package/examples/lens-paper.manic

@@ -0,0 +1,36 @@
+// ============================================================================
+//  lens-paper.manic  —  a converging lens as a textbook figure (annotated)
+// ----------------------------------------------------------------------------
+//  The `lens` sim inked on paper, narrated by a TYPEWRITER caption (a different
+//  elevation lens from refraction-paper's camera), with labelled parallel rays
+//  and focal point while `run` sweeps the focal length. Ideal thin lens.
+// ============================================================================
+
+title("Converging Lens");
+canvas("16:9");
+template("paper");
+
+lens(l, (640, 360));
+
+// ---- textbook annotations (screen-fixed) ----
+text(inlab, (150, 250), "parallel rays"); color(inlab, dim); size(inlab, 22); sticky(inlab);
+text(flab,  (980, 300), "focal point F"); color(flab, dim); size(flab, 22); sticky(flab);
+arrow(farr, (980, 320), (900, 356));     color(farr, dim); sticky(farr);
+
+// a typewriter caption performs the narration (untraced → type reveals it)
+text(cap, (cx, h - 48), "a lens bends parallel light to a single point"); color(cap, fg); size(cap, 26); bold(cap); untraced(cap); sticky(cap);
+
+// ================= THE SCENE =================
+type(cap, 1.6);                    // type the line out
+wait(0.4);
+
+par {
+  run(l, 8);
+  seq {
+    wait(0.6);
+    say(cap, "every ray meets at the focus, F", 0.3);
+    wait(2.8);
+    say(cap, "a shorter focal length is a stronger lens — F slides in", 0.3);
+  }
+}
+wait(1.2);

package/examples/lens-prescription.manic

@@ -0,0 +1,33 @@
+// ============================================================================
+//  lens-prescription.manic  —  type your OWN lens (real prescription)
+// ----------------------------------------------------------------------------
+//  `lenssystem` takes a lens two ways: pick a real design by NAME
+//  ("plano-convex" / "meniscus" / "doublet" / "triplet" / …), or write a CUSTOM
+//  prescription — the lens designer's surface table — as "radius thickness glass"
+//  per surface, separated by "|". Here: a cemented crown+flint achromat, traced
+//  through its actual spherical surfaces with real glass (Sellmeier).
+// ============================================================================
+
+title("A Lens, By Prescription");
+canvas("16:9");
+
+// surface table:  radius  thickness  glass   (| between surfaces; "flat"/"air" allowed)
+lenssystem(l, (600, 380), "160 26 bk7 | -140 8 f2 | -420 0 air");
+
+text(cap, (cx, h - 46), ""); color(cap, fg); size(cap, 24); bold(cap); display(cap); sticky(cap);
+
+// ================= THE SCENE =================
+say(cap, "a lens written as a prescription: radius · thickness · glass", 0.5);
+draw(l.rays, 2.2);                  // trace the real surfaces
+wait(0.4);
+
+par {
+  run(l, 6);                        // sweep the sensor to best focus
+  seq {
+    say(cap, "crown + flint, cemented — the same table a designer would type", 0.3);
+    wait(2.6);
+    say(cap, "traced through the true spherical surfaces (real Sellmeier glass)", 0.3);
+    wait(2.0);
+  }
+}
+wait(1.0);

package/examples/lens-system.manic

@@ -0,0 +1,34 @@
+// ============================================================================
+//  lens-system.manic  —  a REAL lens, ray-traced (best of physics + manic)
+// ----------------------------------------------------------------------------
+//  `lenssystem` traces a parallel beam through the ACTUAL spherical surfaces of
+//  a lens (not the ideal thin lens of `lens`). Here the fast singlet reveals
+//  SPHERICAL ABERRATION: sketch the rays on with `draw`, then `run` sweeps a
+//  sensor plane along the axis while the live spot read-out dips to its minimum
+//  — which never reaches a point, because the outer rays focus short. Then swap
+//  the caption's promise: that's the flaw a doublet/triplet is built to fix.
+// ============================================================================
+
+title("Spherical Aberration — a Real Lens Traced");
+canvas("16:9");
+
+lenssystem(ls, (620, 380), "singlet");
+
+text(cap, (cx, h - 42), ""); color(cap, fg); size(cap, 24); bold(cap); display(cap); sticky(cap);
+
+// ================= THE SCENE =================
+say(cap, "a parallel beam into a real, fast single lens…", 0.5);
+draw(ls.rays, 2.2);                 // the rays sketch through the glass
+wait(0.3);
+
+par {
+  run(ls, 6);                       // the sensor plane sweeps the axis
+  seq {
+    say(cap, "a sensor hunts for focus — watch the spot size", 0.3);
+    wait(2.4);
+    say(cap, "the outer rays focus SHORT — it never reaches a point", 0.3);
+    wait(2.0);
+    say(cap, "that blur is spherical aberration (a doublet/triplet fixes it)", 0.3);
+  }
+}
+wait(1.2);

package/examples/lens.manic

@@ -0,0 +1,31 @@
+// ============================================================================
+//  lens.manic  —  a converging lens, and where it focuses (real optics)
+// ----------------------------------------------------------------------------
+//  The `optics` kit's `lens` builtin: a beam of parallel rays is bent by a
+//  converging lens to meet at the focal point F. `run` SWEEPS the focal length,
+//  so you watch the focus slide in toward the lens — a shorter focal length is
+//  a stronger lens. Ideal thin lens (every parallel ray passes through F).
+// ============================================================================
+
+title("Converging Lens");
+canvas("16:9");
+
+lens(l, (620, 360));
+
+text(cap, (cx, h - 46), ""); color(cap, fg); size(cap, 24); bold(cap); display(cap); sticky(cap);
+
+// ================= THE SCENE =================
+say(cap, "parallel light meets a converging lens…", 0.5);
+wait(0.5);
+
+par {
+  run(l, 7);
+  seq {
+    say(cap, "every ray bends to the SAME point — the focus, F", 0.3);
+    wait(2.6);
+    say(cap, "shorter focal length = a stronger lens → the focus slides IN", 0.3);
+    wait(2.4);
+    say(cap, "past F the rays cross and spread apart again", 0.3);
+  }
+}
+wait(1.2);

package/examples/limit-infinity.manic

@@ -0,0 +1,30 @@
+title("A limit at infinity — limit(id, curve, inf)");
+canvas("16:9");
+
+let ox = 90;          // x = 0 near the left
+let oy = cy + 250;    // y = 0 baseline
+
+text(hdr, (cx, 52), "(5x^3 - 2x + 7) / (x^3 + 4x^2 + 3)  ->  5  as x -> infinity");
+size(hdr, 24); color(hdr, cyan); bold(hdr); display(hdr); hidden(hdr);
+
+text(sub, (cx, 92), "same degree top and bottom: the ratio of leading coefficients, 5/1");
+size(sub, 17); color(sub, dim); display(sub); hidden(sub);
+
+// the x-axis (y = 0)
+line(xaxis, (ox, oy), (ox + 1130, oy));
+color(xaxis, dim); untraced(xaxis);
+
+// the rational function, climbing toward its asymptote
+plot(f, (ox, oy), 9, 88, "(5*x*x*x - 2*x + 7)/(x*x*x + 4*x*x + 3)", (0.5, 125));
+color(f, cyan); stroke(f, 4); untraced(f);
+
+// the limit at infinity: auto-detects the horizontal asymptote y = 5
+limit(lim, f, inf);
+color(lim, gold); hidden(lim);
+
+// ---- timeline ----
+show(hdr, 0.6);
+show(sub, 0.4);
+draw(xaxis, 0.5);
+draw(f, 2.4);
+show(lim, 0.7);