@undefineds.co/xpod 0.3.53 → 0.3.54

package/dist/storage/rdf/PostgresRdfEngine.jsonld

@@ -512,6 +512,10 @@
           "@id": "undefineds:dist/storage/rdf/PostgresRdfEngine.jsonld#PostgresRdfEngine__member_insertQuads",
           "memberFieldName": "insertQuads"
         },
+        {
+          "@id": "undefineds:dist/storage/rdf/PostgresRdfEngine.jsonld#PostgresRdfEngine__member_withRetryableWrite",
+          "memberFieldName": "withRetryableWrite"
+        },
         {
           "@id": "undefineds:dist/storage/rdf/PostgresRdfEngine.jsonld#PostgresRdfEngine__member_deleteExactQuad",
           "memberFieldName": "deleteExactQuad"

package/dist/test-utils/index.d.ts

@@ -2,3 +2,5 @@ export { startNoAuthXpod } from './no-auth-xpod';
 export type { NoAuthXpodOptions } from './no-auth-xpod';
 export { seedPod } from './seed-pod';
 export type { SeedPodOptions } from './seed-pod';
+export { runLocalManagedClientP2PE2ESmoke } from './local-managed-client-p2p-e2e-smoke';
+export type { LocalManagedClientP2PE2ESmokeOptions, LocalManagedClientP2PE2ESmokeResult } from './local-managed-client-p2p-e2e-smoke';

package/dist/test-utils/index.js

@@ -1,8 +1,10 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.seedPod = exports.startNoAuthXpod = void 0;
+exports.runLocalManagedClientP2PE2ESmoke = exports.seedPod = exports.startNoAuthXpod = void 0;
 var no_auth_xpod_1 = require("./no-auth-xpod");
 Object.defineProperty(exports, "startNoAuthXpod", { enumerable: true, get: function () { return no_auth_xpod_1.startNoAuthXpod; } });
 var seed_pod_1 = require("./seed-pod");
 Object.defineProperty(exports, "seedPod", { enumerable: true, get: function () { return seed_pod_1.seedPod; } });
+var local_managed_client_p2p_e2e_smoke_1 = require("./local-managed-client-p2p-e2e-smoke");
+Object.defineProperty(exports, "runLocalManagedClientP2PE2ESmoke", { enumerable: true, get: function () { return local_managed_client_p2p_e2e_smoke_1.runLocalManagedClientP2PE2ESmoke; } });
 //# sourceMappingURL=index.js.map

package/dist/test-utils/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/test-utils/index.ts"],"names":[],"mappings":";;;AAAA,+CAAiD;AAAxC,+GAAA,eAAe,OAAA;AAExB,uCAAqC;AAA5B,mGAAA,OAAO,OAAA","sourcesContent":["export { startNoAuthXpod } from './no-auth-xpod';\nexport type { NoAuthXpodOptions } from './no-auth-xpod';\nexport { seedPod } from './seed-pod';\nexport type { SeedPodOptions } from './seed-pod';\n"]}
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/test-utils/index.ts"],"names":[],"mappings":";;;AAAA,+CAAiD;AAAxC,+GAAA,eAAe,OAAA;AAExB,uCAAqC;AAA5B,mGAAA,OAAO,OAAA;AAEhB,2FAAwF;AAA/E,sJAAA,gCAAgC,OAAA","sourcesContent":["export { startNoAuthXpod } from './no-auth-xpod';\nexport type { NoAuthXpodOptions } from './no-auth-xpod';\nexport { seedPod } from './seed-pod';\nexport type { SeedPodOptions } from './seed-pod';\nexport { runLocalManagedClientP2PE2ESmoke } from './local-managed-client-p2p-e2e-smoke';\nexport type { LocalManagedClientP2PE2ESmokeOptions, LocalManagedClientP2PE2ESmokeResult } from './local-managed-client-p2p-e2e-smoke';\n"]}

package/dist/test-utils/local-managed-client-p2p-e2e-smoke.d.ts

@@ -0,0 +1,63 @@
+import { type ManagedClientP2PSmokeResult, type NodeRawTcpP2PConnectSocketEvent, type RawTcpP2PConnectAttempt } from '../edge/reachability';
+export type LocalManagedClientP2PSocketMode = 'deterministic-injection' | 'real-tcp-listener';
+export interface LocalManagedClientP2PPlan {
+    bucket: number;
+    boundary: number;
+    rendezvousTimeSeconds: number;
+    ports: number[];
+}
+export interface LocalManagedClientP2PE2ESmokeOptions {
+    nodeName?: string;
+    clientId?: string;
+    baseStorageDomain?: string;
+    resourcePath?: string;
+    targetBody?: string;
+    p2pHost?: string;
+    advertiseClientHost?: boolean;
+    advertiseNodeHost?: boolean;
+    routeWaitTimeoutMs?: number;
+    pollIntervalMs?: number;
+    connectTimeoutMs?: number;
+    requestTimeoutMs?: number;
+    socketMode?: LocalManagedClientP2PSocketMode;
+}
+export interface LocalManagedClientP2PE2ESmokeResult {
+    smokeOk: boolean;
+    nodeId: string;
+    apiBaseUrl: string;
+    targetBaseUrl: string;
+    resourceUrl: string;
+    plan: LocalManagedClientP2PPlan;
+    clientPlan: LocalManagedClientP2PPlan;
+    nodePlan: LocalManagedClientP2PPlan;
+    smoke: ManagedClientP2PSmokeResult;
+    p2pAttempts: {
+        client: RawTcpP2PConnectAttempt[];
+        node: RawTcpP2PConnectAttempt[];
+    };
+    connectorEvents: {
+        client: LocalManagedClientP2PConnectorEvent[];
+        node: LocalManagedClientP2PConnectorEvent[];
+    };
+    targetRequests: Array<{
+        method: string;
+        url: string;
+        headers: Record<string, string | string[] | undefined>;
+    }>;
+    evidence: {
+        routeDiscovery: 'p2p-route-published';
+        signaling: 'repository-backed-api';
+        dataPlane: 'deterministic-socket-injection' | 'real-local-tcp-listener';
+        canonicalFetch: 'xpod-p2p-http/1';
+        clientAddress: 'explicit-host' | 'signal-observed';
+        nodeAddress: 'explicit-host' | 'signal-observed';
+    };
+    caveats: string[];
+}
+export interface LocalManagedClientP2PConnectorEvent {
+    type: NodeRawTcpP2PConnectSocketEvent['type'];
+    localPort?: number;
+    remotePort: number;
+    message?: string;
+}
+export declare function runLocalManagedClientP2PE2ESmoke(options?: LocalManagedClientP2PE2ESmokeOptions): Promise<LocalManagedClientP2PE2ESmokeResult>;

package/dist/test-utils/local-managed-client-p2p-e2e-smoke.js

@@ -0,0 +1,478 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runLocalManagedClientP2PE2ESmoke = runLocalManagedClientP2PE2ESmoke;
+const node_http_1 = require("node:http");
+const node_net_1 = require("node:net");
+const ApiServer_1 = require("../api/ApiServer");
+const MultiAuthenticator_1 = require("../api/auth/MultiAuthenticator");
+const NodeTokenAuthenticator_1 = require("../api/auth/NodeTokenAuthenticator");
+const ServiceTokenAuthenticator_1 = require("../api/auth/ServiceTokenAuthenticator");
+const EdgeNodeSignalHandler_1 = require("../api/handlers/EdgeNodeSignalHandler");
+const ReachabilityHandler_1 = require("../api/handlers/ReachabilityHandler");
+const AuthMiddleware_1 = require("../api/middleware/AuthMiddleware");
+const EdgeNodeAgent_1 = require("../edge/EdgeNodeAgent");
+const reachability_1 = require("../edge/reachability");
+const EdgeNodeRepository_1 = require("../identity/drizzle/EdgeNodeRepository");
+const db_1 = require("../identity/drizzle/db");
+const ServiceTokenRepository_1 = require("../identity/drizzle/ServiceTokenRepository");
+async function runLocalManagedClientP2PE2ESmoke(options = {}) {
+    const cleanupStack = [];
+    const nodeName = options.nodeName ?? 'local-p2p-node';
+    const clientId = options.clientId ?? `managed-client-${process.pid}`;
+    const baseStorageDomain = options.baseStorageDomain ?? 'pods.example';
+    const resourcePath = normalizeResourcePath(options.resourcePath ?? '/alice/local-p2p-e2e.txt?version=1');
+    const targetBody = options.targetBody ?? 'local p2p e2e response';
+    const p2pHost = options.p2pHost ?? '127.0.0.1';
+    const advertiseClientHost = options.advertiseClientHost ?? true;
+    const advertiseNodeHost = options.advertiseNodeHost ?? true;
+    const routeWaitTimeoutMs = options.routeWaitTimeoutMs ?? 2_000;
+    const pollIntervalMs = options.pollIntervalMs ?? 10;
+    const connectTimeoutMs = options.connectTimeoutMs ?? 1_000;
+    const requestTimeoutMs = options.requestTimeoutMs ?? 2_000;
+    const socketMode = options.socketMode ?? 'deterministic-injection';
+    try {
+        const db = (0, db_1.getIdentityDatabase)(`sqlite::memory:p2p-local-e2e-${Date.now()}-${Math.random()}`);
+        const nodeRepo = new EdgeNodeRepository_1.EdgeNodeRepository(db);
+        const serviceTokenRepo = new ServiceTokenRepository_1.ServiceTokenRepository(db);
+        const { nodeId, token: nodeToken } = await nodeRepo.createNode(nodeName);
+        const { token: serviceToken } = await serviceTokenRepo.createToken({
+            serviceType: 'cloud',
+            serviceId: 'managed-client-smoke',
+            scopes: ['reachability:read', 'reachability:write'],
+        });
+        const signalApi = await startSignalApi({
+            nodeRepo,
+            serviceTokenRepo,
+            baseStorageDomain,
+        });
+        cleanupStack.push(() => signalApi.close());
+        const target = await startTargetServer({ resourcePath, targetBody });
+        cleanupStack.push(() => target.close());
+        const p2pAttempts = { client: [], node: [] };
+        const connectorEvents = { client: [], node: [] };
+        const clientPort = await reserveTcpPort();
+        const plan = {
+            bucket: 9_001,
+            boundary: 9_001,
+            rendezvousTimeSeconds: 0,
+            ports: [clientPort],
+        };
+        let nodePlan = plan;
+        let clientConnectSocket;
+        let responderDebug;
+        if (socketMode === 'real-tcp-listener') {
+            await publishP2PRoute({
+                repository: nodeRepo,
+                nodeId,
+                baseUrl: `https://${nodeId}.${baseStorageDomain}/`,
+            });
+            const dataPlaneServer = (0, reachability_1.createTcpP2PDataPlaneServer)({
+                handler: (0, reachability_1.createP2PDataPlaneHandler)({ targetBaseUrl: target.baseUrl }),
+                host: p2pHost,
+            });
+            await dataPlaneServer.listen(0);
+            nodePlan = {
+                ...plan,
+                ports: [dataPlaneServer.address().port],
+            };
+            cleanupStack.push(() => dataPlaneServer.close());
+            const responder = startRealTcpNodeCandidateResponder({
+                apiBaseUrl: signalApi.baseUrl,
+                nodeId,
+                nodeToken,
+                host: advertiseNodeHost ? p2pHost : undefined,
+                clientPlan: plan,
+                nodePlan,
+            });
+            responderDebug = responder.diagnostics;
+            cleanupStack.push(() => responder.stop());
+            const nodeConnector = (0, reachability_1.createNodeRawTcpP2PConnectSocket)({
+                onEvent: (event) => connectorEvents.client.push(summarizeConnectorEvent(event)),
+            });
+            clientConnectSocket = async (attempt) => {
+                p2pAttempts.client.push(attempt);
+                return nodeConnector(attempt);
+            };
+        }
+        else {
+            const socketPair = await createSocketPair();
+            cleanupStack.push(() => socketPair.close());
+            const agent = new EdgeNodeAgent_1.EdgeNodeAgent();
+            cleanupStack.push(() => agent.stop());
+            const initialHeartbeat = createDeferred();
+            let heartbeatResponseSeen = false;
+            await agent.start({
+                signalEndpoint: `${signalApi.baseUrl}/v1/signal`,
+                nodeId,
+                nodeToken,
+                baseUrl: `https://${nodeId}.${baseStorageDomain}/`,
+                enableNetworkDetection: false,
+                onHeartbeatResponse: () => {
+                    heartbeatResponseSeen = true;
+                    initialHeartbeat.resolve();
+                },
+                p2p: {
+                    enabled: true,
+                    targetBaseUrl: target.baseUrl,
+                    ...(advertiseNodeHost ? { host: p2pHost } : {}),
+                    acceptIntervalMs: 20,
+                    connectTimeoutMs,
+                    winnerSelectionWindowMs: 0,
+                    connectSocket: async (attempt) => {
+                        p2pAttempts.node.push(attempt);
+                        return socketPair.serverSocket;
+                    },
+                },
+            });
+            clientConnectSocket = async (attempt) => {
+                p2pAttempts.client.push(attempt);
+                return socketPair.clientSocket;
+            };
+            try {
+                await initialHeartbeat.wait(routeWaitTimeoutMs, 'initial P2P heartbeat was not acknowledged before route discovery');
+            }
+            catch (error) {
+                const metadata = await nodeRepo.getNodeMetadata(nodeId);
+                throw new Error(`${error instanceof Error ? error.message : String(error)}; heartbeatResponseSeen=${heartbeatResponseSeen}; signalApi=${signalApi.baseUrl}; nodeMetadata=${JSON.stringify(metadata?.metadata ?? null)}`);
+            }
+        }
+        await waitForRoute({
+            apiBaseUrl: signalApi.baseUrl,
+            nodeId,
+            token: serviceToken,
+            predicate: (route) => route.kind === 'p2p' && route.targetUrl.startsWith('tcp-punch://'),
+            timeoutMs: routeWaitTimeoutMs,
+        });
+        const resourceUrl = `https://${nodeId}.${baseStorageDomain}${resourcePath}`;
+        let smoke;
+        try {
+            smoke = await (0, reachability_1.runManagedClientP2PSmoke)({
+                apiBaseUrl: signalApi.baseUrl,
+                nodeId,
+                token: serviceToken,
+                clientId,
+                resourceUrl,
+                plan,
+                pollIntervalMs,
+                waitTimeoutMs: routeWaitTimeoutMs,
+                connectTimeoutMs,
+                timeoutMs: requestTimeoutMs,
+                ...(advertiseClientHost ? { host: p2pHost } : {}),
+                ...(clientConnectSocket ? { connectSocket: clientConnectSocket } : {}),
+            });
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : String(error);
+            throw new Error(`${message}; responder=${JSON.stringify(responderDebug?.() ?? null)}`);
+        }
+        return {
+            smokeOk: smoke.ok && smoke.route.kind === 'p2p',
+            nodeId,
+            apiBaseUrl: signalApi.baseUrl,
+            targetBaseUrl: target.baseUrl,
+            resourceUrl,
+            plan,
+            clientPlan: plan,
+            nodePlan,
+            smoke,
+            p2pAttempts,
+            connectorEvents,
+            targetRequests: target.requests,
+            evidence: {
+                routeDiscovery: 'p2p-route-published',
+                signaling: 'repository-backed-api',
+                dataPlane: socketMode === 'real-tcp-listener' ? 'real-local-tcp-listener' : 'deterministic-socket-injection',
+                canonicalFetch: 'xpod-p2p-http/1',
+                clientAddress: advertiseClientHost ? 'explicit-host' : 'signal-observed',
+                nodeAddress: advertiseNodeHost ? 'explicit-host' : 'signal-observed',
+            },
+            caveats: [
+                socketMode === 'real-tcp-listener'
+                    ? 'This local smoke uses a real loopback TCP listener, but still does not prove cross-NAT TCP simultaneous open.'
+                    : 'This local smoke does not prove real cross-NAT TCP simultaneous open.',
+                'Cloudflare Tunnel and FRP/SakuraFRP remain independent user-tunnel fallback routes.',
+            ],
+        };
+    }
+    finally {
+        while (cleanupStack.length > 0) {
+            const cleanup = cleanupStack.pop();
+            await cleanup();
+        }
+        await (0, db_1.closeAllIdentityConnections)();
+    }
+}
+function summarizeConnectorEvent(event) {
+    return {
+        type: event.type,
+        ...(event.attempt.localPort ? { localPort: event.attempt.localPort } : {}),
+        remotePort: event.attempt.remotePort,
+        ...(event.error ? { message: event.error.message } : {}),
+    };
+}
+async function publishP2PRoute(options) {
+    await options.repository.updateNodeHeartbeat(options.nodeId, {
+        baseUrl: options.baseUrl,
+        routes: [
+            {
+                id: 'p2p-raw-tcp',
+                nodeId: options.nodeId,
+                canonicalUrl: options.baseUrl,
+                kind: 'p2p',
+                targetUrl: `tcp-punch://node/${encodeURIComponent(options.nodeId)}`,
+                priority: 40,
+                requiresManagedClient: true,
+                visibility: 'authorized-client',
+                health: 'healthy',
+                metadata: {
+                    protocols: {
+                        'raw-tcp-hole-punch': { enabled: true },
+                    },
+                },
+            },
+        ],
+    }, new Date());
+}
+function startRealTcpNodeCandidateResponder(options) {
+    const signaling = (0, reachability_1.createP2PSignalingClient)({
+        apiBaseUrl: options.apiBaseUrl,
+        nodeId: options.nodeId,
+        token: options.nodeToken,
+    });
+    let stopped = false;
+    const debugState = { listCount: 0, sessionCount: 0, addCount: 0, lastError: '', lastSessions: [] };
+    const run = async () => {
+        while (!stopped) {
+            try {
+                const sessions = await signaling.listP2PSessions();
+                debugState.listCount += 1;
+                debugState.sessionCount = sessions.length;
+                debugState.lastSessions = sessions.map((session) => ({ sessionId: session.sessionId, signalingUrl: session.signalingUrl, candidates: session.candidates.map((candidate) => ({ role: candidate.role, sourceId: candidate.sourceId, port: candidate.port, host: candidate.host, address: candidate.address, url: candidate.url, metadata: candidate.metadata })) }));
+                for (const session of sessions) {
+                    const hasClientCandidate = session.candidates.some((candidate) => candidate.role === 'client'
+                        && candidate.metadata?.bucket === options.clientPlan.bucket);
+                    const hasNodeCandidate = session.candidates.some((candidate) => candidate.role === 'node'
+                        && candidate.sourceId === options.nodeId
+                        && candidate.metadata?.bucket === options.nodePlan.bucket);
+                    if (!hasClientCandidate || hasNodeCandidate) {
+                        continue;
+                    }
+                    const candidates = (0, reachability_1.createRawTcpHolePunchCandidates)({
+                        role: 'node',
+                        sourceId: options.nodeId,
+                        host: options.host,
+                        plan: options.nodePlan,
+                    });
+                    const answered = await signaling.addP2PCandidates(session.signalingUrl || session.sessionId, {
+                        role: 'node',
+                        sourceId: options.nodeId,
+                        candidates,
+                    });
+                    debugState.addCount += 1;
+                    debugState.lastSessions = [{ sessionId: answered.sessionId, signalingUrl: answered.signalingUrl, candidates: answered.candidates.map((candidate) => ({ role: candidate.role, sourceId: candidate.sourceId, port: candidate.port, host: candidate.host, address: candidate.address, url: candidate.url, metadata: candidate.metadata })) }];
+                }
+            }
+            catch (error) {
+                debugState.lastError = error instanceof Error ? `${error.name}: ${error.message}` : String(error);
+            }
+            await sleep(10);
+        }
+    };
+    const done = run();
+    return {
+        async stop() {
+            stopped = true;
+            await done;
+        },
+        diagnostics: () => ({ ...debugState }),
+    };
+}
+async function startSignalApi(options) {
+    const authenticator = new MultiAuthenticator_1.MultiAuthenticator({
+        authenticators: [
+            new ServiceTokenAuthenticator_1.ServiceTokenAuthenticator({ repository: options.serviceTokenRepo }),
+            new NodeTokenAuthenticator_1.NodeTokenAuthenticator({ repository: options.nodeRepo }),
+        ],
+    });
+    const server = new ApiServer_1.ApiServer({
+        port: 0,
+        host: '127.0.0.1',
+        authMiddleware: new AuthMiddleware_1.AuthMiddleware({ authenticator }),
+    });
+    let baseUrl = 'http://127.0.0.1:0';
+    (0, EdgeNodeSignalHandler_1.registerEdgeNodeSignalRoutes)(server, { repository: options.nodeRepo });
+    (0, ReachabilityHandler_1.registerReachabilityRoutes)(server, {
+        repository: options.nodeRepo,
+        baseStorageDomain: options.baseStorageDomain,
+        apiBaseUrl: () => baseUrl,
+    });
+    await server.start();
+    const address = server.address();
+    if (!address || typeof address === 'string') {
+        await server.stop();
+        throw new Error('Expected signal API TCP address info');
+    }
+    baseUrl = `http://127.0.0.1:${address.port}`;
+    return {
+        baseUrl,
+        close: () => server.stop(),
+    };
+}
+async function startTargetServer(options) {
+    const requests = [];
+    const server = (0, node_http_1.createServer)((request, response) => {
+        requests.push({
+            method: request.method ?? 'GET',
+            url: request.url ?? '/',
+            headers: request.headers,
+        });
+        if (request.url === options.resourcePath) {
+            response.statusCode = 200;
+            response.setHeader('content-type', 'text/plain');
+            response.end(options.targetBody);
+            return;
+        }
+        response.statusCode = 404;
+        response.end('not found');
+    });
+    await new Promise((resolve, reject) => {
+        server.once('error', reject);
+        server.listen(0, '127.0.0.1', resolve);
+    });
+    const address = server.address();
+    if (!address || typeof address === 'string') {
+        throw new Error('Expected target HTTP server address info');
+    }
+    return {
+        baseUrl: `http://127.0.0.1:${address.port}/`,
+        requests,
+        close: () => closeHttpServer(server),
+    };
+}
+async function waitForRoute(options) {
+    const startedAt = Date.now();
+    let lastError = '';
+    while (Date.now() - startedAt < options.timeoutMs) {
+        try {
+            const response = await fetch(new URL(`/v1/signal/nodes/${encodeURIComponent(options.nodeId)}/routes`, options.apiBaseUrl), {
+                headers: {
+                    authorization: `Bearer ${options.token}`,
+                    accept: 'application/json',
+                },
+            });
+            if (!response.ok) {
+                lastError = `${response.status} ${await response.text()}`;
+            }
+            else {
+                const body = await response.json();
+                const route = body.routes?.find(options.predicate);
+                if (route) {
+                    return route;
+                }
+                lastError = JSON.stringify(body);
+            }
+        }
+        catch (error) {
+            lastError = error instanceof Error ? error.message : String(error);
+        }
+        await sleep(20);
+    }
+    throw new Error(`Timed out waiting for P2P route: ${lastError}`);
+}
+async function reserveTcpPort() {
+    const server = (0, node_net_1.createServer)();
+    await new Promise((resolve, reject) => {
+        server.once('error', reject);
+        server.listen(0, '127.0.0.1', resolve);
+    });
+    const address = server.address();
+    if (!address || typeof address === 'string') {
+        throw new Error('Expected TCP address info');
+    }
+    await closeTcpServer(server);
+    return address.port;
+}
+async function createSocketPair() {
+    const server = (0, node_net_1.createServer)();
+    const serverSocketPromise = new Promise((resolve) => {
+        server.once('connection', resolve);
+    });
+    await new Promise((resolve, reject) => {
+        server.once('error', reject);
+        server.listen(0, '127.0.0.1', resolve);
+    });
+    const address = server.address();
+    const clientSocket = await new Promise((resolve, reject) => {
+        const socket = (0, node_net_1.createConnection)({ host: '127.0.0.1', port: address.port });
+        socket.once('connect', () => resolve(socket));
+        socket.once('error', reject);
+    });
+    const serverSocket = await serverSocketPromise;
+    return {
+        clientSocket,
+        serverSocket,
+        async close() {
+            clientSocket.destroy();
+            serverSocket.destroy();
+            await closeTcpServer(server);
+        },
+    };
+}
+function normalizeResourcePath(value) {
+    if (!value.startsWith('/')) {
+        return `/${value}`;
+    }
+    return value;
+}
+function closeHttpServer(server) {
+    return new Promise((resolve, reject) => {
+        server.close((error) => error ? reject(error) : resolve());
+    });
+}
+function closeTcpServer(server) {
+    return new Promise((resolve, reject) => {
+        server.close((error) => error ? reject(error) : resolve());
+    });
+}
+function sleep(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+}
+function createDeferred() {
+    let settled = false;
+    let resolve;
+    let reject;
+    const promise = new Promise((promiseResolve, promiseReject) => {
+        resolve = (value) => {
+            settled = true;
+            promiseResolve(value);
+        };
+        reject = (reason) => {
+            settled = true;
+            promiseReject(reason);
+        };
+    });
+    return {
+        resolve,
+        reject,
+        wait: async (timeoutMs, timeoutMessage) => {
+            if (settled) {
+                return promise;
+            }
+            let timeout;
+            try {
+                return await Promise.race([
+                    promise,
+                    new Promise((_, timeoutReject) => {
+                        timeout = setTimeout(() => timeoutReject(new Error(timeoutMessage)), timeoutMs);
+                    }),
+                ]);
+            }
+            finally {
+                if (timeout) {
+                    clearTimeout(timeout);
+                }
+            }
+        },
+    };
+}
+//# sourceMappingURL=local-managed-client-p2p-e2e-smoke.js.map