@revizly/node-av 5.2.2-beta.1

package/dist/api/utilities/pixel-format.js

@@ -0,0 +1,97 @@
+import { bindings } from '../../lib/binding.js';
+/**
+ * Video pixel format utilities.
+ *
+ * Provides static methods for querying pixel format properties, converting
+ * between format names and values, and checking hardware acceleration support.
+ *
+ * @example
+ * ```typescript
+ * import { PixelFormat } from 'node-av';
+ * import { AV_PIX_FMT_YUV420P, AV_PIX_FMT_CUDA } from 'node-av/constants';
+ *
+ * // Get format information
+ * console.log(PixelFormat.getName(AV_PIX_FMT_YUV420P));    // "yuv420p"
+ * console.log(PixelFormat.isHardware(AV_PIX_FMT_CUDA));    // true
+ *
+ * // Convert between names and values
+ * const format = PixelFormat.fromName("yuv420p");
+ * console.log(format === AV_PIX_FMT_YUV420P);              // true
+ * ```
+ */
+export class PixelFormatUtils {
+    // Private constructor to prevent instantiation
+    constructor() { }
+    /**
+     * Get the name of a pixel format.
+     *
+     * Returns a string describing the pixel format.
+     * Direct mapping to av_get_pix_fmt_name()
+     *
+     * @param format - Video pixel format
+     *
+     * @returns Format name string, or null for invalid format
+     *
+     * @example
+     * ```typescript
+     * import { PixelFormat } from 'node-av';
+     * import { AV_PIX_FMT_YUV420P, AV_PIX_FMT_RGB24 } from 'node-av/constants';
+     *
+     * console.log(PixelFormat.getName(AV_PIX_FMT_YUV420P)); // "yuv420p"
+     * console.log(PixelFormat.getName(AV_PIX_FMT_RGB24));   // "rgb24"
+     * ```
+     */
+    static getName(format) {
+        return bindings.avGetPixFmtName(format);
+    }
+    /**
+     * Get pixel format from name.
+     *
+     * Converts a pixel format name string to its enum value.
+     * Direct mapping to av_get_pix_fmt()
+     *
+     * @param name - Pixel format name string
+     *
+     * @returns Pixel format enum value, or AV_PIX_FMT_NONE for unknown formats
+     *
+     * @example
+     * ```typescript
+     * import { PixelFormat } from 'node-av';
+     * import { AV_PIX_FMT_YUV420P } from 'node-av/constants';
+     *
+     * const format = PixelFormat.fromName("yuv420p");
+     * console.log(format === AV_PIX_FMT_YUV420P); // true
+     *
+     * const invalid = PixelFormat.fromName("invalid");
+     * console.log(invalid === AV_PIX_FMT_NONE);   // true
+     * ```
+     */
+    static fromName(name) {
+        return bindings.avGetPixFmtFromName(name);
+    }
+    /**
+     * Check if pixel format is hardware accelerated.
+     *
+     * Returns true if the pixel format represents frames in GPU/hardware memory
+     * rather than system memory.
+     * Direct mapping to av_pix_fmt_desc_get() and checking for AV_PIX_FMT_FLAG_HWACCEL
+     *
+     * @param format - Video pixel format
+     *
+     * @returns True if format is hardware accelerated
+     *
+     * @example
+     * ```typescript
+     * import { PixelFormat } from 'node-av';
+     * import { AV_PIX_FMT_YUV420P, AV_PIX_FMT_CUDA, AV_PIX_FMT_VAAPI } from 'node-av/constants';
+     *
+     * console.log(PixelFormat.isHardware(AV_PIX_FMT_YUV420P)); // false
+     * console.log(PixelFormat.isHardware(AV_PIX_FMT_CUDA));    // true
+     * console.log(PixelFormat.isHardware(AV_PIX_FMT_VAAPI));   // true
+     * ```
+     */
+    static isHardware(format) {
+        return bindings.avIsHardwarePixelFormat(format);
+    }
+}
+//# sourceMappingURL=pixel-format.js.map

package/dist/api/utilities/pixel-format.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"pixel-format.js","sourceRoot":"","sources":["../../../src/api/utilities/pixel-format.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,EAAE,MAAM,sBAAsB,CAAC;AAIhD;;;;;;;;;;;;;;;;;;;GAmBG;AACH,MAAM,OAAO,gBAAgB;IAC3B,+CAA+C;IAC/C,gBAAuB,CAAC;IAExB;;;;;;;;;;;;;;;;;;OAkBG;IACH,MAAM,CAAC,OAAO,CAAC,MAAqB;QAClC,OAAO,QAAQ,CAAC,eAAe,CAAC,MAAM,CAAC,CAAC;IAC1C,CAAC;IAED;;;;;;;;;;;;;;;;;;;;;OAqBG;IACH,MAAM,CAAC,QAAQ,CAAC,IAAY;QAC1B,OAAO,QAAQ,CAAC,mBAAmB,CAAC,IAAI,CAAC,CAAC;IAC5C,CAAC;IAED;;;;;;;;;;;;;;;;;;;;OAoBG;IACH,MAAM,CAAC,UAAU,CAAC,MAAqB;QACrC,OAAO,QAAQ,CAAC,uBAAuB,CAAC,MAAM,CAAC,CAAC;IAClD,CAAC;CACF"}

package/dist/api/utilities/sample-format.d.ts

@@ -0,0 +1,129 @@
+import type { AVSampleFormat } from '../../constants/index.js';
+/**
+ * Audio sample format utilities.
+ *
+ * Provides static methods for querying and converting between audio sample formats.
+ * These utilities help with format introspection, conversion between packed/planar
+ * layouts, and getting human-readable format information.
+ *
+ * @example
+ * ```typescript
+ * import { SampleFormat } from 'node-av';
+ * import { AV_SAMPLE_FMT_S16, AV_SAMPLE_FMT_FLTP } from 'node-av/constants';
+ *
+ * // Get format information
+ * console.log(SampleFormat.getName(AV_SAMPLE_FMT_S16));        // "s16"
+ * console.log(SampleFormat.getBytesPerSample(AV_SAMPLE_FMT_S16)); // 2
+ * console.log(SampleFormat.isPlanar(AV_SAMPLE_FMT_FLTP));      // true
+ *
+ * // Convert between packed and planar formats
+ * const packed = SampleFormat.getPackedFormat(AV_SAMPLE_FMT_FLTP);
+ * const planar = SampleFormat.getPlanarFormat(AV_SAMPLE_FMT_FLT);
+ * ```
+ */
+export declare class SampleFormatUtils {
+    private constructor();
+    /**
+     * Get bytes per sample for a sample format.
+     *
+     * Returns the number of bytes required to store one sample in the given format.
+     * Direct mapping to av_get_bytes_per_sample()
+     *
+     * @param format - Audio sample format
+     *
+     * @returns Number of bytes per sample, or 0 for invalid format
+     *
+     * @example
+     * ```typescript
+     * import { SampleFormat } from 'node-av';
+     * import { AV_SAMPLE_FMT_S16, AV_SAMPLE_FMT_FLT } from 'node-av/constants';
+     *
+     * console.log(SampleFormat.getBytesPerSample(AV_SAMPLE_FMT_S16)); // 2
+     * console.log(SampleFormat.getBytesPerSample(AV_SAMPLE_FMT_FLT)); // 4
+     * ```
+     */
+    static getBytesPerSample(format: AVSampleFormat): number;
+    /**
+     * Get the name of a sample format.
+     *
+     * Returns a string describing the sample format.
+     * Direct mapping to av_get_sample_fmt_name()
+     *
+     * @param format - Audio sample format
+     *
+     * @returns Format name string, or null for invalid format
+     *
+     * @example
+     * ```typescript
+     * import { SampleFormat } from 'node-av';
+     * import { AV_SAMPLE_FMT_S16, AV_SAMPLE_FMT_FLTP } from 'node-av/constants';
+     *
+     * console.log(SampleFormat.getName(AV_SAMPLE_FMT_S16));  // "s16"
+     * console.log(SampleFormat.getName(AV_SAMPLE_FMT_FLTP)); // "fltp"
+     * ```
+     */
+    static getName(format: AVSampleFormat): string | null;
+    /**
+     * Get packed sample format.
+     *
+     * Returns the packed variant of the given sample format.
+     * If the format is already packed, returns it unchanged.
+     * Direct mapping to av_get_packed_sample_fmt()
+     *
+     * @param format - Audio sample format
+     *
+     * @returns Packed sample format
+     *
+     * @example
+     * ```typescript
+     * import { SampleFormat } from 'node-av';
+     * import { AV_SAMPLE_FMT_FLTP, AV_SAMPLE_FMT_FLT } from 'node-av/constants';
+     *
+     * const packed = SampleFormat.getPackedFormat(AV_SAMPLE_FMT_FLTP);
+     * console.log(packed === AV_SAMPLE_FMT_FLT); // true
+     * ```
+     */
+    static getPackedFormat(format: AVSampleFormat): AVSampleFormat;
+    /**
+     * Get planar sample format.
+     *
+     * Returns the planar variant of the given sample format.
+     * If the format is already planar, returns it unchanged.
+     * Direct mapping to av_get_planar_sample_fmt()
+     *
+     * @param format - Audio sample format
+     *
+     * @returns Planar sample format
+     *
+     * @example
+     * ```typescript
+     * import { SampleFormat } from 'node-av';
+     * import { AV_SAMPLE_FMT_FLT, AV_SAMPLE_FMT_FLTP } from 'node-av/constants';
+     *
+     * const planar = SampleFormat.getPlanarFormat(AV_SAMPLE_FMT_FLT);
+     * console.log(planar === AV_SAMPLE_FMT_FLTP); // true
+     * ```
+     */
+    static getPlanarFormat(format: AVSampleFormat): AVSampleFormat;
+    /**
+     * Check if sample format is planar.
+     *
+     * Returns true if the sample format stores each channel in a separate buffer.
+     * Returns false if all channels are interleaved in a single buffer.
+     * Direct mapping to av_sample_fmt_is_planar()
+     *
+     * @param format - Audio sample format
+     *
+     * @returns True if format is planar, false if packed/interleaved
+     *
+     * @example
+     * ```typescript
+     * import { SampleFormat } from 'node-av';
+     * import { AV_SAMPLE_FMT_S16, AV_SAMPLE_FMT_S16P } from 'node-av/constants';
+     *
+     * console.log(SampleFormat.isPlanar(AV_SAMPLE_FMT_S16));  // false (packed)
+     * console.log(SampleFormat.isPlanar(AV_SAMPLE_FMT_S16P)); // true (planar)
+     * ```
+     */
+    static isPlanar(format: AVSampleFormat): boolean;
+}

package/dist/api/utilities/sample-format.js

@@ -0,0 +1,141 @@
+import { bindings } from '../../lib/binding.js';
+/**
+ * Audio sample format utilities.
+ *
+ * Provides static methods for querying and converting between audio sample formats.
+ * These utilities help with format introspection, conversion between packed/planar
+ * layouts, and getting human-readable format information.
+ *
+ * @example
+ * ```typescript
+ * import { SampleFormat } from 'node-av';
+ * import { AV_SAMPLE_FMT_S16, AV_SAMPLE_FMT_FLTP } from 'node-av/constants';
+ *
+ * // Get format information
+ * console.log(SampleFormat.getName(AV_SAMPLE_FMT_S16));        // "s16"
+ * console.log(SampleFormat.getBytesPerSample(AV_SAMPLE_FMT_S16)); // 2
+ * console.log(SampleFormat.isPlanar(AV_SAMPLE_FMT_FLTP));      // true
+ *
+ * // Convert between packed and planar formats
+ * const packed = SampleFormat.getPackedFormat(AV_SAMPLE_FMT_FLTP);
+ * const planar = SampleFormat.getPlanarFormat(AV_SAMPLE_FMT_FLT);
+ * ```
+ */
+export class SampleFormatUtils {
+    // Private constructor to prevent instantiation
+    constructor() { }
+    /**
+     * Get bytes per sample for a sample format.
+     *
+     * Returns the number of bytes required to store one sample in the given format.
+     * Direct mapping to av_get_bytes_per_sample()
+     *
+     * @param format - Audio sample format
+     *
+     * @returns Number of bytes per sample, or 0 for invalid format
+     *
+     * @example
+     * ```typescript
+     * import { SampleFormat } from 'node-av';
+     * import { AV_SAMPLE_FMT_S16, AV_SAMPLE_FMT_FLT } from 'node-av/constants';
+     *
+     * console.log(SampleFormat.getBytesPerSample(AV_SAMPLE_FMT_S16)); // 2
+     * console.log(SampleFormat.getBytesPerSample(AV_SAMPLE_FMT_FLT)); // 4
+     * ```
+     */
+    static getBytesPerSample(format) {
+        return bindings.avGetBytesPerSample(format);
+    }
+    /**
+     * Get the name of a sample format.
+     *
+     * Returns a string describing the sample format.
+     * Direct mapping to av_get_sample_fmt_name()
+     *
+     * @param format - Audio sample format
+     *
+     * @returns Format name string, or null for invalid format
+     *
+     * @example
+     * ```typescript
+     * import { SampleFormat } from 'node-av';
+     * import { AV_SAMPLE_FMT_S16, AV_SAMPLE_FMT_FLTP } from 'node-av/constants';
+     *
+     * console.log(SampleFormat.getName(AV_SAMPLE_FMT_S16));  // "s16"
+     * console.log(SampleFormat.getName(AV_SAMPLE_FMT_FLTP)); // "fltp"
+     * ```
+     */
+    static getName(format) {
+        return bindings.avGetSampleFmtName(format);
+    }
+    /**
+     * Get packed sample format.
+     *
+     * Returns the packed variant of the given sample format.
+     * If the format is already packed, returns it unchanged.
+     * Direct mapping to av_get_packed_sample_fmt()
+     *
+     * @param format - Audio sample format
+     *
+     * @returns Packed sample format
+     *
+     * @example
+     * ```typescript
+     * import { SampleFormat } from 'node-av';
+     * import { AV_SAMPLE_FMT_FLTP, AV_SAMPLE_FMT_FLT } from 'node-av/constants';
+     *
+     * const packed = SampleFormat.getPackedFormat(AV_SAMPLE_FMT_FLTP);
+     * console.log(packed === AV_SAMPLE_FMT_FLT); // true
+     * ```
+     */
+    static getPackedFormat(format) {
+        return bindings.avGetPackedSampleFmt(format);
+    }
+    /**
+     * Get planar sample format.
+     *
+     * Returns the planar variant of the given sample format.
+     * If the format is already planar, returns it unchanged.
+     * Direct mapping to av_get_planar_sample_fmt()
+     *
+     * @param format - Audio sample format
+     *
+     * @returns Planar sample format
+     *
+     * @example
+     * ```typescript
+     * import { SampleFormat } from 'node-av';
+     * import { AV_SAMPLE_FMT_FLT, AV_SAMPLE_FMT_FLTP } from 'node-av/constants';
+     *
+     * const planar = SampleFormat.getPlanarFormat(AV_SAMPLE_FMT_FLT);
+     * console.log(planar === AV_SAMPLE_FMT_FLTP); // true
+     * ```
+     */
+    static getPlanarFormat(format) {
+        return bindings.avGetPlanarSampleFmt(format);
+    }
+    /**
+     * Check if sample format is planar.
+     *
+     * Returns true if the sample format stores each channel in a separate buffer.
+     * Returns false if all channels are interleaved in a single buffer.
+     * Direct mapping to av_sample_fmt_is_planar()
+     *
+     * @param format - Audio sample format
+     *
+     * @returns True if format is planar, false if packed/interleaved
+     *
+     * @example
+     * ```typescript
+     * import { SampleFormat } from 'node-av';
+     * import { AV_SAMPLE_FMT_S16, AV_SAMPLE_FMT_S16P } from 'node-av/constants';
+     *
+     * console.log(SampleFormat.isPlanar(AV_SAMPLE_FMT_S16));  // false (packed)
+     * console.log(SampleFormat.isPlanar(AV_SAMPLE_FMT_S16P)); // true (planar)
+     * ```
+     */
+    static isPlanar(format) {
+        return bindings.avSampleFmtIsPlanar(format);
+    }
+}
+//# sourceMappingURL=sample-format.js.map

package/dist/api/utilities/sample-format.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"sample-format.js","sourceRoot":"","sources":["../../../src/api/utilities/sample-format.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,EAAE,MAAM,sBAAsB,CAAC;AAIhD;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,MAAM,OAAO,iBAAiB;IAC5B,+CAA+C;IAC/C,gBAAuB,CAAC;IAExB;;;;;;;;;;;;;;;;;;OAkBG;IACH,MAAM,CAAC,iBAAiB,CAAC,MAAsB;QAC7C,OAAO,QAAQ,CAAC,mBAAmB,CAAC,MAAM,CAAC,CAAC;IAC9C,CAAC;IAED;;;;;;;;;;;;;;;;;;OAkBG;IACH,MAAM,CAAC,OAAO,CAAC,MAAsB;QACnC,OAAO,QAAQ,CAAC,kBAAkB,CAAC,MAAM,CAAC,CAAC;IAC7C,CAAC;IAED;;;;;;;;;;;;;;;;;;;OAmBG;IACH,MAAM,CAAC,eAAe,CAAC,MAAsB;QAC3C,OAAO,QAAQ,CAAC,oBAAoB,CAAC,MAAM,CAAC,CAAC;IAC/C,CAAC;IAED;;;;;;;;;;;;;;;;;;;OAmBG;IACH,MAAM,CAAC,eAAe,CAAC,MAAsB;QAC3C,OAAO,QAAQ,CAAC,oBAAoB,CAAC,MAAM,CAAC,CAAC;IAC/C,CAAC;IAED;;;;;;;;;;;;;;;;;;;OAmBG;IACH,MAAM,CAAC,QAAQ,CAAC,MAAsB;QACpC,OAAO,QAAQ,CAAC,mBAAmB,CAAC,MAAM,CAAC,CAAC;IAC9C,CAAC;CACF"}

package/dist/api/utilities/scheduler.d.ts

@@ -0,0 +1,138 @@
+import { Muxer } from '../muxer.js';
+import type { Frame, Packet } from '../../lib/index.js';
+import type { BitStreamFilterAPI } from '../bitstream-filter.js';
+import type { Encoder } from '../encoder.js';
+import type { FilterAPI } from '../filter.js';
+export interface SchedulableComponent<TItem = Packet | Frame> {
+    sendToQueue(item: TItem | null): Promise<void>;
+    pipeTo(target: FilterAPI | Encoder | BitStreamFilterAPI | Muxer, streamIndex?: number): any;
+}
+/**
+ * Pipeline scheduler for chaining components.
+ *
+ * Allows piping between components (Decoder → Filter → Encoder → Output).
+ */
+export declare class Scheduler<TSend = Packet | Frame> {
+    private firstComponent;
+    /** @internal */
+    lastComponent: SchedulableComponent<any>;
+    /**
+     * @param firstComponent - First component in the pipeline
+     *
+     * @param lastComponent - Last component in the pipeline (defaults to firstComponent)
+     *
+     * @internal
+     */
+    constructor(firstComponent: SchedulableComponent<TSend>, lastComponent?: SchedulableComponent<any>);
+    /**
+     * Pipe output to a filter component.
+     *
+     * @param target - Filter to receive frames
+     *
+     * @returns Scheduler for continued chaining
+     *
+     * @example
+     * ```typescript
+     * decoder.pipeTo(filter1).pipeTo(filter2)
+     * ```
+     */
+    pipeTo(target: FilterAPI): Scheduler<TSend>;
+    /**
+     * Pipe output to an encoder component.
+     *
+     * @param target - Encoder to receive frames
+     *
+     * @returns Scheduler for continued chaining
+     *
+     * @example
+     * ```typescript
+     * decoder.pipeTo(filter).pipeTo(encoder)
+     * ```
+     */
+    pipeTo(target: Encoder): Scheduler<TSend>;
+    /**
+     * Pipe output to a bitstream filter component.
+     *
+     * @param target - BitStreamFilter to receive packets
+     *
+     * @returns Scheduler for continued chaining
+     *
+     * @example
+     * ```typescript
+     * decoder.pipeTo(encoder).pipeTo(bsf).pipeTo(output, 0)
+     * ```
+     */
+    pipeTo(target: BitStreamFilterAPI): Scheduler<TSend>;
+    /**
+     * Pipe output to a muxer (final stage).
+     *
+     * @param output - Muxer to write to
+     *
+     * @param streamIndex - Stream index in output
+     *
+     * @returns Control interface without pipeTo
+     *
+     * @example
+     * ```typescript
+     * const control = decoder
+     *   .pipeTo(encoder)
+     *   .pipeTo(output, 0);
+     *
+     * await control.send(packet);
+     * ```
+     */
+    pipeTo(output: Muxer, streamIndex: number): SchedulerControl<TSend>;
+    /**
+     * Send an item into the pipeline or flush.
+     *
+     * When item is provided, queues it for processing through the pipeline.
+     * When null is provided, triggers flush sequence through all components.
+     *
+     * @param item - Packet or Frame to process, or null to flush
+     *
+     * @example
+     * ```typescript
+     * // Send packet for processing
+     * await scheduler.send(packet);
+     *
+     * // Flush pipeline
+     * await scheduler.send(null);
+     * ```
+     */
+    send(item: TSend | null): Promise<void>;
+}
+/**
+ * Control interface for completed pipelines.
+ *
+ * Provides control methods without pipeTo() - this is the final
+ * stage after piping to Muxer.
+ *
+ * @template TSend - The input type flowing through the pipeline
+ */
+export declare class SchedulerControl<TSend = Packet | Frame> {
+    private firstComponent;
+    /**
+     * @param firstComponent - First component in the pipeline
+     *
+     * @internal
+     */
+    constructor(firstComponent: SchedulableComponent<TSend>);
+    /**
+     * Send an item into the pipeline or flush.
+     *
+     * When item is provided, queues it for processing through the pipeline.
+     * When null is provided, triggers flush sequence through all components.
+     *
+     * @param item - Packet or Frame to process, or null to flush
+     *
+     * @example
+     * ```typescript
+     * // Send packet for processing
+     * await control.send(packet);
+     *
+     * // Flush pipeline
+     * await control.send(null);
+     * ```
+     */
+    send(item: TSend | null): Promise<void>;
+}

package/dist/api/utilities/scheduler.js

@@ -0,0 +1,98 @@
+import { Muxer } from '../muxer.js';
+/**
+ * Pipeline scheduler for chaining components.
+ *
+ * Allows piping between components (Decoder → Filter → Encoder → Output).
+ */
+export class Scheduler {
+    firstComponent;
+    /** @internal */
+    lastComponent;
+    /**
+     * @param firstComponent - First component in the pipeline
+     *
+     * @param lastComponent - Last component in the pipeline (defaults to firstComponent)
+     *
+     * @internal
+     */
+    constructor(firstComponent, lastComponent) {
+        this.firstComponent = firstComponent;
+        this.lastComponent = lastComponent ?? firstComponent;
+    }
+    pipeTo(target, streamIndex) {
+        if (typeof this.lastComponent.pipeTo === 'function') {
+            if (target instanceof Muxer) {
+                // Start the pipe task (encoder -> output)
+                this.lastComponent.pipeTo(target, streamIndex);
+                // Return control with correct firstComponent (not lastComponent!)
+                return new SchedulerControl(this.firstComponent);
+            }
+            else {
+                const resultScheduler = this.lastComponent.pipeTo(target);
+                // Keep the original firstComponent, update to new lastComponent
+                return new Scheduler(this.firstComponent, resultScheduler.lastComponent);
+            }
+        }
+        throw new Error('Last component does not support pipeTo');
+    }
+    /**
+     * Send an item into the pipeline or flush.
+     *
+     * When item is provided, queues it for processing through the pipeline.
+     * When null is provided, triggers flush sequence through all components.
+     *
+     * @param item - Packet or Frame to process, or null to flush
+     *
+     * @example
+     * ```typescript
+     * // Send packet for processing
+     * await scheduler.send(packet);
+     *
+     * // Flush pipeline
+     * await scheduler.send(null);
+     * ```
+     */
+    async send(item) {
+        await this.firstComponent.sendToQueue(item);
+    }
+}
+/**
+ * Control interface for completed pipelines.
+ *
+ * Provides control methods without pipeTo() - this is the final
+ * stage after piping to Muxer.
+ *
+ * @template TSend - The input type flowing through the pipeline
+ */
+export class SchedulerControl {
+    firstComponent;
+    /**
+     * @param firstComponent - First component in the pipeline
+     *
+     * @internal
+     */
+    constructor(firstComponent) {
+        this.firstComponent = firstComponent;
+    }
+    /**
+     * Send an item into the pipeline or flush.
+     *
+     * When item is provided, queues it for processing through the pipeline.
+     * When null is provided, triggers flush sequence through all components.
+     *
+     * @param item - Packet or Frame to process, or null to flush
+     *
+     * @example
+     * ```typescript
+     * // Send packet for processing
+     * await control.send(packet);
+     *
+     * // Flush pipeline
+     * await control.send(null);
+     * ```
+     */
+    async send(item) {
+        await this.firstComponent.sendToQueue(item);
+    }
+}
+//# sourceMappingURL=scheduler.js.map

package/dist/api/utilities/scheduler.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"scheduler.js","sourceRoot":"","sources":["../../../src/api/utilities/scheduler.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,EAAE,MAAM,aAAa,CAAC;AAYpC;;;;GAIG;AACH,MAAM,OAAO,SAAS;IACZ,cAAc,CAA8B;IAEpD,gBAAgB;IAChB,aAAa,CAA4B;IAEzC;;;;;;OAMG;IACH,YAAY,cAA2C,EAAE,aAAyC;QAChG,IAAI,CAAC,cAAc,GAAG,cAAc,CAAC;QACrC,IAAI,CAAC,aAAa,GAAG,aAAa,IAAI,cAAc,CAAC;IACvD,CAAC;IAgED,MAAM,CAAC,MAAwD,EAAE,WAAoB;QACnF,IAAI,OAAO,IAAI,CAAC,aAAa,CAAC,MAAM,KAAK,UAAU,EAAE,CAAC;YACpD,IAAI,MAAM,YAAY,KAAK,EAAE,CAAC;gBAC5B,0CAA0C;gBAC1C,IAAI,CAAC,aAAa,CAAC,MAAM,CAAC,MAAM,EAAE,WAAW,CAAC,CAAC;gBAC/C,kEAAkE;gBAClE,OAAO,IAAI,gBAAgB,CAAQ,IAAI,CAAC,cAAc,CAAC,CAAC;YAC1D,CAAC;iBAAM,CAAC;gBACN,MAAM,eAAe,GAAG,IAAI,CAAC,aAAa,CAAC,MAAM,CAAC,MAAM,CAAC,CAAC;gBAC1D,gEAAgE;gBAChE,OAAO,IAAI,SAAS,CAAQ,IAAI,CAAC,cAAc,EAAE,eAAe,CAAC,aAAa,CAAC,CAAC;YAClF,CAAC;QACH,CAAC;QAED,MAAM,IAAI,KAAK,CAAC,wCAAwC,CAAC,CAAC;IAC5D,CAAC;IAED;;;;;;;;;;;;;;;;OAgBG;IACH,KAAK,CAAC,IAAI,CAAC,IAAkB;QAC3B,MAAM,IAAI,CAAC,cAAc,CAAC,WAAW,CAAC,IAAI,CAAC,CAAC;IAC9C,CAAC;CACF;AAED;;;;;;;GAOG;AACH,MAAM,OAAO,gBAAgB;IACnB,cAAc,CAA8B;IAEpD;;;;OAIG;IACH,YAAY,cAA2C;QACrD,IAAI,CAAC,cAAc,GAAG,cAAc,CAAC;IACvC,CAAC;IAED;;;;;;;;;;;;;;;;OAgBG;IACH,KAAK,CAAC,IAAI,CAAC,IAAkB;QAC3B,MAAM,IAAI,CAAC,cAAc,CAAC,WAAW,CAAC,IAAI,CAAC,CAAC;IAC9C,CAAC;CACF"}