@spacebar_ai/moldclaw-core 2026.3.43 → 2026.3.45

package/dist/register.subclis-B7nrik3-.js

@@ -0,0 +1,315 @@
+import { E as getPrimaryCommand, k as hasHelpOrVersion, x as buildParseArgv } from "./logger-BFfIIIKH.js";
+import { t as isTruthyEnvValue } from "./env-D42cffog.js";
+import { r as resolveActionArgs } from "./helpers-Cs7KLVWb.js";
+import { n as getSubCliEntries$1 } from "./subcli-descriptors-Zv7MlmBG.js";
+//#region src/cli/program/action-reparse.ts
+async function reparseProgramFromActionArgs(program, actionArgs) {
+	const actionCommand = actionArgs.at(-1);
+	const rawArgs = (actionCommand?.parent ?? program).rawArgs;
+	const actionArgsList = resolveActionArgs(actionCommand);
+	const fallbackArgv = actionCommand?.name() ? [actionCommand.name(), ...actionArgsList] : actionArgsList;
+	const parseArgv = buildParseArgv({
+		programName: program.name(),
+		rawArgs,
+		fallbackArgv
+	});
+	await program.parseAsync(parseArgv);
+}
+//#endregion
+//#region src/cli/program/command-tree.ts
+function removeCommand(program, command) {
+	const commands = program.commands;
+	const index = commands.indexOf(command);
+	if (index < 0) return false;
+	commands.splice(index, 1);
+	return true;
+}
+function removeCommandByName(program, name) {
+	const existing = program.commands.find((command) => command.name() === name);
+	if (!existing) return false;
+	return removeCommand(program, existing);
+}
+//#endregion
+//#region src/cli/program/register.subclis.ts
+const shouldRegisterPrimaryOnly = (argv) => {
+	if (isTruthyEnvValue(process.env.MOLDCLAW_DISABLE_LAZY_SUBCOMMANDS)) return false;
+	if (hasHelpOrVersion(argv)) return false;
+	return true;
+};
+const shouldEagerRegisterSubcommands = (_argv) => {
+	return isTruthyEnvValue(process.env.MOLDCLAW_DISABLE_LAZY_SUBCOMMANDS);
+};
+const loadValidatedConfigForPluginRegistration = async () => {
+	const mod = await import("./config-BbvDRSYp.js");
+	if (!(await mod.readConfigFileSnapshot()).valid) return null;
+	return mod.loadConfig();
+};
+const entries = [
+	{
+		name: "acp",
+		description: "Agent Control Protocol tools",
+		hasSubcommands: true,
+		register: async (program) => {
+			(await import("./acp-cli-2JoKJ0xt.js")).registerAcpCli(program);
+		}
+	},
+	{
+		name: "gateway",
+		description: "Run, inspect, and query the WebSocket Gateway",
+		hasSubcommands: true,
+		register: async (program) => {
+			(await import("./gateway-cli-DofujQf3.js")).registerGatewayCli(program);
+		}
+	},
+	{
+		name: "daemon",
+		description: "Gateway service (legacy alias)",
+		hasSubcommands: true,
+		register: async (program) => {
+			(await import("./cli/daemon-cli.js")).registerDaemonCli(program);
+		}
+	},
+	{
+		name: "logs",
+		description: "Tail gateway file logs via RPC",
+		hasSubcommands: false,
+		register: async (program) => {
+			(await import("./logs-cli-CNzOvZ2d.js")).registerLogsCli(program);
+		}
+	},
+	{
+		name: "system",
+		description: "System events, heartbeat, and presence",
+		hasSubcommands: true,
+		register: async (program) => {
+			(await import("./system-cli-BvNps8sl.js")).registerSystemCli(program);
+		}
+	},
+	{
+		name: "models",
+		description: "Discover, scan, and configure models",
+		hasSubcommands: true,
+		register: async (program) => {
+			(await import("./models-cli-CdXULEZe.js")).registerModelsCli(program);
+		}
+	},
+	{
+		name: "approvals",
+		description: "Manage exec approvals (gateway or node host)",
+		hasSubcommands: true,
+		register: async (program) => {
+			(await import("./exec-approvals-cli-kLAev6bP.js")).registerExecApprovalsCli(program);
+		}
+	},
+	{
+		name: "nodes",
+		description: "Manage gateway-owned node pairing and node commands",
+		hasSubcommands: true,
+		register: async (program) => {
+			(await import("./nodes-cli-CBX71Wd_.js")).registerNodesCli(program);
+		}
+	},
+	{
+		name: "devices",
+		description: "Device pairing + token management",
+		hasSubcommands: true,
+		register: async (program) => {
+			(await import("./devices-cli-DIsxj4xp.js")).registerDevicesCli(program);
+		}
+	},
+	{
+		name: "node",
+		description: "Run and manage the headless node host service",
+		hasSubcommands: true,
+		register: async (program) => {
+			(await import("./node-cli-B_2nTm80.js")).registerNodeCli(program);
+		}
+	},
+	{
+		name: "sandbox",
+		description: "Manage sandbox containers for agent isolation",
+		hasSubcommands: true,
+		register: async (program) => {
+			(await import("./sandbox-cli-waaYyhsC.js")).registerSandboxCli(program);
+		}
+	},
+	{
+		name: "tui",
+		description: "Open a terminal UI connected to the Gateway",
+		hasSubcommands: false,
+		register: async (program) => {
+			(await import("./tui-cli-BRUfLUTd.js")).registerTuiCli(program);
+		}
+	},
+	{
+		name: "cron",
+		description: "Manage cron jobs via the Gateway scheduler",
+		hasSubcommands: true,
+		register: async (program) => {
+			(await import("./cron-cli-Bktbk7iP.js")).registerCronCli(program);
+		}
+	},
+	{
+		name: "dns",
+		description: "DNS helpers for wide-area discovery (Tailscale + CoreDNS)",
+		hasSubcommands: true,
+		register: async (program) => {
+			(await import("./dns-cli-BJiz6CLK.js")).registerDnsCli(program);
+		}
+	},
+	{
+		name: "docs",
+		description: "Search the live moldClaw docs",
+		hasSubcommands: false,
+		register: async (program) => {
+			(await import("./docs-cli-Dq2Yi5qO.js")).registerDocsCli(program);
+		}
+	},
+	{
+		name: "hooks",
+		description: "Manage internal agent hooks",
+		hasSubcommands: true,
+		register: async (program) => {
+			(await import("./hooks-cli-DtBvd1lb.js")).registerHooksCli(program);
+		}
+	},
+	{
+		name: "webhooks",
+		description: "Webhook helpers and integrations",
+		hasSubcommands: true,
+		register: async (program) => {
+			(await import("./webhooks-cli-Wl9y6AWW.js")).registerWebhooksCli(program);
+		}
+	},
+	{
+		name: "qr",
+		description: "Generate iOS pairing QR/setup code",
+		hasSubcommands: false,
+		register: async (program) => {
+			(await import("./qr-cli-9H9go9JE.js")).registerQrCli(program);
+		}
+	},
+	{
+		name: "clawbot",
+		description: "Legacy clawbot command aliases",
+		hasSubcommands: true,
+		register: async (program) => {
+			(await import("./clawbot-cli-Cpbxu8dD.js")).registerClawbotCli(program);
+		}
+	},
+	{
+		name: "pairing",
+		description: "Secure DM pairing (approve inbound requests)",
+		hasSubcommands: true,
+		register: async (program) => {
+			const { registerPluginCliCommands } = await import("./cli--2bGSKdX.js");
+			const config = await loadValidatedConfigForPluginRegistration();
+			if (config) registerPluginCliCommands(program, config);
+			(await import("./pairing-cli-DSQTYgc0.js")).registerPairingCli(program);
+		}
+	},
+	{
+		name: "plugins",
+		description: "Manage moldClaw plugins and extensions",
+		hasSubcommands: true,
+		register: async (program) => {
+			(await import("./plugins-cli-BGAgYy3Z.js")).registerPluginsCli(program);
+			const { registerPluginCliCommands } = await import("./cli--2bGSKdX.js");
+			const config = await loadValidatedConfigForPluginRegistration();
+			if (config) registerPluginCliCommands(program, config);
+		}
+	},
+	{
+		name: "channels",
+		description: "Manage connected chat channels (Telegram, Discord, etc.)",
+		hasSubcommands: true,
+		register: async (program) => {
+			(await import("./channels-cli-TmchKLFS.js")).registerChannelsCli(program);
+		}
+	},
+	{
+		name: "directory",
+		description: "Lookup contact and group IDs (self, peers, groups) for supported chat channels",
+		hasSubcommands: true,
+		register: async (program) => {
+			(await import("./directory-cli-D253m0er.js")).registerDirectoryCli(program);
+		}
+	},
+	{
+		name: "security",
+		description: "Security tools and local config audits",
+		hasSubcommands: true,
+		register: async (program) => {
+			(await import("./security-cli-CSsLnFuN.js")).registerSecurityCli(program);
+		}
+	},
+	{
+		name: "secrets",
+		description: "Secrets runtime reload controls",
+		hasSubcommands: true,
+		register: async (program) => {
+			(await import("./secrets-cli-BmeEhlzt.js")).registerSecretsCli(program);
+		}
+	},
+	{
+		name: "skills",
+		description: "List and inspect available skills",
+		hasSubcommands: true,
+		register: async (program) => {
+			(await import("./skills-cli-BGuW-tKw.js")).registerSkillsCli(program);
+		}
+	},
+	{
+		name: "update",
+		description: "Update moldClaw and inspect update channel status",
+		hasSubcommands: true,
+		register: async (program) => {
+			(await import("./update-cli-DPE3GCHJ.js")).registerUpdateCli(program);
+		}
+	},
+	{
+		name: "completion",
+		description: "Generate shell completion script",
+		hasSubcommands: false,
+		register: async (program) => {
+			(await import("./completion-cli-Bg95upyk.js")).registerCompletionCli(program);
+		}
+	}
+];
+function getSubCliEntries() {
+	return getSubCliEntries$1();
+}
+async function registerSubCliByName(program, name) {
+	const entry = entries.find((candidate) => candidate.name === name);
+	if (!entry) return false;
+	removeCommandByName(program, entry.name);
+	await entry.register(program);
+	return true;
+}
+function registerLazyCommand(program, entry) {
+	const placeholder = program.command(entry.name).description(entry.description);
+	placeholder.allowUnknownOption(true);
+	placeholder.allowExcessArguments(true);
+	placeholder.action(async (...actionArgs) => {
+		removeCommand(program, placeholder);
+		await entry.register(program);
+		await reparseProgramFromActionArgs(program, actionArgs);
+	});
+}
+function registerSubCliCommands(program, argv = process.argv) {
+	if (shouldEagerRegisterSubcommands(argv)) {
+		for (const entry of entries) entry.register(program);
+		return;
+	}
+	const primary = getPrimaryCommand(argv);
+	if (primary && shouldRegisterPrimaryOnly(argv)) {
+		const entry = entries.find((candidate) => candidate.name === primary);
+		if (entry) {
+			registerLazyCommand(program, entry);
+			return;
+		}
+	}
+	for (const candidate of entries) registerLazyCommand(program, candidate);
+}
+//#endregion
+export { removeCommandByName as a, registerSubCliCommands as i, loadValidatedConfigForPluginRegistration as n, reparseProgramFromActionArgs as o, registerSubCliByName as r, getSubCliEntries as t };

package/dist/register.subclis-BCoAVyGn.js

@@ -0,0 +1,13 @@
+import "./logger-BFfIIIKH.js";
+import "./paths-D6AgsMTU.js";
+import "./tmp-moldclaw-dir-DWF-d8qD.js";
+import "./theme-BSXzMzAA.js";
+import "./globals-DESrFYmC.js";
+import "./runtime-_tQz41uA.js";
+import "./ansi-BPhP6LBZ.js";
+import "./subsystem-CPmDTJ2P.js";
+import "./boolean-B6zcAynR.js";
+import "./env-D42cffog.js";
+import { n as loadValidatedConfigForPluginRegistration, r as registerSubCliByName } from "./register.subclis-B7nrik3-.js";
+import "./subcli-descriptors-Zv7MlmBG.js";
+export { loadValidatedConfigForPluginRegistration, registerSubCliByName };

package/dist/replies-BU4AvOyD.js

@@ -0,0 +1,110 @@
+import { Na as createReplyReferencePlanner, ci as parseSlackBlocksInput, ei as sendMessageSlack, ti as markdownToSlackMrkdwnChunks } from "./auth-profiles-C-Ul-Qkn.js";
+import { g as chunkMarkdownTextWithMode } from "./text-runtime-Cfq-Uyx0.js";
+import { g as isSilentReplyText } from "./lazy-runtime-BoGB4usD.js";
+//#region extensions/slack/src/monitor/replies.ts
+function readSlackReplyBlocks(payload) {
+	const slackData = payload.channelData?.slack;
+	if (!slackData || typeof slackData !== "object" || Array.isArray(slackData)) return;
+	try {
+		return parseSlackBlocksInput(slackData.blocks);
+	} catch {
+		return;
+	}
+}
+async function deliverReplies(params) {
+	for (const payload of params.replies) {
+		const threadTs = (params.replyToMode === "off" ? void 0 : payload.replyToId) ?? params.replyThreadTs;
+		const mediaList = payload.mediaUrls ?? (payload.mediaUrl ? [payload.mediaUrl] : []);
+		const text = payload.text ?? "";
+		const slackBlocks = readSlackReplyBlocks(payload);
+		if (!text && mediaList.length === 0 && !slackBlocks?.length) continue;
+		if (mediaList.length === 0) {
+			const trimmed = text.trim();
+			if (!trimmed && !slackBlocks?.length) continue;
+			if (trimmed && isSilentReplyText(trimmed, "NO_REPLY")) continue;
+			await sendMessageSlack(params.target, trimmed, {
+				token: params.token,
+				threadTs,
+				accountId: params.accountId,
+				...slackBlocks?.length ? { blocks: slackBlocks } : {},
+				...params.identity ? { identity: params.identity } : {}
+			});
+		} else {
+			let first = true;
+			for (const mediaUrl of mediaList) {
+				const caption = first ? text : "";
+				first = false;
+				await sendMessageSlack(params.target, caption, {
+					token: params.token,
+					mediaUrl,
+					threadTs,
+					accountId: params.accountId,
+					...params.identity ? { identity: params.identity } : {}
+				});
+			}
+		}
+		params.runtime.log?.(`delivered reply to ${params.target}`);
+	}
+}
+/**
+* Compute effective threadTs for a Slack reply based on replyToMode.
+* - "off": stay in thread if already in one, otherwise main channel
+* - "first": first reply goes to thread, subsequent replies to main channel
+* - "all": all replies go to thread
+*/
+function resolveSlackThreadTs(params) {
+	return createSlackReplyReferencePlanner({
+		replyToMode: params.replyToMode,
+		incomingThreadTs: params.incomingThreadTs,
+		messageTs: params.messageTs,
+		hasReplied: params.hasReplied,
+		isThreadReply: params.isThreadReply
+	}).use();
+}
+function createSlackReplyReferencePlanner(params) {
+	return createReplyReferencePlanner({
+		replyToMode: params.isThreadReply ?? Boolean(params.incomingThreadTs) ? "all" : params.replyToMode,
+		existingId: params.incomingThreadTs,
+		startId: params.messageTs,
+		hasReplied: params.hasReplied
+	});
+}
+function createSlackReplyDeliveryPlan(params) {
+	const replyReference = createSlackReplyReferencePlanner({
+		replyToMode: params.replyToMode,
+		incomingThreadTs: params.incomingThreadTs,
+		messageTs: params.messageTs,
+		hasReplied: params.hasRepliedRef.value,
+		isThreadReply: params.isThreadReply
+	});
+	return {
+		nextThreadTs: () => replyReference.use(),
+		markSent: () => {
+			replyReference.markSent();
+			params.hasRepliedRef.value = replyReference.hasReplied();
+		}
+	};
+}
+async function deliverSlackSlashReplies(params) {
+	const messages = [];
+	const chunkLimit = Math.min(params.textLimit, 4e3);
+	for (const payload of params.replies) {
+		const textRaw = payload.text?.trim() ?? "";
+		const text = textRaw && !isSilentReplyText(textRaw, "NO_REPLY") ? textRaw : void 0;
+		const mediaList = payload.mediaUrls ?? (payload.mediaUrl ? [payload.mediaUrl] : []);
+		const combined = [text ?? "", ...mediaList.map((url) => url.trim()).filter(Boolean)].filter(Boolean).join("\n");
+		if (!combined) continue;
+		const chunkMode = params.chunkMode ?? "length";
+		const chunks = (chunkMode === "newline" ? chunkMarkdownTextWithMode(combined, chunkLimit, chunkMode) : [combined]).flatMap((markdown) => markdownToSlackMrkdwnChunks(markdown, chunkLimit, { tableMode: params.tableMode }));
+		if (!chunks.length && combined) chunks.push(combined);
+		for (const chunk of chunks) messages.push(chunk);
+	}
+	if (messages.length === 0) return;
+	const responseType = params.ephemeral ? "ephemeral" : "in_channel";
+	for (const text of messages) await params.respond({
+		text,
+		response_type: responseType
+	});
+}
+//#endregion
+export { resolveSlackThreadTs as a, readSlackReplyBlocks as i, deliverReplies as n, deliverSlackSlashReplies as r, createSlackReplyDeliveryPlan as t };

package/dist/resolve-channels-CDfj5NGq.js

@@ -0,0 +1,226 @@
+import { ri as createSlackWebClient } from "./auth-profiles-C-Ul-Qkn.js";
+//#region extensions/slack/src/resolve-allowlist-common.ts
+function readSlackNextCursor(response) {
+	const next = response.response_metadata?.next_cursor?.trim();
+	return next ? next : void 0;
+}
+async function collectSlackCursorItems(params) {
+	const items = [];
+	let cursor;
+	do {
+		const response = await params.fetchPage(cursor);
+		items.push(...params.collectPageItems(response));
+		cursor = readSlackNextCursor(response);
+	} while (cursor);
+	return items;
+}
+function resolveSlackAllowlistEntries(params) {
+	const results = [];
+	for (const input of params.entries) {
+		const parsed = params.parseInput(input);
+		if (parsed.id) {
+			const match = params.findById(params.lookup, parsed.id);
+			results.push(params.buildIdResolved({
+				input,
+				parsed,
+				match
+			}));
+			continue;
+		}
+		const resolved = params.resolveNonId({
+			input,
+			parsed,
+			lookup: params.lookup
+		});
+		if (resolved) {
+			results.push(resolved);
+			continue;
+		}
+		results.push(params.buildUnresolved(input));
+	}
+	return results;
+}
+//#endregion
+//#region extensions/slack/src/resolve-users.ts
+function parseSlackUserInput(raw) {
+	const trimmed = raw.trim();
+	if (!trimmed) return {};
+	const mention = trimmed.match(/^<@([A-Z0-9]+)>$/i);
+	if (mention) return { id: mention[1]?.toUpperCase() };
+	const prefixed = trimmed.replace(/^(slack:|user:)/i, "");
+	if (/^[A-Z][A-Z0-9]+$/i.test(prefixed)) return { id: prefixed.toUpperCase() };
+	if (trimmed.includes("@") && !trimmed.startsWith("@")) return { email: trimmed.toLowerCase() };
+	const name = trimmed.replace(/^@/, "").trim();
+	return name ? { name } : {};
+}
+async function listSlackUsers(client) {
+	return collectSlackCursorItems({
+		fetchPage: async (cursor) => await client.users.list({
+			limit: 200,
+			cursor
+		}),
+		collectPageItems: (res) => (res.members ?? []).map((member) => {
+			const id = member.id?.trim();
+			const name = member.name?.trim();
+			if (!id || !name) return null;
+			const profile = member.profile ?? {};
+			return {
+				id,
+				name,
+				displayName: profile.display_name?.trim() || void 0,
+				realName: profile.real_name?.trim() || member.real_name?.trim() || void 0,
+				email: profile.email?.trim()?.toLowerCase() || void 0,
+				deleted: Boolean(member.deleted),
+				isBot: Boolean(member.is_bot),
+				isAppUser: Boolean(member.is_app_user)
+			};
+		}).filter(Boolean)
+	});
+}
+function scoreSlackUser(user, match) {
+	let score = 0;
+	if (!user.deleted) score += 3;
+	if (!user.isBot && !user.isAppUser) score += 2;
+	if (match.email && user.email === match.email) score += 5;
+	if (match.name) {
+		const target = match.name.toLowerCase();
+		if ([
+			user.name,
+			user.displayName,
+			user.realName
+		].map((value) => value?.toLowerCase()).filter(Boolean).some((value) => value === target)) score += 2;
+	}
+	return score;
+}
+function resolveSlackUserFromMatches(input, matches, parsed) {
+	const best = matches.map((user) => ({
+		user,
+		score: scoreSlackUser(user, parsed)
+	})).toSorted((a, b) => b.score - a.score)[0]?.user ?? matches[0];
+	return {
+		input,
+		resolved: true,
+		id: best.id,
+		name: best.displayName ?? best.realName ?? best.name,
+		email: best.email,
+		deleted: best.deleted,
+		isBot: best.isBot,
+		note: matches.length > 1 ? "multiple matches; chose best" : void 0
+	};
+}
+async function resolveSlackUserAllowlist(params) {
+	const users = await listSlackUsers(params.client ?? createSlackWebClient(params.token));
+	return resolveSlackAllowlistEntries({
+		entries: params.entries,
+		lookup: users,
+		parseInput: parseSlackUserInput,
+		findById: (lookup, id) => lookup.find((user) => user.id === id),
+		buildIdResolved: ({ input, parsed, match }) => ({
+			input,
+			resolved: true,
+			id: parsed.id,
+			name: match?.displayName ?? match?.realName ?? match?.name,
+			email: match?.email,
+			deleted: match?.deleted,
+			isBot: match?.isBot
+		}),
+		resolveNonId: ({ input, parsed, lookup }) => {
+			if (parsed.email) {
+				const matches = lookup.filter((user) => user.email === parsed.email);
+				if (matches.length > 0) return resolveSlackUserFromMatches(input, matches, parsed);
+			}
+			if (parsed.name) {
+				const target = parsed.name.toLowerCase();
+				const matches = lookup.filter((user) => {
+					return [
+						user.name,
+						user.displayName,
+						user.realName
+					].map((value) => value?.toLowerCase()).filter(Boolean).includes(target);
+				});
+				if (matches.length > 0) return resolveSlackUserFromMatches(input, matches, parsed);
+			}
+		},
+		buildUnresolved: (input) => ({
+			input,
+			resolved: false
+		})
+	});
+}
+//#endregion
+//#region extensions/slack/src/resolve-channels.ts
+function parseSlackChannelMention(raw) {
+	const trimmed = raw.trim();
+	if (!trimmed) return {};
+	const mention = trimmed.match(/^<#([A-Z0-9]+)(?:\|([^>]+))?>$/i);
+	if (mention) return {
+		id: mention[1]?.toUpperCase(),
+		name: mention[2]?.trim()
+	};
+	const prefixed = trimmed.replace(/^(slack:|channel:)/i, "");
+	if (/^[CG][A-Z0-9]+$/i.test(prefixed)) return { id: prefixed.toUpperCase() };
+	const name = prefixed.replace(/^#/, "").trim();
+	return name ? { name } : {};
+}
+async function listSlackChannels(client) {
+	return collectSlackCursorItems({
+		fetchPage: async (cursor) => await client.conversations.list({
+			types: "public_channel,private_channel",
+			exclude_archived: false,
+			limit: 1e3,
+			cursor
+		}),
+		collectPageItems: (res) => (res.channels ?? []).map((channel) => {
+			const id = channel.id?.trim();
+			const name = channel.name?.trim();
+			if (!id || !name) return null;
+			return {
+				id,
+				name,
+				archived: Boolean(channel.is_archived),
+				isPrivate: Boolean(channel.is_private)
+			};
+		}).filter(Boolean)
+	});
+}
+function resolveByName(name, channels) {
+	const target = name.trim().toLowerCase();
+	if (!target) return;
+	const matches = channels.filter((channel) => channel.name.toLowerCase() === target);
+	if (matches.length === 0) return;
+	return matches.find((channel) => !channel.archived) ?? matches[0];
+}
+async function resolveSlackChannelAllowlist(params) {
+	const channels = await listSlackChannels(params.client ?? createSlackWebClient(params.token));
+	return resolveSlackAllowlistEntries({
+		entries: params.entries,
+		lookup: channels,
+		parseInput: parseSlackChannelMention,
+		findById: (lookup, id) => lookup.find((channel) => channel.id === id),
+		buildIdResolved: ({ input, parsed, match }) => ({
+			input,
+			resolved: true,
+			id: parsed.id,
+			name: match?.name ?? parsed.name,
+			archived: match?.archived
+		}),
+		resolveNonId: ({ input, parsed, lookup }) => {
+			if (!parsed.name) return;
+			const match = resolveByName(parsed.name, lookup);
+			if (!match) return;
+			return {
+				input,
+				resolved: true,
+				id: match.id,
+				name: match.name,
+				archived: match.archived
+			};
+		},
+		buildUnresolved: (input) => ({
+			input,
+			resolved: false
+		})
+	});
+}
+//#endregion
+export { resolveSlackUserAllowlist as n, resolveSlackChannelAllowlist as t };