@qvac/sdk 0.18.2 → 0.19.0

package/dist/server/rpc/transport-selector.js

@@ -1,18 +0,0 @@
-export function shouldUseStreamErrorTransport(entry, rawRequest) {
-    if (!entry)
-        return false;
-    if (entry.type === 'stream')
-        return true;
-    if (entry.type !== 'reply')
-        return false;
-    if (rawRequest?.['withProgress'] !== true)
-        return false;
-    try {
-        return typeof entry.supportsProgress === 'function'
-            ? entry.supportsProgress(rawRequest)
-            : !!entry.supportsProgress;
-    }
-    catch {
-        return !!entry.supportsProgress;
-    }
-}

package/dist/server/utils/archive.d.ts

@@ -1,4 +0,0 @@
-export declare function isArchiveUrl(url: string): boolean;
-export declare function extractTarStream(archivePath: string, extractDir: string, useGunzip: boolean, signal?: AbortSignal): Promise<void>;
-export declare function extractAndValidateShardedArchive(archivePath: string, extractDir: string, signal?: AbortSignal): Promise<string>;
-//# sourceMappingURL=archive.d.ts.map

package/dist/server/utils/archive.js

@@ -1,177 +0,0 @@
-import { promises as fsPromises } from 'bare-fs';
-import path from 'bare-path';
-import fs from 'bare-fs';
-import { createGunzip } from 'bare-zlib';
-import tarStream from 'tar-stream';
-import { detectShardedModel, generateShardFilenames, extractTensorsFromShards, validateShardedModelCache } from './shard-utils.js';
-import { ModelLoadFailedError, ArchiveExtractionFailedError, ArchiveUnsupportedTypeError, ArchiveMissingShardsError, DownloadCancelledError } from '../../utils/errors-server.js';
-import { isPathWithinBase } from '../../server/utils/path-security.js';
-import { getServerLogger } from '../../logging/index.js';
-import { SUPPORTED_ARCHIVE_EXTENSIONS, filenameToArchiveTypeSchema } from '../../schemas/archive.js';
-const logger = getServerLogger();
-// Gzip magic bytes: 1f 8b 08
-const GZIP_MAGIC_0 = 0x1f;
-const GZIP_MAGIC_1 = 0x8b;
-const GZIP_MAGIC_2 = 0x08;
-export function isArchiveUrl(url) {
-    const filename = url.split('/').pop()?.split('?')[0]?.toLowerCase() || '';
-    return SUPPORTED_ARCHIVE_EXTENSIONS.some((ext) => filename.endsWith(ext));
-}
-// Whitelist of model file extensions to extract from archives
-const ALLOWED_MODEL_EXTENSIONS = ['.gguf', '.tensors.txt'];
-function isModelFile(entryName) {
-    const basename = path.basename(entryName);
-    // Skip resource forks (._filename)
-    if (basename.startsWith('._')) {
-        return false;
-    }
-    return ALLOWED_MODEL_EXTENSIONS.some((ext) => basename.toLowerCase().endsWith(ext));
-}
-async function isGzip(archivePath) {
-    return new Promise((resolve, reject) => {
-        const stream = fs.createReadStream(archivePath, { start: 0, end: 2 });
-        const chunks = [];
-        stream.on('data', (chunk) => {
-            chunks.push(chunk);
-        });
-        stream.on('end', () => {
-            stream.destroy();
-            const buffer = Buffer.concat(chunks);
-            // Check for gzip magic bytes
-            const isGzipped = buffer[0] === GZIP_MAGIC_0 && buffer[1] === GZIP_MAGIC_1 && buffer[2] === GZIP_MAGIC_2;
-            resolve(isGzipped);
-        });
-        stream.on('error', reject);
-    });
-}
-async function extractArchive(archivePath, extractDir, signal) {
-    const parseResult = filenameToArchiveTypeSchema.safeParse(archivePath);
-    const extensionType = parseResult.success ? parseResult.data : null;
-    if (!extensionType) {
-        throw new ArchiveUnsupportedTypeError(archivePath);
-    }
-    if (signal?.aborted) {
-        throw new DownloadCancelledError();
-    }
-    // Detect actual format from magic bytes (extension might be wrong)
-    const isGzipped = await isGzip(archivePath);
-    const actualType = isGzipped ? 'tar.gz' : 'tar';
-    if (actualType !== extensionType) {
-        logger.warn(`⚠️ Archive extension suggests ${extensionType} but content is ${actualType}`);
-    }
-    await fsPromises.mkdir(extractDir, { recursive: true });
-    await extractTarStream(archivePath, extractDir, isGzipped, signal);
-}
-export async function extractTarStream(archivePath, extractDir, useGunzip, signal) {
-    const extract = tarStream.extract();
-    const gunzip = useGunzip ? createGunzip() : null;
-    return new Promise((resolve, reject) => {
-        let aborted = false;
-        let readStream = null;
-        const cleanup = () => {
-            aborted = true;
-            readStream?.destroy();
-            gunzip?.destroy();
-            extract.destroy();
-        };
-        if (signal) {
-            signal.addEventListener('abort', () => {
-                cleanup();
-                reject(new DownloadCancelledError());
-            });
-        }
-        extract.on('entry', (header, stream, next) => {
-            if (aborted) {
-                stream.resume();
-                return;
-            }
-            if (!isModelFile(header.name)) {
-                stream.resume();
-                next();
-                return;
-            }
-            // Prevent zip-slip: reject entries that escape extractDir (CWE-22)
-            const filePath = path.resolve(path.join(extractDir, header.name));
-            if (!isPathWithinBase(extractDir, filePath)) {
-                logger.warn(`⚠️ Skipping archive entry with path traversal: ${header.name}`);
-                stream.resume();
-                next();
-                return;
-            }
-            if (header.type === 'file') {
-                const dir = path.dirname(filePath);
-                fs.mkdirSync(dir, { recursive: true });
-                const writeStream = fs.createWriteStream(filePath);
-                stream.pipe(writeStream);
-                writeStream.on('finish', next);
-                writeStream.on('error', reject);
-            }
-            else {
-                stream.on('end', next);
-                stream.resume();
-            }
-        });
-        extract.on('finish', resolve);
-        extract.on('error', reject);
-        if (gunzip) {
-            gunzip.on('error', reject);
-        }
-        readStream = fs.createReadStream(archivePath);
-        if (gunzip) {
-            readStream.pipe(gunzip).pipe(extract);
-        }
-        else {
-            readStream.pipe(extract);
-        }
-    });
-}
-export async function extractAndValidateShardedArchive(archivePath, extractDir, signal) {
-    // Check if shards already extracted
-    try {
-        const existingFiles = await fsPromises.readdir(extractDir);
-        const existingShard = existingFiles.find((f) => detectShardedModel(String(f)).isSharded);
-        if (existingShard) {
-            const isComplete = await validateShardedModelCache(extractDir, String(existingShard));
-            if (isComplete) {
-                logger.info(`✅ Archive already extracted: ${extractDir}`);
-                const shardFilenames = generateShardFilenames(String(existingShard));
-                return path.join(extractDir, shardFilenames[0]);
-            }
-            logger.warn(`⚠️ Incomplete extraction found, re-extracting archive`);
-        }
-    }
-    catch {
-        // Directory doesn't exist, proceed with extraction
-    }
-    logger.info(`Extracting archive: ${path.basename(archivePath)}`);
-    try {
-        await extractArchive(archivePath, extractDir, signal);
-    }
-    catch (error) {
-        throw new ArchiveExtractionFailedError(archivePath, error);
-    }
-    const files = await fsPromises.readdir(extractDir);
-    const shardedFile = files.find((f) => detectShardedModel(String(f)).isSharded);
-    if (!shardedFile) {
-        throw new ModelLoadFailedError(`No sharded model files found in archive. Expected pattern: *-00001-of-0000X.*`);
-    }
-    const shardedFileName = String(shardedFile);
-    const shardInfo = detectShardedModel(shardedFileName);
-    if (!shardInfo.baseFilename) {
-        throw new ModelLoadFailedError(`Could not extract base filename from sharded model: ${shardedFileName}`);
-    }
-    const shardFilenames = generateShardFilenames(shardedFileName);
-    for (const shardFilename of shardFilenames) {
-        const filePath = path.join(extractDir, shardFilename);
-        try {
-            await fsPromises.access(filePath);
-        }
-        catch {
-            throw new ArchiveMissingShardsError(shardFilename);
-        }
-    }
-    // Generate tensors.txt if it doesn't exist
-    await extractTensorsFromShards(extractDir, shardedFileName);
-    logger.info(`Archive extracted to ${extractDir} successfully: ${files.length} files`);
-    return path.join(extractDir, shardFilenames[0]);
-}

package/dist/server/utils/audio/decoder.d.ts

@@ -1,41 +0,0 @@
-import { type DecoderOutput } from '@qvac/decoder-audio';
-import { Readable } from 'bare-stream';
-import { type AudioFormat } from '../../../schemas/index.js';
-export declare function needsDecoding(filePath: string): boolean;
-/**
- * Longest silence the decoder may go without emitting a PCM chunk before the
- * decode is abandoned. Measured between outputs, not against the whole file, so
- * long inputs decode fine as long as FFmpeg keeps producing data.
- */
-export declare const DECODER_INACTIVITY_TIMEOUT_MS = 10000;
-export interface DecodeAudioOptions {
-    /** Output sample rate; the decoder's default is 16 kHz (what every transcription engine expects). */
-    sampleRate?: number;
-    /** Inactivity timeout between decoded chunks (default `DECODER_INACTIVITY_TIMEOUT_MS`). */
-    inactivityTimeoutMs?: number;
-}
-/** The subset of the decoder's `QvacResponse` that the stream bridge consumes. */
-export interface DecoderResponseLike {
-    onUpdate(callback: (output: DecoderOutput) => void): DecoderResponseLike;
-    onFinish(callback: () => void): DecoderResponseLike;
-    onError(callback: (error: Error) => void): DecoderResponseLike;
-    await(): Promise<unknown>;
-}
-export interface DecoderStreamOptions {
-    /** Used in error messages only. */
-    inputPath: string;
-    inactivityTimeoutMs?: number;
-    /** Runs once, on whichever terminal path (finish, error, timeout) settles the stream. */
-    onSettled?: () => void;
-}
-/**
- * Decode an audio file into a raw mono PCM stream.
- */
-export declare function decodeAudioToStream(inputPath: string, audioFormat?: AudioFormat, options?: DecodeAudioOptions): Promise<Readable>;
-/**
- * Bridge a decoder response into a `Readable` of PCM chunks. The stream fails
- * if the decoder emits nothing for `inactivityTimeoutMs`; the timer is re-armed
- * on every chunk, so it bounds inactivity, not the total decode time.
- */
-export declare function decoderResponseToStream(response: DecoderResponseLike, options: DecoderStreamOptions): Readable;
-//# sourceMappingURL=decoder.d.ts.map

package/dist/server/utils/audio/decoder.js

@@ -1,108 +0,0 @@
-import fs from 'bare-fs';
-import path from 'bare-path';
-import { FFmpegDecoder } from '@qvac/decoder-audio';
-import { FORMATS_NEEDING_DECODE } from '@qvac/decoder-audio/constants';
-import { Readable } from 'bare-stream';
-import { getServerLogger } from '../../../logging/index.js';
-import {} from '../../../schemas/index.js';
-const logger = getServerLogger();
-export function needsDecoding(filePath) {
-    const ext = path.extname(filePath).toLowerCase();
-    return FORMATS_NEEDING_DECODE.includes(ext);
-}
-/**
- * Longest silence the decoder may go without emitting a PCM chunk before the
- * decode is abandoned. Measured between outputs, not against the whole file, so
- * long inputs decode fine as long as FFmpeg keeps producing data.
- */
-export const DECODER_INACTIVITY_TIMEOUT_MS = 10000;
-/**
- * Decode an audio file into a raw mono PCM stream.
- */
-export async function decodeAudioToStream(inputPath, audioFormat = 's16le', options = {}) {
-    const { sampleRate, inactivityTimeoutMs = DECODER_INACTIVITY_TIMEOUT_MS } = options;
-    const decoder = new FFmpegDecoder({
-        config: { audioFormat, ...(sampleRate !== undefined && { sampleRate }) },
-        logger
-    });
-    try {
-        await decoder.load();
-        const audioStream = fs.createReadStream(inputPath);
-        const response = decoder.run(audioStream);
-        return decoderResponseToStream(response, {
-            inputPath,
-            inactivityTimeoutMs,
-            onSettled: () => setImmediate(() => void decoder.unload())
-        });
-    }
-    catch (error) {
-        await decoder.unload();
-        logger.error('Decoding failed:', error instanceof Error ? error.message : String(error));
-        throw error;
-    }
-}
-/**
- * Bridge a decoder response into a `Readable` of PCM chunks. The stream fails
- * if the decoder emits nothing for `inactivityTimeoutMs`; the timer is re-armed
- * on every chunk, so it bounds inactivity, not the total decode time.
- */
-export function decoderResponseToStream(response, options) {
-    const { inputPath, inactivityTimeoutMs = DECODER_INACTIVITY_TIMEOUT_MS, onSettled } = options;
-    const outputStream = new Readable({
-        read() { }
-    });
-    let hasReceivedData = false;
-    let hasEnded = false;
-    let timeoutId;
-    const settle = () => {
-        if (hasEnded)
-            return false;
-        hasEnded = true;
-        if (timeoutId !== undefined)
-            clearTimeout(timeoutId);
-        onSettled?.();
-        return true;
-    };
-    const armTimeout = () => {
-        if (timeoutId !== undefined)
-            clearTimeout(timeoutId);
-        timeoutId = setTimeout(() => {
-            if (!settle())
-                return;
-            outputStream.destroy(new Error(`Audio decoding produced no output for ${inactivityTimeoutMs}ms for file: ${inputPath}`));
-        }, inactivityTimeoutMs);
-    };
-    armTimeout();
-    outputStream.on('close', () => {
-        settle();
-    });
-    response
-        .onUpdate((output) => {
-        hasReceivedData = true;
-        if (!hasEnded)
-            armTimeout();
-        const bytes = new Uint8Array(output.outputArray);
-        outputStream.push(Buffer.from(bytes));
-    })
-        .onFinish(() => {
-        if (!settle())
-            return;
-        if (!hasReceivedData) {
-            outputStream.destroy(new Error(`No audio data decoded from file: ${inputPath}`));
-        }
-        else {
-            outputStream.push(null);
-        }
-    })
-        .onError((error) => {
-        if (!settle())
-            return;
-        outputStream.destroy(error);
-    });
-    response.await().catch((error) => {
-        if (!settle())
-            return;
-        outputStream.destroy(error instanceof Error ? error : new Error(String(error)));
-    });
-    return outputStream;
-}

package/dist/server/utils/cache/auto-history.d.ts

@@ -1,4 +0,0 @@
-import type { CacheMessage } from './types.js';
-export declare function getAutoCacheLookupHistory(currentHistory: CacheMessage[]): CacheMessage[];
-export declare function buildAutoCacheSaveHistory(currentHistory: CacheMessage[], assistantResponse: string): CacheMessage[];
-//# sourceMappingURL=auto-history.d.ts.map

package/dist/server/utils/cache/auto-history.js

@@ -1,26 +0,0 @@
-import { normalizeAssistantCacheContent } from '../../../utils/cache-normalize.js';
-function normalizeCacheMessage(message) {
-    const { attachments, ...normalized } = message;
-    if (message.role === 'assistant') {
-        normalized.content = normalizeAssistantCacheContent(message.content);
-    }
-    return {
-        ...normalized,
-        ...(attachments && attachments.length > 0 ? { attachments } : {})
-    };
-}
-export function getAutoCacheLookupHistory(currentHistory) {
-    if (currentHistory.length <= 1) {
-        return [];
-    }
-    return currentHistory.slice(0, -1).map(normalizeCacheMessage);
-}
-export function buildAutoCacheSaveHistory(currentHistory, assistantResponse) {
-    return [
-        ...currentHistory.map(normalizeCacheMessage),
-        normalizeCacheMessage({
-            role: 'assistant',
-            content: assistantResponse
-        })
-    ];
-}

package/dist/server/utils/cache/paths.d.ts

@@ -1,43 +0,0 @@
-import type { ShardFileMetadata } from '../../../schemas/index.js';
-export declare function getCacheDir(subDir: string): string;
-export declare function getModelsCacheDir(): string;
-export declare function getKVCacheDir(): string;
-/**
- * Get cache directory for sharded model
- * Returns: cache/sharded/<hyperdriveKey>/
- */
-export declare function getShardedModelCacheDir(hyperdriveKey: string): string;
-/**
- * Get cache directory for a companion set.
- * Returns: cache/sets/<setKey>/
- */
-export declare function getCompanionSetCacheDir(setKey: string): string;
-/**
- * Get full path to a file within a companion set cache.
- * Returns: cache/sets/<setKey>/<targetName>
- */
-export declare function getCompanionSetPath(setKey: string, targetName: string): string;
-/**
- * Get cache path for a single (non-sharded, non-companion) registry model.
- */
-export declare function getSingleFileCachePath(registryPath: string): string;
-/**
- * Get full path to specific shard file
- * Returns: cache/sharded/<hyperdriveKey>/<shardFilename>
- */
-export declare function getShardPath(hyperdriveKey: string, shardFilename: string): string;
-/**
- * Returns the deletion target for `clearStorage`. Scoped to the SDK cache
- * directory — companion set and legacy ONNX paths delete the parent directory.
- */
-export declare function getClearStorageTarget(modelPath: string): {
-    path: string;
-    kind: 'file' | 'directory';
-};
-/**
- * Check if all shards exist and are valid (size + checksum check)
- * Returns array of missing/invalid shard indices (0-based)
- * @param onChecksumTimeMs - Optional callback to report checksum validation time
- */
-export declare function checkShardCompleteness(hyperdriveKey: string, shardFilenames: readonly string[], shardMetadata: readonly ShardFileMetadata[], onChecksumTimeMs?: (ms: number) => void): Promise<number[]>;
-//# sourceMappingURL=paths.d.ts.map

package/dist/server/utils/cache/paths.js

@@ -1,133 +0,0 @@
-import fs, { promises as fsPromises } from 'bare-fs';
-import path from 'bare-path';
-import { getConfiguredCacheDir } from '../../../server/bare/registry/config-registry.js';
-import { getQvacPath } from '../../../server/utils/qvac-paths.js';
-import { calculateFileChecksum } from '../../../server/utils/checksum.js';
-import { validateAndJoinPath } from '../../../server/utils/path-security.js';
-import { generateShortHash } from '../../../server/utils/formatting.js';
-import { getServerLogger } from '../../../logging/index.js';
-import { nowMs } from '../../../profiling/index.js';
-import { resolveClearStorageTarget } from '../../../server/utils/clear-storage.js';
-const logger = getServerLogger();
-export function getCacheDir(subDir) {
-    const cacheDir = getQvacPath(subDir);
-    try {
-        fs.mkdirSync(cacheDir, { recursive: true });
-    }
-    catch (error) {
-        logger.error(`Error creating cache directory (${subDir}):`, error instanceof Error ? error.message : String(error));
-    }
-    return cacheDir;
-}
-export function getModelsCacheDir() {
-    const configuredDir = getConfiguredCacheDir();
-    try {
-        fs.mkdirSync(configuredDir, { recursive: true });
-    }
-    catch (error) {
-        logger.error(`Error creating models cache directory:`, error instanceof Error ? error.message : String(error));
-    }
-    return configuredDir;
-}
-export function getKVCacheDir() {
-    return getCacheDir('kv-cache');
-}
-/**
- * Get cache directory for sharded model
- * Returns: cache/sharded/<hyperdriveKey>/
- */
-export function getShardedModelCacheDir(hyperdriveKey) {
-    const baseCache = getModelsCacheDir();
-    const shardDir = path.join(baseCache, 'sharded', hyperdriveKey);
-    try {
-        fs.mkdirSync(shardDir, { recursive: true });
-    }
-    catch (error) {
-        logger.error(`Error creating sharded model cache directory:`, error instanceof Error ? error.message : String(error));
-    }
-    return shardDir;
-}
-/**
- * Get cache directory for a companion set.
- * Returns: cache/sets/<setKey>/
- */
-export function getCompanionSetCacheDir(setKey) {
-    const baseCache = getModelsCacheDir();
-    const setDir = validateAndJoinPath(baseCache, 'sets', setKey);
-    try {
-        fs.mkdirSync(setDir, { recursive: true });
-    }
-    catch (error) {
-        logger.error(`Error creating companion set cache directory:`, error instanceof Error ? error.message : String(error));
-    }
-    return setDir;
-}
-/**
- * Get full path to a file within a companion set cache.
- * Returns: cache/sets/<setKey>/<targetName>
- */
-export function getCompanionSetPath(setKey, targetName) {
-    const setDir = getCompanionSetCacheDir(setKey);
-    return validateAndJoinPath(setDir, targetName);
-}
-/**
- * Get cache path for a single (non-sharded, non-companion) registry model.
- */
-export function getSingleFileCachePath(registryPath) {
-    const filename = registryPath.split('/').pop() || registryPath;
-    const sourceHash = generateShortHash(registryPath);
-    return path.join(getModelsCacheDir(), `${sourceHash}_${filename}`);
-}
-/**
- * Get full path to specific shard file
- * Returns: cache/sharded/<hyperdriveKey>/<shardFilename>
- */
-export function getShardPath(hyperdriveKey, shardFilename) {
-    const shardDir = getShardedModelCacheDir(hyperdriveKey);
-    return validateAndJoinPath(shardDir, shardFilename);
-}
-/**
- * Returns the deletion target for `clearStorage`. Scoped to the SDK cache
- * directory — companion set and legacy ONNX paths delete the parent directory.
- */
-export function getClearStorageTarget(modelPath) {
-    return resolveClearStorageTarget(modelPath, getModelsCacheDir());
-}
-/**
- * Check if all shards exist and are valid (size + checksum check)
- * Returns array of missing/invalid shard indices (0-based)
- * @param onChecksumTimeMs - Optional callback to report checksum validation time
- */
-export async function checkShardCompleteness(hyperdriveKey, shardFilenames, shardMetadata, onChecksumTimeMs) {
-    const invalidIndices = [];
-    for (let i = 0; i < shardFilenames.length; i++) {
-        const shardPath = getShardPath(hyperdriveKey, shardFilenames[i]);
-        const fileMeta = shardMetadata[i];
-        if (!fileMeta) {
-            invalidIndices.push(i);
-            continue;
-        }
-        try {
-            const stats = await fsPromises.stat(shardPath);
-            if (stats.size !== fileMeta.expectedSize) {
-                logger.warn(`File ${i + 1} size mismatch: expected ${fileMeta.expectedSize}, got ${stats.size}`);
-                invalidIndices.push(i);
-                continue;
-            }
-            if (fileMeta.sha256Checksum) {
-                const start = nowMs();
-                const actualChecksum = await calculateFileChecksum(shardPath);
-                onChecksumTimeMs?.(nowMs() - start);
-                if (actualChecksum !== fileMeta.sha256Checksum) {
-                    logger.warn(`File ${i + 1} checksum mismatch for ${fileMeta.filename}. Expected: ${fileMeta.sha256Checksum}. Actual: ${actualChecksum}. Will re-download.`);
-                    invalidIndices.push(i);
-                }
-            }
-        }
-        catch {
-            // File doesn't exist
-            invalidIndices.push(i);
-        }
-    }
-    return invalidIndices;
-}

package/dist/server/utils/cache/types.d.ts

@@ -1,8 +0,0 @@
-export interface CacheMessage {
-    role: string;
-    content: string;
-    attachments?: {
-        path: string;
-    }[] | undefined;
-}
-//# sourceMappingURL=types.d.ts.map

package/dist/server/utils/cache/types.js

@@ -1 +0,0 @@
-export {};

package/dist/server/utils/checksum.d.ts

@@ -1,4 +0,0 @@
-import type { DownloadHooks } from '../../server/rpc/handlers/load-model/types.js';
-export declare function calculateFileChecksum(filePath: string): Promise<string>;
-export declare function measureChecksum(filePath: string, hooks?: DownloadHooks): Promise<string>;
-//# sourceMappingURL=checksum.d.ts.map

package/dist/server/utils/checksum.js

@@ -1,30 +0,0 @@
-import fs from 'bare-fs';
-import crypto from 'bare-crypto';
-import { nowMs } from '../../profiling/index.js';
-import {} from 'bare-buffer';
-export async function calculateFileChecksum(filePath) {
-    return new Promise((resolve, reject) => {
-        try {
-            const hash = crypto.createHash('sha-256');
-            const stream = fs.createReadStream(filePath);
-            stream.on('data', (chunk) => {
-                hash.update(chunk);
-            });
-            stream.on('end', () => {
-                resolve(hash.digest('hex'));
-            });
-            stream.on('error', (error) => {
-                reject(new Error(`Checksum calculation error: ${error.message}`));
-            });
-        }
-        catch (error) {
-            reject(error instanceof Error ? error : new Error(`Checksum calculation error: ${String(error)}`));
-        }
-    });
-}
-export async function measureChecksum(filePath, hooks) {
-    const start = nowMs();
-    const checksum = await calculateFileChecksum(filePath);
-    hooks?.addChecksumValidationTimeMs?.(nowMs() - start);
-    return checksum;
-}

package/dist/server/utils/clear-storage.d.ts

@@ -1,5 +0,0 @@
-export declare function resolveClearStorageTarget(modelPath: string, modelsCacheDir: string): {
-    path: string;
-    kind: 'file' | 'directory';
-};
-//# sourceMappingURL=clear-storage.d.ts.map

package/dist/server/utils/clear-storage.js

@@ -1,14 +0,0 @@
-export function resolveClearStorageTarget(modelPath, modelsCacheDir) {
-    const normalizedCache = modelsCacheDir.replace(/\\/g, '/').replace(/\/+$/, '');
-    const normalizedPath = modelPath.replace(/\\/g, '/');
-    if (!normalizedPath.startsWith(`${normalizedCache}/`)) {
-        return { path: modelPath, kind: 'file' };
-    }
-    const relativePath = normalizedPath.slice(normalizedCache.length + 1);
-    const parts = relativePath.split('/');
-    if (parts.length === 3 && (parts[0] === 'sets' || parts[0] === 'onnx') && parts[1] && parts[2]) {
-        const lastSlash = normalizedPath.lastIndexOf('/');
-        return { path: normalizedPath.slice(0, lastSlash), kind: 'directory' };
-    }
-    return { path: modelPath, kind: 'file' };
-}

package/dist/server/utils/completion-normalizer.d.ts

@@ -1,18 +0,0 @@
-import type { CompletionEvent, CompletionError, CompletionStats, NormalizerConfig, StopReason, ToolCall } from '../../schemas/index.js';
-export declare const MAX_TOOL_FRAME_CHARS = 1048576;
-export type CompletionNormalizer = ReturnType<typeof createCompletionNormalizer>;
-export declare function createCompletionNormalizer(config: NormalizerConfig): {
-    push: (token: string) => CompletionEvent[];
-    finish: (opts?: {
-        stats?: CompletionStats;
-        toolCalls?: ToolCall[];
-        error?: CompletionError;
-        stopReason?: StopReason;
-    }) => CompletionEvent[];
-    getAccumulated: () => {
-        rawText: string;
-        contentText: string;
-        thinkingText: string | undefined;
-    };
-};
-//# sourceMappingURL=completion-normalizer.d.ts.map