@kodelyth/tlon 2026.5.39 → 2026.5.42

package/dist/doctor-contract-Ip6FcHDH.js

@@ -0,0 +1,7 @@
+import { createLegacyPrivateNetworkDoctorContract } from "klaw/plugin-sdk/ssrf-runtime";
+//#region extensions/tlon/src/doctor-contract.ts
+const contract = createLegacyPrivateNetworkDoctorContract({ channelKey: "tlon" });
+const legacyConfigRules = contract.legacyConfigRules;
+const normalizeCompatibilityConfig = contract.normalizeCompatibilityConfig;
+//#endregion
+export { normalizeCompatibilityConfig as n, legacyConfigRules as t };

package/dist/doctor-contract-api.js

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

package/dist/index.js

@@ -0,0 +1,18 @@
+import { defineBundledChannelEntry } from "klaw/plugin-sdk/channel-entry-contract";
+//#region extensions/tlon/index.ts
+var tlon_default = defineBundledChannelEntry({
+	id: "tlon",
+	name: "Tlon",
+	description: "Tlon/Urbit channel plugin",
+	importMetaUrl: import.meta.url,
+	plugin: {
+		specifier: "./channel-plugin-api.js",
+		exportName: "tlonPlugin"
+	},
+	runtime: {
+		specifier: "./api.js",
+		exportName: "setTlonRuntime"
+	}
+});
+//#endregion
+export { tlon_default as default };

package/dist/runtime-BmSb9A-q.js

@@ -0,0 +1,8 @@
+import { createPluginRuntimeStore } from "klaw/plugin-sdk/runtime-store";
+//#region extensions/tlon/src/runtime.ts
+const { setRuntime: setTlonRuntime, getRuntime: getTlonRuntime } = createPluginRuntimeStore({
+	pluginId: "tlon",
+	errorMessage: "Tlon runtime not initialized"
+});
+//#endregion
+export { setTlonRuntime as n, getTlonRuntime as t };

package/dist/runtime-api-Dq8wkBC_.js

@@ -0,0 +1,4 @@
+import { createDedupeCache } from "klaw/plugin-sdk/core";
+import { createLoggerBackedRuntime } from "klaw/plugin-sdk/runtime";
+import { SsrFBlockedError, fetchWithSsrFGuard as fetchWithSsrFGuard$1, isBlockedHostnameOrIp as isBlockedHostnameOrIp$1, ssrfPolicyFromAllowPrivateNetwork, ssrfPolicyFromDangerouslyAllowPrivateNetwork } from "klaw/plugin-sdk/ssrf-runtime";
+export { ssrfPolicyFromAllowPrivateNetwork as a, isBlockedHostnameOrIp$1 as i, createDedupeCache as n, ssrfPolicyFromDangerouslyAllowPrivateNetwork as o, fetchWithSsrFGuard$1 as r, createLoggerBackedRuntime as s, SsrFBlockedError as t };

package/dist/runtime-api.js

@@ -0,0 +1,2 @@
+import { a as ssrfPolicyFromAllowPrivateNetwork, i as isBlockedHostnameOrIp, n as createDedupeCache, o as ssrfPolicyFromDangerouslyAllowPrivateNetwork, r as fetchWithSsrFGuard, s as createLoggerBackedRuntime, t as SsrFBlockedError } from "./runtime-api-Dq8wkBC_.js";
+export { SsrFBlockedError, createDedupeCache, createLoggerBackedRuntime, fetchWithSsrFGuard, isBlockedHostnameOrIp, ssrfPolicyFromAllowPrivateNetwork, ssrfPolicyFromDangerouslyAllowPrivateNetwork };

package/dist/setup-api.js

@@ -0,0 +1,3 @@
+import { a as tlonSetupAdapter } from "./setup-core-CF3ryHqs.js";
+import { t as tlonSetupWizard } from "./setup-surface-BM5_V_XL.js";
+export { tlonSetupAdapter, tlonSetupWizard };

package/dist/setup-core-CF3ryHqs.js

@@ -0,0 +1,387 @@
+import { hasLegacyFlatAllowPrivateNetworkAlias, isBlockedHostnameOrIp, isPrivateNetworkOptInEnabled } from "klaw/plugin-sdk/ssrf-runtime";
+import { DEFAULT_ACCOUNT_ID, createSetupInputPresenceValidator, createSetupTranslator, formatDocsLink, normalizeAccountId, patchScopedAccountConfig, prepareScopedSetupConfig } from "klaw/plugin-sdk/setup";
+import { normalizeOptionalString, normalizeStringifiedOptionalString } from "klaw/plugin-sdk/string-coerce-runtime";
+import { DEFAULT_ACCOUNT_ID as DEFAULT_ACCOUNT_ID$1, listCombinedAccountIds, normalizeAccountId as normalizeAccountId$1, resolveMergedAccountConfig } from "klaw/plugin-sdk/account-resolution";
+//#region extensions/tlon/src/targets.ts
+const SHIP_RE = /^~?[a-z-]+$/i;
+const NEST_RE = /^chat\/([^/]+)\/([^/]+)$/i;
+function normalizeShip(raw) {
+	const trimmed = raw.trim();
+	if (!trimmed) return trimmed;
+	return trimmed.startsWith("~") ? trimmed : `~${trimmed}`;
+}
+function parseChannelNest(raw) {
+	const match = NEST_RE.exec(raw.trim());
+	if (!match) return null;
+	return {
+		hostShip: normalizeShip(match[1]),
+		channelName: match[2]
+	};
+}
+function makeGroupTarget(parsed) {
+	return {
+		kind: "group",
+		nest: `chat/${parsed.hostShip}/${parsed.channelName}`,
+		hostShip: parsed.hostShip,
+		channelName: parsed.channelName
+	};
+}
+function parseTlonTarget(raw) {
+	const trimmed = raw?.trim();
+	if (!trimmed) return null;
+	const withoutPrefix = trimmed.replace(/^tlon:/i, "");
+	const dmPrefix = withoutPrefix.match(/^dm[/:](.+)$/i);
+	if (dmPrefix) return {
+		kind: "dm",
+		ship: normalizeShip(dmPrefix[1])
+	};
+	const groupPrefix = withoutPrefix.match(/^(group|room)[/:](.+)$/i);
+	if (groupPrefix) {
+		const groupTarget = groupPrefix[2].trim();
+		if (groupTarget.startsWith("chat/")) {
+			const parsed = parseChannelNest(groupTarget);
+			if (!parsed) return null;
+			return makeGroupTarget(parsed);
+		}
+		const parts = groupTarget.split("/");
+		if (parts.length === 2) {
+			const hostShip = normalizeShip(parts[0]);
+			const channelName = parts[1];
+			return {
+				kind: "group",
+				nest: `chat/${hostShip}/${channelName}`,
+				hostShip,
+				channelName
+			};
+		}
+		return null;
+	}
+	if (withoutPrefix.startsWith("chat/")) {
+		const parsed = parseChannelNest(withoutPrefix);
+		if (!parsed) return null;
+		return makeGroupTarget(parsed);
+	}
+	if (SHIP_RE.test(withoutPrefix)) return {
+		kind: "dm",
+		ship: normalizeShip(withoutPrefix)
+	};
+	return null;
+}
+function resolveTlonOutboundTarget(to) {
+	const parsed = parseTlonTarget(to ?? "");
+	if (!parsed) return {
+		ok: false,
+		error: /* @__PURE__ */ new Error(`Invalid Tlon target. Use ${formatTargetHint()}`)
+	};
+	if (parsed.kind === "dm") return {
+		ok: true,
+		to: parsed.ship
+	};
+	return {
+		ok: true,
+		to: parsed.nest
+	};
+}
+function formatTargetHint() {
+	return "dm/~sampel-palnet | ~sampel-palnet | chat/~host-ship/channel | group:~host-ship/channel";
+}
+//#endregion
+//#region extensions/tlon/src/account-fields.ts
+function buildTlonAccountFields(input) {
+	return {
+		...input.ship ? { ship: input.ship } : {},
+		...input.url ? { url: input.url } : {},
+		...input.code ? { code: input.code } : {},
+		...typeof input.dangerouslyAllowPrivateNetwork === "boolean" ? { network: { dangerouslyAllowPrivateNetwork: input.dangerouslyAllowPrivateNetwork } } : {},
+		...input.groupChannels ? { groupChannels: input.groupChannels } : {},
+		...input.dmAllowlist ? { dmAllowlist: input.dmAllowlist } : {},
+		...typeof input.autoDiscoverChannels === "boolean" ? { autoDiscoverChannels: input.autoDiscoverChannels } : {},
+		...input.ownerShip ? { ownerShip: input.ownerShip } : {}
+	};
+}
+//#endregion
+//#region extensions/tlon/src/types.ts
+function resolveTlonChannelConfig(cfg) {
+	return cfg.channels?.tlon;
+}
+function resolveMergedTlonAccountConfig(cfg, accountId) {
+	const channel = resolveTlonChannelConfig(cfg);
+	if (accountId === DEFAULT_ACCOUNT_ID$1) return channel ?? {};
+	return resolveMergedAccountConfig({
+		channelConfig: channel ?? {},
+		accounts: channel?.accounts,
+		accountId,
+		normalizeAccountId: normalizeAccountId$1
+	});
+}
+function resolveTlonAccount(cfg, accountId) {
+	const resolvedAccountId = normalizeAccountId$1(accountId);
+	if (!resolveTlonChannelConfig(cfg)) return {
+		accountId: resolvedAccountId,
+		name: null,
+		enabled: false,
+		configured: false,
+		ship: null,
+		url: null,
+		code: null,
+		dangerouslyAllowPrivateNetwork: null,
+		groupChannels: [],
+		dmAllowlist: [],
+		groupInviteAllowlist: [],
+		autoDiscoverChannels: null,
+		showModelSignature: null,
+		autoAcceptDmInvites: null,
+		autoAcceptGroupInvites: null,
+		defaultAuthorizedShips: [],
+		ownerShip: null
+	};
+	const merged = resolveMergedTlonAccountConfig(cfg, resolvedAccountId);
+	const ship = merged.ship ?? null;
+	const url = merged.url ?? null;
+	const code = merged.code ?? null;
+	const dangerouslyAllowPrivateNetwork = isPrivateNetworkOptInEnabled(merged) ? true : typeof merged.network?.dangerouslyAllowPrivateNetwork === "boolean" ? merged.network.dangerouslyAllowPrivateNetwork : hasLegacyFlatAllowPrivateNetworkAlias(merged) && typeof merged.allowPrivateNetwork === "boolean" ? merged.allowPrivateNetwork : null;
+	const groupChannels = merged.groupChannels ?? [];
+	const dmAllowlist = merged.dmAllowlist ?? [];
+	const groupInviteAllowlist = merged.groupInviteAllowlist ?? [];
+	const autoDiscoverChannels = merged.autoDiscoverChannels ?? null;
+	const showModelSignature = merged.showModelSignature ?? null;
+	const autoAcceptDmInvites = merged.autoAcceptDmInvites ?? null;
+	const autoAcceptGroupInvites = merged.autoAcceptGroupInvites ?? null;
+	const ownerShip = merged.ownerShip ?? null;
+	const defaultAuthorizedShips = merged.defaultAuthorizedShips ?? [];
+	const configured = Boolean(ship && url && code);
+	return {
+		accountId: resolvedAccountId,
+		name: merged.name ?? null,
+		enabled: merged.enabled !== false,
+		configured,
+		ship,
+		url,
+		code,
+		dangerouslyAllowPrivateNetwork,
+		groupChannels,
+		dmAllowlist,
+		groupInviteAllowlist,
+		autoDiscoverChannels,
+		showModelSignature,
+		autoAcceptDmInvites,
+		autoAcceptGroupInvites,
+		defaultAuthorizedShips,
+		ownerShip
+	};
+}
+function listTlonAccountIds(cfg) {
+	const base = resolveTlonChannelConfig(cfg);
+	if (!base) return [];
+	return listCombinedAccountIds({
+		configuredAccountIds: Object.keys(base.accounts ?? {}).map(normalizeAccountId$1),
+		implicitAccountId: base.ship ? DEFAULT_ACCOUNT_ID$1 : void 0
+	});
+}
+//#endregion
+//#region extensions/tlon/src/urbit/base-url.ts
+function hasScheme(value) {
+	return /^[a-zA-Z][a-zA-Z0-9+.-]*:\/\//.test(value);
+}
+function normalizeUrbitHostname(hostname) {
+	return (hostname ?? "").trim().toLowerCase().replace(/\.$/, "");
+}
+function validateUrbitBaseUrl(raw) {
+	const trimmed = raw.trim();
+	if (!trimmed) return {
+		ok: false,
+		error: "Required"
+	};
+	const candidate = hasScheme(trimmed) ? trimmed : `https://${trimmed}`;
+	let parsed;
+	try {
+		parsed = new URL(candidate);
+	} catch {
+		return {
+			ok: false,
+			error: "Invalid URL"
+		};
+	}
+	if (!["http:", "https:"].includes(parsed.protocol)) return {
+		ok: false,
+		error: "URL must use http:// or https://"
+	};
+	if (parsed.username || parsed.password) return {
+		ok: false,
+		error: "URL must not include credentials"
+	};
+	const hostname = normalizeUrbitHostname(parsed.hostname);
+	if (!hostname) return {
+		ok: false,
+		error: "Invalid hostname"
+	};
+	const isIpv6 = hostname.includes(":");
+	const host = parsed.port ? `${isIpv6 ? `[${hostname}]` : hostname}:${parsed.port}` : isIpv6 ? `[${hostname}]` : hostname;
+	return {
+		ok: true,
+		baseUrl: `${parsed.protocol}//${host}`,
+		hostname
+	};
+}
+function isBlockedUrbitHostname(hostname) {
+	const normalized = normalizeUrbitHostname(hostname);
+	if (!normalized) return false;
+	return isBlockedHostnameOrIp(normalized);
+}
+//#endregion
+//#region extensions/tlon/src/setup-core.ts
+const t = createSetupTranslator();
+function tlonChannelId() {
+	return "tlon";
+}
+function isConfigured(account) {
+	return Boolean(account.ship && account.url && account.code);
+}
+function createTlonSetupWizardBase(params) {
+	return {
+		channel: tlonChannelId(),
+		status: {
+			configuredLabel: t("wizard.channels.statusConfigured"),
+			unconfiguredLabel: t("wizard.channels.statusNeedsSetup"),
+			configuredHint: t("wizard.channels.statusConfigured"),
+			unconfiguredHint: t("wizard.channels.statusUrbitMessenger"),
+			configuredScore: 1,
+			unconfiguredScore: 4,
+			resolveConfigured: ({ cfg, accountId }) => params.resolveConfigured({
+				cfg,
+				accountId
+			}),
+			resolveStatusLines: ({ cfg, accountId, configured }) => params.resolveStatusLines?.({
+				cfg,
+				accountId,
+				configured
+			}) ?? []
+		},
+		introNote: {
+			title: t("wizard.tlon.setupTitle"),
+			lines: [
+				t("wizard.tlon.helpNeedsUrlCode"),
+				t("wizard.tlon.helpExampleUrl"),
+				t("wizard.tlon.helpExampleShip"),
+				t("wizard.tlon.helpPrivateNetwork"),
+				`Docs: ${formatDocsLink("/channels/tlon", "channels/tlon")}`
+			]
+		},
+		credentials: [],
+		textInputs: [
+			{
+				inputKey: "ship",
+				message: t("wizard.tlon.shipPrompt"),
+				placeholder: "~sampel-palnet",
+				currentValue: ({ cfg, accountId }) => resolveTlonAccount(cfg, accountId).ship ?? void 0,
+				validate: ({ value }) => normalizeStringifiedOptionalString(value) ? void 0 : "Required",
+				normalizeValue: ({ value }) => normalizeShip(normalizeStringifiedOptionalString(value) ?? ""),
+				applySet: async ({ cfg, accountId, value }) => applyTlonSetupConfig({
+					cfg,
+					accountId,
+					input: { ship: value }
+				})
+			},
+			{
+				inputKey: "url",
+				message: t("wizard.tlon.shipUrlPrompt"),
+				placeholder: "https://your-ship-host",
+				currentValue: ({ cfg, accountId }) => resolveTlonAccount(cfg, accountId).url ?? void 0,
+				validate: ({ value }) => {
+					const next = validateUrbitBaseUrl(value ?? "");
+					if (!next.ok) return next.error;
+				},
+				normalizeValue: ({ value }) => normalizeStringifiedOptionalString(value) ?? "",
+				applySet: async ({ cfg, accountId, value }) => applyTlonSetupConfig({
+					cfg,
+					accountId,
+					input: { url: value }
+				})
+			},
+			{
+				inputKey: "code",
+				message: t("wizard.tlon.loginCodePrompt"),
+				placeholder: "lidlut-tabwed-pillex-ridrup",
+				currentValue: ({ cfg, accountId }) => resolveTlonAccount(cfg, accountId).code ?? void 0,
+				validate: ({ value }) => normalizeStringifiedOptionalString(value) ? void 0 : "Required",
+				normalizeValue: ({ value }) => normalizeStringifiedOptionalString(value) ?? "",
+				applySet: async ({ cfg, accountId, value }) => applyTlonSetupConfig({
+					cfg,
+					accountId,
+					input: { code: value }
+				})
+			}
+		],
+		finalize: params.finalize
+	};
+}
+async function resolveTlonSetupConfigured(cfg, accountId) {
+	if (accountId) return isConfigured(resolveTlonAccount(cfg, accountId));
+	const accountIds = listTlonAccountIds(cfg);
+	return accountIds.length > 0 ? accountIds.some((resolvedAccountId) => isConfigured(resolveTlonAccount(cfg, resolvedAccountId))) : isConfigured(resolveTlonAccount(cfg, DEFAULT_ACCOUNT_ID));
+}
+async function resolveTlonSetupStatusLines(cfg, accountId) {
+	const configured = await resolveTlonSetupConfigured(cfg, accountId);
+	return [`${accountId && accountId !== DEFAULT_ACCOUNT_ID ? `Tlon (${accountId})` : "Tlon"}: ${configured ? "configured" : "needs setup"}`];
+}
+function applyTlonSetupConfig(params) {
+	const { cfg, accountId, input } = params;
+	const useDefault = accountId === DEFAULT_ACCOUNT_ID;
+	const namedConfig = prepareScopedSetupConfig({
+		cfg,
+		channelKey: tlonChannelId(),
+		accountId,
+		name: input.name
+	});
+	const base = namedConfig.channels?.tlon ?? {};
+	const payload = buildTlonAccountFields(input);
+	if (useDefault) return {
+		...namedConfig,
+		channels: {
+			...namedConfig.channels,
+			tlon: {
+				...base,
+				enabled: true,
+				...payload
+			}
+		}
+	};
+	return patchScopedAccountConfig({
+		cfg: namedConfig,
+		channelKey: tlonChannelId(),
+		accountId,
+		patch: { enabled: base.enabled ?? true },
+		accountPatch: {
+			enabled: true,
+			...payload
+		},
+		ensureChannelEnabled: false,
+		ensureAccountEnabled: false
+	});
+}
+const tlonSetupAdapter = {
+	resolveAccountId: ({ accountId }) => normalizeAccountId(accountId),
+	applyAccountName: ({ cfg, accountId, name }) => prepareScopedSetupConfig({
+		cfg,
+		channelKey: tlonChannelId(),
+		accountId,
+		name
+	}),
+	validateInput: createSetupInputPresenceValidator({ validate: ({ cfg, accountId, input }) => {
+		const resolved = resolveTlonAccount(cfg, accountId ?? void 0);
+		const ship = normalizeOptionalString(input.ship) || resolved.ship;
+		const url = normalizeOptionalString(input.url) || resolved.url;
+		const code = normalizeOptionalString(input.code) || resolved.code;
+		if (!ship) return "Tlon requires --ship.";
+		if (!url) return "Tlon requires --url.";
+		if (!code) return "Tlon requires --code.";
+		return null;
+	} }),
+	applyAccountConfig: ({ cfg, accountId, input }) => applyTlonSetupConfig({
+		cfg,
+		accountId,
+		input
+	})
+};
+//#endregion
+export { tlonSetupAdapter as a, validateUrbitBaseUrl as c, formatTargetHint as d, normalizeShip as f, resolveTlonOutboundTarget as h, resolveTlonSetupStatusLines as i, listTlonAccountIds as l, parseTlonTarget as m, createTlonSetupWizardBase as n, isBlockedUrbitHostname as o, parseChannelNest as p, resolveTlonSetupConfigured as r, normalizeUrbitHostname as s, applyTlonSetupConfig as t, resolveTlonAccount as u };

package/dist/setup-entry.js

@@ -0,0 +1,11 @@
+import { defineBundledChannelSetupEntry } from "klaw/plugin-sdk/channel-entry-contract";
+//#region extensions/tlon/setup-entry.ts
+var setup_entry_default = defineBundledChannelSetupEntry({
+	importMetaUrl: import.meta.url,
+	plugin: {
+		specifier: "./api.js",
+		exportName: "tlonPlugin"
+	}
+});
+//#endregion
+export { setup_entry_default as default };

package/dist/setup-surface-BM5_V_XL.js

@@ -0,0 +1,74 @@
+import { c as validateUrbitBaseUrl, f as normalizeShip, i as resolveTlonSetupStatusLines, n as createTlonSetupWizardBase, o as isBlockedUrbitHostname, r as resolveTlonSetupConfigured, t as applyTlonSetupConfig, u as resolveTlonAccount } from "./setup-core-CF3ryHqs.js";
+import { createSetupTranslator } from "klaw/plugin-sdk/setup-runtime";
+//#region extensions/tlon/src/setup-surface.ts
+const t = createSetupTranslator();
+function parseList(value) {
+	return value.split(/[\n,;]+/g).map((entry) => entry.trim()).filter(Boolean);
+}
+const tlonSetupWizard = createTlonSetupWizardBase({
+	resolveConfigured: async ({ cfg, accountId }) => await resolveTlonSetupConfigured(cfg, accountId),
+	resolveStatusLines: async ({ cfg, accountId }) => await resolveTlonSetupStatusLines(cfg, accountId),
+	finalize: async ({ cfg, accountId, prompter }) => {
+		let next = cfg;
+		const resolved = resolveTlonAccount(next, accountId);
+		const validatedUrl = validateUrbitBaseUrl(resolved.url ?? "");
+		if (!validatedUrl.ok) throw new Error(`Invalid URL: ${validatedUrl.error}`);
+		let dangerouslyAllowPrivateNetwork = resolved.dangerouslyAllowPrivateNetwork ?? false;
+		if (isBlockedUrbitHostname(validatedUrl.hostname)) {
+			dangerouslyAllowPrivateNetwork = await prompter.confirm({
+				message: t("wizard.tlon.privateNetworkPrompt"),
+				initialValue: dangerouslyAllowPrivateNetwork
+			});
+			if (!dangerouslyAllowPrivateNetwork) throw new Error("Refusing private/internal ship URL without explicit network opt-in");
+		}
+		next = applyTlonSetupConfig({
+			cfg: next,
+			accountId,
+			input: { dangerouslyAllowPrivateNetwork }
+		});
+		const currentGroups = resolved.groupChannels;
+		if (await prompter.confirm({
+			message: t("wizard.tlon.addGroupsPrompt"),
+			initialValue: currentGroups.length > 0
+		})) {
+			const entry = await prompter.text({
+				message: t("wizard.tlon.groupChannelsPrompt"),
+				placeholder: "chat/~host-ship/general, chat/~host-ship/support",
+				initialValue: currentGroups.join(", ") || void 0
+			});
+			next = applyTlonSetupConfig({
+				cfg: next,
+				accountId,
+				input: { groupChannels: parseList(entry ?? "") }
+			});
+		}
+		const currentAllowlist = resolved.dmAllowlist;
+		if (await prompter.confirm({
+			message: t("wizard.tlon.restrictDmsPrompt"),
+			initialValue: currentAllowlist.length > 0
+		})) {
+			const entry = await prompter.text({
+				message: t("wizard.tlon.dmAllowlistPrompt"),
+				placeholder: "~zod, ~nec",
+				initialValue: currentAllowlist.join(", ") || void 0
+			});
+			next = applyTlonSetupConfig({
+				cfg: next,
+				accountId,
+				input: { dmAllowlist: parseList(entry ?? "").map((ship) => normalizeShip(ship)) }
+			});
+		}
+		const autoDiscoverChannels = await prompter.confirm({
+			message: t("wizard.tlon.autoDiscoveryPrompt"),
+			initialValue: resolved.autoDiscoverChannels ?? true
+		});
+		next = applyTlonSetupConfig({
+			cfg: next,
+			accountId,
+			input: { autoDiscoverChannels }
+		});
+		return { cfg: next };
+	}
+});
+//#endregion
+export { tlonSetupWizard as t };

package/dist/test-api.js

@@ -0,0 +1,2 @@
+import { t as tlonPlugin } from "./channel-Bvzym9ez.js";
+export { tlonPlugin };

package/doctor-contract-api.ts

@@ -0,0 +1 @@
+export { normalizeCompatibilityConfig, legacyConfigRules } from "./src/doctor-contract.js";

package/index.ts

@@ -0,0 +1,16 @@
+import { defineBundledChannelEntry } from "klaw/plugin-sdk/channel-entry-contract";
+
+export default defineBundledChannelEntry({
+  id: "tlon",
+  name: "Tlon",
+  description: "Tlon/Urbit channel plugin",
+  importMetaUrl: import.meta.url,
+  plugin: {
+    specifier: "./channel-plugin-api.js",
+    exportName: "tlonPlugin",
+  },
+  runtime: {
+    specifier: "./api.js",
+    exportName: "setTlonRuntime",
+  },
+});