@qvac/sdk 0.4.1 → 0.6.0

package/dist/server/utils/config-transform.js

@@ -0,0 +1,23 @@
+import { normalizeModelType, ModelType, } from "../../schemas/index.js";
+export function transformConfigForReload(modelType, config) {
+    const canonicalType = normalizeModelType(modelType);
+    switch (canonicalType) {
+        case ModelType.whispercppTranscription: {
+            const whisperConfig = config;
+            // eslint-disable-next-line @typescript-eslint/no-unused-vars
+            const { contextParams, miscConfig, ...whisperParams } = whisperConfig;
+            return {
+                whisperConfig: whisperParams,
+                ...(miscConfig && { miscConfig }),
+            };
+        }
+        case ModelType.llamacppCompletion:
+        case ModelType.llamacppEmbedding:
+        case ModelType.nmtcppTranslation:
+        case ModelType.onnxTts:
+            // Return as-is for now
+            return config;
+        default:
+            return config;
+    }
+}

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

@@ -0,0 +1,13 @@
+/**
+ * Generate a short hash (16 characters) from any input string
+ */
+export declare function generateShortHash(input: string): string;
+/**
+ * Calculate progress percentage with bounds checking and consistent formatting
+ * @param current - Current progress value
+ * @param total - Total value
+ * @param decimals - Number of decimal places (default: 2)
+ * @returns Percentage clamped between 0-100 with fixed decimal places
+ */
+export declare function calculatePercentage(current: number, total: number, decimals?: number): number;
+//# sourceMappingURL=formatting.d.ts.map

package/dist/server/utils/formatting.js

@@ -0,0 +1,26 @@
+import crypto from "bare-crypto";
+/**
+ * Generate a short hash (16 characters) from any input string
+ */
+export function generateShortHash(input) {
+    const hash = crypto
+        .createHash("sha256")
+        .update(Buffer.from(input, "utf8"))
+        .digest("hex");
+    return hash.substring(0, 16);
+}
+/**
+ * Calculate progress percentage with bounds checking and consistent formatting
+ * @param current - Current progress value
+ * @param total - Total value
+ * @param decimals - Number of decimal places (default: 2)
+ * @returns Percentage clamped between 0-100 with fixed decimal places
+ */
+export function calculatePercentage(current, total, decimals = 2) {
+    if (total <= 0 || current < 0) {
+        return 0;
+    }
+    const rawPercentage = (current / total) * 100;
+    const clampedPercentage = Math.min(Math.max(rawPercentage, 0), 100);
+    return Number(clampedPercentage.toFixed(decimals));
+}

package/dist/server/utils/gguf-tensor-extractor.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Extract tensor names from all GGUF shards and write to {baseFilename}.tensors.txt
+ * Required for sharded models to enable incremental/async loading
+ * @throws ModelLoadFailedError if any shard fails extraction
+ */
+export declare function extractAndWriteTensorsFile(shardDir: string, shardFilenames: string[], baseFilename: string): Promise<string>;
+/**
+ * Check if a file has a valid GGUF header structure.
+ * Returns true if the header parses successfully and contains tensor metadata.
+ *
+ * NOTE: This only validates the header structure, NOT that tensor data exists.
+ * A file can have a valid header but be incomplete.
+ */
+export declare function hasValidGGUFHeader(filePath: string): Promise<boolean>;
+//# sourceMappingURL=gguf-tensor-extractor.d.ts.map

package/dist/server/utils/gguf-tensor-extractor.js

@@ -0,0 +1,314 @@
+import { promises as fsPromises, createReadStream } from "bare-fs";
+import path from "bare-path";
+import { getServerLogger } from "../../logging/index.js";
+import { ModelLoadFailedError } from "../../utils/errors-server.js";
+const logger = getServerLogger();
+// GGUF value types
+const GGUF_TYPE = {
+    UINT8: 0,
+    INT8: 1,
+    UINT16: 2,
+    INT16: 3,
+    UINT32: 4,
+    INT32: 5,
+    FLOAT32: 6,
+    BOOL: 7,
+    STRING: 8,
+    ARRAY: 9,
+    UINT64: 10,
+    INT64: 11,
+    FLOAT64: 12,
+};
+// Type sizes in bytes
+const TYPE_SIZE = {
+    [GGUF_TYPE.UINT8]: 1,
+    [GGUF_TYPE.INT8]: 1,
+    [GGUF_TYPE.UINT16]: 2,
+    [GGUF_TYPE.INT16]: 2,
+    [GGUF_TYPE.UINT32]: 4,
+    [GGUF_TYPE.INT32]: 4,
+    [GGUF_TYPE.FLOAT32]: 4,
+    [GGUF_TYPE.BOOL]: 1,
+    [GGUF_TYPE.UINT64]: 8,
+    [GGUF_TYPE.INT64]: 8,
+    [GGUF_TYPE.FLOAT64]: 8,
+};
+// Limits to prevent DoS/corruption issues
+const LIMITS = {
+    MAX_KV_COUNT: 100_000,
+    MAX_TENSOR_COUNT: 1_000_000,
+    MAX_STRING_LEN: 100 * 1024 * 1024, // 100MB for tokenizer vocab
+    MAX_TENSOR_NAME_LEN: 64 * 1024, // 64KB for tensor names
+    MAX_ARRAY_LEN: 1_000_000_000, // 1B elements
+    MAX_DIMS: 32,
+    MAX_HEADER_SIZE: 4 * 1024 * 1024 * 1024, // 4GB max header
+};
+// Magic bytes for endianness detection
+const GGUF_MAGIC_LE = 0x46554747; // "GGUF" little-endian
+const GGUF_MAGIC_BE = 0x47475546; // "FUGG" big-endian
+// File-local error for streaming parser control flow
+// Used to signal "keep reading chunks" rather than an actual failure
+class NeedMoreDataError extends Error {
+    currentOffset;
+    bytesNeeded;
+    constructor(currentOffset, bytesNeeded) {
+        super(`Need more data: offset ${currentOffset} requires ${bytesNeeded} more bytes`);
+        this.currentOffset = currentOffset;
+        this.bytesNeeded = bytesNeeded;
+        this.name = "NeedMoreDataError";
+    }
+}
+function parseGGUFHeader(buffer) {
+    const bufferLength = buffer.length;
+    let offset = 0;
+    let isBigEndian = false;
+    function ensureBytes(needed) {
+        if (offset + needed > bufferLength) {
+            throw new NeedMoreDataError(offset, needed);
+        }
+    }
+    function readU32() {
+        ensureBytes(4);
+        const val = isBigEndian
+            ? buffer.readUInt32BE(offset)
+            : buffer.readUInt32LE(offset);
+        offset += 4;
+        return val;
+    }
+    function readU64() {
+        ensureBytes(8);
+        const val = isBigEndian
+            ? buffer.readBigUInt64BE(offset)
+            : buffer.readBigUInt64LE(offset);
+        offset += 8;
+        return val;
+    }
+    function readU64AsNumber() {
+        const val = readU64();
+        if (val > BigInt(Number.MAX_SAFE_INTEGER)) {
+            throw new ModelLoadFailedError(`Value ${val} exceeds safe integer range`);
+        }
+        return Number(val);
+    }
+    function skipBytes(n) {
+        ensureBytes(n);
+        offset += n;
+    }
+    function skipString() {
+        const len = readU64AsNumber();
+        if (len > LIMITS.MAX_STRING_LEN) {
+            throw new ModelLoadFailedError(`String length ${len} exceeds limit ${LIMITS.MAX_STRING_LEN}`);
+        }
+        skipBytes(len);
+    }
+    function readTensorName() {
+        const len = readU64AsNumber();
+        if (len > LIMITS.MAX_TENSOR_NAME_LEN) {
+            logger.warn(`Tensor name length ${len} exceeds limit, truncating`);
+            skipBytes(len);
+            return "";
+        }
+        ensureBytes(len);
+        const name = buffer.toString("utf8", offset, offset + len);
+        offset += len;
+        return name;
+    }
+    function skipValue(valueType) {
+        const size = TYPE_SIZE[valueType];
+        if (size !== undefined) {
+            skipBytes(size);
+            return;
+        }
+        if (valueType === GGUF_TYPE.STRING) {
+            skipString();
+            return;
+        }
+        if (valueType === GGUF_TYPE.ARRAY) {
+            const arrayType = readU32();
+            const arrayLen = readU64AsNumber();
+            if (arrayLen > LIMITS.MAX_ARRAY_LEN) {
+                throw new ModelLoadFailedError(`Array length ${arrayLen} exceeds limit ${LIMITS.MAX_ARRAY_LEN}`);
+            }
+            const elementSize = TYPE_SIZE[arrayType];
+            if (elementSize !== undefined) {
+                // Fixed-size elements
+                skipBytes(arrayLen * elementSize);
+            }
+            else if (arrayType === GGUF_TYPE.STRING) {
+                // Array of strings
+                for (let i = 0; i < arrayLen; i++) {
+                    skipString();
+                }
+            }
+            else if (arrayType === GGUF_TYPE.ARRAY) {
+                throw new ModelLoadFailedError("Nested arrays not supported");
+            }
+            else {
+                throw new ModelLoadFailedError(`Unknown array element type: ${arrayType}`);
+            }
+            return;
+        }
+        throw new ModelLoadFailedError(`Unknown value type: ${valueType}`);
+    }
+    // Parse header
+    ensureBytes(4);
+    const magicLE = buffer.readUInt32LE(offset);
+    if (magicLE === GGUF_MAGIC_LE) {
+        isBigEndian = false;
+    }
+    else if (magicLE === GGUF_MAGIC_BE) {
+        isBigEndian = true;
+        logger.debug("Detected big-endian GGUF file");
+    }
+    else {
+        throw new ModelLoadFailedError(`Invalid GGUF file - magic number mismatch (got 0x${magicLE.toString(16)})`);
+    }
+    offset += 4;
+    // Version
+    const version = readU32();
+    if (version !== 2 && version !== 3) {
+        throw new ModelLoadFailedError(`Unsupported GGUF version: ${version}`);
+    }
+    // Tensor count and KV count
+    const tensorCount = readU64AsNumber();
+    const kvCount = readU64AsNumber();
+    if (tensorCount > LIMITS.MAX_TENSOR_COUNT) {
+        throw new ModelLoadFailedError(`Tensor count ${tensorCount} exceeds limit ${LIMITS.MAX_TENSOR_COUNT}`);
+    }
+    if (kvCount > LIMITS.MAX_KV_COUNT) {
+        throw new ModelLoadFailedError(`KV count ${kvCount} exceeds limit ${LIMITS.MAX_KV_COUNT}`);
+    }
+    // Skip all KV pairs
+    for (let i = 0; i < kvCount; i++) {
+        skipString();
+        const valueType = readU32();
+        skipValue(valueType);
+    }
+    logger.debug(`KV section complete at offset ${offset}, reading tensor names...`);
+    const tensorNames = [];
+    for (let i = 0; i < tensorCount; i++) {
+        const name = readTensorName();
+        if (name) {
+            tensorNames.push(name);
+        }
+        // n_dims (u32)
+        const nDims = readU32();
+        if (nDims > LIMITS.MAX_DIMS) {
+            throw new ModelLoadFailedError(`Tensor dimensions ${nDims} exceeds limit ${LIMITS.MAX_DIMS}`);
+        }
+        // shape: nDims * u64
+        skipBytes(nDims * 8);
+        // dtype (u32)
+        skipBytes(4);
+        // offset (u64)
+        skipBytes(8);
+    }
+    logger.debug(`Parsed ${tensorNames.length} tensor names successfully`);
+    return tensorNames;
+}
+async function extractTensorNamesFromHeader(filePath) {
+    const stream = createReadStream(filePath);
+    const chunks = [];
+    let totalRead = 0;
+    let streamDestroyed = false;
+    function destroyStream() {
+        if (!streamDestroyed) {
+            streamDestroyed = true;
+            stream.destroy();
+        }
+    }
+    try {
+        for await (const chunk of stream) {
+            chunks.push(chunk);
+            totalRead += chunk.length;
+            // Only attempt parsing once we have enough data for the basic header
+            if (totalRead >= 24) {
+                try {
+                    const buffer = Buffer.concat(chunks);
+                    const result = parseGGUFHeader(buffer);
+                    destroyStream();
+                    return result;
+                }
+                catch (error) {
+                    if (error instanceof NeedMoreDataError) {
+                        // Keep reading
+                        if (totalRead >= LIMITS.MAX_HEADER_SIZE) {
+                            throw new ModelLoadFailedError(`GGUF header exceeds ${LIMITS.MAX_HEADER_SIZE / (1024 * 1024 * 1024)}GB limit`);
+                        }
+                        continue;
+                    }
+                    throw error;
+                }
+            }
+        }
+        throw new ModelLoadFailedError("File ended before GGUF header could be parsed");
+    }
+    finally {
+        destroyStream();
+    }
+}
+/**
+ * Extract tensor names from all GGUF shards and write to {baseFilename}.tensors.txt
+ * Required for sharded models to enable incremental/async loading
+ * @throws ModelLoadFailedError if any shard fails extraction
+ */
+export async function extractAndWriteTensorsFile(shardDir, shardFilenames, baseFilename) {
+    const tensorsFilePath = path.join(shardDir, `${baseFilename}.tensors.txt`);
+    try {
+        await fsPromises.access(tensorsFilePath);
+        logger.info(`Tensors file already exists: ${tensorsFilePath}`);
+        return tensorsFilePath;
+    }
+    catch {
+        // Continue with extraction
+    }
+    logger.info(`Extracting tensors from ${shardFilenames.length} shards...`);
+    const allTensorNames = new Set();
+    const failedShards = [];
+    for (const filename of shardFilenames) {
+        const shardPath = path.join(shardDir, filename);
+        try {
+            logger.debug(`Extracting tensors from ${filename}...`);
+            const tensorNames = await extractTensorNamesFromHeader(shardPath);
+            if (tensorNames.length > 0) {
+                tensorNames.forEach((name) => allTensorNames.add(name));
+                logger.info(`Extracted ${tensorNames.length} tensors from ${filename}`);
+            }
+            else {
+                failedShards.push(filename);
+                logger.error(`No tensors found in ${filename}`);
+            }
+        }
+        catch (error) {
+            failedShards.push(filename);
+            logger.error(`Failed to extract tensors from ${filename}:`, error);
+        }
+    }
+    if (failedShards.length > 0) {
+        throw new ModelLoadFailedError(`Failed to extract tensors from ${failedShards.length}/${shardFilenames.length} shards: ${failedShards.join(", ")}`);
+    }
+    if (allTensorNames.size === 0) {
+        throw new ModelLoadFailedError(`Could not extract any tensors from shards.`);
+    }
+    const tensorNames = Array.from(allTensorNames).sort();
+    await fsPromises.writeFile(tensorsFilePath, tensorNames.join("\n") + "\n", "utf8");
+    logger.info(`Tensors file created: ${tensorsFilePath} (${tensorNames.length} tensors from ${shardFilenames.length} shards)`);
+    return tensorsFilePath;
+}
+/**
+ * Check if a file has a valid GGUF header structure.
+ * Returns true if the header parses successfully and contains tensor metadata.
+ *
+ * NOTE: This only validates the header structure, NOT that tensor data exists.
+ * A file can have a valid header but be incomplete.
+ */
+export async function hasValidGGUFHeader(filePath) {
+    try {
+        const tensorNames = await extractTensorNamesFromHeader(filePath);
+        return tensorNames.length > 0;
+    }
+    catch (error) {
+        logger.warn(`⚠️ GGUF header validation failed: ${error instanceof Error ? error.message : String(error)}`);
+        return false;
+    }
+}

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

@@ -1,7 +1,10 @@
+export * from "./archive";
 export * from "./audio/decoder";
 export * from "./cache";
 export * from "./checksum";
-export * from "./hash";
+export * from "./config-transform";
+export * from "./formatting";
+export * from "./gguf-tensor-extractor";
 export * from "./model-path";
 export * from "./shard-utils";
 //# sourceMappingURL=index.d.ts.map

package/dist/server/utils/index.js

@@ -1,6 +1,9 @@
+export * from "./archive.js";
 export * from "./audio/decoder.js";
 export * from "./cache.js";
 export * from "./checksum.js";
-export * from "./hash.js";
+export * from "./config-transform.js";
+export * from "./formatting.js";
+export * from "./gguf-tensor-extractor.js";
 export * from "./model-path.js";
 export * from "./shard-utils.js";

package/dist/server/utils/shard-utils.d.ts

@@ -1,22 +1,48 @@
-export interface ShardInfo {
-    isSharded: boolean;
-    currentShard?: number;
-    totalShards?: number;
-    baseFilename?: string;
-    extension?: string;
-}
-export interface ShardMetadata {
-    filename: string;
-    expectedSize: number;
-    sha256Checksum: string;
-}
+import type { ShardPatternInfo, ShardUrl } from "../../schemas/index";
 /**
  * Detect if model filename follows shard pattern (00001-of-0000x)
  */
-export declare function detectShardedModel(filename: string): ShardInfo;
+export declare function detectShardedModel(filename: string): ShardPatternInfo;
 /**
- * Generate list of all required files for a sharded model
- * Includes numbered shards AND the .tensors.txt companion file
+ * Generate list of shard filenames for a sharded model
+ * Accepts any shard in the group
+ *
+ * @param shardName - Any shard filename in the group (e.g., "model-00002-of-00005.gguf")
+ * @returns Array of all numbered shard filenames
  */
-export declare function generateShardFilenames(firstShardName: string): string[];
+export declare function generateShardFilenames(shardName: string): string[];
+/**
+ * Parse pattern-based shard URL and generate all shard URLs with cache key
+ * Works with patterns like: https://example.com/path/model-00002-of-00005.gguf
+ *
+ * @param shardUrl - Any shard URL in the group
+ * @returns Object with shard URLs array and cache key
+ */
+export declare function parsePatternBasedShardUrl(shardUrl: string): {
+    shardUrls: ShardUrl[];
+    cacheKey: string;
+};
+/**
+ * Extract tensor information from all shards and write to baseFilename.tensors.txt
+ * Required for sharded models to enable incremental/async loading
+ * @param shardDir - Directory containing the shard files
+ * @param shardFilename - Filename of any shard (e.g., "model-00001-of-00002.gguf")
+ * @returns Path to the created tensors.txt file
+ * @throws If not a sharded model or extraction fails
+ */
+export declare function extractTensorsFromShards(shardDir: string, shardFilename: string): Promise<string>;
+/**
+ * Check if all numbered shard files exist
+ * @param shardDir - Directory containing the shard files
+ * @param shardFilename - Filename of any shard (e.g., "model-00001-of-00002.gguf")
+ * @returns true if all numbered shards exist, false otherwise
+ */
+export declare function checkAllShardsExist(shardDir: string, shardFilename: string): Promise<boolean>;
+/**
+ * Validate that all shards and tensors.txt exist for a sharded model
+ * @param shardDir - Directory containing the shard files
+ * @param shardFilename - Filename of any shard (e.g., "model-00001-of-00002.gguf")
+ * @returns true if all shards and tensors.txt exist, false otherwise
+ */
+export declare function validateShardedModelCache(shardDir: string, shardFilename: string): Promise<boolean>;
 //# sourceMappingURL=shard-utils.d.ts.map

package/dist/server/utils/shard-utils.js

@@ -1,4 +1,8 @@
-import { ModelLoadFailedError } from "../../utils/errors-server.js";
+import { ModelLoadFailedError, InvalidShardUrlPatternError, } from "../../utils/errors-server.js";
+import { generateShortHash } from "./formatting.js";
+import { extractAndWriteTensorsFile } from "./gguf-tensor-extractor.js";
+import { promises as fsPromises } from "bare-fs";
+import path from "bare-path";
 /**
  * Detect if model filename follows shard pattern (00001-of-0000x)
  */
@@ -17,13 +21,16 @@ export function detectShardedModel(filename) {
     return { isSharded: false };
 }
 /**
- * Generate list of all required files for a sharded model
- * Includes numbered shards AND the .tensors.txt companion file
+ * Generate list of shard filenames for a sharded model
+ * Accepts any shard in the group
+ *
+ * @param shardName - Any shard filename in the group (e.g., "model-00002-of-00005.gguf")
+ * @returns Array of all numbered shard filenames
  */
-export function generateShardFilenames(firstShardName) {
-    const shardInfo = detectShardedModel(firstShardName);
+export function generateShardFilenames(shardName) {
+    const shardInfo = detectShardedModel(shardName);
     if (!shardInfo.isSharded || !shardInfo.totalShards) {
-        throw new ModelLoadFailedError(`Not a sharded model filename: ${firstShardName}`);
+        throw new ModelLoadFailedError(`Not a sharded model filename: ${shardName}`);
     }
     const filenames = [];
     const { baseFilename, totalShards, extension } = shardInfo;
@@ -32,6 +39,87 @@ export function generateShardFilenames(firstShardName) {
         const totalShardsStr = totalShards.toString().padStart(5, "0");
         filenames.push(`${baseFilename}-${shardNumber}-of-${totalShardsStr}${extension}`);
     }
-    filenames.push(`${baseFilename}.tensors.txt`);
     return filenames;
 }
+/**
+ * Parse pattern-based shard URL and generate all shard URLs with cache key
+ * Works with patterns like: https://example.com/path/model-00002-of-00005.gguf
+ *
+ * @param shardUrl - Any shard URL in the group
+ * @returns Object with shard URLs array and cache key
+ */
+export function parsePatternBasedShardUrl(shardUrl) {
+    const urlParts = shardUrl.split("/");
+    const filename = urlParts[urlParts.length - 1]?.split("?")[0] || "";
+    const shardInfo = detectShardedModel(filename);
+    if (!shardInfo.isSharded || !shardInfo.baseFilename) {
+        throw new InvalidShardUrlPatternError(shardUrl);
+    }
+    const shardFilenames = generateShardFilenames(filename);
+    const baseUrl = urlParts.slice(0, -1).join("/");
+    return {
+        shardUrls: shardFilenames.map((shardFilename) => ({
+            url: `${baseUrl}/${shardFilename}`,
+            filename: shardFilename,
+        })),
+        cacheKey: generateShortHash(`${baseUrl}/${shardInfo.baseFilename}`),
+    };
+}
+/**
+ * Extract tensor information from all shards and write to baseFilename.tensors.txt
+ * Required for sharded models to enable incremental/async loading
+ * @param shardDir - Directory containing the shard files
+ * @param shardFilename - Filename of any shard (e.g., "model-00001-of-00002.gguf")
+ * @returns Path to the created tensors.txt file
+ * @throws If not a sharded model or extraction fails
+ */
+export async function extractTensorsFromShards(shardDir, shardFilename) {
+    const shardInfo = detectShardedModel(shardFilename);
+    if (!shardInfo.isSharded ||
+        !shardInfo.baseFilename ||
+        !shardInfo.totalShards) {
+        throw new ModelLoadFailedError(`Not a sharded model filename: ${shardFilename}`);
+    }
+    const allShardFilenames = generateShardFilenames(shardFilename);
+    return extractAndWriteTensorsFile(shardDir, allShardFilenames, shardInfo.baseFilename);
+}
+/**
+ * Check if all numbered shard files exist
+ * @param shardDir - Directory containing the shard files
+ * @param shardFilename - Filename of any shard (e.g., "model-00001-of-00002.gguf")
+ * @returns true if all numbered shards exist, false otherwise
+ */
+export async function checkAllShardsExist(shardDir, shardFilename) {
+    const shardInfo = detectShardedModel(shardFilename);
+    if (!shardInfo.isSharded) {
+        return false;
+    }
+    const shardFilenames = generateShardFilenames(shardFilename);
+    const allShardsExist = await Promise.all(shardFilenames.map((f) => fsPromises
+        .access(path.join(shardDir, f))
+        .then(() => true)
+        .catch(() => false))).then((results) => results.every((exists) => exists));
+    return allShardsExist;
+}
+/**
+ * Validate that all shards and tensors.txt exist for a sharded model
+ * @param shardDir - Directory containing the shard files
+ * @param shardFilename - Filename of any shard (e.g., "model-00001-of-00002.gguf")
+ * @returns true if all shards and tensors.txt exist, false otherwise
+ */
+export async function validateShardedModelCache(shardDir, shardFilename) {
+    const shardInfo = detectShardedModel(shardFilename);
+    if (!shardInfo.isSharded || !shardInfo.baseFilename) {
+        return false;
+    }
+    const allShardsExist = await checkAllShardsExist(shardDir, shardFilename);
+    if (!allShardsExist) {
+        return false;
+    }
+    const tensorsFile = `${shardInfo.baseFilename}.tensors.txt`;
+    const tensorsExist = await fsPromises
+        .access(path.join(shardDir, tensorsFile))
+        .then(() => true)
+        .catch(() => false);
+    return tensorsExist;
+}