@pipedog/core 0.1.0 → 0.2.0

package/dist/audio/vad/vad_analyzer.js

@@ -135,9 +135,29 @@ export class VADAnalyzer {
      * @returns Current VAD state after processing the buffer.
      */
     async analyzeAudio(buffer) {
-        return this._runAnalyzer(buffer);
+        // One buffer at a time, like upstream's single-thread executor: an
+        // asynchronous model must not interleave two buffers' windows.
+        while (this.#analyzing)
+            await this.#analyzing;
+        const state = this._runAnalyzer(buffer);
+        if (!isPromiseLike(state))
+            return state;
+        const done = Promise.resolve(state).then(() => { }, () => { });
+        this.#analyzing = done;
+        try {
+            return await state;
+        }
+        finally {
+            if (this.#analyzing === done)
+                this.#analyzing = null;
+        }
     }
-    /** Analyze audio buffer and return current VAD state. */
+    #analyzing = null;
+    /**
+     * Analyze audio buffer and return current VAD state.
+     *
+     * Synchronous when `voiceConfidence` is; otherwise returns a promise.
+     */
     _runAnalyzer(buffer) {
         const combined = new Uint8Array(this._vadBuffer.length + buffer.length);
         combined.set(this._vadBuffer, 0);
@@ -147,43 +167,22 @@ export class VADAnalyzer {
         if (this._vadBuffer.length < numRequiredBytes) {
             return this._vadState;
         }
+        return this.#analyzeWindows();
+    }
+    /** Score every complete window in the buffer, then settle the state. */
+    #analyzeWindows() {
+        const numRequiredBytes = this._vadFramesNumBytes;
         while (this._vadBuffer.length >= numRequiredBytes) {
             const audioFrames = this._vadBuffer.slice(0, numRequiredBytes);
             this._vadBuffer = this._vadBuffer.subarray(numRequiredBytes);
             const confidence = this.voiceConfidence(audioFrames);
-            const volume = this._getSmoothedVolume(audioFrames);
-            this._prevVolume = volume;
-            const speaking = confidence >= this._params.confidence && volume >= this._params.minVolume;
-            if (speaking) {
-                switch (this._vadState) {
-                    case VADState.QUIET:
-                        this._vadState = VADState.STARTING;
-                        this._vadStartingCount = 1;
-                        break;
-                    case VADState.STARTING:
-                        this._vadStartingCount += 1;
-                        break;
-                    case VADState.STOPPING:
-                        this._vadState = VADState.SPEAKING;
-                        this._vadStoppingCount = 0;
-                        break;
-                }
-            }
-            else {
-                switch (this._vadState) {
-                    case VADState.STARTING:
-                        this._vadState = VADState.QUIET;
-                        this._vadStartingCount = 0;
-                        break;
-                    case VADState.SPEAKING:
-                        this._vadState = VADState.STOPPING;
-                        this._vadStoppingCount = 1;
-                        break;
-                    case VADState.STOPPING:
-                        this._vadStoppingCount += 1;
-                        break;
-                }
+            if (isPromiseLike(confidence)) {
+                return Promise.resolve(confidence).then((c) => {
+                    this.#updateState(audioFrames, c);
+                    return this.#analyzeWindows();
+                });
             }
+            this.#updateState(audioFrames, confidence);
         }
         if (this._vadState === VADState.STARTING && this._vadStartingCount >= this._vadStartFrames) {
             this._vadState = VADState.SPEAKING;
@@ -195,6 +194,42 @@ export class VADAnalyzer {
         }
         return this._vadState;
     }
+    /** Advance the state machine with one window's confidence. */
+    #updateState(audioFrames, confidence) {
+        const volume = this._getSmoothedVolume(audioFrames);
+        this._prevVolume = volume;
+        const speaking = confidence >= this._params.confidence && volume >= this._params.minVolume;
+        if (speaking) {
+            switch (this._vadState) {
+                case VADState.QUIET:
+                    this._vadState = VADState.STARTING;
+                    this._vadStartingCount = 1;
+                    break;
+                case VADState.STARTING:
+                    this._vadStartingCount += 1;
+                    break;
+                case VADState.STOPPING:
+                    this._vadState = VADState.SPEAKING;
+                    this._vadStoppingCount = 0;
+                    break;
+            }
+        }
+        else {
+            switch (this._vadState) {
+                case VADState.STARTING:
+                    this._vadState = VADState.QUIET;
+                    this._vadStartingCount = 0;
+                    break;
+                case VADState.SPEAKING:
+                    this._vadState = VADState.STOPPING;
+                    this._vadStoppingCount = 1;
+                    break;
+                case VADState.STOPPING:
+                    this._vadStoppingCount += 1;
+                    break;
+            }
+        }
+    }
     /**
      * Release the analyzer's resources.
      *
@@ -203,6 +238,9 @@ export class VADAnalyzer {
      */
     async cleanup() { }
 }
+function isPromiseLike(x) {
+    return typeof x?.then === "function";
+}
 /** Python's round(): half to even. */
 function pyRound(x) {
     const r = Math.round(x);

package/dist/pipeline/worker.d.ts

@@ -332,6 +332,8 @@ export declare class PipelineWorker extends BaseWorker {
     protected _clock: BaseClock;
     protected _conversationId: string | null;
     protected _enableTracing: boolean;
+    /** `enableTracing` as given; `_enableTracing` also needs OpenTelemetry. */
+    protected _tracingRequested: boolean;
     protected _enableTurnTracking: boolean;
     protected _idleTimeoutSecs: number | null;
     protected _appResources: unknown;
@@ -396,6 +398,11 @@ export declare class PipelineWorker extends BaseWorker {
      * internal processors added by the pipeline worker.
      */
     get pipeline(): BasePipeline;
+    /**
+     * Create the pipeline-scoped tracing context and the latency and turn trace
+     * observers (with turn tracking enabled), and return the observers to add.
+     */
+    protected _createTracingObservers(): BaseObserver[];
     /** The turn tracking observer if enabled, or null. */
     get turnTrackingObserver(): TurnTrackingObserver | null;
     /** The turn trace observer if enabled, or null. */

package/dist/pipeline/worker.js

@@ -33,7 +33,7 @@ import { BaseInputTransport } from "../transports/base_input.js";
 import { BaseOutputTransport } from "../transports/base_output.js";
 import { logger } from "../utils/logger.js";
 import { runSetupHook } from "../utils/startup.js";
-import { isTracingAvailable } from "../utils/tracing/setup.js";
+import { isTracingAvailable, loadOpenTelemetry, } from "../utils/tracing/setup.js";
 import { TracingContext } from "../utils/tracing/tracing_context.js";
 import { TurnTraceObserver } from "../utils/tracing/turn_trace_observer.js";
 import { BaseWorker, } from "../workers/base_worker.js";
@@ -213,6 +213,8 @@ export class PipelineWorker extends BaseWorker {
     _clock;
     _conversationId;
     _enableTracing;
+    /** `enableTracing` as given; `_enableTracing` also needs OpenTelemetry. */
+    _tracingRequested;
     _enableTurnTracking;
     _idleTimeoutSecs;
     _appResources;
@@ -290,7 +292,10 @@ export class PipelineWorker extends BaseWorker {
         this._startTimeoutSecs = options.startTimeoutSecs ?? START_TIMEOUT_SECS;
         this._clock = options.clock ?? new SystemClock();
         this._conversationId = options.conversationId ?? null;
-        this._enableTracing = (options.enableTracing ?? false) && isTracingAvailable();
+        this._tracingRequested = options.enableTracing ?? false;
+        // Rechecked in _setup() (after awaiting core's asynchronous import of
+        // OpenTelemetry), so building the worker early never disables tracing.
+        this._enableTracing = this._tracingRequested && isTracingAvailable();
         this._enableTurnTracking = options.enableTurnTracking ?? true;
         this._idleTimeoutSecs =
             options.idleTimeoutSecs === undefined ? IDLE_TIMEOUT_SECS : options.idleTimeoutSecs;
@@ -311,21 +316,8 @@ export class PipelineWorker extends BaseWorker {
             this._turnTrackingObserver = new TurnTrackingObserver();
             observers.push(this._turnTrackingObserver);
         }
-        if (this._enableTracing && this._turnTrackingObserver) {
-            // Create pipeline-scoped tracing context
-            this._tracingContext = new TracingContext();
-            // Create latency observer for tracing
-            this._userBotLatencyObserver = new UserBotLatencyObserver();
-            observers.push(this._userBotLatencyObserver);
-            // Create turn trace observer with latency tracking
-            this._turnTraceObserver = new TurnTraceObserver({
-                turnTracker: this._turnTrackingObserver,
-                latencyTracker: this._userBotLatencyObserver,
-                conversationId: this._conversationId,
-                additionalSpanAttributes: this._additionalSpanAttributes,
-                tracingContext: this._tracingContext,
-            });
-            observers.push(this._turnTraceObserver);
+        if (this._enableTracing) {
+            observers.push(...this._createTracingObservers());
         }
         // RTVI support
         const enableRtvi = options.enableRtvi ?? bridged === null;
@@ -467,6 +459,28 @@ export class PipelineWorker extends BaseWorker {
     get pipeline() {
         return this._pipeline;
     }
+    /**
+     * Create the pipeline-scoped tracing context and the latency and turn trace
+     * observers (with turn tracking enabled), and return the observers to add.
+     */
+    _createTracingObservers() {
+        if (!this._turnTrackingObserver) {
+            return [];
+        }
+        // Create pipeline-scoped tracing context
+        this._tracingContext = new TracingContext();
+        // Create latency observer for tracing
+        this._userBotLatencyObserver = new UserBotLatencyObserver();
+        // Create turn trace observer with latency tracking
+        this._turnTraceObserver = new TurnTraceObserver({
+            turnTracker: this._turnTrackingObserver,
+            latencyTracker: this._userBotLatencyObserver,
+            conversationId: this._conversationId,
+            additionalSpanAttributes: this._additionalSpanAttributes,
+            tracingContext: this._tracingContext,
+        });
+        return [this._userBotLatencyObserver, this._turnTraceObserver];
+    }
     /** The turn tracking observer if enabled, or null. */
     get turnTrackingObserver() {
         return this._turnTrackingObserver;
@@ -1144,12 +1158,6 @@ export class PipelineWorker extends BaseWorker {
             // the audio the EndFrame exists to play out. A processor that could
             // hold it up watches for that itself.
             await this._pipelineEndEvent.wait();
-            // In asyncio the processor that pushed the EndFrame keeps running until
-            // it next suspends, so work it does right after pushing it (e.g. the
-            // user aggregator flushing its turn at session end) completes before
-            // teardown. Promise continuations interleave instead, so yield one
-            // macrotask to let that processor finish before cleaning up.
-            await sleep(0);
             logger.debug(`${this}: ${frame} reached the end of the pipeline, pipeline is closing.`);
         }
         this._pipelineEndEvent.clear();
@@ -1198,6 +1206,15 @@ export class PipelineWorker extends BaseWorker {
         await super.setup(this._taskManager ?? params.taskManager);
         // Do any additional pipeline worker setup externally.
         await this._loadSetupFiles();
+        // Core imports OpenTelemetry asynchronously: a worker built before that
+        // import finished (e.g. at module top level) turns tracing on here,
+        // before the observers start and the processors get `enableTracing`.
+        if (this._tracingRequested && !this._enableTracing && (await loadOpenTelemetry())) {
+            this._enableTracing = true;
+            for (const observer of this._createTracingObservers()) {
+                this._observer.addObserver(observer);
+            }
+        }
         // Start worker observer.
         await this._observer.setup(this.taskManager);
         // Setup processors

package/dist/utils/file_storage.d.ts

@@ -1,21 +1,3 @@
-/**
- * Pluggable storage for files uploaded by clients and referenced by URL later.
- *
- * `FileStorage` is the shared interface between the development runner's
- * `POST /files` upload endpoint, which saves uploads and hands the resulting
- * URL back to the client, and the LLM service's `FileResolver`, which loads
- * the bytes back when the client references that URL in a send-file message.
- * Passing the same storage instance to both means they agree on where uploads
- * live without each needing its own copy of the configuration, and lets a
- * deployment swap in a backend other than local disk by implementing this
- * interface.
- *
- * The URL is the contract: `FileStorage.save` returns one, callers pass it
- * back unmodified, and each implementation mints whatever form it can later
- * resolve — `pipecat:<id>` for `LocalFileStorage`, or e.g. `gs://` / `s3://`
- * for a custom cloud backend (which the LLM provider may then even fetch
- * itself, without `FileStorage.load` being involved at all).
- */
 /**
  * Thrown by `FileStorage.load` when a URL is invalid or no longer stored
  * (Python's built-in `FileNotFoundError`).
@@ -60,6 +42,29 @@ export declare abstract class FileStorage {
      */
     abstract delete(fileUrl: string): Promise<void>;
 }
+/**
+ * The file operations `LocalFileStorage` needs: a subset of
+ * `node:fs/promises`, which satisfies it as is
+ * (`import * as fs from "node:fs/promises"`; Deno and Bun provide it too).
+ * Core has no filesystem access of its own, so the storage takes one.
+ */
+export interface LocalFileSystem {
+    mkdir(path: string, options: {
+        recursive: true;
+    }): Promise<unknown>;
+    writeFile(path: string, data: Uint8Array): Promise<void>;
+    readFile(path: string): Promise<Uint8Array>;
+    unlink(path: string): Promise<void>;
+    readdir(path: string, options: {
+        withFileTypes: true;
+    }): Promise<Array<{
+        name: string;
+        isFile(): boolean;
+    }>>;
+    stat(path: string): Promise<{
+        mtimeMs: number;
+    }>;
+}
 export interface LocalFileStorageOptions {
     /** Directory to store files in. Created on first save if missing. */
     folder: string;
@@ -68,6 +73,11 @@ export interface LocalFileStorageOptions {
      * once this is exceeded. Set to 0 to disable trimming.
      */
     maxFiles?: number;
+    /**
+     * The filesystem to store files on, e.g. `node:fs/promises`. Required for
+     * `save`, `load` and `delete`; URL validation works without it.
+     */
+    fs?: LocalFileSystem;
 }
 /**
  * Default storage backend: files on local disk, addressed as `pipecat:<hex>`.
@@ -77,8 +87,9 @@ export interface LocalFileStorageOptions {
  * the random hex suffix can't be used for path traversal and doesn't leak the
  * original filename.
  *
- * STUB: disk I/O (`save`, `load`, `delete`, trimming) is not ported, since core
- * cannot import `node:fs`. URL validation is.
+ * Porting note: upstream writes with `aiofiles` and `pathlib`. Core cannot
+ * import `node:fs`, so the disk is reached through the `fs` option (see
+ * `LocalFileSystem`).
  */
 export declare class LocalFileStorage extends FileStorage {
     deleteAfterLoad: boolean;
@@ -86,14 +97,19 @@ export declare class LocalFileStorage extends FileStorage {
     protected static readonly _URL_SUFFIX_PATTERN: RegExp;
     protected _folder: string;
     protected _maxFiles: number;
+    protected _fsImpl: LocalFileSystem | null;
     constructor(options: LocalFileStorageOptions);
     /** Write `contents` to a new randomly-named file and return its `pipecat:` URL. */
-    save(_filename: string, _contents: Uint8Array): Promise<string>;
+    save(_filename: string, contents: Uint8Array): Promise<string>;
     /** Read and return the contents stored under `fileUrl`. */
     load(fileUrl: string): Promise<Uint8Array>;
     /** Delete the file stored under `fileUrl`, if it exists. */
     delete(fileUrl: string): Promise<void>;
     /** Validate `fileUrl` and return the on-disk filename it maps to. */
     protected _resolveSuffix(fileUrl: string): string;
+    /** Keep only the most recent `maxFiles` files; delete oldest by mtime. */
+    protected _trim(): Promise<void>;
+    protected _path(name: string): string;
+    protected _fs(): LocalFileSystem;
 }
 //# sourceMappingURL=file_storage.d.ts.map

package/dist/utils/file_storage.js

@@ -21,6 +21,8 @@
  * for a custom cloud backend (which the LLM provider may then even fetch
  * itself, without `FileStorage.load` being involved at all).
  */
+import { rethrowIfCancelled } from "@pipedog/asyncio";
+import { logger } from "./logger.js";
 /**
  * Thrown by `FileStorage.load` when a URL is invalid or no longer stored
  * (Python's built-in `FileNotFoundError`).
@@ -41,7 +43,14 @@ export class FileStorage {
      */
     deleteAfterLoad = false;
 }
-const NOT_PORTED = "not ported yet: LocalFileStorage needs filesystem access, which @pipedog/core (runtime-agnostic) does not have";
+/** Whether `e` is a filesystem "no such file" error (`ENOENT`). */
+function isNotFound(e) {
+    return typeof e === "object" && e !== null && e.code === "ENOENT";
+}
+/** `uuid.uuid4().hex`. */
+function uuid4Hex() {
+    return crypto.randomUUID().replaceAll("-", "");
+}
 /**
  * Default storage backend: files on local disk, addressed as `pipecat:<hex>`.
  *
@@ -50,8 +59,9 @@ const NOT_PORTED = "not ported yet: LocalFileStorage needs filesystem access, wh
  * the random hex suffix can't be used for path traversal and doesn't leak the
  * original filename.
  *
- * STUB: disk I/O (`save`, `load`, `delete`, trimming) is not ported, since core
- * cannot import `node:fs`. URL validation is.
+ * Porting note: upstream writes with `aiofiles` and `pathlib`. Core cannot
+ * import `node:fs`, so the disk is reached through the `fs` option (see
+ * `LocalFileSystem`).
  */
 export class LocalFileStorage extends FileStorage {
     // Every pipecat: URL is an upload this backend owns, so the file is
@@ -61,31 +71,57 @@ export class LocalFileStorage extends FileStorage {
     static _URL_SUFFIX_PATTERN = /^[0-9a-f]{32}$/;
     _folder;
     _maxFiles;
+    _fsImpl;
     constructor(options) {
         super();
         this._folder = options.folder;
         this._maxFiles = options.maxFiles ?? 10;
+        this._fsImpl = options.fs ?? null;
     }
     /** Write `contents` to a new randomly-named file and return its `pipecat:` URL. */
-    async save(_filename, _contents) {
-        throw new Error(NOT_PORTED);
+    async save(_filename, contents) {
+        const fs = this._fs();
+        await fs.mkdir(this._folder, { recursive: true });
+        const suffix = uuid4Hex();
+        await fs.writeFile(this._path(suffix), contents);
+        await this._trim();
+        return `${LocalFileStorage._URL_PREFIX}${suffix}`;
     }
     /** Read and return the contents stored under `fileUrl`. */
     async load(fileUrl) {
-        this._resolveSuffix(fileUrl);
-        throw new Error(NOT_PORTED);
+        const suffix = this._resolveSuffix(fileUrl);
+        try {
+            return await this._fs().readFile(this._path(suffix));
+        }
+        catch (e) {
+            rethrowIfCancelled(e);
+            if (isNotFound(e))
+                throw new FileNotFoundError(fileUrl);
+            throw e;
+        }
     }
     /** Delete the file stored under `fileUrl`, if it exists. */
     async delete(fileUrl) {
+        let suffix;
         try {
-            this._resolveSuffix(fileUrl);
+            suffix = this._resolveSuffix(fileUrl);
         }
         catch (e) {
             if (e instanceof FileNotFoundError)
                 return;
             throw e;
         }
-        throw new Error(NOT_PORTED);
+        try {
+            // Missing is fine: a consumed upload (deleteAfterLoad) may be deleted
+            // again by session-end cleanup.
+            await this._fs().unlink(this._path(suffix));
+        }
+        catch (e) {
+            rethrowIfCancelled(e);
+            if (isNotFound(e))
+                return;
+            logger.warning(`Failed to remove uploaded file ${fileUrl}: ${e}`);
+        }
     }
     /** Validate `fileUrl` and return the on-disk filename it maps to. */
     _resolveSuffix(fileUrl) {
@@ -96,5 +132,47 @@ export class LocalFileStorage extends FileStorage {
         }
         return suffix;
     }
+    /** Keep only the most recent `maxFiles` files; delete oldest by mtime. */
+    async _trim() {
+        if (this._maxFiles <= 0) {
+            return;
+        }
+        const fs = this._fs();
+        try {
+            const entries = await fs.readdir(this._folder, { withFileTypes: true });
+            const files = entries.filter((e) => e.isFile()).map((e) => e.name);
+            if (files.length <= this._maxFiles) {
+                return;
+            }
+            const mtimes = new Map();
+            for (const name of files) {
+                mtimes.set(name, (await fs.stat(this._path(name))).mtimeMs);
+            }
+            const byMtime = [...files].sort((a, b) => mtimes.get(a) - mtimes.get(b));
+            for (const name of byMtime.slice(0, files.length - this._maxFiles)) {
+                try {
+                    await fs.unlink(this._path(name));
+                    logger.debug(`Trimmed upload ${name} from ${this._folder}`);
+                }
+                catch (e) {
+                    rethrowIfCancelled(e);
+                    logger.warning(`Failed to trim upload ${this._path(name)}: ${e}`);
+                }
+            }
+        }
+        catch (e) {
+            rethrowIfCancelled(e);
+            logger.warning(`Failed to list uploads folder ${this._folder}: ${e}`);
+        }
+    }
+    _path(name) {
+        return /[\\/]$/.test(this._folder) ? `${this._folder}${name}` : `${this._folder}/${name}`;
+    }
+    _fs() {
+        if (this._fsImpl === null) {
+            throw new Error('LocalFileStorage needs a filesystem: pass `fs` (e.g. `import * as fs from "node:fs/promises"`)');
+        }
+        return this._fsImpl;
+    }
 }
 //# sourceMappingURL=file_storage.js.map

package/dist/utils/frame_queue.js

@@ -23,11 +23,11 @@ export class FrameQueue extends Queue {
     }
     /** Whether any frame of the given type is in the queue. */
     hasFrame(frameType) {
-        return this._items.some((item) => this._frameGetter(item) instanceof frameType);
+        return this._queued().some((item) => this._frameGetter(item) instanceof frameType);
     }
     /** Whether any uninterruptible frame is currently in the queue. */
     get hasUninterruptible() {
-        return this._items.some((item) => this._isUninterruptible(item));
+        return this._queued().some((item) => this._isUninterruptible(item));
     }
     /** Remove all interruptible items, keeping uninterruptible ones. */
     reset() {

package/dist/utils/image.d.ts

@@ -1,4 +1,3 @@
-/** Image encoding helpers. */
 /**
  * Encode an image for a model to look at.
  *

package/dist/utils/image.js

@@ -4,6 +4,7 @@
 //
 // Ported from pipecat: src/pipecat/utils/image.py
 /** Image encoding helpers. */
+import { encodeJpegRgb } from "./jpeg_encoder.js";
 /**
  * Encode an image for a model to look at.
  *
@@ -22,9 +23,41 @@ export async function encodeImage(image, size, format) {
     }
     return [await encodeJpeg(image, size, format || "RGB"), "image/jpeg"];
 }
-// STUB: upstream encodes raw pixels with Pillow (`Image.frombytes(...).save(format="JPEG")`)
-// in a thread. Core has no runtime-agnostic JPEG encoder yet.
-async function encodeJpeg(_image, _size, _format) {
-    throw new Error("not ported yet: encodeImage() cannot JPEG-encode raw pixels; pass an already encoded image (format 'image/...')");
+/** Bytes per pixel of the raw pixel formats (Pillow modes) that can be encoded. */
+const PIXEL_FORMATS = { L: 1, LA: 2, RGB: 3, RGBA: 4, RGBX: 4 };
+/**
+ * `Image.frombytes(format, size, image).convert("RGB")`: the pixels as
+ * interleaved RGB, dropping alpha and widening grayscale.
+ */
+function toRgb(image, [width, height], format) {
+    const channels = PIXEL_FORMATS[format];
+    if (channels === undefined) {
+        throw new Error(`unrecognized image mode: ${format}`);
+    }
+    const pixels = width * height;
+    if (image.length < pixels * channels) {
+        throw new Error("not enough image data");
+    }
+    if (channels === 3) {
+        return image;
+    }
+    const rgb = new Uint8Array(pixels * 3);
+    for (let i = 0; i < pixels; i++) {
+        const src = i * channels;
+        if (channels <= 2) {
+            rgb[i * 3] = rgb[i * 3 + 1] = rgb[i * 3 + 2] = image[src];
+        }
+        else {
+            rgb[i * 3] = image[src];
+            rgb[i * 3 + 1] = image[src + 1];
+            rgb[i * 3 + 2] = image[src + 2];
+        }
+    }
+    return rgb;
+}
+// Upstream encodes with Pillow in a thread; there are no threads here, so the
+// (pure TypeScript) encoder runs inline.
+async function encodeJpeg(image, size, format) {
+    return encodeJpegRgb(toRgb(image, size, format), size[0], size[1]);
 }
 //# sourceMappingURL=image.js.map

package/dist/utils/jpeg_encoder.d.ts

@@ -0,0 +1,14 @@
+export interface EncodeJpegOptions {
+    /** Quality from 1 to 100. Defaults to 75, like Pillow. */
+    quality?: number;
+}
+/**
+ * Encode RGB pixels as a baseline JPEG.
+ *
+ * @param rgb Interleaved 8-bit RGB pixels, `width * height * 3` bytes, row-major.
+ * @param width Image width in pixels.
+ * @param height Image height in pixels.
+ * @returns The JPEG file bytes.
+ */
+export declare function encodeJpegRgb(rgb: Uint8Array, width: number, height: number, options?: EncodeJpegOptions): Uint8Array;
+//# sourceMappingURL=jpeg_encoder.d.ts.map