redis-vl 0.1.0-beta.0

package/dist/redis/index-info-parser.js

@@ -0,0 +1,301 @@
+/**
+ * Parser for Redis FT.INFO output to reconstruct IndexSchema
+ */
+import { IndexSchema, IndexInfo, StorageType } from '../schema/index.js';
+import { TextField, TagField, NumericField, GeoField, VectorField, } from '../schema/fields.js';
+import { VectorDistanceMetric, VectorDataType } from '../schema/types.js';
+import { RedisVLError } from '../errors.js';
+// ================================
+// Public API
+// ================================
+/**
+ * Build RedisVL IndexSchema from Redis FT.INFO output
+ *
+ * @param info - The raw output from FT.INFO command
+ * @returns IndexSchema instance reconstructed from Redis index metadata
+ */
+export function buildRedisVLSchemaFromRedisIndexInfo(info) {
+    const indexName = String(info.index_name);
+    const indexDef = asRecord(info.index_definition);
+    const storageType = parseStorageType(indexDef);
+    const isJson = storageType === StorageType.JSON;
+    const prefix = parsePrefix(indexName, indexDef);
+    const stopwords = parseStopwords(info.stopwords_list);
+    // Parse fields
+    const fields = {};
+    for (const rawAttr of info.attributes) {
+        const attr = asRecord(rawAttr);
+        const fieldName = String(attr['identifier']);
+        const fieldType = String(attr['type']);
+        fields[fieldName] = parseField(fieldName, fieldType, attr, isJson);
+    }
+    // Create IndexInfo instance
+    const indexInfo = new IndexInfo({
+        name: indexName,
+        prefix,
+        storageType,
+        // Redis FT.INFO does not expose the key separator used by the application.
+        // Default to ':' (library default).
+        keySeparator: ':',
+        ...(stopwords !== undefined && { stopwords }),
+    });
+    return new IndexSchema({ index: indexInfo, fields });
+}
+// ================================
+// Index-level parsing
+// ================================
+function parseStorageType(indexDef) {
+    const keyType = String(indexDef['key_type']).toLowerCase();
+    return keyType === 'json' ? StorageType.JSON : StorageType.HASH;
+}
+function parsePrefix(indexName, indexDef) {
+    const prefixesValue = indexDef['prefixes'];
+    if (typeof prefixesValue === 'string') {
+        return prefixesValue;
+    }
+    if (Array.isArray(prefixesValue) &&
+        prefixesValue.length > 0 &&
+        prefixesValue.every((p) => typeof p === 'string')) {
+        // Preserve all prefixes when more than one is configured so the schema
+        // round-trips through fromExisting() without silently dropping data.
+        return prefixesValue.length === 1 ? prefixesValue[0] : [...prefixesValue];
+    }
+    throw new RedisVLError(`RedisIndexParseError: Invalid index definition for '${indexName}': missing or invalid 'prefixes' value.`);
+}
+function parseStopwords(value) {
+    if (Array.isArray(value) && value.every((v) => typeof v === 'string')) {
+        return [...value];
+    }
+    return undefined;
+}
+function parseField(fieldName, fieldType, attr, isJson) {
+    const parser = FIELD_PARSERS[fieldType];
+    if (!parser) {
+        throw new RedisVLError(`RedisIndexParseError: Unsupported field type '${fieldType}' for field '${fieldName}' while rebuilding schema from index info.`);
+    }
+    return parser(fieldName, attr, isJson);
+}
+// ================================
+// Common decoding helpers
+// ================================
+function asRecord(value) {
+    if (value === null || value === undefined || typeof value !== 'object') {
+        throw new RedisVLError('RedisIndexParseError: Invalid FT.INFO reply structure: expected an object.');
+    }
+    return value;
+}
+function readString(attr, ...keys) {
+    for (const key of keys) {
+        const value = attr[key];
+        if (typeof value === 'string') {
+            return value;
+        }
+    }
+    return undefined;
+}
+function readNumber(attr, ...keys) {
+    for (const key of keys) {
+        const value = attr[key];
+        if (typeof value === 'number') {
+            return value;
+        }
+        if (typeof value === 'string' && value.trim() !== '') {
+            const parsed = Number(value);
+            if (!Number.isNaN(parsed)) {
+                return parsed;
+            }
+        }
+    }
+    return undefined;
+}
+function readFlag(attr, ...keys) {
+    for (const key of keys) {
+        if (!(key in attr)) {
+            continue;
+        }
+        const value = attr[key];
+        if (value === true) {
+            return true;
+        }
+        if (typeof value === 'string') {
+            // Some replies use empty string to indicate a present flag
+            return value === '' || value.toLowerCase() === 'true' || value === '1';
+        }
+        if (typeof value === 'number') {
+            return value === 1;
+        }
+        // If the key exists and the value isn't a recognized boolean, treat presence as true
+        return true;
+    }
+    return false;
+}
+function normalizeJsonPath(path) {
+    if (path.startsWith('$.')) {
+        return path;
+    }
+    if (path.startsWith('$')) {
+        return `$.${path.slice(1)}`;
+    }
+    return `$.${path}`;
+}
+function parseBaseFieldAttrs(attr, isJson, asName) {
+    const attrs = {
+        sortable: readFlag(attr, 'SORTABLE', 'sortable'),
+        indexMissing: readFlag(attr, 'INDEXMISSING', 'index_missing', 'indexMissing'),
+        indexEmpty: readFlag(attr, 'INDEXEMPTY', 'index_empty', 'indexEmpty'),
+    };
+    // Only include `as` for JSON storage.
+    if (isJson) {
+        attrs.as = asName;
+    }
+    return attrs;
+}
+function applyJsonPath(field, attr, isJson) {
+    if (!isJson) {
+        return;
+    }
+    const rawPath = readString(attr, 'attribute', 'ATTRIBUTE');
+    if (!rawPath) {
+        return;
+    }
+    field.path = normalizeJsonPath(rawPath);
+}
+class TextFieldParser {
+    static parse(fieldName, attr, isJson) {
+        const baseAttrs = parseBaseFieldAttrs(attr, isJson, fieldName);
+        const textAttrs = {
+            ...baseAttrs,
+            weight: readNumber(attr, 'WEIGHT', 'weight'),
+            noStem: readFlag(attr, 'NOSTEM', 'no_stem', 'noStem'),
+            phonetic: readString(attr, 'PHONETIC', 'phonetic'),
+            withSuffixTrie: readFlag(attr, 'WITHSUFFIXTRIE', 'with_suffix_trie', 'withSuffixTrie'),
+        };
+        const field = new TextField(fieldName, textAttrs);
+        applyJsonPath(field, attr, isJson);
+        return field;
+    }
+}
+class TagFieldParser {
+    static parse(fieldName, attr, isJson) {
+        const baseAttrs = parseBaseFieldAttrs(attr, isJson, fieldName);
+        const tagAttrs = {
+            ...baseAttrs,
+            separator: readString(attr, 'SEPARATOR', 'separator'),
+            caseSensitive: readFlag(attr, 'CASESENSITIVE', 'case_sensitive', 'caseSensitive'),
+        };
+        const field = new TagField(fieldName, tagAttrs);
+        applyJsonPath(field, attr, isJson);
+        return field;
+    }
+}
+class NumericFieldParser {
+    static parse(fieldName, attr, isJson) {
+        const baseAttrs = parseBaseFieldAttrs(attr, isJson, fieldName);
+        const field = new NumericField(fieldName, baseAttrs);
+        applyJsonPath(field, attr, isJson);
+        return field;
+    }
+}
+class GeoFieldParser {
+    static parse(fieldName, attr, isJson) {
+        const baseAttrs = parseBaseFieldAttrs(attr, isJson, fieldName);
+        const field = new GeoField(fieldName, baseAttrs);
+        applyJsonPath(field, attr, isJson);
+        return field;
+    }
+}
+class VectorFieldParser {
+    static parse(fieldName, attr, isJson) {
+        const dims = readNumber(attr, 'dim', 'DIM', 'dims', 'DIMS');
+        const algorithmRaw = readString(attr, 'algorithm', 'ALGORITHM');
+        const distanceMetricRaw = readString(attr, 'distance_metric', 'DISTANCE_METRIC');
+        const dataTypeRaw = readString(attr, 'data_type', 'DATA_TYPE', 'TYPE');
+        if (dims === undefined || !Number.isFinite(dims) || dims <= 0 || !Number.isInteger(dims)) {
+            throw new RedisVLError(`RedisIndexParseError: Vector field '${fieldName}' is missing or has invalid dimension (DIM).`);
+        }
+        if (!algorithmRaw) {
+            throw new RedisVLError(`RedisIndexParseError: Vector field '${fieldName}' is missing required 'algorithm' attribute`);
+        }
+        if (!distanceMetricRaw) {
+            throw new RedisVLError(`RedisIndexParseError: Vector field '${fieldName}' is missing required 'distance_metric' attribute`);
+        }
+        if (!dataTypeRaw) {
+            throw new RedisVLError(`RedisIndexParseError: Vector field '${fieldName}' is missing required 'data_type' attribute`);
+        }
+        const algorithm = VectorFieldParser.parseVectorAlgorithm(fieldName, algorithmRaw);
+        const distanceMetric = VectorFieldParser.parseVectorDistanceMetric(fieldName, distanceMetricRaw);
+        const datatype = VectorFieldParser.parseVectorDataType(fieldName, dataTypeRaw);
+        const baseAttrs = parseBaseFieldAttrs(attr, isJson, fieldName);
+        const options = {
+            ...baseAttrs,
+            algorithm,
+            dims,
+            distanceMetric,
+            datatype,
+        };
+        // Parse algorithm-specific parameters
+        if (algorithm === 'hnsw') {
+            const m = readNumber(attr, 'm', 'M');
+            const efConstruction = readNumber(attr, 'ef_construction', 'EF_CONSTRUCTION', 'efConstruction');
+            const efRuntime = readNumber(attr, 'ef_runtime', 'EF_RUNTIME', 'efRuntime');
+            const epsilon = readNumber(attr, 'epsilon', 'EPSILON');
+            if (m !== undefined) {
+                options.m = Math.trunc(m);
+            }
+            if (efConstruction !== undefined) {
+                options.efConstruction = Math.trunc(efConstruction);
+            }
+            if (efRuntime !== undefined) {
+                options.efRuntime = Math.trunc(efRuntime);
+            }
+            if (epsilon !== undefined) {
+                options.epsilon = epsilon;
+            }
+        }
+        if (algorithm === 'flat') {
+            const blockSize = readNumber(attr, 'block_size', 'BLOCK_SIZE', 'blockSize');
+            const initialCap = readNumber(attr, 'initial_cap', 'INITIAL_CAP', 'initialCap');
+            if (blockSize !== undefined) {
+                options.blockSize = Math.trunc(blockSize);
+            }
+            if (initialCap !== undefined) {
+                options.initialCap = Math.trunc(initialCap);
+            }
+        }
+        const field = new VectorField(fieldName, options);
+        applyJsonPath(field, attr, isJson);
+        return field;
+    }
+    static parseVectorAlgorithm(fieldName, algorithmRaw) {
+        const algorithmKey = algorithmRaw.toUpperCase();
+        if (algorithmKey === 'FLAT') {
+            return 'flat';
+        }
+        if (algorithmKey === 'HNSW') {
+            return 'hnsw';
+        }
+        throw new RedisVLError(`RedisIndexParseError: Vector field '${fieldName}' uses unsupported algorithm '${algorithmRaw}'.`);
+    }
+    static parseVectorDistanceMetric(fieldName, metricRaw) {
+        const metricKey = metricRaw.toUpperCase();
+        if (!Object.values(VectorDistanceMetric).includes(metricKey)) {
+            throw new RedisVLError(`RedisIndexParseError: Vector field '${fieldName}' has unsupported distance metric '${metricRaw}'.`);
+        }
+        return metricKey;
+    }
+    static parseVectorDataType(fieldName, typeRaw) {
+        const typeKey = typeRaw.toUpperCase();
+        if (!Object.values(VectorDataType).includes(typeKey)) {
+            throw new RedisVLError(`RedisIndexParseError: Vector field '${fieldName}' has unsupported data type '${typeRaw}'.`);
+        }
+        return typeKey;
+    }
+}
+const FIELD_PARSERS = {
+    TEXT: TextFieldParser.parse,
+    TAG: TagFieldParser.parse,
+    NUMERIC: NumericFieldParser.parse,
+    GEO: GeoFieldParser.parse,
+    VECTOR: VectorFieldParser.parse,
+};
+//# sourceMappingURL=index-info-parser.js.map

package/dist/redis/index-info-parser.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index-info-parser.js","sourceRoot":"","sources":["../../src/redis/index-info-parser.ts"],"names":[],"mappings":"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"}

package/dist/redis/schema-types.d.ts

@@ -0,0 +1,81 @@
+/**
+ * Redis Search Schema Field Type Definitions
+ *
+ * These types are extracted from the RediSearchSchema interface exported by @redis/search.
+ * While @redis/search doesn't export the individual field type interfaces (SchemaTextField, etc.),
+ * we can extract them using TypeScript utility types from the RediSearchSchema union.
+ *
+ * Source: @redis/search/dist/lib/commands/CREATE.d.ts
+ *
+ * This approach is more maintainable than duplicating the type definitions because:
+ * 1. Types automatically stay in sync with @redis/search updates
+ * 2. No risk of type definition drift
+ * 3. Leverages TypeScript's type system for extraction
+ *
+ * @see https://github.com/redis/node-redis/tree/master/packages/search
+ */
+import type { RediSearchSchema } from '@redis/search';
+/**
+ * Extract the union of all schema field types from RediSearchSchema
+ */
+type ExtractSchemaTypes = RediSearchSchema[string];
+/**
+ * Text field schema - extracted from RediSearchSchema
+ */
+export type SchemaTextField = Extract<ExtractSchemaTypes, {
+    type: 'TEXT';
+}>;
+/**
+ * Extract the PHONETIC type from SchemaTextField
+ */
+export type SchemaTextFieldPhonetic = NonNullable<SchemaTextField['PHONETIC']>;
+/**
+ * Numeric field schema - extracted from RediSearchSchema
+ */
+export type SchemaNumericField = Extract<ExtractSchemaTypes, {
+    type: 'NUMERIC';
+}>;
+/**
+ * Geo field schema - extracted from RediSearchSchema
+ */
+export type SchemaGeoField = Extract<ExtractSchemaTypes, {
+    type: 'GEO';
+}>;
+/**
+ * Tag field schema - extracted from RediSearchSchema
+ */
+export type SchemaTagField = Extract<ExtractSchemaTypes, {
+    type: 'TAG';
+}>;
+/**
+ * Vector field schema (base) - extracted from RediSearchSchema
+ */
+type SchemaVectorField = Extract<ExtractSchemaTypes, {
+    type: 'VECTOR';
+}>;
+/**
+ * FLAT vector field schema - extracted from RediSearchSchema
+ */
+export type SchemaFlatVectorField = Extract<SchemaVectorField, {
+    ALGORITHM: 'FLAT';
+}>;
+/**
+ * HNSW vector field schema - extracted from RediSearchSchema
+ */
+export type SchemaHNSWVectorField = Extract<SchemaVectorField, {
+    ALGORITHM: 'HNSW';
+}>;
+/**
+ * Extract the TYPE union from SchemaVectorField
+ */
+export type SchemaVectorFieldType = SchemaVectorField['TYPE'];
+/**
+ * Extract the DISTANCE_METRIC union from SchemaVectorField
+ */
+export type SchemaVectorFieldDistanceMetric = SchemaVectorField['DISTANCE_METRIC'];
+/**
+ * Union type of all Redis schema field types we support
+ */
+export type RedisSchemaFieldType = SchemaTextField | SchemaNumericField | SchemaGeoField | SchemaTagField | SchemaFlatVectorField | SchemaHNSWVectorField;
+export {};
+//# sourceMappingURL=schema-types.d.ts.map

package/dist/redis/schema-types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"schema-types.d.ts","sourceRoot":"","sources":["../../src/redis/schema-types.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;GAeG;AAEH,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,eAAe,CAAC;AAEtD;;GAEG;AACH,KAAK,kBAAkB,GAAG,gBAAgB,CAAC,MAAM,CAAC,CAAC;AAEnD;;GAEG;AACH,MAAM,MAAM,eAAe,GAAG,OAAO,CAAC,kBAAkB,EAAE;IAAE,IAAI,EAAE,MAAM,CAAA;CAAE,CAAC,CAAC;AAE5E;;GAEG;AACH,MAAM,MAAM,uBAAuB,GAAG,WAAW,CAAC,eAAe,CAAC,UAAU,CAAC,CAAC,CAAC;AAE/E;;GAEG;AACH,MAAM,MAAM,kBAAkB,GAAG,OAAO,CAAC,kBAAkB,EAAE;IAAE,IAAI,EAAE,SAAS,CAAA;CAAE,CAAC,CAAC;AAElF;;GAEG;AACH,MAAM,MAAM,cAAc,GAAG,OAAO,CAAC,kBAAkB,EAAE;IAAE,IAAI,EAAE,KAAK,CAAA;CAAE,CAAC,CAAC;AAE1E;;GAEG;AACH,MAAM,MAAM,cAAc,GAAG,OAAO,CAAC,kBAAkB,EAAE;IAAE,IAAI,EAAE,KAAK,CAAA;CAAE,CAAC,CAAC;AAE1E;;GAEG;AACH,KAAK,iBAAiB,GAAG,OAAO,CAAC,kBAAkB,EAAE;IAAE,IAAI,EAAE,QAAQ,CAAA;CAAE,CAAC,CAAC;AAEzE;;GAEG;AACH,MAAM,MAAM,qBAAqB,GAAG,OAAO,CAAC,iBAAiB,EAAE;IAAE,SAAS,EAAE,MAAM,CAAA;CAAE,CAAC,CAAC;AAEtF;;GAEG;AACH,MAAM,MAAM,qBAAqB,GAAG,OAAO,CAAC,iBAAiB,EAAE;IAAE,SAAS,EAAE,MAAM,CAAA;CAAE,CAAC,CAAC;AAEtF;;GAEG;AACH,MAAM,MAAM,qBAAqB,GAAG,iBAAiB,CAAC,MAAM,CAAC,CAAC;AAE9D;;GAEG;AACH,MAAM,MAAM,+BAA+B,GAAG,iBAAiB,CAAC,iBAAiB,CAAC,CAAC;AAEnF;;GAEG;AACH,MAAM,MAAM,oBAAoB,GAC1B,eAAe,GACf,kBAAkB,GAClB,cAAc,GACd,cAAc,GACd,qBAAqB,GACrB,qBAAqB,CAAC"}

package/dist/redis/schema-types.js

@@ -0,0 +1,18 @@
+/**
+ * Redis Search Schema Field Type Definitions
+ *
+ * These types are extracted from the RediSearchSchema interface exported by @redis/search.
+ * While @redis/search doesn't export the individual field type interfaces (SchemaTextField, etc.),
+ * we can extract them using TypeScript utility types from the RediSearchSchema union.
+ *
+ * Source: @redis/search/dist/lib/commands/CREATE.d.ts
+ *
+ * This approach is more maintainable than duplicating the type definitions because:
+ * 1. Types automatically stay in sync with @redis/search updates
+ * 2. No risk of type definition drift
+ * 3. Leverages TypeScript's type system for extraction
+ *
+ * @see https://github.com/redis/node-redis/tree/master/packages/search
+ */
+export {};
+//# sourceMappingURL=schema-types.js.map

package/dist/redis/schema-types.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"schema-types.js","sourceRoot":"","sources":["../../src/redis/schema-types.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;GAeG"}

package/dist/redis/utils.d.ts

@@ -0,0 +1,7 @@
+import { VectorDataType } from '../schema/types.js';
+export type VectorDataTypeInput = VectorDataType | string | undefined;
+export declare function normalizeVectorDataType(datatype: VectorDataTypeInput): VectorDataType;
+export declare function vectorElementByteLength(datatype: VectorDataTypeInput): number;
+export declare function encodeVectorBuffer(vector: readonly unknown[], datatype?: VectorDataTypeInput): Buffer;
+export declare function decodeVectorBuffer(buffer: Buffer, datatype?: VectorDataTypeInput): number[];
+//# sourceMappingURL=utils.d.ts.map

package/dist/redis/utils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"utils.d.ts","sourceRoot":"","sources":["../../src/redis/utils.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,cAAc,EAAE,MAAM,oBAAoB,CAAC;AAEpD,MAAM,MAAM,mBAAmB,GAAG,cAAc,GAAG,MAAM,GAAG,SAAS,CAAC;AAItE,wBAAgB,uBAAuB,CAAC,QAAQ,EAAE,mBAAmB,GAAG,cAAc,CAYrF;AAED,wBAAgB,uBAAuB,CAAC,QAAQ,EAAE,mBAAmB,GAAG,MAAM,CAa7E;AAED,wBAAgB,kBAAkB,CAC9B,MAAM,EAAE,SAAS,OAAO,EAAE,EAC1B,QAAQ,GAAE,mBAA4C,GACvD,MAAM,CAmBR;AAED,wBAAgB,kBAAkB,CAC9B,MAAM,EAAE,MAAM,EACd,QAAQ,GAAE,mBAA4C,GACvD,MAAM,EAAE,CAwBV"}

package/dist/redis/utils.js

@@ -0,0 +1,221 @@
+import { SchemaValidationError } from '../errors.js';
+import { VectorDataType } from '../schema/types.js';
+const VALID_VECTOR_DATA_TYPES = new Set(Object.values(VectorDataType));
+export function normalizeVectorDataType(datatype) {
+    const normalized = String(datatype ?? VectorDataType.FLOAT32).toUpperCase();
+    if (!VALID_VECTOR_DATA_TYPES.has(normalized)) {
+        throw new SchemaValidationError(`Invalid vector datatype: ${datatype}. Supported datatypes are: ${Object.values(VectorDataType).join(', ')}`);
+    }
+    return normalized;
+}
+export function vectorElementByteLength(datatype) {
+    switch (normalizeVectorDataType(datatype)) {
+        case VectorDataType.FLOAT64:
+            return 8;
+        case VectorDataType.FLOAT16:
+        case VectorDataType.BFLOAT16:
+            return 2;
+        case VectorDataType.INT8:
+        case VectorDataType.UINT8:
+            return 1;
+        case VectorDataType.FLOAT32:
+            return 4;
+    }
+}
+export function encodeVectorBuffer(vector, datatype = VectorDataType.FLOAT32) {
+    switch (normalizeVectorDataType(datatype)) {
+        case VectorDataType.FLOAT64:
+            return Buffer.from(new Float64Array(validateVectorValues(vector)).buffer);
+        case VectorDataType.FLOAT16:
+            return encodeFloat16Buffer(validateVectorValues(vector));
+        case VectorDataType.BFLOAT16:
+            return encodeBFloat16Buffer(validateVectorValues(vector));
+        case VectorDataType.INT8:
+            return Buffer.from(Int8Array.from(validateIntegerVector(vector, -128, 127, VectorDataType.INT8)).buffer);
+        case VectorDataType.UINT8:
+            return Buffer.from(Uint8Array.from(validateIntegerVector(vector, 0, 255, VectorDataType.UINT8)).buffer);
+        case VectorDataType.FLOAT32:
+            return Buffer.from(new Float32Array(validateVectorValues(vector)).buffer);
+    }
+}
+export function decodeVectorBuffer(buffer, datatype = VectorDataType.FLOAT32) {
+    const normalizedDatatype = normalizeVectorDataType(datatype);
+    const elementSize = vectorElementByteLength(normalizedDatatype);
+    if (buffer.byteLength % elementSize !== 0) {
+        throw new SchemaValidationError(`Vector buffer byte length (${buffer.byteLength}) is not a multiple of the ${normalizedDatatype} element size (${elementSize} bytes)`);
+    }
+    switch (normalizedDatatype) {
+        case VectorDataType.FLOAT64:
+            return decodeFloat64Buffer(buffer);
+        case VectorDataType.FLOAT16:
+            return decodeFloat16Buffer(buffer);
+        case VectorDataType.BFLOAT16:
+            return decodeBFloat16Buffer(buffer);
+        case VectorDataType.INT8:
+            return Array.from(new Int8Array(buffer.buffer, buffer.byteOffset, buffer.byteLength));
+        case VectorDataType.UINT8:
+            return Array.from(new Uint8Array(buffer.buffer, buffer.byteOffset, buffer.byteLength));
+        case VectorDataType.FLOAT32:
+            return decodeFloat32Buffer(buffer);
+    }
+}
+function validateVectorValues(vector) {
+    return vector.map((value, index) => {
+        assertFiniteNumber(value, index);
+        return value;
+    });
+}
+function validateIntegerVector(vector, min, max, datatype) {
+    return vector.map((value, index) => {
+        assertFiniteNumber(value, index);
+        const numericValue = value;
+        if (!Number.isInteger(numericValue) || numericValue < min || numericValue > max) {
+            throw new SchemaValidationError(`Vector value at index ${index} (${numericValue}) is outside the ${datatype} range (${min} to ${max})`);
+        }
+        return numericValue;
+    });
+}
+function assertFiniteNumber(value, index) {
+    if (typeof value !== 'number' || Number.isNaN(value)) {
+        const reported = Number.isNaN(value) ? 'NaN' : typeof value;
+        throw new SchemaValidationError(`Vector contains non-numeric value at index ${index}: ${reported}`);
+    }
+}
+function decodeFloat32Buffer(buffer) {
+    const values = [];
+    for (let offset = 0; offset + 4 <= buffer.byteLength; offset += 4) {
+        values.push(buffer.readFloatLE(offset));
+    }
+    return values;
+}
+function decodeFloat64Buffer(buffer) {
+    const values = [];
+    for (let offset = 0; offset + 8 <= buffer.byteLength; offset += 8) {
+        values.push(buffer.readDoubleLE(offset));
+    }
+    return values;
+}
+// Float16 (IEEE 754 binary16) encode/decode implemented manually on top of
+// DataView. The standard `Float16Array` and `DataView#getFloat16` both
+// landed in V8 13.0 — Node 23+ — so we can't rely on them while we support
+// Node 22 LTS. The BFloat16 path uses the same DataView-based approach.
+function encodeFloat16Buffer(values) {
+    const buffer = Buffer.alloc(values.length * 2);
+    for (let i = 0; i < values.length; i++) {
+        buffer.writeUInt16LE(encodeFloat16(values[i]), i * 2);
+    }
+    return buffer;
+}
+function decodeFloat16Buffer(buffer) {
+    const values = [];
+    for (let offset = 0; offset + 2 <= buffer.byteLength; offset += 2) {
+        values.push(decodeFloat16(buffer.readUInt16LE(offset)));
+    }
+    return values;
+}
+// Float16 layout: 1 sign | 5 exponent (bias 15) | 10 mantissa.
+// Bridges through float32's bit pattern to preserve IEEE 754 semantics,
+// then rounds to nearest with ties-to-even — matching `Float16Array` so a
+// round-trip through this code produces identical bits on Node 22 vs 24+.
+function encodeFloat16(value) {
+    const dataView = new DataView(new ArrayBuffer(4));
+    dataView.setFloat32(0, value);
+    const x = dataView.getUint32(0);
+    const sign = (x >>> 16) & 0x8000;
+    const exp32 = (x >>> 23) & 0xff;
+    const mant32 = x & 0x7fffff;
+    // NaN / Infinity (exp32 all-ones)
+    if (exp32 === 0xff) {
+        if (mant32 !== 0) {
+            // NaN — keep at least one mantissa bit set so it stays a NaN.
+            return sign | 0x7c00 | (mant32 >>> 13) | 0x200;
+        }
+        return sign | 0x7c00; // signed Infinity
+    }
+    const unbiased = exp32 - 127;
+    // Overflow → signed Infinity.
+    if (unbiased >= 16)
+        return sign | 0x7c00;
+    // Underflow past the smallest subnormal → signed zero.
+    if (unbiased < -24)
+        return sign;
+    // Subnormal range: unbiased in [-24, -15].
+    if (unbiased < -14) {
+        const fullMant = mant32 | 0x800000; // restore the implicit leading 1
+        const shiftBy = -1 - unbiased; // 14..23
+        const half = 1 << (shiftBy - 1);
+        const low = fullMant & ((1 << shiftBy) - 1);
+        let mant16 = fullMant >>> shiftBy;
+        if (low > half || (low === half && (mant16 & 1) !== 0)) {
+            mant16++;
+            // Subnormal mantissa rolled into the smallest normal value.
+            if (mant16 === 0x400)
+                return sign | 0x0400;
+        }
+        return sign | mant16;
+    }
+    // Normal range: unbiased in [-14, 15].
+    const exp16 = unbiased + 15;
+    const halfBit = 1 << 12;
+    const low = mant32 & 0x1fff;
+    let mant16 = mant32 >>> 13;
+    if (low > halfBit || (low === halfBit && (mant16 & 1) !== 0)) {
+        mant16++;
+        if (mant16 === 0x400) {
+            // Mantissa rolled over — bump the exponent and possibly overflow to Inf.
+            const newExp = exp16 + 1;
+            if (newExp >= 31)
+                return sign | 0x7c00;
+            return sign | (newExp << 10);
+        }
+    }
+    return sign | (exp16 << 10) | mant16;
+}
+function decodeFloat16(bits) {
+    const sign = (bits >>> 15) & 1;
+    const exp = (bits >>> 10) & 0x1f;
+    const mantissa = bits & 0x3ff;
+    let abs;
+    if (exp === 0x1f) {
+        // NaN or Infinity
+        abs = mantissa === 0 ? Infinity : NaN;
+    }
+    else if (exp === 0) {
+        // Zero or subnormal: value = mantissa × 2^-24
+        abs = mantissa === 0 ? 0 : mantissa * Math.pow(2, -24);
+    }
+    else {
+        // Normal: value = (1 + mantissa/2^10) × 2^(exp - 15)
+        //              = (1024 + mantissa) × 2^(exp - 25)
+        abs = (1024 + mantissa) * Math.pow(2, exp - 25);
+    }
+    return sign ? -abs : abs;
+}
+function encodeBFloat16Buffer(values) {
+    const buffer = Buffer.alloc(values.length * 2);
+    values.forEach((value, index) => {
+        buffer.writeUInt16LE(encodeBFloat16(value), index * 2);
+    });
+    return buffer;
+}
+function decodeBFloat16Buffer(buffer) {
+    const values = [];
+    for (let offset = 0; offset + 2 <= buffer.byteLength; offset += 2) {
+        values.push(decodeBFloat16(buffer.readUInt16LE(offset)));
+    }
+    return values;
+}
+// Round-half-to-even; matches numpy (ml_dtypes.bfloat16) at exact boundaries.
+function encodeBFloat16(value) {
+    const dataView = new DataView(new ArrayBuffer(4));
+    dataView.setFloat32(0, value, false);
+    const bits = dataView.getUint32(0, false);
+    const leastSignificantBit = (bits >> 16) & 1;
+    return (bits + 0x7fff + leastSignificantBit) >>> 16;
+}
+function decodeBFloat16(bits) {
+    const dataView = new DataView(new ArrayBuffer(4));
+    dataView.setUint32(0, bits << 16, false);
+    return dataView.getFloat32(0, false);
+}
+//# sourceMappingURL=utils.js.map