@seedcord/core 0.1.0-next.5 → 0.1.0-next.7

package/dist/internal.index.cjs

@@ -1,20 +1,21 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
 const require_rolldown_runtime = require('./rolldown-runtime-C_NdSu1c.cjs');
-const require_permissions = require('./permissions-DQL5ViZn.cjs');
+const require_publishDefault = require('./publishDefault-l0NQ-SHo.cjs');
+const require_Silence = require('./Silence-DiP95iwD.cjs');
+const require_devChannel = require('./devChannel-CoCmAVDx.cjs');
 require("reflect-metadata");
 let _seedcord_errors = require("@seedcord/errors");
 let _seedcord_errors_internal = require("@seedcord/errors/internal");
-let discord_api_types_v10 = require("discord-api-types/v10");
 let _discordjs_builders = require("@discordjs/builders");
 let _seedcord_logger = require("@seedcord/logger");
 let _seedcord_utils = require("@seedcord/utils");
-let envapt = require("envapt");
 let chalk = require("chalk");
 chalk = require_rolldown_runtime.__toESM(chalk, 1);
+let envapt = require("envapt");
 
 //#region src/gates/runGates.ts
 function routeIdOf(handlerCtor) {
-	for (const [kind, key] of Object.entries(require_permissions.InteractionRouteKeys)) {
+	for (const [kind, key] of Object.entries(require_publishDefault.InteractionRouteKeys)) {
 		const routes = Reflect.getMetadata(key, handlerCtor);
 		if (routes?.length) return `${kind}:${routes.join(",")}`;
 	}
@@ -23,7 +24,7 @@ function routeIdOf(handlerCtor) {
 async function timedCheck(gate, ctx, observe) {
 	const start = performance.now();
 	try {
-		await require_permissions.runCheck(gate, ctx);
+		await require_Silence.runCheck(gate, ctx);
 	} finally {
 		observe(gate.name, performance.now() - start);
 	}
@@ -35,14 +36,14 @@ async function timedCheck(gate, ctx, observe) {
 */
 async function runGates(gates, ctx, observe) {
 	try {
-		for (const gate of gates) await (observe ? timedCheck(gate, ctx, observe) : require_permissions.runCheck(gate, ctx));
-		await require_permissions.runCommits(ctx);
+		for (const gate of gates) await (observe ? timedCheck(gate, ctx, observe) : require_Silence.runCheck(gate, ctx));
+		await require_Silence.runCommits(ctx);
 	} finally {
-		require_permissions.discardCommits(ctx);
+		require_Silence.discardCommits(ctx);
 	}
 }
 async function runHandlerGates(handlerCtor, ctx, routeId, observe) {
-	const gates = Reflect.getMetadata(require_permissions.GatedMetadataKey, handlerCtor);
+	const gates = Reflect.getMetadata(require_publishDefault.GatedMetadataKey, handlerCtor);
 	if (!gates) return;
 	await runGates(gates, {
 		...ctx,
@@ -55,7 +56,7 @@ async function runHandlerGates(handlerCtor, ctx, routeId, observe) {
 const SLOW_GATE_MS = 750;
 let gateLogger;
 function logger() {
-	gateLogger ??= new _seedcord_logger.Logger("Gates");
+	gateLogger ??= new _seedcord_logger.Logger("Gates", { channel: "gates" });
 	return gateLogger;
 }
 function slowGateMonitor() {
@@ -76,18 +77,6 @@ function slowGateMonitor() {
 	};
 }
 
-//#endregion
-//#region src/hmr/devChannel.ts
-let channel;
-/** @internal */
-function setDevChannel(next) {
-	channel = next;
-}
-/** @internal */
-function getDevChannel() {
-	return channel;
-}
-
 //#endregion
 //#region src/hmr/wrapHot.ts
 /**
@@ -111,7 +100,7 @@ var HmrManager = class {
 	init() {
 		if (!{}.hot) return;
 		const channel = wrapHot({}.hot);
-		setDevChannel(channel);
+		require_devChannel.setDevChannel(channel);
 		if (envapt.Envapter.isDevelopment || envapt.Envapter.isTest) {
 			this.logger.info("Enabled");
 			channel.on("seedcord:hmr", (payload) => {
@@ -135,34 +124,27 @@ var HmrManager = class {
 			try {
 				await listener.onHmr(event);
 			} catch (error) {
-				this.logger.error(`Error handling HMR update in ${chalk.default.bold(listener.name)}: `, error);
+				this.logger.error(`Error handling HMR update in ${chalk.default.bold(listener.constructor.name)}: `, error);
 			}
 		});
 		await Promise.all(promises);
 	}
 };
 
+//#endregion
+//#region src/stops/asError.ts
+/** @internal */
+function asError(caught) {
+	return Error.isError(caught) ? caught : new Error(String(caught), { cause: caught });
+}
+
 //#endregion
 //#region src/pagination/cursor.ts
 const PAGE_MAX = 1e6;
 const SLOT_MAX = 4;
 /** Build the page cursor for a paginator. */
 function pageCursor(prefix) {
-	return new require_permissions.CustomId(prefix).int("page", 0, PAGE_MAX).int("slot", 0, SLOT_MAX);
-}
-
-//#endregion
-//#region src/reply/flags.ts
-/** IsComponentsV2 is unconditional, every framework reply is v2. */
-function sendFlags(opts) {
-	let flags = discord_api_types_v10.MessageFlags.IsComponentsV2;
-	if (opts?.ephemeral ?? true) flags |= discord_api_types_v10.MessageFlags.Ephemeral;
-	if (opts?.silent) flags |= discord_api_types_v10.MessageFlags.SuppressNotifications;
-	return flags;
-}
-/** A deferral carries no content, so only Ephemeral applies. */
-function deferFlags(opts) {
-	return opts?.ephemeral ?? true ? discord_api_types_v10.MessageFlags.Ephemeral : 0;
+	return new require_Silence.CustomId(prefix).int("page", 0, PAGE_MAX).int("slot", 0, SLOT_MAX);
 }
 
 //#endregion
@@ -262,6 +244,60 @@ var AckTrace = class extends Error {
 	}
 };
 
+//#endregion
+//#region src/reply/responseReport.ts
+/** @internal */
+function publishResponse(telemetry, report) {
+	if (!telemetry) return;
+	telemetry.bus[require_publishDefault.PublishDefault]("responseAttempted", {
+		routeId: report.routeId,
+		interactionId: telemetry.interactionId,
+		method: report.method,
+		outcome: report.outcome,
+		durationMs: performance.now() - report.startedAt,
+		messageId: report.messageId,
+		...report.error && { error: report.error }
+	});
+}
+/**
+* Runs a write that returns no message and publishes whichever arm it takes.
+*
+* @internal
+*/
+async function reportedWrite(telemetry, routeId, method, write) {
+	const startedAt = performance.now();
+	const result = await attemptWrite(telemetry, routeId, method, startedAt, write);
+	publishResponse(telemetry, {
+		routeId,
+		method,
+		startedAt,
+		outcome: "sent",
+		messageId: null
+	});
+	return result;
+}
+/**
+* Runs a wire write and publishes the `failed` arm when it throws, since the caller's success report
+* sits after the write and a throw skips it.
+*
+* @internal
+*/
+async function attemptWrite(telemetry, routeId, method, startedAt, write) {
+	try {
+		return await write();
+	} catch (caught) {
+		publishResponse(telemetry, {
+			routeId,
+			method,
+			startedAt,
+			outcome: "failed",
+			messageId: null,
+			error: asError(caught)
+		});
+		throw caught;
+	}
+}
+
 //#endregion
 //#region src/reply/translateSerialization.ts
 const MAX_DEPTH = 8;
@@ -406,28 +442,49 @@ function serializeReply(response, routeId) {
 */
 var BaseReplySender = class {
 	routeId;
+	telemetry;
 	state;
 	sent = /* @__PURE__ */ new Set();
 	ackedBy;
-	constructor(routeId, initialState = "unacked") {
+	constructor(routeId, initialState = "unacked", telemetry) {
 		this.routeId = routeId;
+		this.telemetry = telemetry;
 		this.state = initialState;
 	}
+	report(method, startedAt, outcome, messageId) {
+		publishResponse(this.telemetry, {
+			routeId: this.routeId,
+			method,
+			startedAt,
+			outcome,
+			messageId
+		});
+	}
+	async attempt(method, startedAt, write) {
+		return await attemptWrite(this.telemetry, this.routeId, method, startedAt, write);
+	}
 	async reply(response, opts) {
 		this.checkLegality("reply");
-		const created = await this.writeReply(response, opts);
+		const startedAt = performance.now();
+		const created = await this.attempt("reply", startedAt, () => this.writeReply(response, opts));
 		this.transition("reply", "replied");
-		return this.remember(this.requireMessage(created, "reply"));
+		const message = this.remember(this.requireMessage(created, "reply"));
+		this.report("reply", startedAt, "sent", message.id);
+		return message;
 	}
 	async defer(opts) {
 		this.checkLegality("defer");
-		await this.writeDefer(opts);
+		const startedAt = performance.now();
+		await this.attempt("defer", startedAt, () => this.writeDefer(opts));
 		this.transition("defer", "deferred-reply");
+		this.report("defer", startedAt, "sent", null);
 	}
 	async deferUpdate() {
 		this.checkLegality("deferUpdate");
-		await this.writeDeferUpdate();
+		const startedAt = performance.now();
+		await this.attempt("deferUpdate", startedAt, () => this.writeDeferUpdate());
 		this.transition("deferUpdate", "deferred-update");
+		this.report("deferUpdate", startedAt, "sent", null);
 	}
 	/**
 	* After a deferUpdate the state stays deferred-update, so the rewrite repeats. The returned message
@@ -436,31 +493,51 @@ var BaseReplySender = class {
 	*/
 	async update(response) {
 		this.checkLegality("update");
-		if (this.state === "deferred-update") return await this.editOriginal(response);
-		const created = await this.writeUpdate(response);
+		const startedAt = performance.now();
+		if (this.state === "deferred-update") {
+			const edited = await this.attempt("update", startedAt, () => this.editOriginal(response));
+			this.report("update", startedAt, "sent", edited.id);
+			return edited;
+		}
+		const created = await this.attempt("update", startedAt, () => this.writeUpdate(response));
 		this.transition("update", "replied");
-		return this.remember(this.requireMessage(created, "update"));
+		const message = this.remember(this.requireMessage(created, "update"));
+		this.report("update", startedAt, "sent", message.id);
+		return message;
 	}
 	async followUp(response, opts) {
 		this.checkLegality("followUp");
-		const created = await this.writeFollowUp(response, opts);
-		return this.remember(created);
+		const startedAt = performance.now();
+		const created = await this.attempt("followUp", startedAt, () => this.writeFollowUp(response, opts));
+		const message = this.remember(created);
+		this.report("followUp", startedAt, "sent", message.id);
+		return message;
 	}
 	async edit(targetOrResponse, maybeResponse) {
 		this.checkLegality("edit");
-		if (maybeResponse === void 0) return await this.editOriginal(targetOrResponse);
+		const startedAt = performance.now();
+		if (maybeResponse === void 0) {
+			const edited = await this.attempt("edit", startedAt, () => this.editOriginal(targetOrResponse));
+			this.report("edit", startedAt, "sent", edited.id);
+			return edited;
+		}
 		const target = targetOrResponse;
 		if (!this.sent.has(target.id)) throw new _seedcord_errors_internal.SeedcordError(_seedcord_errors.SeedcordErrorCode.ReplyForeignEditTarget, [
 			"edit",
 			target.id,
 			this.routeId
 		]);
-		return this.remember(await this.writeEditTarget(target.id, maybeResponse));
+		const written = await this.attempt("edit", startedAt, () => this.writeEditTarget(target.id, maybeResponse));
+		const message = this.remember(written);
+		this.report("edit", startedAt, "sent", message.id);
+		return message;
 	}
 	async delete(target) {
 		this.checkLegality("delete");
+		const startedAt = performance.now();
 		if (target === void 0) {
-			await this.writeDeleteOriginal();
+			await this.attempt("delete", startedAt, () => this.writeDeleteOriginal());
+			this.report("delete", startedAt, "sent", null);
 			return;
 		}
 		if (!this.sent.has(target.id)) throw new _seedcord_errors_internal.SeedcordError(_seedcord_errors.SeedcordErrorCode.ReplyForeignEditTarget, [
@@ -468,8 +545,9 @@ var BaseReplySender = class {
 			target.id,
 			this.routeId
 		]);
-		await this.writeDeleteTarget(target.id);
+		await this.attempt("delete", startedAt, () => this.writeDeleteTarget(target.id));
 		this.sent.delete(target.id);
+		this.report("delete", startedAt, "sent", null);
 	}
 	/** Routes to the verb the current ack state permits. Every state has a route, so the illegal-ack throw is unreachable. */
 	async send(response, opts) {
@@ -489,8 +567,10 @@ var BaseReplySender = class {
 			const name = modal.constructor?.name;
 			throw translateSerializationError(error, !name || name === "Object" ? "modal" : name, 0, this.routeId);
 		}
-		await this.writeModal(data);
+		const startedAt = performance.now();
+		await this.attempt("showModal", startedAt, () => this.writeModal(data));
 		this.transition("showModal", "replied");
+		this.report("showModal", startedAt, "sent", null);
 	}
 	serialize(response) {
 		return serializeReply(response, this.routeId);
@@ -518,54 +598,152 @@ var BaseReplySender = class {
 	guardModalSource() {}
 };
 
+//#endregion
+//#region src/subscribers/FaultThrottle.ts
+/**
+* Drops duplicate fault reports inside a fixed window, so a recurring fault (a database outage on a
+* hot path) reports once per window and never floods the webhook.
+*
+* @internal
+*/
+var FaultThrottle = class FaultThrottle {
+	windowMs;
+	now;
+	static perCore = /* @__PURE__ */ new WeakMap();
+	/**
+	* The throttle for one bot instance.
+	*
+	* @internal
+	*/
+	static for(core) {
+		let throttle = FaultThrottle.perCore.get(core);
+		if (!throttle) {
+			throttle = new FaultThrottle();
+			FaultThrottle.perCore.set(core, throttle);
+		}
+		return throttle;
+	}
+	lastReportedAt = /* @__PURE__ */ new Map();
+	constructor(windowMs = 6e4, now = () => Date.now()) {
+		this.windowMs = windowMs;
+		this.now = now;
+	}
+	/** Evicts the entry for this key if it has aged out. */
+	shouldReport(key) {
+		const last = this.lastReportedAt.get(key);
+		if (last === void 0) return true;
+		if (this.now() - last < this.windowMs) return false;
+		this.lastReportedAt.delete(key);
+		return true;
+	}
+	markReported(key) {
+		this.lastReportedAt.set(key, this.now());
+	}
+	clear() {
+		this.lastReportedAt.clear();
+	}
+};
+
+//#endregion
+//#region src/dispatch/dispatchReport.ts
+/**
+* Classifies a caught stop for `interactionDispatched` so a gate and a
+* handler label the same stop identically.
+*
+* @internal
+*/
+function outcomeFor(caught) {
+	if (caught instanceof require_Silence.Silence) return "refused";
+	if (caught instanceof require_Silence.Notice) return caught.report ? "failed" : "refused";
+	return "failed";
+}
+/**
+* Discord's interaction creation to now, read from the snowflake. Called at dispatch entry, since
+* a later read would count the handler run into the queue time as well.
+*
+* @internal
+*/
+function queuedMsFor(interactionId) {
+	try {
+		return Date.now() - (0, _seedcord_utils.timestampFromSnowflake)(interactionId);
+	} catch {
+		return 0;
+	}
+}
+/**
+* Builds the `interactionDispatched` payload both transports publish, so the two clocks are read the
+* same way on each.
+*
+* @internal
+*/
+function dispatchedPayload(report) {
+	return {
+		routeId: report.routeId,
+		interactionId: report.interactionId,
+		kind: report.kind,
+		outcome: report.outcome,
+		fallback: report.fallback,
+		durationMs: performance.now() - report.startedAt,
+		queuedMs: report.queuedMs
+	};
+}
+
 //#endregion
 exports.AckTrace = AckTrace;
 exports.BaseReplySender = BaseReplySender;
-exports.CommandMetadataKey = require_permissions.CommandMetadataKey;
-exports.ComponentDefsKey = require_permissions.ComponentDefsKey;
-exports.EventMetadataKey = require_permissions.EventMetadataKey;
-exports.GateNotice = require_permissions.GateNotice;
-exports.GatedMetadataKey = require_permissions.GatedMetadataKey;
+exports.CommandMetadataKey = require_publishDefault.CommandMetadataKey;
+exports.ComponentDefsKey = require_Silence.ComponentDefsKey;
+exports.EventMetadataKey = require_publishDefault.EventMetadataKey;
+exports.FaultThrottle = FaultThrottle;
+exports.GateNotice = require_Silence.GateNotice;
+exports.GatedMetadataKey = require_publishDefault.GatedMetadataKey;
 exports.HmrManager = HmrManager;
-exports.InteractionMetadataKey = require_permissions.InteractionMetadataKey;
-exports.InteractionRouteKeys = require_permissions.InteractionRouteKeys;
-exports.InteractionRoutes = require_permissions.InteractionRoutes;
-exports.MiddlewareMetadataKey = require_permissions.MiddlewareMetadataKey;
-exports.MissingPermissions = require_permissions.MissingPermissions;
-exports.MissingRole = require_permissions.MissingRole;
-exports.NeedsAny = require_permissions.NeedsAny;
-exports.NotAllowed = require_permissions.NotAllowed;
-exports.NotInDm = require_permissions.NotInDm;
-exports.NotInGuild = require_permissions.NotInGuild;
-exports.NotOwner = require_permissions.NotOwner;
-exports.NoticeCard = require_permissions.NoticeCard;
-exports.OnCooldown = require_permissions.OnCooldown;
+exports.InteractionMetadataKey = require_publishDefault.InteractionMetadataKey;
+exports.InteractionRouteKeys = require_publishDefault.InteractionRouteKeys;
+exports.InteractionRoutes = require_publishDefault.InteractionRoutes;
+exports.MiddlewareMetadataKey = require_publishDefault.MiddlewareMetadataKey;
+exports.MissingPermissions = require_Silence.MissingPermissions;
+exports.MissingRole = require_Silence.MissingRole;
+exports.NeedsAny = require_Silence.NeedsAny;
+exports.NotAllowed = require_Silence.NotAllowed;
+exports.NotInDm = require_Silence.NotInDm;
+exports.NotInGuild = require_Silence.NotInGuild;
+exports.NotOwner = require_Silence.NotOwner;
+exports.NoticeCard = require_Silence.NoticeCard;
+exports.OnCooldown = require_Silence.OnCooldown;
 exports.PAGE_MAX = PAGE_MAX;
-exports.PermissionNames = require_permissions.PermissionNames;
-exports.SubscribeMetadataKey = require_permissions.SubscribeMetadataKey;
-exports.WebhookUrlMetadataKey = require_permissions.WebhookUrlMetadataKey;
-exports.areRoutes = require_permissions.areRoutes;
+exports.PermissionNames = require_Silence.PermissionNames;
+exports.PublishDefault = require_publishDefault.PublishDefault;
+exports.SubscribeMetadataKey = require_publishDefault.SubscribeMetadataKey;
+exports.WebhookUrlMetadataKey = require_publishDefault.WebhookUrlMetadataKey;
+exports.areRoutes = require_Silence.areRoutes;
+exports.asError = asError;
 exports.checkAckLegality = checkAckLegality;
-exports.contextMenuRouteOf = require_permissions.contextMenuRouteOf;
-exports.decodeComponentRoute = require_permissions.decodeComponentRoute;
-exports.decodeFor = require_permissions.decodeFor;
-exports.deferFlags = deferFlags;
-exports.getDevChannel = getDevChannel;
+exports.contextMenuRouteOf = require_Silence.contextMenuRouteOf;
+exports.decodeComponentRoute = require_Silence.decodeComponentRoute;
+exports.decodeFor = require_Silence.decodeFor;
+exports.deferFlags = require_publishDefault.deferFlags;
+exports.dispatchedPayload = dispatchedPayload;
+exports.getDevChannel = require_devChannel.getDevChannel;
+exports.interactionRoutesOf = require_Silence.interactionRoutesOf;
+exports.outcomeFor = outcomeFor;
 exports.pageCursor = pageCursor;
-exports.pickNotice = require_permissions.pickNotice;
-exports.prefixOf = require_permissions.prefixOf;
+exports.pickNotice = require_Silence.pickNotice;
+exports.prefixOf = require_Silence.prefixOf;
+exports.queuedMsFor = queuedMsFor;
+exports.reportedWrite = reportedWrite;
 exports.routeIdOf = routeIdOf;
 exports.runGates = runGates;
 exports.runHandlerGates = runHandlerGates;
-exports.selectMenuRouteOf = require_permissions.selectMenuRouteOf;
-exports.sendFlags = sendFlags;
+exports.selectMenuRouteOf = require_Silence.selectMenuRouteOf;
+exports.sendFlags = require_publishDefault.sendFlags;
 exports.sendTarget = sendTarget;
 exports.serializeReply = serializeReply;
-exports.setBotColor = require_permissions.setBotColor;
-exports.setDevChannel = setDevChannel;
+exports.setBotColor = require_publishDefault.setBotColor;
+exports.setDevChannel = require_devChannel.setDevChannel;
 exports.slowGateMonitor = slowGateMonitor;
-exports.storeComponentRoute = require_permissions.storeComponentRoute;
-exports.storeInteractionRoute = require_permissions.storeInteractionRoute;
+exports.storeComponentRoute = require_Silence.storeComponentRoute;
+exports.storeInteractionRoute = require_Silence.storeInteractionRoute;
 exports.translateSerializationError = translateSerializationError;
 exports.wrapHot = wrapHot;
 //# sourceMappingURL=internal.index.cjs.map