sliftutils 1.4.81 → 1.4.82

package/index.d.ts

@@ -2261,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[];
@@ -2278,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;
@@ -2290,7 +2299,16 @@ declare module "sliftutils/storage/embeddingFormats" {
         model: string;
     }): StoredEmbedding;
     export declare function hashEmbedding(stored: StoredEmbedding): string;
-    export declare const getCloseness: (embedding1: Float32Array | StoredEmbedding, embedding2: Float32Array | StoredEmbedding) => number;
+
+}
+
+declare module "sliftutils/storage/faceFramesData" {
+    export declare function ensureFaceData(fileName: string, byteLength: number): Promise<string>;
+
+}
+
+declare module "sliftutils/storage/faceFramesServer" {
+    export {};
 
 }
 
@@ -2319,6 +2337,28 @@ 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";
@@ -2326,16 +2366,19 @@ declare module "sliftutils/storage/proxydatabase/ivfEmbeddingDatabase" {
     export type IvfConfig = {
         model: string;
         format: EmbeddingFormat;
-        cellTarget: number;
-        splitAt: number;
+        cellTargetSize: number;
     };
     export type IvfEmbeddingRoot = {
         config: IvfConfig;
-        centroids: TransactionSetStore;
+        count: number;
+        flat: TransactionSetStore<StoredEmbedding>;
+        steps: {
+            [step: string]: boolean;
+        };
+        centroids: TransactionSetStore<StoredEmbedding>;
         cells: {
-            [cellId: string]: TransactionSetStore;
+            [cellId: string]: TransactionSetStore<StoredEmbedding>;
         };
-        refIndex: TransactionSetStore;
     };
     export type EmbeddingInput = {
         ref: string;
@@ -2345,26 +2388,31 @@ declare module "sliftutils/storage/proxydatabase/ivfEmbeddingDatabase" {
         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[]): true | undefined;
-    export declare function removeEmbeddings(database: Database<IvfEmbeddingRoot>, refs: string[]): true | 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 replayTransactionStore<Value>(store: TransactionSetStore | undefined): Map<string, Value>;
-    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.81",
+    "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/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"; */

package/storage/dist/faceFramesData.ts.cache

@@ -0,0 +1,55 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule && mod.default) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true , configurable: true});
+//exports.ensureFaceData = void 0;
+const fs_1 = __importDefault(require("fs"));
+const os_1 = __importDefault(require("os"));
+const path_1 = __importDefault(require("path"));
+const http_1 = __importDefault(require("http"));
+// Resolves a face-embedding test file to a local path that holds at least the requested number of bytes. On
+// the machine that owns the data it just uses the original file. Anywhere else it downloads the missing prefix
+// from the faceFramesServer over a range request and caches it in the temp dir, so re-runs only fetch what
+// they haven't already. Point it at a different server with FACEFRAMES_URL.
+const SOURCE_DIR = "/root/claude-work/face-embeddings";
+const SERVER_BASE = process.env.FACEFRAMES_URL || "http://65.109.93.113:8799";
+function downloadInto(fileName, start, endExclusive, cachePath) {
+    return new Promise((resolve, reject) => {
+        const url = `${SERVER_BASE}/${fileName}`;
+        const options = { headers: { Range: `bytes=${start}-${endExclusive - 1}` } };
+        const request = http_1.default.get(url, options, response => {
+            if (response.statusCode !== 206 && response.statusCode !== 200) {
+                response.resume();
+                reject(new Error(`${url} returned ${response.statusCode}`));
+                return;
+            }
+            const out = fs_1.default.createWriteStream(cachePath, start ? { flags: "r+", start } : { flags: "w" });
+            response.pipe(out);
+            out.on("error", reject);
+            response.on("error", reject);
+            out.on("finish", resolve);
+        });
+        request.on("error", reject);
+    });
+}
+async function ensureFaceData(fileName, byteLength) {
+    const local = path_1.default.join(SOURCE_DIR, fileName);
+    if (fs_1.default.existsSync(local) && fs_1.default.statSync(local).size >= byteLength) {
+        return local;
+    }
+    const cachePath = path_1.default.join(os_1.default.tmpdir(), fileName);
+    let cachedBytes = 0;
+    if (fs_1.default.existsSync(cachePath)) {
+        cachedBytes = fs_1.default.statSync(cachePath).size;
+    }
+    if (cachedBytes < byteLength) {
+        const megabytes = ((byteLength - cachedBytes) / 1e6).toFixed(0);
+        console.log(`downloading ${megabytes}MB of ${fileName} from ${SERVER_BASE} -> ${cachePath}`);
+        await downloadInto(fileName, cachedBytes, byteLength, cachePath);
+    }
+    return cachePath;
+}
+exports.ensureFaceData = ensureFaceData;
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZmFjZUZyYW1lc0RhdGEuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyJmYWNlRnJhbWVzRGF0YS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiOzs7Ozs7QUFBQSw0Q0FBb0I7QUFDcEIsNENBQW9CO0FBQ3BCLGdEQUF3QjtBQUN4QixnREFBd0I7QUFFeEIsNEdBQTRHO0FBQzVHLCtHQUErRztBQUMvRywyR0FBMkc7QUFDM0csNEVBQTRFO0FBQzVFLE1BQU0sVUFBVSxHQUFHLG1DQUFtQyxDQUFDO0FBQ3ZELE1BQU0sV0FBVyxHQUFHLE9BQU8sQ0FBQyxHQUFHLENBQUMsY0FBYyxJQUFJLDJCQUEyQixDQUFDO0FBRTlFLFNBQVMsWUFBWSxDQUFDLFFBQWdCLEVBQUUsS0FBYSxFQUFFLFlBQW9CLEVBQUUsU0FBaUI7SUFDMUYsT0FBTyxJQUFJLE9BQU8sQ0FBQyxDQUFDLE9BQU8sRUFBRSxNQUFNLEVBQUUsRUFBRTtRQUNuQyxNQUFNLEdBQUcsR0FBRyxHQUFHLFdBQVcsSUFBSSxRQUFRLEVBQUUsQ0FBQztRQUN6QyxNQUFNLE9BQU8sR0FBRyxFQUFFLE9BQU8sRUFBRSxFQUFFLEtBQUssRUFBRSxTQUFTLEtBQUssSUFBSSxZQUFZLEdBQUcsQ0FBQyxFQUFFLEVBQUUsRUFBRSxDQUFDO1FBQzdFLE1BQU0sT0FBTyxHQUFHLGNBQUksQ0FBQyxHQUFHLENBQUMsR0FBRyxFQUFFLE9BQU8sRUFBRSxRQUFRLENBQUMsRUFBRTtZQUM5QyxJQUFJLFFBQVEsQ0FBQyxVQUFVLEtBQUssR0FBRyxJQUFJLFFBQVEsQ0FBQyxVQUFVLEtBQUssR0FBRyxFQUFFLENBQUM7Z0JBQzdELFFBQVEsQ0FBQyxNQUFNLEVBQUUsQ0FBQztnQkFDbEIsTUFBTSxDQUFDLElBQUksS0FBSyxDQUFDLEdBQUcsR0FBRyxhQUFhLFFBQVEsQ0FBQyxVQUFVLEVBQUUsQ0FBQyxDQUFDLENBQUM7Z0JBQzVELE9BQU87WUFDWCxDQUFDO1lBQ0QsTUFBTSxHQUFHLEdBQUcsWUFBRSxDQUFDLGlCQUFpQixDQUFDLFNBQVMsRUFBRSxLQUFLLENBQUMsQ0FBQyxDQUFDLEVBQUUsS0FBSyxFQUFFLElBQUksRUFBRSxLQUFLLEVBQUUsQ0FBQyxDQUFDLENBQUMsRUFBRSxLQUFLLEVBQUUsR0FBRyxFQUFFLENBQUMsQ0FBQztZQUM3RixRQUFRLENBQUMsSUFBSSxDQUFDLEdBQUcsQ0FBQyxDQUFDO1lBQ25CLEdBQUcsQ0FBQyxFQUFFLENBQUMsT0FBTyxFQUFFLE1BQU0sQ0FBQyxDQUFDO1lBQ3hCLFFBQVEsQ0FBQyxFQUFFLENBQUMsT0FBTyxFQUFFLE1BQU0sQ0FBQyxDQUFDO1lBQzdCLEdBQUcsQ0FBQyxFQUFFLENBQUMsUUFBUSxFQUFFLE9BQU8sQ0FBQyxDQUFDO1FBQzlCLENBQUMsQ0FBQyxDQUFDO1FBQ0gsT0FBTyxDQUFDLEVBQUUsQ0FBQyxPQUFPLEVBQUUsTUFBTSxDQUFDLENBQUM7SUFDaEMsQ0FBQyxDQUFDLENBQUM7QUFDUCxDQUFDO0FBRU0sS0FBSyxVQUFVLGNBQWMsQ0FBQyxRQUFnQixFQUFFLFVBQWtCO0lBQ3JFLE1BQU0sS0FBSyxHQUFHLGNBQUksQ0FBQyxJQUFJLENBQUMsVUFBVSxFQUFFLFFBQVEsQ0FBQyxDQUFDO0lBQzlDLElBQUksWUFBRSxDQUFDLFVBQVUsQ0FBQyxLQUFLLENBQUMsSUFBSSxZQUFFLENBQUMsUUFBUSxDQUFDLEtBQUssQ0FBQyxDQUFDLElBQUksSUFBSSxVQUFVLEVBQUUsQ0FBQztRQUNoRSxPQUFPLEtBQUssQ0FBQztJQUNqQixDQUFDO0lBQ0QsTUFBTSxTQUFTLEdBQUcsY0FBSSxDQUFDLElBQUksQ0FBQyxZQUFFLENBQUMsTUFBTSxFQUFFLEVBQUUsUUFBUSxDQUFDLENBQUM7SUFDbkQsSUFBSSxXQUFXLEdBQUcsQ0FBQyxDQUFDO0lBQ3BCLElBQUksWUFBRSxDQUFDLFVBQVUsQ0FBQyxTQUFTLENBQUMsRUFBRSxDQUFDO1FBQzNCLFdBQVcsR0FBRyxZQUFFLENBQUMsUUFBUSxDQUFDLFNBQVMsQ0FBQyxDQUFDLElBQUksQ0FBQztJQUM5QyxDQUFDO0lBQ0QsSUFBSSxXQUFXLEdBQUcsVUFBVSxFQUFFLENBQUM7UUFDM0IsTUFBTSxTQUFTLEdBQUcsQ0FBQyxDQUFDLFVBQVUsR0FBRyxXQUFXLENBQUMsR0FBRyxHQUFHLENBQUMsQ0FBQyxPQUFPLENBQUMsQ0FBQyxDQUFDLENBQUM7UUFDaEUsT0FBTyxDQUFDLEdBQUcsQ0FBQyxlQUFlLFNBQVMsU0FBUyxRQUFRLFNBQVMsV0FBVyxPQUFPLFNBQVMsRUFBRSxDQUFDLENBQUM7UUFDN0YsTUFBTSxZQUFZLENBQUMsUUFBUSxFQUFFLFdBQVcsRUFBRSxVQUFVLEVBQUUsU0FBUyxDQUFDLENBQUM7SUFDckUsQ0FBQztJQUNELE9BQU8sU0FBUyxDQUFDO0FBQ3JCLENBQUM7QUFoQkQsd0NBZ0JDIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IGZzIGZyb20gXCJmc1wiO1xuaW1wb3J0IG9zIGZyb20gXCJvc1wiO1xuaW1wb3J0IHBhdGggZnJvbSBcInBhdGhcIjtcbmltcG9ydCBodHRwIGZyb20gXCJodHRwXCI7XG5cbi8vIFJlc29sdmVzIGEgZmFjZS1lbWJlZGRpbmcgdGVzdCBmaWxlIHRvIGEgbG9jYWwgcGF0aCB0aGF0IGhvbGRzIGF0IGxlYXN0IHRoZSByZXF1ZXN0ZWQgbnVtYmVyIG9mIGJ5dGVzLiBPblxuLy8gdGhlIG1hY2hpbmUgdGhhdCBvd25zIHRoZSBkYXRhIGl0IGp1c3QgdXNlcyB0aGUgb3JpZ2luYWwgZmlsZS4gQW55d2hlcmUgZWxzZSBpdCBkb3dubG9hZHMgdGhlIG1pc3NpbmcgcHJlZml4XG4vLyBmcm9tIHRoZSBmYWNlRnJhbWVzU2VydmVyIG92ZXIgYSByYW5nZSByZXF1ZXN0IGFuZCBjYWNoZXMgaXQgaW4gdGhlIHRlbXAgZGlyLCBzbyByZS1ydW5zIG9ubHkgZmV0Y2ggd2hhdFxuLy8gdGhleSBoYXZlbid0IGFscmVhZHkuIFBvaW50IGl0IGF0IGEgZGlmZmVyZW50IHNlcnZlciB3aXRoIEZBQ0VGUkFNRVNfVVJMLlxuY29uc3QgU09VUkNFX0RJUiA9IFwiL3Jvb3QvY2xhdWRlLXdvcmsvZmFjZS1lbWJlZGRpbmdzXCI7XG5jb25zdCBTRVJWRVJfQkFTRSA9IHByb2Nlc3MuZW52LkZBQ0VGUkFNRVNfVVJMIHx8IFwiaHR0cDovLzY1LjEwOS45My4xMTM6ODc5OVwiO1xuXG5mdW5jdGlvbiBkb3dubG9hZEludG8oZmlsZU5hbWU6IHN0cmluZywgc3RhcnQ6IG51bWJlciwgZW5kRXhjbHVzaXZlOiBudW1iZXIsIGNhY2hlUGF0aDogc3RyaW5nKTogUHJvbWlzZTx2b2lkPiB7XG4gICAgcmV0dXJuIG5ldyBQcm9taXNlKChyZXNvbHZlLCByZWplY3QpID0+IHtcbiAgICAgICAgY29uc3QgdXJsID0gYCR7U0VSVkVSX0JBU0V9LyR7ZmlsZU5hbWV9YDtcbiAgICAgICAgY29uc3Qgb3B0aW9ucyA9IHsgaGVhZGVyczogeyBSYW5nZTogYGJ5dGVzPSR7c3RhcnR9LSR7ZW5kRXhjbHVzaXZlIC0gMX1gIH0gfTtcbiAgICAgICAgY29uc3QgcmVxdWVzdCA9IGh0dHAuZ2V0KHVybCwgb3B0aW9ucywgcmVzcG9uc2UgPT4ge1xuICAgICAgICAgICAgaWYgKHJlc3BvbnNlLnN0YXR1c0NvZGUgIT09IDIwNiAmJiByZXNwb25zZS5zdGF0dXNDb2RlICE9PSAyMDApIHtcbiAgICAgICAgICAgICAgICByZXNwb25zZS5yZXN1bWUoKTtcbiAgICAgICAgICAgICAgICByZWplY3QobmV3IEVycm9yKGAke3VybH0gcmV0dXJuZWQgJHtyZXNwb25zZS5zdGF0dXNDb2RlfWApKTtcbiAgICAgICAgICAgICAgICByZXR1cm47XG4gICAgICAgICAgICB9XG4gICAgICAgICAgICBjb25zdCBvdXQgPSBmcy5jcmVhdGVXcml0ZVN0cmVhbShjYWNoZVBhdGgsIHN0YXJ0ID8geyBmbGFnczogXCJyK1wiLCBzdGFydCB9IDogeyBmbGFnczogXCJ3XCIgfSk7XG4gICAgICAgICAgICByZXNwb25zZS5waXBlKG91dCk7XG4gICAgICAgICAgICBvdXQub24oXCJlcnJvclwiLCByZWplY3QpO1xuICAgICAgICAgICAgcmVzcG9uc2Uub24oXCJlcnJvclwiLCByZWplY3QpO1xuICAgICAgICAgICAgb3V0Lm9uKFwiZmluaXNoXCIsIHJlc29sdmUpO1xuICAgICAgICB9KTtcbiAgICAgICAgcmVxdWVzdC5vbihcImVycm9yXCIsIHJlamVjdCk7XG4gICAgfSk7XG59XG5cbmV4cG9ydCBhc3luYyBmdW5jdGlvbiBlbnN1cmVGYWNlRGF0YShmaWxlTmFtZTogc3RyaW5nLCBieXRlTGVuZ3RoOiBudW1iZXIpOiBQcm9taXNlPHN0cmluZz4ge1xuICAgIGNvbnN0IGxvY2FsID0gcGF0aC5qb2luKFNPVVJDRV9ESVIsIGZpbGVOYW1lKTtcbiAgICBpZiAoZnMuZXhpc3RzU3luYyhsb2NhbCkgJiYgZnMuc3RhdFN5bmMobG9jYWwpLnNpemUgPj0gYnl0ZUxlbmd0aCkge1xuICAgICAgICByZXR1cm4gbG9jYWw7XG4gICAgfVxuICAgIGNvbnN0IGNhY2hlUGF0aCA9IHBhdGguam9pbihvcy50bXBkaXIoKSwgZmlsZU5hbWUpO1xuICAgIGxldCBjYWNoZWRCeXRlcyA9IDA7XG4gICAgaWYgKGZzLmV4aXN0c1N5bmMoY2FjaGVQYXRoKSkge1xuICAgICAgICBjYWNoZWRCeXRlcyA9IGZzLnN0YXRTeW5jKGNhY2hlUGF0aCkuc2l6ZTtcbiAgICB9XG4gICAgaWYgKGNhY2hlZEJ5dGVzIDwgYnl0ZUxlbmd0aCkge1xuICAgICAgICBjb25zdCBtZWdhYnl0ZXMgPSAoKGJ5dGVMZW5ndGggLSBjYWNoZWRCeXRlcykgLyAxZTYpLnRvRml4ZWQoMCk7XG4gICAgICAgIGNvbnNvbGUubG9nKGBkb3dubG9hZGluZyAke21lZ2FieXRlc31NQiBvZiAke2ZpbGVOYW1lfSBmcm9tICR7U0VSVkVSX0JBU0V9IC0+ICR7Y2FjaGVQYXRofWApO1xuICAgICAgICBhd2FpdCBkb3dubG9hZEludG8oZmlsZU5hbWUsIGNhY2hlZEJ5dGVzLCBieXRlTGVuZ3RoLCBjYWNoZVBhdGgpO1xuICAgIH1cbiAgICByZXR1cm4gY2FjaGVQYXRoO1xufVxuIl19
+ /* _JS_SOURCE_HASH = "623e4d719ca42b7e83579fd05b7d111f3158958917d536b1ac30e1e3373ad1ce"; */

package/storage/embeddingBench.d.ts

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