dotdo 0.0.1 → 0.0.2

package/dist/workflows/data/stream/index.js

@@ -0,0 +1,1215 @@
+/**
+ * Stream Processing API ($.stream)
+ *
+ * Provides real-time stream processing capabilities:
+ * - Stream sources from domain events, tracked events, and measurements
+ * - Transformations: filter(), map(), enrich(), flatMap()
+ * - Keyed streams via keyBy()
+ * - Windowing: tumbling, sliding, session windows
+ * - Aggregations within windows
+ * - Stream joins with temporal constraints
+ * - Sinks to track, measure, and view
+ *
+ * @module workflows/data/stream
+ */
+import { toMillis } from '../../../db/primitives/utils/duration';
+// ============================================================================
+// Implementation
+// ============================================================================
+class StreamImpl {
+    type = 'stream';
+    source;
+    sink;
+    bufferCapacity;
+    bufferStrategy;
+    subscribers = [];
+    errorHandlers = [];
+    deadLetterHandlers = [];
+    forEachHandler;
+    running = false; // Streams don't run until explicitly started
+    streamName;
+    maxRetries = 0;
+    _bufferCapacity = Infinity;
+    _bufferStrategy = 'dropOldest';
+    _buffer = []; // Renamed to avoid conflict with buffer() method
+    throttleMs = 0;
+    lastEmitTime = 0;
+    throttleQueue = [];
+    throttleTimer = null;
+    ctx;
+    pipeline = [];
+    keyedSubscribers = [];
+    started = false; // Track if start() was called
+    isRoot = true; // Whether this is a root stream (receives from emit directly)
+    parentStream; // Parent stream for child streams
+    pendingOperations = []; // Track pending async operations
+    constructor(source, ctx, parent) {
+        this.source = Object.freeze({ ...source });
+        this.ctx = ctx;
+        if (parent) {
+            this.isRoot = false;
+            this.parentStream = parent;
+        }
+    }
+    isRootStream() {
+        return this.isRoot;
+    }
+    filter(predicate) {
+        const newStream = new StreamImpl(this.source, this.ctx, this);
+        newStream.pipeline.push(async (item) => {
+            const result = await predicate(item);
+            if (!result)
+                return Symbol.for('skip');
+            return item;
+        });
+        // Subscribe to parent to receive items, tracking async operations
+        this.subscribe((item) => {
+            const op = newStream.processItem(item);
+            newStream.pendingOperations.push(op);
+        });
+        this.ctx.registerStream(newStream);
+        return newStream;
+    }
+    map(fn) {
+        const newStream = new StreamImpl(this.source, this.ctx, this);
+        newStream.pipeline.push(async (item) => {
+            return await fn(item);
+        });
+        // Subscribe to parent to receive items, tracking async operations
+        this.subscribe((item) => {
+            const op = newStream.processItem(item);
+            newStream.pendingOperations.push(op);
+        });
+        this.ctx.registerStream(newStream);
+        return newStream;
+    }
+    flatMap(fn) {
+        const newStream = new StreamImpl(this.source, this.ctx, this);
+        newStream.pipeline.push(async (item) => {
+            const result = await fn(item);
+            return { __flatMap: result };
+        });
+        // Subscribe to parent to receive items, tracking async operations
+        this.subscribe((item) => {
+            const op = newStream.processItem(item);
+            newStream.pendingOperations.push(op);
+        });
+        this.ctx.registerStream(newStream);
+        return newStream;
+    }
+    enrich(fn) {
+        const newStream = new StreamImpl(this.source, this.ctx, this);
+        newStream.pipeline.push(async (item) => {
+            return await fn(item, this.ctx);
+        });
+        // Subscribe to parent to receive items, tracking async operations
+        this.subscribe((item) => {
+            const op = newStream.processItem(item);
+            newStream.pendingOperations.push(op);
+        });
+        this.ctx.registerStream(newStream);
+        return newStream;
+    }
+    keyBy(keyOrFn) {
+        return new KeyedStreamImpl(this, keyOrFn, this.ctx);
+    }
+    // These methods exist to provide helpful error messages
+    join() {
+        throw new Error('join() requires a keyed stream. Call keyBy() first.');
+    }
+    leftJoin() {
+        throw new Error('leftJoin() requires a keyed stream. Call keyBy() first.');
+    }
+    coGroup() {
+        throw new Error('coGroup() requires a keyed stream. Call keyBy() first.');
+    }
+    get window() {
+        // For non-keyed streams, use global key
+        const globalKeyedStream = new KeyedStreamImpl(this, () => '__global__', this.ctx);
+        return {
+            tumbling: (size) => {
+                const ws = globalKeyedStream.window.tumbling(size);
+                ws.key = '__global__';
+                return ws;
+            },
+            sliding: (size, slide) => globalKeyedStream.window.sliding(size, slide),
+            session: (gap) => globalKeyedStream.window.session(gap),
+        };
+    }
+    subscribe(fn) {
+        this.subscribers.push(fn);
+        // Auto-start when subscribed (implicit running) unless explicitly stopped
+        if (!this.started) {
+            this.running = true;
+        }
+        return () => {
+            const idx = this.subscribers.indexOf(fn);
+            if (idx !== -1)
+                this.subscribers.splice(idx, 1);
+        };
+    }
+    forEach(fn) {
+        this.forEachHandler = fn;
+        // Auto-start when forEach is called
+        if (!this.started) {
+            this.running = true;
+        }
+        return this;
+    }
+    async flush() {
+        // First, flush parent stream if we have one (to ensure upstream items flow through)
+        if (this.parentStream) {
+            await this.parentStream.flush();
+        }
+        // Wait for all pending async operations on THIS stream
+        // Keep flushing until no more pending operations (items may chain through)
+        while (this.pendingOperations.length > 0) {
+            const ops = this.pendingOperations;
+            this.pendingOperations = [];
+            await Promise.all(ops);
+        }
+        // Advance time to trigger window closes
+        this.ctx.advanceTime(Date.now());
+        // Process any throttled items
+        if (this.throttleTimer) {
+            clearTimeout(this.throttleTimer);
+            this.throttleTimer = null;
+        }
+        for (const item of this.throttleQueue) {
+            await this.deliverItem(item, true); // Skip throttle when flushing
+        }
+        this.throttleQueue = [];
+        // Deliver buffered items
+        if (this._buffer.length > 0) {
+            const items = [...this._buffer];
+            this._buffer = [];
+            for (const item of items) {
+                for (const subscriber of this.subscribers) {
+                    subscriber(item);
+                }
+                if (this.forEachHandler) {
+                    await this.forEachHandler(item);
+                }
+                // Also deliver to sinks
+                if (this.sink) {
+                    if (this.sink.type === 'track' && this.sink.event) {
+                        const handlers = this.ctx.getTrackHandlers(this.sink.event);
+                        for (const handler of handlers) {
+                            handler(item);
+                        }
+                    }
+                    else if (this.sink.type === 'measure' && this.sink.metric) {
+                        const handlers = this.ctx.getMeasureHandlers(this.sink.metric);
+                        for (const handler of handlers) {
+                            const value = typeof item === 'number' ? item : item?.value ?? 0;
+                            const labels = item?.labels ?? {};
+                            handler(value, labels);
+                        }
+                    }
+                }
+            }
+        }
+    }
+    async start() {
+        this.started = true;
+        this.running = true;
+    }
+    async stop() {
+        this.running = false;
+    }
+    isRunning() {
+        return this.started && this.running;
+    }
+    name(n) {
+        this.streamName = n;
+        this.ctx.namedStreams.set(n, this);
+        return this;
+    }
+    getName() {
+        return this.streamName;
+    }
+    onError(handler) {
+        this.errorHandlers.push(handler);
+        return this;
+    }
+    deadLetter(handler) {
+        this.deadLetterHandlers.push(handler);
+        return this;
+    }
+    retry(maxRetries) {
+        this.maxRetries = maxRetries;
+        return this;
+    }
+    buffer(capacity, options) {
+        this._bufferCapacity = capacity;
+        this.bufferCapacity = capacity;
+        this._bufferStrategy = options?.strategy ?? 'dropOldest';
+        this.bufferStrategy = this._bufferStrategy;
+        return this;
+    }
+    throttle(interval) {
+        this.throttleMs = toMillis(interval);
+        return this;
+    }
+    get to() {
+        const self = this;
+        return {
+            track: new Proxy({}, {
+                get(_, event) {
+                    self.sink = { type: 'track', event };
+                    self.ctx.registerSinkStream(self, 'track', event);
+                    return self;
+                },
+            }),
+            measure: new Proxy({}, {
+                get(_, metric) {
+                    self.sink = { type: 'measure', metric };
+                    self.ctx.registerSinkStream(self, 'measure', metric);
+                    return self;
+                },
+            }),
+            view: new Proxy({}, {
+                get(_, view) {
+                    self.sink = { type: 'view', view };
+                    self.ctx.registerSinkStream(self, 'view', view);
+                    return self;
+                },
+            }),
+        };
+    }
+    async processItem(item) {
+        // If explicitly stopped (started = true but running = false), don't process
+        if (this.started && !this.running) {
+            return;
+        }
+        // Otherwise, process if:
+        // - root stream (always processes unless explicitly stopped)
+        // - has subscribers
+        // - has forEachHandler
+        // - has pipeline (predicates/transforms to run for side effects like spying)
+        if (!this.isRoot && this.subscribers.length === 0 && !this.forEachHandler && this.pipeline.length === 0) {
+            return;
+        }
+        let current = item;
+        let attempts = 0;
+        const maxAttempts = this.maxRetries + 1;
+        while (attempts < maxAttempts) {
+            try {
+                // Process through pipeline
+                for (const step of this.pipeline) {
+                    current = await step(current);
+                    if (current === Symbol.for('skip'))
+                        return;
+                    if (current && typeof current === 'object' && '__flatMap' in current) {
+                        const items = current.__flatMap;
+                        for (const flatItem of items) {
+                            await this.deliverItem(flatItem);
+                        }
+                        return;
+                    }
+                }
+                await this.deliverItem(current);
+                return;
+            }
+            catch (error) {
+                attempts++;
+                if (attempts >= maxAttempts) {
+                    for (const handler of this.errorHandlers) {
+                        handler(error);
+                    }
+                    for (const handler of this.deadLetterHandlers) {
+                        handler(item, error);
+                    }
+                }
+            }
+        }
+    }
+    async deliverItem(item, skipThrottle = false) {
+        // Handle throttling (skipped when flushing throttled items)
+        if (this.throttleMs > 0 && !skipThrottle) {
+            const now = Date.now();
+            if (now - this.lastEmitTime < this.throttleMs) {
+                this.throttleQueue.push(item);
+                if (!this.throttleTimer) {
+                    this.throttleTimer = setTimeout(() => {
+                        const next = this.throttleQueue.shift();
+                        if (next)
+                            this.deliverItem(next, true);
+                        this.throttleTimer = null;
+                    }, this.throttleMs - (now - this.lastEmitTime));
+                }
+                return;
+            }
+            this.lastEmitTime = now;
+        }
+        // Handle buffering - buffer items and deliver on flush
+        if (this._bufferCapacity < Infinity) {
+            this._buffer.push(item);
+            if (this._buffer.length > this._bufferCapacity) {
+                if (this._bufferStrategy === 'dropOldest') {
+                    this._buffer.shift();
+                }
+                else {
+                    this._buffer.pop(); // Remove the item we just pushed (newest)
+                }
+            }
+            // When buffering, don't deliver immediately - wait for flush
+            return;
+        }
+        for (const subscriber of this.subscribers) {
+            subscriber(item);
+        }
+        if (this.forEachHandler) {
+            await this.forEachHandler(item);
+        }
+        // Deliver to sink if configured
+        if (this.sink) {
+            if (this.sink.type === 'track' && this.sink.event) {
+                const handlers = this.ctx.getTrackHandlers(this.sink.event);
+                for (const handler of handlers) {
+                    handler(item);
+                }
+            }
+            else if (this.sink.type === 'measure' && this.sink.metric) {
+                const handlers = this.ctx.getMeasureHandlers(this.sink.metric);
+                for (const handler of handlers) {
+                    // For measure sinks, extract value and labels from the item
+                    const value = typeof item === 'number' ? item : item?.value ?? 0;
+                    const labels = item?.labels ?? {};
+                    handler(value, labels);
+                }
+            }
+            else if (this.sink.type === 'view' && this.sink.view) {
+                const handlers = this.ctx.getViewHandlers(this.sink.view);
+                for (const handler of handlers) {
+                    handler(item);
+                }
+            }
+        }
+    }
+}
+class KeyedStreamImpl {
+    type = 'keyed-stream';
+    keySelector;
+    parentStream;
+    ctx;
+    subscribers = [];
+    timestampSubscribers = [];
+    constructor(parent, keySelector, ctx) {
+        this.parentStream = parent;
+        this.keySelector = keySelector;
+        this.ctx = ctx;
+        // Subscribe to parent stream to get transformed items
+        this.parentStream.subscribe((item) => {
+            // Get timestamp from item if available, otherwise use current time
+            const timestamp = item?.timestamp ?? Date.now();
+            this.processItem(item, timestamp);
+        });
+        this.ctx.registerKeyedStream(this);
+    }
+    getKey(item) {
+        if (typeof this.keySelector === 'string') {
+            return item[this.keySelector];
+        }
+        return this.keySelector(item);
+    }
+    get window() {
+        return {
+            tumbling: (size) => {
+                const sizeMs = toMillis(size);
+                return new WindowedStreamImpl(this, { type: 'tumbling', size: sizeMs }, this.ctx);
+            },
+            sliding: (size, slide) => {
+                const sizeMs = toMillis(size);
+                const slideMs = toMillis(slide);
+                if (slideMs > sizeMs) {
+                    throw new Error('Slide cannot be larger than size');
+                }
+                return new WindowedStreamImpl(this, { type: 'sliding', size: sizeMs, slide: slideMs }, this.ctx);
+            },
+            session: (gap) => {
+                const gapMs = toMillis(gap);
+                return new WindowedStreamImpl(this, { type: 'session', gap: gapMs }, this.ctx);
+            },
+        };
+    }
+    join(other) {
+        return new JoinBuilderImpl(this, other, 'inner', this.ctx);
+    }
+    leftJoin(other) {
+        return new JoinBuilderImpl(this, other, 'left', this.ctx);
+    }
+    coGroup(other) {
+        return new CoGroupBuilderImpl(this, other, this.ctx);
+    }
+    subscribe(fn) {
+        this.subscribers.push(fn);
+        return () => {
+            const idx = this.subscribers.indexOf(fn);
+            if (idx !== -1)
+                this.subscribers.splice(idx, 1);
+        };
+    }
+    subscribeWithTimestamp(fn) {
+        this.timestampSubscribers.push(fn);
+        return () => {
+            const idx = this.timestampSubscribers.indexOf(fn);
+            if (idx !== -1)
+                this.timestampSubscribers.splice(idx, 1);
+        };
+    }
+    async flush() {
+        await this.parentStream.flush();
+    }
+    processItem(item, timestamp) {
+        const key = this.getKey(item);
+        const ts = timestamp ?? item?.timestamp ?? Date.now();
+        for (const subscriber of this.subscribers) {
+            subscriber(item, key);
+        }
+        for (const subscriber of this.timestampSubscribers) {
+            subscriber(item, key, ts);
+        }
+    }
+}
+class WindowedStreamImpl {
+    type = 'windowed-stream';
+    window;
+    key;
+    keyedStream;
+    ctx;
+    windowCloseHandlers = [];
+    windowState = new Map();
+    subscribers = [];
+    aggregateSpec;
+    reduceSpec;
+    constructor(keyedStream, windowSpec, ctx) {
+        this.keyedStream = keyedStream;
+        this.window = windowSpec;
+        this.ctx = ctx;
+        // Subscribe to keyed stream to receive items
+        this.keyedStream.subscribeWithTimestamp((item, key, timestamp) => {
+            this.processItem(item, timestamp);
+        });
+        this.ctx.registerWindowedStream(this);
+    }
+    aggregate(spec) {
+        this.aggregateSpec = spec;
+        return new AggregatedStreamImpl(this, this.ctx);
+    }
+    reduce(reducer, initial) {
+        this.reduceSpec = { reducer: reducer, initial };
+        return new AggregatedStreamImpl(this, this.ctx);
+    }
+    onWindowClose(handler) {
+        this.windowCloseHandlers.push(handler);
+    }
+    subscribe(fn) {
+        this.subscribers.push(fn);
+        return () => {
+            const idx = this.subscribers.indexOf(fn);
+            if (idx !== -1)
+                this.subscribers.splice(idx, 1);
+        };
+    }
+    async flush() {
+        // Trigger window close for all pending windows
+        for (const [windowKey, state] of this.windowState.entries()) {
+            const [key] = windowKey.split('|');
+            const windowInfo = this.computeWindowInfo(state.lastTimestamp);
+            for (const handler of this.windowCloseHandlers) {
+                handler(key, state.elements, windowInfo);
+            }
+        }
+        this.windowState.clear();
+    }
+    computeWindowInfo(timestamp) {
+        if (this.window.type === 'tumbling') {
+            const size = this.window.size;
+            const start = Math.floor(timestamp / size) * size;
+            return { start, end: start + size };
+        }
+        else if (this.window.type === 'sliding') {
+            const size = this.window.size;
+            const slide = this.window.slide;
+            const start = Math.floor(timestamp / slide) * slide;
+            return { start, end: start + size };
+        }
+        else {
+            // Session - approximate based on elements
+            return { start: timestamp, end: timestamp + (this.window.gap || 0) };
+        }
+    }
+    processItem(item, timestamp) {
+        const key = this.keyedStream.getKey(item);
+        const windowKeys = this.getWindowKeys(key, timestamp);
+        for (const windowKey of windowKeys) {
+            let state = this.windowState.get(windowKey);
+            if (!state) {
+                state = { elements: [], lastTimestamp: timestamp };
+                this.windowState.set(windowKey, state);
+            }
+            state.elements.push(item);
+            state.lastTimestamp = Math.max(state.lastTimestamp, timestamp);
+        }
+        for (const subscriber of this.subscribers) {
+            subscriber(item, key);
+        }
+    }
+    getWindowKeys(key, timestamp) {
+        if (this.window.type === 'tumbling') {
+            const size = this.window.size;
+            const windowStart = Math.floor(timestamp / size) * size;
+            return [`${key}|${windowStart}`];
+        }
+        else if (this.window.type === 'session') {
+            // For session windows, check if we should start a new session
+            const gap = this.window.gap;
+            // Find the current session for this key (if any)
+            let currentSession = null;
+            let currentLastTimestamp = -Infinity;
+            for (const [windowKey, state] of this.windowState.entries()) {
+                if (windowKey.startsWith(`${key}|session_`)) {
+                    if (state.lastTimestamp > currentLastTimestamp) {
+                        currentSession = windowKey;
+                        currentLastTimestamp = state.lastTimestamp;
+                    }
+                }
+            }
+            // If there's no current session, or the gap is too large, start a new session
+            if (currentSession === null || timestamp - currentLastTimestamp > gap) {
+                return [`${key}|session_${timestamp}`];
+            }
+            // Otherwise, add to the current session
+            return [currentSession];
+        }
+        else {
+            // Sliding window: item belongs to all windows where windowStart <= timestamp < windowStart + size
+            const size = this.window.size;
+            const slide = this.window.slide;
+            const keys = [];
+            // Find the earliest window that could contain this timestamp
+            // Window starts at multiples of slide
+            const earliestWindowStart = Math.floor((timestamp - size + 1) / slide) * slide;
+            const latestWindowStart = Math.floor(timestamp / slide) * slide;
+            for (let windowStart = Math.max(0, earliestWindowStart); windowStart <= latestWindowStart; windowStart += slide) {
+                if (timestamp >= windowStart && timestamp < windowStart + size) {
+                    keys.push(`${key}|${windowStart}`);
+                }
+            }
+            return keys;
+        }
+    }
+    triggerWindowClose(currentTime) {
+        const windowsToClose = [];
+        for (const [windowKey, state] of this.windowState.entries()) {
+            const [key, windowId] = windowKey.split('|');
+            let shouldClose = false;
+            let windowInfo;
+            if (this.window.type === 'tumbling') {
+                const size = this.window.size;
+                const windowStart = parseInt(windowId);
+                const windowEnd = windowStart + size;
+                windowInfo = { start: windowStart, end: windowEnd };
+                shouldClose = currentTime >= windowEnd;
+            }
+            else if (this.window.type === 'sliding') {
+                const size = this.window.size;
+                const slide = this.window.slide;
+                const windowStart = parseInt(windowId);
+                const windowEnd = windowStart + size;
+                windowInfo = { start: windowStart, end: windowEnd };
+                shouldClose = currentTime >= windowEnd;
+            }
+            else {
+                // Session
+                const gap = this.window.gap;
+                windowInfo = { start: state.lastTimestamp - gap, end: state.lastTimestamp + gap };
+                shouldClose = currentTime >= state.lastTimestamp + gap;
+            }
+            if (shouldClose) {
+                windowsToClose.push({ key, windowKey, state });
+            }
+        }
+        for (const { key, windowKey, state } of windowsToClose) {
+            const windowInfo = this.computeWindowInfo(state.lastTimestamp);
+            for (const handler of this.windowCloseHandlers) {
+                handler(key, state.elements, windowInfo);
+            }
+            this.windowState.delete(windowKey);
+        }
+    }
+    getAggregateSpec() {
+        return this.aggregateSpec;
+    }
+    getReduceSpec() {
+        return this.reduceSpec;
+    }
+    getWindowState() {
+        return this.windowState;
+    }
+    getKeyedStream() {
+        return this.keyedStream;
+    }
+}
+class AggregatedStreamImpl {
+    type = 'stream';
+    sink;
+    windowedStream;
+    ctx;
+    subscribers = [];
+    mapFn;
+    constructor(windowedStream, ctx) {
+        this.windowedStream = windowedStream;
+        this.ctx = ctx;
+        this.ctx.registerAggregatedStream(this);
+    }
+    map(fn) {
+        const newStream = new AggregatedStreamImpl(this.windowedStream, this.ctx);
+        const prevMapFn = this.mapFn;
+        newStream.mapFn = (item) => {
+            const prev = prevMapFn ? prevMapFn(item) : item;
+            return fn(prev);
+        };
+        return newStream;
+    }
+    subscribe(fn) {
+        this.subscribers.push(fn);
+        return () => {
+            const idx = this.subscribers.indexOf(fn);
+            if (idx !== -1)
+                this.subscribers.splice(idx, 1);
+        };
+    }
+    async flush() {
+        // Advance time to trigger window closes
+        this.ctx.advanceTime(Date.now());
+        await this.windowedStream.flush();
+    }
+    get to() {
+        const self = this;
+        return {
+            track: new Proxy({}, {
+                get(_, event) {
+                    self.sink = { type: 'track', event };
+                    return self;
+                },
+            }),
+            measure: new Proxy({}, {
+                get(_, metric) {
+                    self.sink = { type: 'measure', metric };
+                    self.ctx.registerAggregatedSink(self, 'measure', metric);
+                    return self;
+                },
+            }),
+            view: new Proxy({}, {
+                get(_, view) {
+                    self.sink = { type: 'view', view };
+                    self.ctx.registerAggregatedSink(self, 'view', view);
+                    return self;
+                },
+            }),
+        };
+    }
+    emitResult(result, key, info) {
+        let finalResult = result;
+        if (this.mapFn) {
+            finalResult = this.mapFn(result);
+        }
+        for (const subscriber of this.subscribers) {
+            subscriber(finalResult, key, info);
+        }
+    }
+    getWindowedStream() {
+        return this.windowedStream;
+    }
+}
+class JoinBuilderImpl {
+    type = 'joined-stream';
+    window;
+    leftStream;
+    rightStream;
+    joinType;
+    ctx;
+    constructor(left, right, joinType, ctx) {
+        this.leftStream = left;
+        this.rightStream = right;
+        this.joinType = joinType;
+        this.ctx = ctx;
+    }
+    within(duration) {
+        this.window = toMillis(duration);
+        return this;
+    }
+    on(fn) {
+        const newStream = new StreamImpl({ type: 'domain' }, this.ctx);
+        this.ctx.registerJoin(this.leftStream, this.rightStream, this.window ?? Infinity, this.joinType, fn, newStream);
+        return newStream;
+    }
+}
+class CoGroupBuilderImpl {
+    type = 'joined-stream';
+    window;
+    leftStream;
+    rightStream;
+    ctx;
+    constructor(left, right, ctx) {
+        this.leftStream = left;
+        this.rightStream = right;
+        this.ctx = ctx;
+    }
+    within(duration) {
+        this.window = toMillis(duration);
+        return this;
+    }
+    apply(fn) {
+        const newStream = new StreamImpl({ type: 'domain' }, this.ctx);
+        this.ctx.registerCoGroup(this.leftStream, this.rightStream, this.window ?? Infinity, fn, newStream);
+        return newStream;
+    }
+}
+// ============================================================================
+// Stream Context Implementation
+// ============================================================================
+class StreamContextImpl {
+    _storage = {
+        customers: new Map(),
+    };
+    trackHandlers = new Map();
+    measureHandlers = new Map();
+    entityActionHandlers = new Map();
+    streams = [];
+    keyedStreams = [];
+    windowedStreams = [];
+    aggregatedStreams = [];
+    namedStreams = new Map();
+    eventBuffer = new Map();
+    trackEventBuffer = new Map();
+    // Sink streams
+    sinkStreams = new Map();
+    aggregatedSinks = new Map();
+    // Joins
+    joins = [];
+    coGroups = [];
+    // Views storage
+    viewData = new Map();
+    _hooks = {
+        onTrack: (event, handler) => {
+            if (!this.trackHandlers.has(event))
+                this.trackHandlers.set(event, []);
+            this.trackHandlers.get(event).push(handler);
+        },
+        onMeasure: (metric, handler) => {
+            if (!this.measureHandlers.has(metric))
+                this.measureHandlers.set(metric, []);
+            this.measureHandlers.get(metric).push(handler);
+        },
+        onEntityAction: (entity, action, handler) => {
+            const key = `${entity}.${action}`;
+            if (!this.entityActionHandlers.has(key))
+                this.entityActionHandlers.set(key, []);
+            this.entityActionHandlers.get(key).push(handler);
+        },
+    };
+    // Handler getters for sink delivery
+    getTrackHandlers(event) {
+        return this.trackHandlers.get(event) ?? [];
+    }
+    getMeasureHandlers(metric) {
+        return this.measureHandlers.get(metric) ?? [];
+    }
+    getViewHandlers(view) {
+        // View handlers not currently implemented, return empty array
+        return [];
+    }
+    stream = {
+        from: new Proxy({}, {
+            get: (_, entity) => {
+                if (entity === 'track') {
+                    return new Proxy({}, {
+                        get: (_, event) => {
+                            const stream = new StreamImpl({ type: 'track', event }, this);
+                            this.registerStream(stream);
+                            return stream;
+                        },
+                    });
+                }
+                if (entity === 'measure') {
+                    return new Proxy({}, {
+                        get: (_, metric) => {
+                            const stream = new StreamImpl({ type: 'measure', metric }, this);
+                            this.registerStream(stream);
+                            return stream;
+                        },
+                    });
+                }
+                return new Proxy({}, {
+                    get: (_, event) => {
+                        const stream = new StreamImpl({ type: 'domain', entity, event }, this);
+                        this.registerStream(stream);
+                        return stream;
+                    },
+                });
+            },
+        }),
+        emit: async (entity, event, data) => {
+            const timestamp = data?.timestamp ?? Date.now();
+            if (entity === 'track') {
+                const eventKey = event;
+                if (!this.trackEventBuffer.has(eventKey)) {
+                    this.trackEventBuffer.set(eventKey, []);
+                }
+                this.trackEventBuffer.get(eventKey).push({ data, timestamp });
+                // Process through streams
+                for (const stream of this.streams) {
+                    if (stream.source.type === 'track' && stream.source.event === event) {
+                        await stream.processItem(data);
+                    }
+                }
+                // Don't return - continue to process joins and coGroups below
+            }
+            else {
+                // Domain events
+                const eventKey = `${entity}.${event}`;
+                if (!this.eventBuffer.has(eventKey)) {
+                    this.eventBuffer.set(eventKey, []);
+                }
+                this.eventBuffer.get(eventKey).push({ data, timestamp });
+                // Process through ROOT streams only (child streams get data via parent subscription)
+                for (const stream of this.streams) {
+                    // Check if this stream matches the emit
+                    const isMatchingSource = 
+                    // Domain events: $.stream.from.Order.created
+                    ((stream.source.entity === entity || stream.source.entity === '*') &&
+                        (stream.source.event === event || stream.source.event === '*'));
+                    if (stream.isRootStream() && isMatchingSource) {
+                        await stream.processItem(data);
+                    }
+                }
+            }
+            // NOTE: keyed streams and windowed streams receive data through parent subscriptions
+            // They don't need direct processing here anymore
+            // Process joins
+            for (const join of this.joins) {
+                const leftKey = join.left.getKey(data);
+                const rightKey = join.right.getKey?.(data);
+                // Check if this event matches left stream
+                const leftSource = join.left.parentStream?.source;
+                const leftSourceMatches = (leftSource?.entity === entity && leftSource?.event === event) ||
+                    (leftSource?.type === 'track' && entity === 'track' && leftSource?.event === event);
+                if (leftSourceMatches) {
+                    join.leftBuffer.set(leftKey, join.leftBuffer.get(leftKey) ?? []);
+                    join.leftBuffer.get(leftKey).push({ data, timestamp });
+                    // Try to match with right buffer
+                    const rightMatches = join.rightBuffer.get(leftKey) ?? [];
+                    for (const rightItem of rightMatches) {
+                        if (Math.abs(timestamp - rightItem.timestamp) <= join.window) {
+                            const result = join.mapper(data, rightItem.data);
+                            await join.output.processItem(result);
+                        }
+                    }
+                }
+                // Check if this event matches right stream
+                const rightSource = join.right.parentStream?.source;
+                const rightSourceMatches = (rightSource?.entity === entity && rightSource?.event === event) ||
+                    (rightSource?.type === 'track' && entity === 'track' && rightSource?.event === event);
+                if (rightSourceMatches) {
+                    if (rightKey) {
+                        join.rightBuffer.set(rightKey, join.rightBuffer.get(rightKey) ?? []);
+                        join.rightBuffer.get(rightKey).push({ data, timestamp });
+                        // Try to match with left buffer
+                        const leftMatches = join.leftBuffer.get(rightKey) ?? [];
+                        for (const leftItem of leftMatches) {
+                            if (Math.abs(timestamp - leftItem.timestamp) <= join.window) {
+                                const result = join.mapper(leftItem.data, data);
+                                await join.output.processItem(result);
+                            }
+                        }
+                    }
+                }
+            }
+            // Process coGroups
+            for (const coGroup of this.coGroups) {
+                const leftKey = coGroup.left.getKey(data);
+                const rightKey = coGroup.right.getKey?.(data);
+                const leftSource = coGroup.left.parentStream?.source;
+                const leftSourceMatches = (leftSource?.entity === entity && leftSource?.event === event) ||
+                    (leftSource?.type === 'track' && entity === 'track' && leftSource?.event === event);
+                if (leftSourceMatches) {
+                    coGroup.leftBuffer.set(leftKey, coGroup.leftBuffer.get(leftKey) ?? []);
+                    coGroup.leftBuffer.get(leftKey).push({ data, timestamp });
+                }
+                const rightSource = coGroup.right.parentStream?.source;
+                const rightSourceMatches = (rightSource?.entity === entity && rightSource?.event === event) ||
+                    (rightSource?.type === 'track' && entity === 'track' && rightSource?.event === event);
+                if (rightSourceMatches) {
+                    if (rightKey) {
+                        coGroup.rightBuffer.set(rightKey, coGroup.rightBuffer.get(rightKey) ?? []);
+                        coGroup.rightBuffer.get(rightKey).push({ data, timestamp });
+                    }
+                }
+            }
+        },
+        get: (name) => this.namedStreams.get(name),
+    };
+    registerStream(stream) {
+        this.streams.push(stream);
+    }
+    registerKeyedStream(stream) {
+        this.keyedStreams.push(stream);
+    }
+    registerWindowedStream(stream) {
+        this.windowedStreams.push(stream);
+    }
+    registerAggregatedStream(stream) {
+        this.aggregatedStreams.push(stream);
+    }
+    registerSinkStream(stream, type, name) {
+        const key = `${type}.${name}`;
+        if (!this.sinkStreams.has(key))
+            this.sinkStreams.set(key, []);
+        this.sinkStreams.get(key).push(stream);
+    }
+    registerAggregatedSink(stream, type, name) {
+        const key = `${type}.${name}`;
+        if (!this.aggregatedSinks.has(key))
+            this.aggregatedSinks.set(key, []);
+        this.aggregatedSinks.get(key).push(stream);
+    }
+    registerJoin(left, right, window, joinType, mapper, output) {
+        this.joins.push({
+            left,
+            right,
+            window,
+            joinType,
+            mapper,
+            output,
+            leftBuffer: new Map(),
+            rightBuffer: new Map(),
+        });
+    }
+    registerCoGroup(left, right, window, mapper, output) {
+        this.coGroups.push({
+            left,
+            right,
+            window,
+            mapper,
+            output,
+            leftBuffer: new Map(),
+            rightBuffer: new Map(),
+        });
+    }
+    // Aggregation helpers
+    count() {
+        return { type: 'count' };
+    }
+    sum(field) {
+        return { type: 'sum', field };
+    }
+    avg(field) {
+        return { type: 'avg', field };
+    }
+    min(field) {
+        return { type: 'min', field };
+    }
+    max(field) {
+        return { type: 'max', field };
+    }
+    first() {
+        return { type: 'first' };
+    }
+    last() {
+        return { type: 'last' };
+    }
+    collect() {
+        return { type: 'collect' };
+    }
+    distinct(field) {
+        return { type: 'distinct', field };
+    }
+    // Entity proxies
+    Customer = this.createEntityProxy('Customer');
+    Order = this.createEntityProxy('Order');
+    Payment = this.createEntityProxy('Payment');
+    createEntityProxy(entityName) {
+        return (id) => ({
+            get: async () => {
+                const storage = this._storage[entityName.toLowerCase() + 's'] ?? this._storage.customers;
+                return storage.get(id);
+            },
+            notify: async (payload) => {
+                const handlers = this.entityActionHandlers.get(`${entityName}.notify`) ?? [];
+                for (const handler of handlers) {
+                    handler(id, payload);
+                }
+            },
+        });
+    }
+    // View namespace
+    view = new Proxy({}, {
+        get: (_, viewName) => {
+            if (!this.viewData.has(viewName)) {
+                this.viewData.set(viewName, new Map());
+            }
+            const viewStore = this.viewData.get(viewName);
+            return {
+                get: async (key) => viewStore.get(key),
+                set: async (key, value) => viewStore.set(key, value),
+            };
+        },
+    });
+    // Trigger window processing (called when time advances)
+    advanceTime(currentTime) {
+        for (const windowedStream of this.windowedStreams) {
+            // Process aggregations BEFORE triggering window close (which deletes the state)
+            const aggregateSpec = windowedStream.getAggregateSpec();
+            const reduceSpec = windowedStream.getReduceSpec();
+            const windowState = windowedStream.getWindowState();
+            if (aggregateSpec || reduceSpec) {
+                for (const [windowKey, state] of windowState.entries()) {
+                    const [key, windowId] = windowKey.split('|');
+                    let shouldClose = false;
+                    let windowInfo;
+                    if (windowedStream.window.type === 'tumbling') {
+                        const size = windowedStream.window.size;
+                        const windowStart = parseInt(windowId);
+                        const windowEnd = windowStart + size;
+                        windowInfo = { start: windowStart, end: windowEnd };
+                        shouldClose = currentTime >= windowEnd;
+                    }
+                    else if (windowedStream.window.type === 'sliding') {
+                        const size = windowedStream.window.size;
+                        const slide = windowedStream.window.slide;
+                        const windowStart = parseInt(windowId);
+                        const windowEnd = windowStart + size;
+                        windowInfo = { start: windowStart, end: windowEnd };
+                        shouldClose = currentTime >= windowEnd;
+                    }
+                    else {
+                        const gap = windowedStream.window.gap;
+                        windowInfo = { start: state.lastTimestamp - gap, end: state.lastTimestamp + gap };
+                        shouldClose = currentTime >= state.lastTimestamp + gap;
+                    }
+                    if (shouldClose) {
+                        let result;
+                        if (aggregateSpec) {
+                            result = this.computeAggregation(aggregateSpec, state.elements, key);
+                        }
+                        else if (reduceSpec) {
+                            result = state.elements.reduce((acc, item) => reduceSpec.reducer(acc, item), reduceSpec.initial);
+                        }
+                        // Emit to aggregated streams
+                        for (const aggStream of this.aggregatedStreams) {
+                            if (aggStream.getWindowedStream() === windowedStream) {
+                                aggStream.emitResult(result, key, windowInfo);
+                                // Handle sinks
+                                if (aggStream.sink?.type === 'measure') {
+                                    const handlers = this.measureHandlers.get(aggStream.sink.metric) ?? [];
+                                    const value = typeof result === 'object' ? result.revenue ?? result.count ?? 0 : 0;
+                                    for (const handler of handlers) {
+                                        handler(value, { region: key });
+                                    }
+                                }
+                                if (aggStream.sink?.type === 'view') {
+                                    const viewName = aggStream.sink.view;
+                                    if (!this.viewData.has(viewName)) {
+                                        this.viewData.set(viewName, new Map());
+                                    }
+                                    this.viewData.get(viewName).set(key, result);
+                                }
+                            }
+                        }
+                    }
+                }
+            }
+            // Trigger window close AFTER processing aggregations (this clears the state)
+            windowedStream.triggerWindowClose(currentTime);
+        }
+        // Process left joins (emit unmatched left elements after window expires)
+        for (const join of this.joins) {
+            if (join.joinType === 'left') {
+                for (const [key, leftItems] of join.leftBuffer.entries()) {
+                    const rightItems = join.rightBuffer.get(key) ?? [];
+                    for (const leftItem of leftItems) {
+                        if (currentTime - leftItem.timestamp > join.window) {
+                            // Check if there was a match
+                            const hasMatch = rightItems.some((r) => Math.abs(leftItem.timestamp - r.timestamp) <= join.window);
+                            if (!hasMatch) {
+                                const result = join.mapper(leftItem.data, null);
+                                join.output.processItem(result);
+                            }
+                        }
+                    }
+                }
+            }
+        }
+        // Process coGroups
+        for (const coGroup of this.coGroups) {
+            const allKeys = new Set([
+                ...coGroup.leftBuffer.keys(),
+                ...coGroup.rightBuffer.keys(),
+            ]);
+            for (const key of allKeys) {
+                const leftItems = coGroup.leftBuffer.get(key) ?? [];
+                const rightItems = coGroup.rightBuffer.get(key) ?? [];
+                // Check if any items are past the window
+                const expiredLeft = leftItems.filter((i) => currentTime - i.timestamp > coGroup.window);
+                const expiredRight = rightItems.filter((i) => currentTime - i.timestamp > coGroup.window);
+                if (expiredLeft.length > 0 || expiredRight.length > 0) {
+                    const result = coGroup.mapper(leftItems.map((i) => i.data), rightItems.map((i) => i.data));
+                    coGroup.output.processItem(result);
+                    // Clear processed items
+                    coGroup.leftBuffer.delete(key);
+                    coGroup.rightBuffer.delete(key);
+                }
+            }
+        }
+    }
+    computeAggregation(spec, elements, key) {
+        const result = { key };
+        for (const [name, aggSpec] of Object.entries(spec)) {
+            switch (aggSpec.type) {
+                case 'count':
+                    result[name] = elements.length;
+                    break;
+                case 'sum':
+                    result[name] = elements.reduce((sum, el) => sum + (el[aggSpec.field] ?? 0), 0);
+                    break;
+                case 'avg':
+                    result[name] =
+                        elements.length > 0
+                            ? elements.reduce((sum, el) => sum + (el[aggSpec.field] ?? 0), 0) /
+                                elements.length
+                            : 0;
+                    break;
+                case 'min':
+                    result[name] = Math.min(...elements.map((el) => el[aggSpec.field] ?? Infinity));
+                    break;
+                case 'max':
+                    result[name] = Math.max(...elements.map((el) => el[aggSpec.field] ?? -Infinity));
+                    break;
+                case 'first':
+                    result[name] = elements[0];
+                    break;
+                case 'last':
+                    result[name] = elements[elements.length - 1];
+                    break;
+                case 'collect':
+                    result[name] = [...elements];
+                    break;
+                case 'distinct':
+                    result[name] = new Set(elements.map((el) => el[aggSpec.field])).size;
+                    break;
+            }
+        }
+        return result;
+    }
+}
+// ============================================================================
+// Factory
+// ============================================================================
+export function createStreamContext() {
+    const ctx = new StreamContextImpl();
+    return ctx;
+}
+//# sourceMappingURL=index.js.map