if (a.length !== b.length) {

throw new Error(`vector length mismatch: ${a.length} vs ${b.length}`)

}

let sum = 0

for (let i = 0; i < a.length; i += 1) {

sum += a[i] * b[i]

}

return sum

if (a.length !== b.length) {

throw new Error(`vector length mismatch: ${a.length} vs ${b.length}`)

}

let dot = 0

let normA = 0

let normB = 0

for (let i = 0; i < a.length; i += 1) {

const av = a[i]

const bv = b[i]

dot += av * bv

normA += av * av

normB += bv * bv

}

const denom = Math.sqrt(normA) * Math.sqrt(normB)

if (denom === 0) return 0

return dot / denom

if (a.length !== b.length) {

throw new Error(`vector length mismatch: ${a.length} vs ${b.length}`)

}

let sum = 0

for (let i = 0; i < a.length; i += 1) {

const d = a[i] - b[i]

sum += d * d

}

return Math.sqrt(sum)

let norm = 0

for (let i = 0; i < v.length; i += 1) {

norm += v[i] * v[i]

}

norm = Math.sqrt(norm)

const out = new Float32Array(v.length)

if (norm === 0) return out

for (let i = 0; i < v.length; i += 1) {

out[i] = v[i] / norm

}

return out

const bytes = new Uint8Array(dim + 7 >> 3)

for (let i = 0; i < dim; i += 1) {

if (v[i] >= 0) bytes[i >> 3] |= 1 << (i & 7)

}

return bytes

if (!codes.length) return 0

const stride = Math.max(1, Math.ceil(codes.length / sampleCap))

const ones = new Uint32Array(dimension)

let sampled = 0

for (let row = 0; row < codes.length; row += stride) {

const code = codes[row]

for (let i = 0; i < dimension; i += 1) {

if (code[i >> 3] >> (i & 7) & 1) ones[i] += 1

}

sampled += 1

}

let expected = 0

for (let i = 0; i < dimension; i += 1) {

const p = ones[i] / sampled

expected += 2 * p * (1 - p)

}

return expected

const out = new Float32Array(bytes.byteLength / 4)

const view = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength)

for (let i = 0; i < out.length; i += 1) {

out[i] = view.getFloat32(i * 4, true)

}

return out

/** @type {Record<string, string>} */

const kv = {}

for (const entry of metadata.key_value_metadata ?? []) {

if (entry.value !== undefined) kv[entry.key] = entry.value

}

const version = parseInt(kv['hypvector.version'] ?? '0', 10)

const dimension = parseInt(kv['hypvector.dimension'] ?? '0', 10)

const metric = /** @type {DistanceMetric} */ (kv['hypvector.metric'] ?? 'cosine')

const normalized = kv['hypvector.normalized'] === 'true'

const hasBinary = kv['hypvector.binary'] === 'true'

const count = Number(metadata.num_rows)

const clusters = parseInt(kv['hypvector.clusters'] ?? '0', 10)

if (!dimension) {

throw new Error('Not a hypvector parquet file: missing hypvector.dimension metadata')

}

/** @type {HypVectorMetadata} */

const out = { version, dimension, metric, normalized, hasBinary, count, clusters }

if (clusters > 0 && kv['hypvector.centroids']) {

const binaryBytes = dimension + 7 >> 3

const bytes = decodeBase64(kv['hypvector.centroids'])

if (bytes.byteLength !== clusters * binaryBytes) {

throw new Error(`centroids length mismatch: ${bytes.byteLength} vs ${clusters * binaryBytes}`)

}

out.centroids = []

for (let c = 0; c < clusters; c += 1) {

out.centroids.push(bytes.slice(c * binaryBytes, (c + 1) * binaryBytes))

}

}

if (clusters > 0 && kv['hypvector.clusterCounts']) {

const bytes = decodeBase64(kv['hypvector.clusterCounts'])

// The encoded buffer may not be 4-byte-aligned; copy to ensure alignment.

const aligned = new Uint8Array(bytes.byteLength)

aligned.set(bytes)

out.clusterCounts = new Uint32Array(aligned.buffer, 0, clusters)

}

return out

if (typeof Buffer !== 'undefined') return new Uint8Array(Buffer.from(s, 'base64'))

const bin = atob(s)

const out = new Uint8Array(bin.length)

for (let i = 0; i < bin.length; i += 1) out[i] = bin.charCodeAt(i)

return out

if (typeof Buffer !== 'undefined') return Buffer.from(bytes).toString('base64')

let s = ''

for (let i = 0; i < bytes.length; i += 1) s += String.fromCharCode(bytes[i])

return btoa(s)