@camstack/addon-decoder-nodeav 0.1.1

package/dist/chunk-3GDQP6AS.mjs

@@ -0,0 +1,16 @@
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
+  get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
+}) : x)(function(x) {
+  if (typeof require !== "undefined") return require.apply(this, arguments);
+  throw Error('Dynamic require of "' + x + '" is not supported');
+});
+var __commonJS = (cb, mod) => function __require2() {
+  return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
+};
+
+export {
+  __require,
+  __commonJS
+};
+//# sourceMappingURL=chunk-3GDQP6AS.mjs.map

package/dist/chunk-3GDQP6AS.mjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"sourcesContent":[],"mappings":"","names":[]}

package/dist/index.d.mts

@@ -0,0 +1,293 @@
+import * as _camstack_types from '@camstack/types';
+import { BaseAddon, DecoderHwAccelConfig, IDecoderCapProvider, ProviderRegistration, FrameFormat, DecoderStats, IDecoderSession, DecoderSessionConfig, IScopedLogger, HwAccelBackend, IKernelHwAccel, EncodedPacket, DecodedFrame, Unsubscribe } from '@camstack/types';
+
+/**
+ * Phase 2d of the pipeline-settings migration — decoder addon now
+ * owns its own `hwaccel` choice + `probedBestHwaccel` hint. Sessions
+ * resolve the effective backend from this addon's global settings
+ * instead of the orchestrator's legacy `AgentPipelineSettings.hwaccel`.
+ * Shared config shape + UI options live in `@camstack/types`
+ * (`DecoderHwAccelConfig` / `HWACCEL_OPTIONS`) so every decoder addon
+ * speaks the same vocabulary.
+ */
+/** Cap-compatible frame shape — format must match DecodedFrameSchema enum values. */
+type CapDecodedFrame = {
+    data: Uint8Array<ArrayBuffer>;
+    width: number;
+    height: number;
+    format: FrameFormat;
+    timestamp: number;
+};
+/** Cap-compatible session config — matches DecoderSessionConfigSchema output type. */
+type CapDecoderSessionConfig = {
+    codec: string;
+    maxFps: number;
+    outputFormat: FrameFormat;
+    scale: number;
+    width?: number;
+    height?: number;
+};
+/** Cap-compatible encoded packet — data is Uint8Array matching EncodedPacketSchema. */
+type CapEncodedPacket = {
+    type: 'video' | 'audio';
+    data: Uint8Array<ArrayBuffer>;
+    pts: number;
+    dts: number;
+    keyframe: boolean;
+    codec: string;
+};
+declare class DecoderNodeAvAddon extends BaseAddon<DecoderHwAccelConfig> implements IDecoderCapProvider {
+    private readonly sessions;
+    private readonly frameBuffers;
+    private readonly unsubscribers;
+    private readonly sessionMeta;
+    constructor();
+    protected globalSettingsSchema(): _camstack_types.ConfigUISchema;
+    protected onInitialize(): Promise<ProviderRegistration[]>;
+    /**
+     * Resolve the effective hwaccel backend for a new session. Reads
+     * this addon's own `hwaccel` setting first. `'auto'` defers to the
+     * session's local resolver (`ctx.kernel.hwaccel`) which probes the
+     * host and picks. No more orchestrator round-trip — decoder addon
+     * is self-sufficient for this setting as of phase 2d.
+     */
+    private resolveHwAccelPref;
+    /**
+     * Re-run the platform probe on this host and persist the detected
+     * backend as `probedBestHwaccel`. The operator's `hwaccel` setting
+     * is intentionally left alone — the probe only updates the hint.
+     */
+    reprobeHwaccel(): Promise<{
+        backend: string;
+    }>;
+    supportsCodec(input: {
+        codec: string;
+    }): Promise<boolean>;
+    getInfo(): Promise<{
+        id: string;
+        name: string;
+        isPullMode?: boolean;
+        priority?: number;
+    }>;
+    createSession(config: CapDecoderSessionConfig): Promise<{
+        sessionId: string;
+        nodeId: string;
+    }>;
+    destroySession(input: {
+        sessionId: string;
+    }): Promise<void>;
+    listActiveSessions(): Promise<readonly {
+        sessionId: string;
+        codec: string;
+        outputFormat: string;
+        createdAtMs: number;
+    }[]>;
+    pushPacket(input: {
+        sessionId: string;
+        packet: CapEncodedPacket;
+    }): Promise<void>;
+    openStream(input: {
+        sessionId: string;
+        url: string;
+    }): Promise<void>;
+    pullFrames(input: {
+        sessionId: string;
+        maxCount: number;
+    }): Promise<CapDecodedFrame[]>;
+    updateConfig(input: {
+        sessionId: string;
+        config: Partial<CapDecoderSessionConfig>;
+    }): Promise<void>;
+    getStats(input: {
+        sessionId: string;
+    }): Promise<DecoderStats>;
+    protected onShutdown(): Promise<void>;
+}
+
+/**
+ * NodeAvDecoderSession — IDecoderSession using node-av **push mode**.
+ *
+ * Receives raw H.264/H.265 Annex-B packets from the StreamBroker and decodes
+ * them in-process using the node-av low-level API:
+ *
+ *   CodecParser  → splits raw Annex-B bytes into proper AVPackets
+ *   CodecContext  → software decode (sendPacket / receiveFrame)
+ *   SoftwareScaleContext → scale + convert to target format
+ *
+ * Output format depends on config.outputFormat:
+ *   'jpeg' → scale to RGB24, encode JPEG via sharp (for detection pipeline)
+ *   'gray' → scale to GRAY8 raw buffer (for motion detection only)
+ *
+ * No child process, no duplicate RTSP connection.
+ */
+
+type HwAccelPref = 'auto' | 'none' | HwAccelBackend;
+interface NodeAvDecoderSessionOptions {
+    /** Addon-level hwaccel preference — per-agent. Default `'auto'`. */
+    readonly hwaccel?: HwAccelPref;
+    /**
+     * Kernel hwaccel resolver — typically `ctx.kernel.hwaccel` passed
+     * from the addon. When present, `hwaccel: 'auto'` calls
+     * `resolver.resolve(null)` to get the platform-ordered backend
+     * list; when absent, `'auto'` degrades to software (the session
+     * cannot probe on its own because it lives in a package that must
+     * not depend on `@camstack/kernel`).
+     */
+    readonly hwaccelResolver?: IKernelHwAccel;
+}
+declare class NodeAvDecoderSession implements IDecoderSession {
+    private config;
+    private readonly logger;
+    private frameCallbacks;
+    private destroyed;
+    private parser;
+    private codecCtx;
+    private scaler;
+    private avPacket;
+    private avFrame;
+    private dstFrame;
+    private EAGAIN;
+    private PIX_FMT_GRAY8;
+    private PIX_FMT_RGB24;
+    private SWS_FAST_BILINEAR;
+    /**
+     * Decoder output mode. Drives both the scaler's destination pixel
+     * format and whether sharp runs the JPEG encode at the end:
+     *
+     * - `'jpeg'` — scaler→RGB24 → sharp encode → emit JPEG bytes
+     * - `'rgb'`  — scaler→RGB24 → emit raw RGB24 (no sharp)
+     * - `'gray'` — scaler→GRAY8 → emit raw GRAY8 (no sharp)
+     *
+     * The broker holds the policy decision on which mode to request based
+     * on its active subscribers; on-the-fly conversion (e.g. RGB→JPEG for
+     * a WebRTC consumer that joined while detection holds the decoder in
+     * RGB mode) happens broker-side via the per-frame conversion cache.
+     */
+    private outputMode;
+    private sharpFn;
+    /**
+     * Backpressure for the sharp JPEG encode pipeline. The broker
+     * currently creates sessions with `maxFps: 0` (unlimited) and relies
+     * on per-subscriber throttling, so without a bound the
+     * fire-and-forget `sharp(...).toBuffer()` chain would accumulate
+     * unboundedly whenever sharp falls behind the decoder. Cap at
+     * `MAX_JPEG_INFLIGHT` pending encodes per session — any frame that
+     * arrives while the cap is saturated is dropped and counted.
+     */
+    private static readonly MAX_JPEG_INFLIGHT;
+    private jpegEncodeInFlight;
+    /**
+     * Map a `DecoderSessionConfig.outputFormat` value to one of the three
+     * native scaler/encoder modes the session understands. The cap-level
+     * format vocabulary is broader (it accepts `bgr`, `yuv420`) than what
+     * libav's scaler is wired for here — anything else degrades to RGB
+     * (the canonical raw mode) and the broker is expected to convert
+     * downstream if a subscriber needs a different shape.
+     */
+    private static resolveOutputMode;
+    private initialized;
+    private initializing;
+    private scalerInitializing;
+    /**
+     * Monotonic counter incremented by `updateConfig` whenever the
+     * scaler + dstFrame get invalidated (e.g. output format toggle).
+     * `initScaler` captures the current value at entry and aborts — or
+     * disposes the locally-built scaler — if the epoch moved while
+     * its async init was in flight. Without this, a toggle racing an
+     * in-flight init could leave two scalers allocated natively while
+     * `this.scaler` only holds a reference to one → libav leak.
+     */
+    private scalerEpoch;
+    /**
+     * One-shot guard for the "first frame" diagnostic log + raw frame
+     * dump. Setting this synchronously inside `emitDecodedFrame`
+     * prevents re-entry — without it we were using `outputFrames === 0`
+     * which stays true until the async sharp encode callback runs, so
+     * several decoded frames could trigger the dump before the first
+     * JPEG landed.
+     */
+    private firstFrameLogged;
+    private outWidth;
+    private outHeight;
+    private lastEmitTime;
+    private minIntervalMs;
+    private inputPackets;
+    private outputFrames;
+    private droppedFrames;
+    private totalDecodeTimeMs;
+    private startTime;
+    private readonly hwaccelPref;
+    private readonly hwaccelResolver;
+    /** The backend that actually initialised successfully — `'none'` = software fallback. */
+    private activeHwAccel;
+    private hwDevice;
+    private swTransferFrame;
+    constructor(config: DecoderSessionConfig, logger?: IScopedLogger, options?: NodeAvDecoderSessionOptions);
+    /**
+     * Resolve the backend preference list and try each one against
+     * node-av's HW context APIs. The first backend whose
+     * `HardwareDeviceContext.create()` succeeds gets attached to
+     * `codecCtx.hwDeviceCtx` + its hw pixel format registered via
+     * `setHardwarePixelFormat`. On any failure, falls through to the
+     * next backend; if all fail, returns with `activeHwAccel='none'`
+     * and the decoder runs in software on the same context.
+     */
+    private tryAttachHwAccel;
+    /**
+     * Download a HW frame (format == hw pix fmt) into a SW frame so the
+     * rest of the pipeline (scaler, JPEG encoder, grayscale passthrough)
+     * handles it identically to the pure-software path. Uses the sync
+     * variant so the synchronous receive loop below doesn't need to be
+     * async-ified. Returns `null` on transfer failure, meaning the
+     * caller should drop the frame.
+     */
+    private transferHwFrame;
+    /**
+     * Initialize the decoder pipeline on the first keyframe.
+     * After this returns, all hot-path methods are fully synchronous (except JPEG encode).
+     */
+    private initDecoder;
+    /**
+     * Initialize the scaler after the first frame tells us the actual
+     * dimensions. Output pixel format: RGB24 for JPEG encoding, GRAY8
+     * for raw motion.
+     *
+     * Builds `scaler` + `dstFrame` on local variables and publishes
+     * them onto `this` in a single atomic step at the end. Captures
+     * `scalerEpoch` at entry; if `updateConfig` invalidated the scaler
+     * while this init was in flight (epoch mismatch), the locally
+     * built pair is disposed and discarded so the later init wins.
+     * Without the local-first approach, partial state (scaler set,
+     * dstFrame still null) could be observed by a concurrent
+     * `emitDecodedFrame` call.
+     */
+    private initScaler;
+    pushPacket(packet: EncodedPacket): void;
+    private decodeRawData;
+    private decodePacket;
+    private emitDecodedFrame;
+    /**
+     * Extract packed pixel buffer from a decoded frame.
+     * FFmpeg's av_frame_get_buffer() may pad each row to alignment (32/64 bytes).
+     * Sharp and WASM consumers expect tightly-packed rows (stride = width * channels).
+     * If linesize matches expected stride, return the buffer directly (zero-copy).
+     */
+    private extractPackedBuffer;
+    /**
+     * Encode RGB24 raw buffer as JPEG and emit.
+     *
+     * Drops the frame (and counts it) when `MAX_JPEG_INFLIGHT` encodes
+     * are already pending — prevents unbounded growth of the
+     * fire-and-forget promise chain when sharp cannot keep up with the
+     * decode rate.
+     */
+    private encodeAndEmitJpeg;
+    private emitRawFrame;
+    onFrame(callback: (frame: DecodedFrame) => void): Unsubscribe;
+    updateConfig(update: Partial<DecoderSessionConfig>): void;
+    destroy(): Promise<void>;
+    getStats(): DecoderStats;
+    get isPullMode(): boolean;
+}
+
+export { DecoderNodeAvAddon, NodeAvDecoderSession };

package/dist/index.d.ts

@@ -0,0 +1,293 @@
+import * as _camstack_types from '@camstack/types';
+import { BaseAddon, DecoderHwAccelConfig, IDecoderCapProvider, ProviderRegistration, FrameFormat, DecoderStats, IDecoderSession, DecoderSessionConfig, IScopedLogger, HwAccelBackend, IKernelHwAccel, EncodedPacket, DecodedFrame, Unsubscribe } from '@camstack/types';
+
+/**
+ * Phase 2d of the pipeline-settings migration — decoder addon now
+ * owns its own `hwaccel` choice + `probedBestHwaccel` hint. Sessions
+ * resolve the effective backend from this addon's global settings
+ * instead of the orchestrator's legacy `AgentPipelineSettings.hwaccel`.
+ * Shared config shape + UI options live in `@camstack/types`
+ * (`DecoderHwAccelConfig` / `HWACCEL_OPTIONS`) so every decoder addon
+ * speaks the same vocabulary.
+ */
+/** Cap-compatible frame shape — format must match DecodedFrameSchema enum values. */
+type CapDecodedFrame = {
+    data: Uint8Array<ArrayBuffer>;
+    width: number;
+    height: number;
+    format: FrameFormat;
+    timestamp: number;
+};
+/** Cap-compatible session config — matches DecoderSessionConfigSchema output type. */
+type CapDecoderSessionConfig = {
+    codec: string;
+    maxFps: number;
+    outputFormat: FrameFormat;
+    scale: number;
+    width?: number;
+    height?: number;
+};
+/** Cap-compatible encoded packet — data is Uint8Array matching EncodedPacketSchema. */
+type CapEncodedPacket = {
+    type: 'video' | 'audio';
+    data: Uint8Array<ArrayBuffer>;
+    pts: number;
+    dts: number;
+    keyframe: boolean;
+    codec: string;
+};
+declare class DecoderNodeAvAddon extends BaseAddon<DecoderHwAccelConfig> implements IDecoderCapProvider {
+    private readonly sessions;
+    private readonly frameBuffers;
+    private readonly unsubscribers;
+    private readonly sessionMeta;
+    constructor();
+    protected globalSettingsSchema(): _camstack_types.ConfigUISchema;
+    protected onInitialize(): Promise<ProviderRegistration[]>;
+    /**
+     * Resolve the effective hwaccel backend for a new session. Reads
+     * this addon's own `hwaccel` setting first. `'auto'` defers to the
+     * session's local resolver (`ctx.kernel.hwaccel`) which probes the
+     * host and picks. No more orchestrator round-trip — decoder addon
+     * is self-sufficient for this setting as of phase 2d.
+     */
+    private resolveHwAccelPref;
+    /**
+     * Re-run the platform probe on this host and persist the detected
+     * backend as `probedBestHwaccel`. The operator's `hwaccel` setting
+     * is intentionally left alone — the probe only updates the hint.
+     */
+    reprobeHwaccel(): Promise<{
+        backend: string;
+    }>;
+    supportsCodec(input: {
+        codec: string;
+    }): Promise<boolean>;
+    getInfo(): Promise<{
+        id: string;
+        name: string;
+        isPullMode?: boolean;
+        priority?: number;
+    }>;
+    createSession(config: CapDecoderSessionConfig): Promise<{
+        sessionId: string;
+        nodeId: string;
+    }>;
+    destroySession(input: {
+        sessionId: string;
+    }): Promise<void>;
+    listActiveSessions(): Promise<readonly {
+        sessionId: string;
+        codec: string;
+        outputFormat: string;
+        createdAtMs: number;
+    }[]>;
+    pushPacket(input: {
+        sessionId: string;
+        packet: CapEncodedPacket;
+    }): Promise<void>;
+    openStream(input: {
+        sessionId: string;
+        url: string;
+    }): Promise<void>;
+    pullFrames(input: {
+        sessionId: string;
+        maxCount: number;
+    }): Promise<CapDecodedFrame[]>;
+    updateConfig(input: {
+        sessionId: string;
+        config: Partial<CapDecoderSessionConfig>;
+    }): Promise<void>;
+    getStats(input: {
+        sessionId: string;
+    }): Promise<DecoderStats>;
+    protected onShutdown(): Promise<void>;
+}
+
+/**
+ * NodeAvDecoderSession — IDecoderSession using node-av **push mode**.
+ *
+ * Receives raw H.264/H.265 Annex-B packets from the StreamBroker and decodes
+ * them in-process using the node-av low-level API:
+ *
+ *   CodecParser  → splits raw Annex-B bytes into proper AVPackets
+ *   CodecContext  → software decode (sendPacket / receiveFrame)
+ *   SoftwareScaleContext → scale + convert to target format
+ *
+ * Output format depends on config.outputFormat:
+ *   'jpeg' → scale to RGB24, encode JPEG via sharp (for detection pipeline)
+ *   'gray' → scale to GRAY8 raw buffer (for motion detection only)
+ *
+ * No child process, no duplicate RTSP connection.
+ */
+
+type HwAccelPref = 'auto' | 'none' | HwAccelBackend;
+interface NodeAvDecoderSessionOptions {
+    /** Addon-level hwaccel preference — per-agent. Default `'auto'`. */
+    readonly hwaccel?: HwAccelPref;
+    /**
+     * Kernel hwaccel resolver — typically `ctx.kernel.hwaccel` passed
+     * from the addon. When present, `hwaccel: 'auto'` calls
+     * `resolver.resolve(null)` to get the platform-ordered backend
+     * list; when absent, `'auto'` degrades to software (the session
+     * cannot probe on its own because it lives in a package that must
+     * not depend on `@camstack/kernel`).
+     */
+    readonly hwaccelResolver?: IKernelHwAccel;
+}
+declare class NodeAvDecoderSession implements IDecoderSession {
+    private config;
+    private readonly logger;
+    private frameCallbacks;
+    private destroyed;
+    private parser;
+    private codecCtx;
+    private scaler;
+    private avPacket;
+    private avFrame;
+    private dstFrame;
+    private EAGAIN;
+    private PIX_FMT_GRAY8;
+    private PIX_FMT_RGB24;
+    private SWS_FAST_BILINEAR;
+    /**
+     * Decoder output mode. Drives both the scaler's destination pixel
+     * format and whether sharp runs the JPEG encode at the end:
+     *
+     * - `'jpeg'` — scaler→RGB24 → sharp encode → emit JPEG bytes
+     * - `'rgb'`  — scaler→RGB24 → emit raw RGB24 (no sharp)
+     * - `'gray'` — scaler→GRAY8 → emit raw GRAY8 (no sharp)
+     *
+     * The broker holds the policy decision on which mode to request based
+     * on its active subscribers; on-the-fly conversion (e.g. RGB→JPEG for
+     * a WebRTC consumer that joined while detection holds the decoder in
+     * RGB mode) happens broker-side via the per-frame conversion cache.
+     */
+    private outputMode;
+    private sharpFn;
+    /**
+     * Backpressure for the sharp JPEG encode pipeline. The broker
+     * currently creates sessions with `maxFps: 0` (unlimited) and relies
+     * on per-subscriber throttling, so without a bound the
+     * fire-and-forget `sharp(...).toBuffer()` chain would accumulate
+     * unboundedly whenever sharp falls behind the decoder. Cap at
+     * `MAX_JPEG_INFLIGHT` pending encodes per session — any frame that
+     * arrives while the cap is saturated is dropped and counted.
+     */
+    private static readonly MAX_JPEG_INFLIGHT;
+    private jpegEncodeInFlight;
+    /**
+     * Map a `DecoderSessionConfig.outputFormat` value to one of the three
+     * native scaler/encoder modes the session understands. The cap-level
+     * format vocabulary is broader (it accepts `bgr`, `yuv420`) than what
+     * libav's scaler is wired for here — anything else degrades to RGB
+     * (the canonical raw mode) and the broker is expected to convert
+     * downstream if a subscriber needs a different shape.
+     */
+    private static resolveOutputMode;
+    private initialized;
+    private initializing;
+    private scalerInitializing;
+    /**
+     * Monotonic counter incremented by `updateConfig` whenever the
+     * scaler + dstFrame get invalidated (e.g. output format toggle).
+     * `initScaler` captures the current value at entry and aborts — or
+     * disposes the locally-built scaler — if the epoch moved while
+     * its async init was in flight. Without this, a toggle racing an
+     * in-flight init could leave two scalers allocated natively while
+     * `this.scaler` only holds a reference to one → libav leak.
+     */
+    private scalerEpoch;
+    /**
+     * One-shot guard for the "first frame" diagnostic log + raw frame
+     * dump. Setting this synchronously inside `emitDecodedFrame`
+     * prevents re-entry — without it we were using `outputFrames === 0`
+     * which stays true until the async sharp encode callback runs, so
+     * several decoded frames could trigger the dump before the first
+     * JPEG landed.
+     */
+    private firstFrameLogged;
+    private outWidth;
+    private outHeight;
+    private lastEmitTime;
+    private minIntervalMs;
+    private inputPackets;
+    private outputFrames;
+    private droppedFrames;
+    private totalDecodeTimeMs;
+    private startTime;
+    private readonly hwaccelPref;
+    private readonly hwaccelResolver;
+    /** The backend that actually initialised successfully — `'none'` = software fallback. */
+    private activeHwAccel;
+    private hwDevice;
+    private swTransferFrame;
+    constructor(config: DecoderSessionConfig, logger?: IScopedLogger, options?: NodeAvDecoderSessionOptions);
+    /**
+     * Resolve the backend preference list and try each one against
+     * node-av's HW context APIs. The first backend whose
+     * `HardwareDeviceContext.create()` succeeds gets attached to
+     * `codecCtx.hwDeviceCtx` + its hw pixel format registered via
+     * `setHardwarePixelFormat`. On any failure, falls through to the
+     * next backend; if all fail, returns with `activeHwAccel='none'`
+     * and the decoder runs in software on the same context.
+     */
+    private tryAttachHwAccel;
+    /**
+     * Download a HW frame (format == hw pix fmt) into a SW frame so the
+     * rest of the pipeline (scaler, JPEG encoder, grayscale passthrough)
+     * handles it identically to the pure-software path. Uses the sync
+     * variant so the synchronous receive loop below doesn't need to be
+     * async-ified. Returns `null` on transfer failure, meaning the
+     * caller should drop the frame.
+     */
+    private transferHwFrame;
+    /**
+     * Initialize the decoder pipeline on the first keyframe.
+     * After this returns, all hot-path methods are fully synchronous (except JPEG encode).
+     */
+    private initDecoder;
+    /**
+     * Initialize the scaler after the first frame tells us the actual
+     * dimensions. Output pixel format: RGB24 for JPEG encoding, GRAY8
+     * for raw motion.
+     *
+     * Builds `scaler` + `dstFrame` on local variables and publishes
+     * them onto `this` in a single atomic step at the end. Captures
+     * `scalerEpoch` at entry; if `updateConfig` invalidated the scaler
+     * while this init was in flight (epoch mismatch), the locally
+     * built pair is disposed and discarded so the later init wins.
+     * Without the local-first approach, partial state (scaler set,
+     * dstFrame still null) could be observed by a concurrent
+     * `emitDecodedFrame` call.
+     */
+    private initScaler;
+    pushPacket(packet: EncodedPacket): void;
+    private decodeRawData;
+    private decodePacket;
+    private emitDecodedFrame;
+    /**
+     * Extract packed pixel buffer from a decoded frame.
+     * FFmpeg's av_frame_get_buffer() may pad each row to alignment (32/64 bytes).
+     * Sharp and WASM consumers expect tightly-packed rows (stride = width * channels).
+     * If linesize matches expected stride, return the buffer directly (zero-copy).
+     */
+    private extractPackedBuffer;
+    /**
+     * Encode RGB24 raw buffer as JPEG and emit.
+     *
+     * Drops the frame (and counts it) when `MAX_JPEG_INFLIGHT` encodes
+     * are already pending — prevents unbounded growth of the
+     * fire-and-forget promise chain when sharp cannot keep up with the
+     * decode rate.
+     */
+    private encodeAndEmitJpeg;
+    private emitRawFrame;
+    onFrame(callback: (frame: DecodedFrame) => void): Unsubscribe;
+    updateConfig(update: Partial<DecoderSessionConfig>): void;
+    destroy(): Promise<void>;
+    getStats(): DecoderStats;
+    get isPullMode(): boolean;
+}
+
+export { DecoderNodeAvAddon, NodeAvDecoderSession };