@omujs/omu 0.9.9 → 0.9.26

package/dist/esm/api/session/extension.js

@@ -0,0 +1,2111 @@
+// @bun
+// src/identifier.ts
+var NAMESPACE_REGEX = /^(\.[^/:.]|[\w-])+$/;
+var NAME_REGEX = /^[^/:]+$/;
+
+class Identifier {
+  namespace;
+  path;
+  constructor(namespace, ...path) {
+    Identifier.validate(namespace, path);
+    this.namespace = namespace;
+    this.path = path;
+  }
+  static serialize(identifier) {
+    return identifier.key();
+  }
+  static deserialize(json) {
+    return Identifier.fromJson(json);
+  }
+  static from(id) {
+    if (id instanceof Identifier) {
+      return id;
+    } else if (id instanceof App) {
+      return id.id;
+    } else if (typeof id === "string") {
+      return Identifier.fromKey(id);
+    } else {
+      const idCasted = id;
+      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;
+      if (typeof idWithId.id !== "undefined") {
+        return Identifier.from(idWithId.id);
+      }
+      throw new Error(`Cannot convert to Identifier: ${id}`);
+    }
+  }
+  static fromOptional(id) {
+    if (id === undefined || id === null) {
+      return;
+    }
+    return Identifier.from(id);
+  }
+  static validate(namespace, path) {
+    if (!namespace) {
+      throw new Error("Invalid namespace: Namespace cannot be empty");
+    }
+    if (path.length === 0) {
+      throw new Error("Invalid path: Path must have at least one name");
+    }
+    if (!NAMESPACE_REGEX.test(namespace)) {
+      throw new Error(`Invalid namespace: Namespace must match ${NAMESPACE_REGEX}`);
+    }
+    for (const name of path) {
+      if (!NAME_REGEX.test(name)) {
+        throw new Error(`Invalid path: Name must match ${NAME_REGEX} but got ${name}`);
+      }
+    }
+  }
+  static format(namespace, ...path) {
+    Identifier.validate(namespace, path);
+    return `${namespace}:${path.join("/")}`;
+  }
+  static fromKey(key) {
+    const separator = key.indexOf(":");
+    if (separator === -1) {
+      throw new Error(`Invalid key: No separator found in ${key}`);
+    }
+    if (key.indexOf(":", separator + 1) !== -1) {
+      throw new Error(`Invalid key: Multiple separators found in ${key}`);
+    }
+    const namespace = key.slice(0, separator);
+    const path = key.slice(separator + 1);
+    if (!namespace || !path) {
+      throw new Error("Invalid key: Namespace and path cannot be empty");
+    }
+    return new Identifier(namespace, ...path.split("/"));
+  }
+  static fromUrl(url) {
+    const parsedUrl = new URL(url);
+    const namespace = Identifier.namespaceFromUrl(parsedUrl.href);
+    const path = parsedUrl.pathname.slice(1).split("/");
+    return new Identifier(namespace, ...path);
+  }
+  static namespaceFromUrl(url) {
+    const parsed = new URL(url);
+    return parsed.hostname.split(".").reverse().join(".");
+  }
+  toJson() {
+    return this.key();
+  }
+  static fromJson(json) {
+    return Identifier.fromKey(json);
+  }
+  key() {
+    return Identifier.format(this.namespace, ...this.path);
+  }
+  isEqual(other) {
+    return this.key() === other.key();
+  }
+  isNamespaceEqual(other) {
+    return this.namespace === other.namespace;
+  }
+  isSubpathOf(other) {
+    if (this.namespace !== other.namespace) {
+      return false;
+    }
+    if (this.path.length < other.path.length) {
+      return false;
+    }
+    for (let i = 0;i < other.path.length; i++) {
+      if (this.path[i] !== other.path[i]) {
+        return false;
+      }
+    }
+    return true;
+  }
+  join(...path) {
+    return new Identifier(this.namespace, ...this.path, ...path);
+  }
+}
+
+class IdentifierMap {
+  map = new Map;
+  constructor(entries) {
+    if (!entries)
+      return;
+    for (const [id, value] of entries) {
+      this.map.set(id.key(), value);
+    }
+  }
+  get size() {
+    return this.map.size;
+  }
+  set(identifier, value) {
+    this.map.set(identifier.key(), value);
+  }
+  get(identifier) {
+    return this.map.get(identifier.key());
+  }
+  has(identifier) {
+    return this.map.has(identifier.key());
+  }
+  delete(identifier) {
+    this.map.delete(identifier.key());
+  }
+  clear() {
+    this.map.clear();
+  }
+  *keys() {
+    for (const key of this.map.keys()) {
+      yield Identifier.fromKey(key);
+    }
+  }
+  values() {
+    return this.map.values();
+  }
+  *entries() {
+    for (const [key, value] of this.map.entries()) {
+      yield [Identifier.fromKey(key), value];
+    }
+  }
+  [Symbol.iterator]() {
+    return this.entries();
+  }
+}
+
+class IdentifierSet {
+  set = new Set;
+  get size() {
+    return this.set.size;
+  }
+  add(identifier) {
+    this.set.add(identifier.key());
+  }
+  has(identifier) {
+    return this.set.has(identifier.key());
+  }
+  delete(identifier) {
+    this.set.delete(identifier.key());
+  }
+  clear() {
+    this.set.clear();
+  }
+  *keys() {
+    for (const key of this.set.keys()) {
+      yield Identifier.fromKey(key);
+    }
+  }
+  values() {
+    return this.keys();
+  }
+  *entries() {
+    for (const key of this.set.keys()) {
+      const identifier = Identifier.fromKey(key);
+      yield [identifier, identifier];
+    }
+  }
+  [Symbol.iterator]() {
+    return this.entries();
+  }
+}
+
+// src/app.ts
+class App {
+  id;
+  type;
+  parentId;
+  version;
+  url;
+  metadata;
+  dependencies;
+  constructor(id, options) {
+    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 ?? "app";
+    this.dependencies = options.dependencies ?? {};
+  }
+  static deserialize(info) {
+    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 ?? {}
+    });
+  }
+  static serialize(data) {
+    return {
+      id: data.id.key(),
+      type: data.type,
+      parent_id: data.parentId?.key(),
+      version: data.version,
+      url: data.url,
+      metadata: data.metadata,
+      dependencies: data.dependencies
+    };
+  }
+  join(...paths) {
+    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
+    });
+  }
+}
+
+// src/const.ts
+var textEncoder = new TextEncoder;
+var textDecoder = new TextDecoder;
+
+// src/serialize/serializer.ts
+class Serializer {
+  serialize;
+  deserialize;
+  constructor(serialize, deserialize) {
+    this.serialize = serialize;
+    this.deserialize = deserialize;
+  }
+  static of(serializer) {
+    return new Serializer(serializer.serialize, serializer.deserialize);
+  }
+  static pipe(ser1, ser2) {
+    return new Serializer((data) => ser2.serialize(ser1.serialize(data)), (data) => ser1.deserialize(ser2.deserialize(data)));
+  }
+  static transform(func) {
+    return new Serializer(func, func);
+  }
+  static noop() {
+    return new Serializer((data) => data, (data) => data);
+  }
+  field(key, serializer) {
+    return new Serializer((data) => {
+      const serialized = this.serialize(data);
+      return {
+        ...serialized,
+        [key]: serializer.serialize(serialized[key])
+      };
+    }, (data) => {
+      return this.deserialize({
+        ...data,
+        [key]: serializer.deserialize(data[key])
+      });
+    });
+  }
+  static json() {
+    return new Serializer((data) => textEncoder.encode(JSON.stringify(data)), (data) => {
+      const text = textDecoder.decode(data);
+      return JSON.parse(text);
+    });
+  }
+  toJson() {
+    return new Serializer((data) => textEncoder.encode(JSON.stringify(this.serialize(data))), (data) => {
+      const text = textDecoder.decode(data);
+      return this.deserialize(JSON.parse(text));
+    });
+  }
+  toArray() {
+    return new Serializer((data) => data.map((item) => this.serialize(item)), (data) => data.map((item) => this.deserialize(item)));
+  }
+  toMap() {
+    return new Serializer((data) => {
+      const result = new Map;
+      data.forEach((value, key) => {
+        result.set(key, this.serialize(value));
+      });
+      return result;
+    }, (data) => {
+      const result = new Map;
+      data.forEach((value, key) => {
+        result.set(key, this.deserialize(value));
+      });
+      return result;
+    });
+  }
+  fallback(fallback) {
+    return new Serializer((data) => this.serialize(data), (data) => {
+      try {
+        return this.deserialize(data);
+      } catch {
+        return fallback;
+      }
+    });
+  }
+  fallbackMap(fallback) {
+    return new Serializer((data) => this.serialize(data), (data) => {
+      try {
+        return this.deserialize(data);
+      } catch (error) {
+        return fallback(data, error);
+      }
+    });
+  }
+  pipe(serializer) {
+    return new Serializer((data) => serializer.serialize(this.serialize(data)), (data) => this.deserialize(serializer.deserialize(data)));
+  }
+}
+
+// src/serialize/bytebuffer.ts
+class Flags {
+  value;
+  length;
+  constructor(options) {
+    this.value = options.value ?? 0;
+    this.length = options.length ?? 32;
+  }
+  has(position) {
+    return (this.value & 1 << position) !== 0;
+  }
+  get(position) {
+    return (this.value & 1 << position) !== 0;
+  }
+  ifSet(position, callback) {
+    if (this.has(position)) {
+      return callback();
+    }
+    return;
+  }
+  set(position, value) {
+    if (value) {
+      this.value |= 1 << position;
+    } else {
+      this.value &= ~(1 << position);
+    }
+  }
+  write(writer) {
+    const bits = new Uint8Array((this.length + 7) / 8);
+    for (let i = 0;i < bits.length; i++) {
+      bits[i] = this.value >> i * 8 & 255;
+    }
+    writer.write(bits);
+  }
+  static read(reader, length) {
+    let value = 0;
+    for (let i = 0;i < (length + 7) / 8; i++) {
+      value |= reader.readUint8() << i * 8;
+    }
+    return new Flags({ value, length });
+  }
+}
+function readFloat16(dataView, offset) {
+  const sign = dataView.getUint16(offset) & 32768 ? -1 : 1;
+  const exponent = (dataView.getUint16(offset) & 31744) >> 10;
+  const mantissa = dataView.getUint16(offset) & 1023;
+  if (exponent === 0 && mantissa === 0) {
+    return 0;
+  } else if (exponent === 31) {
+    return mantissa === 0 ? Infinity * sign : NaN;
+  } else {
+    const normalizedExponent = exponent - 15;
+    const normalizedMantissa = mantissa / 1024;
+    return sign * Math.pow(2, normalizedExponent) * (1 + normalizedMantissa);
+  }
+}
+function writeFloat16(dataView, offset, value) {
+  if (value === 0) {
+    dataView.setUint16(offset, 0);
+    return;
+  }
+  const sign = value < 0 ? 1 : 0;
+  value = Math.abs(value);
+  if (!isFinite(value)) {
+    dataView.setUint16(offset, 31744 | sign << 15);
+    return;
+  }
+  const exponent = Math.floor(Math.log2(value));
+  const mantissa = value / Math.pow(2, exponent) - 1;
+  const normalizedExponent = exponent + 15;
+  const normalizedMantissa = Math.round(mantissa * 1024);
+  if (normalizedExponent <= 0) {
+    dataView.setUint16(offset, sign << 15);
+  } else if (normalizedExponent >= 31) {
+    dataView.setUint16(offset, 31744 | sign << 15);
+  } else {
+    dataView.setUint16(offset, sign << 15 | normalizedExponent << 10 | normalizedMantissa);
+  }
+}
+
+class ByteWriter {
+  dataView;
+  buffer;
+  offset = 0;
+  finished = false;
+  constructor(init, offset) {
+    this.offset = offset ?? 0;
+    this.buffer = init ?? new ArrayBuffer(1024);
+    this.dataView = new DataView(this.buffer);
+  }
+  static fromUint8Array(buffer) {
+    const arrayBuffer = new ArrayBuffer(buffer.byteLength);
+    const uint8Array = new Uint8Array(arrayBuffer);
+    uint8Array.set(new Uint8Array(buffer));
+    return new ByteWriter(arrayBuffer, buffer.byteLength);
+  }
+  allocate(length) {
+    if (this.offset + length > this.buffer.byteLength) {
+      const newByteLength = Math.max(this.buffer.byteLength * 2, this.offset + length);
+      const newBuffer = new ArrayBuffer(newByteLength);
+      new Uint8Array(newBuffer).set(new Uint8Array(this.buffer));
+      this.buffer = newBuffer;
+      this.dataView = new DataView(this.buffer);
+    }
+  }
+  write(data) {
+    if (this.finished) {
+      throw new Error("Buffer already finished");
+    }
+    this.allocate(data.length);
+    new Uint8Array(this.buffer).set(data, this.offset);
+    this.offset += data.length;
+    return this;
+  }
+  writeBoolean(value) {
+    this.allocate(1);
+    this.dataView.setInt8(this.offset, value ? 1 : 0);
+    this.offset += 1;
+    return this;
+  }
+  writeInt8(value) {
+    this.allocate(1);
+    this.dataView.setInt8(this.offset, value);
+    this.offset += 1;
+    return this;
+  }
+  writeUint8(value) {
+    this.allocate(1);
+    this.dataView.setUint8(this.offset, value);
+    this.offset += 1;
+    return this;
+  }
+  writeInt16(value) {
+    this.allocate(2);
+    this.dataView.setInt16(this.offset, value);
+    this.offset += 2;
+    return this;
+  }
+  writeUint16(value) {
+    this.allocate(2);
+    this.dataView.setUint16(this.offset, value);
+    this.offset += 2;
+    return this;
+  }
+  writeInt32(value) {
+    this.allocate(4);
+    this.dataView.setInt32(this.offset, value);
+    this.offset += 4;
+    return this;
+  }
+  writeUint32(value) {
+    this.allocate(4);
+    this.dataView.setUint32(this.offset, value);
+    this.offset += 4;
+    return this;
+  }
+  writeInt64(value) {
+    this.allocate(8);
+    this.dataView.setBigInt64(this.offset, value);
+    this.offset += 8;
+    return this;
+  }
+  writeUint64(value) {
+    this.allocate(8);
+    this.dataView.setBigUint64(this.offset, value);
+    this.offset += 8;
+    return this;
+  }
+  writeULEB128(value) {
+    if (value < 0) {
+      throw new Error("Value must be non-negative");
+    }
+    while (value > 127) {
+      this.allocate(1);
+      this.dataView.setUint8(this.offset, value & 127 | 128);
+      this.offset += 1;
+      value >>= 7;
+    }
+    this.allocate(1);
+    this.dataView.setUint8(this.offset, value & 127);
+    this.offset += 1;
+    return this;
+  }
+  writeFloat16(value) {
+    this.allocate(2);
+    writeFloat16(this.dataView, this.offset, value);
+    this.offset += 2;
+    return this;
+  }
+  writeFloat32(value) {
+    this.allocate(4);
+    this.dataView.setFloat32(this.offset, value);
+    this.offset += 4;
+    return this;
+  }
+  writeFloat64(value) {
+    this.allocate(4);
+    this.dataView.setFloat64(this.offset, value);
+    this.offset += 4;
+    return this;
+  }
+  writeUint8Array(value) {
+    this.writeULEB128(value.byteLength);
+    this.write(value);
+    return this;
+  }
+  writeString(value) {
+    this.writeUint8Array(textEncoder.encode(value));
+    return this;
+  }
+  writeJSON(value) {
+    this.writeString(JSON.stringify(value));
+    return this;
+  }
+  writeFlags(flags) {
+    flags.write(this);
+    return this;
+  }
+  finish() {
+    if (this.finished) {
+      throw new Error("Buffer already finished");
+    }
+    this.finished = true;
+    return new Uint8Array(this.buffer, 0, this.offset);
+  }
+}
+
+class ByteReader {
+  dataView;
+  offset;
+  finished;
+  constructor(data) {
+    this.dataView = data;
+    this.offset = 0;
+    this.finished = false;
+  }
+  static fromUint8Array(buffer) {
+    const arrayBuffer = new ArrayBuffer(buffer.byteLength);
+    const uint8Array = new Uint8Array(arrayBuffer);
+    uint8Array.set(new Uint8Array(buffer));
+    const dataView = new DataView(arrayBuffer);
+    return new ByteReader(dataView);
+  }
+  static fromArrayBuffer(buffer) {
+    const dataView = new DataView(buffer);
+    return new ByteReader(dataView);
+  }
+  static async fromBlob(blob) {
+    const arrayBuffer = await blob.arrayBuffer();
+    const dataView = new DataView(arrayBuffer);
+    return new ByteReader(dataView);
+  }
+  read(size) {
+    if (this.finished) {
+      throw new Error("Buffer already finished");
+    }
+    if (size < 0) {
+      throw new Error("Size must be positive");
+    }
+    if (this.offset + size > this.dataView.byteLength) {
+      throw new Error("Buffer not fully read");
+    }
+    const value = new Uint8Array(this.dataView.buffer, this.offset, size);
+    this.offset += size;
+    return value;
+  }
+  readBoolean() {
+    const value = this.dataView.getInt8(this.offset);
+    this.offset += 1;
+    return value !== 0;
+  }
+  readInt8() {
+    const value = this.dataView.getInt8(this.offset);
+    this.offset += 1;
+    return value;
+  }
+  readUint8() {
+    const value = this.dataView.getUint8(this.offset);
+    this.offset += 1;
+    return value;
+  }
+  readInt16() {
+    const value = this.dataView.getInt16(this.offset);
+    this.offset += 2;
+    return value;
+  }
+  readUint16() {
+    const value = this.dataView.getUint16(this.offset);
+    this.offset += 2;
+    return value;
+  }
+  readInt32() {
+    const value = this.dataView.getInt32(this.offset);
+    this.offset += 4;
+    return value;
+  }
+  readUint32() {
+    const value = this.dataView.getUint32(this.offset);
+    this.offset += 4;
+    return value;
+  }
+  readInt64() {
+    const value = this.dataView.getBigInt64(this.offset);
+    this.offset += 8;
+    return value;
+  }
+  readUint64() {
+    const value = this.dataView.getBigUint64(this.offset);
+    this.offset += 8;
+    return value;
+  }
+  readULEB128() {
+    let value = 0;
+    let shift = 0;
+    let byte;
+    do {
+      if (this.offset >= this.dataView.byteLength) {
+        throw new Error("Buffer not fully read");
+      }
+      byte = this.dataView.getUint8(this.offset);
+      this.offset += 1;
+      value |= (byte & 127) << shift;
+      shift += 7;
+    } while ((byte & 128) !== 0);
+    return value;
+  }
+  readFloat16() {
+    const value = readFloat16(this.dataView, this.offset);
+    this.offset += 2;
+    return value;
+  }
+  readFloat32() {
+    const value = this.dataView.getFloat32(this.offset);
+    this.offset += 4;
+    return value;
+  }
+  readFloat64() {
+    const value = this.dataView.getFloat64(this.offset);
+    this.offset += 8;
+    return value;
+  }
+  readUint8Array() {
+    const length = this.readULEB128();
+    return this.read(length);
+  }
+  readString() {
+    const byteArray = this.readUint8Array();
+    return textDecoder.decode(byteArray);
+  }
+  readJSON() {
+    return JSON.parse(this.readString());
+  }
+  readFlags(length) {
+    return Flags.read(this, length);
+  }
+  finish() {
+    if (this.finished) {
+      throw new Error("Buffer already finished");
+    }
+    this.finished = true;
+    if (this.offset !== this.dataView.byteLength) {
+      throw new Error("Buffer not fully read");
+    }
+  }
+}
+// src/network/packet/packet.ts
+class PacketType {
+  id;
+  serializer;
+  constructor(id, serializer) {
+    this.id = id;
+    this.serializer = serializer;
+  }
+  new(data) {
+    return {
+      type: this,
+      data
+    };
+  }
+  match(packet) {
+    return packet.type === this;
+  }
+  static createJson(identifier, {
+    name,
+    serializer
+  }) {
+    return new PacketType(identifier.join(name), Serializer.pipe(serializer ?? Serializer.noop(), Serializer.json()));
+  }
+  static createSerialized(identifier, {
+    name,
+    serializer
+  }) {
+    return new PacketType(identifier.join(name), serializer);
+  }
+}
+
+// src/network/packet/packet-types.ts
+var IDENTIFIER = new Identifier("core", "packet");
+
+class ConnectPacket {
+  protocol;
+  app;
+  token;
+  encryption;
+  constructor(options) {
+    this.protocol = options.protocol;
+    this.app = options.app;
+    this.token = options.token;
+    this.encryption = options.encryption ?? null;
+  }
+  static deserialize(data) {
+    return new ConnectPacket({
+      protocol: data.protocol,
+      app: App.deserialize(data.app),
+      encryption: data.encryption,
+      token: data.token
+    });
+  }
+  static serialize(data) {
+    return {
+      protocol: data.protocol,
+      app: App.serialize(data.app),
+      encryption: data.encryption,
+      token: data.token
+    };
+  }
+}
+class DisconnectPacket {
+  type;
+  message;
+  constructor(options) {
+    this.type = options.type;
+    this.message = options.message ?? null;
+  }
+  static serialize(data) {
+    return data.toJson();
+  }
+  static deserialize(data) {
+    return DisconnectPacket.fromJson(data);
+  }
+  static fromJson(data) {
+    return new DisconnectPacket({
+      type: data.type,
+      message: data.message
+    });
+  }
+  toJson() {
+    return {
+      type: this.type,
+      message: this.message
+    };
+  }
+}
+var PACKET_TYPES = {
+  SERVER_META: PacketType.createJson(IDENTIFIER, {
+    name: "server_meta"
+  }),
+  CONNECT: PacketType.createJson(IDENTIFIER, {
+    name: "connect",
+    serializer: ConnectPacket
+  }),
+  DISCONNECT: PacketType.createJson(IDENTIFIER, {
+    name: "disconnect",
+    serializer: DisconnectPacket
+  }),
+  TOKEN: PacketType.createJson(IDENTIFIER, {
+    name: "token"
+  }),
+  READY: PacketType.createJson(IDENTIFIER, {
+    name: "ready"
+  }),
+  ENCRYPTED_PACKET: PacketType.createSerialized(IDENTIFIER, {
+    name: "e",
+    serializer: Serializer.noop()
+  })
+};
+// src/api/endpoint/endpoint.ts
+class EndpointType {
+  id;
+  requestSerializer;
+  responseSerializer;
+  permissionId;
+  constructor(id, requestSerializer, responseSerializer, permissionId) {
+    this.id = id;
+    this.requestSerializer = requestSerializer;
+    this.responseSerializer = responseSerializer;
+    this.permissionId = permissionId;
+  }
+  static createJson(identifier, {
+    name,
+    requestSerializer,
+    responseSerializer,
+    permissionId
+  }) {
+    return new EndpointType(Identifier.from(identifier).join(name), Serializer.pipe(requestSerializer ?? Serializer.noop(), Serializer.json()), Serializer.pipe(responseSerializer ?? Serializer.noop(), Serializer.json()), permissionId ? Identifier.from(permissionId) : undefined);
+  }
+  static createSerialized(identifier, {
+    name,
+    requestSerializer,
+    responseSerializer,
+    permissionId
+  }) {
+    return new EndpointType(Identifier.from(identifier).join(name), requestSerializer, responseSerializer, permissionId ? Identifier.from(permissionId) : undefined);
+  }
+}
+// src/api/extension.ts
+class ExtensionType extends Identifier {
+  name;
+  create;
+  constructor(name, create) {
+    super("ext", name);
+    this.name = name;
+    this.create = create;
+  }
+  key() {
+    return this.name;
+  }
+}
+
+// src/event/index.ts
+class EventEmitter {
+  listeners = [];
+  listen(listener) {
+    this.listeners.push(listener);
+    return () => {
+      this.listeners.splice(this.listeners.indexOf(listener), 1);
+    };
+  }
+  async emit(...args) {
+    for (const listener of [...this.listeners]) {
+      await listener(...args);
+    }
+  }
+}
+
+// src/lock.ts
+class Lock {
+  tasks = [];
+  waiter = null;
+  wait() {
+    if (this.waiter) {
+      return this.waiter;
+    }
+    this.waiter = new Promise((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;
+  }
+  async use(callback) {
+    const promise = new Promise((resolve, reject) => {
+      const task = async () => {
+        const promise2 = callback();
+        try {
+          resolve(await promise2);
+        } catch (reason) {
+          reject(reason);
+        }
+      };
+      this.tasks.push(task);
+    });
+    await this.wait();
+    return promise;
+  }
+}
+
+// src/api/registry/packets.ts
+class RegistryPacket {
+  id;
+  value;
+  constructor(id, value) {
+    this.id = id;
+    this.value = value;
+  }
+  static serialize(packet) {
+    const writer = new ByteWriter;
+    writer.writeString(packet.id.key());
+    writer.writeBoolean(packet.value !== null);
+    if (packet.value !== null) {
+      writer.writeUint8Array(packet.value);
+    }
+    return writer.finish();
+  }
+  static deserialize(data) {
+    const reader = ByteReader.fromUint8Array(data);
+    const id = Identifier.fromKey(reader.readString());
+    const existing = reader.readBoolean();
+    const value = existing ? reader.readUint8Array() : null;
+    return new RegistryPacket(id, value);
+  }
+}
+
+class RegisterPacket {
+  id;
+  permissions;
+  constructor(id, permissions) {
+    this.id = id;
+    this.permissions = permissions;
+  }
+  static serialize(packet) {
+    const { permissions: perms } = packet;
+    return {
+      id: packet.id.key(),
+      permissions: {
+        all: perms.all ? Identifier.from(perms.all).key() : undefined,
+        read: perms.read ? Identifier.from(perms.read).key() : undefined,
+        write: perms.write ? Identifier.from(perms.write).key() : undefined
+      }
+    };
+  }
+  static deserialize(data) {
+    const { permissions: perms } = data;
+    return new RegisterPacket(Identifier.from(data.id), {
+      all: perms.all ? Identifier.from(perms.all) : undefined,
+      read: perms.read ? Identifier.from(perms.read) : undefined,
+      write: perms.write ? Identifier.from(perms.write) : undefined
+    });
+  }
+}
+
+// src/api/registry/registry.ts
+class RegistryType {
+  id;
+  defaultValue;
+  serializer;
+  permissions;
+  constructor(id, defaultValue, serializer, permissions) {
+    this.id = id;
+    this.defaultValue = defaultValue;
+    this.serializer = serializer;
+    this.permissions = permissions;
+  }
+  static createJson(identifier, {
+    name,
+    defaultValue,
+    permissions,
+    serializer
+  }) {
+    return new RegistryType(Identifier.from(identifier).join(name), defaultValue, Serializer.pipe(serializer ?? Serializer.noop(), Serializer.json()), permissions ?? {});
+  }
+  static createSerialized(identifier, {
+    name,
+    defaultValue,
+    serializer,
+    permissions
+  }) {
+    return new RegistryType(Identifier.from(identifier).join(name), defaultValue, serializer, permissions ?? {});
+  }
+}
+
+// src/api/registry/extension.ts
+class RegistryExtension {
+  omu;
+  type = REGISTRY_EXTENSION_TYPE;
+  registries = new IdentifierMap;
+  constructor(omu) {
+    this.omu = omu;
+    omu.network.registerPacket(REGISTRY_REGISTER_PACKET, REGISTRY_UPDATE_PACKET, REGISTRY_LISTEN_PACKET);
+  }
+  createRegistry(registryType) {
+    if (this.registries.has(registryType.id)) {
+      throw new Error(`Registry with identifier '${registryType.id}' already exists`);
+    }
+    return new RegistryImpl(this.omu, registryType);
+  }
+  get(registryType) {
+    const identifier = registryType.id;
+    let registry = this.registries.get(identifier);
+    if (registry === undefined) {
+      registry = this.createRegistry(registryType);
+      this.registries.set(identifier, registry);
+    }
+    return registry;
+  }
+  json(name, options) {
+    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(identifier, {
+      name,
+      defaultValue: options.default,
+      serializer: options.serializer
+    });
+    return this.createRegistry(tableType);
+  }
+  serialized(name, options) {
+    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(identifier, {
+      name,
+      defaultValue: options.default,
+      serializer: options.serializer
+    });
+    return this.createRegistry(tableType);
+  }
+}
+
+class RegistryImpl {
+  omu;
+  type;
+  eventEmitter = new EventEmitter;
+  lock = new Lock;
+  listening = false;
+  value;
+  constructor(omu, type) {
+    this.omu = omu;
+    this.type = type;
+    this.value = type.defaultValue;
+    omu.network.addPacketHandler(REGISTRY_UPDATE_PACKET, (packet) => this.handleUpdate(packet));
+    omu.network.addTask(() => this.onTask());
+  }
+  async#get() {
+    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);
+  }
+  async#set(value) {
+    this.omu.send(REGISTRY_UPDATE_PACKET, {
+      id: this.type.id,
+      value: this.type.serializer.serialize(value)
+    });
+  }
+  async get() {
+    const value = await this.lock.use(async () => this.#get());
+    this.eventEmitter.emit(value);
+    return value;
+  }
+  async set(value) {
+    await this.lock.use(async () => this.#set(value));
+    this.eventEmitter.emit(value);
+  }
+  async update(fn) {
+    const value = await this.lock.use(async () => {
+      const value2 = await this.#get();
+      const newValue = await fn(value2);
+      await this.#set(newValue);
+      return newValue;
+    });
+    this.eventEmitter.emit(value);
+    return value;
+  }
+  async modify(fn) {
+    const value = await this.lock.use(async () => {
+      const value2 = await this.#get();
+      const newValue = await fn(value2);
+      await this.#set(newValue);
+      return newValue;
+    });
+    this.eventEmitter.emit(value);
+    return value;
+  }
+  listen(handler) {
+    if (!this.listening && this.omu.ready) {
+      this.omu.send(REGISTRY_LISTEN_PACKET, this.type.id);
+    }
+    this.listening = true;
+    return this.eventEmitter.listen(handler);
+  }
+  handleUpdate(data) {
+    if (!data.id.isEqual(this.type.id)) {
+      return;
+    }
+    if (data.value !== null) {
+      this.value = this.type.serializer.deserialize(data.value);
+    }
+    this.eventEmitter.emit(this.value);
+  }
+  onTask() {
+    if (this.listening) {
+      this.omu.send(REGISTRY_LISTEN_PACKET, this.type.id);
+    }
+    if (!this.type.id.isSubpathOf(this.omu.app.id)) {
+      return;
+    }
+    this.omu.send(REGISTRY_REGISTER_PACKET, {
+      id: this.type.id,
+      permissions: this.type.permissions
+    });
+  }
+}
+var REGISTRY_EXTENSION_TYPE = new ExtensionType("registry", (omu) => new RegistryExtension(omu));
+var REGISTRY_PERMISSION_ID = REGISTRY_EXTENSION_TYPE.join("permission");
+var REGISTRY_REGISTER_PACKET = PacketType.createJson(REGISTRY_EXTENSION_TYPE, {
+  name: "register",
+  serializer: RegisterPacket
+});
+var REGISTRY_UPDATE_PACKET = PacketType.createSerialized(REGISTRY_EXTENSION_TYPE, {
+  name: "update",
+  serializer: RegistryPacket
+});
+var REGISTRY_LISTEN_PACKET = PacketType.createJson(REGISTRY_EXTENSION_TYPE, {
+  name: "listen",
+  serializer: Identifier
+});
+var REGISTRY_GET_ENDPOINT = EndpointType.createSerialized(REGISTRY_EXTENSION_TYPE, {
+  name: "get",
+  requestSerializer: Serializer.of(Identifier).toJson(),
+  responseSerializer: RegistryPacket,
+  permissionId: REGISTRY_PERMISSION_ID
+});
+// src/api/table/packets.ts
+class TablePacket {
+  id;
+  constructor(id) {
+    this.id = id;
+  }
+  static serialize(packet) {
+    const writer = new ByteWriter;
+    writer.writeString(packet.id.key());
+    return writer.finish();
+  }
+  static deserialize(data) {
+    const reader = ByteReader.fromUint8Array(data);
+    const id = Identifier.fromKey(reader.readString());
+    return new TablePacket(id);
+  }
+}
+
+class TableItemsPacket {
+  id;
+  items;
+  constructor(id, items) {
+    this.id = id;
+    this.items = items;
+  }
+  static serialize(packet) {
+    const writer = new ByteWriter;
+    writer.writeString(packet.id.key());
+    writer.writeULEB128(Object.keys(packet.items).length);
+    for (const [key, value] of Object.entries(packet.items)) {
+      writer.writeString(key);
+      writer.writeUint8Array(value);
+    }
+    return writer.finish();
+  }
+  static deserialize(data) {
+    const reader = ByteReader.fromUint8Array(data);
+    const id = Identifier.fromKey(reader.readString());
+    const count = reader.readULEB128();
+    const items = {};
+    for (let i = 0;i < count; i++) {
+      const key = reader.readString();
+      const value = reader.readUint8Array();
+      items[key] = value;
+    }
+    return new TableItemsPacket(id, items);
+  }
+}
+
+class TableKeysPacket {
+  id;
+  keys;
+  constructor(id, keys) {
+    this.id = id;
+    this.keys = keys;
+  }
+  static serialize(packet) {
+    const writer = new ByteWriter;
+    writer.writeString(packet.id.key());
+    writer.writeULEB128(packet.keys.length);
+    for (const key of packet.keys) {
+      writer.writeString(key);
+    }
+    return writer.finish();
+  }
+  static deserialize(data) {
+    const reader = ByteReader.fromUint8Array(data);
+    const id = Identifier.fromKey(reader.readString());
+    const count = reader.readULEB128();
+    const keys = [];
+    for (let i = 0;i < count; i++) {
+      keys.push(reader.readString());
+    }
+    return new TableKeysPacket(id, keys);
+  }
+}
+
+class TableProxyPacket {
+  id;
+  items;
+  key;
+  constructor(id, items, key) {
+    this.id = id;
+    this.items = items;
+    this.key = key;
+  }
+  static serialize(packet) {
+    const writer = new ByteWriter;
+    writer.writeString(packet.id.key());
+    writer.writeULEB128(packet.key);
+    writer.writeULEB128(Object.keys(packet.items).length);
+    for (const [key, value] of Object.entries(packet.items)) {
+      writer.writeString(key);
+      writer.writeUint8Array(value);
+    }
+    return writer.finish();
+  }
+  static deserialize(data) {
+    const reader = ByteReader.fromUint8Array(data);
+    const id = Identifier.fromKey(reader.readString());
+    const key = reader.readULEB128();
+    const count = reader.readULEB128();
+    const items = {};
+    for (let i = 0;i < count; i++) {
+      const key2 = reader.readString();
+      const value = reader.readUint8Array();
+      items[key2] = value;
+    }
+    return new TableProxyPacket(id, items, key);
+  }
+}
+
+class TableFetchPacket {
+  id;
+  limit;
+  backward;
+  cursor;
+  constructor(id, limit, backward = false, cursor = null) {
+    this.id = id;
+    this.limit = limit;
+    this.backward = backward;
+    this.cursor = cursor;
+  }
+  static serialize(packet) {
+    const writer = new ByteWriter;
+    writer.writeString(packet.id.key());
+    writer.writeULEB128(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);
+    }
+    return writer.finish();
+  }
+  static deserialize(data) {
+    const reader = ByteReader.fromUint8Array(data);
+    const id = Identifier.fromKey(reader.readString());
+    const limit = reader.readULEB128();
+    const flags = reader.readFlags(2);
+    const backward = flags.get(0);
+    const cursor = flags.ifSet(1, () => reader.readString());
+    return new TableFetchPacket(id, limit, backward, cursor);
+  }
+}
+
+class TableFetchRangePacket {
+  id;
+  start;
+  end;
+  constructor(id, start, end) {
+    this.id = id;
+    this.start = start;
+    this.end = end;
+  }
+  static serialize(packet) {
+    const writer = new ByteWriter;
+    writer.writeString(packet.id.key());
+    writer.writeString(packet.start);
+    writer.writeString(packet.end);
+    return writer.finish();
+  }
+  static deserialize(data) {
+    const reader = ByteReader.fromUint8Array(data);
+    const id = Identifier.fromKey(reader.readString());
+    const start = reader.readString();
+    const end = reader.readString();
+    return new TableFetchRangePacket(id, start, end);
+  }
+}
+
+class SetConfigPacket {
+  id;
+  config;
+  constructor(id, config) {
+    this.id = id;
+    this.config = config;
+  }
+  static serialize(packet) {
+    const writer = new ByteWriter;
+    writer.writeString(packet.id.key());
+    writer.writeString(JSON.stringify(packet.config));
+    return writer.finish();
+  }
+  static deserialize(data) {
+    const reader = ByteReader.fromUint8Array(data);
+    const id = Identifier.fromKey(reader.readString());
+    const config = JSON.parse(reader.readString());
+    return new SetConfigPacket(id, config);
+  }
+}
+
+class SetPermissionPacket {
+  id;
+  all;
+  read;
+  write;
+  remove;
+  proxy;
+  constructor(id, all, read, write, remove, proxy) {
+    this.id = id;
+    this.all = all;
+    this.read = read;
+    this.write = write;
+    this.remove = remove;
+    this.proxy = proxy;
+  }
+  static serialize(packet) {
+    const writer = new ByteWriter;
+    writer.writeString(packet.id.key());
+    let flags = 0;
+    if (packet.all !== null) {
+      flags |= 1;
+    }
+    if (packet.read !== null) {
+      flags |= 2;
+    }
+    if (packet.write !== null) {
+      flags |= 4;
+    }
+    if (packet.remove !== null) {
+      flags |= 8;
+    }
+    if (packet.proxy !== null) {
+      flags |= 16;
+    }
+    writer.writeUint8(flags);
+    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();
+  }
+  static deserialize(data) {
+    const reader = ByteReader.fromUint8Array(data);
+    const id = Identifier.fromKey(reader.readString());
+    const flags = reader.readUint8();
+    const all = flags & 1 ? Identifier.fromKey(reader.readString()) : null;
+    const read = flags & 2 ? Identifier.fromKey(reader.readString()) : null;
+    const write = flags & 4 ? Identifier.fromKey(reader.readString()) : null;
+    const remove = flags & 8 ? Identifier.fromKey(reader.readString()) : null;
+    const proxy = flags & 16 ? Identifier.fromKey(reader.readString()) : null;
+    return new SetPermissionPacket(id, all, read, write, remove, proxy);
+  }
+}
+
+// src/api/table/table.ts
+class TableType {
+  id;
+  serializer;
+  keyFunction;
+  permissions;
+  constructor(id, serializer, keyFunction, permissions) {
+    this.id = id;
+    this.serializer = serializer;
+    this.keyFunction = keyFunction;
+    this.permissions = permissions;
+  }
+  static createJson(identifier, {
+    name,
+    key,
+    permissions,
+    serializer
+  }) {
+    return new TableType(Identifier.from(identifier).join(name), Serializer.pipe(serializer ?? Serializer.noop(), Serializer.json()), key, permissions);
+  }
+  static createSerialized(identifier, {
+    name,
+    key,
+    permissions,
+    serializer
+  }) {
+    return new TableType(Identifier.from(identifier).join(name), serializer, key, permissions);
+  }
+}
+
+// src/api/table/extension.ts
+var TABLE_EXTENSION_TYPE = new ExtensionType("table", (client) => new TableExtension(client));
+var TABLE_PERMISSION_ID = TABLE_EXTENSION_TYPE.join("permission");
+var TABLE_SET_PERMISSION_PACKET = PacketType.createSerialized(TABLE_EXTENSION_TYPE, {
+  name: "set_permission",
+  serializer: SetPermissionPacket
+});
+var TABLE_SET_CONFIG_PACKET = PacketType.createSerialized(TABLE_EXTENSION_TYPE, {
+  name: "set_config",
+  serializer: SetConfigPacket
+});
+var TABLE_LISTEN_PACKET = PacketType.createJson(TABLE_EXTENSION_TYPE, {
+  name: "listen",
+  serializer: Identifier
+});
+var TABLE_PROXY_LISTEN_PACKET = PacketType.createJson(TABLE_EXTENSION_TYPE, {
+  name: "proxy_listen",
+  serializer: Identifier
+});
+var TABLE_PROXY_PACKET = PacketType.createSerialized(TABLE_EXTENSION_TYPE, {
+  name: "proxy",
+  serializer: TableProxyPacket
+});
+var TABLE_ITEM_ADD_PACKET = PacketType.createSerialized(TABLE_EXTENSION_TYPE, {
+  name: "item_add",
+  serializer: TableItemsPacket
+});
+var TABLE_ITEM_UPDATE_PACKET = PacketType.createSerialized(TABLE_EXTENSION_TYPE, {
+  name: "item_update",
+  serializer: TableItemsPacket
+});
+var TABLE_ITEM_REMOVE_PACKET = PacketType.createSerialized(TABLE_EXTENSION_TYPE, {
+  name: "item_remove",
+  serializer: TableItemsPacket
+});
+var TABLE_ITEM_GET_ENDPOINT = EndpointType.createSerialized(TABLE_EXTENSION_TYPE, {
+  name: "item_get",
+  requestSerializer: TableKeysPacket,
+  responseSerializer: TableItemsPacket,
+  permissionId: TABLE_PERMISSION_ID
+});
+var TABLE_ITEM_HAS_ENDPOINT = EndpointType.createSerialized(TABLE_EXTENSION_TYPE, {
+  name: "item_has",
+  requestSerializer: TableKeysPacket,
+  responseSerializer: Serializer.json(),
+  permissionId: TABLE_PERMISSION_ID
+});
+var TABLE_ITEM_HAS_ALL_ENDPOINT = EndpointType.createSerialized(TABLE_EXTENSION_TYPE, {
+  name: "item_has_all",
+  requestSerializer: TableKeysPacket,
+  responseSerializer: Serializer.json(),
+  permissionId: TABLE_PERMISSION_ID
+});
+var TABLE_ITEM_HAS_ANY_ENDPOINT = EndpointType.createSerialized(TABLE_EXTENSION_TYPE, {
+  name: "item_has_any",
+  requestSerializer: TableKeysPacket,
+  responseSerializer: Serializer.json(),
+  permissionId: TABLE_PERMISSION_ID
+});
+var TABLE_FETCH_ENDPOINT = EndpointType.createSerialized(TABLE_EXTENSION_TYPE, {
+  name: "fetch",
+  requestSerializer: TableFetchPacket,
+  responseSerializer: TableItemsPacket,
+  permissionId: TABLE_PERMISSION_ID
+});
+var TABLE_FETCH_RANGE_ENDPOINT = EndpointType.createSerialized(TABLE_EXTENSION_TYPE, {
+  name: "fetch_range",
+  requestSerializer: TableFetchRangePacket,
+  responseSerializer: TableItemsPacket,
+  permissionId: TABLE_PERMISSION_ID
+});
+var TABLE_FETCH_ALL_ENDPOINT = EndpointType.createSerialized(TABLE_EXTENSION_TYPE, {
+  name: "fetch_all",
+  requestSerializer: TablePacket,
+  responseSerializer: TableItemsPacket,
+  permissionId: TABLE_PERMISSION_ID
+});
+var TABLE_SIZE_ENDPOINT = EndpointType.createSerialized(TABLE_EXTENSION_TYPE, {
+  name: "size",
+  requestSerializer: TablePacket,
+  responseSerializer: Serializer.json(),
+  permissionId: TABLE_PERMISSION_ID
+});
+var TABLE_ITEM_CLEAR_PACKET = PacketType.createSerialized(TABLE_EXTENSION_TYPE, {
+  name: "clear",
+  serializer: TablePacket
+});
+
+class TableExtension {
+  omu;
+  type = TABLE_EXTENSION_TYPE;
+  tableMap = new IdentifierMap;
+  constructor(omu) {
+    this.omu = omu;
+    omu.network.registerPacket(TABLE_SET_PERMISSION_PACKET, TABLE_SET_CONFIG_PACKET, TABLE_LISTEN_PACKET, TABLE_PROXY_LISTEN_PACKET, TABLE_PROXY_PACKET, TABLE_ITEM_ADD_PACKET, TABLE_ITEM_UPDATE_PACKET, TABLE_ITEM_REMOVE_PACKET, TABLE_ITEM_CLEAR_PACKET);
+  }
+  createTable(tableType) {
+    this.omu.permissions.require(TABLE_PERMISSION_ID);
+    if (this.has(tableType.id)) {
+      throw new Error("Table already exists");
+    }
+    const table = new TableImpl(this.omu, tableType);
+    this.tableMap.set(tableType.id, table);
+    return table;
+  }
+  json(name, options) {
+    const tableType = new TableType(this.omu.app.id.join(name), Serializer.pipe(options.serializer ?? Serializer.noop(), Serializer.json()), options.key);
+    return this.createTable(tableType);
+  }
+  serialized(name, options) {
+    const tableType = new TableType(this.omu.app.id.join(name), options.serializer, options.key);
+    return this.createTable(tableType);
+  }
+  get(type) {
+    if (this.has(type.id)) {
+      return this.tableMap.get(type.id);
+    }
+    return this.createTable(type);
+  }
+  has(identifier) {
+    return this.tableMap.has(identifier);
+  }
+}
+
+class TableImpl {
+  omu;
+  cache;
+  event;
+  promiseMap;
+  proxies;
+  id;
+  serializer;
+  keyFunction;
+  listening;
+  cacheSize;
+  config;
+  permissions;
+  constructor(omu, tableType) {
+    this.omu = omu;
+    this.id = tableType.id;
+    this.serializer = tableType.serializer;
+    this.keyFunction = tableType.keyFunction;
+    this.cache = new Map;
+    this.event = {
+      add: new EventEmitter,
+      update: new EventEmitter,
+      remove: new EventEmitter,
+      clear: new EventEmitter,
+      cacheUpdate: new EventEmitter
+    };
+    this.promiseMap = new Map;
+    this.proxies = [];
+    this.listening = false;
+    omu.network.addPacketHandler(TABLE_PROXY_PACKET, (packet) => {
+      if (!packet.id.isEqual(this.id)) {
+        return;
+      }
+      let items = this.deserializeItems(packet.items);
+      this.proxies.forEach((proxy) => {
+        items = new Map([...items.entries()].map(([key, item]) => {
+          const proxyItem = proxy(item);
+          if (proxyItem !== undefined) {
+            return [key, proxyItem];
+          }
+          return;
+        }).filter((item) => {
+          return typeof item !== "undefined";
+        }));
+      });
+      omu.send(TABLE_PROXY_PACKET, {
+        id: this.id,
+        key: packet.key,
+        items: Object.fromEntries([...items.entries()].map(([key, item]) => {
+          return [key, this.serializer.serialize(item)];
+        }))
+      });
+    });
+    omu.network.addPacketHandler(TABLE_ITEM_ADD_PACKET, (packet) => {
+      if (!packet.id.isEqual(this.id)) {
+        return;
+      }
+      const items = this.deserializeItems(packet.items);
+      this.updateCache(items);
+      this.event.add.emit(items);
+    });
+    omu.network.addPacketHandler(TABLE_ITEM_UPDATE_PACKET, (packet) => {
+      if (!packet.id.isEqual(this.id)) {
+        return;
+      }
+      const items = this.deserializeItems(packet.items);
+      this.updateCache(items);
+      this.event.update.emit(items);
+    });
+    omu.network.addPacketHandler(TABLE_ITEM_REMOVE_PACKET, (packet) => {
+      if (!packet.id.isEqual(this.id)) {
+        return;
+      }
+      const items = this.deserializeItems(packet.items);
+      items.forEach((_, key) => {
+        this.cache.delete(key);
+      });
+      this.event.remove.emit(items);
+      this.event.cacheUpdate.emit(this.cache);
+    });
+    omu.network.addPacketHandler(TABLE_ITEM_CLEAR_PACKET, (packet) => {
+      if (!packet.id.isEqual(this.id)) {
+        return;
+      }
+      this.cache = new Map;
+      this.event.clear.emit();
+      this.event.cacheUpdate.emit(this.cache);
+    });
+    omu.event.ready.listen(() => this.onReady());
+  }
+  updateCache(items) {
+    if (!this.cacheSize) {
+      this.cache = items;
+    } else {
+      const cache = new Map([...this.cache, ...items].slice(-this.cacheSize));
+      this.cache = cache;
+    }
+    this.event.cacheUpdate.emit(this.cache);
+  }
+  listen(listener) {
+    if (!this.listening) {
+      this.omu.onReady(() => {
+        this.omu.send(TABLE_LISTEN_PACKET, this.id);
+      });
+      this.listening = true;
+    }
+    if (listener) {
+      return this.event.cacheUpdate.listen(listener);
+    }
+    return () => {};
+  }
+  proxy(callback) {
+    if (this.proxies.length === 0) {
+      let cancel = () => {};
+      cancel = this.omu.onReady(() => {
+        if (this.proxies.length === 0) {
+          cancel();
+          return;
+        }
+        this.omu.send(TABLE_PROXY_LISTEN_PACKET, this.id);
+      });
+    }
+    this.proxies.push(callback);
+    return () => {
+      this.proxies.splice(this.proxies.indexOf(callback), 1);
+    };
+  }
+  onReady() {
+    if (this.config) {
+      this.omu.send(TABLE_SET_CONFIG_PACKET, {
+        id: this.id,
+        config: this.config
+      });
+    }
+  }
+  async get(key) {
+    if (this.cache.has(key)) {
+      return this.cache.get(key);
+    }
+    if (this.promiseMap.has(key)) {
+      return await this.promiseMap.get(key);
+    }
+    const promise = this.omu.endpoints.call(TABLE_ITEM_GET_ENDPOINT, {
+      id: this.id,
+      keys: [key]
+    }).then((res) => {
+      const items = this.deserializeItems(res.items);
+      this.updateCache(items);
+      return this.cache.get(key);
+    });
+    this.promiseMap.set(key, promise);
+    return await promise.then((item) => {
+      this.promiseMap.delete(key);
+      return item;
+    });
+  }
+  async getMany(...keys) {
+    const filteredKeys = keys.filter((key) => !this.cache.has(key)).filter((key) => !this.promiseMap.has(key));
+    if (filteredKeys.length === 0) {
+      return new Map([...this.cache].filter(([key]) => keys.includes(key)));
+    }
+    const promise = this.omu.endpoints.call(TABLE_ITEM_GET_ENDPOINT, {
+      id: this.id,
+      keys: filteredKeys
+    }).then((res) => {
+      const items2 = this.deserializeItems(res.items);
+      this.updateCache(items2);
+      return items2;
+    });
+    for (const key of filteredKeys) {
+      this.promiseMap.set(key, promise.then((items2) => items2.get(key)));
+    }
+    const items = await promise;
+    for (const key of filteredKeys) {
+      this.promiseMap.delete(key);
+    }
+    return new Map([...this.cache, ...items].filter(([key]) => keys.includes(key)));
+  }
+  async add(...items) {
+    const data = this.serializeItems(items);
+    this.omu.send(TABLE_ITEM_ADD_PACKET, {
+      id: this.id,
+      items: data
+    });
+  }
+  async update(...items) {
+    const data = this.serializeItems(items);
+    this.omu.send(TABLE_ITEM_UPDATE_PACKET, {
+      id: this.id,
+      items: data
+    });
+  }
+  async remove(...items) {
+    const data = this.serializeItems(items);
+    const keys = Object.keys(data);
+    this.cache = new Map([...this.cache].filter(([key]) => !keys.includes(key)));
+    this.omu.send(TABLE_ITEM_REMOVE_PACKET, {
+      id: this.id,
+      items: data
+    });
+  }
+  async clear() {
+    this.omu.send(TABLE_ITEM_CLEAR_PACKET, {
+      id: this.id
+    });
+  }
+  async has(key) {
+    if (this.cache.has(key)) {
+      return true;
+    }
+    const res = await this.omu.endpoints.call(TABLE_ITEM_HAS_ENDPOINT, {
+      id: this.id,
+      keys: [key]
+    });
+    return res[key] ?? false;
+  }
+  async hasMany(...keys) {
+    const res = await this.omu.endpoints.call(TABLE_ITEM_HAS_ENDPOINT, {
+      id: this.id,
+      keys
+    });
+    return res;
+  }
+  async hasAll(...keys) {
+    const res = await this.omu.endpoints.call(TABLE_ITEM_HAS_ALL_ENDPOINT, {
+      id: this.id,
+      keys
+    });
+    return res;
+  }
+  async hasAny(...keys) {
+    const res = await this.omu.endpoints.call(TABLE_ITEM_HAS_ANY_ENDPOINT, {
+      id: this.id,
+      keys
+    });
+    return res;
+  }
+  async fetchItems({
+    limit,
+    backward,
+    cursor
+  }) {
+    const res = await this.omu.endpoints.call(TABLE_FETCH_ENDPOINT, new TableFetchPacket(this.id, limit, backward, cursor));
+    const items = this.deserializeItems(res.items);
+    this.updateCache(items);
+    return items;
+  }
+  async fetchRange({
+    start,
+    end
+  }) {
+    const res = await this.omu.endpoints.call(TABLE_FETCH_RANGE_ENDPOINT, {
+      id: this.id,
+      start,
+      end
+    });
+    const items = this.deserializeItems(res.items);
+    this.updateCache(items);
+    return items;
+  }
+  async fetchAll() {
+    const res = await this.omu.endpoints.call(TABLE_FETCH_ALL_ENDPOINT, {
+      id: this.id
+    });
+    const items = this.deserializeItems(res.items);
+    this.updateCache(items);
+    return items;
+  }
+  async* iterate({
+    backward,
+    cursor
+  }) {
+    while (true) {
+      const items = await this.fetchItems({
+        limit: this.cacheSize ?? 100,
+        backward,
+        cursor
+      });
+      if (items.size === 0) {
+        break;
+      }
+      yield* items.values();
+      if (cursor !== undefined) {
+        items.delete(cursor);
+      }
+      const cursorItem = backward ? items.values().next().value : [...items.values()].pop();
+      if (!cursorItem) {
+        break;
+      }
+      cursor = this.keyFunction(cursorItem);
+    }
+  }
+  async size() {
+    return await this.omu.endpoints.call(TABLE_SIZE_ENDPOINT, {
+      id: this.id
+    });
+  }
+  deserializeItems(items) {
+    return new Map(Object.entries(items).map(([key, data]) => {
+      const item = this.serializer.deserialize(data);
+      this.cache.set(key, item);
+      return [key, item];
+    }));
+  }
+  serializeItems(items) {
+    return Object.fromEntries(items.map((item) => {
+      return [this.keyFunction(item), this.serializer.serialize(item)];
+    }));
+  }
+  setCacheSize(size) {
+    this.cacheSize = size;
+  }
+  setConfig(config) {
+    if (this.omu.running) {
+      throw new Error("Cannot set config after client has started");
+    }
+    this.config = config;
+  }
+  setPermissions(permissions) {
+    this.permissions = permissions;
+  }
+}
+// src/api/server/extension.ts
+var SERVER_EXTENSION_TYPE = new ExtensionType("server", (omu) => new ServerExtension(omu));
+var SERVER_APPS_READ_PERMISSION_ID = SERVER_EXTENSION_TYPE.join("apps", "read");
+var SERVER_APPS_WRITE_PERMISSION_ID = SERVER_EXTENSION_TYPE.join("apps", "write");
+var SERVER_INDEX_READ_PERMISSION_ID = SERVER_EXTENSION_TYPE.join("index", "read");
+var SERVER_INDEX_REGISTRY_TYPE = RegistryType.createJson(SERVER_EXTENSION_TYPE, {
+  name: "index",
+  defaultValue: { indexes: {} },
+  permissions: {
+    write: SERVER_APPS_WRITE_PERMISSION_ID,
+    read: SERVER_INDEX_READ_PERMISSION_ID
+  }
+});
+var APP_TABLE_TYPE = TableType.createJson(SERVER_EXTENSION_TYPE, {
+  name: "apps",
+  serializer: App,
+  key: (app) => app.id.key(),
+  permissions: {
+    all: SERVER_APPS_WRITE_PERMISSION_ID,
+    read: SERVER_APPS_READ_PERMISSION_ID
+  }
+});
+var SERVER_SHUTDOWN_PERMISSION_ID = SERVER_EXTENSION_TYPE.join("shutdown");
+var SHUTDOWN_ENDPOINT_TYPE = EndpointType.createJson(SERVER_EXTENSION_TYPE, {
+  name: "shutdown",
+  permissionId: SERVER_SHUTDOWN_PERMISSION_ID
+});
+var TRUSTED_ORIGINS_GET_PERMISSION_ID = SERVER_EXTENSION_TYPE.join("trusted_origins", "get");
+var TRUSTED_ORIGINS_SET_PERMISSION_ID = SERVER_EXTENSION_TYPE.join("trusted_origins", "set");
+var TRUSTED_HOSTS_REGISTRY_TYPE = RegistryType.createJson(SERVER_EXTENSION_TYPE, {
+  name: "trusted_hosts",
+  defaultValue: {},
+  permissions: {
+    read: TRUSTED_ORIGINS_GET_PERMISSION_ID,
+    write: TRUSTED_ORIGINS_SET_PERMISSION_ID
+  }
+});
+
+class ServerExtension {
+  omu;
+  type = SERVER_EXTENSION_TYPE;
+  apps;
+  index;
+  trustedHosts;
+  constructor(omu) {
+    this.omu = omu;
+    this.apps = omu.tables.get(APP_TABLE_TYPE);
+    this.index = omu.registries.get(SERVER_INDEX_REGISTRY_TYPE);
+    this.trustedHosts = omu.registries.get(TRUSTED_HOSTS_REGISTRY_TYPE);
+  }
+  async shutdown(restart) {
+    this.omu.endpoints.call(SHUTDOWN_ENDPOINT_TYPE, restart ?? false);
+    await new Promise((resolve) => {
+      const unlisten = this.omu.network.event.disconnected.listen(() => {
+        resolve();
+        unlisten();
+      });
+    });
+    return true;
+  }
+}
+
+class SessionObserver {
+  onConnectCallbacks;
+  onDisconnectCallbacks;
+  constructor(onConnectCallbacks, onDisconnectCallbacks) {
+    this.onConnectCallbacks = onConnectCallbacks;
+    this.onDisconnectCallbacks = onDisconnectCallbacks;
+  }
+  onConnect(callback) {
+    this.onConnectCallbacks.push(callback);
+  }
+  onDisconnect(callback) {
+    this.onDisconnectCallbacks.push(callback);
+  }
+}
+
+// src/api/session/extension.ts
+var SESSION_EXTENSION_TYPE = new ExtensionType("sessions", (omu) => new SessionExtension(omu));
+var SESSIONS_READ_PERMISSION_ID = SESSION_EXTENSION_TYPE.join("read");
+var SESSION_TABLE_TYPE = TableType.createJson(SESSION_EXTENSION_TYPE, {
+  name: "sessions",
+  serializer: App,
+  key: (app) => app.id.key(),
+  permissions: {
+    read: SESSIONS_READ_PERMISSION_ID
+  }
+});
+var REQUIRE_APPS_PACKET_TYPE = PacketType.createJson(SESSION_EXTENSION_TYPE, {
+  name: "require",
+  serializer: Serializer.of(Identifier).toArray()
+});
+var SESSION_OBSERVE_PACKET_TYPE = PacketType.createJson(SESSION_EXTENSION_TYPE, {
+  name: "observe",
+  serializer: Serializer.of(Identifier).toArray()
+});
+var SESSION_CONNECTED_PACKET_TYPE = PacketType.createJson(SESSION_EXTENSION_TYPE, {
+  name: "session_connected",
+  serializer: App
+});
+var SESSION_DISCONNECTED_PACKET_TYPE = PacketType.createJson(SESSION_EXTENSION_TYPE, {
+  name: "session_disconnected",
+  serializer: App
+});
+var REMOTE_APP_REQUEST_PERMISSION_ID = SESSION_EXTENSION_TYPE.join("remote_app", "request");
+var REMOTE_APP_REQUEST_ENDPOINT_TYPE = EndpointType.createJson(SESSION_EXTENSION_TYPE, {
+  name: "remote_app_request",
+  permissionId: REMOTE_APP_REQUEST_PERMISSION_ID
+});
+var GENERATE_TOKEN_PERMISSION_ID = SESSION_EXTENSION_TYPE.join("generate_token");
+var GENERATE_TOKEN_ENDPOINT_TYPE = EndpointType.createJson(SESSION_EXTENSION_TYPE, {
+  name: "generate_token",
+  permissionId: GENERATE_TOKEN_PERMISSION_ID
+});
+
+class SessionExtension {
+  omu;
+  type = SESSION_EXTENSION_TYPE;
+  sessions;
+  sessionObservers = new IdentifierMap;
+  requiredApps = new IdentifierSet;
+  constructor(omu) {
+    this.omu = omu;
+    omu.network.registerPacket(REQUIRE_APPS_PACKET_TYPE, SESSION_OBSERVE_PACKET_TYPE, SESSION_CONNECTED_PACKET_TYPE, SESSION_DISCONNECTED_PACKET_TYPE);
+    omu.network.addPacketHandler(SESSION_CONNECTED_PACKET_TYPE, (app) => this.handleSessionConnect(app));
+    omu.network.addPacketHandler(SESSION_DISCONNECTED_PACKET_TYPE, (app) => this.handleSessionDisconnect(app));
+    this.sessions = omu.tables.get(SESSION_TABLE_TYPE);
+    omu.network.addTask(() => this.onTask());
+    omu.onReady(() => this.onReady());
+  }
+  async has(id) {
+    return await this.sessions.has(Identifier.from(id).key());
+  }
+  observe(appId, {
+    onConnect,
+    onDisconnect
+  }) {
+    const id = Identifier.from(appId);
+    if (this.omu.running) {
+      this.omu.send(SESSION_OBSERVE_PACKET_TYPE, [id]);
+    }
+    const observer = this.sessionObservers.get(id) ?? new SessionObserver([], []);
+    observer.onConnect(onConnect);
+    observer.onDisconnect(onDisconnect);
+    this.sessionObservers.set(id, observer);
+    return observer;
+  }
+  async handleSessionConnect(app) {
+    const observer = this.sessionObservers.get(app.id);
+    if (!observer) {
+      return;
+    }
+    for (const callback of observer.onConnectCallbacks) {
+      await callback(app);
+    }
+  }
+  async handleSessionDisconnect(app) {
+    const observer = this.sessionObservers.get(app.id);
+    if (!observer) {
+      return;
+    }
+    for (const callback of observer.onDisconnectCallbacks) {
+      await callback(app);
+    }
+  }
+  require(...appIds) {
+    if (this.omu.running) {
+      throw new Error("Cannot require apps after the client has started");
+    }
+    for (const appId of appIds) {
+      this.requiredApps.add(Identifier.from(appId));
+    }
+  }
+  async onTask() {
+    if (this.requiredApps.size > 0) {
+      this.omu.send(REQUIRE_APPS_PACKET_TYPE, Array.from(this.requiredApps.values()));
+    }
+  }
+  async onReady() {
+    if (this.sessionObservers.size > 0) {
+      this.omu.send(SESSION_OBSERVE_PACKET_TYPE, Array.from(this.sessionObservers.keys()));
+    }
+  }
+  async requestRemoteApp(options) {
+    const { app } = options;
+    if (!app.url) {
+      throw new Error("App must have a URL to request it remotely");
+    }
+    if (app.type !== "remote") {
+      throw new Error("App must be a remote app to request it remotely");
+    }
+    if (!app.metadata) {
+      throw new Error("App must have metadata to request it remotely");
+    }
+    return this.omu.endpoints.call(REMOTE_APP_REQUEST_ENDPOINT_TYPE, {
+      app: App.serialize(options.app),
+      permissions: options.permissions.map((id) => Identifier.from(id).key())
+    });
+  }
+  async generateToken(options) {
+    return this.omu.endpoints.call(GENERATE_TOKEN_ENDPOINT_TYPE, {
+      app: App.serialize(options.app),
+      permissions: options.permissions.map((id) => Identifier.from(id).key())
+    });
+  }
+}
+export {
+  SessionExtension,
+  SESSION_EXTENSION_TYPE,
+  SESSIONS_READ_PERMISSION_ID,
+  REMOTE_APP_REQUEST_PERMISSION_ID,
+  GENERATE_TOKEN_PERMISSION_ID
+};
+
+//# debugId=A3B60CEE774E7BF364756E2164756E21
+//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../../src/identifier.ts", "../../src/app.ts", "../../src/const.ts", "../../src/serialize/serializer.ts", "../../src/serialize/bytebuffer.ts", "../../src/network/packet/packet.ts", "../../src/network/packet/packet-types.ts", "../../src/api/endpoint/endpoint.ts", "../../src/api/extension.ts", "../../src/event/index.ts", "../../src/lock.ts", "../../src/api/registry/packets.ts", "../../src/api/registry/registry.ts", "../../src/api/registry/extension.ts", "../../src/api/table/packets.ts", "../../src/api/table/table.ts", "../../src/api/table/extension.ts", "../../src/api/server/extension.ts", "../../src/api/session/extension.ts"],
  "sourcesContent": [
    "import type { ExtensionType } from './api';\nimport { App } from './app';\n\nconst NAMESPACE_REGEX = /^(\\.[^/:.]|[\\w-])+$/;\nconst NAME_REGEX = /^[^/:]+$/;\n\nexport type IntoId = Identifier | string | ExtensionType | App;\n\nexport class Identifier {\n    public readonly namespace: string;\n    public readonly path: string[];\n\n    constructor(\n        namespace: string,\n        ...path: string[]\n    ) {\n        Identifier.validate(namespace, path);\n        this.namespace = namespace;\n        this.path = path;\n    }\n\n    public static serialize(identifier: Identifier): string {\n        return identifier.key();\n    }\n\n    public static deserialize(json: string): Identifier {\n        return Identifier.fromJson(json);\n    }\n\n    public static from(id: IntoId): Identifier {\n        if (id instanceof Identifier) {\n            return id;\n        } else if (id instanceof App) {\n            return id.id;\n        } else if (typeof id === 'string') {\n            return Identifier.fromKey(id);\n        } else {\n            // Try to infer\n            // Vite does not preserve class information when importing from different packages\n            const idCasted = id as { namespace: string; path: string[] };\n            if (\n                typeof idCasted.namespace === 'string' &&\n                Array.isArray(idCasted.path) &&\n                idCasted.path.every((p) => typeof p === 'string')\n            ) {\n                return new Identifier(idCasted.namespace, ...idCasted.path);\n            }\n            const idWithId = id as { id: IntoId | undefined };\n            if (typeof idWithId.id !== 'undefined') {\n                return Identifier.from(idWithId.id);\n            }\n            throw new Error(`Cannot convert to Identifier: ${id}`);\n        }\n    }\n\n    public static fromOptional(id: IntoId | undefined | null): Identifier | undefined {\n        if (id === undefined || id === null) {\n            return undefined;\n        }\n        return Identifier.from(id);\n    }\n\n    static validate(namespace: string, path: string[]): void {\n        if (!namespace) {\n            throw new Error('Invalid namespace: Namespace cannot be empty');\n        }\n        if (path.length === 0) {\n            throw new Error('Invalid path: Path must have at least one name');\n        }\n        if (!NAMESPACE_REGEX.test(namespace)) {\n            throw new Error(`Invalid namespace: Namespace must match ${NAMESPACE_REGEX}`);\n        }\n        for (const name of path) {\n            if (!NAME_REGEX.test(name)) {\n                throw new Error(`Invalid path: Name must match ${NAME_REGEX} but got ${name}`);\n            }\n        }\n    }\n\n    static format(namespace: string, ...path: string[]): string {\n        Identifier.validate(namespace, path);\n        return `${namespace}:${path.join('/')}`;\n    }\n\n    static fromKey(key: string): Identifier {\n        const separator = key.indexOf(':');\n        if (separator === -1) {\n            throw new Error(`Invalid key: No separator found in ${key}`);\n        }\n        if (key.indexOf(':', separator + 1) !== -1) {\n            throw new Error(`Invalid key: Multiple separators found in ${key}`);\n        }\n        const namespace = key.slice(0, separator);\n        const path = key.slice(separator + 1);\n        if (!namespace || !path) {\n            throw new Error('Invalid key: Namespace and path cannot be empty');\n        }\n        return new Identifier(namespace, ...path.split('/'));\n    }\n\n    public static fromUrl(url: string | URL): Identifier {\n        const parsedUrl = new URL(url);\n        const namespace = Identifier.namespaceFromUrl(parsedUrl.href);\n        const path = parsedUrl.pathname.slice(1).split('/');\n        return new Identifier(namespace, ...path);\n    }\n\n    public static namespaceFromUrl(url: string | URL): string {\n        const parsed = new URL(url);\n        return parsed.hostname.split('.').reverse().join('.');\n    }\n\n    public toJson(): string {\n        return this.key();\n    }\n\n    static fromJson(json: string): Identifier {\n        return Identifier.fromKey(json);\n    }\n\n    public key(): string {\n        return Identifier.format(this.namespace, ...this.path);\n    }\n\n    public isEqual(other: Identifier): boolean {\n        return this.key() === other.key();\n    }\n\n    public isNamespaceEqual(other: Identifier): boolean {\n        return this.namespace === other.namespace;\n    }\n\n    public isSubpathOf(other: Identifier): boolean {\n        if (this.namespace !== other.namespace) {\n            return false;\n        }\n        if (this.path.length < other.path.length) {\n            return false;\n        }\n        for (let i = 0; i < other.path.length; i++) {\n            if (this.path[i] !== other.path[i]) {\n                return false;\n            }\n        }\n        return true;\n    }\n\n    public join(...path: string[]): Identifier {\n        return new Identifier(this.namespace, ...this.path, ...path);\n    }\n}\n\nexport class IdentifierMap<T> {\n    private readonly map: Map<string, T> = new Map();\n    constructor(\n        entries?: Iterable<[Identifier, T]>,\n    ) {\n        if (!entries) return;\n        for (const [id, value] of entries) {\n            this.map.set(id.key(), value);\n        }\n    }\n\n    public get size(): number {\n        return this.map.size;\n    }\n\n    public set(identifier: Identifier, value: T): void {\n        this.map.set(identifier.key(), value);\n    }\n\n    public get(identifier: Identifier): T | undefined {\n        return this.map.get(identifier.key());\n    }\n\n    public has(identifier: Identifier): boolean {\n        return this.map.has(identifier.key());\n    }\n\n    public delete(identifier: Identifier): void {\n        this.map.delete(identifier.key());\n    }\n\n    public clear(): void {\n        this.map.clear();\n    }\n\n    public *keys(): IterableIterator<Identifier> {\n        for (const key of this.map.keys()) {\n            yield Identifier.fromKey(key);\n        }\n    }\n\n    public values(): IterableIterator<T> {\n        return this.map.values();\n    }\n\n    public *entries(): IterableIterator<[Identifier, T]> {\n        for (const [key, value] of this.map.entries()) {\n            yield [Identifier.fromKey(key), value];\n        }\n    }\n\n    public [Symbol.iterator](): IterableIterator<[Identifier, T]> {\n        return this.entries();\n    }\n}\n\nexport class IdentifierSet {\n    private readonly set: Set<string> = new Set();\n\n    public get size(): number {\n        return this.set.size;\n    }\n\n    public add(identifier: Identifier): void {\n        this.set.add(identifier.key());\n    }\n\n    public has(identifier: Identifier): boolean {\n        return this.set.has(identifier.key());\n    }\n\n    public delete(identifier: Identifier): void {\n        this.set.delete(identifier.key());\n    }\n\n    public clear(): void {\n        this.set.clear();\n    }\n\n    public *keys(): IterableIterator<Identifier> {\n        for (const key of this.set.keys()) {\n            yield Identifier.fromKey(key);\n        }\n    }\n\n    public values(): IterableIterator<Identifier> {\n        return this.keys();\n    }\n\n    public *entries(): IterableIterator<[Identifier, Identifier]> {\n        for (const key of this.set.keys()) {\n            const identifier = Identifier.fromKey(key);\n            yield [identifier, identifier];\n        }\n    }\n\n    public [Symbol.iterator](): IterableIterator<[Identifier, Identifier]> {\n        return this.entries();\n    }\n}\n",
    "import { Identifier, IntoId } from './identifier';\nimport type { Locale } from './localization/locale.js';\nimport type { LocalizedText } from './localization/localization.js';\n\nexport type AppMetadata = {\n    locale: Locale;\n    name?: LocalizedText;\n    icon?: LocalizedText;\n    description?: LocalizedText;\n    image?: LocalizedText;\n    site?: LocalizedText;\n    repository?: LocalizedText;\n    authors?: LocalizedText;\n    license?: LocalizedText;\n    tags?: string[];\n};\n\nexport type AppType = 'app' | 'service' | 'remote' | 'plugin' | 'dashboard';\n\nexport type DependencySpecifier = {\n    version: string;\n    index?: string;\n};\n\nexport type AppJson = {\n    id: string;\n    type: AppType;\n    parent_id?: string;\n    version?: string;\n    url?: string;\n    metadata?: AppMetadata;\n    dependencies?: Record<string, DependencySpecifier | string>;\n};\n\nexport class App {\n    public readonly id: Identifier;\n    public readonly type: AppType;\n    public readonly parentId?: Identifier;\n    public readonly version?: string;\n    public readonly url?: string;\n    public readonly metadata?: AppMetadata;\n    public readonly dependencies: Record<string, DependencySpecifier | string>;\n\n    constructor(id: IntoId, options: {\n        type?: AppType;\n        parentId?: IntoId;\n        version?: string;\n        url?: string;\n        metadata?: AppMetadata;\n        dependencies?: Record<string, DependencySpecifier | string>;\n    }) {\n        this.id = Identifier.from(id);\n        this.parentId = Identifier.fromOptional(options.parentId);\n        this.version = options.version;\n        this.url = options.url;\n        this.metadata = options.metadata;\n        this.type = options.type ?? 'app';\n        this.dependencies = options.dependencies ?? {};\n    }\n\n    public static deserialize(info: AppJson): App {\n        const id = Identifier.fromKey(info.id);\n        return new App(id, {\n            parentId: Identifier.fromOptional(info.parent_id),\n            version: info.version,\n            url: info.url,\n            type: info.type,\n            metadata: info.metadata,\n            dependencies: info.dependencies ?? {},\n        });\n    }\n\n    public static serialize(data: App): AppJson {\n        return {\n            id: data.id.key(),\n            type: data.type,\n            parent_id: data.parentId?.key(),\n            version: data.version,\n            url: data.url,\n            metadata: data.metadata,\n            dependencies: data.dependencies,\n        };\n    }\n\n    public join(...paths: string[]): App {\n        return new App(this.id.join(...paths), {\n            parentId: this.parentId,\n            version: this.version,\n            url: this.url,\n            type: this.type,\n            metadata: this.metadata,\n            dependencies: this.dependencies,\n        });\n    }\n}\n",
    "export const textEncoder: TextEncoder = new TextEncoder();\nexport const textDecoder: TextDecoder = new TextDecoder();\n",
    "import { textDecoder, textEncoder } from '../const.js';\n\nexport type JsonType = string | number | boolean | null | undefined | { [key in never]?: JsonType } | JsonType[];\n\nexport interface Serializable<T, D> {\n    serialize(data: T): D;\n    deserialize(data: D): T;\n}\n\nexport class Serializer<T, D> {\n    constructor(\n        public serialize: (data: T) => D,\n        public deserialize: (data: D) => T,\n    ) { }\n\n    public static of<T, D>(serializer: Serializable<T, D>): Serializer<T, D> {\n        return new Serializer<T, D>(serializer.serialize, serializer.deserialize);\n    }\n\n    public static pipe<T, R, D>(ser1: Serializable<T, R>, ser2: Serializable<R, D>): Serializable<T, D> {\n        return new Serializer<T, D>(\n            (data) => ser2.serialize(ser1.serialize(data)),\n            (data) => ser1.deserialize(ser2.deserialize(data)),\n        );\n    }\n\n    public static transform<T>(func: (value: T) => T): Serializer<T, T> {\n        return new Serializer<T, T>(\n            func,\n            func,\n        );\n    }\n\n    public static noop<T>(): Serializer<T, T> {\n        return new Serializer<T, T>(\n            (data) => data,\n            (data) => data,\n        );\n    }\n\n    public field<\n        K extends keyof D,\n        R,\n    >(\n        key: K,\n        serializer: Serializable<D[K], R>,\n    ): Serializer<\n        T,\n        { [P in keyof D]: P extends K ? R : D[P] }\n    > {\n        return new Serializer<\n            T,\n            { [P in keyof D]: P extends K ? R : D[P] }\n        >(\n            (data) => {\n                const serialized = this.serialize(data);\n                return {\n                    ...serialized,\n                    [key]: serializer.serialize(serialized[key]),\n                } as { [P in keyof D]: P extends K ? R : D[P] };\n            },\n            (data) => {\n                return this.deserialize({\n                    ...data,\n                    [key]: serializer.deserialize(data[key] as R),\n                } as D);\n            },\n        );\n    }\n\n    static json<T extends JsonType>(): Serializer<T, Uint8Array> {\n        return new Serializer<T, Uint8Array>(\n            (data) => textEncoder.encode(JSON.stringify(data)),\n            (data) => {\n                const text = textDecoder.decode(data);\n                return JSON.parse(text);\n            },\n        );\n    }\n\n    public toJson(): Serializer<T, Uint8Array> {\n        return new Serializer<T, Uint8Array>(\n            (data) => textEncoder.encode(JSON.stringify(this.serialize(data))),\n            (data) => {\n                const text = textDecoder.decode(data);\n                return this.deserialize(JSON.parse(text));\n            },\n        );\n    }\n\n    public toArray(): Serializer<T[], D[]> {\n        return new Serializer<T[], D[]>(\n            (data) => data.map((item) => this.serialize(item)),\n            (data) => data.map((item) => this.deserialize(item)),\n        );\n    }\n\n    public toMap(): Serializer<Map<string, T>, Map<string, D>> {\n        return new Serializer<Map<string, T>, Map<string, D>>(\n            (data) => {\n                const result = new Map<string, D>();\n                data.forEach((value, key) => {\n                    result.set(key, this.serialize(value));\n                });\n                return result;\n            },\n            (data) => {\n                const result = new Map<string, T>();\n                data.forEach((value, key) => {\n                    result.set(key, this.deserialize(value));\n                });\n                return result;\n            },\n        );\n    }\n\n    public fallback(fallback: T): Serializer<T, D> {\n        return new Serializer<T, D>(\n            (data) => this.serialize(data),\n            (data) => {\n                try {\n                    return this.deserialize(data);\n                } catch {\n                    return fallback;\n                }\n            },\n        );\n    }\n\n    public fallbackMap(fallback: (data: D, error: unknown) => T): Serializer<T, D> {\n        return new Serializer<T, D>(\n            (data) => this.serialize(data),\n            (data) => {\n                try {\n                    return this.deserialize(data);\n                } catch (error) {\n                    return fallback(data, error);\n                }\n            },\n        );\n    }\n\n    public pipe<E>(serializer: Serializable<D, E>): Serializer<T, E> {\n        return new Serializer<T, E>(\n            (data) => serializer.serialize(this.serialize(data)),\n            (data) => this.deserialize(serializer.deserialize(data)),\n        );\n    }\n}\n",
    "import { textDecoder, textEncoder } from '../const.js';\nimport { JsonType } from './serializer.js';\n\nexport class Flags {\n    private value: number;\n    private length: number;\n\n    constructor(options: { value?: number; length?: number }) {\n        this.value = options.value ?? 0;\n        this.length = options.length ?? 32;\n    }\n\n    public has(position: number): boolean {\n        return (this.value & (1 << position)) !== 0;\n    }\n\n    public get(position: number): boolean {\n        return (this.value & (1 << position)) !== 0;\n    }\n\n    public ifSet<T>(position: number, callback: () => T): T | undefined {\n        if (this.has(position)) {\n            return callback();\n        }\n        return undefined;\n    }\n\n    public set(position: number, value: boolean): void {\n        if (value) {\n            this.value |= 1 << position;\n        } else {\n            this.value &= ~(1 << position);\n        }\n    }\n\n    public write(writer: ByteWriter): void {\n        const bits = new Uint8Array((this.length + 7) / 8);\n        for (let i = 0; i < bits.length; i++) {\n            bits[i] = (this.value >> (i * 8)) & 0xff;\n        }\n        writer.write(bits);\n    }\n\n    public static read(reader: ByteReader, length: number): Flags {\n        let value = 0;\n        for (let i = 0; i < (length + 7) / 8; i++) {\n            value |= reader.readUint8() << (i * 8);\n        }\n        return new Flags({ value, length });\n    }\n}\n\nfunction readFloat16(dataView: DataView, offset: number): number {\n    const sign = (dataView.getUint16(offset) & 0x8000) ? -1 : 1;\n    const exponent = (dataView.getUint16(offset) & 0x7c00) >> 10;\n    const mantissa = (dataView.getUint16(offset) & 0x03ff);\n    if (exponent === 0 && mantissa === 0) {\n        return 0;\n    } else if (exponent === 0x1f) {\n        return mantissa === 0 ? Infinity * sign : NaN;\n    } else {\n        const normalizedExponent = exponent - 15;\n        const normalizedMantissa = mantissa / 1024;\n        return sign * Math.pow(2, normalizedExponent) * (1 + normalizedMantissa);\n    }\n}\n\nfunction writeFloat16(dataView: DataView, offset: number, value: number): void {\n    if (value === 0) {\n        dataView.setUint16(offset, 0);\n        return;\n    }\n    const sign = value < 0 ? 1 : 0;\n    value = Math.abs(value);\n    if (!isFinite(value)) {\n        dataView.setUint16(offset, 0x7c00 | (sign << 15));\n        return;\n    }\n    const exponent = Math.floor(Math.log2(value));\n    const mantissa = value / Math.pow(2, exponent) - 1;\n    const normalizedExponent = exponent + 15;\n    const normalizedMantissa = Math.round(mantissa * 1024);\n    if (normalizedExponent <= 0) {\n        dataView.setUint16(offset, sign << 15);\n    } else if (normalizedExponent >= 0x1f) {\n        dataView.setUint16(offset, 0x7c00 | (sign << 15));\n    } else {\n        dataView.setUint16(offset, (sign << 15) | (normalizedExponent << 10) | normalizedMantissa);\n    }\n}\n\nexport class ByteWriter {\n    private dataView: DataView;\n    private buffer: ArrayBuffer;\n    private offset = 0;\n    private finished = false;\n\n    constructor(init?: ArrayBuffer, offset?: number) {\n        this.offset = offset ?? 0;\n        this.buffer = init ?? new ArrayBuffer(1024);\n        this.dataView = new DataView(this.buffer);\n    }\n\n    public static fromUint8Array(buffer: Uint8Array): ByteWriter {\n        const arrayBuffer = new ArrayBuffer(buffer.byteLength);\n        const uint8Array = new Uint8Array(arrayBuffer);\n        uint8Array.set(new Uint8Array(buffer));\n        return new ByteWriter(arrayBuffer, buffer.byteLength);\n    }\n\n    private allocate(length: number): void {\n        if (this.offset + length > this.buffer.byteLength) {\n            const newByteLength = Math.max(this.buffer.byteLength * 2, this.offset + length);\n            const newBuffer = new ArrayBuffer(newByteLength);\n            new Uint8Array(newBuffer).set(new Uint8Array(this.buffer));\n            this.buffer = newBuffer;\n            this.dataView = new DataView(this.buffer);\n        }\n    }\n\n    public write(data: Uint8Array): ByteWriter {\n        if (this.finished) {\n            throw new Error('Buffer already finished');\n        }\n        this.allocate(data.length);\n        new Uint8Array(this.buffer).set(data, this.offset);\n        this.offset += data.length;\n        return this;\n    }\n\n    public writeBoolean(value: boolean): ByteWriter {\n        this.allocate(1);\n        this.dataView.setInt8(this.offset, value ? 1 : 0);\n        this.offset += 1;\n        return this;\n    }\n\n    public writeInt8(value: number): ByteWriter {\n        this.allocate(1);\n        this.dataView.setInt8(this.offset, value);\n        this.offset += 1;\n        return this;\n    }\n\n    public writeUint8(value: number): ByteWriter {\n        this.allocate(1);\n        this.dataView.setUint8(this.offset, value);\n        this.offset += 1;\n        return this;\n    }\n\n    public writeInt16(value: number): ByteWriter {\n        this.allocate(2);\n        this.dataView.setInt16(this.offset, value);\n        this.offset += 2;\n        return this;\n    }\n\n    public writeUint16(value: number): ByteWriter {\n        this.allocate(2);\n        this.dataView.setUint16(this.offset, value);\n        this.offset += 2;\n        return this;\n    }\n\n    public writeInt32(value: number): ByteWriter {\n        this.allocate(4);\n        this.dataView.setInt32(this.offset, value);\n        this.offset += 4;\n        return this;\n    }\n\n    public writeUint32(value: number): ByteWriter {\n        this.allocate(4);\n        this.dataView.setUint32(this.offset, value);\n        this.offset += 4;\n        return this;\n    }\n\n    public writeInt64(value: bigint): ByteWriter {\n        this.allocate(8);\n        this.dataView.setBigInt64(this.offset, value);\n        this.offset += 8;\n        return this;\n    }\n\n    public writeUint64(value: bigint): ByteWriter {\n        this.allocate(8);\n        this.dataView.setBigUint64(this.offset, value);\n        this.offset += 8;\n        return this;\n    }\n\n    public writeULEB128(value: number): ByteWriter {\n        // Unsigned LEB128\n        if (value < 0) {\n            throw new Error('Value must be non-negative');\n        }\n        while (value > 0x7f) {\n            this.allocate(1);\n            this.dataView.setUint8(this.offset, (value & 0x7f) | 0x80);\n            this.offset += 1;\n            value >>= 7;\n        }\n        this.allocate(1);\n        this.dataView.setUint8(this.offset, value & 0x7f);\n        this.offset += 1;\n        return this;\n    }\n\n    public writeFloat16(value: number): ByteWriter {\n        this.allocate(2);\n        writeFloat16(this.dataView, this.offset, value);\n        this.offset += 2;\n        return this;\n    }\n\n    public writeFloat32(value: number): ByteWriter {\n        this.allocate(4);\n        this.dataView.setFloat32(this.offset, value);\n        this.offset += 4;\n        return this;\n    }\n\n    public writeFloat64(value: number): ByteWriter {\n        this.allocate(4);\n        this.dataView.setFloat64(this.offset, value);\n        this.offset += 4;\n        return this;\n    }\n\n    public writeUint8Array(value: Uint8Array): ByteWriter {\n        this.writeULEB128(value.byteLength);\n        this.write(value);\n        return this;\n    }\n\n    public writeString(value: string): ByteWriter {\n        this.writeUint8Array(textEncoder.encode(value));\n        return this;\n    }\n\n    public writeJSON(value: JsonType): ByteWriter {\n        this.writeString(JSON.stringify(value));\n        return this;\n    }\n\n    public writeFlags(flags: Flags): ByteWriter {\n        flags.write(this);\n        return this;\n    }\n\n    public finish(): Uint8Array {\n        if (this.finished) {\n            throw new Error('Buffer already finished');\n        }\n        this.finished = true;\n        return new Uint8Array(this.buffer, 0, this.offset);\n    }\n}\n\nexport class ByteReader {\n    private dataView: DataView;\n    private offset: number;\n    private finished: boolean;\n\n    private constructor(data: DataView) {\n        this.dataView = data;\n        this.offset = 0;\n        this.finished = false;\n    }\n\n    public static fromUint8Array(buffer: Uint8Array): ByteReader {\n        const arrayBuffer = new ArrayBuffer(buffer.byteLength);\n        const uint8Array = new Uint8Array(arrayBuffer);\n        uint8Array.set(new Uint8Array(buffer));\n        const dataView = new DataView(arrayBuffer);\n        return new ByteReader(dataView);\n    }\n\n    public static fromArrayBuffer(buffer: ArrayBuffer): ByteReader {\n        const dataView = new DataView(buffer);\n        return new ByteReader(dataView);\n    }\n\n    public static async fromBlob(blob: Blob): Promise<ByteReader> {\n        const arrayBuffer = await blob.arrayBuffer();\n        const dataView = new DataView(arrayBuffer);\n        return new ByteReader(dataView);\n    }\n\n    public read(size: number): Uint8Array {\n        if (this.finished) {\n            throw new Error('Buffer already finished');\n        }\n        if (size < 0) {\n            throw new Error('Size must be positive');\n        }\n        if (this.offset + size > this.dataView.byteLength) {\n            throw new Error('Buffer not fully read');\n        }\n        const value = new Uint8Array(this.dataView.buffer, this.offset, size);\n        this.offset += size;\n        return value;\n    }\n\n    public readBoolean(): boolean {\n        const value = this.dataView.getInt8(this.offset);\n        this.offset += 1;\n        return value !== 0;\n    }\n\n    public readInt8(): number {\n        const value = this.dataView.getInt8(this.offset);\n        this.offset += 1;\n        return value;\n    }\n\n    public readUint8(): number {\n        const value = this.dataView.getUint8(this.offset);\n        this.offset += 1;\n        return value;\n    }\n\n    public readInt16(): number {\n        const value = this.dataView.getInt16(this.offset);\n        this.offset += 2;\n        return value;\n    }\n\n    public readUint16(): number {\n        const value = this.dataView.getUint16(this.offset);\n        this.offset += 2;\n        return value;\n    }\n\n    public readInt32(): number {\n        const value = this.dataView.getInt32(this.offset);\n        this.offset += 4;\n        return value;\n    }\n\n    public readUint32(): number {\n        const value = this.dataView.getUint32(this.offset);\n        this.offset += 4;\n        return value;\n    }\n\n    public readInt64(): bigint {\n        const value = this.dataView.getBigInt64(this.offset);\n        this.offset += 8;\n        return value;\n    }\n\n    public readUint64(): bigint {\n        const value = this.dataView.getBigUint64(this.offset);\n        this.offset += 8;\n        return value;\n    }\n\n    public readULEB128(): number {\n        // Unsigned LEB128\n        let value = 0;\n        let shift = 0;\n        let byte: number;\n        do {\n            if (this.offset >= this.dataView.byteLength) {\n                throw new Error('Buffer not fully read');\n            }\n            byte = this.dataView.getUint8(this.offset);\n            this.offset += 1;\n            value |= (byte & 0b01111111) << shift;\n            shift += 7;\n        }\n        while ((byte & 0b10000000) !== 0);\n        return value;\n    }\n\n    public readFloat16(): number {\n        const value = readFloat16(this.dataView, this.offset);\n        this.offset += 2;\n        return value;\n    }\n\n    public readFloat32(): number {\n        const value = this.dataView.getFloat32(this.offset);\n        this.offset += 4;\n        return value;\n    }\n\n    public readFloat64(): number {\n        const value = this.dataView.getFloat64(this.offset);\n        this.offset += 8;\n        return value;\n    }\n\n    public readUint8Array(): Uint8Array {\n        const length = this.readULEB128();\n        return this.read(length);\n    }\n\n    public readString(): string {\n        const byteArray = this.readUint8Array();\n        return textDecoder.decode(byteArray);\n    }\n\n    public readJSON<T extends JsonType>(): T {\n        return JSON.parse(this.readString());\n    }\n\n    public readFlags(length: number): Flags {\n        return Flags.read(this, length);\n    }\n\n    public finish(): void {\n        if (this.finished) {\n            throw new Error('Buffer already finished');\n        }\n        this.finished = true;\n        if (this.offset !== this.dataView.byteLength) {\n            throw new Error('Buffer not fully read');\n        }\n    }\n}\n",
    "import type { Identifier } from '../../identifier';\nimport { JsonType, type Serializable, Serializer } from '../../serialize';\n\nexport type PacketData = {\n    readonly type: string;\n    readonly data: Uint8Array;\n};\n\nexport type Packet<T = unknown> = {\n    readonly type: PacketType<T>;\n    readonly data: T;\n};\n\nexport class PacketType<T> {\n    constructor(\n        public readonly id: Identifier,\n        public readonly serializer: Serializable<T, Uint8Array>,\n    ) { }\n\n    public new(data: T): Packet<T> {\n        return {\n            type: this,\n            data,\n        };\n    }\n    public match(packet: Packet): packet is Packet<T> {\n        return packet.type === this;\n    }\n\n    static createJson<T, D extends JsonType = JsonType>(identifier: Identifier, {\n        name,\n        serializer,\n    }: {\n        name: string;\n        serializer?: Serializable<T, D>;\n    }): PacketType<T> {\n        return new PacketType<T>(\n            identifier.join(name),\n            Serializer.pipe<T, D, Uint8Array>(serializer ?? Serializer.noop(), Serializer.json()),\n        );\n    }\n\n    static createSerialized<T>(identifier: Identifier, {\n        name,\n        serializer,\n    }: {\n        name: string;\n        serializer: Serializable<T, Uint8Array>;\n    }): PacketType<T> {\n        return new PacketType(\n            identifier.join(name),\n            serializer,\n        );\n    }\n}\n",
    "import type { AppJson } from '../../app.js';\nimport { App } from '../../app.js';\nimport { Identifier } from '../../identifier';\nimport { Serializer } from '../../serialize/serializer.js';\nimport { PacketType } from './packet.js';\n\nconst IDENTIFIER = new Identifier('core', 'packet');\n\ntype ProtocolInfo = {\n    version: string;\n};\n\ntype RSANumbers = {\n    e: string;\n    n: string;\n};\n\ntype EncryptionRequest = {\n    kind: 'v1';\n    rsa: RSANumbers;\n};\n\ntype EncryptionResponse = {\n    kind: 'v1';\n    rsa: RSANumbers;\n    aes: string;\n};\n\nexport type ServerMeta = {\n    protocol: ProtocolInfo;\n    encryption: EncryptionRequest | null;\n    hash: string | undefined;\n};\n\ntype ConnectPacketJson = {\n    protocol: ProtocolInfo;\n    app: AppJson;\n    token: string;\n    encryption: EncryptionResponse | null;\n};\n\nexport class ConnectPacket {\n    public readonly protocol: ProtocolInfo;\n    public readonly app: App;\n    public readonly token: string;\n    public readonly encryption: EncryptionResponse | null;\n\n    constructor(options: {\n        protocol: ProtocolInfo;\n        app: App;\n        token: string;\n        encryption?: EncryptionResponse | null;\n    }) {\n        this.protocol = options.protocol;\n        this.app = options.app;\n        this.token = options.token;\n        this.encryption = options.encryption ?? null;\n    }\n\n    public static deserialize(data: ConnectPacketJson): ConnectPacket {\n        return new ConnectPacket({\n            protocol: data.protocol,\n            app: App.deserialize(data.app),\n            encryption: data.encryption,\n            token: data.token,\n        });\n    }\n\n    public static serialize(data: ConnectPacket): ConnectPacketJson {\n        return {\n            protocol: data.protocol,\n            app: App.serialize(data.app),\n            encryption: data.encryption,\n            token: data.token,\n        };\n    }\n}\n\nexport enum DisconnectType {\n    INVALID_TOKEN = 'invalid_token',\n    INVALID_ORIGIN = 'invalid_origin',\n    INVALID_VERSION = 'invalid_version',\n    INVALID_PACKET_TYPE = 'invalid_packet_type',\n    INVALID_PACKET_DATA = 'invalid_packet_data',\n    INVALID_PACKET = 'invalid_packet',\n    INTERNAL_ERROR = 'internal_error',\n    ANOTHER_CONNECTION = 'another_connection',\n    PERMISSION_DENIED = 'permission_denied',\n    APP_REMOVED = 'app_removed',\n    SERVER_RESTART = 'server_restart',\n    SHUTDOWN = 'shutdown',\n    CLOSE = 'close',\n}\n\ntype DisconnectPacketJson = {\n    type: DisconnectType;\n    message: string | null;\n};\n\nexport class DisconnectPacket {\n    public readonly type: DisconnectType;\n    public readonly message: string | null;\n\n    constructor(options: {\n        type: DisconnectType;\n        message?: string | null;\n    }) {\n        this.type = options.type;\n        this.message = options.message ?? null;\n    }\n\n    public static serialize(data: DisconnectPacket): DisconnectPacketJson {\n        return data.toJson();\n    }\n\n    public static deserialize(data: DisconnectPacketJson): DisconnectPacket {\n        return DisconnectPacket.fromJson(data);\n    }\n\n    static fromJson(data: DisconnectPacketJson): DisconnectPacket {\n        return new DisconnectPacket({\n            type: data.type,\n            message: data.message,\n        });\n    }\n\n    toJson(): DisconnectPacketJson {\n        return {\n            type: this.type,\n            message: this.message,\n        };\n    }\n}\n\nexport const PACKET_TYPES: {\n    SERVER_META: PacketType<ServerMeta>;\n    CONNECT: PacketType<ConnectPacket>;\n    DISCONNECT: PacketType<DisconnectPacket>;\n    TOKEN: PacketType<string>;\n    READY: PacketType<undefined>;\n    ENCRYPTED_PACKET: PacketType<Uint8Array>;\n} = {\n    SERVER_META: PacketType.createJson<ServerMeta>(IDENTIFIER, {\n        name: 'server_meta',\n    }),\n    CONNECT: PacketType.createJson<ConnectPacket>(IDENTIFIER, {\n        name: 'connect',\n        serializer: ConnectPacket,\n    }),\n    DISCONNECT: PacketType.createJson<DisconnectPacket>(IDENTIFIER, {\n        name: 'disconnect',\n        serializer: DisconnectPacket,\n    }),\n    TOKEN: PacketType.createJson<string>(IDENTIFIER, {\n        name: 'token',\n    }),\n    READY: PacketType.createJson<undefined>(IDENTIFIER, {\n        name: 'ready',\n    }),\n    ENCRYPTED_PACKET: PacketType.createSerialized<Uint8Array>(IDENTIFIER, {\n        name: 'e',\n        serializer: Serializer.noop(),\n    }),\n};\n",
    "import { Identifier, IntoId } from '../../identifier';\nimport { JsonType, type Serializable, Serializer } from '../../serialize';\n\nexport class EndpointType<Req = unknown, Res = unknown> {\n    constructor(\n        public readonly id: Identifier,\n        public readonly requestSerializer: Serializable<Req, Uint8Array>,\n        public readonly responseSerializer: Serializable<Res, Uint8Array>,\n        public readonly permissionId?: Identifier | undefined,\n    ) { }\n\n    static createJson<Req, Res, ReqData extends JsonType = JsonType, ResData extends JsonType = JsonType>(\n        identifier: IntoId,\n        {\n            name,\n            requestSerializer,\n            responseSerializer,\n            permissionId,\n        }: {\n            name: string;\n            requestSerializer?: Serializable<Req, ReqData>;\n            responseSerializer?: Serializable<Res, ResData>;\n            permissionId?: IntoId;\n        },\n    ): EndpointType<Req, Res> {\n        return new EndpointType<Req, Res>(\n            Identifier.from(identifier).join(name),\n            Serializer.pipe<Req, JsonType, Uint8Array>(requestSerializer ?? Serializer.noop(), Serializer.json()),\n            Serializer.pipe<Res, JsonType, Uint8Array>(responseSerializer ?? Serializer.noop(), Serializer.json()),\n            permissionId ? Identifier.from(permissionId) : undefined,\n        );\n    }\n\n    static createSerialized<Req, Res>(\n        identifier: IntoId,\n        {\n            name,\n            requestSerializer,\n            responseSerializer,\n            permissionId,\n        }: {\n            name: string;\n            requestSerializer: Serializable<Req, Uint8Array>;\n            responseSerializer: Serializable<Res, Uint8Array>;\n            permissionId?: IntoId;\n        },\n    ): EndpointType<Req, Res> {\n        return new EndpointType<Req, Res>(\n            Identifier.from(identifier).join(name),\n            requestSerializer,\n            responseSerializer,\n            permissionId ? Identifier.from(permissionId) : undefined,\n        );\n    }\n}\n\n",
    "import { Identifier } from '../identifier';\nimport { Omu } from '../omu';\n\nexport interface Extension {\n    readonly type: ExtensionType;\n}\n\nexport class ExtensionType<T extends Extension = Extension> extends Identifier {\n    constructor(\n        public readonly name: string,\n        public readonly create: (omu: Omu) => T,\n    ) {\n        super('ext', name);\n    }\n\n    public key(): string {\n        return this.name;\n    }\n}\n",
    "export type Unlisten = () => void;\n\nexport class EventEmitter<P extends Array<any>> {\n    private readonly listeners: Array<(...args: P) => Promise<void> | void> = [];\n\n    public listen(listener: (...args: P) => any): Unlisten {\n        this.listeners.push(listener);\n        return () => {\n            this.listeners.splice(this.listeners.indexOf(listener), 1);\n        };\n    }\n\n    public async emit(...args: P): Promise<void> {\n        for (const listener of [...this.listeners]) {\n            await listener(...args);\n        }\n    }\n}\n",
    "\ntype Task = () => Promise<void>;\n\nexport class Lock {\n    private tasks: (Task)[] = [];\n    private waiter: Promise<void> | null = null;\n\n    private wait(): Promise<void> {\n        if (this.waiter) {\n            return this.waiter;\n        }\n        this.waiter = new Promise<void>((resolve) => {\n            const runTasks = async () => {\n                while (this.tasks.length > 0) {\n                    const task = this.tasks.shift();\n                    if (task) {\n                        await task();\n                    }\n                }\n                this.waiter = null;\n                resolve();\n            };\n            runTasks();\n        });\n        return this.waiter;\n    }\n\n    public async use<T>(callback: () => Promise<T>): Promise<T> {\n        const promise = new Promise<T>((resolve, reject) => {\n            const task = async () => {\n                const promise = callback();\n                try {\n                    resolve(await promise);\n                } catch (reason) {\n                    reject(reason);\n                }\n            };\n            this.tasks.push(task);\n        });\n        await this.wait();\n        return promise;\n    }\n}\n",
    "import { Identifier } from '../../identifier';\nimport { ByteReader, ByteWriter } from '../../serialize';\nimport { RegistryPermissions, RegistryPermissionsJSON } from './registry';\n\nexport class RegistryPacket {\n    constructor(\n        public readonly id: Identifier,\n        public readonly value: Uint8Array | null,\n    ) { }\n\n    public static serialize(packet: RegistryPacket): Uint8Array {\n        const writer = new ByteWriter();\n        writer.writeString(packet.id.key());\n        writer.writeBoolean(packet.value !== null);\n        if (packet.value !== null) {\n            writer.writeUint8Array(packet.value);\n        }\n        return writer.finish();\n    }\n\n    public static deserialize(data: Uint8Array): RegistryPacket {\n        const reader = ByteReader.fromUint8Array(data);\n        const id = Identifier.fromKey(reader.readString());\n        const existing = reader.readBoolean();\n        const value = existing ? reader.readUint8Array() : null;\n        return new RegistryPacket(id, value);\n    }\n}\n\nexport interface RegisterPacketJSON {\n    id: string;\n    permissions: RegistryPermissionsJSON;\n}\n\nexport class RegisterPacket {\n    constructor(\n        public readonly id: Identifier,\n        public readonly permissions: RegistryPermissions,\n    ) {}\n\n    public static serialize(packet: RegisterPacket): RegisterPacketJSON {\n        const { permissions: perms } = packet;\n        return {\n            id: packet.id.key(),\n            permissions: {\n                all: perms.all ? Identifier.from(perms.all).key() : undefined,\n                read: perms.read ? Identifier.from(perms.read).key() : undefined,\n                write: perms.write ? Identifier.from(perms.write).key() : undefined,\n            },\n        };\n    }\n\n    public static deserialize(data: RegisterPacketJSON): RegisterPacket {\n        const { permissions: perms } = data;\n        return new RegisterPacket(\n            Identifier.from(data.id),\n            {\n                all: perms.all ? Identifier.from(perms.all) : undefined,\n                read: perms.read ? Identifier.from(perms.read) : undefined,\n                write: perms.write ? Identifier.from(perms.write) : undefined,\n            },\n        );\n    }\n}\n",
    "import type { Unlisten } from '../../event';\nimport { Identifier, IntoId } from '../../identifier';\nimport type { JsonType, Serializable } from '../../serialize';\nimport { Serializer } from '../../serialize';\n\nexport interface RegistryPermissionsJSON {\n    all?: string;\n    read?: string;\n    write?: string;\n}\n\nexport interface RegistryPermissions {\n    all?: IntoId;\n    read?: IntoId;\n    write?: IntoId;\n}\n\nexport class RegistryType<T> {\n    constructor(\n        public readonly id: Identifier,\n        public readonly defaultValue: T,\n        public readonly serializer: Serializable<T, Uint8Array>,\n        public readonly permissions: RegistryPermissions,\n    ) { }\n\n    public static createJson<T, D extends JsonType = JsonType>(identifier: IntoId, {\n        name,\n        defaultValue,\n        permissions,\n        serializer,\n    }: {\n        name: string;\n        defaultValue: T;\n        permissions?: RegistryPermissions;\n        serializer?: Serializable<T, D>;\n    }): RegistryType<T> {\n        return new RegistryType(\n            Identifier.from(identifier).join(name),\n            defaultValue,\n            Serializer.pipe<T, D, Uint8Array>(serializer ?? Serializer.noop(), Serializer.json()),\n            permissions ?? {},\n        );\n    }\n\n    public static createSerialized<T>(identifier: IntoId, {\n        name,\n        defaultValue,\n        serializer,\n        permissions,\n    }: {\n        name: string;\n        defaultValue: T;\n        serializer: Serializable<T, Uint8Array>;\n        permissions?: RegistryPermissions;\n    }): RegistryType<T> {\n        return new RegistryType(\n            Identifier.from(identifier).join(name),\n            defaultValue,\n            serializer,\n            permissions ?? {},\n        );\n    }\n}\n\nexport interface Registry<T> {\n    readonly type: RegistryType<T>;\n    readonly value: T;\n    get(): Promise<T>;\n    set(value: T): Promise<void>;\n    update(fn: (value: T) => PromiseLike<T> | T): Promise<T>;\n    modify(fn: (value: T) => PromiseLike<T> | T): Promise<T>;\n    listen(fn: (value: T) => void): Unlisten;\n}\n",
    "import type { Unlisten } from '../../event';\nimport { EventEmitter } from '../../event';\nimport { Identifier, IdentifierMap } from '../../identifier';\nimport { Lock } from '../../lock.js';\nimport { PacketType } from '../../network/packet';\nimport { Omu } from '../../omu';\nimport { JsonType, Serializer } from '../../serialize';\nimport { EndpointType } from '../endpoint/endpoint.js';\nimport { type Extension, ExtensionType } from '../extension.js';\n\nimport { RegisterPacket, RegistryPacket } from './packets.js';\nimport { type Registry, RegistryType } from './registry.js';\n\nexport class RegistryExtension implements Extension {\n    public readonly type: ExtensionType<RegistryExtension> = REGISTRY_EXTENSION_TYPE;\n    private readonly registries = new IdentifierMap<Registry<unknown>>();\n\n    constructor(private readonly omu: Omu) {\n        omu.network.registerPacket(\n            REGISTRY_REGISTER_PACKET,\n            REGISTRY_UPDATE_PACKET,\n            REGISTRY_LISTEN_PACKET,\n        );\n    }\n\n    private createRegistry<T>(registryType: RegistryType<T>): Registry<T> {\n        if (this.registries.has(registryType.id)) {\n            throw new Error(`Registry with identifier '${registryType.id}' already exists`);\n        }\n        return new RegistryImpl(this.omu, registryType);\n    }\n\n    public get<T>(registryType: RegistryType<T>): Registry<T> {\n        const identifier = registryType.id;\n        let registry = this.registries.get(identifier);\n        if (registry === undefined) {\n            registry = this.createRegistry(registryType);\n            this.registries.set(identifier, registry);\n        }\n        return registry as Registry<T>;\n    }\n\n    public json<T, D extends JsonType = JsonType>(name: string, options: { default: T; serializer?: Serializer<T, D> }): Registry<T> {\n        const identifier = this.omu.app.id.join(name);\n        if (this.registries.has(identifier)) {\n            throw new Error(`Registry with name '${name}' already exists`);\n        }\n        const tableType = RegistryType.createJson<T>(identifier, {\n            name,\n            defaultValue: options.default,\n            serializer: options.serializer,\n        });\n        return this.createRegistry(tableType);\n    }\n\n    public serialized<T>(name: string, options: { default: T; serializer: Serializer<T, Uint8Array> }): Registry<T> {\n        const identifier = this.omu.app.id.join(name);\n        if (this.registries.has(identifier)) {\n            throw new Error(`Registry with name '${name}' already exists`);\n        }\n        const tableType = RegistryType.createSerialized<T>(identifier, {\n            name,\n            defaultValue: options.default,\n            serializer: options.serializer,\n        });\n        return this.createRegistry(tableType);\n    }\n}\n\nclass RegistryImpl<T> implements Registry<T> {\n    private readonly eventEmitter: EventEmitter<[T]> = new EventEmitter();\n    private readonly lock: Lock = new Lock();\n    private listening = false;\n    public value: T;\n\n    constructor(\n        private readonly omu: Omu,\n        public readonly type: RegistryType<T>,\n    ) {\n        this.value = type.defaultValue;\n        omu.network.addPacketHandler(REGISTRY_UPDATE_PACKET, (packet) =>\n            this.handleUpdate(packet),\n        );\n        omu.network.addTask(() => this.onTask());\n    }\n\n    async #get(): Promise<T> {\n        const result = await this.omu.endpoints.call(REGISTRY_GET_ENDPOINT, this.type.id);\n        if (result.value === null) {\n            return this.type.defaultValue;\n        }\n        return this.type.serializer.deserialize(result.value);\n    }\n\n    async #set(value: T): Promise<void> {\n        this.omu.send(REGISTRY_UPDATE_PACKET, {\n            id: this.type.id,\n            value: this.type.serializer.serialize(value),\n        });\n    }\n\n    public async get(): Promise<T> {\n        const value = await this.lock.use(async () => this.#get());\n        this.eventEmitter.emit(value);\n        return value;\n    }\n\n    public async set(value: T): Promise<void> {\n        await this.lock.use(async () => this.#set(value));\n        this.eventEmitter.emit(value);\n    }\n\n    public async update(fn: (value: T) => PromiseLike<T> | T): Promise<T> {\n        const value = await this.lock.use(async () => {\n            const value = await this.#get();\n            const newValue = await fn(value);\n            await this.#set(newValue);\n            return newValue;\n        });\n        this.eventEmitter.emit(value);\n        return value;\n    }\n\n    public async modify(fn: (value: T) => PromiseLike<T> | T): Promise<T> {\n        const value = await this.lock.use(async () => {\n            const value = await this.#get();\n            const newValue = await fn(value);\n            await this.#set(newValue);\n            return newValue;\n        });\n        this.eventEmitter.emit(value);\n        return value;\n    }\n\n    public listen(handler: (value: T) => Promise<void> | void): Unlisten {\n        if (!this.listening && this.omu.ready) {\n            this.omu.send(REGISTRY_LISTEN_PACKET, this.type.id);\n        }\n        this.listening = true;\n        return this.eventEmitter.listen(handler);\n    }\n\n    private handleUpdate(data: RegistryPacket): void {\n        if (!data.id.isEqual(this.type.id)) {\n            return;\n        }\n        if (data.value !== null) {\n            this.value = this.type.serializer.deserialize(data.value);\n        }\n        this.eventEmitter.emit(this.value);\n    }\n\n    private onTask(): void {\n        if (this.listening) {\n            this.omu.send(REGISTRY_LISTEN_PACKET, this.type.id);\n        }\n        if (!this.type.id.isSubpathOf(this.omu.app.id)) {\n            return;\n        }\n        this.omu.send(REGISTRY_REGISTER_PACKET, {\n            id: this.type.id,\n            permissions: this.type.permissions,\n        });\n    }\n}\n\nexport const REGISTRY_EXTENSION_TYPE: ExtensionType<RegistryExtension> = new ExtensionType(\n    'registry',\n    (omu: Omu) => new RegistryExtension(omu),\n);\nexport const REGISTRY_PERMISSION_ID: Identifier = REGISTRY_EXTENSION_TYPE.join('permission');\nconst REGISTRY_REGISTER_PACKET = PacketType.createJson<RegisterPacket>(REGISTRY_EXTENSION_TYPE, {\n    name: 'register',\n    serializer: RegisterPacket,\n});\nconst REGISTRY_UPDATE_PACKET = PacketType.createSerialized<RegistryPacket>(\n    REGISTRY_EXTENSION_TYPE,\n    {\n        name: 'update',\n        serializer: RegistryPacket,\n    },\n);\nconst REGISTRY_LISTEN_PACKET = PacketType.createJson<Identifier>(REGISTRY_EXTENSION_TYPE, {\n    name: 'listen',\n    serializer: Identifier,\n});\nconst REGISTRY_GET_ENDPOINT = EndpointType.createSerialized<Identifier, RegistryPacket>(\n    REGISTRY_EXTENSION_TYPE,\n    {\n        name: 'get',\n        requestSerializer: Serializer.of(Identifier).toJson(),\n        responseSerializer: RegistryPacket,\n        permissionId: REGISTRY_PERMISSION_ID,\n    },\n);\n",
    "import { Identifier } from '../../identifier';\nimport { ByteReader, ByteWriter, Flags } from '../../serialize';\n\nimport type { TableConfig } from './table.js';\n\nexport class TablePacket {\n    constructor(public readonly id: Identifier) {}\n\n    public static serialize(packet: TablePacket): Uint8Array {\n        const writer = new ByteWriter();\n        writer.writeString(packet.id.key());\n        return writer.finish();\n    }\n\n    public static deserialize(data: Uint8Array): TablePacket {\n        const reader = ByteReader.fromUint8Array(data);\n        const id = Identifier.fromKey(reader.readString());\n        return new TablePacket(id);\n    }\n}\n\nexport class TableItemsPacket {\n    constructor(\n        public readonly id: Identifier,\n        public readonly items: Record<string, Uint8Array>,\n    ) {}\n\n    public static serialize(packet: TableItemsPacket): Uint8Array {\n        const writer = new ByteWriter();\n        writer.writeString(packet.id.key());\n        writer.writeULEB128(Object.keys(packet.items).length);\n        for (const [key, value] of Object.entries(packet.items)) {\n            writer.writeString(key);\n            writer.writeUint8Array(value);\n        }\n        return writer.finish();\n    }\n\n    public static deserialize(data: Uint8Array): TableItemsPacket {\n        const reader = ByteReader.fromUint8Array(data);\n        const id = Identifier.fromKey(reader.readString());\n        const count = reader.readULEB128();\n        const items: Record<string, Uint8Array> = {};\n        for (let i = 0; i < count; i++) {\n            const key = reader.readString();\n            const value = reader.readUint8Array();\n            items[key] = value;\n        }\n        return new TableItemsPacket(id, items);\n    }\n}\n\nexport class TableKeysPacket {\n    constructor(\n        public readonly id: Identifier,\n        public readonly keys: string[],\n    ) {}\n\n    public static serialize(packet: TableKeysPacket): Uint8Array {\n        const writer = new ByteWriter();\n        writer.writeString(packet.id.key());\n        writer.writeULEB128(packet.keys.length);\n        for (const key of packet.keys) {\n            writer.writeString(key);\n        }\n        return writer.finish();\n    }\n\n    public static deserialize(data: Uint8Array): TableKeysPacket {\n        const reader = ByteReader.fromUint8Array(data);\n        const id = Identifier.fromKey(reader.readString());\n        const count = reader.readULEB128();\n        const keys: string[] = [];\n        for (let i = 0; i < count; i++) {\n            keys.push(reader.readString());\n        }\n        return new TableKeysPacket(id, keys);\n    }\n}\n\nexport class TableProxyPacket {\n    constructor(\n        public readonly id: Identifier,\n        public readonly items: Record<string, Uint8Array>,\n        public readonly key: number,\n    ) {}\n\n    public static serialize(packet: TableProxyPacket): Uint8Array {\n        const writer = new ByteWriter();\n        writer.writeString(packet.id.key());\n        writer.writeULEB128(packet.key);\n        writer.writeULEB128(Object.keys(packet.items).length);\n        for (const [key, value] of Object.entries(packet.items)) {\n            writer.writeString(key);\n            writer.writeUint8Array(value);\n        }\n        return writer.finish();\n    }\n\n    public static deserialize(data: Uint8Array): TableProxyPacket {\n        const reader = ByteReader.fromUint8Array(data);\n        const id = Identifier.fromKey(reader.readString());\n        const key = reader.readULEB128();\n        const count = reader.readULEB128();\n        const items: Record<string, Uint8Array> = {};\n        for (let i = 0; i < count; i++) {\n            const key = reader.readString();\n            const value = reader.readUint8Array();\n            items[key] = value;\n        }\n        return new TableProxyPacket(id, items, key);\n    }\n}\nexport class TableFetchPacket {\n    constructor(\n        public readonly id: Identifier,\n        public readonly limit: number,\n        public readonly backward: boolean = false,\n        public readonly cursor: string | null = null,\n    ) {}\n\n    public static serialize(packet: TableFetchPacket): Uint8Array {\n        const writer = new ByteWriter();\n        writer.writeString(packet.id.key());\n        writer.writeULEB128(packet.limit);\n        const flags = new Flags({ length: 2 });\n        flags.set(0, packet.backward);\n        flags.set(1, packet.cursor !== null);\n        writer.writeFlags(flags);\n        if (packet.cursor !== null) {\n            writer.writeString(packet.cursor);\n        }\n        return writer.finish();\n    }\n\n    public static deserialize(data: Uint8Array): TableFetchPacket {\n        const reader = ByteReader.fromUint8Array(data);\n        const id = Identifier.fromKey(reader.readString());\n        const limit = reader.readULEB128();\n        const flags = reader.readFlags(2);\n        const backward = flags.get(0);\n        const cursor = flags.ifSet(1, () => reader.readString());\n        return new TableFetchPacket(id, limit, backward, cursor);\n    }\n}\n\nexport class TableFetchRangePacket {\n    constructor(\n        public readonly id: Identifier,\n        public readonly start: string,\n        public readonly end: string,\n    ) {}\n\n    public static serialize(packet: TableFetchRangePacket): Uint8Array {\n        const writer = new ByteWriter();\n        writer.writeString(packet.id.key());\n        writer.writeString(packet.start);\n        writer.writeString(packet.end);\n        return writer.finish();\n    }\n\n    public static deserialize(data: Uint8Array): TableFetchRangePacket {\n        const reader = ByteReader.fromUint8Array(data);\n        const id = Identifier.fromKey(reader.readString());\n        const start = reader.readString();\n        const end = reader.readString();\n        return new TableFetchRangePacket(id, start, end);\n    }\n}\n\nexport class SetConfigPacket {\n    constructor(\n        public readonly id: Identifier,\n        public readonly config: TableConfig,\n    ) {}\n\n    public static serialize(packet: SetConfigPacket): Uint8Array {\n        const writer = new ByteWriter();\n        writer.writeString(packet.id.key());\n        writer.writeString(JSON.stringify(packet.config));\n        return writer.finish();\n    }\n\n    public static deserialize(data: Uint8Array): SetConfigPacket {\n        const reader = ByteReader.fromUint8Array(data);\n        const id = Identifier.fromKey(reader.readString());\n        const config = JSON.parse(reader.readString());\n        return new SetConfigPacket(id, config);\n    }\n}\n\nexport class SetPermissionPacket {\n    constructor(\n        public readonly id: Identifier,\n        public readonly all: Identifier | null,\n        public readonly read: Identifier | null,\n        public readonly write: Identifier | null,\n        public readonly remove: Identifier | null,\n        public readonly proxy: Identifier | null,\n    ) {}\n\n    public static serialize(packet: SetPermissionPacket): Uint8Array {\n        const writer = new ByteWriter();\n        writer.writeString(packet.id.key());\n        let flags = 0;\n        if (packet.all !== null) {\n            flags |= 0b1;\n        }\n        if (packet.read !== null) {\n            flags |= 0b10;\n        }\n        if (packet.write !== null) {\n            flags |= 0b100;\n        }\n        if (packet.remove !== null) {\n            flags |= 0b1000;\n        }\n        if (packet.proxy !== null) {\n            flags |= 0b10000;\n        }\n        writer.writeUint8(flags);\n        if (packet.all) {\n            writer.writeString(packet.all.key());\n        }\n        if (packet.read) {\n            writer.writeString(packet.read.key());\n        }\n        if (packet.write) {\n            writer.writeString(packet.write.key());\n        }\n        if (packet.remove) {\n            writer.writeString(packet.remove.key());\n        }\n        if (packet.proxy) {\n            writer.writeString(packet.proxy.key());\n        }\n        return writer.finish();\n    }\n\n    public static deserialize(data: Uint8Array): SetPermissionPacket {\n        const reader = ByteReader.fromUint8Array(data);\n        const id = Identifier.fromKey(reader.readString());\n        const flags = reader.readUint8();\n        const all = flags & 0b1 ? Identifier.fromKey(reader.readString()) : null;\n        const read = flags & 0b10 ? Identifier.fromKey(reader.readString()) : null;\n        const write = flags & 0b100 ? Identifier.fromKey(reader.readString()) : null;\n        const remove = flags & 0b1000 ? Identifier.fromKey(reader.readString()) : null;\n        const proxy = flags & 0b10000 ? Identifier.fromKey(reader.readString()) : null;\n        return new SetPermissionPacket(id, all, read, write, remove, proxy);\n    }\n}\n\n",
    "import type { EventEmitter, Unlisten } from '../../event';\nimport { Identifier, IntoId } from '../../identifier';\nimport type { JsonType, Serializable } from '../../serialize';\nimport { Serializer } from '../../serialize';\n\nexport type TableConfig = {\n    cache_size: number;\n};\n\nexport interface Table<T> {\n    readonly cache: ReadonlyMap<string, T>;\n    readonly event: TableEvents<T>;\n    get(key: string): Promise<T | undefined>;\n    getMany(...keys: string[]): Promise<Map<string, T>>;\n    add(...item: T[]): Promise<void>;\n    update(...item: T[]): Promise<void>;\n    remove(...items: T[]): Promise<void>;\n    clear(): Promise<void>;\n    has(key: string): Promise<boolean>;\n    hasMany<T extends Record<string, unknown>>(...keys: (keyof T)[]): Promise<{ [key in keyof T]: boolean }>;\n    hasAll(...keys: string[]): Promise<boolean>;\n    hasAny(...keys: string[]): Promise<boolean>;\n\n    fetchItems({\n        limit,\n        backward,\n        cursor,\n    }: {\n        limit: number;\n        backward?: boolean;\n        cursor?: string;\n    }): Promise<Map<string, T>>;\n    fetchRange({ start, end }: { start: string; end: string }): Promise<Map<string, T>>;\n    fetchAll(): Promise<Map<string, T>>;\n    iterate({ backward, cursor }: { backward?: boolean; cursor?: string }): AsyncIterable<T>;\n    size(): Promise<number>;\n\n    proxy(proxy: (item: T) => T | undefined): Unlisten;\n    setCacheSize(size: number): void;\n    setConfig(config: TableConfig): void;\n    setPermissions(permissions: TablePermissions): void;\n\n    listen(listener?: (items: Map<string, T>) => void): Unlisten;\n}\n\nexport type TableEvents<T> = {\n    add: EventEmitter<[Map<string, T>]>;\n    update: EventEmitter<[Map<string, T>]>;\n    remove: EventEmitter<[Map<string, T>]>;\n    clear: EventEmitter<[]>;\n    cacheUpdate: EventEmitter<[Map<string, T>]>;\n};\n\nexport type TablePermissions = {\n    all?: Identifier;\n    read?: Identifier;\n    write?: Identifier;\n    remove?: Identifier;\n    proxy?: Identifier;\n};\n\nexport class TableType<T> {\n    constructor(\n        public id: Identifier,\n        public serializer: Serializable<T, Uint8Array>,\n        public keyFunction: (item: T) => string,\n        public permissions?: TablePermissions | undefined,\n    ) {}\n\n    public static createJson<T, D extends JsonType = JsonType>(\n        identifier: IntoId,\n        {\n            name,\n            key,\n            permissions,\n            serializer,\n        }: {\n            name: string;\n            key: (item: T) => string;\n            permissions?: TablePermissions;\n            serializer?: Serializable<T, D>;\n        },\n    ): TableType<T> {\n        return new TableType<T>(\n            Identifier.from(identifier).join(name),\n            Serializer.pipe<T, D, Uint8Array>(serializer ?? Serializer.noop(), Serializer.json()),\n            key,\n            permissions,\n        );\n    }\n\n    public static createSerialized<T>(\n        identifier: IntoId,\n        {\n            name,\n            key,\n            permissions,\n            serializer,\n        }: {\n            name: string;\n            key: (item: T) => string;\n            permissions?: TablePermissions;\n            serializer: Serializable<T, Uint8Array>;\n        },\n    ): TableType<T> {\n        return new TableType<T>(\n            Identifier.from(identifier).join(name),\n            serializer,\n            key,\n            permissions,\n        );\n    }\n}\n",
    "import type { Unlisten } from '../../event';\nimport { EventEmitter } from '../../event';\nimport { Identifier, IdentifierMap } from '../../identifier';\nimport { PacketType } from '../../network/packet/packet.js';\nimport { Omu } from '../../omu';\nimport type { JsonType, Serializable } from '../../serialize';\nimport { Serializer } from '../../serialize';\nimport { EndpointType } from '../endpoint/endpoint.js';\nimport type { Extension } from '../extension.js';\nimport { ExtensionType } from '../extension.js';\n\nimport {\n    SetConfigPacket,\n    SetPermissionPacket,\n    TableFetchPacket,\n    TableFetchRangePacket,\n    TableItemsPacket,\n    TableKeysPacket,\n    TablePacket,\n    TableProxyPacket,\n} from './packets.js';\nimport type { Table, TableConfig, TableEvents, TablePermissions } from './table.js';\nimport { TableType } from './table.js';\n\nexport const TABLE_EXTENSION_TYPE: ExtensionType<TableExtension> = new ExtensionType(\n    'table',\n    (client) => new TableExtension(client),\n);\nexport const TABLE_PERMISSION_ID: Identifier = TABLE_EXTENSION_TYPE.join('permission');\n\nconst TABLE_SET_PERMISSION_PACKET = PacketType.createSerialized<SetPermissionPacket>(TABLE_EXTENSION_TYPE, {\n    name: 'set_permission',\n    serializer: SetPermissionPacket,\n});\nconst TABLE_SET_CONFIG_PACKET = PacketType.createSerialized<SetConfigPacket>(TABLE_EXTENSION_TYPE, {\n    name: 'set_config',\n    serializer: SetConfigPacket,\n});\nconst TABLE_LISTEN_PACKET = PacketType.createJson<Identifier>(TABLE_EXTENSION_TYPE, {\n    name: 'listen',\n    serializer: Identifier,\n});\nconst TABLE_PROXY_LISTEN_PACKET = PacketType.createJson<Identifier>(TABLE_EXTENSION_TYPE, {\n    name: 'proxy_listen',\n    serializer: Identifier,\n});\nconst TABLE_PROXY_PACKET = PacketType.createSerialized<TableProxyPacket>(TABLE_EXTENSION_TYPE, {\n    name: 'proxy',\n    serializer: TableProxyPacket,\n});\nconst TABLE_ITEM_ADD_PACKET = PacketType.createSerialized<TableItemsPacket>(TABLE_EXTENSION_TYPE, {\n    name: 'item_add',\n    serializer: TableItemsPacket,\n});\nconst TABLE_ITEM_UPDATE_PACKET = PacketType.createSerialized<TableItemsPacket>(TABLE_EXTENSION_TYPE, {\n    name: 'item_update',\n    serializer: TableItemsPacket,\n});\nconst TABLE_ITEM_REMOVE_PACKET = PacketType.createSerialized<TableItemsPacket>(TABLE_EXTENSION_TYPE, {\n    name: 'item_remove',\n    serializer: TableItemsPacket,\n});\nconst TABLE_ITEM_GET_ENDPOINT = EndpointType.createSerialized<TableKeysPacket, TableItemsPacket>(TABLE_EXTENSION_TYPE, {\n    name: 'item_get',\n    requestSerializer: TableKeysPacket,\n    responseSerializer: TableItemsPacket,\n    permissionId: TABLE_PERMISSION_ID,\n});\nconst TABLE_ITEM_HAS_ENDPOINT = EndpointType.createSerialized<TableKeysPacket, Record<string, boolean>>(TABLE_EXTENSION_TYPE, {\n    name: 'item_has',\n    requestSerializer: TableKeysPacket,\n    responseSerializer: Serializer.json(),\n    permissionId: TABLE_PERMISSION_ID,\n});\nconst TABLE_ITEM_HAS_ALL_ENDPOINT = EndpointType.createSerialized<TableKeysPacket, boolean>(TABLE_EXTENSION_TYPE, {\n    name: 'item_has_all',\n    requestSerializer: TableKeysPacket,\n    responseSerializer: Serializer.json(),\n    permissionId: TABLE_PERMISSION_ID,\n});\nconst TABLE_ITEM_HAS_ANY_ENDPOINT = EndpointType.createSerialized<TableKeysPacket, boolean>(TABLE_EXTENSION_TYPE, {\n    name: 'item_has_any',\n    requestSerializer: TableKeysPacket,\n    responseSerializer: Serializer.json(),\n    permissionId: TABLE_PERMISSION_ID,\n});\nconst TABLE_FETCH_ENDPOINT = EndpointType.createSerialized<TableFetchPacket, TableItemsPacket>(TABLE_EXTENSION_TYPE, {\n    name: 'fetch',\n    requestSerializer: TableFetchPacket,\n    responseSerializer: TableItemsPacket,\n    permissionId: TABLE_PERMISSION_ID,\n});\nconst TABLE_FETCH_RANGE_ENDPOINT = EndpointType.createSerialized<TableFetchRangePacket, TableItemsPacket>(TABLE_EXTENSION_TYPE, {\n    name: 'fetch_range',\n    requestSerializer: TableFetchRangePacket,\n    responseSerializer: TableItemsPacket,\n    permissionId: TABLE_PERMISSION_ID,\n});\nconst TABLE_FETCH_ALL_ENDPOINT = EndpointType.createSerialized<TablePacket, TableItemsPacket>(TABLE_EXTENSION_TYPE, {\n    name: 'fetch_all',\n    requestSerializer: TablePacket,\n    responseSerializer: TableItemsPacket,\n    permissionId: TABLE_PERMISSION_ID,\n});\nconst TABLE_SIZE_ENDPOINT = EndpointType.createSerialized<TablePacket, number>(TABLE_EXTENSION_TYPE, {\n    name: 'size',\n    requestSerializer: TablePacket,\n    responseSerializer: Serializer.json(),\n    permissionId: TABLE_PERMISSION_ID,\n});\nconst TABLE_ITEM_CLEAR_PACKET = PacketType.createSerialized<TablePacket>(TABLE_EXTENSION_TYPE, {\n    name: 'clear',\n    serializer: TablePacket,\n});\n\nexport class TableExtension implements Extension {\n    public readonly type: ExtensionType<TableExtension> = TABLE_EXTENSION_TYPE;\n    private readonly tableMap = new IdentifierMap<Table<unknown>>();\n\n    constructor(private readonly omu: Omu) {\n        omu.network.registerPacket(\n            TABLE_SET_PERMISSION_PACKET,\n            TABLE_SET_CONFIG_PACKET,\n            TABLE_LISTEN_PACKET,\n            TABLE_PROXY_LISTEN_PACKET,\n            TABLE_PROXY_PACKET,\n            TABLE_ITEM_ADD_PACKET,\n            TABLE_ITEM_UPDATE_PACKET,\n            TABLE_ITEM_REMOVE_PACKET,\n            TABLE_ITEM_CLEAR_PACKET,\n        );\n    }\n\n    private createTable<T>(tableType: TableType<T>): Table<T> {\n        this.omu.permissions.require(TABLE_PERMISSION_ID);\n        if (this.has(tableType.id)) {\n            throw new Error('Table already exists');\n        }\n        const table = new TableImpl<T>(this.omu, tableType);\n        this.tableMap.set(tableType.id, table as Table<unknown>);\n        return table;\n    }\n\n    public json<T, D extends JsonType = JsonType>(name: string, options: { key: (item: T) => string; serializer?: Serializable<T, D> }): Table<T> {\n        const tableType = new TableType<T>(\n            this.omu.app.id.join(name),\n            Serializer.pipe<T, JsonType, Uint8Array>(options.serializer ?? Serializer.noop(), Serializer.json()),\n            options.key,\n        );\n        return this.createTable(tableType);\n    }\n\n    public serialized<T>(name: string, options: { key: (item: T) => string; serializer: Serializable<T, Uint8Array> }): Table<T> {\n        const tableType = new TableType<T>(\n            this.omu.app.id.join(name),\n            options.serializer,\n            options.key,\n        );\n        return this.createTable(tableType);\n    }\n\n    public get<T>(type: TableType<T>): Table<T> {\n        if (this.has(type.id)) {\n            return this.tableMap.get(type.id) as Table<T>;\n        }\n        return this.createTable(type);\n    }\n\n    public has(identifier: Identifier): boolean {\n        return this.tableMap.has(identifier);\n    }\n}\n\nclass TableImpl<T> implements Table<T> {\n    public cache: Map<string, T>;\n    public readonly event: TableEvents<T>;\n    private readonly promiseMap: Map<string, Promise<T | undefined>>;\n    private readonly proxies: Array<(item: T) => T | undefined>;\n    private id: Identifier;\n    private serializer: Serializable<T, Uint8Array>;\n    private keyFunction: (item: T) => string;\n    private listening: boolean;\n    private cacheSize?: number;\n    private config?: TableConfig;\n    private permissions?: TablePermissions;\n\n    constructor(\n        private readonly omu: Omu,\n        tableType: TableType<T>,\n    ) {\n        this.id = tableType.id;\n        this.serializer = tableType.serializer;\n        this.keyFunction = tableType.keyFunction;\n        this.cache = new Map();\n        this.event = {\n            add: new EventEmitter<[Map<string, T>]>(),\n            update: new EventEmitter<[Map<string, T>]>(),\n            remove: new EventEmitter<[Map<string, T>]>(),\n            clear: new EventEmitter<[]>(),\n            cacheUpdate: new EventEmitter<[Map<string, T>]>(),\n        };\n        this.promiseMap = new Map();\n        this.proxies = [];\n        this.listening = false;\n\n        omu.network.addPacketHandler(TABLE_PROXY_PACKET, (packet) => {\n            if (!packet.id.isEqual(this.id)) {\n                return;\n            }\n            let items = this.deserializeItems(packet.items);\n            this.proxies.forEach((proxy) => {\n                items = new Map(\n                    [...items.entries()]\n                        .map(([key, item]) => {\n                            const proxyItem = proxy(item);\n                            if (proxyItem !== undefined) {\n                                return [key, proxyItem as T];\n                            }\n                            return undefined;\n                        })\n                        .filter((item): item is [string, T] => {\n                            return typeof item !== 'undefined';\n                        }),\n                );\n            });\n            omu.send(TABLE_PROXY_PACKET, {\n                id: this.id,\n                key: packet.key,\n                items: Object.fromEntries(\n                    [...items.entries()].map(([key, item]) => {\n                        return [key, this.serializer.serialize(item)];\n                    }),\n                ),\n            });\n        });\n        omu.network.addPacketHandler(TABLE_ITEM_ADD_PACKET, (packet) => {\n            if (!packet.id.isEqual(this.id)) {\n                return;\n            }\n            const items = this.deserializeItems(packet.items);\n            this.updateCache(items);\n            this.event.add.emit(items);\n        });\n        omu.network.addPacketHandler(TABLE_ITEM_UPDATE_PACKET, (packet) => {\n            if (!packet.id.isEqual(this.id)) {\n                return;\n            }\n            const items = this.deserializeItems(packet.items);\n            this.updateCache(items);\n            this.event.update.emit(items);\n        });\n        omu.network.addPacketHandler(TABLE_ITEM_REMOVE_PACKET, (packet) => {\n            if (!packet.id.isEqual(this.id)) {\n                return;\n            }\n            const items = this.deserializeItems(packet.items);\n            items.forEach((_, key) => {\n                this.cache.delete(key);\n            });\n            this.event.remove.emit(items);\n            this.event.cacheUpdate.emit(this.cache);\n        });\n        omu.network.addPacketHandler(TABLE_ITEM_CLEAR_PACKET, (packet) => {\n            if (!packet.id.isEqual(this.id)) {\n                return;\n            }\n            this.cache = new Map();\n            this.event.clear.emit();\n            this.event.cacheUpdate.emit(this.cache);\n        });\n        omu.event.ready.listen(() => this.onReady());\n    }\n\n    private updateCache(items: Map<string, T>): void {\n        if (!this.cacheSize) {\n            this.cache = items;\n        } else {\n            const cache = new Map([...this.cache, ...items].slice(-this.cacheSize));\n            this.cache = cache;\n        }\n        this.event.cacheUpdate.emit(this.cache);\n    }\n\n    public listen(listener?: (items: Map<string, T>) => void): Unlisten {\n        if (!this.listening) {\n            this.omu.onReady(() => {\n                this.omu.send(TABLE_LISTEN_PACKET, this.id);\n            });\n            this.listening = true;\n        }\n        if (listener) {\n            return this.event.cacheUpdate.listen(listener);\n        }\n        return () => {};\n    }\n\n    public proxy(callback: (item: T) => T | undefined): Unlisten {\n        if (this.proxies.length === 0) {\n            let cancel = (): void => {};\n            cancel = this.omu.onReady(() => {\n                if (this.proxies.length === 0) {\n                    cancel();\n                    return;\n                }\n                this.omu.send(TABLE_PROXY_LISTEN_PACKET, this.id);\n            });\n        }\n        this.proxies.push(callback);\n        return () => {\n            this.proxies.splice(this.proxies.indexOf(callback), 1);\n        };\n    }\n\n    private onReady(): void {\n        if (this.config) {\n            this.omu.send(TABLE_SET_CONFIG_PACKET, {\n                id: this.id,\n                config: this.config,\n            });\n        }\n    }\n\n    public async get(key: string): Promise<T | undefined> {\n        if (this.cache.has(key)) {\n            return this.cache.get(key);\n        }\n        if (this.promiseMap.has(key)) {\n            return await this.promiseMap.get(key);\n        }\n        const promise = this.omu.endpoints\n            .call(TABLE_ITEM_GET_ENDPOINT, {\n                id: this.id,\n                keys: [key],\n            })\n            .then((res) => {\n                const items = this.deserializeItems(res.items);\n                this.updateCache(items);\n                return this.cache.get(key);\n            });\n        this.promiseMap.set(key, promise);\n        return await promise.then((item) => {\n            this.promiseMap.delete(key);\n            return item;\n        });\n    }\n\n    public async getMany(...keys: string[]): Promise<Map<string, T>> {\n        const filteredKeys = keys\n            .filter((key) => !this.cache.has(key))\n            .filter((key) => !this.promiseMap.has(key));\n        if (filteredKeys.length === 0) {\n            return new Map([...this.cache].filter(([key]) => keys.includes(key)));\n        }\n        const promise = this.omu.endpoints\n            .call(TABLE_ITEM_GET_ENDPOINT, {\n                id: this.id,\n                keys: filteredKeys,\n            })\n            .then((res) => {\n                const items = this.deserializeItems(res.items);\n                this.updateCache(items);\n                return items;\n            });\n        for (const key of filteredKeys) {\n            this.promiseMap.set(\n                key,\n                promise.then((items) => items.get(key)),\n            );\n        }\n        const items = await promise;\n        for (const key of filteredKeys) {\n            this.promiseMap.delete(key);\n        }\n        return new Map([...this.cache, ...items].filter(([key]) => keys.includes(key)));\n    }\n\n    public async add(...items: T[]): Promise<void> {\n        const data = this.serializeItems(items);\n        this.omu.send(TABLE_ITEM_ADD_PACKET, {\n            id: this.id,\n            items: data,\n        });\n    }\n\n    public async update(...items: T[]): Promise<void> {\n        const data = this.serializeItems(items);\n        this.omu.send(TABLE_ITEM_UPDATE_PACKET, {\n            id: this.id,\n            items: data,\n        });\n    }\n\n    public async remove(...items: T[]): Promise<void> {\n        const data = this.serializeItems(items);\n        const keys = Object.keys(data);\n        this.cache = new Map([...this.cache].filter(([key]) => !keys.includes(key)));\n        this.omu.send(TABLE_ITEM_REMOVE_PACKET, {\n            id: this.id,\n            items: data,\n        });\n    }\n\n    public async clear(): Promise<void> {\n        this.omu.send(TABLE_ITEM_CLEAR_PACKET, {\n            id: this.id,\n        });\n    }\n\n    public async has(key: string): Promise<boolean> {\n        if (this.cache.has(key)) {\n            return true;\n        }\n        const res = await this.omu.endpoints.call(TABLE_ITEM_HAS_ENDPOINT, {\n            id: this.id,\n            keys: [key],\n        });\n        return res[key] ?? false;\n    }\n\n    public async hasMany<T extends Record<string, unknown>>(...keys: (keyof T)[]): Promise<{ [key in keyof T]: boolean }> {\n        const res = await this.omu.endpoints.call(TABLE_ITEM_HAS_ENDPOINT, {\n            id: this.id,\n            keys: keys,\n        });\n        return res as { [key in keyof T]: boolean };\n    }\n\n    public async hasAll(...keys: string[]): Promise<boolean> {\n        const res = await this.omu.endpoints.call(TABLE_ITEM_HAS_ALL_ENDPOINT, {\n            id: this.id,\n            keys,\n        });\n        return res;\n    }\n\n    public async hasAny(...keys: string[]): Promise<boolean> {\n        const res = await this.omu.endpoints.call(TABLE_ITEM_HAS_ANY_ENDPOINT, {\n            id: this.id,\n            keys,\n        });\n        return res;\n    }\n\n    public async fetchItems({\n        limit,\n        backward,\n        cursor,\n    }: {\n        limit: number;\n        backward?: boolean;\n        cursor?: string;\n    }): Promise<Map<string, T>> {\n        const res = await this.omu.endpoints.call(\n            TABLE_FETCH_ENDPOINT,\n            new TableFetchPacket(this.id, limit, backward, cursor),\n        );\n        const items = this.deserializeItems(res.items);\n        this.updateCache(items);\n        return items;\n    }\n\n    public async fetchRange({\n        start,\n        end,\n    }: {\n        start: string;\n        end: string;\n    }): Promise<Map<string, T>> {\n        const res = await this.omu.endpoints.call(TABLE_FETCH_RANGE_ENDPOINT, {\n            id: this.id,\n            start,\n            end,\n        });\n        const items = this.deserializeItems(res.items);\n        this.updateCache(items);\n        return items;\n    }\n\n    public async fetchAll(): Promise<Map<string, T>> {\n        const res = await this.omu.endpoints.call(TABLE_FETCH_ALL_ENDPOINT, {\n            id: this.id,\n        });\n        const items = this.deserializeItems(res.items);\n        this.updateCache(items);\n        return items;\n    }\n\n    public async *iterate({\n        backward,\n        cursor,\n    }: {\n        backward?: boolean;\n        cursor?: string;\n    }): AsyncIterable<T> {\n        while (true) {\n            const items = await this.fetchItems({\n                limit: this.cacheSize ?? 100,\n                backward,\n                cursor,\n            });\n            if (items.size === 0) {\n                break;\n            }\n            yield* items.values();\n            if (cursor !== undefined) {\n                items.delete(cursor);\n            }\n            const cursorItem = backward ? items.values().next().value : [...items.values()].pop();\n            if (!cursorItem) {\n                break;\n            }\n            cursor = this.keyFunction(cursorItem);\n        }\n    }\n\n    public async size(): Promise<number> {\n        return await this.omu.endpoints.call(TABLE_SIZE_ENDPOINT, {\n            id: this.id,\n        });\n    }\n\n    private deserializeItems(items: Record<string, Uint8Array>): Map<string, T> {\n        return new Map(\n            Object.entries(items).map(([key, data]) => {\n                const item = this.serializer.deserialize(data);\n                this.cache.set(key, item);\n                return [key, item];\n            }),\n        );\n    }\n\n    private serializeItems(items: T[]): Record<string, Uint8Array> {\n        return Object.fromEntries(\n            items.map((item) => {\n                return [this.keyFunction(item), this.serializer.serialize(item)];\n            }),\n        );\n    }\n\n    public setCacheSize(size: number): void {\n        this.cacheSize = size;\n    }\n\n    public setConfig(config: TableConfig): void {\n        if (this.omu.running) {\n            throw new Error('Cannot set config after client has started');\n        }\n        this.config = config;\n    }\n\n    public setPermissions(permissions: TablePermissions): void {\n        this.permissions = permissions;\n    }\n}\n",
    "import { App, AppJson } from '../../app.js';\nimport { Identifier, IdentifierMap } from '../../identifier';\nimport { Omu } from '../../omu.js';\nimport { EndpointType } from '../endpoint/endpoint.js';\nimport { ExtensionType, type Extension } from '../extension.js';\nimport { Registry, RegistryType } from '../registry';\nimport { TableType, type Table } from '../table';\n\nexport const SERVER_EXTENSION_TYPE: ExtensionType<ServerExtension> = new ExtensionType(\n    'server',\n    (omu: Omu) => new ServerExtension(omu),\n);\n\nexport interface AppIndexEntry {\n    url: string;\n    added_at: string;\n};\n\nexport interface AppIndex {\n    indexes: Record<string, AppIndexEntry>;\n};\n\nexport const SERVER_APPS_READ_PERMISSION_ID: Identifier = SERVER_EXTENSION_TYPE.join('apps', 'read');\nexport const SERVER_APPS_WRITE_PERMISSION_ID: Identifier = SERVER_EXTENSION_TYPE.join('apps', 'write');\nexport const SERVER_INDEX_READ_PERMISSION_ID: Identifier = SERVER_EXTENSION_TYPE.join('index', 'read');\nexport const SERVER_INDEX_REGISTRY_TYPE: RegistryType<AppIndex> = RegistryType.createJson<AppIndex>(SERVER_EXTENSION_TYPE, {\n    name: 'index',\n    defaultValue: { 'indexes': {} },\n    permissions: {\n        write: SERVER_APPS_WRITE_PERMISSION_ID,\n        read: SERVER_INDEX_READ_PERMISSION_ID,\n    },\n});\nconst APP_TABLE_TYPE = TableType.createJson(SERVER_EXTENSION_TYPE, {\n    name: 'apps',\n    serializer: App,\n    key: (app) => app.id.key(),\n    permissions: {\n        all: SERVER_APPS_WRITE_PERMISSION_ID,\n        read: SERVER_APPS_READ_PERMISSION_ID,\n    },\n});\n\nexport const SERVER_SHUTDOWN_PERMISSION_ID: Identifier = SERVER_EXTENSION_TYPE.join('shutdown');\nconst SHUTDOWN_ENDPOINT_TYPE = EndpointType.createJson<boolean, boolean>(SERVER_EXTENSION_TYPE, {\n    name: 'shutdown',\n    permissionId: SERVER_SHUTDOWN_PERMISSION_ID,\n});\nexport const TRUSTED_ORIGINS_GET_PERMISSION_ID: Identifier = SERVER_EXTENSION_TYPE.join('trusted_origins', 'get');\nexport const TRUSTED_ORIGINS_SET_PERMISSION_ID: Identifier = SERVER_EXTENSION_TYPE.join('trusted_origins', 'set');\nconst TRUSTED_HOSTS_REGISTRY_TYPE = RegistryType.createJson<Record<string, string>>(SERVER_EXTENSION_TYPE, {\n    name: 'trusted_hosts',\n    defaultValue: {},\n    permissions: {\n        read: TRUSTED_ORIGINS_GET_PERMISSION_ID,\n        write: TRUSTED_ORIGINS_SET_PERMISSION_ID,\n    },\n});\n\nexport class ServerExtension implements Extension {\n    public readonly type: ExtensionType<ServerExtension> = SERVER_EXTENSION_TYPE;\n    public readonly apps: Table<App>;\n    public readonly index: Registry<AppIndex>;\n    public readonly trustedHosts: Registry<Record<string, string>>;\n\n    constructor(private readonly omu: Omu) {\n        this.apps = omu.tables.get(APP_TABLE_TYPE);\n        this.index = omu.registries.get(SERVER_INDEX_REGISTRY_TYPE);\n        this.trustedHosts = omu.registries.get(TRUSTED_HOSTS_REGISTRY_TYPE);\n    }\n\n    public async shutdown(restart?: boolean): Promise<boolean> {\n        this.omu.endpoints.call(SHUTDOWN_ENDPOINT_TYPE, restart ?? false);\n        await new Promise<void>((resolve) => {\n            const unlisten = this.omu.network.event.disconnected.listen(() => {\n                resolve();\n                unlisten();\n            });\n        });\n        return true;\n    }\n}\n\nexport class SessionObserver {\n    constructor(\n        public readonly onConnectCallbacks: Array<(app: App) => Promise<void> | void>,\n        public readonly onDisconnectCallbacks: Array<(app: App) => Promise<void> | void>,\n    ) { }\n\n    public onConnect(callback: (app: App) => Promise<void> | void): void {\n        this.onConnectCallbacks.push(callback);\n    }\n\n    public onDisconnect(callback: (app: App) => Promise<void> | void): void {\n        this.onDisconnectCallbacks.push(callback);\n    }\n}\n\nexport interface AppIndexRegistryJSON {\n    id: string;\n    apps: Record<string, AppJson>;\n}\n\nexport class AppIndexRegistry {\n    constructor(\n        public id: Identifier,\n        public apps: IdentifierMap<App>,\n    ) { }\n\n    public static fromJSON(json: AppIndexRegistryJSON): AppIndexRegistry {\n        const id = Identifier.fromKey(json['id']);\n        const apps = new IdentifierMap<App>();\n        for (const [idStr, appJSON] of Object.entries(json['apps'])) {\n            const id = Identifier.fromKey(idStr);\n            const app = App.deserialize(appJSON);\n            if (!id.isNamespaceEqual(app.id)) {\n                throw new Error(`App ID does not match the ID in the index. ${app.id} != ${id}`);\n            }\n            apps.set(id, app);\n        }\n        return new AppIndexRegistry(\n            id,\n            apps,\n        );\n    }\n}\n",
    "import { App, AppJson } from '../../app';\nimport { Identifier, IdentifierMap, IdentifierSet, IntoId } from '../../identifier';\nimport { PacketType } from '../../network/packet';\nimport { Omu } from '../../omu';\nimport { Serializer } from '../../serialize';\nimport { EndpointType } from '../endpoint';\nimport { Extension, ExtensionType } from '../extension';\nimport { SessionObserver } from '../server/extension';\nimport { Table, TableType } from '../table';\n\nexport const SESSION_EXTENSION_TYPE: ExtensionType<SessionExtension> = new ExtensionType('sessions', (omu: Omu) => new SessionExtension(omu));\n\nexport const SESSIONS_READ_PERMISSION_ID: Identifier = SESSION_EXTENSION_TYPE.join('read');\nconst SESSION_TABLE_TYPE = TableType.createJson(SESSION_EXTENSION_TYPE, {\n    name: 'sessions',\n    serializer: App,\n    key: (app) => app.id.key(),\n    permissions: {\n        read: SESSIONS_READ_PERMISSION_ID,\n    },\n});\nconst REQUIRE_APPS_PACKET_TYPE = PacketType.createJson<Identifier[]>(SESSION_EXTENSION_TYPE, {\n    name: 'require',\n    serializer: Serializer.of(Identifier).toArray(),\n});\nconst SESSION_OBSERVE_PACKET_TYPE = PacketType.createJson<Identifier[]>(SESSION_EXTENSION_TYPE, {\n    name: 'observe',\n    serializer: Serializer.of(Identifier).toArray(),\n});\nconst SESSION_CONNECTED_PACKET_TYPE = PacketType.createJson<App>(SESSION_EXTENSION_TYPE, {\n    name: 'session_connected',\n    serializer: App,\n});\nconst SESSION_DISCONNECTED_PACKET_TYPE = PacketType.createJson<App>(SESSION_EXTENSION_TYPE, {\n    name: 'session_disconnected',\n    serializer: App,\n});\n\ntype RemoteAppRequestPayload = {\n    app: AppJson;\n    permissions: string[];\n};\n\nexport type RequestRemoteAppResponse = {\n    type: 'success';\n    token: string;\n    lan_ip: string;\n} | {\n    type: 'error';\n    message: string;\n};\n\nexport const REMOTE_APP_REQUEST_PERMISSION_ID: Identifier = SESSION_EXTENSION_TYPE.join('remote_app', 'request');\n\nconst REMOTE_APP_REQUEST_ENDPOINT_TYPE = EndpointType.createJson<RemoteAppRequestPayload, RequestRemoteAppResponse>(SESSION_EXTENSION_TYPE, {\n    name: 'remote_app_request',\n    permissionId: REMOTE_APP_REQUEST_PERMISSION_ID,\n});\n\nexport type GenerateTokenResponse = {\n    type: 'success';\n    token: string;\n} | {\n    type: 'error';\n    message: string;\n};\n\nexport const GENERATE_TOKEN_PERMISSION_ID: Identifier = SESSION_EXTENSION_TYPE.join('generate_token');\n\ntype GenerateTokenPayload = {\n    app: AppJson;\n    permissions: string[];\n};\n\nconst GENERATE_TOKEN_ENDPOINT_TYPE = EndpointType.createJson<GenerateTokenPayload, GenerateTokenResponse>(SESSION_EXTENSION_TYPE, {\n    name: 'generate_token',\n    permissionId: GENERATE_TOKEN_PERMISSION_ID,\n});\n\nexport class SessionExtension implements Extension {\n    public readonly type: ExtensionType<SessionExtension> = SESSION_EXTENSION_TYPE;\n    public readonly sessions: Table<App>;\n    private readonly sessionObservers = new IdentifierMap<SessionObserver>();\n    private readonly requiredApps = new IdentifierSet();\n\n    constructor(private readonly omu: Omu) {\n        omu.network.registerPacket(\n            REQUIRE_APPS_PACKET_TYPE,\n            SESSION_OBSERVE_PACKET_TYPE,\n            SESSION_CONNECTED_PACKET_TYPE,\n            SESSION_DISCONNECTED_PACKET_TYPE,\n        );\n        omu.network.addPacketHandler(\n            SESSION_CONNECTED_PACKET_TYPE, (app) => this.handleSessionConnect(app),\n        );\n        omu.network.addPacketHandler(\n            SESSION_DISCONNECTED_PACKET_TYPE, (app) => this.handleSessionDisconnect(app),\n        );\n        this.sessions = omu.tables.get(SESSION_TABLE_TYPE);\n        omu.network.addTask(() => this.onTask());\n        omu.onReady(() => this.onReady());\n    }\n\n    public async has(id: IntoId): Promise<boolean> {\n        return await this.sessions.has(Identifier.from(id).key());\n    }\n\n    public observe(appId: IntoId, {\n        onConnect,\n        onDisconnect,\n    }: {\n        onConnect(app: App): void;\n        onDisconnect(app: App): void;\n    }): SessionObserver {\n        const id = Identifier.from(appId);\n        if (this.omu.running) {\n            this.omu.send(SESSION_OBSERVE_PACKET_TYPE, [id]);\n        }\n        const observer = this.sessionObservers.get(id) ?? new SessionObserver([], []);\n        observer.onConnect(onConnect);\n        observer.onDisconnect(onDisconnect);\n        this.sessionObservers.set(id, observer);\n        return observer;\n    }\n\n    private async handleSessionConnect(app: App): Promise<void> {\n        const observer = this.sessionObservers.get(app.id);\n        if (!observer) {\n            return;\n        }\n        for (const callback of observer.onConnectCallbacks) {\n            await callback(app);\n        }\n    }\n\n    private async handleSessionDisconnect(app: App): Promise<void> {\n        const observer = this.sessionObservers.get(app.id);\n        if (!observer) {\n            return;\n        }\n        for (const callback of observer.onDisconnectCallbacks) {\n            await callback(app);\n        }\n    }\n\n    public require(...appIds: IntoId[]): void {\n        if (this.omu.running) {\n            throw new Error('Cannot require apps after the client has started');\n        }\n        for (const appId of appIds) {\n            this.requiredApps.add(Identifier.from(appId));\n        }\n    }\n\n    private async onTask(): Promise<void> {\n        if (this.requiredApps.size > 0) {\n            this.omu.send(REQUIRE_APPS_PACKET_TYPE, Array.from(this.requiredApps.values()));\n        }\n    }\n\n    private async onReady(): Promise<void> {\n        if (this.sessionObservers.size > 0) {\n            this.omu.send(SESSION_OBSERVE_PACKET_TYPE, Array.from(this.sessionObservers.keys()));\n        }\n    }\n\n    public async requestRemoteApp(options: {\n        app: App;\n        permissions: IntoId[];\n    }): Promise<RequestRemoteAppResponse> {\n        const { app } = options;\n        if (!app.url) {\n            throw new Error('App must have a URL to request it remotely');\n        }\n        if (app.type !== 'remote') {\n            throw new Error('App must be a remote app to request it remotely');\n        }\n        if (!app.metadata) {\n            throw new Error('App must have metadata to request it remotely');\n        }\n        return this.omu.endpoints.call(REMOTE_APP_REQUEST_ENDPOINT_TYPE, {\n            app: App.serialize(options.app),\n            permissions: options.permissions.map(id => Identifier.from(id).key()),\n        });\n    }\n\n    public async generateToken(options: {\n        app: App;\n        permissions: IntoId[];\n    }): Promise<GenerateTokenResponse> {\n        return this.omu.endpoints.call(GENERATE_TOKEN_ENDPOINT_TYPE, {\n            app: App.serialize(options.app),\n            permissions: options.permissions.map(id => Identifier.from(id).key()),\n        });\n    }\n}\n"
  ],
  "mappings": "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",
  "debugId": "A3B60CEE774E7BF364756E2164756E21",
  "names": []
}