@plitzi/sdk-server 0.32.25 → 0.33.1

package/dist/modules/mcp/apps/render/view/index.tsx

@@ -1,314 +0,0 @@
-/* eslint-disable react-refresh/only-export-components -- one bundled entry: components cannot move out. */
-import { useApp, useHostStyles } from '@modelcontextprotocol/ext-apps/react';
-import PlitziSdk from '@plitzi/plitzi-sdk';
-import { Component, useEffect, useRef, useState } from 'react';
-import { createRoot } from 'react-dom/client';
-
-import { readHeldBatch, writeHeldBatch } from './heldBatch';
-import { mergeProgress, streamProgress } from './streamProgress';
-
-import type { StreamProgress } from './streamProgress';
-import type { App, McpUiHostContext } from '@modelcontextprotocol/ext-apps';
-import type { CallToolResult } from '@modelcontextprotocol/sdk/types.js';
-import type { OfflineDataRaw } from '@plitzi/sdk-shared';
-import type { ReactNode } from 'react';
-
-/** The view for plitzi_render: the entry the server bundles (React, the MCP Apps runtime and the Plitzi SDK
- *  included) and inlines in the shared ui:// page shell — which is what lets it run in a sandbox that can fetch
- *  nothing. It mounts on `#app`, the shell's root. */
-
-const panelStyle = { padding: 16, font: '13px/1.5 system-ui, sans-serif', color: '#b91c1c' } as const;
-
-// Every failure ends up here: an iframe left on its placeholder would hide the reason in the sandbox's console.
-const ErrorPanel = ({ title, details }: { title: string; details: string }) => (
-  <div style={panelStyle}>
-    <strong>{title}</strong>
-    <pre style={{ margin: '8px 0 0', whiteSpace: 'pre-wrap', color: '#7f1d1d', fontSize: 12 }}>{details}</pre>
-  </div>
-);
-
-/** The wait a user reads as "this is slow" is the model TYPING the batch: the tool only runs once the last brace
- *  is written, and until then the page shows its static "Rendering…". The host streams the arguments as they
- *  arrive, so this stands in for the widget meanwhile — bars that grow with the elements already authored, and the
- *  widget's own title as soon as the batch names it. It never shows a half-built widget: the real one replaces it
- *  wholesale when the result lands. A host that streams nothing paints none of this and keeps the static text. */
-const SKELETON_BAR_WIDTHS = ['92%', '78%', '85%', '64%', '88%', '72%'];
-
-// The deployment's own switch (mcpAi.renderStreaming), handed over by the page. Absent means on: a page built
-// before the setting existed carries none, and a host that streams no arguments paints the same either way.
-const streamingEnabled =
-  (globalThis as { __PLITZI_VIEW__?: { streaming?: boolean } }).__PLITZI_VIEW__?.streaming !== false;
-
-const skeletonBarStyle = {
-  height: 10,
-  borderRadius: 5,
-  backgroundColor: 'var(--color-background-tertiary, light-dark(#e2e8f0, #333a48))',
-  animation: 'plitzi-skeleton-pulse 1.4s ease-in-out infinite'
-} as const;
-
-// One bar per few elements, so the block visibly grows while the model writes, and a ceiling so a 200-element
-// widget does not fill the panel with grey. Total by construction: this paints a wait, and a placeholder that
-// renders nothing at all (an empty slice off a NaN) would read as the view having died.
-const barCount = (elements: number): number => {
-  const bars = Math.ceil(elements / 3);
-
-  return Number.isFinite(bars) ? Math.min(Math.max(bars, 2), 6) : 2;
-};
-
-const StreamSkeleton = ({ progress }: { progress: StreamProgress }) => {
-  const caption = progress.patch ? 'Updating the widget…' : 'Building the widget…';
-
-  return (
-    <div
-      role="status"
-      aria-live="polite"
-      style={{
-        display: 'flex',
-        flexDirection: 'column',
-        gap: 10,
-        padding: 16,
-        font: '13px/1.5 var(--font-sans, system-ui, sans-serif)'
-      }}
-    >
-      <style>{'@keyframes plitzi-skeleton-pulse { 0%, 100% { opacity: 0.5 } 50% { opacity: 1 } }'}</style>
-      {progress.title && <strong style={{ fontSize: 15 }}>{progress.title}</strong>}
-      {SKELETON_BAR_WIDTHS.slice(0, barCount(progress.elements)).map(width => (
-        <div key={width} style={{ ...skeletonBarStyle, width }} />
-      ))}
-      <span style={{ color: 'var(--color-text-tertiary, light-dark(#64748b, #9aa4b2))' }}>
-        {caption}
-        {progress.elements > 0 && ` ${progress.elements} elements so far`}
-      </span>
-    </div>
-  );
-};
-
-class RenderBoundary extends Component<{ children: ReactNode }, { error?: Error }> {
-  state: { error?: Error } = {};
-
-  static getDerivedStateFromError(error: Error) {
-    return { error };
-  }
-
-  render() {
-    if (this.state.error) {
-      return <ErrorPanel title="Widget failed to render" details={this.state.error.message} />;
-    }
-
-    return this.props.children;
-  }
-}
-
-/** The batch the widget on screen was built from. It lives on the HOST side — this ref plus localStorage — because
- *  the server keeps nothing between calls, which is what lets any replica (or an edge deployment) answer any
- *  request. A patch is merged into it and sent back through `callServerTool`, so the full batch never enters the
- *  model's context. The ref alone would not do: the host gives each tool call its own view, so a patch usually
- *  starts from an empty instance and reads the batch back from storage by renderId (see heldBatch.ts). */
-type Held = { renderId?: string; operations: unknown[] };
-
-const summarise = (result: CallToolResult): string => {
-  const text = result.content.find(entry => entry.type === 'text');
-
-  return text?.text ?? 'no summary';
-};
-
-const RenderApp = () => {
-  const [result, setResult] = useState<CallToolResult | null>(null);
-  const [progress, setProgress] = useState<StreamProgress | undefined>(undefined);
-  const [cancelled, setCancelled] = useState<string | undefined>(undefined);
-  const [context, setContext] = useState<McpUiHostContext | undefined>(undefined);
-  const held = useRef<Held>({ operations: [] });
-  const appRef = useRef<App | null>(null);
-  // The handlers are registered once, so they close over the FIRST render's state: a ref is the only way they can
-  // tell whether a widget is already on screen.
-  const painted = useRef(false);
-
-  const showWidget = (toolResult: CallToolResult): void => {
-    painted.current = true;
-    setResult(toolResult);
-  };
-
-  /** Streamed arguments are the one input here nobody validated: healed JSON, from a host, about a call that does
-   *  not exist yet. So it is fenced off — it feeds the placeholder and NOTHING else (never the held batch, never
-   *  storage, never the server), it cannot run once a widget is up, and it cannot throw: a notification handler
-   *  that raises would break the App's dispatch, and this one exists only to decorate a wait. */
-  const trackInput = (args: unknown): void => {
-    if (painted.current) {
-      return;
-    }
-
-    try {
-      const next = streamProgress(args);
-      setProgress(previous => mergeProgress(previous, next));
-    } catch {
-      // A placeholder that stops growing is a non-event; the widget is still on its way.
-    }
-  };
-
-  // A patch carries only what changed. Merging it onto the held batch and re-calling the tool is what keeps the
-  // server stateless: it re-renders the WHOLE widget (so refs, integrity and the audit are all checked as usual)
-  // from a payload that travelled host↔server, and the model hears the outcome through updateModelContext.
-  const applyPatch = async (renderId: string, delta: unknown[]): Promise<void> => {
-    const app = appRef.current;
-    if (!app) {
-      return;
-    }
-
-    const base = held.current.renderId === renderId ? held.current.operations : (readHeldBatch(renderId) ?? []);
-    if (base.length === 0) {
-      await app.updateModelContext({
-        content: [
-          {
-            type: 'text',
-            text: `The widget ${renderId} could not be recovered, so nothing was patched. Call plitzi_render again with the complete batch and without \`patch\`.`
-          }
-        ]
-      });
-
-      return;
-    }
-
-    const merged = [...base, ...delta];
-    // The round trip can fail on its own: a host that forwards no tool calls, a connection dropped mid-patch, a
-    // view torn down while the answer is in flight. Unreported it would surface as an unhandled rejection inside
-    // the sandbox and the model would wait forever for a widget that is never coming.
-    try {
-      const rendered = await app.callServerTool({
-        name: 'plitzi_render',
-        arguments: { operations: merged, renderId }
-      });
-      const offlineData = rendered.structuredContent?.offlineData;
-      if (offlineData) {
-        const applied = (rendered.structuredContent?.operations as unknown[] | undefined) ?? merged;
-        held.current = { renderId, operations: applied };
-        writeHeldBatch(renderId, applied);
-        showWidget(rendered);
-      }
-
-      await app.updateModelContext({
-        content: [
-          {
-            type: 'text',
-            text: offlineData
-              ? `Widget updated: ${summarise(rendered)}`
-              : `The patch did not apply, the widget is unchanged: ${summarise(rendered)}`
-          }
-        ]
-      });
-    } catch (reason) {
-      await app
-        .updateModelContext({
-          content: [
-            {
-              type: 'text',
-              text: `The patch could not be delivered (${reason instanceof Error ? reason.message : String(reason)}), so the widget is unchanged. Re-send the full batch without \`patch\` if it needs to change.`
-            }
-          ]
-        })
-        .catch(() => undefined);
-    }
-  };
-
-  // useApp creates the App, runs onAppCreated so every handler is in place BEFORE the handshake, and connects.
-  const { app, error } = useApp({
-    appInfo: { name: 'Plitzi Widget', version: '1.0.0' },
-    capabilities: {},
-    onAppCreated: instance => {
-      appRef.current = instance;
-      // Streaming arguments (sent zero or more times while the model writes) and then the complete ones, which the
-      // host MUST send before the result: the last frame the placeholder gets covers the server render itself.
-      // The `on*` setters are the deprecated half of the API, kept because every other handler here uses them —
-      // mixing addEventListener for one of them would hide the lifecycle this component is built around.
-      if (streamingEnabled) {
-        instance.ontoolinputpartial = params => trackInput(params.arguments);
-        instance.ontoolinput = params => trackInput(params.arguments);
-      }
-
-      instance.ontoolresult = toolResult => {
-        const renderId = toolResult.structuredContent?.renderId as string | undefined;
-        if (toolResult.structuredContent?.patch === true && renderId) {
-          void applyPatch(renderId, (toolResult.structuredContent.operations as unknown[] | undefined) ?? []);
-
-          return;
-        }
-
-        // A result carrying no widget is a failed render or a refused patch. The model already reads its reasons
-        // as text, so it must not blank a widget that is on screen — nor drop the batch that widget was built
-        // from, which is the only copy of it anywhere. With nothing on screen yet, the error IS the view.
-        if (!toolResult.structuredContent?.offlineData && held.current.operations.length > 0) {
-          return;
-        }
-
-        const operations = (toolResult.structuredContent?.operations as unknown[] | undefined) ?? [];
-        held.current = { renderId, operations };
-        if (renderId && operations.length > 0) {
-          writeHeldBatch(renderId, operations);
-        }
-
-        showWidget(toolResult);
-      };
-      instance.ontoolcancelled = params => setCancelled(params.reason ?? 'The host cancelled the render.');
-      instance.onhostcontextchanged = params => setContext(previous => ({ ...previous, ...params }));
-      instance.onteardown = () => ({});
-    }
-  });
-
-  // The context the host sent in its initialize result predates any change notification.
-  useEffect(() => {
-    if (app) {
-      setContext(app.getHostContext());
-    }
-  }, [app]);
-
-  useHostStyles(app, context);
-
-  const failure = error?.message ?? cancelled;
-  if (failure) {
-    return <ErrorPanel title="Could not render the widget" details={failure} />;
-  }
-
-  // Waiting for the result. Once the host has streamed any of the arguments the skeleton stands in for the widget
-  // being written; before that (and on a host that streams nothing) the page's own CSS placeholder covers it.
-  if (!result) {
-    if (progress) {
-      return <StreamSkeleton progress={progress} />;
-    }
-
-    return null;
-  }
-
-  // The payload rides in structuredContent, which the protocol types as unknown-valued; plitzi_render is the one
-  // guaranteeing the shape, and the SDK validates it again when it renders.
-  const offlineData = result.structuredContent?.offlineData as OfflineDataRaw | undefined;
-  if (!offlineData) {
-    // A failed render answers with its (already compact) reasons as the tool's JSON text summary.
-    const text = result.content.find(entry => entry.type === 'text');
-
-    return <ErrorPanel title="Render failed" details={text?.text ?? 'The tool returned no widget data.'} />;
-  }
-
-  const insets = context?.safeAreaInsets;
-  // The icon fonts, ~330 KB of base64 woff2, are not in the page: they arrive with the widgets that draw an icon,
-  // so every other widget's iframe has that much less to load before it paints (see ../styles.ts).
-  const iconCss = result.structuredContent?.iconCss as string | undefined;
-
-  return (
-    <div
-      style={{
-        padding: `${insets?.top ?? 0}px ${insets?.right ?? 0}px ${insets?.bottom ?? 0}px ${insets?.left ?? 0}px`
-      }}
-    >
-      {iconCss && <style>{iconCss}</style>}
-      <RenderBoundary>
-        <PlitziSdk offlineData={offlineData} offlineMode environment="main" renderMode="raw" branding={false} />
-      </RenderBoundary>
-    </div>
-  );
-};
-
-const root = document.getElementById('app');
-if (root) {
-  // The SDK styles its tree from this container class down.
-  root.className = 'plitzi-root-container';
-  createRoot(root).render(<RenderApp />);
-}

package/dist/modules/mcp/apps/render/view/streamProgress.ts

@@ -1,137 +0,0 @@
-/** What the host has streamed of the tool call so far, reduced to the little a placeholder can honestly show.
- *
- *  The wait a user sees is almost entirely the model TYPING this batch — the server render takes milliseconds —
- *  so the only way to look alive is to read the arguments while they are still arriving. The host sends them as
- *  "healed" JSON (it closes the braces the model has not written yet), which means every field may be missing and
- *  the last operation is usually half-written: nothing here may assume a shape, and a fragment it cannot read
- *  simply contributes nothing.
- *
- *  Two properties this module owes the view, because a placeholder that misbehaves is worse than none:
- *  - it is TOTAL — no input throws, and every number it returns is a finite count;
- *  - it only ever moves FORWARD (see mergeProgress) — healing is best-effort and the spec warns that fields may
- *    change between notifications, so a frame that recovers less than the one before it must not shrink the
- *    placeholder, which the eye reads as flicker. */
-export type StreamProgress = { elements: number; title?: string; patch: boolean };
-
-const isRecord = (value: unknown): value is Record<string, unknown> =>
-  typeof value === 'object' && value !== null && !Array.isArray(value);
-
-const asArray = (value: unknown): unknown[] => (Array.isArray(value) ? value : []);
-
-// The walk is over a structure this code did not build, so it is bounded rather than trusted: a pathological
-// nesting would otherwise turn a placeholder into a stack overflow, which kills the view for good — including
-// the widget that was on its way. Far beyond anything a real widget nests.
-const MAX_DEPTH = 64;
-
-// A title is a label in a small panel: whitespace collapsed so a multi-line heading cannot push the bars off
-// screen, and cut where it stops being a label.
-const MAX_TITLE = 80;
-
-// A repeat renders its template once per row, so the rows are what the user will actually count on screen. An
-// items list that has not started streaming yet still stands for at least the one template being written.
-const rowsOf = (items: unknown): number => Math.max(asArray(items).length, 1);
-
-const countElements = (node: unknown, depth = 0): number => {
-  if (!isRecord(node) || depth > MAX_DEPTH) {
-    return 0;
-  }
-
-  const repeat = isRecord(node.repeat) ? node.repeat : undefined;
-  const nested = repeat ? countElements(repeat.template, depth + 1) * rowsOf(repeat.items) : 0;
-
-  return asArray(node.children).reduce<number>((total, child) => total + countElements(child, depth + 1), 1 + nested);
-};
-
-// A heading's content arrives one fragment at a time, so this runs against half-written text: `{{` rules out a
-// repeat template's placeholder (a literal "{{item.name}}" on screen reads as a bug, not as progress), and an
-// empty string is what a heading looks like before its content exists at all.
-const titleOf = (content: unknown): string | undefined => {
-  if (typeof content !== 'string' || content.includes('{{')) {
-    return undefined;
-  }
-
-  const text = content.replace(/\s+/gu, ' ').trim();
-  if (text === '') {
-    return undefined;
-  }
-
-  return text.length > MAX_TITLE ? `${text.slice(0, MAX_TITLE)}…` : text;
-};
-
-// The first heading the batch declares is the widget's own title far more often than not, so showing it turns the
-// placeholder from "something is happening" into "your pricing table is coming".
-const findTitle = (node: unknown, depth = 0): string | undefined => {
-  if (!isRecord(node) || depth > MAX_DEPTH) {
-    return undefined;
-  }
-
-  const props = isRecord(node.props) ? node.props : undefined;
-  if (node.type === 'heading') {
-    const title = titleOf(props?.content);
-    if (title !== undefined) {
-      return title;
-    }
-  }
-
-  for (const child of asArray(node.children)) {
-    const found = findTitle(child, depth + 1);
-    if (found !== undefined) {
-      return found;
-    }
-  }
-
-  return undefined;
-};
-
-// An op either builds a tree (upsertElement) or repeats one (repeatElement); anything else — a definition, a
-// binding, the truncated tail — adds no elements to count.
-const treeOf = (op: Record<string, unknown>): unknown => {
-  if (isRecord(op.element)) {
-    return op.element;
-  }
-
-  return isRecord(op.template) ? op.template : undefined;
-};
-
-export const streamProgress = (args: unknown): StreamProgress => {
-  const record = isRecord(args) ? args : {};
-  let elements = 0;
-  let title: string | undefined;
-
-  for (const op of asArray(record.operations)) {
-    if (!isRecord(op)) {
-      continue;
-    }
-
-    const tree = treeOf(op);
-    if (tree === undefined) {
-      continue;
-    }
-
-    elements += countElements(tree) * (isRecord(op.template) ? rowsOf(op.items) : 1);
-    title ??= findTitle(tree);
-  }
-
-  return { elements: Number.isFinite(elements) ? elements : 0, title, patch: record.patch === true };
-};
-
-/** Fold a freshly read frame into what the placeholder already shows. Monotonic on purpose — the count never goes
- *  down and a title, once read, is never taken away — because the healed JSON of frame N+1 can legitimately
- *  recover LESS than frame N, and a placeholder that shrinks and grows is the flicker this whole thing exists to
- *  avoid. Returns the previous object unchanged when nothing moved, so an unchanged frame costs no re-render. */
-export const mergeProgress = (previous: StreamProgress | undefined, next: StreamProgress): StreamProgress => {
-  if (!previous) {
-    return next;
-  }
-
-  const merged: StreamProgress = {
-    elements: Math.max(previous.elements, next.elements),
-    title: next.title ?? previous.title,
-    patch: previous.patch || next.patch
-  };
-  if (merged.elements === previous.elements && merged.title === previous.title && merged.patch === previous.patch) {
-    return previous;
-  }
-
-  return merged;
-};

package/dist/modules/mcp/apps/shared/assets.js

@@ -1,10 +0,0 @@
-import "node:path";
-//#region src/modules/mcp/apps/shared/assets.ts
-/** The one folder of an app that ships to dist as SOURCE: its browser entry (`view/index.tsx`) and every module
-*  that entry bundles. The server builds it with esbuild at request time, so none of it is in the module graph the
-*  library build compiles — a view-side module that does not travel verbatim is simply missing at runtime, which
-*  the package only finds out when a host asks for the page. Everything else in an app (its definition) compiles
-*  like any other module. */
-var VIEW_DIR = "view";
-//#endregion
-export { VIEW_DIR };

package/dist/modules/mcp/apps/shared/bundle.js

@@ -1,23 +0,0 @@
-import { require } from "./resolve.js";
-import { zodEnglishOnly } from "./zodEnglishOnly.js";
-import { build } from "esbuild";
-//#region src/modules/mcp/apps/shared/bundle.ts
-var options = (entry) => ({
-	entryPoints: [entry],
-	bundle: true,
-	write: false,
-	format: "iife",
-	platform: "browser",
-	target: "es2022",
-	jsx: "automatic",
-	minify: true,
-	alias: { "@plitzi/plitzi-sdk": require.resolve("@plitzi/plitzi-sdk") },
-	define: { "process.env.NODE_ENV": "\"production\"" },
-	plugins: [zodEnglishOnly],
-	logLevel: "silent"
-});
-var bundle = async (entry) => {
-	return (await build(options(entry))).outputFiles[0].text;
-};
-//#endregion
-export { bundle };

package/dist/modules/mcp/apps/shared/page.js

@@ -1,34 +0,0 @@
-import { bundle } from "./bundle.js";
-import path from "node:path";
-import { fileURLToPath } from "node:url";
-import { readFileSync } from "node:fs";
-import ejs from "ejs";
-//#region src/modules/mcp/apps/shared/page.ts
-var SHELL = path.resolve(path.dirname(fileURLToPath(import.meta.url)), "shell.ejs");
-var template = () => ejs.compile(readFileSync(SHELL, "utf-8"), { filename: SHELL });
-var scripts = /* @__PURE__ */ new Map();
-var pages = /* @__PURE__ */ new Map();
-var script = (entry) => {
-	let built = scripts.get(entry);
-	if (!built) {
-		built = bundle(entry);
-		scripts.set(entry, built);
-	}
-	return built;
-};
-var page = (app, settings) => {
-	const key = `${app.uri}|${JSON.stringify(settings)}`;
-	let html = pages.get(key);
-	if (!html) {
-		html = script(app.entry).then((code) => template()({
-			title: app.title,
-			app: code,
-			css: (app.styles?.() ?? []).join("\n"),
-			settings: JSON.stringify(settings)
-		}));
-		pages.set(key, html);
-	}
-	return html;
-};
-//#endregion
-export { page };

package/dist/modules/mcp/apps/shared/registerApp.js

@@ -1,43 +0,0 @@
-import { page } from "./page.js";
-import { RESOURCE_MIME_TYPE, registerAppResource } from "@modelcontextprotocol/ext-apps/server";
-//#region src/modules/mcp/apps/shared/registerApp.ts
-var WILDCARDS = [
-	"*",
-	"https:",
-	"https://*"
-];
-var defaultCsp = (proxyOrigin) => proxyOrigin ? {
-	resourceDomains: [proxyOrigin],
-	connectDomains: [proxyOrigin]
-} : {
-	resourceDomains: [
-		...WILDCARDS,
-		"data:",
-		"blob:"
-	],
-	connectDomains: [...WILDCARDS]
-};
-var originOf = (endpoint) => {
-	if (!endpoint) return;
-	try {
-		return new URL(endpoint).origin;
-	} catch {
-		return;
-	}
-};
-/** Serves the app as a self-contained page: no import map, no asset mounts, no cross-origin fetches, so the
-*  strictest host sandbox runs it and no deployment has to serve anything extra. */
-var registerApp = (server, app, settings) => {
-	const meta = { ui: { csp: app.csp ?? defaultCsp(originOf(settings.proxyEndpoint)) } };
-	registerAppResource(server, app.name, app.uri, {
-		description: app.description,
-		_meta: meta
-	}, async () => ({ contents: [{
-		uri: app.uri,
-		mimeType: RESOURCE_MIME_TYPE,
-		text: await page(app, settings),
-		_meta: meta
-	}] }));
-};
-//#endregion
-export { registerApp };

package/dist/modules/mcp/apps/shared/resolve.js

@@ -1,5 +0,0 @@
-import { createRequire } from "node:module";
-//#region src/modules/mcp/apps/shared/resolve.ts
-var require = createRequire(import.meta.url);
-//#endregion
-export { require };

package/dist/modules/mcp/apps/shared/shell.ejs

@@ -1,59 +0,0 @@
-<%#
-  The page shell every MCP App shares. The host renders it in a sandboxed iframe on ITS OWN origin: the app and
-  its styles are inlined, so the page fetches NOTHING and runs under a deny-by-default sandbox CSP.
--%>
-<!doctype html>
-<html lang="en">
-  <head>
-    <meta charset="utf-8" />
-    <meta name="viewport" content="width=device-width, initial-scale=1" />
-    <title><%= title %></title>
-
-    <style>
-      /*
-        The page inherits the HOST's theme, which may be dark: nothing here paints a surface, so an app that sets no
-        colours would otherwise draw the browser's black default text over the host's own background — unreadable in
-        a dark chat. `light-dark()` picks the right side of every pair; `color-scheme` is what tells it which side,
-        and it follows the OS until useHostStyles replaces it with the theme the host actually reported (that hook
-        also fills the --color-* variables in, so the var() fallbacks below only apply on a host that sends none).
-      */
-      html {
-        color-scheme: light dark;
-      }
-
-      html,
-      body {
-        margin: 0;
-      }
-
-      body {
-        background-color: transparent;
-        color: var(--color-text-primary, light-dark(#0f172a, #e8eaed));
-        font-family: var(--font-sans, system-ui, sans-serif);
-      }
-      /* The app renders nothing until the host pushes the tool result in. */
-      #app:empty::after {
-        content: 'Rendering…';
-        display: block;
-        padding: 16px;
-        font-size: 14px;
-        color: var(--color-text-tertiary, light-dark(#64748b, #9aa4b2));
-      }
-    </style>
-    <style>
-<%- css %>
-    </style>
-  </head>
-  <body>
-    <div id="app"></div>
-
-    <%# Deployment switches, before the app so the view reads them as it mounts. They ride in the page, not the
-        bundle, so a server serving both settings still builds the browser bundle once. -%>
-    <script id="plitzi-view-settings">
-      window.__PLITZI_VIEW__ = <%- settings %>;
-    </script>
-    <script>
-<%- app %>
-    </script>
-  </body>
-</html>

package/dist/modules/mcp/apps/shared/zodEnglishOnly.js

@@ -1,23 +0,0 @@
-//#region src/modules/mcp/apps/shared/zodEnglishOnly.ts
-var NAMESPACE = "zod-locales-stub";
-var ZOD_PACKAGE = /node_modules[/\\]zod[/\\]/u;
-/** Drops zod's ~40 translations (194 KB): they are re-exported as a namespace, which no bundler can tree-shake.
-*  English survives because zod imports `locales/en.js` directly, not through this index. */
-var zodEnglishOnly = {
-	name: "zod-english-only",
-	setup(builder) {
-		builder.onResolve({ filter: /locales[/\\]index\.js$/ }, (args) => ZOD_PACKAGE.test(args.importer) ? {
-			path: args.path,
-			namespace: NAMESPACE
-		} : void 0);
-		builder.onLoad({
-			filter: /.*/,
-			namespace: NAMESPACE
-		}, () => ({
-			contents: "export {};",
-			loader: "js"
-		}));
-	}
-};
-//#endregion
-export { zodEnglishOnly };