@omujs/omu 0.9.10 → 0.9.27

package/src/api/http/index.ts

@@ -0,0 +1,2 @@
+export { HTTP_REQUEST_PERMISSION_ID, OmuWS, type WSMsg } from './extension';
+

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

@@ -1,29 +1,28 @@
-import type { Client } from '../../client.js';
+import { Identifier } from '../../identifier';
 import type { Locale } from '../../localization/locale.js';
 import type { LocalizedText } from '../../localization/localization.js';
+import { Omu } from '../../omu';
 import type { Extension } from '../extension.js';
 import { ExtensionType } from '../extension.js';
-import type { Registry } from '../registry/index.js';
-import { RegistryType } from '../registry/index.js';
+import { RegistryType, type Registry } from '../registry';
 
-export const I18N_EXTENSION_TYPE = new ExtensionType('i18n', (client) => new I18nExtension(client));
+export const I18N_EXTENSION_TYPE: ExtensionType<I18nExtension> = new ExtensionType('i18n', (client) => new I18nExtension(client));
 
-export const I18N_SET_LOCALES_PERMISSION_ID = I18N_EXTENSION_TYPE.join('locales', 'set');
-export const I18N_GET_LOCALES_PERMISSION_ID = I18N_EXTENSION_TYPE.join('locales', 'get');
+export const I18N_SET_LOCALES_PERMISSION_ID: Identifier = I18N_EXTENSION_TYPE.join('locales', 'set');
+export const I18N_GET_LOCALES_PERMISSION_ID: Identifier = I18N_EXTENSION_TYPE.join('locales', 'get');
 const I18N_LOCALES_REGISTRY_TYPE = RegistryType.createJson<Locale[]>(I18N_EXTENSION_TYPE, {
     name: 'locales',
     defaultValue: [],
 });
 
 export class I18nExtension implements Extension {
-    public readonly type = I18N_EXTENSION_TYPE;
+    public readonly type: ExtensionType<I18nExtension> = I18N_EXTENSION_TYPE;
     public readonly localesRegistry: Registry<Locale[]>;
     private locales?: Locale[];
     public defaultLocales?: Locale[];
 
-    constructor(private readonly client: Client) {
-        client.permissions.require(I18N_GET_LOCALES_PERMISSION_ID);
-        this.localesRegistry = client.registries.get(I18N_LOCALES_REGISTRY_TYPE);
+    constructor(private readonly omu: Omu) {
+        this.localesRegistry = omu.registries.get(I18N_LOCALES_REGISTRY_TYPE);
         this.localesRegistry.listen((locale) => {
             this.locales = locale;
         });

package/src/api/i18n/index.ts

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

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

@@ -1,37 +1,36 @@
-import type { Client } from '../../client.js';
-import type { Unlisten } from '../../event-emitter.js';
-import { Identifier, IdentifierMap } from '../../identifier.js';
+import type { Unlisten } from '../../event';
+import { Identifier, IdentifierMap } from '../../identifier';
 import { PacketType } from '../../network/packet/packet.js';
-import { Serializer } from '../../serializer.js';
+import { Omu } from '../../omu';
 import { ExtensionType } from '../extension.js';
 
 import type { LogMessage } from './packets.js';
 import { LogPacket, LogType } from './packets.js';
 
-export const LOGGER_EXTENSION_TYPE = new ExtensionType(
+export const LOGGER_EXTENSION_TYPE: ExtensionType<LoggerExtension> = new ExtensionType(
     'logger',
     (client) => new LoggerExtension(client),
 );
 
-export const LOGGER_LOG_PERMISSION_ID = LOGGER_EXTENSION_TYPE.join('log');
+export const LOGGER_LOG_PERMISSION_ID: Identifier = LOGGER_EXTENSION_TYPE.join('log');
 
-export const LOGGER_LOG_PACKET = PacketType.createSerialized<LogPacket>(LOGGER_EXTENSION_TYPE, {
+export const LOGGER_LOG_PACKET: PacketType<LogPacket> = PacketType.createSerialized<LogPacket>(LOGGER_EXTENSION_TYPE, {
     name: 'log',
     serializer: LogPacket,
 });
-export const LOGGER_LISTEN_PACKET = PacketType.createJson<Identifier>(LOGGER_EXTENSION_TYPE, {
+export const LOGGER_LISTEN_PACKET: PacketType<Identifier> = PacketType.createJson<Identifier>(LOGGER_EXTENSION_TYPE, {
     name: 'listen',
-    serializer: Serializer.model(Identifier),
+    serializer: Identifier,
 });
 
 type LogListener = (message: LogMessage) => void;
 export class LoggerExtension {
-    public readonly type = LOGGER_EXTENSION_TYPE;
+    public readonly type: ExtensionType<LoggerExtension> = LOGGER_EXTENSION_TYPE;
     private readonly listeners: IdentifierMap<LogListener[]> = new IdentifierMap();
 
-    constructor(private readonly client: Client) {
-        client.network.registerPacket(LOGGER_LOG_PACKET, LOGGER_LISTEN_PACKET);
-        client.network.addPacketHandler(LOGGER_LOG_PACKET, (packet) => {
+    constructor(private readonly omu: Omu) {
+        omu.network.registerPacket(LOGGER_LOG_PACKET, LOGGER_LISTEN_PACKET);
+        omu.network.addPacketHandler(LOGGER_LOG_PACKET, (packet) => {
             const listener = this.listeners.get(packet.id);
             if (listener) {
                 listener.forEach((it) => it(packet.message));
@@ -40,8 +39,8 @@ export class LoggerExtension {
     }
 
     public log(message: LogMessage): void {
-        const packet = new LogPacket(this.client.app.id, message);
-        this.client.send(LOGGER_LOG_PACKET, packet);
+        const packet = new LogPacket(this.omu.app.id, message);
+        this.omu.send(LOGGER_LOG_PACKET, packet);
     }
 
     public error(text: string): void {
@@ -62,8 +61,8 @@ export class LoggerExtension {
 
     public listen(id: Identifier, listener: LogListener): Unlisten {
         if (!this.listeners.has(id)) {
-            this.client.onReady(() => {
-                this.client.send(LOGGER_LISTEN_PACKET, id);
+            this.omu.onReady(() => {
+                this.omu.send(LOGGER_LISTEN_PACKET, id);
             });
         }
         const list = this.listeners.get(id) ?? [];

package/src/api/logger/index.ts

@@ -0,0 +1,4 @@
+export {
+    LOGGER_LOG_PERMISSION_ID,
+} from './extension.js';
+

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

@@ -1,5 +1,5 @@
-import { ByteReader, ByteWriter } from '../../bytebuffer.js';
-import { Identifier } from '../../identifier.js';
+import { Identifier } from '../../identifier';
+import { ByteReader, ByteWriter } from '../../serialize';
 
 export enum LogType {
     ERROR = 'error',
@@ -28,7 +28,7 @@ export class LogPacket {
     }
 
     public static deserialize(item: Uint8Array): LogPacket {
-        const reader = new ByteReader(item);
+        const reader = ByteReader.fromUint8Array(item);
         const id = reader.readString();
         const type = reader.readString() as LogType;
         const text = reader.readString();

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

@@ -1,13 +1,13 @@
-import type { Client } from '../../client.js';
-import { Identifier, IdentifierMap, IdentifierSet } from '../../identifier.js';
+import { Identifier, IdentifierMap, IdentifierSet, IntoId } from '../../identifier';
 import { PacketType } from '../../network/packet/packet.js';
-import { Serializer } from '../../serializer.js';
+import { Omu } from '../../omu';
+import { Serializer } from '../../serialize';
 import { EndpointType } from '../endpoint/endpoint.js';
 import { ExtensionType } from '../extension.js';
 
 import { PermissionType } from './permission.js';
 
-export const PERMISSION_EXTENSION_TYPE = new ExtensionType(
+export const PERMISSION_EXTENSION_TYPE: ExtensionType<PermissionExtension> = new ExtensionType(
     'permission',
     (client) => new PermissionExtension(client),
 );
@@ -15,54 +15,57 @@ const PERMISSION_REGISTER_PACKET = PacketType.createJson<PermissionType[]>(
     PERMISSION_EXTENSION_TYPE,
     {
         name: 'register',
-        serializer: Serializer.model(PermissionType).toArray(),
+        serializer: Serializer.of(PermissionType).toArray(),
     },
 );
 const PERMISSION_REQUIRE_PACKET = PacketType.createJson<Identifier[]>(PERMISSION_EXTENSION_TYPE, {
     name: 'require',
-    serializer: Serializer.model(Identifier).toArray(),
+    serializer: Serializer.of(Identifier).toArray(),
 });
 const PERMISSION_REQUEST_ENDPOINT = EndpointType.createJson<Identifier[], void>(
     PERMISSION_EXTENSION_TYPE,
     {
         name: 'request',
-        requestSerializer: Serializer.model(Identifier).toArray(),
+        requestSerializer: Serializer.of(Identifier).toArray(),
     },
 );
 const PERMISSION_GRANT_PACKET = PacketType.createJson<PermissionType[]>(PERMISSION_EXTENSION_TYPE, {
     name: 'grant',
-    serializer: Serializer.model(PermissionType).toArray(),
+    serializer: Serializer.of(PermissionType).toArray(),
 });
 
 export class PermissionExtension {
-    public readonly type = PERMISSION_EXTENSION_TYPE;
+    public readonly type: ExtensionType<PermissionExtension> = PERMISSION_EXTENSION_TYPE;
     private permissions = new IdentifierMap<PermissionType>();
     private readonly registeredPermissions = new IdentifierMap<PermissionType>();
     private readonly requiredPermissions = new IdentifierSet();
 
-    constructor(private readonly client: Client) {
-        client.network.registerPacket(
+    constructor(private readonly omu: Omu) {
+        omu.network.registerPacket(
             PERMISSION_REGISTER_PACKET,
             PERMISSION_REQUIRE_PACKET,
             PERMISSION_GRANT_PACKET,
         );
-        client.network.addPacketHandler(PERMISSION_GRANT_PACKET, (permissions) => {
+        omu.network.addPacketHandler(PERMISSION_GRANT_PACKET, (permissions) => {
             for (const permission of permissions) {
                 this.permissions.set(permission.id, permission);
             }
         });
-        client.network.addTask(() => this.onTask());
+        omu.network.addTask(() => this.onTask());
     }
 
     private onTask(): void {
+        if (this.omu.app.type === 'remote') {
+            return;
+        }
         if (this.registeredPermissions.size > 0) {
-            this.client.send(
+            this.omu.send(
                 PERMISSION_REGISTER_PACKET,
                 Array.from(this.registeredPermissions.values()),
             );
         }
         if (this.requiredPermissions.size > 0) {
-            this.client.send(
+            this.omu.send(
                 PERMISSION_REQUIRE_PACKET,
                 Array.from(this.requiredPermissions.values()),
             );
@@ -70,18 +73,16 @@ export class PermissionExtension {
     }
 
     public register(permission: PermissionType): void {
-        if (this.client.running) {
-            this.client.send(PERMISSION_REGISTER_PACKET, [permission]);
+        if (this.omu.running) {
+            this.omu.send(PERMISSION_REGISTER_PACKET, [permission]);
         }
         this.registeredPermissions.set(permission.id, permission);
     }
 
-    public require(...permissionIds: (Identifier | string)[]): void {
-        const ids: Identifier[] = permissionIds.map((id) =>
-            typeof id === 'string' ? Identifier.fromKey(id) : id,
-        );
+    public require(...permissionIds: IntoId[]): void {
+        const ids = permissionIds.map(Identifier.from);
         const missing = ids.filter((id) => !this.permissions.has(id));
-        if (this.client.running) {
+        if (this.omu.running) {
             if (missing.length > 0) {
                 throw new Error('Permissions must be registered before the client starts');
             }
@@ -93,7 +94,7 @@ export class PermissionExtension {
     }
 
     public async request(...permissionIds: Identifier[]): Promise<void> {
-        await this.client.endpoints.call(PERMISSION_REQUEST_ENDPOINT, permissionIds);
+        await this.omu.endpoints.call(PERMISSION_REQUEST_ENDPOINT, permissionIds);
     }
 
     public has(permissionIdentifier: Identifier): boolean {

package/src/api/permission/index.ts

@@ -0,0 +1,2 @@
+export { PermissionType, type PermissionLevel, type PermissionMetadata } from './permission.js';
+

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

@@ -1,6 +1,5 @@
-import { Identifier } from '../../identifier.js';
+import { Identifier, IntoId } from '../../identifier';
 import type { LocalizedText } from '../../localization/localization.js';
-import type { Model } from '../../model.js';
 
 export type PermissionLevel = 'low' | 'medium' | 'high';
 
@@ -15,7 +14,7 @@ export type PermissionTypeJson = {
     metadata: PermissionMetadata;
 };
 
-export class PermissionType implements Model<PermissionTypeJson> {
+export class PermissionType {
     public readonly id: Identifier;
     public readonly metadata: PermissionMetadata;
 
@@ -25,29 +24,27 @@ export class PermissionType implements Model<PermissionTypeJson> {
     }
 
     public static create(
-        identifier: Identifier,
+        identifier: IntoId,
         {
-            name,
             metadata,
         }: {
-            name: string;
             metadata: PermissionMetadata;
         },
     ): PermissionType {
         return new PermissionType({
-            id: identifier.join(name),
+            id: Identifier.from(identifier),
             metadata: metadata,
         });
     }
 
-    public toJson(): PermissionTypeJson {
+    public static serialize(data: PermissionType): PermissionTypeJson {
         return {
-            id: this.id.key(),
-            metadata: this.metadata,
+            id: data.id.key(),
+            metadata: data.metadata,
         };
     }
 
-    public static fromJson(json: PermissionTypeJson): PermissionType {
+    public static deserialize(json: PermissionTypeJson): PermissionType {
         return new PermissionType({
             id: Identifier.fromKey(json.id),
             metadata: json.metadata,

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

@@ -1,37 +1,38 @@
-import type { Client } from '../../client.js';
+import { Identifier } from '../../identifier';
 import { PacketType } from '../../network/packet/packet.js';
+import { Omu } from '../../omu';
 import { EndpointType } from '../endpoint/endpoint.js';
 import { ExtensionType } from '../extension.js';
 import { Table, TableType } from '../table/table.js';
 
-export const PLUGIN_EXTENSION_TYPE = new ExtensionType(
+export const PLUGIN_EXTENSION_TYPE: ExtensionType<PluginExtension> = new ExtensionType(
     'plugin',
-    (client: Client) => new PluginExtension(client),
+    (omu: Omu) => new PluginExtension(omu),
 );
 
 export class PluginExtension {
-    public readonly type = PLUGIN_EXTENSION_TYPE;
+    public readonly type: ExtensionType<PluginExtension> = PLUGIN_EXTENSION_TYPE;
     private readonly requiredPlugins: Map<string, string | null> = new Map();
 
-    constructor(private readonly client: Client) {
-        client.network.registerPacket(PLUGIN_REQUIRE_PACKET);
-        client.network.addTask(() => this.onTask());
+    constructor(private readonly omu: Omu) {
+        omu.network.registerPacket(PLUGIN_REQUIRE_PACKET);
+        omu.network.addTask(() => this.onTask());
     }
 
     public getAllowedPackages(): Table<PluginPackageInfo> {
-        return this.client.tables.get(PLUGIN_ALLOWED_PACKAGE_TABLE);
+        return this.omu.tables.get(PLUGIN_ALLOWED_PACKAGE_TABLE);
     }
 
     public reload(options: ReloadOptions): void {
-        this.client.endpoints.call(PLUGIN_RELOAD_ENDPOINT_TYPE, options);
+        this.omu.endpoints.call(PLUGIN_RELOAD_ENDPOINT_TYPE, options);
     }
 
     private async onTask(): Promise<void> {
-        this.client.send(PLUGIN_REQUIRE_PACKET, Object.fromEntries(this.requiredPlugins));
+        this.omu.send(PLUGIN_REQUIRE_PACKET, Object.fromEntries(this.requiredPlugins));
     }
 
     public require(plugins: Record<string, string | null>): void {
-        if (this.client.running) {
+        if (this.omu.running) {
             throw new Error('Plugins must be required before the client starts');
         }
         for (const [key, value] of Object.entries(plugins)) {
@@ -55,11 +56,19 @@ export class PluginPackageInfo {
         this.version = version;
     }
 
-    public static fromJson(json: { package: string, version: string }): PluginPackageInfo {
+    public static serialize(data: PluginPackageInfo): { package: string; version: string } {
+        return data.toJson();
+    }
+
+    public static deserialize(data: { package: string; version: string }): PluginPackageInfo {
+        return PluginPackageInfo.fromJson(data);
+    }
+
+    public static fromJson(json: { package: string; version: string }): PluginPackageInfo {
         return new PluginPackageInfo(json.package, json.version);
     }
 
-    public toJson(): { package: string, version: string } {
+    public toJson(): { package: string; version: string } {
         return { package: this.package, version: this.version };
     }
 
@@ -68,19 +77,23 @@ export class PluginPackageInfo {
     }
 }
 
-export const PLUGIN_READ_PACKAGE_PERMISSION_ID = PLUGIN_EXTENSION_TYPE.join('package', 'read')
-export const PLUGIN_MANAGE_PACKAGE_PERMISSION_ID = PLUGIN_EXTENSION_TYPE.join('package', 'manage')
+export const PLUGIN_READ_PACKAGE_PERMISSION_ID: Identifier = PLUGIN_EXTENSION_TYPE.join('package', 'read');
+export const PLUGIN_MANAGE_PACKAGE_PERMISSION_ID: Identifier = PLUGIN_EXTENSION_TYPE.join('package', 'manage');
 
-const PLUGIN_ALLOWED_PACKAGE_TABLE = TableType.createModel(PLUGIN_EXTENSION_TYPE, {
+const PLUGIN_ALLOWED_PACKAGE_TABLE = TableType.createJson(PLUGIN_EXTENSION_TYPE, {
     name: 'allowed_package',
-    model: PluginPackageInfo,
+    serializer: PluginPackageInfo,
+    key: (item) => item.key(),
 });
+
 type ReloadOptions = {
-    packages: string[] | null,
+    packages: string[] | null;
 };
+
 type ReloadResult = {
-    packages: Record<string, string>,
+    packages: Record<string, string>;
 };
+
 const PLUGIN_RELOAD_ENDPOINT_TYPE = EndpointType.createJson<ReloadOptions, ReloadResult>(PLUGIN_EXTENSION_TYPE, {
     name: 'reload',
     permissionId: PLUGIN_MANAGE_PACKAGE_PERMISSION_ID,

package/src/api/plugin/index.ts

@@ -0,0 +1,3 @@
+export { PLUGIN_MANAGE_PACKAGE_PERMISSION_ID, PLUGIN_READ_PACKAGE_PERMISSION_ID, PluginPackageInfo } from './extension.js';
+export type { PackageInfo } from './package-info.js';
+

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

@@ -1,21 +1,22 @@
-import type { Client } from '../../client.js';
-import type { Unlisten } from '../../event-emitter.js';
-import { EventEmitter } from '../../event-emitter.js';
-import { Identifier, IdentifierMap } from '../../identifier.js';
-import { PacketType } from '../../network/packet/index.js';
-import { Serializer } from '../../serializer.js';
+import type { Unlisten } from '../../event';
+import { EventEmitter } from '../../event';
+import { Identifier, IdentifierMap } from '../../identifier';
+import { Lock } from '../../lock.js';
+import { PacketType } from '../../network/packet';
+import { Omu } from '../../omu';
+import { JsonType, Serializer } from '../../serialize';
 import { EndpointType } from '../endpoint/endpoint.js';
 import { type Extension, ExtensionType } from '../extension.js';
 
-import { RegistryPacket, RegistryRegisterPacket } from './packets.js';
+import { RegisterPacket, RegistryPacket } from './packets.js';
 import { type Registry, RegistryType } from './registry.js';
 
 export class RegistryExtension implements Extension {
-    public readonly type = REGISTRY_EXTENSION_TYPE;
+    public readonly type: ExtensionType<RegistryExtension> = REGISTRY_EXTENSION_TYPE;
     private readonly registries = new IdentifierMap<Registry<unknown>>();
 
-    constructor(private readonly client: Client) {
-        client.network.registerPacket(
+    constructor(private readonly omu: Omu) {
+        omu.network.registerPacket(
             REGISTRY_REGISTER_PACKET,
             REGISTRY_UPDATE_PACKET,
             REGISTRY_LISTEN_PACKET,
@@ -23,11 +24,10 @@ export class RegistryExtension implements Extension {
     }
 
     private createRegistry<T>(registryType: RegistryType<T>): Registry<T> {
-        this.client.permissions.require(REGISTRY_PERMISSION_ID);
         if (this.registries.has(registryType.id)) {
             throw new Error(`Registry with identifier '${registryType.id}' already exists`);
         }
-        return new RegistryImpl(this.client, registryType);
+        return new RegistryImpl(this.omu, registryType);
     }
 
     public get<T>(registryType: RegistryType<T>): Registry<T> {
@@ -40,15 +40,28 @@ export class RegistryExtension implements Extension {
         return registry as Registry<T>;
     }
 
-    public create<T>(name: string, options: { default: T, serializer?: Serializer<T, Uint8Array> }): Registry<T> {
-        const identifier = this.client.app.id.join(name);
+    public json<T, D extends JsonType = JsonType>(name: string, options: { default: T; serializer?: Serializer<T, D> }): Registry<T> {
+        const identifier = this.omu.app.id.join(name);
+        if (this.registries.has(identifier)) {
+            throw new Error(`Registry with name '${name}' already exists`);
+        }
+        const tableType = RegistryType.createJson<T>(identifier, {
+            name,
+            defaultValue: options.default,
+            serializer: options.serializer,
+        });
+        return this.createRegistry(tableType);
+    }
+
+    public serialized<T>(name: string, options: { default: T; serializer: Serializer<T, Uint8Array> }): Registry<T> {
+        const identifier = this.omu.app.id.join(name);
         if (this.registries.has(identifier)) {
             throw new Error(`Registry with name '${name}' already exists`);
         }
         const tableType = RegistryType.createSerialized<T>(identifier, {
             name,
             defaultValue: options.default,
-            serializer: options.serializer ?? Serializer.json(),
+            serializer: options.serializer,
         });
         return this.createRegistry(tableType);
     }
@@ -56,53 +69,72 @@ export class RegistryExtension implements Extension {
 
 class RegistryImpl<T> implements Registry<T> {
     private readonly eventEmitter: EventEmitter<[T]> = new EventEmitter();
+    private readonly lock: Lock = new Lock();
     private listening = false;
     public value: T;
 
     constructor(
-        private readonly client: Client,
+        private readonly omu: Omu,
         public readonly type: RegistryType<T>,
     ) {
         this.value = type.defaultValue;
-        client.network.addPacketHandler(REGISTRY_UPDATE_PACKET, (packet) =>
+        omu.network.addPacketHandler(REGISTRY_UPDATE_PACKET, (packet) =>
             this.handleUpdate(packet),
         );
-        client.network.addTask(() => this.onTask());
+        omu.network.addTask(() => this.onTask());
     }
 
-    public async get(): Promise<T> {
-        const result = await this.client.endpoints.call(REGISTRY_GET_ENDPOINT, this.type.id);
+    async #get(): Promise<T> {
+        const result = await this.omu.endpoints.call(REGISTRY_GET_ENDPOINT, this.type.id);
         if (result.value === null) {
             return this.type.defaultValue;
         }
         return this.type.serializer.deserialize(result.value);
     }
 
-    public async set(value: T): Promise<void> {
-        this.client.send(REGISTRY_UPDATE_PACKET, {
+    async #set(value: T): Promise<void> {
+        this.omu.send(REGISTRY_UPDATE_PACKET, {
             id: this.type.id,
             value: this.type.serializer.serialize(value),
         });
+    }
+
+    public async get(): Promise<T> {
+        const value = await this.lock.use(async () => this.#get());
+        this.eventEmitter.emit(value);
+        return value;
+    }
+
+    public async set(value: T): Promise<void> {
+        await this.lock.use(async () => this.#set(value));
         this.eventEmitter.emit(value);
     }
 
     public async update(fn: (value: T) => PromiseLike<T> | T): Promise<T> {
-        const value = await this.get();
-        const newValue = await fn(value);
-        await this.set(newValue);
-        return newValue;
+        const value = await this.lock.use(async () => {
+            const value = await this.#get();
+            const newValue = await fn(value);
+            await this.#set(newValue);
+            return newValue;
+        });
+        this.eventEmitter.emit(value);
+        return value;
     }
 
     public async modify(fn: (value: T) => PromiseLike<T> | T): Promise<T> {
-        const value = await this.get();
-        const newValue = await fn(value);
-        await this.set(newValue);
-        return newValue;
+        const value = await this.lock.use(async () => {
+            const value = await this.#get();
+            const newValue = await fn(value);
+            await this.#set(newValue);
+            return newValue;
+        });
+        this.eventEmitter.emit(value);
+        return value;
     }
 
     public listen(handler: (value: T) => Promise<void> | void): Unlisten {
-        if (!this.listening && this.client.ready) {
-            this.client.send(REGISTRY_LISTEN_PACKET, this.type.id);
+        if (!this.listening && this.omu.ready) {
+            this.omu.send(REGISTRY_LISTEN_PACKET, this.type.id);
         }
         this.listening = true;
         return this.eventEmitter.listen(handler);
@@ -120,30 +152,27 @@ class RegistryImpl<T> implements Registry<T> {
 
     private onTask(): void {
         if (this.listening) {
-            this.client.send(REGISTRY_LISTEN_PACKET, this.type.id);
+            this.omu.send(REGISTRY_LISTEN_PACKET, this.type.id);
         }
-        if (!this.type.id.isSubpathOf(this.client.app.id)) {
+        if (!this.type.id.isSubpathOf(this.omu.app.id)) {
             return;
         }
-        this.client.send(REGISTRY_REGISTER_PACKET, {
+        this.omu.send(REGISTRY_REGISTER_PACKET, {
             id: this.type.id,
             permissions: this.type.permissions,
         });
     }
 }
 
-export const REGISTRY_EXTENSION_TYPE = new ExtensionType(
+export const REGISTRY_EXTENSION_TYPE: ExtensionType<RegistryExtension> = new ExtensionType(
     'registry',
-    (client: Client) => new RegistryExtension(client),
-);
-export const REGISTRY_PERMISSION_ID = REGISTRY_EXTENSION_TYPE.join('permission');
-const REGISTRY_REGISTER_PACKET = PacketType.createSerialized<RegistryRegisterPacket>(
-    REGISTRY_EXTENSION_TYPE,
-    {
-        name: 'register',
-        serializer: RegistryRegisterPacket,
-    },
+    (omu: Omu) => new RegistryExtension(omu),
 );
+export const REGISTRY_PERMISSION_ID: Identifier = REGISTRY_EXTENSION_TYPE.join('permission');
+const REGISTRY_REGISTER_PACKET = PacketType.createJson<RegisterPacket>(REGISTRY_EXTENSION_TYPE, {
+    name: 'register',
+    serializer: RegisterPacket,
+});
 const REGISTRY_UPDATE_PACKET = PacketType.createSerialized<RegistryPacket>(
     REGISTRY_EXTENSION_TYPE,
     {
@@ -153,13 +182,13 @@ const REGISTRY_UPDATE_PACKET = PacketType.createSerialized<RegistryPacket>(
 );
 const REGISTRY_LISTEN_PACKET = PacketType.createJson<Identifier>(REGISTRY_EXTENSION_TYPE, {
     name: 'listen',
-    serializer: Serializer.model(Identifier),
+    serializer: Identifier,
 });
 const REGISTRY_GET_ENDPOINT = EndpointType.createSerialized<Identifier, RegistryPacket>(
     REGISTRY_EXTENSION_TYPE,
     {
         name: 'get',
-        requestSerializer: Serializer.model(Identifier).toJson(),
+        requestSerializer: Serializer.of(Identifier).toJson(),
         responseSerializer: RegistryPacket,
         permissionId: REGISTRY_PERMISSION_ID,
     },

package/src/api/registry/index.ts

@@ -0,0 +1,3 @@
+export { REGISTRY_PERMISSION_ID } from './extension.js';
+export { RegistryType, type Registry, type RegistryPermissions } from './registry.js';
+