semiotic 2.0.2 → 3.0.0-beta.1

package/ai/dist/src/components/realtime/RingBuffer.js

@@ -0,0 +1,104 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RingBuffer = void 0;
+class RingBuffer {
+    constructor(_capacity) {
+        this._capacity = _capacity;
+        this.head = 0;
+        this._size = 0;
+        if (_capacity < 1) {
+            throw new Error("RingBuffer capacity must be at least 1");
+        }
+        this.buffer = new Array(_capacity);
+    }
+    push(value) {
+        let evicted;
+        if (this._size === this._capacity) {
+            // Buffer is full — the slot at head is the oldest item
+            evicted = this.buffer[this.head];
+        }
+        else {
+            this._size++;
+        }
+        this.buffer[this.head] = value;
+        this.head = (this.head + 1) % this._capacity;
+        return evicted;
+    }
+    pushMany(values) {
+        const evicted = [];
+        for (const v of values) {
+            const e = this.push(v);
+            if (e !== undefined) {
+                evicted.push(e);
+            }
+        }
+        return evicted;
+    }
+    get(index) {
+        if (index < 0 || index >= this._size)
+            return undefined;
+        const realIndex = (this.head - this._size + index + this._capacity) % this._capacity;
+        return this.buffer[realIndex];
+    }
+    peek() {
+        if (this._size === 0)
+            return undefined;
+        return this.buffer[(this.head - 1 + this._capacity) % this._capacity];
+    }
+    peekOldest() {
+        if (this._size === 0)
+            return undefined;
+        return this.buffer[(this.head - this._size + this._capacity) % this._capacity];
+    }
+    [Symbol.iterator]() {
+        let i = 0;
+        const self = this;
+        return {
+            next() {
+                if (i >= self._size)
+                    return { done: true, value: undefined };
+                return { done: false, value: self.get(i++) };
+            }
+        };
+    }
+    toArray() {
+        const result = [];
+        for (const item of this) {
+            result.push(item);
+        }
+        return result;
+    }
+    resize(newCapacity) {
+        if (newCapacity < 1) {
+            throw new Error("RingBuffer capacity must be at least 1");
+        }
+        const items = this.toArray();
+        const evicted = [];
+        while (items.length > newCapacity) {
+            evicted.push(items.shift());
+        }
+        this._capacity = newCapacity;
+        this.buffer = new Array(newCapacity);
+        this.head = 0;
+        this._size = 0;
+        for (const item of items) {
+            this.push(item);
+        }
+        return evicted;
+    }
+    clear() {
+        this.buffer = new Array(this._capacity);
+        this.head = 0;
+        this._size = 0;
+    }
+    get size() {
+        return this._size;
+    }
+    get capacity() {
+        return this._capacity;
+    }
+    get full() {
+        return this._size === this._capacity;
+    }
+}
+exports.RingBuffer = RingBuffer;

package/ai/dist/src/components/realtime/renderers/barRenderer.js

@@ -0,0 +1,133 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.barRenderer = void 0;
+const BinAccumulator_1 = require("../BinAccumulator");
+const DEFAULT_PALETTE = [
+    "#4e79a7", "#f28e2b", "#e15759", "#76b7b2",
+    "#59a14f", "#edc948", "#b07aa1", "#ff9da7",
+    "#9c755f", "#bab0ac"
+];
+const barRenderer = (ctx, data, scales, layout, style, accessors, annotations, options) => {
+    const binSize = options?.binSize;
+    if (!binSize)
+        return;
+    const { time: timeScale, value: valueScale } = scales;
+    const { timeAxis } = layout;
+    const { time: getTime, value: getValue, category: getCategory } = accessors;
+    const barColors = options?.barColors;
+    const barStyle = options?.barStyle;
+    const bins = (0, BinAccumulator_1.computeBins)(data, getTime, getValue, binSize, getCategory);
+    if (bins.size === 0)
+        return;
+    const [domainMin, domainMax] = timeScale.domain();
+    const gap = barStyle?.gap ?? 1;
+    const hasCategories = getCategory != null;
+    // Determine category order: barColors keys first, then alphabetical for unlisted
+    let categoryOrder = null;
+    if (hasCategories) {
+        const allCategories = new Set();
+        for (const bin of bins.values()) {
+            for (const cat of bin.categories.keys()) {
+                allCategories.add(cat);
+            }
+        }
+        const colorKeys = barColors ? Object.keys(barColors) : [];
+        const listed = new Set(colorKeys);
+        const unlisted = Array.from(allCategories).filter(c => !listed.has(c)).sort();
+        categoryOrder = [...colorKeys.filter(k => allCategories.has(k)), ...unlisted];
+    }
+    // Bar stroke settings
+    const hasBarStroke = barStyle?.stroke != null;
+    if (hasBarStroke) {
+        ctx.strokeStyle = barStyle.stroke;
+        ctx.lineWidth = barStyle?.strokeWidth ?? 1;
+    }
+    for (const bin of bins.values()) {
+        if (timeAxis === "x") {
+            const clampedStart = Math.max(bin.start, domainMin);
+            const clampedEnd = Math.min(bin.end, domainMax);
+            if (clampedStart >= clampedEnd)
+                continue;
+            const rawX0 = timeScale(clampedStart);
+            const rawX1 = timeScale(clampedEnd);
+            const x0 = Math.min(rawX0, rawX1) + gap / 2;
+            const x1 = Math.max(rawX0, rawX1) - gap / 2;
+            const barWidth = x1 - x0;
+            if (barWidth <= 0)
+                continue;
+            if (hasCategories && categoryOrder) {
+                let cumulativeBase = 0;
+                let paletteIdx = 0;
+                for (const cat of categoryOrder) {
+                    const catVal = bin.categories.get(cat) || 0;
+                    if (catVal === 0)
+                        continue;
+                    const yBottom = valueScale(cumulativeBase);
+                    const yTop = valueScale(cumulativeBase + catVal);
+                    const rectY = Math.min(yBottom, yTop);
+                    const rectH = Math.abs(yBottom - yTop);
+                    ctx.fillStyle = (barColors && barColors[cat]) || DEFAULT_PALETTE[paletteIdx % DEFAULT_PALETTE.length];
+                    ctx.fillRect(x0, rectY, barWidth, rectH);
+                    if (hasBarStroke)
+                        ctx.strokeRect(x0, rectY, barWidth, rectH);
+                    cumulativeBase += catVal;
+                    paletteIdx++;
+                }
+            }
+            else {
+                const yZero = valueScale(0);
+                const yTop = valueScale(bin.total);
+                const rectY = Math.min(yZero, yTop);
+                const rectH = Math.abs(yZero - yTop);
+                ctx.fillStyle = barStyle?.fill || style.stroke || "#007bff";
+                ctx.fillRect(x0, rectY, barWidth, rectH);
+                if (hasBarStroke)
+                    ctx.strokeRect(x0, rectY, barWidth, rectH);
+            }
+        }
+        else {
+            // timeAxis === "y": horizontal bars
+            const clampedStart = Math.max(bin.start, domainMin);
+            const clampedEnd = Math.min(bin.end, domainMax);
+            if (clampedStart >= clampedEnd)
+                continue;
+            const rawY0 = timeScale(clampedStart);
+            const rawY1 = timeScale(clampedEnd);
+            const y0 = Math.min(rawY0, rawY1) + gap / 2;
+            const y1 = Math.max(rawY0, rawY1) - gap / 2;
+            const barHeight = y1 - y0;
+            if (barHeight <= 0)
+                continue;
+            if (hasCategories && categoryOrder) {
+                let cumulativeBase = 0;
+                let paletteIdx = 0;
+                for (const cat of categoryOrder) {
+                    const catVal = bin.categories.get(cat) || 0;
+                    if (catVal === 0)
+                        continue;
+                    const xLeft = valueScale(cumulativeBase);
+                    const xRight = valueScale(cumulativeBase + catVal);
+                    const rectX = Math.min(xLeft, xRight);
+                    const rectW = Math.abs(xRight - xLeft);
+                    ctx.fillStyle = (barColors && barColors[cat]) || DEFAULT_PALETTE[paletteIdx % DEFAULT_PALETTE.length];
+                    ctx.fillRect(rectX, y0, rectW, barHeight);
+                    if (hasBarStroke)
+                        ctx.strokeRect(rectX, y0, rectW, barHeight);
+                    cumulativeBase += catVal;
+                    paletteIdx++;
+                }
+            }
+            else {
+                const xZero = valueScale(0);
+                const xEnd = valueScale(bin.total);
+                const rectX = Math.min(xZero, xEnd);
+                const rectW = Math.abs(xEnd - xZero);
+                ctx.fillStyle = barStyle?.fill || style.stroke || "#007bff";
+                ctx.fillRect(rectX, y0, rectW, barHeight);
+                if (hasBarStroke)
+                    ctx.strokeRect(rectX, y0, rectW, barHeight);
+            }
+        }
+    }
+};
+exports.barRenderer = barRenderer;

package/ai/dist/src/components/realtime/renderers/candlestickRenderer.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.candlestickRenderer = void 0;
+const candlestickRenderer = () => {
+    throw new Error("candlestickRenderer: Not yet implemented");
+};
+exports.candlestickRenderer = candlestickRenderer;

package/ai/dist/src/components/realtime/renderers/lineRenderer.js

@@ -0,0 +1,164 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.lineRenderer = void 0;
+function resolveColor(value, thresholds, baseColor) {
+    let color = baseColor;
+    for (const t of thresholds) {
+        if (t.thresholdType === "lesser") {
+            if (value < t.value)
+                color = t.color;
+        }
+        else {
+            if (value > t.value)
+                color = t.color;
+        }
+    }
+    return color;
+}
+const lineRenderer = (ctx, data, scales, layout, style, accessors, annotations) => {
+    const { time: timeScale, value: valueScale } = scales;
+    const { timeAxis } = layout;
+    const { time: getTime, value: getValue } = accessors;
+    const baseColor = style.stroke || "#007bff";
+    // Extract color thresholds from annotations
+    const colorThresholds = annotations
+        ? annotations
+            .filter((a) => a.type === "threshold" && a.color)
+            .map((a) => ({
+            value: a.value,
+            color: a.color,
+            thresholdType: (a.thresholdType || "greater")
+        }))
+        : null;
+    const hasColorThresholds = colorThresholds && colorThresholds.length > 0;
+    // Fast path: no color thresholds — single-path draw, zero overhead
+    if (!hasColorThresholds) {
+        ctx.beginPath();
+        ctx.strokeStyle = baseColor;
+        ctx.lineWidth = style.strokeWidth || 2;
+        if (style.strokeDasharray) {
+            ctx.setLineDash(style.strokeDasharray.split(/[\s,]+/).map(Number));
+        }
+        else {
+            ctx.setLineDash([]);
+        }
+        let started = false;
+        for (const d of data) {
+            const t = getTime(d);
+            const v = getValue(d);
+            if (t == null || v == null || Number.isNaN(t) || Number.isNaN(v)) {
+                started = false;
+                continue;
+            }
+            const tPixel = timeScale(t);
+            const vPixel = valueScale(v);
+            const x = timeAxis === "x" ? tPixel : vPixel;
+            const y = timeAxis === "x" ? vPixel : tPixel;
+            if (!started) {
+                ctx.moveTo(x, y);
+                started = true;
+            }
+            else {
+                ctx.lineTo(x, y);
+            }
+        }
+        ctx.stroke();
+        return;
+    }
+    // Threshold mode: segment-based drawing
+    ctx.lineWidth = style.strokeWidth || 2;
+    if (style.strokeDasharray) {
+        ctx.setLineDash(style.strokeDasharray.split(/[\s,]+/).map(Number));
+    }
+    else {
+        ctx.setLineDash([]);
+    }
+    let prevX = null;
+    let prevY = null;
+    let prevValue = null;
+    let prevColor = null;
+    let pathStarted = false;
+    function toPixel(t, v) {
+        const tPixel = timeScale(t);
+        const vPixel = valueScale(v);
+        return timeAxis === "x" ? [tPixel, vPixel] : [vPixel, tPixel];
+    }
+    function startSegment(color, x, y) {
+        ctx.beginPath();
+        ctx.strokeStyle = color;
+        ctx.moveTo(x, y);
+        pathStarted = true;
+    }
+    function endSegment() {
+        if (pathStarted) {
+            ctx.stroke();
+            pathStarted = false;
+        }
+    }
+    for (const d of data) {
+        const t = getTime(d);
+        const v = getValue(d);
+        if (t == null || v == null || Number.isNaN(t) || Number.isNaN(v)) {
+            endSegment();
+            prevX = null;
+            prevY = null;
+            prevValue = null;
+            prevColor = null;
+            continue;
+        }
+        const [x, y] = toPixel(t, v);
+        const currColor = resolveColor(v, colorThresholds, baseColor);
+        if (prevX === null || prevColor === null || prevValue === null) {
+            // First valid point
+            startSegment(currColor, x, y);
+            prevX = x;
+            prevY = y;
+            prevValue = v;
+            prevColor = currColor;
+            continue;
+        }
+        if (currColor === prevColor) {
+            ctx.lineTo(x, y);
+        }
+        else {
+            // Find all thresholds crossed between prevValue and v, sorted by interpolation t
+            const crossings = [];
+            for (const threshold of colorThresholds) {
+                const tv = threshold.value;
+                // Check if the threshold value lies between prevValue and v
+                if ((prevValue <= tv && v >= tv) || (prevValue >= tv && v <= tv)) {
+                    // Don't add crossing at exact endpoints
+                    if (prevValue !== tv && v !== tv) {
+                        const interpT = (tv - prevValue) / (v - prevValue);
+                        crossings.push({ t: interpT, color: "" }); // color resolved after sorting
+                    }
+                }
+            }
+            // Sort crossings by interpolation parameter
+            crossings.sort((a, b) => a.t - b.t);
+            // Walk through crossings
+            let lastT = 0;
+            let runningColor = prevColor;
+            for (const crossing of crossings) {
+                const midX = prevX + (x - prevX) * crossing.t;
+                const midY = prevY + (y - prevY) * crossing.t;
+                // Determine value at crossing point to resolve next color
+                const midValue = prevValue + (v - prevValue) * crossing.t;
+                // Nudge slightly past the crossing to determine the color on the other side
+                const nudgedValue = prevValue + (v - prevValue) * Math.min(crossing.t + 0.0001, 1);
+                const nextColor = resolveColor(nudgedValue, colorThresholds, baseColor);
+                ctx.lineTo(midX, midY);
+                endSegment();
+                startSegment(nextColor, midX, midY);
+                runningColor = nextColor;
+            }
+            ctx.lineTo(x, y);
+        }
+        prevX = x;
+        prevY = y;
+        prevValue = v;
+        prevColor = currColor;
+    }
+    endSegment();
+};
+exports.lineRenderer = lineRenderer;

package/ai/dist/src/components/realtime/renderers/swarmRenderer.js

@@ -0,0 +1,91 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.swarmRenderer = void 0;
+const DEFAULT_PALETTE = [
+    "#007bff", "#28a745", "#dc3545", "#fd7e14", "#6f42c1",
+    "#20c997", "#e83e8c", "#17a2b8", "#6610f2", "#ffc107"
+];
+function resolveColor(value, thresholds, baseColor) {
+    let color = baseColor;
+    for (const t of thresholds) {
+        if (t.thresholdType === "lesser") {
+            if (value < t.value)
+                color = t.color;
+        }
+        else {
+            if (value > t.value)
+                color = t.color;
+        }
+    }
+    return color;
+}
+const swarmRenderer = (ctx, data, scales, layout, style, accessors, annotations, options) => {
+    const { time: timeScale, value: valueScale } = scales;
+    const { timeAxis } = layout;
+    const { time: getTime, value: getValue, category: getCategory } = accessors;
+    const ss = options?.swarmStyle;
+    const barColors = options?.barColors;
+    const radius = ss?.radius ?? 3;
+    const defaultFill = ss?.fill ?? style.stroke ?? "#007bff";
+    const opacity = ss?.opacity ?? 0.7;
+    const hasStroke = ss?.stroke != null;
+    // Extract color thresholds from annotations
+    const colorThresholds = annotations
+        ? annotations
+            .filter((a) => a.type === "threshold" && a.color)
+            .map((a) => ({
+            value: a.value,
+            color: a.color,
+            thresholdType: (a.thresholdType || "greater")
+        }))
+        : null;
+    const hasColorThresholds = colorThresholds && colorThresholds.length > 0;
+    ctx.globalAlpha = opacity;
+    let paletteIndex = 0;
+    const categoryColorCache = {};
+    for (const d of data) {
+        const t = getTime(d);
+        const v = getValue(d);
+        if (v == null || Number.isNaN(v))
+            continue;
+        let x, y;
+        if (timeAxis === "x") {
+            x = timeScale(t);
+            y = valueScale(v);
+        }
+        else {
+            x = valueScale(v);
+            y = timeScale(t);
+        }
+        // Determine fill color
+        let fill = defaultFill;
+        if (getCategory) {
+            const cat = getCategory(d);
+            if (barColors && barColors[cat]) {
+                fill = barColors[cat];
+            }
+            else {
+                if (!(cat in categoryColorCache)) {
+                    categoryColorCache[cat] = DEFAULT_PALETTE[paletteIndex % DEFAULT_PALETTE.length];
+                    paletteIndex++;
+                }
+                fill = categoryColorCache[cat];
+            }
+        }
+        // Threshold coloring overrides category/default fill
+        if (hasColorThresholds) {
+            fill = resolveColor(v, colorThresholds, fill);
+        }
+        ctx.fillStyle = fill;
+        ctx.beginPath();
+        ctx.arc(x, y, radius, 0, Math.PI * 2);
+        ctx.fill();
+        if (hasStroke) {
+            ctx.strokeStyle = ss.stroke;
+            ctx.lineWidth = ss?.strokeWidth ?? 1;
+            ctx.stroke();
+        }
+    }
+    ctx.globalAlpha = 1;
+};
+exports.swarmRenderer = swarmRenderer;

package/ai/dist/src/components/realtime/renderers/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/ai/dist/src/components/realtime/renderers/waterfallRenderer.js

@@ -0,0 +1,163 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.waterfallRenderer = void 0;
+exports.computeWaterfallExtent = computeWaterfallExtent;
+const DEFAULT_POSITIVE_COLOR = "#28a745";
+const DEFAULT_NEGATIVE_COLOR = "#dc3545";
+function computeWaterfallExtent(data, getValue) {
+    let min = 0;
+    let max = 0;
+    let cumulative = 0;
+    for (const d of data) {
+        const v = getValue(d);
+        if (v == null || Number.isNaN(v))
+            continue;
+        cumulative += v;
+        if (cumulative < min)
+            min = cumulative;
+        if (cumulative > max)
+            max = cumulative;
+    }
+    return [min, max];
+}
+const waterfallRenderer = (ctx, data, scales, layout, style, accessors, annotations, options) => {
+    const { time: timeScale, value: valueScale } = scales;
+    const { timeAxis, width, height } = layout;
+    const { time: getTime, value: getValue } = accessors;
+    const ws = options?.waterfallStyle;
+    const positiveColor = ws?.positiveColor ?? DEFAULT_POSITIVE_COLOR;
+    const negativeColor = ws?.negativeColor ?? DEFAULT_NEGATIVE_COLOR;
+    const gap = ws?.gap ?? 1;
+    const connectorStroke = ws?.connectorStroke;
+    const connectorWidth = ws?.connectorWidth ?? 1;
+    const hasStroke = ws?.stroke != null;
+    if (hasStroke) {
+        ctx.strokeStyle = ws.stroke;
+        ctx.lineWidth = ws?.strokeWidth ?? 1;
+    }
+    // Collect into array for random access (skip NaN/null values)
+    const arr = [];
+    for (const d of data) {
+        const v = getValue(d);
+        if (v == null || Number.isNaN(v))
+            continue;
+        arr.push(d);
+    }
+    if (arr.length === 0)
+        return;
+    let baseline = 0;
+    // Track the end edge of the previous bar and its cumulative value for connectors
+    let prevEdge = null;
+    let prevCumulative = null;
+    for (let i = 0; i < arr.length; i++) {
+        const d = arr[i];
+        const t = getTime(d);
+        const delta = getValue(d);
+        const cumEnd = baseline + delta;
+        // Compute bar width from time gap to next point
+        let barWidthTime;
+        if (i < arr.length - 1) {
+            barWidthTime = getTime(arr[i + 1]) - t;
+        }
+        else if (i > 0) {
+            barWidthTime = t - getTime(arr[i - 1]);
+        }
+        else {
+            // Single point fallback: use 0 to trigger pixel fallback
+            barWidthTime = 0;
+        }
+        ctx.fillStyle = delta >= 0 ? positiveColor : negativeColor;
+        if (timeAxis === "x") {
+            let rawX0, rawX1;
+            if (barWidthTime !== 0) {
+                rawX0 = timeScale(t);
+                rawX1 = timeScale(t + barWidthTime);
+            }
+            else {
+                rawX0 = timeScale(t);
+                rawX1 = rawX0 + width / 10;
+            }
+            const x0 = Math.min(rawX0, rawX1) + gap / 2;
+            const x1 = Math.max(rawX0, rawX1) - gap / 2;
+            const barWidth = x1 - x0;
+            if (barWidth <= 0) {
+                baseline = cumEnd;
+                prevEdge = x1;
+                prevCumulative = cumEnd;
+                continue;
+            }
+            const yBaseline = valueScale(baseline);
+            const yTop = valueScale(cumEnd);
+            const rectY = Math.min(yBaseline, yTop);
+            const rectH = Math.abs(yBaseline - yTop);
+            // Connector line at the baseline level from previous bar's right edge to this bar's left edge
+            if (connectorStroke && prevEdge != null && prevCumulative != null) {
+                ctx.save();
+                ctx.strokeStyle = connectorStroke;
+                ctx.lineWidth = connectorWidth;
+                const connY = valueScale(prevCumulative);
+                ctx.beginPath();
+                ctx.moveTo(prevEdge, connY);
+                ctx.lineTo(x0, connY);
+                ctx.stroke();
+                ctx.restore();
+                if (hasStroke) {
+                    ctx.strokeStyle = ws.stroke;
+                    ctx.lineWidth = ws?.strokeWidth ?? 1;
+                }
+            }
+            ctx.fillRect(x0, rectY, barWidth, rectH);
+            if (hasStroke)
+                ctx.strokeRect(x0, rectY, barWidth, rectH);
+            prevEdge = x1;
+        }
+        else {
+            // timeAxis === "y": horizontal bars
+            let rawY0, rawY1;
+            if (barWidthTime !== 0) {
+                rawY0 = timeScale(t);
+                rawY1 = timeScale(t + barWidthTime);
+            }
+            else {
+                rawY0 = timeScale(t);
+                rawY1 = rawY0 + height / 10;
+            }
+            const y0 = Math.min(rawY0, rawY1) + gap / 2;
+            const y1 = Math.max(rawY0, rawY1) - gap / 2;
+            const barHeight = y1 - y0;
+            if (barHeight <= 0) {
+                baseline = cumEnd;
+                prevEdge = y1;
+                prevCumulative = cumEnd;
+                continue;
+            }
+            const xBaseline = valueScale(baseline);
+            const xEnd = valueScale(cumEnd);
+            const rectX = Math.min(xBaseline, xEnd);
+            const rectW = Math.abs(xEnd - xBaseline);
+            // Connector line at the baseline level from previous bar's bottom edge to this bar's top edge
+            if (connectorStroke && prevEdge != null && prevCumulative != null) {
+                ctx.save();
+                ctx.strokeStyle = connectorStroke;
+                ctx.lineWidth = connectorWidth;
+                const connX = valueScale(prevCumulative);
+                ctx.beginPath();
+                ctx.moveTo(connX, prevEdge);
+                ctx.lineTo(connX, y0);
+                ctx.stroke();
+                ctx.restore();
+                if (hasStroke) {
+                    ctx.strokeStyle = ws.stroke;
+                    ctx.lineWidth = ws?.strokeWidth ?? 1;
+                }
+            }
+            ctx.fillRect(rectX, y0, rectW, barHeight);
+            if (hasStroke)
+                ctx.strokeRect(rectX, y0, rectW, barHeight);
+            prevEdge = y1;
+        }
+        baseline = cumEnd;
+        prevCumulative = cumEnd;
+    }
+};
+exports.waterfallRenderer = waterfallRenderer;

package/ai/dist/src/components/realtime/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });