@helyx/bot 1.1.0 → 1.2.0

package/dist/embedded-auto-moderation-pool.js

@@ -0,0 +1,324 @@
+import { Worker } from "node:worker_threads";
+const MAXIMUM_WORKERS = 4;
+const MAXIMUM_RESTARTS = 5;
+const MAXIMUM_RESTART_BACKOFF_MS = 5_000;
+export class EmbeddedAutoModerationPool {
+    limits;
+    #queues = new Map();
+    #activeGuilds = new Set();
+    #workers = new Set();
+    #workerFactory;
+    #configurations = [];
+    #configuredGuilds = new Set();
+    #requestSequence = 0;
+    #queuedItems = 0;
+    #queuedBytes = 0;
+    #overflow = 0;
+    #expired = 0;
+    #workerFailures = 0;
+    #consecutiveWorkerFailures = 0;
+    #restartTimer = null;
+    #stopping = false;
+    #stopped = false;
+    #circuitOpen = false;
+    #drainWaiters = [];
+    constructor(limits, options = {}) {
+        this.limits = limits;
+        validateLimits(limits);
+        const workerUrl = options.workerUrl ?? defaultWorkerUrl();
+        this.#workerFactory =
+            options.workerFactory ?? (() => new Worker(workerUrl));
+        this.now = options.now ?? Date.now;
+    }
+    now;
+    replaceConfigurations(configurations) {
+        if (this.#stopping || this.#stopped)
+            return;
+        const guildIds = new Set();
+        for (const configuration of configurations) {
+            const guildId = configuration.source.guildId;
+            if (!guildId || guildIds.has(guildId))
+                throw new Error("Embedded scanner configuration snapshot is invalid");
+            guildIds.add(guildId);
+        }
+        this.#configurations = Object.freeze([...configurations]);
+        this.#configuredGuilds = guildIds;
+        if (configurations.length === 0) {
+            this.#discardQueued();
+            void this.#terminateWorkers();
+            return;
+        }
+        if (this.#circuitOpen)
+            return;
+        this.#ensureWorkers();
+        for (const record of this.#workers)
+            record.worker.postMessage({
+                type: "replace-configurations",
+                configurations: this.#configurations,
+            });
+        this.#pump();
+    }
+    submit(input) {
+        const bytes = Buffer.byteLength(input.observation.content, "utf8");
+        const guildQueue = this.#queues.get(input.observation.guildId) ?? [];
+        if (this.#stopping ||
+            this.#stopped ||
+            this.#circuitOpen ||
+            !this.#configuredGuilds.has(input.observation.guildId) ||
+            input.deadlineAt <= this.now() ||
+            this.#queuedItems >= this.limits.maximumItems ||
+            this.#queuedBytes + bytes > this.limits.maximumBytes ||
+            guildQueue.length >= this.limits.maximumItemsPerGuild) {
+            this.#overflow += 1;
+            return false;
+        }
+        guildQueue.push({
+            requestId: ++this.#requestSequence,
+            guildId: input.observation.guildId,
+            bytes,
+            deadlineAt: input.deadlineAt,
+            observation: input.observation,
+            complete: input.complete,
+        });
+        this.#queues.set(input.observation.guildId, guildQueue);
+        this.#queuedItems += 1;
+        this.#queuedBytes += bytes;
+        this.#pump();
+        return true;
+    }
+    snapshot() {
+        return {
+            status: this.#stopped
+                ? "stopped"
+                : this.#circuitOpen
+                    ? "circuit_open"
+                    : this.#configurations.length === 0
+                        ? "idle"
+                        : this.#workers.size === this.limits.workers
+                            ? "ready"
+                            : "degraded",
+            workers: this.#workers.size,
+            configuredGuilds: this.#configuredGuilds.size,
+            queuedItems: this.#queuedItems,
+            queuedBytes: this.#queuedBytes,
+            activeItems: [...this.#workers].filter(({ active }) => active).length,
+            overflow: this.#overflow,
+            expired: this.#expired,
+            workerFailures: this.#workerFailures,
+        };
+    }
+    async stop(timeoutMs = 5_000) {
+        if (this.#stopped)
+            return true;
+        this.#stopping = true;
+        if (this.#restartTimer)
+            clearTimeout(this.#restartTimer);
+        const drained = await this.#waitForDrain(timeoutMs);
+        this.#discardQueued();
+        this.#configurations = [];
+        this.#configuredGuilds.clear();
+        await this.#terminateWorkers();
+        this.#stopped = true;
+        this.#notifyDrain();
+        return drained;
+    }
+    #ensureWorkers() {
+        while (!this.#stopping &&
+            !this.#circuitOpen &&
+            this.#configurations.length > 0 &&
+            this.#workers.size < this.limits.workers) {
+            let worker;
+            try {
+                worker = this.#workerFactory();
+            }
+            catch {
+                this.#recordWorkerFailure();
+                return;
+            }
+            const record = {
+                worker,
+                ready: false,
+                active: null,
+                failed: false,
+            };
+            this.#workers.add(record);
+            worker.on("message", (value) => this.#workerMessage(record, value));
+            worker.on("error", () => this.#workerLost(record));
+            worker.on("exit", () => this.#workerLost(record));
+            worker.postMessage({
+                type: "replace-configurations",
+                configurations: this.#configurations,
+            });
+        }
+    }
+    #workerMessage(record, value) {
+        const response = value;
+        if (response.type === "ready") {
+            record.ready = true;
+            this.#pump();
+            return;
+        }
+        if (response.type === "configurations-replaced")
+            return;
+        const item = record.active;
+        if (!item ||
+            (response.type !== "result" && response.type !== "failed") ||
+            response.requestId !== item.requestId) {
+            this.#workerLost(record);
+            void record.worker.terminate();
+            return;
+        }
+        record.active = null;
+        this.#consecutiveWorkerFailures = 0;
+        this.#pump();
+        void item
+            .complete(response.type === "result" ? response.result : null)
+            .catch(() => undefined)
+            .finally(() => {
+            this.#activeGuilds.delete(item.guildId);
+            this.#pump();
+            this.#notifyDrain();
+        });
+    }
+    #workerLost(record) {
+        if (record.failed || !this.#workers.delete(record))
+            return;
+        record.failed = true;
+        if (record.active) {
+            const item = record.active;
+            record.active = null;
+            this.#activeGuilds.delete(item.guildId);
+            void item.complete(null).catch(() => undefined);
+        }
+        if (this.#stopping) {
+            this.#notifyDrain();
+            return;
+        }
+        this.#recordWorkerFailure();
+        this.#pump();
+    }
+    #recordWorkerFailure() {
+        this.#workerFailures += 1;
+        this.#consecutiveWorkerFailures += 1;
+        if (this.#consecutiveWorkerFailures >= MAXIMUM_RESTARTS) {
+            this.#circuitOpen = true;
+            this.#discardQueued();
+            void this.#terminateWorkers();
+            return;
+        }
+        if (this.#restartTimer || this.#configurations.length === 0)
+            return;
+        const delay = Math.min(100 * 2 ** (this.#consecutiveWorkerFailures - 1), MAXIMUM_RESTART_BACKOFF_MS);
+        this.#restartTimer = setTimeout(() => {
+            this.#restartTimer = null;
+            this.#ensureWorkers();
+            this.#pump();
+        }, delay);
+        this.#restartTimer.unref();
+    }
+    #pump() {
+        if (this.#stopped || this.#circuitOpen)
+            return;
+        for (const record of this.#workers) {
+            if (!record.ready || record.active)
+                continue;
+            const item = this.#nextItem();
+            if (!item)
+                break;
+            record.active = item;
+            this.#activeGuilds.add(item.guildId);
+            record.worker.postMessage({
+                type: "scan",
+                requestId: item.requestId,
+                observation: item.observation,
+            });
+        }
+        this.#notifyDrain();
+    }
+    #nextItem() {
+        while (this.#queuedItems > 0) {
+            let removedExpired = false;
+            for (const [guildId, queue] of this.#queues) {
+                if (this.#activeGuilds.has(guildId))
+                    continue;
+                const item = queue.shift();
+                if (!item)
+                    continue;
+                if (queue.length === 0)
+                    this.#queues.delete(guildId);
+                this.#queuedItems -= 1;
+                this.#queuedBytes -= item.bytes;
+                if (item.deadlineAt <= this.now()) {
+                    this.#expired += 1;
+                    removedExpired = true;
+                    break;
+                }
+                return item;
+            }
+            if (!removedExpired)
+                break;
+        }
+        return null;
+    }
+    #discardQueued() {
+        this.#queues.clear();
+        this.#queuedItems = 0;
+        this.#queuedBytes = 0;
+        this.#notifyDrain();
+    }
+    async #terminateWorkers() {
+        const workers = [...this.#workers];
+        this.#workers.clear();
+        for (const record of workers) {
+            if (!record.active)
+                continue;
+            this.#activeGuilds.delete(record.active.guildId);
+            record.active = null;
+        }
+        await Promise.all(workers.map(async ({ worker }) => {
+            try {
+                worker.postMessage({ type: "clear" });
+                await worker.terminate();
+            }
+            catch {
+                // Termination is best effort after intake has stopped and memory cleared.
+            }
+        }));
+        this.#notifyDrain();
+    }
+    #waitForDrain(timeoutMs) {
+        if (this.#queuedItems === 0 && this.#activeGuilds.size === 0)
+            return Promise.resolve(true);
+        return new Promise((resolve) => {
+            const timer = setTimeout(() => resolve(false), timeoutMs);
+            this.#drainWaiters.push(() => {
+                clearTimeout(timer);
+                resolve(true);
+            });
+        });
+    }
+    #notifyDrain() {
+        if (this.#queuedItems !== 0 || this.#activeGuilds.size !== 0)
+            return;
+        for (const resolve of this.#drainWaiters.splice(0))
+            resolve();
+    }
+}
+function validateLimits(limits) {
+    if (!Number.isSafeInteger(limits.workers) ||
+        limits.workers < 1 ||
+        limits.workers > MAXIMUM_WORKERS ||
+        !Number.isSafeInteger(limits.maximumItems) ||
+        limits.maximumItems < 1 ||
+        !Number.isSafeInteger(limits.maximumBytes) ||
+        limits.maximumBytes < 1 ||
+        !Number.isSafeInteger(limits.maximumItemsPerGuild) ||
+        limits.maximumItemsPerGuild < 1 ||
+        limits.maximumItemsPerGuild > limits.maximumItems)
+        throw new Error("Embedded scanner pool limits are invalid");
+}
+function defaultWorkerUrl() {
+    const extension = import.meta.url.endsWith(".ts") ? "ts" : "js";
+    return new URL(`./embedded-auto-moderation-worker.${extension}`, import.meta.url);
+}
+//# sourceMappingURL=embedded-auto-moderation-pool.js.map

package/dist/embedded-auto-moderation-scanner.d.ts

@@ -0,0 +1,34 @@
+import { type AutoModerationScannerObservation, type AutoModerationScannerObservationService } from "@helyx/sdk";
+import type { BotAutoModerationScannerRegistry } from "./auto-moderation-scanner-registry.js";
+import { EmbeddedAutoModerationPool, type EmbeddedScannerPoolLimits, type EmbeddedScannerPoolSnapshot } from "./embedded-auto-moderation-pool.js";
+import type { TransientViolationEvidenceStore } from "./transient-violation-evidence.js";
+export interface EmbeddedScannerSnapshot {
+    status: "idle" | "ready" | "degraded" | "stopped";
+    configurationFingerprint: string;
+    lastSynchronizedAt: string | null;
+    synchronizationFailures: number;
+    scanned: number;
+    matched: number;
+    rejected: number;
+    pool: EmbeddedScannerPoolSnapshot;
+}
+export declare class EmbeddedAutoModerationScanner implements AutoModerationScannerObservationService {
+    #private;
+    private readonly input;
+    constructor(input: {
+        registry: BotAutoModerationScannerRegistry;
+        evidenceStore: TransientViolationEvidenceStore;
+        environment: string;
+        poolLimits: EmbeddedScannerPoolLimits;
+        refreshIntervalMs: number;
+        pool?: EmbeddedAutoModerationPool;
+        now?: () => number;
+    });
+    synchronize(): Promise<void>;
+    observe(observation: AutoModerationScannerObservation): boolean;
+    isConfigured(guildId: string): boolean;
+    snapshot(): EmbeddedScannerSnapshot;
+    stop(): Promise<boolean>;
+    private readonly now;
+}
+//# sourceMappingURL=embedded-auto-moderation-scanner.d.ts.map

package/dist/embedded-auto-moderation-scanner.js

@@ -0,0 +1,263 @@
+import { scanSimilarMessage, SimilarMessageWindow, } from "@helyx/module-automod/engine";
+import { AUTOMOD_ENHANCED_CONTRACT_VERSION, AUTOMOD_ENHANCED_PROVIDER_ID, AUTOMOD_ENHANCED_RESULT_PROTOCOL, AUTOMOD_SCANNER_LIMITS, } from "@helyx/sdk";
+import { randomBytes, randomUUID } from "node:crypto";
+import { EmbeddedAutoModerationPool, } from "./embedded-auto-moderation-pool.js";
+const MAXIMUM_CONFIGURATION_ENTRIES = 5_000;
+const MAXIMUM_CONFIGURATION_BYTES = 512 * 1_024 * 1_024;
+const MAXIMUM_CONFIGURATION_PAGES = 50;
+export class EmbeddedAutoModerationScanner {
+    input;
+    #pool;
+    #similarMessages = new SimilarMessageWindow(randomBytes(32));
+    #configurations = new Map();
+    #configurationFingerprint = "";
+    #lastSynchronizedAt = null;
+    #synchronizationFailures = 0;
+    #scanned = 0;
+    #matched = 0;
+    #rejected = 0;
+    #stopped = false;
+    #synchronizing = null;
+    #refreshTimer = null;
+    constructor(input) {
+        this.input = input;
+        if (!Number.isSafeInteger(input.refreshIntervalMs) ||
+            input.refreshIntervalMs < 30_000 ||
+            input.refreshIntervalMs > 300_000)
+            throw new Error("Embedded scanner refresh interval is invalid");
+        this.#pool = input.pool ?? new EmbeddedAutoModerationPool(input.poolLimits);
+    }
+    synchronize() {
+        if (this.#stopped)
+            return Promise.resolve();
+        if (this.#synchronizing)
+            return this.#synchronizing;
+        this.#synchronizing = this.#replaceSnapshot().finally(() => {
+            this.#synchronizing = null;
+        });
+        return this.#synchronizing;
+    }
+    observe(observation) {
+        const now = this.now();
+        const configuration = this.#configurations.get(observation.guildId);
+        if (this.#stopped ||
+            !configuration ||
+            Date.parse(configuration.source.expiresAt) <= now ||
+            observation.source !== "user" ||
+            observation.content.length < 1 ||
+            observation.content.length > AUTOMOD_SCANNER_LIMITS.messageCharacters ||
+            Buffer.byteLength(observation.content, "utf8") >
+                AUTOMOD_SCANNER_LIMITS.messageUtf8Bytes) {
+            this.#rejected += 1;
+            return false;
+        }
+        const accepted = this.#pool.submit({
+            observation: {
+                guildId: observation.guildId,
+                channelId: observation.channelId,
+                parentChannelId: observation.parentChannelId,
+                memberRoleIds: [...observation.memberRoleIds],
+                content: observation.content,
+                source: observation.source,
+            },
+            deadlineAt: now + AUTOMOD_SCANNER_LIMITS.actionDeadlineSeconds * 1_000,
+            complete: (scan) => {
+                const contextual = scanSimilarMessage(configuration, this.#similarMessages, {
+                    guildId: observation.guildId,
+                    memberId: observation.authorUserId,
+                    channelId: observation.channelId,
+                    parentChannelId: observation.parentChannelId,
+                    memberRoleIds: observation.memberRoleIds,
+                    content: observation.content,
+                    observedAtMs: Date.parse(observation.observedAt),
+                    source: observation.source,
+                });
+                return this.#completeObservation(observation, configuration, scan?.outcome === "detected" ? scan : contextual);
+            },
+        });
+        if (!accepted)
+            this.#rejected += 1;
+        else
+            this.#scanned += 1;
+        return accepted;
+    }
+    isConfigured(guildId) {
+        const configuration = this.#configurations.get(guildId);
+        return Boolean(!this.#stopped &&
+            configuration &&
+            Date.parse(configuration.source.expiresAt) > this.now());
+    }
+    snapshot() {
+        const pool = this.#pool.snapshot();
+        return {
+            status: this.#stopped
+                ? "stopped"
+                : pool.status === "idle"
+                    ? "idle"
+                    : pool.status === "ready" && this.#synchronizationFailures === 0
+                        ? "ready"
+                        : "degraded",
+            configurationFingerprint: this.#configurationFingerprint,
+            lastSynchronizedAt: this.#lastSynchronizedAt,
+            synchronizationFailures: this.#synchronizationFailures,
+            scanned: this.#scanned,
+            matched: this.#matched,
+            rejected: this.#rejected,
+            pool,
+        };
+    }
+    async stop() {
+        if (this.#stopped)
+            return true;
+        this.#stopped = true;
+        if (this.#refreshTimer)
+            clearInterval(this.#refreshTimer);
+        this.#refreshTimer = null;
+        this.#configurations.clear();
+        this.#configurationFingerprint = "";
+        return this.#pool.stop(AUTOMOD_SCANNER_LIMITS.actionDeadlineSeconds * 1_000);
+    }
+    now = () => (this.input.now ?? Date.now)();
+    async #replaceSnapshot() {
+        try {
+            const configurations = [];
+            const cursors = new Set();
+            let cursor;
+            let snapshotFingerprint = null;
+            for (let pageIndex = 0; pageIndex < MAXIMUM_CONFIGURATION_PAGES; pageIndex += 1) {
+                const page = await this.input.registry.getConfigurationPage({
+                    adapter: "embedded",
+                    providerId: AUTOMOD_ENHANCED_PROVIDER_ID,
+                    contractVersion: AUTOMOD_ENHANCED_CONTRACT_VERSION,
+                    limit: AUTOMOD_SCANNER_LIMITS.configurationPageServers,
+                    ...(cursor ? { cursor } : {}),
+                });
+                if (snapshotFingerprint !== null &&
+                    snapshotFingerprint !== page.snapshotFingerprint)
+                    throw new Error("Embedded scanner snapshot changed between pages");
+                snapshotFingerprint = page.snapshotFingerprint;
+                configurations.push(...page.items);
+                if (!page.nextCursor)
+                    break;
+                if (cursors.has(page.nextCursor))
+                    throw new Error("Embedded scanner snapshot cursor repeated");
+                cursors.add(page.nextCursor);
+                cursor = page.nextCursor;
+                if (pageIndex === MAXIMUM_CONFIGURATION_PAGES - 1)
+                    throw new Error("Embedded scanner snapshot exceeded page bounds");
+            }
+            if (configurations.length > MAXIMUM_CONFIGURATION_ENTRIES)
+                throw new Error("Embedded scanner snapshot exceeded entry bounds");
+            const next = new Map();
+            const { compileEnhancedConfiguration } = await import("@helyx/module-automod/engine");
+            let bytes = 0;
+            for (const source of configurations) {
+                if (next.has(source.guildId))
+                    throw new Error("Embedded scanner snapshot contains a duplicate guild");
+                const refreshAfter = Date.parse(source.refreshAfter);
+                const expiresAt = Date.parse(source.expiresAt);
+                if (!Number.isFinite(refreshAfter) ||
+                    !Number.isFinite(expiresAt) ||
+                    refreshAfter >= expiresAt ||
+                    expiresAt <= this.now())
+                    throw new Error("Embedded scanner configuration freshness is invalid");
+                const compiled = compileEnhancedConfiguration(source);
+                bytes += compiled.estimatedBytes;
+                if (bytes > MAXIMUM_CONFIGURATION_BYTES)
+                    throw new Error("Embedded scanner snapshot exceeded memory bounds");
+                next.set(source.guildId, compiled);
+            }
+            this.#configurations = next;
+            this.#similarMessages.clear();
+            this.#configurationFingerprint = snapshotFingerprint ?? "";
+            this.#lastSynchronizedAt = new Date(this.now()).toISOString();
+            this.#synchronizationFailures = 0;
+            this.#pool.replaceConfigurations([...next.values()]);
+            this.#updateRefreshTimer(true);
+        }
+        catch (error) {
+            this.#synchronizationFailures += 1;
+            this.#updateRefreshTimer(true);
+            throw error;
+        }
+    }
+    #updateRefreshTimer(active) {
+        if (!active)
+            return;
+        if (this.#refreshTimer)
+            return;
+        this.#refreshTimer = setInterval(() => {
+            void this.synchronize().catch(() => undefined);
+        }, this.input.refreshIntervalMs);
+        this.#refreshTimer.unref();
+    }
+    async #completeObservation(observation, configuration, scan) {
+        if (!scan || scan.outcome !== "detected")
+            return;
+        this.#matched += 1;
+        const now = this.now();
+        const { enhancedOperationId } = await import("@helyx/module-automod/engine");
+        const operationId = enhancedOperationId({
+            environment: this.input.environment,
+            observation,
+            configurationRevision: configuration.source.configurationRevision,
+            detectorVersion: configuration.source.engineVersion,
+            ruleId: scan.detection.ruleId,
+            termId: scan.detection.termId,
+            resultClass: scan.detection.confidenceClass,
+        });
+        const result = {
+            protocol: AUTOMOD_ENHANCED_RESULT_PROTOCOL,
+            providerId: AUTOMOD_ENHANCED_PROVIDER_ID,
+            contractVersion: AUTOMOD_ENHANCED_CONTRACT_VERSION,
+            detectorVersion: configuration.source.engineVersion,
+            scoringVersion: configuration.source.scoringVersion,
+            operationId,
+            nonce: randomBytes(24).toString("base64url"),
+            issuedAt: new Date(now).toISOString(),
+            deadlineAt: new Date(now + AUTOMOD_SCANNER_LIMITS.actionDeadlineSeconds * 1_000).toISOString(),
+            environment: this.input.environment,
+            guildId: observation.guildId,
+            channelId: observation.channelId,
+            parentChannelId: observation.parentChannelId,
+            messageId: observation.messageId,
+            authorUserId: observation.authorUserId,
+            observation: {
+                type: observation.type,
+                version: observation.version,
+                observedAt: observation.observedAt,
+            },
+            ruleId: scan.detection.ruleId,
+            categoryId: scan.detection.categoryId,
+            termId: scan.detection.termId,
+            configurationRevision: configuration.source.configurationRevision,
+            severity: scan.detection.severity,
+            method: scan.detection.method,
+            confidenceScore: scan.detection.confidenceScore,
+            confidenceClass: scan.detection.confidenceClass,
+            effectiveThreshold: scan.detection.effectiveThreshold,
+            correlationId: randomUUID(),
+        };
+        const rule = configuration.source.rules.find(({ ruleId }) => ruleId === result.ruleId);
+        const evidenceReference = rule?.openViolationThread
+            ? (this.input.evidenceStore.capture({
+                source: "enhanced_scanner",
+                sourceEventId: operationId,
+                configurationRevision: result.configurationRevision,
+                guildId: result.guildId,
+                channelId: result.channelId,
+                messageId: result.messageId,
+                authorUserId: result.authorUserId,
+                content: observation.content,
+            }) ?? undefined)
+            : undefined;
+        await this.input.registry.acceptResult({
+            adapter: "embedded",
+            providerId: AUTOMOD_ENHANCED_PROVIDER_ID,
+            contractVersion: AUTOMOD_ENHANCED_CONTRACT_VERSION,
+            result,
+            ...(evidenceReference ? { evidenceReference } : {}),
+        });
+    }
+}
+//# sourceMappingURL=embedded-auto-moderation-scanner.js.map

package/dist/embedded-auto-moderation-worker-runtime.d.ts

@@ -0,0 +1,37 @@
+import { type CompiledEnhancedConfiguration, type EnhancedScanResult } from "@helyx/module-automod/engine";
+export interface EmbeddedWorkerObservation {
+    guildId: string;
+    channelId: string;
+    parentChannelId: string | null;
+    memberRoleIds: readonly string[];
+    content: string;
+    source: "user" | "bot" | "webhook" | "system" | "unknown";
+}
+export type EmbeddedWorkerRequest = {
+    type: "replace-configurations";
+    configurations: readonly CompiledEnhancedConfiguration[];
+} | {
+    type: "scan";
+    requestId: number;
+    observation: EmbeddedWorkerObservation;
+} | {
+    type: "clear";
+};
+export type EmbeddedWorkerResponse = {
+    type: "ready";
+} | {
+    type: "configurations-replaced";
+    count: number;
+} | {
+    type: "result";
+    requestId: number;
+    result: EnhancedScanResult;
+} | {
+    type: "failed";
+    requestId: number;
+};
+export declare class EmbeddedWorkerRuntime {
+    #private;
+    handle(request: EmbeddedWorkerRequest): EmbeddedWorkerResponse | null;
+}
+//# sourceMappingURL=embedded-auto-moderation-worker-runtime.d.ts.map

package/dist/embedded-auto-moderation-worker-runtime.js

@@ -0,0 +1,37 @@
+import { scanEnhancedMessage, } from "@helyx/module-automod/engine";
+export class EmbeddedWorkerRuntime {
+    #configurations = new Map();
+    handle(request) {
+        if (request.type === "clear") {
+            this.#configurations.clear();
+            return null;
+        }
+        if (request.type === "replace-configurations") {
+            const next = new Map();
+            for (const configuration of request.configurations) {
+                const guildId = configuration.source.guildId;
+                if (!guildId || next.has(guildId))
+                    throw new Error("Embedded scanner configuration set is invalid");
+                next.set(guildId, configuration);
+            }
+            this.#configurations.clear();
+            for (const [guildId, configuration] of next)
+                this.#configurations.set(guildId, configuration);
+            return { type: "configurations-replaced", count: next.size };
+        }
+        const configuration = this.#configurations.get(request.observation.guildId);
+        if (!configuration)
+            return { type: "failed", requestId: request.requestId };
+        try {
+            return {
+                type: "result",
+                requestId: request.requestId,
+                result: scanEnhancedMessage(configuration, request.observation),
+            };
+        }
+        catch {
+            return { type: "failed", requestId: request.requestId };
+        }
+    }
+}
+//# sourceMappingURL=embedded-auto-moderation-worker-runtime.js.map