sliftutils 1.4.80 → 1.4.82

package/index.d.ts

@@ -963,8 +963,11 @@ declare module "sliftutils/storage/BulkDatabase2/BulkDatabaseBase" {
         private storageFactory;
         private config;
         constructor(name: string, deps: ReactiveDeps, storageFactory: StorageFactory, config?: BulkDatabase2Config);
+        private _reader;
+        private get reader();
+        private activated;
+        private activate;
         private setupVisibilityMergeCheck;
-        private reader;
         private subCaches;
         private pendingAppends;
         private flushTimer;
@@ -2258,6 +2261,11 @@ declare module "sliftutils/storage/backblaze" {
 
 }
 
+declare module "sliftutils/storage/embeddingBench" {
+    export {};
+
+}
+
 declare module "sliftutils/storage/embeddingFormats" {
     export type EmbeddingFormat = "q8g8_2048" | "q8_g16_2048" | "q8_g16_1024" | "float32";
     export declare const EMBEDDING_FORMATS: EmbeddingFormat[];
@@ -2275,6 +2283,10 @@ declare module "sliftutils/storage/embeddingFormats" {
         data: Uint8Array;
         scales: Uint8Array;
     };
+    export declare function embeddingLength(input: Float32Array | StoredEmbedding): number;
+    export declare function releaseFloat32(buffer: Float32Array): void;
+    export declare function embeddingToFloat32(input: Float32Array | StoredEmbedding, usePool?: boolean): Float32Array;
+    export declare const getCloseness: (a: Float32Array | StoredEmbedding, b: Float32Array | StoredEmbedding) => number;
     export declare function encodeEmbedding(config: {
         input: Float32Array | StoredEmbedding;
         format: EmbeddingFormat;
@@ -2282,7 +2294,21 @@ declare module "sliftutils/storage/embeddingFormats" {
     }): StoredEmbedding;
     export declare function serializeStoredEmbedding(stored: StoredEmbedding): string;
     export declare function deserializeStoredEmbedding(base64: string): StoredEmbedding;
-    export declare const getCloseness: (embedding1: Float32Array | StoredEmbedding, embedding2: Float32Array | StoredEmbedding) => number;
+    export declare function averageEmbeddings(embeddings: StoredEmbedding[], config: {
+        format: EmbeddingFormat;
+        model: string;
+    }): StoredEmbedding;
+    export declare function hashEmbedding(stored: StoredEmbedding): string;
+
+}
+
+declare module "sliftutils/storage/faceFramesData" {
+    export declare function ensureFaceData(fileName: string, byteLength: number): Promise<string>;
+
+}
+
+declare module "sliftutils/storage/faceFramesServer" {
+    export {};
 
 }
 
@@ -2311,16 +2337,82 @@ declare module "sliftutils/storage/proxydatabase/Database" {
 
 }
 
+declare module "sliftutils/storage/proxydatabase/inMemoryDatabase" {
+    import { Database } from "./Database";
+    export declare class InMemoryDatabase<Root> implements Database<Root> {
+        readCalls: number;
+        writeCalls: number;
+        deleteCalls: number;
+        bytesRead: number;
+        bytesWritten: number;
+        private root;
+        constructor(initial: Root);
+        readData<Value>(deref: (root: Root) => Value): Value | undefined;
+        writeData<Value>(deref: (root: Root) => Value, newValue: Value): void;
+        deleteData(deref: (root: Root) => unknown): void;
+    }
+
+}
+
+declare module "sliftutils/storage/proxydatabase/ivfDbCheck" {
+    export {};
+
+}
+
+declare module "sliftutils/storage/proxydatabase/ivfEmbeddingDatabase" {
+    import { Database } from "./Database";
+    import { TransactionSetStore } from "./transactionSet";
+    import { StoredEmbedding, EmbeddingFormat } from "../embeddingFormats";
+    export type IvfConfig = {
+        model: string;
+        format: EmbeddingFormat;
+        cellTargetSize: number;
+    };
+    export type IvfEmbeddingRoot = {
+        config: IvfConfig;
+        count: number;
+        flat: TransactionSetStore<StoredEmbedding>;
+        steps: {
+            [step: string]: boolean;
+        };
+        centroids: TransactionSetStore<StoredEmbedding>;
+        cells: {
+            [cellId: string]: TransactionSetStore<StoredEmbedding>;
+        };
+    };
+    export type EmbeddingInput = {
+        ref: string;
+        embedding: StoredEmbedding;
+    };
+    export type SearchHit = {
+        ref: string;
+        closeness: number;
+    };
+    export declare function rebuildStructure(database: Database<IvfEmbeddingRoot>): void;
+    export declare function searchEmbeddings(database: Database<IvfEmbeddingRoot>, query: StoredEmbedding, options: {
+        probeBudget: number;
+        resultCount: number;
+    }): SearchHit[] | undefined;
+    export declare function insertEmbeddings(database: Database<IvfEmbeddingRoot>, items: EmbeddingInput[]): undefined;
+    export declare function removeEmbeddings(database: Database<IvfEmbeddingRoot>, items: EmbeddingInput[]): void;
+
+}
+
 declare module "sliftutils/storage/proxydatabase/transactionSet" {
     import { Database } from "./Database";
-    export type TransactionSetStore = {
+    declare const valueTag: unique symbol;
+    export type TransactionSetStore<Value> = {
         [fileNumber: string]: Uint8Array;
+        [valueTag]?: Value;
     };
-    export declare function transactionRead<Value>(database: Database<TransactionSetStore>): Map<string, Value> | undefined;
-    export declare function transactionMutate<Value>(database: Database<TransactionSetStore>, transactions: {
+    export declare function transactionRead<Value>(database: Database<TransactionSetStore<Value>>): Map<string, Value> | undefined;
+    export declare function replayTransactionStore<Value>(store: TransactionSetStore<Value> | undefined): Map<string, Value>;
+    export declare function transactionMutate<Value>(database: Database<TransactionSetStore<Value>>, transactions: {
         key: string;
         value: Value | undefined;
-    }[], compactAfterFiles?: number): true | undefined;
+    }[], compactAfterFiles?: number): void;
+    export declare function transactionDelete<Value>(database: Database<TransactionSetStore<Value>>): void;
+    export {};
 
 }
 

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "sliftutils",
-    "version": "1.4.80",
+    "version": "1.4.82",
     "main": "index.js",
     "license": "MIT",
     "files": [

package/spec.txt

@@ -40,3 +40,21 @@ unknown
 
     BUT... how do we update IVF
 
+
+
+
+1) Converting once is faster, so we should investigate if we can have a pool of memory. If we can reuse it, then the allocations are free. 
+
+1) Fix embedding formats. It's really, really stupid. decodeToLength was just absolutely retarded. 
+
+
+
+
+
+
+0) Make sure the AI stops trying to stop when a read didn't work because it doesn't fucking matter. I don't think there's a single place that's doing it where it actually matters. 
+    - I mean, I guess there are a few places. Like when we're rebalancing, that's one place.
+    - I guess some of the returns are valid, but I guess we have to check all of them. 
+
+1) Make sure the AI gets rid of all those four each's. I mean, what the fuck? 
+1)  Ensure the AI efficiently switches from the hard-coded stuff to the regular stuff and correctly regenerates the codebook. 

package/storage/BulkDatabase2/BulkDatabaseBase.d.ts

@@ -35,8 +35,11 @@ export declare class BulkDatabaseBase<T extends {
     private storageFactory;
     private config;
     constructor(name: string, deps: ReactiveDeps, storageFactory: StorageFactory, config?: BulkDatabase2Config);
+    private _reader;
+    private get reader();
+    private activated;
+    private activate;
     private setupVisibilityMergeCheck;
-    private reader;
     private subCaches;
     private pendingAppends;
     private flushTimer;

package/storage/BulkDatabase2/BulkDatabaseBase.ts

@@ -148,14 +148,31 @@ export class BulkDatabaseBase<T extends { key: string }> {
         protected deps: ReactiveDeps,
         private storageFactory: StorageFactory,
         private config: BulkDatabase2Config = {},
-    ) {
-        this.reader = new BulkDatabaseReader<T>({
-            name,
-            deps,
-            maxTriggerThrottleMs: config.maxTriggerThrottleMs,
+    ) { }
+
+    // The reader (and the background machinery that rides along with it) must NOT be set up just
+    // because the collection was constructed. Many collections are constructed and never touched, and
+    // in Node a merge tick would poke the storage factory (e.g. indexedDB) and throw. We build it
+    // lazily on first access to `this.reader`: every read, write, and merge goes through the reader,
+    // while pure construction never touches it.
+    private _reader: BulkDatabaseReader<T> | undefined;
+    private get reader(): BulkDatabaseReader<T> {
+        if (this._reader) return this._reader;
+        const reader = new BulkDatabaseReader<T>({
+            name: this.name,
+            deps: this.deps,
+            maxTriggerThrottleMs: this.config.maxTriggerThrottleMs,
         });
-        this.reader.setEnsureIndex(() => this.ensureIndex());
+        reader.setEnsureIndex(() => this.ensureIndex());
+        this._reader = reader;
+        this.activate();
+        return reader;
+    }
 
+    private activated = false;
+    private activate(): void {
+        if (this.activated) return;
+        this.activated = true;
         if (typeof window !== "undefined") {
             try {
                 window.addEventListener("pagehide", () => void this.flushPending());
@@ -205,7 +222,6 @@ export class BulkDatabaseBase<T extends { key: string }> {
         } catch { /* not in a DOM context */ }
     }
 
-    private reader: BulkDatabaseReader<T>;
     private subCaches: SubReaderCaches = { bulk: new Map(), stream: new Map() };
 
     private pendingAppends: { framed: Buffer; rows: number }[] = [];

package/storage/dist/embeddingFormats.ts.cache

@@ -0,0 +1,340 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true , configurable: true});
+//exports.hashEmbedding = exports.averageEmbeddings = exports.deserializeStoredEmbedding = exports.serializeStoredEmbedding = exports.encodeEmbedding = exports.getCloseness = exports.embeddingToFloat32 = exports.releaseFloat32 = exports.embeddingLength = exports.DEFAULT_EMBEDDING_FORMAT = exports.EMBEDDING_FORMATS = void 0;
+const measure_1 = require("socket-function/src/profiling/measure");
+const buffers_1 = require("socket-function/src/buffers");
+exports.EMBEDDING_FORMATS = ["q8g8_2048", "q8_g16_2048", "q8_g16_1024", "float32"];
+exports.DEFAULT_EMBEDDING_FORMAT = "q8g8_2048";
+const INT8_MAX = 127;
+const FORMAT_CONFIGS = {
+    q8g8_2048: { truncation: 2048, quant: { type: "q8", groupSize: 8 } },
+    q8_g16_2048: { truncation: 2048, quant: { type: "q8", groupSize: 16 } },
+    q8_g16_1024: { truncation: 1024, quant: { type: "q8", groupSize: 16 } },
+    float32: {},
+};
+const Float16ArrayCtor = globalThis.Float16Array;
+const f32Scratch = new Float32Array(1);
+const i32Scratch = new Int32Array(f32Scratch.buffer);
+function floatToHalf(value) {
+    f32Scratch[0] = value;
+    let bitsIn = i32Scratch[0];
+    let bits = (bitsIn >> 16) & 0x8000;
+    let mantissa = (bitsIn >> 12) & 0x07ff;
+    let exponent = (bitsIn >> 23) & 0xff;
+    if (exponent < 103)
+        return bits;
+    if (exponent > 142) {
+        bits |= 0x7c00;
+        if (exponent !== 255) {
+            bits |= (bitsIn & 0x007fffff);
+        }
+        return bits;
+    }
+    if (exponent < 113) {
+        mantissa |= 0x0800;
+        bits |= (mantissa >> (114 - exponent)) + ((mantissa >> (113 - exponent)) & 1);
+        return bits;
+    }
+    bits |= ((exponent - 112) << 10) | (mantissa >> 1);
+    bits += mantissa & 1;
+    return bits;
+}
+function halfToFloat(half) {
+    let sign = (half & 0x8000) >> 15;
+    let exponent = (half & 0x7c00) >> 10;
+    let fraction = half & 0x03ff;
+    let signMultiplier = sign && -1 || 1;
+    if (exponent === 0) {
+        return signMultiplier * Math.pow(2, -14) * (fraction / 1024);
+    }
+    if (exponent === 0x1f) {
+        if (fraction)
+            return NaN;
+        return signMultiplier * Infinity;
+    }
+    return signMultiplier * Math.pow(2, exponent - 15) * (1 + fraction / 1024);
+}
+function asInt8(bytes) {
+    return new Int8Array(bytes.buffer, bytes.byteOffset, bytes.byteLength);
+}
+function encodeFloat16(values) {
+    if (Float16ArrayCtor) {
+        let half = new Float16ArrayCtor(values);
+        return new Uint8Array(half.buffer, half.byteOffset, half.byteLength);
+    }
+    let out = new Uint8Array(values.length * 2);
+    let view = new DataView(out.buffer);
+    for (let index = 0; index < values.length; index++) {
+        view.setUint16(index * 2, floatToHalf(values[index]), true);
+    }
+    return out;
+}
+function asFloat16Indexable(bytes) {
+    // Float16Array / Uint16Array views require 2-byte alignment; copy when the stored bytes aren't.
+    if (bytes.byteOffset % 2 !== 0) {
+        bytes = new Uint8Array(bytes);
+    }
+    let count = Math.floor(bytes.byteLength / 2);
+    if (Float16ArrayCtor) {
+        return new Float16ArrayCtor(bytes.buffer, bytes.byteOffset, count);
+    }
+    let halves = new Uint16Array(bytes.buffer, bytes.byteOffset, count);
+    let out = new Float32Array(count);
+    for (let index = 0; index < count; index++) {
+        out[index] = halfToFloat(halves[index]);
+    }
+    return out;
+}
+function embeddingLength(input) {
+    if (input instanceof Float32Array)
+        return input.length;
+    if (input.kind === "float32")
+        return input.values.length;
+    return input.data.length;
+}
+exports.embeddingLength = embeddingLength;
+// A pool of reusable Float32 buffers keyed by length. Most embeddings share a size, so internal hot paths
+// borrow a buffer (embeddingToFloat32 with usePool) and return it (releaseFloat32) to avoid per-op
+// allocations and GC thrashing. A borrowed buffer holds stale data; whoever borrows it overwrites it fully.
+//
+// Each free buffer records when it was last released; an hourly sweep drops any that have sat idle for over
+// an hour, so the runtime can free buffers a burst of work allocated but isn't actually reusing anymore.
+const POOL_MAX_IDLE_MS = 60 * 60 * 1000;
+const float32Pool = new Map();
+function acquireFloat32(length) {
+    let free = float32Pool.get(length);
+    if (free && free.length) {
+        return free.pop().buffer;
+    }
+    return new Float32Array(length);
+}
+function releaseFloat32(buffer) {
+    let free = float32Pool.get(buffer.length);
+    if (!free) {
+        free = [];
+        float32Pool.set(buffer.length, free);
+    }
+    free.push({ buffer, releasedAt: Date.now() });
+}
+exports.releaseFloat32 = releaseFloat32;
+function sweepFloat32Pool() {
+    let cutoff = Date.now() - POOL_MAX_IDLE_MS;
+    for (let free of float32Pool.values()) {
+        let writeIndex = 0;
+        for (let readIndex = 0; readIndex < free.length; readIndex++) {
+            if (free[readIndex].releasedAt > cutoff) {
+                free[writeIndex++] = free[readIndex];
+            }
+        }
+        free.length = writeIndex;
+    }
+}
+const poolSweepTimer = setInterval(sweepFloat32Pool, POOL_MAX_IDLE_MS);
+if (typeof poolSweepTimer.unref === "function") {
+    poolSweepTimer.unref();
+}
+// Decode to a Float32Array (full length). Stored values are already unit-normalized (encodeEmbedding does
+// that), so this only de-quantizes. By default it allocates a fresh array (a float input is returned as-is,
+// no copy). With usePool it borrows a pooled buffer the caller must releaseFloat32 — used by hot internal
+// paths so repeated decodes don't allocate.
+function embeddingToFloat32(input, usePool = false) {
+    if (input instanceof Float32Array) {
+        if (!usePool)
+            return input;
+        let out = acquireFloat32(input.length);
+        out.set(input);
+        return out;
+    }
+    if (input.kind === "float32") {
+        if (!usePool)
+            return input.values;
+        let out = acquireFloat32(input.values.length);
+        out.set(input.values);
+        return out;
+    }
+    let int8 = asInt8(input.data);
+    let scales = asFloat16Indexable(input.scales);
+    let groupSize = input.groupSize;
+    let length = int8.length;
+    let out = usePool ? acquireFloat32(length) : new Float32Array(length);
+    let group = 0;
+    for (let start = 0; start < length; start += groupSize) {
+        let scale = scales[group++];
+        let end = Math.min(start + groupSize, length);
+        for (let index = start; index < end; index++) {
+            out[index] = int8[index] * scale;
+        }
+    }
+    return out;
+}
+exports.embeddingToFloat32 = embeddingToFloat32;
+function closenessFromDot(dot) {
+    // Inputs are unit vectors, so euclidean^2 = 2 - 2*dot; clamp away tiny negatives from float error.
+    return 1 - Math.sqrt(Math.max(0, 2 - 2 * dot));
+}
+function dotFloat32(a, b) {
+    let length = Math.min(a.length, b.length);
+    let dot = 0;
+    for (let index = 0; index < length; index++) {
+        dot += a[index] * b[index];
+    }
+    return dot;
+}
+// Closeness = 1 - euclidean distance of two unit vectors. Always decode both to (pooled) float32 and dot:
+// simple, and once the decodes are pooled it's the fastest per-call path. Batch callers (k-means) decode
+// every vector once themselves instead of going through here.
+exports.getCloseness = (0, measure_1.measureWrap)(function getCloseness(a, b) {
+    let va = embeddingToFloat32(a, true);
+    let vb = embeddingToFloat32(b, true);
+    let result = closenessFromDot(dotFloat32(va, vb));
+    releaseFloat32(va);
+    releaseFloat32(vb);
+    return result;
+});
+// Encode a vector (or re-encode an embedding) into the requested format. This is THE place we normalize:
+// the (truncated) vector is made unit length here, so anything that's been encoded is reliably normalized
+// and the comparison/decoding paths never have to re-normalize.
+function encodeEmbedding(config) {
+    let { input, format, model } = config;
+    let formatConfig = FORMAT_CONFIGS[format];
+    let decoded = embeddingToFloat32(input, true);
+    let length = decoded.length;
+    if (formatConfig.truncation !== undefined && formatConfig.truncation < length) {
+        length = formatConfig.truncation;
+    }
+    let norm = 0;
+    for (let index = 0; index < length; index++) {
+        norm += decoded[index] * decoded[index];
+    }
+    let magnitude = Math.sqrt(norm) || 1;
+    for (let index = 0; index < length; index++) {
+        decoded[index] /= magnitude;
+    }
+    let result;
+    if (!formatConfig.quant) {
+        result = { kind: "float32", model, values: new Float32Array(decoded.subarray(0, length)) };
+    }
+    else {
+        let { type, groupSize } = formatConfig.quant;
+        let groupCount = Math.ceil(length / groupSize);
+        let int8 = new Int8Array(length);
+        let scales = new Float32Array(groupCount);
+        for (let group = 0; group < groupCount; group++) {
+            let start = group * groupSize;
+            let end = Math.min(start + groupSize, length);
+            let maxAbs = 0;
+            for (let index = start; index < end; index++) {
+                let absValue = Math.abs(decoded[index]);
+                if (absValue > maxAbs)
+                    maxAbs = absValue;
+            }
+            let scale = maxAbs / INT8_MAX;
+            scales[group] = scale;
+            if (!scale)
+                continue;
+            for (let index = start; index < end; index++) {
+                let quantized = Math.round(decoded[index] / scale);
+                if (quantized > INT8_MAX)
+                    quantized = INT8_MAX;
+                if (quantized < -INT8_MAX)
+                    quantized = -INT8_MAX;
+                int8[index] = quantized;
+            }
+        }
+        result = {
+            kind: "quant",
+            model,
+            type,
+            groupSize,
+            data: new Uint8Array(int8.buffer, int8.byteOffset, int8.byteLength),
+            scales: encodeFloat16(scales),
+        };
+    }
+    releaseFloat32(decoded);
+    return result;
+}
+exports.encodeEmbedding = encodeEmbedding;
+// Serialize to base64 so a StoredEmbedding can travel through the (string) API call result. Layout:
+// [4-byte little-endian header length][JSON header][raw typed-array payload(s)].
+function serializeStoredEmbedding(stored) {
+    let header;
+    let payload;
+    if (stored.kind === "float32") {
+        header = { kind: "float32", model: stored.model };
+        payload = [new Uint8Array(stored.values.buffer, stored.values.byteOffset, stored.values.byteLength)];
+    }
+    else {
+        header = { kind: "quant", model: stored.model, type: stored.type, groupSize: stored.groupSize, dataBytes: stored.data.byteLength };
+        payload = [stored.data, stored.scales];
+    }
+    let headerBytes = Buffer.from(JSON.stringify(header), "utf8");
+    let headerLength = Buffer.alloc(4);
+    headerLength.writeUInt32LE(headerBytes.length, 0);
+    return Buffer.concat([headerLength, headerBytes, ...payload.map(buffers_1.asBuffer)]).toString("base64");
+}
+exports.serializeStoredEmbedding = serializeStoredEmbedding;
+function deserializeStoredEmbedding(base64) {
+    let buffer = Buffer.from(base64, "base64");
+    if (buffer.length < 4) {
+        throw new Error(`Serialized embedding is too short (${buffer.length} bytes): ${base64.slice(0, 200)}`);
+    }
+    let headerLength = buffer.readUInt32LE(0);
+    let headerEnd = 4 + headerLength;
+    if (headerLength <= 0 || headerEnd > buffer.length) {
+        throw new Error(`Serialized embedding header length ${headerLength} is invalid for ${buffer.length} bytes: ${base64.slice(0, 200)}`);
+    }
+    let header = JSON.parse(buffer.toString("utf8", 4, headerEnd));
+    let payload = buffer.subarray(headerEnd);
+    if (header.kind === "float32") {
+        return { kind: "float32", model: header.model, values: (0, buffers_1.asFloat32)((0, buffers_1.asBuffer)(Uint8Array.from(payload))) };
+    }
+    return {
+        kind: "quant",
+        model: header.model,
+        type: header.type,
+        groupSize: header.groupSize,
+        data: Uint8Array.from(payload.subarray(0, header.dataBytes)),
+        scales: Uint8Array.from(payload.subarray(header.dataBytes)),
+    };
+}
+exports.deserializeStoredEmbedding = deserializeStoredEmbedding;
+// Mean of several embeddings (encodeEmbedding normalizes the result to a unit centroid). Borrows a pooled
+// accumulator.
+function averageEmbeddings(embeddings, config) {
+    let length = Infinity;
+    for (let embedding of embeddings) {
+        length = Math.min(length, embeddingLength(embedding));
+    }
+    let sum = acquireFloat32(length);
+    sum.fill(0);
+    for (let embedding of embeddings) {
+        let vector = embeddingToFloat32(embedding, true);
+        for (let dimension = 0; dimension < length; dimension++) {
+            sum[dimension] += vector[dimension];
+        }
+        releaseFloat32(vector);
+    }
+    let result = encodeEmbedding({ input: sum.subarray(0, length), format: config.format, model: config.model });
+    releaseFloat32(sum);
+    return result;
+}
+exports.averageEmbeddings = averageEmbeddings;
+// A stable 16-byte (base64) content hash of an embedding's values, for use as a cell id derived from its
+// centroid. Iterates via the accessor (the value bits are hashed, so any format hashes consistently).
+function hashEmbedding(stored) {
+    let vector = embeddingToFloat32(stored, true);
+    let length = vector.length;
+    let lanes = new Uint32Array([2166136261, 2654435761, 40503, 3266489917]);
+    for (let index = 0; index < length; index++) {
+        f32Scratch[0] = vector[index];
+        let bits = i32Scratch[0];
+        for (let lane = 0; lane < lanes.length; lane++) {
+            lanes[lane] = Math.imul(lanes[lane] ^ (bits + lane * 131 + index), 16777619);
+        }
+    }
+    releaseFloat32(vector);
+    return Buffer.from(lanes.buffer).toString("base64");
+}
+exports.hashEmbedding = hashEmbedding;
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"embeddingFormats.js","sourceRoot":"","sources":["embeddingFormats.ts"],"names":[],"mappings":"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","sourcesContent":["import { measureWrap } from \"socket-function/src/profiling/measure\";\nimport { asBuffer, asFloat32 } from \"socket-function/src/buffers\";\n\n// The formats an embedding can be stored & compared in. The trailing number is the Matryoshka\n// truncation length (the count of leading dimensions kept). \"q8gN\" means signed int8 values with\n// one scale shared across every N dimensions. \"float32\" keeps the raw (truncated) vector.\nexport type EmbeddingFormat = \"q8g8_2048\" | \"q8_g16_2048\" | \"q8_g16_1024\" | \"float32\";\n\nexport const EMBEDDING_FORMATS: EmbeddingFormat[] = [\"q8g8_2048\", \"q8_g16_2048\", \"q8_g16_1024\", \"float32\"];\nexport const DEFAULT_EMBEDDING_FORMAT: EmbeddingFormat = \"q8g8_2048\";\n\n// The only element quantization we support right now (signed int8, values in [-127, 127]).\nexport type QuantType = \"q8\";\n\nconst INT8_MAX = 127;\n\ntype FormatConfig = {\n    // Leading dimensions kept. undefined keeps the full vector.\n    truncation?: number;\n    // int8 group quantization parameters. undefined stores the raw float32 vector.\n    quant?: { type: QuantType; groupSize: number };\n};\nconst FORMAT_CONFIGS: { [format in EmbeddingFormat]: FormatConfig } = {\n    q8g8_2048: { truncation: 2048, quant: { type: \"q8\", groupSize: 8 } },\n    q8_g16_2048: { truncation: 2048, quant: { type: \"q8\", groupSize: 16 } },\n    q8_g16_1024: { truncation: 1024, quant: { type: \"q8\", groupSize: 16 } },\n    float32: {},\n};\n\nexport type StoredEmbedding = {\n    kind: \"float32\";\n    model: string;\n    values: Float32Array;\n} | {\n    kind: \"quant\";\n    model: string;\n    // Element quantization. \"q8\" is signed int8 (values in [-127, 127]).\n    type: QuantType;\n    // Number of consecutive dimensions sharing one scale.\n    groupSize: number;\n    // int8 values (one per kept dimension), reinterpreted as raw bytes.\n    data: Uint8Array;\n    // float16 scales (one per group), reinterpreted as raw bytes.\n    scales: Uint8Array;\n};\n\n// Float16Array isn't in our TypeScript lib and isn't guaranteed at runtime, so we read it off\n// globalThis and fall back to a manual half<->float conversion when it's missing.\ninterface Float16ArrayLike {\n    readonly length: number;\n    [index: number]: number;\n    readonly buffer: ArrayBufferLike;\n    readonly byteOffset: number;\n    readonly byteLength: number;\n}\ninterface Float16ArrayConstructor {\n    new(length: number): Float16ArrayLike;\n    new(elements: ArrayLike<number>): Float16ArrayLike;\n    new(buffer: ArrayBufferLike, byteOffset?: number, length?: number): Float16ArrayLike;\n}\nconst Float16ArrayCtor = (globalThis as { Float16Array?: Float16ArrayConstructor }).Float16Array;\n\nconst f32Scratch = new Float32Array(1);\nconst i32Scratch = new Int32Array(f32Scratch.buffer);\nfunction floatToHalf(value: number): number {\n    f32Scratch[0] = value;\n    let bitsIn = i32Scratch[0];\n    let bits = (bitsIn >> 16) & 0x8000;\n    let mantissa = (bitsIn >> 12) & 0x07ff;\n    let exponent = (bitsIn >> 23) & 0xff;\n    if (exponent < 103) return bits;\n    if (exponent > 142) {\n        bits |= 0x7c00;\n        if (exponent !== 255) {\n            bits |= (bitsIn & 0x007fffff);\n        }\n        return bits;\n    }\n    if (exponent < 113) {\n        mantissa |= 0x0800;\n        bits |= (mantissa >> (114 - exponent)) + ((mantissa >> (113 - exponent)) & 1);\n        return bits;\n    }\n    bits |= ((exponent - 112) << 10) | (mantissa >> 1);\n    bits += mantissa & 1;\n    return bits;\n}\nfunction halfToFloat(half: number): number {\n    let sign = (half & 0x8000) >> 15;\n    let exponent = (half & 0x7c00) >> 10;\n    let fraction = half & 0x03ff;\n    let signMultiplier = sign && -1 || 1;\n    if (exponent === 0) {\n        return signMultiplier * Math.pow(2, -14) * (fraction / 1024);\n    }\n    if (exponent === 0x1f) {\n        if (fraction) return NaN;\n        return signMultiplier * Infinity;\n    }\n    return signMultiplier * Math.pow(2, exponent - 15) * (1 + fraction / 1024);\n}\n\nfunction asInt8(bytes: Uint8Array): Int8Array {\n    return new Int8Array(bytes.buffer, bytes.byteOffset, bytes.byteLength);\n}\nfunction encodeFloat16(values: Float32Array): Uint8Array {\n    if (Float16ArrayCtor) {\n        let half = new Float16ArrayCtor(values);\n        return new Uint8Array(half.buffer, half.byteOffset, half.byteLength);\n    }\n    let out = new Uint8Array(values.length * 2);\n    let view = new DataView(out.buffer);\n    for (let index = 0; index < values.length; index++) {\n        view.setUint16(index * 2, floatToHalf(values[index]), true);\n    }\n    return out;\n}\nfunction asFloat16Indexable(bytes: Uint8Array): { readonly length: number;[index: number]: number } {\n    // Float16Array / Uint16Array views require 2-byte alignment; copy when the stored bytes aren't.\n    if (bytes.byteOffset % 2 !== 0) {\n        bytes = new Uint8Array(bytes);\n    }\n    let count = Math.floor(bytes.byteLength / 2);\n    if (Float16ArrayCtor) {\n        return new Float16ArrayCtor(bytes.buffer, bytes.byteOffset, count);\n    }\n    let halves = new Uint16Array(bytes.buffer, bytes.byteOffset, count);\n    let out = new Float32Array(count);\n    for (let index = 0; index < count; index++) {\n        out[index] = halfToFloat(halves[index]);\n    }\n    return out;\n}\n\nexport function embeddingLength(input: Float32Array | StoredEmbedding): number {\n    if (input instanceof Float32Array) return input.length;\n    if (input.kind === \"float32\") return input.values.length;\n    return input.data.length;\n}\n\n// A pool of reusable Float32 buffers keyed by length. Most embeddings share a size, so internal hot paths\n// borrow a buffer (embeddingToFloat32 with usePool) and return it (releaseFloat32) to avoid per-op\n// allocations and GC thrashing. A borrowed buffer holds stale data; whoever borrows it overwrites it fully.\n//\n// Each free buffer records when it was last released; an hourly sweep drops any that have sat idle for over\n// an hour, so the runtime can free buffers a burst of work allocated but isn't actually reusing anymore.\nconst POOL_MAX_IDLE_MS = 60 * 60 * 1000;\ntype PooledFloat32 = { buffer: Float32Array; releasedAt: number };\nconst float32Pool = new Map<number, PooledFloat32[]>();\nfunction acquireFloat32(length: number): Float32Array {\n    let free = float32Pool.get(length);\n    if (free && free.length) {\n        return free.pop()!.buffer;\n    }\n    return new Float32Array(length);\n}\nexport function releaseFloat32(buffer: Float32Array): void {\n    let free = float32Pool.get(buffer.length);\n    if (!free) {\n        free = [];\n        float32Pool.set(buffer.length, free);\n    }\n    free.push({ buffer, releasedAt: Date.now() });\n}\nfunction sweepFloat32Pool(): void {\n    let cutoff = Date.now() - POOL_MAX_IDLE_MS;\n    for (let free of float32Pool.values()) {\n        let writeIndex = 0;\n        for (let readIndex = 0; readIndex < free.length; readIndex++) {\n            if (free[readIndex].releasedAt > cutoff) {\n                free[writeIndex++] = free[readIndex];\n            }\n        }\n        free.length = writeIndex;\n    }\n}\nconst poolSweepTimer = setInterval(sweepFloat32Pool, POOL_MAX_IDLE_MS) as unknown as { unref?: () => void };\nif (typeof poolSweepTimer.unref === \"function\") {\n    poolSweepTimer.unref();\n}\n\n// Decode to a Float32Array (full length). Stored values are already unit-normalized (encodeEmbedding does\n// that), so this only de-quantizes. By default it allocates a fresh array (a float input is returned as-is,\n// no copy). With usePool it borrows a pooled buffer the caller must releaseFloat32 — used by hot internal\n// paths so repeated decodes don't allocate.\nexport function embeddingToFloat32(input: Float32Array | StoredEmbedding, usePool = false): Float32Array {\n    if (input instanceof Float32Array) {\n        if (!usePool) return input;\n        let out = acquireFloat32(input.length);\n        out.set(input);\n        return out;\n    }\n    if (input.kind === \"float32\") {\n        if (!usePool) return input.values;\n        let out = acquireFloat32(input.values.length);\n        out.set(input.values);\n        return out;\n    }\n    let int8 = asInt8(input.data);\n    let scales = asFloat16Indexable(input.scales);\n    let groupSize = input.groupSize;\n    let length = int8.length;\n    let out = usePool ? acquireFloat32(length) : new Float32Array(length);\n    let group = 0;\n    for (let start = 0; start < length; start += groupSize) {\n        let scale = scales[group++];\n        let end = Math.min(start + groupSize, length);\n        for (let index = start; index < end; index++) {\n            out[index] = int8[index] * scale;\n        }\n    }\n    return out;\n}\n\nfunction closenessFromDot(dot: number): number {\n    // Inputs are unit vectors, so euclidean^2 = 2 - 2*dot; clamp away tiny negatives from float error.\n    return 1 - Math.sqrt(Math.max(0, 2 - 2 * dot));\n}\n\nfunction dotFloat32(a: Float32Array, b: Float32Array): number {\n    let length = Math.min(a.length, b.length);\n    let dot = 0;\n    for (let index = 0; index < length; index++) {\n        dot += a[index] * b[index];\n    }\n    return dot;\n}\n\n// Closeness = 1 - euclidean distance of two unit vectors. Always decode both to (pooled) float32 and dot:\n// simple, and once the decodes are pooled it's the fastest per-call path. Batch callers (k-means) decode\n// every vector once themselves instead of going through here.\nexport const getCloseness = measureWrap(function getCloseness(a: Float32Array | StoredEmbedding, b: Float32Array | StoredEmbedding): number {\n    let va = embeddingToFloat32(a, true);\n    let vb = embeddingToFloat32(b, true);\n    let result = closenessFromDot(dotFloat32(va, vb));\n    releaseFloat32(va);\n    releaseFloat32(vb);\n    return result;\n});\n\n// Encode a vector (or re-encode an embedding) into the requested format. This is THE place we normalize:\n// the (truncated) vector is made unit length here, so anything that's been encoded is reliably normalized\n// and the comparison/decoding paths never have to re-normalize.\nexport function encodeEmbedding(config: {\n    input: Float32Array | StoredEmbedding;\n    format: EmbeddingFormat;\n    model: string;\n}): StoredEmbedding {\n    let { input, format, model } = config;\n    let formatConfig = FORMAT_CONFIGS[format];\n    let decoded = embeddingToFloat32(input, true);\n    let length = decoded.length;\n    if (formatConfig.truncation !== undefined && formatConfig.truncation < length) {\n        length = formatConfig.truncation;\n    }\n    let norm = 0;\n    for (let index = 0; index < length; index++) {\n        norm += decoded[index] * decoded[index];\n    }\n    let magnitude = Math.sqrt(norm) || 1;\n    for (let index = 0; index < length; index++) {\n        decoded[index] /= magnitude;\n    }\n\n    let result: StoredEmbedding;\n    if (!formatConfig.quant) {\n        result = { kind: \"float32\", model, values: new Float32Array(decoded.subarray(0, length)) };\n    } else {\n        let { type, groupSize } = formatConfig.quant;\n        let groupCount = Math.ceil(length / groupSize);\n        let int8 = new Int8Array(length);\n        let scales = new Float32Array(groupCount);\n        for (let group = 0; group < groupCount; group++) {\n            let start = group * groupSize;\n            let end = Math.min(start + groupSize, length);\n            let maxAbs = 0;\n            for (let index = start; index < end; index++) {\n                let absValue = Math.abs(decoded[index]);\n                if (absValue > maxAbs) maxAbs = absValue;\n            }\n            let scale = maxAbs / INT8_MAX;\n            scales[group] = scale;\n            if (!scale) continue;\n            for (let index = start; index < end; index++) {\n                let quantized = Math.round(decoded[index] / scale);\n                if (quantized > INT8_MAX) quantized = INT8_MAX;\n                if (quantized < -INT8_MAX) quantized = -INT8_MAX;\n                int8[index] = quantized;\n            }\n        }\n        result = {\n            kind: \"quant\",\n            model,\n            type,\n            groupSize,\n            data: new Uint8Array(int8.buffer, int8.byteOffset, int8.byteLength),\n            scales: encodeFloat16(scales),\n        };\n    }\n    releaseFloat32(decoded);\n    return result;\n}\n\ntype SerializedHeader =\n    | { kind: \"float32\"; model: string }\n    | { kind: \"quant\"; model: string; type: QuantType; groupSize: number; dataBytes: number };\n\n// Serialize to base64 so a StoredEmbedding can travel through the (string) API call result. Layout:\n// [4-byte little-endian header length][JSON header][raw typed-array payload(s)].\nexport function serializeStoredEmbedding(stored: StoredEmbedding): string {\n    let header: SerializedHeader;\n    let payload: Uint8Array[];\n    if (stored.kind === \"float32\") {\n        header = { kind: \"float32\", model: stored.model };\n        payload = [new Uint8Array(stored.values.buffer, stored.values.byteOffset, stored.values.byteLength)];\n    } else {\n        header = { kind: \"quant\", model: stored.model, type: stored.type, groupSize: stored.groupSize, dataBytes: stored.data.byteLength };\n        payload = [stored.data, stored.scales];\n    }\n    let headerBytes = Buffer.from(JSON.stringify(header), \"utf8\");\n    let headerLength = Buffer.alloc(4);\n    headerLength.writeUInt32LE(headerBytes.length, 0);\n    return Buffer.concat([headerLength, headerBytes, ...payload.map(asBuffer)]).toString(\"base64\");\n}\nexport function deserializeStoredEmbedding(base64: string): StoredEmbedding {\n    let buffer = Buffer.from(base64, \"base64\");\n    if (buffer.length < 4) {\n        throw new Error(`Serialized embedding is too short (${buffer.length} bytes): ${base64.slice(0, 200)}`);\n    }\n    let headerLength = buffer.readUInt32LE(0);\n    let headerEnd = 4 + headerLength;\n    if (headerLength <= 0 || headerEnd > buffer.length) {\n        throw new Error(`Serialized embedding header length ${headerLength} is invalid for ${buffer.length} bytes: ${base64.slice(0, 200)}`);\n    }\n    let header = JSON.parse(buffer.toString(\"utf8\", 4, headerEnd)) as SerializedHeader;\n    let payload = buffer.subarray(headerEnd);\n    if (header.kind === \"float32\") {\n        return { kind: \"float32\", model: header.model, values: asFloat32(asBuffer(Uint8Array.from(payload))) };\n    }\n    return {\n        kind: \"quant\",\n        model: header.model,\n        type: header.type,\n        groupSize: header.groupSize,\n        data: Uint8Array.from(payload.subarray(0, header.dataBytes)),\n        scales: Uint8Array.from(payload.subarray(header.dataBytes)),\n    };\n}\n\n// Mean of several embeddings (encodeEmbedding normalizes the result to a unit centroid). Borrows a pooled\n// accumulator.\nexport function averageEmbeddings(embeddings: StoredEmbedding[], config: { format: EmbeddingFormat; model: string }): StoredEmbedding {\n    let length = Infinity;\n    for (let embedding of embeddings) {\n        length = Math.min(length, embeddingLength(embedding));\n    }\n    let sum = acquireFloat32(length);\n    sum.fill(0);\n    for (let embedding of embeddings) {\n        let vector = embeddingToFloat32(embedding, true);\n        for (let dimension = 0; dimension < length; dimension++) {\n            sum[dimension] += vector[dimension];\n        }\n        releaseFloat32(vector);\n    }\n    let result = encodeEmbedding({ input: sum.subarray(0, length), format: config.format, model: config.model });\n    releaseFloat32(sum);\n    return result;\n}\n\n// A stable 16-byte (base64) content hash of an embedding's values, for use as a cell id derived from its\n// centroid. Iterates via the accessor (the value bits are hashed, so any format hashes consistently).\nexport function hashEmbedding(stored: StoredEmbedding): string {\n    let vector = embeddingToFloat32(stored, true);\n    let length = vector.length;\n    let lanes = new Uint32Array([2166136261, 2654435761, 40503, 3266489917]);\n    for (let index = 0; index < length; index++) {\n        f32Scratch[0] = vector[index];\n        let bits = i32Scratch[0];\n        for (let lane = 0; lane < lanes.length; lane++) {\n            lanes[lane] = Math.imul(lanes[lane] ^ (bits + lane * 131 + index), 16777619);\n        }\n    }\n    releaseFloat32(vector);\n    return Buffer.from(lanes.buffer).toString(\"base64\");\n}\n"]}
+ /* _JS_SOURCE_HASH = "252bf7f8cc3cfd27bebc9b3e1ddee9aa39631ffeffa137c02456c63deb496996"; */