sliftutils 1.7.12 → 1.7.14

package/misc/https/hostServer.d.ts

@@ -6,6 +6,13 @@ export type HostServerConfig = {
     setDNSRecord?: boolean;
     publicIp?: string;
     allowHostnames?: string[];
+    /** Deploy takeover: when the port is busy (the previous version still holds it), mount on a random alternate port instead, and keep trying to take the real port - once it frees, a raw TCP relay on the real port forwards to our listener (SocketFunction can only mount once per process). Only pass this when a deploy timeline actually exists; without it a busy port is a real misconfiguration and must throw. */
+    portFallback?: {
+        /** Delay until the next main-port acquisition attempt (tightened around the predecessor's scheduled death) */
+        getAcquireDelay: () => number;
+        /** Reports every port we become reachable on (the alternate at mount, the main port once relayed) */
+        onListening: (port: number, isMainPort: boolean) => void;
+    };
 };
 /** Hosts a SocketFunction server on a real domain, with an automatically created and renewed Let's Encrypt HTTPS certificate (cached in the home folder, shared between processes on the machine). Expose your controllers (and any RequireController setup) before calling this. Returns the mounted nodeId. */
 export declare function hostServer(config: HostServerConfig): Promise<string>;

package/misc/https/hostServer.ts

@@ -1,5 +1,6 @@
 import os from "os";
 import fs from "fs";
+import net from "net";
 import { SocketFunction } from "socket-function/SocketFunction";
 import { timeInMinute } from "socket-function/src/misc";
 import { delay } from "socket-function/src/batching";
@@ -13,6 +14,10 @@ import { setRecord } from "./dns";
 const RENEW_THRESHOLD_MIN = 0.4;
 const RENEW_THRESHOLD_MAX = 0.6;
 const CERT_CHECK_INTERVAL = timeInMinute * 15;
+// Alternate ports (deploy takeover) are picked randomly from [port + OFFSET, port + OFFSET + RANGE)
+const ALT_PORT_OFFSET = 1000;
+const ALT_PORT_RANGE = 1000;
+const ALT_PORT_ATTEMPTS = 10;
 
 // One threshold per process, so a process is consistently early or late relative to its siblings
 const renewThreshold = RENEW_THRESHOLD_MIN + Math.random() * (RENEW_THRESHOLD_MAX - RENEW_THRESHOLD_MIN);
@@ -27,6 +32,13 @@ export type HostServerConfig = {
     setDNSRecord?: boolean;
     publicIp?: string;
     allowHostnames?: string[];
+    /** Deploy takeover: when the port is busy (the previous version still holds it), mount on a random alternate port instead, and keep trying to take the real port - once it frees, a raw TCP relay on the real port forwards to our listener (SocketFunction can only mount once per process). Only pass this when a deploy timeline actually exists; without it a busy port is a real misconfiguration and must throw. */
+    portFallback?: {
+        /** Delay until the next main-port acquisition attempt (tightened around the predecessor's scheduled death) */
+        getAcquireDelay: () => number;
+        /** Reports every port we become reachable on (the alternate at mount, the main port once relayed) */
+        onListening: (port: number, isMainPort: boolean) => void;
+    };
 };
 
 /** Hosts a SocketFunction server on a real domain, with an automatically created and renewed Let's Encrypt HTTPS certificate (cached in the home folder, shared between processes on the machine). Expose your controllers (and any RequireController setup) before calling this. Returns the mounted nodeId. */
@@ -50,30 +62,87 @@ export async function hostServer(config: HostServerConfig): Promise<string> {
         }
     });
 
-    let nodeId = await SocketFunction.mount({
-        public: true,
-        autoForwardPort: true,
-        port,
-        ...getThreadKeyCert(rootDomain),
-        SNICerts: {
-            [domain]: callback => {
-                callback(keyCert);
-                certListeners.push(callback);
+    let mountOn = async (mountPort: number) => {
+        return await SocketFunction.mount({
+            public: true,
+            autoForwardPort: true,
+            port: mountPort,
+            ...getThreadKeyCert(rootDomain),
+            SNICerts: {
+                [domain]: callback => {
+                    callback(keyCert);
+                    certListeners.push(callback);
+                },
+                [getOwnMachineId(rootDomain) + "." + rootDomain]: async callback => {
+                    let threadCert = await getThreadKeyCert(rootDomain);
+                    callback({
+                        key: threadCert.key,
+                        cert: threadCert.cert,
+                    });
+                },
             },
-            [getOwnMachineId(rootDomain) + "." + rootDomain]: async callback => {
-                let threadCert = await getThreadKeyCert(rootDomain);
-                callback({
-                    key: threadCert.key,
-                    cert: threadCert.cert,
-                });
-            },
-        },
-        allowHostnames: config.allowHostnames,
-    });
-    console.log(magenta(`Hosting https://${domain}:${port} (nodeId ${nodeId})`));
+            allowHostnames: config.allowHostnames,
+        });
+    };
+
+    let servingPort = port;
+    let nodeId: string;
+    try {
+        nodeId = await mountOn(port);
+    } catch (e) {
+        let fallback = config.portFallback;
+        if (!fallback || !String((e as Error).stack ?? e).includes("EADDRINUSE")) throw e;
+        // Deploy takeover: the previous version still holds the port. Serve on an alternate port,
+        // and relay the real port to ourselves once the predecessor dies and frees it.
+        let mounted: string | undefined;
+        for (let attempt = 0; attempt < ALT_PORT_ATTEMPTS && !mounted; attempt++) {
+            let altPort = port + ALT_PORT_OFFSET + Math.floor(Math.random() * ALT_PORT_RANGE);
+            try {
+                mounted = await mountOn(altPort);
+                servingPort = altPort;
+            } catch (e2) {
+                if (!String((e2 as Error).stack ?? e2).includes("EADDRINUSE")) throw e2;
+            }
+        }
+        if (!mounted) throw e;
+        nodeId = mounted;
+        console.log(magenta(`Port ${port} is held by our predecessor; serving on alternate port ${servingPort} until it frees`));
+        void runMainPortAcquireLoop(domain, port, servingPort, fallback);
+    }
+    config.portFallback?.onListening(servingPort, servingPort === port);
+    console.log(magenta(`Hosting https://${domain}:${servingPort} (nodeId ${nodeId})`));
     return nodeId;
 }
 
+// SocketFunction can only mount once per process, so "taking over" the main port is a raw TCP
+// relay forwarding to our real listener - TLS/SNI passes straight through, and clients address
+// servers by ip domain (wildcard negotiation), so the extra hop is invisible.
+async function runMainPortAcquireLoop(domain: string, mainPort: number, servingPort: number, fallback: NonNullable<HostServerConfig["portFallback"]>): Promise<void> {
+    while (true) {
+        await delay(fallback.getAcquireDelay());
+        let acquired = await new Promise<boolean>(resolve => {
+            let relay = net.createServer(client => {
+                let upstream = net.connect({ host: "127.0.0.1", port: servingPort });
+                client.pipe(upstream);
+                upstream.pipe(client);
+                let cleanup = () => {
+                    client.destroy();
+                    upstream.destroy();
+                };
+                client.on("error", cleanup);
+                upstream.on("error", cleanup);
+            });
+            relay.once("error", () => resolve(false));
+            relay.listen(mainPort, () => resolve(true));
+        });
+        if (acquired) {
+            console.log(magenta(`Acquired main port ${mainPort} for https://${domain} (relaying to our listener on ${servingPort})`));
+            fallback.onListening(mainPort, true);
+            return;
+        }
+    }
+}
+
 function getCertDiskPath(domain: string) {
     return os.homedir() + `/httpscert_${domain}.json`;
 }

package/misc/openrouter.ts

@@ -1,5 +1,6 @@
 import { parseYAML } from "./yaml";
 import { retryFunctional } from "socket-function/src/batching";
+import { httpsRequest } from "socket-function/src/https";
 
 const CANNOT_RETRY = "(CANNOT RETRY)";
 import { formatNumber } from "socket-function/src/formatting/format";
@@ -110,13 +111,11 @@ export async function openRouterCallBase(config: {
 
     try {
         return await retryFunctional(async () => {
-            let response = await fetch("https://openrouter.ai/api/v1/chat/completions", {
-                method: "POST",
-                headers: {
-                    "Authorization": `Bearer ${openrouterKey}`,
-                    "Content-Type": "application/json",
-                },
-                body: JSON.stringify({
+            // httpsRequest routes through socket-function's DNS cache and throws on any non-2xx (with the
+            //  response body in the message), which retryFunctional then retries.
+            let responseBody = await httpsRequest(
+                "https://openrouter.ai/api/v1/chat/completions",
+                Buffer.from(JSON.stringify({
                     model,
                     messages,
                     provider: {
@@ -124,14 +123,18 @@ export async function openRouterCallBase(config: {
                     },
                     usage: { include: true },
                     ...options,
-                }),
-            });
+                })),
+                "POST",
+                false,
+                {
+                    headers: {
+                        "Authorization": `Bearer ${openrouterKey}`,
+                        "Content-Type": "application/json",
+                    },
+                }
+            );
 
-            if (response.status !== 200) {
-                let responseText = await response.text();
-                throw new Error(`Failed to call OpenRouter: ${response.status} ${response.statusText} ${responseText}`);
-            }
-            let responseObj = await response.json() as {
+            let responseObj = JSON.parse(responseBody.toString()) as {
                 usage: {
                     cost: number;
                 };

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "sliftutils",
-    "version": "1.7.12",
+    "version": "1.7.14",
     "main": "index.js",
     "license": "MIT",
     "files": [
@@ -57,7 +57,7 @@
         "node-forge": "https://github.com/sliftist/forge#e618181b469b07bdc70b968b0391beb8ef5fecd6",
         "preact-old-types": "^10.28.1",
         "shell-quote": "^1.8.3",
-        "socket-function": "^1.2.16",
+        "socket-function": "^1.2.20",
         "typenode": "^6.6.1",
         "typesafecss": "*",
         "ws": "^8.18.3",

package/storage/ArchivesDisk.d.ts

@@ -20,7 +20,7 @@ export declare class ArchivesDisk implements IArchives {
     private filePath;
     set(key: string, data: Buffer, config?: {
         lastModified?: number;
-    }): Promise<void>;
+    }): Promise<string>;
     del(key: string): Promise<void>;
     get(key: string, config?: {
         range?: {

package/storage/ArchivesDisk.ts

@@ -144,7 +144,7 @@ export class ArchivesDisk implements IArchives {
         return result;
     }
 
-    public async set(key: string, data: Buffer, config?: { lastModified?: number }): Promise<void> {
+    public async set(key: string, data: Buffer, config?: { lastModified?: number }): Promise<string> {
         await this.init();
         let lastModified = config?.lastModified;
         if (lastModified) {
@@ -165,6 +165,7 @@ export class ArchivesDisk implements IArchives {
                 await handle.utimes(new Date(lastModified), new Date(lastModified));
             }
         });
+        return key;
     }
 
     public async del(key: string): Promise<void> {

package/storage/IArchives.d.ts

@@ -126,10 +126,14 @@ export interface IArchives {
      * lastModified stamps the write with that last-write time instead of now. If it is OLDER than
      * the file's current last-write time the write no-ops (so delayed / synchronized writes can
      * never clobber newer data). Times more than 15 minutes in the future are rejected.
+     *
+     * Returns the full key actually written - identical to fileName, EXCEPT for keys containing
+     * VARIABLE_SHARD, where the shard value is materialized into the key (picked by shard latency,
+     * see ArchivesChain) and the caller needs the returned key to ever read the value back.
      */
     set(fileName: string, data: Buffer, config?: {
         lastModified?: number;
-    }): Promise<void>;
+    }): Promise<string>;
     del(fileName: string): Promise<void>;
     /** Streams a file too large to hold in memory. getNextData returns undefined when done. */
     setLargeFile(config: {

package/storage/IArchives.ts

@@ -197,8 +197,12 @@ export interface IArchives {
      * lastModified stamps the write with that last-write time instead of now. If it is OLDER than
      * the file's current last-write time the write no-ops (so delayed / synchronized writes can
      * never clobber newer data). Times more than 15 minutes in the future are rejected.
+     *
+     * Returns the full key actually written - identical to fileName, EXCEPT for keys containing
+     * VARIABLE_SHARD, where the shard value is materialized into the key (picked by shard latency,
+     * see ArchivesChain) and the caller needs the returned key to ever read the value back.
      */
-    set(fileName: string, data: Buffer, config?: { lastModified?: number }): Promise<void>;
+    set(fileName: string, data: Buffer, config?: { lastModified?: number }): Promise<string>;
     del(fileName: string): Promise<void>;
     /** Streams a file too large to hold in memory. getNextData returns undefined when done. */
     setLargeFile(config: { path: string; getNextData(): Promise<Buffer | undefined> }): Promise<void>;

package/storage/backblaze.d.ts

@@ -41,7 +41,7 @@ export declare class ArchivesBackblaze implements IArchives {
     hasWriteAccess(): Promise<boolean>;
     set(fileName: string, data: Buffer, config?: {
         lastModified?: number;
-    }): Promise<void>;
+    }): Promise<string>;
     del(fileName: string): Promise<void>;
     setLargeFile(config: {
         path: string;

package/storage/backblaze.ts

@@ -661,13 +661,13 @@ export class ArchivesBackblaze implements IArchives {
             return false;
         }
     }
-    public async set(fileName: string, data: Buffer, config?: { lastModified?: number }): Promise<void> {
+    public async set(fileName: string, data: Buffer, config?: { lastModified?: number }): Promise<string> {
         if (config?.lastModified) {
             assertValidLastModified(config.lastModified);
             let existing = await this.getInfo(fileName);
             // An older write never overwrites a newer one (see IArchives.set). B2 stamps its own
             // upload time, so the exact lastModified is not preserved on the stored file.
-            if (existing && config.lastModified < existing.writeTime) return;
+            if (existing && config.lastModified < existing.writeTime) return fileName;
         }
         this.log(`backblaze upload (${formatNumber(data.length)}B) ${fileName}`);
         let f = fileName;
@@ -685,7 +685,7 @@ export class ArchivesBackblaze implements IArchives {
             let exists = await this.getInfo(fileName);
             console.warn(`File ${fileName}/${f} was uploaded, but could not be found afterwards. Hopefully it was just deleted, very quickly? If backblaze is taking too long for files to propagate, then we might run into issues with the database atomicity.`);
         }
-
+        return fileName;
     }
     public async del(fileName: string): Promise<void> {
         this.log(`backblaze delete ${fileName}`);
@@ -743,17 +743,20 @@ export class ArchivesBackblaze implements IArchives {
             if (!data?.length) return;
             // Backblaze disallows overly small files
             if (data.length < MIN_CHUNK_SIZE) {
-                return await this.set(fileName, data);
+                await this.set(fileName, data);
+                return;
             }
             // Backblaze disallows less than 2 chunks
             let secondData = await getNextData();
             if (!secondData?.length) {
-                return await this.set(fileName, data);
+                await this.set(fileName, data);
+                return;
             }
             // ALSO, if there are two chunks, but one is too small, combine it. This helps allow us never
             //  send small chunks.
             if (secondData.length < MIN_CHUNK_SIZE) {
-                return await this.set(fileName, Buffer.concat([data, secondData]));
+                await this.set(fileName, Buffer.concat([data, secondData]));
+                return;
             }
             this.log(`Uploading large file ${config.path}`);
             dataQueue.unshift(data, secondData);

package/storage/dist/embeddingFormats.ts.cache

@@ -1,4 +1,4 @@
-"use strict";
+"use strict"; var console = (function shimConsole() {             let baseConsole = globalThis.console;             if (typeof window !== "undefined")                 return baseConsole;             let name = __filename.replaceAll("\\", "/").split("/").pop();             let dirName = __dirname.replaceAll("\\", "/").split("/").pop();             let context = {                 __FILE__: __filename,                 __DIR__: __dirname,                 __NAME__: name,                 __DIRNAME__: dirName             };             let newConsole = {                 ...baseConsole             };             for (let shim of ["log", "info", "warn", "error"]) {                 newConsole[shim] = (...args) => {                     args.push(context);                     baseConsole[shim](...args);                 };             }             newConsole.__context = context;             return newConsole;         })(); "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");
@@ -337,4 +337,4 @@ function hashEmbedding(stored) {
 }
 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"; */
+ /* _JS_SOURCE_HASH = "667dde839f46c7c3f10ea92a2c74c5c2c98824118f56e021de748b660953952e"; */

package/storage/proxydatabase/dist/Database.ts.cache

@@ -1,4 +1,4 @@
-"use strict";
+"use strict"; var console = (function shimConsole() {             let baseConsole = globalThis.console;             if (typeof window !== "undefined")                 return baseConsole;             let name = __filename.replaceAll("\\", "/").split("/").pop();             let dirName = __dirname.replaceAll("\\", "/").split("/").pop();             let context = {                 __FILE__: __filename,                 __DIR__: __dirname,                 __NAME__: name,                 __DIRNAME__: dirName             };             let newConsole = {                 ...baseConsole             };             for (let shim of ["log", "info", "warn", "error"]) {                 newConsole[shim] = (...args) => {                     args.push(context);                     baseConsole[shim](...args);                 };             }             newConsole.__context = context;             return newConsole;         })(); "use strict";
 Object.defineProperty(exports, "__esModule", { value: true , configurable: true});
 //exports.namespaceDatabase = void 0;
 function namespaceDatabase(database, into) {
@@ -10,4 +10,4 @@ function namespaceDatabase(database, into) {
 }
 exports.namespaceDatabase = namespaceDatabase;
 //# sourceMappingURL=data:application/json;base64,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
- /* _JS_SOURCE_HASH = "93a620d26b6a59665b5f7dab689d9739693a4990e1c4781abcddc6cda24bda11"; */
+ /* _JS_SOURCE_HASH = "a66e8405ab4b7b49928062632c915e26904e833e3d97a1f7e7f635613bb15809"; */