@plitzi/sdk-server 0.32.25 → 0.33.0

package/dist/modules/mcp/helpers/log.js

@@ -1,64 +0,0 @@
-import { renderLogEvent } from "../../../helpers/serverLog.js";
-//#region src/modules/mcp/helpers/log.ts
-var MCP_DEBUG = process.env.MCP_DEBUG === "1";
-var MCP_LOG_ARGS = process.env.MCP_LOG_ARGS === "1";
-var shapeOf = (value, depth = 0) => {
-	if (value === null) return "null";
-	if (Array.isArray(value)) return `[${value.length}]`;
-	if (typeof value === "object") {
-		if (depth >= 2) return "{…}";
-		const entries = Object.entries(value);
-		const shown = entries.slice(0, 8).map(([key, item]) => `${key}:${shapeOf(item, depth + 1)}`);
-		return `{${[...shown, ...entries.length > shown.length ? ["…"] : []].join(",")}}`;
-	}
-	return typeof value;
-};
-var rawSummary = (value, max = 300) => {
-	let json;
-	try {
-		json = JSON.stringify(value);
-	} catch {
-		return "[unserializable]";
-	}
-	return json.length > max ? `${json.slice(0, max)}…` : json;
-};
-var summarize = (value) => {
-	if (value === void 0) return;
-	return MCP_LOG_ARGS ? rawSummary(value) : shapeOf(value);
-};
-var errorText = (error) => error instanceof Error ? error.message : String(error);
-var noop = () => void 0;
-var inertLog = {
-	toolCall: noop,
-	resourceRead: noop
-};
-/** Build the protocol-log sink for one MCP server. Dispatches structured events to the consumer's `logger` when
-*  provided; otherwise renders to the console when MCP_DEBUG=1; otherwise a no-op. */
-var createMcpLog = (logger) => {
-	if (!logger && !MCP_DEBUG) return inertLog;
-	const emit = (event) => {
-		if (logger) logger(event);
-		else console.log(renderLogEvent(event));
-	};
-	return {
-		toolCall: (name, args, ms, error) => emit({
-			kind: "tool",
-			name,
-			durationMs: ms,
-			ok: !error,
-			...error ? { error: errorText(error) } : {},
-			...summarize(args) !== void 0 ? { argsSummary: summarize(args) } : {},
-			timestamp: (/* @__PURE__ */ new Date()).toISOString()
-		}),
-		resourceRead: (uri, ms, error) => emit({
-			kind: "resource",
-			name: uri,
-			durationMs: ms,
-			ok: !error,
-			...error ? { error: errorText(error) } : {},
-			timestamp: (/* @__PURE__ */ new Date()).toISOString()
-		})
-	};
-};
-//#endregion
-export { createMcpLog };

package/dist/modules/mcp/helpers/opResult.js

@@ -1,18 +0,0 @@
-//#region src/modules/mcp/helpers/opResult.ts
-var empty = () => ({
-	created: 0,
-	updated: 0,
-	deleted: 0,
-	staleResources: []
-});
-var fail = (path, message, hint, validValues) => ({
-	...empty(),
-	errors: [{
-		path,
-		message,
-		hint,
-		validValues
-	}]
-});
-//#endregion
-export { empty, fail };

package/dist/modules/mcp/helpers/space.js

@@ -1,300 +0,0 @@
-//#region src/modules/mcp/helpers/space.ts
-var cloneSpace = (space) => ({
-	schema: structuredClone(space.schema),
-	style: structuredClone(space.style),
-	...space.catalog ? { catalog: space.catalog } : {}
-});
-var emptySpace = () => ({
-	schema: {
-		flat: {},
-		definition: {
-			name: "",
-			permanentUrl: ""
-		},
-		variables: [],
-		settings: { customCss: "" },
-		pages: [],
-		pageFolders: []
-	},
-	style: {
-		platform: {
-			desktop: {},
-			tablet: {},
-			mobile: {}
-		},
-		theme: {
-			default: "system",
-			schemes: ["light", "dark"]
-		},
-		variables: {},
-		cache: ""
-	}
-});
-var slugify = (value) => value.toLowerCase().replace(/[^a-z0-9._-]+/g, "-").replace(/^-+|-+$/g, "") || "";
-/** A value when it is a string, otherwise undefined — for the many attributes typed as `unknown` that are strings
-*  in practice (name, slug, subType, dom id…). */
-var strOr = (value) => typeof value === "string" ? value : void 0;
-/** Display name of a page or element: its `name` attribute when set, otherwise its definition label. */
-var nameOf = (el) => strOr(el.attributes.name) ?? el.definition.label;
-/** Stable, human-readable ref for a page: its idRef, then slug, then a slugified label. A page without an idRef is
-*  still addressable — unlike a data source, a page ref has meaningful fallbacks the agent can read off the tree. */
-var pageRefOf = (el) => {
-	if (el.idRef) return el.idRef;
-	const slug = strOr(el.attributes.slug)?.trim();
-	if (slug) return slugify(slug);
-	if (el.attributes.default === true) return "home";
-	return slugify(nameOf(el)) || el.id;
-};
-/** Stable ref for ADDRESSING a non-page element in the tree: its idRef when present, otherwise the opaque id so an
-*  element without one is still reachable — the agent needs to name it to give it an idRef in the first place.
-*  This is not the wiring key: the runtime wires interactions and data sources by idRef only, so an element
-*  addressed here by its id alone publishes no source and takes no interactions (see `getSourceName`). */
-var elementRefOf = (el) => el.idRef ?? el.id;
-var buildIndex = (schema) => {
-	const flat = schema.flat;
-	const lookup = (id) => flat[id];
-	const pageIds = new Set(schema.pages);
-	for (const el of Object.values(flat)) if (el.definition.type === "page") pageIds.add(el.id);
-	const pageElements = [];
-	const pageByRef = /* @__PURE__ */ new Map();
-	const elementByRef = /* @__PURE__ */ new Map();
-	for (const el of Object.values(flat)) if (pageIds.has(el.id)) {
-		pageElements.push(el);
-		const ref = pageRefOf(el);
-		if (!pageByRef.has(ref)) pageByRef.set(ref, el);
-		if (!pageByRef.has(el.id)) pageByRef.set(el.id, el);
-	} else {
-		const ref = elementRefOf(el);
-		if (!elementByRef.has(ref)) elementByRef.set(ref, el);
-		if (!elementByRef.has(el.id)) elementByRef.set(el.id, el);
-	}
-	const pageOf = /* @__PURE__ */ new Map();
-	for (const page of pageElements) {
-		pageOf.set(page.id, page.id);
-		const stack = [...page.definition.items ?? []];
-		while (stack.length > 0) {
-			const id = stack.pop();
-			if (id === void 0 || pageOf.has(id)) continue;
-			const el = lookup(id);
-			if (!el) continue;
-			pageOf.set(id, page.id);
-			for (const childId of el.definition.items ?? []) stack.push(childId);
-		}
-	}
-	return {
-		pageIds,
-		pageElements,
-		pageByRef,
-		elementByRef,
-		pageOf,
-		detailCache: /* @__PURE__ */ new Map()
-	};
-};
-var indexCache = /* @__PURE__ */ new WeakMap();
-/** The index for a schema, built once and memoized on the schema object. */
-var spaceIndex = (schema) => {
-	let index = indexCache.get(schema);
-	if (!index) {
-		index = buildIndex(schema);
-		indexCache.set(schema, index);
-	}
-	return index;
-};
-var cachedIndex = (schema) => indexCache.get(schema);
-/** A new non-page element was created under `pageId`. */
-var indexAddElement = (schema, el, pageId) => {
-	const index = cachedIndex(schema);
-	if (!index) return;
-	index.elementByRef.set(el.id, el);
-	if (el.idRef) index.elementByRef.set(el.idRef, el);
-	index.pageOf.set(el.id, pageId);
-	index.detailCache.clear();
-};
-/** These non-page elements were deleted (an element and its descendants). */
-var indexRemoveElements = (schema, els) => {
-	const index = cachedIndex(schema);
-	if (!index) return;
-	for (const el of els) {
-		index.elementByRef.delete(el.id);
-		if (el.idRef) index.elementByRef.delete(el.idRef);
-		index.pageOf.delete(el.id);
-	}
-	index.detailCache.clear();
-};
-/** An existing element was just given an idRef (it had none), so it becomes addressable by that ref. */
-var indexReRefElement = (schema, el) => {
-	const index = cachedIndex(schema);
-	if (!index) return;
-	if (el.idRef) index.elementByRef.set(el.idRef, el);
-	index.detailCache.clear();
-};
-/** A new page element was created. */
-var indexAddPage = (schema, page) => {
-	const index = cachedIndex(schema);
-	if (!index) return;
-	index.pageIds.add(page.id);
-	index.pageElements.push(page);
-	index.pageByRef.set(page.id, page);
-	index.pageByRef.set(pageRefOf(page), page);
-	index.pageOf.set(page.id, page.id);
-	index.detailCache.clear();
-};
-/** A page and its `descendants` (its non-page elements) were deleted. */
-var indexRemovePage = (schema, page, descendants) => {
-	const index = cachedIndex(schema);
-	if (!index) return;
-	index.pageIds.delete(page.id);
-	const at = index.pageElements.findIndex((p) => p.id === page.id);
-	if (at >= 0) index.pageElements.splice(at, 1);
-	index.pageByRef.delete(page.id);
-	index.pageByRef.delete(pageRefOf(page));
-	index.pageOf.delete(page.id);
-	for (const el of descendants) {
-		index.elementByRef.delete(el.id);
-		if (el.idRef) index.elementByRef.delete(el.idRef);
-		index.pageOf.delete(el.id);
-	}
-	index.detailCache.clear();
-};
-/** A page's slug/name/default changed; re-key its pageByRef entry if that changed its ref. `oldRef` is the ref
-*  computed BEFORE the attribute change. */
-var indexReRefPage = (schema, page, oldRef) => {
-	const index = cachedIndex(schema);
-	if (!index) return;
-	const newRef = pageRefOf(page);
-	if (newRef !== oldRef) {
-		index.pageByRef.delete(oldRef);
-		index.pageByRef.set(newRef, page);
-		index.detailCache.clear();
-	}
-};
-/** A move reparented an element within its page: the ref/page maps are unchanged, but the moved element's
-*  parentRef and both parents' childRefs did change, so their memoized detail must be dropped. */
-var indexInvalidateDetails = (schema) => {
-	cachedIndex(schema)?.detailCache.clear();
-};
-var isPageElement = (schema, el) => spaceIndex(schema).pageIds.has(el.id) || el.definition.type === "page";
-var getPageElements = (schema) => spaceIndex(schema).pageElements;
-/** Finds a page by its semantic ref (idRef/slug/…) or its raw id, so legacy schemas without an idRef still resolve. */
-var findPageByRef = (schema, pageRef) => spaceIndex(schema).pageByRef.get(pageRef);
-/** Find any non-page element by its semantic ref (idRef) or raw id, across the whole space. */
-var findElementByRef = (schema, ref) => spaceIndex(schema).elementByRef.get(ref);
-var pageFoldersOf = (schema) => {
-	schema.pageFolders ??= [];
-	return schema.pageFolders;
-};
-/** Resolve a folder by its id, or (for agent convenience) by an exact name or slug when that is unambiguous. */
-var findFolderByRef = (schema, ref) => {
-	const folders = pageFoldersOf(schema);
-	const byId = folders.find((f) => f.id === ref);
-	if (byId) return byId;
-	const byName = folders.filter((f) => f.name === ref);
-	if (byName.length === 1) return byName[0];
-	const bySlug = folders.filter((f) => f.slug === ref);
-	return bySlug.length === 1 ? bySlug[0] : void 0;
-};
-/** Order folders so every parent precedes its children — the invariant the schema validator enforces on
-*  pageFolders (a parentId must appear earlier in the array). Cycles (rejected upstream) are left in place. */
-var sortFolders = (folders) => {
-	const byId = new Map(folders.map((f) => [f.id, f]));
-	const placed = /* @__PURE__ */ new Set();
-	const result = [];
-	const visit = (folder, ancestry) => {
-		if (placed.has(folder.id)) return;
-		const parent = folder.parentId ? byId.get(folder.parentId) : void 0;
-		if (parent && !ancestry.has(parent.id)) visit(parent, new Set(ancestry).add(folder.id));
-		if (!placed.has(folder.id)) {
-			placed.add(folder.id);
-			result.push(folder);
-		}
-	};
-	for (const folder of folders) visit(folder, /* @__PURE__ */ new Set([folder.id]));
-	return result;
-};
-/** Ancestor ids of a folder (following parentId), stopping on a cycle. Used to reject a parent change that would
-*  make a folder its own ancestor. */
-var folderAncestorIds = (folders, startParentId) => {
-	const byId = new Map(folders.map((f) => [f.id, f]));
-	const chain = [];
-	const seen = /* @__PURE__ */ new Set();
-	let current = startParentId ? byId.get(startParentId) : void 0;
-	while (current && !seen.has(current.id)) {
-		seen.add(current.id);
-		chain.push(current.id);
-		current = current.parentId ? byId.get(current.parentId) : void 0;
-	}
-	return chain;
-};
-/** Route params a page's slug binds (e.g. ":spaceId/update/*" → ["spaceId"]). These are valid {{name}}
-*  references on that page even though they are not space-level schema variables. */
-var slugRouteParams = (slug) => {
-	const params = [];
-	for (const segment of slug.split("/")) if (segment.startsWith(":")) params.push(segment.slice(1).replace(/[*+?]+$/, ""));
-	return params;
-};
-/** Every route param bound by any page slug in the space (union), so {{name}} validation does not false-flag a
-*  page-scoped dynamic binding. */
-var routeParamNames = (schema) => {
-	const params = /* @__PURE__ */ new Set();
-	for (const page of getPageElements(schema)) {
-		const slug = typeof page.attributes.slug === "string" ? page.attributes.slug : "";
-		for (const param of slugRouteParams(slug)) params.add(param);
-	}
-	return [...params];
-};
-/** Indexed lookup that reflects the runtime reality: a flat id may be dangling (rsc placeholders, stale items). */
-var elementById = (schema, id) => schema.flat[id];
-/** All element ids belonging to a page subtree (excluding the page root). */
-var collectDescendants = (schema, rootId, acc) => {
-	const el = elementById(schema, rootId);
-	if (!el) return;
-	const childIds = el.definition.items ?? [];
-	for (const childId of childIds) if (elementById(schema, childId)) {
-		acc.push(childId);
-		collectDescendants(schema, childId, acc);
-	}
-};
-var descendantIds = (schema, pageRootId) => {
-	const acc = [];
-	collectDescendants(schema, pageRootId, acc);
-	return acc;
-};
-/** Resolve a ref to a concrete element within a page subtree (or the page root itself). Accepts either the
-*  semantic ref (idRef) or the raw element id, so schemas predating idRef keep working through their ids. */
-var resolveRef = (schema, page, ref) => {
-	if (elementRefOf(page) === ref || pageRefOf(page) === ref || page.id === ref) return page;
-	const index = spaceIndex(schema);
-	const el = index.elementByRef.get(ref);
-	return el && index.pageOf.get(el.id) === page.id ? el : void 0;
-};
-/** Ordered children of an element, honoring definition.items and skipping dangling ids. */
-var orderedChildren = (schema, el) => {
-	return (el.definition.items ?? []).map((id) => schema.flat[id]).filter((child) => Boolean(child));
-};
-/** The page ref an element belongs to. 'unknown' when it has no page ancestor. */
-var pageRefOfElement = (schema, el) => {
-	const pageId = spaceIndex(schema).pageOf.get(el.id);
-	const page = pageId ? schema.flat[pageId] : void 0;
-	return page ? pageRefOf(page) : "unknown";
-};
-/** Total number of descendant elements under a subtree (excluding the root). */
-var descendantCount = (schema, rootId) => descendantIds(schema, rootId).length;
-var emptySpaceMessage = "Space data not available";
-/** The code a space-dependent answer carries when the connection reaches no space, so both the agent and a host UI
-*  can tell "this connection cannot do that" from "the call failed". */
-var noSpaceError = "NO_SPACE_ATTACHED";
-var unauthorizedSpaceMessage = "This connection has no space attached (a guest or widgets-only grant, or a token that carries no space), so NOTHING in a space can be read or edited — every other space tool will fail the same way, do not retry them. Use plitzi_render instead: it builds a self-contained widget offline, with no space, backend or account (read plitzi://render/guide). To edit a real space, the user must reconnect the integration and grant access to one.";
-/** Raised when a space-dependent operation runs on a connection that resolves no spaceId. A type of its own so the
-*  host answers it as a STATE of the connection — a plain result the agent reads — instead of letting it surface as
-*  a failed call, which hosts render to the user as "cannot connect to this server". */
-var NoSpaceError = class extends Error {
-	constructor() {
-		super(unauthorizedSpaceMessage);
-		this.name = "NoSpaceError";
-	}
-};
-var generateObjectId = () => {
-	return `${Math.floor(Date.now() / 1e3).toString(16).padStart(8, "0")}${Array.from({ length: 16 }, () => Math.floor(Math.random() * 16).toString(16)).join("")}`;
-};
-//#endregion
-export { NoSpaceError, cloneSpace, descendantCount, descendantIds, elementById, elementRefOf, emptySpace, emptySpaceMessage, findElementByRef, findFolderByRef, findPageByRef, folderAncestorIds, generateObjectId, getPageElements, indexAddElement, indexAddPage, indexInvalidateDetails, indexReRefElement, indexReRefPage, indexRemoveElements, indexRemovePage, isPageElement, nameOf, noSpaceError, orderedChildren, pageFoldersOf, pageRefOf, pageRefOfElement, resolveRef, routeParamNames, slugRouteParams, slugify, sortFolders, spaceIndex, strOr, unauthorizedSpaceMessage };

package/dist/modules/mcp/helpers/uris.js

@@ -1,44 +0,0 @@
-//#region src/modules/mcp/helpers/uris.ts
-var guideUri = "plitzi://guide";
-var typesUri = "plitzi://types";
-var cssPropertiesUri = "plitzi://css-properties";
-var primerUri = (env) => `plitzi://primer/${env}`;
-var pagesUri = (env) => `plitzi://schema/${env}/pages`;
-var pageUri = (env, ref) => `plitzi://schema/${env}/pages/${ref}`;
-var elementUri = (env, ref) => `plitzi://schema/${env}/elements/${ref}`;
-var schemaVarsUri = (env) => `plitzi://schema-variables/${env}`;
-var settingsUri = (env) => `plitzi://settings/${env}`;
-var interactionsUri = (env) => `plitzi://interactions/${env}`;
-var dataSourcesUri = (env) => `plitzi://data-sources/${env}`;
-var foldersUri = (env) => `plitzi://folders/${env}`;
-var folderUri = (env, ref) => `plitzi://folders/${env}/${ref}`;
-var defsUri = (env) => `plitzi://definitions/${env}`;
-var defUri = (env, ref) => `plitzi://definitions/${env}/${ref}`;
-var globalsUri = (env) => `plitzi://global-styles/${env}`;
-var globalUri = (env, componentType) => `plitzi://global-styles/${env}/${componentType}`;
-var idsUri = (env) => `plitzi://id-styles/${env}`;
-var idUri = (env, targetId) => `plitzi://id-styles/${env}/${targetId}`;
-var styleVarsUri = (env) => `plitzi://style-variables/${env}`;
-var styleVarUri = (env, category) => `plitzi://style-variables/${env}/${category}`;
-var aliasedRoots = [
-	"definitions",
-	"global-styles",
-	"id-styles",
-	"style-variables",
-	"schema-variables",
-	"folders"
-];
-var itemTemplates = (env) => [
-	pageUri(env, "{ref}"),
-	elementUri(env, "{ref}"),
-	defUri(env, "{ref}"),
-	globalUri(env, "{componentType}"),
-	idUri(env, "{targetId}"),
-	styleVarUri(env, "{category}"),
-	folderUri(env, "{ref}")
-];
-/** The remainder of `uri` after `prefix`, or undefined when it does not start with it — so a resolver matches a
-*  family and extracts its ref in one step, without repeating the prefix string for both the startsWith and slice. */
-var afterPrefix = (uri, prefix) => uri.startsWith(prefix) ? uri.slice(prefix.length) : void 0;
-//#endregion
-export { afterPrefix, aliasedRoots, cssPropertiesUri, dataSourcesUri, defUri, defsUri, elementUri, folderUri, foldersUri, globalUri, globalsUri, guideUri, idUri, idsUri, interactionsUri, itemTemplates, pageUri, pagesUri, primerUri, schemaVarsUri, settingsUri, styleVarUri, styleVarsUri, typesUri };

package/dist/modules/mcp/previewClient.js

@@ -1,31 +0,0 @@
-//#region src/modules/mcp/previewClient.ts
-/** Default `PreviewClient`: POSTs the preview request to the SSR `/preview` endpoint over HTTP. Used when the
-*  MCP server is a separate process from the SSR renderer (the common case). A network/HTTP failure surfaces as
-*  an `ok:false` result rather than throwing, so the calling tool can degrade gracefully. */
-var createHttpPreviewClient = ({ url, secret, fetchImpl = fetch }) => ({ async render(body) {
-	let res;
-	try {
-		res = await fetchImpl(url, {
-			method: "POST",
-			headers: {
-				"content-type": "application/json",
-				...secret ? { "x-preview-secret": secret } : {}
-			},
-			body: JSON.stringify(body)
-		});
-	} catch (err) {
-		return {
-			ok: false,
-			error: "PREVIEW_UNREACHABLE",
-			message: `Preview endpoint unreachable: ${String(err)}`
-		};
-	}
-	if (!res.ok && res.status !== 422) return {
-		ok: false,
-		error: "PREVIEW_REQUEST_FAILED",
-		message: `Preview endpoint returned ${res.status}.`
-	};
-	return await res.json();
-} });
-//#endregion
-export { createHttpPreviewClient };

package/dist/modules/mcp/proxy/config.js

@@ -1,63 +0,0 @@
-import { requestOrigin } from "../../../core/requestParser.js";
-import { connectionId } from "./sign.js";
-import { DEFAULT_PROXY_TOOLS } from "./types.js";
-//#region src/modules/mcp/proxy/config.ts
-var PROXY_PATH = "/__proxy";
-var MAX_BYTES = 8388608;
-var TTL_SECONDS = 604800;
-/** What this deployment serves at its widget endpoint, or undefined when it serves none. A secret is what turns it
-*  on: without one the endpoint could not tell its own widgets' URLs from anyone else's, and an unsigned fetcher
-*  on a public origin is an open proxy. */
-var proxySettings = (config) => {
-	const proxy = config.mcpAi?.proxy;
-	if (!proxy?.secret || proxy.enabled === false) return;
-	return {
-		path: proxy.path ?? "/__proxy",
-		secret: proxy.secret,
-		maxBytes: proxy.maxBytes ?? MAX_BYTES,
-		ttl: proxy.ttl ?? TTL_SECONDS,
-		tools: proxy.tools ?? DEFAULT_PROXY_TOOLS,
-		baseUrl: proxy.baseUrl
-	};
-};
-/** The endpoint as a widget must address it: absolute, because the page runs on the host's origin and a relative
-*  URL there points at the host. Falls back to the origin this request came in on, which is the right one whenever
-*  the MCP server owns its sub-domain; a deployment reached under a different public name sets `proxy.baseUrl`. */
-var endpointOf = (settings, req) => {
-	const base = (settings.baseUrl ?? requestOrigin(req)).replace(/\/$/, "");
-	return base ? `${base}${settings.path}` : void 0;
-};
-/** The proxy a tool rewrites through. The grants it mints carry the fingerprint of THIS request's credential, so
-*  they belong to this connection. */
-var requestProxy = (config, req) => {
-	const settings = proxySettings(config);
-	const endpoint = settings && endpointOf(settings, req);
-	if (!settings || !endpoint) return;
-	return {
-		endpoint,
-		secret: settings.secret,
-		identity: connectionId(req.headers.authorization, settings.secret),
-		ttl: settings.ttl,
-		tools: settings.tools
-	};
-};
-/** The proxy the ENDPOINT itself mints with, while serving an API answer that carries URLs of its own. The request
-*  it is serving comes from a sandboxed iframe and presents no credential, so the connection is the one signed into
-*  the grant being served — the widget's own — rather than one read off a header. */
-var grantingProxy = (settings, req, identity) => {
-	const endpoint = endpointOf(settings, req);
-	return endpoint ? {
-		endpoint,
-		secret: settings.secret,
-		identity,
-		ttl: settings.ttl,
-		tools: settings.tools
-	} : void 0;
-};
-/** The proxy THIS tool may use, or undefined — the single place that decides it, so a tool cannot reach the
-*  endpoint by being wired to it later. A render authors a throwaway widget, so rewriting its URLs is invisible
-*  and lasts as long as the widget does; a tool that WRITES a space (plitzi_apply) would persist those URLs into
-*  content the user owns, which is why it is not on the list unless a deployment puts it there deliberately. */
-var proxyForTool = (proxy, tool) => proxy?.tools.includes(tool) ? proxy : void 0;
-//#endregion
-export { PROXY_PATH, grantingProxy, proxyForTool, proxySettings, requestProxy };

package/dist/modules/mcp/proxy/fetch.js

@@ -1,91 +0,0 @@
-import { isPublicHost } from "./guard.js";
-//#region src/modules/mcp/proxy/fetch.ts
-var TIMEOUT_MS = 1e4;
-var MAX_REDIRECTS = 4;
-var ALLOWED_TYPES = {
-	asset: [
-		"image/",
-		"video/",
-		"audio/",
-		"font/",
-		"application/font",
-		"application/octet-stream"
-	],
-	data: [
-		"application/json",
-		"application/ld+json",
-		"application/xml",
-		"text/plain",
-		"text/csv",
-		"text/xml"
-	]
-};
-var REQUEST_HEADERS = {
-	asset: {
-		"User-Agent": "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/125.0 Safari/537.36",
-		Accept: "image/avif,image/webp,image/apng,image/*,*/*;q=0.8",
-		"Accept-Language": "en-US,en;q=0.9"
-	},
-	data: {
-		"User-Agent": "PlitziWidget/1.0 (+https://plitzi.com)",
-		Accept: "application/json,text/plain;q=0.9,*/*;q=0.8"
-	}
-};
-var failure = (status, reason) => ({
-	ok: false,
-	status,
-	reason
-});
-var parseTarget = (target) => {
-	try {
-		const url = new URL(target);
-		return url.protocol === "http:" || url.protocol === "https:" ? url : void 0;
-	} catch {
-		return;
-	}
-};
-/** Fetch a remote resource on the widget's behalf. Redirects are followed by hand rather than by fetch, because
-*  each hop is a new host that has to pass the same guard — an allowed URL that redirects into the private network
-*  would otherwise walk straight through it. (It is also what makes the redirect-based image services work at
-*  all: the sandbox loses the redirect, this does not.) */
-var fetchResource = async (target, kind, maxBytes) => {
-	let url = parseTarget(target);
-	if (!url) return failure(400, "Only http(s) URLs can be fetched.");
-	const controller = new AbortController();
-	const timer = setTimeout(() => controller.abort(), TIMEOUT_MS);
-	try {
-		for (let redirects = 0; redirects <= MAX_REDIRECTS; redirects += 1) {
-			if (!await isPublicHost(url.hostname)) return failure(403, "That host is not reachable from here.");
-			const response = await fetch(url, {
-				headers: REQUEST_HEADERS[kind],
-				redirect: "manual",
-				signal: controller.signal
-			});
-			const location = response.headers.get("location");
-			if (response.status >= 300 && response.status < 400 && location) {
-				const next = parseTarget(new URL(location, url).toString());
-				if (!next) return failure(502, "It redirected somewhere that is not an http(s) URL.");
-				url = next;
-				continue;
-			}
-			if (!response.ok) return failure(502, `It could not be fetched (upstream ${response.status}).`);
-			const contentType = response.headers.get("content-type")?.split(";")[0]?.trim().toLowerCase() ?? "";
-			if (!ALLOWED_TYPES[kind].some((allowed) => contentType.startsWith(allowed))) return failure(415, `That URL answered with ${contentType || "no content type"}, which is not ${kind === "asset" ? "an image or media file" : "data"}.`);
-			const declared = Number(response.headers.get("content-length"));
-			if (Number.isFinite(declared) && declared > maxBytes) return failure(413, "That response is too large to load in a widget.");
-			return {
-				ok: true,
-				contentType,
-				contentLength: Number.isFinite(declared) && declared > 0 ? declared : void 0,
-				body: response.body
-			};
-		}
-		return failure(502, "It redirected too many times.");
-	} catch (error) {
-		return failure(504, error instanceof Error && error.name === "AbortError" ? "It timed out." : "unreachable");
-	} finally {
-		clearTimeout(timer);
-	}
-};
-//#endregion
-export { fetchResource };