@omujs/omu 0.9.10 → 0.9.27

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

@@ -1,238 +0,0 @@
-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 { AppInstallRequest, AppInstallResponse, AppUpdateRequest, AppUpdateResponse, 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 const DASHBOARD_APP_INSTALL_PERMISSION_ID = DASHBOARD_EXTENSION_TYPE.join('app', 'install');
-const DASHBOARD_APP_INSTALL_ENDPOINT = EndpointType.createJson<App, AppInstallResponse>(DASHBOARD_EXTENSION_TYPE, {
-    name: 'install_app',
-    requestSerializer: Serializer.model(App),
-    permissionId: DASHBOARD_APP_INSTALL_PERMISSION_ID,
-});
-const DASHBOARD_APP_INSTALL_PACKET = PacketType.createSerialized<AppInstallRequest>(DASHBOARD_EXTENSION_TYPE, {
-    name: 'install_app',
-    serializer: AppInstallRequest,
-});
-const DASHBOARD_APP_INSTALL_ACCEPT_PACKET = PacketType.createJson<string>(DASHBOARD_EXTENSION_TYPE, {
-    name: 'install_app_accept',
-});
-const DASHBOARD_APP_INSTALL_DENY_PACKET = PacketType.createJson<string>(DASHBOARD_EXTENSION_TYPE, {
-    name: 'install_app_deny',
-});
-const DASHBOARD_APP_UPDATE_PERMISSION_ID = DASHBOARD_EXTENSION_TYPE.join('app', 'update');
-const DASHBOARD_APP_UPDATE_ENDPOINT = EndpointType.createJson<App, AppUpdateResponse>(DASHBOARD_EXTENSION_TYPE, {
-    name: 'update_app',
-    requestSerializer: Serializer.model(App),
-    permissionId: DASHBOARD_APP_UPDATE_PERMISSION_ID,
-});
-const DASHBOARD_APP_UPDATE_PACKET = PacketType.createSerialized<AppUpdateRequest>(DASHBOARD_EXTENSION_TYPE, {
-    name: 'update_app',
-    serializer: AppUpdateRequest,
-});
-const DASHBOARD_APP_UPDATE_ACCEPT_PACKET = PacketType.createJson<string>(DASHBOARD_EXTENSION_TYPE, {
-    name: 'update_app_accept',
-});
-const DASHBOARD_APP_UPDATE_DENY_PACKET = PacketType.createJson<string>(DASHBOARD_EXTENSION_TYPE, {
-    name: 'update_app_deny',
-});
-
-export class DashboardExtension {
-    public readonly type = DASHBOARD_EXTENSION_TYPE;
-    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,
-            DASHBOARD_APP_INSTALL_PACKET,
-            DASHBOARD_APP_INSTALL_ACCEPT_PACKET,
-            DASHBOARD_APP_INSTALL_DENY_PACKET,
-            DASHBOARD_APP_UPDATE_PACKET,
-            DASHBOARD_APP_UPDATE_ACCEPT_PACKET,
-            DASHBOARD_APP_UPDATE_DENY_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_APP_INSTALL_PACKET, async (request) => {
-            this.handleInstallApp(request);
-        });
-        client.network.addPacketHandler(DASHBOARD_APP_UPDATE_PACKET, async (request) => {
-            this.handleUpdateApp(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 handleInstallApp(request: AppInstallRequest): Promise<void> {
-        await this.handleDashboard(async (dashboard) => {
-            const response = await dashboard.handleInstallApp(request);
-            if (response) {
-                this.client.send(DASHBOARD_APP_INSTALL_ACCEPT_PACKET, request.requestId);
-            } else {
-                this.client.send(DASHBOARD_APP_INSTALL_DENY_PACKET, request.requestId);
-            }
-        });
-    }
-
-    private async handleUpdateApp(request: AppUpdateRequest): Promise<void> {
-        await this.handleDashboard(async (dashboard) => {
-            const response = await dashboard.handleUpdateApp(request);
-            if (response) {
-                this.client.send(DASHBOARD_APP_UPDATE_ACCEPT_PACKET, request.requestId);
-            } else {
-                this.client.send(DASHBOARD_APP_UPDATE_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.onReady(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);
-    }
-
-    public async installApp(app: App): Promise<AppInstallResponse> {
-        return await this.client.endpoints.call(DASHBOARD_APP_INSTALL_ENDPOINT, app);
-    }
-
-    public async updateApp(app: App): Promise<AppUpdateResponse> {
-        return await this.client.endpoints.call(DASHBOARD_APP_UPDATE_ENDPOINT, app);
-    }
-}

package/src/extension/dashboard/dashboard.ts

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

package/src/extension/dashboard/index.ts

@@ -1,9 +0,0 @@
-export {
-    DASHBOARD_APP_INSTALL_PERMISSION_ID, 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

@@ -1,98 +0,0 @@
-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);
-    }
-}
-
-export class AppInstallRequest {
-    constructor(public readonly requestId: string, public readonly app: App) { }
-
-    public static serialize(packet: AppInstallRequest): Uint8Array {
-        const writer = new ByteWriter();
-        writer.writeString(packet.requestId);
-        writer.writeString(JSON.stringify(packet.app.toJson()));
-        return writer.finish();
-    }
-
-    public static deserialize(data: Uint8Array): AppInstallRequest {
-        const reader = new ByteReader(data);
-        const requestId = reader.readString();
-        const app = App.fromJson(JSON.parse(reader.readString()));
-        return new AppInstallRequest(requestId, app);
-    }
-}
-
-export class AppUpdateRequest {
-    constructor(public readonly requestId: string, public readonly oldApp: App, public readonly newApp: App) { }
-    
-    public static serialize(packet: AppUpdateRequest): Uint8Array {
-        const writer = new ByteWriter();
-        writer.writeString(packet.requestId);
-        writer.writeString(JSON.stringify(packet.oldApp.toJson()));
-        writer.writeString(JSON.stringify(packet.newApp.toJson()));
-        return writer.finish();
-    }
-
-    public static deserialize(data: Uint8Array): AppUpdateRequest {
-        const reader = new ByteReader(data);
-        const requestId = reader.readString();
-        const oldApp = App.fromJson(JSON.parse(reader.readString()));
-        const newApp = App.fromJson(JSON.parse(reader.readString()));
-        return new AppUpdateRequest(requestId, oldApp, newApp);
-    }
-}
-
-export type AppInstallResponse = {
-    accepted: boolean;
-}
-
-export type AppUpdateResponse = {
-    accepted: boolean;
-}

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

@@ -1,125 +0,0 @@
-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 {
-    public readonly type = ENDPOINT_EXTENSION_TYPE;
-    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

@@ -1,58 +0,0 @@
-import type { Identifier } from '../../identifier.js';
-import { type Serializable, Serializer } 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

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

package/src/extension/endpoint/packets.ts

@@ -1,78 +0,0 @@
-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

@@ -1,39 +0,0 @@
-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);
-    }
-}

package/src/extension/i18n/index.ts

@@ -1,2 +0,0 @@
-export { I18N_EXTENSION_TYPE, I18N_GET_LOCALES_PERMISSION_ID, I18N_SET_LOCALES_PERMISSION_ID, I18nExtension } from './i18n-extension.js';
-

package/src/extension/logger/index.ts

@@ -1,5 +0,0 @@
-export {
-    LOGGER_EXTENSION_TYPE,
-    LOGGER_LOG_PERMISSION_ID,
-    LoggerExtension,
-} from './logger-extension.js';

package/src/extension/permission/index.ts

@@ -1,3 +0,0 @@
-export { PERMISSION_EXTENSION_TYPE, PermissionExtension } from './permission-extension.js';
-export { PermissionType } from './permission.js';
-

package/src/extension/plugin/index.ts

@@ -1,4 +0,0 @@
-export {
-    PLUGIN_EXTENSION_TYPE, PLUGIN_MANAGE_PACKAGE_PERMISSION_ID, PLUGIN_READ_PACKAGE_PERMISSION_ID, PluginExtension
-} from './plugin-extension.js';
-