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

package/README.md

@@ -0,0 +1,6 @@
+# DeltaNet Protocol
+#### `@mml-io/delta-net-protocol`
+
+[![npm version](https://img.shields.io/npm/v/@mml-io/delta-net-protocol.svg?style=flat)](https://www.npmjs.com/package/@mml-io/delta-net-protocol)
+
+This package contains a TypeScript definition / message types of the `delta-net-v0.1` protocol used by `@mml-io/delta-net-server` and `@mml-io/delta-net-web`.

package/build/BufferReader.d.ts

@@ -0,0 +1,92 @@
+/**
+ * A class for reading binary data from a Uint8Array buffer.
+ * Supports various data types including varints, strings, and boolean arrays.
+ * All numeric values are read using varint encoding for efficiency.
+ */
+export declare class BufferReader {
+    private buffer;
+    private offset;
+    /**
+     * Creates a new BufferReader instance.
+     * @param buffer - The Uint8Array to read from
+     */
+    constructor(buffer: Uint8Array);
+    /**
+     * Reads a single unsigned 8-bit integer from the buffer.
+     * @returns The read value
+     */
+    readUInt8(): number;
+    /**
+     * Reads a boolean value from the buffer.
+     * @returns true if the read byte is 1, false otherwise
+     */
+    readBoolean(): boolean;
+    /**
+     * Reads a specified number of bytes from the buffer.
+     * @param length - The number of bytes to read
+     * @returns A new Uint8Array containing the read bytes
+     */
+    readBytes(length: number): Uint8Array;
+    /**
+     * Reads a length-prefixed byte array from the buffer.
+     * The length is encoded as a varint.
+     * @returns A new Uint8Array containing the read bytes
+     */
+    readUVarintPrefixedBytes(): Uint8Array;
+    /**
+     * Reads a varint-encoded integer from the buffer.
+     * Varints are variable-length integers that use the high bit of each byte to indicate if more bytes follow.
+     * @param signed - Whether to interpret the value as a signed integer
+     * @returns The decoded integer value
+     * @throws Error if the varint encoding is invalid
+     */
+    readUVarint(signed?: boolean): number;
+    /**
+     * Reads a string from the buffer with a specified byte length.
+     * Optimized for ASCII strings, falls back to TextDecoder for non-ASCII.
+     * @param byteLength - The number of bytes to read
+     * @returns The decoded string
+     */
+    private readStringBytes;
+    /**
+     * Reads a length-prefixed string from the buffer.
+     * The length is encoded as an unsigned varint.
+     * @returns The decoded string
+     */
+    readUVarintPrefixedString(): string;
+    /**
+     * Reads a length-prefixed string from the buffer.
+     * The length is encoded as a signed varint.
+     * @returns A tuple containing the decoded string and a boolean indicating if the length was negative
+     */
+    readVarintPrefixedString(): [string, boolean];
+    /**
+     * Reads a signed varint-encoded integer from the buffer.
+     * @returns The decoded signed integer value
+     */
+    readVarint(): number;
+    /**
+     * Reads a varint-encoded bigint from the buffer.
+     * Varints are variable-length integers that use the high bit of each byte to indicate if more bytes follow.
+     * @param signed - Whether to interpret the value as a signed integer
+     * @returns The decoded bigint value
+     * @throws Error if the varint encoding is invalid
+     */
+    readUVarintBigInt(signed?: boolean): bigint;
+    /**
+     * Reads a signed varint-encoded integer from the buffer.
+     * @returns The decoded signed integer value
+     */
+    readBigIntVarint(): bigint;
+    /**
+     * Reads an array of boolean values from the buffer.
+     * The booleans are packed into bytes (8 booleans per byte).
+     * @returns An array of boolean values
+     */
+    readLengthPrefixedBoolArray(): boolean[];
+    /**
+     * Checks if the reader has reached the end of the buffer.
+     * @returns true if all bytes have been read, false otherwise
+     */
+    isEnd(): boolean;
+}

package/build/BufferWriter.d.ts

@@ -0,0 +1,98 @@
+/**
+ * A class for writing binary data to a Uint8Array buffer.
+ * Supports various data types including varints, strings, and boolean arrays.
+ * All numeric values are written using varint encoding for efficiency.
+ * The buffer automatically expands as needed.
+ */
+export declare class BufferWriter {
+    private buffer;
+    private offset;
+    /**
+     * Creates a new BufferWriter instance.
+     * @param initialLength - The initial size of the buffer in bytes
+     */
+    constructor(initialLength: number);
+    /**
+     * Writes an unsigned 8-bit integer to the buffer.
+     * @param value - The value to write (will be truncated to 8 bits)
+     */
+    writeUint8(value: number): void;
+    /**
+     * Writes a boolean value to the buffer.
+     * @param bool - The boolean value to write (true = 1, false = 0)
+     */
+    writeBoolean(bool: boolean): void;
+    /**
+     * Writes an array of bytes to the buffer without a length prefix.
+     * @param bytes - The bytes to write
+     */
+    writeUnprefixedBytes(bytes: Uint8Array): void;
+    /**
+     * Writes a length-prefixed array of bytes to the buffer.
+     * The length is encoded as an unsigned varint.
+     * @param bytes - The bytes to write
+     */
+    writeUVarintLengthPrefixedBytes(bytes: Uint8Array): void;
+    /**
+     * Gets the written bytes as a Uint8Array.
+     * @returns A new Uint8Array containing only the written bytes
+     */
+    getBuffer(): Uint8Array;
+    /**
+     * Gets the number of bytes written so far.
+     * @returns The current write offset
+     */
+    getWrittenLength(): number;
+    /**
+     * Ensures the buffer has enough capacity for the required space.
+     * @param neededSpace - The number of additional bytes needed
+     */
+    private ensureCapacity;
+    /**
+     * Expands the buffer by doubling its current length.
+     */
+    private expandBuffer;
+    /**
+     * Writes an unsigned varint to the buffer.
+     * Varints are variable-length integers that use the high bit of each byte to indicate if more bytes follow.
+     * @param x - The value to write
+     */
+    writeUVarint(x: number): void;
+    /**
+     * Writes an unsigned varint to the buffer.
+     * Varints are variable-length integers that use the high bit of each byte to indicate if more bytes follow.
+     * @param x - The value to write
+     */
+    writeUVarintBigInt(x: bigint): void;
+    /**
+     * Writes a signed varint to the buffer using zigzag encoding.
+     * @param x - The signed value to write
+     */
+    writeVarint(x: number): void;
+    /**
+     * Writes a signed varint to the buffer using zigzag encoding.
+     * @param x - The signed value to write
+     */
+    writeBigIntVarint(x: bigint): void;
+    /**
+     * Writes an array of boolean values to the buffer.
+     * The booleans are packed into bytes (8 booleans per byte).
+     * @param data - The array of boolean values to write
+     */
+    writeLengthPrefixedBoolArray(data: boolean[]): void;
+    /**
+     * Writes a length-prefixed string to the buffer.
+     * Optimized for ASCII strings, falls back to TextEncoder for non-ASCII.
+     * @param value - The string to write
+     * @param varint - Whether to use signed varint for length (default: false)
+     * @param negativeLength - Whether the length should be negative (only used if varint is true)
+     */
+    writeLengthPrefixedString(value: string, varint?: boolean, negativeLength?: boolean): void;
+}
+/**
+ * Encodes a signed integer using zigzag encoding.
+ * Zigzag encoding maps signed integers to unsigned integers in a way that preserves ordering.
+ * @param value - The signed value to encode
+ * @returns The zigzag-encoded value
+ */
+export declare function zigzagEncode(value: number): number;

package/build/DeflateCompressor.d.ts

@@ -0,0 +1,14 @@
+export declare enum CompressionLibraryChoice {
+    PAKO = "PAKO",
+    NODE_ZLIB = "NODE_ZLIB",
+    NO_PREFERENCE = "NO_PREFERENCE",
+    NONE = "NONE"
+}
+export declare class DeflateCompressor {
+    static compress(data: Uint8Array, compressionLibrary?: CompressionLibraryChoice): Uint8Array;
+    static decompress(compressed: Uint8Array, compressionLibrary?: CompressionLibraryChoice): Uint8Array;
+    static varIntCompress(data: BigInt64Array, length: number, compressionLibrary?: CompressionLibraryChoice): [Uint8Array, Uint8Array];
+    static varIntDecompress(compressed: Uint8Array, length: number, compressionLibrary?: CompressionLibraryChoice): BigInt64Array;
+    static varIntBytesCompress(data: Array<Uint8Array | null>, length: number, compressionLibrary?: CompressionLibraryChoice): [Uint8Array, Uint8Array];
+    static varIntBytesDecompress(compressed: Uint8Array, length: number, compressionLibrary?: CompressionLibraryChoice): Array<Uint8Array>;
+}

package/build/delta-net-v0.1/constants.d.ts

@@ -0,0 +1 @@
+export declare const deltaNetProtocolSubProtocol_v0_1 = "delta-net-v0.1";

package/build/delta-net-v0.1/decodeClientMessages.d.ts

@@ -0,0 +1,3 @@
+import { BufferReader } from "../BufferReader";
+import { DeltaNetV01ClientMessage } from "./messages";
+export declare function decodeClientMessages(buffer: BufferReader): Array<DeltaNetV01ClientMessage>;

package/build/delta-net-v0.1/decodeServerMessages.d.ts

@@ -0,0 +1,6 @@
+import { BufferReader } from "../BufferReader";
+import { DeltaNetV01ServerMessage } from "./messages";
+export type DecodeServerMessageOptions = {
+    ignoreData?: boolean;
+};
+export declare function decodeServerMessages(buffer: BufferReader, opts?: DecodeServerMessageOptions): Array<DeltaNetV01ServerMessage>;

package/build/delta-net-v0.1/encodeClientMessage.d.ts

@@ -0,0 +1,3 @@
+import { BufferWriter } from "../BufferWriter";
+import { DeltaNetV01ClientMessage } from "./messages";
+export declare function encodeClientMessage(message: DeltaNetV01ClientMessage, writer: BufferWriter): void | BufferWriter;

package/build/delta-net-v0.1/encodeServerMessage.d.ts

@@ -0,0 +1,3 @@
+import { BufferWriter } from "../BufferWriter";
+import { DeltaNetV01ServerMessage } from "./messages";
+export declare function encodeServerMessage(message: DeltaNetV01ServerMessage, writer?: BufferWriter): BufferWriter;

package/build/delta-net-v0.1/index.d.ts

@@ -0,0 +1,7 @@
+export * from "./constants";
+export * from "./decodeClientMessages";
+export * from "./decodeServerMessages";
+export * from "./encodeClientMessage";
+export * from "./encodeServerMessage";
+export * from "./messages";
+export * from "./messageTypes";

package/build/delta-net-v0.1/messageTypes.d.ts

@@ -0,0 +1,12 @@
+export declare const InitialCheckoutMessageType = 1;
+export declare const ServerCustomMessageType = 2;
+export declare const UserIndexMessageType = 3;
+export declare const TickMessageType = 4;
+export declare const PingMessageType = 5;
+export declare const WarningMessageType = 6;
+export declare const ErrorMessageType = 7;
+export declare const ConnectUserMessageType = 64;
+export declare const ClientCustomMessageType = 65;
+export declare const SetUserComponentsMessageType = 66;
+export declare const SetUserStateMessageType = 67;
+export declare const PongMessageType = 68;

package/build/delta-net-v0.1/messages/from-client/clientCustom.d.ts

@@ -0,0 +1,9 @@
+import { BufferReader } from "../../../BufferReader";
+import { BufferWriter } from "../../../BufferWriter";
+export type DeltaNetV01ClientCustomMessage = {
+    type: "clientCustom";
+    customType: number;
+    contents: string;
+};
+export declare function encodeClientCustom(msg: DeltaNetV01ClientCustomMessage, writer?: BufferWriter): BufferWriter;
+export declare function decodeClientCustom(buffer: BufferReader): DeltaNetV01ClientCustomMessage;

package/build/delta-net-v0.1/messages/from-client/connectUser.d.ts

@@ -0,0 +1,31 @@
+import { BufferReader } from "../../../BufferReader";
+import { BufferWriter } from "../../../BufferWriter";
+/**
+ * Initial connection request message from client to server.
+ * Contains authentication token and initial state of the connecting user.
+ */
+export type DeltaNetV01ConnectUserMessage = {
+    /** Message type identifier */
+    type: "connectUser";
+    /** Authentication token for the user */
+    token: string;
+    /** Whether the client is an observer-only client */
+    observer: boolean;
+    /** Array of [componentId, value] pairs for the user's initial component values */
+    components: Array<[number, bigint]>;
+    /** Array of [stateId, value] pairs for the user's initial state values */
+    states: Array<[number, Uint8Array]>;
+};
+/**
+ * Encodes a connect user message into a binary buffer.
+ * @param connectUserMessage - The message to encode
+ * @param writer - The BufferWriter to write to
+ */
+export declare function encodeConnectUser(connectUserMessage: DeltaNetV01ConnectUserMessage, writer: BufferWriter): void;
+/**
+ * Decodes a connect user message from a binary buffer.
+ * Assumes that the first byte (message type) has already been read.
+ * @param buffer - The BufferReader containing the message data
+ * @returns The decoded connect user message
+ */
+export declare function decodeConnectUser(buffer: BufferReader): DeltaNetV01ConnectUserMessage;

package/build/delta-net-v0.1/messages/from-client/index.d.ts

@@ -0,0 +1,9 @@
+import { DeltaNetV01ClientCustomMessage } from "./clientCustom";
+import { DeltaNetV01ConnectUserMessage } from "./connectUser";
+import { DeltaNetV01PongMessage } from "./pong";
+import { DeltaNetV01SetUserComponentsMessage } from "./setUserComponents";
+export * from "./connectUser";
+export * from "./pong";
+export * from "./setUserComponents";
+export * from "./clientCustom";
+export type DeltaNetV01ClientMessage = DeltaNetV01ConnectUserMessage | DeltaNetV01SetUserComponentsMessage | DeltaNetV01PongMessage | DeltaNetV01ClientCustomMessage;

package/build/delta-net-v0.1/messages/from-client/pong.d.ts

@@ -0,0 +1,8 @@
+import { BufferReader } from "../../../BufferReader";
+import { BufferWriter } from "../../../BufferWriter";
+export type DeltaNetV01PongMessage = {
+    type: "pong";
+    pong: number;
+};
+export declare function encodePong(pongMessage: DeltaNetV01PongMessage, writer: BufferWriter): void;
+export declare function decodePong(buffer: BufferReader): DeltaNetV01PongMessage;

package/build/delta-net-v0.1/messages/from-client/setUserComponents.d.ts

@@ -0,0 +1,27 @@
+import { BufferReader } from "../../../BufferReader";
+import { BufferWriter } from "../../../BufferWriter";
+/**
+ * Message sent by client to update component and state values.
+ * Used to send user input and state changes to the server.
+ */
+export type DeltaNetV01SetUserComponentsMessage = {
+    /** Message type identifier */
+    type: "setUserComponents";
+    /** Array of [componentId, value] pairs for updated component values */
+    components: Array<[number, bigint]>;
+    /** Array of [stateId, value] pairs for updated state values */
+    states: Array<[number, Uint8Array]>;
+};
+/**
+ * Encodes a set user components message into a binary buffer.
+ * @param message - The message to encode
+ * @param writer - The BufferWriter to write to
+ */
+export declare function encodeSetUserComponents(message: DeltaNetV01SetUserComponentsMessage, writer: BufferWriter): void;
+/**
+ * Decodes a set user components message from a binary buffer.
+ * Assumes that the first byte (message type) has already been read.
+ * @param buffer - The BufferReader containing the message data
+ * @returns The decoded set user components message
+ */
+export declare function decodeSetUserComponents(buffer: BufferReader): DeltaNetV01SetUserComponentsMessage;

package/build/delta-net-v0.1/messages/from-server/error.d.ts

@@ -0,0 +1,22 @@
+import { BufferReader } from "../../../BufferReader";
+import { BufferWriter } from "../../../BufferWriter";
+export declare namespace DeltaNetV01ServerErrors {
+    const USER_ALREADY_AUTHENTICATED_ERROR_TYPE = "USER_ALREADY_AUTHENTICATED";
+    const USER_NOT_AUTHENTICATED_ERROR_TYPE = "USER_NOT_AUTHENTICATED";
+    const AUTHENTICATION_IN_PROGRESS_ERROR_TYPE = "AUTHENTICATION_IN_PROGRESS";
+    const OBSERVER_CANNOT_SEND_STATE_UPDATES_ERROR_TYPE = "OBSERVER_CANNOT_SEND_STATE_UPDATES";
+    const UNSUPPORTED_WEBSOCKET_SUBPROTOCOL_ERROR_TYPE = "UNSUPPORTED_WEBSOCKET_SUBPROTOCOL";
+    const USER_NETWORKING_UNKNOWN_ERROR_TYPE = "USER_NETWORKING_UNKNOWN_ERROR";
+    const USER_AUTHENTICATION_FAILED_ERROR_TYPE = "USER_AUTHENTICATION_FAILED";
+    const USER_NETWORKING_CONNECTION_LIMIT_REACHED_ERROR_TYPE = "CONNECTION_LIMIT_REACHED";
+    const USER_NETWORKING_SERVER_SHUTDOWN_ERROR_TYPE = "SERVER_SHUTDOWN";
+}
+export type DeltaNetV01ServerErrorType = typeof DeltaNetV01ServerErrors.USER_ALREADY_AUTHENTICATED_ERROR_TYPE | typeof DeltaNetV01ServerErrors.USER_NOT_AUTHENTICATED_ERROR_TYPE | typeof DeltaNetV01ServerErrors.AUTHENTICATION_IN_PROGRESS_ERROR_TYPE | typeof DeltaNetV01ServerErrors.OBSERVER_CANNOT_SEND_STATE_UPDATES_ERROR_TYPE | typeof DeltaNetV01ServerErrors.UNSUPPORTED_WEBSOCKET_SUBPROTOCOL_ERROR_TYPE | typeof DeltaNetV01ServerErrors.USER_NETWORKING_UNKNOWN_ERROR_TYPE | typeof DeltaNetV01ServerErrors.USER_AUTHENTICATION_FAILED_ERROR_TYPE | typeof DeltaNetV01ServerErrors.USER_NETWORKING_CONNECTION_LIMIT_REACHED_ERROR_TYPE | typeof DeltaNetV01ServerErrors.USER_NETWORKING_SERVER_SHUTDOWN_ERROR_TYPE;
+export type DeltaNetV01ErrorMessage = {
+    type: "error";
+    errorType: DeltaNetV01ServerErrorType | string;
+    message: string;
+    retryable: boolean;
+};
+export declare function encodeError(msg: DeltaNetV01ErrorMessage, writer?: BufferWriter): BufferWriter;
+export declare function decodeError(buffer: BufferReader): DeltaNetV01ErrorMessage;

package/build/delta-net-v0.1/messages/from-server/index.d.ts

@@ -0,0 +1,15 @@
+import { DeltaNetV01ErrorMessage } from "./error";
+import { DeltaNetV01InitialCheckoutMessage } from "./initialCheckout";
+import { DeltaNetV01PingMessage } from "./ping";
+import { DeltaNetV01ServerCustomMessage } from "./serverCustom";
+import { DeltaNetV01Tick } from "./tick";
+import { DeltaNetV01UserIndexMessage } from "./userIndex";
+import { DeltaNetV01WarningMessage } from "./warning";
+export * from "./error";
+export * from "./initialCheckout";
+export * from "./ping";
+export * from "./serverCustom";
+export * from "./tick";
+export * from "./userIndex";
+export * from "./warning";
+export type DeltaNetV01ServerMessage = DeltaNetV01InitialCheckoutMessage | DeltaNetV01ServerCustomMessage | DeltaNetV01UserIndexMessage | DeltaNetV01Tick | DeltaNetV01PingMessage | DeltaNetV01ErrorMessage | DeltaNetV01WarningMessage;

package/build/delta-net-v0.1/messages/from-server/initialCheckout.d.ts

@@ -0,0 +1,56 @@
+import { BufferReader } from "../../../BufferReader";
+import { BufferWriter } from "../../../BufferWriter";
+import { DecodeServerMessageOptions } from "../../decodeServerMessages";
+/**
+ * Represents a component in the initial checkout message.
+ * Contains both the initial values and the delta values that will be used for subsequent ticks.
+ */
+export type DeltaNetV01InitialCheckoutComponent = {
+    /** Unique identifier for the component */
+    componentId: number;
+    /** The delta values from the tick this initial checkout is from which will be referred to in subsequent ticks */
+    deltas: BigInt64Array;
+    /** The initial values for all users */
+    values: BigInt64Array;
+};
+export type DeltaNetV01InitialCheckoutState = {
+    /** Unique identifier for the state */
+    stateId: number;
+    /** The initial values for all users */
+    values: Array<Uint8Array>;
+};
+/**
+ * Initial checkout message sent when a client first connects.
+ * Contains the complete initial state of the game, including all components and states.
+ */
+export type DeltaNetV01InitialCheckoutMessage = {
+    /** Message type identifier */
+    type: "initialCheckout";
+    /** Current server time */
+    serverTime: number;
+    /** Number of user indices in the system */
+    indicesCount: number;
+    /** Array of components with their initial values and deltas */
+    components: Array<DeltaNetV01InitialCheckoutComponent>;
+    /** Array of state values, each containing [stateId, stateValue] */
+    states: Array<DeltaNetV01InitialCheckoutState>;
+};
+/**
+ * Encodes an initial checkout message into a binary buffer.
+ * @param msg - The message to encode
+ * @param writer - Optional BufferWriter instance to use (creates a new one if not provided)
+ * @returns The BufferWriter containing the encoded message
+ */
+export declare function encodeInitialCheckout(msg: DeltaNetV01InitialCheckoutMessage, writer?: BufferWriter): BufferWriter;
+export declare const lastInitialCheckoutDebugData: {
+    componentsByteLength: number;
+    statesByteLength: number;
+};
+/**
+ * Decodes an initial checkout message from a binary buffer.
+ * Assumes that the first byte (message type) has already been read.
+ * @param buffer - The BufferReader containing the message data
+ * @param opts - Optional options for decoding, such as ignoring data
+ * @returns The decoded initial checkout message
+ */
+export declare function decodeInitialCheckout(buffer: BufferReader, opts?: DecodeServerMessageOptions): DeltaNetV01InitialCheckoutMessage;

package/build/delta-net-v0.1/messages/from-server/ping.d.ts

@@ -0,0 +1,8 @@
+import { BufferReader } from "../../../BufferReader";
+import { BufferWriter } from "../../../BufferWriter";
+export type DeltaNetV01PingMessage = {
+    type: "ping";
+    ping: number;
+};
+export declare function encodePing(pingMessage: DeltaNetV01PingMessage, writer?: BufferWriter): BufferWriter;
+export declare function decodePing(buffer: BufferReader): DeltaNetV01PingMessage;

package/build/delta-net-v0.1/messages/from-server/serverCustom.d.ts

@@ -0,0 +1,9 @@
+import { BufferReader } from "../../../BufferReader";
+import { BufferWriter } from "../../../BufferWriter";
+export type DeltaNetV01ServerCustomMessage = {
+    type: "serverCustom";
+    customType: number;
+    contents: string;
+};
+export declare function encodeServerCustom(msg: DeltaNetV01ServerCustomMessage, writer?: BufferWriter): BufferWriter;
+export declare function decodeServerCustom(buffer: BufferReader): DeltaNetV01ServerCustomMessage;

package/build/delta-net-v0.1/messages/from-server/tick.d.ts

@@ -0,0 +1,60 @@
+import { BufferReader } from "../../../BufferReader";
+import { BufferWriter } from "../../../BufferWriter";
+import { DecodeServerMessageOptions } from "../../decodeServerMessages";
+/**
+ * Represents state updates in a tick message.
+ * States are not updated every tick, so they are specified as indices that have changed and their new values.
+ */
+export type DeltaNetV01StateUpdates = {
+    /** Unique identifier for the state */
+    stateId: number;
+    /** Array of [index, value] pairs for updated states */
+    updatedStates: Array<[number, Uint8Array]>;
+};
+/**
+ * Represents component updates in a tick message.
+ * Uses second-order delta compression (deltas of deltas) for efficient updates.
+ */
+export type DeltaNetV01ComponentTick = {
+    /** Unique identifier for the component */
+    componentId: number;
+    /** The second-order delta values (deltas of deltas) from the previous tick */
+    deltaDeltas: BigInt64Array;
+};
+/**
+ * Regular state update message sent at configurable intervals (typically 5-20Hz).
+ * Contains updates to components and states, as well as information about user indices.
+ */
+export type DeltaNetV01Tick = {
+    /** Message type identifier */
+    type: "tick";
+    /** Current server time */
+    serverTime: number;
+    /** Indices of users that have been removed since the last tick */
+    removedIndices: Array<number>;
+    /** Current number of user indices in the system */
+    indicesCount: number;
+    /** Array of component updates using second-order delta compression */
+    componentDeltaDeltas: Array<DeltaNetV01ComponentTick>;
+    /** Array of state updates */
+    states: Array<DeltaNetV01StateUpdates>;
+};
+/**
+ * Encodes a tick message into a binary buffer.
+ * @param msg - The message to encode
+ * @param writer - Optional BufferWriter instance to use (creates a new one if not provided)
+ * @returns The BufferWriter containing the encoded message
+ */
+export declare function encodeTick(msg: DeltaNetV01Tick, writer?: BufferWriter): BufferWriter;
+export declare const lastTickDebugData: {
+    componentsByteLength: number;
+    statesByteLength: number;
+};
+/**
+ * Decodes a tick message from a binary buffer.
+ * Assumes that the first byte (message type) has already been read.
+ * @param buffer - The BufferReader containing the message data
+ * @param opts - Optional options for decoding, such as ignoring data
+ * @returns The decoded tick message
+ */
+export declare function decodeTick(buffer: BufferReader, opts?: DecodeServerMessageOptions): DeltaNetV01Tick;

package/build/delta-net-v0.1/messages/from-server/userIndex.d.ts

@@ -0,0 +1,8 @@
+import { BufferReader } from "../../../BufferReader";
+import { BufferWriter } from "../../../BufferWriter";
+export type DeltaNetV01UserIndexMessage = {
+    type: "userIndex";
+    index: number;
+};
+export declare function encodeUserIndex(msg: DeltaNetV01UserIndexMessage, writer?: BufferWriter): BufferWriter;
+export declare function decodeUserIndex(buffer: BufferReader): DeltaNetV01UserIndexMessage;

package/build/delta-net-v0.1/messages/from-server/warning.d.ts

@@ -0,0 +1,8 @@
+import { BufferReader } from "../../../BufferReader";
+import { BufferWriter } from "../../../BufferWriter";
+export type DeltaNetV01WarningMessage = {
+    type: "warning";
+    message: string;
+};
+export declare function encodeWarning(msg: DeltaNetV01WarningMessage, writer?: BufferWriter): BufferWriter;
+export declare function decodeWarning(buffer: BufferReader): DeltaNetV01WarningMessage;

package/build/delta-net-v0.1/messages/index.d.ts

@@ -0,0 +1,2 @@
+export * from "./from-client";
+export * from "./from-server";

package/build/index.d.ts

@@ -0,0 +1,4 @@
+export * from "./BufferReader";
+export * from "./BufferWriter";
+export * from "./DeflateCompressor";
+export * from "./delta-net-v0.1";