socket-function 1.1.48 → 1.1.49

package/index.d.ts

@@ -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.1.48",
+	"version": "1.1.49",
 	"main": "index.js",
 	"license": "MIT",
 	"dependencies": {

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

@@ -22,6 +22,9 @@ const NTP_TIMEOUT = 1000 * 10;
 //      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.
@@ -138,13 +141,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() {
@@ -174,8 +188,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;