@qvac/sdk 0.18.2 → 0.19.0

package/dist/server/bare/ops/translate.js

@@ -1,284 +0,0 @@
-var __addDisposableResource = (this && this.__addDisposableResource) || function (env, value, async) {
-    if (value !== null && value !== void 0) {
-        if (typeof value !== "object" && typeof value !== "function") throw new TypeError("Object expected.");
-        var dispose, inner;
-        if (async) {
-            if (!Symbol.asyncDispose) throw new TypeError("Symbol.asyncDispose is not defined.");
-            dispose = value[Symbol.asyncDispose];
-        }
-        if (dispose === void 0) {
-            if (!Symbol.dispose) throw new TypeError("Symbol.dispose is not defined.");
-            dispose = value[Symbol.dispose];
-            if (async) inner = dispose;
-        }
-        if (typeof dispose !== "function") throw new TypeError("Object not disposable.");
-        if (inner) dispose = function() { try { inner.call(this); } catch (e) { return Promise.reject(e); } };
-        env.stack.push({ value: value, dispose: dispose, async: async });
-    }
-    else if (async) {
-        env.stack.push({ async: true });
-    }
-    return value;
-};
-var __disposeResources = (this && this.__disposeResources) || (function (SuppressedError) {
-    return function (env) {
-        function fail(e) {
-            env.error = env.hasError ? new SuppressedError(e, env.error, "An error was suppressed during disposal.") : e;
-            env.hasError = true;
-        }
-        var r, s = 0;
-        function next() {
-            while (r = env.stack.pop()) {
-                try {
-                    if (!r.async && s === 1) return s = 0, env.stack.push(r), Promise.resolve().then(next);
-                    if (r.dispose) {
-                        var result = r.dispose.call(r.value);
-                        if (r.async) return s |= 2, Promise.resolve(result).then(next, function(e) { fail(e); return next(); });
-                    }
-                    else s |= 1;
-                }
-                catch (e) {
-                    fail(e);
-                }
-            }
-            if (s === 1) return env.hasError ? Promise.reject(env.error) : Promise.resolve();
-            if (env.hasError) throw env.error;
-        }
-        return next();
-    };
-})(typeof SuppressedError === "function" ? SuppressedError : function (error, suppressed, message) {
-    var e = new Error(message);
-    return e.name = "SuppressedError", e.error = error, e.suppressed = suppressed, e;
-});
-import { getModelEntry } from '../../../server/bare/registry/model-registry.js';
-import { translateServerParamsSchema, normalizeModelType, ModelType, AFRICAN_LANGUAGES_MAP } from '../../../schemas/index.js';
-import { getLangName, detectOne } from '@qvac/langdetect-text';
-import { nowMs } from '../../../profiling/index.js';
-import { buildStreamResult } from '../../../profiling/model-execution.js';
-import { buildNmtTranslationStats } from '../../../server/bare/ops/translate-stats.js';
-import { ModelIsDelegatedError, ModelNotFoundError, ModelTypeMismatchError, TranslationFailedError } from '../../../utils/errors-server.js';
-import { getRequestRegistry, withRequestContext } from '../../../server/bare/runtime/index.js';
-import { isAddonContextOverflowError } from '../../../server/bare/plugins/llamacpp-completion/ops/context-overflow.js';
-import { generateServerRequestId } from '../../../server/bare/runtime/request-id.js';
-import { getModelParallel } from '../../../server/utils/index.js';
-import { getServerLogger } from '../../../logging/index.js';
-export function getLanguage(code) {
-    if (!code)
-        return '';
-    if (AFRICAN_LANGUAGES_MAP.has(code))
-        return AFRICAN_LANGUAGES_MAP.get(code);
-    const fullName = getLangName(code);
-    return fullName ?? code.toUpperCase();
-}
-export function isAfrican(code) {
-    return !!code && AFRICAN_LANGUAGES_MAP.has(code);
-}
-const LLM_TRANSLATE_GENERATION_PARAMS = {
-    temp: 0,
-    top_k: 1,
-    top_p: 1,
-    repeat_penalty: 1.3,
-    seed: 42,
-    predict: 256
-};
-function shouldSkipPerCallSampling(modelName) {
-    return !!modelName && modelName.startsWith('AFRICAN_');
-}
-export async function* translate(params, requestId) {
-    const env_1 = { stack: [], error: void 0, hasError: false };
-    try {
-        const { modelId, text, modelType: inputModelType } = params;
-        const entry = getModelEntry(modelId);
-        if (!entry) {
-            throw new ModelNotFoundError(modelId);
-        }
-        if (entry.isDelegated) {
-            throw new ModelIsDelegatedError(modelId);
-        }
-        const canonicalModelType = entry.local.modelType;
-        const model = entry.local.model;
-        if (inputModelType !== undefined) {
-            const requestedCanonical = normalizeModelType(inputModelType);
-            if (requestedCanonical !== canonicalModelType) {
-                throw new ModelTypeMismatchError(canonicalModelType, requestedCanonical);
-            }
-        }
-        const isLlm = canonicalModelType === ModelType.llamacppCompletion;
-        let from = isLlm ? params.from : undefined;
-        const to = isLlm ? params.to : undefined;
-        const context = isLlm ? params.context : undefined;
-        translateServerParamsSchema.parse(params);
-        // Auto-detect the source language when the caller didn't pass `from` (LLM
-        // only). This used to run in each client; moving it here gives every
-        // language binding one detector instead of each shipping its own (lingua in
-        // Python vs langdetect-text in JS drifted on the same input). Store the
-        // detected code — not the language name — so the explicit-`from` and
-        // detected paths feed getLanguage() identically.
-        if (isLlm && !from) {
-            const detected = detectOne(text);
-            if (detected.code === 'und' || detected.language === 'Undetermined') {
-                throw new TranslationFailedError("Could not detect the source language. Please specify the 'from' parameter explicitly.");
-            }
-            from = detected.code;
-        }
-        const afriquePrompt = isLlm && (isAfrican(from) || isAfrican(to));
-        const fromLanguage = getLanguage(from);
-        const toLanguage = getLanguage(to);
-        // Open a request-scoped lifecycle for both engine branches. The LLM
-        // path cancels only its own run response (wired below), so a peer
-        // completion on the same model keeps running; NMT-translate has no
-        // addon cancel — the loop exits on `signal.aborted`, scope unwinds,
-        // and the addon may run to completion in the background, which is
-        // fine because the result is dropped either way.
-        const ctx = __addDisposableResource(env_1, await getRequestRegistry().begin({
-            requestId: requestId ?? generateServerRequestId(),
-            kind: 'translate',
-            modelId,
-            // LLM translate joins the completion lane (its cap = the model's own
-            // `parallel`); NMT passes no cap and stays ungated on its own model.
-            ...(isLlm && {
-                maxConcurrentPerModel: getModelParallel(entry.local.config)
-            })
-        }), true);
-        const requestLogger = withRequestContext(getServerLogger(), ctx);
-        // Cancel only this run's response, not the addon's global cancel, so a peer
-        // completion keeps running.
-        let activeResponse = null;
-        const cancelActive = () => {
-            activeResponse?.cancel().catch((err) => {
-                requestLogger.warn(`[cancel] translate response.cancel() rejected during abort for modelId=${modelId}: ${err instanceof Error ? err.message : String(err)}`);
-            });
-        };
-        if (isLlm) {
-            ctx.signal.addEventListener('abort', cancelActive, { once: true });
-            if (ctx.signal.aborted)
-                cancelActive();
-            ctx.scope.defer(() => {
-                ctx.signal.removeEventListener('abort', cancelActive);
-                activeResponse = null;
-            });
-        }
-        // Check if input is an array and model type is NMT
-        if (Array.isArray(text) && canonicalModelType === ModelType.nmtcppTranslation) {
-            // A cancel that landed before native work (e.g. the model is being unloaded)
-            // must not start the batch. Bail before runBatch, dropping the result.
-            if (ctx.signal.aborted) {
-                return { modelExecutionMs: 0 };
-            }
-            // Use runBatch for batch processing
-            const modelStart = nowMs();
-            const translations = await model.runBatch(text);
-            const modelExecutionMs = nowMs() - modelStart;
-            // Soft-cancel boundary: if `cancel({ requestId })` landed while
-            // the addon was running the batch, bail before yielding anything.
-            // The addon may have completed its work; the result is dropped.
-            if (ctx.signal.aborted) {
-                return { modelExecutionMs };
-            }
-            // Yield each translation with a newline separator
-            for (let i = 0; i < translations.length; i++) {
-                if (ctx.signal.aborted)
-                    break;
-                const translation = translations[i];
-                yield translation;
-                if (i < translations.length - 1) {
-                    yield '\n';
-                }
-            }
-            return { modelExecutionMs };
-        }
-        // Single text processing (for NMT or LLM)
-        const singleText = Array.isArray(text) ? text[0] : text;
-        // Prepare input based on model type
-        const input = canonicalModelType === ModelType.nmtcppTranslation
-            ? singleText
-            : [
-                {
-                    role: afriquePrompt ? 'user' : 'system',
-                    content: afriquePrompt
-                        ? `Translate ${fromLanguage} to ${toLanguage}.\n${fromLanguage}: ${singleText}\n${toLanguage}:`
-                        : `${context ? `${context}. ` : ''}Translate the following text from ${fromLanguage} into ${toLanguage}. Only output the translation, nothing else.\n\n${fromLanguage}: ${singleText}\n${toLanguage}:`
-                }
-            ];
-        // A translate cancelled before native work (queued-cancel, or the model being
-        // unloaded) must not call run(): LLM could decode against an exclusive finetune
-        // holding the lane, and either engine would run against a model being torn
-        // down. Bail with an empty soft-cancel result for both engines — the server
-        // never throws InferenceCancelledError (that error is client-constructed and
-        // would cross the RPC as a generic error).
-        if (ctx.signal.aborted) {
-            return { modelExecutionMs: 0 };
-        }
-        const modelStart = nowMs();
-        let response;
-        if (canonicalModelType === ModelType.llamacppCompletion &&
-            !shouldSkipPerCallSampling(entry.local.name)) {
-            response = await model.run(input, {
-                generationParams: LLM_TRANSLATE_GENERATION_PARAMS
-            });
-        }
-        else {
-            response = await model.run(input);
-        }
-        if (isLlm) {
-            activeResponse = response;
-            // A cancel that landed while `run(...)` was admitting still applies.
-            if (ctx.signal.aborted)
-                cancelActive();
-        }
-        // Check if the response has an iterate method (like LLM models)
-        if (canonicalModelType === ModelType.llamacppCompletion &&
-            typeof response.iterate === 'function') {
-            const llmResponse = response;
-            try {
-                for await (const token of llmResponse.iterate()) {
-                    if (ctx.signal.aborted)
-                        break;
-                    yield token;
-                }
-            }
-            catch (err) {
-                // A context-overflow rejection is a real terminal condition, not a
-                // cancellation — surface it even under an aborted signal, as completion does.
-                if (isAddonContextOverflowError(err))
-                    throw err;
-                // The request signal is the SDK-owned cancellation contract. Addon
-                // rejection shapes differ for active and queued native sequences, so once
-                // cancellation is accepted the translate ends cleanly regardless of that
-                // transport detail; without an abort, every error still propagates.
-                if (!ctx.signal.aborted)
-                    throw err;
-            }
-            const modelExecutionMs = nowMs() - modelStart;
-            const stats = {
-                ...(llmResponse.stats?.TPS !== undefined && { tokensPerSecond: llmResponse.stats.TPS }),
-                ...(llmResponse.stats?.TTFT !== undefined && { timeToFirstToken: llmResponse.stats.TTFT }),
-                ...(llmResponse.stats?.CacheTokens !== undefined && {
-                    cacheTokens: llmResponse.stats.CacheTokens
-                }),
-                ...(llmResponse.stats?.generatedTokens !== undefined && {
-                    totalTokens: llmResponse.stats.generatedTokens
-                })
-            };
-            return buildStreamResult(modelExecutionMs, stats);
-        }
-        const nmtResponse = response;
-        for await (const token of nmtResponse.iterate()) {
-            if (ctx.signal.aborted)
-                break;
-            yield token;
-        }
-        const modelExecutionMs = nowMs() - modelStart;
-        const stats = buildNmtTranslationStats(nmtResponse.stats);
-        return buildStreamResult(modelExecutionMs, stats);
-    }
-    catch (e_1) {
-        env_1.error = e_1;
-        env_1.hasError = true;
-    }
-    finally {
-        const result_1 = __disposeResources(env_1);
-        if (result_1)
-            await result_1;
-    }
-}

package/dist/server/bare/ops/unload-model.d.ts

@@ -1,3 +0,0 @@
-import { type UnloadModelParams } from '../../../schemas/index.js';
-export declare function unloadModel(params: UnloadModelParams): Promise<void>;
-//# sourceMappingURL=unload-model.d.ts.map

package/dist/server/bare/ops/unload-model.js

@@ -1,51 +0,0 @@
-import { promises as fsPromises } from 'bare-fs';
-import path from 'bare-path';
-import { unregisterModel } from '../../../server/bare/registry/model-registry.js';
-import { getRequestRegistry } from '../../../server/bare/runtime/index.js';
-import { unregisterAllLoggingStreams } from '../../../server/bare/registry/logging-stream-registry.js';
-import { clearFinetuneRuntimeState } from '../../../server/bare/plugins/llamacpp-completion/ops/finetune.js';
-import { unregisterAddonLogger, getServerLogger } from '../../../logging/index.js';
-import { unloadModelParamsSchema } from '../../../schemas/index.js';
-import { ModelNotLoadedError } from '../../../utils/errors-server.js';
-import { detectShardedModel } from '../../../server/utils/index.js';
-import { getClearStorageTarget } from '../../../server/utils/cache/paths.js';
-const logger = getServerLogger();
-export async function unloadModel(params) {
-    const { modelId, clearStorage } = unloadModelParamsSchema.parse(params);
-    const entry = unregisterModel(modelId);
-    if (!entry) {
-        throw new ModelNotLoadedError(modelId);
-    }
-    // Cancel and drain the model's requests, then tear down under the admission
-    // barrier so nothing goes active against a model being freed. The barrier is
-    // lifted for us when this resolves.
-    await getRequestRegistry().withModelDraining(modelId, async () => {
-        clearFinetuneRuntimeState(modelId);
-        if (!entry.isDelegated) {
-            if (entry.local.model.unload) {
-                await entry.local.model.unload();
-            }
-            if (clearStorage && entry.local.path) {
-                const modelPath = entry.local.path;
-                const modelFileName = path.basename(modelPath);
-                const shardInfo = detectShardedModel(modelFileName);
-                if (shardInfo.isSharded) {
-                    const shardDir = path.dirname(modelPath);
-                    await fsPromises.rm(shardDir, { recursive: true, force: true });
-                    logger.info(`Sharded model storage cleared: ${shardDir}`);
-                }
-                else {
-                    const target = getClearStorageTarget(modelPath);
-                    await fsPromises.rm(target.path, {
-                        recursive: target.kind === 'directory',
-                        force: true
-                    });
-                    logger.info(`Model storage cleared (${target.kind}): ${target.path}`);
-                }
-            }
-        }
-        unregisterAddonLogger(modelId);
-        unregisterAllLoggingStreams(modelId);
-        logger.info(`Model ${modelId} unloaded`);
-    });
-}

package/dist/server/bare/plugins/asr-ggml/config.d.ts

@@ -1,32 +0,0 @@
-import type ASRGgml from '@qvac/asr-ggml';
-import type { ParakeetConfig, WhisperConfig } from '../../../../schemas/index.js';
-export declare function buildWhisperEngineConfig(config: WhisperConfig): {
-    miscConfig?: {
-        [k: string]: unknown;
-    };
-    contextParams?: {
-        [k: string]: unknown;
-    };
-    engine: "whisper";
-    whisperConfig: ASRGgml.WhisperConfig;
-};
-export declare function buildParakeetEngineConfig(config: ParakeetConfig): {
-    engine: "parakeet";
-    parakeetConfig: {
-        [k: string]: unknown;
-    };
-};
-export declare function buildWhisperReloadConfig(config: WhisperConfig): {
-    miscConfig?: {
-        [k: string]: unknown;
-    };
-    whisperConfig: {
-        [k: string]: unknown;
-    };
-};
-export declare function buildParakeetReloadConfig(config: ParakeetConfig): {
-    parakeetConfig: {
-        [k: string]: unknown;
-    };
-};
-//# sourceMappingURL=config.d.ts.map

package/dist/server/bare/plugins/asr-ggml/config.js

@@ -1,46 +0,0 @@
-function omitUndefined(config) {
-    return Object.fromEntries(Object.entries(config).filter(([, value]) => value !== undefined));
-}
-function buildWhisperConfig(config) {
-    const whisperConfig = omitUndefined(config);
-    delete whisperConfig['contextParams'];
-    delete whisperConfig['miscConfig'];
-    delete whisperConfig['vadModelSrc'];
-    const detectLanguage = whisperConfig['detect_language'];
-    delete whisperConfig['detect_language'];
-    if (detectLanguage === true) {
-        whisperConfig['language'] = 'auto';
-    }
-    return whisperConfig;
-}
-export function buildWhisperEngineConfig(config) {
-    const whisperConfig = buildWhisperConfig(config);
-    return {
-        engine: 'whisper',
-        whisperConfig: whisperConfig,
-        ...(config.contextParams && {
-            contextParams: omitUndefined(config.contextParams)
-        }),
-        ...(config.miscConfig && { miscConfig: omitUndefined(config.miscConfig) })
-    };
-}
-export function buildParakeetEngineConfig(config) {
-    return {
-        engine: 'parakeet',
-        parakeetConfig: omitUndefined(config)
-    };
-}
-export function buildWhisperReloadConfig(config) {
-    const whisperConfig = buildWhisperConfig(config);
-    return {
-        whisperConfig,
-        ...(config.miscConfig && {
-            miscConfig: omitUndefined(config.miscConfig)
-        })
-    };
-}
-export function buildParakeetReloadConfig(config) {
-    return {
-        parakeetConfig: omitUndefined(config)
-    };
-}

package/dist/server/bare/plugins/asr-ggml/logging.d.ts

@@ -1,11 +0,0 @@
-import type { ModelType } from '../../../../schemas/index.js';
-type AsrModelType = typeof ModelType.whispercppTranscription | typeof ModelType.parakeetTranscription;
-/**
- * ASRGgml's native logger is process-global and cannot identify its originating
- * model. Keep instance loggers on engine-specific namespaces so the logger
- * passed to each ASRGgml instance remains isolated instead of subscribing both
- * model streams to the shared native callback.
- */
-export declare function createAsrModelLogger(modelId: string, modelType: AsrModelType): import("../../../../logging/index.js").Logger;
-export {};
-//# sourceMappingURL=logging.d.ts.map

package/dist/server/bare/plugins/asr-ggml/logging.js

@@ -1,12 +0,0 @@
-import { createStreamLogger, registerAddonLogger } from '../../../../logging/index.js';
-/**
- * ASRGgml's native logger is process-global and cannot identify its originating
- * model. Keep instance loggers on engine-specific namespaces so the logger
- * passed to each ASRGgml instance remains isolated instead of subscribing both
- * model streams to the shared native callback.
- */
-export function createAsrModelLogger(modelId, modelType) {
-    const logger = createStreamLogger(modelId, modelType);
-    registerAddonLogger(modelId, modelType, logger);
-    return logger;
-}

package/dist/server/bare/plugins/audiogen-ggml/config.d.ts

@@ -1,18 +0,0 @@
-import { type ResolveContext } from '../../../../schemas/index.js';
-export declare function resolveAudioGenConfig(config: Record<string, unknown>, ctx: ResolveContext): Promise<{
-    config: {
-        useGPU?: boolean | undefined;
-        inferenceSteps?: number | undefined;
-        shift?: number | undefined;
-        nGpuLayers?: number | undefined;
-        threads?: number | undefined;
-        backendsDir?: string | undefined;
-    };
-    artifacts: {
-        textEncModelPath: string;
-        lmModelPath: string;
-        ditModelPath: string;
-        vaeModelPath: string;
-    };
-}>;
-//# sourceMappingURL=config.d.ts.map

package/dist/server/bare/plugins/audiogen-ggml/config.js

@@ -1,23 +0,0 @@
-import { audioGenConfigSchema } from '../../../../schemas/index.js';
-export async function resolveAudioGenConfig(config, ctx) {
-    const parsed = audioGenConfigSchema.parse(config);
-    const { textEncModelSrc, lmModelSrc, ditModelSrc, vaeModelSrc, ...runtimeConfig } = parsed;
-    // These four artifacts total several gigabytes. Resolving them concurrently
-    // splits bandwidth across independent registry streams and can make each one
-    // exceed the per-block stall timeout even while aggregate throughput is
-    // healthy. Resolve sequentially until model constants and config resolution
-    // can expose a companion set together with all four resolved artifact paths.
-    const textEncModelPath = await ctx.resolveModelPath(textEncModelSrc);
-    const lmModelPath = await ctx.resolveModelPath(lmModelSrc);
-    const ditModelPath = await ctx.resolveModelPath(ditModelSrc);
-    const vaeModelPath = await ctx.resolveModelPath(vaeModelSrc);
-    return {
-        config: runtimeConfig,
-        artifacts: {
-            textEncModelPath,
-            lmModelPath,
-            ditModelPath,
-            vaeModelPath
-        }
-    };
-}

package/dist/server/bare/plugins/audiogen-ggml/ops/audio-gen-input.d.ts

@@ -1,20 +0,0 @@
-import { type AudioGenAudioInput } from '../../../../../schemas/audio-gen.js';
-export type AudioGenAudioInputName = 'referenceAudio' | 'sourceAudio';
-/**
- * Resolve a reference/source audio input into the interleaved stereo 48 kHz
- * Float32 PCM the ACE-Step engine consumes.
- *
- * - `base64` inputs (client `Buffer`/`Uint8Array`) must already be raw
- *   interleaved stereo 48 kHz Float32 LE PCM; they are handed over as-is
- *   (a copy is made only when the bytes are not 4-byte aligned).
- * - `filePath` inputs with a decodable extension (`.wav`, `.mp3`, `.m4a`,
- *   `.ogg`, `.flac`, `.aac`) are decoded through the SDK's FFmpeg decoder to
- *   48 kHz mono float PCM and duplicated onto both channels. Any other
- *   extension is streamed in as raw interleaved stereo 48 kHz Float32 LE PCM.
- *
- * Every path is bounded by `AUDIOGEN_INPUT_MAX_SECONDS` and rejects
- * non-finite samples, so malformed or oversized input fails with
- * `InvalidAudioInputError` before the engine is invoked.
- */
-export declare function resolveAudioGenPcm(input: AudioGenAudioInput, name: AudioGenAudioInputName): Promise<Float32Array>;
-//# sourceMappingURL=audio-gen-input.d.ts.map

package/dist/server/bare/plugins/audiogen-ggml/ops/audio-gen-input.js

@@ -1,153 +0,0 @@
-import fs from 'bare-fs';
-import { AUDIOGEN_INPUT_CHANNELS, AUDIOGEN_INPUT_MAX_SECONDS, AUDIOGEN_INPUT_SAMPLE_RATE } from '../../../../../schemas/audio-gen.js';
-import { decodeAudioToStream, needsDecoding } from '../../../../../server/utils/audio/decoder.js';
-import { AudioFileNotFoundError, InvalidAudioInputError } from '../../../../../utils/errors-server.js';
-const FLOAT32_BYTES = Float32Array.BYTES_PER_ELEMENT;
-const STEREO_FRAME_BYTES = FLOAT32_BYTES * AUDIOGEN_INPUT_CHANNELS;
-/** Upper bound for raw stereo input bytes (base64 payloads and raw PCM files). */
-const MAX_STEREO_BYTES = AUDIOGEN_INPUT_MAX_SECONDS * AUDIOGEN_INPUT_SAMPLE_RATE * STEREO_FRAME_BYTES;
-/** Upper bound for the mono float stream the FFmpeg decoder may emit. */
-const MAX_DECODED_MONO_BYTES = AUDIOGEN_INPUT_MAX_SECONDS * AUDIOGEN_INPUT_SAMPLE_RATE * FLOAT32_BYTES;
-/**
- * Resolve a reference/source audio input into the interleaved stereo 48 kHz
- * Float32 PCM the ACE-Step engine consumes.
- *
- * - `base64` inputs (client `Buffer`/`Uint8Array`) must already be raw
- *   interleaved stereo 48 kHz Float32 LE PCM; they are handed over as-is
- *   (a copy is made only when the bytes are not 4-byte aligned).
- * - `filePath` inputs with a decodable extension (`.wav`, `.mp3`, `.m4a`,
- *   `.ogg`, `.flac`, `.aac`) are decoded through the SDK's FFmpeg decoder to
- *   48 kHz mono float PCM and duplicated onto both channels. Any other
- *   extension is streamed in as raw interleaved stereo 48 kHz Float32 LE PCM.
- *
- * Every path is bounded by `AUDIOGEN_INPUT_MAX_SECONDS` and rejects
- * non-finite samples, so malformed or oversized input fails with
- * `InvalidAudioInputError` before the engine is invoked.
- */
-export async function resolveAudioGenPcm(input, name) {
-    switch (input.type) {
-        case 'base64':
-            return toStereoFloat32(Buffer.from(input.value, 'base64'), name);
-        case 'filePath': {
-            const filePath = input.value;
-            if (!needsDecoding(filePath)) {
-                return toStereoFloat32(await readRawPcmFile(filePath, name), name);
-            }
-            await assertDecodableFileSize(filePath, name);
-            return monoToStereo(await decodeMonoFloat32(filePath, name), name);
-        }
-        default:
-            throw new InvalidAudioInputError(`${name} must be a file path or raw PCM bytes`);
-    }
-}
-async function statInput(filePath) {
-    try {
-        return await fs.promises.stat(filePath);
-    }
-    catch (error) {
-        throw new AudioFileNotFoundError(filePath, error);
-    }
-}
-/**
- * The FFmpeg decoder buffers the whole input file before emitting PCM, so the
- * file itself is bounded up front: no encoded container for a clip within
- * `AUDIOGEN_INPUT_MAX_SECONDS` exceeds the size of that clip as raw stereo
- * Float32 PCM.
- */
-async function assertDecodableFileSize(filePath, name) {
-    const stats = await statInput(filePath);
-    if (stats.size <= MAX_STEREO_BYTES)
-        return;
-    throw new InvalidAudioInputError(`${name} (${filePath}) is ${Math.round(stats.size / 1_000_000)} MB; ` +
-        `files over ${Math.round(MAX_STEREO_BYTES / 1_000_000)} MB cannot fit the ` +
-        `${AUDIOGEN_INPUT_MAX_SECONDS} s limit and are rejected before decoding`);
-}
-/** Stream a raw PCM file into memory without blocking the event loop, capped by size. */
-async function readRawPcmFile(filePath, name) {
-    const stats = await statInput(filePath);
-    assertWithinLimit(stats.size, MAX_STEREO_BYTES, STEREO_FRAME_BYTES, name, filePath);
-    const chunks = [];
-    let total = 0;
-    const stream = fs.createReadStream(filePath);
-    for await (const chunk of stream) {
-        total += chunk.byteLength;
-        assertWithinLimit(total, MAX_STEREO_BYTES, STEREO_FRAME_BYTES, name, filePath);
-        chunks.push(chunk);
-    }
-    return chunks.length === 1 ? chunks[0] : Buffer.concat(chunks, total);
-}
-async function decodeMonoFloat32(filePath, name) {
-    const chunks = [];
-    let total = 0;
-    try {
-        const stream = await decodeAudioToStream(filePath, 'f32le', {
-            sampleRate: AUDIOGEN_INPUT_SAMPLE_RATE
-        });
-        for await (const chunk of stream) {
-            total += chunk.byteLength;
-            if (total > MAX_DECODED_MONO_BYTES) {
-                ;
-                stream.destroy();
-                assertWithinLimit(total, MAX_DECODED_MONO_BYTES, FLOAT32_BYTES, name, filePath);
-            }
-            chunks.push(chunk);
-        }
-    }
-    catch (error) {
-        if (error instanceof InvalidAudioInputError)
-            throw error;
-        throw new InvalidAudioInputError(`${name} could not be decoded from ${filePath}`, error);
-    }
-    if (total === 0 || total % FLOAT32_BYTES !== 0) {
-        throw new InvalidAudioInputError(`${name} decoded to no usable audio from ${filePath}`);
-    }
-    return asFloat32(chunks.length === 1 ? chunks[0] : Buffer.concat(chunks, total));
-}
-function monoToStereo(mono, name) {
-    if (mono.length === 0) {
-        throw new InvalidAudioInputError(`${name} decoded to no usable audio`);
-    }
-    const stereo = new Float32Array(mono.length * AUDIOGEN_INPUT_CHANNELS);
-    for (let frame = 0; frame < mono.length; frame++) {
-        const sample = mono[frame];
-        if (!Number.isFinite(sample))
-            throw nonFiniteError(name);
-        stereo[frame * AUDIOGEN_INPUT_CHANNELS] = sample;
-        stereo[frame * AUDIOGEN_INPUT_CHANNELS + 1] = sample;
-    }
-    return stereo;
-}
-function toStereoFloat32(bytes, name) {
-    if (bytes.byteLength === 0 || bytes.byteLength % STEREO_FRAME_BYTES !== 0) {
-        throw new InvalidAudioInputError(`${name} must be non-empty interleaved stereo ${AUDIOGEN_INPUT_SAMPLE_RATE} Hz Float32 PCM ` +
-            `(byte length a multiple of ${STEREO_FRAME_BYTES}, got ${bytes.byteLength})`);
-    }
-    assertWithinLimit(bytes.byteLength, MAX_STEREO_BYTES, STEREO_FRAME_BYTES, name);
-    const pcm = asFloat32(bytes);
-    for (let index = 0; index < pcm.length; index++) {
-        if (!Number.isFinite(pcm[index]))
-            throw nonFiniteError(name);
-    }
-    return pcm;
-}
-/**
- * View the bytes as Float32 without copying when they are 4-byte aligned
- * (fresh Buffers from base64/file reads and `Buffer.concat` are); only a
- * misaligned pooled slice needs to be copied out.
- */
-function asFloat32(bytes) {
-    if (bytes.byteOffset % FLOAT32_BYTES === 0) {
-        return new Float32Array(bytes.buffer, bytes.byteOffset, bytes.byteLength / FLOAT32_BYTES);
-    }
-    return new Float32Array(bytes.buffer.slice(bytes.byteOffset, bytes.byteOffset + bytes.byteLength));
-}
-function assertWithinLimit(bytes, limit, frameBytes, name, filePath) {
-    if (bytes <= limit)
-        return;
-    const seconds = Math.round(bytes / frameBytes / AUDIOGEN_INPUT_SAMPLE_RATE);
-    throw new InvalidAudioInputError(`${name}${filePath ? ` (${filePath})` : ''} is about ${seconds} s long; ` +
-        `the limit is ${AUDIOGEN_INPUT_MAX_SECONDS} s`);
-}
-function nonFiniteError(name) {
-    return new InvalidAudioInputError(`${name} must contain only finite samples`);
-}

package/dist/server/bare/plugins/audiogen-ggml/ops/audio-gen-stream.d.ts

@@ -1,3 +0,0 @@
-import { type AudioGenStreamRequest, type AudioGenStreamResponse } from '../../../../../schemas/audio-gen.js';
-export declare function audioGenStream(request: AudioGenStreamRequest): AsyncGenerator<AudioGenStreamResponse>;
-//# sourceMappingURL=audio-gen-stream.d.ts.map