@maniclang/workbench 0.1.11

package/examples/motion-graphics.manic

@@ -0,0 +1,81 @@
+// motion-graphics.manic — persistent objects, paths, particles, and a clean settle
+
+title("Motion Graphics Essentials");
+canvas("9:16");
+template("mono");
+watermark(manicMark, (150, 145), "Made With Manic");
+
+let accent = 194;
+let warm = 38;
+
+text(kicker, (540, 170), "MOTION GRAPHICS");
+size(kicker, 24); color(kicker, dim);
+text(headline, (540, 245), "Keep the object. Change its state.");
+size(headline, 42);
+
+rect(chamber, (540, 535), 700, 300);
+outline(chamber, dim); outlined(chamber); stroke(chamber, 3);
+rect(startCell, (350, 535), 290, 270); hidden(startCell);
+particles(dots, startCell, 36, 6, 23);
+hue(dots, accent, 0.58, 0.72); glow(dots, 0.7);
+text(note, (540, 835), "random layout · organic deterministic routes");
+size(note, 25); color(note, dim);
+
+plot(path, (245, 1120), 145, 175, "1-exp(-1.4*x)", (0, 3.8));
+hue(path, warm, 0.60, 0.70); stroke(path, 5); untraced(path);
+dot(marker, (245, 1120), 9); color(marker, fg); glow(marker, 1.0);
+text(pathNote, (540, 1215), "travel moves the real marker — then it stays");
+size(pathNote, 25); color(pathNote, dim);
+
+line(connector, (245, 1120), (835, 850)); hidden(connector);
+plot(pathMorph, (245, 1120), 145, 175, "1-exp(-1.4*x)", (0, 3.8));
+hue(pathMorph, warm, 0.60, 0.70); stroke(pathMorph, 5);
+morph(pathMorph, connector); hidden(pathMorph);
+
+circle(orbit, (540, 535), 245); hidden(orbit);
+
+step("scatter") {
+  seq {
+    par {
+      seq { arrange(dots, chamber, "random", 1.25, out); wander(dots, 1.75); }
+      seq { wait(0.25); say(note, "same dots · natural motion · repeatable render", 0.45); }
+    }
+  }
+}
+
+step("follow-a-path") {
+  seq {
+    par {
+      draw(path, 2.4, smooth);
+      travel(marker, path, 2.4, smooth);
+    }
+    wait(0.45);
+  }
+}
+
+step("preserve-the-path") {
+  seq {
+    par {
+      fade(path, 0.20);
+      show(pathMorph, 0.10);
+      to(pathMorph, morph, 1, 0.90, smooth);
+      say(pathNote, "morph keeps an open path open", 0.45);
+    }
+    wait(0.45);
+  }
+}
+
+step("arrive-and-settle") {
+  seq {
+    par {
+      arrange(dots, orbit, "ring", 1.15, smooth);
+      fade(chamber, 0.35);
+      seq { wait(0.45); say(note, "ring arrival", 0.35); }
+    }
+    par {
+      transform(dots, (540,535), 0.9659, -0.2588, 0.2588, 0.9659, 0.50, out);
+      say(note, "brief motion → a deliberate stop", 0.35);
+    }
+    wait(1.20);
+  }
+}

package/examples/multivariable3.manic

@@ -0,0 +1,26 @@
+title("Calculus on a surface — gradient, tangent plane, volume");
+canvas("16:9");
+
+camera3((8, -10, 7), (0, 0, 0.8), 42);
+axes3(world, (0, 0, 0), 3);
+color(world, dim);
+
+// a smooth hill: z = 1.6 e^(-(x^2 + y^2)/3.6)
+surface3(hill, "1.6*exp(-(x*x + y*y)*0.28)", (-3, 3), (-3, 3), 28);
+color(hill, cyan); untraced(hill);
+
+// the tangent plane at a point on the slope
+tangentplane3(tp, hill, 1.1, -0.7);
+color(tp, magenta); hidden(tp);
+
+// the gradient there — an arrow pointing straight up the steepest slope
+gradient3(grad, hill, 1.1, -0.7);
+color(grad, gold); hidden(grad);
+
+// ---- timeline ----
+show(world, 0.6);
+draw(hill, 1.8);
+wait(0.4);
+show(tp, 0.6);
+show(grad, 0.6);
+orbit3(70, 30, 15, 4.5);

package/examples/mystory.manic

@@ -0,0 +1,9 @@
+title("mystory");
+canvas("16:9");
+
+// Build your story here.
+
+// BEGIN WORKBENCH CANVAS
+// Scene built visually. Every line is ordinary Manic — edit freely.
+template("black");
+// END WORKBENCH CANVAS

package/examples/newton.manic

@@ -0,0 +1,39 @@
+title("Newton's method: chasing a root");
+canvas("16:9");
+
+text(hdr, (cx, 56), "Newton's method finds where x squared = 2");
+size(hdr, 28); color(hdr, cyan); bold(hdr); display(hdr); hidden(hdr);
+
+// a reference frame so the x-axis (where the tangents land) is visible
+axes(ax, (cx - 250, cy + 170), 540, 360, 1);
+color(ax, dim); untraced(ax);
+
+// f(x) = x^2 - 2, whose positive root is sqrt(2)
+plot(f, (cx - 250, cy + 170), 180, 70, "x*x - 2", (-0.4, 3));
+color(f, cyan); stroke(f, 3); untraced(f);
+
+// the true zero-crossing, marked
+roots(zero, f);
+color(zero, lime); hidden(zero);
+
+// the Newton zig-zag from a first guess of x = 3
+newton(walk, f, 3);
+color(walk, gold); stroke(walk, 3); untraced(walk);
+
+text(cap, (cx, h - 60), "each tangent slides the guess closer");
+size(cap, 20); color(cap, dim); display(cap); hidden(cap);
+
+// ---- timeline ----
+show(hdr, 0.5);
+draw(ax, 0.8);
+draw(f, 1.4);
+wait(0.3);
+show(cap, 0.4);
+
+// walk the iterates in to the root
+draw(walk, 3.5);
+wait(0.3);
+
+// reveal the exact root it converged on
+show(zero, 0.5);
+pulse(zero, 0.6);

package/examples/newtons-cradle.manic

@@ -0,0 +1,10 @@
+// newtons-cradle.manic — Newton's cradle: pull N balls, N swing out. An EVENT-
+// DRIVEN sim — free-flight pendulums between elastic collisions resolved by the
+// shared `collide_1d` impulse. `newtonscradle(id,[center],[balls],[pulled])`.
+title("Newton's cradle — momentum passes through");
+canvas("16:9");
+text(hdr, (cx, 70), "Pull one, one swings out — momentum and energy pass straight through"); size(hdr, 22); color(hdr, cyan); bold(hdr); display(hdr);
+newtonscradle(nc, (cx, 170), 5, 1);
+energygraph(nc, (1040, 470), 90);
+text(cap, (cx, h - 40), "five equal balls, elastic collisions (e = 1): the chain conserves momentum and energy"); size(cap, 15); color(cap, dim); display(cap);
+run(nc, 8);

package/examples/nine_point.manic

@@ -0,0 +1,59 @@
+// The Nine-Point Circle — one circle through the three side-midpoints AND the
+// three altitude feet. (It's the circumcircle of the medial triangle.)
+// Dynamic: drag C and the circle still catches all six points.
+//
+//   manic examples/nine_point.manic
+//   manic examples/nine_point.manic --record out --fps 60
+
+title("The Nine-Point Circle");
+canvas(1280, 720);
+
+text(head, (640, 120), "three midpoints + three feet, one circle");
+display(head);  color(head, cyan);  size(head, 26);  hidden(head);
+text(cap, (640, 668), "");  color(cap, dim);  size(cap, 22);
+
+point(A, (320, 560), "A");
+point(B, (1000, 560), "B");
+point(C, (620, 175), "C");
+hidden(A);  hidden(B);  hidden(C);
+
+segment(ab, A, B);  segment(bc, B, C);  segment(ca, C, A);
+untraced(ab);  untraced(bc);  untraced(ca);
+
+// side midpoints
+midpoint(mAB, A, B);  midpoint(mBC, B, C);  midpoint(mCA, C, A);
+color(mAB, lime);  color(mBC, lime);  color(mCA, lime);
+hidden(mAB);  hidden(mBC);  hidden(mCA);
+
+// altitude feet
+foot(fA, A, B, C);  foot(fB, B, C, A);  foot(fC, C, A, B);
+color(fA, magenta);  color(fB, magenta);  color(fC, magenta);
+hidden(fA);  hidden(fB);  hidden(fC);
+
+// the nine-point circle = circumcircle of the medial triangle
+circumcircle(npc, mAB, mBC, mCA);  outline(npc, cyan);  untraced(npc);
+
+show(head, 0.5);
+say(cap, "start with a triangle");
+par { show(A);  show(B);  show(C); }
+par { draw(ab, 0.5);  draw(bc, 0.5);  draw(ca, 0.5); }
+wait(0.3);
+
+section("Six points");
+say(cap, "the three side-midpoints (lime)");
+stagger(0.2) { show(mAB);  show(mBC);  show(mCA); }
+say(cap, "and the three altitude feet (magenta)");
+stagger(0.2) { show(fA);  show(fB);  show(fC); }
+wait(0.4);
+
+section("One circle");
+say(cap, "a single circle passes through all six");
+draw(npc, 1.0);
+wait(0.6);
+
+section("Drag a vertex");
+say(cap, "move C — the circle still catches all six");
+move(C, (820, 220), 1.3, smooth);
+move(C, (440, 240), 1.3, smooth);
+move(C, (620, 175), 1.0, smooth);
+wait(1.0);

package/examples/noise-terrain.manic

@@ -0,0 +1,16 @@
+// Fractal Terrain — procedural generation from a single formula. `noise(x,y)` and
+// `fbm(x,y)` (fractal Brownian motion — five octaves of smooth value noise) are now
+// formula functions, right beside sin/cos, so any `surface3`/`heightmap3`/`plot`
+// formula can be organic. Here fbm alone sculpts a whole landscape the camera tours.
+title("Fractal Terrain — Noise in a Formula");
+canvas("16:9");
+template("neon");
+
+camera3((0, -13, 6.5), (0, 0, 0.3), 28);
+surface3(land, "fbm(x*0.9, y*0.9)*2.4", (-4, 4), (-4, 4), 72);
+color(land, cyan);
+
+// A slow turntable so the fractal relief reads in 3D.
+orbit3(60, 30, 13, 4.5, smooth);
+orbit3(190, 26, 13, 4.5, smooth);
+orbit3(320, 32, 13, 4.5, smooth);

package/examples/off-axis.manic

@@ -0,0 +1,32 @@
+// ============================================================================
+//  off-axis.manic  —  coma & astigmatism, off the axis (3-D ray-traced)
+// ----------------------------------------------------------------------------
+//  On the axis a lens can be sharp — but light coming in at an ANGLE is a harder
+//  test. `fieldspot` traces a full 2-D pupil in 3-D at a field angle and plots
+//  where the rays land. A single lens flares into a COMA comet; a doublet holds
+//  the spot near the Airy disk (the diffraction limit). Same 8° field, side by
+//  side — real off-axis aberration only a 3-D trace reveals.
+// ============================================================================
+
+title("Off-Axis — Coma vs a Corrected Lens");
+canvas("16:9");
+
+fieldspot(bad, (350, 380), "singlet", 8);    // one element → a coma comet
+fieldspot(good, (930, 380), "doublet", 8);    // doublet → tight, near diffraction
+
+text(cap, (cx, h - 44), ""); color(cap, fg); size(cap, 24); bold(cap); display(cap); sticky(cap);
+
+// ================= THE SCENE =================
+say(cap, "now aim the light 8° OFF the axis — the hard test", 0.5);
+wait(0.4);
+
+say(cap, "a single lens smears into a COMA comet (RMS ~7 px)", 0.3);
+draw(bad.dots, 1.6);
+wait(0.6);
+
+say(cap, "the doublet holds it near the Airy disk — the diffraction limit", 0.3);
+draw(good.dots, 1.4);
+wait(0.6);
+
+say(cap, "the circle is Airy: shrink the blur to it and you're diffraction-limited", 0.3);
+wait(1.2);

package/examples/onprem-advanced-web-service-v2.manic

@@ -0,0 +1,196 @@
+title("Advanced On-Premises Web Service — Runtime Paths (with icons)");
+canvas("16:9");
+template("neon");
+
+let u = (w+h-abs(w-h))/1440;
+watermark(mark, (w*0.14, h*0.03), "Made With Manic");
+text(kicker, (cx, h*0.04), "SYSTEMS KIT · ON-PREMISES WEB SERVICE");
+text(headline, (cx, h*0.125), "One platform. Three runtime stories.");
+text(caption, (cx, h*0.945), "First reveal ownership; then distinguish requests, telemetry, and the analytics stream.");
+size(kicker, 16*u); color(kicker, dim); bold(kicker);
+size(headline, 30*u); bold(headline); wrap(headline, w*0.86);
+size(caption, 18*u); color(caption, dim); wrap(caption, w*0.86);
+
+if h > 1.25*w {
+  architecture(platform, (cx,h*0.52), w*0.84,h*0.72);
+}
+else {
+  architecture(platform, (cx,h*0.52), w*0.95,h*0.72);
+}
+
+node(ingress, platform, "onprem:nginx", "Nginx Ingress");
+
+cluster(services, platform, "SERVICE CLUSTER");
+node(grpc1, services, "onprem:server", "gRPC 1");
+node(grpc2, services, "onprem:server", "gRPC 2");
+node(grpc3, services, "onprem:server", "gRPC 3");
+
+cluster(state, platform, "");
+cluster(sessions, state, "SESSIONS HA");
+node(sessionPrimary, sessions, "onprem:redis", "Redis Session");
+node(sessionReplica, sessions, "onprem:redis", "Redis Replica");
+cluster(databases, state, "DATABASE HA");
+node(dbPrimary, databases, "onprem:postgresql", "PostgreSQL Users");
+node(dbReplica, databases, "onprem:postgresql", "PostgreSQL Replica");
+
+cluster(pipeline, platform, "EVENT ANALYTICS");
+node(logging, pipeline, "onprem:fluentd", "Fluentd Logging");
+node(stream, pipeline, "onprem:kafka", "Kafka Stream");
+node(analytics, pipeline, "onprem:spark", "Spark Analytics");
+
+cluster(observability, platform, "OBSERVABILITY");
+node(metrics, observability, "onprem:prometheus", "Prometheus");
+node(monitoring, observability, "onprem:grafana", "Grafana");
+
+// Main request and dependency possibilities.
+connect(ingressToServices, ingress, services);
+connect(servicesToSessions, services, sessionPrimary, orthogonal);
+connect(servicesToDatabase, services, dbPrimary, orthogonal);
+connect(servicesToLogging, services, logging, orthogonal);
+
+// The log stream remains one explicit pipeline.
+connect(loggingToStream, logging, stream, orthogonal);
+connect(streamToAnalytics, stream, analytics, orthogonal);
+
+// Grafana queries Prometheus; Prometheus explicitly scrapes both replicas.
+connect(dashboardQuery, monitoring, metrics, orthogonal);
+connect(sessionScrape, metrics, sessionReplica, orthogonal);
+connect(databaseScrape, metrics, dbReplica, orthogonal);
+
+// HA replication is a neutral relationship, not a directed runtime claim.
+link(sessionReplication, sessionPrimary.card, sessionReplica.card);
+link(databaseReplication, dbPrimary.card, dbReplica.card);
+dashed(sessionReplication); dashed(databaseReplication);
+color(sessionReplication, dim); color(databaseReplication, dim);
+stroke(sessionReplication, 2.5*u); stroke(databaseReplication, 2.5*u);
+
+// --- colour every path by its RELATIONSHIP (cold dashed line + hot overlay) ---
+// request path = cyan · analytics pipeline = gold · telemetry/scrape = magenta.
+color(ingressToServices, cyan);  color(ingressToServices.hot, cyan);
+color(servicesToSessions, cyan); color(servicesToSessions.hot, cyan);
+color(servicesToDatabase, cyan); color(servicesToDatabase.hot, cyan);
+color(servicesToLogging, gold);  color(servicesToLogging.hot, gold);
+color(loggingToStream, gold);    color(loggingToStream.hot, gold);
+color(streamToAnalytics, gold);  color(streamToAnalytics.hot, gold);
+color(dashboardQuery, magenta);  color(dashboardQuery.hot, magenta);
+color(sessionScrape, magenta);   color(sessionScrape.hot, magenta);
+color(databaseScrape, magenta);  color(databaseScrape.hot, magenta);
+// (replication links stay neutral dim — a relationship, not a runtime path)
+
+// legend: relationship → colour
+text(legReq, (w*0.30, h*0.175), "REQUEST"); size(legReq, 13*u); color(legReq, cyan); bold(legReq);
+text(legAna, (w*0.44, h*0.175), "ANALYTICS"); size(legAna, 13*u); color(legAna, gold); bold(legAna);
+text(legTel, (w*0.60, h*0.175), "TELEMETRY"); size(legTel, 13*u); color(legTel, magenta); bold(legTel);
+text(legRep, (w*0.76, h*0.175), "REPLICATION"); size(legRep, 13*u); color(legRep, dim); bold(legRep);
+hidden(legReq); hidden(legAna); hidden(legTel); hidden(legRep);
+
+message(webRequest, ingress, "REQ");
+message(sessionRead, grpc2, "S");
+message(databaseRead, grpc3, "DB");
+message(logEvent, grpc1, "LOG");
+message(query, monitoring, "Q");
+message(sessionProbe, metrics, "S");
+message(databaseProbe, metrics, "D");
+
+hidden(kicker); hidden(headline); hidden(caption);
+hidden(platform.nodes);
+hidden(services.parts); hidden(state.parts); hidden(sessions.parts); hidden(databases.parts);
+hidden(pipeline.parts); hidden(observability.parts);
+hidden(webRequest.parts); hidden(sessionRead.parts); hidden(databaseRead.parts);
+hidden(logEvent.parts); hidden(query.parts); hidden(sessionProbe.parts); hidden(databaseProbe.parts);
+untraced(platform.connections); untraced(sessionReplication); untraced(databaseReplication);
+
+step("entry-and-services") {
+  par {
+    show(kicker, 0.30); show(headline, 0.45); show(caption, 0.40);
+    show(ingress, 0.35);
+    show(services.parts, 0.45);
+    stagger(0.08) { show(grpc1, 0.30); show(grpc2, 0.30); show(grpc3, 0.30); }
+    say(caption, "Nginx can reach three gRPC workers. The dashed fan-out is possibility, not a load-balancing simulation.", 0.40);
+  }
+}
+wait(0.20);
+
+step("state-pipeline-and-monitoring") {
+  par {
+    show(state.parts, 0.45); show(sessions.parts, 0.40); show(databases.parts, 0.40);
+    show(sessionPrimary, 0.30); show(sessionReplica, 0.30);
+    show(dbPrimary, 0.30); show(dbReplica, 0.30);
+    show(pipeline.parts, 0.45); show(logging, 0.30); show(stream, 0.30); show(analytics, 0.30);
+    show(observability.parts, 0.45); show(metrics, 0.30); show(monitoring, 0.30);
+    say(caption, "Sessions, users, analytics, and observability keep separate ownership boundaries.", 0.40);
+  }
+}
+wait(0.20);
+
+step("possible-topology") {
+  par {
+    draw(platform.connections, 1.10, smooth);
+    draw(sessionReplication, 0.55, smooth);
+    draw(databaseReplication, 0.55, smooth);
+    show(legReq, 0.3); show(legAna, 0.3); show(legTel, 0.3); show(legRep, 0.3);
+    say(caption, "Each path is coloured by relationship: request, analytics, telemetry, replication.", 0.40);
+  }
+}
+wait(0.30);
+
+step("one-ingress-request") {
+  par {
+    seq {
+      show(webRequest.parts, 0.18);
+      route(webRequest, ingressToServices, 1.00, linear);
+    }
+    say(caption, "One HTTP request selects one gRPC worker; the other possible ingress lanes remain cold.", 0.40);
+  }
+}
+wait(0.25);
+
+step("parallel-state-dependencies") {
+  par {
+    fade(webRequest.parts, 0.20);
+    seq { show(sessionRead.parts, 0.18); route(sessionRead, servicesToSessions, 1.45, linear); }
+    seq { show(databaseRead.parts, 0.18); route(databaseRead, servicesToDatabase, 1.45, linear); }
+    flow(sessionReplication, 1.45, both, continuous);
+    flow(databaseReplication, 1.45, both, continuous);
+    say(caption, "Two workers can contact independent state systems while replication stays a neutral HA relationship.", 0.40);
+  }
+}
+wait(0.25);
+
+step("logging-to-analytics") {
+  par {
+    fade(sessionRead.parts, 0.20); fade(databaseRead.parts, 0.20);
+    fade(servicesToSessions.hot, 0.25); fade(servicesToDatabase.hot, 0.25);
+    seq {
+      show(logEvent.parts, 0.18);
+      route(logEvent, servicesToLogging, 1.00, linear);
+      route(logEvent, loggingToStream, 0.85, linear);
+      route(logEvent, streamToAnalytics, 0.85, linear);
+    }
+    say(caption, "The same log event travels gRPC → Fluentd → Kafka → Spark without becoming a replacement dot.", 0.40);
+  }
+}
+wait(0.25);
+
+step("observability") {
+  par {
+    fade(logEvent.parts, 0.20);
+    fade(servicesToLogging.hot, 0.25);
+    fade(loggingToStream.hot, 0.25);
+    fade(streamToAnalytics.hot, 0.25);
+    seq { show(query.parts, 0.18); route(query, dashboardQuery, 0.80, linear); }
+    seq { show(sessionProbe.parts, 0.18); route(sessionProbe, sessionScrape, 1.25, linear); }
+    seq { show(databaseProbe.parts, 0.18); route(databaseProbe, databaseScrape, 1.25, linear); }
+    say(caption, "Grafana queries Prometheus while two explicit scrape messages select the replica targets.", 0.40);
+  }
+}
+wait(0.35);
+
+step("takeaway") {
+  par {
+    pulse(services.parts, 0.70); pulse(state.parts, 0.70);
+    pulse(pipeline.parts, 0.70); pulse(observability.parts, 0.70);
+    say(caption, "Ownership stays static. Persistent objects and authored paths explain what the platform does.", 0.45);
+  }
+}
+wait(1.30);

package/examples/onprem-advanced-web-service.manic

@@ -0,0 +1,175 @@
+title("Advanced On-Premises Web Service — Runtime Paths");
+canvas("16:9");
+template("neon");
+
+let u = (w+h-abs(w-h))/1440;
+watermark(mark, (w*0.14, h*0.03), "Made With Manic");
+text(kicker, (cx, h*0.04), "SYSTEMS KIT · ON-PREMISES WEB SERVICE");
+text(headline, (cx, h*0.125), "One platform. Three runtime stories.");
+text(caption, (cx, h*0.945), "First reveal ownership; then distinguish requests, telemetry, and the analytics stream.");
+size(kicker, 16*u); color(kicker, dim); bold(kicker);
+size(headline, 30*u); bold(headline); wrap(headline, w*0.86);
+size(caption, 18*u); color(caption, dim); wrap(caption, w*0.86);
+
+if h > 1.25*w {
+  architecture(platform, (cx,h*0.52), w*0.84,h*0.72);
+}
+else {
+  architecture(platform, (cx,h*0.52), w*0.95,h*0.72);
+}
+
+node(ingress, platform, "gateway", "Nginx Ingress");
+
+cluster(services, platform, "SERVICE CLUSTER");
+node(grpc1, services, "service", "gRPC 1");
+node(grpc2, services, "service", "gRPC 2");
+node(grpc3, services, "service", "gRPC 3");
+
+cluster(state, platform, "");
+cluster(sessions, state, "SESSIONS HA");
+node(sessionPrimary, sessions, "cache", "Redis Session");
+node(sessionReplica, sessions, "cache", "Redis Replica");
+cluster(databases, state, "DATABASE HA");
+node(dbPrimary, databases, "database", "PostgreSQL Users");
+node(dbReplica, databases, "database", "PostgreSQL Replica");
+
+cluster(pipeline, platform, "EVENT ANALYTICS");
+node(logging, pipeline, "service", "Fluentd Logging");
+node(stream, pipeline, "queue", "Kafka Stream");
+node(analytics, pipeline, "service", "Spark Analytics");
+
+cluster(observability, platform, "OBSERVABILITY");
+node(metrics, observability, "external", "Prometheus");
+node(monitoring, observability, "external", "Grafana");
+
+// Main request and dependency possibilities.
+connect(ingressToServices, ingress, services);
+connect(servicesToSessions, services, sessionPrimary, orthogonal);
+connect(servicesToDatabase, services, dbPrimary, orthogonal);
+connect(servicesToLogging, services, logging, orthogonal);
+
+// The log stream remains one explicit pipeline.
+connect(loggingToStream, logging, stream, orthogonal);
+connect(streamToAnalytics, stream, analytics, orthogonal);
+
+// Grafana queries Prometheus; Prometheus explicitly scrapes both replicas.
+connect(dashboardQuery, monitoring, metrics, orthogonal);
+connect(sessionScrape, metrics, sessionReplica, orthogonal);
+connect(databaseScrape, metrics, dbReplica, orthogonal);
+
+// HA replication is a neutral relationship, not a directed runtime claim.
+link(sessionReplication, sessionPrimary.card, sessionReplica.card);
+link(databaseReplication, dbPrimary.card, dbReplica.card);
+dashed(sessionReplication); dashed(databaseReplication);
+color(sessionReplication, dim); color(databaseReplication, dim);
+stroke(sessionReplication, 2.5*u); stroke(databaseReplication, 2.5*u);
+
+message(webRequest, ingress, "REQ");
+message(sessionRead, grpc2, "S");
+message(databaseRead, grpc3, "DB");
+message(logEvent, grpc1, "LOG");
+message(query, monitoring, "Q");
+message(sessionProbe, metrics, "S");
+message(databaseProbe, metrics, "D");
+
+hidden(kicker); hidden(headline); hidden(caption);
+hidden(platform.nodes);
+hidden(services.parts); hidden(state.parts); hidden(sessions.parts); hidden(databases.parts);
+hidden(pipeline.parts); hidden(observability.parts);
+hidden(webRequest.parts); hidden(sessionRead.parts); hidden(databaseRead.parts);
+hidden(logEvent.parts); hidden(query.parts); hidden(sessionProbe.parts); hidden(databaseProbe.parts);
+untraced(platform.connections); untraced(sessionReplication); untraced(databaseReplication);
+
+step("entry-and-services") {
+  par {
+    show(kicker, 0.30); show(headline, 0.45); show(caption, 0.40);
+    show(ingress, 0.35);
+    show(services.parts, 0.45);
+    stagger(0.08) { show(grpc1, 0.30); show(grpc2, 0.30); show(grpc3, 0.30); }
+    say(caption, "Nginx can reach three gRPC workers. The dashed fan-out is possibility, not a load-balancing simulation.", 0.40);
+  }
+}
+wait(0.20);
+
+step("state-pipeline-and-monitoring") {
+  par {
+    show(state.parts, 0.45); show(sessions.parts, 0.40); show(databases.parts, 0.40);
+    show(sessionPrimary, 0.30); show(sessionReplica, 0.30);
+    show(dbPrimary, 0.30); show(dbReplica, 0.30);
+    show(pipeline.parts, 0.45); show(logging, 0.30); show(stream, 0.30); show(analytics, 0.30);
+    show(observability.parts, 0.45); show(metrics, 0.30); show(monitoring, 0.30);
+    say(caption, "Sessions, users, analytics, and observability keep separate ownership boundaries.", 0.40);
+  }
+}
+wait(0.20);
+
+step("possible-topology") {
+  par {
+    draw(platform.connections, 1.10, smooth);
+    draw(sessionReplication, 0.55, smooth);
+    draw(databaseReplication, 0.55, smooth);
+    say(caption, "Straight, curved, and port-aware orthogonal paths still form one selectable topology.", 0.40);
+  }
+}
+wait(0.30);
+
+step("one-ingress-request") {
+  par {
+    seq {
+      show(webRequest.parts, 0.18);
+      route(webRequest, ingressToServices, 1.00, linear);
+    }
+    say(caption, "One HTTP request selects one gRPC worker; the other possible ingress lanes remain cold.", 0.40);
+  }
+}
+wait(0.25);
+
+step("parallel-state-dependencies") {
+  par {
+    fade(webRequest.parts, 0.20);
+    seq { show(sessionRead.parts, 0.18); route(sessionRead, servicesToSessions, 1.45, linear); }
+    seq { show(databaseRead.parts, 0.18); route(databaseRead, servicesToDatabase, 1.45, linear); }
+    flow(sessionReplication, 1.45, both, continuous);
+    flow(databaseReplication, 1.45, both, continuous);
+    say(caption, "Two workers can contact independent state systems while replication stays a neutral HA relationship.", 0.40);
+  }
+}
+wait(0.25);
+
+step("logging-to-analytics") {
+  par {
+    fade(sessionRead.parts, 0.20); fade(databaseRead.parts, 0.20);
+    fade(servicesToSessions.hot, 0.25); fade(servicesToDatabase.hot, 0.25);
+    seq {
+      show(logEvent.parts, 0.18);
+      route(logEvent, servicesToLogging, 1.00, linear);
+      route(logEvent, loggingToStream, 0.85, linear);
+      route(logEvent, streamToAnalytics, 0.85, linear);
+    }
+    say(caption, "The same log event travels gRPC → Fluentd → Kafka → Spark without becoming a replacement dot.", 0.40);
+  }
+}
+wait(0.25);
+
+step("observability") {
+  par {
+    fade(logEvent.parts, 0.20);
+    fade(servicesToLogging.hot, 0.25);
+    fade(loggingToStream.hot, 0.25);
+    fade(streamToAnalytics.hot, 0.25);
+    seq { show(query.parts, 0.18); route(query, dashboardQuery, 0.80, linear); }
+    seq { show(sessionProbe.parts, 0.18); route(sessionProbe, sessionScrape, 1.25, linear); }
+    seq { show(databaseProbe.parts, 0.18); route(databaseProbe, databaseScrape, 1.25, linear); }
+    say(caption, "Grafana queries Prometheus while two explicit scrape messages select the replica targets.", 0.40);
+  }
+}
+wait(0.35);
+
+step("takeaway") {
+  par {
+    pulse(services.parts, 0.70); pulse(state.parts, 0.70);
+    pulse(pipeline.parts, 0.70); pulse(observability.parts, 0.70);
+    say(caption, "Ownership stays static. Persistent objects and authored paths explain what the platform does.", 0.45);
+  }
+}
+wait(1.30);