@rforum/protocol 0.1.0

package/dist/content/index.d.ts

@@ -0,0 +1,39 @@
+export type ContentType = "text/plain" | "application/json";
+export interface PostContent {
+    kind: "post";
+    thread_id: string;
+    author_id: string;
+    created_at: number;
+    content_type: ContentType;
+    body: string;
+}
+export interface EditContent {
+    kind: "edit";
+    target_id: string;
+    author_id: string;
+    created_at: number;
+    patch: PatchOperation[];
+}
+export interface ThreadContent {
+    kind: "thread";
+    thread_id: string;
+    root_post_id: string;
+    created_at: number;
+    title?: string;
+}
+export interface ForkContent {
+    kind: "fork";
+    source_thread_id: string;
+    fork_thread_id: string;
+    created_at: number;
+}
+export type ContentObject = PostContent | EditContent | ThreadContent | ForkContent;
+export interface PatchOperation {
+    op: "add" | "remove" | "replace";
+    path: string;
+    value?: unknown;
+}
+export declare function createPost(input: Omit<PostContent, "kind">): PostContent;
+export declare function createEdit(input: Omit<EditContent, "kind">): EditContent;
+export declare function hashContent(content: ContentObject): string;
+export declare function applyPatch<T extends Record<string, unknown>>(base: T, patch: PatchOperation[]): T;

package/dist/content/index.js

@@ -0,0 +1,43 @@
+import { sha256 } from "@noble/hashes/sha256";
+import { bytesToHex, canonicalJson } from "../utils.js";
+export function createPost(input) {
+    return { kind: "post", ...input };
+}
+export function createEdit(input) {
+    return { kind: "edit", ...input };
+}
+export function hashContent(content) {
+    const json = canonicalJson(content);
+    return bytesToHex(sha256(new TextEncoder().encode(json)));
+}
+export function applyPatch(base, patch) {
+    let output = { ...base };
+    for (const op of patch) {
+        output = applyOperation(output, op);
+    }
+    return output;
+}
+function applyOperation(target, op) {
+    const pathParts = op.path.split("/").filter((part) => part.length > 0);
+    if (pathParts.length === 0) {
+        return target;
+    }
+    const root = { ...target };
+    let cursor = root;
+    for (let i = 0; i < pathParts.length - 1; i += 1) {
+        const key = pathParts[i];
+        const next = cursor[key];
+        if (typeof next !== "object" || next === null) {
+            cursor[key] = {};
+        }
+        cursor = cursor[key];
+    }
+    const lastKey = pathParts[pathParts.length - 1];
+    if (op.op === "remove") {
+        delete cursor[lastKey];
+    }
+    else if (op.op === "add" || op.op === "replace") {
+        cursor[lastKey] = op.value;
+    }
+    return root;
+}

package/dist/envelope/index.d.ts

@@ -0,0 +1,26 @@
+import { Bytes } from "../utils.js";
+export type MessageType = number;
+export interface Envelope {
+    version: number;
+    message_type: MessageType;
+    sender_public_key: Bytes;
+    timestamp: number;
+    payload: unknown;
+    signature: Bytes;
+}
+export interface EnvelopeUnsigned {
+    version: number;
+    message_type: MessageType;
+    sender_public_key: Bytes;
+    timestamp: number;
+    payload: unknown;
+}
+export declare function createEnvelope(unsigned: EnvelopeUnsigned, signature: Bytes): Envelope;
+export declare function serializeEnvelope(envelope: Envelope): string;
+export declare function deserializeEnvelope(serialized: string): Envelope;
+export declare function envelopeFromObject(obj: Record<string, unknown>): Envelope;
+export declare function unsignedEnvelopeBytes(unsigned: EnvelopeUnsigned): Bytes;
+export declare function signEnvelope(unsigned: EnvelopeUnsigned, secretKey: Bytes): Envelope;
+export declare function verifyEnvelope(envelope: Envelope): boolean;
+export declare function envelopeToBytes(envelope: Envelope): Bytes;
+export declare function envelopeFromBytes(bytes: Bytes): Envelope;

package/dist/envelope/index.js

@@ -0,0 +1,65 @@
+import nacl from "tweetnacl";
+import { canonicalJson, utf8ToBytes, bytesToUtf8 } from "../utils.js";
+export function createEnvelope(unsigned, signature) {
+    return { ...unsigned, signature };
+}
+export function serializeEnvelope(envelope) {
+    return canonicalJson({
+        version: envelope.version,
+        message_type: envelope.message_type,
+        sender_public_key: Array.from(envelope.sender_public_key),
+        timestamp: envelope.timestamp,
+        payload: envelope.payload,
+        signature: Array.from(envelope.signature)
+    });
+}
+export function deserializeEnvelope(serialized) {
+    const parsed = JSON.parse(serialized);
+    return envelopeFromObject(parsed);
+}
+export function envelopeFromObject(obj) {
+    const version = Number(obj.version);
+    const messageType = Number(obj.message_type);
+    const sender = new Uint8Array(obj.sender_public_key);
+    const signature = new Uint8Array(obj.signature);
+    return {
+        version,
+        message_type: messageType,
+        sender_public_key: sender,
+        timestamp: Number(obj.timestamp),
+        payload: obj.payload,
+        signature
+    };
+}
+export function unsignedEnvelopeBytes(unsigned) {
+    const json = canonicalJson({
+        version: unsigned.version,
+        message_type: unsigned.message_type,
+        sender_public_key: Array.from(unsigned.sender_public_key),
+        timestamp: unsigned.timestamp,
+        payload: unsigned.payload
+    });
+    return utf8ToBytes(json);
+}
+export function signEnvelope(unsigned, secretKey) {
+    const message = unsignedEnvelopeBytes(unsigned);
+    const signature = nacl.sign.detached(message, secretKey);
+    return createEnvelope(unsigned, signature);
+}
+export function verifyEnvelope(envelope) {
+    const unsigned = {
+        version: envelope.version,
+        message_type: envelope.message_type,
+        sender_public_key: envelope.sender_public_key,
+        timestamp: envelope.timestamp,
+        payload: envelope.payload
+    };
+    const message = unsignedEnvelopeBytes(unsigned);
+    return nacl.sign.detached.verify(message, envelope.signature, envelope.sender_public_key);
+}
+export function envelopeToBytes(envelope) {
+    return utf8ToBytes(serializeEnvelope(envelope));
+}
+export function envelopeFromBytes(bytes) {
+    return deserializeEnvelope(bytesToUtf8(bytes));
+}

package/dist/extensions/index.d.ts

@@ -0,0 +1,13 @@
+export interface ExtensionDefinition {
+    namespace: string;
+    message_types: string[];
+    capabilities: string[];
+}
+export declare class ExtensionRegistry {
+    private extensions;
+    register(extension: ExtensionDefinition): void;
+    list(): ExtensionDefinition[];
+    registerMessageType(namespace: string, messageType: string): void;
+    registerCapability(namespace: string, capability: string): void;
+    private getOrCreate;
+}

package/dist/extensions/index.js

@@ -0,0 +1,38 @@
+export class ExtensionRegistry {
+    extensions = new Map();
+    register(extension) {
+        const key = extension.namespace;
+        if (this.extensions.has(key)) {
+            throw new Error("Extension already registered");
+        }
+        this.extensions.set(key, extension);
+    }
+    list() {
+        return Array.from(this.extensions.values());
+    }
+    registerMessageType(namespace, messageType) {
+        const extension = this.getOrCreate(namespace);
+        if (!extension.message_types.includes(messageType)) {
+            extension.message_types.push(messageType);
+        }
+    }
+    registerCapability(namespace, capability) {
+        const extension = this.getOrCreate(namespace);
+        if (!extension.capabilities.includes(capability)) {
+            extension.capabilities.push(capability);
+        }
+    }
+    getOrCreate(namespace) {
+        const existing = this.extensions.get(namespace);
+        if (existing) {
+            return existing;
+        }
+        const created = {
+            namespace,
+            message_types: [],
+            capabilities: []
+        };
+        this.extensions.set(namespace, created);
+        return created;
+    }
+}

package/dist/handshake/index.d.ts

@@ -0,0 +1,39 @@
+export interface Capabilities {
+    supported_protocol_versions: number[];
+    supported_content_types: string[];
+    supported_compression: string[];
+    supported_replication_modes: string[];
+    supported_extensions: string[];
+}
+export interface NegotiatedCapabilities {
+    protocol_version: number | null;
+    content_types: string[];
+    compression: string[];
+    replication_modes: string[];
+    extensions: string[];
+}
+export interface HandshakeHello {
+    type: "hello";
+    timestamp: number;
+    capabilities: Capabilities;
+}
+export interface HandshakeAck {
+    type: "ack";
+    timestamp: number;
+    negotiated: NegotiatedCapabilities;
+}
+export type HandshakeMessage = HandshakeHello | HandshakeAck;
+export declare function negotiateCapabilities(local: Capabilities, remote: Capabilities): NegotiatedCapabilities;
+export type HandshakeState = "idle" | "sent" | "received" | "negotiated" | "failed";
+export declare class HandshakeMachine {
+    private state;
+    private local;
+    private remote;
+    private negotiated;
+    constructor(local: Capabilities);
+    getState(): HandshakeState;
+    getNegotiated(): NegotiatedCapabilities | null;
+    createHello(): HandshakeHello;
+    receiveHello(message: HandshakeHello): HandshakeAck;
+    receiveAck(message: HandshakeAck): void;
+}

package/dist/handshake/index.js

@@ -0,0 +1,49 @@
+import { nowUnixMillis } from "../utils.js";
+export function negotiateCapabilities(local, remote) {
+    const protocol_version = intersectNumbers(local.supported_protocol_versions, remote.supported_protocol_versions)[0] ?? null;
+    return {
+        protocol_version,
+        content_types: intersectStrings(local.supported_content_types, remote.supported_content_types),
+        compression: intersectStrings(local.supported_compression, remote.supported_compression),
+        replication_modes: intersectStrings(local.supported_replication_modes, remote.supported_replication_modes),
+        extensions: intersectStrings(local.supported_extensions, remote.supported_extensions)
+    };
+}
+export class HandshakeMachine {
+    state = "idle";
+    local;
+    remote = null;
+    negotiated = null;
+    constructor(local) {
+        this.local = local;
+    }
+    getState() {
+        return this.state;
+    }
+    getNegotiated() {
+        return this.negotiated;
+    }
+    createHello() {
+        this.state = "sent";
+        return { type: "hello", timestamp: nowUnixMillis(), capabilities: this.local };
+    }
+    receiveHello(message) {
+        this.remote = message.capabilities;
+        this.state = "received";
+        this.negotiated = negotiateCapabilities(this.local, message.capabilities);
+        this.state = this.negotiated.protocol_version ? "negotiated" : "failed";
+        return { type: "ack", timestamp: nowUnixMillis(), negotiated: this.negotiated };
+    }
+    receiveAck(message) {
+        this.negotiated = message.negotiated;
+        this.state = this.negotiated.protocol_version ? "negotiated" : "failed";
+    }
+}
+function intersectStrings(a, b) {
+    const set = new Set(b);
+    return a.filter((item) => set.has(item));
+}
+function intersectNumbers(a, b) {
+    const set = new Set(b);
+    return a.filter((item) => set.has(item)).sort((x, y) => y - x);
+}

package/dist/identity/index.d.ts

@@ -0,0 +1,20 @@
+import { Bytes } from "../utils.js";
+export interface Keypair {
+    publicKey: Bytes;
+    secretKey: Bytes;
+}
+export interface Persona {
+    id: string;
+    publicKey: Bytes;
+    label?: string;
+}
+export declare function generateKeypair(): Keypair;
+export declare function deriveIdentityId(publicKey: Bytes): string;
+export declare function createPersona(publicKey: Bytes, label?: string): Persona;
+export interface SerializedIdentity {
+    public_key_hex: string;
+    secret_key_hex: string;
+    label?: string;
+}
+export declare function serializeIdentity(keypair: Keypair, label?: string): SerializedIdentity;
+export declare function deserializeIdentity(serialized: SerializedIdentity): Keypair;

package/dist/identity/index.js

@@ -0,0 +1,26 @@
+import nacl from "tweetnacl";
+import { sha256 } from "@noble/hashes/sha256";
+import { bytesToHex, hexToBytes } from "../utils.js";
+export function generateKeypair() {
+    const keys = nacl.sign.keyPair();
+    return { publicKey: keys.publicKey, secretKey: keys.secretKey };
+}
+export function deriveIdentityId(publicKey) {
+    return bytesToHex(sha256(publicKey));
+}
+export function createPersona(publicKey, label) {
+    return { id: deriveIdentityId(publicKey), publicKey, label };
+}
+export function serializeIdentity(keypair, label) {
+    return {
+        public_key_hex: bytesToHex(keypair.publicKey),
+        secret_key_hex: bytesToHex(keypair.secretKey),
+        label
+    };
+}
+export function deserializeIdentity(serialized) {
+    return {
+        publicKey: hexToBytes(serialized.public_key_hex),
+        secretKey: hexToBytes(serialized.secret_key_hex)
+    };
+}

package/dist/index.d.ts

@@ -0,0 +1,8 @@
+export * from "./utils.js";
+export * from "./envelope/index.js";
+export * from "./handshake/index.js";
+export * from "./wire/index.js";
+export * from "./identity/index.js";
+export * from "./content/index.js";
+export * from "./replication/index.js";
+export * from "./extensions/index.js";

package/dist/index.js

@@ -0,0 +1,8 @@
+export * from "./utils.js";
+export * from "./envelope/index.js";
+export * from "./handshake/index.js";
+export * from "./wire/index.js";
+export * from "./identity/index.js";
+export * from "./content/index.js";
+export * from "./replication/index.js";
+export * from "./extensions/index.js";

package/dist/replication/index.d.ts

@@ -0,0 +1,43 @@
+export interface GossipHave {
+    type: "have";
+    topic_id: string;
+    post_ids: string[];
+    timestamp: number;
+}
+export interface GossipWant {
+    type: "want";
+    topic_id: string;
+    post_ids: string[];
+    timestamp: number;
+}
+export type GossipMessage = GossipHave | GossipWant;
+export interface PullRequest {
+    type: "pull";
+    topic_id: string;
+    since_ts: number;
+    until_ts: number;
+    max_items: number;
+}
+export interface PushOffer {
+    type: "push";
+    topic_id: string;
+    post_ids: string[];
+}
+export interface PullPushNegotiation {
+    request: PullRequest;
+    offers: PushOffer[];
+}
+export declare class NeighborhoodCache {
+    private peers;
+    private maxPeers;
+    constructor(maxPeers?: number);
+    recordPeer(peerId: string, topics: string[]): void;
+    getPeersForTopic(topicId: string): string[];
+    listPeers(): PeerEntry[];
+}
+interface PeerEntry {
+    peer_id: string;
+    topics: string[];
+    last_seen: number;
+}
+export {};

package/dist/replication/index.js

@@ -0,0 +1,29 @@
+import { nowUnixMillis } from "../utils.js";
+export class NeighborhoodCache {
+    peers = new Map();
+    maxPeers;
+    constructor(maxPeers = 128) {
+        this.maxPeers = maxPeers;
+    }
+    recordPeer(peerId, topics) {
+        if (!this.peers.has(peerId) && this.peers.size >= this.maxPeers) {
+            const oldest = Array.from(this.peers.values()).sort((a, b) => a.last_seen - b.last_seen)[0];
+            if (oldest) {
+                this.peers.delete(oldest.peer_id);
+            }
+        }
+        this.peers.set(peerId, {
+            peer_id: peerId,
+            topics,
+            last_seen: nowUnixMillis()
+        });
+    }
+    getPeersForTopic(topicId) {
+        return Array.from(this.peers.values())
+            .filter((peer) => peer.topics.includes(topicId))
+            .map((peer) => peer.peer_id);
+    }
+    listPeers() {
+        return Array.from(this.peers.values());
+    }
+}

package/dist/tests/wire.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/tests/wire.test.js

@@ -0,0 +1,50 @@
+import { describe, expect, it } from "vitest";
+import { encodeEnvelope, decodeEnvelope, encodeHandshake, decodeHandshake } from "../wire/index.js";
+import { generateKeypair } from "../identity/index.js";
+import { signEnvelope } from "../envelope/index.js";
+function bytesEqual(a, b) {
+    if (a.length !== b.length)
+        return false;
+    for (let i = 0; i < a.length; i += 1) {
+        if (a[i] !== b[i])
+            return false;
+    }
+    return true;
+}
+describe("wire", () => {
+    it("round-trips envelope", () => {
+        const keys = generateKeypair();
+        const unsigned = {
+            version: 1,
+            message_type: 16,
+            sender_public_key: keys.publicKey,
+            timestamp: 1700000000000,
+            payload: { hello: "world", count: 2 }
+        };
+        const envelope = signEnvelope(unsigned, keys.secretKey);
+        const encoded = encodeEnvelope(envelope);
+        const decoded = decodeEnvelope(encoded);
+        expect(decoded.version).toBe(envelope.version);
+        expect(decoded.message_type).toBe(envelope.message_type);
+        expect(decoded.timestamp).toBe(envelope.timestamp);
+        expect(bytesEqual(decoded.sender_public_key, envelope.sender_public_key)).toBe(true);
+        expect(bytesEqual(decoded.signature, envelope.signature)).toBe(true);
+        expect(decoded.payload).toEqual(envelope.payload);
+    });
+    it("round-trips handshake", () => {
+        const message = {
+            type: "hello",
+            timestamp: 1700000000000,
+            capabilities: {
+                supported_protocol_versions: [1],
+                supported_content_types: ["text/plain"],
+                supported_compression: ["none"],
+                supported_replication_modes: ["gossip"],
+                supported_extensions: ["rforum/core"]
+            }
+        };
+        const encoded = encodeHandshake(message);
+        const decoded = decodeHandshake(encoded);
+        expect(decoded).toEqual(message);
+    });
+});

package/dist/utils.d.ts

@@ -0,0 +1,9 @@
+export type Bytes = Uint8Array;
+export declare function bytesToHex(bytes: Bytes): string;
+export declare function hexToBytes(hex: string): Bytes;
+export declare function concatBytes(parts: Bytes[]): Bytes;
+export declare function utf8ToBytes(text: string): Bytes;
+export declare function bytesToUtf8(bytes: Bytes): string;
+export declare function canonicalize(value: unknown): unknown;
+export declare function canonicalJson(value: unknown): string;
+export declare function nowUnixMillis(): number;

package/dist/utils.js

@@ -0,0 +1,61 @@
+export function bytesToHex(bytes) {
+    return Array.from(bytes)
+        .map((b) => b.toString(16).padStart(2, "0"))
+        .join("");
+}
+export function hexToBytes(hex) {
+    const clean = hex.startsWith("0x") ? hex.slice(2) : hex;
+    if (clean.length % 2 !== 0) {
+        throw new Error("Invalid hex length");
+    }
+    const out = new Uint8Array(clean.length / 2);
+    for (let i = 0; i < out.length; i += 1) {
+        out[i] = parseInt(clean.slice(i * 2, i * 2 + 2), 16);
+    }
+    return out;
+}
+export function concatBytes(parts) {
+    const total = parts.reduce((sum, part) => sum + part.length, 0);
+    const out = new Uint8Array(total);
+    let offset = 0;
+    for (const part of parts) {
+        out.set(part, offset);
+        offset += part.length;
+    }
+    return out;
+}
+export function utf8ToBytes(text) {
+    return new TextEncoder().encode(text);
+}
+export function bytesToUtf8(bytes) {
+    return new TextDecoder().decode(bytes);
+}
+function isPlainObject(value) {
+    if (value === null || typeof value !== "object") {
+        return false;
+    }
+    return Object.getPrototypeOf(value) === Object.prototype;
+}
+export function canonicalize(value) {
+    if (Array.isArray(value)) {
+        return value.map((item) => canonicalize(item));
+    }
+    if (isPlainObject(value)) {
+        const entries = Object.entries(value)
+            .filter(([, v]) => v !== undefined)
+            .sort(([a], [b]) => a.localeCompare(b))
+            .map(([k, v]) => [k, canonicalize(v)]);
+        const out = {};
+        for (const [k, v] of entries) {
+            out[k] = v;
+        }
+        return out;
+    }
+    return value;
+}
+export function canonicalJson(value) {
+    return JSON.stringify(canonicalize(value));
+}
+export function nowUnixMillis() {
+    return Date.now();
+}

package/dist/wire/index.d.ts

@@ -0,0 +1,7 @@
+import { Bytes } from "../utils.js";
+import { Envelope } from "../envelope/index.js";
+import { HandshakeMessage } from "../handshake/index.js";
+export declare function encodeEnvelope(envelope: Envelope): Bytes;
+export declare function decodeEnvelope(bytes: Bytes): Envelope;
+export declare function encodeHandshake(message: HandshakeMessage): Bytes;
+export declare function decodeHandshake(bytes: Bytes): HandshakeMessage;

package/dist/wire/index.js

@@ -0,0 +1,141 @@
+import { canonicalJson, bytesToUtf8, utf8ToBytes, concatBytes } from "../utils.js";
+import { envelopeFromObject } from "../envelope/index.js";
+const MAGIC = new Uint8Array([0x52, 0x46, 0x4f, 0x52]);
+const KIND_ENVELOPE = 1;
+const KIND_HANDSHAKE = 2;
+export function encodeEnvelope(envelope) {
+    const payloadJson = canonicalJson(envelope.payload);
+    const payloadBytes = utf8ToBytes(payloadJson);
+    const header = new ByteWriter();
+    header.writeBytes(MAGIC);
+    header.writeU8(KIND_ENVELOPE);
+    header.writeU8(envelope.version);
+    header.writeU16(envelope.message_type);
+    header.writeU64(envelope.timestamp);
+    header.writeU16(envelope.sender_public_key.length);
+    header.writeBytes(envelope.sender_public_key);
+    header.writeU32(payloadBytes.length);
+    header.writeBytes(payloadBytes);
+    header.writeU16(envelope.signature.length);
+    header.writeBytes(envelope.signature);
+    return header.toBytes();
+}
+export function decodeEnvelope(bytes) {
+    const reader = new ByteReader(bytes);
+    reader.expectBytes(MAGIC);
+    reader.expectU8(KIND_ENVELOPE);
+    const version = reader.readU8();
+    const messageType = reader.readU16();
+    const timestamp = reader.readU64();
+    const pubLen = reader.readU16();
+    const publicKey = reader.readBytes(pubLen);
+    const payloadLen = reader.readU32();
+    const payloadJson = bytesToUtf8(reader.readBytes(payloadLen));
+    const signatureLen = reader.readU16();
+    const signature = reader.readBytes(signatureLen);
+    const payload = JSON.parse(payloadJson);
+    return envelopeFromObject({
+        version,
+        message_type: messageType,
+        sender_public_key: Array.from(publicKey),
+        timestamp,
+        payload,
+        signature: Array.from(signature)
+    });
+}
+export function encodeHandshake(message) {
+    const payloadJson = canonicalJson(message);
+    const payloadBytes = utf8ToBytes(payloadJson);
+    const header = new ByteWriter();
+    header.writeBytes(MAGIC);
+    header.writeU8(KIND_HANDSHAKE);
+    header.writeU16(payloadBytes.length);
+    header.writeBytes(payloadBytes);
+    return header.toBytes();
+}
+export function decodeHandshake(bytes) {
+    const reader = new ByteReader(bytes);
+    reader.expectBytes(MAGIC);
+    reader.expectU8(KIND_HANDSHAKE);
+    const len = reader.readU16();
+    const payload = bytesToUtf8(reader.readBytes(len));
+    return JSON.parse(payload);
+}
+class ByteWriter {
+    parts = [];
+    writeU8(value) {
+        this.parts.push(new Uint8Array([value & 0xff]));
+    }
+    writeU16(value) {
+        const buf = new Uint8Array(2);
+        const view = new DataView(buf.buffer);
+        view.setUint16(0, value, false);
+        this.parts.push(buf);
+    }
+    writeU32(value) {
+        const buf = new Uint8Array(4);
+        const view = new DataView(buf.buffer);
+        view.setUint32(0, value, false);
+        this.parts.push(buf);
+    }
+    writeU64(value) {
+        const buf = new Uint8Array(8);
+        const view = new DataView(buf.buffer);
+        view.setBigUint64(0, BigInt(value), false);
+        this.parts.push(buf);
+    }
+    writeBytes(bytes) {
+        this.parts.push(bytes);
+    }
+    toBytes() {
+        return concatBytes(this.parts);
+    }
+}
+class ByteReader {
+    offset = 0;
+    view;
+    bytes;
+    constructor(bytes) {
+        this.bytes = bytes;
+        this.view = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);
+    }
+    readU8() {
+        const value = this.view.getUint8(this.offset);
+        this.offset += 1;
+        return value;
+    }
+    readU16() {
+        const value = this.view.getUint16(this.offset, false);
+        this.offset += 2;
+        return value;
+    }
+    readU32() {
+        const value = this.view.getUint32(this.offset, false);
+        this.offset += 4;
+        return value;
+    }
+    readU64() {
+        const value = Number(this.view.getBigUint64(this.offset, false));
+        this.offset += 8;
+        return value;
+    }
+    readBytes(length) {
+        const out = this.bytes.slice(this.offset, this.offset + length);
+        this.offset += length;
+        return out;
+    }
+    expectBytes(expected) {
+        const actual = this.readBytes(expected.length);
+        for (let i = 0; i < expected.length; i += 1) {
+            if (actual[i] !== expected[i]) {
+                throw new Error("Invalid magic bytes");
+            }
+        }
+    }
+    expectU8(expected) {
+        const actual = this.readU8();
+        if (actual !== expected) {
+            throw new Error("Unexpected message kind");
+        }
+    }
+}

package/package.json

@@ -0,0 +1,22 @@
+{
+  "name": "@rforum/protocol",
+  "version": "0.1.0",
+  "description": "RForum protocol library (app-agnostic)",
+  "type": "module",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "files": ["dist"],
+  "scripts": {
+    "build": "tsc -p tsconfig.json",
+    "test": "vitest run"
+  },
+  "dependencies": {
+    "@noble/hashes": "^1.4.0",
+    "tweetnacl": "^1.0.3"
+  },
+  "devDependencies": {
+    "@types/node": "^20.11.30",
+    "typescript": "^5.4.5",
+    "vitest": "^1.5.0"
+  }
+}