@omujs/omu 0.9.10 → 0.9.26

package/src/{extension → api}/table/packets.ts

@@ -1,5 +1,5 @@
-import { ByteReader, ByteWriter, Flags } from '../../bytebuffer.js';
-import { Identifier } from '../../identifier.js';
+import { Identifier } from '../../identifier';
+import { ByteReader, ByteWriter, Flags } from '../../serialize';
 
 import type { TableConfig } from './table.js';
 
@@ -13,7 +13,7 @@ export class TablePacket {
     }
 
     public static deserialize(data: Uint8Array): TablePacket {
-        const reader = new ByteReader(data);
+        const reader = ByteReader.fromUint8Array(data);
         const id = Identifier.fromKey(reader.readString());
         return new TablePacket(id);
     }
@@ -28,22 +28,22 @@ export class TableItemsPacket {
     public static serialize(packet: TableItemsPacket): Uint8Array {
         const writer = new ByteWriter();
         writer.writeString(packet.id.key());
-        writer.writeInt(Object.keys(packet.items).length);
+        writer.writeULEB128(Object.keys(packet.items).length);
         for (const [key, value] of Object.entries(packet.items)) {
             writer.writeString(key);
-            writer.writeByteArray(value);
+            writer.writeUint8Array(value);
         }
         return writer.finish();
     }
 
     public static deserialize(data: Uint8Array): TableItemsPacket {
-        const reader = new ByteReader(data);
+        const reader = ByteReader.fromUint8Array(data);
         const id = Identifier.fromKey(reader.readString());
-        const count = reader.readInt();
+        const count = reader.readULEB128();
         const items: Record<string, Uint8Array> = {};
         for (let i = 0; i < count; i++) {
             const key = reader.readString();
-            const value = reader.readByteArray();
+            const value = reader.readUint8Array();
             items[key] = value;
         }
         return new TableItemsPacket(id, items);
@@ -59,7 +59,7 @@ export class TableKeysPacket {
     public static serialize(packet: TableKeysPacket): Uint8Array {
         const writer = new ByteWriter();
         writer.writeString(packet.id.key());
-        writer.writeInt(packet.keys.length);
+        writer.writeULEB128(packet.keys.length);
         for (const key of packet.keys) {
             writer.writeString(key);
         }
@@ -67,9 +67,9 @@ export class TableKeysPacket {
     }
 
     public static deserialize(data: Uint8Array): TableKeysPacket {
-        const reader = new ByteReader(data);
+        const reader = ByteReader.fromUint8Array(data);
         const id = Identifier.fromKey(reader.readString());
-        const count = reader.readInt();
+        const count = reader.readULEB128();
         const keys: string[] = [];
         for (let i = 0; i < count; i++) {
             keys.push(reader.readString());
@@ -88,24 +88,24 @@ export class TableProxyPacket {
     public static serialize(packet: TableProxyPacket): Uint8Array {
         const writer = new ByteWriter();
         writer.writeString(packet.id.key());
-        writer.writeInt(packet.key);
-        writer.writeInt(Object.keys(packet.items).length);
+        writer.writeULEB128(packet.key);
+        writer.writeULEB128(Object.keys(packet.items).length);
         for (const [key, value] of Object.entries(packet.items)) {
             writer.writeString(key);
-            writer.writeByteArray(value);
+            writer.writeUint8Array(value);
         }
         return writer.finish();
     }
 
     public static deserialize(data: Uint8Array): TableProxyPacket {
-        const reader = new ByteReader(data);
+        const reader = ByteReader.fromUint8Array(data);
         const id = Identifier.fromKey(reader.readString());
-        const key = reader.readInt();
-        const count = reader.readInt();
+        const key = reader.readULEB128();
+        const count = reader.readULEB128();
         const items: Record<string, Uint8Array> = {};
         for (let i = 0; i < count; i++) {
             const key = reader.readString();
-            const value = reader.readByteArray();
+            const value = reader.readUint8Array();
             items[key] = value;
         }
         return new TableProxyPacket(id, items, key);
@@ -122,8 +122,8 @@ export class TableFetchPacket {
     public static serialize(packet: TableFetchPacket): Uint8Array {
         const writer = new ByteWriter();
         writer.writeString(packet.id.key());
-        writer.writeInt(packet.limit);
-        const flags = new Flags({length: 2});
+        writer.writeULEB128(packet.limit);
+        const flags = new Flags({ length: 2 });
         flags.set(0, packet.backward);
         flags.set(1, packet.cursor !== null);
         writer.writeFlags(flags);
@@ -134,9 +134,9 @@ export class TableFetchPacket {
     }
 
     public static deserialize(data: Uint8Array): TableFetchPacket {
-        const reader = new ByteReader(data);
+        const reader = ByteReader.fromUint8Array(data);
         const id = Identifier.fromKey(reader.readString());
-        const limit = reader.readInt();
+        const limit = reader.readULEB128();
         const flags = reader.readFlags(2);
         const backward = flags.get(0);
         const cursor = flags.ifSet(1, () => reader.readString());
@@ -160,7 +160,7 @@ export class TableFetchRangePacket {
     }
 
     public static deserialize(data: Uint8Array): TableFetchRangePacket {
-        const reader = new ByteReader(data);
+        const reader = ByteReader.fromUint8Array(data);
         const id = Identifier.fromKey(reader.readString());
         const start = reader.readString();
         const end = reader.readString();
@@ -182,7 +182,7 @@ export class SetConfigPacket {
     }
 
     public static deserialize(data: Uint8Array): SetConfigPacket {
-        const reader = new ByteReader(data);
+        const reader = ByteReader.fromUint8Array(data);
         const id = Identifier.fromKey(reader.readString());
         const config = JSON.parse(reader.readString());
         return new SetConfigPacket(id, config);
@@ -218,7 +218,7 @@ export class SetPermissionPacket {
         if (packet.proxy !== null) {
             flags |= 0b10000;
         }
-        writer.writeByte(flags);
+        writer.writeUint8(flags);
         if (packet.all) {
             writer.writeString(packet.all.key());
         }
@@ -238,9 +238,9 @@ export class SetPermissionPacket {
     }
 
     public static deserialize(data: Uint8Array): SetPermissionPacket {
-        const reader = new ByteReader(data);
+        const reader = ByteReader.fromUint8Array(data);
         const id = Identifier.fromKey(reader.readString());
-        const flags = reader.readByte();
+        const flags = reader.readUint8();
         const all = flags & 0b1 ? Identifier.fromKey(reader.readString()) : null;
         const read = flags & 0b10 ? Identifier.fromKey(reader.readString()) : null;
         const write = flags & 0b100 ? Identifier.fromKey(reader.readString()) : null;
@@ -249,3 +249,4 @@ export class SetPermissionPacket {
         return new SetPermissionPacket(id, all, read, write, remove, proxy);
     }
 }
+

package/src/{extension → api}/table/table.ts

@@ -1,10 +1,7 @@
-import type { EventEmitter, Unlisten } from '../../event-emitter.js';
-import type { Identifier } from '../../identifier.js';
-import type { Keyable } from '../../interface.js';
-import type { Model } from '../../model.js';
-import type { Serializable } from '../../serializer.js';
-import { Serializer } from '../../serializer.js';
-import type { ExtensionType } from '../extension.js';
+import type { EventEmitter, Unlisten } from '../../event';
+import { Identifier, IntoId } from '../../identifier';
+import type { JsonType, Serializable } from '../../serialize';
+import { Serializer } from '../../serialize';
 
 export type TableConfig = {
     cache_size: number;
@@ -67,41 +64,50 @@ export class TableType<T> {
         public id: Identifier,
         public serializer: Serializable<T, Uint8Array>,
         public keyFunction: (item: T) => string,
-        public permissions?: TablePermissions,
+        public permissions?: TablePermissions | undefined,
     ) {}
 
-    public static createModel<T extends Keyable & Model<D>, D = unknown>(
-        identifier: Identifier | ExtensionType,
+    public static createJson<T, D extends JsonType = JsonType>(
+        identifier: IntoId,
         {
             name,
-            model,
+            key,
             permissions,
+            serializer,
         }: {
             name: string;
-            model: { fromJson(data: D): T };
+            key: (item: T) => string;
             permissions?: TablePermissions;
+            serializer?: Serializable<T, D>;
         },
     ): TableType<T> {
         return new TableType<T>(
-            identifier.join(name),
-            Serializer.model(model).pipe(Serializer.json()),
-            (item) => item.key(),
+            Identifier.from(identifier).join(name),
+            Serializer.pipe<T, D, Uint8Array>(serializer ?? Serializer.noop(), Serializer.json()),
+            key,
             permissions,
         );
     }
 
-    public static createJson<T>(
-        identifier: Identifier | ExtensionType,
+    public static createSerialized<T>(
+        identifier: IntoId,
         {
             name,
             key,
             permissions,
+            serializer,
         }: {
             name: string;
             key: (item: T) => string;
             permissions?: TablePermissions;
+            serializer: Serializable<T, Uint8Array>;
         },
     ): TableType<T> {
-        return new TableType<T>(identifier.join(name), Serializer.json<T>(), key, permissions);
+        return new TableType<T>(
+            Identifier.from(identifier).join(name),
+            serializer,
+            key,
+            permissions,
+        );
     }
 }

package/src/app.ts

@@ -1,8 +1,6 @@
-import { Identifier } from './identifier.js';
-import type { Keyable } from './interface.js';
+import { Identifier, IntoId } from './identifier';
 import type { Locale } from './localization/locale.js';
 import type { LocalizedText } from './localization/localization.js';
-import type { Model } from './model.js';
 
 export type AppMetadata = {
     locale: Locale;
@@ -15,63 +13,83 @@ export type AppMetadata = {
     authors?: LocalizedText;
     license?: LocalizedText;
     tags?: string[];
-}
+};
+
+export type AppType = 'app' | 'service' | 'remote' | 'plugin' | 'dashboard';
 
-export type AppType = 'app' | 'plugin' | 'dashboard';
+export type DependencySpecifier = {
+    version: string;
+    index?: string;
+};
 
 export type AppJson = {
     id: string;
+    type: AppType;
+    parent_id?: string;
     version?: string;
     url?: string;
-    type?: AppType;
     metadata?: AppMetadata;
-}
+    dependencies?: Record<string, DependencySpecifier | string>;
+};
 
-export class App implements Keyable, Model<AppJson> {
+export class App {
     public readonly id: Identifier;
+    public readonly type: AppType;
+    public readonly parentId?: Identifier;
     public readonly version?: string;
     public readonly url?: string;
     public readonly metadata?: AppMetadata;
-    public readonly type?: AppType;
+    public readonly dependencies: Record<string, DependencySpecifier | string>;
 
-    constructor(id: Identifier | string, options: {
+    constructor(id: IntoId, options: {
+        type?: AppType;
+        parentId?: IntoId;
         version?: string;
         url?: string;
         metadata?: AppMetadata;
-        type?: AppType;
+        dependencies?: Record<string, DependencySpecifier | string>;
     }) {
-        if (typeof id === 'string') {
-            this.id = Identifier.fromKey(id);
-        } else {
-            this.id = id;
-        }
+        this.id = Identifier.from(id);
+        this.parentId = Identifier.fromOptional(options.parentId);
         this.version = options.version;
         this.url = options.url;
         this.metadata = options.metadata;
-        this.type = options.type;
-    }
-
-    public key(): string {
-        return this.id.key();
+        this.type = options.type ?? 'app';
+        this.dependencies = options.dependencies ?? {};
     }
 
-    public static fromJson(info: AppJson): App {
+    public static deserialize(info: AppJson): App {
         const id = Identifier.fromKey(info.id);
         return new App(id, {
+            parentId: Identifier.fromOptional(info.parent_id),
             version: info.version,
             url: info.url,
             type: info.type,
             metadata: info.metadata,
+            dependencies: info.dependencies ?? {},
         });
     }
 
-    public toJson(): AppJson {
+    public static serialize(data: App): AppJson {
         return {
-            id: this.id.key(),
+            id: data.id.key(),
+            type: data.type,
+            parent_id: data.parentId?.key(),
+            version: data.version,
+            url: data.url,
+            metadata: data.metadata,
+            dependencies: data.dependencies,
+        };
+    }
+
+    public join(...paths: string[]): App {
+        return new App(this.id.join(...paths), {
+            parentId: this.parentId,
             version: this.version,
             url: this.url,
             type: this.type,
             metadata: this.metadata,
-        };
+            dependencies: this.dependencies,
+        });
     }
 }

package/src/const.ts

@@ -1,2 +1,2 @@
-export const textEncoder = new TextEncoder();
-export const textDecoder = new TextDecoder();
+export const textEncoder: TextEncoder = new TextEncoder();
+export const textDecoder: TextDecoder = new TextDecoder();

package/src/errors.ts

@@ -15,6 +15,12 @@ export class DisconnectReason extends OmuError {
     }
 }
 
+export class ServerRestart extends DisconnectReason {
+    constructor(message: string) {
+        super(DisconnectType.SERVER_RESTART, message);
+    }
+}
+
 export class AnotherConnection extends DisconnectReason {
     constructor(message: string) {
         super(DisconnectType.ANOTHER_CONNECTION, message);
@@ -27,6 +33,12 @@ export class PermissionDenied extends DisconnectReason {
     }
 }
 
+export class AppRemoved extends DisconnectReason {
+    constructor(message: string) {
+        super(DisconnectType.APP_REMOVED, message);
+    }
+}
+
 export class InvalidToken extends DisconnectReason {
     constructor(message: string) {
         super(DisconnectType.INVALID_TOKEN, message);

package/src/helper.ts

@@ -0,0 +1,16 @@
+type Ok<T> = {
+    ok: true;
+    data: T;
+};
+type Err<E> = {
+    ok: false;
+    data: E;
+};
+
+export function tryCatch<T, E = Error>(func: () => T): Ok<T> | Err<E> {
+    try {
+        return { ok: true, data: func() };
+    } catch (e) {
+        return { ok: false, data: e as E };
+    }
+}

package/src/identifier.ts

@@ -1,10 +1,12 @@
-import type { Keyable } from './interface.js';
-import type { Model } from './model.js';
+import type { ExtensionType } from './api';
+import { App } from './app';
 
 const NAMESPACE_REGEX = /^(\.[^/:.]|[\w-])+$/;
 const NAME_REGEX = /^[^/:]+$/;
 
-export class Identifier implements Model<string>, Keyable {
+export type IntoId = Identifier | string | ExtensionType | App;
+
+export class Identifier {
     public readonly namespace: string;
     public readonly path: string[];
 
@@ -17,6 +19,47 @@ export class Identifier implements Model<string>, Keyable {
         this.path = path;
     }
 
+    public static serialize(identifier: Identifier): string {
+        return identifier.key();
+    }
+
+    public static deserialize(json: string): Identifier {
+        return Identifier.fromJson(json);
+    }
+
+    public static from(id: IntoId): Identifier {
+        if (id instanceof Identifier) {
+            return id;
+        } else if (id instanceof App) {
+            return id.id;
+        } else if (typeof id === 'string') {
+            return Identifier.fromKey(id);
+        } else {
+            // Try to infer
+            // Vite does not preserve class information when importing from different packages
+            const idCasted = id as { namespace: string; path: string[] };
+            if (
+                typeof idCasted.namespace === 'string' &&
+                Array.isArray(idCasted.path) &&
+                idCasted.path.every((p) => typeof p === 'string')
+            ) {
+                return new Identifier(idCasted.namespace, ...idCasted.path);
+            }
+            const idWithId = id as { id: IntoId | undefined };
+            if (typeof idWithId.id !== 'undefined') {
+                return Identifier.from(idWithId.id);
+            }
+            throw new Error(`Cannot convert to Identifier: ${id}`);
+        }
+    }
+
+    public static fromOptional(id: IntoId | undefined | null): Identifier | undefined {
+        if (id === undefined || id === null) {
+            return undefined;
+        }
+        return Identifier.from(id);
+    }
+
     static validate(namespace: string, path: string[]): void {
         if (!namespace) {
             throw new Error('Invalid namespace: Namespace cannot be empty');
@@ -29,7 +72,7 @@ export class Identifier implements Model<string>, Keyable {
         }
         for (const name of path) {
             if (!NAME_REGEX.test(name)) {
-                throw new Error(`Invalid path: Name must match ${NAME_REGEX}`);
+                throw new Error(`Invalid path: Name must match ${NAME_REGEX} but got ${name}`);
             }
         }
     }
@@ -83,6 +126,10 @@ export class Identifier implements Model<string>, Keyable {
         return this.key() === other.key();
     }
 
+    public isNamespaceEqual(other: Identifier): boolean {
+        return this.namespace === other.namespace;
+    }
+
     public isSubpathOf(other: Identifier): boolean {
         if (this.namespace !== other.namespace) {
             return false;
@@ -105,6 +152,14 @@ export class Identifier implements Model<string>, Keyable {
 
 export class IdentifierMap<T> {
     private readonly map: Map<string, T> = new Map();
+    constructor(
+        entries?: Iterable<[Identifier, T]>,
+    ) {
+        if (!entries) return;
+        for (const [id, value] of entries) {
+            this.map.set(id.key(), value);
+        }
+    }
 
     public get size(): number {
         return this.map.size;

package/src/index.ts

@@ -1,7 +1,88 @@
-export { App } from './app.js';
-export { Identifier } from './identifier.js';
-export * as interfaces from './interface.js';
+export { App, AppMetadata } from './app.js';
+export { DisconnectReason } from './errors.js';
+export { Identifier, IdentifierMap, IdentifierSet, IntoId } from './identifier';
+export * as network from './network';
 export { Omu } from './omu.js';
-export { Serializer } from './serializer.js';
-export type { Serializable } from './serializer.js';
+export { Serializer } from './serialize';
+export type { Serializable } from './serialize';
+export { BrowserTokenProvider, type SessionParam, type TokenProvider } from './token';
+import { ASSET_DELETE_PERMISSION_ID, ASSET_DOWNLOAD_PERMISSION_ID, ASSET_UPLOAD_PERMISSION_ID } from './api/asset';
+import {
+    DASHBOARD_APP_INSTALL_PERMISSION_ID,
+    DAShBOARD_DRAG_DROP_PERMISSION_ID,
+    DASHBOARD_OPEN_APP_PERMISSION_ID,
+    DASHBOARD_SET_PERMISSION_ID,
+    DASHBOARD_SPEECH_RECOGNITION_PERMISSION_ID,
+    DASHBOARD_WEBVIEW_PERMISSION_ID,
+    DASHOBARD_APP_EDIT_PERMISSION_ID,
+    DASHOBARD_APP_READ_PERMISSION_ID,
+} from './api/dashboard';
+import { HTTP_REQUEST_PERMISSION_ID } from './api/http';
+import { I18N_GET_LOCALES_PERMISSION_ID, I18N_SET_LOCALES_PERMISSION_ID } from './api/i18n';
+import { LOGGER_LOG_PERMISSION_ID } from './api/logger';
+import { PLUGIN_MANAGE_PACKAGE_PERMISSION_ID, PLUGIN_READ_PACKAGE_PERMISSION_ID } from './api/plugin';
+import { REGISTRY_PERMISSION_ID } from './api/registry';
+import { SERVER_APPS_READ_PERMISSION_ID, SERVER_SHUTDOWN_PERMISSION_ID, TRUSTED_ORIGINS_GET_PERMISSION_ID, TRUSTED_ORIGINS_SET_PERMISSION_ID } from './api/server';
+import { GENERATE_TOKEN_PERMISSION_ID, REMOTE_APP_REQUEST_PERMISSION_ID, SESSIONS_READ_PERMISSION_ID } from './api/session';
+import { TABLE_PERMISSION_ID } from './api/table';
+import { Identifier } from './identifier';
 
+export const OmuPermissions: {
+    // Asset API
+    readonly ASSET_DELETE_PERMISSION_ID: Identifier; readonly ASSET_DOWNLOAD_PERMISSION_ID: Identifier; readonly ASSET_UPLOAD_PERMISSION_ID: Identifier;
+    // Dashboard API
+    readonly DASHBOARD_APP_INSTALL_PERMISSION_ID: Identifier; readonly DAShBOARD_DRAG_DROP_PERMISSION_ID: Identifier; readonly DASHBOARD_OPEN_APP_PERMISSION_ID: Identifier; readonly DASHBOARD_SET_PERMISSION_ID: Identifier; readonly DASHBOARD_SPEECH_RECOGNITION_PERMISSION_ID: Identifier; readonly DASHBOARD_WEBVIEW_PERMISSION_ID: Identifier; readonly DASHOBARD_APP_EDIT_PERMISSION_ID: Identifier; readonly DASHOBARD_APP_READ_PERMISSION_ID: Identifier;
+    // HTTP API
+    readonly HTTP_REQUEST_PERMISSION_ID: Identifier;
+    // I18n API
+    readonly I18N_GET_LOCALES_PERMISSION_ID: Identifier; readonly I18N_SET_LOCALES_PERMISSION_ID: Identifier;
+    // Logger API
+    readonly LOGGER_LOG_PERMISSION_ID: Identifier;
+    // Plugin API
+    readonly PLUGIN_MANAGE_PACKAGE_PERMISSION_ID: Identifier; readonly PLUGIN_READ_PACKAGE_PERMISSION_ID: Identifier;
+    // Registry API
+    readonly REGISTRY_PERMISSION_ID: Identifier;
+    // Server API
+    readonly SERVER_APPS_READ_PERMISSION_ID: Identifier; readonly SERVER_SHUTDOWN_PERMISSION_ID: Identifier; readonly TRUSTED_ORIGINS_GET_PERMISSION_ID: Identifier; readonly TRUSTED_ORIGINS_SET_PERMISSION_ID: Identifier;
+    // Session API
+    readonly GENERATE_TOKEN_PERMISSION_ID: Identifier; readonly REMOTE_APP_REQUEST_PERMISSION_ID: Identifier; readonly SESSIONS_READ_PERMISSION_ID: Identifier;
+    // Table API
+    readonly TABLE_PERMISSION_ID: Identifier;
+} = {
+    // Asset API
+    ASSET_DELETE_PERMISSION_ID,
+    ASSET_DOWNLOAD_PERMISSION_ID,
+    ASSET_UPLOAD_PERMISSION_ID,
+    // Dashboard API
+    DASHBOARD_APP_INSTALL_PERMISSION_ID,
+    DAShBOARD_DRAG_DROP_PERMISSION_ID,
+    DASHBOARD_OPEN_APP_PERMISSION_ID,
+    DASHBOARD_SET_PERMISSION_ID,
+    DASHBOARD_SPEECH_RECOGNITION_PERMISSION_ID,
+    DASHBOARD_WEBVIEW_PERMISSION_ID,
+    DASHOBARD_APP_EDIT_PERMISSION_ID,
+    DASHOBARD_APP_READ_PERMISSION_ID,
+    // HTTP API
+    HTTP_REQUEST_PERMISSION_ID,
+    // I18n API
+    I18N_GET_LOCALES_PERMISSION_ID,
+    I18N_SET_LOCALES_PERMISSION_ID,
+    // Logger API
+    LOGGER_LOG_PERMISSION_ID,
+    // Plugin API
+    PLUGIN_MANAGE_PACKAGE_PERMISSION_ID,
+    PLUGIN_READ_PACKAGE_PERMISSION_ID,
+    // Registry API
+    REGISTRY_PERMISSION_ID,
+    // Server API
+    SERVER_APPS_READ_PERMISSION_ID,
+    SERVER_SHUTDOWN_PERMISSION_ID,
+    TRUSTED_ORIGINS_GET_PERMISSION_ID,
+    TRUSTED_ORIGINS_SET_PERMISSION_ID,
+    // Session API
+    GENERATE_TOKEN_PERMISSION_ID,
+    REMOTE_APP_REQUEST_PERMISSION_ID,
+    SESSIONS_READ_PERMISSION_ID,
+    // Table API
+    TABLE_PERMISSION_ID,
+} as const;

package/src/localization/index.ts

@@ -1,3 +1,3 @@
-export { LOCALE_NAMES, Locale as Locale } from './locale.js';
-export { LocalizedText, Translations } from './localization.js';
+export { Locale as Locale, LOCALE_NAMES } from './locale.js';
+export type { LocalizedText, Translations } from './localization.js';
 

package/src/lock.ts

@@ -0,0 +1,43 @@
+
+type Task = () => Promise<void>;
+
+export class Lock {
+    private tasks: (Task)[] = [];
+    private waiter: Promise<void> | null = null;
+
+    private wait(): Promise<void> {
+        if (this.waiter) {
+            return this.waiter;
+        }
+        this.waiter = new Promise<void>((resolve) => {
+            const runTasks = async () => {
+                while (this.tasks.length > 0) {
+                    const task = this.tasks.shift();
+                    if (task) {
+                        await task();
+                    }
+                }
+                this.waiter = null;
+                resolve();
+            };
+            runTasks();
+        });
+        return this.waiter;
+    }
+
+    public async use<T>(callback: () => Promise<T>): Promise<T> {
+        const promise = new Promise<T>((resolve, reject) => {
+            const task = async () => {
+                const promise = callback();
+                try {
+                    resolve(await promise);
+                } catch (reason) {
+                    reject(reason);
+                }
+            };
+            this.tasks.push(task);
+        });
+        await this.wait();
+        return promise;
+    }
+}

package/src/network/connection.ts

@@ -1,8 +1,7 @@
-import { Identifier, IdentifierMap } from '../identifier.js';
-import type { Serializable } from '../serializer.js';
+import { Identifier, IdentifierMap } from '../identifier';
+import type { Serializable } from '../serialize';
 
-import type { PacketData, PacketType } from './packet/index.js';
-import type { Packet } from './packet/packet.js';
+import type { Packet, PacketData, PacketType } from './packet';
 
 export class PacketMapper implements Serializable<Packet, PacketData> {
     private readonly packetMap = new IdentifierMap<PacketType<unknown>>();
@@ -34,8 +33,11 @@ export class PacketMapper implements Serializable<Packet, PacketData> {
     }
 }
 
+export interface Transport {
+    connect(): Promise<Connection>;
+}
+
 export interface Connection {
-    connect(): Promise<void>;
     send(packet: Packet, serializer: Serializable<Packet, PacketData>): void;
     receive(serializer: Serializable<Packet, PacketData>): Promise<Packet | null>;
     close(): void;