tutticode 0.0.0-stage → 0.1.1

package/dist/skills/tutticode/references/sample-operations.md

@@ -0,0 +1,102 @@
+# Sample operations
+
+Play part of a sample, change its speed, cut it into slices, fit it to the tempo and choke it.
+
+Drum sounds and your own samples are recordings, so you can play a window of
+them, faster or slower, forwards or backwards. In TuttiDAW every variation
+becomes its own pad in a Drum Rack, so the result opens in the studio exactly
+as it sounds.
+
+## Window: begin and end
+
+`.begin(...)` and `.end(...)` set where a sample starts and stops, as a
+fraction of its length (0 to 1).
+
+```js
+s("oh*4").end("<0.1 0.3 0.6 1>")
+```
+
+## Speed
+
+`.speed(n)` plays a sample `n` times as fast: 2 is an octave up, 0.5 an
+octave down, and a negative speed plays it backwards.
+
+```js
+s("cp*4").speed("1 2 0.5 -1")
+```
+
+## Gating and choke groups: clip and cut
+
+A sample normally plays to its end. `.clip(1)` stops it at the end of its
+step (`.clip(0.5)` halfway). `.cut(n)` puts sounds in a choke group: a new
+hit stops the one still ringing, like an open hi-hat closed by a closed one.
+
+```js
+s("[oh hh]*4").cut(1)
+```
+
+```js
+s("oh*8").clip("<1 0.25>")
+```
+
+## Cutting into parts: chop and striate
+
+`.chop(n)` cuts every event, and its sample, into `n` parts played one after
+another. `.striate(n)` plays the whole pattern `n` times, a later part of each
+sample each time.
+
+```js
+s("cr").chop(8).speed("<1 -1>")
+```
+
+```js
+s("bd sd").striate(4)
+```
+
+## Slices: slice and splice
+
+`.slice(n, indices)` cuts a sample into `n` equal slices and plays the slices
+the index pattern names - the classic way to rearrange a break. `.splice` does
+the same and changes each slice's speed so it fills its step exactly.
+
+```js
+s("cr").slice(8, "0 7 2 5 4 3 6 1")
+```
+
+```js
+s("oh").splice(4, "0 2 1 [3 3]")
+```
+
+## Fitting to the tempo: loopAt and fit
+
+`.loopAt(n)` changes a sample's speed so it lasts exactly `n` cycles - ideal
+for loops and breaks. `.fit()` makes each sample fill its own step. Both follow
+the tempo, so the loop stays in time when you change `setcpm`.
+
+```js
+s("cr").loopAt(1).chop(4)
+```
+
+## Scrubbing
+
+`.scrub("position:speed")` starts the sample at a position, like moving a
+tape head.
+
+```js
+s("cr*4").scrub("0 0.5:2 0.25 0.75:0.5")
+```
+
+## With your own loops
+
+These operations are at their best on your own recordings. Declare them with
+`samples(...)` (see [Sounds](sounds.md#your-own-samples)) and slice away:
+
+```js
+samples({ break: "https://example.com/loops/break-120.wav" })
+s("break").loopAt(2).slice(8, "0 1 <2 6> 3 [4 4] 5 6 <7 1>")
+```
+
+A pitched instrument - a synth or a General MIDI name - plays its notes as
+written: these operations only change sampled drums and samples.
+
+Source: https://tuttidaw.com/code/learn/sample-operations

package/dist/skills/tutticode/references/sounds.md

@@ -0,0 +1,109 @@
+# Sounds
+
+Drum kits and banks, synth waveforms, General MIDI instrument names, Ensemble sounds and your own samples.
+
+A voice's sound decides which TuttiDAW instrument plays it. You can name
+sounds the Strudel way with `s(...)`, or load any TuttiDAW instrument by name
+with `.inst(...)` (next chapters).
+
+## Drum kits
+
+Drum names (`bd sd rim cp hh oh cr rd ht mt lt sh cb`) play the pads of a
+Drum Rack. Without a bank the voice uses the 808 Core Kit; `.bank(...)`
+chooses another factory kit by its machine (`tr909`, `tr707`, `tr606`,
+`tr505`, `linn`, `dmx`, `cr78`).
+
+```js
+setcpm(30)
+kit: s("bd [~ bd] sd ~, [~ hh]*4, ~ ~ ~ oh").bank("tr909")
+```
+
+Strudel's banked names such as `RolandTR909_bd` are read as that drum. A
+number after a colon (`bd:2`) or `.n(...)` picks another variant of the same
+drum where the kit has one.
+
+## Synth waveforms
+
+`sine`, `triangle`, `square` and `sawtooth` (short: `sin`, `tri`, `sqr`,
+`saw`) play on a TuttiDAW synth whose envelope is set to match Strudel's
+built-in synth. `supersaw` is a detuned stack of saws.
+
+```js
+note("c2 [~ c2] eb2 [g1 bb1]").s("sawtooth").lpf(700)
+```
+
+```js
+note("<[c3,eb3,g3] [ab2,c3,eb3]>").s("supersaw").gain(0.6)
+```
+
+`white`, `pink` and `brown` are noise, from bright to soft (pink falls
+3 dB per octave, brown 6 dB). They take the envelope and filters like the
+waveforms: short noise bursts make hats. `crackle` is approximated with
+Vinyl Distortion's crackle.
+
+```js
+s("<white pink brown>*8").decay(0.04).sustain(0)
+```
+
+## Instrument names
+
+`piano` plays TuttiDAW's sampled grand piano. General MIDI names in Strudel's
+`gm_` style play the closest TuttiDAW instrument: for example `gm_piano`,
+`gm_epiano1`, `gm_acoustic_bass`, `gm_violin`, `gm_vibraphone`, `gm_flute`,
+`gm_pad_warm`, and the Asian instruments `gm_koto`, `gm_dulcimer` and
+`gm_shakuhachi`.
+
+```js
+setcpm(22)
+koto: n("0 2 4 <7 5> 4 2").scale("D:minor:pentatonic").s("gm_koto")
+bass: note("<d2 a1 bb1 c2>").s("gm_acoustic_bass")
+```
+
+A name TuttiDAW does not know still plays: drum-like names fall back to a
+drum pad, everything else to a synth, with a warning in the diagnostics.
+
+## Ensemble sounds
+
+Ensemble is TuttiDAW's multi-engine sound module (Physical, Sample, Duo, FM6
+and more). Its factory sounds are named `<Engine> <SOUND>`, for example
+`Physical PLUCK` or `Sample FLUTE`, and are loaded with `.inst`:
+
+```js
+setcpm(24)
+pluck: n("0 2 4 6 4 2").scale("E:minor").inst("Ensemble:Physical PLUCK")
+flute: note("<b4 a4 g4 e4>").inst("Ensemble:Sample FLUTE")
+```
+
+Ensemble parts play inside an Ensemble Set with its own chorus, delay and
+reverb. On TuttiCode up to four Ensemble voices share one Set; **Open in
+TuttiDAW** builds the same Set in your project. The [device
+catalogue](devices.md) lists every Ensemble sound.
+
+## Your own samples
+
+`samples(...)` declares audio files hosted on the web (HTTPS). The names you
+declare then work in `s(...)` like the built-in ones. A `github:user/repo`
+shortcut reads the `strudel.json` sample map at the root of that repository.
+
+```js
+samples({ stab: "https://example.com/sounds/stab.wav" })
+s("stab ~ stab [~ stab]")
+```
+
+What TuttiDAW does with them:
+
+- **Nothing is downloaded until you ask.** TuttiCode loads new samples
+  only when you press **Play** or **Evaluate** yourself; typing never starts a
+  download, and Muse's edits never do either.
+- Files are fetched by your browser from where they are hosted, kept in
+  memory for the session, and never uploaded to TuttiDAW. A saved project
+  stores the links, not the audio.
+- Limits keep pages safe: at most 8 MB per file, 32 MB in total, 10 seconds
+  per download, mono or stereo audio up to 120 seconds.
+- If a file cannot load, the voice plays a built-in sound and the diagnostics
+  say which file failed.
+
+Only use samples you are allowed to use; TuttiDAW plays them from their host
+and does not check their licence.
+
+Source: https://tuttidaw.com/code/learn/sounds

package/dist/skills/tutticode/references/time-and-structure.md

@@ -0,0 +1,161 @@
+# Time and structure
+
+Functions that speed up, shift, reverse, repeat and combine patterns, and arrange them into sections.
+
+Mini-notation writes one cycle. Methods - the `.name(...)` calls after a
+pattern - change how it unfolds over time. They can be chained, and most
+take patterns as arguments too.
+
+## Speed: fast and slow
+
+```js
+note("c3 eb3 g3 bb3").fast(2)
+```
+
+```js
+note("c3 eb3 g3 bb3").slow(2)
+```
+
+A patterned argument changes the speed from bar to bar:
+
+```js
+s("bd sd").fast("<1 2 4 2>")
+```
+
+## Shifting: early and late
+
+`.late(t)` delays a pattern by `t` cycles; `.early(t)` moves it forward. A
+quarter of a cycle is one beat.
+
+```js
+stack(
+  s("bd*4"),
+  s("cp*2").late(0.25)
+)
+```
+
+## Reversing and rotating
+
+`.rev()` plays each cycle backwards, `.palindrome()` alternates forwards and
+backwards, and `.iter(n)` starts each cycle one step further into the pattern.
+
+```js
+note("c3 d3 e3 g3").iter(4)
+```
+
+```js
+note("c3 d3 e3 g3 a3").palindrome()
+```
+
+## Repeating: ply
+
+`.ply(n)` repeats every event `n` times within its own length - a quick way
+to make rolls.
+
+```js
+s("bd sd bd [sd cp]").ply("<1 2>")
+```
+
+## Every few cycles: every, lastOf, chunk
+
+`.every(n, f)` applies the change `f` on the first of every `n` cycles;
+`.lastOf(n, f)` on the last one, which suits a fill at the end of a phrase.
+`f` is a small function written with an arrow: `x => x.fast(2)`.
+
+```js
+s("bd sd bd sd").lastOf(4, x => x.ply(2))
+```
+
+`.chunk(n, f)` applies `f` to one quarter (one `n`th) of the cycle, moving
+along each cycle.
+
+```js
+note("c3 d3 e3 f3").chunk(4, x => x.add(note(12)))
+```
+
+## Layering: off, superimpose, layer, jux
+
+`.off(t, f)` adds a copy that is shifted by `t` and changed by `f` - an echo
+with a twist.
+
+```js
+note("c3 eb3 g3 bb3").off(1/8, x => x.add(note(12)))
+```
+
+`.superimpose(f)` stacks a changed copy without moving it; `.jux(f)` puts the
+original on the left and the changed copy on the right.
+
+```js
+note("c3 e3 g3 e3").superimpose(x => x.add(note(7)))
+```
+
+```js
+s("bd hh sd hh").jux(rev)
+```
+
+## Echoes: echo
+
+`.echo(times, time, feedback)` repeats each event, quieter each time.
+
+```js
+s("cp ~ ~ ~").echo(3, 1/8, 0.6)
+```
+
+## Rhythm from another pattern: struct, mask, euclid
+
+`.struct("x ~ x x")` plays the values on the rhythm of `x`s.
+`.mask("1 0 1 1")` silences the parts where the mask is 0. `.euclid(k, n)` is
+the method form of `(k,n)`.
+
+```js
+note("[c3,eb3,g3]").struct("x ~ x x ~ x ~ ~")
+```
+
+```js
+note("c2").euclid(5, 8)
+```
+
+## Swing
+
+`.swingBy(amount, n)` divides the cycle into `n` slices and delays the second
+half of each slice. `1/3` gives a triplet feel; `.swing(n)` is a shortcut for
+it.
+
+```js
+s("hh*8").swingBy(1/3, 4)
+```
+
+## Combining patterns: stack, cat, seq
+
+`stack(a, b)` plays patterns together, `cat(a, b)` plays one per cycle in turn
+and `seq(a, b)` squeezes them into one cycle.
+
+```js
+cat(
+  note("c3 e3 g3 e3"),
+  note("a2 c3 e3 c3")
+)
+```
+
+## Sections: arrange
+
+`arrange([cycles, pattern], ...)` builds a song form: each pattern plays for
+its number of cycles, then the next one, and the whole thing loops.
+
+```js
+const verse = note("c3 eb3 g3 eb3")
+const chorus = note("ab2 c3 eb3 c3").fast(2)
+arrange([4, verse], [2, chorus])
+```
+
+## Randomness that repeats
+
+`.sometimes(f)` applies `f` to about half of the events, `.degradeBy(p)` drops
+events with probability `p`. Like `?` and `|`, they are seeded, so a program
+always plays the same way.
+
+```js
+s("hh*16").degradeBy(0.3).sometimes(x => x.velocity(0.5))
+```
+
+Source: https://tuttidaw.com/code/learn/time-and-structure

package/dist/skills/tutticode/references/tuttidaw-extensions.md

@@ -0,0 +1,131 @@
+# TuttiDAW extensions
+
+Load any TuttiDAW instrument, MIDI effect or audio effect with presets and parameters; voices, groups and Open in TuttiDAW.
+
+Strudel controls such as `.lpf` or `.room` describe a sound in general terms.
+TuttiDAW adds three methods that name **real devices** - the same ones you
+find in the studio's browser - with their factory presets and parameters:
+
+| Method | What it adds | Where it goes |
+|---|---|---|
+| `.inst(name, params)` | an instrument (one per voice) | the voice's instrument slot |
+| `.midifx(name, params)` | a MIDI effect | before the instrument, in call order |
+| `.fx(name, params)` | an audio effect | after the instrument, in call order |
+
+These are TuttiDAW-only: a program that uses them does not play on
+strudel.cc, so TuttiCode hides its "Open in strudel.cc" link for it.
+
+## Instruments: .inst
+
+The name is a device, or a device and one of its factory presets joined by a
+colon. Case and punctuation do not matter.
+
+```js
+setcpm(30)
+bass: note("c2 [~ c2] eb2 [~ g1]").inst("Drift:Deep Bass")
+keys: chord("<Cm7 Ab^7 Fm7 G7>").voicing().inst("Electric")
+```
+
+`.inst` decides the instrument, even when the voice also has an `s(...)`.
+On a drum voice `s(...)` still picks the pads, so you can play the names on
+any kit:
+
+```js
+s("bd*2 [~ bd] sd ~, hh*8").inst("Drum Rack:909 Core Kit")
+```
+
+## Audio effects: .fx
+
+Effects are added after the instrument in the order you call them. Use
+several `.fx` calls to build a chain.
+
+```js
+note("<[c3,eb3,g3] [bb2,d3,f3]>")
+  .inst("Wavetable")
+  .fx("Chorus:Wide Classic")
+  .fx("Reverb:Large Hall", { decayTime: "4s", dryWetBalance: 0.35 })
+```
+
+## MIDI effects: .midifx
+
+MIDI effects change the notes on their way into the instrument - for example
+an Arpeggiator turns held chords into runs. The clip keeps the notes you
+wrote; the effect plays them live, as in the studio.
+
+```js
+note("<[c3,eb3,g3] [ab2,c3,eb3]>")
+  .midifx("Arpeggiator", { style: "UpDown", rate: "1/16" })
+  .inst("Operator")
+```
+
+```js
+note("c3 ~ f3 ~").midifx("Chord:Minor 7 Chord").inst("Electric")
+```
+
+## Parameters
+
+The second argument is an object of parameter values:
+
+- **Keys** are the device's parameter keys (`decayTime`, `cutoff`,
+  `dryWetBalance`); a parameter's unique Live label works too. The
+  [device catalogue](devices.md) lists every key with its range and unit.
+- **Numbers** are in the parameter's own unit (Hz, ms, dB, semitones). A
+  string with a unit is converted: `"250ms"`, `"2s"`, `"-6dB"`,
+  `"1.2kHz"`, `"30%"`.
+- **Choices** take their label (`"UpDown"`, `"1/16"`, `"Dorian"`) or a
+  0-based index; switches take `true` or `false`.
+- Two reserved keys: `on` switches the device on or off, `id` names a device
+  when a voice uses the same one twice.
+
+```js
+s("bd*4, ~ sd, hh*8")
+  .fx("Saturator", { drive: "6dB" })
+  .fx("Compressor", { threshold: "-18dB", ratio: 4, attack: "10ms" })
+```
+
+Values outside a parameter's range are clamped, with a warning. Device
+parameters take constant values for now; a pattern such as `"<300 600>"` as a
+device parameter is reported and not applied yet. Strudel controls
+(`.lpf("<300 600>")`) can already change over time.
+
+## Strudel controls and devices together
+
+Strudel controls keep working next to devices: `.lpf(...)` still adds an
+Auto Filter. When a voice names the same kind of device itself, the control
+goes onto that device instead of adding a second one - `.room(0.4)` with
+`.fx("Reverb:...")` sets that Reverb's mix.
+
+## Inline controls: slider and toggle
+
+`slider(value, min, max)` puts a small slider in the editor next to the
+number; dragging it changes the program while it plays. `toggle(1)` (a
+TuttiDAW addition) puts an on/off switch there.
+
+```js
+note("c2*8").s("sawtooth").lpf(slider(800, 200, 4000))
+```
+
+```js
+stack(
+  s("bd*4"),
+  s("hh*8").mask(toggle(1))
+)
+```
+
+## Voices become tracks
+
+Each labelled voice of a program is one track. **Open in TuttiDAW** on
+TuttiCode saves the program as a studio project:
+
+- the program lives on a **group track**: its `{}` button opens the code,
+  and evaluating there updates every voice;
+- each voice is a track in the group, with its instrument, effects and a
+  Pattern Clip holding that voice's code;
+- moving controls become clip envelopes.
+
+Editing a voice by hand - its notes, or a parameter the code set - detaches
+that voice from the code, so your edit is kept. **Re-attach** gives it back
+to the code. A single Pattern Clip (code in a MIDI clip without a group)
+plays notes only: devices named in its code are not applied there.
+
+Source: https://tuttidaw.com/code/learn/tuttidaw-extensions

package/dist/skills/tutticode-sound-for-media/SKILL.md

@@ -0,0 +1,104 @@
+---
+name: tutticode-sound-for-media
+description: Make music beds, loops, stems and sound effects (riser, impact, whoosh, UI click/confirm/error, notification, transition, ambience) for videos, apps and games with TuttiCode, rendered to files at an exact length and a platform loudness (-14 LUFS web/social, -16 podcasts, -23 broadcast) with the tutticode tools. Use when a video, app, game, podcast or presentation needs music or sound effects, or when asked to render audio of a given length or loudness.
+---
+
+# Sound for videos, apps and games with TuttiCode
+
+Make music beds, loops, stems and sound effects for media in TuttiCode, and
+deliver files at the right length and loudness. The language itself is in
+the `tutticode` skill (install both: `tutticode skills install`); the tools
+are `code_check`, `code_render`, `code_compare` from the local `tutticode`
+MCP server or CLI (default: free, renders in the user's browser, writes
+files) or TuttiDAW's web MCP (server renders, Muse points, 60 s, no files:
+a `listenUrl`).
+
+## Workflow
+
+1. **Brief.** Pin down: what it is for (video, app UI, game, podcast),
+   mood, exact length in seconds (or loop), where it plays (the loudness
+   target below), whether it sits under speech, stems or not, file format.
+   Ask only what you cannot infer.
+2. **Pick a recipe** nearest the brief: `references/sfx-recipes.md` for
+   effects, `references/music-recipes.md` for beds and loops. Recipes are
+   tested to compile and render clean.
+3. **Write**: adapt the recipe (key, chords, sounds, tempo, length). Label
+   every voice (`drums:`, `pad:`): labels name the stems and the tracks.
+4. **`code_check`**: fix every error, then the mix warnings.
+5. **`code_render`** with the delivery settings: the exact length
+   (`seconds`, or `loops` for a loop), `fadeIn` / `fadeOut`, a `tail` for
+   reverbs, `lufs` for the platform, `stems: true` if the editor wants
+   them, `out` with the extension of the format (`.wav`, `.flac`, `.mp3`).
+6. **Read the stats** (the `tutticode` skill's `references/agent-loop.md`):
+   loudness and true peak, clipping, silent bars, every voice's level,
+   `barTimes` / `beatTimes` for syncing cuts.
+7. **Revise** one thing at a time and render again; `code_compare` with
+   `againstRenderId` says whether the edit moved what you meant.
+8. **Deliver**: the file paths, the length and loudness, and the
+   `editUrl` (local) or `listenUrl` (web).
+
+Recipe index:
+
+- Sound effects (`references/sfx-recipes.md`): `riser`, `impact`, `whoosh`, `ui-click`, `ui-confirm`, `ui-error`, `notification`, `transition`, `ambience-bed`
+- Music beds (`references/music-recipes.md`): `lofi-bed`, `upbeat-pop-bed`, `cinematic-tension`, `ambient-bed`, `chiptune-loop`
+
+## Loudness and length
+
+| Where it plays | `lufs` |
+| --- | --- |
+| Web, social video, apps, games (music) | -14 |
+| Podcasts, video beds | -16 |
+| A bed under a voice-over | -20..-24 (or -16 and let the editor duck it) |
+| Broadcast (EBU R128) | -23 |
+| Short sound effects | -18..-26: peaky, see each recipe |
+
+- True peak ceiling -1 dBTP (the default, `truePeak`). No file is written
+  clipped: without `lufs`, a render that would pass the ceiling is lowered
+  by one static gain (a negative `gainDb` and a line in `warnings`). `lufs`
+  is one static gain: a peaky program (most drum programs at -14..-16)
+  fails with `clip`. Then lower the target, lower the loudest voice's
+  `.gain` and render again, end the program with
+  `master.fx("Limiter", {gainDb: 3, ceiling: -3})` (the program's own bus
+  catches the peaks before the gain, as the music recipes do), or add
+  `limit: true` (`--limit`): the render's true-peak limiter holds the
+  ceiling and reports the most it took off (`limitDb`). More than about
+  6 dB of it flattens the drums: then lower the target instead.
+- Exact durations: `seconds` cuts exactly. A one-shot effect is one bar
+  long: `setcpm` sets the bar (`setcpm(60)` = 1 s, `setcpm(15)` = 4 s).
+- Video beds: `fadeIn` 1-3 s, `fadeOut` 2-5 s, `tail` for the reverb.
+- Loops for apps and games: `loops` N with `tail: 0`, no fades, so the file
+  is exactly N loops and repeats in time; keep the last step short.
+- Stems: `stems: true` writes one file per voice (named by the labels); the
+  mix's static gain applies to the stems too, so they still sum to the mix.
+  A stem that would clip on its own is lowered further (its `gainDb` in
+  `voices`, a line in `warnings`); the limiter never touches stems.
+
+## Quality bar: never deliver
+
+- a render whose `check.diagnostics` has an `error`, or the `clip` error;
+- clipping (`analysis.loudness.clipping`) or a true peak above -1 dBTP;
+- a dead mix: integrated loudness null / -70, an unplanned silent bar, or a
+  voice whose `lufs` is null;
+- a length other than the one asked for (check `window.seconds`, plus the
+  tail);
+- without the `editUrl` (or `listenUrl`): always give it to the user, it
+  opens the program in TuttiCode to keep editing.
+
+## Sound effects
+
+Synth voices work everywhere. Noise is `s("white")`, `s("pink")` or
+`s("brown")` (hard to soft), shaped by the envelope and filters like any
+synth voice (`s("crackle")` is approximated). Pitch sweeps
+use the pitch envelope (`.penv(semitones).pattack(s)` / `.pdecay(s)`),
+swells the amplitude envelope (`.attack` / `.decay` / `.sustain(0)`), and
+`gm_reverse_cymbal`, `gm_fx_rain`, `gm_seashore`, `gm_fx_sci_fi` are ready
+riser, rain, waves and sci-fi textures (`note("c4").s(...)`).
+
+## References
+
+- `references/sfx-recipes.md`: riser, impact, whoosh, UI click / confirm /
+  error, notification, transition, ambience bed; each with render settings.
+- `references/music-recipes.md`: music beds and loops by mood, with their
+  Muse style for `code_compare`.
+- The `tutticode` skill: the language, `references/agent-loop.md` (every
+  report field), functions and devices.

package/dist/skills/tutticode-sound-for-media/references/music-recipes.md

@@ -0,0 +1,86 @@
+# Music-bed recipes
+
+Loopable background music for videos, apps and games. Each recipe compiles
+and renders (tested on every change). Start from the one nearest the brief,
+change the key, chords and sounds, then check and render. `style` is the
+Muse style id to compare with (`code_compare { goals: { style } }`); a
+bed without a master chain sits a few LU under a style's mastered loudness,
+so compare its spectrum and balance, and set the level with `lufs`.
+
+## Lo-fi bed (`lofi-bed`)
+
+Study, cooking, vlog and tutorial backgrounds: 80 BPM, swung drums, electric piano, soft bass. Style: `lofi-hip-hop`.
+
+```js
+setcpm(20) // 80 BPM
+drums: s("bd ~ [~ bd] ~, ~ sd, hh*8").bank("tr808").swingBy(1/6, 4).gain(0.45)
+keys: chord("<Fm9 Bbm9>").voicing().inst("Electric").gain(0.7)
+bass: n("<0 -4>").scale("F2:minor").s("sawtooth").lpf(400).gain(0.8)
+master.fx("Limiter", {gainDb: 3, ceiling: -3}) // fewer peaks at the loudness target
+```
+
+Render: `tutticode render lofi-bed.tc -o lofi-bed.wav --loops 8 --fade-out 3 --lufs -19`, or `code_render` with `{"loops":8,"fadeOut":3,"lufs":-19}`.
+
+Vary: Another key: change the chords and the scale together. Under speech: drop the keys gain to 0.4 and render at -22 LUFS.
+
+## Upbeat pop bed (`upbeat-pop-bed`)
+
+App promos, product launches, upbeat social videos: 120 BPM four-on-the-floor, I-V-vi-IV. Style: `modern-pop`.
+
+```js
+setcpm(30) // 120 BPM
+drums: s("bd*4, ~ cp ~ cp, hh*8").bank("tr909").gain(0.6)
+chords: chord("<C G Am F>").voicing().s("supersaw").release(0.2).lpf(2500).gain(0.2)
+bass: note("<c2 g1 a1 f1>").ply(4).s("sawtooth").lpf(600).gain(0.6)
+lead: n("<[0 2 4 2] [4 6 8 6] [5 7 9 7] [3 5 7 5]>").scale("C5:major").s("triangle").gain(0.4)
+master.fx("Limiter", {gainDb: 3, ceiling: -3})
+```
+
+Render: `tutticode render upbeat-pop-bed.tc -o upbeat-pop-bed.wav --loops 2 --fade-out 2 --lufs -17`, or `code_render` with `{"loops":2,"fadeOut":2,"lufs":-17}`.
+
+Vary: The lead arpeggiates each chord (scale degrees of the chord tones): keep that relation when you change the chords. Under a voice-over: mute the lead (_lead:).
+
+## Cinematic tension (`cinematic-tension`)
+
+Trailers, reveals, suspense, game menus: a low drone, slow minor strings and a ticking pulse at 60 BPM. Style: `cinematic`.
+
+```js
+setcpm(15) // 60 BPM
+drone: note("c2").s("sawtooth").lpf(300).attack(1).release(1).gain(0.5)
+strings: chord("<Cm Ab>").voicing().s("supersaw").attack(2).release(2).lpf(1200).gain(0.3).room(0.7)
+pulse: note("c6*8").s("sine").decay(0.1).sustain(0).gain(0.4)
+```
+
+Render: `tutticode render cinematic-tension.tc -o cinematic-tension.wav --loops 3 --tail 3 --fade-out 4 --lufs -18`, or `code_render` with `{"loops":3,"tail":3,"fadeOut":4,"lufs":-18}`.
+
+Vary: Rising tension: double the pulse (c6*16) for the last loop, or render the riser over the end.
+
+## Ambient bed (`ambient-bed`)
+
+Meditation, wellness, slow product shots: a wide pad and sparse echoing bells at 48 BPM. Style: `ambient`.
+
+```js
+setcpm(12) // 48 BPM
+pad: chord("<Dm F>").voicing().s("supersaw").attack(2).release(3).lpf(1000).gain(0.3).room(0.8).size(0.9)
+bells: n("0 2 4 7 4 2").scale("D5:minor").s("sine").decay(0.8).sustain(0).delay(0.4).gain(0.4)
+```
+
+Render: `tutticode render ambient-bed.tc -o ambient-bed.wav --loops 3 --tail 4 --fade-in 3 --fade-out 5 --lufs -20`, or `code_render` with `{"loops":3,"tail":4,"fadeIn":3,"fadeOut":5,"lufs":-20}`.
+
+Vary: The bells play chord tones of both chords (d f a): keep them on tones the chords share when you change the harmony.
+
+## Chiptune game loop (`chiptune-loop`)
+
+Retro and casual games, pixel-art videos: 150 BPM square-wave lead and bass that loop seamlessly.
+
+```js
+setcpm(37.5) // 150 BPM
+lead: n("<[0 2 4 7] [4 2 0 ~]>*2").scale("C4:major").s("square").decay(0.12).sustain(0.3).gain(0.35)
+bass: note("<c2 a1 f1 g1>").ply(8).s("square").lpf(800).gain(0.45)
+drums: s("bd ~ sd ~, hh*8").bank("tr808").gain(0.6)
+master.fx("Limiter", {gainDb: 3, ceiling: -3})
+```
+
+Render: `tutticode render chiptune-loop.tc -o chiptune-loop.wav --loops 2 --tail 0 --lufs -19`, or `code_render` with `{"loops":2,"tail":0,"lufs":-19}`.
+
+Vary: A game loop file has no fades and `tail: 0`: exactly N loops, so it repeats in time. A boss level: setcpm(45) and a minor scale.