socket-function 1.2.2 → 1.2.5

package/SocketFunction.d.ts

@@ -1,6 +1,6 @@
+/// <reference path="require/RequireController.d.ts" />
 /// <reference types="node" />
 /// <reference types="node" />
-/// <reference types="socket-function/require/requirecontroller" />
 import { SocketExposedInterface, SocketFunctionHook, SocketFunctionClientHook, SocketExposedShape, SocketRegistered, CallerContext, FullCallType, SocketRegisterType } from "./SocketFunctionTypes";
 import { SocketServerConfig } from "./src/webSocketServer";
 import { Args, MaybePromise } from "./src/types";

package/SocketFunctionTypes.d.ts

@@ -1,4 +1,4 @@
-/// <reference types="socket-function/require/requirecontroller" />
+/// <reference path="require/RequireController.d.ts" />
 import { getCallObj } from "./src/nodeProxy";
 import { Args, MaybePromise } from "./src/types";
 export declare const socket: unique symbol;

package/hot/HotReloadController.d.ts

@@ -1,5 +1,5 @@
-/// <reference types="typenode" />
-/// <reference types="socket-function/require/requirecontroller" />
+/// <reference path="../../typenode/index.d.ts" />
+/// <reference path="../require/RequireController.d.ts" />
 /** Enables some hot reload functionality.
  *      - Triggers a refresh clientside
  *      - Triggers a reload server, for modules marked with `module.hotreload`
@@ -28,7 +28,7 @@ export declare function isHotReloading(): boolean;
 export declare function hotReloadingGuard(): true;
 export declare function setExternalHotReloading(value: boolean): void;
 export declare function onHotReload(callback: (modules: NodeJS.Module[]) => void): void;
-export declare const HotReloadController: import("socket-function/SocketFunctionTypes").SocketRegistered<{
+export declare const HotReloadController: import("../SocketFunctionTypes").SocketRegistered<{
     watchFiles: () => Promise<void>;
     fileUpdated: (files: string[], changeTime: number) => Promise<void>;
 }>;

package/index.d.ts

@@ -7,9 +7,9 @@ declare module "socket-function/SetProcessVariables" {
 }
 
 declare module "socket-function/SocketFunction" {
+    /// <reference path="require/RequireController.d.ts" />
     /// <reference types="node" />
     /// <reference types="node" />
-    /// <reference types="socket-function/require/requirecontroller" />
     import { SocketExposedInterface, SocketFunctionHook, SocketFunctionClientHook, SocketExposedShape, SocketRegistered, CallerContext, FullCallType, SocketRegisterType } from "socket-function/SocketFunctionTypes";
     import { SocketServerConfig } from "socket-function/src/webSocketServer";
     import { Args, MaybePromise } from "socket-function/src/types";
@@ -128,7 +128,7 @@ declare module "socket-function/SocketFunction" {
 }
 
 declare module "socket-function/SocketFunctionTypes" {
-    /// <reference types="socket-function/require/requirecontroller" />
+    /// <reference path="require/RequireController.d.ts" />
     import { getCallObj } from "socket-function/src/nodeProxy";
     import { Args, MaybePromise } from "socket-function/src/types";
     export declare const socket: unique symbol;
@@ -218,8 +218,8 @@ declare module "socket-function/SocketFunctionTypes" {
 }
 
 declare module "socket-function/hot/HotReloadController" {
-    /// <reference types="typenode" />
-    /// <reference types="socket-function/require/requirecontroller" />
+    /// <reference path="../../typenode/index.d.ts" />
+    /// <reference path="../require/RequireController.d.ts" />
     /** Enables some hot reload functionality.
      *      - Triggers a refresh clientside
      *      - Triggers a reload server, for modules marked with `module.hotreload`
@@ -307,15 +307,15 @@ declare module "socket-function/mobx/promiseToObservable" {
 }
 
 declare module "socket-function/require/CSSShim" {
-    /// <reference types="socket-function/require/requirecontroller" />
+    /// <reference path="RequireController.d.ts" />
     export {};
 
 }
 
 declare module "socket-function/require/RequireController" {
+    /// <reference path="../../typenode/index.d.ts" />
     /// <reference types="node" />
     /// <reference types="node" />
-    /// <reference types="typenode" />
     declare global {
         namespace NodeJS {
             interface Module {
@@ -430,8 +430,8 @@ declare module "socket-function/require/RequireController" {
 }
 
 declare module "socket-function/require/compileFlags" {
+    /// <reference path="RequireController.d.ts" />
     /// <reference types="node" />
-    /// <reference types="socket-function/require/requirecontroller" />
     /**
      *      Adds a global function setFlag(require, "typescript", flag) which sets a flag on the client
      *          - Ex, setFlag(require, "typescript", "allowclient") so allowclient = true on the typescript module.
@@ -453,7 +453,7 @@ declare module "socket-function/require/extMapper" {
 }
 
 declare module "socket-function/require/require" {
-    /// <reference types="socket-function/src/src" />
+    /// <reference path="../src/src.d.ts" />
     declare global {
         var onProgressHandler: undefined | ((progress: {
             type: string;
@@ -789,7 +789,7 @@ declare module "socket-function/src/callHTTPHandler" {
 }
 
 declare module "socket-function/src/callManager" {
-    /// <reference types="socket-function/hot/hotreloadcontroller" />
+    /// <reference path="../hot/HotReloadController.d.ts" />
     import { CallerContext, CallType, ClientHookContext, FullCallType, FunctionFlags, HookContext, SocketExposedInterface, SocketExposedShape, SocketFunctionClientHook, SocketFunctionHook, SocketRegistered } from "socket-function/SocketFunctionTypes";
     export declare function getCallFlags(call: CallType): FunctionFlags | undefined;
     export declare function shouldCompressCall(call: CallType): boolean | "LZ4" | undefined;
@@ -1560,13 +1560,28 @@ declare module "socket-function/time/trueTimeShim" {
         fromTime: number;
         toTime: number;
     };
+    export declare function computeTweenedOffset(components: {
+        systemTime: number;
+        fromOffset: number;
+        toOffset: number;
+        fromTime: number;
+    }): number;
     export declare function getTimeComponents(): {
         systemTime: number;
         offset: number;
     };
     export declare function getTrueTime(): number;
     export declare function getTrueTimeOffset(): number;
-    export declare function getTrueTimeProof(): TimeOffsetProof | undefined;
+    export type TrueTimeProof = {
+        systemTime: number;
+        fromOffset: number;
+        toOffset: number;
+        fromTime: number;
+        toTime: number;
+        offset: number;
+        measurement?: TimeOffsetProof;
+    };
+    export declare function getTrueTimeProof(): TrueTimeProof | undefined;
     export declare function waitForFirstTimeSync(): Promise<void> | undefined;
     declare global {
         var TRUE_TIME_ALREADY_SHIMMED: boolean;

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "socket-function",
-	"version": "1.2.2",
+	"version": "1.2.5",
 	"main": "index.js",
 	"license": "MIT",
 	"dependencies": {

package/require/CSSShim.d.ts

@@ -1,2 +1,2 @@
-/// <reference types="socket-function/require/requirecontroller" />
+/// <reference path="RequireController.d.ts" />
 export {};

package/require/RequireController.d.ts

@@ -1,6 +1,6 @@
+/// <reference path="../../typenode/index.d.ts" />
 /// <reference types="node" />
 /// <reference types="node" />
-/// <reference types="typenode" />
 declare global {
     namespace NodeJS {
         interface Module {
@@ -85,7 +85,7 @@ declare global {
 /** @deprecated, not needed, as this defaults to ".", which is a lot easier to reason about anyways. */
 export declare function setRequireBootRequire(dir: string): void;
 export declare function allowAllNodeModules(): void;
-export declare const RequireController: import("socket-function/SocketFunctionTypes").SocketRegistered<{
+export declare const RequireController: import("../SocketFunctionTypes").SocketRegistered<{
     rootResolvePath: "Function has implementation but is not exposed in the SocketFunction.register call";
     requireHTML: (config?: {
         requireCalls?: string[];

package/require/compileFlags.d.ts

@@ -1,5 +1,5 @@
+/// <reference path="RequireController.d.ts" />
 /// <reference types="node" />
-/// <reference types="socket-function/require/requirecontroller" />
 /**
  *      Adds a global function setFlag(require, "typescript", flag) which sets a flag on the client
  *          - Ex, setFlag(require, "typescript", "allowclient") so allowclient = true on the typescript module.

package/require/require.d.ts

@@ -1,4 +1,4 @@
-/// <reference types="socket-function/src/src" />
+/// <reference path="../src/src.d.ts" />
 declare global {
     var onProgressHandler: undefined | ((progress: {
         type: string;

package/src/callManager.d.ts

@@ -1,4 +1,4 @@
-/// <reference types="socket-function/hot/hotreloadcontroller" />
+/// <reference path="../hot/HotReloadController.d.ts" />
 import { CallerContext, CallType, ClientHookContext, FullCallType, FunctionFlags, HookContext, SocketExposedInterface, SocketExposedShape, SocketFunctionClientHook, SocketFunctionHook, SocketRegistered } from "../SocketFunctionTypes";
 export declare function getCallFlags(call: CallType): FunctionFlags | undefined;
 export declare function shouldCompressCall(call: CallType): boolean | "LZ4" | undefined;

package/src/webSocketServer.ts

@@ -20,6 +20,12 @@ import { formatTime } from "./formatting/format";
 import { getExternalIP, testTCPIsListening } from "./networking";
 import { forwardPort } from "./forwardPort";
 
+// When a requested port is taken and useAvailablePortIfPortInUse is set, we scan
+//  upwards from this base instead of binding a random OS-assigned port, so restarts
+//  land on predictable, consistent ports.
+const PORT_SCAN_START = 13000;
+const PORT_SCAN_COUNT = 10000;
+
 export type SocketServerConfig = (
     https.ServerOptions & {
         key: string | Buffer;
@@ -311,52 +317,55 @@ export async function startSocketServer(
 
     let port = config.port;
     if (!SocketFunction.silent) {
-        console.log(yellow(`Trying to listening on ${host}:${port}`));
+        console.log(yellow(`Trying to listen on ${host}:${port}`));
     }
 
-    let listeningPromise = waitUntilListening();
-    listeningPromise.catch(e => { });
-
-    // Return true if we are listening, false if the address is in use, and throws on other errors
-    async function waitUntilListening() {
+    // Attempts to bind realServer to a single port. Resolves true once the server is
+    //  actually listening, false if the port is already in use, and rejects on any
+    //  other error. After an EADDRINUSE the server is still usable, so the caller can
+    //  simply retry listen() on the next candidate.
+    async function tryListen(candidatePort: number): Promise<boolean> {
         return await new Promise<boolean>((resolve, reject) => {
-            realServer.once("error", e => {
-                reject(e);
-            });
-            realServer.once("listening", () => {
-                resolve(false);
-            });
-        });
-    }
-
-    if (config.useAvailablePortIfPortInUse && port) {
-        realServer.listen(port, host);
-        let isListening = await new Promise<boolean>((resolve, reject) => {
-            if (realServer.listening) {
-                resolve(true);
-                return;
+            function cleanup() {
+                realServer.removeListener("error", onError);
+                realServer.removeListener("listening", onListening);
             }
-            realServer.once("error", e => {
-                if (e.message.includes("EADDRINUSE")) {
-                    resolve(true);
+            function onError(e: NodeJS.ErrnoException) {
+                cleanup();
+                if (e.code === "EADDRINUSE" || e.message.includes("EADDRINUSE")) {
+                    resolve(false);
                 } else {
                     reject(e);
                 }
-            });
-            realServer.once("listening", () => {
-                resolve(false);
-            });
+            }
+            function onListening() {
+                cleanup();
+                resolve(true);
+            }
+            realServer.once("error", onError);
+            realServer.once("listening", onListening);
+            realServer.listen(candidatePort, host);
         });
-        if (!isListening) {
-            port = 0;
-            realServer.listen(port, host);
-            listeningPromise = waitUntilListening();
+    }
+
+    let bound = await tryListen(port);
+    if (!bound && config.useAvailablePortIfPortInUse) {
+        for (let candidate = PORT_SCAN_START; candidate < PORT_SCAN_START + PORT_SCAN_COUNT; candidate++) {
+            if (candidate === port) continue;
+            if (await tryListen(candidate)) {
+                bound = true;
+                port = candidate;
+                break;
+            }
         }
-    } else {
-        realServer.listen(port, host);
+        if (!bound) {
+            throw new Error(`Could not find an available port in range ${PORT_SCAN_START}-${PORT_SCAN_START + PORT_SCAN_COUNT - 1} (requested ${config.port})`);
+        }
+    }
+    if (!bound) {
+        throw new Error(`Port ${port} is already in use (set useAvailablePortIfPortInUse to fall back to another port)`);
     }
 
-    await listeningPromise;
     port = (realServer.address() as net.AddressInfo).port;
 
     if (config.autoForwardPort && config.public) {

package/test.ts

@@ -1,4 +1,4 @@
-import { getTimeComponentsDetailed, waitForFirstTimeSync } from "./time/trueTimeShim";
+import { computeTweenedOffset, getTimeComponentsDetailed, waitForFirstTimeSync } from "./time/trueTimeShim";
 import * as fs from "fs";
 import * as path from "path";
 
@@ -19,7 +19,6 @@ async function sampleMode() {
         toOffset: number;
         fromTime: number;
         toTime: number;
-        fraction: number;
     };
 
     const samples: Sample[] = [];
@@ -28,11 +27,8 @@ async function sampleMode() {
     for (let i = 0; i < SAMPLE_COUNT; i++) {
         const detailed = getTimeComponentsDetailed();
 
-        // Calculate smearing using the same systemTime
-        const elapsed = detailed.systemTime - detailed.fromTime;
-        const duration = detailed.toTime - detailed.fromTime;
-        const fraction = duration > 0 ? Math.min(1, elapsed / duration) : 0;
-        const offset = detailed.fromOffset + (detailed.toOffset - detailed.fromOffset) * fraction;
+        // Calculate the tween using the same systemTime
+        const offset = computeTweenedOffset(detailed);
 
         samples.push({
             id: TEST_RUN_ID,
@@ -42,7 +38,6 @@ async function sampleMode() {
             toOffset: detailed.toOffset,
             fromTime: detailed.fromTime,
             toTime: detailed.toTime,
-            fraction,
         });
 
         if (SAMPLE_INTERVAL_MS > 0) {
@@ -88,7 +83,6 @@ async function verifyMode() {
         toOffset: number;
         fromTime: number;
         toTime: number;
-        fraction: number;
         file: string;
     };
 
@@ -126,13 +120,13 @@ async function verifyMode() {
             console.error(`    systemTime: ${prev.systemTime}`);
             console.error(`    offset: ${prev.offset}`);
             console.error(`    trueTime: ${prevTrueTime}`);
-            console.error(`    smearing: ${prev.fromOffset} -> ${prev.toOffset} (${(prev.fraction * 100).toFixed(2)}%)`);
+            console.error(`    tween: ${prev.fromOffset} -> ${prev.toOffset}`);
             console.error(`    timeWindow: ${prev.fromTime} -> ${prev.toTime}`);
             console.error(`  Current [ID: ${sample.id}, file: ${sample.file}]:`);
             console.error(`    systemTime: ${sample.systemTime}`);
             console.error(`    offset: ${sample.offset}`);
             console.error(`    trueTime: ${trueTime}`);
-            console.error(`    smearing: ${sample.fromOffset} -> ${sample.toOffset} (${(sample.fraction * 100).toFixed(2)}%)`);
+            console.error(`    tween: ${sample.fromOffset} -> ${sample.toOffset}`);
             console.error(`    timeWindow: ${sample.fromTime} -> ${sample.toTime}`);
             console.error(`  Difference: ${trueTime - lastTrueTime}ms`);
         }

package/time/trueTimeShim.d.ts

@@ -15,13 +15,28 @@ export declare function getTimeComponentsDetailed(): {
     fromTime: number;
     toTime: number;
 };
+export declare function computeTweenedOffset(components: {
+    systemTime: number;
+    fromOffset: number;
+    toOffset: number;
+    fromTime: number;
+}): number;
 export declare function getTimeComponents(): {
     systemTime: number;
     offset: number;
 };
 export declare function getTrueTime(): number;
 export declare function getTrueTimeOffset(): number;
-export declare function getTrueTimeProof(): TimeOffsetProof | undefined;
+export type TrueTimeProof = {
+    systemTime: number;
+    fromOffset: number;
+    toOffset: number;
+    fromTime: number;
+    toTime: number;
+    offset: number;
+    measurement?: TimeOffsetProof;
+};
+export declare function getTrueTimeProof(): TrueTimeProof | undefined;
 export declare function waitForFirstTimeSync(): Promise<void> | undefined;
 declare global {
     var TRUE_TIME_ALREADY_SHIMMED: boolean;

package/time/trueTimeShim.ts

@@ -27,6 +27,9 @@ const LMDB_MAX_CORRUPTION_FAILURES = 3;
 //      the real time to catch up with it.
 const MINIMUM_TIME_RATE = 0.5;
 
+// The offset tweens toward its target at this fraction of elapsed real time, then plateaus once it gets there. Must stay below 1 so output time keeps moving forward even while the offset is shrinking. Tweening across the whole transition window instead would mean a badly-off clock (many seconds) takes the entire window to converge, which breaks transactional consistency with other machines.
+const OFFSET_TWEEN_RATE = 0.5;
+
 const THROW_ON_ERROR = false;
 
 // Hugely important as if we don't synchronize between processes, it means our logs are going to be confusing and out of order.
@@ -143,13 +146,24 @@ export function getTimeComponentsDetailed(): {
     }
 }
 
+export function computeTweenedOffset(components: {
+    systemTime: number;
+    fromOffset: number;
+    toOffset: number;
+    fromTime: number;
+}): number {
+    const elapsed = Math.max(0, components.systemTime - components.fromTime);
+    const delta = components.toOffset - components.fromOffset;
+    const maxChange = elapsed * OFFSET_TWEEN_RATE;
+    if (Math.abs(delta) <= maxChange) {
+        return components.toOffset;
+    }
+    return components.fromOffset + Math.sign(delta) * maxChange;
+}
+
 export function getTimeComponents(): { systemTime: number; offset: number } {
     const detailed = getTimeComponentsDetailed();
-    const elapsed = detailed.systemTime - detailed.fromTime;
-    const duration = detailed.toTime - detailed.fromTime;
-    const fraction = duration > 0 ? Math.min(1, elapsed / duration) : 0;
-    const offset = detailed.fromOffset + (detailed.toOffset - detailed.fromOffset) * fraction;
-    return { systemTime: detailed.systemTime, offset };
+    return { systemTime: detailed.systemTime, offset: computeTweenedOffset(detailed) };
 }
 
 export function getTrueTime() {
@@ -179,8 +193,30 @@ export function getTrueTimeOffset() {
     const { offset } = getTimeComponents();
     return offset;
 }
-export function getTrueTimeProof(): TimeOffsetProof | undefined {
-    return cachedTimeOffsetData?.proof;
+export type TrueTimeProof = {
+    systemTime: number;
+    // The tween endpoints the current offset is moving between. When offset !== toOffset we are still converging.
+    fromOffset: number;
+    toOffset: number;
+    fromTime: number;
+    toTime: number;
+    offset: number;
+    // The raw measurement that produced the newest offset. Undefined if the offset came from a caller-provided base that only returns numbers.
+    measurement?: TimeOffsetProof;
+};
+export function getTrueTimeProof(): TrueTimeProof | undefined {
+    const data = cachedTimeOffsetData;
+    if (!data) return undefined;
+    const detailed = getTimeComponentsDetailed();
+    return {
+        systemTime: detailed.systemTime,
+        fromOffset: detailed.fromOffset,
+        toOffset: detailed.toOffset,
+        fromTime: detailed.fromTime,
+        toTime: detailed.toTime,
+        offset: computeTweenedOffset(detailed),
+        measurement: data.proof,
+    };
 }
 export function waitForFirstTimeSync(): Promise<void> | undefined {
     if (didFirstTimeSync) return undefined;

package/dist/SetProcessVariables.ts.cache

@@ -1,9 +0,0 @@
-"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"; 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});
-module.allowclient = true;
-const misc_1 = require("./src/misc");
-if (!(0, misc_1.isNode)()) {
-    process.env.CBOR_NATIVE_ACCELERATION_DISABLED = "true";
-}
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiU2V0UHJvY2Vzc1ZhcmlhYmxlcy5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIlNldFByb2Nlc3NWYXJpYWJsZXMudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6Ijs7QUFBQSxNQUFNLENBQUMsV0FBVyxHQUFHLElBQUksQ0FBQztBQUMxQixxQ0FBb0M7QUFFcEMsSUFBSSxDQUFDLElBQUEsYUFBTSxHQUFFLEVBQUUsQ0FBQztJQUNaLE9BQU8sQ0FBQyxHQUFHLENBQUMsaUNBQWlDLEdBQUcsTUFBTSxDQUFDO0FBQzNELENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyJtb2R1bGUuYWxsb3djbGllbnQgPSB0cnVlO1xuaW1wb3J0IHsgaXNOb2RlIH0gZnJvbSBcIi4vc3JjL21pc2NcIjtcblxuaWYgKCFpc05vZGUoKSkge1xuICAgIHByb2Nlc3MuZW52LkNCT1JfTkFUSVZFX0FDQ0VMRVJBVElPTl9ESVNBQkxFRCA9IFwidHJ1ZVwiO1xufSJdfQ=//=
- /* _JS_SOURCE_HASH = "17f221dc44d3e6b670edca79d328239589b294826e978bd1870b2edb56a5e5ed"; */