@opendaw/studio-adapters 0.2.1 → 0.3.1

package/dist/devices/instruments/Cubed/AblPattern.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"AblPattern.d.ts","sourceRoot":"","sources":["../../../../src/devices/instruments/Cubed/AblPattern.ts"],"names":[],"mappings":"AAAA,OAAO,EAAC,GAAG,EAAS,MAAM,kBAAkB,CAAA;AAC5C,OAAO,EAAC,SAAS,EAAC,MAAM,aAAa,CAAA;AAErC;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AACH,MAAM,MAAM,UAAU,GAAG;IACrB,KAAK,EAAE,aAAa,CAAC,SAAS,CAAC,CAAA;IAC/B,MAAM,EAAE,GAAG,CAAA;CACd,CAAA;AAED,yBAAiB,UAAU,CAAC;IACxB;;;;;OAKG;IACI,MAAM,SAAS,EAAE,GAAQ,CAAA;IAoBzB,MAAM,KAAK,GAAI,MAAM,MAAM,KAAG,UA+BpC,CAAA;CACJ"}

package/dist/devices/instruments/Cubed/AblPattern.js

@@ -0,0 +1,66 @@
+import { Option } from "@opendaw/lib-std";
+export var AblPattern;
+(function (AblPattern) {
+    /**
+     * MIDI note for the plugin's pitch 0. VERIFIED twice against captured plugin state: decoding the
+     * `scream` and `userlab` banks with this base reproduces their known note sequences exactly.
+     *
+     * NOT the Cubed step default of 60 - using that loads every pattern two octaves high.
+     */
+    AblPattern.BASE_NOTE = 36;
+    const NOTE_NAMES = {
+        c: 0, "c#": 1, d: 2, "d#": 3, e: 4, f: 5, "f#": 6, g: 7, "g#": 8, a: 9, "a#": 10, b: 11
+    };
+    /** `a#3` / `c-5` -> MIDI note. The `-` is a placeholder for "no accidental", not a minus sign. */
+    const parseNoteName = (text) => {
+        const match = text.toLowerCase().match(/^([a-g][#-]?)(-?\d+)$/);
+        if (match === null) {
+            return Option.None;
+        }
+        const semitone = NOTE_NAMES[match[1].replace("-", "")];
+        if (semitone === undefined) {
+            return Option.None;
+        }
+        // The named octave maps directly, which puts the plugin's base note (pitch 0 = MIDI 36) at
+        // `c-3` and middle C at `c-5` - consistent with the verified ABL3 base.
+        const note = semitone + parseInt(match[2], 10) * 12;
+        return note >= 0 && note <= 127 ? Option.wrap(note) : Option.None;
+    };
+    const flag = (text) => text !== undefined && parseInt(text, 10) !== 0;
+    AblPattern.parse = (text) => {
+        const steps = [];
+        for (const raw of text.split(/\r?\n/)) {
+            const line = raw.trim();
+            if (line.length === 0 || line.startsWith(";")) {
+                continue;
+            }
+            const columns = line.split(/\s+/);
+            const named = parseNoteName(columns[0]);
+            if (named.nonEmpty()) {
+                // ABL2: note gate accent slide
+                steps.push({
+                    note: named.unwrap(),
+                    active: flag(columns[1]),
+                    accent: flag(columns[2]),
+                    slide: flag(columns[3])
+                });
+                continue;
+            }
+            const pitch = parseInt(columns[0], 10);
+            if (!Number.isFinite(pitch)) {
+                continue;
+            }
+            // ABL3: pitch down up accent slide gate. Pitch is a semitone offset from the plugin's
+            // BASE NOTE, and the down/up flags shift it an octave.
+            const octave = (flag(columns[2]) ? 12 : 0) - (flag(columns[1]) ? 12 : 0);
+            const note = AblPattern.BASE_NOTE + pitch + octave;
+            steps.push({
+                note: Math.max(0, Math.min(127, note)),
+                accent: flag(columns[3]),
+                slide: flag(columns[4]),
+                active: flag(columns[5])
+            });
+        }
+        return { steps, length: steps.length };
+    };
+})(AblPattern || (AblPattern = {}));

package/dist/devices/instruments/Cubed/CubedPatternData.d.ts

@@ -0,0 +1,16 @@
+import { int, Option } from "@opendaw/lib-std";
+import { CubedStep } from "./CubedStep";
+export type CubedPatternData = {
+    length: int;
+    steps: ReadonlyArray<CubedStep>;
+};
+export declare namespace CubedPatternData {
+    const MaxSteps: int;
+    const Type = "cubed-pattern";
+    const Version = 1;
+    /** Accepts `60`, `C3` or `C#3`. The octave offset matches MidiKeys.toFullString. */
+    const parseNote: (text: string) => Option<int>;
+    const toJSON: ({ length, steps }: CubedPatternData) => string;
+    const fromJSON: (text: string) => Option<CubedPatternData>;
+}
+//# sourceMappingURL=CubedPatternData.d.ts.map

package/dist/devices/instruments/Cubed/CubedPatternData.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"CubedPatternData.d.ts","sourceRoot":"","sources":["../../../../src/devices/instruments/Cubed/CubedPatternData.ts"],"names":[],"mappings":"AAAA,OAAO,EAAQ,GAAG,EAAa,MAAM,EAAC,MAAM,kBAAkB,CAAA;AAE9D,OAAO,EAAC,SAAS,EAAC,MAAM,aAAa,CAAA;AAErC,MAAM,MAAM,gBAAgB,GAAG;IAC3B,MAAM,EAAE,GAAG,CAAA;IACX,KAAK,EAAE,aAAa,CAAC,SAAS,CAAC,CAAA;CAClC,CAAA;AAED,yBAAiB,gBAAgB,CAAC;IACvB,MAAM,QAAQ,EAAE,GAAQ,CAAA;IACxB,MAAM,IAAI,kBAAkB,CAAA;IAC5B,MAAM,OAAO,IAAI,CAAA;IAExB,oFAAoF;IAC7E,MAAM,SAAS,GAAI,MAAM,MAAM,KAAG,MAAM,CAAC,GAAG,CAYlD,CAAA;IAEM,MAAM,MAAM,GAAI,mBAAiB,gBAAgB,KAAG,MAOhD,CAAA;IAEJ,MAAM,QAAQ,GAAI,MAAM,MAAM,KAAG,MAAM,CAAC,gBAAgB,CACA,CAAA;CAmClE"}

package/dist/devices/instruments/Cubed/CubedPatternData.js

@@ -0,0 +1,75 @@
+import { clamp, isDefined, Option } from "@opendaw/lib-std";
+import { MidiKeys } from "@opendaw/lib-dsp";
+export var CubedPatternData;
+(function (CubedPatternData) {
+    CubedPatternData.MaxSteps = 64;
+    CubedPatternData.Type = "cubed-pattern";
+    CubedPatternData.Version = 1;
+    /** Accepts `60`, `C3` or `C#3`. The octave offset matches MidiKeys.toFullString. */
+    CubedPatternData.parseNote = (text) => {
+        const trimmed = text.trim();
+        if (/^\d+$/.test(trimmed)) {
+            const value = parseInt(trimmed, 10);
+            return value >= 0 && value <= 127 ? Option.wrap(value) : Option.None;
+        }
+        const match = trimmed.match(/^([A-Ga-g])([#b]?)(-?\d+)$/);
+        if (match === null) {
+            return Option.None;
+        }
+        const bases = { C: 0, D: 2, E: 4, F: 5, G: 7, A: 9, B: 11 };
+        const accidental = match[2] === "#" ? 1 : match[2] === "b" ? -1 : 0;
+        const note = bases[match[1].toUpperCase()] + accidental + (parseInt(match[3], 10) + 2) * 12;
+        return note >= 0 && note <= 127 ? Option.wrap(note) : Option.None;
+    };
+    CubedPatternData.toJSON = ({ length, steps }) => JSON.stringify({
+        type: CubedPatternData.Type,
+        version: CubedPatternData.Version,
+        length,
+        steps: steps.map(({ note, active, slide, accent }) => ({
+            note: MidiKeys.toFullString(note), gate: active, slide, accent
+        }))
+    }, null, 2);
+    CubedPatternData.fromJSON = (text) => Option.tryCatch(() => JSON.parse(text)).flatMap(readObject);
+    const readNote = (value) => {
+        if (typeof value === "number" && Number.isFinite(value)) {
+            return Option.wrap(clamp(Math.round(value), 0, 127));
+        }
+        return typeof value === "string" ? CubedPatternData.parseNote(value) : Option.None;
+    };
+    const readFlag = (value) => value === true;
+    const readStep = (value) => {
+        if (typeof value !== "object" || value === null) {
+            return Option.None;
+        }
+        const source = value;
+        return readNote(source.note).map(note => ({
+            note,
+            active: readFlag(isDefined(source.gate) ? source.gate : source.active),
+            slide: readFlag(source.slide),
+            accent: readFlag(source.accent)
+        }));
+    };
+    const readObject = (value) => {
+        if (typeof value !== "object" || value === null) {
+            return Option.None;
+        }
+        const source = value;
+        if (isDefined(source.type) && source.type !== CubedPatternData.Type) {
+            return Option.None;
+        }
+        if (!Array.isArray(source.steps)) {
+            return Option.None;
+        }
+        const steps = source.steps.slice(0, CubedPatternData.MaxSteps).map(readStep);
+        if (steps.some(step => step.isEmpty())) {
+            return Option.None;
+        }
+        if (steps.length === 0) {
+            return Option.None;
+        }
+        const length = typeof source.length === "number" && Number.isFinite(source.length)
+            ? clamp(Math.round(source.length), 1, steps.length)
+            : steps.length;
+        return Option.wrap({ length, steps: steps.map(step => step.unwrap()) });
+    };
+})(CubedPatternData || (CubedPatternData = {}));

package/dist/devices/instruments/Cubed/CubedRandomize.d.ts

@@ -0,0 +1,22 @@
+import { int, unitValue } from "@opendaw/lib-std";
+import { MidiKeys } from "@opendaw/lib-dsp";
+export type CubedContour = "free" | "walk" | "rise" | "fall";
+export type CubedRandomizeOptions = {
+    root: int;
+    scale: MidiKeys.PredefinedScale;
+    octave: int;
+    octaves: int;
+    density: unitValue;
+    accent: unitValue;
+    slide: unitValue;
+    motif: int;
+    contour: CubedContour;
+    rootFirst: boolean;
+};
+export declare namespace CubedRandomize {
+    const Contours: ReadonlyArray<CubedContour>;
+    const Motifs: ReadonlyArray<int>;
+    const Default: CubedRandomizeOptions;
+    const steps: (options: CubedRandomizeOptions, count: int) => ReadonlyArray<int>;
+}
+//# sourceMappingURL=CubedRandomize.d.ts.map

package/dist/devices/instruments/Cubed/CubedRandomize.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"CubedRandomize.d.ts","sourceRoot":"","sources":["../../../../src/devices/instruments/Cubed/CubedRandomize.ts"],"names":[],"mappings":"AAAA,OAAO,EAAgB,GAAG,EAAE,SAAS,EAAC,MAAM,kBAAkB,CAAA;AAC9D,OAAO,EAAC,QAAQ,EAAC,MAAM,kBAAkB,CAAA;AAGzC,MAAM,MAAM,YAAY,GAAG,MAAM,GAAG,MAAM,GAAG,MAAM,GAAG,MAAM,CAAA;AAE5D,MAAM,MAAM,qBAAqB,GAAG;IAChC,IAAI,EAAE,GAAG,CAAA;IACT,KAAK,EAAE,QAAQ,CAAC,eAAe,CAAA;IAC/B,MAAM,EAAE,GAAG,CAAA;IACX,OAAO,EAAE,GAAG,CAAA;IACZ,OAAO,EAAE,SAAS,CAAA;IAClB,MAAM,EAAE,SAAS,CAAA;IACjB,KAAK,EAAE,SAAS,CAAA;IAChB,KAAK,EAAE,GAAG,CAAA;IACV,OAAO,EAAE,YAAY,CAAA;IACrB,SAAS,EAAE,OAAO,CAAA;CACrB,CAAA;AAED,yBAAiB,cAAc,CAAC;IACrB,MAAM,QAAQ,EAAE,aAAa,CAAC,YAAY,CAAoC,CAAA;IAC9E,MAAM,MAAM,EAAE,aAAa,CAAC,GAAG,CAAmB,CAAA;IAElD,MAAM,OAAO,EAAE,qBAWrB,CAAA;IAOM,MAAM,KAAK,GAAI,SAAS,qBAAqB,EAAE,OAAO,GAAG,KAAG,aAAa,CAAC,GAAG,CA2BnF,CAAA;CACJ"}

package/dist/devices/instruments/Cubed/CubedRandomize.js

@@ -0,0 +1,51 @@
+import { Arrays, clamp } from "@opendaw/lib-std";
+import { MidiKeys } from "@opendaw/lib-dsp";
+import { CubedStep } from "./CubedStep";
+export var CubedRandomize;
+(function (CubedRandomize) {
+    CubedRandomize.Contours = ["free", "walk", "rise", "fall"];
+    CubedRandomize.Motifs = [0, 2, 3, 4, 8];
+    CubedRandomize.Default = {
+        root: 0,
+        scale: MidiKeys.StockScales[1],
+        octave: 1,
+        octaves: 3,
+        density: 0.6,
+        accent: 0.3,
+        slide: 0.2,
+        motif: 0,
+        contour: "free",
+        rootFirst: true
+    };
+    const keysOf = (scale) => {
+        const keys = Arrays.create(index => index, 12).filter(key => scale.has(key));
+        return keys.length === 0 ? [0] : keys;
+    };
+    CubedRandomize.steps = (options, count) => {
+        const keys = keysOf(options.scale);
+        const octaves = Math.max(1, options.octaves);
+        const span = keys.length * octaves;
+        const base = (options.octave + 2) * 12 + options.root;
+        const noteOf = (degree) => {
+            const bounded = clamp(degree, 0, span - 1);
+            return clamp(base + keys[bounded % keys.length] + Math.floor(bounded / keys.length) * 12, 0, 127);
+        };
+        const period = options.motif > 0 ? Math.min(options.motif, count) : count;
+        const jitter = (amount) => Math.round((Math.random() * 2 - 1) * amount);
+        const degrees = new Array(period);
+        for (let index = 0; index < period; index++) {
+            const ramp = period < 2 ? 0 : (index / (period - 1)) * (span - 1);
+            degrees[index] = options.rootFirst && index === 0 ? 0 : clamp(options.contour === "walk" ? (index === 0 ? span >> 1 : degrees[index - 1] + jitter(2))
+                : options.contour === "rise" ? Math.round(ramp) + jitter(1)
+                    : options.contour === "fall" ? Math.round(span - 1 - ramp) + jitter(1)
+                        : Math.floor(Math.random() * span), 0, span - 1);
+        }
+        const motif = Arrays.create(index => CubedStep.pack({
+            note: noteOf(degrees[index]),
+            active: (options.rootFirst && index === 0) || Math.random() < options.density,
+            slide: Math.random() < options.slide,
+            accent: Math.random() < options.accent
+        }), period);
+        return Arrays.create(index => motif[index % period], count);
+    };
+})(CubedRandomize || (CubedRandomize = {}));

package/dist/devices/instruments/Cubed/CubedStep.d.ts

@@ -0,0 +1,13 @@
+import { int } from "@opendaw/lib-std";
+export type CubedStep = {
+    note: int;
+    active: boolean;
+    slide: boolean;
+    accent: boolean;
+};
+export declare namespace CubedStep {
+    const DefaultNote: int;
+    const pack: (step: CubedStep) => int;
+    const unpack: (bits: int) => CubedStep;
+}
+//# sourceMappingURL=CubedStep.d.ts.map

package/dist/devices/instruments/Cubed/CubedStep.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"CubedStep.d.ts","sourceRoot":"","sources":["../../../../src/devices/instruments/Cubed/CubedStep.ts"],"names":[],"mappings":"AAAA,OAAO,EAAC,GAAG,EAAC,MAAM,kBAAkB,CAAA;AAEpC,MAAM,MAAM,SAAS,GAAG;IACpB,IAAI,EAAE,GAAG,CAAA;IACT,MAAM,EAAE,OAAO,CAAA;IACf,KAAK,EAAE,OAAO,CAAA;IACd,MAAM,EAAE,OAAO,CAAA;CAClB,CAAA;AAED,yBAAiB,SAAS,CAAC;IAChB,MAAM,WAAW,EAAE,GAAQ,CAAA;IAG3B,MAAM,IAAI,GAAI,MAAM,SAAS,KAAG,GAIL,CAAA;IAE3B,MAAM,MAAM,GAAI,MAAM,GAAG,KAAG,SAKjC,CAAA;CACL"}

package/dist/devices/instruments/Cubed/CubedStep.js

@@ -0,0 +1,15 @@
+export var CubedStep;
+(function (CubedStep) {
+    CubedStep.DefaultNote = 60;
+    // one int32 per step: midi-note 0..6, active 7, slide 8, accent 9
+    CubedStep.pack = (step) => (step.note & 0x7F)
+        | ((step.active ? 1 : 0) << 7)
+        | ((step.slide ? 1 : 0) << 8)
+        | ((step.accent ? 1 : 0) << 9);
+    CubedStep.unpack = (bits) => ({
+        note: bits & 0x7F,
+        active: ((bits >> 7) & 1) === 1,
+        slide: ((bits >> 8) & 1) === 1,
+        accent: ((bits >> 9) & 1) === 1
+    });
+})(CubedStep || (CubedStep = {}));

package/dist/devices/instruments/CubedDeviceBoxAdapter.d.ts

@@ -0,0 +1,48 @@
+import { int, UUID } from "@opendaw/lib-std";
+import { CubedDeviceBox, CubedPattern } from "@opendaw/studio-boxes";
+import { Address, BooleanField, StringField } from "@opendaw/lib-box";
+import { DeviceHost, InstrumentDeviceBoxAdapter } from "../../DeviceAdapter";
+import { LabeledAudioOutput } from "../../LabeledAudioOutputsOwner";
+import { BoxAdaptersContext } from "../../BoxAdaptersContext";
+import { TrackType } from "../../timeline/TrackType";
+import { AudioUnitBoxAdapter } from "../../audio-unit/AudioUnitBoxAdapter";
+import { CubedPatternData } from "./Cubed/CubedPatternData";
+import { CubedRandomizeOptions } from "./Cubed/CubedRandomize";
+export declare class CubedDeviceBoxAdapter implements InstrumentDeviceBoxAdapter {
+    #private;
+    readonly type = "instrument";
+    readonly accepts = "midi";
+    readonly manualUrl = "manuals/devices/instruments/cubed";
+    readonly namedParameter: {
+        readonly tuning: import("../..").AutomatableParameterFieldAdapter<number>;
+        readonly cutoff: import("../..").AutomatableParameterFieldAdapter<import("@opendaw/lib-box").PrimitiveValues>;
+        readonly resonance: import("../..").AutomatableParameterFieldAdapter<import("@opendaw/lib-box").PrimitiveValues>;
+        readonly envMod: import("../..").AutomatableParameterFieldAdapter<import("@opendaw/lib-box").PrimitiveValues>;
+        readonly decay: import("../..").AutomatableParameterFieldAdapter<import("@opendaw/lib-box").PrimitiveValues>;
+        readonly accent: import("../..").AutomatableParameterFieldAdapter<import("@opendaw/lib-box").PrimitiveValues>;
+        readonly volume: import("../..").AutomatableParameterFieldAdapter<number>;
+        readonly waveform: import("../..").AutomatableParameterFieldAdapter<number>;
+        readonly patternIndex: import("../..").AutomatableParameterFieldAdapter<number>;
+    };
+    constructor(context: BoxAdaptersContext, box: CubedDeviceBox);
+    get box(): CubedDeviceBox;
+    get uuid(): UUID.Bytes;
+    get address(): Address;
+    get labelField(): StringField;
+    get iconField(): StringField;
+    get defaultTrackType(): TrackType;
+    get enabledField(): BooleanField;
+    get minimizedField(): BooleanField;
+    get acceptsMidiEvents(): boolean;
+    currentPattern(): CubedPattern;
+    readCurrentPattern(): CubedPatternData;
+    writeCurrentPattern({ length, steps }: CubedPatternData): void;
+    clearCurrentPattern(): void;
+    randomizeCurrentPattern(options?: CubedRandomizeOptions): void;
+    rotateCurrentPattern(offset: int): void;
+    deviceHost(): DeviceHost;
+    audioUnitBoxAdapter(): AudioUnitBoxAdapter;
+    labeledAudioOutputs(): Iterable<LabeledAudioOutput>;
+    terminate(): void;
+}
+//# sourceMappingURL=CubedDeviceBoxAdapter.d.ts.map

package/dist/devices/instruments/CubedDeviceBoxAdapter.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"CubedDeviceBoxAdapter.d.ts","sourceRoot":"","sources":["../../../src/devices/instruments/CubedDeviceBoxAdapter.ts"],"names":[],"mappings":"AAAA,OAAO,EAAQ,GAAG,EAAyB,IAAI,EAAe,MAAM,kBAAkB,CAAA;AACtF,OAAO,EAAC,cAAc,EAAE,YAAY,EAAC,MAAM,uBAAuB,CAAA;AAClE,OAAO,EAAC,OAAO,EAAE,YAAY,EAAE,WAAW,EAAC,MAAM,kBAAkB,CAAA;AACnE,OAAO,EAAC,UAAU,EAAW,0BAA0B,EAAC,MAAM,qBAAqB,CAAA;AACnF,OAAO,EAAC,kBAAkB,EAAC,MAAM,gCAAgC,CAAA;AACjE,OAAO,EAAC,kBAAkB,EAAC,MAAM,0BAA0B,CAAA;AAE3D,OAAO,EAAC,SAAS,EAAC,MAAM,0BAA0B,CAAA;AAClD,OAAO,EAAC,mBAAmB,EAAC,MAAM,sCAAsC,CAAA;AAExE,OAAO,EAAC,gBAAgB,EAAC,MAAM,0BAA0B,CAAA;AACzD,OAAO,EAAiB,qBAAqB,EAAC,MAAM,wBAAwB,CAAA;AAI5E,qBAAa,qBAAsB,YAAW,0BAA0B;;IACpE,QAAQ,CAAC,IAAI,gBAAe;IAC5B,QAAQ,CAAC,OAAO,UAAS;IACzB,QAAQ,CAAC,SAAS,uCAAsC;IAMxD,QAAQ,CAAC,cAAc;;;;;;;;;;MAAA;gBAEX,OAAO,EAAE,kBAAkB,EAAE,GAAG,EAAE,cAAc;IAO5D,IAAI,GAAG,IAAI,cAAc,CAAmB;IAC5C,IAAI,IAAI,IAAI,IAAI,CAAC,KAAK,CAAgC;IACtD,IAAI,OAAO,IAAI,OAAO,CAA2B;IACjD,IAAI,UAAU,IAAI,WAAW,CAAyB;IACtD,IAAI,SAAS,IAAI,WAAW,CAAwB;IACpD,IAAI,gBAAgB,IAAI,SAAS,CAAyB;IAC1D,IAAI,YAAY,IAAI,YAAY,CAA2B;IAC3D,IAAI,cAAc,IAAI,YAAY,CAA6B;IAC/D,IAAI,iBAAiB,IAAI,OAAO,CAAc;IAE9C,cAAc,IAAI,YAAY;IAE9B,kBAAkB,IAAI,gBAAgB;IAStC,mBAAmB,CAAC,EAAC,MAAM,EAAE,KAAK,EAAC,EAAE,gBAAgB,GAAG,IAAI;IAS5D,mBAAmB,IAAI,IAAI;IAI3B,uBAAuB,CAAC,OAAO,GAAE,qBAA8C,GAAG,IAAI;IAOtF,oBAAoB,CAAC,MAAM,EAAE,GAAG,GAAG,IAAI;IAQvC,UAAU,IAAI,UAAU;IAKxB,mBAAmB,IAAI,mBAAmB;IAExC,mBAAmB,IAAI,QAAQ,CAAC,kBAAkB,CAAC;IAIrD,SAAS,IAAI,IAAI;CAwBpB"}

package/dist/devices/instruments/CubedDeviceBoxAdapter.js

@@ -0,0 +1,100 @@
+var __classPrivateFieldSet = (this && this.__classPrivateFieldSet) || function (receiver, state, value, kind, f) {
+    if (kind === "m") throw new TypeError("Private method is not writable");
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a setter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot write private member to an object whose class did not declare it");
+    return (kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;
+};
+var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (receiver, state, kind, f) {
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
+    return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
+};
+var _CubedDeviceBoxAdapter_instances, _CubedDeviceBoxAdapter_context, _CubedDeviceBoxAdapter_box, _CubedDeviceBoxAdapter_parametric, _CubedDeviceBoxAdapter_wrapParameters;
+import { clamp, Option, StringMapping, ValueMapping } from "@opendaw/lib-std";
+import { Devices } from "../../DeviceAdapter";
+import { ParameterAdapterSet } from "../../ParameterAdapterSet";
+import { TrackType } from "../../timeline/TrackType";
+import { CubedStep } from "./Cubed/CubedStep";
+import { CubedRandomize } from "./Cubed/CubedRandomize";
+const DefaultStep = CubedStep.pack({ note: CubedStep.DefaultNote, active: false, slide: false, accent: false });
+export class CubedDeviceBoxAdapter {
+    constructor(context, box) {
+        _CubedDeviceBoxAdapter_instances.add(this);
+        this.type = "instrument";
+        this.accepts = "midi";
+        this.manualUrl = "manuals/devices/instruments/cubed";
+        _CubedDeviceBoxAdapter_context.set(this, void 0);
+        _CubedDeviceBoxAdapter_box.set(this, void 0);
+        _CubedDeviceBoxAdapter_parametric.set(this, void 0);
+        __classPrivateFieldSet(this, _CubedDeviceBoxAdapter_context, context, "f");
+        __classPrivateFieldSet(this, _CubedDeviceBoxAdapter_box, box, "f");
+        __classPrivateFieldSet(this, _CubedDeviceBoxAdapter_parametric, new ParameterAdapterSet(__classPrivateFieldGet(this, _CubedDeviceBoxAdapter_context, "f")), "f");
+        this.namedParameter = __classPrivateFieldGet(this, _CubedDeviceBoxAdapter_instances, "m", _CubedDeviceBoxAdapter_wrapParameters).call(this, box);
+    }
+    get box() { return __classPrivateFieldGet(this, _CubedDeviceBoxAdapter_box, "f"); }
+    get uuid() { return __classPrivateFieldGet(this, _CubedDeviceBoxAdapter_box, "f").address.uuid; }
+    get address() { return __classPrivateFieldGet(this, _CubedDeviceBoxAdapter_box, "f").address; }
+    get labelField() { return __classPrivateFieldGet(this, _CubedDeviceBoxAdapter_box, "f").label; }
+    get iconField() { return __classPrivateFieldGet(this, _CubedDeviceBoxAdapter_box, "f").icon; }
+    get defaultTrackType() { return TrackType.Notes; }
+    get enabledField() { return __classPrivateFieldGet(this, _CubedDeviceBoxAdapter_box, "f").enabled; }
+    get minimizedField() { return __classPrivateFieldGet(this, _CubedDeviceBoxAdapter_box, "f").minimized; }
+    get acceptsMidiEvents() { return true; }
+    currentPattern() { return __classPrivateFieldGet(this, _CubedDeviceBoxAdapter_box, "f").patterns.getField(__classPrivateFieldGet(this, _CubedDeviceBoxAdapter_box, "f").patternIndex.getValue()); }
+    readCurrentPattern() {
+        const pattern = this.currentPattern();
+        const length = pattern.length.getValue();
+        return {
+            length,
+            steps: pattern.steps.fields().slice(0, length).map(field => CubedStep.unpack(field.getValue()))
+        };
+    }
+    writeCurrentPattern({ length, steps }) {
+        const pattern = this.currentPattern();
+        const fields = pattern.steps.fields();
+        const used = Math.min(steps.length, fields.length);
+        fields.forEach((field, index) => field.setValue(index < used ? CubedStep.pack(steps[index]) : DefaultStep));
+        pattern.length.setValue(clamp(length, 1, fields.length));
+    }
+    clearCurrentPattern() {
+        this.currentPattern().steps.fields().forEach(field => field.setValue(DefaultStep));
+    }
+    randomizeCurrentPattern(options = CubedRandomize.Default) {
+        const pattern = this.currentPattern();
+        const length = pattern.length.getValue();
+        const steps = CubedRandomize.steps(options, length);
+        pattern.steps.fields().forEach((field, index) => field.setValue(index < length ? steps[index] : DefaultStep));
+    }
+    rotateCurrentPattern(offset) {
+        const pattern = this.currentPattern();
+        const length = pattern.length.getValue();
+        const fields = pattern.steps.fields().slice(0, length);
+        const values = fields.map(field => field.getValue());
+        fields.forEach((field, index) => field.setValue(values[(index + offset + length) % length]));
+    }
+    deviceHost() {
+        return __classPrivateFieldGet(this, _CubedDeviceBoxAdapter_context, "f").boxAdapters
+            .adapterFor(__classPrivateFieldGet(this, _CubedDeviceBoxAdapter_box, "f").host.targetVertex.unwrap("no device-host").box, Devices.isHost);
+    }
+    audioUnitBoxAdapter() { return this.deviceHost().audioUnitBoxAdapter(); }
+    *labeledAudioOutputs() {
+        yield { address: this.address, label: this.labelField.getValue(), children: () => Option.None };
+    }
+    terminate() {
+        __classPrivateFieldGet(this, _CubedDeviceBoxAdapter_parametric, "f").terminate();
+    }
+}
+_CubedDeviceBoxAdapter_context = new WeakMap(), _CubedDeviceBoxAdapter_box = new WeakMap(), _CubedDeviceBoxAdapter_parametric = new WeakMap(), _CubedDeviceBoxAdapter_instances = new WeakSet(), _CubedDeviceBoxAdapter_wrapParameters = function _CubedDeviceBoxAdapter_wrapParameters(box) {
+    const unipolar = (field, name, anchor) => __classPrivateFieldGet(this, _CubedDeviceBoxAdapter_parametric, "f").createParameter(field, ValueMapping.unipolar(), StringMapping.percent({ fractionDigits: 0 }), name, anchor);
+    return {
+        tuning: __classPrivateFieldGet(this, _CubedDeviceBoxAdapter_parametric, "f").createParameter(box.tuning, ValueMapping.linear(-1200, 1200), StringMapping.numeric({ unit: "ct", fractionDigits: 0 }), "Tuning", 0.5),
+        cutoff: unipolar(box.cutoff, "Cutoff"),
+        resonance: unipolar(box.resonance, "Resonance"),
+        envMod: unipolar(box.envMod, "Env Mod"),
+        decay: unipolar(box.decay, "Decay"),
+        accent: unipolar(box.accent, "Accent"),
+        volume: __classPrivateFieldGet(this, _CubedDeviceBoxAdapter_parametric, "f").createParameter(box.volume, ValueMapping.DefaultDecibel, StringMapping.numeric({ unit: "dB", fractionDigits: 1 }), "Volume"),
+        waveform: __classPrivateFieldGet(this, _CubedDeviceBoxAdapter_parametric, "f").createParameter(box.waveform, ValueMapping.linearInteger(0, 1), StringMapping.indices("", ["Sawtooth", "Square"]), "Waveform", 0.5),
+        patternIndex: __classPrivateFieldGet(this, _CubedDeviceBoxAdapter_parametric, "f").createParameter(box.patternIndex, ValueMapping.linearInteger(0, box.patterns.fields().length - 1), StringMapping.oneBasedIndex(), "Pattern")
+    };
+};

package/dist/devices/instruments/MIDIOutputDeviceBoxAdapter.d.ts

@@ -11,7 +11,7 @@ export declare class MIDIOutputDeviceBoxAdapter implements InstrumentDeviceBoxAd
     #private;
     readonly type = "instrument";
     readonly accepts = "midi";
-    readonly manualUrl = "manuals/devices/instruments/midi-output";
+    readonly manualUrl = "manuals/devices/instruments/midioutput";
     constructor(context: BoxAdaptersContext, box: MIDIOutputDeviceBox);
     get box(): MIDIOutputDeviceBox;
     get uuid(): UUID.Bytes;

package/dist/devices/instruments/MIDIOutputDeviceBoxAdapter.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"MIDIOutputDeviceBoxAdapter.d.ts","sourceRoot":"","sources":["../../../src/devices/instruments/MIDIOutputDeviceBoxAdapter.ts"],"names":[],"mappings":"AAAA,OAAO,EAGH,gBAAgB,EAIhB,IAAI,EAEP,MAAM,kBAAkB,CAAA;AACzB,OAAO,EAAC,aAAa,EAAE,mBAAmB,EAAyB,MAAM,uBAAuB,CAAA;AAChG,OAAO,EAAC,OAAO,EAAE,YAAY,EAAE,WAAW,EAAC,MAAM,kBAAkB,CAAA;AACnE,OAAO,EAAC,UAAU,EAAW,0BAA0B,EAAC,MAAM,qBAAqB,CAAA;AACnF,OAAO,EAAC,kBAAkB,EAAC,MAAM,gCAAgC,CAAA;AACjE,OAAO,EAAC,kBAAkB,EAAC,MAAM,0BAA0B,CAAA;AAE3D,OAAO,EAAC,mBAAmB,EAAC,MAAM,2BAA2B,CAAA;AAC7D,OAAO,EAAC,SAAS,EAAC,MAAM,0BAA0B,CAAA;AAClD,OAAO,EAAC,mBAAmB,EAAC,MAAM,sCAAsC,CAAA;AAExE,qBAAa,0BAA2B,YAAW,0BAA0B;;IAGzE,QAAQ,CAAC,IAAI,gBAAe;IAC5B,QAAQ,CAAC,OAAO,UAAS;IACzB,QAAQ,CAAC,SAAS,6CAA8B;gBAQpC,OAAO,EAAE,kBAAkB,EAAE,GAAG,EAAE,mBAAmB;IAqBjE,IAAI,GAAG,IAAI,mBAAmB,CAAmB;IACjD,IAAI,IAAI,IAAI,IAAI,CAAC,KAAK,CAAgC;IACtD,IAAI,OAAO,IAAI,OAAO,CAA2B;IACjD,IAAI,UAAU,IAAI,WAAW,CAAyB;IACtD,IAAI,SAAS,IAAI,WAAW,CAAwB;IACpD,IAAI,gBAAgB,IAAI,SAAS,CAAyB;IAC1D,IAAI,YAAY,IAAI,YAAY,CAA2B;IAC3D,IAAI,cAAc,IAAI,YAAY,CAA6B;IAC/D,IAAI,iBAAiB,IAAI,OAAO,CAAc;IAC9C,IAAI,UAAU,IAAI,mBAAmB,CAA0B;IAC/D,IAAI,UAAU,IAAI,gBAAgB,CAAC,aAAa,CAAC,CAA0B;IAE3E,UAAU,IAAI,UAAU;IAKxB,mBAAmB,IAAI,mBAAmB;IAEzC,mBAAmB,IAAI,QAAQ,CAAC,kBAAkB,CAAC;IAIpD,SAAS,IAAI,IAAI;CACpB"}
+{"version":3,"file":"MIDIOutputDeviceBoxAdapter.d.ts","sourceRoot":"","sources":["../../../src/devices/instruments/MIDIOutputDeviceBoxAdapter.ts"],"names":[],"mappings":"AAAA,OAAO,EAGH,gBAAgB,EAQhB,IAAI,EAEP,MAAM,kBAAkB,CAAA;AACzB,OAAO,EAAC,aAAa,EAAE,mBAAmB,EAAyB,MAAM,uBAAuB,CAAA;AAChG,OAAO,EAAC,OAAO,EAAE,YAAY,EAAE,WAAW,EAAC,MAAM,kBAAkB,CAAA;AACnE,OAAO,EAAC,UAAU,EAAW,0BAA0B,EAAC,MAAM,qBAAqB,CAAA;AACnF,OAAO,EAAC,kBAAkB,EAAC,MAAM,gCAAgC,CAAA;AACjE,OAAO,EAAC,kBAAkB,EAAC,MAAM,0BAA0B,CAAA;AAE3D,OAAO,EAAC,mBAAmB,EAAC,MAAM,2BAA2B,CAAA;AAC7D,OAAO,EAAC,SAAS,EAAC,MAAM,0BAA0B,CAAA;AAClD,OAAO,EAAC,mBAAmB,EAAC,MAAM,sCAAsC,CAAA;AAoBxE,qBAAa,0BAA2B,YAAW,0BAA0B;;IAGzE,QAAQ,CAAC,IAAI,gBAAe;IAC5B,QAAQ,CAAC,OAAO,UAAS;IACzB,QAAQ,CAAC,SAAS,4CAA8B;gBAQpC,OAAO,EAAE,kBAAkB,EAAE,GAAG,EAAE,mBAAmB;IAuBjE,IAAI,GAAG,IAAI,mBAAmB,CAAmB;IACjD,IAAI,IAAI,IAAI,IAAI,CAAC,KAAK,CAAgC;IACtD,IAAI,OAAO,IAAI,OAAO,CAA2B;IACjD,IAAI,UAAU,IAAI,WAAW,CAAyB;IACtD,IAAI,SAAS,IAAI,WAAW,CAAwB;IACpD,IAAI,gBAAgB,IAAI,SAAS,CAAyB;IAC1D,IAAI,YAAY,IAAI,YAAY,CAA2B;IAC3D,IAAI,cAAc,IAAI,YAAY,CAA6B;IAC/D,IAAI,iBAAiB,IAAI,OAAO,CAAc;IAC9C,IAAI,UAAU,IAAI,mBAAmB,CAA0B;IAC/D,IAAI,UAAU,IAAI,gBAAgB,CAAC,aAAa,CAAC,CAA0B;IAE3E,UAAU,IAAI,UAAU;IAKxB,mBAAmB,IAAI,mBAAmB;IAEzC,mBAAmB,IAAI,QAAQ,CAAC,kBAAkB,CAAC;IAIpD,SAAS,IAAI,IAAI;CACpB"}

package/dist/devices/instruments/MIDIOutputDeviceBoxAdapter.js

@@ -10,12 +10,26 @@ var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (
     return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
 };
 var _MIDIOutputDeviceBoxAdapter_terminator, _MIDIOutputDeviceBoxAdapter_context, _MIDIOutputDeviceBoxAdapter_box, _MIDIOutputDeviceBoxAdapter_midiDevice, _MIDIOutputDeviceBoxAdapter_parametric;
-import { asInstanceOf, MutableObservableOption, Option, StringMapping, Terminator, ValueMapping } from "@opendaw/lib-std";
+import { asInstanceOf, MutableObservableOption, Option, StringMapping, Terminable, Terminator, ValueMapping } from "@opendaw/lib-std";
 import { MIDIOutputBox, MIDIOutputParameterBox } from "@opendaw/studio-boxes";
 import { Devices } from "../../DeviceAdapter";
 import { DeviceManualUrls } from "../../DeviceManualUrls";
 import { ParameterAdapterSet } from "../../ParameterAdapterSet";
 import { TrackType } from "../../timeline/TrackType";
+const parameterName = (box) => new class {
+    getValue() {
+        const label = box.label.getValue().trim();
+        const controller = box.controller.getValue();
+        return label.length === 0 ? String(controller) : `${label} ${controller}`;
+    }
+    subscribe(observer) {
+        return Terminable.many(box.label.subscribe(() => observer(this)), box.controller.subscribe(() => observer(this)));
+    }
+    catchupAndSubscribe(observer) {
+        observer(this);
+        return this.subscribe(observer);
+    }
+};
 export class MIDIOutputDeviceBoxAdapter {
     constructor(context, box) {
         _MIDIOutputDeviceBoxAdapter_terminator.set(this, new Terminator());
@@ -31,8 +45,10 @@ export class MIDIOutputDeviceBoxAdapter {
         __classPrivateFieldSet(this, _MIDIOutputDeviceBoxAdapter_midiDevice, new MutableObservableOption(), "f");
         __classPrivateFieldSet(this, _MIDIOutputDeviceBoxAdapter_parametric, __classPrivateFieldGet(this, _MIDIOutputDeviceBoxAdapter_terminator, "f").own(new ParameterAdapterSet(__classPrivateFieldGet(this, _MIDIOutputDeviceBoxAdapter_context, "f"))), "f");
         __classPrivateFieldGet(this, _MIDIOutputDeviceBoxAdapter_terminator, "f").ownAll(box.parameters.pointerHub.catchupAndSubscribe({
-            onAdded: (({ box }) => __classPrivateFieldGet(this, _MIDIOutputDeviceBoxAdapter_parametric, "f")
-                .createParameter(asInstanceOf(box, MIDIOutputParameterBox).value, ValueMapping.unipolar(), StringMapping.percent({ fractionDigits: 1 }), "", 0.0)),
+            onAdded: (({ box }) => {
+                const parameterBox = asInstanceOf(box, MIDIOutputParameterBox);
+                __classPrivateFieldGet(this, _MIDIOutputDeviceBoxAdapter_parametric, "f").createParameter(parameterBox.value, ValueMapping.unipolar(), StringMapping.percent({ fractionDigits: 1 }), parameterName(parameterBox), 0.0);
+            }),
             onRemoved: (({ box }) => __classPrivateFieldGet(this, _MIDIOutputDeviceBoxAdapter_parametric, "f")
                 .removeParameter(asInstanceOf(box, MIDIOutputParameterBox).value.address))
         }), __classPrivateFieldGet(this, _MIDIOutputDeviceBoxAdapter_box, "f").device.catchupAndSubscribe(({ targetVertex }) => targetVertex.match({

package/dist/devices/instruments/NanoDeviceBoxAdapter.js

@@ -52,7 +52,7 @@ export class NanoDeviceBoxAdapter {
 }
 _NanoDeviceBoxAdapter_context = new WeakMap(), _NanoDeviceBoxAdapter_box = new WeakMap(), _NanoDeviceBoxAdapter_parametric = new WeakMap(), _NanoDeviceBoxAdapter_instances = new WeakSet(), _NanoDeviceBoxAdapter_wrapParameters = function _NanoDeviceBoxAdapter_wrapParameters(box) {
     return {
-        volume: __classPrivateFieldGet(this, _NanoDeviceBoxAdapter_parametric, "f").createParameter(box.volume, ValueMapping.DefaultDecibel, StringMapping.numeric({ unit: "db", fractionDigits: 1 }), "volume"),
-        release: __classPrivateFieldGet(this, _NanoDeviceBoxAdapter_parametric, "f").createParameter(box.release, ValueMapping.exponential(0.001, 8.0), StringMapping.numeric({ unit: "s", fractionDigits: 3 }), "release")
+        volume: __classPrivateFieldGet(this, _NanoDeviceBoxAdapter_parametric, "f").createParameter(box.volume, ValueMapping.DefaultDecibel, StringMapping.numeric({ unit: "db", fractionDigits: 1 }), "Volume"),
+        release: __classPrivateFieldGet(this, _NanoDeviceBoxAdapter_parametric, "f").createParameter(box.release, ValueMapping.exponential(0.001, 8.0), StringMapping.numeric({ unit: "s", fractionDigits: 3 }), "Release")
     };
 };

package/dist/devices/instruments/Playfield/ChopModel.d.ts

@@ -0,0 +1,21 @@
+import { int, unitValue } from "@opendaw/lib-std";
+import { PlayfieldChopSlice } from "../PlayfieldDeviceBoxAdapter";
+export type ChopMode = "transients" | "grid";
+export declare const GridDivisions: readonly [number, number, number, number];
+export type GridDivision = (typeof GridDivisions)[number];
+export declare namespace ChopMath {
+    const MAX_KEY = 128;
+    const fitBpmPow2: (durationInSeconds: number) => number;
+    const sliceSecondsForGrid: (bpm: number, division: GridDivision) => number;
+}
+export declare class ChopModel {
+    #private;
+    get boundaries(): ReadonlyArray<unitValue>;
+    fromTransients(transientSeconds: ReadonlyArray<number>, durationInSeconds: number, maxSlices: int): void;
+    fromGrid(bpm: number, division: GridDivision, durationInSeconds: number, maxSlices: int): void;
+    dragBoundary(index: int, position: unitValue): void;
+    splitAt(position: unitValue): void;
+    removeBoundary(index: int): void;
+    slices(startKey: int): ReadonlyArray<PlayfieldChopSlice>;
+}
+//# sourceMappingURL=ChopModel.d.ts.map

package/dist/devices/instruments/Playfield/ChopModel.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ChopModel.d.ts","sourceRoot":"","sources":["../../../../src/devices/instruments/Playfield/ChopModel.ts"],"names":[],"mappings":"AAAA,OAAO,EAAQ,GAAG,EAAE,SAAS,EAAC,MAAM,kBAAkB,CAAA;AACtD,OAAO,EAAC,kBAAkB,EAAC,MAAM,8BAA8B,CAAA;AAE/D,MAAM,MAAM,QAAQ,GAAG,YAAY,GAAG,MAAM,CAAA;AAE5C,eAAO,MAAM,aAAa,2CAA0C,CAAA;AACpE,MAAM,MAAM,YAAY,GAAG,CAAC,OAAO,aAAa,CAAC,CAAC,MAAM,CAAC,CAAA;AAEzD,yBAAiB,QAAQ,CAAC;IACf,MAAM,OAAO,MAAM,CAAA;IAEnB,MAAM,UAAU,GAAI,mBAAmB,MAAM,KAAG,MAMtD,CAAA;IAEM,MAAM,mBAAmB,GAAI,KAAK,MAAM,EAAE,UAAU,YAAY,KAAG,MAAqC,CAAA;CAClH;AAED,qBAAa,SAAS;;IAGlB,IAAI,UAAU,IAAI,aAAa,CAAC,SAAS,CAAC,CAA0B;IAepE,cAAc,CAAC,gBAAgB,EAAE,aAAa,CAAC,MAAM,CAAC,EAAE,iBAAiB,EAAE,MAAM,EAAE,SAAS,EAAE,GAAG,GAAG,IAAI;IAKxG,QAAQ,CAAC,GAAG,EAAE,MAAM,EAAE,QAAQ,EAAE,YAAY,EAAE,iBAAiB,EAAE,MAAM,EAAE,SAAS,EAAE,GAAG,GAAG,IAAI;IAY9F,YAAY,CAAC,KAAK,EAAE,GAAG,EAAE,QAAQ,EAAE,SAAS,GAAG,IAAI;IAOnD,OAAO,CAAC,QAAQ,EAAE,SAAS,GAAG,IAAI;IASlC,cAAc,CAAC,KAAK,EAAE,GAAG,GAAG,IAAI;IAKhC,MAAM,CAAC,QAAQ,EAAE,GAAG,GAAG,aAAa,CAAC,kBAAkB,CAAC;CAQ3D"}