@mml-io/delta-net-server 0.0.0-experimental-bcf0b7c-20250715

package/README.md

@@ -0,0 +1,10 @@
+# DeltaNet Server
+#### `@mml-io/delta-net-server`
+
+[![npm version](https://img.shields.io/npm/v/@mml-io/delta-net-server.svg?style=flat)](https://www.npmjs.com/package/@mml-io/delta-net-server)
+
+This package contains the `DeltaNetServer` class that provides a way to accept websocket connections that can each set int64 components and byte states which are then visible to every other connected user.
+
+The WebSocket protocol used by this package, `delta-net-v0.1`, is defined in `@mml-io/delta-net-protocol`.
+
+A client for the `delta-net-v0.1` protocol is provided by `@mml-io/delta-net-web`.

package/build/ComponentCollection.d.ts

@@ -0,0 +1,22 @@
+export declare class ComponentCollection {
+    private targetValues;
+    private pendingDeltas;
+    private previousEmittedDeltas;
+    private currentObservableValues;
+    private static readonly MIN_INT64;
+    private static readonly MAX_INT64;
+    constructor(initialLength?: number);
+    setLength(length: number): void;
+    setValue(index: number, value: bigint): void;
+    private clampToInt64;
+    tick(): {
+        delta: BigInt64Array;
+        deltaDeltas: BigInt64Array;
+    };
+    removeIndices(sortedUnoccupyingIndices: Array<number>): void;
+    getTargetValue(index: number): bigint;
+    getPendingDelta(index: number): bigint;
+    get length(): number;
+    getCurrentValuesArray(): BigInt64Array;
+    getPreviousEmittedDeltasArray(): BigInt64Array;
+}

package/build/DeltaNetServer.d.ts

@@ -0,0 +1,126 @@
+import { DeltaNetV01ServerErrorType } from "@mml-io/delta-net-protocol";
+import { DeltaNetV01Connection } from "./DeltaNetV01Connection";
+export type onJoinerOptions = {
+    deltaNetV01Connection: DeltaNetV01Connection;
+    components: Array<[number, bigint]>;
+    states: Array<[number, Uint8Array]>;
+    token: string;
+    internalConnectionId: number;
+};
+export type onComponentsUpdateOptions = {
+    deltaNetV01Connection: DeltaNetV01Connection;
+    internalConnectionId: number;
+    components: Array<[number, bigint]>;
+};
+export type onStatesUpdateOptions = {
+    deltaNetV01Connection: DeltaNetV01Connection;
+    internalConnectionId: number;
+    states: Array<[number, Uint8Array]>;
+};
+export type onLeaveOptions = {
+    deltaNetV01Connection: DeltaNetV01Connection;
+    internalConnectionId: number;
+    components: Array<[number, number]>;
+    states: Array<[number, Uint8Array]>;
+};
+export type onCustomMessageOptions = {
+    deltaNetV01Connection: DeltaNetV01Connection;
+    internalConnectionId: number;
+    customType: number;
+    contents: string;
+};
+export declare class DeltaNetServerError extends Error {
+    errorType: DeltaNetV01ServerErrorType;
+    retryable: boolean;
+    constructor(errorType: DeltaNetV01ServerErrorType, message: string, retryable: boolean);
+}
+export type DeltaNetServerOptions = {
+    onJoiner?: (opts: onJoinerOptions) => true | void | Error | DeltaNetServerError | {
+        success: true;
+        stateOverrides?: Array<[number, Uint8Array]>;
+    } | Promise<true | void | Error | DeltaNetServerError | {
+        success: true;
+        stateOverrides?: Array<[number, Uint8Array]>;
+    }>;
+    onComponentsUpdate?: (opts: onComponentsUpdateOptions) => true | void | Error | DeltaNetServerError;
+    onStatesUpdate?: (opts: onStatesUpdateOptions) => true | void | Error | DeltaNetServerError | {
+        success: true;
+        stateOverrides?: Array<[number, Uint8Array]>;
+    } | Promise<true | void | Error | DeltaNetServerError | {
+        success: true;
+        stateOverrides?: Array<[number, Uint8Array]>;
+    }>;
+    onLeave?: (opts: onLeaveOptions) => void;
+    onCustomMessage?: (opts: onCustomMessageOptions) => void;
+    serverConnectionIdStateId?: number;
+    maxStateValueSize?: number;
+    maxMessageSize?: number;
+};
+export declare class DeltaNetServer {
+    private opts;
+    private currentConnectionId;
+    private nextIndex;
+    private preTickData;
+    private connectionIdToComponentIndex;
+    private componentIndexToConnectionId;
+    private connectionIdToDeltaNetServerConnection;
+    private allDeltaNetV01Connections;
+    private authenticatedDeltaNetV01Connections;
+    private observerConnections;
+    private webSocketToDeltaNetServerConnection;
+    private components;
+    private states;
+    private documentEffectiveStartTime;
+    private pingCounter;
+    private disposed;
+    private maxStateValueSize;
+    private maxMessageSize;
+    constructor(opts?: DeltaNetServerOptions);
+    static handleWebsocketSubprotocol(protocols: Set<string> | Array<string>): string | false;
+    addWebSocket(webSocket: WebSocket): void;
+    removeWebSocket(webSocket: WebSocket): void;
+    hasWebSocket(webSocket: WebSocket): boolean;
+    dangerouslyGetConnectionsToComponentIndex(): Map<number, number>;
+    dangerouslyAddNewJoinerCallback(callback: (index: number) => {
+        id: number;
+        afterAddCallback?: () => void;
+    } | null): void;
+    private disconnectWithError;
+    getComponentValue(componentId: number, componentIndex: number): number;
+    getNextConnectionId(): number;
+    getMaxMessageSize(): number;
+    validateJoiner(deltaNetV01Connection: DeltaNetV01Connection, token: string, components: Array<[number, bigint]>, states: Array<[number, Uint8Array]>): Promise<{
+        success: true;
+    } | {
+        success: false;
+        error: string;
+    }> | {
+        success: true;
+    } | {
+        success: false;
+        error: string;
+    };
+    addAuthenticatedConnection(deltaNetV01Connection: DeltaNetV01Connection): void;
+    validateAndApplyStateUpdate(deltaNetV01Connection: DeltaNetV01Connection, internalConnectionId: number, stateId: number, stateValue: Uint8Array): Promise<true | void | Error | DeltaNetServerError> | true | void | Error | DeltaNetServerError;
+    clearInternalConnectionId(internalConnectionId: number): void;
+    private sendPings;
+    tick(): {
+        removedIds: Set<number>;
+        addedIds: Set<number>;
+    };
+    getServerTime(): number;
+    setUserComponents(deltaNetV01Connection: DeltaNetV01Connection, internalConnectionId: number, components: Array<[number, bigint]>): {
+        success: true;
+    } | {
+        success: false;
+        error: string;
+    };
+    setComponentValue(componentId: number, index: number, value: bigint): void;
+    private applyComponentUpdates;
+    overrideUserStates(deltaNetV01Connection: DeltaNetV01Connection | null, internalConnectionId: number, states: Array<[number, Uint8Array]>): void;
+    setUserState(index: number, stateId: number, stateValue: Uint8Array): void;
+    private applyStateUpdates;
+    handleCustomMessage(deltaNetV01Connection: DeltaNetV01Connection, internalConnectionId: number, customType: number, contents: string): void;
+    broadcastCustomMessage(customType: number, contents: string): void;
+    dispose(): void;
+}

package/build/DeltaNetV01Connection.d.ts

@@ -0,0 +1,25 @@
+import { DeltaNetV01ServerMessage } from "@mml-io/delta-net-protocol";
+import { DeltaNetServer } from "./DeltaNetServer";
+export declare class DeltaNetV01Connection {
+    readonly webSocket: WebSocket;
+    readonly deltaNetServer: DeltaNetServer;
+    private websocketListener;
+    readonly internalConnectionId: number;
+    isObserver: boolean;
+    components: Map<number, bigint>;
+    states: Map<number, Uint8Array<ArrayBufferLike>>;
+    private pendingStateValidations;
+    private nextValidationId;
+    private isAuthenticated;
+    private isAuthenticating;
+    private authenticationAbortController;
+    constructor(webSocket: WebSocket, deltaNetServer: DeltaNetServer);
+    sendMessage(message: DeltaNetV01ServerMessage): void;
+    sendEncodedBytes(bytes: Uint8Array): void;
+    dispose(): void;
+    setAuthenticated(): void;
+    private disconnectWithError;
+    private handleConnectUser;
+    handleStateUpdate(stateId: number, stateValue: Uint8Array): Promise<void>;
+    private handleClientMessage;
+}

package/build/StateCollection.d.ts

@@ -0,0 +1,8 @@
+export declare class StateCollection {
+    values: Array<Uint8Array>;
+    private modifiedIndices;
+    constructor();
+    setValue(index: number, value: Uint8Array | null): void;
+    tick(): Array<[number, Uint8Array]>;
+    removeIndices(sortedUnoccupyingIndices: Array<number>): void;
+}

package/build/createDeltaNetServerConnectionForWebsocket.d.ts

@@ -0,0 +1,4 @@
+import { DeltaNetServer } from "./DeltaNetServer";
+import { DeltaNetV01Connection } from "./DeltaNetV01Connection";
+export declare const SupportedWebsocketSubProtocolsPreferenceOrder: readonly ["delta-net-v0.1"];
+export declare function createDeltaNetServerConnectionForWebsocket(webSocket: WebSocket, deltaNetServer: DeltaNetServer): DeltaNetV01Connection | null;

package/build/index.d.ts

@@ -0,0 +1,2 @@
+export * from "./DeltaNetServer";
+export { DeltaNetV01Connection } from "./DeltaNetV01Connection";