@omujs/omu 0.6.20 → 0.6.22

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

@@ -9,7 +9,7 @@ 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';
+import { AppInstallRequest, AppInstallResponse, AppUpdateRequest, AppUpdateResponse, PermissionRequestPacket, PluginRequestPacket } from './packets.js';
 
 export const DASHBOARD_EXTENSION_TYPE = new ExtensionType(
     'dashboard',
@@ -75,8 +75,41 @@ const DASHBOARD_APP_TABLE_TYPE = TableType.createModel(DASHBOARD_EXTENSION_TYPE,
         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>;
 
@@ -89,6 +122,12 @@ export class DashboardExtension {
             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),
@@ -96,9 +135,16 @@ export class DashboardExtension {
         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);
     }
 
@@ -124,6 +170,28 @@ export class DashboardExtension {
         });
     }
 
+    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);
@@ -159,4 +227,12 @@ export class DashboardExtension {
     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,9 +1,11 @@
 import type { App } from '../../app.js';
 
-import type { PermissionRequestPacket, PluginRequestPacket } from './packets.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,3 +1,9 @@
-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 {
+    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

@@ -50,3 +50,49 @@ export class PluginRequestPacket {
         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

@@ -23,6 +23,7 @@ type EndpointHandler = {
 };
 
 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;

package/src/extension/endpoint/endpoint.ts

@@ -1,5 +1,5 @@
 import type { Identifier } from '../../identifier.js';
-import { Serializer, type Serializable } from '../../serializer.js';
+import { type Serializable, Serializer } from '../../serializer.js';
 
 export class EndpointType<Req = unknown, Res = unknown> {
     constructor(

package/src/extension/extension.ts

@@ -1,7 +1,9 @@
 import { type Client } from '../client.js';
 import { Identifier } from '../identifier.js';
 
-export interface Extension {}
+export interface Extension {
+    readonly type: ExtensionType;
+}
 
 export class ExtensionType<T extends Extension = Extension> extends Identifier {
     constructor(

package/src/extension/i18n/i18n-extension.ts

@@ -16,35 +16,43 @@ const I18N_LOCALES_REGISTRY_TYPE = RegistryType.createJson<Locale[]>(I18N_EXTENS
 });
 
 export class I18nExtension implements Extension {
+    public readonly type = I18N_EXTENSION_TYPE;
     public readonly localesRegistry: Registry<Locale[]>;
-    public locales?: Locale[];
+    private locales?: Locale[];
+    public defaultLocales?: Locale[];
 
     constructor(private readonly client: Client) {
         client.permissions.require(I18N_GET_LOCALES_PERMISSION_ID);
-        this.localesRegistry = client.registry.get(I18N_LOCALES_REGISTRY_TYPE);
+        this.localesRegistry = client.registries.get(I18N_LOCALES_REGISTRY_TYPE);
         this.localesRegistry.listen((locale) => {
             this.locales = locale;
         });
     }
 
-    public translate(localizedText: LocalizedText): string {
-        if (!this.locales) {
-            throw new Error('Locale not set');
+    public getLocales(): readonly Locale[] {
+        if (this.locales && this.locales.length > 0) {
+            return this.locales;
+        }
+        if (!this.defaultLocales || this.defaultLocales.length === 0) {
+            throw new Error('Default locales are not set');
         }
+        return this.defaultLocales;
+    }
+
+    public translate(localizedText: LocalizedText): string {
+        const locales = this.getLocales();
         if (typeof localizedText === 'string') {
             return localizedText;
         }
-        const translation = this.selectBestTranslation(this.locales, localizedText);
+        const translation = this.selectBestTranslation(locales, localizedText);
         if (!translation) {
-            throw new Error(
-                `Missing translation for ${this.locales} in ${JSON.stringify(localizedText)}`,
-            );
+            return Object.values(localizedText)[0];
         }
         return translation;
     }
 
     public selectBestTranslation(
-        locales: Locale[],
+        locales: readonly Locale[],
         localizedText: LocalizedText,
     ): string | undefined {
         if (typeof localizedText === 'string') {

package/src/extension/logger/logger-extension.ts

@@ -26,6 +26,7 @@ export const LOGGER_LISTEN_PACKET = PacketType.createJson<Identifier>(LOGGER_EXT
 
 type LogListener = (message: LogMessage) => void;
 export class LoggerExtension {
+    public readonly type = LOGGER_EXTENSION_TYPE;
     private readonly listeners: IdentifierMap<LogListener[]> = new IdentifierMap();
 
     constructor(private readonly client: Client) {

package/src/extension/permission/permission-extension.ts

@@ -35,6 +35,7 @@ const PERMISSION_GRANT_PACKET = PacketType.createJson<PermissionType[]>(PERMISSI
 });
 
 export class PermissionExtension {
+    public readonly type = PERMISSION_EXTENSION_TYPE;
     private permissions = new IdentifierMap<PermissionType>();
     private readonly registeredPermissions = new IdentifierMap<PermissionType>();
     private readonly requiredPermissions = new IdentifierSet();

package/src/extension/permission/permission.ts

@@ -2,7 +2,7 @@ import { Identifier } from '../../identifier.js';
 import type { LocalizedText } from '../../localization/localization.js';
 import type { Model } from '../../model.js';
 
-type PermissionLevel = 'low' | 'medium' | 'high';
+export type PermissionLevel = 'low' | 'medium' | 'high';
 
 export type PermissionMetadata = {
     name: LocalizedText;

package/src/extension/plugin/plugin-extension.ts

@@ -8,6 +8,7 @@ export const PLUGIN_EXTENSION_TYPE = new ExtensionType(
 );
 
 export class PluginExtension {
+    public readonly type = PLUGIN_EXTENSION_TYPE;
     private readonly requiredPlugins: Map<string, string | null> = new Map();
 
     constructor(private readonly client: Client) {

package/src/extension/registry/registry-extension.ts

@@ -5,12 +5,13 @@ import { Identifier, IdentifierMap } from '../../identifier.js';
 import { PacketType } from '../../network/packet/index.js';
 import { Serializer } from '../../serializer.js';
 import { EndpointType } from '../endpoint/endpoint.js';
-import { ExtensionType, type Extension } from '../extension.js';
+import { type Extension, ExtensionType } from '../extension.js';
 
 import { RegistryPacket, RegistryRegisterPacket } from './packets.js';
-import { RegistryType, type Registry } from './registry.js';
+import { type Registry, RegistryType } from './registry.js';
 
 export class RegistryExtension implements Extension {
+    public readonly type = REGISTRY_EXTENSION_TYPE;
     private readonly registries = new IdentifierMap<Registry<unknown>>();
 
     constructor(private readonly client: Client) {

package/src/extension/registry/registry.ts

@@ -13,7 +13,7 @@ export class RegistryPermissions {
     ) { }
 
     public serialize(writer: ByteWriter): void {
-        const flags = new Flags(0, 3);
+        const flags = new Flags({length: 3});
         flags.set(0, this.all !== undefined);
         flags.set(1, this.read !== undefined);
         flags.set(2, this.write !== undefined);

package/src/extension/server/server-extension.ts

@@ -1,11 +1,12 @@
 import { App } from '../../app.js';
 import type { Client } from '../../client.js';
-import { Identifier, IdentifierSet } from '../../identifier.js';
+import { Identifier, IdentifierMap, IdentifierSet } from '../../identifier.js';
 import { PacketType } from '../../network/packet/packet.js';
 import { Serializer } from '../../serializer.js';
 import { EndpointType } from '../endpoint/endpoint.js';
 import type { Extension } from '../extension.js';
 import { ExtensionType } from '../extension.js';
+import { Registry, RegistryPermissions, RegistryType } from '../registry/registry.js';
 import type { Table } from '../table/index.js';
 import { TABLE_EXTENSION_TYPE } from '../table/table-extension.js';
 import { TableType } from '../table/table.js';
@@ -42,27 +43,110 @@ const REQUIRE_APPS_PACKET_TYPE = PacketType.createJson<Identifier[]>(SERVER_EXTE
     name: 'require_apps',
     serializer: Serializer.model(Identifier).toArray(),
 });
+export const TRUSTED_ORIGINS_GET_PERMISSION_ID = SERVER_EXTENSION_TYPE.join('trusted_origins', 'get');
+export const TRUSTED_ORIGINS_SET_PERMISSION_ID = SERVER_EXTENSION_TYPE.join('trusted_origins', 'set');
+const TRUSTED_ORIGINS_REGISTRY_TYPE = RegistryType.createJson<string[]>(SERVER_EXTENSION_TYPE, {
+    name: 'trusted_origins',
+    defaultValue: [],
+    permissions: new RegistryPermissions(
+        TRUSTED_ORIGINS_GET_PERMISSION_ID,
+        TRUSTED_ORIGINS_SET_PERMISSION_ID,
+    ),
+});
+const SESSION_OBSERVE_PACKET_TYPE = PacketType.createJson<Identifier[]>(SERVER_EXTENSION_TYPE, {
+    name: 'session_observe',
+    serializer: Serializer.model(Identifier).toArray(),
+});
+const SESSION_CONNECT_PACKET_TYPE = PacketType.createJson<App>(SERVER_EXTENSION_TYPE, {
+    name: 'session_connect',
+    serializer: Serializer.model(App),
+});
+const SESSION_DISCONNECT_PACKET_TYPE = PacketType.createJson<App>(SERVER_EXTENSION_TYPE, {
+    name: 'session_disconnect',
+    serializer: Serializer.model(App),
+});
 
 export class ServerExtension implements Extension {
+    public readonly type = SERVER_EXTENSION_TYPE;
     public readonly apps: Table<App>;
     public readonly sessions: Table<App>;
-    private requiredApps = new IdentifierSet();
+    public readonly trustedOrigins: Registry<string[]>;
+    private readonly sessionObservers = new IdentifierMap<SessionObserver>();
+    private readonly requiredApps = new IdentifierSet();
 
     constructor(private readonly client: Client) {
-        client.network.registerPacket(REQUIRE_APPS_PACKET_TYPE);
+        client.network.registerPacket(
+            REQUIRE_APPS_PACKET_TYPE,
+            SESSION_OBSERVE_PACKET_TYPE,
+            SESSION_CONNECT_PACKET_TYPE,
+            SESSION_DISCONNECT_PACKET_TYPE,
+        );
+        client.network.addPacketHandler(
+            SESSION_CONNECT_PACKET_TYPE, (app) => this.handleSessionConnect(app)
+        )
+        client.network.addPacketHandler(
+            SESSION_DISCONNECT_PACKET_TYPE, (app) => this.handleSessionDisconnect(app)
+        )
         this.apps = client.tables.get(APP_TABLE_TYPE);
         this.sessions = client.tables.get(SESSION_TABLE_TYPE);
+        this.trustedOrigins = client.registries.get(TRUSTED_ORIGINS_REGISTRY_TYPE);
         client.network.addTask(() => this.onTask());
+        client.onReady(() => this.onReady());
     }
 
     private async onTask(): Promise<void> {
-        this.client.send(REQUIRE_APPS_PACKET_TYPE, Array.from(this.requiredApps.values()));
+        if (this.requiredApps.size > 0) {
+            this.client.send(REQUIRE_APPS_PACKET_TYPE, Array.from(this.requiredApps.values()));
+        }
+    }
+
+    private async onReady(): Promise<void> {
+        if (this.sessionObservers.size > 0) {
+            this.client.send(SESSION_OBSERVE_PACKET_TYPE, Array.from(this.sessionObservers.keys()));
+        }
     }
 
     public async shutdown(restart?: boolean): Promise<boolean> {
         return await this.client.endpoints.call(SHUTDOWN_ENDPOINT_TYPE, restart ?? false);
     }
 
+    public observeSession(appId: Identifier, {
+        onConnect,
+        onDisconnect
+    }: {
+        onConnect(app: App): void;
+        onDisconnect(app: App): void;
+    }): SessionObserver {
+        if (this.client.running) {
+            throw new Error('Cannot observe sessions after the client has started');
+        }
+        const observer = this.sessionObservers.get(appId) ?? new SessionObserver([], []);
+        observer.onConnect(onConnect);
+        observer.onDisconnect(onDisconnect);
+        this.sessionObservers.set(appId, 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: Identifier[]): void {
         if (this.client.running) {
             throw new Error('Cannot require apps after the client has started');
@@ -72,3 +156,18 @@ export class ServerExtension implements Extension {
         }
     }
 }
+
+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);
+    }
+}

package/src/extension/signal/signal-extension.ts

@@ -3,7 +3,7 @@ import type { Unlisten } from '../../event-emitter.js';
 import { Identifier, IdentifierMap } from '../../identifier.js';
 import { PacketType } from '../../network/packet/index.js';
 import { Serializer } from '../../serializer.js';
-import { ExtensionType, type Extension } from '../extension.js';
+import { type Extension, ExtensionType } from '../extension.js';
 
 import { SignalPacket, SignalRegisterPacket } from './packets.js';
 import type { Signal } from './signal.js';
@@ -31,6 +31,7 @@ const SIGNAL_NOTIFY_PACKET = PacketType.createSerialized<SignalPacket>(SIGNAL_EX
 });
 
 export class SignalExtension implements Extension {
+    public readonly type = SIGNAL_EXTENSION_TYPE;
     private readonly signals = new IdentifierMap<SignalType<unknown>>();
 
     constructor(private readonly client: Client) {

package/src/extension/signal/signal.ts

@@ -13,7 +13,7 @@ export class SignalPermissions {
     ) {}
 
     public serialize(writer: ByteWriter): void {
-        const flags = new Flags(0, 3);
+        const flags = new Flags({length: 3});
         flags.set(0, this.all !== undefined);
         flags.set(1, this.listen !== undefined);
         flags.set(2, this.send !== undefined);

package/src/extension/table/packets.ts

@@ -1,4 +1,4 @@
-import { ByteReader, ByteWriter } from '../../bytebuffer.js';
+import { ByteReader, ByteWriter, Flags } from '../../bytebuffer.js';
 import { Identifier } from '../../identifier.js';
 
 import type { TableConfig } from './table.js';
@@ -114,31 +114,19 @@ export class TableProxyPacket {
 export class TableFetchPacket {
     constructor(
         public readonly id: Identifier,
-        public readonly before: number | null,
-        public readonly after: number | null,
-        public readonly cursor: string | null,
+        public readonly limit: number,
+        public readonly backward: boolean = false,
+        public readonly cursor: string | null = null,
     ) {}
 
     public static serialize(packet: TableFetchPacket): Uint8Array {
         const writer = new ByteWriter();
         writer.writeString(packet.id.key());
-        let flags = 0;
-        if (packet.before !== null) {
-            flags |= 0b1;
-        }
-        if (packet.after !== null) {
-            flags |= 0b10;
-        }
-        if (packet.cursor !== null) {
-            flags |= 0b100;
-        }
-        writer.writeByte(flags);
-        if (packet.before !== null) {
-            writer.writeInt(packet.before);
-        }
-        if (packet.after !== null) {
-            writer.writeInt(packet.after);
-        }
+        writer.writeInt(packet.limit);
+        const flags = new Flags({length: 2});
+        flags.set(0, packet.backward);
+        flags.set(1, packet.cursor !== null);
+        writer.writeFlags(flags);
         if (packet.cursor !== null) {
             writer.writeString(packet.cursor);
         }
@@ -148,11 +136,11 @@ export class TableFetchPacket {
     public static deserialize(data: Uint8Array): TableFetchPacket {
         const reader = new ByteReader(data);
         const id = Identifier.fromKey(reader.readString());
-        const flags = reader.readByte();
-        const before = flags & 0b1 ? reader.readInt() : null;
-        const after = flags & 0b10 ? reader.readInt() : null;
-        const cursor = flags & 0b100 ? reader.readString() : null;
-        return new TableFetchPacket(id, before, after, cursor);
+        const limit = reader.readInt();
+        const flags = reader.readFlags(2);
+        const backward = flags.get(0);
+        const cursor = flags.ifSet(1, () => reader.readString());
+        return new TableFetchPacket(id, limit, backward, cursor);
     }
 }
 
@@ -231,11 +219,21 @@ export class SetPermissionPacket {
             flags |= 0b10000;
         }
         writer.writeByte(flags);
-        packet.all && writer.writeString(packet.all.key());
-        packet.read && writer.writeString(packet.read.key());
-        packet.write && writer.writeString(packet.write.key());
-        packet.remove && writer.writeString(packet.remove.key());
-        packet.proxy && writer.writeString(packet.proxy.key());
+        if (packet.all) {
+            writer.writeString(packet.all.key());
+        }
+        if (packet.read) {
+            writer.writeString(packet.read.key());
+        }
+        if (packet.write) {
+            writer.writeString(packet.write.key());
+        }
+        if (packet.remove) {
+            writer.writeString(packet.remove.key());
+        }
+        if (packet.proxy) {
+            writer.writeString(packet.proxy.key());
+        }
         return writer.finish();
     }