@pipedog/core 0.0.0 → 0.1.0

package/dist/processors/audio/vad_processor.js

@@ -0,0 +1,103 @@
+// Copyright (c) 2024-2026, Daily
+// Copyright (c) 2026, pipedog contributors
+// SPDX-License-Identifier: BSD-2-Clause
+//
+// Ported from pipecat: src/pipecat/processors/audio/vad_processor.py
+import { VADController } from "../../audio/vad/vad_controller.js";
+import { CancelFrame, EndFrame, StartFrame, UserSpeakingFrame, VADUserStartedSpeakingFrame, VADUserStoppedSpeakingFrame, } from "../../frames/frames.js";
+import { logger } from "../../utils/logger.js";
+import { FrameProcessor, } from "../frame_processor.js";
+/**
+ * Processes audio frames through voice activity detection.
+ *
+ * This processor wraps a VADController to detect speech in audio streams
+ * and push VAD frames into the pipeline:
+ *
+ * - `VADUserStartedSpeakingFrame`: pushed when speech begins.
+ * - `VADUserStoppedSpeakingFrame`: pushed when speech ends.
+ * - `UserSpeakingFrame`: pushed periodically while speech is detected.
+ *
+ * @example
+ * const vadProcessor = new VADProcessor({ vadAnalyzer: new SileroVADAnalyzer() });
+ */
+export class VADProcessor extends FrameProcessor {
+    _vadController;
+    /**
+     * Initialize the VAD processor.
+     *
+     * @param options.vadAnalyzer The VADAnalyzer instance for processing audio.
+     * @param options.speechActivityPeriod Minimum interval in seconds between
+     *   UserSpeakingFrame pushes. Defaults to 0.2.
+     * @param options.audioIdleTimeout Timeout in seconds to force speech stop
+     *   when no audio frames are received while in SPEAKING state. Set to 0 to
+     *   disable. Defaults to 1.0. Other options are passed to the parent class.
+     */
+    constructor(options) {
+        super(options);
+        const vadAnalyzer = options.vadAnalyzer;
+        this._vadController = new VADController(vadAnalyzer, {
+            speechActivityPeriod: options.speechActivityPeriod ?? 0.2,
+            audioIdleTimeout: options.audioIdleTimeout ?? 1.0,
+        });
+        // Push VAD frames when speech events are detected. Upstream reads the
+        // params through the controller's analyzer, which is this same instance.
+        this._vadController.addEventHandler("on_speech_started", async () => {
+            logger.debug(`${this}: User started speaking`);
+            await this.broadcastFrame(VADUserStartedSpeakingFrame, {
+                startSecs: vadAnalyzer.params.startSecs,
+            });
+        });
+        this._vadController.addEventHandler("on_speech_stopped", async () => {
+            logger.debug(`${this}: User stopped speaking`);
+            await this.broadcastFrame(VADUserStoppedSpeakingFrame, {
+                stopSecs: vadAnalyzer.params.stopSecs,
+            });
+        });
+        this._vadController.addEventHandler("on_speech_activity", async () => {
+            await this.broadcastFrame(UserSpeakingFrame);
+        });
+        // Wire up frame pushing from controller to processor
+        this._vadController.addEventHandler("on_push_frame", async (_controller, frame, direction) => {
+            await this.pushFrame(frame, direction);
+        });
+        this._vadController.addEventHandler("on_broadcast_frame", async (_controller, frameCls, kwargs) => {
+            await this.broadcastFrame(frameCls, kwargs ?? {});
+        });
+    }
+    /**
+     * Set up the processor.
+     *
+     * @param setup Configuration object containing setup parameters.
+     */
+    async setup(setup) {
+        await super.setup(setup);
+        await this._vadController.setup(setup);
+    }
+    /** Clean up VAD controller resources. */
+    async cleanup() {
+        await super.cleanup();
+        await this._vadController.cleanup();
+    }
+    /**
+     * Process a frame through VAD and forward it.
+     *
+     * @param frame The frame to process.
+     * @param direction The direction of frame flow in the pipeline.
+     */
+    async processFrame(frame, direction) {
+        await super.processFrame(frame, direction);
+        // Forward the frame first, then let VAD controller process. This ensures:
+        // 1. StartFrame reaches downstream before SpeechControlParamsFrame is broadcast
+        // 2. Audio flows through immediately while VAD detection happens after
+        await this.pushFrame(frame, direction);
+        if (frame instanceof StartFrame) {
+            await this._vadController.start();
+        }
+        else if (frame instanceof EndFrame || frame instanceof CancelFrame) {
+            await this._vadController.stop();
+        }
+        // Let the VAD controller handle the frame
+        await this._vadController.processFrame(frame);
+    }
+}
+//# sourceMappingURL=vad_processor.js.map

package/dist/processors/consumer_processor.d.ts

@@ -0,0 +1,49 @@
+/** Consumer processor for consuming frames from ProducerProcessor queues. */
+import type { Queue, Task } from "@pipedog/asyncio";
+import { CancelFrame, EndFrame, type Frame, StartFrame } from "../frames/frames.ts";
+import { FrameDirection, FrameProcessor, type FrameProcessorOptions } from "./frame_processor.ts";
+import { type FrameTransformer, type ProducerProcessor } from "./producer_processor.ts";
+export interface ConsumerProcessorOptions extends FrameProcessorOptions {
+    /** The producer processor to consume frames from. */
+    producer: ProducerProcessor;
+    /** Function to transform frames before pushing. Defaults to `identityTransformer`. */
+    transformer?: FrameTransformer;
+    /** Direction to push consumed frames. Defaults to DOWNSTREAM. */
+    direction?: FrameDirection;
+}
+/**
+ * Frame processor that consumes frames from a ProducerProcessor's queue.
+ *
+ * This processor passes through frames normally while also consuming frames
+ * from a ProducerProcessor's queue. When frames are received from the producer
+ * queue, they are optionally transformed and pushed in the specified direction.
+ */
+export declare class ConsumerProcessor extends FrameProcessor {
+    protected _transformer: FrameTransformer;
+    protected _direction: FrameDirection;
+    protected _producer: ProducerProcessor;
+    protected _consumerTask: Task<unknown> | null;
+    protected _queue: Queue<Frame> | null;
+    /** Initialize the consumer processor. */
+    constructor(options: ConsumerProcessorOptions);
+    /**
+     * Process incoming frames and handle lifecycle events.
+     *
+     * @param frame The frame to process.
+     * @param direction The direction the frame is traveling.
+     */
+    processFrame(frame: Frame, direction: FrameDirection): Promise<void>;
+    /** Start the consumer task and register with the producer. */
+    protected _start(_frame: StartFrame): Promise<void>;
+    /** Stop the consumer task. */
+    protected _stop(_frame: EndFrame): Promise<void>;
+    /** Cancel the consumer task. */
+    protected _cancel(_frame: CancelFrame): Promise<void>;
+    /** Clean up the processor and release resources. */
+    cleanup(): Promise<void>;
+    /** Cancel the consumer task, idempotently. */
+    protected _cancelConsumerTask(): Promise<void>;
+    /** Handle consuming frames from the producer queue. */
+    protected _consumerTaskHandler(): Promise<void>;
+}
+//# sourceMappingURL=consumer_processor.d.ts.map

package/dist/processors/consumer_processor.js

@@ -0,0 +1,85 @@
+// Copyright (c) 2024-2026, Daily
+// Copyright (c) 2026, pipedog contributors
+// SPDX-License-Identifier: BSD-2-Clause
+//
+// Ported from pipecat: src/pipecat/processors/consumer_processor.py
+import { CancelFrame, EndFrame, StartFrame } from "../frames/frames.js";
+import { FrameDirection, FrameProcessor } from "./frame_processor.js";
+import { identityTransformer, } from "./producer_processor.js";
+/**
+ * Frame processor that consumes frames from a ProducerProcessor's queue.
+ *
+ * This processor passes through frames normally while also consuming frames
+ * from a ProducerProcessor's queue. When frames are received from the producer
+ * queue, they are optionally transformed and pushed in the specified direction.
+ */
+export class ConsumerProcessor extends FrameProcessor {
+    _transformer;
+    _direction;
+    _producer;
+    _consumerTask = null;
+    _queue = null;
+    /** Initialize the consumer processor. */
+    constructor(options) {
+        super(options);
+        this._transformer = options.transformer ?? identityTransformer;
+        this._direction = options.direction ?? FrameDirection.DOWNSTREAM;
+        this._producer = options.producer;
+    }
+    /**
+     * Process incoming frames and handle lifecycle events.
+     *
+     * @param frame The frame to process.
+     * @param direction The direction the frame is traveling.
+     */
+    async processFrame(frame, direction) {
+        await super.processFrame(frame, direction);
+        if (frame instanceof StartFrame) {
+            await this._start(frame);
+        }
+        else if (frame instanceof EndFrame) {
+            await this._stop(frame);
+        }
+        else if (frame instanceof CancelFrame) {
+            await this._cancel(frame);
+        }
+        await this.pushFrame(frame, direction);
+    }
+    /** Start the consumer task and register with the producer. */
+    async _start(_frame) {
+        if (!this._consumerTask) {
+            this._queue = this._producer.addConsumer();
+            this._consumerTask = this.createTask(() => this._consumerTaskHandler());
+        }
+    }
+    /** Stop the consumer task. */
+    async _stop(_frame) {
+        await this._cancelConsumerTask();
+    }
+    /** Cancel the consumer task. */
+    async _cancel(_frame) {
+        await this._cancelConsumerTask();
+    }
+    /** Clean up the processor and release resources. */
+    async cleanup() {
+        await super.cleanup();
+        await this._cancelConsumerTask();
+    }
+    /** Cancel the consumer task, idempotently. */
+    async _cancelConsumerTask() {
+        if (this._consumerTask) {
+            await this.cancelTask(this._consumerTask);
+            this._consumerTask = null;
+        }
+    }
+    /** Handle consuming frames from the producer queue. */
+    async _consumerTaskHandler() {
+        const queue = this._queue;
+        for (;;) {
+            const frame = await queue.get();
+            const newFrame = await this._transformer(frame);
+            await this.queueFrame(newFrame, this._direction);
+        }
+    }
+}
+//# sourceMappingURL=consumer_processor.js.map

package/dist/processors/filters/frame_filter.d.ts

@@ -0,0 +1,39 @@
+/** Frame filtering processor for the Pipecat framework. */
+import { type Frame } from "../../frames/frames.ts";
+import type { FrameClass } from "../../utils/frame_queue.ts";
+import { type FrameDirection, FrameProcessor } from "../frame_processor.ts";
+export interface FrameFilterOptions {
+    /**
+     * Frame types that should be allowed to pass through the filter. All other
+     * frame types (except SystemFrame and EndFrame) will be blocked.
+     */
+    types: readonly FrameClass[];
+}
+/**
+ * A frame processor that filters frames based on their types.
+ *
+ * This processor acts as a selective gate in the pipeline, allowing only
+ * frames of specified types to pass through. System and end frames are
+ * automatically allowed to pass through to maintain pipeline integrity.
+ */
+export declare class FrameFilter extends FrameProcessor {
+    protected _types: readonly FrameClass[];
+    /**
+     * Initialize the frame filter.
+     *
+     * @param options.types Frame types that should be allowed to pass through
+     *   the filter. All other frame types (except SystemFrame and EndFrame) will
+     *   be blocked.
+     */
+    constructor(options: FrameFilterOptions);
+    /** Determine if a frame should pass through the filter. */
+    protected _shouldPassthroughFrame(frame: Frame): boolean;
+    /**
+     * Process an incoming frame and conditionally pass it through.
+     *
+     * @param frame The frame to process.
+     * @param direction The direction of frame flow in the pipeline.
+     */
+    processFrame(frame: Frame, direction: FrameDirection): Promise<void>;
+}
+//# sourceMappingURL=frame_filter.d.ts.map

package/dist/processors/filters/frame_filter.js

@@ -0,0 +1,52 @@
+// Copyright (c) 2024-2026, Daily
+// Copyright (c) 2026, pipedog contributors
+// SPDX-License-Identifier: BSD-2-Clause
+//
+// Ported from pipecat: src/pipecat/processors/filters/frame_filter.py
+/** Frame filtering processor for the Pipecat framework. */
+import { EndFrame, SystemFrame } from "../../frames/frames.js";
+import { FrameProcessor } from "../frame_processor.js";
+/**
+ * A frame processor that filters frames based on their types.
+ *
+ * This processor acts as a selective gate in the pipeline, allowing only
+ * frames of specified types to pass through. System and end frames are
+ * automatically allowed to pass through to maintain pipeline integrity.
+ */
+export class FrameFilter extends FrameProcessor {
+    _types;
+    /**
+     * Initialize the frame filter.
+     *
+     * @param options.types Frame types that should be allowed to pass through
+     *   the filter. All other frame types (except SystemFrame and EndFrame) will
+     *   be blocked.
+     */
+    constructor(options) {
+        super();
+        this._types = options.types;
+    }
+    //
+    // Frame processor
+    //
+    /** Determine if a frame should pass through the filter. */
+    _shouldPassthroughFrame(frame) {
+        if (this._types.some((t) => frame instanceof t)) {
+            return true;
+        }
+        return frame instanceof EndFrame || frame instanceof SystemFrame;
+    }
+    /**
+     * Process an incoming frame and conditionally pass it through.
+     *
+     * @param frame The frame to process.
+     * @param direction The direction of frame flow in the pipeline.
+     */
+    async processFrame(frame, direction) {
+        await super.processFrame(frame, direction);
+        if (this._shouldPassthroughFrame(frame)) {
+            await this.pushFrame(frame, direction);
+        }
+    }
+}
+//# sourceMappingURL=frame_filter.js.map

package/dist/processors/filters/function_filter.d.ts

@@ -0,0 +1,59 @@
+/**
+ * Function-based frame filtering for Pipecat pipelines.
+ *
+ * This module provides a processor that filters frames based on a custom
+ * function, allowing for flexible frame filtering logic in processing pipelines.
+ */
+import { type Frame } from "../../frames/frames.ts";
+import { FrameDirection, FrameProcessor, type FrameProcessorOptions } from "../frame_processor.ts";
+export type FilterType = (frame: Frame) => Promise<boolean>;
+export interface FunctionFilterOptions extends FrameProcessorOptions {
+    /**
+     * An async function that takes a Frame and returns true if the frame should
+     * pass through, false otherwise.
+     */
+    filter: FilterType;
+    /**
+     * The direction to apply filtering. Only frames moving in this direction
+     * will be filtered; frames in the other direction pass through unfiltered.
+     * If null, frames in both directions are filtered. Defaults to DOWNSTREAM.
+     */
+    direction?: FrameDirection | null;
+    /** Whether to filter system frames. Defaults to false. */
+    filterSystemFrames?: boolean;
+}
+/**
+ * A frame processor that filters frames using a custom function.
+ *
+ * This processor allows frames to pass through based on the result of a
+ * user-provided filter function. System and end frames always pass through
+ * regardless of the filter result.
+ */
+export declare class FunctionFilter extends FrameProcessor {
+    protected _filter: FilterType;
+    protected _direction: FrameDirection | null;
+    protected _filterSystemFrames: boolean;
+    /**
+     * Initialize the function filter.
+     *
+     * @param options.filter An async function that takes a Frame and returns
+     *   true if the frame should pass through, false otherwise.
+     * @param options.direction The direction to apply filtering. Only frames
+     *   moving in this direction will be filtered; frames in the other direction
+     *   pass through unfiltered. If null, frames in both directions are
+     *   filtered. Defaults to DOWNSTREAM.
+     * @param options.filterSystemFrames Whether to filter system frames.
+     *   Defaults to false.
+     */
+    constructor(options: FunctionFilterOptions);
+    /** Check if a frame should pass through without filtering. */
+    protected _shouldPassthroughFrame(frame: Frame, direction: FrameDirection): boolean;
+    /**
+     * Process a frame through the filter.
+     *
+     * @param frame The frame to process.
+     * @param direction The direction the frame is moving in the pipeline.
+     */
+    processFrame(frame: Frame, direction: FrameDirection): Promise<void>;
+}
+//# sourceMappingURL=function_filter.d.ts.map

package/dist/processors/filters/function_filter.js

@@ -0,0 +1,78 @@
+// Copyright (c) 2024-2026, Daily
+// Copyright (c) 2026, pipedog contributors
+// SPDX-License-Identifier: BSD-2-Clause
+//
+// Ported from pipecat: src/pipecat/processors/filters/function_filter.py
+/**
+ * Function-based frame filtering for Pipecat pipelines.
+ *
+ * This module provides a processor that filters frames based on a custom
+ * function, allowing for flexible frame filtering logic in processing pipelines.
+ */
+import { CancelFrame, EndFrame, StartFrame, SystemFrame } from "../../frames/frames.js";
+import { FrameDirection, FrameProcessor } from "../frame_processor.js";
+/**
+ * A frame processor that filters frames using a custom function.
+ *
+ * This processor allows frames to pass through based on the result of a
+ * user-provided filter function. System and end frames always pass through
+ * regardless of the filter result.
+ */
+export class FunctionFilter extends FrameProcessor {
+    _filter;
+    _direction;
+    _filterSystemFrames;
+    /**
+     * Initialize the function filter.
+     *
+     * @param options.filter An async function that takes a Frame and returns
+     *   true if the frame should pass through, false otherwise.
+     * @param options.direction The direction to apply filtering. Only frames
+     *   moving in this direction will be filtered; frames in the other direction
+     *   pass through unfiltered. If null, frames in both directions are
+     *   filtered. Defaults to DOWNSTREAM.
+     * @param options.filterSystemFrames Whether to filter system frames.
+     *   Defaults to false.
+     */
+    constructor(options) {
+        super(options);
+        this._filter = options.filter;
+        this._direction =
+            options.direction === undefined ? FrameDirection.DOWNSTREAM : options.direction;
+        this._filterSystemFrames = options.filterSystemFrames ?? false;
+    }
+    //
+    // Frame processor
+    //
+    /** Check if a frame should pass through without filtering. */
+    _shouldPassthroughFrame(frame, direction) {
+        // Always passthrough frames in the wrong direction
+        if (this._direction && direction !== this._direction) {
+            return true;
+        }
+        // Always passthrough lifecycle frames
+        if (frame instanceof StartFrame || frame instanceof EndFrame || frame instanceof CancelFrame) {
+            return true;
+        }
+        // If not filtering system frames, passthrough all other system frames
+        if (!this._filterSystemFrames && frame instanceof SystemFrame) {
+            return true;
+        }
+        return false;
+    }
+    /**
+     * Process a frame through the filter.
+     *
+     * @param frame The frame to process.
+     * @param direction The direction the frame is moving in the pipeline.
+     */
+    async processFrame(frame, direction) {
+        await super.processFrame(frame, direction);
+        const passthrough = this._shouldPassthroughFrame(frame, direction);
+        const allowed = await this._filter(frame);
+        if (passthrough || allowed) {
+            await this.pushFrame(frame, direction);
+        }
+    }
+}
+//# sourceMappingURL=function_filter.js.map

package/dist/processors/filters/identity_filter.d.ts

@@ -0,0 +1,33 @@
+/**
+ * Identity filter for transparent frame passthrough.
+ *
+ * This module provides a simple passthrough filter that forwards all frames
+ * without modification, useful for testing and pipeline composition.
+ */
+import type { Frame } from "../../frames/frames.ts";
+import { type FrameDirection, FrameProcessor, type FrameProcessorOptions } from "../frame_processor.ts";
+export interface IdentityFilterOptions extends FrameProcessorOptions {
+}
+/**
+ * A pass-through filter that forwards all frames without modification.
+ *
+ * This filter acts as a transparent passthrough, allowing all frames to flow
+ * through unchanged. It can be useful when testing `ParallelPipeline` to
+ * create pipelines that pass through frames (no frames should be repeated).
+ */
+export declare class IdentityFilter extends FrameProcessor {
+    /**
+     * Initialize the identity filter.
+     *
+     * @param options Options passed to the parent FrameProcessor.
+     */
+    constructor(options?: IdentityFilterOptions);
+    /**
+     * Process an incoming frame by passing it through unchanged.
+     *
+     * @param frame The frame to process and forward.
+     * @param direction The direction of frame flow in the pipeline.
+     */
+    processFrame(frame: Frame, direction: FrameDirection): Promise<void>;
+}
+//# sourceMappingURL=identity_filter.d.ts.map

package/dist/processors/filters/identity_filter.js

@@ -0,0 +1,37 @@
+// Copyright (c) 2024-2026, Daily
+// Copyright (c) 2026, pipedog contributors
+// SPDX-License-Identifier: BSD-2-Clause
+//
+// Ported from pipecat: src/pipecat/processors/filters/identity_filter.py
+import { FrameProcessor, } from "../frame_processor.js";
+/**
+ * A pass-through filter that forwards all frames without modification.
+ *
+ * This filter acts as a transparent passthrough, allowing all frames to flow
+ * through unchanged. It can be useful when testing `ParallelPipeline` to
+ * create pipelines that pass through frames (no frames should be repeated).
+ */
+export class IdentityFilter extends FrameProcessor {
+    /**
+     * Initialize the identity filter.
+     *
+     * @param options Options passed to the parent FrameProcessor.
+     */
+    constructor(options = {}) {
+        super(options);
+    }
+    //
+    // Frame processor
+    //
+    /**
+     * Process an incoming frame by passing it through unchanged.
+     *
+     * @param frame The frame to process and forward.
+     * @param direction The direction of frame flow in the pipeline.
+     */
+    async processFrame(frame, direction) {
+        await super.processFrame(frame, direction);
+        await this.pushFrame(frame, direction);
+    }
+}
+//# sourceMappingURL=identity_filter.js.map

package/dist/processors/filters/index.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=index.d.ts.map

package/dist/processors/filters/index.js

@@ -0,0 +1,8 @@
+// Copyright (c) 2024-2026, Daily
+// Copyright (c) 2026, pipedog contributors
+// SPDX-License-Identifier: BSD-2-Clause
+//
+// Ported from pipecat: src/pipecat/processors/filters/__init__.py
+// The upstream package initializer is empty; import the modules directly.
+export {};
+//# sourceMappingURL=index.js.map

package/dist/processors/filters/null_filter.d.ts

@@ -0,0 +1,34 @@
+/**
+ * Null filter processor for blocking frame transmission.
+ *
+ * This module provides a frame processor that blocks all frames except
+ * system and end frames, useful for testing or temporarily stopping
+ * frame flow in a pipeline.
+ */
+import { type Frame } from "../../frames/frames.ts";
+import { type FrameDirection, FrameProcessor, type FrameProcessorOptions } from "../frame_processor.ts";
+export interface NullFilterOptions extends FrameProcessorOptions {
+}
+/**
+ * A filter that blocks all frames except system and end frames.
+ *
+ * This processor acts as a null filter, preventing frames from passing
+ * through the pipeline while still allowing essential system and end
+ * frames to maintain proper pipeline operation.
+ */
+export declare class NullFilter extends FrameProcessor {
+    /**
+     * Initialize the null filter.
+     *
+     * @param options Options passed to the parent FrameProcessor.
+     */
+    constructor(options?: NullFilterOptions);
+    /**
+     * Process incoming frames, only allowing system and end frames through.
+     *
+     * @param frame The frame to process.
+     * @param direction The direction of frame flow in the pipeline.
+     */
+    processFrame(frame: Frame, direction: FrameDirection): Promise<void>;
+}
+//# sourceMappingURL=null_filter.d.ts.map

package/dist/processors/filters/null_filter.js

@@ -0,0 +1,47 @@
+// Copyright (c) 2024-2026, Daily
+// Copyright (c) 2026, pipedog contributors
+// SPDX-License-Identifier: BSD-2-Clause
+//
+// Ported from pipecat: src/pipecat/processors/filters/null_filter.py
+/**
+ * Null filter processor for blocking frame transmission.
+ *
+ * This module provides a frame processor that blocks all frames except
+ * system and end frames, useful for testing or temporarily stopping
+ * frame flow in a pipeline.
+ */
+import { EndFrame, SystemFrame } from "../../frames/frames.js";
+import { FrameProcessor, } from "../frame_processor.js";
+/**
+ * A filter that blocks all frames except system and end frames.
+ *
+ * This processor acts as a null filter, preventing frames from passing
+ * through the pipeline while still allowing essential system and end
+ * frames to maintain proper pipeline operation.
+ */
+export class NullFilter extends FrameProcessor {
+    /**
+     * Initialize the null filter.
+     *
+     * @param options Options passed to the parent FrameProcessor.
+     */
+    constructor(options = {}) {
+        super(options);
+    }
+    //
+    // Frame processor
+    //
+    /**
+     * Process incoming frames, only allowing system and end frames through.
+     *
+     * @param frame The frame to process.
+     * @param direction The direction of frame flow in the pipeline.
+     */
+    async processFrame(frame, direction) {
+        await super.processFrame(frame, direction);
+        if (frame instanceof SystemFrame || frame instanceof EndFrame) {
+            await this.pushFrame(frame, direction);
+        }
+    }
+}
+//# sourceMappingURL=null_filter.js.map