@omujs/omu 0.1.22

package/src/extension/asset/asset-extension.ts

@@ -0,0 +1,148 @@
+import { ByteReader, ByteWriter } from '../../bytebuffer.js';
+import type { Client } from '../../client.js';
+import { Identifier } from '../../identifier.js';
+import { Serializer } from '../../serializer.js';
+import { EndpointType } from '../endpoint/endpoint.js';
+import { ExtensionType } from '../extension.js';
+
+export const ASSET_EXTENSION_TYPE = new ExtensionType(
+    'asset',
+    (client: Client) => new AssetExtension(client),
+);
+
+type File = {
+    identifier: Identifier;
+    buffer: Uint8Array;
+};
+
+const FILE_SERIALIZER = new Serializer<File, Uint8Array>(
+    (file) => {
+        const writer = new ByteWriter();
+        writer.writeString(file.identifier.key());
+        writer.writeByteArray(file.buffer);
+        return writer.finish();
+    },
+    (data) => {
+        const reader = new ByteReader(data);
+        const identifier = Identifier.fromKey(reader.readString());
+        const buffer = reader.readByteArray();
+        reader.finish();
+        return { identifier, buffer };
+    },
+);
+const FILE_ARRAY_SERIALIZER = new Serializer<File[], Uint8Array>(
+    (files) => {
+        const writer = new ByteWriter();
+        writer.writeInt(files.length);
+        for (const file of files) {
+            writer.writeString(file.identifier.key());
+            writer.writeByteArray(file.buffer);
+        }
+        return writer.finish();
+    },
+    (data) => {
+        const reader = new ByteReader(data);
+        const count = reader.readInt();
+        const files: File[] = [];
+        for (let i = 0; i < count; i++) {
+            const identifier = Identifier.fromKey(reader.readString());
+            const buffer = reader.readByteArray();
+            files.push({ identifier, buffer });
+        }
+        reader.finish();
+        return files;
+    },
+);
+
+export const ASSET_UPLOAD_PERMISSION_ID = ASSET_EXTENSION_TYPE.join('upload');
+const ASSET_UPLOAD_ENDPOINT = EndpointType.createSerialized<File, Identifier>(
+    ASSET_EXTENSION_TYPE,
+    {
+        name: 'upload',
+        requestSerializer: FILE_SERIALIZER,
+        responseSerializer: Serializer.model(Identifier).pipe(Serializer.json()),
+        permissionId: ASSET_UPLOAD_PERMISSION_ID,
+    },
+);
+export const ASSET_UPLOAD_MANY_PERMISSION_ID = ASSET_EXTENSION_TYPE.join('upload', 'many');
+const ASSET_UPLOAD_MANY_ENDPOINT = EndpointType.createSerialized<File[], Identifier[]>(
+    ASSET_EXTENSION_TYPE,
+    {
+        name: 'upload_many',
+        requestSerializer: FILE_ARRAY_SERIALIZER,
+        responseSerializer: Serializer.model(Identifier).toArray().pipe(Serializer.json()),
+        permissionId: ASSET_UPLOAD_MANY_PERMISSION_ID,
+    },
+);
+export const ASSET_DOWNLOAD_PERMISSION_ID = ASSET_EXTENSION_TYPE.join('download');
+const ASSET_DOWNLOAD_ENDPOINT = EndpointType.createSerialized<Identifier, File>(
+    ASSET_EXTENSION_TYPE,
+    {
+        name: 'download',
+        requestSerializer: Serializer.model(Identifier).pipe(Serializer.json()),
+        responseSerializer: FILE_SERIALIZER,
+        permissionId: ASSET_DOWNLOAD_PERMISSION_ID,
+    },
+);
+export const ASSET_DOWNLOAD_MANY_PERMISSION_ID = ASSET_EXTENSION_TYPE.join('download', 'many');
+const ASSET_DOWNLOAD_MANY_ENDPOINT = EndpointType.createSerialized<Identifier[], File[]>(
+    ASSET_EXTENSION_TYPE,
+    {
+        name: 'download_many',
+        requestSerializer: Serializer.model(Identifier).toArray().pipe(Serializer.json()),
+        responseSerializer: FILE_ARRAY_SERIALIZER,
+        permissionId: ASSET_DOWNLOAD_MANY_PERMISSION_ID,
+    },
+);
+
+export class AssetExtension {
+    constructor(private readonly client: Client) {}
+
+    public async upload(identifier: Identifier, buffer: Uint8Array): Promise<Identifier> {
+        const assetIdentifier = await this.client.endpoints.call(ASSET_UPLOAD_ENDPOINT, {
+            identifier,
+            buffer,
+        });
+        return assetIdentifier;
+    }
+
+    public async uploadMany(...files: File[]): Promise<Identifier[]> {
+        const uploaded = await this.client.endpoints.call(ASSET_UPLOAD_MANY_ENDPOINT, files);
+        return uploaded;
+    }
+
+    public async download(identifier: Identifier): Promise<File> {
+        const downloaded = await this.client.endpoints.call(ASSET_DOWNLOAD_ENDPOINT, identifier);
+        return downloaded;
+    }
+
+    public async downloadMany(...identifiers: Identifier[]): Promise<File[]> {
+        const downloaded = await this.client.endpoints.call(
+            ASSET_DOWNLOAD_MANY_ENDPOINT,
+            identifiers,
+        );
+        return downloaded;
+    }
+
+    public url(
+        identifier: Identifier,
+        {
+            noCache,
+        }: {
+            noCache?: boolean;
+        } = {},
+    ): string {
+        const address = this.client.network.address;
+        const protocol = address.secure ? 'https' : 'http';
+        if (noCache) {
+            return `${protocol}://${address.host}:${address.port}/asset?id=${encodeURIComponent(identifier.key())}&t=${Date.now()}`;
+        }
+        return `${protocol}://${address.host}:${address.port}/asset?id=${encodeURIComponent(identifier.key())}`;
+    }
+
+    public proxy(url: string): string {
+        const address = this.client.network.address;
+        const protocol = address.secure ? 'https' : 'http';
+        return `${protocol}://${address.host}:${address.port}/proxy?url=${encodeURIComponent(url)}`;
+    }
+}

package/src/extension/asset/index.ts

@@ -0,0 +1 @@
+export { ASSET_DOWNLOAD_MANY_PERMISSION_ID, ASSET_DOWNLOAD_PERMISSION_ID, ASSET_EXTENSION_TYPE, ASSET_UPLOAD_MANY_PERMISSION_ID, ASSET_UPLOAD_PERMISSION_ID, AssetExtension } from './asset-extension.js';

package/src/extension/dashboard/dashboard-extension.ts

@@ -0,0 +1,162 @@
+import { App } from '../../app.js';
+import type { Client } from '../../client.js';
+import { Identifier } from '../../identifier.js';
+import { PacketType } from '../../network/packet/packet.js';
+import { Serializer } from '../../serializer.js';
+import { EndpointType } from '../endpoint/endpoint.js';
+import { ExtensionType } from '../extension.js';
+import type { Table } from '../table/table.js';
+import { TableType } from '../table/table.js';
+
+import type { DashboardHandler } from './dashboard.js';
+import { PermissionRequestPacket, PluginRequestPacket } from './packets.js';
+
+export const DASHBOARD_EXTENSION_TYPE = new ExtensionType(
+    'dashboard',
+    (client: Client) => new DashboardExtension(client),
+);
+
+type DashboardSetResponse = {
+    success: boolean;
+};
+export const DASHBOARD_SET_PERMISSION_ID = DASHBOARD_EXTENSION_TYPE.join('set');
+const DASHBOARD_SET_ENDPOINT = EndpointType.createJson<Identifier, DashboardSetResponse>(
+    DASHBOARD_EXTENSION_TYPE,
+    {
+        name: 'set',
+        requestSerializer: Serializer.model(Identifier),
+        permissionId: DASHBOARD_SET_PERMISSION_ID,
+    },
+);
+const DASHBOARD_PERMISSION_REQUEST_PACKET = PacketType.createSerialized<PermissionRequestPacket>(
+    DASHBOARD_EXTENSION_TYPE,
+    {
+        name: 'permission_request',
+        serializer: PermissionRequestPacket,
+    },
+);
+const DASHBOARD_PERMISSION_ACCEPT_PACKET = PacketType.createJson<string>(DASHBOARD_EXTENSION_TYPE, {
+    name: 'permission_accept',
+});
+const DASHBOARD_PERMISSION_DENY_PACKET = PacketType.createJson<string>(DASHBOARD_EXTENSION_TYPE, {
+    name: 'permission_deny',
+});
+const DASHBOARD_PLUGIN_REQUEST_PACKET = PacketType.createSerialized<PluginRequestPacket>(
+    DASHBOARD_EXTENSION_TYPE,
+    {
+        name: 'plugin_request',
+        serializer: PluginRequestPacket,
+    },
+);
+const DASHBOARD_PLUGIN_ACCEPT_PACKET = PacketType.createJson<string>(DASHBOARD_EXTENSION_TYPE, {
+    name: 'plugin_accept',
+});
+const DASHBOARD_PLUGIN_DENY_PACKET = PacketType.createJson<string>(DASHBOARD_EXTENSION_TYPE, {
+    name: 'plugin_deny',
+});
+export const DASHBOARD_OPEN_APP_PERMISSION_ID = DASHBOARD_EXTENSION_TYPE.join('app', 'open');
+const DASHBOARD_OPEN_APP_ENDPOINT = EndpointType.createJson<App, void>(DASHBOARD_EXTENSION_TYPE, {
+    name: 'open_app',
+    requestSerializer: Serializer.model(App),
+    permissionId: DASHBOARD_OPEN_APP_PERMISSION_ID,
+});
+const DASHBOARD_OPEN_APP_PACKET = PacketType.createJson<App>(DASHBOARD_EXTENSION_TYPE, {
+    name: 'open_app',
+    serializer: Serializer.model(App),
+});
+export const DASHOBARD_APP_READ_PERMISSION_ID = DASHBOARD_EXTENSION_TYPE.join('app', 'read');
+export const DASHOBARD_APP_EDIT_PERMISSION_ID = DASHBOARD_EXTENSION_TYPE.join('app', 'edit');
+const DASHBOARD_APP_TABLE_TYPE = TableType.createModel(DASHBOARD_EXTENSION_TYPE, {
+    name: 'apps',
+    model: App,
+    permissions: {
+        read: DASHOBARD_APP_READ_PERMISSION_ID,
+        write: DASHOBARD_APP_EDIT_PERMISSION_ID,
+        remove: DASHOBARD_APP_EDIT_PERMISSION_ID,
+    },
+});
+
+export class DashboardExtension {
+    private dashboard: DashboardHandler | null = null;
+    public readonly apps: Table<App>;
+
+    constructor(private readonly client: Client) {
+        client.network.registerPacket(
+            DASHBOARD_PERMISSION_REQUEST_PACKET,
+            DASHBOARD_PERMISSION_ACCEPT_PACKET,
+            DASHBOARD_PERMISSION_DENY_PACKET,
+            DASHBOARD_PLUGIN_REQUEST_PACKET,
+            DASHBOARD_PLUGIN_ACCEPT_PACKET,
+            DASHBOARD_PLUGIN_DENY_PACKET,
+            DASHBOARD_OPEN_APP_PACKET,
+        );
+        client.network.addPacketHandler(DASHBOARD_PERMISSION_REQUEST_PACKET, (request) =>
+            this.handlePermissionRequest(request),
+        );
+        client.network.addPacketHandler(DASHBOARD_PLUGIN_REQUEST_PACKET, (request) =>
+            this.handlePluginRequest(request),
+        );
+        client.network.addPacketHandler(DASHBOARD_OPEN_APP_PACKET, (app) =>
+            this.handleOpenApp(app),
+        );
+        this.apps = client.tables.get(DASHBOARD_APP_TABLE_TYPE);
+    }
+
+    private async handlePermissionRequest(request: PermissionRequestPacket): Promise<void> {
+        await this.handleDashboard(async (dashboard) => {
+            const response = await dashboard.handlePermissionRequest(request);
+            if (response) {
+                this.client.send(DASHBOARD_PERMISSION_ACCEPT_PACKET, request.requestId);
+            } else {
+                this.client.send(DASHBOARD_PERMISSION_DENY_PACKET, request.requestId);
+            }
+        });
+    }
+
+    private async handlePluginRequest(request: PluginRequestPacket): Promise<void> {
+        await this.handleDashboard(async (dashboard) => {
+            const response = await dashboard.handlePluginRequest(request);
+            if (response) {
+                this.client.send(DASHBOARD_PLUGIN_ACCEPT_PACKET, request.requestId);
+            } else {
+                this.client.send(DASHBOARD_PLUGIN_DENY_PACKET, request.requestId);
+            }
+        });
+    }
+
+    private async handleOpenApp(app: App): Promise<void> {
+        await this.handleDashboard(async (dashboard) => {
+            await dashboard.handleOpenApp(app);
+        });
+    }
+
+    private async handleDashboard(
+        callback: (dashboard: DashboardHandler) => Promise<void>,
+    ): Promise<void> {
+        if (this.dashboard === null) {
+            throw new Error('Dashboard not set');
+        }
+        await callback(this.dashboard);
+    }
+
+    public set(dashboard: DashboardHandler): void {
+        this.client.permissions.require(DASHBOARD_SET_PERMISSION_ID);
+        if (this.dashboard !== null) {
+            throw new Error('Dashboard already set');
+        }
+        this.dashboard = dashboard;
+        this.client.whenReady(async () => {
+            const response = await this.client.endpoints.call(
+                DASHBOARD_SET_ENDPOINT,
+                this.client.app.id,
+            );
+            if (!response.success) {
+                throw new Error('Failed to set dashboard');
+            }
+        });
+    }
+
+    public async openApp(app: App): Promise<void> {
+        return await this.client.endpoints.call(DASHBOARD_OPEN_APP_ENDPOINT, app);
+    }
+}

package/src/extension/dashboard/dashboard.ts

@@ -0,0 +1,9 @@
+import type { App } from '../../app.js';
+
+import type { PermissionRequestPacket, PluginRequestPacket } from './packets.js';
+
+export interface DashboardHandler {
+    handlePermissionRequest(request: PermissionRequestPacket): Promise<boolean>;
+    handlePluginRequest(request: PluginRequestPacket): Promise<boolean>;
+    handleOpenApp(app: App): Promise<void>;
+}

package/src/extension/dashboard/index.ts

@@ -0,0 +1,3 @@
+export { DASHBOARD_EXTENSION_TYPE, DASHBOARD_OPEN_APP_PERMISSION_ID, DASHBOARD_SET_PERMISSION_ID, DASHOBARD_APP_EDIT_PERMISSION_ID, DASHOBARD_APP_READ_PERMISSION_ID, DashboardExtension } from './dashboard-extension.js';
+export { DashboardHandler } from './dashboard.js';
+

package/src/extension/dashboard/packets.ts

@@ -0,0 +1,52 @@
+import { App } from '../../app.js';
+import { ByteReader, ByteWriter } from '../../bytebuffer.js';
+import { PermissionType } from '../permission/permission.js';
+import type { PackageInfo } from '../plugin/package-info.js';
+
+export class PermissionRequestPacket {
+    constructor(
+        public readonly requestId: string,
+        public readonly app: App,
+        public readonly permissions: PermissionType[],
+    ) { }
+
+    public static serialize(packet: PermissionRequestPacket): Uint8Array {
+        const writer = new ByteWriter();
+        writer.writeString(packet.requestId);
+        writer.writeString(JSON.stringify(packet.app.toJson()));
+        writer.writeString(JSON.stringify(packet.permissions.map(permission => permission.toJson())));
+        return writer.finish();
+    }
+
+    public static deserialize(data: Uint8Array): PermissionRequestPacket {
+        const reader = new ByteReader(data);
+        const requestId = reader.readString();
+        const app = App.fromJson(JSON.parse(reader.readString()));
+        const permissions = JSON.parse(reader.readString()).map(PermissionType.fromJson);
+        return new PermissionRequestPacket(requestId, app, permissions);
+    }
+}
+
+export class PluginRequestPacket {
+    constructor(
+        public readonly requestId: string,
+        public readonly app: App,
+        public readonly packages: PackageInfo[],
+    ) { }
+
+    public static serialize(packet: PluginRequestPacket): Uint8Array {
+        const writer = new ByteWriter();
+        writer.writeString(packet.requestId);
+        writer.writeString(JSON.stringify(packet.app.toJson()));
+        writer.writeString(JSON.stringify(packet.packages));
+        return writer.finish();
+    }
+
+    public static deserialize(data: Uint8Array): PluginRequestPacket {
+        const reader = new ByteReader(data);
+        const requestId = reader.readString();
+        const app = App.fromJson(JSON.parse(reader.readString()));
+        const packages = JSON.parse(reader.readString());
+        return new PluginRequestPacket(requestId, app, packages);
+    }
+}

package/src/extension/endpoint/endpoint-extension.ts

@@ -0,0 +1,124 @@
+import type { Client } from '../../client.js';
+import type { Identifier } from '../../identifier.js';
+import { IdentifierMap } from '../../identifier.js';
+import { PacketType } from '../../network/packet/index.js';
+import { ExtensionType } from '../extension.js';
+
+import { EndpointType } from './endpoint.js';
+import { EndpointDataPacket, EndpointErrorPacket, EndpointRegisterPacket } from './packets.js';
+
+export const ENDPOINT_EXTENSION_TYPE = new ExtensionType(
+    'endpoint',
+    (client: Client) => new EndpointExtension(client),
+);
+
+type CallPromise = {
+    resolve: (data: Uint8Array) => void;
+    reject: (error: Error) => void;
+};
+
+type EndpointHandler = {
+    type: EndpointType;
+    handler: (arg: any) => Promise<any>;
+};
+
+export class EndpointExtension {
+    private readonly registeredEndpoints = new IdentifierMap<EndpointHandler>();
+    private readonly promiseMap: Map<number, CallPromise> = new Map();
+    private callId: number;
+
+    constructor(private readonly client: Client) {
+        this.callId = 0;
+        client.network.registerPacket(
+            ENDPOINT_REGISTER_PACKET,
+            ENDPOINT_CALL_PACKET,
+            ENDPOINT_RECEIVE_PACKET,
+            ENDPOINT_ERROR_PACKET,
+        );
+        client.network.addPacketHandler(ENDPOINT_RECEIVE_PACKET, (event) => {
+            const promise = this.promiseMap.get(event.key);
+            if (!promise) return;
+            this.promiseMap.delete(event.key);
+            promise.resolve(event.data);
+        });
+        client.network.addPacketHandler(ENDPOINT_ERROR_PACKET, (event) => {
+            const promise = this.promiseMap.get(event.key);
+            if (!promise) return;
+            this.promiseMap.delete(event.key);
+            promise.reject(new Error(event.error));
+        });
+        client.network.addTask(() => this.onTask());
+    }
+
+    private onTask(): void {
+        const endpoints = new IdentifierMap<Identifier | undefined>();
+        for (const [key, endpoint] of this.registeredEndpoints) {
+            endpoints.set(key, endpoint.type.permissionId);
+        }
+        const packet = new EndpointRegisterPacket(endpoints);
+        this.client.send(ENDPOINT_REGISTER_PACKET, packet);
+    }
+
+    public register<Req, Res>(
+        type: EndpointType<Req, Res>,
+        handler: (data: Req) => Promise<Res>,
+    ): void {
+        if (this.client.running) {
+            throw new Error('Cannot register endpoints after the client has started');
+        }
+        if (this.registeredEndpoints.has(type.id)) {
+            throw new Error(`Endpoint for key ${type.id} already registered`);
+        }
+        this.registeredEndpoints.set(type.id, { type, handler });
+    }
+
+    public listen<Req, Res>(handler: (data: Req) => Promise<Res>, name?: string): void {
+        const type = EndpointType.createJson<Req, Res>(this.client.app.id, {
+            name: name ?? handler.name,
+        });
+        this.register(type, handler);
+    }
+
+    public async call<Req, Res>(endpoint: EndpointType<Req, Res>, data: Req): Promise<Res> {
+        const key = this.callId++;
+        const promise = new Promise<Uint8Array>((resolve, reject) => {
+            this.promiseMap.set(key, { resolve, reject });
+        });
+        this.client.send(ENDPOINT_CALL_PACKET, {
+            id: endpoint.id,
+            key,
+            data: endpoint.requestSerializer.serialize(data),
+        });
+        const response = await promise;
+        return endpoint.responseSerializer.deserialize(response);
+    }
+}
+
+const ENDPOINT_REGISTER_PACKET = PacketType.createSerialized<EndpointRegisterPacket>(
+    ENDPOINT_EXTENSION_TYPE,
+    {
+        name: 'register',
+        serializer: EndpointRegisterPacket,
+    },
+);
+const ENDPOINT_CALL_PACKET = PacketType.createSerialized<EndpointDataPacket>(
+    ENDPOINT_EXTENSION_TYPE,
+    {
+        name: 'call',
+        serializer: EndpointDataPacket,
+    },
+);
+const ENDPOINT_RECEIVE_PACKET = PacketType.createSerialized<EndpointDataPacket>(
+    ENDPOINT_EXTENSION_TYPE,
+    {
+        name: 'receive',
+        serializer: EndpointDataPacket,
+    },
+);
+const ENDPOINT_ERROR_PACKET = PacketType.createSerialized<EndpointErrorPacket>(
+    ENDPOINT_EXTENSION_TYPE,
+    {
+        name: 'error',
+        serializer: EndpointErrorPacket,
+    },
+);

package/src/extension/endpoint/endpoint.ts

@@ -0,0 +1,58 @@
+import type { Identifier } from '../../identifier.js';
+import { Serializer, type Serializable } from '../../serializer.js';
+
+export class EndpointType<Req = unknown, Res = unknown> {
+    constructor(
+        public readonly id: Identifier,
+        public readonly requestSerializer: Serializable<Req, Uint8Array>,
+        public readonly responseSerializer: Serializable<Res, Uint8Array>,
+        public readonly permissionId?: Identifier,
+    ) { }
+
+    static createJson<Req, Res>(
+        identifier: Identifier,
+        {
+            name,
+            requestSerializer,
+            responseSerializer,
+            permissionId,
+        }: {
+            name: string,
+            requestSerializer?: Serializable<Req, any>,
+            responseSerializer?: Serializable<Res, any>,
+            permissionId?: Identifier,
+        },
+    ): EndpointType<Req, Res> {
+        return new EndpointType<Req, Res>(
+            identifier.join(name),
+            Serializer.of<Req, any>(requestSerializer ?? Serializer.noop())
+                .pipe(Serializer.json()),
+            Serializer.of<Res, any>(responseSerializer ?? Serializer.noop())
+                .pipe(Serializer.json()),
+            permissionId,
+        );
+    }
+
+    static createSerialized<Req, Res>(
+        identifier: Identifier,
+        {
+            name,
+            requestSerializer,
+            responseSerializer,
+            permissionId,
+        }: {
+            name: string,
+            requestSerializer: Serializable<Req, Uint8Array>,
+            responseSerializer: Serializable<Res, Uint8Array>,
+            permissionId?: Identifier,
+        },
+    ): EndpointType<Req, Res> {
+        return new EndpointType<Req, Res>(
+            identifier.join(name),
+            requestSerializer,
+            responseSerializer,
+            permissionId,
+        );
+    }
+}
+

package/src/extension/endpoint/index.ts

@@ -0,0 +1,3 @@
+export { ENDPOINT_EXTENSION_TYPE, EndpointExtension } from './endpoint-extension.js';
+export { type EndpointType } from './endpoint.js';
+

package/src/extension/endpoint/packets.ts

@@ -0,0 +1,78 @@
+import { ByteReader, ByteWriter } from '../../bytebuffer.js';
+import { Identifier, IdentifierMap } from '../../identifier.js';
+
+export class EndpointRegisterPacket {
+    constructor(
+        public endpoints: IdentifierMap<Identifier | undefined>,
+    ) { }
+
+    public static serialize(item: EndpointRegisterPacket): Uint8Array {
+        const writer = new ByteWriter();
+        writer.writeInt(item.endpoints.size);
+        for (const [key, value] of item.endpoints) {
+            writer.writeString(key.key());
+            writer.writeString(value?.key() ?? '');
+        }
+        return writer.finish();
+    }
+
+    public static deserialize(item: Uint8Array): EndpointRegisterPacket {
+        const reader = new ByteReader(item);
+        const count = reader.readInt();
+        const endpoints = new IdentifierMap<Identifier | undefined>();
+        for (let i = 0; i < count; i++) {
+            const key = Identifier.fromKey(reader.readString());
+            const value = Identifier.fromKey(reader.readString());
+            endpoints.set(key, value);
+        }
+        return new EndpointRegisterPacket(endpoints);
+    }
+}
+
+export class EndpointDataPacket {
+    constructor(
+        public id: Identifier,
+        public key: number,
+        public data: Uint8Array,
+    ) { }
+
+    public static serialize(item: EndpointDataPacket): Uint8Array {
+        const writer = new ByteWriter();
+        writer.writeString(item.id.key());
+        writer.writeInt(item.key);
+        writer.writeByteArray(item.data);
+        return writer.finish();
+    }
+
+    public static deserialize(item: Uint8Array): EndpointDataPacket {
+        const reader = new ByteReader(item);
+        const id = Identifier.fromKey(reader.readString());
+        const key = reader.readInt();
+        const data = reader.readByteArray();
+        return new EndpointDataPacket(id, key, data);
+    }
+}
+
+export class EndpointErrorPacket {
+    constructor(
+        public id: Identifier,
+        public key: number,
+        public error: string,
+    ) { }
+
+    public static serialize(item: EndpointErrorPacket): Uint8Array {
+        const writer = new ByteWriter();
+        writer.writeString(item.id.key());
+        writer.writeInt(item.key);
+        writer.writeString(item.error);
+        return writer.finish();
+    }
+
+    public static deserialize(item: Uint8Array): EndpointErrorPacket {
+        const reader = new ByteReader(item);
+        const id = Identifier.fromKey(reader.readString());
+        const key = reader.readInt();
+        const error = reader.readString();
+        return new EndpointErrorPacket(id, key, error);
+    }
+}

package/src/extension/extension-registry.ts

@@ -0,0 +1,39 @@
+import type { Client } from '../client.js';
+
+import type { Extension, ExtensionType } from './extension.js';
+
+export class ExtensionRegistry {
+    private readonly extensionMap: Map<string, Extension> = new Map();
+    constructor(private readonly client: Client) {}
+    register<T extends Extension>(type: ExtensionType<T>): T {
+        if (this.has(type)) {
+            throw new Error(`Extension type ${type.name} already registered`);
+        }
+        type.dependencies?.().forEach((dependency) => {
+            if (!this.has(dependency)) {
+                throw new Error(
+                    `Extension type ${type.name} depends on ${dependency.name} which is not registered`,
+                );
+            }
+        });
+        const extension = type.create(this.client);
+        this.extensionMap.set(type.name, extension);
+        return extension;
+    }
+
+    registerAll(types: ExtensionType[]): void {
+        types.forEach((type) => this.register(type));
+    }
+
+    get<Ext extends Extension>(extensionType: ExtensionType<Ext>): Ext {
+        const extension = this.extensionMap.get(extensionType.name);
+        if (!extension) {
+            throw new Error(`Extension type ${extensionType.name} not registered`);
+        }
+        return extension as Ext;
+    }
+
+    has<T extends Extension>(extensionType: ExtensionType<T>): boolean {
+        return this.extensionMap.has(extensionType.name);
+    }
+}