Blocks

stingo blocks            # what is registered, with every field
stingo blocks chart      # just one

scenes:
  - block: title
    kicker: concurrency
    text: Goroutines are not threads
    sub: And that difference is the whole point.

scenes:
  - block: statement
    text: Waiting is not working.
    emphasis: [ working. ]

scenes:
  - block: code
    lang: go
    code: |-
      func main() {
          ch := make(chan string)

          go func() {
              ch <- "done"
          }()

          fmt.Println(<-ch)
      }
    highlight: [ 4, 5 ]
    caption: go starts it; the channel says when it finished.

scenes:
  - block: terminal
    title: bench
    lines:
      - prompt: $
        cmd: go run serial.go
        out: processed 200 jobs in 20.4s
      - prompt: $
        cmd: go run parallel.go
        out: processed 200 jobs in 1.1s

scenes:
  - block: diagram
    title: fan out, fan in
    nodes:
      - id: main
        label: main
        at: [ 0, 0 ]
        span: 2
        accent: true
      - id: w1
        label: worker
        at: [ 0, 1 ]
      - id: w2
        label: worker
        at: [ 1, 1 ]
      - id: ch
        label: results chan
        at: [ 0, 2 ]
        span: 2
        kind: queue
    edges:
      - from: main
        to: w1
        label: go
      - from: main
        to: w2
        label: go
      - from: w1
        to: ch
      - from: w2
        to: ch

scenes:
  - block: chart
    kind: bar
    title: 200 jobs, same machine
    unit: s
    data:
      - label: serial
        value: 20.4
      - label: parallel
        value: 1.1
    highlightIndex: 1

scenes:
  - block: stat
    value: 18x
    label: faster
    sub: Same CPU. It simply stopped waiting in line.

scenes:
  - block: list
    title: Why Sleep fails
    marker: arrow
    items:
      - You are guessing how long work takes
      - Too short, and you drop results
      - Too long, and you waste the speedup
      - It will break on a slower machine

scenes:
  - block: compare
    left:
      title: OS thread
      items:
        - 1 MB stack, reserved up front
        - Kernel schedules it
        - Thousands is a lot
    right:
      title: goroutine
      items:
        - 2 KB stack, grows on demand
        - Go runtime schedules it
        - Millions is fine

scenes:
  - block: quote
    text: Do not communicate by sharing memory; share memory by communicating.
    attrib: Rob Pike

scenes:
  - block: image
    src: ./diagram.png
    frame: window
    title: diagram.png
    caption: A still, framed like a window.

scenes:
  - block: broll
    caption: a breathing beat between sections
    bg:
      kind: particles
      opacity: 0.8

scenes:
  - block: camera
    camera:
      src: takes/01.mp4
      layout: pip
    lower:
      name: Your name
      role: the person explaining

scenes:
  - block: outro
    text: Now go write something concurrent
    sub: Then run it with -race.
    handle: "@stingo"

// packages/blocks/src/countdown.ts
import { z } from 'zod';
import { defineBlock } from './define';
import { box, text } from '@stingo/render';
import { typeStyle } from './ctx';
import { T } from './stage';
import { lifecycle } from './anim';

export default defineBlock({
  name: 'countdown',
  describe: 'A number ticking down to zero.',

  // block-specific fields. The base fields — id, dur, at, bg, enter, exit,
  // say, camera, cut — are added for you.
  fields: {
    from: z.number().int().default(3),
    label: z.string().optional(),
  },

  // base is a floor, not a fallback: a content estimate can push past it,
  // narration replaces it, and the taste's pacing bounds clamp the result.
  duration: { base: 4, estimate: (s) => 0.8 + s.from * 0.9 },

  // what plays behind, when the scene does not say
  broll: { kind: 'pulse', opacity: 0.5 },

  render: (s, c) => {
    const n = Math.max(0, s.from - Math.floor(c.t));
    return box(
      { width: c.stage.w, height: c.stage.h, flexDirection: 'column',
        alignItems: 'center', justifyContent: 'center', gap: c.stage.unit },
      text({ ...typeStyle(c, 'display', T.huge(c.stage), c.taste.palette.accent) }, String(n)),
      s.label
        ? text({ ...typeStyle(c, 'body', T.body(c.stage), c.taste.palette.muted),
                 ...lifecycle(c.t, c.dur, c.taste, 'fade', 0.2) }, s.label)
        : null,
    );
  },
});

- block: countdown
  from: 5
  label: until launch

class CountdownBuilder extends SceneBuilder<CountdownBuilder> {
  label(v: string) { this.s.label = v; return this; }
}
export const countdown = (from: number) =>
  new CountdownBuilder({ block: 'countdown', from });

countdown(5).label('until launch').bg('pulse')

import { defineBlock } from '@hersidev/stingo';
export default defineBlock({ name: 'myblock', /* … */ });