@plitzi/sdk-server 0.32.25 → 0.33.1

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

@@ -1,67 +0,0 @@
-import { sign, verify } from "./sign.js";
-//#region src/modules/mcp/proxy/grant.ts
-/** The single query parameter a proxied URL carries: `<signature>.<kind>.<expiry>.<connection>.<target>`. One
-*  parameter rather than several so the URL holds no `&` — these end up inside HTML attributes and markdown
-*  links, where an unescaped ampersand is the kind of detail that silently truncates a URL. */
-var PARAM = "i";
-var CODE = {
-	asset: "a",
-	data: "d"
-};
-var KIND = {
-	a: "asset",
-	d: "data"
-};
-var isTemplated = (target) => target.includes("{{");
-var originOf = (target) => {
-	try {
-		return new URL(target).origin;
-	} catch {
-		return;
-	}
-};
-var encodeTarget = (target) => encodeURIComponent(target).replace(/%7B/g, "{").replace(/%7D/g, "}");
-var payloadOf = (kind, expiry, identity, target) => `${CODE[kind]}.${expiry.toString(36)}.${identity}.${target}`;
-/** Mint the URL a widget will load this target from: this server's endpoint, carrying the target, the kind it was
-*  granted for, when the grant stops working and which connection minted it — all covered by one signature. */
-var grantUrl = (target, proxy, kind = "asset") => {
-	const expiry = Math.floor(Date.now() / 1e3) + proxy.ttl;
-	const scope = (isTemplated(target) ? originOf(target) : target) ?? target;
-	const signature = sign(payloadOf(kind, expiry, proxy.identity, scope), proxy.secret);
-	const payload = `${CODE[kind]}.${expiry.toString(36)}.${proxy.identity}.${encodeTarget(target)}`;
-	return `${proxy.endpoint}?${PARAM}=${signature}.${payload}`;
-};
-/** What this endpoint was asked to fetch, or undefined when the parameter is missing, malformed, expired or not
-*  signed here — which is what keeps it from being an open proxy for anyone who finds it: it serves the URLs this
-*  server rewrote, for as long as it said, and nothing else.
-*
-*  Takes the parameter as the query parser hands it over — decoded exactly once, which is the form that was
-*  signed. Decoding it again would corrupt every target that legitimately carries a percent-escape (an API URL
-*  with a nested URL in its query) and reject it as unsigned. */
-var readGrant = (param, secret) => {
-	const parts = param?.split(".") ?? [];
-	if (parts.length < 5) return;
-	const [signature = "", code = "", expiry = "", identity = ""] = parts;
-	const kind = KIND[code];
-	const target = parts.slice(4).join(".");
-	const expiresAt = parseInt(expiry, 36);
-	if (!kind || !Number.isFinite(expiresAt) || expiresAt * 1e3 < Date.now()) return;
-	const payload = payloadOf(kind, expiresAt, identity, target);
-	if (verify(payload, signature, secret)) return {
-		kind,
-		target,
-		identity
-	};
-	const origin = originOf(target);
-	return origin && verify(payloadOf(kind, expiresAt, identity, origin), signature, secret) ? {
-		kind,
-		target,
-		identity
-	} : void 0;
-};
-/** Is this URL one the widget can already reach? Absolute http(s) URLs are the ones a sandbox CSP blocks;
-*  `data:`/`blob:` carry their own bytes, and a relative URL has no origin to reach in the first place. */
-var isRemote = (url) => /^https?:\/\//i.test(url);
-var isGranted = (url, proxy) => url.startsWith(`${proxy.endpoint}?`);
-//#endregion
-export { grantUrl, isGranted, isRemote, readGrant };

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

@@ -1,38 +0,0 @@
-import { lookup } from "node:dns/promises";
-import { isIP } from "node:net";
-//#region src/modules/mcp/proxy/guard.ts
-var isPrivateIpv4 = (address) => {
-	const parts = address.split(".").map(Number);
-	if (parts.length !== 4 || parts.some((part) => !Number.isInteger(part) || part < 0 || part > 255)) return true;
-	const [a = 0, b = 0] = parts;
-	return a === 0 || a === 10 || a === 127 || a === 100 && b >= 64 && b <= 127 || a === 169 && b === 254 || a === 172 && b >= 16 && b <= 31 || a === 192 && b === 0 || a === 192 && b === 168 || a === 198 && (b === 18 || b === 19) || a >= 224;
-};
-var isPrivateIpv6 = (address) => {
-	const normalized = address.toLowerCase().split("%")[0] ?? "";
-	if (normalized.startsWith("::ffff:") && normalized.includes(".")) return isPrivateIpv4(normalized.slice(7));
-	return normalized === "::" || normalized === "::1" || normalized.startsWith("fc") || normalized.startsWith("fd") || normalized.startsWith("fe8") || normalized.startsWith("fe9") || normalized.startsWith("fea") || normalized.startsWith("feb");
-};
-var isPrivateAddress = (address) => isIP(address) === 6 ? isPrivateIpv6(address) : isPrivateIpv4(address);
-var PRIVATE_SUFFIXES = [
-	".local",
-	".internal",
-	".localhost",
-	".home.arpa"
-];
-/** Does this hostname resolve somewhere on the public internet? The endpoint fetches URLs an agent authored, so
-*  without this it would be a way to read whatever the pod itself can reach — the cluster's services, the cloud
-*  metadata endpoint, a database on the node. Both the literal address and every address the name resolves to are
-*  checked; a name that does not resolve is refused rather than handed to fetch. */
-var isPublicHost = async (hostname) => {
-	const host = hostname.toLowerCase().replace(/^\[|\]$/g, "");
-	if (!host || host === "localhost" || PRIVATE_SUFFIXES.some((suffix) => host.endsWith(suffix))) return false;
-	if (isIP(host)) return !isPrivateAddress(host);
-	try {
-		const addresses = await lookup(host, { all: true });
-		return addresses.length > 0 && addresses.every((entry) => !isPrivateAddress(entry.address));
-	} catch {
-		return false;
-	}
-};
-//#endregion
-export { isPrivateAddress, isPublicHost };

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

@@ -1,99 +0,0 @@
-import { grantingProxy } from "./config.js";
-import { readGrant } from "./grant.js";
-import { fetchResource } from "./fetch.js";
-import { rewritablePayload, rewritePayload } from "./payload.js";
-//#region src/modules/mcp/proxy/handler.ts
-var CACHE_CONTROL = {
-	asset: "public, max-age=86400, immutable",
-	data: "no-store"
-};
-/** Read a response whole, or undefined once it is past the limit. Only a rewritable answer is read this way: it has
-*  to be complete before a URL inside it can be swapped, and an API answer is small — which is exactly why the
-*  streaming path below stays the rule for everything else. */
-var readAll = async (body, maxBytes) => {
-	const reader = body.getReader();
-	const chunks = [];
-	let written = 0;
-	for (;;) {
-		const { done, value } = await reader.read();
-		if (done) break;
-		written += value.byteLength;
-		if (written > maxBytes) {
-			await reader.cancel();
-			return;
-		}
-		chunks.push(Buffer.from(value));
-	}
-	return Buffer.concat(chunks);
-};
-var fail = (res, status, reason) => {
-	res.setStatus(status);
-	res.setHeader("Content-Type", "text/plain; charset=utf-8");
-	res.setHeader("Cache-Control", "no-store");
-	res.send(reason);
-};
-/** Serve one external resource on behalf of a widget: check the grant this server signed, fetch the target, and
-*  stream it back under this origin — the one the CSP declares. Read-only, credential-free and CORS-open, because
-*  it answers the host's sandboxed iframe: a browser that has no origin of its own and can present nothing. The
-*  grant is what stands in for a caller identity — it is unforgeable, it names one target (or one host, for a
-*  templated API URL), it names the kind, it expires, and it carries the connection that minted it. */
-var handleProxyRequest = async (req, res, settings) => {
-	res.setHeader("Access-Control-Allow-Origin", "*");
-	res.setHeader("Cross-Origin-Resource-Policy", "cross-origin");
-	if (req.method === "OPTIONS") {
-		res.setHeader("Access-Control-Allow-Methods", "GET, HEAD, OPTIONS");
-		res.setHeader("Access-Control-Allow-Headers", "*");
-		res.setStatus(204);
-		res.end();
-		return;
-	}
-	if (req.method !== "GET" && req.method !== "HEAD") {
-		fail(res, 405, "Only GET is served here.");
-		return;
-	}
-	const grant = readGrant(req.query["i"], settings.secret);
-	if (!grant) {
-		fail(res, 403, "This URL is missing a grant, or the one it carries was not issued here or has expired.");
-		return;
-	}
-	const result = await fetchResource(grant.target, grant.kind, settings.maxBytes);
-	if (!result.ok) {
-		fail(res, result.status, result.reason);
-		return;
-	}
-	res.setStatus(200);
-	res.setHeader("Content-Type", result.contentType);
-	res.setHeader("Cache-Control", CACHE_CONTROL[grant.kind]);
-	if (req.method === "HEAD" || !result.body) {
-		res.end();
-		return;
-	}
-	const payloadProxy = grant.kind === "data" && rewritablePayload(result.contentType) ? grantingProxy(settings, req, grant.identity) : void 0;
-	if (payloadProxy) {
-		const body = await readAll(result.body, settings.maxBytes);
-		if (!body) {
-			fail(res, 413, "That response is too large to load in a widget.");
-			return;
-		}
-		res.send(rewritePayload(body.toString("utf8"), payloadProxy));
-		return;
-	}
-	const reader = result.body.getReader();
-	let written = 0;
-	try {
-		for (;;) {
-			const { done, value } = await reader.read();
-			if (done) break;
-			written += value.byteLength;
-			if (written > settings.maxBytes) {
-				await reader.cancel();
-				break;
-			}
-			res.write(Buffer.from(value));
-		}
-	} finally {
-		res.end();
-	}
-};
-//#endregion
-export { handleProxyRequest };

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

@@ -1,29 +0,0 @@
-import { grantUrl, isGranted, isRemote } from "./grant.js";
-import { looksLikeAsset } from "./rewrite.js";
-//#region src/modules/mcp/proxy/payload.ts
-var JSON_TYPES = ["application/json", "application/ld+json"];
-var ASSET_FIELD = /(image|img|thumb|photo|picture|avatar|icon|logo|cover|banner|poster|artwork|media|src)/i;
-/** Is this what the endpoint fetched a body it can rewrite? Only JSON: it is what an apiContainer binds against,
-*  and re-serializing anything else would risk changing a document to fix a URL that may not even be loaded. */
-var rewritablePayload = (contentType) => JSON_TYPES.some((type) => contentType.startsWith(type));
-var rewriteNode = (node, field, proxy) => {
-	if (typeof node === "string") return isRemote(node) && !isGranted(node, proxy) && (looksLikeAsset(node) || ASSET_FIELD.test(field)) ? grantUrl(node, proxy) : node;
-	if (Array.isArray(node)) return node.map((item) => rewriteNode(item, field, proxy));
-	if (node !== null && typeof node === "object") {
-		const entries = Object.entries(node);
-		return Object.fromEntries(entries.map(([key, value]) => [key, rewriteNode(value, key, proxy)]));
-	}
-	return node;
-};
-/** Rewrite the asset URLs an API answer carries so the widget loads them through this endpoint too. Returns the
-*  body untouched when it is not the JSON it claimed to be — the widget asked for that response, and serving it
-*  as it came is better than failing the fetch over a rewrite. */
-var rewritePayload = (body, proxy) => {
-	try {
-		return JSON.stringify(rewriteNode(JSON.parse(body), "", proxy));
-	} catch {
-		return body;
-	}
-};
-//#endregion
-export { rewritablePayload, rewritePayload };

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

@@ -1,138 +0,0 @@
-import { grantUrl, isGranted, isRemote } from "./grant.js";
-//#region src/modules/mcp/proxy/rewrite.ts
-var URL_ATTRIBUTES = ["src", "poster"];
-var MARKUP_ATTRIBUTES = ["content", "html"];
-var FETCHING_TYPE = "apiContainer";
-var SET_STATE_ACTION = "setState";
-var NAVIGATION_ACTION = "navigate";
-var FETCHING_UTILITY = "webHook";
-var ASSET_EXTENSION = /\.(?:apng|avif|bmp|gif|ico|jpe?g|png|svg|webp|aac|flac|m4a|mp3|oga|ogg|opus|wav|mp4|m4v|mov|ogv|webm|otf|ttf|woff2?)$/i;
-var CSS_URL = /url\(\s*(["']?)(https?:\/\/[^"')\s]+)\1\s*\)/gi;
-var HTML_SRC = /(<[^>]+?\ssrc\s*=\s*)(["'])(https?:\/\/[^"']+)\2/gi;
-var MARKDOWN_IMAGE = /(!\[[^\]]*\]\(\s*)(https?:\/\/[^\s)]+)/gi;
-var unescapeHtml = (url) => url.replace(/&amp;/g, "&");
-var toProxy = (url, proxy) => isGranted(url, proxy) ? url : grantUrl(unescapeHtml(url), proxy);
-/** Does this URL name a file the widget loads, judged by its path alone? Used where nothing else says what a URL is
-*  for — an interaction param, a field of an API answer — so the extension is the evidence and its absence is a
-*  reason to leave the URL alone. */
-var looksLikeAsset = (url) => {
-	try {
-		return ASSET_EXTENSION.test(new URL(url).pathname);
-	} catch {
-		return false;
-	}
-};
-/** Rewrite every remote URL embedded in a string: `url(…)` in CSS, `src="…"` in markup, `![](…)` in markdown. */
-var rewriteText = (text, proxy) => text.replace(CSS_URL, (_match, quote, url) => `url(${quote}${toProxy(url, proxy)}${quote})`).replace(HTML_SRC, (_match, prefix, quote, url) => `${prefix}${quote}${toProxy(url, proxy)}${quote}`).replace(MARKDOWN_IMAGE, (_match, prefix, url) => `${prefix}${toProxy(url, proxy)}`);
-var rewriteStyleObject = (styleObject, proxy) => {
-	for (const [property, value] of Object.entries(styleObject)) if (typeof value === "string" && value.includes("url(")) styleObject[property] = rewriteText(value, proxy);
-};
-var rewriteStyleBlock = (block, proxy) => {
-	if (block.default) rewriteStyleObject(block.default, proxy);
-	for (const state of Object.values(block.states ?? {})) rewriteStyleObject(state, proxy);
-};
-/** Why a request was left as authored, or undefined when it can be granted. Each case is one this hop cannot
-*  reproduce faithfully, and getting it wrong silently would be worse than the request being blocked: a write sent
-*  through a GET, or an API answering 401 because its credential was dropped on the way. Reads both vocabularies —
-*  an apiContainer's attributes and a webHook's params name the same things differently. */
-var unproxyableFetch = (source) => {
-	const { method, headers, accessToken, authorizationToken } = source;
-	if (typeof method === "string" && method.toLowerCase() !== "get") return `it is a ${method.toUpperCase()} request`;
-	if (typeof accessToken === "string" && accessToken !== "") return "it sends its own credentials";
-	if (typeof authorizationToken === "string" && authorizationToken !== "") return "it sends its own credentials";
-	return headers && Object.keys(headers).length > 0 ? "it sends its own headers" : void 0;
-};
-var rewriteSetState = (params, proxy) => {
-	const { key, value } = params;
-	if (typeof key !== "string" || typeof value !== "string") return false;
-	if (URL_ATTRIBUTES.includes(key) && isRemote(value)) {
-		params.value = toProxy(value, proxy);
-		return true;
-	}
-	if (MARKUP_ATTRIBUTES.includes(key) && value.includes("http")) {
-		params.value = rewriteText(value, proxy);
-		return true;
-	}
-	return false;
-};
-var rewriteParams = (params, proxy) => {
-	for (const [name, value] of Object.entries(params)) {
-		if (typeof value !== "string") continue;
-		if (URL_ATTRIBUTES.includes(name) && isRemote(value)) params[name] = toProxy(value, proxy);
-		else if (MARKUP_ATTRIBUTES.includes(name) && value.includes("http")) params[name] = rewriteText(value, proxy);
-		else if (isRemote(value) && looksLikeAsset(value)) params[name] = toProxy(value, proxy);
-	}
-};
-var rewriteWebHook = (node, proxy, warnings) => {
-	const params = node.params;
-	const url = params.url;
-	if (typeof url !== "string" || !isRemote(url) || isGranted(url, proxy)) return;
-	const blocked = unproxyableFetch(params);
-	if (blocked) {
-		warnings.push(`The ${FETCHING_UTILITY} step "${node.title}" calls its endpoint directly because ${blocked}, so that request is subject to the network policy of the surface it renders in, and to the CORS headers of the API, and may not run. A plain GET with no credentials is fetched by the widget server instead, which always works.`);
-		return;
-	}
-	params.url = grantUrl(url, proxy, "data");
-};
-var rewriteInteractions = (interactions, proxy, warnings) => {
-	for (const node of Object.values(interactions ?? {})) {
-		if (node.type === "globalCallback" && node.action === NAVIGATION_ACTION) continue;
-		if (node.type === "utility" && node.action === FETCHING_UTILITY) {
-			rewriteWebHook(node, proxy, warnings);
-			continue;
-		}
-		const params = node.params;
-		if (node.action === SET_STATE_ACTION && rewriteSetState(params, proxy)) continue;
-		rewriteParams(params, proxy);
-	}
-};
-var rewriteBindings = (bindings, proxy) => {
-	for (const category of Object.values(bindings ?? {})) for (const binding of category) for (const transformer of binding.transformers ?? []) rewriteParams(transformer.params, proxy);
-};
-var rewriteSchema = (schema, proxy, warnings) => {
-	for (const element of Object.values(schema.flat)) {
-		rewriteInteractions(element.definition.interactions, proxy, warnings);
-		rewriteBindings(element.definition.bindings, proxy);
-		const attributes = element.attributes;
-		for (const name of URL_ATTRIBUTES) {
-			const value = attributes[name];
-			if (typeof value === "string" && isRemote(value) && !isGranted(value, proxy)) attributes[name] = grantUrl(value, proxy);
-		}
-		for (const name of MARKUP_ATTRIBUTES) {
-			const value = attributes[name];
-			if (typeof value === "string" && value.includes("http")) attributes[name] = rewriteText(value, proxy);
-		}
-		const query = attributes.query;
-		if (element.definition.type !== FETCHING_TYPE || typeof query !== "string" || !isRemote(query)) continue;
-		const blocked = unproxyableFetch(attributes);
-		if (blocked) {
-			warnings.push(`The ${FETCHING_TYPE} "${element.idRef ?? element.id}" calls its endpoint directly because ${blocked}, so that request is subject to the network policy of the surface it renders in, and to the CORS headers of the API, and may not run. A plain GET with no headers is fetched by the widget server instead, which always works.`);
-			continue;
-		}
-		if (!isGranted(query, proxy)) attributes.query = grantUrl(query, proxy, "data");
-	}
-};
-var rewriteStyle = (style, proxy) => {
-	for (const items of Object.values(style.platform)) for (const item of Object.values(items)) {
-		for (const selector of Object.values(item.attributes)) {
-			rewriteStyleBlock(selector, proxy);
-			for (const variant of Object.values(selector.variants ?? {})) rewriteStyleBlock(variant, proxy);
-		}
-		if (item.cache.includes("url(")) item.cache = rewriteText(item.cache, proxy);
-	}
-	if (style.cache.includes("url(")) style.cache = rewriteText(style.cache, proxy);
-};
-/** Point everything an authored widget loads from outside — images, media, fonts, the data an apiContainer fetches
-*  and the URLs its interactions swap in later — at this server's endpoint, in place. The AGENT never sees this: it
-*  authors the real URL and this runs
-*  afterwards, on the throwaway space a render builds (so nothing shared is mutated) and before the global style
-*  cache is compiled (so the concatenated CSS comes out already rewritten). Returns what could not be rewritten,
-*  which is the only part the model hears about. */
-var proxifyResources = (space, proxy) => {
-	const warnings = [];
-	rewriteSchema(space.schema, proxy, warnings);
-	rewriteStyle(space.style, proxy);
-	return warnings;
-};
-//#endregion
-export { looksLikeAsset, proxifyResources, rewriteText };

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

@@ -1,15 +0,0 @@
-import { createHmac, timingSafeEqual } from "node:crypto";
-//#region src/modules/mcp/proxy/sign.ts
-var SIGNATURE_LENGTH = 22;
-var sign = (payload, secret) => createHmac("sha256", secret).update(payload).digest("base64url").slice(0, SIGNATURE_LENGTH);
-var verify = (payload, signature, secret) => {
-	const expected = Buffer.from(sign(payload, secret));
-	const given = Buffer.from(signature);
-	return expected.length === given.length && timingSafeEqual(expected, given);
-};
-/** A short, stable fingerprint of the MCP credential a request carried — the connection a grant belongs to.
-*  Derived through the same secret, so it identifies without echoing any part of the token; a request with no
-*  credential (the public widgets surface) gets the shared anonymous identity. */
-var connectionId = (authorization, secret) => authorization ? sign(`id:${authorization}`, secret).slice(0, 10) : "anon";
-//#endregion
-export { connectionId, sign, verify };

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

@@ -1,9 +0,0 @@
-//#region src/modules/mcp/proxy/types.ts
-/** The tools a proxy may be handed to. `plitzi_render` alone by default, and that default is a guard, not a
-*  convenience: a render is a THROWAWAY widget, so rewriting its URLs changes nothing that outlives the call —
-*  while plitzi_apply writes to the user's real space, where a rewritten URL would be PERSISTED and the space
-*  would come to depend on this server's endpoint for content it owns. Nothing else should be added here without
-*  that being the intention. */
-var DEFAULT_PROXY_TOOLS = ["plitzi_render"];
-//#endregion
-export { DEFAULT_PROXY_TOOLS };

package/dist/modules/mcp/resources/canonical.js

@@ -1,30 +0,0 @@
-import { afterPrefix, aliasedRoots, itemTemplates, primerUri } from "../helpers/uris.js";
-//#region src/modules/mcp/resources/canonical.ts
-var canonicalUri = (env, uri) => {
-	const rest = afterPrefix(uri, `plitzi://schema/${env}/`);
-	if (rest === void 0) return uri;
-	for (const root of aliasedRoots) {
-		if (rest === root) return `plitzi://${root}/${env}`;
-		if (rest.startsWith(`${root}/`)) return `plitzi://${root}/${env}/${rest.slice(root.length + 1)}`;
-	}
-	return uri;
-};
-/** Teachable message for a URI that read as null. Distinguishes a well-formed URI whose ref does not resolve (the
-*  resource may be stale/deleted) from a URI whose shape matches no template at all (malformed — echo the valid
-*  templates so the agent stops hand-building URIs). See RFC 0004 I2. */
-var resourceErrorMessage = (env, uri) => {
-	const canonical = canonicalUri(env, uri);
-	if (itemTemplates(env).some((tpl) => canonical.startsWith(tpl.slice(0, tpl.lastIndexOf("/") + 1)))) return JSON.stringify({
-		error: "NOT_FOUND",
-		message: `No resource at '${uri}'. Its shape is valid but the ref does not resolve.`,
-		hint: "It may have been deleted or your URI is stale. Re-list the parent resource (pages/definitions) to refresh."
-	});
-	return JSON.stringify({
-		error: "MALFORMED_URI",
-		message: `'${uri}' matches no resource template.`,
-		hint: "Do not hand-build element URIs — take the ready-made uri from plitzi_search or a write response.",
-		validTemplates: [primerUri(env), ...itemTemplates(env)]
-	});
-};
-//#endregion
-export { canonicalUri, resourceErrorMessage };

package/dist/modules/mcp/resources/core.js

@@ -1,18 +0,0 @@
-import { cssProperties, cssShorthands } from "../catalogs/cssCatalog/index.js";
-import { buildTypeRegistry } from "../catalogs/registry.js";
-import "../helpers/uris.js";
-import { guideText } from "../helpers/guide.js";
-import { envelope } from "./envelope.js";
-//#region src/modules/mcp/resources/core.ts
-/** Space-independent singletons: the usage guide, the observed type registry and the CSS property catalog.
-*  Returns undefined when the URI is not one of these, so the router falls through to the next resolver. */
-var readCoreResource = (space, uri) => {
-	if (uri === "plitzi://guide") return envelope(guideText);
-	if (uri === "plitzi://types") return envelope(buildTypeRegistry(space.schema, space.catalog));
-	if (uri === "plitzi://css-properties") return envelope({
-		properties: cssProperties,
-		shorthands: cssShorthands
-	});
-};
-//#endregion
-export { readCoreResource };

package/dist/modules/mcp/resources/envelope.js

@@ -1,14 +0,0 @@
-import { computeVersion } from "../helpers/computeVersion.js";
-//#region src/modules/mcp/resources/envelope.ts
-/** Wrap any read projection with the version its optimistic-concurrency checks key on. */
-var envelope = (data) => ({
-	stateVersion: computeVersion(data),
-	data
-});
-var jsonContents = (uri, data) => ({ contents: [{
-	uri,
-	mimeType: "application/json",
-	text: JSON.stringify(data)
-}] });
-//#endregion
-export { envelope, jsonContents };

package/dist/modules/mcp/resources/primer.js

@@ -1,31 +0,0 @@
-import { cssProperties, cssShorthands } from "../catalogs/cssCatalog/index.js";
-import { buildDataSourceCatalog, buildInteractionCatalog } from "../catalogs/observed.js";
-import { buildTypeRegistry } from "../catalogs/registry.js";
-import { guideQuickstart } from "../helpers/guide.js";
-import { envelope } from "./envelope.js";
-import { definitionRefs, styleVariablesToAI } from "../tools/operations/style/translator.js";
-import { foldersToAI, pageSummariesToAI, schemaVariablesToAI, settingsToAI } from "../tools/operations/schema/translator.js";
-//#region src/modules/mcp/resources/primer.ts
-/** The cold-start bundle: everything the guide says to read before the first write, in one round-trip.
-*  Summaries only — never full page/element trees (those are opened on demand), so it stays cheap even on a
-*  large space. Carries the condensed `guideQuickstart` (not the full guideText, which the agent reads on demand at
-*  plitzi://guide) to keep the bundle small. Returns undefined when the URI is not the primer. */
-var readPrimerResource = (space, env, uri) => {
-	if (uri !== `plitzi://primer/${env}`) return;
-	return envelope({
-		guide: guideQuickstart,
-		types: buildTypeRegistry(space.schema, space.catalog),
-		cssProperties,
-		cssShorthands,
-		pages: pageSummariesToAI(space.schema),
-		folders: foldersToAI(space.schema),
-		definitions: definitionRefs(space.style),
-		styleVariables: styleVariablesToAI(space.style),
-		schemaVariables: schemaVariablesToAI(space.schema, false),
-		settings: settingsToAI(space.schema),
-		interactions: buildInteractionCatalog(space.schema),
-		dataSources: buildDataSourceCatalog(space.schema)
-	});
-};
-//#endregion
-export { readPrimerResource };