@pluv/platform-pluv 3.2.2 → 4.0.0

package/dist/index.mjs

@@ -1,469 +1,467 @@
-var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
-  get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
-}) : x)(function(x) {
-  if (typeof require !== "undefined") return require.apply(this, arguments);
-  throw Error('Dynamic require of "' + x + '" is not supported');
-});
-var __async = (__this, __arguments, generator) => {
-  return new Promise((resolve, reject) => {
-    var fulfilled = (value) => {
-      try {
-        step(generator.next(value));
-      } catch (e) {
-        reject(e);
-      }
-    };
-    var rejected = (value) => {
-      try {
-        step(generator.throw(value));
-      } catch (e) {
-        reject(e);
-      }
-    };
-    var step = (x) => x.done ? resolve(x.value) : Promise.resolve(x.value).then(fulfilled, rejected);
-    step((generator = generator.apply(__this, __arguments)).next());
-  });
-};
-
-// src/PluvPlatform.ts
+import { createRequire } from "node:module";
 import { AbstractPlatform } from "@pluv/io";
 import stringify from "fast-json-stable-stringify";
 import { Hono } from "hono";
+import { z } from "zod";
 
-// src/constants.ts
-var SIGNATURE_ALGORITHM = "sha256";
-var SIGNATURE_HEADER = "x-pluv-signature-256";
+//#region rolldown:runtime
+var __require = /* @__PURE__ */ createRequire(import.meta.url);
 
-// src/schemas.ts
-import { z } from "zod";
-var ZodEventKind = z.union([
-  z.literal("initial-storage"),
-  z.literal("room-deleted"),
-  z.literal("user-connected"),
-  z.literal("user-disconnected")
+//#endregion
+//#region src/constants.ts
+const SIGNATURE_ALGORITHM = "sha256";
+const SIGNATURE_HEADER = "x-pluv-signature-256";
+
+//#endregion
+//#region src/schemas.ts
+const ZodEventKind = z.union([
+	z.literal("initial-storage"),
+	z.literal("room-destroyed"),
+	z.literal("storage-destroyed"),
+	z.literal("user-connected"),
+	z.literal("user-disconnected")
 ]);
-var ZodEventInitialStorage = z.object({
-  event: z.literal("initial-storage"),
-  data: z.object({
-    room: z.string()
-  })
+const ZodEventInitialStorage = z.object({
+	event: z.literal("initial-storage"),
+	data: z.object({ room: z.string() })
+});
+const ZodEventRoomDestroyed = z.object({
+	event: z.literal("room-destroyed"),
+	data: z.object({ room: z.string() })
 });
-var ZodEventRoomDeleted = z.object({
-  event: z.literal("room-deleted"),
-  data: z.object({
-    room: z.string(),
-    storage: z.string().nullable()
-  })
+const ZodEventStorageDestroyed = z.object({
+	event: z.literal("storage-destroyed"),
+	data: z.object({
+		room: z.string(),
+		storage: z.string().nullable()
+	})
 });
-var ZodEventUserConnected = z.object({
-  event: z.literal("user-connected"),
-  data: z.object({
-    room: z.string(),
-    storage: z.string().nullable(),
-    user: z.object({
-      id: z.string()
-    }).passthrough()
-  })
+const ZodEventUserConnected = z.object({
+	event: z.literal("user-connected"),
+	data: z.object({
+		room: z.string(),
+		storage: z.string().nullable(),
+		user: z.object({ id: z.string() }).passthrough()
+	})
 });
-var ZodEventUserDisconnected = z.object({
-  event: z.literal("user-disconnected"),
-  data: z.object({
-    room: z.string(),
-    storage: z.string().nullable(),
-    user: z.object({
-      id: z.string()
-    }).passthrough()
-  })
+const ZodEventUserDisconnected = z.object({
+	event: z.literal("user-disconnected"),
+	data: z.object({
+		room: z.string(),
+		storage: z.string().nullable(),
+		user: z.object({ id: z.string() }).passthrough()
+	})
 });
-var ZodEvent = z.discriminatedUnion("event", [
-  ZodEventInitialStorage,
-  ZodEventRoomDeleted,
-  ZodEventUserConnected,
-  ZodEventUserDisconnected
+const ZodEvent = z.discriminatedUnion("event", [
+	ZodEventInitialStorage,
+	ZodEventRoomDestroyed,
+	ZodEventStorageDestroyed,
+	ZodEventUserConnected,
+	ZodEventUserDisconnected
 ]);
-var ZodInitialStorageResponse = z.object({
-  event: z.literal("initial-storage"),
-  room: z.string(),
-  storage: z.string().nullable()
+const ZodInitialStorageResponse = z.object({
+	event: z.literal("initial-storage"),
+	room: z.string(),
+	storage: z.string().nullable()
 });
-var ZodRoomDeletedResponse = z.object({
-  event: z.literal("room-deleted"),
-  room: z.string()
+const ZodRoomDestroyedResponse = z.object({
+	event: z.literal("room-destroyed"),
+	room: z.string()
 });
-var ZodUserConnectedResponse = z.object({
-  event: z.literal("user-connected"),
-  room: z.string()
+const ZodStorageDestroyedResponse = z.object({
+	event: z.literal("storage-destroyed"),
+	room: z.string()
 });
-var ZodUserDisconnectedResponse = z.object({
-  event: z.literal("user-disconnected"),
-  room: z.string()
+const ZodUserConnectedResponse = z.object({
+	event: z.literal("user-connected"),
+	room: z.string()
 });
-var ZodEventResponse = z.discriminatedUnion("event", [
-  ZodInitialStorageResponse,
-  ZodRoomDeletedResponse,
-  ZodUserConnectedResponse,
-  ZodUserDisconnectedResponse
+const ZodUserDisconnectedResponse = z.object({
+	event: z.literal("user-disconnected"),
+	room: z.string()
+});
+const ZodEventResponse = z.discriminatedUnion("event", [
+	ZodInitialStorageResponse,
+	ZodRoomDestroyedResponse,
+	ZodStorageDestroyedResponse,
+	ZodUserConnectedResponse,
+	ZodUserDisconnectedResponse
 ]);
 
-// src/shared/createErrorResponse.ts
-var createErrorResponse = (c, error, status) => {
-  return c.json({ ok: false, error: { message: error.message } }, status);
+//#endregion
+//#region src/shared/createErrorResponse.ts
+const createErrorResponse = (c, error, status) => {
+	return c.json({
+		ok: false,
+		error: { message: error.message }
+	}, status);
 };
 
-// src/shared/getCrypto.ts
-var getCrypto = () => {
-  if (typeof crypto !== "undefined") {
-    return crypto;
-  }
-  if (typeof __require === "function") {
-    return __require("crypto").webcrypto;
-  }
-  throw new Error("Missing crypto module");
+//#endregion
+//#region src/shared/getCrypto.ts
+const getCrypto = () => {
+	if (typeof crypto !== "undefined") return crypto;
+	if (typeof __require === "function") return __require("node:crypto").webcrypto;
+	throw new Error("Missing crypto module");
 };
 
-// src/shared/createHmac.ts
-var createHmac = (params) => __async(null, null, function* () {
-  const { payload, secret } = params;
-  if (!payload || !secret) throw new Error("Secret and payload are required to sign payload");
-  const encoder = new TextEncoder();
-  const keyBytes = encoder.encode(secret);
-  const crypto2 = getCrypto();
-  const algorithm = { name: "HMAC", hash: { name: "SHA-256" } };
-  const extractable = false;
-  const key = yield crypto2.subtle.importKey("raw", keyBytes, algorithm, extractable, [
-    "sign",
-    "verify"
-  ]);
-  const payloadBytes = encoder.encode(payload);
-  const signature = yield crypto2.subtle.sign("HMAC", key, payloadBytes);
-  const hmac = Array.from(new Uint8Array(signature)).map((b) => ("0" + b.toString(16)).slice(-2)).join("");
-  return { algorithm: "sha256", hmac };
-});
+//#endregion
+//#region src/shared/createHmac.ts
+const createHmac = async (params) => {
+	const { payload, secret } = params;
+	if (!payload || !secret) throw new Error("Secret and payload are required to sign payload");
+	const encoder = new TextEncoder();
+	const keyBytes = encoder.encode(secret);
+	const crypto = getCrypto();
+	const key = await crypto.subtle.importKey("raw", keyBytes, {
+		name: "HMAC",
+		hash: { name: "SHA-256" }
+	}, false, ["sign", "verify"]);
+	const payloadBytes = encoder.encode(payload);
+	const signature = await crypto.subtle.sign("HMAC", key, payloadBytes);
+	return {
+		algorithm: "sha256",
+		hmac: Array.from(new Uint8Array(signature)).map((b) => ("0" + b.toString(16)).slice(-2)).join("")
+	};
+};
 
-// src/shared/createSuccessResponse.ts
-var createSuccessResponse = (c, data, status = 200) => {
-  return c.json(
-    {
-      ok: true,
-      data: ZodEventResponse.parse(data)
-    },
-    status
-  );
+//#endregion
+//#region src/shared/createSuccessResponse.ts
+const createSuccessResponse = (c, data, status = 200) => {
+	return c.json({
+		ok: true,
+		data: ZodEventResponse.parse(data)
+	}, status);
 };
 
-// src/shared/HttpError.ts
+//#endregion
+//#region src/shared/HttpError.ts
 var HttpError = class extends Error {
-  constructor(message, status) {
-    super(message);
-    this.status = status;
-  }
+	status;
+	constructor(message, status) {
+		super(message);
+		this.status = status;
+	}
 };
 
-// src/shared/timingSafeEqual.ts
-var timingSafeEqual = (a, b) => {
-  if (a.length !== b.length) return false;
-  let result = 0;
-  for (let i = 0; i < a.length; i++) {
-    result |= a[i] ^ b[i];
-  }
-  return result === 0;
+//#endregion
+//#region src/shared/timingSafeEqual.ts
+const timingSafeEqual = (a, b) => {
+	if (a.length !== b.length) return false;
+	let result = 0;
+	for (let i = 0; i < a.length; i++) result |= a[i] ^ b[i];
+	return result === 0;
 };
 
-// src/shared/verifyWebhook.ts
-var verifyWebhook = (params) => __async(null, null, function* () {
-  const { payload, secret, signature } = params;
-  if (!secret || !payload || !signature) {
-    throw new Error("Secret, payload and signature are required to verify payload");
-  }
-  const { hmac } = yield createHmac({ payload, secret });
-  if (hmac.length !== signature.length) return false;
-  const encoder = new TextEncoder();
-  const verificationBytes = encoder.encode(hmac);
-  const signatureBytes = encoder.encode(signature);
-  if (verificationBytes.length !== signatureBytes.length) return false;
-  return timingSafeEqual(verificationBytes, signatureBytes);
-});
+//#endregion
+//#region src/shared/verifyWebhook.ts
+const verifyWebhook = async (params) => {
+	const { payload, secret, signature } = params;
+	if (!secret || !payload || !signature) throw new Error("Secret, payload and signature are required to verify payload");
+	const { hmac } = await createHmac({
+		payload,
+		secret
+	});
+	if (hmac.length !== signature.length) return false;
+	const encoder = new TextEncoder();
+	const verificationBytes = encoder.encode(hmac);
+	const signatureBytes = encoder.encode(signature);
+	if (verificationBytes.length !== signatureBytes.length) return false;
+	return timingSafeEqual(verificationBytes, signatureBytes);
+};
 
-// src/PluvPlatform.ts
+//#endregion
+//#region src/PluvPlatform.ts
 var PluvPlatform = class extends AbstractPlatform {
-  constructor(params) {
-    var _a, _b;
-    super();
-    this.id = Math.random().toString();
-    this._config = {
-      authorize: {
-        secret: false
-      },
-      handleMode: "fetch",
-      registrationMode: "attached",
-      requireAuth: true,
-      listeners: {
-        onRoomDeleted: true,
-        onRoomMessage: false,
-        onStorageUpdated: false,
-        onUserConnected: true,
-        onUserDisconnected: true
-      },
-      router: false
-    };
-    this._name = "platformPluv";
-    this._createToken = (params) => __async(this, null, function* () {
-      var _a, _b;
-      const parsed = params.authorize.user.parse(params.user);
-      const [endpoints, publicKey, secretKey] = yield Promise.all([
-        typeof this._endpoints === "object" ? this._endpoints : this._endpoints(),
-        typeof this._publicKey === "string" ? this._publicKey : this._publicKey(),
-        typeof this._secretKey === "string" ? this._secretKey : this._secretKey()
-      ]);
-      this._logDebug({ endpoints, publicKey, secretKey });
-      const res = yield fetch(endpoints.createToken, {
-        headers: { "content-type": "application/json" },
-        method: "post",
-        body: JSON.stringify({
-          maxAge: (_a = params.maxAge) != null ? _a : null,
-          publicKey,
-          room: params.room,
-          secretKey,
-          user: parsed
-        })
-      }).catch((error) => {
-        this._logDebug(error);
-        return null;
-      });
-      this._logDebug({ response: { status: (_b = res == null ? void 0 : res.status) != null ? _b : null } });
-      if (!res || !res.ok || res.status !== 200) {
-        throw new Error("Authorization failed");
-      }
-      const token = yield res.text().catch(() => null);
-      this._logDebug({ token });
-      if (typeof token !== "string") throw new Error("Authorization failed");
-      return token;
-    });
-    this._webhooksRouter = new Hono().basePath("/").post("/", (c) => __async(this, null, function* () {
-      var _a, _b, _c, _d, _e, _f, _g, _h;
-      const [algorithm, signature] = (_b = (_a = c.req.header(SIGNATURE_HEADER)) == null ? void 0 : _a.split("=")) != null ? _b : [];
-      try {
-        if (!this._webhookSecret) {
-          this._logDebug("Missing webhook secret");
-          throw new HttpError("Unauthorized", 401);
-        }
-        if (algorithm !== SIGNATURE_ALGORITHM) {
-          this._logDebug(
-            `Verification algorithm is not ${SIGNATURE_ALGORITHM}. Found: `,
-            algorithm
-          );
-          throw new HttpError("Unauthorized", 401);
-        }
-        if (!signature) {
-          this._logDebug("Missing webhook signature");
-          throw new HttpError("Unauthorized", 401);
-        }
-        const [payload, webhookSecret] = yield Promise.all([
-          c.req.json(),
-          typeof this._webhookSecret === "string" ? this._webhookSecret : yield this._webhookSecret()
-        ]).catch((error) => {
-          this._logDebug(
-            "Could not derive webhook secret: ",
-            error instanceof Error ? error.message : "Unexpected error"
-          );
-          throw error;
-        });
-        const verified = yield verifyWebhook({
-          payload: stringify(payload),
-          signature,
-          secret: webhookSecret
-        }).catch((error) => {
-          this._logDebug(
-            "Error while verifying webhook: ",
-            error instanceof Error ? error.message : "Unexpected error"
-          );
-          return false;
-        });
-        if (!verified) {
-          this._logDebug("Failed to verify webhook");
-          throw new HttpError("Unauthorized", 401);
-        }
-        const parsed = ZodEvent.safeParse(payload);
-        if (!parsed.success) {
-          this._logDebug(
-            "Failed to validate event payload:",
-            JSON.stringify((_c = parsed.data) != null ? _c : {}, null, 4)
-          );
-          throw new HttpError("Invalid request", 400);
-        }
-        const { event, data } = parsed.data;
-        const context = yield this._getContext();
-        switch (event) {
-          case "initial-storage": {
-            const room = data.room;
-            const storage = typeof room === "string" ? (_e = yield (_d = this._getInitialStorage) == null ? void 0 : _d.call(this, { context, room })) != null ? _e : null : null;
-            try {
-              return createSuccessResponse(c, { event, room, storage });
-            } catch (error) {
-              this._logDebug("Could not create getInitialStorage response");
-              throw error;
-            }
-          }
-          case "room-deleted": {
-            const room = data.room;
-            const encodedState = data.storage;
-            yield Promise.resolve(
-              (_f = this._listeners) == null ? void 0 : _f.onRoomDeleted({ context, encodedState, room })
-            );
-            try {
-              return createSuccessResponse(c, { event, room });
-            } catch (error) {
-              this._logDebug("Could not create onRoomDeleted response");
-              throw error;
-            }
-          }
-          case "user-connected": {
-            const room = data.room;
-            const encodedState = data.storage;
-            const user = data.user;
-            yield Promise.resolve(
-              (_g = this._listeners) == null ? void 0 : _g.onUserConnected({
-                context,
-                encodedState,
-                platform: this,
-                room,
-                user
-              })
-            );
-            try {
-              return createSuccessResponse(c, { event, room });
-            } catch (error) {
-              this._logDebug("Could not create onUserConnected response");
-              throw error;
-            }
-          }
-          case "user-disconnected": {
-            const room = data.room;
-            const encodedState = data.storage;
-            const user = data.user;
-            yield Promise.resolve(
-              (_h = this._listeners) == null ? void 0 : _h.onUserDisconnected({
-                context,
-                encodedState,
-                platform: this,
-                room,
-                user
-              })
-            );
-            try {
-              return createSuccessResponse(c, { event, room });
-            } catch (error) {
-              this._logDebug("Could not create onUserDisconnected response");
-              throw error;
-            }
-          }
-          default: {
-            throw new HttpError("Unknown event", 400);
-          }
-        }
-      } catch (error) {
-        const message = error instanceof Error ? error.message : "Unexpected error";
-        const status = error instanceof HttpError ? error.status : 500;
-        this._logDebug("Uncaught error: ", message);
-        return createErrorResponse(c, { message }, status);
-      }
-    }));
-    const { _defs, basePath, context, publicKey, secretKey, webhookSecret } = params;
-    this._basePath = basePath;
-    this._context = context != null ? context : {};
-    this._debug = (_a = _defs == null ? void 0 : _defs.debug) != null ? _a : false;
-    this._endpoints = (_b = _defs == null ? void 0 : _defs.endpoints) != null ? _b : {
-      createToken: "https://rooms.pluv.io/api/room/token"
-    };
-    this._publicKey = publicKey;
-    this._secretKey = secretKey;
-    this._webhookSecret = webhookSecret;
-    this._app = new Hono().basePath(this._basePath).route("/", this._webhooksRouter);
-    this._fetch = this._app.fetch;
-  }
-  acceptWebSocket(webSocket) {
-    throw new Error("Not implemented");
-  }
-  convertWebSocket(webSocket, config) {
-    throw new Error("Not implemented");
-  }
-  getLastPing(webSocket) {
-    throw new Error("Not implemented");
-  }
-  getSerializedState(webSocket) {
-    throw new Error("Not implemented");
-  }
-  getSessionId(webSocket) {
-    throw new Error("Not implemented");
-  }
-  getWebSockets() {
-    throw new Error("Not implemented");
-  }
-  initialize(config) {
-    throw new Error("Not implemented");
-  }
-  parseData(data) {
-    throw new Error("Not implemented");
-  }
-  randomUUID() {
-    throw new Error("Not implemented");
-  }
-  setSerializedState(webSocket, state) {
-    throw new Error("Not implemented");
-  }
-  validateConfig(config) {
-    this._logDebug("validating config with properties:", Object.keys(config != null ? config : {}));
-    if (!config.authorize) {
-      this._logDebug("Config `authorize` must be provided to `platformPluv`");
-      throw new Error("Config `authorize` must be provided to `platformPluv`");
-    }
-    if (!!config.onRoomMessage) {
-      this._logDebug("Config `onRoomMessage` is not supported on `platformPluv`");
-      throw new Error("Config `onRoomMessage` is not supported on `platformPluv`");
-    }
-    if (!!config.onStorageUpdated) {
-      this._logDebug("Config `onStorageUpdated` is not supported on `platformPluv`");
-      throw new Error("Config `onStorageUpdated` is not supported on `platformPluv`");
-    }
-    this._getInitialStorage = config.getInitialStorage;
-    this._listeners = {
-      onRoomDeleted: (event) => {
-        var _a;
-        return (_a = config.onRoomDeleted) == null ? void 0 : _a.call(config, event);
-      },
-      onUserConnected: (event) => {
-        var _a;
-        return (_a = config.onUserConnected) == null ? void 0 : _a.call(config, event);
-      },
-      onUserDisconnected: (event) => {
-        var _a;
-        return (_a = config.onUserDisconnected) == null ? void 0 : _a.call(config, event);
-      }
-    };
-  }
-  _getContext() {
-    return __async(this, null, function* () {
-      return typeof this._context === "function" ? yield Promise.resolve(this._context(this._roomContext)) : yield Promise.resolve(this._context);
-    });
-  }
-  _logDebug(...args) {
-    if (!this._debug) return;
-    console.log("[PLATFORM PLUV]", ...args);
-  }
+	id = Math.random().toString();
+	_config = {
+		authorize: { secret: false },
+		handleMode: "fetch",
+		registrationMode: "attached",
+		requireAuth: true,
+		listeners: {
+			onRoomDestroyed: true,
+			onRoomMessage: false,
+			onStorageDestroyed: true,
+			onStorageUpdated: false,
+			onUserConnected: true,
+			onUserDisconnected: true
+		},
+		router: false
+	};
+	_name = "platformPluv";
+	_app;
+	_basePath;
+	_context;
+	_debug;
+	_endpoints;
+	_getInitialStorage;
+	_listeners;
+	_publicKey;
+	_secretKey;
+	_webhookSecret;
+	_createToken = async (params) => {
+		const parsed = params.authorize.user.parse(params.user);
+		const [endpoints, publicKey, secretKey] = await Promise.all([
+			typeof this._endpoints === "object" ? this._endpoints : this._endpoints(),
+			typeof this._publicKey === "string" ? this._publicKey : this._publicKey(),
+			typeof this._secretKey === "string" ? this._secretKey : this._secretKey()
+		]);
+		this._logDebug({
+			endpoints,
+			publicKey,
+			secretKey
+		});
+		const res = await fetch(endpoints.createToken, {
+			headers: { "content-type": "application/json" },
+			method: "post",
+			body: JSON.stringify({
+				maxAge: params.maxAge ?? null,
+				publicKey,
+				room: params.room,
+				secretKey,
+				user: parsed
+			})
+		}).catch((error) => {
+			this._logDebug(error);
+			return null;
+		});
+		this._logDebug({ response: { status: res?.status ?? null } });
+		if (!res || !res.ok || res.status !== 200) throw new Error("Authorization failed");
+		const token = await res.text().catch(() => null);
+		this._logDebug({ token });
+		if (typeof token !== "string") throw new Error("Authorization failed");
+		return token;
+	};
+	constructor(params) {
+		super();
+		const { _defs, basePath, context, publicKey, secretKey, webhookSecret } = params;
+		this._basePath = basePath;
+		this._context = context ?? {};
+		this._debug = _defs?.debug ?? false;
+		this._endpoints = _defs?.endpoints ?? { createToken: "https://rooms.pluv.io/api/room/token" };
+		this._publicKey = publicKey;
+		this._secretKey = secretKey;
+		this._webhookSecret = webhookSecret;
+		this._app = new Hono().basePath(this._basePath).route("/", this._webhooksRouter);
+		this._fetch = this._app.fetch;
+	}
+	acceptWebSocket(webSocket) {
+		throw new Error("Not implemented");
+	}
+	convertWebSocket(webSocket, config) {
+		throw new Error("Not implemented");
+	}
+	getLastPing(webSocket) {
+		throw new Error("Not implemented");
+	}
+	getSerializedState(webSocket) {
+		throw new Error("Not implemented");
+	}
+	getSessionId(webSocket) {
+		throw new Error("Not implemented");
+	}
+	getWebSockets() {
+		throw new Error("Not implemented");
+	}
+	initialize(config) {
+		throw new Error("Not implemented");
+	}
+	parseData(data) {
+		throw new Error("Not implemented");
+	}
+	randomUUID() {
+		throw new Error("Not implemented");
+	}
+	setSerializedState(webSocket, state) {
+		throw new Error("Not implemented");
+	}
+	validateConfig(config) {
+		this._logDebug("validating config with properties:", Object.keys(config ?? {}));
+		if (!config.authorize) {
+			this._logDebug("Config `authorize` must be provided to `platformPluv`");
+			throw new Error("Config `authorize` must be provided to `platformPluv`");
+		}
+		if (!!config.onRoomMessage) {
+			this._logDebug("Config `onRoomMessage` is not supported on `platformPluv`");
+			throw new Error("Config `onRoomMessage` is not supported on `platformPluv`");
+		}
+		if (!!config.onStorageUpdated) {
+			this._logDebug("Config `onStorageUpdated` is not supported on `platformPluv`");
+			throw new Error("Config `onStorageUpdated` is not supported on `platformPluv`");
+		}
+		this._getInitialStorage = config.getInitialStorage;
+		this._listeners = {
+			onRoomDestroyed: (event) => config.onRoomDestroyed?.(event),
+			onStorageDestroyed: (event) => config.onStorageDestroyed?.(event),
+			onUserConnected: (event) => config.onUserConnected?.(event),
+			onUserDisconnected: (event) => config.onUserDisconnected?.(event)
+		};
+	}
+	_webhooksRouter = new Hono().basePath("/").post("/", async (c) => {
+		const [algorithm, signature] = c.req.header(SIGNATURE_HEADER)?.split("=") ?? [];
+		try {
+			if (!this._webhookSecret) {
+				this._logDebug("Missing webhook secret");
+				throw new HttpError("Unauthorized", 401);
+			}
+			if (algorithm !== SIGNATURE_ALGORITHM) {
+				this._logDebug(`Verification algorithm is not ${SIGNATURE_ALGORITHM}. Found: `, algorithm);
+				throw new HttpError("Unauthorized", 401);
+			}
+			if (!signature) {
+				this._logDebug("Missing webhook signature");
+				throw new HttpError("Unauthorized", 401);
+			}
+			const [payload, webhookSecret] = await Promise.all([c.req.json(), typeof this._webhookSecret === "string" ? this._webhookSecret : await this._webhookSecret()]).catch((error) => {
+				this._logDebug("Could not derive webhook secret: ", error instanceof Error ? error.message : "Unexpected error");
+				throw error;
+			});
+			if (!await verifyWebhook({
+				payload: stringify(payload),
+				signature,
+				secret: webhookSecret
+			}).catch((error) => {
+				this._logDebug("Error while verifying webhook: ", error instanceof Error ? error.message : "Unexpected error");
+				return false;
+			})) {
+				this._logDebug("Failed to verify webhook");
+				throw new HttpError("Unauthorized", 401);
+			}
+			const parsed = ZodEvent.safeParse(payload);
+			if (!parsed.success) {
+				this._logDebug("Failed to validate event payload:", JSON.stringify(parsed.data ?? {}, null, 4));
+				throw new HttpError("Invalid request", 400);
+			}
+			const { event, data } = parsed.data;
+			const context = await this._getContext();
+			switch (event) {
+				case "initial-storage": {
+					const room = data.room;
+					const storage = typeof room === "string" ? await this._getInitialStorage?.({
+						context,
+						room
+					}) ?? null : null;
+					try {
+						return createSuccessResponse(c, {
+							event,
+							room,
+							storage
+						});
+					} catch (error) {
+						this._logDebug("Could not create getInitialStorage response");
+						throw error;
+					}
+				}
+				case "room-destroyed": {
+					const room = data.room;
+					await Promise.resolve(this._listeners?.onRoomDestroyed({
+						context,
+						platform: this,
+						room
+					}));
+					try {
+						return createSuccessResponse(c, {
+							event,
+							room
+						});
+					} catch (error) {
+						this._logDebug("Could not create onRoomDestroyed response");
+						throw error;
+					}
+				}
+				case "storage-destroyed": {
+					const room = data.room;
+					const encodedState = data.storage;
+					await Promise.resolve(this._listeners?.onStorageDestroyed({
+						context,
+						encodedState,
+						platform: this,
+						room
+					}));
+					try {
+						return createSuccessResponse(c, {
+							event,
+							room
+						});
+					} catch (error) {
+						this._logDebug("Could not create onStorageDestroyed response");
+						throw error;
+					}
+				}
+				case "user-connected": {
+					const room = data.room;
+					const encodedState = data.storage;
+					const user = data.user;
+					await Promise.resolve(this._listeners?.onUserConnected({
+						context,
+						encodedState,
+						platform: this,
+						room,
+						user
+					}));
+					try {
+						return createSuccessResponse(c, {
+							event,
+							room
+						});
+					} catch (error) {
+						this._logDebug("Could not create onUserConnected response");
+						throw error;
+					}
+				}
+				case "user-disconnected": {
+					const room = data.room;
+					const encodedState = data.storage;
+					const user = data.user;
+					await Promise.resolve(this._listeners?.onUserDisconnected({
+						context,
+						encodedState,
+						platform: this,
+						room,
+						user
+					}));
+					try {
+						return createSuccessResponse(c, {
+							event,
+							room
+						});
+					} catch (error) {
+						this._logDebug("Could not create onUserDisconnected response");
+						throw error;
+					}
+				}
+				default: throw new HttpError("Unknown event", 400);
+			}
+		} catch (error) {
+			const message = error instanceof Error ? error.message : "Unexpected error";
+			const status = error instanceof HttpError ? error.status : 500;
+			this._logDebug("Uncaught error: ", message);
+			return createErrorResponse(c, { message }, status);
+		}
+	});
+	async _getContext() {
+		return typeof this._context === "function" ? await Promise.resolve(this._context(this._roomContext)) : await Promise.resolve(this._context);
+	}
+	_logDebug(...args) {
+		if (!this._debug) return;
+		console.log("[PLATFORM PLUV]", ...args);
+	}
 };
 
-// src/platformPluv.ts
-var platformPluv = (config) => {
-  const { authorize, context, crdt, debug } = config;
-  return {
-    authorize,
-    context,
-    crdt,
-    debug,
-    platform: () => new PluvPlatform(config)
-  };
-};
-export {
-  PluvPlatform,
-  platformPluv
+//#endregion
+//#region src/platformPluv.ts
+const platformPluv = (config) => {
+	const { authorize, context, crdt, debug } = config;
+	return {
+		authorize,
+		context,
+		crdt,
+		debug,
+		platform: () => new PluvPlatform(config)
+	};
 };
+
+//#endregion
+export { PluvPlatform, platformPluv };
+//# sourceMappingURL=index.mjs.map