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

package/dist/internal.index.cjs

@@ -1,44 +1,146 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
-const require_CustomId = require('./CustomId-DV7daU7r.cjs');
+const require_rolldown_runtime = require('./rolldown-runtime-C_NdSu1c.cjs');
+const require_permissions = require('./permissions-DQL5ViZn.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);
 
 //#region src/gates/runGates.ts
 function routeIdOf(handlerCtor) {
-	for (const [kind, key] of Object.entries(require_CustomId.InteractionRouteKeys)) {
+	for (const [kind, key] of Object.entries(require_permissions.InteractionRouteKeys)) {
 		const routes = Reflect.getMetadata(key, handlerCtor);
 		if (routes?.length) return `${kind}:${routes.join(",")}`;
 	}
 	return null;
 }
+async function timedCheck(gate, ctx, observe) {
+	const start = performance.now();
+	try {
+		await require_permissions.runCheck(gate, ctx);
+	} finally {
+		observe(gate.name, performance.now() - start);
+	}
+}
 /**
 * Runs each gate's check in order, so the first refusal propagates to the dispatcher boundary. An effect
-* gate's commit runs once the whole set passes.
+* gate's commit runs once the whole set passes. When `observe` is given, each check is timed and reported,
+* commits excluded.
 */
-async function runGates(gates, ctx) {
+async function runGates(gates, ctx, observe) {
 	try {
-		for (const gate of gates) await require_CustomId.runCheck(gate, ctx);
-		await require_CustomId.runCommits(ctx);
+		for (const gate of gates) await (observe ? timedCheck(gate, ctx, observe) : require_permissions.runCheck(gate, ctx));
+		await require_permissions.runCommits(ctx);
 	} finally {
-		require_CustomId.discardCommits(ctx);
+		require_permissions.discardCommits(ctx);
 	}
 }
-async function runHandlerGates(handlerCtor, ctx) {
-	const gates = Reflect.getMetadata(require_CustomId.GatedMetadataKey, handlerCtor);
+async function runHandlerGates(handlerCtor, ctx, routeId, observe) {
+	const gates = Reflect.getMetadata(require_permissions.GatedMetadataKey, handlerCtor);
 	if (!gates) return;
 	await runGates(gates, {
 		...ctx,
-		routeId: routeIdOf(handlerCtor)
-	});
+		routeId: routeId ?? routeIdOf(handlerCtor)
+	}, observe);
+}
+
+//#endregion
+//#region src/gates/slowGate.ts
+const SLOW_GATE_MS = 750;
+let gateLogger;
+function logger() {
+	gateLogger ??= new _seedcord_logger.Logger("Gates");
+	return gateLogger;
+}
+function slowGateMonitor() {
+	if (envapt.Envapter.isProduction) return void 0;
+	const readings = [];
+	return {
+		observe: (name, ms) => readings.push({
+			name,
+			ms
+		}),
+		report(routeId) {
+			const total = readings.reduce((sum, reading) => sum + reading.ms, 0);
+			if (total < SLOW_GATE_MS) return;
+			const shares = readings.toSorted((a, b) => b.ms - a.ms).map((reading) => `${_seedcord_logger.paint.sky.bold(reading.name)} ${Math.round(reading.ms)}ms`);
+			const headline = `gates${routeId === null ? "" : ` for ${_seedcord_logger.paint.sky.bold(routeId)}`} took ${_seedcord_logger.paint.amber(`${Math.round(total)}ms`)} of the 3s ack budget`;
+			logger().utils.block(headline, shares, "warn", (text) => text);
+		}
+	};
 }
 
 //#endregion
-//#region src/customId/routing.ts
+//#region src/hmr/devChannel.ts
+let channel;
+/** @internal */
+function setDevChannel(next) {
+	channel = next;
+}
+/** @internal */
+function getDevChannel() {
+	return channel;
+}
+
+//#endregion
+//#region src/hmr/wrapHot.ts
 /**
-* The route decorators store a handler's customId definitions here so the component base can decode
-* against them at runtime.
+* Wraps a raw vite hot object as a typed {@link DevChannel}.
 *
 * @internal
 */
-const ComponentDefsKey = Symbol("seedcord:customId:componentDefs");
+function wrapHot(hot) {
+	return {
+		send: (event, data) => hot.send(event, data),
+		on: (event, cb) => hot.on(event, cb)
+	};
+}
+
+//#endregion
+//#region src/hmr/HmrManager.ts
+var HmrManager = class {
+	logger = new _seedcord_logger.Logger("HMR", { channel: "hmr" });
+	listeners = /* @__PURE__ */ new Set();
+	/** @internal */
+	init() {
+		if (!{}.hot) return;
+		const channel = wrapHot({}.hot);
+		setDevChannel(channel);
+		if (envapt.Envapter.isDevelopment || envapt.Envapter.isTest) {
+			this.logger.info("Enabled");
+			channel.on("seedcord:hmr", (payload) => {
+				const affected = payload.affectedModules?.length ?? 0;
+				this.logger.info(`${chalk.default.bold("1")} module changed, ${chalk.default.bold(affected)} affected modules`);
+				if (payload.affectedModules) this.logger.utils.list(payload.affectedModules.map((mod) => (0, _seedcord_utils.formatFilePath)(mod)), "Affected modules: ");
+				this.handleUpdate(payload);
+			});
+		}
+	}
+	/** @internal */
+	register(listener) {
+		this.listeners.add(listener);
+	}
+	/** @internal */
+	unregister(listener) {
+		this.listeners.delete(listener);
+	}
+	async handleUpdate(event) {
+		const promises = [...this.listeners].map(async (listener) => {
+			try {
+				await listener.onHmr(event);
+			} catch (error) {
+				this.logger.error(`Error handling HMR update in ${chalk.default.bold(listener.name)}: `, error);
+			}
+		});
+		await Promise.all(promises);
+	}
+};
 
 //#endregion
 //#region src/pagination/cursor.ts
@@ -46,34 +148,424 @@ const PAGE_MAX = 1e6;
 const SLOT_MAX = 4;
 /** Build the page cursor for a paginator. */
 function pageCursor(prefix) {
-	return new require_CustomId.CustomId(prefix).int("page", 0, PAGE_MAX).int("slot", 0, SLOT_MAX);
+	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;
+}
+
+//#endregion
+//#region src/reply/ackLegality.ts
+const showModalReason = {
+	reason: "this interaction was already acknowledged",
+	alternative: "showModal() must be the initial response."
+};
+function deferReason(what) {
+	return {
+		reason: `this interaction was already acknowledged with ${what}`,
+		alternative: "A deferral can only be the initial response."
+	};
+}
+const ILLEGAL = {
+	reply: {
+		"deferred-reply": {
+			reason: "this interaction was already deferred",
+			alternative: "Use edit() to fill the deferred reply or followUp() for a new message."
+		},
+		"deferred-update": {
+			reason: "this interaction was already acknowledged with a deferred update",
+			alternative: "Use followUp() for a new message."
+		},
+		replied: {
+			reason: "this interaction was already replied to",
+			alternative: "Use followUp() for a new message or edit() to rewrite the reply."
+		}
+	},
+	defer: {
+		"deferred-reply": deferReason("a deferred reply"),
+		"deferred-update": deferReason("a deferred update"),
+		replied: deferReason("a reply")
+	},
+	deferUpdate: {
+		"deferred-reply": deferReason("a deferred reply"),
+		"deferred-update": deferReason("a deferred update"),
+		replied: deferReason("a reply")
+	},
+	update: {
+		"deferred-reply": {
+			reason: "this interaction was deferred as a reply",
+			alternative: "The placeholder is yours via edit(). update() rewrites a source message."
+		},
+		replied: {
+			reason: "this interaction was already replied to",
+			alternative: "update() rewrites a source message. Use edit() or followUp() instead."
+		}
+	},
+	followUp: { unacked: {
+		reason: "this interaction has not been acknowledged yet",
+		alternative: "Ack first with reply() or defer()."
+	} },
+	edit: { unacked: {
+		reason: "nothing has been sent yet",
+		alternative: "Send with reply() or defer() first, then edit() rewrites it."
+	} },
+	delete: { unacked: {
+		reason: "nothing has been sent yet",
+		alternative: "Acknowledge first with reply() or defer(), then delete() removes it."
+	} },
+	showModal: {
+		"deferred-reply": showModalReason,
+		"deferred-update": showModalReason,
+		replied: showModalReason
+	}
+};
+const SEND_TARGET = {
+	unacked: "reply",
+	"deferred-reply": "edit",
+	"deferred-update": "followUp",
+	replied: "followUp"
+};
+/** Throws before any API call. `ackedBy` becomes the throw cause, its stack points at the first ack. */
+function checkAckLegality(method, state, routeId, ackedBy) {
+	if (method === "send") return;
+	const illegal = ILLEGAL[method][state];
+	if (!illegal) return;
+	throw new _seedcord_errors_internal.SeedcordError(_seedcord_errors.SeedcordErrorCode.ReplyIllegalAckState, [
+		method,
+		illegal.reason,
+		illegal.alternative,
+		routeId
+	], { cause: ackedBy });
+}
+function sendTarget(state) {
+	return SEND_TARGET[state];
+}
+
+//#endregion
+//#region src/reply/AckTrace.ts
+/** The first ack's stack, passed as the throw cause so a double-ack points to both lines. */
+var AckTrace = class extends Error {
+	constructor(method) {
+		super(`${method}() acknowledged this interaction`);
+		this.name = "AckTrace";
+	}
+};
+
+//#endregion
+//#region src/reply/translateSerialization.ts
+const MAX_DEPTH = 8;
+const OPERATOR_WORD = {
+	"<=": "at most",
+	">=": "at least",
+	"<": "fewer than",
+	">": "more than"
+};
+const KIND_WORD = {
+	string: "a string",
+	number: "a number",
+	boolean: "a boolean",
+	bigint: "a bigint",
+	array: "a list",
+	tuple: "a list",
+	date: "a date",
+	object: "an object"
+};
+function asRecord(value) {
+	return typeof value === "object" && value !== null ? value : null;
+}
+function firstLine(message) {
+	if (typeof message !== "string") return "unknown validation failure";
+	return message.split("\n")[0] ?? message;
+}
+const GIVEN_PREVIEW_LIMIT = 40;
+function gotPhrase(given) {
+	if (given === void 0) return "nothing";
+	if (given === null) return "null";
+	if (typeof given === "string") {
+		if (given.length === 0) return "an empty string";
+		if (given.length > GIVEN_PREVIEW_LIMIT) return `${given.length} characters`;
+		return JSON.stringify(given);
+	}
+	if (Array.isArray(given)) return given.length === 0 ? "an empty list" : `${given.length} items`;
+	if (typeof given === "number" || typeof given === "bigint" || typeof given === "boolean") return String(given);
+	if (typeof given === "object") return given.constructor?.name ?? "an object";
+	return typeof given;
+}
+function needPhrase(expected, given) {
+	const bounds = [...expected.matchAll(/expected(\.length)?\s*(<=|>=|<|>)\s*(\d+)/g)];
+	if (bounds.length === 0) return null;
+	return bounds.map(([, lengthPart, operator, limit]) => {
+		const word = OPERATOR_WORD[operator ?? ""] ?? operator ?? "";
+		if (!lengthPart) return `${word} ${limit}`;
+		const unit = typeof given === "string" ? "character" : "item";
+		return `${word} ${limit} ${Number(limit) === 1 ? unit : `${unit}s`}`;
+	}).join(" and ");
+}
+function instanceName(expected) {
+	if (typeof expected === "function" && expected.name) return expected.name;
+	return "specific class instance";
+}
+function describeLeaf(record) {
+	if (typeof record.constraint === "string") {
+		const need = typeof record.expected === "string" ? needPhrase(record.expected, record.given) : null;
+		if (need) return `need ${need}, got ${gotPhrase(record.given)}`;
+		return `${firstLine(record.message)}${"given" in record ? ` (got ${gotPhrase(record.given)})` : ""}`;
+	}
+	if (typeof record.expected === "function") return `need a ${instanceName(record.expected)}, got ${gotPhrase(record.given)}`;
+	if (typeof record.validator === "string") {
+		const kind = KIND_WORD[record.validator.replace(/^s\./, "").replace(/\(.*$/, "")];
+		if (kind) return `need ${kind}, got ${gotPhrase(record.given)}`;
+		return `${firstLine(record.message)}, got ${gotPhrase(record.given)}`;
+	}
+	return firstLine(record.message);
+}
+function describeUnion(branches, depth) {
+	const records = [];
+	for (const branch of branches) {
+		const record = asRecord(branch);
+		if (record) records.push(record);
+	}
+	const bounded = records.find((record) => typeof record.constraint === "string");
+	if (bounded) return describeLeaf(bounded);
+	const names = [];
+	let allInstances = records.length > 0;
+	for (const record of records) if (typeof record.expected === "function") names.push(instanceName(record.expected));
+	else allInstances = false;
+	if (allInstances) return `need a ${[...new Set(names)].join(" or ")}, got ${gotPhrase(records[0]?.given)}`;
+	return detailOf(branches[0], depth + 1);
+}
+function detailOf(value, depth) {
+	const record = asRecord(value);
+	if (!record || depth >= MAX_DEPTH) return firstLine(record?.message);
+	if (Array.isArray(record.errors) && record.errors.length > 0) {
+		const errors = record.errors;
+		const [first] = errors;
+		if (Array.isArray(first)) {
+			const [key, inner] = first;
+			return `${String(key)}: ${detailOf(inner, depth + 1)}`;
+		}
+		return describeUnion(errors, depth);
+	}
+	return describeLeaf(record);
 }
+/**
+* Translates a shapeshift throw into an actionable message, keeping the original as `cause`. Any other
+* throw contributes its message as the detail.
+*/
+function translateSerializationError(error, componentClass, index, routeId) {
+	const detail = detailOf(error, 0);
+	return new _seedcord_errors_internal.SeedcordError(_seedcord_errors.SeedcordErrorCode.ReplyComponentSerialization, [
+		componentClass,
+		index,
+		detail,
+		routeId
+	], { cause: error });
+}
+
+//#endregion
+//#region src/reply/serializeReply.ts
+/** Wraps a string in a TextDisplay component. */
+function serializeReply(response, routeId) {
+	if (typeof response === "string") try {
+		return { components: [new _discordjs_builders.TextDisplayBuilder().setContent(response).toJSON()] };
+	} catch (error) {
+		throw translateSerializationError(error, "TextDisplayBuilder", 0, routeId);
+	}
+	return {
+		components: response.components.map((component, index) => {
+			try {
+				return component.toJSON();
+			} catch (error) {
+				const name = component.constructor?.name;
+				throw translateSerializationError(error, !name || name === "Object" ? "component" : name, index, routeId);
+			}
+		}),
+		...response.allowedMentions && { allowedMentions: response.allowedMentions },
+		...response.files && { files: response.files }
+	};
+}
+
+//#endregion
+//#region src/reply/BaseReplySender.ts
+/**
+* Tracks acknowledgement state and throws a translated `SeedcordError` on an illegal verb before any
+* transport call. Verbs execute the legality check, control the transport wire writer, then update the
+* state and ack trace. Each transport binds `TMessage` to its created-message lens and supplies the
+* writers.
+*/
+var BaseReplySender = class {
+	routeId;
+	state;
+	sent = /* @__PURE__ */ new Set();
+	ackedBy;
+	constructor(routeId, initialState = "unacked") {
+		this.routeId = routeId;
+		this.state = initialState;
+	}
+	async reply(response, opts) {
+		this.checkLegality("reply");
+		const created = await this.writeReply(response, opts);
+		this.transition("reply", "replied");
+		return this.remember(this.requireMessage(created, "reply"));
+	}
+	async defer(opts) {
+		this.checkLegality("defer");
+		await this.writeDefer(opts);
+		this.transition("defer", "deferred-reply");
+	}
+	async deferUpdate() {
+		this.checkLegality("deferUpdate");
+		await this.writeDeferUpdate();
+		this.transition("deferUpdate", "deferred-update");
+	}
+	/**
+	* After a deferUpdate the state stays deferred-update, so the rewrite repeats. The returned message
+	* is the source message, editable only through a bare `update` or `edit`. A targeted `edit` or `delete`
+	* of it throws the foreign-target error.
+	*/
+	async update(response) {
+		this.checkLegality("update");
+		if (this.state === "deferred-update") return await this.editOriginal(response);
+		const created = await this.writeUpdate(response);
+		this.transition("update", "replied");
+		return this.remember(this.requireMessage(created, "update"));
+	}
+	async followUp(response, opts) {
+		this.checkLegality("followUp");
+		const created = await this.writeFollowUp(response, opts);
+		return this.remember(created);
+	}
+	async edit(targetOrResponse, maybeResponse) {
+		this.checkLegality("edit");
+		if (maybeResponse === void 0) return await this.editOriginal(targetOrResponse);
+		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));
+	}
+	async delete(target) {
+		this.checkLegality("delete");
+		if (target === void 0) {
+			await this.writeDeleteOriginal();
+			return;
+		}
+		if (!this.sent.has(target.id)) throw new _seedcord_errors_internal.SeedcordError(_seedcord_errors.SeedcordErrorCode.ReplyForeignEditTarget, [
+			"delete",
+			target.id,
+			this.routeId
+		]);
+		await this.writeDeleteTarget(target.id);
+		this.sent.delete(target.id);
+	}
+	/** 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) {
+		const target = sendTarget(this.state);
+		if (target === "reply") return await this.reply(response, opts);
+		if (target === "edit") return await this.edit(response);
+		return await this.followUp(response, opts);
+	}
+	/** Must be the initial response. */
+	async showModal(modal) {
+		this.checkLegality("showModal");
+		this.guardModalSource();
+		let data;
+		try {
+			data = modal.toJSON();
+		} catch (error) {
+			const name = modal.constructor?.name;
+			throw translateSerializationError(error, !name || name === "Object" ? "modal" : name, 0, this.routeId);
+		}
+		await this.writeModal(data);
+		this.transition("showModal", "replied");
+	}
+	serialize(response) {
+		return serializeReply(response, this.routeId);
+	}
+	remember(created) {
+		this.sent.add(created.id);
+		return created;
+	}
+	requireMessage(created, method) {
+		if (!created) throw new _seedcord_errors_internal.SeedcordError(_seedcord_errors.SeedcordErrorCode.ReplyCallbackMissingMessage, [method, this.routeId]);
+		return created;
+	}
+	async editOriginal(response) {
+		const edited = await this.writeEditOriginal(response);
+		if (this.state !== "deferred-update") this.remember(edited);
+		return edited;
+	}
+	checkLegality(method) {
+		checkAckLegality(method, this.state, this.routeId, this.ackedBy);
+	}
+	transition(method, state) {
+		this.state = state;
+		this.ackedBy = new AckTrace(method);
+	}
+	guardModalSource() {}
+};
 
 //#endregion
-exports.CommandMetadataKey = require_CustomId.CommandMetadataKey;
-exports.ComponentDefsKey = ComponentDefsKey;
-exports.EventMetadataKey = require_CustomId.EventMetadataKey;
-exports.GateNotice = require_CustomId.GateNotice;
-exports.GatedMetadataKey = require_CustomId.GatedMetadataKey;
-exports.InteractionMetadataKey = require_CustomId.InteractionMetadataKey;
-exports.InteractionRouteKeys = require_CustomId.InteractionRouteKeys;
-exports.InteractionRoutes = require_CustomId.InteractionRoutes;
-exports.MiddlewareMetadataKey = require_CustomId.MiddlewareMetadataKey;
-exports.NeedsAny = require_CustomId.NeedsAny;
-exports.NotAllowed = require_CustomId.NotAllowed;
-exports.NotInDm = require_CustomId.NotInDm;
-exports.NotInGuild = require_CustomId.NotInGuild;
-exports.NotOwner = require_CustomId.NotOwner;
-exports.NoticeCard = require_CustomId.NoticeCard;
-exports.OnCooldown = require_CustomId.OnCooldown;
+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.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.PAGE_MAX = PAGE_MAX;
-exports.SubscribeMetadataKey = require_CustomId.SubscribeMetadataKey;
-exports.decodeFor = require_CustomId.decodeFor;
+exports.PermissionNames = require_permissions.PermissionNames;
+exports.SubscribeMetadataKey = require_permissions.SubscribeMetadataKey;
+exports.WebhookUrlMetadataKey = require_permissions.WebhookUrlMetadataKey;
+exports.areRoutes = require_permissions.areRoutes;
+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.pageCursor = pageCursor;
-exports.pickNotice = require_CustomId.pickNotice;
-exports.prefixOf = require_CustomId.prefixOf;
+exports.pickNotice = require_permissions.pickNotice;
+exports.prefixOf = require_permissions.prefixOf;
 exports.routeIdOf = routeIdOf;
 exports.runGates = runGates;
 exports.runHandlerGates = runHandlerGates;
-exports.setBotColor = require_CustomId.setBotColor;
+exports.selectMenuRouteOf = require_permissions.selectMenuRouteOf;
+exports.sendFlags = sendFlags;
+exports.sendTarget = sendTarget;
+exports.serializeReply = serializeReply;
+exports.setBotColor = require_permissions.setBotColor;
+exports.setDevChannel = setDevChannel;
+exports.slowGateMonitor = slowGateMonitor;
+exports.storeComponentRoute = require_permissions.storeComponentRoute;
+exports.storeInteractionRoute = require_permissions.storeInteractionRoute;
+exports.translateSerializationError = translateSerializationError;
+exports.wrapHot = wrapHot;
 //# sourceMappingURL=internal.index.cjs.map