tonal-guitar 0.6.0 → 0.8.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
package/CHANGELOG.md CHANGED
@@ -7,6 +7,54 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
7
7
 
8
8
  ## [Unreleased]
9
9
 
10
+ ## [0.8.0] — 2026-11-19
11
+
12
+ ### Changed (breaking)
13
+
14
+ [docs/UPGRADING.md](./docs/UPGRADING.md) says what to look for in your code and what to do about each of these, with the call before and after.
15
+
16
+ - **`connectSequences` joins two walks.** It kept its name and changed its meaning: `connectSequences({ notes, walk }, { notes, walk }, options?)` takes the two walks themselves, as lists of notes with the `WalkSpec` each was made with, and returns `{ bridge, next, kind, through }`: the notes to play between them, the second walk as it is played (whole, or less its first notes, so a turning note sounds once), whether the bridge carries the first walk on (`"extend"`) or goes the way the second walk goes (`"reach-back"`), and the note names a run went through. The options are `turn` (`"repeat"`, `"pivot"` or `"next"`, default `"next"`), `fill` (`"run"` or `"leap"`) and `through`. A bridge stops by the second walk's first note, and a run goes along the string through a scale or a chord, over frets neither walk plays. The old call, `connectSequences({ prev, next }, { dedupSeam, strategy })`, is read as a call with no notes: it returns `undefined` and does not throw. `undefined` is what `connectSequences` returns for any input it cannot read (a `direction` that is not one of `walk`'s four among them), so check for it before reading the result. `{ dedupSeam: false }` is `{ turn: "repeat" }`, and `{ dedupSeam: true }`, the old default, is `{ turn: "pivot" }`: the same notes are heard in each of the ten cases this library's examples compare, and not at every seam (about one in four of 10,000 generated pairs differs; see the upgrade notes). The types `ChainDirection`, `ConnectSequencesInput`, `ConnectorOptions`, `ConnectorStrategy` and `ConnectSequencesResult` are removed, so a TypeScript caller of the old form no longer compiles. The result is also `undefined` when a note at a joined seam has no finite `midi`, and when the notes of the two walks on the last note's string span more than 1,024 frets or are more than 1,025 different pitches.
17
+ - **`walk`'s default turn is named `"next"`.** `turn` is `"repeat" | "pivot" | "next"`, default `"next"`: `"next"` is the walk the 0.7.0 default `"no-repeat"` played, note for note, so a walk written without a `turn` plays what it played before. `"no-repeat"` is still read, as `"next"`, so a stored `Segment.walk` keeps its meaning, and `WalkSpec.turn` still takes it in TypeScript, deprecated; it is not in the `Turn` type, which `connectSequences` and `chain` take; `"pivot"` is new (below). Write `"next"`.
18
+
19
+ ### Changed
20
+
21
+ - `walk` returns `[]` for a scale or an option that throws when it is read, and for a scale that is not an object. It used to throw.
22
+
23
+ ### Added
24
+
25
+ - Key helpers: `orderKeys(keys, order, startKey?)` puts keys in fourths, fifths, half steps or as listed (`KeyOrder`: `"fourths"`, `"fifths"`, `"half-step"`, `"listed"`); `keyShift(from, to)` and `normalizeKeyShift(semitones)` give the distance between two keys as a whole number from -6 to 5; `spellTonic(pc, prefer, mode?)` names a pitch class with flats, with sharps or as the key with that tonic is written; `moveKeyBy(key, semitones)` moves a key name and keeps its form (`"A minor"` by 1 is `"Bb minor"`); `slideOffset(low, high, semitones, fretCount?)` is how far written material slides to stay on the neck. A key is a string `keySignatureOf` reads; each gives `undefined` for what is not a key and for a number that is not whole, and none throws. See [docs/api/keys.md](./docs/api/keys.md).
26
+ - `keyRun(parts, options?)` joins one part for each key into the segments of a line, with a gap between keys (`between`, `meter`) and the key's name above its first note (`label`). It gives `undefined` for a gap that does not fill a whole number of bars of its own meter (a rest of 3/2, 5/4, 1/3 or 1/7 in 4/4), since every key after it would start off the bar line. Types: `KeyRunPart`, `KeyRunOptions`.
27
+ - `chain(segments, options)` joins the segments of a line with a bridge segment at each turn, by the rule `connectSequences` applies, once at each seam (`ChainOptions`: `tuning`, `turn`, `fill`, `through`, `rhythm`). `Segment.bridge` (`"extend"` or `"reach-back"`) marks a segment `chain` added. It is a new optional field and the stored form stays `"tonal-guitar/line@1"`, which keeps `bridge` and which 0.7.0 reads without it; `lineIssues` reports a `bridge` that is not one of the two values, and one on a gap, as a `segment` issue. A bridge note on a fret neither segment plays is `{ string, fret, midi, pc }`, as `connectSequences` gives it. When a segment gives up its first steps at a turn, the first chord symbol and the first text on them move to the step that now comes first, unless it has its own; marks and fingering go with the notes. See [docs/api/lines.md](./docs/api/lines.md#chain).
28
+ - `fitSegments(segments, meter, options?)` is `fitToBars` for a pass of several segments, such as one `chain` made: the last note is held to the beat and the bar is filled once, for the whole pass. See [docs/api/lines.md](./docs/api/lines.md#fitsegments).
29
+ - `walk`: `turn: "pivot"` plays the turning note once and begins the way back on it (59 notes for the E shape of A major in thirds, up and down, where `"repeat"` plays 60 and `"next"` 58). `count` stops a walk after that many notes (a whole number from 1 to 4,096). `ends: "turn"` makes a walk turn at each end of the shape until `count` notes, and needs `count`. `after: { notes, shape? }` carries on from another walk: from the first position past the last note it played, the way it was going, or the other way when the shape has none left, so a line through changes needs no loop of the caller's own. `start` and `end: "root"` are refused with `after` and with `count` respectively. See [docs/api/patterns.md](./docs/api/patterns.md#walk).
30
+ - `Turn`, `Fill`, `JoinKind`, `WalkedNotes`, `BridgeNote`, `ConnectOptions` and `ConnectResult` types, for `walk` and `connectSequences`.
31
+ - `TabNote` (`{ string, fret, midi }`): what the note form of `toAlphaTeX`, `toAsciiTab` and `walk`'s `after.notes` read of a note. Their parameters now take `TabNote` lists where they took `FrettedNote` lists, so a list joined by `connectSequences` (`[...notes, ...result.bridge, ...result.next]`, where a bridge note can be a fret neither walk plays) goes straight in. Every call that compiled before still compiles.
32
+ - API pages: Keys (`docs/api/keys.md`) and Exercise spec (`docs/api/exercise-spec.md`), a `connectSequences` section on the Patterns page, `chain`, `fitSegments` and `bridge` on the Lines page, and what `nearestPlacement` answers when a caller asks for the "nearest" or "closest" shape on the Placement page.
33
+
34
+ ### Experimental
35
+
36
+ These may change in any release, including in a way that stops a stored spec from being read; see [docs/api/exercise-spec.md](./docs/api/exercise-spec.md).
37
+
38
+ - `ExerciseSpec` (`"tonal-guitar/exercise@0"`): a whole exercise as one plain object, with `validateExerciseSpec(spec)`, which lists what is wrong with one (`ExerciseIssue`, `ExerciseIssueCode`) and needs no Tonal.js peer, and `buildExercise(spec, options?)`, which calls the pieces of the other pages in order (placement, `walk`, `applyRhythm`, `chain` when the spec joins its boxes with a bridge, `fitSegments`, `keyRun`) and returns `{ line, issues }`: all or nothing, so any issue leaves `line` `undefined` (`BuildExerciseOptions`, `ExerciseResult`). Besides shape and bounds, the check refuses a walk with `ends: "turn"` and no `count` or with `end: "root"` and a `count`, and a spec whose keys, boxes and turning walk's `count` ask for more than the 200,000 steps a line holds; and `buildExercise` refuses a position given by `number` with no `placement.system` in a key where more than one system has that number. A field the check does not know is an issue (`keys.lable is not a field of keys`), so a misspelled field is not dropped silently. A scale whose name begins with `minor` or `major` (`"minor pentatonic"`, `"major blues"`) is written with that key's signature, however the key is listed. Parts of the type: `ExerciseMaterial`, `ExercisePlacement`, `ExerciseTime`, `ExerciseKeys`.
39
+
40
+ ## [0.7.0] — 2026-11-17
41
+
42
+ ### Added
43
+
44
+ - Notes in time. `Dur` (`{ n, d }`, a fraction of a whole note) with `isDur`, `reduceDur`, `addDur`, `subtractDur`, `multiplyDur`, `compareDur` and `sumDur`: exact, in lowest terms, never a floating point sum. A `Step` is notes (`[]` is a rest; a note is a `StepNote`, which needs only a `string` and a `fret`, so a built `FrettedNote` and a hand-written `{ string: 0, fret: 3 }` both fit) with a `dur`, and optionally a `tuplet`, `tie`, `marks`, `finger`, `text` and `chord`; a `Segment` is steps from one placement (`from`, which is `{ shapeId, buildRoot, tonic, scaleType? }`, and `walk`) with an optional `label`, `meter`, `key`, `tempo`, `section`, `repeatStart`, `repeatEnd` and `gap`; a `Line` is a `tuning`, a `meter`, an optional `key`, `feel` and `tempo`, and `segments`. Exported types: `Dur`, `Meter`, `Tuplet`, `Feel`, `Mark`, `StepNote`, `Step`, `SegmentSource`, `Segment`, `Line`.
45
+ - `applyRhythm(notes, rhythm)` gives a walk's notes their lengths from one duration or a repeating cell of slots (rests, ties, tuplets), and `RHYTHM_CELLS` has eight common cells (`quarters`, `eighths`, `triplets`, `sixteenths`, `sixteenth-triplets`, `gallop`, `reverse-gallop`, `dotted-eighth-sixteenth`). Types: `RhythmSlot`, `RhythmCell`, `RhythmCellId`.
46
+ - `fitToBars(steps, meter, options?)` ends a list of steps on a beat (the last note is held to it) and fills its last bar with rests, and can cut steps at bar lines, leaving each mark on the part it belongs to, so the cut steps write the same tab (`FitOptions`, `FitResult`). `gapSegment(gap, meter)` is a segment of silence (`"none"`, `{ rest }` or `{ bars }`); a gap is written in the key and tempo of the segment it leads into. `segmentFrom(placement, steps, extra?)` makes a segment with `from` and, where it can be read, `key`. Type: `Gap`.
47
+ - `lineBars(line)` and `lineEvents(line)`: where the bar lines fall (`LineBar`) and when each sounding note starts and how long it lasts, with tied runs joined (`LineEvent`). `lineIssues(line)` lists everything that stops a line being written, with a code, a message that shows the value, and indexes (`LineIssue`, `LineIssueCode`). Among them are things alphaTab would show wrong without saying so: two chord symbols that differ only in letter case (`CM7` and `Cm7`), and a slide to the next note together with a slide out. A line has at most 200,000 steps, a step at most 12 notes and 16 marks; every read of a list stops at a bound. A step's `text` or `chord` and a segment's `label` or `section` has at most 1,000 characters, and a `key` at most 64: a longer one is a `text` or `key` issue that says to shorten it or, for a text, to split the exercise into more than one line. The fields of a segment's `from` have the same 1,000-character bound (a longer one is a `segment` issue), and a note's descriptive strings or a walk's option strings over it are left out of the stored form. A walk's `motif` of more than 64 numbers is left out of the stored form as well. A stored form too long to be a string is not written: `serializeLine` gives `undefined`, and when the strings alone pass 536,870,888 characters it does so without building the text. Within these bounds a line can still ask for a tab too long to return, which costs seconds before `""` comes back; the Lines page gives the measurements.
48
+ - `normalizeLine`, `lineEquals`, `serializeLine`, `parseLine` and `LINE_SCHEMA` (`"tonal-guitar/line@1"`): equality of two lines as data, and a stable JSON form, tagged under `$schema`, that parses back to the same line.
49
+ - `toAlphaTeX(line, options?)` writes a `Line`: a five-line header, then one bar per line in which every bar adds up. A step that crosses a bar line is cut and tied; a short bar has a meter of its own and is filled to the beat when it has to be; a segment's meter, key and tempo, section and repeats are written where they change; marks, fingering, pick strokes, tuplets, text and chord symbols are written, and a line with an issue writes `""`. `LineTexOptions` is the new options type (`title`, `staff`). The note form of `toAlphaTeX` is kept until 1.0 and its output is unchanged.
50
+ - `MOTIFS`: the motifs of eleven common drills (`linear`, `thirds`, `fourths`, `sixths`, `triads`, `sevenths`, `groups-3`, `groups-4`, `1235`, `up-and-back`, `triad-climb`) for `walk`'s `motif`, frozen. Type: `MotifId`.
51
+ - `keySignatureOf(key)`: the key signature for a key written as one string (`"A minor"`, `"D dorian"`), by the rule `toAlphaTeX`'s `key` already used; `undefined` for a string it cannot read.
52
+ - Docs: a Lines page (`docs/api/lines.md`), and the line form of `toAlphaTeX` on the Output page.
53
+
54
+ ### Changed
55
+
56
+ - `toAlphaTeX` given an object that is not an array reads it as a line: it returns the tab when the object is a valid `Line` and `""` when it is not. Such a call used to throw (`TypeError: notes.map is not a function` for `{}`, a `Map` or a `Date`; `group.map is not a function` for a typed array with entries). An object with a `map` of its own that returned nothing did not throw: an empty typed array gave a tab with no notes, and now gives `""`. Arrays, `null`, strings and numbers behave as before, and the output for a list of notes is unchanged.
57
+
10
58
  ## [0.6.0] — 2026-11-17
11
59
 
12
60
  ### Added
package/README.md CHANGED
@@ -52,6 +52,50 @@ console.log(toAsciiTab(notes));
52
52
  console.log(toAlphaTeX(notes, { tempo: 100, duration: 8 }));
53
53
  ```
54
54
 
55
+ ## Notes in time
56
+
57
+ A walk gives notes with no length. Give them lengths with `applyRhythm`, fit them to bars with `fitToBars`, and write the tab of a `Line` with `toAlphaTeX`:
58
+
59
+ ```ts
60
+ import {
61
+ placeScale,
62
+ walk,
63
+ MOTIFS,
64
+ applyRhythm,
65
+ fitToBars,
66
+ segmentFrom,
67
+ toAlphaTeX,
68
+ STANDARD,
69
+ type Line,
70
+ } from "tonal-guitar";
71
+
72
+ // C major, CAGED E shape, thirds up and down, in eighth notes
73
+ const box = placeScale("C major", {
74
+ system: "caged",
75
+ position: { view: "tonic", letter: "E" },
76
+ });
77
+ const notes = walk(box, { motif: [...MOTIFS.thirds], direction: "up-down" });
78
+ const steps = applyRhythm(notes, { n: 1, d: 8 }) ?? []; // give each note an eighth
79
+ const fit = fitToBars(steps, [4, 4]); // fill the last bar with rests
80
+ if (!fit) throw new Error("the notes could not be fitted");
81
+
82
+ const line: Line = {
83
+ tuning: STANDARD,
84
+ meter: [4, 4],
85
+ segments: [segmentFrom(box, fit.steps, { label: "C major thirds" })],
86
+ };
87
+ console.log(toAlphaTeX(line, { title: "C major, E shape, thirds" }));
88
+ // => \title "C major, E shape, thirds"
89
+ // \tempo 120
90
+ // \track ("Guitar" "Gtr")
91
+ // \staff {tabs}
92
+ // \tuning (E4 B3 G3 D3 A2 E2)
93
+ // \ts (4 4) \ks C :8 7.6{txt "C major thirds"} 10.6 8.6 7.5 10.6 8.5 7.5 10.5 |
94
+ // ... eight bars in all: 58 notes and three quarter rests
95
+ ```
96
+
97
+ A `Line` is plain data (`tuning`, `meter` and `segments` of `steps`); `lineIssues` lists what is wrong with one, `lineBars` and `lineEvents` say where the bars fall and when each note sounds, and `serializeLine` and `parseLine` store it. See [docs/api/lines.md](./docs/api/lines.md) and [docs/api/output.md](./docs/api/output.md).
98
+
55
99
  ## v0.2.0 Changes
56
100
 
57
101
  - **`buildFromScale` pitch-correctness fix.** `buildFromScale` now relabels a shape into the requested scale's interval frame before building, so minor-tonic (and other non-major) scale names produce correct pitch content instead of silently building the shape's original (usually major) frame at the new tonic. See [buildFromScale](#tonaljs-integration) for the before/after example.
@@ -423,13 +467,55 @@ walk(scale, { motif: [1, 3], start: "lowest-root", end: "root" });
423
467
  | ----------- | ------------------------------------------------------- | ------- |
424
468
  | `motif` | `[1]` | Steps of one statement, 1-based from the statement's own position (0 or a negative number reaches back). An empty or unset motif is the plain walk |
425
469
  | `direction` | `"up"` | `"up"`, `"down"`, `"up-down"` or `"down-up"` |
426
- | `turn` | `"no-repeat"` | At the turn of a two-leg walk, `"repeat"` plays the turning note twice |
470
+ | `turn` | `"next"` | At the turn of a walk that goes there and back: `"repeat"` plays the turning note twice, `"pivot"` once with the way back beginning on it, `"next"` once with the way back beginning on the next note |
427
471
  | `start` | `"lowest"` going up first, `"highest"` going down first | `"lowest"`, `"lowest-root"`, `"highest"` or `"highest-root"` |
428
472
  | `end` | `"where-it-stops"` | `"root"` appends the notes to the nearest root, the root included |
429
473
  | `stride` | `1` | Positions the statement moves between statements |
430
474
  | `index` | `"pitch-order"` | `"degree"` lays notes out by degree across octaves and leaves a hole where a degree has no note |
475
+ | `after` | none | `{ notes, shape? }`: carry on from another walk, from the first position past its last note, the way it was going. Not with `start` |
476
+ | `count` | none | Stop after this many notes, a whole number from 1 to 4,096 |
477
+ | `ends` | `"stop"` | At an end of the shape, `"turn"` turns and goes the other way until `count` notes; it needs `count` |
478
+
479
+ `"no-repeat"`, the name `"next"` had before `"pivot"` existed, is still read as `"next"`. A leg ends when a statement does not fit. Going down plays the motif from each position and moves down, unlike `walkPattern`'s `"down"`. `walkShapeMotif(scale, [])` is now the plain walk. See [docs/api/patterns.md](./docs/api/patterns.md) for the details.
480
+
481
+ #### `connectSequences(before: WalkedNotes, next: WalkedNotes, options?: ConnectOptions) => ConnectResult | undefined`
482
+
483
+ Joins two walks you already made: the notes to play between them, and the second walk as it is played, with its first notes left out where the turn would sound twice. Each argument is a walk's notes and the `WalkSpec` it was made with (its `direction` and `motif` are read). It plays neither walk, takes no tuning, never throws and changes nothing it is given.
484
+
485
+ ```js
486
+ import { connectSequences, walk, get, buildFrettedScale } from "tonal-guitar";
431
487
 
432
- A leg ends when a statement does not fit. Going down plays the motif from each position and moves down, unlike `walkPattern`'s `"down"`. `walkShapeMotif(scale, [])` is now the plain walk. See [docs/api/patterns.md](./docs/api/patterns.md) for the details.
488
+ const walked = (shape, spec) => ({
489
+ notes: walk(buildFrettedScale(get(shape), "A"), spec),
490
+ walk: spec,
491
+ });
492
+
493
+ // A major: the E shape in thirds going up, then the D shape in thirds coming down
494
+ const before = walked("E Shape", { motif: [1, 3], direction: "up" });
495
+ const next = walked("D Shape", { motif: [1, 3], direction: "down" });
496
+
497
+ const joined = connectSequences(before, next);
498
+ if (joined === undefined) throw new Error("the two walks could not be read");
499
+ const { bridge, next: rest, kind, through } = joined;
500
+ // kind => "extend"
501
+ // bridge => 5.1 9.1 7.1 10.1 (as fret.string: string 1 is the high E)
502
+ // rest => 28 notes: 9.1 10.2 7.1 9.2 ... (the D shape's walk less its first two notes)
503
+ // through => ["G#", "A", "B", "C#", "D", "E", "F#"]
504
+ ```
505
+
506
+ Play `before.notes`, `bridge`, then `rest`. The options are `turn` (`"repeat"`, `"pivot"` or `"next"`, the default, as for `walk`), `fill` (`"run"`, the default, goes along the string through the scale; `"leap"` uses only the notes the two walks play) and `through` (the note names a run goes through). The result is `undefined` for input it cannot read, and a call in the form of 0.7.0 is such input. See [docs/api/patterns.md](./docs/api/patterns.md#connectsequences), and [docs/UPGRADING.md](./docs/UPGRADING.md) for what changed.
507
+
508
+ ### Keys, chains and the exercise spec
509
+
510
+ **Keys.** `orderKeys`, `keyShift`, `normalizeKeyShift`, `spellTonic`, `moveKeyBy` and `slideOffset` answer the small questions of an exercise played through several keys: which key comes next (in fourths, fifths, half steps or as listed), how far one is from another (a whole number from -6 to 5), what to call a pitch class (flats, sharps or as the key is written), a key name moved by semitones, and how far written material slides to stay on the neck. A key is a string `keySignatureOf` reads (`"A minor"`, `"D dorian"`); each gives `undefined` for what is not a key and for a number that is not whole. See [docs/api/keys.md](./docs/api/keys.md).
511
+
512
+ **`keyRun(parts, options?)`** joins one part for each key (a key and its segments) into the segments of a line, with a gap between keys and the key's name above its first note. It does not move the notes: each key is placed from its shape. See [docs/api/keys.md](./docs/api/keys.md#keyrun).
513
+
514
+ **`chain(segments, options)`** joins the segments of a line with a bridge segment at each turn, by the rule `connectSequences` uses; `Segment.bridge` marks the segments it adds. See [docs/api/lines.md](./docs/api/lines.md#chain).
515
+
516
+ **`fitSegments(segments, meter, options?)`** is `fitToBars` for a pass of several segments, such as one `chain` made: the last note is held to the beat and the bar is filled once for the whole pass. See [docs/api/lines.md](./docs/api/lines.md#fitsegments).
517
+
518
+ **The exercise spec (experimental).** `ExerciseSpec` is a whole exercise as one plain object (what is played, where on the neck, how it is walked, in what time and through which keys); `validateExerciseSpec(spec)` lists what is wrong with one and `buildExercise(spec)` builds its `Line`. It may change in any release, including in a way that stops a stored spec from being read. See [docs/api/exercise-spec.md](./docs/api/exercise-spec.md).
433
519
 
434
520
  ### Sequences
435
521
 
@@ -507,7 +593,9 @@ parseScalePattern("5-8,5-7,5-7,5-7,5-8,5-8");
507
593
 
508
594
  ### Output Formatters
509
595
 
510
- #### `toAlphaTeX(notes: FrettedNote[], options?: AlphaTexOptions) => string`
596
+ #### `toAlphaTeX(notes: TabNote[], options?: AlphaTexOptions) => string`
597
+
598
+ `toAlphaTeX(line: Line, options?: LineTexOptions)` writes a `Line` (see [Notes in time](#notes-in-time)); the note form below is kept until 1.0 and its output does not change. A plain object that is not a valid line used to make it throw and now gives `""`.
511
599
 
512
600
  Format notes as [AlphaTeX](https://www.alphatab.net/docs/alphatex/) notation:
513
601
 
@@ -542,7 +630,11 @@ keySignature("D", "dorian"); // => { tonic: "C", mode: "major", accidentals: 0 }
542
630
  keySignature("H"); // => undefined
543
631
  ```
544
632
 
545
- #### `toAsciiTab(notes: FrettedNote[], options?: AsciiTabOptions) => string`
633
+ #### `keySignatureOf(key: string) => KeySignature | undefined`
634
+
635
+ The same, for a key written as one string: `keySignatureOf("A minor")` is `{ tonic: "A", mode: "minor", accidentals: 0 }`, `keySignatureOf("D dorian")` is C major's, and `keySignatureOf("C blues")` is `undefined`.
636
+
637
+ #### `toAsciiTab(notes: TabNote[], options?: AsciiTabOptions) => string`
546
638
 
547
639
  Format notes as ASCII tablature:
548
640
 
@@ -832,8 +924,12 @@ The package exports these TypeScript interfaces:
832
924
  - `InferenceProbe` — normalised internal probe used by the scoring core
833
925
  - `ScoreBreakdown` — transparent per-term score breakdown on each `InferenceCandidate`
834
926
  - `WalkOptions` — options for `walkPattern`
835
- - `WalkSpec` — options for `walk`
927
+ - `WalkSpec`, `Turn` — options for `walk` and the three values of its `turn`
836
928
  - `KeyMode`, `KeySignature` — the mode argument and the result of `keySignature`
929
+ - `Dur`, `Meter`, `Tuplet`, `Feel`, `Mark`, `Step`, `SegmentSource`, `Segment`, `Line` — notes in time (see [docs/api/lines.md](./docs/api/lines.md)); `LineTexOptions`, `LineBar`, `LineEvent`, `LineIssue`, `LineIssueCode`, `RhythmSlot`, `RhythmCell`, `RhythmCellId`, `FitOptions`, `FitResult`, `Gap`, `MotifId`
930
+ - `KeyOrder` — the `order` of `orderKeys`; `KeyRunPart`, `KeyRunOptions` — the parts and options of `keyRun` (see [docs/api/keys.md](./docs/api/keys.md))
931
+ - `WalkedNotes`, `ConnectOptions`, `ConnectResult`, `BridgeNote`, `Fill`, `JoinKind` — the arguments and result of `connectSequences`; `ChainOptions` — options of `chain`
932
+ - `ExerciseSpec`, `ExerciseMaterial`, `ExercisePlacement`, `ExerciseTime`, `ExerciseKeys`, `ExerciseIssue`, `ExerciseIssueCode`, `BuildExerciseOptions`, `ExerciseResult` — the experimental exercise spec (see [docs/api/exercise-spec.md](./docs/api/exercise-spec.md))
837
933
  - `SequenceOptions` — options for `applySequence`
838
934
  - `AlphaTexOptions` — options for `toAlphaTeX`
839
935
  - `AsciiTabOptions` — options for `toAsciiTab`