hume 0.13.4 → 0.13.6

package/.mock/definition/empathic-voice/__package__.yml

@@ -351,6 +351,11 @@ types:
           session-specific details. For more guidance, see our [guide on using
           dynamic
           variables](/docs/speech-to-speech-evi/features/dynamic-variables).
+      voice_id:
+        type: optional<string>
+        docs: >-
+          Allows you to change the voice during an active chat. Updating the
+          voice does not affect chat context or conversation history.
     source:
       openapi: evi-asyncapi.json
   Tool:
@@ -1526,12 +1531,12 @@ types:
           Version numbers are integer values representing different iterations
           of the Config. Each update to the Config increments its version
           number.
-      tools:
-        type: optional<list<optional<ReturnUserDefinedTool>>>
-        docs: List of user-defined tools associated with this Config.
       version_description:
         type: optional<string>
         docs: An optional description of the Config version.
+      tools:
+        type: optional<list<optional<ReturnUserDefinedTool>>>
+        docs: List of user-defined tools associated with this Config.
       language_model:
         type: optional<ReturnLanguageModel>
         docs: >-

package/.mock/definition/tts/__package__.yml

@@ -317,7 +317,11 @@ types:
     source:
       openapi: tts-openapi.json
   SnippetAudioChunk:
+    docs: Metadata for a chunk of generated audio.
     properties:
+      request_id:
+        type: string
+        docs: ID of the initiating request.
       generation_id:
         type: string
         docs: >-

package/.mock/definition/tts/streamInput.yml

@@ -25,12 +25,40 @@ channel:
       type: optional<boolean>
       default: true
       docs: >-
-        Accelerates processing to reduce streaming latency.Incurs approximately
-        10% additional cost while preserving full voice quality.
+        Enables ultra-low latency streaming, significantly reducing the time
+        until the first audio chunk is received. Recommended for real-time
+        applications requiring immediate audio playback. For further details,
+        see our documentation on [instant
+        mode](/docs/text-to-speech-tts/overview#ultra-low-latency-streaming-instant-mode).
     no_binary:
       type: optional<boolean>
       default: false
       docs: If enabled, no binary websocket messages will be sent to the client.
+    access_token:
+      type: optional<string>
+      default: ''
+      docs: >-
+        Access token used for authenticating the client. If not provided, an
+        `api_key` must be provided to authenticate.
+
+
+        The access token is generated using both an API key and a Secret key,
+        which provides an additional layer of security compared to using just an
+        API key.
+
+
+        For more details, refer to the [Authentication Strategies
+        Guide](/docs/introduction/api-key#authentication-strategies).
+    api_key:
+      type: optional<string>
+      default: ''
+      docs: >-
+        API key used for authenticating the client. If not provided, an
+        `access_token` must be provided to authenticate.
+
+
+        For more details, refer to the [Authentication Strategies
+        Guide](/docs/introduction/api-key#authentication-strategies).
   messages:
     publish:
       origin: client

package/.mock/fern.config.json

@@ -1,4 +1,4 @@
 {
   "organization" : "hume",
-  "version" : "0.66.15"
+  "version" : "0.76.2"
 }

package/Client.js

@@ -40,13 +40,20 @@ const Client_1 = require("./api/resources/tts/client/Client");
 const Client_2 = require("./api/resources/empathicVoice/client/Client");
 const Client_3 = require("./api/resources/expressionMeasurement/client/Client");
 const version_1 = require("./version");
-const fetcherThatAddsHeaders = (fetcherToWrap) => {
+const customFetcher = (fetcherToWrap, accessToken) => {
     return (args) => {
-        var _a;
+        var _a, _b;
         const newArgs = Object.assign({}, args);
         newArgs.headers = (_a = newArgs.headers) !== null && _a !== void 0 ? _a : {};
         ((newArgs.headers["X-Hume-Client-Name"] = "typescript_sdk"),
             (newArgs.headers["X-Hume-Client-Version"] = version_1.SDK_VERSION));
+        if (accessToken) {
+            const supplied = core.Supplier.get(accessToken);
+            if (supplied) {
+                newArgs.headers = (_b = newArgs.headers) !== null && _b !== void 0 ? _b : {};
+                newArgs.headers["Authorization"] = `Bearer ${supplied}`;
+            }
+        }
         return fetcherToWrap(args);
     };
 };
@@ -55,7 +62,7 @@ class HumeClient {
         var _a;
         this._options = _options;
         const defaultFetcher = (_a = _options.fetcher) !== null && _a !== void 0 ? _a : core.fetcher;
-        this._options.fetcher = fetcherThatAddsHeaders(defaultFetcher);
+        this._options.fetcher = customFetcher(defaultFetcher, _options.accessToken);
     }
     get tts() {
         var _a;

package/api/resources/empathicVoice/types/ReturnConfig.d.ts

@@ -18,10 +18,10 @@ export interface ReturnConfig {
      * Version numbers are integer values representing different iterations of the Config. Each update to the Config increments its version number.
      */
     version?: number;
-    /** List of user-defined tools associated with this Config. */
-    tools?: (Hume.empathicVoice.ReturnUserDefinedTool | undefined)[];
     /** An optional description of the Config version. */
     versionDescription?: string;
+    /** List of user-defined tools associated with this Config. */
+    tools?: (Hume.empathicVoice.ReturnUserDefinedTool | undefined)[];
     /**
      * The supplemental language model associated with this Config.
      *

package/api/resources/empathicVoice/types/SessionSettings.d.ts

@@ -75,4 +75,6 @@ export interface SessionSettings {
      * Using this field, you can personalize responses based on session-specific details. For more guidance, see our [guide on using dynamic variables](/docs/speech-to-speech-evi/features/dynamic-variables).
      */
     variables?: Record<string, Hume.empathicVoice.SessionSettingsVariablesValue>;
+    /** Allows you to change the voice during an active chat. Updating the voice does not affect chat context or conversation history. */
+    voiceId?: string;
 }

package/api/resources/index.d.ts

@@ -1,3 +1,3 @@
-export * as tts from "./tts";
 export * as empathicVoice from "./empathicVoice";
+export * as tts from "./tts";
 export * as expressionMeasurement from "./expressionMeasurement";

package/api/resources/index.js

@@ -33,7 +33,7 @@ var __importStar = (this && this.__importStar) || (function () {
     };
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.expressionMeasurement = exports.empathicVoice = exports.tts = void 0;
-exports.tts = __importStar(require("./tts"));
+exports.expressionMeasurement = exports.tts = exports.empathicVoice = void 0;
 exports.empathicVoice = __importStar(require("./empathicVoice"));
+exports.tts = __importStar(require("./tts"));
 exports.expressionMeasurement = __importStar(require("./expressionMeasurement"));

package/api/resources/tts/types/SnippetAudioChunk.d.ts

@@ -2,7 +2,12 @@
  * This file was auto-generated by Fern from our API Definition.
  */
 import * as Hume from "../../../index";
+/**
+ * Metadata for a chunk of generated audio.
+ */
 export interface SnippetAudioChunk {
+    /** ID of the initiating request. */
+    requestId: string;
     /** The generation ID of the parent snippet that this chunk corresponds to. */
     generationId: string;
     /** The ID of the parent snippet that this chunk corresponds to. */

package/dist/Client.js

@@ -40,13 +40,20 @@ const Client_1 = require("./api/resources/tts/client/Client");
 const Client_2 = require("./api/resources/empathicVoice/client/Client");
 const Client_3 = require("./api/resources/expressionMeasurement/client/Client");
 const version_1 = require("./version");
-const fetcherThatAddsHeaders = (fetcherToWrap) => {
+const customFetcher = (fetcherToWrap, accessToken) => {
     return (args) => {
-        var _a;
+        var _a, _b;
         const newArgs = Object.assign({}, args);
         newArgs.headers = (_a = newArgs.headers) !== null && _a !== void 0 ? _a : {};
         ((newArgs.headers["X-Hume-Client-Name"] = "typescript_sdk"),
             (newArgs.headers["X-Hume-Client-Version"] = version_1.SDK_VERSION));
+        if (accessToken) {
+            const supplied = core.Supplier.get(accessToken);
+            if (supplied) {
+                newArgs.headers = (_b = newArgs.headers) !== null && _b !== void 0 ? _b : {};
+                newArgs.headers["Authorization"] = `Bearer ${supplied}`;
+            }
+        }
         return fetcherToWrap(args);
     };
 };
@@ -55,7 +62,7 @@ class HumeClient {
         var _a;
         this._options = _options;
         const defaultFetcher = (_a = _options.fetcher) !== null && _a !== void 0 ? _a : core.fetcher;
-        this._options.fetcher = fetcherThatAddsHeaders(defaultFetcher);
+        this._options.fetcher = customFetcher(defaultFetcher, _options.accessToken);
     }
     get tts() {
         var _a;

package/dist/api/resources/empathicVoice/types/ReturnConfig.d.ts

@@ -18,10 +18,10 @@ export interface ReturnConfig {
      * Version numbers are integer values representing different iterations of the Config. Each update to the Config increments its version number.
      */
     version?: number;
-    /** List of user-defined tools associated with this Config. */
-    tools?: (Hume.empathicVoice.ReturnUserDefinedTool | undefined)[];
     /** An optional description of the Config version. */
     versionDescription?: string;
+    /** List of user-defined tools associated with this Config. */
+    tools?: (Hume.empathicVoice.ReturnUserDefinedTool | undefined)[];
     /**
      * The supplemental language model associated with this Config.
      *

package/dist/api/resources/empathicVoice/types/SessionSettings.d.ts

@@ -75,4 +75,6 @@ export interface SessionSettings {
      * Using this field, you can personalize responses based on session-specific details. For more guidance, see our [guide on using dynamic variables](/docs/speech-to-speech-evi/features/dynamic-variables).
      */
     variables?: Record<string, Hume.empathicVoice.SessionSettingsVariablesValue>;
+    /** Allows you to change the voice during an active chat. Updating the voice does not affect chat context or conversation history. */
+    voiceId?: string;
 }

package/dist/api/resources/index.d.ts

@@ -1,3 +1,3 @@
-export * as tts from "./tts";
 export * as empathicVoice from "./empathicVoice";
+export * as tts from "./tts";
 export * as expressionMeasurement from "./expressionMeasurement";

package/dist/api/resources/index.js

@@ -33,7 +33,7 @@ var __importStar = (this && this.__importStar) || (function () {
     };
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.expressionMeasurement = exports.empathicVoice = exports.tts = void 0;
-exports.tts = __importStar(require("./tts"));
+exports.expressionMeasurement = exports.tts = exports.empathicVoice = void 0;
 exports.empathicVoice = __importStar(require("./empathicVoice"));
+exports.tts = __importStar(require("./tts"));
 exports.expressionMeasurement = __importStar(require("./expressionMeasurement"));

package/dist/api/resources/tts/types/SnippetAudioChunk.d.ts

@@ -2,7 +2,12 @@
  * This file was auto-generated by Fern from our API Definition.
  */
 import * as Hume from "../../../index";
+/**
+ * Metadata for a chunk of generated audio.
+ */
 export interface SnippetAudioChunk {
+    /** ID of the initiating request. */
+    requestId: string;
     /** The generation ID of the parent snippet that this chunk corresponds to. */
     generationId: string;
     /** The ID of the parent snippet that this chunk corresponds to. */

package/dist/serialization/resources/empathicVoice/types/ReturnConfig.d.ts

@@ -20,8 +20,8 @@ export declare namespace ReturnConfig {
         name?: string | null;
         id?: string | null;
         version?: number | null;
-        tools?: (ReturnUserDefinedTool.Raw | null | undefined)[] | null;
         version_description?: string | null;
+        tools?: (ReturnUserDefinedTool.Raw | null | undefined)[] | null;
         language_model?: ReturnLanguageModel.Raw | null;
         builtin_tools?: (ReturnBuiltinTool.Raw | null | undefined)[] | null;
         evi_version?: string | null;

package/dist/serialization/resources/empathicVoice/types/ReturnConfig.js

@@ -52,8 +52,8 @@ exports.ReturnConfig = core.serialization.object({
     name: core.serialization.string().optional(),
     id: core.serialization.string().optional(),
     version: core.serialization.number().optional(),
-    tools: core.serialization.list(ReturnUserDefinedTool_1.ReturnUserDefinedTool.optional()).optional(),
     versionDescription: core.serialization.property("version_description", core.serialization.string().optional()),
+    tools: core.serialization.list(ReturnUserDefinedTool_1.ReturnUserDefinedTool.optional()).optional(),
     languageModel: core.serialization.property("language_model", ReturnLanguageModel_1.ReturnLanguageModel.optional()),
     builtinTools: core.serialization.property("builtin_tools", core.serialization.list(ReturnBuiltinTool_1.ReturnBuiltinTool.optional()).optional()),
     eviVersion: core.serialization.property("evi_version", core.serialization.string().optional()),

package/dist/serialization/resources/empathicVoice/types/SessionSettings.d.ts

@@ -22,5 +22,6 @@ export declare namespace SessionSettings {
         builtin_tools?: BuiltinToolConfig.Raw[] | null;
         metadata?: Record<string, unknown> | null;
         variables?: Record<string, SessionSettingsVariablesValue.Raw> | null;
+        voice_id?: string | null;
     }
 }

package/dist/serialization/resources/empathicVoice/types/SessionSettings.js

@@ -54,4 +54,5 @@ exports.SessionSettings = core.serialization.object({
     builtinTools: core.serialization.property("builtin_tools", core.serialization.list(BuiltinToolConfig_1.BuiltinToolConfig).optional()),
     metadata: core.serialization.record(core.serialization.string(), core.serialization.unknown()).optional(),
     variables: core.serialization.record(core.serialization.string(), SessionSettingsVariablesValue_1.SessionSettingsVariablesValue).optional(),
+    voiceId: core.serialization.property("voice_id", core.serialization.string().optional()),
 });

package/dist/serialization/resources/index.d.ts

@@ -1,3 +1,3 @@
-export * as tts from "./tts";
 export * as empathicVoice from "./empathicVoice";
+export * as tts from "./tts";
 export * as expressionMeasurement from "./expressionMeasurement";

package/dist/serialization/resources/index.js

@@ -33,7 +33,7 @@ var __importStar = (this && this.__importStar) || (function () {
     };
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.expressionMeasurement = exports.empathicVoice = exports.tts = void 0;
-exports.tts = __importStar(require("./tts"));
+exports.expressionMeasurement = exports.tts = exports.empathicVoice = void 0;
 exports.empathicVoice = __importStar(require("./empathicVoice"));
+exports.tts = __importStar(require("./tts"));
 exports.expressionMeasurement = __importStar(require("./expressionMeasurement"));

package/dist/serialization/resources/tts/types/SnippetAudioChunk.d.ts

@@ -9,6 +9,7 @@ import { Snippet } from "./Snippet";
 export declare const SnippetAudioChunk: core.serialization.ObjectSchema<serializers.tts.SnippetAudioChunk.Raw, Hume.tts.SnippetAudioChunk>;
 export declare namespace SnippetAudioChunk {
     interface Raw {
+        request_id: string;
         generation_id: string;
         snippet_id: string;
         text: string;

package/dist/serialization/resources/tts/types/SnippetAudioChunk.js

@@ -41,6 +41,7 @@ const core = __importStar(require("../../../../core"));
 const AudioFormatType_1 = require("./AudioFormatType");
 const Snippet_1 = require("./Snippet");
 exports.SnippetAudioChunk = core.serialization.object({
+    requestId: core.serialization.property("request_id", core.serialization.string()),
     generationId: core.serialization.property("generation_id", core.serialization.string()),
     snippetId: core.serialization.property("snippet_id", core.serialization.string()),
     text: core.serialization.string(),

package/dist/version.d.ts

@@ -1 +1 @@
-export declare const SDK_VERSION = "0.13.4";
+export declare const SDK_VERSION = "0.13.6";

package/dist/version.js

@@ -1,4 +1,4 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.SDK_VERSION = void 0;
-exports.SDK_VERSION = "0.13.4";
+exports.SDK_VERSION = "0.13.6";

package/dist/wrapper/SilenceFiller.d.ts

@@ -0,0 +1,85 @@
+import { Readable } from "stream";
+/**
+ * SilenceFiller is a Readable stream that intersperses incoming audio data
+ * with bytes of silence. This is important in some cases to keep an audio
+ * stream "alive". Audio players, such as ffmpeg, can interpret inactivity as
+ * meaning the stream is ended, or disconnected.
+ *
+ * @example
+ * ```typescript
+ * import { SilenceFiller } from 'hume';
+ *
+ * const BYTES_PER_SAMPLE = 2; // 16-bit samples
+ * const SAMPLE_RATE = 48000;
+ * const BUFFER_SIZE = Math.floor(SAMPLE_RATE * 0.1 * BYTES_PER_SAMPLE); // 100ms buffer
+ * const silenceFiller = new SilenceFiller(BUFFER_SIZE, SAMPLE_RATE, BYTES_PER_SAMPLE, 10);
+ *
+ * // Pipe silence filler output to audio player stdin
+ * silenceFiller.pipe(audioPlayer.stdin);
+ *
+ * // Handle pipe errors
+ * silenceFiller.on('error', (err) => {
+ *   console.error("SilenceFiller error:", err);
+ * });
+ *
+ * // Write audio data as it arrives
+ * silenceFiller.writeAudio(audioBuffer);
+ *
+ * // End the stream when done
+ * await silenceFiller.endStream();
+ * ```
+ */
+export declare class SilenceFiller extends Readable {
+    private unclockedSilenceFiller;
+    private isStarted;
+    private pushInterval;
+    private bytesPerSample;
+    private pushIntervalMs;
+    /**
+     * Creates a new SilenceFiller instance.
+     *
+     * @param pushIntervalMs - The interval in milliseconds for pushing audio data (default: 5ms).
+     * @param sampleRate - The sample rate of the audio (e.g., 48000).
+     * @param bytesPerSample - The number of bytes per audio sample (e.g., 2 for 16-bit).
+     * @param bufferSize - How much to 'prebuffer'. If you set this too low there
+     * is a chance that playback will stutter, but if you set it too high
+     * playback will take longer to start.
+     */
+    constructor(pushIntervalMs?: number, sampleRate?: number, bytesPerSample?: number, bufferSize?: number);
+    /**
+     * Writes audio data to the silence filler.
+     *
+     * @param audioBuffer - The audio buffer to write.
+     */
+    writeAudio(audioBuffer: Buffer): void;
+    private startPushInterval;
+    private pushData;
+    _read(): void;
+    _destroy(error: Error | null, callback: (error?: Error | null) => void): void;
+    /**
+     * Ends the stream and drains all remaining audio data.
+     *
+     * @returns A promise that resolves when the stream has ended.
+     */
+    endStream(): Promise<void>;
+}
+/**
+ * Does the actual calculation of how interspersing audio with silence
+ * is "pure" in the sense that it does not rely on the system clock.
+ * It's up to the caller to provide timestamps.
+ *
+ * @internal
+ */
+export declare class UnclockedSilenceFiller {
+    private audioQueue;
+    private totalBufferedBytes;
+    private startTimestamp;
+    private totalBytesSent;
+    donePrebuffering: boolean;
+    private bufferSize;
+    private sampleRate;
+    private bytesPerSample;
+    constructor(bufferSize: number, sampleRate: number, bytesPerSample: number);
+    writeAudio(audioBuffer: Buffer, timestamp: number): void;
+    readAudio(timestamp: number): Buffer | null;
+}

package/dist/wrapper/SilenceFiller.js

@@ -0,0 +1,203 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.UnclockedSilenceFiller = exports.SilenceFiller = void 0;
+const stream_1 = require("stream");
+/**
+ * SilenceFiller is a Readable stream that intersperses incoming audio data
+ * with bytes of silence. This is important in some cases to keep an audio
+ * stream "alive". Audio players, such as ffmpeg, can interpret inactivity as
+ * meaning the stream is ended, or disconnected.
+ *
+ * @example
+ * ```typescript
+ * import { SilenceFiller } from 'hume';
+ *
+ * const BYTES_PER_SAMPLE = 2; // 16-bit samples
+ * const SAMPLE_RATE = 48000;
+ * const BUFFER_SIZE = Math.floor(SAMPLE_RATE * 0.1 * BYTES_PER_SAMPLE); // 100ms buffer
+ * const silenceFiller = new SilenceFiller(BUFFER_SIZE, SAMPLE_RATE, BYTES_PER_SAMPLE, 10);
+ *
+ * // Pipe silence filler output to audio player stdin
+ * silenceFiller.pipe(audioPlayer.stdin);
+ *
+ * // Handle pipe errors
+ * silenceFiller.on('error', (err) => {
+ *   console.error("SilenceFiller error:", err);
+ * });
+ *
+ * // Write audio data as it arrives
+ * silenceFiller.writeAudio(audioBuffer);
+ *
+ * // End the stream when done
+ * await silenceFiller.endStream();
+ * ```
+ */
+class SilenceFiller extends stream_1.Readable {
+    /**
+     * Creates a new SilenceFiller instance.
+     *
+     * @param pushIntervalMs - The interval in milliseconds for pushing audio data (default: 5ms).
+     * @param sampleRate - The sample rate of the audio (e.g., 48000).
+     * @param bytesPerSample - The number of bytes per audio sample (e.g., 2 for 16-bit).
+     * @param bufferSize - How much to 'prebuffer'. If you set this too low there
+     * is a chance that playback will stutter, but if you set it too high
+     * playback will take longer to start.
+     */
+    constructor(pushIntervalMs = 5, sampleRate = 48000, bytesPerSample = 2, bufferSize = 9600) {
+        super({ objectMode: false });
+        this.isStarted = false;
+        this.pushInterval = null;
+        this.unclockedSilenceFiller = new UnclockedSilenceFiller(bufferSize, sampleRate, bytesPerSample);
+        this.bytesPerSample = bytesPerSample;
+        this.pushIntervalMs = pushIntervalMs;
+    }
+    /**
+     * Writes audio data to the silence filler.
+     *
+     * @param audioBuffer - The audio buffer to write.
+     */
+    writeAudio(audioBuffer) {
+        const now = Date.now();
+        try {
+            this.unclockedSilenceFiller.writeAudio(audioBuffer, now);
+            if (!this.isStarted && this.unclockedSilenceFiller.donePrebuffering) {
+                this.isStarted = true;
+                this.startPushInterval();
+            }
+        }
+        catch (error) {
+            console.error(`[SilenceFiller] Error writing audio:`, error);
+            this.emit("error", error);
+        }
+    }
+    startPushInterval() {
+        this.pushInterval = setInterval(() => {
+            this.pushData();
+        }, this.pushIntervalMs);
+    }
+    pushData() {
+        if (!this.isStarted)
+            return;
+        try {
+            const now = Date.now();
+            const audioChunk = this.unclockedSilenceFiller.readAudio(now);
+            if (audioChunk && audioChunk.length > 0) {
+                // Ensure chunk size is aligned to bytesPerSample
+                const alignedChunkSize = Math.floor(audioChunk.length / this.bytesPerSample) * this.bytesPerSample;
+                if (alignedChunkSize > 0) {
+                    const chunk = audioChunk.subarray(0, alignedChunkSize);
+                    this.push(chunk);
+                }
+            }
+        }
+        catch (error) {
+            console.error(`[SilenceFiller] Error pushing data:`, error);
+            this.emit("error", error);
+        }
+    }
+    _read() { }
+    _destroy(error, callback) {
+        super._destroy(error, callback);
+    }
+    /**
+     * Ends the stream and drains all remaining audio data.
+     *
+     * @returns A promise that resolves when the stream has ended.
+     */
+    endStream() {
+        return new Promise((resolve) => {
+            // Stop pushing data
+            if (this.pushInterval) {
+                clearInterval(this.pushInterval);
+                this.pushInterval = null;
+            }
+            // Drain all remaining audio from SilenceFiller
+            const now = Date.now();
+            // Keep reading until no more audio is available
+            while (true) {
+                const remainingChunk = this.unclockedSilenceFiller.readAudio(now);
+                if (!remainingChunk || remainingChunk.length === 0) {
+                    break;
+                }
+                const alignedChunkSize = Math.floor(remainingChunk.length / this.bytesPerSample) * this.bytesPerSample;
+                if (alignedChunkSize > 0) {
+                    const chunk = remainingChunk.subarray(0, alignedChunkSize);
+                    this.push(chunk);
+                }
+            }
+            this.push(null); // Signal end of stream
+            this.once("end", () => {
+                resolve();
+            });
+        });
+    }
+}
+exports.SilenceFiller = SilenceFiller;
+/**
+ * Does the actual calculation of how interspersing audio with silence
+ * is "pure" in the sense that it does not rely on the system clock.
+ * It's up to the caller to provide timestamps.
+ *
+ * @internal
+ */
+class UnclockedSilenceFiller {
+    constructor(bufferSize, sampleRate, bytesPerSample) {
+        this.audioQueue = [];
+        this.totalBufferedBytes = 0;
+        this.startTimestamp = null;
+        this.totalBytesSent = 0;
+        this.donePrebuffering = false;
+        this.bufferSize = bufferSize;
+        this.sampleRate = sampleRate;
+        this.bytesPerSample = bytesPerSample;
+    }
+    writeAudio(audioBuffer, timestamp) {
+        this.audioQueue.push(audioBuffer);
+        this.totalBufferedBytes += audioBuffer.length;
+        if (this.startTimestamp === null) {
+            this.startTimestamp = timestamp;
+        }
+        if (!this.donePrebuffering && this.totalBufferedBytes >= this.bufferSize) {
+            this.donePrebuffering = true;
+        }
+    }
+    readAudio(timestamp) {
+        if (this.startTimestamp === null || !this.donePrebuffering) {
+            return null;
+        }
+        const elapsedMs = timestamp - this.startTimestamp;
+        const targetBytesSent = Math.floor(((this.sampleRate * elapsedMs) / 1000) * this.bytesPerSample);
+        const bytesNeeded = targetBytesSent - this.totalBytesSent;
+        if (bytesNeeded <= 0) {
+            return null;
+        }
+        // Ensure bytesNeeded is a multiple of bytesPerSample
+        const alignedBytesNeeded = Math.floor(bytesNeeded / this.bytesPerSample) * this.bytesPerSample;
+        if (alignedBytesNeeded <= 0) {
+            return null;
+        }
+        let chunk = Buffer.alloc(0);
+        // Drain from queue until we have enough bytes
+        while (chunk.length < alignedBytesNeeded && this.audioQueue.length > 0) {
+            const nextBuffer = this.audioQueue.shift();
+            chunk = Buffer.concat([chunk, nextBuffer]);
+            this.totalBufferedBytes -= nextBuffer.length;
+        }
+        // If we have more than needed, put the excess back
+        if (chunk.length > alignedBytesNeeded) {
+            const excess = chunk.subarray(alignedBytesNeeded);
+            this.audioQueue.unshift(excess);
+            this.totalBufferedBytes += excess.length;
+            chunk = chunk.subarray(0, alignedBytesNeeded);
+        }
+        // Fill remaining with silence if needed
+        if (chunk.length < alignedBytesNeeded) {
+            const silenceNeeded = Buffer.alloc(alignedBytesNeeded - chunk.length, 0);
+            chunk = Buffer.concat([chunk, silenceNeeded]);
+        }
+        // Update total bytes sent
+        this.totalBytesSent += chunk.length;
+        return chunk;
+    }
+}
+exports.UnclockedSilenceFiller = UnclockedSilenceFiller;