@ibgib/core-gib 0.1.58 → 0.1.60

package/src/sync/sync-peer/sync-peer-websocket/README.md

@@ -0,0 +1,42 @@
+# WebSocket Sync Peers
+
+This directory contains the WebSocket client (sender) and server (receiver) peer implementations.
+
+## WebSocket Resource Management & Teardown
+
+Since WebSockets manage active OS-level TCP connections, they must be cleanly closed to prevent socket descriptor leaks on the client and resource exhaustion (DoS) on the server.
+
+### Analysis (2026-06-12T09:45:21-05:00)
+
+Our analysis highlights several areas where WebSocket connections are currently left open:
+
+1. **Sender Connect Failures**: If connection handshake fails or times out, the client rejects the promise but does not close the socket.
+2. **Sender Runtime Failures**: If runtime message validation fails, we throw an error but leave the socket open.
+3. **Sender Saga Completion**: When the sync loop finishes successfully, the socket is left open indefinitely because there is no `disconnect` method.
+4. **Receiver Message Handling Failures**: If incoming messages fail validation/authentication, the server sends a `sync_error` or `auth_fail` frame, but relies on the client to close the connection. A buggy/malicious client can leave it open forever.
+
+#### Design Questions & Ideas
+* **Idempotent `disconnect()`**: The disconnect method on the sender should clear `this.handshakeMessageListener` and set it to `undefined` so that multiple calls to `disconnect()` are safe.
+* **Reuse `disconnect()`**: In connection failure handlers (like `handleHandshakeAuthFail`), we can call `this.disconnect()` to ensure uniform cleanup.
+* **Server-side Close on Error (best-effort `send`)**: If a message fails, we want to notify the client first and then close the connection. If the `send()` itself throws, we want a safe cleanup. In JavaScript, we can nest `try..catch..finally` inside a `catch` block, or use a short `setTimeout` to push the socket close operation to the next event loop tick, ensuring the outgoing frame is written before the socket is terminated.
+
+---
+
+### Implementation TODOs
+
+- [x] **Implement `disconnect` method on `SyncPeerWebSocketSender_V1`**
+  - Implement a synchronous or asynchronous `disconnect()` method.
+  - Safely remove the message event listener `this.handshakeMessageListener`.
+  - Set `this.handshakeMessageListener = undefined` to make it idempotent.
+  - Close the WebSocket `this.ws.close()`.
+  
+- [x] **Clean up socket on Sender connection failures**
+  - Call `this.disconnect()` inside `handleHandshakeAuthFail`.
+  - Call `this.disconnect()` inside `handleHandshakeSyncError`.
+  
+- [x] **Close socket on Sender runtime message validation failures**
+  - In `handleRuntimeMessage` and `handleRuntimeSyncFrameResponse`, catch validation errors, trigger `this.disconnect()`, and rethrow.
+
+- [x] **Close socket on Receiver message handling failures**
+  - In the catch block of `handleIncomingMessage`, call `this.socketWrapper?.close()` (or equivalent wrapper cleanup) to force-close connections after sending error frames.
+  - Wrap the `send()` call in a nested try/catch or use `setTimeout` to ensure best-effort message transmission before terminating the socket wrapper.

package/src/sync/sync-peer/sync-peer-websocket/sync-peer-websocket-constants.mts

@@ -0,0 +1,68 @@
+// #region SyncWebSocketMsgType enum
+
+export const SYNC_WEB_SOCKET_MSG_TYPE_AUTH_CHALLENGE_INIT = 'auth-challenge-init';
+export const SYNC_WEB_SOCKET_MSG_TYPE_AUTH_INIT = 'auth-init';
+export const SYNC_WEB_SOCKET_MSG_TYPE_AUTH_CHALLENGE = 'auth-challenge';
+export const SYNC_WEB_SOCKET_MSG_TYPE_AUTH_PROOF = 'auth-proof';
+export const SYNC_WEB_SOCKET_MSG_TYPE_AUTH_OK = 'auth-ok';
+export const SYNC_WEB_SOCKET_MSG_TYPE_AUTH_FAIL = 'auth-fail';
+export const SYNC_WEB_SOCKET_MSG_TYPE_SYNC_FRAME = 'sync-frame';
+export const SYNC_WEB_SOCKET_MSG_TYPE_SYNC_FRAME_RESPONSE = 'sync-frame-response';
+export const SYNC_WEB_SOCKET_MSG_TYPE_SYNC_FRAME_AUTHENTICATED = 'sync-frame-authenticated';
+export const SYNC_WEB_SOCKET_MSG_TYPE_SYNC_FRAME_RESPONSE_AUTHENTICATED = 'sync-frame-response-authenticated';
+export const SYNC_WEB_SOCKET_MSG_TYPE_DOMAIN_PAYLOAD = 'domain-payload';
+export const SYNC_WEB_SOCKET_MSG_TYPE_SYNC_ERROR = 'sync-error';
+
+/**
+ * Message types transmitted over the stateful WebSocket connection
+ * during a sync saga session handshake and execution.
+ */
+export type SyncWebSocketMsgType =
+    | typeof SYNC_WEB_SOCKET_MSG_TYPE_AUTH_CHALLENGE_INIT
+    | typeof SYNC_WEB_SOCKET_MSG_TYPE_AUTH_INIT
+    | typeof SYNC_WEB_SOCKET_MSG_TYPE_AUTH_CHALLENGE
+    | typeof SYNC_WEB_SOCKET_MSG_TYPE_AUTH_PROOF
+    | typeof SYNC_WEB_SOCKET_MSG_TYPE_AUTH_OK
+    | typeof SYNC_WEB_SOCKET_MSG_TYPE_AUTH_FAIL
+    | typeof SYNC_WEB_SOCKET_MSG_TYPE_SYNC_FRAME
+    | typeof SYNC_WEB_SOCKET_MSG_TYPE_SYNC_FRAME_RESPONSE
+    | typeof SYNC_WEB_SOCKET_MSG_TYPE_SYNC_FRAME_AUTHENTICATED
+    | typeof SYNC_WEB_SOCKET_MSG_TYPE_SYNC_FRAME_RESPONSE_AUTHENTICATED
+    | typeof SYNC_WEB_SOCKET_MSG_TYPE_DOMAIN_PAYLOAD
+    | typeof SYNC_WEB_SOCKET_MSG_TYPE_SYNC_ERROR
+    ;
+
+export const SyncWebSocketMsgType = {
+    /** Sent by server/receiver to trigger connection authentication. */
+    auth_challenge_init: SYNC_WEB_SOCKET_MSG_TYPE_AUTH_CHALLENGE_INIT,
+    /** Sent by client/sender to start the authentication handshake with the target session address. */
+    auth_init: SYNC_WEB_SOCKET_MSG_TYPE_AUTH_INIT,
+    /** Sent by server/receiver with dynamic connect challenges to be solved. */
+    auth_challenge: SYNC_WEB_SOCKET_MSG_TYPE_AUTH_CHALLENGE,
+    /** Sent by client/sender with proof of session keystone evolution solving challenges. */
+    auth_proof: SYNC_WEB_SOCKET_MSG_TYPE_AUTH_PROOF,
+    /** Sent by server/receiver signaling successful challenge resolution and upgrade to active sync. */
+    auth_ok: SYNC_WEB_SOCKET_MSG_TYPE_AUTH_OK,
+    /** Sent when authentication fails. */
+    auth_fail: SYNC_WEB_SOCKET_MSG_TYPE_AUTH_FAIL,
+    /** Sent by client/sender to transmit the next sync transaction context without payload ibgibs. */
+    sync_frame: SYNC_WEB_SOCKET_MSG_TYPE_SYNC_FRAME,
+    /** Sent by server/receiver responding with the next sync transaction context. */
+    sync_frame_response: SYNC_WEB_SOCKET_MSG_TYPE_SYNC_FRAME_RESPONSE,
+    /** Sent by server/receiver after context is validated/authenticated to signal payload transmission. */
+    sync_frame_authenticated: SYNC_WEB_SOCKET_MSG_TYPE_SYNC_FRAME_AUTHENTICATED,
+    /** Sent by client/sender after response context is validated/authenticated to signal payload transmission. */
+    sync_frame_response_authenticated: SYNC_WEB_SOCKET_MSG_TYPE_SYNC_FRAME_RESPONSE_AUTHENTICATED,
+    /** Sent to stream a single domain payload ibgib. */
+    domain_payload: SYNC_WEB_SOCKET_MSG_TYPE_DOMAIN_PAYLOAD,
+    /** Sent when a sync runtime execution error occurs. */
+    sync_error: SYNC_WEB_SOCKET_MSG_TYPE_SYNC_ERROR,
+} satisfies { readonly [key: string]: SyncWebSocketMsgType };
+
+export const SYNC_WEB_SOCKET_MSG_TYPE_VALID_VALUES: SyncWebSocketMsgType[] = Object.values(SyncWebSocketMsgType);
+
+export function isSyncWebSocketMsgType(value: any): value is SyncWebSocketMsgType {
+    return SYNC_WEB_SOCKET_MSG_TYPE_VALID_VALUES.includes(value);
+}
+
+// #endregion SyncWebSocketMsgType enum

package/src/sync/sync-peer/{sync-peer-websocket-receiver → sync-peer-websocket/sync-peer-websocket-receiver}/sync-peer-websocket-receiver-types.mts

@@ -5,8 +5,8 @@ import { IbGib_V1 } from '@ibgib/ts-gib/dist/V1/types.mjs';
 import {
     SyncPeerData_V1, SyncPeerRel8ns_V1, SyncPeerWitness,
     InitializeSyncPeerOpts, ConnectSyncPeerOpts
-} from '../sync-peer-types.mjs';
-import { SyncSagaCoordinator } from '../../sync-saga-coordinator.mjs';
+} from '../../sync-peer-types.mjs';
+import { SyncSagaCoordinator } from '../../../sync-saga-coordinator.mjs';
 
 /**
  * Data for the SyncPeerWebSocketReceiver witness.

package/src/sync/sync-peer/{sync-peer-websocket-receiver → sync-peer-websocket/sync-peer-websocket-receiver}/sync-peer-websocket-receiver-v1.mts

@@ -5,21 +5,25 @@
 import { extractErrorMsg, getUUID } from '@ibgib/helper-gib/dist/helpers/utils-helper.mjs';
 import { getIbGibAddr } from '@ibgib/ts-gib/dist/helper.mjs';
 import { IbGib_V1 } from '@ibgib/ts-gib/dist/V1/types.mjs';
-
-import { GLOBAL_LOG_A_LOT } from '../../../core-constants.mjs';
-import { SyncPeer_V1 } from '../sync-peer-v1.mjs';
-import { SyncSagaContextIbGib_V1 } from '../../sync-saga-context/sync-saga-context-types.mjs';
-import { authenticateContext } from '../../sync-saga-context/sync-saga-context-helpers.mjs';
-import { IbGibSpaceAny } from '../../../witness/space/space-base-v1.mjs';
-import { putInSpace, registerNewIbGib } from '../../../witness/space/space-helper.mjs';
+import { validateIbGibIntrinsically } from '@ibgib/ts-gib/dist/V1/validate-helper.mjs';
+
+import { GLOBAL_LOG_A_LOT } from '../../../../core-constants.mjs';
+import { SyncPeer_V1 } from '../../sync-peer-v1.mjs';
+import { SyncSagaContextIbGib_V1 } from '../../../sync-saga-context/sync-saga-context-types.mjs';
+import { authenticateContextIntrinsically } from '../../../sync-saga-context/sync-saga-context-helpers.mjs';
+import { IbGibSpaceAny } from '../../../../witness/space/space-base-v1.mjs';
+import { putInSpace, registerNewIbGib } from '../../../../witness/space/space-helper.mjs';
 import {
     ConnectSyncPeerWebSocketReceiverOpts,
     InitializeSyncPeerWebSocketReceiverOpts,
     SyncPeerWebSocketReceiverData_V1, SyncPeerWebSocketReceiverRel8ns_V1,
     SyncPeerWebSocketReceiverIbGib_V1
 } from './sync-peer-websocket-receiver-types.mjs';
-import { KeystoneIbGib_V1 } from '../../../keystone/keystone-types.mjs';
+import { KeystoneIbGib_V1 } from '../../../../keystone/keystone-types.mjs';
+import { SyncWebSocketMsgType } from '../sync-peer-websocket-constants.mjs';
 import { SESSION_KEYSTONE_POLICY, verifyConnectProof } from './sync-websocket-peer-helpers.mjs';
+import { getFullSyncSagaHistory } from '../../../sync-helpers.mjs';
+import { toDto } from '../../../../common/other/ibgib-helper.mjs';
 
 const logalot = GLOBAL_LOG_A_LOT || true;
 
@@ -30,6 +34,7 @@ export interface IWebSocketWrapper {
     send(data: string): void;
     onMessage(callback: (data: string) => void): void;
     onClose(callback: () => void): void;
+    close(): void;
 }
 
 /**
@@ -59,6 +64,11 @@ export class SyncPeerWebSocketReceiver_V1
     protected demandedIds?: string[];
     protected sessionS_tjpAddr?: string;
 
+    // Runtime state variables for delayed payload streaming
+    protected pendingContext?: SyncSagaContextIbGib_V1;
+    protected pendingPayloadAddrs?: Set<string>;
+    protected pendingResponsePayloadsToSend: IbGib_V1[] = [];
+
     constructor(
         initialData: SyncPeerWebSocketReceiverData_V1,
         initialRel8ns?: SyncPeerWebSocketReceiverRel8ns_V1,
@@ -79,13 +89,13 @@ export class SyncPeerWebSocketReceiver_V1
         try {
             this.challengeUuid = await getUUID();
             socketWrapper.send(JSON.stringify({
-                type: 'auth-challenge-init',
+                type: SyncWebSocketMsgType.auth_challenge_init,
                 challengeUuid: this.challengeUuid
             }));
         } catch (error) {
             console.error(`${lc} failed triggering challenge init: ${extractErrorMsg(error)}`);
             socketWrapper.send(JSON.stringify({
-                type: 'auth-fail',
+                type: SyncWebSocketMsgType.auth_fail,
                 message: 'Internal server connect error'
             }));
         }
@@ -171,41 +181,99 @@ export class SyncPeerWebSocketReceiver_V1
             }
 
             // 2. Authenticated Runtime Sync Route
-            if (msg.type === 'domain-payload') {
+            if (msg.type === SyncWebSocketMsgType.domain_payload) {
                 const ibGib = msg.ibGib as IbGib_V1;
-                const tempSpace = await this.ensureLocalTempSpace();
-                await putInSpace({ space: tempSpace, ibGibs: [ibGib] });
-            } else if (msg.type === 'sync-frame') {
+                const validationErrors =
+                    await validateIbGibIntrinsically({ ibGib }) ?? [];
+                if (validationErrors.length > 0) {
+                    throw new Error(`controlIbGibs invalid intrinsically. validationErrors: ${validationErrors.join('|')} (E: 5ee1787d4cc53d3d2c55f3d4f2865226)`);
+                }
+
+                if (this.pendingContext && this.pendingPayloadAddrs) {
+                    const addr = getIbGibAddr({ ibGib });
+                    if (this.pendingPayloadAddrs.has(addr)) {
+                        const tempSpace = await this.ensureLocalTempSpace();
+                        await putInSpace({ space: tempSpace, ibGibs: [ibGib] });
+                        this.pendingPayloadAddrs.delete(addr);
+
+                        // If all expected payloads for the pending context are received
+                        if (this.pendingPayloadAddrs.size === 0) {
+                            const context = this.pendingContext;
+                            this.pendingContext = undefined;
+                            this.pendingPayloadAddrs = undefined;
+
+                            await this.executeIncomingSyncRequestAndRespond({ context });
+                        }
+                    } else {
+                        console.warn(`${lc} received payload not in expected list: ${addr}`);
+                    }
+                }
+            } else if (msg.type === SyncWebSocketMsgType.sync_frame) {
                 const context = msg.context as SyncSagaContextIbGib_V1;
 
-                // Process turn through coordinator
-                const responseCtx = await this.handleIncomingSyncRequest({ context });
-
-                if (responseCtx) {
-                    // Send outgoing payload domain ibgibs first
-                    const responsePayloads = responseCtx.payloadIbGibsDomain ?? [];
-                    for (const ibGib of responsePayloads) {
-                        this.socketWrapper.send(JSON.stringify({
-                            type: 'domain-payload',
-                            ibGib
-                        }));
+                // First, validate and authenticate the context
+                const allControlIbGibs: IbGib_V1[] = [
+                    toDto({ ibGib: context }),
+                    context.sagaFrame,
+                    context.sagaFrameMsg
+                ];
+                if (context.signedSessionIdentity) {
+                    allControlIbGibs.push(context.signedSessionIdentity);
+                }
+
+                for (const controlIbGib of allControlIbGibs) {
+                    const validationErrors =
+                        await validateIbGibIntrinsically({ ibGib: controlIbGib }) ?? [];
+                    if (validationErrors.length > 0) {
+                        throw new Error(`controlIbGibs invalid intrinsically. validationErrors: ${validationErrors.join('|')} (E: d40dfa87265a0b73c8ef784d1265ea26)`);
                     }
+                }
+
+                await this.authenticateAndValidate({ context });
+
+                // Put control ibgibs into durable space immediately for audit trail
+                for (const ibGib of allControlIbGibs) {
+                    await putInSpace({ space: this.opts!.localSpace, ibGibs: [ibGib] });
+                    await registerNewIbGib({ space: this.opts!.localSpace, ibGib });
+                }
 
-                    // Send evolved context turn response
+                // Check if payloads are expected
+                const expectedPayloadAddrs = context.data?.['@payloadAddrsDomain'] || [];
+                if (expectedPayloadAddrs.length > 0) {
+                    // Set up wait state and request payloads
+                    this.pendingContext = context;
+                    this.pendingPayloadAddrs = new Set(expectedPayloadAddrs);
                     this.socketWrapper.send(JSON.stringify({
-                        type: 'sync-frame-response',
-                        context: responseCtx
+                        type: SyncWebSocketMsgType.sync_frame_authenticated,
+                        contextAddr: getIbGibAddr({ ibGib: context })
                     }));
                 } else {
-                    if (logalot) { console.log(`${lc} synchronization session completed successfully.`); }
+                    // No payloads expected, process immediately
+                    await this.executeIncomingSyncRequestAndRespond({ context });
+                }
+            } else if (msg.type === SyncWebSocketMsgType.sync_frame_response_authenticated) {
+                // Alice authenticated our response context, stream our payloads now
+                const payloads = this.pendingResponsePayloadsToSend || [];
+                this.pendingResponsePayloadsToSend = [];
+                for (const ibGib of payloads) {
+                    this.socketWrapper.send(JSON.stringify({
+                        type: SyncWebSocketMsgType.domain_payload,
+                        ibGib
+                    }));
                 }
             }
         } catch (error) {
             console.error(`${lc} message frame handling failed: ${extractErrorMsg(error)}`);
-            this.socketWrapper?.send(JSON.stringify({
-                type: this.isAuthenticated ? 'sync-error' : 'auth-fail',
-                message: extractErrorMsg(error)
-            }));
+            try {
+                this.socketWrapper?.send(JSON.stringify({
+                    type: this.isAuthenticated ? SyncWebSocketMsgType.sync_error : SyncWebSocketMsgType.auth_fail,
+                    message: extractErrorMsg(error)
+                }));
+            } catch (nestedError) {
+                console.error(`${lc}[nested catch] failed to send error frame: ${extractErrorMsg(nestedError)}`);
+            } finally {
+                this.socketWrapper?.close();
+            }
         }
     }
 
@@ -217,7 +285,7 @@ export class SyncPeerWebSocketReceiver_V1
         const metaspace = this.opts!.localMetaspace;
         const space = this.opts!.localSpace;
 
-        if (msg.type === 'auth-init') {
+        if (msg.type === SyncWebSocketMsgType.auth_init) {
             const { sAddr } = msg;
             if (logalot) { console.log(`${lc} auth-init for ${sAddr}`); }
 
@@ -237,12 +305,12 @@ export class SyncPeerWebSocketReceiver_V1
             this.sessionS_tjpAddr = (past && past.length > 0) ? past[0] : getIbGibAddr({ ibGib: authorizedS });
 
             this.socketWrapper!.send(JSON.stringify({
-                type: 'auth-challenge',
+                type: SyncWebSocketMsgType.auth_challenge,
                 challengeUuid: this.challengeUuid,
                 demandedIds: this.demandedIds
             }));
 
-        } else if (msg.type === 'auth-proof') {
+        } else if (msg.type === SyncWebSocketMsgType.auth_proof) {
             const { proofFrame } = msg;
             if (logalot) { console.log(`${lc} verifying auth-proof...`); }
 
@@ -267,12 +335,13 @@ export class SyncPeerWebSocketReceiver_V1
 
             // Persist the newly validated evolved session keystone tip
             await metaspace.put({ ibGibs: [proofFrame], space });
+            await metaspace.registerNewIbGib({ ibGib: proofFrame, space });
 
             if (logalot) { console.log(`${lc} connect validation successful! Connection upgraded to active sync session.`); }
             this.isAuthenticated = true;
 
             this.socketWrapper!.send(JSON.stringify({
-                type: 'auth-ok'
+                type: SyncWebSocketMsgType.auth_ok
             }));
         } else {
             throw new Error(`Unexpected message type ${msg.type} during connect phase (E: f67a0f47f8426c2b01af5bc3d0146b26)`);
@@ -280,57 +349,45 @@ export class SyncPeerWebSocketReceiver_V1
     }
 
     /**
-     * Executes the transaction turn through the local SyncSagaCoordinator.
+     * Executes the incoming sync request through the local SyncSagaCoordinator and sends response.
      */
-    public async handleIncomingSyncRequest({
-        context,
-        payloadIbGibsControl = [],
+    protected async executeIncomingSyncRequestAndRespond({
+        context
     }: {
         context: SyncSagaContextIbGib_V1;
-        payloadIbGibsControl?: IbGib_V1[];
-    }): Promise<SyncSagaContextIbGib_V1 | undefined> {
-        const lc = `${this.lc}[${this.handleIncomingSyncRequest.name}]`;
+    }): Promise<void> {
+        const lc = `${this.lc}[${this.executeIncomingSyncRequestAndRespond.name}]`;
         try {
-            if (logalot) { console.log(`${lc} starting incoming sync turn...`); }
+            if (logalot) { console.log(`${lc} executing incoming sync turn...`); }
 
             if (!this.opts) { throw new Error(`opts not initialized. (E: 0c98186714e85b9a08bb9d98daada826)`); }
             const { localCoordinator, localMetaspace, localSpace } = this.opts;
             const localTempSpace = await this.ensureLocalTempSpace();
 
-            // Put control ibgibs into durable space
-            const allControlIbGibs = [context, ...payloadIbGibsControl];
-            for (const ibGib of allControlIbGibs) {
-                await putInSpace({ space: localSpace, ibGibs: [ibGib] });
-                await registerNewIbGib({ space: localSpace, ibGib });
-            }
-
-            // Authenticate context signature
-            const authErrors = await authenticateContext({
-                context,
-                space: localSpace,
-            });
-            if (authErrors.length > 0) {
-                throw new Error(`Context authentication failed: ${authErrors.join(', ')} (E: 424bd9b03ff8a42df8b1a438ed393726)`);
-            }
-
-            // Put incoming domain payloads into temp space
-            if (context.payloadIbGibsDomain && context.payloadIbGibsDomain.length > 0) {
-                for (const ibGib of context.payloadIbGibsDomain) {
-                    await putInSpace({ space: localTempSpace, ibGibs: [ibGib] });
-                }
-            }
-
-            // Evolve frame and run next coordinator sync turn
             const responseCtx = await localCoordinator.continueSync({
                 sagaContext: context,
                 metaspace: localMetaspace,
                 mySpace: localSpace,
                 myTempSpace: localTempSpace,
+                peer: this,
             });
 
-            return responseCtx || undefined;
+            if (responseCtx) {
+                const responsePayloads = responseCtx.payloadIbGibsDomain ?? [];
+                delete responseCtx.payloadIbGibsDomain;
+
+                // Save payloads to stream once authenticated by Alice
+                this.pendingResponsePayloadsToSend = responsePayloads;
+
+                this.socketWrapper!.send(JSON.stringify({
+                    type: SyncWebSocketMsgType.sync_frame_response,
+                    context: responseCtx
+                }));
+            } else {
+                if (logalot) { console.log(`${lc} synchronization session completed successfully.`); }
+            }
         } catch (error) {
-            console.error(`${lc} handleIncomingSyncRequest turn execution failed: ${extractErrorMsg(error)}`);
+            console.error(`${lc} executeIncomingSyncRequestAndRespond failed: ${extractErrorMsg(error)}`);
             throw error;
         }
     }

package/src/sync/sync-peer/{sync-peer-websocket-receiver → sync-peer-websocket/sync-peer-websocket-receiver}/sync-websocket-peer-helpers.mts

@@ -11,17 +11,17 @@ import { validateIbGibAddr, validateIbGibIntrinsically } from '@ibgib/ts-gib/dis
 import { getGibInfo } from '@ibgib/ts-gib/dist/V1/transforms/transform-helper.mjs';
 import { IbGib_V1 } from '@ibgib/ts-gib/dist/V1/types.mjs';
 
-import { GLOBAL_LOG_A_LOT } from '../../../core-constants.mjs';
+import { GLOBAL_LOG_A_LOT } from '../../../../core-constants.mjs';
 import {
     KeystoneReplenishStrategy, KeystoneChallengeType, KeystoneIbGib_V1,
     KeystoneSolution, KeystoneChallenge
-} from '../../../keystone/keystone-types.mjs';
-import { parseKeystoneIb } from '../../../keystone/keystone-helpers.mjs';
-import { KeystoneStrategyFactory } from '../../../keystone/strategy/keystone-strategy-factory.mjs';
-import { KeystoneService_V1 } from '../../../keystone/keystone-service-v1.mjs';
-import { IbGibSpaceAny } from '../../../witness/space/space-base-v1.mjs';
-import { MetaspaceService } from '../../../witness/space/metaspace/metaspace-types.mjs';
-import { POOL_ID_CONNECT, KEYSTONE_VERB_CONNECT } from '../../../keystone/keystone-constants.mjs';
+} from '../../../../keystone/keystone-types.mjs';
+import { parseKeystoneIb } from '../../../../keystone/keystone-helpers.mjs';
+import { KeystoneStrategyFactory } from '../../../../keystone/strategy/keystone-strategy-factory.mjs';
+import { KeystoneService_V1 } from '../../../../keystone/keystone-service-v1.mjs';
+import { IbGibSpaceAny } from '../../../../witness/space/space-base-v1.mjs';
+import { MetaspaceService } from '../../../../witness/space/metaspace/metaspace-types.mjs';
+import { POOL_ID_CONNECT, KEYSTONE_VERB_CONNECT } from '../../../../keystone/keystone-constants.mjs';
 
 const logalot = GLOBAL_LOG_A_LOT
 

package/src/sync/sync-peer/{sync-peer-websocket-sender → sync-peer-websocket/sync-peer-websocket-sender}/sync-peer-websocket-sender-types.mts

@@ -5,7 +5,7 @@ import { IbGib_V1 } from '@ibgib/ts-gib/dist/V1/types.mjs';
 import {
     SyncPeerData_V1, SyncPeerRel8ns_V1, SyncPeerWitness,
     InitializeSyncPeerOpts, ConnectSyncPeerOpts
-} from '../sync-peer-types.mjs';
+} from '../../sync-peer-types.mjs';
 
 /**
  * Data for the SyncPeerWebSocketSender witness.