@bpmnkit/api 0.0.8

package/dist/runtime/config.js

@@ -0,0 +1,371 @@
+import { readFileSync } from "node:fs";
+import { CamundaError } from "./errors.js";
+import { parseYaml } from "./yaml.js";
+// ─── Environment variable names ───────────────────────────────────────────────
+const ENV = {
+    BASE_URL: "CAMUNDA_BASE_URL",
+    CONFIG_FILE: "CAMUNDA_CONFIG_FILE",
+    TIMEOUT: "CAMUNDA_TIMEOUT",
+    AUTH_TYPE: "CAMUNDA_AUTH_TYPE",
+    AUTH_TOKEN: "CAMUNDA_AUTH_TOKEN",
+    AUTH_CLIENT_ID: "CAMUNDA_AUTH_CLIENT_ID",
+    AUTH_CLIENT_SECRET: "CAMUNDA_AUTH_CLIENT_SECRET",
+    AUTH_TOKEN_URL: "CAMUNDA_AUTH_TOKEN_URL",
+    AUTH_SCOPE: "CAMUNDA_AUTH_SCOPE",
+    AUTH_USERNAME: "CAMUNDA_AUTH_USERNAME",
+    AUTH_PASSWORD: "CAMUNDA_AUTH_PASSWORD",
+    TOKEN_CACHE_DISABLED: "CAMUNDA_TOKEN_CACHE_DISABLED",
+    TOKEN_CACHE_FILE: "CAMUNDA_TOKEN_CACHE_FILE",
+    RETRY_MAX_ATTEMPTS: "CAMUNDA_RETRY_MAX_ATTEMPTS",
+    RETRY_INITIAL_DELAY: "CAMUNDA_RETRY_INITIAL_DELAY",
+    RETRY_MAX_DELAY: "CAMUNDA_RETRY_MAX_DELAY",
+    RETRY_BACKOFF_FACTOR: "CAMUNDA_RETRY_BACKOFF_FACTOR",
+    RETRY_ON: "CAMUNDA_RETRY_ON",
+    CACHE_ENABLED: "CAMUNDA_CACHE_ENABLED",
+    CACHE_TTL: "CAMUNDA_CACHE_TTL",
+    CACHE_MAX_SIZE: "CAMUNDA_CACHE_MAX_SIZE",
+    LOG_LEVEL: "CAMUNDA_LOG_LEVEL",
+};
+// ─── Env loader ───────────────────────────────────────────────────────────────
+function loadFromEnv() {
+    const e = process.env;
+    const result = {};
+    if (e[ENV.BASE_URL])
+        result.baseUrl = e[ENV.BASE_URL];
+    if (e[ENV.CONFIG_FILE])
+        result.configFile = e[ENV.CONFIG_FILE];
+    if (e[ENV.TIMEOUT])
+        result.timeout = Number.parseInt(e[ENV.TIMEOUT] ?? "", 10);
+    const auth = authFromEnv(e);
+    if (auth)
+        result.auth = auth;
+    const retry = retryFromEnv(e);
+    if (retry)
+        result.retry = retry;
+    const cache = cacheFromEnv(e);
+    if (cache)
+        result.cache = cache;
+    const logger = loggerFromEnv(e);
+    if (logger)
+        result.logger = logger;
+    return result;
+}
+function authFromEnv(e) {
+    const type = e[ENV.AUTH_TYPE];
+    if (!type)
+        return undefined;
+    switch (type) {
+        case "bearer": {
+            const token = e[ENV.AUTH_TOKEN];
+            if (!token)
+                return undefined;
+            return { type: "bearer", token };
+        }
+        case "oauth2": {
+            const clientId = e[ENV.AUTH_CLIENT_ID];
+            const clientSecret = e[ENV.AUTH_CLIENT_SECRET];
+            const tokenUrl = e[ENV.AUTH_TOKEN_URL];
+            if (!clientId || !clientSecret || !tokenUrl)
+                return undefined;
+            const tokenCache = tokenCacheFromEnv(e);
+            return {
+                type: "oauth2",
+                clientId,
+                clientSecret,
+                tokenUrl,
+                ...(e[ENV.AUTH_SCOPE] ? { scope: e[ENV.AUTH_SCOPE] } : {}),
+                ...(tokenCache ? { tokenCache } : {}),
+            };
+        }
+        case "basic": {
+            const username = e[ENV.AUTH_USERNAME];
+            const password = e[ENV.AUTH_PASSWORD];
+            if (!username || !password)
+                return undefined;
+            return { type: "basic", username, password };
+        }
+        case "none":
+            return { type: "none" };
+        default:
+            return undefined;
+    }
+}
+function tokenCacheFromEnv(e) {
+    const disabled = e[ENV.TOKEN_CACHE_DISABLED];
+    const filePath = e[ENV.TOKEN_CACHE_FILE];
+    if (!disabled && !filePath)
+        return undefined;
+    return {
+        ...(disabled !== undefined ? { disabled: disabled === "true" || disabled === "1" } : {}),
+        ...(filePath ? { filePath } : {}),
+    };
+}
+function retryFromEnv(e) {
+    const cfg = {};
+    if (e[ENV.RETRY_MAX_ATTEMPTS])
+        cfg.maxAttempts = Number.parseInt(e[ENV.RETRY_MAX_ATTEMPTS] ?? "", 10);
+    if (e[ENV.RETRY_INITIAL_DELAY])
+        cfg.initialDelay = Number.parseInt(e[ENV.RETRY_INITIAL_DELAY] ?? "", 10);
+    if (e[ENV.RETRY_MAX_DELAY])
+        cfg.maxDelay = Number.parseInt(e[ENV.RETRY_MAX_DELAY] ?? "", 10);
+    if (e[ENV.RETRY_BACKOFF_FACTOR])
+        cfg.backoffFactor = Number.parseFloat(e[ENV.RETRY_BACKOFF_FACTOR] ?? "");
+    if (e[ENV.RETRY_ON]) {
+        cfg.retryOn = (e[ENV.RETRY_ON] ?? "")
+            .split(",")
+            .map((s) => Number.parseInt(s.trim(), 10))
+            .filter((n) => !Number.isNaN(n));
+    }
+    return Object.keys(cfg).length > 0 ? cfg : undefined;
+}
+function cacheFromEnv(e) {
+    const cfg = {};
+    if (e[ENV.CACHE_ENABLED] !== undefined) {
+        cfg.enabled = e[ENV.CACHE_ENABLED] === "true" || e[ENV.CACHE_ENABLED] === "1";
+    }
+    if (e[ENV.CACHE_TTL])
+        cfg.ttl = Number.parseInt(e[ENV.CACHE_TTL] ?? "", 10);
+    if (e[ENV.CACHE_MAX_SIZE])
+        cfg.maxSize = Number.parseInt(e[ENV.CACHE_MAX_SIZE] ?? "", 10);
+    return Object.keys(cfg).length > 0 ? cfg : undefined;
+}
+function loggerFromEnv(e) {
+    const level = e[ENV.LOG_LEVEL];
+    if (!level)
+        return undefined;
+    return { level };
+}
+// ─── File loader ──────────────────────────────────────────────────────────────
+function loadFromFile(filePath) {
+    let raw;
+    try {
+        raw = readFileSync(filePath, "utf8");
+    }
+    catch (err) {
+        throw new CamundaError(`Cannot read config file "${filePath}": ${err}`);
+    }
+    let doc;
+    try {
+        doc = parseYaml(raw);
+    }
+    catch (err) {
+        throw new CamundaError(`Cannot parse config file "${filePath}": ${err}`);
+    }
+    return coerceFileConfig(doc, filePath);
+}
+function coerceFileConfig(doc, filePath) {
+    const result = {};
+    if (typeof doc.baseUrl === "string")
+        result.baseUrl = doc.baseUrl;
+    if (typeof doc.configFile === "string")
+        result.configFile = doc.configFile;
+    if (typeof doc.timeout === "number")
+        result.timeout = doc.timeout;
+    const auth = coerceAuth(doc.auth, filePath);
+    if (auth)
+        result.auth = auth;
+    const retry = coerceRetry(doc.retry);
+    if (retry)
+        result.retry = retry;
+    const cache = coerceCache(doc.cache);
+    if (cache)
+        result.cache = cache;
+    const logger = coerceLogger(doc.logger);
+    if (logger)
+        result.logger = logger;
+    return result;
+}
+function coerceAuth(raw, filePath) {
+    if (typeof raw !== "object" || raw === null)
+        return undefined;
+    const a = raw;
+    const type = a.type;
+    switch (type) {
+        case "bearer":
+            if (typeof a.token !== "string")
+                return undefined;
+            return { type: "bearer", token: a.token };
+        case "oauth2": {
+            if (typeof a.clientId !== "string" ||
+                typeof a.clientSecret !== "string" ||
+                typeof a.tokenUrl !== "string") {
+                throw new CamundaError(`Config file "${filePath}": oauth2 auth requires clientId, clientSecret, and tokenUrl`);
+            }
+            const tokenCache = coerceTokenCache(a.tokenCache);
+            return {
+                type: "oauth2",
+                clientId: a.clientId,
+                clientSecret: a.clientSecret,
+                tokenUrl: a.tokenUrl,
+                ...(typeof a.scope === "string" ? { scope: a.scope } : {}),
+                ...(tokenCache ? { tokenCache } : {}),
+            };
+        }
+        case "basic":
+            if (typeof a.username !== "string" || typeof a.password !== "string")
+                return undefined;
+            return { type: "basic", username: a.username, password: a.password };
+        case "none":
+            return { type: "none" };
+        default:
+            return undefined;
+    }
+}
+function coerceTokenCache(raw) {
+    if (typeof raw !== "object" || raw === null)
+        return undefined;
+    const t = raw;
+    const cfg = {};
+    if (typeof t.disabled === "boolean")
+        cfg.disabled = t.disabled;
+    if (typeof t.filePath === "string")
+        cfg.filePath = t.filePath;
+    return Object.keys(cfg).length > 0 ? cfg : undefined;
+}
+function coerceRetry(raw) {
+    if (typeof raw !== "object" || raw === null)
+        return undefined;
+    const r = raw;
+    const cfg = {};
+    if (typeof r.maxAttempts === "number")
+        cfg.maxAttempts = r.maxAttempts;
+    if (typeof r.initialDelay === "number")
+        cfg.initialDelay = r.initialDelay;
+    if (typeof r.maxDelay === "number")
+        cfg.maxDelay = r.maxDelay;
+    if (typeof r.backoffFactor === "number")
+        cfg.backoffFactor = r.backoffFactor;
+    if (Array.isArray(r.retryOn)) {
+        cfg.retryOn = r.retryOn.filter((n) => typeof n === "number");
+    }
+    return Object.keys(cfg).length > 0 ? cfg : undefined;
+}
+function coerceCache(raw) {
+    if (typeof raw !== "object" || raw === null)
+        return undefined;
+    const c = raw;
+    const cfg = {};
+    if (typeof c.enabled === "boolean")
+        cfg.enabled = c.enabled;
+    if (typeof c.ttl === "number")
+        cfg.ttl = c.ttl;
+    if (typeof c.maxSize === "number")
+        cfg.maxSize = c.maxSize;
+    return Object.keys(cfg).length > 0 ? cfg : undefined;
+}
+function coerceLogger(raw) {
+    if (typeof raw !== "object" || raw === null)
+        return undefined;
+    const l = raw;
+    if (typeof l.level === "string")
+        return { level: l.level };
+    return undefined;
+}
+// ─── Merge ────────────────────────────────────────────────────────────────────
+/**
+ * Merge auth configs from multiple sources (lowest → highest priority).
+ * When the `type` matches across sources, fields are merged so you can
+ * split non-sensitive config (type, tokenUrl) from secrets (clientSecret).
+ */
+function mergeAuth(...sources) {
+    // Determine winning auth type from highest-priority source that declares one
+    let winningType;
+    for (const s of sources) {
+        if (s?.type)
+            winningType = s.type;
+    }
+    if (!winningType)
+        return undefined;
+    // Collect all fields from sources that share the winning type
+    const merged = { type: winningType };
+    for (const s of sources) {
+        if (!s)
+            continue;
+        if (s.type !== winningType)
+            continue; // different type — skip entirely
+        Object.assign(merged, s);
+    }
+    return merged;
+}
+function mergeRetry(...sources) {
+    const merged = {};
+    for (const s of sources) {
+        if (!s)
+            continue;
+        if (s.maxAttempts !== undefined)
+            merged.maxAttempts = s.maxAttempts;
+        if (s.initialDelay !== undefined)
+            merged.initialDelay = s.initialDelay;
+        if (s.maxDelay !== undefined)
+            merged.maxDelay = s.maxDelay;
+        if (s.backoffFactor !== undefined)
+            merged.backoffFactor = s.backoffFactor;
+        if (s.retryOn !== undefined)
+            merged.retryOn = s.retryOn;
+    }
+    return Object.keys(merged).length > 0 ? merged : undefined;
+}
+function mergeCache(...sources) {
+    const merged = {};
+    for (const s of sources) {
+        if (!s)
+            continue;
+        if (s.enabled !== undefined)
+            merged.enabled = s.enabled;
+        if (s.ttl !== undefined)
+            merged.ttl = s.ttl;
+        if (s.maxSize !== undefined)
+            merged.maxSize = s.maxSize;
+    }
+    return Object.keys(merged).length > 0 ? merged : undefined;
+}
+function mergeLogger(...sources) {
+    let result;
+    for (const s of sources) {
+        if (!s)
+            continue;
+        result = { ...result, ...s };
+    }
+    return result;
+}
+// ─── Public API ───────────────────────────────────────────────────────────────
+/**
+ * Resolve the final `CamundaClientConfig` from three layers (lowest → highest):
+ *  1. Environment variables (CAMUNDA_*)
+ *  2. YAML config file (path from `input.configFile` or `CAMUNDA_CONFIG_FILE`)
+ *  3. Values passed directly to the constructor (`input`)
+ *
+ * Throws `CamundaError` if `baseUrl` or `auth` cannot be resolved.
+ */
+export function resolveConfig(input) {
+    const fromEnv = loadFromEnv();
+    // Config file path: constructor > env
+    const configFilePath = input.configFile ?? fromEnv.configFile;
+    const fromFile = configFilePath ? loadFromFile(configFilePath) : {};
+    // Merge: env (lowest) < file < explicit (highest)
+    const baseUrl = input.baseUrl ?? fromFile.baseUrl ?? fromEnv.baseUrl;
+    const auth = mergeAuth(fromEnv.auth, fromFile.auth, input.auth);
+    const timeout = input.timeout ?? fromFile.timeout ?? fromEnv.timeout;
+    const configFile = configFilePath;
+    const retry = mergeRetry(fromEnv.retry, fromFile.retry, input.retry);
+    const cache = mergeCache(fromEnv.cache, fromFile.cache, input.cache);
+    const logger = mergeLogger(fromEnv.logger, fromFile.logger, input.logger);
+    if (!baseUrl) {
+        throw new CamundaError("baseUrl is required. Set it in the constructor, a config file, or CAMUNDA_BASE_URL.");
+    }
+    if (!auth) {
+        throw new CamundaError("auth is required. Set it in the constructor, a config file, or CAMUNDA_AUTH_* env vars.");
+    }
+    return {
+        baseUrl,
+        auth,
+        ...(configFile ? { configFile } : {}),
+        ...(timeout !== undefined ? { timeout } : {}),
+        ...(retry ? { retry } : {}),
+        ...(cache ? { cache } : {}),
+        ...(logger ? { logger } : {}),
+    };
+}
+/** Exported for testing. */
+export { loadFromEnv, loadFromFile };
+//# sourceMappingURL=config.js.map

package/dist/runtime/errors.d.ts

@@ -0,0 +1,53 @@
+/** Base class for all errors thrown by the Camunda API client. */
+export declare class CamundaError extends Error {
+    readonly name: string;
+}
+/** An HTTP-level error (non-2xx response from the API). */
+export declare class CamundaHttpError extends CamundaError {
+    readonly status: number;
+    readonly body: unknown;
+    readonly url: string;
+    readonly name: string;
+    constructor(message: string, status: number, body: unknown, url: string, options?: ErrorOptions);
+}
+/** 400 Bad Request — invalid input. */
+export declare class CamundaValidationError extends CamundaHttpError {
+    readonly name: string;
+}
+/** 401 Unauthorized — missing or invalid credentials. */
+export declare class CamundaAuthError extends CamundaHttpError {
+    readonly name: string;
+}
+/** 403 Forbidden — authenticated but not allowed. */
+export declare class CamundaForbiddenError extends CamundaHttpError {
+    readonly name: string;
+}
+/** 404 Not Found. */
+export declare class CamundaNotFoundError extends CamundaHttpError {
+    readonly name: string;
+}
+/** 409 Conflict — resource is in the wrong state. */
+export declare class CamundaConflictError extends CamundaHttpError {
+    readonly name: string;
+}
+/** 429 Too Many Requests — rate limited. */
+export declare class CamundaRateLimitError extends CamundaHttpError {
+    readonly name: string;
+    /** Seconds until the client may retry, if provided by the server. */
+    readonly retryAfter?: number;
+    constructor(message: string, status: number, body: unknown, url: string, retryAfter?: number, options?: ErrorOptions);
+}
+/** 5xx Server Error. */
+export declare class CamundaServerError extends CamundaHttpError {
+    readonly name: string;
+}
+/** Network-level failure (no response received). */
+export declare class CamundaNetworkError extends CamundaError {
+    readonly name: string;
+}
+/** Request timed out before a response was received. */
+export declare class CamundaTimeoutError extends CamundaNetworkError {
+    readonly name: string;
+}
+export declare function buildHttpError(status: number, body: unknown, url: string): CamundaHttpError;
+//# sourceMappingURL=errors.d.ts.map

package/dist/runtime/errors.js

@@ -0,0 +1,101 @@
+/** Base class for all errors thrown by the Camunda API client. */
+export class CamundaError extends Error {
+    name = "CamundaError";
+}
+/** An HTTP-level error (non-2xx response from the API). */
+export class CamundaHttpError extends CamundaError {
+    status;
+    body;
+    url;
+    name = "CamundaHttpError";
+    constructor(message, status, body, url, options) {
+        super(message, options);
+        this.status = status;
+        this.body = body;
+        this.url = url;
+    }
+}
+/** 400 Bad Request — invalid input. */
+export class CamundaValidationError extends CamundaHttpError {
+    name = "CamundaValidationError";
+}
+/** 401 Unauthorized — missing or invalid credentials. */
+export class CamundaAuthError extends CamundaHttpError {
+    name = "CamundaAuthError";
+}
+/** 403 Forbidden — authenticated but not allowed. */
+export class CamundaForbiddenError extends CamundaHttpError {
+    name = "CamundaForbiddenError";
+}
+/** 404 Not Found. */
+export class CamundaNotFoundError extends CamundaHttpError {
+    name = "CamundaNotFoundError";
+}
+/** 409 Conflict — resource is in the wrong state. */
+export class CamundaConflictError extends CamundaHttpError {
+    name = "CamundaConflictError";
+}
+/** 429 Too Many Requests — rate limited. */
+export class CamundaRateLimitError extends CamundaHttpError {
+    name = "CamundaRateLimitError";
+    /** Seconds until the client may retry, if provided by the server. */
+    retryAfter;
+    constructor(message, status, body, url, retryAfter, options) {
+        super(message, status, body, url, options);
+        this.retryAfter = retryAfter;
+    }
+}
+/** 5xx Server Error. */
+export class CamundaServerError extends CamundaHttpError {
+    name = "CamundaServerError";
+}
+/** Network-level failure (no response received). */
+export class CamundaNetworkError extends CamundaError {
+    name = "CamundaNetworkError";
+}
+/** Request timed out before a response was received. */
+export class CamundaTimeoutError extends CamundaNetworkError {
+    name = "CamundaTimeoutError";
+}
+export function buildHttpError(status, body, url) {
+    const message = extractMessage(body, status);
+    switch (status) {
+        case 400:
+            return new CamundaValidationError(message, status, body, url);
+        case 401:
+            return new CamundaAuthError(message, status, body, url);
+        case 403:
+            return new CamundaForbiddenError(message, status, body, url);
+        case 404:
+            return new CamundaNotFoundError(message, status, body, url);
+        case 409:
+            return new CamundaConflictError(message, status, body, url);
+        case 429: {
+            const retryAfter = typeof body === "object" &&
+                body !== null &&
+                "retryAfter" in body &&
+                typeof body.retryAfter === "number"
+                ? body.retryAfter
+                : undefined;
+            return new CamundaRateLimitError(message, status, body, url, retryAfter);
+        }
+        default:
+            if (status >= 500) {
+                return new CamundaServerError(message, status, body, url);
+            }
+            return new CamundaHttpError(message, status, body, url);
+    }
+}
+function extractMessage(body, status) {
+    if (typeof body === "object" && body !== null) {
+        const b = body;
+        if (typeof b.message === "string")
+            return b.message;
+        if (typeof b.detail === "string")
+            return b.detail;
+        if (typeof b.title === "string")
+            return b.title;
+    }
+    return `HTTP ${status}`;
+}
+//# sourceMappingURL=errors.js.map

package/dist/runtime/errors.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=errors.test.d.ts.map

package/dist/runtime/errors.test.js

@@ -0,0 +1,40 @@
+import { describe, expect, it } from "vitest";
+import { CamundaAuthError, CamundaConflictError, CamundaForbiddenError, CamundaNotFoundError, CamundaRateLimitError, CamundaServerError, CamundaValidationError, buildHttpError, } from "./errors.js";
+describe("buildHttpError", () => {
+    it("returns CamundaValidationError for 400", () => {
+        const err = buildHttpError(400, { message: "bad input" }, "http://test");
+        expect(err).toBeInstanceOf(CamundaValidationError);
+        expect(err.status).toBe(400);
+        expect(err.message).toBe("bad input");
+    });
+    it("returns CamundaAuthError for 401", () => {
+        expect(buildHttpError(401, null, "http://test")).toBeInstanceOf(CamundaAuthError);
+    });
+    it("returns CamundaForbiddenError for 403", () => {
+        expect(buildHttpError(403, null, "http://test")).toBeInstanceOf(CamundaForbiddenError);
+    });
+    it("returns CamundaNotFoundError for 404", () => {
+        expect(buildHttpError(404, null, "http://test")).toBeInstanceOf(CamundaNotFoundError);
+    });
+    it("returns CamundaConflictError for 409", () => {
+        expect(buildHttpError(409, null, "http://test")).toBeInstanceOf(CamundaConflictError);
+    });
+    it("returns CamundaRateLimitError for 429 with retryAfter", () => {
+        const err = buildHttpError(429, { retryAfter: 30 }, "http://test");
+        expect(err).toBeInstanceOf(CamundaRateLimitError);
+        expect(err.retryAfter).toBe(30);
+    });
+    it("returns CamundaServerError for 500+", () => {
+        expect(buildHttpError(500, null, "http://test")).toBeInstanceOf(CamundaServerError);
+        expect(buildHttpError(503, null, "http://test")).toBeInstanceOf(CamundaServerError);
+    });
+    it("extracts message from response body detail field", () => {
+        const err = buildHttpError(400, { detail: "invalid value" }, "http://test");
+        expect(err.message).toBe("invalid value");
+    });
+    it("falls back to HTTP status as message", () => {
+        const err = buildHttpError(422, {}, "http://test");
+        expect(err.message).toBe("HTTP 422");
+    });
+});
+//# sourceMappingURL=errors.test.js.map

package/dist/runtime/events.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Minimal typed event emitter — no Node.js dependency, works in any runtime.
+ */
+export declare class TypedEventEmitter<TMap extends Record<string, unknown>> {
+    #private;
+    on<K extends keyof TMap>(event: K, listener: (data: TMap[K]) => void): this;
+    off<K extends keyof TMap>(event: K, listener: (data: TMap[K]) => void): this;
+    once<K extends keyof TMap>(event: K, listener: (data: TMap[K]) => void): this;
+    emit<K extends keyof TMap>(event: K, data: TMap[K]): void;
+    removeAllListeners<K extends keyof TMap>(event?: K): void;
+}
+//# sourceMappingURL=events.d.ts.map

package/dist/runtime/events.js

@@ -0,0 +1,48 @@
+/**
+ * Minimal typed event emitter — no Node.js dependency, works in any runtime.
+ */
+export class TypedEventEmitter {
+    #listeners = new Map();
+    on(event, listener) {
+        let set = this.#listeners.get(event);
+        if (!set) {
+            set = new Set();
+            this.#listeners.set(event, set);
+        }
+        set.add(listener);
+        return this;
+    }
+    off(event, listener) {
+        this.#listeners.get(event)?.delete(listener);
+        return this;
+    }
+    once(event, listener) {
+        const wrapped = (data) => {
+            this.off(event, wrapped);
+            listener(data);
+        };
+        return this.on(event, wrapped);
+    }
+    emit(event, data) {
+        const set = this.#listeners.get(event);
+        if (!set)
+            return;
+        for (const listener of set) {
+            try {
+                listener(data);
+            }
+            catch {
+                // Listeners must not crash the client.
+            }
+        }
+    }
+    removeAllListeners(event) {
+        if (event !== undefined) {
+            this.#listeners.delete(event);
+        }
+        else {
+            this.#listeners.clear();
+        }
+    }
+}
+//# sourceMappingURL=events.js.map

package/dist/runtime/events.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=events.test.d.ts.map