socket-function 1.1.48 → 1.2.0

package/src/dist/nodeCache.ts.cache

@@ -0,0 +1,136 @@
+"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.countOpenConnections = exports.resetAllNodeCallFactories = exports.debugGetAllCallFactories = exports.getCallFactory = exports.getCreateCallFactory = exports.registerNodeClient = exports.getNodeIdDomainMaybeUndefined = exports.getNodeIdDomain = exports.getNodeIdLocation = exports.getNodeIdIP = exports.isClientNodeId = exports.getClientNodeId = exports.getNodeIdFromLocation = exports.getNodeId = void 0;
+const CallFactory_1 = require("./CallFactory");
+const caching_1 = require("./caching");
+const SocketFunction_1 = require("../SocketFunction");
+const createSingleton_1 = require("./createSingleton");
+// TODO: Add CallInstanceFactory.isClosed, so nodeCache can clean up old entries.
+//  This is only needed for memory management, and not for correctness. Entries never
+//  need to be refreshed, because NetworkLocation.listeningPorts shouldn't really change.
+//  Either we will have listeningPorts and re-establish the connection, or we won't, and
+//  then it is a client, in which case we cannot re-establish the connection (and we just
+//  have to wait for the client to re-establish it). AND, if the listeningPorts change from
+//  a value to a new value... then they should be obtained using connect() anyway,
+//  and so whatever way the user got the NetworkLocation to begin with, they should use again.
+function getNodeId(domain, port) {
+    // NOTE: As domains are never reused, this doesn't need any randomness
+    return `${domain}:${port}`;
+}
+exports.getNodeId = getNodeId;
+/** @deprecated, call getBrowserUrlNode instead, which does important additional checks. */
+function getNodeIdFromLocation() {
+    return SocketFunction_1.SocketFunction.browserNodeId();
+}
+exports.getNodeIdFromLocation = getNodeIdFromLocation;
+/** A nodeId not available for reconnecting. */
+function getClientNodeId(address) {
+    return `client:${address}:${Date.now()}:${Math.random()}`;
+}
+exports.getClientNodeId = getClientNodeId;
+function isClientNodeId(nodeId) {
+    return nodeId.startsWith("client:");
+}
+exports.isClientNodeId = isClientNodeId;
+/** Will always be available, even if getNodeIdLocation is not (as we don't always have the port,
+ *      but we should always have an address).
+ *  - Rarely used, as for logging you can just log the nodeId. ALSO, it isn't sufficient to reconnect, as the port is also needed!
+ *  */
+function getNodeIdIP(nodeId) {
+    if (isClientNodeId(nodeId)) {
+        return nodeId.split(":")[1];
+    }
+    return getNodeIdLocation(nodeId).address;
+}
+exports.getNodeIdIP = getNodeIdIP;
+function getNodeIdLocation(nodeId) {
+    if (isClientNodeId(nodeId)) {
+        return undefined;
+    }
+    let [address, port] = nodeId.split(":");
+    return { address, port: parseInt(port) };
+}
+exports.getNodeIdLocation = getNodeIdLocation;
+// NOTE: This returns the full domain.
+//  - It didn't used to, but I think it also wasn't used before, and now we're using this to find the ip. 
+function getNodeIdDomain(nodeId) {
+    let result = getNodeIdDomainMaybeUndefined(nodeId);
+    if (result === undefined) {
+        throw new Error(`Cannot get domain from nodeId, which is only usable as a client. NodeId: ${JSON.stringify(nodeId)}`);
+    }
+    return result;
+}
+exports.getNodeIdDomain = getNodeIdDomain;
+function getNodeIdDomainMaybeUndefined(nodeId) {
+    let location = getNodeIdLocation(nodeId);
+    if (!location) {
+        return undefined;
+    }
+    return new URL("https://" + location.address).hostname;
+}
+exports.getNodeIdDomainMaybeUndefined = getNodeIdDomainMaybeUndefined;
+// NOTE: CallFactory turns into an actual CallFactory when registerNodeClient is called
+// nodeId =>
+// Shared across copies of this package, so connections established through one copy are reused
+//  by the others (instead of each copy opening its own duplicate connection). See createSingleton.
+const nodeCache = (0, createSingleton_1.createSingleton)("nodeCache", 1, () => new Map()).get();
+// NOTE: Should be called directly inside call factory constructor whenever
+//      their nodeId changes (and on construction).
+function registerNodeClient(callFactory) {
+    nodeCache.set(callFactory.nodeId, callFactory);
+    startCleanupLoop();
+}
+exports.registerNodeClient = registerNodeClient;
+function getCreateCallFactory(nodeId) {
+    let callFactory = nodeCache.get(nodeId);
+    if (callFactory === undefined) {
+        callFactory = (0, CallFactory_1.createCallFactory)(undefined, nodeId);
+        nodeCache.set(nodeId, callFactory);
+    }
+    return callFactory;
+}
+exports.getCreateCallFactory = getCreateCallFactory;
+function getCallFactory(nodeId) {
+    return nodeCache.get(nodeId);
+}
+exports.getCallFactory = getCallFactory;
+function debugGetAllCallFactories() {
+    let result = [];
+    for (let [key, value] of nodeCache.entries()) {
+        if (value instanceof Promise) {
+            continue;
+        }
+        result.push(value);
+    }
+    return result;
+}
+exports.debugGetAllCallFactories = debugGetAllCallFactories;
+function resetAllNodeCallFactories() {
+    // Needs to be done if you want to reset authentication. Outstanding calls still work,
+    //  but new calls use new factories (and connections).
+    nodeCache.clear();
+}
+exports.resetAllNodeCallFactories = resetAllNodeCallFactories;
+function countOpenConnections() {
+    return Array.from(nodeCache.values()).filter(factory => factory instanceof Promise ? false : factory.isConnected).length;
+}
+exports.countOpenConnections = countOpenConnections;
+const startCleanupLoop = (0, caching_1.lazy)(() => {
+    (async () => {
+        while (true) {
+            for (let [key, value] of Array.from(nodeCache.entries())) {
+                let factory = value;
+                if (!(factory instanceof Promise)) {
+                    if (factory.closedForever) {
+                        nodeCache.delete(key);
+                    }
+                }
+            }
+            await new Promise(resolve => setTimeout(resolve, 1000 * 60 * 5));
+        }
+    })().catch(e => {
+        console.error(`nodeCache cleanup loop failed, ${e.stack}`);
+    });
+});
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"nodeCache.js","sourceRoot":"","sources":["nodeCache.ts"],"names":[],"mappings":"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","sourcesContent":["import { CallFactory, createCallFactory } from \"./CallFactory\";\nimport { MaybePromise } from \"./types\";\nimport { lazy } from \"./caching\";\nimport { SocketFunction } from \"../SocketFunction\";\nimport { isNode } from \"./misc\";\nimport { createSingleton } from \"./createSingleton\";\n\n// TODO: Add CallInstanceFactory.isClosed, so nodeCache can clean up old entries.\n//  This is only needed for memory management, and not for correctness. Entries never\n//  need to be refreshed, because NetworkLocation.listeningPorts shouldn't really change.\n//  Either we will have listeningPorts and re-establish the connection, or we won't, and\n//  then it is a client, in which case we cannot re-establish the connection (and we just\n//  have to wait for the client to re-establish it). AND, if the listeningPorts change from\n//  a value to a new value... then they should be obtained using connect() anyway,\n//  and so whatever way the user got the NetworkLocation to begin with, they should use again.\n\nexport function getNodeId(domain: string, port: number): string {\n    // NOTE: As domains are never reused, this doesn't need any randomness\n    return `${domain}:${port}`;\n}\n\n/** @deprecated, call getBrowserUrlNode instead, which does important additional checks. */\nexport function getNodeIdFromLocation() {\n    return SocketFunction.browserNodeId();\n}\n\n/** A nodeId not available for reconnecting. */\nexport function getClientNodeId(address: string): string {\n    return `client:${address}:${Date.now()}:${Math.random()}`;\n}\nexport function isClientNodeId(nodeId: string): boolean {\n    return nodeId.startsWith(\"client:\");\n}\n/** Will always be available, even if getNodeIdLocation is not (as we don't always have the port,\n *      but we should always have an address).\n *  - Rarely used, as for logging you can just log the nodeId. ALSO, it isn't sufficient to reconnect, as the port is also needed!\n *  */\nexport function getNodeIdIP(nodeId: string): string {\n    if (isClientNodeId(nodeId)) {\n        return nodeId.split(\":\")[1];\n    }\n    return getNodeIdLocation(nodeId)!.address;\n}\n\nexport function getNodeIdLocation(nodeId: string): { address: string, port: number; } | undefined {\n    if (isClientNodeId(nodeId)) {\n        return undefined;\n    }\n    let [address, port] = nodeId.split(\":\");\n    return { address, port: parseInt(port) };\n}\n\n// NOTE: This returns the full domain.\n//  - It didn't used to, but I think it also wasn't used before, and now we're using this to find the ip. \nexport function getNodeIdDomain(nodeId: string): string {\n    let result = getNodeIdDomainMaybeUndefined(nodeId);\n    if (result === undefined) {\n        throw new Error(`Cannot get domain from nodeId, which is only usable as a client. NodeId: ${JSON.stringify(nodeId)}`);\n    }\n    return result;\n}\nexport function getNodeIdDomainMaybeUndefined(nodeId: string): string | undefined {\n    let location = getNodeIdLocation(nodeId);\n    if (!location) {\n        return undefined;\n    }\n    return new URL(\"https://\" + location.address).hostname;\n}\n\n// NOTE: CallFactory turns into an actual CallFactory when registerNodeClient is called\n// nodeId =>\n// Shared across copies of this package, so connections established through one copy are reused\n//  by the others (instead of each copy opening its own duplicate connection). See createSingleton.\nconst nodeCache = createSingleton(\"nodeCache\", 1, () => new Map<string, MaybePromise<CallFactory>>()).get();\n\n// NOTE: Should be called directly inside call factory constructor whenever\n//      their nodeId changes (and on construction).\nexport function registerNodeClient(callFactory: CallFactory) {\n    nodeCache.set(callFactory.nodeId, callFactory);\n    startCleanupLoop();\n}\n\nexport function getCreateCallFactory(nodeId: string): MaybePromise<CallFactory> {\n    let callFactory = nodeCache.get(nodeId);\n    if (callFactory === undefined) {\n        callFactory = createCallFactory(undefined, nodeId);\n        nodeCache.set(nodeId, callFactory);\n    }\n    return callFactory;\n}\nexport function getCallFactory(nodeId: string): MaybePromise<CallFactory | undefined> {\n    return nodeCache.get(nodeId);\n}\n\nexport function debugGetAllCallFactories(): CallFactory[] {\n    let result: CallFactory[] = [];\n    for (let [key, value] of nodeCache.entries()) {\n        if (value instanceof Promise) {\n            continue;\n        }\n        result.push(value);\n    }\n    return result;\n}\n\nexport function resetAllNodeCallFactories() {\n    // Needs to be done if you want to reset authentication. Outstanding calls still work,\n    //  but new calls use new factories (and connections).\n    nodeCache.clear();\n}\n\nexport function countOpenConnections() {\n    return Array.from(nodeCache.values()).filter(factory => factory instanceof Promise ? false : factory.isConnected).length;\n}\n\nconst startCleanupLoop = lazy(() => {\n    (async () => {\n        while (true) {\n            for (let [key, value] of Array.from(nodeCache.entries())) {\n                let factory = value;\n                if (!(factory instanceof Promise)) {\n                    if (factory.closedForever) {\n                        nodeCache.delete(key);\n                    }\n                }\n            }\n            await new Promise(resolve => setTimeout(resolve, 1000 * 60 * 5));\n        }\n    })().catch(e => {\n        console.error(`nodeCache cleanup loop failed, ${e.stack}`);\n    });\n});"]}
+ /* _JS_SOURCE_HASH = "5d2e436f7a090cbdf7f16d6e9494138a7f879d63faa5fbd63b789f74f0dc5c86"; */

package/src/dist/nodeProxy.ts.cache

@@ -0,0 +1,57 @@
+"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.getCallProxy = exports.getCallObj = void 0;
+exports.getCallObj = Symbol.for("getCallObj");
+let proxyCache = new Map();
+function getCallProxy(id, callback) {
+    let value = proxyCache.get(id);
+    if (!value) {
+        let nodeCache = new Map();
+        value = new Proxy(Object.create(null), {
+            get(target, nodeId) {
+                if (typeof nodeId !== "string")
+                    return undefined;
+                let nodeProxy = nodeCache.get(nodeId);
+                if (!nodeProxy) {
+                    nodeProxy = new Proxy(Object.create(null), {
+                        get(target, functionName) {
+                            if (typeof functionName !== "string")
+                                return undefined;
+                            // Ignore "then" calls, as they happen when awaiting a callProxy (to check if it's
+                            //  a promise), and we don't want to act like a promise (we don't want to call the
+                            //  "then" api call).
+                            if (functionName === "then")
+                                return undefined;
+                            return Object.assign((...args) => {
+                                let call = {
+                                    classGuid: id,
+                                    nodeId,
+                                    functionName,
+                                    args,
+                                };
+                                return callback(call);
+                            }, {
+                                [exports.getCallObj]: (...args) => {
+                                    let call = {
+                                        classGuid: id,
+                                        nodeId,
+                                        functionName,
+                                        args,
+                                    };
+                                    return call;
+                                }
+                            });
+                        }
+                    });
+                    nodeCache.set(nodeId, nodeProxy);
+                }
+                return nodeProxy;
+            },
+        });
+        proxyCache.set(id, value);
+    }
+    return value;
+}
+exports.getCallProxy = getCallProxy;
+//# sourceMappingURL=data:application/json;base64,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
+ /* _JS_SOURCE_HASH = "1b9d0bc34f50fed0c63e4f540176e1b8baee57f4c424770acb06b52e4cbe7ead"; */

package/src/dist/protocolNegotiation.ts.cache

@@ -0,0 +1,101 @@
+"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";
+// Negotiates connection-level flags via Sec-WebSocket-Protocol on the WebSocket
+// upgrade handshake. The client proposes every flag combination it accepts (hex-
+// encoded so the value is a valid HTTP token). The server picks the first value
+// whose target nodeId matches its own, then returns it verbatim. If none match,
+// the server returns no protocol and the handshake fails — which is exactly the
+// rejection semantics we want (indistinguishable from "node not reachable").
+Object.defineProperty(exports, "__esModule", { value: true , configurable: true});
+//exports.chooseProtocol = exports.proposeProtocols = exports.decodeProtocol = void 0;
+const PROTOCOL_VERSION = "v1";
+function hexEncode(s) {
+    return Buffer.from(s, "utf8").toString("hex");
+}
+function hexDecode(s) {
+    return Buffer.from(s, "hex").toString("utf8");
+}
+function encodeFlagBit(b) { return b ? "1" : "0"; }
+// An empty-string target encodes "match any server nodeId" — used for
+// browser clients which don't know our internal nodeId because they're
+// connecting through a Let's Encrypt cert on a public domain.
+const WILDCARD_TARGET = "";
+function encodeOne(target, flags) {
+    let plain = `${PROTOCOL_VERSION}|${target}|clz4=${encodeFlagBit(flags.clientLZ4)}|slz4=${encodeFlagBit(flags.serverLZ4)}`;
+    return hexEncode(plain);
+}
+function decodeProtocol(hex) {
+    if (!/^[0-9a-fA-F]+$/.test(hex))
+        return undefined;
+    let plain;
+    try {
+        plain = hexDecode(hex);
+    }
+    catch (_a) {
+        return undefined;
+    }
+    let parts = plain.split("|");
+    if (parts.length < 2)
+        return undefined;
+    if (parts[0] !== PROTOCOL_VERSION)
+        return undefined;
+    let target = parts[1];
+    let flags = { clientLZ4: false, serverLZ4: false };
+    for (let i = 2; i < parts.length; i++) {
+        let [k, v] = parts[i].split("=");
+        if (k === "clz4")
+            flags.clientLZ4 = v === "1";
+        else if (k === "slz4")
+            flags.serverLZ4 = v === "1";
+    }
+    return { target, flags };
+}
+exports.decodeProtocol = decodeProtocol;
+// Build the list of subprotocol values the client wants to propose. We enumerate
+// every flag combination the client accepts — the server will pick whichever
+// one it can serve (matching its own flag support). Caller is responsible for
+// not proposing flags it can't handle.
+//
+// `target` is the nodeId the client wants to reach. Pass undefined for browser
+// clients (or any context where the client doesn't know the server's nodeId,
+// because it's reaching the server through a public DNS name + Let's Encrypt
+// cert). The server then accepts the connection regardless of its identity,
+// while still negotiating flags.
+function proposeProtocols(target, clientCapabilities) {
+    let out = [];
+    let clientLZ4Options = clientCapabilities.lz4 ? [true, false] : [false];
+    let serverLZ4Options = [true, false];
+    let encodedTarget = target !== null && target !== void 0 ? target : WILDCARD_TARGET;
+    for (let clientLZ4 of clientLZ4Options) {
+        for (let serverLZ4 of serverLZ4Options) {
+            out.push(encodeOne(encodedTarget, { clientLZ4, serverLZ4 }));
+        }
+    }
+    return out;
+}
+exports.proposeProtocols = proposeProtocols;
+// Server-side: given the proposed (hex-encoded) subprotocol values from the
+// client, the server's own nodeId, and the server's capabilities — pick the
+// first value matching this server with a flag combo we can support. Returns
+// the chosen hex string verbatim (so the server echoes it back), or undefined
+// to signal no match → reject the handshake.
+//
+// A proposal with target === WILDCARD_TARGET ("") matches any server (used
+// by browsers that don't know our internal nodeId).
+function chooseProtocol(proposed, serverNodeId, serverCapabilities) {
+    for (let hex of proposed) {
+        let decoded = decodeProtocol(hex);
+        if (!decoded)
+            continue;
+        if (decoded.target !== WILDCARD_TARGET && decoded.target !== serverNodeId)
+            continue;
+        // Server capability check: if the proposal asks the server to receive
+        // LZ4 (slz4=1) but the server doesn't support it, skip.
+        if (decoded.flags.serverLZ4 && !serverCapabilities.lz4)
+            continue;
+        return hex;
+    }
+    return undefined;
+}
+exports.chooseProtocol = chooseProtocol;
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"protocolNegotiation.js","sourceRoot":"","sources":["protocolNegotiation.ts"],"names":[],"mappings":"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","sourcesContent":["// Negotiates connection-level flags via Sec-WebSocket-Protocol on the WebSocket\n// upgrade handshake. The client proposes every flag combination it accepts (hex-\n// encoded so the value is a valid HTTP token). The server picks the first value\n// whose target nodeId matches its own, then returns it verbatim. If none match,\n// the server returns no protocol and the handshake fails — which is exactly the\n// rejection semantics we want (indistinguishable from \"node not reachable\").\n\nconst PROTOCOL_VERSION = \"v1\";\n\nexport type ConnectionFlags = {\n    // Client supports receiving LZ4-compressed frames\n    clientLZ4: boolean;\n    // Server supports receiving LZ4-compressed frames (i.e. server can accept LZ4)\n    serverLZ4: boolean;\n};\n\nexport type DecodedProtocol = {\n    target: string;\n    flags: ConnectionFlags;\n};\n\nfunction hexEncode(s: string): string {\n    return Buffer.from(s, \"utf8\").toString(\"hex\");\n}\nfunction hexDecode(s: string): string {\n    return Buffer.from(s, \"hex\").toString(\"utf8\");\n}\n\nfunction encodeFlagBit(b: boolean): string { return b ? \"1\" : \"0\"; }\n\n// An empty-string target encodes \"match any server nodeId\" — used for\n// browser clients which don't know our internal nodeId because they're\n// connecting through a Let's Encrypt cert on a public domain.\nconst WILDCARD_TARGET = \"\";\n\nfunction encodeOne(target: string, flags: ConnectionFlags): string {\n    let plain = `${PROTOCOL_VERSION}|${target}|clz4=${encodeFlagBit(flags.clientLZ4)}|slz4=${encodeFlagBit(flags.serverLZ4)}`;\n    return hexEncode(plain);\n}\n\nexport function decodeProtocol(hex: string): DecodedProtocol | undefined {\n    if (!/^[0-9a-fA-F]+$/.test(hex)) return undefined;\n    let plain: string;\n    try {\n        plain = hexDecode(hex);\n    } catch {\n        return undefined;\n    }\n    let parts = plain.split(\"|\");\n    if (parts.length < 2) return undefined;\n    if (parts[0] !== PROTOCOL_VERSION) return undefined;\n    let target = parts[1];\n    let flags: ConnectionFlags = { clientLZ4: false, serverLZ4: false };\n    for (let i = 2; i < parts.length; i++) {\n        let [k, v] = parts[i].split(\"=\");\n        if (k === \"clz4\") flags.clientLZ4 = v === \"1\";\n        else if (k === \"slz4\") flags.serverLZ4 = v === \"1\";\n    }\n    return { target, flags };\n}\n\n// Build the list of subprotocol values the client wants to propose. We enumerate\n// every flag combination the client accepts — the server will pick whichever\n// one it can serve (matching its own flag support). Caller is responsible for\n// not proposing flags it can't handle.\n//\n// `target` is the nodeId the client wants to reach. Pass undefined for browser\n// clients (or any context where the client doesn't know the server's nodeId,\n// because it's reaching the server through a public DNS name + Let's Encrypt\n// cert). The server then accepts the connection regardless of its identity,\n// while still negotiating flags.\nexport function proposeProtocols(target: string | undefined, clientCapabilities: { lz4: boolean }): string[] {\n    let out: string[] = [];\n    let clientLZ4Options = clientCapabilities.lz4 ? [true, false] : [false];\n    let serverLZ4Options = [true, false];\n    let encodedTarget = target ?? WILDCARD_TARGET;\n    for (let clientLZ4 of clientLZ4Options) {\n        for (let serverLZ4 of serverLZ4Options) {\n            out.push(encodeOne(encodedTarget, { clientLZ4, serverLZ4 }));\n        }\n    }\n    return out;\n}\n\n// Server-side: given the proposed (hex-encoded) subprotocol values from the\n// client, the server's own nodeId, and the server's capabilities — pick the\n// first value matching this server with a flag combo we can support. Returns\n// the chosen hex string verbatim (so the server echoes it back), or undefined\n// to signal no match → reject the handshake.\n//\n// A proposal with target === WILDCARD_TARGET (\"\") matches any server (used\n// by browsers that don't know our internal nodeId).\nexport function chooseProtocol(\n    proposed: string[],\n    serverNodeId: string,\n    serverCapabilities: { lz4: boolean }\n): string | undefined {\n    for (let hex of proposed) {\n        let decoded = decodeProtocol(hex);\n        if (!decoded) continue;\n        if (decoded.target !== WILDCARD_TARGET && decoded.target !== serverNodeId) continue;\n        // Server capability check: if the proposal asks the server to receive\n        // LZ4 (slz4=1) but the server doesn't support it, skip.\n        if (decoded.flags.serverLZ4 && !serverCapabilities.lz4) continue;\n        return hex;\n    }\n    return undefined;\n}\n"]}
+ /* _JS_SOURCE_HASH = "148a717dbc4ad826e2af1e42050c7cef4014c49eba4584cc3b7400e8bd1fb760"; */

package/src/dist/tlsParsing.ts.cache

@@ -0,0 +1,85 @@
+"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.parseSNIExtension = exports.SNIType = exports.parseTLSHello = void 0;
+function parseTLSHello(buffer) {
+    let output = {
+        extensions: [],
+        missingBytes: 0
+    };
+    try {
+        let pos = 0;
+        function readShort() {
+            let high = buffer[pos++];
+            let low = buffer[pos++];
+            return high * 256 + low;
+        }
+        let type = buffer[pos++];
+        let version = readShort();
+        var contentLength = readShort();
+        let clientMessageType = buffer[pos++];
+        // High length byte (how would this be used if contentLength is only 2 bytes?)
+        pos++;
+        let clientMessageLength = readShort();
+        // Client version
+        let clientVersion = readShort();
+        // Client random
+        pos += 32;
+        // Session id
+        let sessionIdLength = buffer[pos++];
+        pos += sessionIdLength;
+        let cipherSuiteLength = readShort();
+        pos += cipherSuiteLength;
+        let compressionLength = buffer[pos++];
+        pos += compressionLength;
+        let extensionsLength = readShort();
+        let extensionsEnd = pos + extensionsLength;
+        while (pos < extensionsEnd) {
+            let extensionType = readShort();
+            let length = readShort();
+            // Break if we only have part of the extension
+            if (Number.isNaN(extensionType) || Number.isNaN(length)) {
+                break;
+            }
+            if (pos + length > buffer.length) {
+                break;
+            }
+            output.extensions.push({
+                type: extensionType, data: viewSliceBuffer(buffer, pos, length)
+            });
+            pos += length;
+        }
+        output.missingBytes = contentLength - pos;
+    }
+    catch (_a) { }
+    return output;
+}
+exports.parseTLSHello = parseTLSHello;
+exports.SNIType = 0x0;
+function parseSNIExtension(data) {
+    let pos = 0;
+    function readShort() {
+        let high = data[pos++];
+        let low = data[pos++];
+        return high * 256 + low;
+    }
+    let snis = [];
+    try {
+        while (pos < data.length) {
+            let len = readShort();
+            let end = pos + len;
+            let type = data[pos++];
+            let len2 = readShort();
+            snis.push(viewSliceBuffer(data, pos, len2).toString());
+            pos = end;
+        }
+    }
+    catch (_a) { }
+    return snis;
+}
+exports.parseSNIExtension = parseSNIExtension;
+function viewSliceBuffer(data, index, count) {
+    count = count !== null && count !== void 0 ? count : (data.length - index);
+    return Buffer.from(data.buffer, data.byteOffset + index, count);
+}
+//# sourceMappingURL=data:application/json;base64,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
+ /* _JS_SOURCE_HASH = "ce4d35d8f15f2d3a95b795d55d30f85321b7c72a9d8180605338b339f4c54443"; */

package/src/dist/types.ts.cache

@@ -0,0 +1,9 @@
+"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.canHaveChildren = void 0;
+function canHaveChildren(value) {
+    return typeof value === "object" && value !== null || typeof value === "function";
+}
+exports.canHaveChildren = canHaveChildren;
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidHlwZXMuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyJ0eXBlcy50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiOzs7QUFNQSxTQUFnQixlQUFlLENBQUMsS0FBYztJQUMxQyxPQUFPLE9BQU8sS0FBSyxLQUFLLFFBQVEsSUFBSSxLQUFLLEtBQUssSUFBSSxJQUFJLE9BQU8sS0FBSyxLQUFLLFVBQVUsQ0FBQztBQUN0RixDQUFDO0FBRkQsMENBRUMiLCJzb3VyY2VzQ29udGVudCI6WyJleHBvcnQgdHlwZSBNYXliZVByb21pc2U8VD4gPSBUIHwgUHJvbWlzZTxUPjtcblxuZXhwb3J0IHR5cGUgQXJnczxUPiA9IFQgZXh0ZW5kcyAoLi4uYXJnczogaW5mZXIgVikgPT4gYW55ID8gViA6IG5ldmVyO1xuXG5leHBvcnQgdHlwZSBBbnlGdW5jdGlvbiA9ICguLi5hcmdzOiBhbnkpID0+IGFueTtcblxuZXhwb3J0IGZ1bmN0aW9uIGNhbkhhdmVDaGlsZHJlbih2YWx1ZTogdW5rbm93bik6IHZhbHVlIGlzIHsgW2tleSBpbiBQcm9wZXJ0eUtleV06IHVua25vd24gfSB7XG4gICAgcmV0dXJuIHR5cGVvZiB2YWx1ZSA9PT0gXCJvYmplY3RcIiAmJiB2YWx1ZSAhPT0gbnVsbCB8fCB0eXBlb2YgdmFsdWUgPT09IFwiZnVuY3Rpb25cIjtcbn0iXX0=
+ /* _JS_SOURCE_HASH = "e4a11e3ad260c988d5f2bf31710ef89454fe4cebf4787ff056ddfcf601114cd9"; */