querysub 0.433.0 → 0.437.0

package/src/TestController.ts

@@ -1,35 +1,35 @@
-module.allowclient = true;
-
-import debugbreak from "debugbreak";
-import { SocketFunction } from "socket-function/SocketFunction";
-import { IdentityController_getReconnectNodeId } from "./-c-identity/IdentityController";
-
-import { requiresNetworkTrustHook } from "./-d-trust/NetworkTrust2";
-import os from "os";
-
-class TestControllerBase {
-    async test() {
-        const caller = SocketFunction.getCaller();
-        console.log(`test called from ${caller.nodeId}`);
-        return {
-            nodeId: caller?.nodeId,
-            reconnectNodeId: IdentityController_getReconnectNodeId(caller),
-        };
-    }
-    async getProcessId() {
-        return process.pid;
-    }
-}
-
-
-export const TestController = SocketFunction.register(
-    "TestController-fbdd0aa9-a8ed-4d8c-80a8-8ab2f57c99db",
-    new TestControllerBase(),
-    () => ({
-        getProcessId: {},
-        test: {},
-    }),
-    () => ({
-        hooks: [requiresNetworkTrustHook],
-    })
+module.allowclient = true;
+
+import debugbreak from "debugbreak";
+import { SocketFunction } from "socket-function/SocketFunction";
+import { IdentityController_getReconnectNodeId } from "./-c-identity/IdentityController";
+
+import { requiresNetworkTrustHook } from "./-d-trust/NetworkTrust2";
+import os from "os";
+
+class TestControllerBase {
+    async test() {
+        const caller = SocketFunction.getCaller();
+        console.log(`test called from ${caller.nodeId}`);
+        return {
+            nodeId: caller?.nodeId,
+            reconnectNodeId: IdentityController_getReconnectNodeId(caller),
+        };
+    }
+    async getProcessId() {
+        return process.pid;
+    }
+}
+
+
+export const TestController = SocketFunction.register(
+    "TestController-fbdd0aa9-a8ed-4d8c-80a8-8ab2f57c99db",
+    new TestControllerBase(),
+    () => ({
+        getProcessId: {},
+        test: {},
+    }),
+    () => ({
+        hooks: [requiresNetworkTrustHook],
+    })
 );

package/src/bits.ts

@@ -1,105 +1,105 @@
-
-/** Subtracts the smallest possible value from a number (a double). This makes it possible to convert an exclusive range end
- *      to an inclusive range end, which is sometimes required (as in, < x is the same as <= minusEpsilon(x)).
- */
-export function minusEpsilon(value: number) {
-    let high = getHighUint32(value);
-    let low = getLowUint32(value);
-
-    if (low === 0) {
-        low = 2 ** 32 - 1;
-        high--;
-    } else {
-        low--;
-    }
-
-    return setLowHighUint32(low, high);
-}
-const maxUint32 = 2 ** 32 - 1;
-export function addEpsilons(value: number, count: number) {
-    let high = getHighUint32(value);
-    let low = getLowUint32(value);
-
-    low += count;
-    if (low < 0) {
-        low += maxUint32;
-        high++;
-    } else if (low > maxUint32) {
-        low -= maxUint32;
-        high--;
-    }
-
-    return setLowHighUint32(low, high);
-}
-
-let conversionBuffer = new Float64Array(1);
-let conversionUint8Buffer = new Uint8Array(conversionBuffer.buffer);
-let conversionUint32Buffer = new Uint32Array(conversionBuffer.buffer);
-export function getHighUint32(num: number): number {
-    conversionBuffer[0] = num;
-    return conversionUint32Buffer[1];
-}
-export function getLowUint32(num: number): number {
-    conversionBuffer[0] = num;
-    return conversionUint32Buffer[0];
-}
-
-/** IMPORTANT! Beware of comparisons with 64 bit numbers. getFloat64_fromBytes(4294136438, 168) !== getFloat64_fromBytes(4294136438, 168).
- *      USE is64BitEqual instead, OR, ensure the 2 highest bits are always 0.
- */
-export function setLowHighUint32(low: number, high: number): number {
-    conversionUint32Buffer[0] = low;
-    conversionUint32Buffer[1] = high;
-    return conversionBuffer[0];
-}
-
-/** Adds protection against NaN values, changing the result if it would be NaN. This is because NaN values will compare to be not equal even if they are equal in certain cases, and in other cases, they'll always be equal, even if their bits are not equal.
-    - This means this is not a reversible operation. However, in a lot of cases, that doesn't matter. 
-*/
-export function setLowHighUint32Safe(low: number, high: number): number {
-    conversionUint32Buffer[0] = low;
-    // Prevent NaN by not setting all the exponent bits to 1
-    conversionUint32Buffer[1] = high & 0xBFFFFFFF;
-    return conversionBuffer[0];
-}
-
-// NOTE: Not reversible, see setLowHighUint32Safe
-export function xor64BitsSafe(a: number, b: number): number {
-    let high = getHighUint32(a);
-    let low = getLowUint32(a);
-    let high2 = getHighUint32(b);
-    let low2 = getLowUint32(b);
-    return setLowHighUint32Safe(low ^ low2, high ^ high2);
-}
-
-// Gets bits that can be stored in a number. Specifically, the first 62 bits,
-//  as 64 bits will not compare correctly when treated as a double.
-export function getShortNumber(buffer: Buffer): number {
-    let high = buffer.readUInt32BE(0) & 0x3FFFFFFF;
-    let low = buffer.readUInt32BE(4);
-    return setLowHighUint32(low, high);
-}
-/* Returns a number between 0 and 2**48 */
-export function getBufferInt(buffer: Buffer): number {
-    let num = 0;
-    for (let i = 0; i < Math.min(buffer.length, 6); i++) {
-        num = num * 256 + buffer[i];
-    }
-    return num;
-}
-const intMax = 2 ** 48;
-/** Returns a number between 0 (inclusive) and 1 (exclusive) */
-export function getBufferFraction(buffer: Buffer): number {
-    let int = getBufferInt(buffer);
-    return int / intMax;
-}
-
-/*
-export function numberToBase64(num: number): string {
-    conversionBuffer[0] = num;
-    return Buffer.from(conversionBuffer.buffer).toString("base64");
-}
-export function numberFromBase64(base64: string) {
-    return new Float64Array(Buffer.from(base64, "base64"))[0];
-}
+
+/** Subtracts the smallest possible value from a number (a double). This makes it possible to convert an exclusive range end
+ *      to an inclusive range end, which is sometimes required (as in, < x is the same as <= minusEpsilon(x)).
+ */
+export function minusEpsilon(value: number) {
+    let high = getHighUint32(value);
+    let low = getLowUint32(value);
+
+    if (low === 0) {
+        low = 2 ** 32 - 1;
+        high--;
+    } else {
+        low--;
+    }
+
+    return setLowHighUint32(low, high);
+}
+const maxUint32 = 2 ** 32 - 1;
+export function addEpsilons(value: number, count: number) {
+    let high = getHighUint32(value);
+    let low = getLowUint32(value);
+
+    low += count;
+    if (low < 0) {
+        low += maxUint32;
+        high++;
+    } else if (low > maxUint32) {
+        low -= maxUint32;
+        high--;
+    }
+
+    return setLowHighUint32(low, high);
+}
+
+let conversionBuffer = new Float64Array(1);
+let conversionUint8Buffer = new Uint8Array(conversionBuffer.buffer);
+let conversionUint32Buffer = new Uint32Array(conversionBuffer.buffer);
+export function getHighUint32(num: number): number {
+    conversionBuffer[0] = num;
+    return conversionUint32Buffer[1];
+}
+export function getLowUint32(num: number): number {
+    conversionBuffer[0] = num;
+    return conversionUint32Buffer[0];
+}
+
+/** IMPORTANT! Beware of comparisons with 64 bit numbers. getFloat64_fromBytes(4294136438, 168) !== getFloat64_fromBytes(4294136438, 168).
+ *      USE is64BitEqual instead, OR, ensure the 2 highest bits are always 0.
+ */
+export function setLowHighUint32(low: number, high: number): number {
+    conversionUint32Buffer[0] = low;
+    conversionUint32Buffer[1] = high;
+    return conversionBuffer[0];
+}
+
+/** Adds protection against NaN values, changing the result if it would be NaN. This is because NaN values will compare to be not equal even if they are equal in certain cases, and in other cases, they'll always be equal, even if their bits are not equal.
+    - This means this is not a reversible operation. However, in a lot of cases, that doesn't matter. 
+*/
+export function setLowHighUint32Safe(low: number, high: number): number {
+    conversionUint32Buffer[0] = low;
+    // Prevent NaN by not setting all the exponent bits to 1
+    conversionUint32Buffer[1] = high & 0xBFFFFFFF;
+    return conversionBuffer[0];
+}
+
+// NOTE: Not reversible, see setLowHighUint32Safe
+export function xor64BitsSafe(a: number, b: number): number {
+    let high = getHighUint32(a);
+    let low = getLowUint32(a);
+    let high2 = getHighUint32(b);
+    let low2 = getLowUint32(b);
+    return setLowHighUint32Safe(low ^ low2, high ^ high2);
+}
+
+// Gets bits that can be stored in a number. Specifically, the first 62 bits,
+//  as 64 bits will not compare correctly when treated as a double.
+export function getShortNumber(buffer: Buffer): number {
+    let high = buffer.readUInt32BE(0) & 0x3FFFFFFF;
+    let low = buffer.readUInt32BE(4);
+    return setLowHighUint32(low, high);
+}
+/* Returns a number between 0 and 2**48 */
+export function getBufferInt(buffer: Buffer): number {
+    let num = 0;
+    for (let i = 0; i < Math.min(buffer.length, 6); i++) {
+        num = num * 256 + buffer[i];
+    }
+    return num;
+}
+const intMax = 2 ** 48;
+/** Returns a number between 0 (inclusive) and 1 (exclusive) */
+export function getBufferFraction(buffer: Buffer): number {
+    let int = getBufferInt(buffer);
+    return int / intMax;
+}
+
+/*
+export function numberToBase64(num: number): string {
+    conversionBuffer[0] = num;
+    return Buffer.from(conversionBuffer.buffer).toString("base64");
+}
+export function numberFromBase64(base64: string) {
+    return new Float64Array(Buffer.from(base64, "base64"))[0];
+}
 */

package/src/buffers.ts

@@ -1,69 +1,69 @@
-import { canHaveChildren } from "socket-function/src/types";
-
-export type ArrayBufferViewTypes = Uint8Array | Int8Array | Uint16Array | Int16Array | Uint32Array | Int32Array | BigUint64Array | BigInt64Array | Float64Array | Float32Array | Uint8ClampedArray;
-export type BufferType = ArrayBuffer | SharedArrayBuffer | ArrayBufferViewTypes;
-
-export function cloneBuffer(data: Buffer): Buffer {
-    let newBuffer = Buffer.alloc(data.length);
-    data.copy(newBuffer);
-    return newBuffer;
-}
-
-
-export function asBuffer(data: BufferType): Buffer {
-    if (!data) return data;
-    if (data instanceof Buffer) return data;
-    if (!canHaveChildren(data)) return data as any;
-    if (!("buffer" in data) || !("byteOffset" in data) || !("byteLength" in data)) {
-        return Buffer.from(data);
-    }
-    let result = Buffer.from((data as any).buffer, (data as any).byteOffset, (data as any).byteLength);
-    return result;
-}
-export function asFloat64(data: Buffer): Float64Array {
-    if (data.length % 8 !== 0) {
-        throw new Error(`Data is not 8 count aligned, received length of ${data.length}`);
-    }
-    if (data.byteOffset % 8 !== 0) {
-        throw new Error(`Data is not 8 byte aligned, received offset of ${data.byteOffset}`);
-    }
-    return new Float64Array(data.buffer, data.byteOffset, Math.floor(data.length / 8));
-}
-export function asFloat32(data: Buffer): Float32Array {
-    if (data.length % 4 !== 0) {
-        throw new Error(`Data is not 4 byte aligned, received length of ${data.length}`);
-    }
-    if (data.byteOffset % 4 !== 0) {
-        throw new Error(`Data is not 4 byte aligned, received offset of ${data.byteOffset}`);
-    }
-    return new Float32Array(data.buffer, data.byteOffset, Math.floor(data.length / 4));
-}
-export function asUint32(data: Buffer): Uint32Array {
-    if (data.length % 4 !== 0) {
-        throw new Error(`Data is not 4 byte aligned, received length of ${data.length}`);
-    }
-    if (data.byteOffset % 4 !== 0) {
-        throw new Error(`Data is not 4 byte aligned, received offset of ${data.byteOffset}`);
-    }
-    return new Uint32Array(data.buffer, data.byteOffset, Math.floor(data.length / 4));
-}
-export function asInt32(data: Buffer): Int32Array {
-    if (data.length % 4 !== 0) {
-        throw new Error(`Data is not 4 byte aligned, received length of ${data.length}`);
-    }
-    if (data.byteOffset % 4 !== 0) {
-        throw new Error(`Data is not 4 byte aligned, received offset of ${data.byteOffset}`);
-    }
-    return new Int32Array(data.buffer, data.byteOffset, Math.floor(data.length / 4));
-}
-
-
-export function asFloat64MaybeCopy(data: Buffer) {
-    if (data.length % 8 !== 0) {
-        throw new Error(`Data is not 8 count aligned, received length of ${data.length}`);
-    }
-    if (data.byteOffset % 8 !== 0) {
-        return asFloat64(cloneBuffer(data));
-    }
-    return new Float64Array(data.buffer, data.byteOffset, Math.floor(data.length / 8));
-}
+import { canHaveChildren } from "socket-function/src/types";
+
+export type ArrayBufferViewTypes = Uint8Array | Int8Array | Uint16Array | Int16Array | Uint32Array | Int32Array | BigUint64Array | BigInt64Array | Float64Array | Float32Array | Uint8ClampedArray;
+export type BufferType = ArrayBuffer | SharedArrayBuffer | ArrayBufferViewTypes;
+
+export function cloneBuffer(data: Buffer): Buffer {
+    let newBuffer = Buffer.alloc(data.length);
+    data.copy(newBuffer);
+    return newBuffer;
+}
+
+
+export function asBuffer(data: BufferType): Buffer {
+    if (!data) return data;
+    if (data instanceof Buffer) return data;
+    if (!canHaveChildren(data)) return data as any;
+    if (!("buffer" in data) || !("byteOffset" in data) || !("byteLength" in data)) {
+        return Buffer.from(data);
+    }
+    let result = Buffer.from((data as any).buffer, (data as any).byteOffset, (data as any).byteLength);
+    return result;
+}
+export function asFloat64(data: Buffer): Float64Array {
+    if (data.length % 8 !== 0) {
+        throw new Error(`Data is not 8 count aligned, received length of ${data.length}`);
+    }
+    if (data.byteOffset % 8 !== 0) {
+        throw new Error(`Data is not 8 byte aligned, received offset of ${data.byteOffset}`);
+    }
+    return new Float64Array(data.buffer, data.byteOffset, Math.floor(data.length / 8));
+}
+export function asFloat32(data: Buffer): Float32Array {
+    if (data.length % 4 !== 0) {
+        throw new Error(`Data is not 4 byte aligned, received length of ${data.length}`);
+    }
+    if (data.byteOffset % 4 !== 0) {
+        throw new Error(`Data is not 4 byte aligned, received offset of ${data.byteOffset}`);
+    }
+    return new Float32Array(data.buffer, data.byteOffset, Math.floor(data.length / 4));
+}
+export function asUint32(data: Buffer): Uint32Array {
+    if (data.length % 4 !== 0) {
+        throw new Error(`Data is not 4 byte aligned, received length of ${data.length}`);
+    }
+    if (data.byteOffset % 4 !== 0) {
+        throw new Error(`Data is not 4 byte aligned, received offset of ${data.byteOffset}`);
+    }
+    return new Uint32Array(data.buffer, data.byteOffset, Math.floor(data.length / 4));
+}
+export function asInt32(data: Buffer): Int32Array {
+    if (data.length % 4 !== 0) {
+        throw new Error(`Data is not 4 byte aligned, received length of ${data.length}`);
+    }
+    if (data.byteOffset % 4 !== 0) {
+        throw new Error(`Data is not 4 byte aligned, received offset of ${data.byteOffset}`);
+    }
+    return new Int32Array(data.buffer, data.byteOffset, Math.floor(data.length / 4));
+}
+
+
+export function asFloat64MaybeCopy(data: Buffer) {
+    if (data.length % 8 !== 0) {
+        throw new Error(`Data is not 8 count aligned, received length of ${data.length}`);
+    }
+    if (data.byteOffset % 8 !== 0) {
+        return asFloat64(cloneBuffer(data));
+    }
+    return new Float64Array(data.buffer, data.byteOffset, Math.floor(data.length / 8));
+}

package/src/diagnostics/ActionsHistory.ts

@@ -1,58 +1,58 @@
-import { blue, green } from "socket-function/src/formatting/logColors";
-import { ClientWatcher } from "../1-path-client/pathValueClientWatcher";
-import { debugPathValuePath, PathValue } from "../0-path-value-core/pathValueCore";
-import { pathValueSerializer } from "../-h-path-value-serialize/PathValueSerializer";
-import { LOCAL_DOMAIN_PATH } from "../0-path-value-core/PathRouter";
-
-
-
-function group(expanded: boolean) {
-    return expanded ? console.group : console.groupCollapsed;
-}
-
-let epoch = Date.now();
-export class ActionsHistory {
-    public static LOG_ACTION_HISTORY = "";
-    public static OnNewWatches(config: { newPathsWatched: Set<string>; newParentsWatched: Set<string>; debugName?: string; authorityId: string; }) {
-        if (ClientWatcher.DEBUG_READS) {
-            let now = Date.now();
-            group(ClientWatcher.DEBUG_READS_EXPANDED)(`(${now - epoch}ms) New watch count ${config.newPathsWatched.size} (${config.newParentsWatched.size} parent watches) for ${JSON.stringify(config.debugName || "anonymous")}. Authority ${config.authorityId}, time ${now}`);
-            for (let path of config.newParentsWatched) {
-                console.log(blue(path));
-            }
-            for (let path of config.newPathsWatched) {
-                console.log(path);
-            }
-            console.groupEnd();
-        }
-    }
-    public static OnRead(values: PathValue[]) {
-        if (ClientWatcher.DEBUG_READS && values.length > 0) {
-            values = values.filter(x => !x.path.startsWith(LOCAL_DOMAIN_PATH));
-            if (values.length > 0) {
-                let now = Date.now();
-                let oldest = Math.min(...values.map(x => x.time.time).filter(x => x), now);
-                group(ClientWatcher.DEBUG_READS_EXPANDED)(`(${now - epoch}ms, ${now}) Read count ${values.length}, ${(Date.now() - oldest).toFixed()}ms old`);
-                for (let value of values) {
-                    console.log(blue(debugPathValuePath(value)), "===", pathValueSerializer.getPathValue(value), `(${value.valid ? "valid" : "invalid"})`);
-                }
-                console.groupEnd();
-            }
-        }
-        if (!ActionsHistory.LOG_ACTION_HISTORY) return;
-    }
-    public static OnWrite(values: PathValue[]) {
-        if (ClientWatcher.DEBUG_WRITES) {
-            values = values.filter(x => !x.path.startsWith(LOCAL_DOMAIN_PATH));
-            if (values.length > 0) {
-                let now = Date.now();
-                group(ClientWatcher.DEBUG_WRITES_EXPANDED)(green(`(${now - epoch}ms, ${now}) Committing writes ${values.length}`));
-                for (let value of values) {
-                    console.log(green(debugPathValuePath(value)), "=", pathValueSerializer.getPathValue(value), `(${value.valid ? "valid" : "invalid"})`);
-                }
-                console.groupEnd();
-            }
-        }
-        if (!ActionsHistory.LOG_ACTION_HISTORY) return;
-    }
+import { blue, green } from "socket-function/src/formatting/logColors";
+import { ClientWatcher } from "../1-path-client/pathValueClientWatcher";
+import { debugPathValuePath, PathValue } from "../0-path-value-core/pathValueCore";
+import { pathValueSerializer } from "../-h-path-value-serialize/PathValueSerializer";
+import { LOCAL_DOMAIN_PATH } from "../0-path-value-core/PathRouter";
+
+
+
+function group(expanded: boolean) {
+    return expanded ? console.group : console.groupCollapsed;
+}
+
+let epoch = Date.now();
+export class ActionsHistory {
+    public static LOG_ACTION_HISTORY = "";
+    public static OnNewWatches(config: { newPathsWatched: Set<string>; newParentsWatched: Set<string>; debugName?: string; authorityId: string; }) {
+        if (ClientWatcher.DEBUG_READS) {
+            let now = Date.now();
+            group(ClientWatcher.DEBUG_READS_EXPANDED)(`(${now - epoch}ms) New watch count ${config.newPathsWatched.size} (${config.newParentsWatched.size} parent watches) for ${JSON.stringify(config.debugName || "anonymous")}. Authority ${config.authorityId}, time ${now}`);
+            for (let path of config.newParentsWatched) {
+                console.log(blue(path));
+            }
+            for (let path of config.newPathsWatched) {
+                console.log(path);
+            }
+            console.groupEnd();
+        }
+    }
+    public static OnRead(values: PathValue[]) {
+        if (ClientWatcher.DEBUG_READS && values.length > 0) {
+            values = values.filter(x => !x.path.startsWith(LOCAL_DOMAIN_PATH));
+            if (values.length > 0) {
+                let now = Date.now();
+                let oldest = Math.min(...values.map(x => x.time.time).filter(x => x), now);
+                group(ClientWatcher.DEBUG_READS_EXPANDED)(`(${now - epoch}ms, ${now}) Read count ${values.length}, ${(Date.now() - oldest).toFixed()}ms old`);
+                for (let value of values) {
+                    console.log(blue(debugPathValuePath(value)), "===", pathValueSerializer.getPathValue(value), `(${value.valid ? "valid" : "invalid"})`);
+                }
+                console.groupEnd();
+            }
+        }
+        if (!ActionsHistory.LOG_ACTION_HISTORY) return;
+    }
+    public static OnWrite(values: PathValue[]) {
+        if (ClientWatcher.DEBUG_WRITES) {
+            values = values.filter(x => !x.path.startsWith(LOCAL_DOMAIN_PATH));
+            if (values.length > 0) {
+                let now = Date.now();
+                group(ClientWatcher.DEBUG_WRITES_EXPANDED)(green(`(${now - epoch}ms, ${now}) Committing writes ${values.length}`));
+                for (let value of values) {
+                    console.log(green(debugPathValuePath(value)), "=", pathValueSerializer.getPathValue(value), `(${value.valid ? "valid" : "invalid"})`);
+                }
+                console.groupEnd();
+            }
+        }
+        if (!ActionsHistory.LOG_ACTION_HISTORY) return;
+    }
 }