socket-function 0.8.37 → 0.8.38

package/src/profiling/getOwnTime.ts

@@ -0,0 +1,143 @@
+import debugbreak from "debugbreak";
+// TODO: We could probably make this an optional / dev dependency, to allow
+//  for use on machines without the ability to compile?
+import { now } from "rdtsc-now";
+
+export type OwnTimeObj = {
+    name: string;
+    time: number;
+    ownTime: number;
+};
+type OwnTimeObjInternal = OwnTimeObj & {
+    lastStartTime: number;
+    firstStartTime: number;
+    parent: OwnTimeObjInternal | undefined;
+    child: OwnTimeObjInternal | undefined;
+};
+
+let pendingCallTime: OwnTimeObjInternal | undefined;
+export function getPendingOwnTimeObjs(): (OwnTimeObj & { source: OwnTimeObjInternal })[] | undefined {
+    let time = now();
+    let instances = getPendingOwnTimeInstances();
+    if (!instances) return undefined;
+    if (!pendingCallTime) return undefined;
+    let results = instances.map((instance) => ({
+        name: instance.name,
+        ownTime: instance.ownTime,
+        time: time - instance.firstStartTime,
+        source: instance
+    }));
+    results[0].ownTime += time - pendingCallTime.lastStartTime;
+    return results;
+}
+export function getPendingOwnTimeInstances(): OwnTimeObjInternal[] | undefined {
+    if (!pendingCallTime) return undefined;
+    let results: OwnTimeObjInternal[] = [];
+    let current: OwnTimeObjInternal | undefined = pendingCallTime;
+    while (current) {
+        results.push(current);
+        current = current.parent;
+    }
+    return results;
+}
+(global as any).pendingOwnCallTime = pendingCallTime;
+
+// NOTE: This overhead time is actually mostly for aggregate time, but it is needed,
+//  otherwise we consistently underestimate the time spent.
+//  ALSO! This forces high count lines to be at the top of the aggregate time list, which is really important!
+// NOTE: The overhead time greatly varies, but even if it only takes 100ns, if 10X of that
+//  is significant, you are probably spending too much timing profiling anyway!
+export const measureOverheadTime = 500 / 1000 / 1000;
+// We internally add, because of where we measure time, there is time spent before we grab the
+//  current time, and after we record the last time, that is lost, but should be added.
+let addMeasureOverheadTime = 0;
+{
+    // NOTE: This is going to vary considerably. I assume because sometimes we are on a core
+    //  that is free, and other times we are on a core that is hyperthreading with another hardware
+    //  thread. This really hurts us because our timing uses rdtsc, which really hates hyper threading,
+    //  and can easily get 50% slower because of it.
+    let results: number[] = [];
+    for (let j = 0; j < 10; j++) {
+        const measureCount = 1000 * 10;
+        let time = now();
+        for (let i = 0; i < measureCount; i++) {
+            getOwnTime("test", () => { }, () => { });
+        }
+        time = now() - time;
+        let overhead = time / measureCount;
+        results.push(overhead);
+    }
+    results.sort((a, b) => a - b);
+    addMeasureOverheadTime = results[results.length / 2];
+}
+
+// TIMING: About 60ns, of which 40ns is just now() calls.
+//  If async is closer to 300ns.
+export function getOwnTime<T>(
+    name: string,
+    code: () => T,
+    onTime: (obj: OwnTimeObj) => void
+): T {
+    let time = now();
+    let obj: OwnTimeObjInternal = {
+        name,
+        time: 0,
+        ownTime: 0,
+        firstStartTime: time,
+        lastStartTime: time,
+        parent: pendingCallTime,
+        child: undefined,
+    };
+    if (pendingCallTime) {
+        pendingCallTime.child = obj;
+    }
+    pendingCallTime = obj;
+    if (obj.parent) {
+        obj.parent.ownTime += obj.lastStartTime - obj.parent.lastStartTime;
+    }
+
+    function finish() {
+        let time = now();
+        obj.time = time - obj.firstStartTime;
+        if (pendingCallTime === obj) {
+            // Good case, all of our children call ended before us.
+
+            // End our own time calculation
+            obj.ownTime += time - obj.lastStartTime;
+
+            // Our parent is now the last open call
+            pendingCallTime = obj.parent;
+            if (pendingCallTime) {
+                // Resume our parent ownTime counting
+                pendingCallTime.lastStartTime = time;
+            }
+        }
+        if (obj.child && obj.parent) {
+            obj.child.parent = obj.parent;
+            obj.parent.child = obj.child;
+        }
+        obj.parent = undefined;
+        obj.child = undefined;
+
+        obj.time += addMeasureOverheadTime;
+        obj.ownTime += addMeasureOverheadTime;
+
+        onTime(obj);
+    }
+
+    let isAsync = false;
+    try {
+        let result = code();
+        if (result && typeof result === "object" && result instanceof Promise) {
+            isAsync = true;
+            return result.finally(() => {
+                finish();
+            }) as any;
+        }
+        return result;
+    } finally {
+        if (!isAsync) {
+            finish();
+        }
+    }
+}

package/src/profiling/measure.ts

@@ -0,0 +1,241 @@
+import debugbreak from "debugbreak";
+import { formatTime, formatNumber } from "../formatting/format";
+import { red, yellow, blue } from "../formatting/logColors";
+
+import { getOwnTime, getPendingOwnTimeInstances, getPendingOwnTimeObjs, OwnTimeObj } from "./getOwnTime";
+import { addToStats, addToStatsValue, createStatsValue, getStatsTop, StatsValue } from "./stats";
+
+/** NOTE: Must be called BEFORE anything else is imported! */
+export function enableMeasurements() {
+    if (functionsSkipped) {
+        console.warn(red(`Skipped measure shimming ${functionsSkipped} functions. Fix this by calling enableMeasurements before any other imports.`));
+    }
+    measurementsEnabled = true;
+}
+
+let functionsSkipped = 0;
+
+const measureOverhead = 5 / 1000;
+
+const AsyncFunction = (async () => { }).constructor;
+
+// TIMING: 1-5us. I have seen timing values greatly vary, but it does seem to be quite high, despite
+//  microbenchmarks saying it is slow. Perhaps it is because getOwnTime breaks the cpu pipeline,
+//  which causes slowness for code around us, but not if we are running in isolation?
+export function measureFnc(target: any, propertyKey: string, descriptor: PropertyDescriptor) {
+    let name = propertyKey;
+    if (target.name) {
+        name = `${target.name}.${name}`;
+    } else {
+        let constructorName = target.constructor.name;
+        if (constructorName) {
+            name = `${constructorName}().${name}`;
+        }
+    }
+    if (descriptor.value instanceof AsyncFunction) {
+        name += `(async)`;
+    }
+    descriptor.value = measureWrap(descriptor.value, name);
+}
+export function measureWrap<T extends (...args: any[]) => any>(fnc: T, name?: string): T {
+    if (!measurementsEnabled) {
+        functionsSkipped++;
+        return fnc;
+    }
+    let usedName = name || fnc.name;
+    return (function (this: any, ...args: unknown[]): unknown {
+        if (outstandingProfiles.length === 0) {
+            return fnc.apply(this, args);
+        }
+        return getOwnTime(usedName, () => fnc.apply(this, args), recordOwnTime);
+    }) as T;
+}
+export function measureBlock<T extends (...args: any[]) => any>(fnc: T, name?: string): ReturnType<T> {
+    return measureWrap(fnc, name)();
+}
+
+export function startMeasure(): {
+    finish: () => MeasureProfile;
+} {
+    if (!measurementsEnabled) {
+        console.warn(red(`To capture measurements enableMeasurements() must be called before any other imports in your entry point`));
+    }
+    let profile: MeasureProfile = {
+        entries: Object.create(null),
+    };
+    let openAtStart = new Set(getPendingOwnTimeInstances());
+
+    outstandingProfiles.push(profile);
+    return {
+        finish() {
+            let pending = getPendingOwnTimeObjs() || [];
+            for (let timeObj of pending) {
+                if (openAtStart.has(timeObj.source)) continue;
+                addToProfile(profile, timeObj, true);
+            }
+            outstandingProfiles.splice(outstandingProfiles.indexOf(profile), 1);
+            return profile;
+        }
+    };
+}
+
+export interface LogMeasureTableConfig {
+    useTotalTime?: boolean;
+    name?: string;
+    // Defaults to 0.05
+    thresholdInTable?: number;
+}
+
+export function logMeasureTable(
+    profile: MeasureProfile,
+    config?: LogMeasureTableConfig
+) {
+    let { useTotalTime, name, thresholdInTable } = config || {};
+    if (thresholdInTable === undefined) {
+        thresholdInTable = 0.05;
+    }
+
+    function getTime(entry: ProfileEntry) {
+        return useTotalTime ? entry.totalTime : entry.ownTime;
+    }
+    let entries = Object.values(profile.entries);
+    entries.sort((a, b) => getTime(b).sum - getTime(a).sum);
+
+    let totalTime = entries.map(x => getTime(x).sum).reduce((a, b) => a + b, 0);
+
+    console.log();
+    let title = yellow(`Profiled ${formatTime(totalTime)}`);
+    if (name) {
+        title += ` ${blue(name)}`;
+    }
+    console.log(title);
+    function percent(value: number) {
+        return `${(value * 100).toFixed(2)}%`;
+    }
+
+    entries = entries.slice(0, 10);
+    let maxNameLength = Math.max(...entries.map(x => x.name.length));
+
+    for (let entry of entries.slice(0, 10)) {
+        if (getTime(entry).sum / totalTime < thresholdInTable) break;
+        let output = "";
+        output += `${blue(entry.name)}`;
+        output += Array(maxNameLength + 4 - entry.name.length).fill(" ").join("");
+
+        let text = `${percent(getTime(entry).sum / totalTime).padStart(6, " ")} ( ${formatTime(getTime(entry).sum / getTime(entry).count).padStart(6, " ")} per * ${formatNumber(getTime(entry).count).padStart(6, " ")} = ${formatTime(getTime(entry).sum).padStart(6, " ")} )`;
+        let overhead = measureOverhead * getTime(entry).count;
+        let overheadFraction = overhead / getTime(entry).sum;
+        let overheadIsAProblem = overheadFraction > 0.5;
+        if (overheadIsAProblem) {
+            text = yellow(text);
+        }
+
+        output += text;
+
+        if (overheadIsAProblem) {
+            output += red(`    measurement overhead is ~${percent(overheadFraction)} of the time.`);
+        }
+
+        let ownTimeTop = getStatsTop(getTime(entry));
+        if (ownTimeTop.topHeavy) {
+            output += red(`    TOP ${percent(ownTimeTop.valueFraction)} of the time is owned by ${percent(ownTimeTop.countFraction)} of the calls`);
+        }
+
+        if (entry.stillOpenCount > 0) {
+            output += red(`    (${entry.stillOpenCount} open)`);
+        }
+
+        console.log(output);
+    }
+    console.log();
+}
+
+export async function measureCode<T>(code: () => Promise<T>, config?: LogMeasureTableConfig) {
+    let measure = startMeasure();
+    try {
+        return await measureBlock(code, code.name || "untracked");
+    } finally {
+        finishProfile(measure, config);
+    }
+}
+export function measureCodeSync<T>(code: () => T, config?: LogMeasureTableConfig): T {
+    let measure = startMeasure();
+    try {
+        return measureBlock(code, code.name || "untracked");
+    } finally {
+        finishProfile(measure, config);
+    }
+}
+function finishProfile(measure: { finish(): MeasureProfile }, config?: LogMeasureTableConfig) {
+    let profile = measure.finish();
+    logMeasureTable(profile, config);
+}
+
+
+export interface MeasureProfile {
+    entries: {
+        [name: string]: ProfileEntry;
+    };
+}
+export function createMeasureProfile(): MeasureProfile {
+    return {
+        entries: Object.create(null),
+    };
+}
+
+export function addToMeasureProfile(base: MeasureProfile, other: MeasureProfile) {
+    for (let name in other.entries) {
+        let entry = other.entries[name];
+        let baseEntry = base.entries[name];
+        if (!baseEntry) {
+            baseEntry = {
+                name: name,
+                ownTime: createStatsValue(),
+                totalTime: createStatsValue(),
+                stillOpenCount: 0,
+            };
+            base.entries[name] = baseEntry;
+        }
+        addToStats(baseEntry.ownTime, entry.ownTime);
+        addToStats(baseEntry.totalTime, entry.totalTime);
+        baseEntry.stillOpenCount += entry.stillOpenCount;
+    }
+}
+
+interface ProfileEntry {
+    name: string;
+    ownTime: StatsValue;
+    totalTime: StatsValue;
+    stillOpenCount: number;
+}
+
+let measurementsEnabled = false;
+
+let outstandingProfiles: MeasureProfile[] = [];
+function recordOwnTime(ownTimeObj: OwnTimeObj) {
+    if (outstandingProfiles.length === 0) return;
+    for (let i = 0; i < outstandingProfiles.length; i++) {
+        let profile = outstandingProfiles[i];
+        addToProfile(profile, ownTimeObj);
+    }
+}
+
+
+function addToProfile(profile: MeasureProfile, ownTimeObj: OwnTimeObj, stillOpen?: boolean) {
+    let name = ownTimeObj.name;
+    let entry = profile.entries[name];
+    if (!entry) {
+        entry = {
+            name: name,
+            ownTime: createStatsValue(),
+            totalTime: createStatsValue(),
+            stillOpenCount: 0,
+        };
+        profile.entries[name] = entry;
+    }
+    addToStatsValue(entry.ownTime, ownTimeObj.ownTime);
+    addToStatsValue(entry.totalTime, ownTimeObj.time);
+    if (stillOpen) {
+        entry.stillOpenCount++;
+    }
+}

package/src/profiling/stats.ts

@@ -0,0 +1,213 @@
+export interface StatsValue {
+    count: number;
+    sum: number;
+    sumSquares: number;
+
+    // All logs use base 10
+    //  This supports values from 0.1ns to 1 week
+    logn7Value: number; logn7Count: number; logn6Value: number; logn6Count: number; logn5Value: number; logn5Count: number; logn4Value: number; logn4Count: number; logn3Value: number; logn3Count: number; logn2Value: number; logn2Count: number; logn1Value: number; logn1Count: number; log0Value: number; log0VCount: number; log1Value: number; log1VCount: number; log2Value: number; log2VCount: number; log3Value: number; log3VCount: number; log4Value: number; log4VCount: number; log5Value: number; log5VCount: number; log6Value: number; log6VCount: number; log7Value: number; log7VCount: number; log8Value: number; log8VCount: number; log9Value: number; log9VCount: number;
+}
+
+export function createStatsValue(): StatsValue {
+    return {
+        count: 0,
+        sum: 0,
+        sumSquares: 0,
+        logn7Value: 0, logn7Count: 0, logn6Value: 0, logn6Count: 0, logn5Value: 0, logn5Count: 0, logn4Value: 0, logn4Count: 0, logn3Value: 0, logn3Count: 0, logn2Value: 0, logn2Count: 0, logn1Value: 0, logn1Count: 0, log0Value: 0, log0VCount: 0, log1Value: 0, log1VCount: 0, log2Value: 0, log2VCount: 0, log3Value: 0, log3VCount: 0, log4Value: 0, log4VCount: 0, log5Value: 0, log5VCount: 0, log6Value: 0, log6VCount: 0, log7Value: 0, log7VCount: 0, log8Value: 0, log8VCount: 0, log9Value: 0, log9VCount: 0,
+    };
+}
+
+// TIMING: Between 5.6ns and 8ns, depending on the size of the value (smaller values are faster to add)
+//  - A C++ implementation takes about 3.5ns, so... this is pretty fast!
+export function addToStatsValue(stats: StatsValue, value: number) {
+    stats.count++;
+    stats.sum += value;
+    stats.sumSquares += value * value;
+    if (value < 0.000001) {
+        stats.logn7Value += value;
+        stats.logn7Count++;
+    } else if (value < 0.00001) {
+        stats.logn6Value += value;
+        stats.logn6Count++;
+    } else if (value < 0.0001) {
+        stats.logn5Value += value;
+        stats.logn5Count++;
+    } else if (value < 0.001) {
+        stats.logn4Value += value;
+        stats.logn4Count++;
+    } else if (value < 0.01) {
+        stats.logn3Value += value;
+        stats.logn3Count++;
+    } else if (value < 0.1) {
+        stats.logn2Value += value;
+        stats.logn2Count++;
+    } else if (value < 1) {
+        stats.logn1Value += value;
+        stats.logn1Count++;
+    } else if (value < 10) {
+        stats.log0Value += value;
+        stats.log0VCount++;
+    } else if (value < 100) {
+        stats.log1Value += value;
+        stats.log1VCount++;
+    } else if (value < 1000) {
+        stats.log2Value += value;
+        stats.log2VCount++;
+    } else if (value < 10000) {
+        stats.log3Value += value;
+        stats.log3VCount++;
+    } else if (value < 100000) {
+        stats.log4Value += value;
+        stats.log4VCount++;
+    } else if (value < 1000000) {
+        stats.log5Value += value;
+        stats.log5VCount++;
+    } else if (value < 10000000) {
+        stats.log6Value += value;
+        stats.log6VCount++;
+    } else if (value < 100000000) {
+        stats.log7Value += value;
+        stats.log7VCount++;
+    } else if (value < 1000000000) {
+        stats.log8Value += value;
+        stats.log8VCount++;
+    } else {
+        stats.log9Value += value;
+        stats.log9VCount++;
+    }
+}
+
+export function addToStats(stats: StatsValue, other: StatsValue) {
+    stats.count += other.count;
+    stats.sum += other.sum;
+    stats.sumSquares += other.sumSquares;
+    stats.logn7Value += other.logn7Value;
+    stats.logn7Count += other.logn7Count;
+    stats.logn6Value += other.logn6Value;
+    stats.logn6Count += other.logn6Count;
+    stats.logn5Value += other.logn5Value;
+    stats.logn5Count += other.logn5Count;
+    stats.logn4Value += other.logn4Value;
+    stats.logn4Count += other.logn4Count;
+    stats.logn3Value += other.logn3Value;
+    stats.logn3Count += other.logn3Count;
+    stats.logn2Value += other.logn2Value;
+    stats.logn2Count += other.logn2Count;
+    stats.logn1Value += other.logn1Value;
+    stats.logn1Count += other.logn1Count;
+    stats.log0Value += other.log0Value;
+    stats.log0VCount += other.log0VCount;
+    stats.log1Value += other.log1Value;
+    stats.log1VCount += other.log1VCount;
+    stats.log2Value += other.log2Value;
+    stats.log2VCount += other.log2VCount;
+    stats.log3Value += other.log3Value;
+    stats.log3VCount += other.log3VCount;
+    stats.log4Value += other.log4Value;
+    stats.log4VCount += other.log4VCount;
+    stats.log5Value += other.log5Value;
+    stats.log5VCount += other.log5VCount;
+    stats.log6Value += other.log6Value;
+    stats.log6VCount += other.log6VCount;
+    stats.log7Value += other.log7Value;
+    stats.log7VCount += other.log7VCount;
+    stats.log8Value += other.log8Value;
+    stats.log8VCount += other.log8VCount;
+    stats.log9Value += other.log9Value;
+    stats.log9VCount += other.log9VCount;
+}
+
+interface StatsBucket {
+    sum: number;
+    count: number;
+}
+// Ordered from lowest average to highest average
+function getStatsBuckets(stats: StatsValue): StatsBucket[] {
+    return [
+        { sum: stats.logn7Value, count: stats.logn7Count },
+        { sum: stats.logn6Value, count: stats.logn6Count },
+        { sum: stats.logn5Value, count: stats.logn5Count },
+        { sum: stats.logn4Value, count: stats.logn4Count },
+        { sum: stats.logn3Value, count: stats.logn3Count },
+        { sum: stats.logn2Value, count: stats.logn2Count },
+        { sum: stats.logn1Value, count: stats.logn1Count },
+        { sum: stats.log0Value, count: stats.log0VCount },
+        { sum: stats.log1Value, count: stats.log1VCount },
+        { sum: stats.log2Value, count: stats.log2VCount },
+        { sum: stats.log3Value, count: stats.log3VCount },
+        { sum: stats.log4Value, count: stats.log4VCount },
+        { sum: stats.log5Value, count: stats.log5VCount },
+        { sum: stats.log6Value, count: stats.log6VCount },
+        { sum: stats.log7Value, count: stats.log7VCount },
+        { sum: stats.log8Value, count: stats.log8VCount },
+        { sum: stats.log9Value, count: stats.log9VCount },
+    ];
+}
+
+export interface StatsTop {
+    // NOTE: countFraction <= valueFraction, because we take the largest values
+    countFraction: number;
+    valueFraction: number;
+    count: number;
+    value: number;
+    topHeavy: boolean;
+}
+/** Identifies cases where the value is concentrated in few instances. This indicates most of the value (time)
+ *      is not spent on the common case, but on an outlier. Which isn't a problem, it just means that the measurements
+ *      should be more precise, to pull that heavy case out.
+ */
+export function getStatsTop(stats: StatsValue): StatsTop {
+    if (stats.sum === 0) {
+        return { countFraction: 1, valueFraction: 1, count: 0, value: 0, topHeavy: false, };
+    }
+
+    const minFraction = 0.2;
+
+    let totalSum = stats.sum;
+    let totalCount = stats.count;
+    let totalMean = totalSum / totalCount;
+
+    // Find the sum above the average (with a minimum of minFraction, as sometimes there isn't really anything above the average)
+    let buckets = getStatsBuckets(stats);
+    buckets.reverse();
+
+    let curSum = 0;
+    let curCount = 0;
+    for (let entry of buckets) {
+        let mean = entry.sum / entry.count;
+        if (curSum > totalSum * minFraction && mean < totalMean) break;
+
+        curSum += entry.sum;
+        curCount += entry.count;
+    }
+
+    let countFraction = curCount / totalCount;
+    let valueFraction = curSum / totalSum;
+
+    return {
+        countFraction,
+        valueFraction,
+        count: curCount,
+        value: curSum,
+        // If more than 50% is above the average, it's top heavy
+        topHeavy: valueFraction / countFraction > 2 && valueFraction > 0.4,
+    };
+}
+
+
+
+
+
+function benchmarkAddToStats() {
+    let stats = createStatsValue();
+    let start = Date.now();
+    const count = 1000000;
+    for (let i = 0; i < count; i++) {
+        addToStatsValue(stats, 10000000000);
+    }
+    let end = Date.now();
+    let time = end - start;
+    let timePer = (time) / count * 1000 * 1000;
+    console.log(`Time per: ${timePer}ns, in ${time}ms`);
+}
+//benchmarkAddToStats();

package/src/profiling/tcpLagProxy.ts

@@ -0,0 +1,64 @@
+import net from "net";
+import { pipeline, PipelineTransform, PipelineTransformSource, Transform } from "stream";
+
+export async function tcpLagProxy(config: {
+    localPort: number;
+    remoteHost: string;
+    remotePort: number;
+    // NOTE: Lag values between 1 and 10 are about the same, as setTimeout introduces a minimum delay.
+    //  As a result lag values of 0 are about 2X faster than lag values of 1.
+    lag: number;
+    networkWriteSize?: { value: number };
+    networkReadSize?: { value: number };
+    networkWritePackets?: { value: number };
+    networkReadPackets?: { value: number };
+}) {
+    const { localPort, remoteHost, remotePort, lag, networkWriteSize, networkReadSize, networkWritePackets, networkReadPackets } = config;
+    let server = net.createServer();
+
+    server.on("connection", async socket => {
+        // Swallow all errors, as the pipe should handle it anyways?
+        socket.on("error", () => { });
+        if (lag > 0) {
+            await new Promise(r => setTimeout(r, lag));
+        }
+        let remoteSocket = net.createConnection(remotePort, remoteHost);
+        remoteSocket.on("error", () => { });
+
+        const lagWrite = new Transform({
+            transform(chunk, encoding, callback) {
+                if (lag > 0) {
+                    setTimeout(() => callback(undefined, chunk), lag);
+                } else {
+                    callback(undefined, chunk);
+                }
+            },
+        });
+        const lagRead = new Transform({
+            transform(chunk, encoding, callback) {
+                if (lag > 0) {
+                    setTimeout(() => callback(undefined, chunk), lag);
+                } else {
+                    callback(undefined, chunk);
+                }
+            },
+        });
+
+        socket.pipe(lagWrite).pipe(remoteSocket);
+        remoteSocket.pipe(lagRead).pipe(socket);
+
+        socket.on("data", data => {
+            if (networkWriteSize) networkWriteSize.value += data.length;
+            if (networkWritePackets) networkWritePackets.value++;
+        });
+        remoteSocket.on("data", data => {
+            if (networkReadSize) networkReadSize.value += data.length;
+            if (networkReadPackets) networkReadPackets.value++;
+        });
+    });
+    server.listen(localPort);
+    return new Promise<void>((resolve, reject) => {
+        server.on("listening", () => resolve());
+        server.on("error", reject);
+    });
+}

package/src/types.ts

@@ -4,6 +4,6 @@ export type Args<T> = T extends (...args: infer V) => any ? V : never;
 
 export type AnyFunction = (...args: any) => any;
 
-export function canHaveChildren(value: unknown): value is object {
+export function canHaveChildren(value: unknown): value is { [key in PropertyKey]: unknown } {
     return typeof value === "object" && value !== null || typeof value === "function";
 }