@omujs/omu 0.9.10 → 0.9.27

package/src/api/registry/packets.ts

@@ -0,0 +1,64 @@
+import { Identifier } from '../../identifier';
+import { ByteReader, ByteWriter } from '../../serialize';
+import { RegistryPermissions, RegistryPermissionsJSON } from './registry';
+
+export class RegistryPacket {
+    constructor(
+        public readonly id: Identifier,
+        public readonly value: Uint8Array | null,
+    ) { }
+
+    public static serialize(packet: RegistryPacket): Uint8Array {
+        const writer = new ByteWriter();
+        writer.writeString(packet.id.key());
+        writer.writeBoolean(packet.value !== null);
+        if (packet.value !== null) {
+            writer.writeUint8Array(packet.value);
+        }
+        return writer.finish();
+    }
+
+    public static deserialize(data: Uint8Array): RegistryPacket {
+        const reader = ByteReader.fromUint8Array(data);
+        const id = Identifier.fromKey(reader.readString());
+        const existing = reader.readBoolean();
+        const value = existing ? reader.readUint8Array() : null;
+        return new RegistryPacket(id, value);
+    }
+}
+
+export interface RegisterPacketJSON {
+    id: string;
+    permissions: RegistryPermissionsJSON;
+}
+
+export class RegisterPacket {
+    constructor(
+        public readonly id: Identifier,
+        public readonly permissions: RegistryPermissions,
+    ) {}
+
+    public static serialize(packet: RegisterPacket): RegisterPacketJSON {
+        const { permissions: perms } = packet;
+        return {
+            id: packet.id.key(),
+            permissions: {
+                all: perms.all ? Identifier.from(perms.all).key() : undefined,
+                read: perms.read ? Identifier.from(perms.read).key() : undefined,
+                write: perms.write ? Identifier.from(perms.write).key() : undefined,
+            },
+        };
+    }
+
+    public static deserialize(data: RegisterPacketJSON): RegisterPacket {
+        const { permissions: perms } = data;
+        return new RegisterPacket(
+            Identifier.from(data.id),
+            {
+                all: perms.all ? Identifier.from(perms.all) : undefined,
+                read: perms.read ? Identifier.from(perms.read) : undefined,
+                write: perms.write ? Identifier.from(perms.write) : undefined,
+            },
+        );
+    }
+}

package/src/api/registry/registry.ts

@@ -0,0 +1,73 @@
+import type { Unlisten } from '../../event';
+import { Identifier, IntoId } from '../../identifier';
+import type { JsonType, Serializable } from '../../serialize';
+import { Serializer } from '../../serialize';
+
+export interface RegistryPermissionsJSON {
+    all?: string;
+    read?: string;
+    write?: string;
+}
+
+export interface RegistryPermissions {
+    all?: IntoId;
+    read?: IntoId;
+    write?: IntoId;
+}
+
+export class RegistryType<T> {
+    constructor(
+        public readonly id: Identifier,
+        public readonly defaultValue: T,
+        public readonly serializer: Serializable<T, Uint8Array>,
+        public readonly permissions: RegistryPermissions,
+    ) { }
+
+    public static createJson<T, D extends JsonType = JsonType>(identifier: IntoId, {
+        name,
+        defaultValue,
+        permissions,
+        serializer,
+    }: {
+        name: string;
+        defaultValue: T;
+        permissions?: RegistryPermissions;
+        serializer?: Serializable<T, D>;
+    }): RegistryType<T> {
+        return new RegistryType(
+            Identifier.from(identifier).join(name),
+            defaultValue,
+            Serializer.pipe<T, D, Uint8Array>(serializer ?? Serializer.noop(), Serializer.json()),
+            permissions ?? {},
+        );
+    }
+
+    public static createSerialized<T>(identifier: IntoId, {
+        name,
+        defaultValue,
+        serializer,
+        permissions,
+    }: {
+        name: string;
+        defaultValue: T;
+        serializer: Serializable<T, Uint8Array>;
+        permissions?: RegistryPermissions;
+    }): RegistryType<T> {
+        return new RegistryType(
+            Identifier.from(identifier).join(name),
+            defaultValue,
+            serializer,
+            permissions ?? {},
+        );
+    }
+}
+
+export interface Registry<T> {
+    readonly type: RegistryType<T>;
+    readonly value: T;
+    get(): Promise<T>;
+    set(value: T): Promise<void>;
+    update(fn: (value: T) => PromiseLike<T> | T): Promise<T>;
+    modify(fn: (value: T) => PromiseLike<T> | T): Promise<T>;
+    listen(fn: (value: T) => void): Unlisten;
+}

package/src/api/server/extension.ts

@@ -0,0 +1,126 @@
+import { App, AppJson } from '../../app.js';
+import { Identifier, IdentifierMap } from '../../identifier';
+import { Omu } from '../../omu.js';
+import { EndpointType } from '../endpoint/endpoint.js';
+import { ExtensionType, type Extension } from '../extension.js';
+import { Registry, RegistryType } from '../registry';
+import { TableType, type Table } from '../table';
+
+export const SERVER_EXTENSION_TYPE: ExtensionType<ServerExtension> = new ExtensionType(
+    'server',
+    (omu: Omu) => new ServerExtension(omu),
+);
+
+export interface AppIndexEntry {
+    url: string;
+    added_at: string;
+};
+
+export interface AppIndex {
+    indexes: Record<string, AppIndexEntry>;
+};
+
+export const SERVER_APPS_READ_PERMISSION_ID: Identifier = SERVER_EXTENSION_TYPE.join('apps', 'read');
+export const SERVER_APPS_WRITE_PERMISSION_ID: Identifier = SERVER_EXTENSION_TYPE.join('apps', 'write');
+export const SERVER_INDEX_READ_PERMISSION_ID: Identifier = SERVER_EXTENSION_TYPE.join('index', 'read');
+export const SERVER_INDEX_REGISTRY_TYPE: RegistryType<AppIndex> = RegistryType.createJson<AppIndex>(SERVER_EXTENSION_TYPE, {
+    name: 'index',
+    defaultValue: { 'indexes': {} },
+    permissions: {
+        write: SERVER_APPS_WRITE_PERMISSION_ID,
+        read: SERVER_INDEX_READ_PERMISSION_ID,
+    },
+});
+const APP_TABLE_TYPE = TableType.createJson(SERVER_EXTENSION_TYPE, {
+    name: 'apps',
+    serializer: App,
+    key: (app) => app.id.key(),
+    permissions: {
+        all: SERVER_APPS_WRITE_PERMISSION_ID,
+        read: SERVER_APPS_READ_PERMISSION_ID,
+    },
+});
+
+export const SERVER_SHUTDOWN_PERMISSION_ID: Identifier = SERVER_EXTENSION_TYPE.join('shutdown');
+const SHUTDOWN_ENDPOINT_TYPE = EndpointType.createJson<boolean, boolean>(SERVER_EXTENSION_TYPE, {
+    name: 'shutdown',
+    permissionId: SERVER_SHUTDOWN_PERMISSION_ID,
+});
+export const TRUSTED_ORIGINS_GET_PERMISSION_ID: Identifier = SERVER_EXTENSION_TYPE.join('trusted_origins', 'get');
+export const TRUSTED_ORIGINS_SET_PERMISSION_ID: Identifier = SERVER_EXTENSION_TYPE.join('trusted_origins', 'set');
+const TRUSTED_HOSTS_REGISTRY_TYPE = RegistryType.createJson<Record<string, string>>(SERVER_EXTENSION_TYPE, {
+    name: 'trusted_hosts',
+    defaultValue: {},
+    permissions: {
+        read: TRUSTED_ORIGINS_GET_PERMISSION_ID,
+        write: TRUSTED_ORIGINS_SET_PERMISSION_ID,
+    },
+});
+
+export class ServerExtension implements Extension {
+    public readonly type: ExtensionType<ServerExtension> = SERVER_EXTENSION_TYPE;
+    public readonly apps: Table<App>;
+    public readonly index: Registry<AppIndex>;
+    public readonly trustedHosts: Registry<Record<string, string>>;
+
+    constructor(private readonly omu: Omu) {
+        this.apps = omu.tables.get(APP_TABLE_TYPE);
+        this.index = omu.registries.get(SERVER_INDEX_REGISTRY_TYPE);
+        this.trustedHosts = omu.registries.get(TRUSTED_HOSTS_REGISTRY_TYPE);
+    }
+
+    public async shutdown(restart?: boolean): Promise<boolean> {
+        this.omu.endpoints.call(SHUTDOWN_ENDPOINT_TYPE, restart ?? false);
+        await new Promise<void>((resolve) => {
+            const unlisten = this.omu.network.event.disconnected.listen(() => {
+                resolve();
+                unlisten();
+            });
+        });
+        return true;
+    }
+}
+
+export class SessionObserver {
+    constructor(
+        public readonly onConnectCallbacks: Array<(app: App) => Promise<void> | void>,
+        public readonly onDisconnectCallbacks: Array<(app: App) => Promise<void> | void>,
+    ) { }
+
+    public onConnect(callback: (app: App) => Promise<void> | void): void {
+        this.onConnectCallbacks.push(callback);
+    }
+
+    public onDisconnect(callback: (app: App) => Promise<void> | void): void {
+        this.onDisconnectCallbacks.push(callback);
+    }
+}
+
+export interface AppIndexRegistryJSON {
+    id: string;
+    apps: Record<string, AppJson>;
+}
+
+export class AppIndexRegistry {
+    constructor(
+        public id: Identifier,
+        public apps: IdentifierMap<App>,
+    ) { }
+
+    public static fromJSON(json: AppIndexRegistryJSON): AppIndexRegistry {
+        const id = Identifier.fromKey(json['id']);
+        const apps = new IdentifierMap<App>();
+        for (const [idStr, appJSON] of Object.entries(json['apps'])) {
+            const id = Identifier.fromKey(idStr);
+            const app = App.deserialize(appJSON);
+            if (!id.isNamespaceEqual(app.id)) {
+                throw new Error(`App ID does not match the ID in the index. ${app.id} != ${id}`);
+            }
+            apps.set(id, app);
+        }
+        return new AppIndexRegistry(
+            id,
+            apps,
+        );
+    }
+}

package/src/api/server/index.ts

@@ -0,0 +1,11 @@
+export {
+    AppIndexRegistry,
+    SERVER_APPS_READ_PERMISSION_ID,
+    SERVER_SHUTDOWN_PERMISSION_ID,
+    TRUSTED_ORIGINS_GET_PERMISSION_ID,
+    TRUSTED_ORIGINS_SET_PERMISSION_ID,
+    type AppIndex,
+    type AppIndexEntry,
+    type AppIndexRegistryJSON,
+} from './extension.js';
+

package/src/api/session/extension.ts

@@ -0,0 +1,196 @@
+import { App, AppJson } from '../../app';
+import { Identifier, IdentifierMap, IdentifierSet, IntoId } from '../../identifier';
+import { PacketType } from '../../network/packet';
+import { Omu } from '../../omu';
+import { Serializer } from '../../serialize';
+import { EndpointType } from '../endpoint';
+import { Extension, ExtensionType } from '../extension';
+import { SessionObserver } from '../server/extension';
+import { Table, TableType } from '../table';
+
+export const SESSION_EXTENSION_TYPE: ExtensionType<SessionExtension> = new ExtensionType('sessions', (omu: Omu) => new SessionExtension(omu));
+
+export const SESSIONS_READ_PERMISSION_ID: Identifier = SESSION_EXTENSION_TYPE.join('read');
+const SESSION_TABLE_TYPE = TableType.createJson(SESSION_EXTENSION_TYPE, {
+    name: 'sessions',
+    serializer: App,
+    key: (app) => app.id.key(),
+    permissions: {
+        read: SESSIONS_READ_PERMISSION_ID,
+    },
+});
+const REQUIRE_APPS_PACKET_TYPE = PacketType.createJson<Identifier[]>(SESSION_EXTENSION_TYPE, {
+    name: 'require',
+    serializer: Serializer.of(Identifier).toArray(),
+});
+const SESSION_OBSERVE_PACKET_TYPE = PacketType.createJson<Identifier[]>(SESSION_EXTENSION_TYPE, {
+    name: 'observe',
+    serializer: Serializer.of(Identifier).toArray(),
+});
+const SESSION_CONNECTED_PACKET_TYPE = PacketType.createJson<App>(SESSION_EXTENSION_TYPE, {
+    name: 'session_connected',
+    serializer: App,
+});
+const SESSION_DISCONNECTED_PACKET_TYPE = PacketType.createJson<App>(SESSION_EXTENSION_TYPE, {
+    name: 'session_disconnected',
+    serializer: App,
+});
+
+type RemoteAppRequestPayload = {
+    app: AppJson;
+    permissions: string[];
+};
+
+export type RequestRemoteAppResponse = {
+    type: 'success';
+    token: string;
+    lan_ip: string;
+} | {
+    type: 'error';
+    message: string;
+};
+
+export const REMOTE_APP_REQUEST_PERMISSION_ID: Identifier = SESSION_EXTENSION_TYPE.join('remote_app', 'request');
+
+const REMOTE_APP_REQUEST_ENDPOINT_TYPE = EndpointType.createJson<RemoteAppRequestPayload, RequestRemoteAppResponse>(SESSION_EXTENSION_TYPE, {
+    name: 'remote_app_request',
+    permissionId: REMOTE_APP_REQUEST_PERMISSION_ID,
+});
+
+export type GenerateTokenResponse = {
+    type: 'success';
+    token: string;
+} | {
+    type: 'error';
+    message: string;
+};
+
+export const GENERATE_TOKEN_PERMISSION_ID: Identifier = SESSION_EXTENSION_TYPE.join('generate_token');
+
+type GenerateTokenPayload = {
+    app: AppJson;
+    permissions: string[];
+};
+
+const GENERATE_TOKEN_ENDPOINT_TYPE = EndpointType.createJson<GenerateTokenPayload, GenerateTokenResponse>(SESSION_EXTENSION_TYPE, {
+    name: 'generate_token',
+    permissionId: GENERATE_TOKEN_PERMISSION_ID,
+});
+
+export class SessionExtension implements Extension {
+    public readonly type: ExtensionType<SessionExtension> = SESSION_EXTENSION_TYPE;
+    public readonly sessions: Table<App>;
+    private readonly sessionObservers = new IdentifierMap<SessionObserver>();
+    private readonly requiredApps = new IdentifierSet();
+
+    constructor(private readonly omu: Omu) {
+        omu.network.registerPacket(
+            REQUIRE_APPS_PACKET_TYPE,
+            SESSION_OBSERVE_PACKET_TYPE,
+            SESSION_CONNECTED_PACKET_TYPE,
+            SESSION_DISCONNECTED_PACKET_TYPE,
+        );
+        omu.network.addPacketHandler(
+            SESSION_CONNECTED_PACKET_TYPE, (app) => this.handleSessionConnect(app),
+        );
+        omu.network.addPacketHandler(
+            SESSION_DISCONNECTED_PACKET_TYPE, (app) => this.handleSessionDisconnect(app),
+        );
+        this.sessions = omu.tables.get(SESSION_TABLE_TYPE);
+        omu.network.addTask(() => this.onTask());
+        omu.onReady(() => this.onReady());
+    }
+
+    public async has(id: IntoId): Promise<boolean> {
+        return await this.sessions.has(Identifier.from(id).key());
+    }
+
+    public observe(appId: IntoId, {
+        onConnect,
+        onDisconnect,
+    }: {
+        onConnect(app: App): void;
+        onDisconnect(app: App): void;
+    }): SessionObserver {
+        const id = Identifier.from(appId);
+        if (this.omu.running) {
+            this.omu.send(SESSION_OBSERVE_PACKET_TYPE, [id]);
+        }
+        const observer = this.sessionObservers.get(id) ?? new SessionObserver([], []);
+        observer.onConnect(onConnect);
+        observer.onDisconnect(onDisconnect);
+        this.sessionObservers.set(id, observer);
+        return observer;
+    }
+
+    private async handleSessionConnect(app: App): Promise<void> {
+        const observer = this.sessionObservers.get(app.id);
+        if (!observer) {
+            return;
+        }
+        for (const callback of observer.onConnectCallbacks) {
+            await callback(app);
+        }
+    }
+
+    private async handleSessionDisconnect(app: App): Promise<void> {
+        const observer = this.sessionObservers.get(app.id);
+        if (!observer) {
+            return;
+        }
+        for (const callback of observer.onDisconnectCallbacks) {
+            await callback(app);
+        }
+    }
+
+    public require(...appIds: IntoId[]): void {
+        if (this.omu.running) {
+            throw new Error('Cannot require apps after the client has started');
+        }
+        for (const appId of appIds) {
+            this.requiredApps.add(Identifier.from(appId));
+        }
+    }
+
+    private async onTask(): Promise<void> {
+        if (this.requiredApps.size > 0) {
+            this.omu.send(REQUIRE_APPS_PACKET_TYPE, Array.from(this.requiredApps.values()));
+        }
+    }
+
+    private async onReady(): Promise<void> {
+        if (this.sessionObservers.size > 0) {
+            this.omu.send(SESSION_OBSERVE_PACKET_TYPE, Array.from(this.sessionObservers.keys()));
+        }
+    }
+
+    public async requestRemoteApp(options: {
+        app: App;
+        permissions: IntoId[];
+    }): Promise<RequestRemoteAppResponse> {
+        const { app } = options;
+        if (!app.url) {
+            throw new Error('App must have a URL to request it remotely');
+        }
+        if (app.type !== 'remote') {
+            throw new Error('App must be a remote app to request it remotely');
+        }
+        if (!app.metadata) {
+            throw new Error('App must have metadata to request it remotely');
+        }
+        return this.omu.endpoints.call(REMOTE_APP_REQUEST_ENDPOINT_TYPE, {
+            app: App.serialize(options.app),
+            permissions: options.permissions.map(id => Identifier.from(id).key()),
+        });
+    }
+
+    public async generateToken(options: {
+        app: App;
+        permissions: IntoId[];
+    }): Promise<GenerateTokenResponse> {
+        return this.omu.endpoints.call(GENERATE_TOKEN_ENDPOINT_TYPE, {
+            app: App.serialize(options.app),
+            permissions: options.permissions.map(id => Identifier.from(id).key()),
+        });
+    }
+}

package/src/api/session/index.ts

@@ -0,0 +1,7 @@
+export {
+    GENERATE_TOKEN_PERMISSION_ID, REMOTE_APP_REQUEST_PERMISSION_ID, SESSION_EXTENSION_TYPE,
+    SessionExtension,
+    SESSIONS_READ_PERMISSION_ID,
+    type RequestRemoteAppResponse,
+} from './extension';
+

package/src/{extension/signal/signal-extension.ts → api/signal/extension.ts}

@@ -1,29 +1,24 @@
-import type { Client } from '../../client.js';
-import type { Unlisten } from '../../event-emitter.js';
-import { Identifier, IdentifierMap } from '../../identifier.js';
-import { PacketType } from '../../network/packet/index.js';
-import { Serializable, Serializer } from '../../serializer.js';
-import { type Extension, ExtensionType } from '../extension.js';
-
+import type { Unlisten } from '../../event';
+import { Identifier, IdentifierMap } from '../../identifier';
+import { PacketType } from '../../network/packet';
+import { Omu } from '../../omu';
+import { JsonType, Serializable } from '../../serialize';
+import { ExtensionType, type Extension } from '../extension.js';
 import { SignalPacket, SignalRegisterPacket } from './packets.js';
-import type { Signal } from './signal.js';
-import { SignalType } from './signal.js';
+import { SignalType, type Signal } from './signal.js';
 
-export const SIGNAL_EXTENSION_TYPE = new ExtensionType(
+export const SIGNAL_EXTENSION_TYPE: ExtensionType<SignalExtension> = new ExtensionType(
     'signal',
-    (client: Client) => new SignalExtension(client),
+    (omu: Omu) => new SignalExtension(omu),
 );
 
-const SIGNAL_REGISTER_PACKET = PacketType.createSerialized<SignalRegisterPacket>(
-    SIGNAL_EXTENSION_TYPE,
-    {
-        name: 'register',
-        serializer: SignalRegisterPacket,
-    },
-);
+const SIGNAL_REGISTER_PACKET = PacketType.createJson<SignalRegisterPacket>(SIGNAL_EXTENSION_TYPE, {
+    name: 'register',
+    serializer: SignalRegisterPacket,
+});
 const SIGNAL_LISTEN_PACKET = PacketType.createJson<Identifier>(SIGNAL_EXTENSION_TYPE, {
     name: 'listen',
-    serializer: Serializer.model(Identifier),
+    serializer: Identifier,
 });
 const SIGNAL_NOTIFY_PACKET = PacketType.createSerialized<SignalPacket>(SIGNAL_EXTENSION_TYPE, {
     name: 'notify',
@@ -31,11 +26,11 @@ const SIGNAL_NOTIFY_PACKET = PacketType.createSerialized<SignalPacket>(SIGNAL_EX
 });
 
 export class SignalExtension implements Extension {
-    public readonly type = SIGNAL_EXTENSION_TYPE;
+    public readonly type: ExtensionType<SignalExtension> = SIGNAL_EXTENSION_TYPE;
     private readonly signals = new IdentifierMap<SignalType<unknown>>();
 
-    constructor(private readonly client: Client) {
-        client.network.registerPacket(
+    constructor(private readonly omu: Omu) {
+        omu.network.registerPacket(
             SIGNAL_REGISTER_PACKET,
             SIGNAL_LISTEN_PACKET,
             SIGNAL_NOTIFY_PACKET,
@@ -46,14 +41,23 @@ export class SignalExtension implements Extension {
         if (this.signals.has(signalType.id)) {
             throw new Error(`Signal for key ${signalType.id} already created`);
         }
-        return new SignalImpl(this.client, signalType);
+        return new SignalImpl(this.omu, signalType);
     }
 
-    public create<T>(name: string, options?: { serializer?: Serializable<T, Uint8Array> }): Signal<T> {
-        const id = this.client.app.id.join(name);
-        const type = SignalType.createSerialized<T>(id, { 
+    public json<T, D extends JsonType = JsonType>(name: string, options?: { serializer?: Serializable<T, D> }): Signal<T> {
+        const id = this.omu.app.id.join(name);
+        const type = SignalType.createJson<T>(id, {
             name,
-            serializer: options?.serializer ?? Serializer.json(),
+            serializer: options?.serializer,
+        });
+        return this.createSignal(type);
+    }
+
+    public serialized<T>(name: string, options: { serializer: Serializable<T, Uint8Array> }): Signal<T> {
+        const id = this.omu.app.id.join(name);
+        const type = SignalType.createSerialized<T>(id, {
+            name,
+            serializer: options?.serializer,
         });
         return this.createSignal(type);
     }
@@ -68,25 +72,28 @@ class SignalImpl<T> implements Signal<T> {
     private listening = false;
 
     constructor(
-        private readonly client: Client,
+        private readonly omu: Omu,
         private readonly type: SignalType<T>,
     ) {
-        client.network.addPacketHandler(SIGNAL_NOTIFY_PACKET, (data) => this.handleBroadcast(data));
-        client.network.addTask(() => this.onTask());
+        omu.network.addPacketHandler(SIGNAL_NOTIFY_PACKET, (data) => this.handleBroadcast(data));
+        omu.network.addTask(() => this.onTask());
     }
 
     public notify(body: T): void {
         const data = this.type.serializer.serialize(body);
-        this.client.send(SIGNAL_NOTIFY_PACKET, {
+        this.omu.send(SIGNAL_NOTIFY_PACKET, {
             id: this.type.id,
             body: data,
         });
+        for (const listener of this.listeners) {
+            listener(body);
+        }
     }
 
     public listen(handler: (value: T) => void): Unlisten {
         if (!this.listening) {
-            this.client.onReady(() => {
-                this.client.send(SIGNAL_LISTEN_PACKET, this.type.id);
+            this.omu.onReady(() => {
+                this.omu.send(SIGNAL_LISTEN_PACKET, this.type.id);
             });
             this.listening = true;
         }
@@ -107,10 +114,10 @@ class SignalImpl<T> implements Signal<T> {
     }
 
     private onTask(): void {
-        if (!this.type.id.isSubpathOf(this.client.app.id)) {
+        if (!this.type.id.isSubpathOf(this.omu.app.id)) {
             return;
         }
-        this.client.send(SIGNAL_REGISTER_PACKET, {
+        this.omu.send(SIGNAL_REGISTER_PACKET, {
             id: this.type.id,
             permissions: this.type.permissions,
         });

package/src/api/signal/index.ts

@@ -0,0 +1 @@
+export { SignalPermissions, SignalType, type Signal } from './signal.js';

package/src/api/signal/packets.ts

@@ -0,0 +1,61 @@
+import { Identifier } from '../../identifier';
+import { ByteReader, ByteWriter } from '../../serialize';
+
+import { SignalPermissions, SignalPermissionsJSON } from './signal.js';
+
+export class SignalPacket {
+    constructor(
+        public readonly id: Identifier,
+        public readonly body: Uint8Array,
+    ) { }
+
+    public static serialize(packet: SignalPacket): Uint8Array {
+        const writer = new ByteWriter();
+        writer.writeString(packet.id.key());
+        writer.writeUint8Array(packet.body);
+        return writer.finish();
+    }
+
+    public static deserialize(data: Uint8Array): SignalPacket {
+        const reader = ByteReader.fromUint8Array(data);
+        const id = Identifier.fromKey(reader.readString());
+        const body = reader.readUint8Array();
+        return new SignalPacket(id, body);
+    }
+}
+
+interface SignalRegisterPacketJSON {
+    id: string;
+    permissions: SignalPermissionsJSON;
+}
+
+export class SignalRegisterPacket {
+    constructor(
+        public readonly id: Identifier,
+        public readonly permissions: SignalPermissions,
+    ) {}
+
+    public static serialize(packet: SignalRegisterPacket): SignalRegisterPacketJSON {
+        const { permissions: perms } = packet;
+        return {
+            id: packet.id.key(),
+            permissions: {
+                all: perms.all ? Identifier.from(perms.all).key() : undefined,
+                listen: perms.listen ? Identifier.from(perms.listen).key() : undefined,
+                send: perms.send ? Identifier.from(perms.send).key() : undefined,
+            },
+        };
+    }
+
+    public static deserialize(data: SignalRegisterPacketJSON): SignalRegisterPacket {
+        const { permissions: perms } = data;
+        return new SignalRegisterPacket(
+            Identifier.fromKey(data.id),
+            {
+                all: perms.all ? Identifier.fromKey(perms.all) : undefined,
+                listen: perms.listen ? Identifier.fromKey(perms.listen) : undefined,
+                send: perms.send ? Identifier.fromKey(perms.send) : undefined,
+            },
+        );
+    }
+}