Generation config with header + grid output (default).

s <- seek "*" $ gen
s <- seek "*" $ cue start $ tonal ctx $ len 4 $ entropy 0.3 $ gen

Generation config with compact musical summary.

Generation config with verbose diagnostic traces.

Static grid: repeats the cue chord for len bars. No database access.

s <- seek "*" $ cue start $ len 4 $ genGrid

genGrid with compact musical summary.

genGrid with verbose diagnostic traces.

Regenerate a range of bars within an existing progression. The cue is inferred from the bar before the start position (wrapping). A cue override applies to every family EXCEPT FStrata: the strata regen must seed from the source's own bar to keep the walk-graph seam valid, so it ignores the override.

FAMILY-AWARE: regeneration produces states of the family the source progression already is — families never mix. The one downgrade is deliberate: hand-built extended (FExtended) sources regenerate as triads (with a printed notice), so the result re-infers as mixed material rather than pretending the fusion family still exists.

• pcProvenance = Just _ — strata-aware path: regenerates all three layers + provenance in lockstep, with one-step lookahead at the e → e+1 seam to keep the spliced bar sequence walk-graph valid under allowedNext.
• FPoly (genE source) — polytonal path: regenerates the foundation range plus both partner chains, seeded from the kept partner bars before the range; the S/M labelling of the source is preserved (chains are never reordered by a partial regen).
• uniform 4-note hand-built material — regenerated bars come back as plain triads with a printed notice.
• uniform 3-note (gen source) — plain triad regen.
• hand-mixed cardinalities — regenerated as plain triads with a printed notice (hand-mixed material is the human aberration channel; regen does not amplify it).

s' <- seek "*" $ entropy 0.3 $ genFrom s 2 3 s' <- seek "*" $ cue start $ genFrom s 2 3 -- override inferred cue s' <- seek "*" $ len 6 $ genFrom s 2 3 -- expand range s' <- seek "*" $ genFrom' s 2 3 -- Standard per-step trace s' <- seek "*" $ genFrom'' s 2 3 -- Verbose trace (+ scoreboard with attempt)

Standard-verbosity alias of genFrom. Mirrors gen', genP' and genI'.

Verbose-verbosity alias of genFrom. Mirrors gen'', genP'' and genI''.

Fill the S (pentatonic) and M (mode) layers of a context from the key-area analysis of its triad layer. Identity on FStrata and FPoly contexts, whose layers are already meaningful. Layer bars are built exactly like genP's aux layers (Unison movement, chroma expressed as intervals from the bar root), so they voice through the same chroma engine (strataModeFlow) and print as mode names via the 7-PC display path. The M bar is rooted on the bar's harmonic root (the mode OF the bar — every tier of the override ladder contains it); the S bar is rooted on the PENTATONIC's own root — a pentatonic legitimately excludes the chord root (the pent-on-the-fifth over a maj7 does so by design), and the set is named from its own root. (Bar roots seed only bar 0's lattice in the chroma engine; pattern indices then track their lattice slot, not the bar root.) Provenance stays Nothing (provenance is strata-specific and gates strata regen / scoring).

The derived bars are forced to normal form as part of the result's WHNF: ProgressionContext fields are lazy, and the first thing to inspect an unforced layer can be the derived Eq inside an arrange / lineHarmony cache lookup — i.e. the audio thread. Generated contexts are forced when the generator prints them, so their analysis always lands at generation time; a hand-applied chordscale evaluates at its own first use — print it (or run chordscaleReport on it) at build time to keep the work off the performance path.

Render the per-bar key-area analysis of a gen / genJ (or hand-built) context. Returns Nothing for FStrata / FPoly contexts, whose layers carry their own semantics and their own reports.

Live-coding helper: print the chordscale report for a gen / genJ result alongside the standard Show output.

The genE paradigm: polytonal three-layer generation. The T layer is a foundation walk byte-identical to gen (all R constraints apply to it alone — the foundation owns the bass); the S/M layers are partner triad chains, each a corpus-valid walk of its own, sharing exactly 2 pitch classes with the foundation per bar and unioning to exactly 5. The traversal chooses freely per bar between the two admitted geometries — common-dyad (every layer pair sounds 4 tones) and base-anchored (pairs with the foundation sound 4, S+M sounds the pentad). Partners honour key/roots/overtones but never direction specs or strata machinery. Combine layers at the pattern surface via the Layer selectors (TS/TM/SM/TSM/PT). Cues are triadic.

s <- seek "*" $ len 8 $ entropy 0.3 $ genE'

genE with compact musical summary (per-bar layer table).

genE with verbose diagnostic traces (adds partner pool/tier trace).

Every layer view of a polytonal context, labelled: single layers, pair unions, the pentad, the pivot tones. Returns Nothing for other families — the labels are genE-specific (partner chains, pentad, pivot dyad). gen/genJ layer content is printed by chordscaleReport, genP's by genPReport.

Live-coding helper: print every layer view of a polytonal context as progression grids. Use at the REPL between takes to see what each pattern-level layer selection will sound.

Generate over the jazz (Change) graph: the genJ family. Same modifier chain as gen (seek "*" $ cue start $ len 8 $ entropy 0.3 $ genJ); the seek spec resolves against BOTH corpora (see Harmonic.Framework.Builder.JazzGen for the full semantics: jazz names blend, classical names steer via the steer dial, "*" walks the whole corpus, "none" is refused — the jazz graph has no offline mode). Progressions carry variable-arity chords (3-6 tones) straight from the corpus vocabulary, stamped FJazz so genFrom regenerates them jazz-natively and attempt ranks them against the Change graph. tonal constraints apply through the same R filter as every family; a step they empty is relaxed with a notice (there is deliberately no fallback pool).

genJ with Standard per-step trace (walk steps, pool sizes, picks).

genJ with Verbose trace (adds seek resolution and steer notices).

Strata-first generation entrypoint. Seeded by a StrataLabel; produces a ProgressionContext with distinct triad, strata, and mode layers and pcProvenance = Just ….

Uncued, the starting chord is drawn from inside the stratum itself — a five-tone set admits few triads, and the ordinary whole-corpus cue almost never lands in one. A cue you pass with cue is honoured as given; one that escapes the stratum is reported with the triads that would have fitted, rather than silently replaced.

s <- seek "none" $ len 6 $ genP VI s <- seek "none" $ cue start $ len 6 $ genP VI

Standard-verbosity variant of genP.

Verbose-verbosity variant of genP.

Render a multi-line report of the per-bar provenance of a ProgressionContext: for each bar, the tristrata index, its three strata, and the selected strata for that bar. Returns Nothing when the context has no provenance (e.g., a legacy gen result).

Live-coding helper: print a pretty tristrata report for a genP result alongside the standard Show output. Takes the bound context directly, mirroring genEReport. Useful at the REPL for sanity-checking a strata walk.

Silent-verbosity genP aliases, one per Roman numeral — genI pins the starting tristrata to I, genII to II, and so on through genXI.

s <- seek "*" $ attempt 3 12 $ entropy 0.4 $ genI

Three verbosities throughout, by the usual prime convention: genI silent, genI' standard, genI'' verbose.

Silent-verbosity genP aliases, one per Roman numeral — genI pins the starting tristrata to I, genII to II, and so on through genXI.

s <- seek "*" $ attempt 3 12 $ entropy 0.4 $ genI

Three verbosities throughout, by the usual prime convention: genI silent, genI' standard, genI'' verbose.

Silent-verbosity genP aliases, one per Roman numeral — genI pins the starting tristrata to I, genII to II, and so on through genXI.

s <- seek "*" $ attempt 3 12 $ entropy 0.4 $ genI

Three verbosities throughout, by the usual prime convention: genI silent, genI' standard, genI'' verbose.

Silent-verbosity genP aliases, one per Roman numeral — genI pins the starting tristrata to I, genII to II, and so on through genXI.

s <- seek "*" $ attempt 3 12 $ entropy 0.4 $ genI

Three verbosities throughout, by the usual prime convention: genI silent, genI' standard, genI'' verbose.

Silent-verbosity genP aliases, one per Roman numeral — genI pins the starting tristrata to I, genII to II, and so on through genXI.

s <- seek "*" $ attempt 3 12 $ entropy 0.4 $ genI

Three verbosities throughout, by the usual prime convention: genI silent, genI' standard, genI'' verbose.

Silent-verbosity genP aliases, one per Roman numeral — genI pins the starting tristrata to I, genII to II, and so on through genXI.

s <- seek "*" $ attempt 3 12 $ entropy 0.4 $ genI

Three verbosities throughout, by the usual prime convention: genI silent, genI' standard, genI'' verbose.

Silent-verbosity genP aliases, one per Roman numeral — genI pins the starting tristrata to I, genII to II, and so on through genXI.

s <- seek "*" $ attempt 3 12 $ entropy 0.4 $ genI

Three verbosities throughout, by the usual prime convention: genI silent, genI' standard, genI'' verbose.

Silent-verbosity genP aliases, one per Roman numeral — genI pins the starting tristrata to I, genII to II, and so on through genXI.

s <- seek "*" $ attempt 3 12 $ entropy 0.4 $ genI

Three verbosities throughout, by the usual prime convention: genI silent, genI' standard, genI'' verbose.

Silent-verbosity genP aliases, one per Roman numeral — genI pins the starting tristrata to I, genII to II, and so on through genXI.

s <- seek "*" $ attempt 3 12 $ entropy 0.4 $ genI

Three verbosities throughout, by the usual prime convention: genI silent, genI' standard, genI'' verbose.

Silent-verbosity genP aliases, one per Roman numeral — genI pins the starting tristrata to I, genII to II, and so on through genXI.

s <- seek "*" $ attempt 3 12 $ entropy 0.4 $ genI

Three verbosities throughout, by the usual prime convention: genI silent, genI' standard, genI'' verbose.

Silent-verbosity genP aliases, one per Roman numeral — genI pins the starting tristrata to I, genII to II, and so on through genXI.

s <- seek "*" $ attempt 3 12 $ entropy 0.4 $ genI

Three verbosities throughout, by the usual prime convention: genI silent, genI' standard, genI'' verbose.

Standard-verbosity Roman numeral aliases: per-step musical context plus the grid. See genI.

Standard-verbosity Roman numeral aliases: per-step musical context plus the grid. See genI.

Standard-verbosity Roman numeral aliases: per-step musical context plus the grid. See genI.

Standard-verbosity Roman numeral aliases: per-step musical context plus the grid. See genI.

Standard-verbosity Roman numeral aliases: per-step musical context plus the grid. See genI.

Standard-verbosity Roman numeral aliases: per-step musical context plus the grid. See genI.

Standard-verbosity Roman numeral aliases: per-step musical context plus the grid. See genI.

Standard-verbosity Roman numeral aliases: per-step musical context plus the grid. See genI.

Standard-verbosity Roman numeral aliases: per-step musical context plus the grid. See genI.

Standard-verbosity Roman numeral aliases: per-step musical context plus the grid. See genI.

Standard-verbosity Roman numeral aliases: per-step musical context plus the grid. See genI.

Verbose-verbosity Roman numeral aliases: full traces, the grid, and the multi-attempt scoreboard when paired with attempt. See genI.

Verbose-verbosity Roman numeral aliases: full traces, the grid, and the multi-attempt scoreboard when paired with attempt. See genI.

Verbose-verbosity Roman numeral aliases: full traces, the grid, and the multi-attempt scoreboard when paired with attempt. See genI.

Verbose-verbosity Roman numeral aliases: full traces, the grid, and the multi-attempt scoreboard when paired with attempt. See genI.

Verbose-verbosity Roman numeral aliases: full traces, the grid, and the multi-attempt scoreboard when paired with attempt. See genI.

Verbose-verbosity Roman numeral aliases: full traces, the grid, and the multi-attempt scoreboard when paired with attempt. See genI.

Verbose-verbosity Roman numeral aliases: full traces, the grid, and the multi-attempt scoreboard when paired with attempt. See genI.

Verbose-verbosity Roman numeral aliases: full traces, the grid, and the multi-attempt scoreboard when paired with attempt. See genI.

Verbose-verbosity Roman numeral aliases: full traces, the grid, and the multi-attempt scoreboard when paired with attempt. See genI.

Verbose-verbosity Roman numeral aliases: full traces, the grid, and the multi-attempt scoreboard when paired with attempt. See genI.

Verbose-verbosity Roman numeral aliases: full traces, the grid, and the multi-attempt scoreboard when paired with attempt. See genI.

Set starting state.

s <- seek "*" $ cue start $ gen

Set progression length (number of chords).

s <- seek "*" $ len 8 $ gen

Set composer blend and execute. Terminal modifier — produces IO ProgressionContext. Every family returns distinct layers: genP carries curated strata/mode chroma with Just provenance, genE partner triads, and gen/genJ chordscale-derived pentatonic/mode layers (chordscale is applied in the dispatch fallthrough) with pcProvenance Nothing.

s <- seek "*" $ gen s <- seek "bach:70 debussy:30" $ cue start $ len 4 $ gen s <- seek "none" $ cue start $ len 6 $ genVI

Set entropy (>= 0) — the gamma sampler targets rank entropy * 10 in the scored pool, so 0 usually takes the top candidate, 0.5 wanders around the 5th, 1 around the 10th; values above 1 reach deeper still.

s <- seek "*" $ entropy 0.5 $ gen

Set harmonic context (R constraints).

s <- seek "*" $ tonal (hcKey "0#" $ hContext) $ gen

Per-bar position within the dynamically-changing active tristrata. Elements ∈ {1,2,3} cycle circularly. Sets _gcLenOverride to the parsed list length so _gcLen doesn't need to be set explicitly; len applied later clears the override (last-writer-wins).

s <- seek "none" $ relStrata "1 1 2 2 3 3" $ genVI -- 6 bars

Per-bar absolute strata label across all tristratas. Elements are Roman numerals I..XI cycling circularly. Sets _gcLenOverride to the parsed list length.

s <- seek "none" $ absStrata "I V X" $ genI -- 3 bars

Override the same-strata continuity boost multiplier. Values below 1.0 favour candidates whose strata matches the previous bar's. Default 0.90. Pass 1.0 to disable the bias.

s <- seek "none" $ sameBoost 0.5 $ genVI -- strong same-strata pull

Override the flip-flop boost multiplier (candidates matching the grandparent strata when the current /= previous). Default 0.80.

Override the same-tristrata continuity boost multiplier. Values below 1.0 favour candidates whose active tristrata matches the previous bar's. Default 0.70 (strongest of the three).

Run multi-attempt rank-and-select generation: produce up to maxAttempts candidate progressions, stop early once viableTarget viable attempts (all bars ModeOk) have been collected, then return the highest-scoring one. Scoring blends root motion, voice leading, and mode validity via defaultWeightsOffline.

s <- seek "*" $ attempt 3 24 $ entropy 0.4 $ gen -- best of up to 24

Polytonal (genE) attempts rank differently, because they are three progressions rather than one: each layer is scored in its own right (half the weight on the foundation, a quarter on each partner) and a divergence axis rewards the layers standing apart — the point of the family. See PolyScore. Raising maxAttempts raises both the quality and the divergence of what comes back.

Defaults are attempt 1 1 — i.e. the modifier is a no-op when omitted, preserving legacy single-pass behaviour.

Set the viability quality floor used by attempt. An attempt is viable iff psModeValidity >= 1.0 (structural invariant) and totalScore >= floor. Default is 0.5; passing 0.0 recovers the original structural-only viability.

s <- seek "*" $ viability 0.65 $ attempt 3 24 $ gen

Tune downward if attempt N K frequently fails to collect N viable within K (raise K or lower the floor); tune upward if K is being hit consistently with mediocre-quality picks (lower K or raise the floor).

Set the genJ classical-steer boost strength (default 3.0). Applies only when the seek spec names classical composers: a jazz candidate containing one of the steer blend's top recommended triads has its score multiplied by up to (1 + strength). 0 disables steering influence entirely. Initial calibration — tune by ear.

s <- seek "debussy" $ steer 6 $ len 8 $ genJ'

Configuration for the modifier-based generation API.

Built via modifier chains:

s <- seek "*" $ cue start $ tonal ctx $ len 4 $ entropy 0.3 $ gen

Generation mode.

Verbosity level for generation output.

Default generation configuration.

cue:     random root, major triad — but an uncued run resolves its cue
         context-aware at run time: inside the tonal context for gen /
         genE / grid (tonalStartCue),
         from the stratum for genP, from the Change graph for genJ
len:     4
seek:    "*" (all composers)
entropy: 0.2
tonal:   hContext (chromatic)

Execute a GenConfig, producing a progression.

Progression-typed view of execGenConfigPC: one dispatcher and one emission path for every family, and the attempt loop (_gcMaxAttempts) is honoured rather than silently ignored.

Terminal executor producing a ProgressionContext.

When _gcMaxAttempts > 1, dispatches through generateBest for rank-and-select multi-attempt generation; otherwise runs a single pass.

The single-pass dispatch reads _gcMode: StrataMode runs the strata- first traversal producing distinct layers; all other modes fall through to execGenConfig and wrap the resulting triad Progression via fromProgression.

Generate with custom configuration and maximum diagnostics (internal).

Generate a progression with NO diagnostic output (verbosity 0 - silent mode).

Generate a progression with STANDARD diagnostic output (verbosity 1).

Generate a progression with VERBOSE diagnostic output (verbosity 2).

Positional generate with header + grid output (internal).

Positional generate with compact musical summary (internal).

Positional generate with verbose traces (internal).

Harmonic context defines the Rules (R) that constrain the generative space.

These filters are applied BEFORE database evaluation (R in R→E→T pipeline), limiting which cadences can even be considered as candidates.

Three-part filtering system: * overtones: Pitch candidate set (e.g., "E A D G" for bass tuning overtones) * key: Key filter applied to candidates (e.g., C, "#", "bb" for key signature) * roots: Root/bass candidate set (e.g., "E F# G" for valid root notes)

Filters use "*" as wildcard (match all). Format matches legacy Overtone.hs notation.

Constructor for HarmonicContext.

Arguments: * overtones: Pitch set filter ("E A D G", C, "*") * key: Key signature filter (C, "#", "bb", Am, "*") * roots: Root notes filter ("E F# G", "1#", "*")

Example: harmonicContext "*" "*" "*" -- No filtering (all candidates) harmonicContext "E A D G" C "*" -- Bass tuning, C major key harmonicContext "*" "#" "E G" -- G major key, E/G roots only String (not Text) so editor plugins that wrap literals in Tidal's deltaContext (which has a Stringy String instance but no Text one) can pass filter strings straight through.

Default harmonic context for Tidal live coding: all wildcards (chromatic). Named hContext to avoid collision with TidalCycles' EventF.context field.

Use modifier functions to constrain the context:

ctx = invSkip 2
    $ consonant
    $ hcRoots "C E G"
    $ hcKey "0#"
    $ hcOvertones "E A D G"
    $ hContext

Direction of dissonance drift across a generated progression.

When applied to a HarmonicContext, the generation engine filters the candidate pool at each step so that only chords with equal or greater (Dissonant) or equal or lesser (Consonant) dissonance than the current chord are preferred. Free imposes no constraint (default).

Advisory, not hard: if the drift predicate would empty the pool at a step, the filter relaxes and that step proceeds unconstrained rather than reaching an absorbing state (applyDriftFilter in Builder.Core). Note the predicate is dissonanceScore — an evaluation function acting as a filter, the documented E-inside-R leak (see ARCHITECTURE §2).

Set overtone filter. Default: "*" (all pitches).

hcOvertones "E A D G" $ hContext — bass tuning overtones

Set key filter. Default: "*" (chromatic).

hcKey "0#" $ hContext — C major

Set roots/bass filter. Default: "*" (all roots).

hcRoots "C E G" $ hContext — only C, E, G as bass notes

Modify context to trend toward increasing dissonance. Each subsequent chord should have dissonance >= the current chord; advisory — relaxes at any step where it would empty the pool.

Modify context to trend toward decreasing dissonance. Each subsequent chord should have dissonance <= the current chord; advisory — relaxes at any step where it would empty the pool.

Set minimum number of non-inversion states between inversions.

invSkip 0 allows inversions at any step (default, current behaviour). invSkip 1 requires at least 1 non-inversion between inversions. invSkip 2 requires at least 2 non-inversions between inversions. The starting state counts toward the counter (a non-inversion start means the first generated step may already be an inversion with invSkip 1).

Advisory, not hard: if excluding inversions would empty the pool at a step, the spacing constraint relaxes for that step rather than halting generation.

Require specific pitch classes to be present in every generated chord.

Tokens are note names (C, G, Bb). A trailing ? marks a tone as preferred rather than required — it is applied when it does not reduce the candidate pool below a minimum viable size, and relaxed otherwise.

Advisory at the limit: the relaxation chain is preferred → required → unfiltered (applyPedalFilter in Builder.Core), so even required tones are dropped as a last resort at a step where enforcing them would leave no candidates — generation never reaches an absorbing state through a pedal constraint.

hcPedal C $ hContext — C must appear in every chord hcPedal "C G" $ hContext — C and G must both appear hcPedal "C G?" $ hContext — C required, G preferred

Restrict the active tristrata pool for genP.

"" (default) — all 12 tristrata allowed. "5" — lock to a single tristrata (here #5, IV-VI-X). "1 2 5" — whitelist multiple tristrata. "[1,2,5]" — bracket form accepted.

Parsed via parseTristrataList; unknown tokens are silently discarded.

Movement represents bass motion by a musical interval

Chord quality/functionality as a string (e.g., "maj", "min7", "dim") Preserved as String for compatibility with legacy naming conventions

Derive functionality name from a pitch set using the legacy triad nameFunc This is for TRIADS (exactly 3 pitch classes)

Derive functionality name from a pitch set using the chord nameFunc This is for CHORDS (any number of pitch classes, extended harmonies)

A Chord is an abstract pitch structure: root note name, functionality, and pitch content as integers, bass first (register-capable). NOTE: toTriad's base case stores ABSOLUTE pitch classes here, not root-relative intervals (F major reads back as [5, 9, 0] — pinned by BridgeSpec); treat the field as "pitches as constructed", never assume root-relative.

A Cadence is a movement type combined with a target chord quality. Abstract: defines "approach by descending 5th to a major chord" without specifying which root pitch.

Convert two pitch classes to a Movement (bass motion direction/distance) Ported from legacy MusicData.hs toMovement

Movement direction is determined by the shorter path around the pitch class circle. Example: C(0) to G(7) = descending by 5 (shorter path is 5 semitones down via P 12) G(7) to C(0) = ascending by 5 (shorter path is 5 semitones up to P 12 ≡ P 0)

Convert Movement back to PitchClass interval

Enharmonic spelling preference (sharp or flat) Stored in CadenceState to enable consistent spelling throughout a progression

Convert EnharmonicSpelling to the actual function (PitchClass -> NoteName) |Classify a pitch class by its natural enharmonic preference. C (PC 0) is AMBIGUOUS - it adopts the pairing's preference (prior or posterior). All other pitch classes have definite preferences.

Get the natural enharmonic preference for a pitch class. C (0) is ambiguous and should be handled specially. F#/Gb (6) is always treated as sharp (F#).

Determine enharmonic spelling for posterior root given prior's actual spelling and both pitch classes.

Rules: (1) SAME PITCH CLASS: Always use prior's actual spelling (the root hasn't changed!) - Example: D# → D# keep Sharp, Eb → Eb keep Flat (2) C IS FLEXIBLE: When C is prior or posterior, the OTHER pitch's preference can override - Prior is C + posterior is definite: adopt posterior's preference - Posterior is C + prior is definite: adopt prior's actual spelling - Both C: persist current (no preference to guide) (3) BOTH DEFINITE (different pitch classes): Consensus-based switching a) If prior's actual spelling matches posterior's preference → persist (consensus on choice) b) If both have SAME preference AND it differs from prior's actual → switch (consensus to switch) c) Otherwise: persist prior's actual spelling (disagreement or already aligned)

Examples: D# → D# (same PC) → persist prior's actual spelling (Sharp or Flat, doesn't matter which) D# (actual Sharp) → E (SharpPref) → both prefer Sharp, actual differs → switch to Sharp!

Default enharmonic spelling for initial state based on root pitch class. C defaults to flat; all others use their natural preference.

Convert enharmonic spelling to the corresponding preference (for symmetry).

Select the spelling function for a given EnharmonicSpelling — sharp or flat. Used to render a pitch class as a note name consistently across a progression, so a single chord grid does not mix F# and Gb.

Infer enharmonic spelling from absolute pitches (bass first). Three-layer system: Layer 1: 3-set match — bass matches AND remaining 2 PCs are subset of chord Layer 2: 2-set match — bass matches AND remaining 1 PC is subset of chord Layer 3: Root fallback — defaultEnharm on bass PC

Detect if a NoteName carries an explicit sharp/flat preference. Sharp variants (C', D', F', G', A') → Just SharpSpelling Flat variants (Db, Eb, Gb, Ab, Bb) → Just FlatSpelling Natural notes (C, D, E, F, G, A, B) → Nothing (use inference)

Check if a chord's absolute pitches match an ambiguous pattern.

A ChordState is a Chord with a concrete root pitch (anchored in pitch space).

A CadenceState is a Cadence with a concrete root pitch and enharmonic spelling. This represents "descend by 5th to G major (flat spelling)" rather than abstract. The enharmonic spelling ensures consistent note naming throughout a progression.

Build a Triad from an enharmonic function and integer list TRIADS: exactly 3 pitch classes. If >3 input, reduces to best triad. Uses elaborate inversion detection from legacy MusicData.hs

Shortcut with flat spelling for triads

Shortcut with sharp spelling for triads

Build a Chord from an enharmonic function and integer list CHORDS: preserves all pitches, uses chord-specific naming for extended harmonies Ported from legacy MusicData.hs toChord (lines 896-941)

Shortcut with flat spelling for chords

Shortcut with sharp spelling for chords

Convert a pair of Chords to a Cadence

Convert ChordState to the underlying Chord

Convert CadenceState back to a Chord (applying the root and spelling)

Initialize a CadenceState from movement, note name, and quality intervals. Enharmonic spelling is inferred from the chord's absolute pitch content.

Build a CadenceState from a root, movement, and root-relative intervals, preserving full cardinality. The non-truncating counterpart to initCadenceState, which routes through flatTriad / toCadence and silently reduces >3 PCs to a triad. Intervals are root-relative (0 = the root; inserted if missing); stored in zero form (sorted, deduped mod 12). Functionality dispatches on cardinality: <=3 uses the triad namer, 4+ the chord namer. Spelling from the typed root when it implies one (Eb → flat), otherwise inferred from absolute pitch content.

Project a Cadence onto its most consonant ROOTED embedded triad. Identity for intervals (every corpus-generated cadence). For3: enumerates the 3-subsets that keep the root ([0,a,b] over the nonzero intervals), picks the least dissonant via the Layer-B mostConsonant replica, and renames with the triad namer. Root, movement, and (via walkTriadState) spelling are preserved, so the projected cadence's show is always a corpus-shaped graph key. This is the walk shadow for >3-note material (regen over hand-built extended progressions, the genJ classical steer): a hand-built added tone can reinterpret the harmony (e.g. [0,3,6]+7 projects to [0,3,7] minor) and thereby steer the next step.

State-level walk projection: walkTriadCadence on the cadence, root and spelling untouched. Identity for triad states.

Trace of toTriad transformation steps

Convert CadenceState to Chord with full transformation trace. Used for maximum verbosity diagnostics (gen''). Includes raw DB data plus all transformation stages.

Construct a Cadence from DB text format (movement string, chord string)

Example: constructCadence ("desc 3", "[P 0,P 3,P 8]") => Cadence { cadenceFunctionality = "maj_1stInv", cadenceMovement = Desc (P 3), ... }

Name a zero-form triad exactly as the corpus stores it. The graph's node keys (show = movement + functionality) carry the names below; any cadence whose show is used as a fetch key MUST be named through here, or the walk silently drops to fallback-only after landing on that form (a latent bug fixed 2026-08-19: constructCadence previously named via bare toFunctionality, so every graph-selected inversion candidate — [0,3,8] read back as min#5 instead of the stored maj_1stInv — produced a keyless next fetch).

The table is the complete 55-form vocabulary transcribed verbatim from a live corpus dump (2026-08-19, MATCH (c:Cadence) RETURN DISTINCT c.chord, c.show). It reflects the LEGACY naming rules the database was ingested under — including the forms where the modernised nameFuncTriad deliberately diverges ([0,2,7] is stored sus4_1stInv, modern says sus2; [0,5,10] is stored sus4_2ndInv, modern says 7sus4) — so it cannot be derived from the current namers. If the corpus is ever re-ingested, regenerate this table from the same query.

Non-triad input (fewer/more than 3 PCs) falls back to the current namers — such sets are never corpus keys.

Deconstruct a Cadence to DB text format (movement, pitch class list) Returns the Movement and [PitchClass] for serialization

Extract the root note from a Chord

Generate all cyclic inversions of a pitch set (in zero form) Each inversion is transformed to zero form for proper comparison

Check if a cadence is an inversion (1st or 2nd) based on zero-form intervals. Patterns match those in detectInversion.

Normalize a pitch set to its most compact form Ported from legacy MusicData.hs normalForm

Compute prime form (transposition and inversion invariant) Ported from legacy MusicData.hs primeForm

Zero-form for pitch classes Subtracts the FIRST element (not minimum) then sorts, matching legacy behavior |Normalize pitch class set to zero form by subtracting first element then sorting. Examples: [P 4, P 7, P 11] → [P 0, P 3, P 7] (maj7 in root position) [P 8, P 11, P 3] → [P 0, P 3, P 7] (maj7 in 2nd inversion) Used by all Cadence construction paths (DB, toCadence, fallback) for semantic consistency.

Calculate the voice leading cost between two chords.

Cost components: * Base: sum of absolute MIDI movements per voice. * Parallel penalty: +3 for each parallel perfect 5th / octave between ANY voice pair (not just adjacent), when at least one voice moves. * Large leap penalty: +2 per voice moving > 4 semitones. * Register-exchange penalty: +4 per adjacent voice pair where both voices move ≥5 semitones in opposite directions (split-leap pattern producing register inversion). Note: not classical "voice crossing" — sorted MIDI voicings have no voice identity to cross — but the same musical effect of register-swapping leaps. * Contrary motion bonus: −1 per voice pair (any pair) where both voices move ≤4 semitones in opposite directions (modest divergence). * Stepwise motion bonus: −1 per stepping voice (movement ∈ {1, 2}) when ≥2 voices step. Single-voice steps contribute 0.

Magnitudes calibrated to compose: contrary motion and register exchange are deliberately disjoint by magnitude (≤4 vs ≥5 thresholds), aligning with the leap-penalty trigger so the same motion is never both rewarded and penalised. They also differ in pair scope by design: register exchange scans ADJACENT pairs only (a register swap is a neighbouring-voices phenomenon), while contrary motion rewards ANY pair.

The total is floored at 1 for any actual motion (from /= to): bonuses could otherwise exceed base + penalties and drive a moving transition below the held-chord cost of 0 — inverting the musical preference. A held chord ("available static movement") is always strictly cheapest; bonuses still discriminate among positive-cost alternatives. The floor applies to the TOTAL only — component bonuses stay un-clamped inside the sum (e.g. [0,4,7]→[-1,2,7] = base 3 + stepwise −1 = 2). Cross-cardinality transitions (mixed-set seams: lead' cues, hand-built fromChords material) are costed by optimal monotone padding: the smaller sorted voicing is expanded by duplicating tones per the minimal-distance non-crossing alignment in which every voice of BOTH chords participates (alignVoices), then the full cost above runs verbatim on the aligned pair. An extra voice pays exactly its distance to the tone it splits from (a literal unison doubling is free); no voice can appear or vanish unpenalised. Historical note: this branch was a flat 999 sentinel, which in the DP acted as "ignore this edge" — seam registers were decided by downstream edges alone and the cyclic wrap objective was silently disabled on mixed material. Voicings must be SORTED ascending — list position is voice order for both the alignment and the parallel-perfect scan. Every production caller sorts before calling.

Calculate total voice leading cost for a sequence of chords

Calculate cyclic cost: total cost including wrap-around from last to first. This is essential for loop-aware optimization.

From the evaluation document: "Adding wrap-around cost to the voice leading solver solves the drift issue elegantly. It forces the algorithm to find a path that is not just locally optimal, but topologically closed."

Calculate the movement for a single voice between two concrete pitches. Movement is measured in absolute semitones (not mod 12 since we're working with concrete pitches in the [0,36] range).

Calculate minimal movement between two pitch class values (mod 12). Exported API; currently unused inside the engine (kept for REPL and downstream use).

Generate all valid voicings for a pitch-class set of any cardinality. Each pitch class is placed at its pitchPlacements octaves (PCs 0-6 get 2 placements in [12, 30]; PCs 7-11 get 3 in [7, 35]) — candidate count is the per-PC placement product (2^a·3^b: typically 12 for a triad, 36 for a tetrad, 72 for a 5-PC set), NOT 3^N. The key-dependent window asymmetry is a known calibration; widening it changes every solved voicing globally and is deferred behind a before/after listening protocol. Results are sorted low-to-high and deduplicated.

Historical note: this was hard-coded to 3 notes, with non-triads falling back to the single candidate [sort pcs] pinned in octave [0,11] — which collapsed bars 2..n of any multi-bar 4+-note progression ~2 octaves below bar 1 under flow/grid (bar 1 goes through initialCompact, the rest through here, then normalizeByFirstRoot applies one uniform shift).

Create initial compact voicing: root in bass in target octave (12-23), upper voices stacked compactly above.

Solve with root always in bass (root paradigm). Filters candidates at each position to only those where bass note mod 12 == root PC. Result is normalized so first chord's root is in [-12,-1]. Memoised: see memoSolve.

Solve FLOW paradigm using cyclic DP: Smoothest voice leading with any inversion allowed for bars 1..n-1. Bar 0 is anchored to the compact root-position voicing (initialCompact) so the progression's starting register is predictable and normalizeByFirstRoot has a stable anchor. Voice crossings permitted in subsequent bars for optimal smoothness. Result is normalized so first chord's root is in [-12, -1]. Memoised: see memoSolve.

Parse overtones from a String (Tidal-friendly) Example: overtones "E A D G" -> bass tuning overtones

Parse key from a String (Tidal-friendly) Example: key "#" -> G major, key "bb" -> Bb major

Parse fundamentals from a String (Tidal-friendly) Example: funds "E F# G" -> [4, 6, 7]

Parse tuning from a String (Tidal-friendly)

Check if a string is a wildcard (Tidal-friendly)

Parse overtones with 3 overtones (default: root, P5, M3)

Parse key (overtone count not used for keys)

Parse fundamentals with 3 overtones (default)

Parse tuning with 3 overtones (default: root, P5, M3 — the distinct pitch classes of the playable tapped-harmonic domain)

Check if a filter string is a wildcard (matches everything)

Parse a tuning string preserving string names for overtone annotation. Case is preserved for string identification (uppercase = lower octave, lowercase = higher octave per thesis convention).

Examples: "E A D G" → [(E,4), (A,9), (D,2), (G,7)] "E A e G B" → [(E,4), (A,9), ("e",4), (G,7), (B,11)] "*" → [] (wildcard has no named strings)

Connect to the local Neo4j from Harmonic.Config (override with the HA_NEO4J_URL environment variable, e.g. http://localhost:7477 to point a REPL at a scratch container). Probes the server with RETURN 1 so an unreachable database surfaces the error here, at connect time — matching what every online generation path expects.

Voice function type: extracts integer pitch sequences from progression

Filter pattern events by DEGREE-INDEX range — the raw Pattern Int values before the degree→pitch mapping, NOT MIDI notes. Instrument range clipping in MIDI space happens later, via clip.

Render scale-degree patterns into a playable ControlPattern, reading pitches from the progression under the given voicing strategy.

The workhorse of the Tidal interface: every orchestral instrument in Harmonic.Interface.Tidal.Orchestra is a thin wrapper around it.

d1 $ arrange (0,1) k (-9,9) T flow id ["0 1 2 3"]

Map notes through chords using squeeze, with kinetics range gating.

Same kinetics/modifier pattern as arrange, but uses squeeze strategy: each chord slot gets the full input pattern compressed to fit.

Stack fixed-interval parallel voices over an arranged ControlPattern. The offset pattern is the FULL voice spec in absolute semitones: each note of pat is replaced by one copy per simultaneous offset, shifted by that offset. Include 0 to retain the original note; omit it to drop the root.

Comma = simultaneous voices, space = time-sequenced offsets (standard mininotation, natively evaluated). Applied post-voicing/post-range-filter, so offsets are not gated by the arrange MIDI range.

parallel "0 7"      $ arrange ... -- root + perfect fifth above
parallel "7"        $ arrange ... -- fifth only (root dropped)
parallel "[0,-5,4]" $ arrange ... -- root, fourth below, major third above

The chosen layer's pitch classes as held MIDI notes, for a device that locks a played keyboard to the harmony (the rig's MiDiNiNjA X3).

One note per distinct pitch class, MIDI 108-119 (pitch class = note mod 12), on MIDI channel 10, each held for the length of its chord: the structure follows the chord grid (snd k), so two chords in a bar give two held sets. Any layer or combination (T, S, M, TS, ...) and any set size. Degree indices 0-11 cover the largest set; the indices past a chord's size fold back onto pitch classes already sent and are dropped, so each chord change costs one message per pitch class on a DIN line shared with the music.

Each set goes out stateLead ahead of its chord: on the wire before the chord's own notes, and in place for keys played just before the downbeat.

Channel 10, notes 108-119 sits above everything else on that channel in both rigs: the JV-map kit (0-9, 60-80), metronome and count, the MPC sub (35-48). The X3 consumes these notes before they reach the MPC.

kmap f k lyr = p "kmap" $ f $ harmonicState lyr k (BootTidal)

Parse a mininotation chord selection pattern (bar-relative). The /N divisor specifies the number of bars the pattern spans.

let r = warp "[1 2 3 4]/4"   -- 4 chords over 4 bars (1 per bar)
let r = warp "[1 2]/8"       -- 2 chords over 8 bars (4 bars each)

Generate a sequential chord selection pattern from a progression. Auto-derives length from the progression. Timing is bar-relative.

let r = rep s4 1     -- 4 chords over 4 bars (1 bar each)
let r = rep s4 0.5   -- 4 chords over 2 bars (half bar each)

Point-query a chord selection pattern at a specific time. Returns the chord index (0-indexed) active at time t. Falls back to chord 0 if no events found.

Lookup a chord from a progression context by index with modulo wrap. Operates on the triad layer (the harmonic content).

Lookup progression (triad layer) as a pattern of voicings via flow.

Forward overlap: merge pitches from n bars ahead

Open strings of an overtone instrument as (name, scientific octave): (A,1) is A1 = MIDI 33.

The instrument behind hmnx: the Electric Contrabass Cittern as the MPC harmonics keymap holds it — open strings A2 E3 G3 (thesis §2.1: EAeGB is E2 A2 E3 G3 B3) and the top string in both Hipshot lever positions, B3 and C4. B and C are one physical string, but the keygroup carries both sets of samples, so both are always available to a pattern; the harmonic context is what limits the space. Fixed on purpose: the keymap never changes, so no launcher states a tuning.

The whole overtone instrument. Pattern ints index the bar's viable composite series — the harmonics of ecbc whose pitch class the layer voices — compressed to 0, 1, 2 … ascending and looped by floor-mod, so "[0,1,2]" is the lowest three available tones from the bottom up and "[-1,-2,-3]" the highest three from the top down, whatever the size of the structure in play. A pitch class present in two octaves is two ints. Never an octave wrap: these are fixed sample pitches. A bar whose voicing has no instrument tone rests. Polyphonic; harmonics is the per-string filter over the same mapping. The harmonic context is the only limit on the space: generating inside the instrument's palette (hcOvertones) keeps every tone reachable, and overtoneMap shows what each int hits.

, composite (0,1) k T ["~", "[0,1,2]/4"] # ch 11

One string of ecbc, named by its open note (A E G B C; enharmonics collapse): the SAME int → pitch mapping as composite, but only the pitches that string can sound pass — the rest are silent, not remapped — so a string block isolates or mutes a string and owns its sustain. Within the string the result is mono' (latest-note priority: a new harmonic damps the previous, as on the instrument).

, harmonics A (0,1) k T ["~", pat] # ch 11

Print, per chord of a progression, what the ints of the basic series map to on the instrument — pitch, MIDI number and sources in thesis notation (E2 = string E, overtone 2; / = alternative sources) — with the top-down alias beside each int; then the distinct ints of the contour over its first bar, resolved per chord. Takes the progression context and the layer the block plays, so what it prints is what composite sounds.

overtoneMap s T ["[0,1,2]/4"]

The basic series over a set of voiced pitch classes, on ecbc: (int, MIDI pitch, sources), a source being (string, overtone number) in the thesis's numbering — OT1 the fundamental's class (partials 2 and 4), OT2 the fifth, OT3 the third. Pure core of overtoneMap.

The composite overtone series (thesis §2.2): every pitch any string of a tuning can sound as a natural harmonic, ascending, once each. compositeSeries ecbc is the keymap: 57 64 67 69 71 72 73 74 76 78 79 80 83 84 87 88.

The four playable partials of the 2016 thesis — octave, fifth, double octave, third (partials 2 3 4 5) — of one open string, as MIDI pitches.

Semitones from a string's fundamental to its n-th partial: round (12 * logBase 2 n), so partials 2..5 sit at +12 +19 +24 +28.

A node in a form definition: a point in time with kinetics level, dynamic level, active progression, and the transition style of the section starting here.

A node's position in time — wall-clock Secs elapsed (0 = the start) or musical Bars (4/4), numbered from 1 as the 12 Step counts them (bar 1 = the start). Resolved to Tidal cycles at realization (see formK). Mix freely in one form.

How a section moves to the next node: Smooth (ramped) or Snap (hold this node's value, then jump on the next node's exact time).

Realized form: continuous and discrete signals for live performance.

Performance context: Kinetics bundled with chord selection pattern. Reduces parameter threading — r and k are always passed together.

Form node builders. Time unit and transition are orthogonal: at/at' take wall-clock seconds elapsed, rh/rh' take musical bar numbers (rehearsal marks, 4/4, bar 1 = the start of the form); unprimed = smooth transition, primed = snap.

at 0 0 0 s seconds, smooth rh 10 0.5 0.5 s bars, smooth at' 60 1 1 s seconds, snap rh' 18 0.9 0.9 s bars, snap

Form node builders. Time unit and transition are orthogonal: at/at' take wall-clock seconds elapsed, rh/rh' take musical bar numbers (rehearsal marks, 4/4, bar 1 = the start of the form); unprimed = smooth transition, primed = snap.

at 0 0 0 s seconds, smooth rh 10 0.5 0.5 s bars, smooth at' 60 1 1 s seconds, snap rh' 18 0.9 0.9 s bars, snap

Form node builders. Time unit and transition are orthogonal: at/at' take wall-clock seconds elapsed, rh/rh' take musical bar numbers (rehearsal marks, 4/4, bar 1 = the start of the form); unprimed = smooth transition, primed = snap.

at 0 0 0 s seconds, smooth rh 10 0.5 0.5 s bars, smooth at' 60 1 1 s seconds, snap rh' 18 0.9 0.9 s bars, snap

Form node builders. Time unit and transition are orthogonal: at/at' take wall-clock seconds elapsed, rh/rh' take musical bar numbers (rehearsal marks, 4/4, bar 1 = the start of the form); unprimed = smooth transition, primed = snap.

at 0 0 0 s seconds, smooth rh 10 0.5 0.5 s bars, smooth at' 60 1 1 s seconds, snap rh' 18 0.9 0.9 s bars, snap

Construct performance context from BPM, form nodes, and chord selection.

k = iK tempo [at 0 0 0 s, at 30 1 1 s] (warp "[1 2 3 4]/8")

Live kinetics: build IK from reactive kinetics/dynamics signals. Bypasses form interpolation — use when the envelope is driven by live input (e.g. MIDI CC) rather than a static keyframed form.

k = lK exP exP s r -- pedal drives both kinetics and dynamics

Realize a form definition into Kinetics signals at a given BPM. Single-node forms produce constant signals (global state). Multi-node forms produce per-segment signals — smooth (ramp) or snap (step) per each node's fnTrans — and a step-function progression, looping at the form's total duration. Time is resolved from each node's FormTime.

Contract details:

• The LAST node is the loop terminator, not a playable section: segments run between consecutive node pairs, and the final node's time sets kLoopSecs. Its kinetics/dynamic values only shape the ramp INTO it.
• Nodes are sorted by resolved time before use, so a moved rehearsal mark cannot produce negative-width segments. Nodes sharing a time yield a zero-width segment (the earlier one is inaudible).
• formK bpm [] yields silence on every signal — safe to evaluate mid-edit; nothing sounds until a node exists.
• Smooth ramps render at 16 steps per SEGMENT regardless of length (see formSignal) — a long segment crosses kinetics thresholds on a correspondingly coarse grid.

Range gate: mask a pattern by kinetics signal level. Events pass only when kSignal is within the (lo, hi) range.

Gated stack: stack patterns and gate by kinetics range.

Bridge helper: apply a function taking ProgressionContext to a Kinetics context. Uses innerJoin to reactively switch when the form changes progressions.

A degree range for every line the launcher starts, applied in k:

k = isolate (-4,2) $ iK tempo form (rep s 4)

isolate keeps degree indices lo..hi (inclusive), as a line's own (-9,9) does; isolate' keeps only those outside it (lo and hi dropped). Each line's own range still applies, so the two intersect, and calls compose: isolate (-9,4) . isolate' (0,0) is -9..4 without degree 0. Lines that don't voice degree indices (drums, walking bass, subKick, harmonics, kmap) are unaffected.

A degree range for every line the launcher starts, applied in k:

k = isolate (-4,2) $ iK tempo form (rep s 4)

isolate keeps degree indices lo..hi (inclusive), as a line's own (-9,9) does; isolate' keeps only those outside it (lo and hi dropped). Each line's own range still applies, so the two intersect, and calls compose: isolate (-9,4) . isolate' (0,0) is -9..4 without degree 0. Lines that don't voice degree indices (drums, walking bass, subKick, harmonics, kmap) are unaffected.

markAt in bars (see the doctrine there).

markAt in seconds.

markAt in bars (see the doctrine there).

markAt in seconds.

Form-relative cue: place patterns ONCE per form loop at a form time. The list is stacked (the shape of slate); each pattern's first cycle is squeezed into the one-beat window starting at that time, so a plain one-note pattern fires exactly on the beat and "1 1" gives two hits within it. Loops in lockstep with kSignal — the same slow loopCycles wrap as formSignal — so a cue and the kinetics can never drift apart. NOT kinetics-gated: a placement is absolute (the launcher's |* vel d still applies).

Time-unit doctrine: unprimed = bars, primed = seconds. mark takes musical bar numbers as written for rh nodes (bar 1 = cycle 0, the number the 12 Step shows); mark' takes seconds elapsed as for at nodes (the 12 Step's seconds counter reads the same) and, like them, assumes cps has been constant since cycle 0. markbar / marksec are synonyms.

Atemporal forms (single node, lK) fire once at absolute cycles. A time at or beyond the loop end, or no cps, is silence.

, mark 34 k [ pad 1 |* vel 0.9 ]      -- speech sample on the drop

Rotate a progression by n bars (positive = left, negative = right). Bar-aligned: provenance and family travel with the bars.

Extract bars start to end (1-indexed, inclusive). Bar-aligned: provenance and family travel with the bars.

Insert a CadenceState at position (1-indexed), replacing the existing one. Bar substitution: the foreign bar breaks strata/polytonal invariants, so provenance drops and those families downgrade.

Switch two bars at positions m and n (1-indexed). Treated as substitution (drops provenance, downgrades strata/polytonal families); promotable to the aligned tier via a lockstep update pair if per-bar identity is ever wanted here.

Clone bar m to position n (overwrites n with contents of m). Treated as substitution — see switch.

Extract a single CadenceState at index (1-indexed, modulo wrap) from the triad layer

Transpose a progression by n semitones. Strata provenance is anchored to ABSOLUTE pitch classes (the octatripentatonic universe has no transposition closure), so provenance and family survive only octave shifts; any other interval drops them.

Reverse a progression. Bar-aligned: provenance and family travel.

Fuse multiple progressions into one (concatenation)

Binary fuse for convenience in live coding

Interleave two progressions (alternating chords) Example: interleave [A,B,C] [X,Y,Z] = [A,X,B,Y,C,Z]

Expand a progression by repeating the WHOLE progression n times (expandP 2 on C F G A yields C F G A C F G A). Bar-aligned replication: provenance and family travel.

Bidirectional overlap: merge pitches from n bars in both directions

Forward-only overlap: merge pitches from n bars ahead

Backward-only overlap: merge pitches from n bars behind

GRID paradigm: Root locked in bass with smooth compact voice leading. Uses cyclic DP to find globally optimal voicings. First chord starts compact with root in bass; all subsequent chords maintain root in bass with minimal voice movement.

FLOW paradigm: Smoothest voice leading with any inversion allowed. Uses cyclic DP to find globally optimal voicings. Voice crossings permitted for optimal smoothness; bass doesn't need to be the root if an inversion provides smoother voice leading.

LITE paradigm: Literal voicings with first-root normalization. Returns pitches as stored, but normalized so first chord's root is in [-12,-1]. No voice leading optimization applied (only octave normalization).

Alias for lite (legacy compatibility)

ROOT paradigm: Root note only (root pitch class per chord). Extracts the root note (first element, mod 12) from each chord. Returns as single-element lists in [0,11] range.

Construct a Progression from explicit pitch-class sets. This is the main function for composing/arranging workflow (not generation). Takes an enharmonic spelling and a list of chord pitch-class sets, returns a Progression ready for arrange.

Example: fromChords [[0,4,7], [5,9,0], [7,11,2]] --> C major → F major → G major

Legacy alias for fromChords (matches legacy prog function)

Groove interface: kick and sub bass locked to the harmony, with chord selection and kinetics gating from IK.

Sub on/off patterns and the kick pattern are bar-relative: "[1]/2" = one onset every 2 bars, "1*4" = 4 kicks per bar.

Each sub note is held by its own duration: from its onset to the next kill boundary — the manual offs (subOffPat) and, for maxDur < 1, each onset shifted by maxDur*4 — emitted with legato 1 so the note-off lands on the boundary. The hold is by note length, not by a CC64 pedal: the MPC sub program does not treat CC64 as a damper (a MIDI note-off arriving under a held pedal is stranded), so no CC64 is emitted here at all.

Chord selection uses innerJoin — we WANT new note-ons when the chord changes. Sub is gated at (0.1, 1) and kick at (0.2, 1) via ki. The launcher dynamic is the only dynamic applied — subKick deliberately ignores the form's kDynamic envelope, so the sub holds its level while the orchestra swells and ducks around it.

Hold each onset of pat until the next onset in bounds, rewriting the event whole to [onset, nextBoundary) (continuation fragments across cycles are preserved). A boundary is where the note must stop, so the note stops exactly there. Pair with # legato 1 so the emitted MIDI note-off lands on the boundary. Values are sampled once at the onset and held for the whole note (no mid-note re-sampling). look is the lookahead/lookback in cycles; note lengths must not exceed it.

Extract harmonic roots regardless of inversion — the harmonic FUNDAMENTAL uniformly, where root is uniformly the sounding bass. Triads go through inversion detection (a first-inversion bar reports its harmonic root, not its bass). Bars of more than three tones ask the jazz namer for the rotation: a slash structure (Bb7 over Ab) reports its true root (Bb), matching the chart-convention grid name; a root-position extended chord — and any set the namer cannot read — keeps its stored anchor. The walking bass is unaffected either way: it anchors on the stored root internally and reads a voice function only for beat-1 pitch choice.

Truncate each gate onset's note length to at most 1/n of a bar (bar = 4 cycles), else extend it to the next onset. Only True onsets sound; a truncated tail is a rest; onsets are not moved. Pair with # legato 1 on sustaining instruments to hear the length. Precondition: n > 0.

Bar patterns are written "/4" (1 cycle = 1 beat, 1 bar = 4 cycles), so e.g. noteoff 4 caps each hit at a quarter note (1 cycle):

noteoff 4 "[[1 0 0 0] [0 0 0 0] [1 0 0 0] [1 0 0 0]]\/4"  ==  "[1 0 1 1]\/4"

Explicit 16-step (2-bar) boolean grids, one stroke per position, for clave and cascara feels. Use with struct or mask on any instrument or drum part.

32 is the 3-2 orientation; 23 is the 2-3 rotation (2 <~ over the /4 two-bar span swaps the halves). Onset positions are 1-indexed.

Explicit 16-step (2-bar) boolean grids, one stroke per position, for clave and cascara feels. Use with struct or mask on any instrument or drum part.

32 is the 3-2 orientation; 23 is the 2-3 rotation (2 <~ over the /4 two-bar span swaps the halves). Onset positions are 1-indexed.

Explicit 16-step (2-bar) boolean grids, one stroke per position, for clave and cascara feels. Use with struct or mask on any instrument or drum part.

32 is the 3-2 orientation; 23 is the 2-3 rotation (2 <~ over the /4 two-bar span swaps the halves). Onset positions are 1-indexed.

Explicit 16-step (2-bar) boolean grids, one stroke per position, for clave and cascara feels. Use with struct or mask on any instrument or drum part.

32 is the 3-2 orientation; 23 is the 2-3 rotation (2 <~ over the /4 two-bar span swaps the halves). Onset positions are 1-indexed.

Explicit 16-step (2-bar) boolean grids, one stroke per position, for clave and cascara feels. Use with struct or mask on any instrument or drum part.

32 is the 3-2 orientation; 23 is the 2-3 rotation (2 <~ over the /4 two-bar span swaps the halves). Onset positions are 1-indexed.

Explicit 16-step (2-bar) boolean grids, one stroke per position, for clave and cascara feels. Use with struct or mask on any instrument or drum part.

32 is the 3-2 orientation; 23 is the 2-3 rotation (2 <~ over the /4 two-bar span swaps the halves). Onset positions are 1-indexed.

Explicit 16-step (2-bar) boolean grids, one stroke per position, for clave and cascara feels. Use with struct or mask on any instrument or drum part.

32 is the 3-2 orientation; 23 is the 2-3 rotation (2 <~ over the /4 two-bar span swaps the halves). Onset positions are 1-indexed.

Explicit 16-step (2-bar) boolean grids, one stroke per position, for clave and cascara feels. Use with struct or mask on any instrument or drum part.

32 is the 3-2 orientation; 23 is the 2-3 rotation (2 <~ over the /4 two-bar span swaps the halves). Onset positions are 1-indexed.

Walking-bass arrangement with kinetics gating.

Fixed to the double-bass register (E1..C3, MIDI 28..48) inside walkLine; the emitted Tidal note values are pre-shifted by tidalNoteOffset so this range is audibly true at default synth tuning — no |- oct n compensation needed. Runtime register shifts via |+ oct n / |- oct n on the launcher side still compose normally.