@opendaw/studio-core 0.0.112 → 0.0.113

package/dist/project/Project.d.ts

@@ -12,6 +12,7 @@ import { EngineWorklet } from "../EngineWorklet";
 import { MIDILearning } from "../midi";
 import { ppqn, TempoMap } from "@opendaw/lib-dsp";
 import { RegionOverlapResolver, TimelineFocus } from "../ui";
+import { AudioUnitFreeze } from "../AudioUnitFreeze";
 export type RestartWorklet = {
     unload: Func<unknown, Promise<unknown>>;
     load: Procedure<EngineWorklet>;
@@ -47,6 +48,7 @@ export declare class Project implements BoxAdaptersContext, Terminable, Terminab
     readonly overlapResolver: RegionOverlapResolver;
     readonly timelineFocus: TimelineFocus;
     readonly engine: EngineFacade;
+    readonly audioUnitFreeze: AudioUnitFreeze;
     private constructor();
     startAudioWorklet(restart?: RestartWorklet, options?: ProcessorOptions): EngineWorklet;
     handleCpuOverload(): void;

package/dist/project/Project.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"Project.d.ts","sourceRoot":"","sources":["../../src/project/Project.ts"],"names":[],"mappings":"AAAA,OAAO,EAEH,IAAI,EAGJ,SAAS,EAIT,UAAU,EACV,eAAe,EACf,UAAU,EACV,IAAI,EACP,MAAM,kBAAkB,CAAA;AACzB,OAAO,EAAC,UAAU,EAAE,QAAQ,EAA0B,MAAM,kBAAkB,CAAA;AAC9E,OAAO,EACH,WAAW,EAGX,YAAY,EACZ,KAAK,EAEL,OAAO,EACP,WAAW,EAEX,gBAAgB,EACnB,MAAM,uBAAuB,CAAA;AAC9B,OAAO,EACH,mBAAmB,EACnB,mBAAmB,EACnB,WAAW,EACX,kBAAkB,EAClB,cAAc,EACd,gBAAgB,EAGhB,iBAAiB,EAEjB,sBAAsB,EACtB,gBAAgB,EAEhB,eAAe,EAEf,cAAc,EACd,mBAAmB,EACnB,sBAAsB,EACtB,kBAAkB,EAElB,kBAAkB,EAElB,eAAe,EAClB,MAAM,0BAA0B,CAAA;AACjC,OAAO,EAAC,qBAAqB,EAAE,kBAAkB,EAAC,MAAM,qBAAqB,CAAA;AAC7E,OAAO,EAAC,UAAU,EAAC,MAAM,cAAc,CAAA;AACvC,OAAO,EAAC,KAAK,EAAC,MAAM,UAAU,CAAA;AAC9B,OAAO,EAAC,UAAU,EAAC,MAAM,cAAc,CAAA;AAEvC,OAAO,EAAC,cAAc,EAAY,MAAM,YAAY,CAAA;AACpD,OAAO,EAAC,YAAY,EAAC,MAAM,iBAAiB,CAAA;AAC5C,OAAO,EAAC,aAAa,EAAC,MAAM,kBAAkB,CAAA;AAC9C,OAAO,EAAc,YAAY,EAAC,MAAM,SAAS,CAAA;AAEjD,OAAO,EAAC,IAAI,EAAE,QAAQ,EAAW,MAAM,kBAAkB,CAAA;AAGzD,OAAO,EAAC,qBAAqB,EAAE,aAAa,EAAC,MAAM,OAAO,CAAA;AAG1D,MAAM,MAAM,cAAc,GAAG;IAAE,MAAM,EAAE,IAAI,CAAC,OAAO,EAAE,OAAO,CAAC,OAAO,CAAC,CAAC,CAAC;IAAC,IAAI,EAAE,SAAS,CAAC,aAAa,CAAC,CAAA;CAAE,CAAA;AAExG,MAAM,MAAM,oBAAoB,GAAG;IAC/B,aAAa,CAAC,EAAE,OAAO,CAAA;CAC1B,CAAA;AAGD,qBAAa,OAAQ,YAAW,kBAAkB,EAAE,UAAU,EAAE,eAAe;;IAC3E,MAAM,CAAC,GAAG,CAAC,GAAG,EAAE,UAAU,EAAE,OAAO,CAAC,EAAE,oBAAoB,GAAG,OAAO;IAYpE,MAAM,CAAC,IAAI,CAAC,GAAG,EAAE,UAAU,EAAE,WAAW,EAAE,WAAW,GAAG,OAAO;WAIlD,cAAc,CAAC,GAAG,EAAE,UAAU,EAAE,WAAW,EAAE,WAAW,GAAG,OAAO,CAAC,OAAO,CAAC;IAOxF,MAAM,CAAC,YAAY,CAAC,GAAG,EAAE,UAAU,EAAE,QAAQ,EAAE,eAAe,EAAE,eAAe,GAAE,OAAc,GAAG,OAAO;IAYzG,QAAQ,CAAC,QAAQ,EAAE,QAAQ,CAAC,KAAK,CAAC,OAAO,CAAC,CAAA;IAE1C,QAAQ,CAAC,OAAO,EAAE,OAAO,CAAA;IACzB,QAAQ,CAAC,kBAAkB,EAAE,aAAa,CAAC,gBAAgB,CAAC,CAAA;IAC5D,QAAQ,CAAC,kBAAkB,EAAE,WAAW,CAAA;IACxC,QAAQ,CAAC,mBAAmB,EAAE,YAAY,CAAA;IAC1C,QAAQ,CAAC,WAAW,EAAE,WAAW,CAAA;IAEjC,QAAQ,CAAC,GAAG,EAAE,UAAU,CAAA;IACxB,QAAQ,CAAC,cAAc,EAAE,cAAc,CAAA;IACvC,QAAQ,CAAC,OAAO,EAAE,UAAU,CAAA;IAC5B,QAAQ,CAAC,SAAS,EAAE,eAAe,CAAA;IACnC,QAAQ,CAAC,eAAe,EAAE,iBAAiB,CAAC,gBAAgB,CAAC,CAAA;IAC7D,QAAQ,CAAC,eAAe,EAAE,iBAAiB,CAAC,mBAAmB,CAAC,CAAA;IAChE,QAAQ,CAAC,WAAW,EAAE,WAAW,CAAA;IACjC,QAAQ,CAAC,kBAAkB,EAAE,kBAAkB,CAAA;IAC/C,QAAQ,CAAC,sBAAsB,EAAE,sBAAsB,CAAA;IACvD,QAAQ,CAAC,kBAAkB,EAAE,kBAAkB,CAAA;IAC/C,QAAQ,CAAC,YAAY,EAAE,YAAY,CAAA;IACnC,QAAQ,CAAC,KAAK,EAAE,KAAK,CAAA;IACrB,QAAQ,CAAC,QAAQ,EAAE,QAAQ,CAAA;IAC3B,QAAQ,CAAC,eAAe,EAAE,qBAAqB,CAAA;IAC/C,QAAQ,CAAC,aAAa,EAAE,aAAa,CAAA;IACrC,QAAQ,CAAC,MAAM,eAAqB;IAKpC,OAAO;IAkEP,iBAAiB,CAAC,OAAO,CAAC,EAAE,cAAc,EAAE,OAAO,CAAC,EAAE,gBAAgB,GAAG,aAAa;IAoBtF,iBAAiB,IAAI,IAAI;IASzB,cAAc,CAAC,OAAO,GAAE,OAAc;IAMtC,aAAa,IAAI,IAAI;IAKrB,WAAW,IAAI,OAAO;IAEtB,MAAM,CAAC,GAAG,EAAE,gBAAgB,GAAG,IAAI;IAMnC,GAAG,CAAC,CAAC,SAAS,UAAU,EAAE,UAAU,EAAE,CAAC,GAAG,CAAC;IAC3C,MAAM,CAAC,CAAC,SAAS,UAAU,EAAE,GAAG,WAAW,EAAE,KAAK,CAAC,CAAC,CAAC,GAAG,IAAI;IAC5D,KAAK,IAAI,UAAU;IAEnB,IAAI,GAAG,IAAI,UAAU,CAAmB;IACxC,IAAI,cAAc,IAAI,cAAc,CAA8B;IAClE,IAAI,kBAAkB,IAAI,kBAAkB,CAAkC;IAC9E,IAAI,aAAa,IAAI,mBAAmB,CAAiC;IACzE,IAAI,gBAAgB,IAAI,sBAAsB,CAAoC;IAClF,IAAI,cAAc,IAAI,cAAc,CAAkD;IACtF,IAAI,cAAc,IAAI,OAAO,CAAe;IAC5C,IAAI,YAAY,IAAI,OAAO,CAAc;IACzC,IAAI,0BAA0B,IAAI,mBAAmB,CAEpD;IACD,IAAI,qBAAqB,IAAI,qBAAqB,CAAkD;IAEpG,IAAI,QAAQ,IAAI,eAAe,CAW9B;IAED,sBAAsB,CAAC,YAAY,EAAE,MAAM,EAAE,IAAI,EAAE,UAAU,EAAE,gBAAgB,EAAE,MAAM,GAAG,IAAI;IAe9F,kBAAkB,IAAI,aAAa,CAAC,IAAI,CAAC,KAAK,CAAC;IAM/C,gBAAgB,IAAI,IAAI;IAsBxB,aAAa,IAAI,eAAe;IAEhC,IAAI,CAAC,GAAG,CAAC,EAAE,OAAO,CAAC,UAAU,CAAC,GAAG,OAAO;IAIxC,OAAO,IAAI,OAAO;IAuBlB,gBAAgB,IAAI,IAAI;IAOxB,sBAAsB,CAAC,IAAI,EAAE,IAAI,CAAC,KAAK,GAAG,IAAI;IAI9C,SAAS,IAAI,IAAI;CA4BpB"}
+{"version":3,"file":"Project.d.ts","sourceRoot":"","sources":["../../src/project/Project.ts"],"names":[],"mappings":"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"}

package/dist/project/Project.js

@@ -15,6 +15,7 @@ import { MidiData } from "@opendaw/lib-midi";
 import { StudioPreferences } from "../StudioPreferences";
 import { RegionOverlapResolver, TimelineFocus } from "../ui";
 import { SampleStorage } from "../samples";
+import { AudioUnitFreeze } from "../AudioUnitFreeze";
 // Main Entry Point for a Project
 export class Project {
     static new(env, options) {
@@ -73,6 +74,7 @@ export class Project {
     overlapResolver;
     timelineFocus;
     engine = new EngineFacade();
+    audioUnitFreeze;
     #rootBoxAdapter;
     #timelineBoxAdapter;
     constructor(env, boxGraph, { rootBox, userInterfaceBoxes, primaryAudioBusBox, primaryAudioUnitBox, timelineBox }) {
@@ -106,6 +108,7 @@ export class Project {
         this.mixer = new Mixer(this.#rootBoxAdapter.audioUnits);
         this.overlapResolver = new RegionOverlapResolver(this.editing, this.api, this.boxAdapters);
         this.timelineFocus = this.#terminator.own(new TimelineFocus());
+        this.audioUnitFreeze = this.#terminator.own(new AudioUnitFreeze(this));
         console.debug(`Project was created on ${this.rootBoxAdapter.created.toString()}`);
         this.#sampleRegistrations = UUID.newSet(({ uuid }) => uuid);
         for (const box of this.boxGraph.boxes()) {

package/dist/ui/index.d.ts

@@ -7,6 +7,7 @@ export * from "./clipboard/types/NotesClipboardHandler";
 export * from "./clipboard/types/RegionsClipboardHandler";
 export * from "./clipboard/types/ValuesClipboardHandler";
 export * from "./menu/MenuItems";
+export * from "./renderer";
 export * from "./timeline/RegionClipResolver";
 export * from "./timeline/RegionKeepExistingResolver";
 export * from "./timeline/RegionModifyStrategies";

package/dist/ui/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/ui/index.ts"],"names":[],"mappings":"AAAA,cAAc,8BAA8B,CAAA;AAC5C,cAAc,4BAA4B,CAAA;AAC1C,cAAc,yBAAyB,CAAA;AACvC,cAAc,8CAA8C,CAAA;AAC5D,cAAc,2CAA2C,CAAA;AACzD,cAAc,yCAAyC,CAAA;AACvD,cAAc,2CAA2C,CAAA;AACzD,cAAc,0CAA0C,CAAA;AACxD,cAAc,kBAAkB,CAAA;AAChC,cAAc,+BAA+B,CAAA;AAC7C,cAAc,uCAAuC,CAAA;AACrD,cAAc,mCAAmC,CAAA;AACjD,cAAc,kCAAkC,CAAA;AAChD,cAAc,uCAAuC,CAAA;AACrD,cAAc,0BAA0B,CAAA;AACxC,cAAc,qBAAqB,CAAA;AACnC,cAAc,0BAA0B,CAAA;AACxC,cAAc,0BAA0B,CAAA"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/ui/index.ts"],"names":[],"mappings":"AAAA,cAAc,8BAA8B,CAAA;AAC5C,cAAc,4BAA4B,CAAA;AAC1C,cAAc,yBAAyB,CAAA;AACvC,cAAc,8CAA8C,CAAA;AAC5D,cAAc,2CAA2C,CAAA;AACzD,cAAc,yCAAyC,CAAA;AACvD,cAAc,2CAA2C,CAAA;AACzD,cAAc,0CAA0C,CAAA;AACxD,cAAc,kBAAkB,CAAA;AAChC,cAAc,YAAY,CAAA;AAC1B,cAAc,+BAA+B,CAAA;AAC7C,cAAc,uCAAuC,CAAA;AACrD,cAAc,mCAAmC,CAAA;AACjD,cAAc,kCAAkC,CAAA;AAChD,cAAc,uCAAuC,CAAA;AACrD,cAAc,0BAA0B,CAAA;AACxC,cAAc,qBAAqB,CAAA;AACnC,cAAc,0BAA0B,CAAA;AACxC,cAAc,0BAA0B,CAAA"}

package/dist/ui/index.js

@@ -7,6 +7,7 @@ export * from "./clipboard/types/NotesClipboardHandler";
 export * from "./clipboard/types/RegionsClipboardHandler";
 export * from "./clipboard/types/ValuesClipboardHandler";
 export * from "./menu/MenuItems";
+export * from "./renderer";
 export * from "./timeline/RegionClipResolver";
 export * from "./timeline/RegionKeepExistingResolver";
 export * from "./timeline/RegionModifyStrategies";

package/dist/ui/renderer/audio.d.ts

@@ -0,0 +1,9 @@
+import { RegionBound } from "./env";
+import { Option } from "@opendaw/lib-std";
+import { LoopableRegion, TempoMap } from "@opendaw/lib-dsp";
+import { AudioFileBoxAdapter, AudioPlayMode } from "@opendaw/studio-adapters";
+import { TimelineRange } from "../timeline/TimelineRange";
+export declare namespace AudioRenderer {
+    const render: (context: CanvasRenderingContext2D, range: TimelineRange, file: AudioFileBoxAdapter, tempoMap: TempoMap, playMode: Option<AudioPlayMode>, waveformOffset: number, gain: number, { top, bottom }: RegionBound, contentColor: string, { rawStart, resultStart, resultEnd }: LoopableRegion.LoopCycle, clip?: boolean) => void;
+}
+//# sourceMappingURL=audio.d.ts.map

package/dist/ui/renderer/audio.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"audio.d.ts","sourceRoot":"","sources":["../../../src/ui/renderer/audio.ts"],"names":[],"mappings":"AAAA,OAAO,EAAC,WAAW,EAAC,MAAM,OAAO,CAAA;AACjC,OAAO,EAAC,MAAM,EAAC,MAAM,kBAAkB,CAAA;AACvC,OAAO,EAAW,cAAc,EAAyB,QAAQ,EAAC,MAAM,kBAAkB,CAAA;AAE1F,OAAO,EAAC,mBAAmB,EAAE,aAAa,EAAC,MAAM,0BAA0B,CAAA;AAC3E,OAAO,EAAC,aAAa,EAAC,MAAM,2BAA2B,CAAA;AAEvD,yBAAiB,aAAa,CAAC;IASpB,MAAM,MAAM,GACf,SAAS,wBAAwB,EACjC,OAAO,aAAa,EACpB,MAAM,mBAAmB,EACzB,UAAU,QAAQ,EAClB,UAAU,MAAM,CAAC,aAAa,CAAC,EAC/B,gBAAgB,MAAM,EACtB,MAAM,MAAM,EACZ,iBAAe,WAAW,EAC1B,cAAc,MAAM,EACpB,sCAAoC,cAAc,CAAC,SAAS,EAC5D,OAAM,OAAc,SA2VvB,CAAA;CACJ"}

package/dist/ui/renderer/audio.js

@@ -0,0 +1,277 @@
+import { dbToGain, PPQN, TempoChangeGrid } from "@opendaw/lib-dsp";
+import { PeaksPainter } from "@opendaw/lib-fusion";
+export var AudioRenderer;
+(function (AudioRenderer) {
+    AudioRenderer.render = (context, range, file, tempoMap, playMode, waveformOffset, gain, { top, bottom }, contentColor, { rawStart, resultStart, resultEnd }, clip = true) => {
+        if (file.peaks.isEmpty()) {
+            return;
+        }
+        const peaks = file.peaks.unwrap();
+        const durationInSeconds = file.endInSeconds - file.startInSeconds;
+        const numFrames = peaks.numFrames;
+        const numberOfChannels = peaks.numChannels;
+        const ht = bottom - top;
+        const peaksHeight = Math.floor((ht - 4) / numberOfChannels);
+        const scale = dbToGain(-gain);
+        const segments = [];
+        if (playMode.nonEmpty()) {
+            const { warpMarkers } = playMode.unwrap();
+            const markers = warpMarkers.asArray();
+            if (markers.length < 2) {
+                return;
+            }
+            const first = markers[0];
+            const second = markers[1];
+            const secondLast = markers[markers.length - 2];
+            const last = markers[markers.length - 1];
+            const firstRate = (second.seconds - first.seconds) /
+                (second.position - first.position);
+            const lastRate = (last.seconds - secondLast.seconds) /
+                (last.position - secondLast.position);
+            const addSegment = (posStart, posEnd, audioStart, audioEnd, outside) => {
+                if (posStart >= posEnd) {
+                    return;
+                }
+                if (posStart > range.unitMax || posEnd < range.unitMin) {
+                    return;
+                }
+                const clippedStart = Math.max(posStart, range.unitMin - range.unitPadding);
+                const clippedEnd = Math.min(posEnd, range.unitMax);
+                if (clippedStart >= clippedEnd) {
+                    return;
+                }
+                const t0 = (clippedStart - posStart) / (posEnd - posStart);
+                const t1 = (clippedEnd - posStart) / (posEnd - posStart);
+                let aStart = audioStart + t0 * (audioEnd - audioStart) + waveformOffset;
+                let aEnd = audioStart + t1 * (audioEnd - audioStart) + waveformOffset;
+                let x0 = range.unitToX(clippedStart) * devicePixelRatio;
+                let x1 = range.unitToX(clippedEnd) * devicePixelRatio;
+                if (aStart < 0.0) {
+                    const ratio = -aStart / (aEnd - aStart);
+                    x0 = x0 + ratio * (x1 - x0);
+                    aStart = 0.0;
+                }
+                if (aEnd > durationInSeconds) {
+                    const ratio = (aEnd - durationInSeconds) / (aEnd - aStart);
+                    x1 = x1 - ratio * (x1 - x0);
+                    aEnd = durationInSeconds;
+                }
+                if (aStart >= aEnd) {
+                    return;
+                }
+                segments.push({
+                    x0,
+                    x1,
+                    u0: (aStart / durationInSeconds) * numFrames,
+                    u1: (aEnd / durationInSeconds) * numFrames,
+                    outside
+                });
+            };
+            const handleSegment = (segmentStart, segmentEnd, audioStartSeconds, audioEndSeconds) => {
+                if (segmentStart >= segmentEnd) {
+                    return;
+                }
+                if (clip) {
+                    if (segmentEnd <= resultStart || segmentStart >= resultEnd) {
+                        return;
+                    }
+                    const clippedStart = Math.max(segmentStart, resultStart);
+                    const clippedEnd = Math.min(segmentEnd, resultEnd);
+                    const t0 = (clippedStart - segmentStart) / (segmentEnd - segmentStart);
+                    const t1 = (clippedEnd - segmentStart) / (segmentEnd - segmentStart);
+                    const aStart = audioStartSeconds + t0 * (audioEndSeconds - audioStartSeconds);
+                    const aEnd = audioStartSeconds + t1 * (audioEndSeconds - audioStartSeconds);
+                    addSegment(clippedStart, clippedEnd, aStart, aEnd, false);
+                }
+                else {
+                    const rate = (audioEndSeconds - audioStartSeconds) / (segmentEnd - segmentStart);
+                    // Before audible
+                    if (segmentStart < resultStart) {
+                        const endPos = Math.min(segmentEnd, resultStart);
+                        const aEnd = audioStartSeconds + (endPos - segmentStart) * rate;
+                        addSegment(segmentStart, endPos, audioStartSeconds, aEnd, true);
+                    }
+                    // Audible
+                    if (segmentEnd > resultStart && segmentStart < resultEnd) {
+                        const startPos = Math.max(segmentStart, resultStart);
+                        const endPos = Math.min(segmentEnd, resultEnd);
+                        const aStart = audioStartSeconds + (startPos - segmentStart) * rate;
+                        const aEnd = audioStartSeconds + (endPos - segmentStart) * rate;
+                        addSegment(startPos, endPos, aStart, aEnd, false);
+                    }
+                    // After audible
+                    if (segmentEnd > resultEnd) {
+                        const startPos = Math.max(segmentStart, resultEnd);
+                        const aStart = audioStartSeconds + (startPos - segmentStart) * rate;
+                        addSegment(startPos, segmentEnd, aStart, audioEndSeconds, true);
+                    }
+                }
+            };
+            const visibleLocalStart = (clip ? resultStart : range.unitMin) - rawStart;
+            const visibleLocalEnd = (clip ? resultEnd : range.unitMax) - rawStart;
+            // With positive offset, audio from file start appears BEFORE first.position
+            // With negative offset, audio from file end appears AFTER last.position
+            const extraNeededBefore = waveformOffset > 0 ? waveformOffset / firstRate : 0;
+            const extraNeededAfter = waveformOffset < 0 ? -waveformOffset / lastRate : 0;
+            const extrapolateStartLocal = Math.min(visibleLocalStart, first.position - extraNeededBefore);
+            const extrapolateEndLocal = Math.max(visibleLocalEnd, last.position + extraNeededAfter);
+            // Extrapolate before the first warp marker
+            if (extrapolateStartLocal < first.position) {
+                const audioStart = first.seconds +
+                    (extrapolateStartLocal - first.position) * firstRate;
+                handleSegment(rawStart + extrapolateStartLocal, rawStart + first.position, audioStart, first.seconds);
+            }
+            // Interior warp segments - only iterate visible range
+            const startIndex = Math.max(0, warpMarkers.floorLastIndex(visibleLocalStart));
+            for (let i = startIndex; i < markers.length - 1; i++) {
+                const w0 = markers[i];
+                if (w0.position > visibleLocalEnd) {
+                    break;
+                }
+                const w1 = markers[i + 1];
+                handleSegment(rawStart + w0.position, rawStart + w1.position, w0.seconds, w1.seconds);
+            }
+            // Extrapolate after the last warp marker
+            if (extrapolateEndLocal > last.position) {
+                const audioEnd = last.seconds + (extrapolateEndLocal - last.position) * lastRate;
+                handleSegment(rawStart + last.position, rawStart + extrapolateEndLocal, last.seconds, audioEnd);
+            }
+        }
+        else {
+            // Non-stretch mode - audio plays at 100% original speed
+            // Audio time = elapsed timeline seconds since rawStart + waveformOffset
+            // Use rawStart (not resultStart) because resultStart is clipped to viewport
+            const regionStartSeconds = tempoMap.ppqnToSeconds(rawStart);
+            // Use absolute time conversion so it works for positions before AND after rawStart
+            const audioTimeAt = (ppqn) => tempoMap.ppqnToSeconds(ppqn) - regionStartSeconds + waveformOffset;
+            // Fixed step size for consistent rendering across zoom levels
+            const addSegmentDirect = (ppqnStart, ppqnEnd, audioStart, audioEnd, outside) => {
+                if (ppqnStart >= ppqnEnd) {
+                    return;
+                }
+                if (ppqnEnd < range.unitMin - range.unitPadding ||
+                    ppqnStart > range.unitMax) {
+                    return;
+                }
+                const clippedStart = Math.max(ppqnStart, range.unitMin - range.unitPadding);
+                const clippedEnd = Math.min(ppqnEnd, range.unitMax);
+                if (clippedStart >= clippedEnd) {
+                    return;
+                }
+                // Interpolate audio times for clipped range
+                const t0 = (clippedStart - ppqnStart) / (ppqnEnd - ppqnStart);
+                const t1 = (clippedEnd - ppqnStart) / (ppqnEnd - ppqnStart);
+                let aStart = audioStart + t0 * (audioEnd - audioStart);
+                let aEnd = audioStart + t1 * (audioEnd - audioStart);
+                let x0 = range.unitToX(clippedStart) * devicePixelRatio;
+                let x1 = range.unitToX(clippedEnd) * devicePixelRatio;
+                if (aStart < 0) {
+                    const ratio = -aStart / (aEnd - aStart);
+                    x0 += ratio * (x1 - x0);
+                    aStart = 0;
+                }
+                if (aEnd > durationInSeconds) {
+                    const ratio = (aEnd - durationInSeconds) / (aEnd - aStart);
+                    x1 -= ratio * (x1 - x0);
+                    aEnd = durationInSeconds;
+                }
+                if (aStart >= aEnd) {
+                    return;
+                }
+                const u0 = (aStart / durationInSeconds) * numFrames;
+                const u1 = (aEnd / durationInSeconds) * numFrames;
+                if (u0 < u1 && x1 - x0 >= 1) {
+                    segments.push({ x0, x1, u0, u1, outside });
+                }
+            };
+            // Similar to stretch mode: handle clipping at region boundaries
+            const handleTempoSegment = (segStart, segEnd, audioStart, audioEnd) => {
+                if (segStart >= segEnd) {
+                    return;
+                }
+                if (clip) {
+                    if (segEnd <= resultStart || segStart >= resultEnd) {
+                        return;
+                    }
+                    const clippedStart = Math.max(segStart, resultStart);
+                    const clippedEnd = Math.min(segEnd, resultEnd);
+                    const t0 = (clippedStart - segStart) / (segEnd - segStart);
+                    const t1 = (clippedEnd - segStart) / (segEnd - segStart);
+                    const aStart = audioStart + t0 * (audioEnd - audioStart);
+                    const aEnd = audioStart + t1 * (audioEnd - audioStart);
+                    addSegmentDirect(clippedStart, clippedEnd, aStart, aEnd, false);
+                }
+                else {
+                    const rate = (audioEnd - audioStart) / (segEnd - segStart);
+                    // Before audible region
+                    if (segStart < resultStart) {
+                        const endPos = Math.min(segEnd, resultStart);
+                        const aEnd = audioStart + (endPos - segStart) * rate;
+                        addSegmentDirect(segStart, endPos, audioStart, aEnd, true);
+                    }
+                    // Audible region
+                    if (segEnd > resultStart && segStart < resultEnd) {
+                        const startPos = Math.max(segStart, resultStart);
+                        const endPos = Math.min(segEnd, resultEnd);
+                        const aStart = audioStart + (startPos - segStart) * rate;
+                        const aEnd = audioStart + (endPos - segStart) * rate;
+                        addSegmentDirect(startPos, endPos, aStart, aEnd, false);
+                    }
+                    // After audible region
+                    if (segEnd > resultEnd) {
+                        const startPos = Math.max(segStart, resultEnd);
+                        const aStart = audioStart + (startPos - segStart) * rate;
+                        addSegmentDirect(startPos, segEnd, aStart, audioEnd, true);
+                    }
+                }
+            };
+            // Calculate iteration bounds
+            // Where does audioTime = 0? Solve: ppqnToSeconds(ppqn) - regionStartSeconds + waveformOffset = 0
+            const audioStartPPQN = tempoMap.secondsToPPQN(regionStartSeconds - waveformOffset);
+            // Where does audioTime = durationInSeconds?
+            const audioEndPPQN = tempoMap.secondsToPPQN(regionStartSeconds - waveformOffset + durationInSeconds);
+            // Determine visible iteration range (include padding on the left for smooth scrolling)
+            const iterStart = clip
+                ? Math.max(resultStart, range.unitMin - range.unitPadding)
+                : Math.max(Math.min(audioStartPPQN, resultStart), range.unitMin - range.unitPadding);
+            const iterEnd = clip
+                ? Math.min(resultEnd, range.unitMax + TempoChangeGrid)
+                : Math.min(Math.max(audioEndPPQN, resultEnd), range.unitMax + TempoChangeGrid);
+            // Dynamic step size: ensure each step is at least 1 device pixel wide
+            const minStepSize = range.unitsPerPixel * devicePixelRatio;
+            const stepSize = Math.max(TempoChangeGrid, Math.ceil(minStepSize / TempoChangeGrid) * TempoChangeGrid);
+            // Align to grid for consistent rendering across zoom levels
+            let currentPPQN = Math.floor(iterStart / stepSize) * stepSize;
+            // Compute initial audio time once, then increment (avoid O(n) ppqnToSeconds calls per step)
+            let currentAudioTime = audioTimeAt(currentPPQN);
+            while (currentPPQN < iterEnd) {
+                const nextPPQN = currentPPQN + stepSize;
+                // Incremental: get tempo at the current position and compute step duration
+                const stepSeconds = PPQN.pulsesToSeconds(stepSize, tempoMap.getTempoAt(currentPPQN));
+                const nextAudioTime = currentAudioTime + stepSeconds;
+                // Skip if entirely outside audio file range
+                if (nextAudioTime > 0 && currentAudioTime < durationInSeconds) {
+                    handleTempoSegment(currentPPQN, nextPPQN, currentAudioTime, nextAudioTime);
+                }
+                currentPPQN = nextPPQN;
+                currentAudioTime = nextAudioTime;
+            }
+        }
+        context.fillStyle = contentColor;
+        for (const { x0, x1, u0, u1, outside } of segments) {
+            context.globalAlpha = outside && !clip ? 0.25 : 1.0;
+            for (let channel = 0; channel < numberOfChannels; channel++) {
+                PeaksPainter.renderBlocks(context, peaks, channel, {
+                    u0,
+                    u1,
+                    v0: -scale,
+                    v1: +scale,
+                    x0,
+                    x1,
+                    y0: 3 + top + channel * peaksHeight,
+                    y1: 3 + top + (channel + 1) * peaksHeight
+                });
+            }
+        }
+    };
+})(AudioRenderer || (AudioRenderer = {}));

package/dist/ui/renderer/env.d.ts

@@ -0,0 +1,5 @@
+export type RegionBound = {
+    top: number;
+    bottom: number;
+};
+//# sourceMappingURL=env.d.ts.map

package/dist/ui/renderer/env.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"env.d.ts","sourceRoot":"","sources":["../../../src/ui/renderer/env.ts"],"names":[],"mappings":"AAAA,MAAM,MAAM,WAAW,GAAG;IACtB,GAAG,EAAE,MAAM,CAAA;IACX,MAAM,EAAE,MAAM,CAAA;CACjB,CAAA"}

package/dist/ui/renderer/env.js

@@ -0,0 +1 @@
+export {};

package/dist/ui/renderer/fading.d.ts

@@ -0,0 +1,7 @@
+import { FadingEnvelope } from "@opendaw/lib-dsp";
+import { TimelineRange } from "../../index";
+import { RegionBound } from "./env";
+export declare namespace AudioFadingRenderer {
+    const render: (context: CanvasRenderingContext2D, range: TimelineRange, fading: FadingEnvelope.Config, { top, bottom }: RegionBound, startPPQN: number, endPPQN: number, color: string) => void;
+}
+//# sourceMappingURL=fading.d.ts.map

package/dist/ui/renderer/fading.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"fading.d.ts","sourceRoot":"","sources":["../../../src/ui/renderer/fading.ts"],"names":[],"mappings":"AACA,OAAO,EAAC,cAAc,EAAC,MAAM,kBAAkB,CAAA;AAC/C,OAAO,EAAC,aAAa,EAAC,MAAM,aAAa,CAAA;AACzC,OAAO,EAAC,WAAW,EAAC,MAAM,OAAO,CAAA;AAEjC,yBAAiB,mBAAmB,CAAC;IAC1B,MAAM,MAAM,GAAI,SAAS,wBAAwB,EACjC,OAAO,aAAa,EACpB,QAAQ,cAAc,CAAC,MAAM,EAC7B,iBAAe,WAAW,EAC1B,WAAW,MAAM,EACjB,SAAS,MAAM,EACf,OAAO,MAAM,KAAG,IAkDtC,CAAA;CACJ"}

package/dist/ui/renderer/fading.js

@@ -0,0 +1,55 @@
+import { Curve, TAU } from "@opendaw/lib-std";
+export var AudioFadingRenderer;
+(function (AudioFadingRenderer) {
+    AudioFadingRenderer.render = (context, range, fading, { top, bottom }, startPPQN, endPPQN, color) => {
+        const { inSlope: fadeInSlope, outSlope: fadeOutSlope } = fading;
+        const duration = endPPQN - startPPQN;
+        const totalFading = fading.in + fading.out;
+        const scale = totalFading > duration ? duration / totalFading : 1.0;
+        const fadeIn = fading.in * scale;
+        const fadeOut = fading.out * scale;
+        context.strokeStyle = color;
+        context.fillStyle = "rgba(0,0,0,0.25)";
+        context.lineWidth = devicePixelRatio;
+        if (fadeIn > 0) {
+            const fadeInEndPPQN = startPPQN + fadeIn;
+            const x0 = range.unitToX(startPPQN) * devicePixelRatio;
+            const x1 = range.unitToX(fadeInEndPPQN) * devicePixelRatio;
+            const xn = x1 - x0;
+            const path = new Path2D();
+            path.moveTo(x0, bottom);
+            let x = x0;
+            Curve.run(fadeInSlope, xn, bottom, top, y => path.lineTo(++x, y));
+            path.lineTo(x1, top);
+            context.stroke(path);
+            path.lineTo(x0, top);
+            path.lineTo(x0, bottom);
+            context.fill(path);
+        }
+        if (fadeOut > 0) {
+            const x0 = range.unitToX(endPPQN - fadeOut) * devicePixelRatio;
+            const x1 = range.unitToX(endPPQN) * devicePixelRatio;
+            const xn = x1 - x0;
+            const path = new Path2D();
+            path.moveTo(x0, top);
+            let x = x0;
+            Curve.run(fadeOutSlope, xn, top, bottom, y => path.lineTo(++x, y));
+            path.lineTo(x1, bottom);
+            context.strokeStyle = color;
+            context.stroke(path);
+            path.lineTo(x1, top);
+            path.lineTo(x0, top);
+            context.fill(path);
+        }
+        const handleRadius = 1.5 * devicePixelRatio;
+        const x0 = Math.max(range.unitToX(startPPQN + fadeIn), range.unitToX(startPPQN)) * devicePixelRatio;
+        const x1 = Math.min(range.unitToX(endPPQN - fadeOut), range.unitToX(endPPQN)) * devicePixelRatio;
+        context.fillStyle = color;
+        context.beginPath();
+        context.arc(x0, top, handleRadius, 0, TAU);
+        context.fill();
+        context.beginPath();
+        context.arc(x1, top, handleRadius, 0, TAU);
+        context.fill();
+    };
+})(AudioFadingRenderer || (AudioFadingRenderer = {}));

package/dist/ui/renderer/index.d.ts

@@ -0,0 +1,6 @@
+export * from "./audio";
+export * from "./env";
+export * from "./fading";
+export * from "./notes";
+export * from "./value";
+//# sourceMappingURL=index.d.ts.map

package/dist/ui/renderer/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/ui/renderer/index.ts"],"names":[],"mappings":"AAAA,cAAc,SAAS,CAAA;AACvB,cAAc,OAAO,CAAA;AACrB,cAAc,UAAU,CAAA;AACxB,cAAc,SAAS,CAAA;AACvB,cAAc,SAAS,CAAA"}

package/dist/ui/renderer/index.js

@@ -0,0 +1,5 @@
+export * from "./audio";
+export * from "./env";
+export * from "./fading";
+export * from "./notes";
+export * from "./value";

package/dist/ui/renderer/notes.d.ts

@@ -0,0 +1,7 @@
+import { NoteRegionBoxAdapter } from "@opendaw/studio-adapters";
+import { LoopableRegion } from "@opendaw/lib-dsp";
+import { RegionBound, TimelineRange } from "../../index";
+export declare namespace NotesRenderer {
+    const render: (context: CanvasRenderingContext2D, range: TimelineRange, region: NoteRegionBoxAdapter, { top, bottom }: RegionBound, contentColor: string, { rawStart, regionStart, resultStart, resultEnd }: LoopableRegion.LoopCycle) => void;
+}
+//# sourceMappingURL=notes.d.ts.map

package/dist/ui/renderer/notes.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"notes.d.ts","sourceRoot":"","sources":["../../../src/ui/renderer/notes.ts"],"names":[],"mappings":"AAAA,OAAO,EAAC,oBAAoB,EAAC,MAAM,0BAA0B,CAAA;AAC7D,OAAO,EAAC,cAAc,EAAC,MAAM,kBAAkB,CAAA;AAC/C,OAAO,EAAC,WAAW,EAAE,aAAa,EAAC,MAAM,aAAa,CAAA;AAEtD,yBAAiB,aAAa,CAAC;IACpB,MAAM,MAAM,GAAI,SAAS,wBAAwB,EACjC,OAAO,aAAa,EACpB,QAAQ,oBAAoB,EAC5B,iBAAe,WAAW,EAC1B,cAAc,MAAM,EACpB,mDAAiD,cAAc,CAAC,SAAS,SAiB/F,CAAA;CACJ"}

package/dist/ui/renderer/notes.js

@@ -0,0 +1,23 @@
+export var NotesRenderer;
+(function (NotesRenderer) {
+    NotesRenderer.render = (context, range, region, { top, bottom }, contentColor, { rawStart, regionStart, resultStart, resultEnd }) => {
+        const collection = region.optCollection.unwrap();
+        const height = bottom - top;
+        context.fillStyle = contentColor;
+        const padding = 8;
+        const noteHeight = 5;
+        const searchStart = Math.floor(resultStart - rawStart);
+        const searchEnd = Math.floor(resultEnd - rawStart);
+        for (const note of collection.events.iterateRange(searchStart - collection.maxDuration, searchEnd)) {
+            const position = rawStart + note.position;
+            if (position < regionStart) {
+                continue;
+            }
+            const complete = Math.min(rawStart + note.complete, resultEnd);
+            const x0 = Math.floor(range.unitToX(position) * devicePixelRatio);
+            const x1 = Math.floor(range.unitToX(complete) * devicePixelRatio);
+            const y = top + padding + Math.floor(note.normalizedPitch() * (height - (padding * 2 + noteHeight)));
+            context.fillRect(x0, y, Math.max(1, x1 - x0), noteHeight);
+        }
+    };
+})(NotesRenderer || (NotesRenderer = {}));

package/dist/ui/renderer/value.d.ts

@@ -0,0 +1,7 @@
+import { LoopableRegion, ValueEvent } from "@opendaw/lib-dsp";
+import { Func, unitValue } from "@opendaw/lib-std";
+import { TimelineRange } from "../../index";
+export declare namespace ValueStreamRenderer {
+    const render: (context: CanvasRenderingContext2D, range: TimelineRange, generator: IterableIterator<ValueEvent>, valueToY: Func<unitValue, number>, contentColor: string, alphaFill: unitValue, anchor: unitValue, { resultStart, resultEnd, rawStart: delta }: LoopableRegion.LoopCycle) => void;
+}
+//# sourceMappingURL=value.d.ts.map

package/dist/ui/renderer/value.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"value.d.ts","sourceRoot":"","sources":["../../../src/ui/renderer/value.ts"],"names":[],"mappings":"AAAA,OAAO,EAAC,cAAc,EAAE,UAAU,EAAC,MAAM,kBAAkB,CAAA;AAC3D,OAAO,EAA2B,IAAI,EAAE,SAAS,EAAC,MAAM,kBAAkB,CAAA;AAC1E,OAAO,EAAC,aAAa,EAAC,MAAM,aAAa,CAAA;AAEzC,yBAAiB,mBAAmB,CAAC;IAC1B,MAAM,MAAM,GAAI,SAAS,wBAAwB,EACjC,OAAO,aAAa,EACpB,WAAW,gBAAgB,CAAC,UAAU,CAAC,EACvC,UAAU,IAAI,CAAC,SAAS,EAAE,MAAM,CAAC,EACjC,cAAc,MAAM,EACpB,WAAW,SAAS,EACpB,QAAQ,SAAS,EACjB,6CAA2C,cAAc,CAAC,SAAS,SAuFzF,CAAA;CACJ"}

package/dist/ui/renderer/value.js

@@ -0,0 +1,101 @@
+import { asDefined, assert, Curve } from "@opendaw/lib-std";
+export var ValueStreamRenderer;
+(function (ValueStreamRenderer) {
+    ValueStreamRenderer.render = (context, range, generator, valueToY, contentColor, alphaFill, anchor, { resultStart, resultEnd, rawStart: delta }) => {
+        const { done, value } = generator.next();
+        if (done) {
+            return;
+        }
+        const unitToX = (unit) => range.unitToX(unit + delta) * devicePixelRatio;
+        const path = new Path2D();
+        const windowMin = resultStart - delta;
+        const windowMax = resultEnd - delta;
+        const xMin = unitToX(windowMin);
+        const xMax = unitToX(windowMax);
+        let notMoved = true; // makes sure we start with a moveTo command
+        let prev = asDefined(value);
+        for (const next of generator) {
+            assert(prev !== next, "iterator error");
+            const { position: p0, value: v0, interpolation } = prev;
+            const { position: p1, value: v1 } = next;
+            const type = interpolation.type;
+            const x0 = unitToX(p0);
+            const x1 = unitToX(p1);
+            const y0 = valueToY(v0);
+            const y1 = valueToY(v1);
+            if (type === "none" || p1 - p0 === 0) { // hold and jumps to the next event's value
+                if (notMoved) {
+                    if (p1 > windowMax) {
+                        break;
+                    } // leave the rest for after the loop
+                    path.moveTo(xMin, y0); // move pen to window min
+                    path.lineTo(x1, y0); // line to next event
+                    notMoved = false;
+                }
+                if (x1 > xMax) {
+                    break;
+                }
+                path.lineTo(x1, y0); // hold value to the next event
+                path.lineTo(x1, y1); // jump to the next event value
+            }
+            else if (type === "linear") {
+                const ratio = (v1 - v0) / (p1 - p0);
+                if (notMoved) {
+                    path.moveTo(xMin, valueToY(p0 < windowMin ? v0 + ratio * (windowMin - p0) : v0)); // move pen to window min
+                    if (p0 > windowMin) {
+                        path.lineTo(x0, y0);
+                    } // line to first event
+                    notMoved = false;
+                }
+                if (p1 > windowMax) {
+                    path.lineTo(xMax, valueToY(v0 + ratio * (windowMax - p0))); // line to window max
+                }
+                else {
+                    path.lineTo(x1, y1); // line to next event
+                }
+            }
+            else if (type === "curve") {
+                const cx0 = Math.max(x0, xMin);
+                const cx1 = Math.min(x1, xMax);
+                const definition = { slope: interpolation.slope, steps: x1 - x0, y0, y1 };
+                if (notMoved) {
+                    if (p0 > windowMin) {
+                        path.moveTo(xMin, y0); // move to window edge
+                        path.lineTo(x0, y0); // draw the line to the first event
+                    }
+                    else {
+                        path.moveTo(cx0, Curve.valueAt(definition, cx0 - x0));
+                    }
+                    notMoved = false;
+                }
+                // TODO We can optimise this by walking the Curve.coefficients
+                for (let x = cx0; x <= cx1; x += 4) {
+                    path.lineTo(x, Curve.valueAt(definition, x - x0));
+                }
+                path.lineTo(cx1, Curve.valueAt(definition, cx1 - x0));
+            }
+            prev = next;
+        }
+        if (notMoved) {
+            // we have not moved, so let's draw a straight line from min to max to respect the sole event
+            path.moveTo(xMin, valueToY(prev.value));
+            path.lineTo(xMax, valueToY(prev.value));
+        }
+        else if (prev.position < windowMax) {
+            // hold value to the window max
+            path.lineTo(xMax, valueToY(prev.value));
+        }
+        const yMin = valueToY(anchor) + devicePixelRatio;
+        const style = contentColor;
+        context.fillStyle = style;
+        context.strokeStyle = style;
+        context.beginPath();
+        context.stroke(path);
+        path.lineTo(xMax, yMin);
+        path.lineTo(xMin, yMin);
+        path.closePath();
+        context.globalAlpha = alphaFill;
+        context.fill(path);
+        context.globalAlpha = 1.00;
+    };
+})(ValueStreamRenderer || (ValueStreamRenderer = {}));