@openclaw/slack 2026.7.2-beta.2 → 2026.7.2-beta.4

package/dist/{config-schema-xPSnK2VK.js → config-schema-B4j4tCOI.js}

@@ -1,8 +1,9 @@
-import { n as buildChannelConfigSchema, t as SlackConfigSchema } from "./config-api-Df9a1B8C.js";
+import { buildSecretInputSchema, hasConfiguredSecretInput } from "openclaw/plugin-sdk/secret-input";
 import { createChannelConfigUiHints } from "openclaw/plugin-sdk/channel-core";
-//#endregion
-//#region extensions/slack/src/config-schema.ts
-const SlackChannelConfigSchema = buildChannelConfigSchema(SlackConfigSchema, { uiHints: {
+import { ChannelBotLoopProtectionSchema, ChannelDangerouslyAllowNameMatchingSchema, ChannelImplicitMentionsSchema, ChannelPreviewStreamingConfigSchema, ChannelStreamingProgressSchema, GroupPolicySchema, ProviderCommandsSchema, ReplyToModeSchema, buildChannelAllowBotsSchema, buildChannelConfigSchema, buildChannelExecApprovalsSchema, buildChannelReactionShape, buildCommonChannelAccountShape, buildGroupEntrySchema, requireAllowlistAllowFrom, requireOpenAllowFrom } from "openclaw/plugin-sdk/channel-config-schema";
+import { z } from "zod";
+//#region extensions/slack/src/config-ui-hints.ts
+const slackChannelConfigUiHints = {
 	"": {
 		label: "Slack",
 		help: "Slack channel provider configuration for bot/app tokens, streaming behavior, and DM policy controls. Keep token handling and thread behavior explicit to avoid noisy workspace interactions."
@@ -11,19 +12,21 @@ const SlackChannelConfigSchema = buildChannelConfigSchema(SlackConfigSchema, { u
 		label: "Slack Enterprise Grid Org Install",
 		help: "Enable only for an Enterprise Grid org-wide bot installation. OpenClaw verifies the token with Slack auth.test at startup; DMs must be disabled or use dmPolicy=\"open\" with allowFrom=[\"*\"]."
 	},
+	postAs: {
+		label: "Slack Identity",
+		help: "Select \"bot\" (default) for the classic Slack app/bot identity or \"user\" to post as the authorizing human through a user token while the app carries event transport."
+	},
 	...createChannelConfigUiHints({
 		channelLabel: "Slack",
-		dmPolicy: {
-			channelKey: "slack",
-			includeLegacyNestedPolicy: true
-		},
+		dmPolicy: { channelKey: "slack" },
 		configWrites: true,
 		mentionPatterns: {
 			targetDescription: "Slack channel IDs",
 			policyNote: "Native Slack @mentions still trigger even when regex patterns are denied.",
 			denyNote: "Native @mentions still trigger."
 		},
-		nativeCommands: true
+		nativeCommands: true,
+		implicitMentions: true
 	}),
 	allowBots: {
 		label: "Slack Allow Bot Messages",
@@ -49,22 +52,6 @@ const SlackChannelConfigSchema = buildChannelConfigSchema(SlackConfigSchema, { u
 		label: "Slack Bot Loop Cooldown Seconds",
 		help: "How long to suppress the bot pair after it exceeds the budget. Default: 60."
 	},
-	socketMode: {
-		label: "Slack Socket Mode Transport",
-		help: "Slack Socket Mode transport tuning passed to the Slack SDK. Use only when investigating ping/pong timeout or stale websocket behavior."
-	},
-	"socketMode.clientPingTimeout": {
-		label: "Slack Socket Mode Pong Timeout",
-		help: "Milliseconds the Slack SDK waits for a pong after its client ping before treating the websocket as stale (OpenClaw default: 15000). Increase on hosts with event-loop starvation or slow network scheduling."
-	},
-	"socketMode.serverPingTimeout": {
-		label: "Slack Socket Mode Server Ping Timeout",
-		help: "Milliseconds the Slack SDK waits for Slack server pings before treating the websocket as stale."
-	},
-	"socketMode.pingPongLoggingEnabled": {
-		label: "Slack Socket Mode Ping/Pong Logging",
-		help: "Enable Slack SDK ping/pong transport logs while debugging Socket Mode websocket health."
-	},
 	relay: {
 		label: "Slack Relay Mode",
 		help: "Relay-delivered Slack events. Use with mode=\"relay\" when openclaw-slack-router owns the Slack Socket Mode connection."
@@ -212,11 +199,230 @@ const SlackChannelConfigSchema = buildChannelConfigSchema(SlackConfigSchema, { u
 	"thread.initialHistoryLimit": {
 		label: "Slack Thread Initial History Limit",
 		help: "Maximum number of existing Slack thread messages to fetch when starting a new thread session (default: 20, set to 0 to disable)."
-	},
-	"thread.requireExplicitMention": {
-		label: "Slack Thread Require Explicit Mention",
-		help: "If true, require an explicit @mention even inside threads where the bot has participated. Suppresses implicit thread mention behavior so the bot only responds to explicit @bot mentions in threads (default: false)."
 	}
-} });
+};
+//#endregion
+//#region extensions/slack/src/config-schema.ts
+const SecretInputSchema = buildSecretInputSchema();
+const SlackStreamingProgressSchema = ChannelStreamingProgressSchema.extend({ nativeTaskCards: z.boolean().optional() }).strict();
+const SlackStreamingConfigSchema = ChannelPreviewStreamingConfigSchema.extend({
+	nativeTransport: z.boolean().optional(),
+	progress: SlackStreamingProgressSchema.optional()
+}).strict();
+const SlackCapabilitiesSchema = z.union([z.array(z.string()), z.object({ interactiveReplies: z.boolean().optional() }).strict()]);
+const SlackDmSchema = z.object({
+	enabled: z.boolean().optional(),
+	groupEnabled: z.boolean().optional(),
+	groupChannels: z.array(z.union([z.string(), z.number()])).optional()
+}).strict();
+const SlackPresenceEventsSchema = z.object({ mode: z.enum([
+	"off",
+	"auto",
+	"on"
+]).optional() }).strict();
+const SlackChannelSchema = buildGroupEntrySchema({
+	ignoreOtherMentions: z.boolean().optional(),
+	replyToMode: ReplyToModeSchema.optional(),
+	allowBots: buildChannelAllowBotsSchema({ allowMentions: true }),
+	botLoopProtection: ChannelBotLoopProtectionSchema.optional(),
+	users: z.array(z.union([z.string(), z.number()])).optional(),
+	presenceEvents: SlackPresenceEventsSchema.optional()
+}, { omit: ["allowFrom"] });
+const SlackThreadSchema = z.object({
+	historyScope: z.enum(["thread", "channel"]).optional(),
+	inheritParent: z.boolean().optional(),
+	initialHistoryLimit: z.number().int().min(0).optional()
+}).strict();
+const ReplyToModeByChatTypeSchema = z.object({
+	direct: ReplyToModeSchema.optional(),
+	group: ReplyToModeSchema.optional(),
+	channel: ReplyToModeSchema.optional()
+}).strict();
+const SlackRelaySchema = z.object({
+	url: z.string().optional(),
+	authToken: SecretInputSchema.optional(),
+	gatewayId: z.string().optional()
+}).strict();
+const SlackIdentitySchema = z.enum(["bot", "user"]);
+const SlackAccountSchema = z.object({
+	...buildCommonChannelAccountShape({
+		omit: ["groupAllowFrom"],
+		capabilities: SlackCapabilitiesSchema.optional(),
+		streaming: SlackStreamingConfigSchema.optional()
+	}),
+	postAs: SlackIdentitySchema.default("bot"),
+	mode: z.enum([
+		"socket",
+		"http",
+		"relay"
+	]).optional(),
+	enterpriseOrgInstall: z.boolean().optional(),
+	relay: SlackRelaySchema.optional(),
+	signingSecret: SecretInputSchema.optional(),
+	webhookPath: z.string().optional(),
+	execApprovals: buildChannelExecApprovalsSchema(z.union([z.string(), z.number()])),
+	commands: ProviderCommandsSchema,
+	botToken: SecretInputSchema.optional(),
+	appToken: SecretInputSchema.optional(),
+	userToken: SecretInputSchema.optional(),
+	userTokenReadOnly: z.boolean().optional().default(true),
+	allowBots: buildChannelAllowBotsSchema({ allowMentions: true }),
+	botLoopProtection: ChannelBotLoopProtectionSchema.optional(),
+	dangerouslyAllowNameMatching: ChannelDangerouslyAllowNameMatchingSchema,
+	requireMention: z.boolean().optional(),
+	implicitMentions: ChannelImplicitMentionsSchema.optional(),
+	unfurlLinks: z.boolean().optional(),
+	unfurlMedia: z.boolean().optional(),
+	...buildChannelReactionShape({
+		notificationModes: [
+			"off",
+			"own",
+			"all",
+			"allowlist"
+		],
+		reactionAllowlist: true,
+		ackReaction: z.string().optional()
+	}),
+	replyToModeByChatType: ReplyToModeByChatTypeSchema.optional(),
+	thread: SlackThreadSchema.optional(),
+	presenceEvents: SlackPresenceEventsSchema.optional(),
+	actions: z.object({
+		reactions: z.boolean().optional(),
+		messages: z.boolean().optional(),
+		pins: z.boolean().optional(),
+		search: z.boolean().optional(),
+		permissions: z.boolean().optional(),
+		memberInfo: z.boolean().optional(),
+		channelInfo: z.boolean().optional(),
+		emojiList: z.boolean().optional()
+	}).strict().optional(),
+	slashCommand: z.object({
+		enabled: z.boolean().optional(),
+		name: z.string().optional(),
+		sessionPrefix: z.string().optional(),
+		ephemeral: z.boolean().optional()
+	}).strict().optional(),
+	dm: SlackDmSchema.optional(),
+	channels: z.record(z.string(), SlackChannelSchema.optional()).optional(),
+	typingReaction: z.string().optional()
+}).strict();
+const SlackAccountEntrySchema = SlackAccountSchema.extend({ postAs: SlackIdentitySchema.optional() });
+function validateSlackSigningSecretRequirements(value, ctx) {
+	const resolveMode = (mode) => mode === "http" || mode === "socket" || mode === "relay" ? mode : void 0;
+	const baseMode = resolveMode(value.mode) ?? "socket";
+	if (baseMode === "http" && !hasConfiguredSecretInput(value.signingSecret)) ctx.addIssue({
+		code: z.ZodIssueCode.custom,
+		message: "channels.slack.mode=\"http\" requires channels.slack.signingSecret",
+		path: ["signingSecret"]
+	});
+	for (const [accountId, account] of Object.entries(value.accounts ?? {})) {
+		if (!account || account.enabled === false) continue;
+		if ((resolveMode(account.mode) ?? baseMode) !== "http") continue;
+		if (!hasConfiguredSecretInput(account.signingSecret ?? value.signingSecret)) ctx.addIssue({
+			code: z.ZodIssueCode.custom,
+			message: "channels.slack.accounts.*.mode=\"http\" requires channels.slack.signingSecret or channels.slack.accounts.*.signingSecret",
+			path: [
+				"accounts",
+				accountId,
+				"signingSecret"
+			]
+		});
+	}
+}
+const SlackChannelConfigSchema = buildChannelConfigSchema(SlackAccountSchema.safeExtend({
+	mode: z.enum([
+		"socket",
+		"http",
+		"relay"
+	]).optional().default("socket"),
+	signingSecret: SecretInputSchema.optional(),
+	webhookPath: z.string().optional().default("/slack/events"),
+	groupPolicy: GroupPolicySchema.optional().default("allowlist"),
+	accounts: z.record(z.string(), SlackAccountEntrySchema.optional()).optional(),
+	defaultAccount: z.string().optional()
+}).superRefine((value, ctx) => {
+	const dmPolicy = value.dmPolicy ?? "pairing";
+	const allowFrom = value.allowFrom;
+	requireOpenAllowFrom({
+		policy: dmPolicy,
+		allowFrom,
+		ctx,
+		path: ["allowFrom"],
+		message: "channels.slack.dmPolicy=\"open\" requires channels.slack.allowFrom to include \"*\""
+	});
+	requireAllowlistAllowFrom({
+		policy: dmPolicy,
+		allowFrom,
+		ctx,
+		path: ["allowFrom"],
+		message: "channels.slack.dmPolicy=\"allowlist\" requires channels.slack.allowFrom to contain at least one sender ID"
+	});
+	const requireRelayConfig = (relay, path) => {
+		if (typeof relay?.url !== "string" || !relay.url.trim()) ctx.addIssue({
+			code: z.ZodIssueCode.custom,
+			message: "channels.slack.mode=\"relay\" requires relay.url",
+			path: [...path, "url"]
+		});
+		if (!hasConfiguredSecretInput(relay?.authToken)) ctx.addIssue({
+			code: z.ZodIssueCode.custom,
+			message: "channels.slack.mode=\"relay\" requires relay.authToken",
+			path: [...path, "authToken"]
+		});
+		if (typeof relay?.gatewayId !== "string" || !relay.gatewayId.trim()) ctx.addIssue({
+			code: z.ZodIssueCode.custom,
+			message: "channels.slack.mode=\"relay\" requires relay.gatewayId",
+			path: [...path, "gatewayId"]
+		});
+	};
+	const baseMode = value.mode ?? "socket";
+	const accountIds = value.accounts ? Object.keys(value.accounts) : [];
+	if (!value.accounts) {
+		if (baseMode === "relay") requireRelayConfig(value.relay, ["relay"]);
+		validateSlackSigningSecretRequirements(value, ctx);
+		return;
+	}
+	for (const accountId of accountIds) {
+		const account = value.accounts[accountId];
+		if (!account || account.enabled === false) continue;
+		const accountMode = account.mode ?? baseMode;
+		const effectiveRelay = {
+			...value.relay,
+			...account.relay
+		};
+		const effectivePolicy = account.dmPolicy ?? value.dmPolicy ?? "pairing";
+		const effectiveAllowFrom = account.allowFrom ?? value.allowFrom;
+		requireOpenAllowFrom({
+			policy: effectivePolicy,
+			allowFrom: effectiveAllowFrom,
+			ctx,
+			path: [
+				"accounts",
+				accountId,
+				"allowFrom"
+			],
+			message: "channels.slack.accounts.*.dmPolicy=\"open\" requires channels.slack.accounts.*.allowFrom (or channels.slack.allowFrom) to include \"*\""
+		});
+		requireAllowlistAllowFrom({
+			policy: effectivePolicy,
+			allowFrom: effectiveAllowFrom,
+			ctx,
+			path: [
+				"accounts",
+				accountId,
+				"allowFrom"
+			],
+			message: "channels.slack.accounts.*.dmPolicy=\"allowlist\" requires channels.slack.accounts.*.allowFrom (or channels.slack.allowFrom) to contain at least one sender ID"
+		});
+		if (accountMode !== "http") {
+			if (accountMode === "relay") requireRelayConfig(effectiveRelay, [
+				"accounts",
+				accountId,
+				"relay"
+			]);
+			continue;
+		}
+	}
+	validateSlackSigningSecretRequirements(value, ctx);
+}), { uiHints: slackChannelConfigUiHints });
 //#endregion
 export { SlackChannelConfigSchema as t };

package/dist/{directory-config-DRkFujwG.js → directory-config-B08pm5ZT.js}

@@ -1,5 +1,5 @@
 import { t as __exportAll } from "./rolldown-runtime-D7D4PA-g.js";
-import { i as resolveDefaultSlackAccountId, o as resolveSlackAccountAllowFrom, r as mergeSlackAccountConfig } from "./accounts-BOJJiHSr.js";
+import { i as resolveDefaultSlackAccountId, o as resolveSlackAccountAllowFrom, r as mergeSlackAccountConfig } from "./accounts-BSr252c_.js";
 import { i as parseSlackTarget } from "./target-parsing-N6lHogYZ.js";
 import "./targets-KmjP2E8s.js";
 import { normalizeAccountId } from "openclaw/plugin-sdk/account-resolution";

package/dist/directory-contract-api.js

@@ -1,2 +1,2 @@
-import { n as listSlackDirectoryGroupsFromConfig, r as listSlackDirectoryPeersFromConfig } from "./directory-config-DRkFujwG.js";
+import { n as listSlackDirectoryGroupsFromConfig, r as listSlackDirectoryPeersFromConfig } from "./directory-config-B08pm5ZT.js";
 export { listSlackDirectoryGroupsFromConfig, listSlackDirectoryPeersFromConfig };

package/dist/{directory-live-D_yZhjgp.js → directory-live-DpPKzPrn.js}

@@ -1,6 +1,6 @@
 import { t as __exportAll } from "./rolldown-runtime-D7D4PA-g.js";
-import { a as resolveSlackAccount } from "./accounts-BOJJiHSr.js";
-import { n as createSlackLookupClient } from "./client-WIPAS3Yr.js";
+import { a as resolveSlackAccount } from "./accounts-BSr252c_.js";
+import { a as createSlackLookupClient } from "./probe-CVRuArHA.js";
 import { normalizeLowercaseStringOrEmpty, normalizeOptionalLowercaseString, normalizeOptionalString } from "openclaw/plugin-sdk/string-coerce-runtime";
 //#region extensions/slack/src/directory-live.ts
 var directory_live_exports = /* @__PURE__ */ __exportAll({

package/dist/doctor-contract-U6oVntbM.js

@@ -0,0 +1,173 @@
+import { n as resolveSlackNativeStreaming, r as resolveSlackStreamingMode } from "./streaming-compat-3_X-21wW.js";
+import { asObjectRecord, defineChannelAliasMigration, hasLegacyAccountStreamingAliases, normalizeChannelConfigEntries } from "openclaw/plugin-sdk/runtime-doctor";
+//#region extensions/slack/src/doctor-contract.ts
+const streamingAliasMigration = defineChannelAliasMigration({
+	channelId: "slack",
+	streaming: {
+		defaultMode: "partial",
+		resolveMode: resolveSlackStreamingMode,
+		resolveNativeTransport: resolveSlackNativeStreaming
+	},
+	dm: {
+		root: true,
+		accounts: true
+	}
+});
+function hasLegacySlackChannelAllowAlias(value) {
+	const channels = asObjectRecord(asObjectRecord(value)?.channels);
+	if (!channels) return false;
+	return Object.values(channels).some((channel) => Object.hasOwn(asObjectRecord(channel) ?? {}, "allow"));
+}
+function hasLegacySlackThreadMentionPolicy(value) {
+	const thread = asObjectRecord(asObjectRecord(value)?.thread);
+	return Boolean(thread && Object.hasOwn(thread, "requireExplicitMention"));
+}
+function hasLegacyDmReplyMode(value) {
+	return Object.hasOwn(asObjectRecord(asObjectRecord(value)?.dm) ?? {}, "replyToMode");
+}
+function migrateDmReplyMode(entry, path, changes) {
+	const dm = asObjectRecord(entry.dm);
+	if (!dm || !Object.hasOwn(dm, "replyToMode")) return false;
+	const byType = asObjectRecord(entry.replyToModeByChatType) ?? {};
+	if (byType.direct === void 0) {
+		byType.direct = dm.replyToMode;
+		entry.replyToModeByChatType = byType;
+		changes.push(`Moved ${path}.dm.replyToMode → ${path}.replyToModeByChatType.direct.`);
+	} else changes.push(`Removed ${path}.dm.replyToMode (replyToModeByChatType.direct already set).`);
+	delete dm.replyToMode;
+	return true;
+}
+function normalizeSlackThreadMentionPolicy(params) {
+	const thread = asObjectRecord(params.value.thread);
+	if (!thread || !Object.hasOwn(thread, "requireExplicitMention")) return {
+		value: params.value,
+		changed: false
+	};
+	const next = { ...params.value };
+	const nextThread = { ...thread };
+	const nextImplicitMentions = { ...asObjectRecord(params.value.implicitMentions) ?? {} };
+	const legacyValue = thread.requireExplicitMention;
+	const targetPath = `${params.pathPrefix}.implicitMentions.threadParticipation`;
+	if (nextImplicitMentions.threadParticipation !== void 0) params.changes.push(`Removed ${params.pathPrefix}.thread.requireExplicitMention (${targetPath} already set).`);
+	else if (typeof legacyValue === "boolean") {
+		nextImplicitMentions.threadParticipation = !legacyValue;
+		params.changes.push(`Moved ${params.pathPrefix}.thread.requireExplicitMention → ${targetPath} (${String(!legacyValue)}).`);
+	} else params.changes.push(`Removed invalid ${params.pathPrefix}.thread.requireExplicitMention value.`);
+	delete nextThread.requireExplicitMention;
+	if (Object.keys(nextThread).length > 0) next.thread = nextThread;
+	else delete next.thread;
+	if (Object.keys(nextImplicitMentions).length > 0) next.implicitMentions = nextImplicitMentions;
+	return {
+		value: next,
+		changed: true
+	};
+}
+function normalizeSlackChannelAllowAliases(params) {
+	let changed = false;
+	const nextChannels = { ...params.channels };
+	for (const [channelId, channelValue] of Object.entries(params.channels)) {
+		const channel = asObjectRecord(channelValue);
+		if (!channel || !Object.hasOwn(channel, "allow")) continue;
+		const nextChannel = { ...channel };
+		if (nextChannel.enabled === void 0) {
+			nextChannel.enabled = channel.allow;
+			params.changes.push(`Moved ${params.pathPrefix}.${channelId}.allow → ${params.pathPrefix}.${channelId}.enabled.`);
+		} else params.changes.push(`Removed ${params.pathPrefix}.${channelId}.allow (${params.pathPrefix}.${channelId}.enabled already set).`);
+		delete nextChannel.allow;
+		nextChannels[channelId] = nextChannel;
+		changed = true;
+	}
+	return {
+		channels: nextChannels,
+		changed
+	};
+}
+const legacyConfigRules = [
+	...streamingAliasMigration.legacyConfigRules,
+	{
+		path: ["channels", "slack"],
+		message: "channels.slack.dm.replyToMode moved to replyToModeByChatType.direct. Run \"openclaw doctor --fix\".",
+		match: hasLegacyDmReplyMode
+	},
+	{
+		path: [
+			"channels",
+			"slack",
+			"accounts"
+		],
+		message: "channels.slack.accounts.<id>.dm.replyToMode moved to replyToModeByChatType.direct. Run \"openclaw doctor --fix\".",
+		match: (value) => hasLegacyAccountStreamingAliases(value, hasLegacyDmReplyMode)
+	},
+	{
+		path: ["channels", "slack"],
+		message: "channels.slack.thread.requireExplicitMention is legacy; use channels.slack.implicitMentions.threadParticipation instead. Run \"openclaw doctor --fix\".",
+		match: hasLegacySlackThreadMentionPolicy
+	},
+	{
+		path: [
+			"channels",
+			"slack",
+			"accounts"
+		],
+		message: "channels.slack.accounts.<id>.thread.requireExplicitMention is legacy; use channels.slack.accounts.<id>.implicitMentions.threadParticipation instead. Run \"openclaw doctor --fix\".",
+		match: (value) => hasLegacyAccountStreamingAliases(value, hasLegacySlackThreadMentionPolicy)
+	},
+	{
+		path: ["channels", "slack"],
+		message: "channels.slack.channels.<id>.allow is legacy; use channels.slack.channels.<id>.enabled instead. Run \"openclaw doctor --fix\".",
+		match: hasLegacySlackChannelAllowAlias
+	},
+	{
+		path: [
+			"channels",
+			"slack",
+			"accounts"
+		],
+		message: "channels.slack.accounts.<id>.channels.<id>.allow is legacy; use channels.slack.accounts.<id>.channels.<id>.enabled instead. Run \"openclaw doctor --fix\".",
+		match: (value) => hasLegacyAccountStreamingAliases(value, hasLegacySlackChannelAllowAlias)
+	}
+];
+function normalizeSlackEntry(params) {
+	let entry = params.entry;
+	let changed = migrateDmReplyMode(entry, params.pathPrefix, params.changes);
+	const threadPolicy = normalizeSlackThreadMentionPolicy({
+		value: entry,
+		pathPrefix: params.pathPrefix,
+		changes: params.changes
+	});
+	entry = threadPolicy.value;
+	changed = changed || threadPolicy.changed;
+	const channels = asObjectRecord(entry.channels);
+	if (channels) {
+		const normalized = normalizeSlackChannelAllowAliases({
+			channels,
+			pathPrefix: `${params.pathPrefix}.channels`,
+			changes: params.changes
+		});
+		if (normalized.changed) {
+			entry = {
+				...entry,
+				channels: normalized.channels
+			};
+			changed = true;
+		}
+	}
+	return {
+		entry,
+		changed
+	};
+}
+function normalizeCompatibilityConfig({ cfg }) {
+	const changes = [];
+	return normalizeChannelConfigEntries({
+		cfg: streamingAliasMigration.normalizeChannelConfig({
+			cfg,
+			changes
+		}).config,
+		channelId: "slack",
+		changes,
+		normalizeEntry: normalizeSlackEntry
+	});
+}
+//#endregion
+export { normalizeCompatibilityConfig as n, legacyConfigRules as t };

package/dist/doctor-contract-api.js

@@ -1,2 +1,2 @@
-import { n as normalizeCompatibilityConfig, t as legacyConfigRules } from "./doctor-contract-DddfkMlF.js";
+import { n as normalizeCompatibilityConfig, t as legacyConfigRules } from "./doctor-contract-U6oVntbM.js";
 export { legacyConfigRules, normalizeCompatibilityConfig };