semiotic 3.7.4 → 3.8.0

package/ai/dist/mcp-server.js

@@ -3206,11 +3206,11 @@ var require_utils = __commonJS({
       output.address = address.join("");
       return output;
     }
-    function normalizeIPv6(host) {
-      if (findToken(host, ":") < 2) {
-        return { host, isIPV6: false };
+    function normalizeIPv6(host2) {
+      if (findToken(host2, ":") < 2) {
+        return { host: host2, isIPV6: false };
       }
-      const ipv63 = getIPV6(host);
+      const ipv63 = getIPV6(host2);
       if (!ipv63.error) {
         let newHost = ipv63.address;
         let escapedHost = ipv63.address;
@@ -3220,7 +3220,7 @@ var require_utils = __commonJS({
         }
         return { host: newHost, isIPV6: true, escapedHost };
       } else {
-        return { host, isIPV6: false };
+        return { host: host2, isIPV6: false };
       }
     }
     function findToken(str, token) {
@@ -3308,10 +3308,10 @@ var require_utils = __commonJS({
     var HOST_DELIMS = { "@": "%40", "/": "%2F", "?": "%3F", "#": "%23", ":": "%3A" };
     var HOST_DELIM_RE = /[@/?#:]/g;
     var HOST_DELIM_NO_COLON_RE = /[@/?#]/g;
-    function reescapeHostDelimiters(host, isIP) {
+    function reescapeHostDelimiters(host2, isIP) {
       const re = isIP ? HOST_DELIM_NO_COLON_RE : HOST_DELIM_RE;
       re.lastIndex = 0;
-      return host.replace(re, (ch) => HOST_DELIMS[ch]);
+      return host2.replace(re, (ch) => HOST_DELIMS[ch]);
     }
     function normalizePercentEncoding(input, decodeUnreserved = false) {
       if (input.indexOf("%") === -1) {
@@ -3384,16 +3384,16 @@ var require_utils = __commonJS({
         uriTokens.push("@");
       }
       if (component.host !== void 0) {
-        let host = unescape(component.host);
-        if (!isIPv4(host)) {
-          const ipV6res = normalizeIPv6(host);
+        let host2 = unescape(component.host);
+        if (!isIPv4(host2)) {
+          const ipV6res = normalizeIPv6(host2);
           if (ipV6res.isIPV6 === true) {
-            host = `[${ipV6res.escapedHost}]`;
+            host2 = `[${ipV6res.escapedHost}]`;
           } else {
-            host = reescapeHostDelimiters(host, false);
+            host2 = reescapeHostDelimiters(host2, false);
           }
         }
-        uriTokens.push(host);
+        uriTokens.push(host2);
       }
       if (typeof component.port === "number" || typeof component.port === "string") {
         uriTokens.push(":");
@@ -6894,7 +6894,7 @@ var require_dist = __commonJS({
 var require_componentMetadata = __commonJS({
   "ai/componentMetadata.cjs"(exports2, module2) {
     "use strict";
-    var CATEGORY_ORDER = ["xy", "ordinal", "network", "geo", "realtime", "value"];
+    var CATEGORY_ORDER = ["xy", "ordinal", "network", "geo", "realtime", "physics", "value"];
     var COMPONENTS_BY_CATEGORY = {
       xy: [
         "LineChart",
@@ -6952,6 +6952,15 @@ var require_componentMetadata = __commonJS({
         "RealtimeWaterfallChart",
         "RealtimeHeatmap"
       ],
+      physics: [
+        "GaltonBoardChart",
+        "EventDropChart",
+        "PhysicsPileChart",
+        "CollisionSwarmChart",
+        "PhysicalFlowChart",
+        "ProcessFlowChart",
+        "GauntletChart"
+      ],
       value: [
         "BigNumber"
       ]
@@ -6973,6 +6982,7 @@ var require_componentMetadata = __commonJS({
       return category;
     }
     function importPathForCategory(category) {
+      if (category === "physics") return "semiotic/physics";
       return category === "geo" ? "semiotic/geo" : `semiotic/${category}`;
     }
     function metadataForComponent2(entryOrName) {
@@ -14325,13 +14335,13 @@ var $ZodObject = /* @__PURE__ */ $constructor("$ZodObject", (inst, def) => {
     }
     return propValues;
   });
-  const isObject2 = isObject;
+  const isObject3 = isObject;
   const catchall = def.catchall;
   let value;
   inst._zod.parse = (payload, ctx) => {
     value ?? (value = _normalized.value);
     const input = payload.value;
-    if (!isObject2(input)) {
+    if (!isObject3(input)) {
       payload.issues.push({
         expected: "object",
         code: "invalid_type",
@@ -14429,7 +14439,7 @@ var $ZodObjectJIT = /* @__PURE__ */ $constructor("$ZodObjectJIT", (inst, def) =>
     return (payload, ctx) => fn(shape, payload, ctx);
   };
   let fastpass;
-  const isObject2 = isObject;
+  const isObject3 = isObject;
   const jit = !globalConfig.jitless;
   const allowsEval2 = allowsEval;
   const fastEnabled = jit && allowsEval2.value;
@@ -14438,7 +14448,7 @@ var $ZodObjectJIT = /* @__PURE__ */ $constructor("$ZodObjectJIT", (inst, def) =>
   inst._zod.parse = (payload, ctx) => {
     value ?? (value = _normalized.value);
     const input = payload.value;
-    if (!isObject2(input)) {
+    if (!isObject3(input)) {
       payload.issues.push({
         expected: "object",
         code: "invalid_type",
@@ -31204,8 +31214,8 @@ var newRequest = (incoming, defaultHostname) => {
     }
     return req;
   }
-  const host = (incoming instanceof import_http22.Http2ServerRequest ? incoming.authority : incoming.headers.host) || defaultHostname;
-  if (!host) {
+  const host2 = (incoming instanceof import_http22.Http2ServerRequest ? incoming.authority : incoming.headers.host) || defaultHostname;
+  if (!host2) {
     throw new RequestError("Missing host header");
   }
   let scheme;
@@ -31217,8 +31227,8 @@ var newRequest = (incoming, defaultHostname) => {
   } else {
     scheme = incoming.socket && incoming.socket.encrypted ? "https" : "http";
   }
-  const url2 = new URL(`${scheme}://${host}${incomingUrl}`);
-  if (url2.hostname.length !== host.length && url2.hostname !== host.replace(/:\d+$/, "")) {
+  const url2 = new URL(`${scheme}://${host2}${incomingUrl}`);
+  if (url2.hostname.length !== host2.length && url2.hostname !== host2.replace(/:\d+$/, "")) {
     throw new RequestError("Invalid host header");
   }
   req[urlKey] = url2.href;
@@ -32356,6 +32366,584 @@ var fs = __toESM(require("fs"));
 var path = __toESM(require("path"));
 var http = __toESM(require("http"));
 
+// ai/mcp-server-options.ts
+var DEFAULT_HTTP_HOST = "127.0.0.1";
+function getFlagValue(args, flag) {
+  const inlinePrefix = `${flag}=`;
+  for (let index = 0; index < args.length; index++) {
+    const argument = args[index];
+    if (argument.startsWith(inlinePrefix)) return argument.slice(inlinePrefix.length);
+    if (argument !== flag) continue;
+    const next = args[index + 1];
+    return next && !next.startsWith("--") ? next : void 0;
+  }
+  return void 0;
+}
+function resolveHTTPListenHost(args, env = process.env) {
+  return getFlagValue(args, "--host")?.trim() || env.MCP_HOST?.trim() || DEFAULT_HTTP_HOST;
+}
+
+// ai/mcp-logging.ts
+var DEFAULT_MCP_LOG_LEVEL = "info";
+var DEFAULT_MCP_LOG_RETENTION_DAYS = 30;
+var DEFAULT_MCP_LOG_MAX_EVENT_BYTES = 1024;
+var MIN_MCP_LOG_MAX_EVENT_BYTES = 256;
+var MAX_MCP_LOG_MAX_EVENT_BYTES = 4096;
+var MAX_MCP_LOG_RETENTION_DAYS = 90;
+var LEVEL_RANK = {
+  error: 0,
+  warn: 1,
+  info: 2
+};
+var SAFE_EVENTS = /* @__PURE__ */ new Set([
+  "request_completed",
+  "request_failed",
+  "request_rejected",
+  "service_fatal",
+  "service_started",
+  "log_event_truncated"
+]);
+var SAFE_REASONS = /* @__PURE__ */ new Set([
+  "forbidden_host",
+  "forbidden_origin",
+  "invalid_json",
+  "operation_limit",
+  "request_body_too_large",
+  "request_concurrency",
+  "request_handler_error",
+  "request_rate",
+  "request_stream_error",
+  "service_startup_failure",
+  "unauthorized",
+  "unsupported_accept",
+  "unsupported_protocol_version"
+]);
+var SAFE_ROUTES = /* @__PURE__ */ new Set([
+  "/",
+  "/mcp",
+  "/health",
+  "/healthz",
+  "/.well-known/openai-apps-challenge"
+]);
+function boundedPositiveInteger(value, fallback, min, max) {
+  const parsed = Number(value);
+  if (!Number.isSafeInteger(parsed) || parsed <= 0) return fallback;
+  return Math.min(max, Math.max(min, parsed));
+}
+function resolveMcpLoggingPolicy(env = process.env) {
+  const requestedLevel = env.MCP_LOG_LEVEL?.trim().toLowerCase();
+  const level = requestedLevel === "silent" || requestedLevel === "error" || requestedLevel === "warn" || requestedLevel === "info" ? requestedLevel : DEFAULT_MCP_LOG_LEVEL;
+  return {
+    level,
+    retentionDays: boundedPositiveInteger(
+      env.MCP_LOG_RETENTION_DAYS,
+      DEFAULT_MCP_LOG_RETENTION_DAYS,
+      1,
+      MAX_MCP_LOG_RETENTION_DAYS
+    ),
+    maxEventBytes: boundedPositiveInteger(
+      env.MCP_LOG_MAX_EVENT_BYTES,
+      DEFAULT_MCP_LOG_MAX_EVENT_BYTES,
+      MIN_MCP_LOG_MAX_EVENT_BYTES,
+      MAX_MCP_LOG_MAX_EVENT_BYTES
+    )
+  };
+}
+function safeMethod(value) {
+  if (typeof value !== "string") return "other";
+  const upper = value.toUpperCase();
+  return upper === "GET" || upper === "POST" || upper === "OPTIONS" ? upper : "other";
+}
+function safeRoute(value) {
+  return typeof value === "string" && SAFE_ROUTES.has(value) ? value : "other";
+}
+function safeCode(value, allowlist) {
+  return typeof value === "string" && allowlist.has(value) ? value : "other";
+}
+function safeInteger(value, min, max) {
+  return typeof value === "number" && Number.isSafeInteger(value) && value >= min && value <= max ? value : void 0;
+}
+function sanitizeMcpLogMetadata(input = {}) {
+  const metadata = {};
+  if (input.method !== void 0) metadata.method = safeMethod(input.method);
+  if (input.route !== void 0) metadata.route = safeRoute(input.route);
+  const status = safeInteger(input.status, 100, 599);
+  if (status !== void 0) metadata.status = status;
+  if (input.reason !== void 0) metadata.reason = safeCode(input.reason, SAFE_REASONS);
+  const durationMs = safeInteger(input.durationMs, 0, 864e5);
+  if (durationMs !== void 0) metadata.durationMs = durationMs;
+  const bodyBytes = safeInteger(input.bodyBytes, 0, 1073741824);
+  if (bodyBytes !== void 0) metadata.bodyBytes = bodyBytes;
+  if (input.profile !== void 0) {
+    metadata.profile = input.profile === "public" || input.profile === "developer" ? input.profile : "other";
+  }
+  const retentionDays = safeInteger(input.retentionDays, 1, MAX_MCP_LOG_RETENTION_DAYS);
+  if (retentionDays !== void 0) metadata.retentionDays = retentionDays;
+  if (typeof input.protocolVersionPresent === "boolean") {
+    metadata.protocolVersionPresent = input.protocolVersionPresent;
+  }
+  return metadata;
+}
+function defaultMcpLogWriter(_severity, line) {
+  process.stderr.write(`${line}
+`);
+}
+function serializeBoundedRecord(record2, maxEventBytes) {
+  const serialized = JSON.stringify(record2);
+  if (Buffer.byteLength(serialized, "utf8") <= maxEventBytes) return serialized;
+  return JSON.stringify({
+    schema: "semiotic-mcp-log/v1",
+    service: "semiotic-mcp",
+    timestamp: record2.timestamp,
+    severity: record2.severity,
+    event: "log_event_truncated",
+    metadata: {}
+  });
+}
+function createMcpMetadataLogger(policy = resolveMcpLoggingPolicy(), writer = defaultMcpLogWriter) {
+  const emit = (severity, event, metadata = {}) => {
+    if (policy.level === "silent" || LEVEL_RANK[severity] > LEVEL_RANK[policy.level]) return;
+    const record2 = {
+      schema: "semiotic-mcp-log/v1",
+      service: "semiotic-mcp",
+      timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+      severity: severity.toUpperCase(),
+      event: safeCode(event, SAFE_EVENTS),
+      metadata: sanitizeMcpLogMetadata(metadata)
+    };
+    try {
+      writer(severity, serializeBoundedRecord(record2, policy.maxEventBytes));
+    } catch {
+    }
+  };
+  return {
+    error: (event, metadata) => emit("error", event, metadata),
+    warn: (event, metadata) => emit("warn", event, metadata),
+    info: (event, metadata) => emit("info", event, metadata)
+  };
+}
+
+// ai/mcp-request-limits.ts
+var DEFAULT_MCP_MAX_CONCURRENT_REQUESTS = 16;
+var DEFAULT_MCP_MAX_REQUESTS_PER_WINDOW = 240;
+var DEFAULT_MCP_REQUEST_WINDOW_MS = 6e4;
+function positiveInteger(value, fallback) {
+  const parsed = Number.parseInt(value || "", 10);
+  return Number.isSafeInteger(parsed) && parsed > 0 ? parsed : fallback;
+}
+function resolveMcpRequestLimits(env = process.env) {
+  return {
+    maxConcurrentRequests: positiveInteger(
+      env.MCP_MAX_CONCURRENT_REQUESTS,
+      DEFAULT_MCP_MAX_CONCURRENT_REQUESTS
+    ),
+    maxRequestsPerWindow: positiveInteger(
+      env.MCP_MAX_REQUESTS_PER_WINDOW,
+      DEFAULT_MCP_MAX_REQUESTS_PER_WINDOW
+    ),
+    requestWindowMs: positiveInteger(env.MCP_REQUEST_WINDOW_MS, DEFAULT_MCP_REQUEST_WINDOW_MS)
+  };
+}
+function defaultWindowStart(now) {
+  return now <= 0 ? 1 : now;
+}
+function createMcpRequestLimiter(limits) {
+  let activeRequests = 0;
+  let requestWindowStart = defaultWindowStart(Date.now());
+  let requestsInWindow = 0;
+  const resetWindowIfExpired = (now) => {
+    const elapsed = now - requestWindowStart;
+    if (elapsed >= limits.requestWindowMs || elapsed < 0) {
+      requestWindowStart = now;
+      requestsInWindow = 0;
+    }
+  };
+  const snapshot = () => ({
+    activeRequests,
+    requestWindowStart,
+    requestsInWindow
+  });
+  const tryAcquire = (now = Date.now()) => {
+    resetWindowIfExpired(now);
+    if (activeRequests >= limits.maxConcurrentRequests) {
+      return {
+        ok: false,
+        code: "MCP_REQUEST_CONCURRENCY",
+        message: `Request concurrency limit exceeded. Set MCP_MAX_CONCURRENT_REQUESTS to raise the live limit.`,
+        retryAfterMs: 1e3
+      };
+    }
+    if (requestsInWindow >= limits.maxRequestsPerWindow) {
+      const retryAfterMs = Math.max(
+        0,
+        requestWindowStart + limits.requestWindowMs - now
+      );
+      return {
+        ok: false,
+        code: "MCP_REQUEST_RATE",
+        message: `Request rate limit exceeded. Set MCP_MAX_REQUESTS_PER_WINDOW / MCP_REQUEST_WINDOW_MS to raise the rate window/capacity.`,
+        retryAfterMs
+      };
+    }
+    activeRequests++;
+    requestsInWindow++;
+    let released = false;
+    return {
+      ok: true,
+      release: () => {
+        if (released) return;
+        released = true;
+        activeRequests = Math.max(0, activeRequests - 1);
+      }
+    };
+  };
+  return {
+    snapshot,
+    tryAcquire
+  };
+}
+
+// ai/mcp-operation-limits.ts
+var DEFAULT_MCP_MAX_ROWS = 1e4;
+var DEFAULT_MCP_MAX_CELLS = 1e5;
+var DEFAULT_MCP_MAX_NESTING_DEPTH = 64;
+function positiveInteger2(value, fallback) {
+  const parsed = Number.parseInt(value || "", 10);
+  return Number.isSafeInteger(parsed) && parsed > 0 ? parsed : fallback;
+}
+function resolveMcpOperationLimits(env = process.env) {
+  return {
+    maxRows: positiveInteger2(env.MCP_MAX_ROWS, DEFAULT_MCP_MAX_ROWS),
+    maxCells: positiveInteger2(env.MCP_MAX_CELLS, DEFAULT_MCP_MAX_CELLS),
+    maxNestingDepth: positiveInteger2(
+      env.MCP_MAX_NESTING_DEPTH,
+      DEFAULT_MCP_MAX_NESTING_DEPTH
+    )
+  };
+}
+function isObject2(value) {
+  return value !== null && typeof value === "object";
+}
+function inspectMcpOperationInput(input, limits) {
+  let rows = 0;
+  let cells = 0;
+  let nestingDepth = 0;
+  const seen = /* @__PURE__ */ new WeakSet();
+  const stack = [{ value: input, depth: 0 }];
+  while (stack.length > 0) {
+    const current = stack.pop();
+    const { value, depth } = current;
+    if (!isObject2(value) || seen.has(value)) continue;
+    seen.add(value);
+    nestingDepth = Math.max(nestingDepth, depth);
+    if (nestingDepth > limits.maxNestingDepth) {
+      return {
+        ok: false,
+        limit: "nestingDepth",
+        observed: nestingDepth,
+        maximum: limits.maxNestingDepth
+      };
+    }
+    if (Array.isArray(value)) {
+      rows += value.length;
+      if (rows > limits.maxRows) {
+        return { ok: false, limit: "rows", observed: rows, maximum: limits.maxRows };
+      }
+      for (let index = value.length - 1; index >= 0; index--) {
+        stack.push({ value: value[index], depth: depth + 1 });
+      }
+      continue;
+    }
+    const keys = Object.keys(value);
+    cells += keys.length;
+    if (cells > limits.maxCells) {
+      return { ok: false, limit: "cells", observed: cells, maximum: limits.maxCells };
+    }
+    for (let index = keys.length - 1; index >= 0; index--) {
+      stack.push({ value: value[keys[index]], depth: depth + 1 });
+    }
+  }
+  return { ok: true, rows, cells, nestingDepth };
+}
+function formatMcpOperationLimitError(result) {
+  if (result.ok) return "";
+  switch (result.limit) {
+    case "rows":
+      return `Tool arguments exceed the collection-entry limit (${result.observed} > ${result.maximum}; set MCP_MAX_ROWS to adjust).`;
+    case "cells":
+      return `Tool arguments exceed the object-field limit (${result.observed} > ${result.maximum}; set MCP_MAX_CELLS to adjust).`;
+    case "nestingDepth":
+      return `Tool arguments exceed the nesting-depth limit (${result.observed} > ${result.maximum}; set MCP_MAX_NESTING_DEPTH to adjust).`;
+  }
+}
+
+// ai/mcp-render-output-limits.ts
+var DEFAULT_MCP_MAX_RENDER_OUTPUT_BYTES = 2 * 1024 * 1024;
+var DEFAULT_MCP_MAX_WIDGET_OUTPUT_BYTES = 2 * 1024 * 1024;
+var DEFAULT_MCP_MAX_WIDGET_METADATA_BYTES = 64 * 1024;
+var DEFAULT_MCP_MAX_WIDGET_ROWS = 50;
+var DEFAULT_MCP_MAX_WIDGET_COLUMNS = 16;
+var DEFAULT_MCP_MAX_WIDGET_VALUE_BYTES = 256;
+var WIDGET_COLUMN_LABEL_BYTES = 96;
+var WIDGET_EVIDENCE_ARRAY_ITEMS = 32;
+var WIDGET_EVIDENCE_OBJECT_KEYS = 16;
+function positiveInteger3(value, fallback) {
+  const parsed = Number.parseInt(value || "", 10);
+  return Number.isSafeInteger(parsed) && parsed > 0 ? parsed : fallback;
+}
+function resolveMcpRenderOutputLimits(env = process.env) {
+  return {
+    maxRenderOutputBytes: positiveInteger3(
+      env.MCP_MAX_RENDER_OUTPUT_BYTES,
+      DEFAULT_MCP_MAX_RENDER_OUTPUT_BYTES
+    ),
+    maxWidgetOutputBytes: positiveInteger3(
+      env.MCP_MAX_WIDGET_OUTPUT_BYTES,
+      DEFAULT_MCP_MAX_WIDGET_OUTPUT_BYTES
+    ),
+    maxWidgetMetadataBytes: positiveInteger3(
+      env.MCP_MAX_WIDGET_METADATA_BYTES,
+      DEFAULT_MCP_MAX_WIDGET_METADATA_BYTES
+    ),
+    maxWidgetRows: positiveInteger3(env.MCP_MAX_WIDGET_ROWS, DEFAULT_MCP_MAX_WIDGET_ROWS),
+    maxWidgetColumns: positiveInteger3(env.MCP_MAX_WIDGET_COLUMNS, DEFAULT_MCP_MAX_WIDGET_COLUMNS),
+    maxWidgetValueBytes: positiveInteger3(
+      env.MCP_MAX_WIDGET_VALUE_BYTES,
+      DEFAULT_MCP_MAX_WIDGET_VALUE_BYTES
+    )
+  };
+}
+function utf8ByteLength(value) {
+  return Buffer.byteLength(value, "utf8");
+}
+function serializedMcpOutputBytes(value) {
+  const serialized = JSON.stringify(value);
+  return utf8ByteLength(serialized === void 0 ? "" : serialized);
+}
+function truncateUtf8(value, maximumBytes) {
+  if (maximumBytes <= 0 || !value) return "";
+  if (utf8ByteLength(value) <= maximumBytes) return value;
+  const marker = "\u2026";
+  const markerBytes = utf8ByteLength(marker);
+  if (maximumBytes < markerBytes) return "";
+  const targetBytes = maximumBytes - markerBytes;
+  let output = "";
+  let usedBytes = 0;
+  for (const character of value) {
+    const characterBytes = utf8ByteLength(character);
+    if (usedBytes + characterBytes > targetBytes) break;
+    output += character;
+    usedBytes += characterBytes;
+  }
+  return `${output}${marker}`;
+}
+function inspectMcpOutputLimit(value, maximum) {
+  const observed = serializedMcpOutputBytes(value);
+  return observed <= maximum ? { ok: true, observed, maximum } : { ok: false, observed, maximum };
+}
+function formatMcpOutputLimitError(args) {
+  return `${args.label} output exceeds the configured response limit (${args.limit.observed} > ${args.limit.maximum} bytes; set ${args.setting} to adjust). Reduce chart data or request a smaller render.`;
+}
+function isRecord(value) {
+  return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+function isSensitiveField(name) {
+  return /password|passwd|secret|token|api[-_]?key|authorization|cookie|credential|private[-_]?key/i.test(name);
+}
+function previewColumnLabel(key, used) {
+  const base = truncateUtf8(key || "value", WIDGET_COLUMN_LABEL_BYTES) || "value";
+  let label = base;
+  let suffix = 2;
+  while (used.has(label)) {
+    label = `${base} (${suffix})`;
+    suffix += 1;
+  }
+  used.add(label);
+  return label;
+}
+function selectPreviewCollection(props) {
+  for (const collection of ["data", "nodes", "edges", "links"]) {
+    if (Array.isArray(props[collection])) {
+      return { collection, rows: props[collection] };
+    }
+  }
+  return { collection: null, rows: [] };
+}
+function collectPreviewColumns(rows, limits) {
+  const keys = [];
+  const seen = /* @__PURE__ */ new Set();
+  let truncated = false;
+  for (const row of rows) {
+    if (isRecord(row)) {
+      for (const key of Object.keys(row)) {
+        if (seen.has(key)) continue;
+        if (keys.length >= limits.maxWidgetColumns) {
+          truncated = true;
+          break;
+        }
+        seen.add(key);
+        keys.push(key);
+      }
+    } else if (!seen.has("value")) {
+      if (keys.length >= limits.maxWidgetColumns) {
+        truncated = true;
+      } else {
+        seen.add("value");
+        keys.push("value");
+      }
+    }
+    if (keys.length >= limits.maxWidgetColumns && truncated) break;
+  }
+  const usedLabels = /* @__PURE__ */ new Set();
+  return {
+    columns: keys.map((key) => ({ key, label: previewColumnLabel(key, usedLabels) })),
+    truncated
+  };
+}
+function previewCell(value, fieldName, limits) {
+  if (isSensitiveField(fieldName)) {
+    return { value: "[redacted]", redacted: true, truncated: false };
+  }
+  if (value === null || value === void 0) {
+    return { value: null, redacted: false, truncated: false };
+  }
+  if (typeof value === "string") {
+    const bounded = truncateUtf8(value, limits.maxWidgetValueBytes);
+    return { value: bounded, redacted: false, truncated: bounded !== value };
+  }
+  if (typeof value === "number") {
+    return Number.isFinite(value) ? { value, redacted: false, truncated: false } : { value: String(value), redacted: false, truncated: false };
+  }
+  if (typeof value === "boolean") return { value, redacted: false, truncated: false };
+  if (Array.isArray(value)) {
+    return { value: `[array: ${value.length} items]`, redacted: false, truncated: true };
+  }
+  if (typeof value === "object") {
+    return { value: "[object]", redacted: false, truncated: true };
+  }
+  return {
+    value: truncateUtf8(String(value), limits.maxWidgetValueBytes),
+    redacted: false,
+    truncated: true
+  };
+}
+function createWidgetDataPreview(props, limits = resolveMcpRenderOutputLimits()) {
+  const selected = selectPreviewCollection(props);
+  const inputRows = selected.rows.slice(0, limits.maxWidgetRows);
+  const columnSelection = collectPreviewColumns(inputRows, limits);
+  const rows = [];
+  let redactedFields = 0;
+  let truncatedValues = 0;
+  let metadataBoundReached = false;
+  for (const input of inputRows) {
+    const row = {};
+    let rowRedactedFields = 0;
+    let rowTruncatedValues = 0;
+    for (const column of columnSelection.columns) {
+      const hasValue = isRecord(input) ? Object.prototype.hasOwnProperty.call(input, column.key) : column.key === "value";
+      const value = isRecord(input) ? input[column.key] : input;
+      if (!hasValue) {
+        row[column.label] = null;
+        continue;
+      }
+      const cell = previewCell(value, column.key, limits);
+      row[column.label] = cell.value;
+      if (cell.redacted) rowRedactedFields += 1;
+      if (cell.truncated) rowTruncatedValues += 1;
+    }
+    const candidate = {
+      collection: selected.collection,
+      totalRows: selected.rows.length,
+      returnedRows: rows.length + 1,
+      returnedColumns: columnSelection.columns.length,
+      rows: [...rows, row],
+      redactedFields: redactedFields + rowRedactedFields,
+      truncatedValues: truncatedValues + rowTruncatedValues,
+      truncated: true
+    };
+    if (serializedMcpOutputBytes(candidate) > limits.maxWidgetMetadataBytes) {
+      metadataBoundReached = true;
+      break;
+    }
+    rows.push(row);
+    redactedFields += rowRedactedFields;
+    truncatedValues += rowTruncatedValues;
+  }
+  const truncated = metadataBoundReached || columnSelection.truncated || selected.rows.length > rows.length || truncatedValues > 0;
+  return {
+    collection: selected.collection,
+    totalRows: selected.rows.length,
+    returnedRows: rows.length,
+    returnedColumns: columnSelection.columns.length,
+    rows,
+    redactedFields,
+    truncatedValues,
+    truncated
+  };
+}
+function finiteNumber(value) {
+  return typeof value === "number" && Number.isFinite(value) ? value : void 0;
+}
+function boundedEvidenceStrings(value, limits) {
+  if (!Array.isArray(value)) return void 0;
+  const values = value.slice(0, WIDGET_EVIDENCE_ARRAY_ITEMS).map((item) => truncateUtf8(String(item), limits.maxWidgetValueBytes));
+  return { values, truncated: value.length > values.length };
+}
+function createWidgetEvidencePreview(evidence, limits = resolveMcpRenderOutputLimits()) {
+  if (!evidence) return null;
+  const preview = {};
+  for (const key of ["component", "frameType", "status", "ariaLabel"]) {
+    if (typeof evidence[key] === "string") {
+      preview[key] = truncateUtf8(evidence[key], limits.maxWidgetValueBytes);
+    }
+  }
+  if (typeof evidence.empty === "boolean") preview.empty = evidence.empty;
+  for (const key of [
+    "markCount",
+    "width",
+    "height",
+    "nodeCount",
+    "edgeCount",
+    "legendItems",
+    "annotationCount"
+  ]) {
+    const value = finiteNumber(evidence[key]);
+    if (value !== void 0) preview[key] = value;
+  }
+  for (const key of ["xDomain", "yDomain"]) {
+    const domain2 = evidence[key];
+    if (Array.isArray(domain2) && domain2.length === 2) {
+      const values = domain2.map(finiteNumber);
+      if (values[0] !== void 0 && values[1] !== void 0) preview[key] = values;
+    }
+  }
+  const categories = boundedEvidenceStrings(evidence.categories, limits);
+  if (categories) {
+    preview.categories = categories.values;
+    if (categories.truncated) preview.categoriesTruncated = true;
+  }
+  const warnings = boundedEvidenceStrings(evidence.warnings, limits);
+  if (warnings) {
+    preview.warnings = warnings.values;
+    if (warnings.truncated) preview.warningsTruncated = true;
+  }
+  if (isRecord(evidence.markCountByType)) {
+    const markCountByType = {};
+    const entries = Object.entries(evidence.markCountByType).sort(([left], [right]) => left.localeCompare(right)).slice(0, WIDGET_EVIDENCE_OBJECT_KEYS);
+    for (const [key, value] of entries) {
+      const count = finiteNumber(value);
+      if (count !== void 0) {
+        markCountByType[truncateUtf8(key, WIDGET_COLUMN_LABEL_BYTES)] = count;
+      }
+    }
+    preview.markCountByType = markCountByType;
+    if (Object.keys(evidence.markCountByType).length > entries.length) {
+      preview.markCountByTypeTruncated = true;
+    }
+  }
+  return preview;
+}
+
 // ai/renderHOCToSVG.tsx
 var React = __toESM(require("react"));
 var ReactDOMServer = __toESM(require("react-dom/server"));
@@ -32404,7 +32992,14 @@ var COMPONENT_REGISTRY = {
   ChoroplethMap: { component: import_geo.ChoroplethMap, category: "geo" },
   ProportionalSymbolMap: { component: import_geo.ProportionalSymbolMap, category: "geo" },
   FlowMap: { component: import_geo.FlowMap, category: "geo" },
-  DistanceCartogram: { component: import_geo.DistanceCartogram, category: "geo" }
+  DistanceCartogram: { component: import_geo.DistanceCartogram, category: "geo" },
+  GaltonBoardChart: { component: import_ai.GaltonBoardChart, category: "physics" },
+  EventDropChart: { component: import_ai.EventDropChart, category: "physics" },
+  PhysicsPileChart: { component: import_ai.PhysicsPileChart, category: "physics" },
+  CollisionSwarmChart: { component: import_ai.CollisionSwarmChart, category: "physics" },
+  PhysicalFlowChart: { component: import_ai.PhysicalFlowChart, category: "physics" },
+  ProcessFlowChart: { component: import_ai.ProcessFlowChart, category: "physics" },
+  GauntletChart: { component: import_ai.GauntletChart, category: "physics" }
 };
 
 // ai/renderHOCToSVG.tsx
@@ -32473,6 +33068,79 @@ var componentNames = Object.keys(COMPONENT_REGISTRY).sort();
 var REPO = "nteract/semiotic";
 var SEMIOTIC_CHART_WIDGET_URI = "ui://semiotic/chart-widget.html";
 var MCP_APP_MIME_TYPE = "text/html;profile=mcp-app";
+var DEFAULT_MCP_SUPPORTED_PROTOCOL_VERSION = "2024-11-05";
+var DEFAULT_MCP_MAX_RENDER_WORK_MS = 2500;
+var DEFAULT_MCP_MAX_PNG_CONVERSION_MS = 4e3;
+var DEFAULT_MCP_MAX_INTERACTIVE_SVG_SANITIZE_MS = 3e3;
+var mcpLoggingPolicy = resolveMcpLoggingPolicy();
+var mcpLogger = createMcpMetadataLogger(mcpLoggingPolicy);
+function writeJsonRpcError(res, status, code, message) {
+  res.writeHead(status, { "Content-Type": "application/json" });
+  res.end(JSON.stringify({
+    jsonrpc: "2.0",
+    error: { code, message },
+    id: null
+  }));
+}
+function isAuthorizedRequest(req, token, scheme) {
+  if (!token) return true;
+  const authorization = req.headers.authorization;
+  if (typeof authorization !== "string") return false;
+  const [providedScheme, providedToken] = authorization.split(/\s+/, 2);
+  return providedScheme?.toLowerCase() === scheme.toLowerCase() && Boolean(providedToken) && providedToken === token;
+}
+function hasSupportedAccept(acceptHeader) {
+  if (!acceptHeader) return true;
+  const lower = acceptHeader.toLowerCase();
+  return lower.includes("*/*") || lower.includes("application/json") || lower.includes("text/event-stream");
+}
+function isSupportedProtocolVersion(protocolVersion, supported) {
+  if (!protocolVersion || supported.length === 0) return true;
+  return supported.includes(protocolVersion);
+}
+function parsePositiveInteger(value, fallback) {
+  const parsed = Number.parseInt(value || "", 10);
+  return Number.isSafeInteger(parsed) && parsed > 0 ? parsed : fallback;
+}
+function resolveMcpRenderExecutionLimits(env = process.env) {
+  return {
+    maxRenderWorkMs: parsePositiveInteger(env.MCP_MAX_RENDER_WORK_MS, DEFAULT_MCP_MAX_RENDER_WORK_MS),
+    maxPngConversionMs: parsePositiveInteger(env.MCP_MAX_PNG_CONVERSION_MS, DEFAULT_MCP_MAX_PNG_CONVERSION_MS),
+    maxInteractiveSanitizeMs: parsePositiveInteger(env.MCP_MAX_INTERACTIVE_SVG_SANITIZE_MS, DEFAULT_MCP_MAX_INTERACTIVE_SVG_SANITIZE_MS)
+  };
+}
+function makeRenderExecutionError(code, label, limitMs, observedMs) {
+  const text = code === "MCP_RENDER_TIMEOUT" ? `${label} exceeded ${limitMs} ms timeout budget (${observedMs ?? 0} ms). Set ${label === "PNG conversion" ? "MCP_MAX_PNG_CONVERSION_MS" : label.includes("sanitize") ? "MCP_MAX_INTERACTIVE_SVG_SANITIZE_MS" : "MCP_MAX_RENDER_WORK_MS"} to adjust.` : `${label} was canceled before completion.`;
+  const error48 = new Error(text);
+  error48.code = code;
+  return error48;
+}
+function throwIfRequestCanceled(signal, label = "render work") {
+  if (signal?.aborted) {
+    throw makeRenderExecutionError("MCP_RENDER_CANCELLED", label, 0);
+  }
+}
+async function runRenderStep(label, limitMs, signal, work) {
+  throwIfRequestCanceled(signal, label);
+  const started = Date.now();
+  const result = await Promise.resolve(work());
+  if (signal?.aborted) throw makeRenderExecutionError("MCP_RENDER_CANCELLED", label, 0);
+  const elapsed = Date.now() - started;
+  if (limitMs > 0 && elapsed > limitMs) {
+    throw makeRenderExecutionError("MCP_RENDER_TIMEOUT", label, limitMs, elapsed);
+  }
+  return result;
+}
+function isRenderExecutionError(error48) {
+  return !!error48 && typeof error48 === "object" && (error48.code === "MCP_RENDER_TIMEOUT" || error48.code === "MCP_RENDER_CANCELLED");
+}
+function renderExecutionErrorResult(message, code) {
+  return {
+    content: [{ type: "text", text: message }],
+    isError: true,
+    structuredContent: { code }
+  };
+}
 function aiFilePath(fileName) {
   return path.resolve(__dirname, "..", fileName);
 }
@@ -32526,11 +33194,203 @@ function promptMessage(text) {
     }]
   };
 }
-function stripUnsafeSvg(svg) {
-  return svg.replace(/<script\b[^<]*(?:(?!<\/script>)<[^<]*)*<\/script>/gi, "").replace(/\son[a-z]+\s*=\s*"[^"]*"/gi, "").replace(/\son[a-z]+\s*=\s*'[^']*'/gi, "").replace(/\s(href|xlink:href)\s*=\s*(["'])\s*javascript:[^"']*\2/gi, "");
+var SVG_NAMESPACE = "http://www.w3.org/2000/svg";
+var SAFE_SVG_ELEMENTS = /* @__PURE__ */ new Set([
+  "svg",
+  "g",
+  "path",
+  "line",
+  "polyline",
+  "polygon",
+  "rect",
+  "circle",
+  "ellipse",
+  "text",
+  "tspan",
+  "title",
+  "desc",
+  "defs",
+  "style",
+  "linearGradient",
+  "radialGradient",
+  "stop",
+  "clipPath",
+  "mask",
+  "pattern",
+  "filter",
+  "marker",
+  "use",
+  "symbol"
+]);
+var SAFE_SVG_ATTRIBUTES = /* @__PURE__ */ new Set([
+  "alignment-baseline",
+  "alignmentadjust",
+  "aria-hidden",
+  "aria-label",
+  "aria-labelledby",
+  "aria-describedby",
+  "clip-path",
+  "cx",
+  "cy",
+  "d",
+  "dx",
+  "dy",
+  "dominant-baseline",
+  "fill",
+  "fill-opacity",
+  "fill-rule",
+  "font-family",
+  "font-size",
+  "font-style",
+  "font-weight",
+  "gradientunits",
+  "gradienttransform",
+  "height",
+  "id",
+  "marker-height",
+  "marker-units",
+  "marker-width",
+  "marker-end",
+  "marker-mid",
+  "marker-start",
+  "offset",
+  "opacity",
+  "orientation",
+  "pattern-content-units",
+  "pattern-transform",
+  "pattern-units",
+  "preserveaspectratio",
+  "r",
+  "rx",
+  "ry",
+  "role",
+  "shape-rendering",
+  "spreadmethod",
+  "startoffset",
+  "stroke",
+  "stroke-linecap",
+  "stroke-linejoin",
+  "stroke-opacity",
+  "stroke-width",
+  "style",
+  "text-anchor",
+  "transform",
+  "viewbox",
+  "width",
+  "x",
+  "x1",
+  "x2",
+  "xmlns",
+  "xmlns:xlink",
+  "y",
+  "y1",
+  "y2",
+  "xml:space",
+  "class"
+]);
+var SAFE_URL_ATTR_PREFIXES = [
+  "http://",
+  "https://",
+  "#",
+  "/",
+  "./",
+  "../",
+  "mailto:",
+  "tel:",
+  "data:image/"
+];
+function isSafeUrlValue(value) {
+  const trimmed = value.trim().toLowerCase();
+  if (!trimmed) return true;
+  if (/^(javascript|vbscript|file):/i.test(trimmed)) return false;
+  return SAFE_URL_ATTR_PREFIXES.some((prefix) => trimmed.startsWith(prefix));
+}
+function sanitizeStyleValue(value) {
+  return value.replace(/\/\*[\s\S]*?\*\//g, "").replace(/@import[^;]*;/gi, "").replace(/expression\s*\([^)]*\)/gi, "").replace(/url\(\s*["']?\s*([^)"']+)\s*["']?\s*\)/gi, (_match, rawUrl) => {
+    const safeUrl = String(rawUrl || "").trim().toLowerCase();
+    if (safeUrl && !isSafeUrlValue(safeUrl)) return "url()";
+    return `url(${rawUrl})`;
+  });
+}
+function isAllowedSvgAttribute(name) {
+  const lower = name.toLowerCase();
+  if (lower.startsWith("on")) return false;
+  if (lower.startsWith("data-")) return true;
+  if (lower.startsWith("aria-")) return true;
+  if (lower.startsWith("xml:")) return true;
+  if (lower === "xmlns" || lower.startsWith("xmlns:")) return true;
+  if (SAFE_SVG_ATTRIBUTES.has(lower)) return true;
+  return /^[a-z][a-z0-9-_:.]*$/.test(lower);
+}
+function sanitizeSvgAttribute(name, value) {
+  const lower = name.toLowerCase();
+  if (!isAllowedSvgAttribute(name)) return null;
+  if ((lower === "href" || lower === "xlink:href" || lower === "src") && !isSafeUrlValue(value)) {
+    return null;
+  }
+  if (lower === "style") return sanitizeStyleValue(value);
+  return value;
+}
+function sanitizeSvgNode(node, doc) {
+  if (node.nodeType === 3 || node.nodeType === 4) {
+    const text = node.textContent ?? "";
+    return text ? doc.createTextNode(text) : null;
+  }
+  if (node.nodeType !== 1) return null;
+  const source = node;
+  const tag = source.tagName;
+  if (!SAFE_SVG_ELEMENTS.has(tag)) return null;
+  const safe = doc.createElementNS(SVG_NAMESPACE, tag);
+  const isStyleTag = tag === "style";
+  if (!isStyleTag) {
+    for (const attribute of Array.from(source.attributes)) {
+      const safeValue = sanitizeSvgAttribute(attribute.name, attribute.value);
+      if (safeValue == null) continue;
+      safe.setAttribute(attribute.name, safeValue);
+    }
+  } else {
+    const styleText = sanitizeStyleValue(source.textContent ?? "");
+    if (styleText) {
+      safe.appendChild(doc.createTextNode(styleText));
+    }
+    return safe;
+  }
+  for (const child of Array.from(source.childNodes)) {
+    const sanitized = sanitizeSvgNode(child, doc);
+    if (sanitized) safe.appendChild(sanitized);
+  }
+  return safe;
+}
+var jsdomModulePromise = null;
+function loadJsdomModule() {
+  if (!jsdomModulePromise) jsdomModulePromise = import("jsdom");
+  return jsdomModulePromise;
+}
+void loadJsdomModule().catch(() => {
+});
+async function sanitizeSvgForWidget(svg) {
+  const trimmed = svg.trim();
+  if (!trimmed) return "";
+  try {
+    const { JSDOM } = await loadJsdomModule();
+    const parsed = new JSDOM(trimmed, { contentType: "image/svg+xml" });
+    const parsedDocument = parsed.window.document;
+    const sourceRoot = parsedDocument.documentElement;
+    if (!sourceRoot || sourceRoot.tagName.toLowerCase() !== "svg") return "";
+    if (parsedDocument.getElementsByTagName("parsererror")[0]) return "";
+    const cleanDocument = parsedDocument.implementation.createDocument(SVG_NAMESPACE, null, null);
+    const safeRoot = sanitizeSvgNode(sourceRoot, cleanDocument);
+    if (!safeRoot) return "";
+    cleanDocument.appendChild(safeRoot);
+    return new parsed.window.XMLSerializer().serializeToString(safeRoot);
+  } catch {
+    return "";
+  }
 }
 function parseRenderEvidence(result) {
-  const evidenceText = result.content.find((block) => block.text.startsWith("Render evidence:\n"))?.text;
+  const evidenceText = result.content.find(
+    (block) => block.type === "text" && block.text.startsWith("Render evidence:\n")
+  )?.text;
   if (!evidenceText) return null;
   try {
     return JSON.parse(evidenceText.replace(/^Render evidence:\n/, ""));
@@ -32539,7 +33399,8 @@ function parseRenderEvidence(result) {
   }
 }
 function chartTitleFromProps(component, props) {
-  return typeof props.title === "string" && props.title.trim() ? props.title.trim() : component;
+  const title = typeof props.title === "string" && props.title.trim() ? props.title.trim() : component;
+  return truncateUtf8(title, resolveMcpRenderOutputLimits().maxWidgetValueBytes);
 }
 function chartDatumCount(props) {
   if (Array.isArray(props.data)) return props.data.length;
@@ -32704,22 +33565,26 @@ function renderSemioticChartWidgetHTML() {
       return { output, meta };
     }
 
-    function sampleRows(meta) {
-      const props = meta?.props || {};
-      if (Array.isArray(props.data)) return props.data.slice(0, 50);
-      if (Array.isArray(props.nodes)) return props.nodes.slice(0, 50);
-      if (Array.isArray(props.edges)) return props.edges.slice(0, 50);
-      if (Array.isArray(props.links)) return props.links.slice(0, 50);
-      return [];
+    function dataPreview(meta) {
+      const preview = meta?.dataPreview;
+      return preview && Array.isArray(preview.rows) ? preview : null;
     }
 
-    function renderTable(rows) {
+    function renderTable(preview) {
+      const rows = preview?.rows || [];
       if (!rows.length) return '<pre>No row data was provided in the widget metadata.</pre>';
       const columns = Array.from(rows.reduce((set, row) => {
         Object.keys(row || {}).forEach((key) => set.add(key));
         return set;
       }, new Set()));
-      return '<table><thead><tr>' + columns.map((col) => '<th>' + html(col) + '</th>').join('') +
+      const totalRows = Number.isFinite(preview?.totalRows) ? preview.totalRows : rows.length;
+      const collection = preview?.collection || 'data';
+      const notes = [
+        'Showing ' + rows.length + ' of ' + totalRows + ' ' + html(collection) + ' rows.',
+        preview?.truncated ? 'Preview values or rows were truncated.' : '',
+        preview?.redactedFields ? 'Sensitive fields were redacted.' : ''
+      ].filter(Boolean).join(' ');
+      return '<div class="summary">' + notes + '</div><table><thead><tr>' + columns.map((col) => '<th>' + html(col) + '</th>').join('') +
         '</tr></thead><tbody>' + rows.map((row) => '<tr>' + columns.map((col) => '<td>' + html(row?.[col]) + '</td>').join('') + '</tr>').join('') + '</tbody></table>';
     }
 
@@ -32734,8 +33599,8 @@ function renderSemioticChartWidgetHTML() {
       } else {
         chartEl.innerHTML = '<div class="empty">No SVG payload received. The model-visible chart summary is still available above.</div>';
       }
-      const rows = sampleRows(hidden);
-      dataDrawer.innerHTML = renderTable(rows);
+      const preview = dataPreview(hidden);
+      dataDrawer.innerHTML = renderTable(preview);
       evidenceText.textContent = JSON.stringify(payload.evidence || hidden.evidence || {}, null, 2);
     }
 
@@ -32799,6 +33664,46 @@ function renderSemioticChartWidgetHTML() {
 </body>
 </html>`.trim();
 }
+function capRenderedToolResult(result, args) {
+  const limit = inspectMcpOutputLimit(result, args.maximum);
+  if (limit.ok) return result;
+  return {
+    content: [{
+      type: "text",
+      text: formatMcpOutputLimitError({
+        label: args.label,
+        limit,
+        setting: args.setting
+      })
+    }],
+    isError: true,
+    structuredContent: {
+      code: "OUTPUT_LIMIT_EXCEEDED",
+      maximumBytes: limit.maximum,
+      observedBytes: limit.observed
+    }
+  };
+}
+function capRenderChartResult(result) {
+  const limits = resolveMcpRenderOutputLimits();
+  return capRenderedToolResult(result, {
+    label: "Rendered chart",
+    maximum: limits.maxRenderOutputBytes,
+    setting: "MCP_MAX_RENDER_OUTPUT_BYTES"
+  });
+}
+function capInteractiveWidgetResult(result) {
+  const limits = resolveMcpRenderOutputLimits();
+  return capRenderedToolResult(result, {
+    label: "Interactive widget",
+    maximum: limits.maxWidgetOutputBytes,
+    setting: "MCP_MAX_WIDGET_OUTPUT_BYTES"
+  });
+}
+var SURFACE_VERSION = `${schema.version || "3.0.0"}-ai`;
+function profileResult(result) {
+  return { ...result, surfaceVersion: SURFACE_VERSION };
+}
 async function getSchemaHandler(args) {
   const component = args.component;
   if (!component) {
@@ -32809,7 +33714,7 @@ ${list.join(", ")}
 
 Components marked [renderable] can be rendered to SVG via renderChart (pass theme parameter for styled output). Others (Realtime*) require a browser environment.
 
-For full agent context, read MCP resources: semiotic://schema, semiotic://components, semiotic://behavior-contracts, semiotic://system-prompt, semiotic://examples.
+For full agent context, read MCP resources: semiotic://schema, semiotic://components, semiotic://surface-manifest, semiotic://behavior-contracts, semiotic://system-prompt, semiotic://examples.
 
 All charts support CSS custom properties for theming (--semiotic-bg, --semiotic-text, --semiotic-grid, etc.) and <ThemeProvider>. Use COLOR_BLIND_SAFE_CATEGORICAL (import from semiotic/themes) for accessible color palettes.
 
@@ -32859,98 +33764,148 @@ async function suggestChartHandler(args) {
   }
   return { content, structuredContent: result };
 }
-async function renderChartHandler(args) {
+async function renderChartHandler(args, context = {}) {
+  const limits = context.limits ?? resolveMcpRenderExecutionLimits();
+  const signal = context.signal;
   const component = args.component;
   const props = args.props ?? {};
   const theme = args.theme;
   const format = args.format || "svg";
   if (!component) {
-    return {
+    return capRenderChartResult({
       content: [{ type: "text", text: `Missing 'component' field. Provide { component: '<name>', props: { ... } }. Available: ${componentNames.join(", ")}` }],
       isError: true
-    };
+    });
   }
   if (!COMPONENT_REGISTRY[component]) {
     if (schemaByComponent[component]) {
-      return {
+      return capRenderChartResult({
         content: [{ type: "text", text: `Component "${component}" is known but cannot be rendered via renderChart. It requires a browser/live environment. Renderable components: ${componentNames.join(", ")}` }],
         isError: true
-      };
+      });
     }
-    return {
+    return capRenderChartResult({
       content: [{ type: "text", text: `Unknown component "${component}". Available: ${componentNames.join(", ")}` }],
       isError: true
-    };
+    });
+  }
+  let result;
+  try {
+    result = await runRenderStep(
+      "render work",
+      limits.maxRenderWorkMs,
+      signal,
+      () => renderHOCToSVG(component, props)
+    );
+  } catch (err) {
+    if (isRenderExecutionError(err)) {
+      return capRenderChartResult(renderExecutionErrorResult(err.message, err.code));
+    }
+    throw err;
   }
-  const result = renderHOCToSVG(component, props);
   if (result.error) {
-    return {
+    return capRenderChartResult({
       content: [{ type: "text", text: result.error }],
       isError: true
-    };
+    });
   }
   let svg = result.svg;
   let evidenceBlock = null;
   try {
-    const { svg: evidenceSvg, evidence } = (0, import_server2.renderChartWithEvidence)(component, props);
+    const { svg: evidenceSvg, evidence } = await runRenderStep(
+      "layout/render evidence",
+      limits.maxRenderWorkMs,
+      signal,
+      () => (0, import_server2.renderChartWithEvidence)(component, props)
+    );
     svg = evidenceSvg;
     evidenceBlock = {
       type: "text",
       text: `Render evidence:
 ${JSON.stringify(evidence, null, 2)}`
     };
-  } catch {
+  } catch (err) {
+    if (isRenderExecutionError(err)) {
+      return capRenderChartResult(renderExecutionErrorResult(err.message, err.code));
+    }
     evidenceBlock = {
       type: "text",
       text: `Render evidence: unavailable for ${component} (no server render config). The SVG above is the validated React render; mark-count / domain evidence is only produced for components with a server render path.`
     };
   }
   if (theme && Object.keys(theme).length > 0) {
-    const validVars = Object.entries(theme).filter(([k]) => k.startsWith("--semiotic-")).map(([k, v]) => `${k}: ${v}`).join("; ");
-    if (validVars) {
-      svg = svg.replace(/<svg([^>]*)>/, `<svg$1><style>:root { ${validVars} }</style>`);
+    try {
+      svg = await runRenderStep(
+        "theme application",
+        limits.maxRenderWorkMs,
+        signal,
+        () => {
+          const isUnsafeCssValue = (v) => /<|>|{|}|@|expression\(|javascript:|url\(|\*\//i.test(v);
+          const validVars = Object.entries(theme).filter(([k, v]) => k.startsWith("--semiotic-") && typeof v === "string" && !isUnsafeCssValue(v)).map(([k, v]) => `${k}: ${v}`).join("; ");
+          if (!validVars) return svg;
+          return svg.replace(/<svg([^>]*)>/, `<svg$1><style>:root { ${validVars} }</style>`);
+        }
+      );
+    } catch (err) {
+      if (isRenderExecutionError(err)) {
+        return capRenderChartResult(renderExecutionErrorResult(err.message, err.code));
+      }
+      throw err;
     }
   }
   if (format === "png") {
     try {
-      const sharpMod = await Function('return import("sharp")')();
-      const sharpFn = sharpMod.default || sharpMod;
-      const pngBuffer = await sharpFn(Buffer.from(svg)).png().toBuffer();
+      const pngBuffer = await runRenderStep(
+        "PNG conversion",
+        limits.maxPngConversionMs,
+        signal,
+        async () => {
+          const sharpMod = await Function('return import("sharp")')();
+          const sharpFn = sharpMod.default || sharpMod;
+          return sharpFn(Buffer.from(svg)).png().toBuffer();
+        }
+      );
       const base643 = pngBuffer.toString("base64");
-      return {
+      return capRenderChartResult({
         content: [
-          { type: "text", text: `data:image/png;base64,${base643}` },
+          { type: "image", data: base643, mimeType: "image/png" },
           ...evidenceBlock ? [evidenceBlock] : []
         ]
-      };
+      });
     } catch (err) {
-      if (err.code === "MODULE_NOT_FOUND" || err.code === "ERR_MODULE_NOT_FOUND") {
-        return {
+      if (isRenderExecutionError(err)) {
+        return capRenderChartResult(renderExecutionErrorResult(err.message, err.code));
+      }
+      const typedErr = err;
+      if (typedErr.code === "MODULE_NOT_FOUND" || typedErr.code === "ERR_MODULE_NOT_FOUND") {
+        return capRenderChartResult({
           content: [{ type: "text", text: `PNG output requires the 'sharp' package. Install it with: npm install sharp
 
 Falling back to SVG output:
 
 ${svg}` }]
-        };
+        });
       }
-      return {
-        content: [{ type: "text", text: `PNG conversion failed: ${err.message}
+      return capRenderChartResult({
+        content: [{ type: "text", text: `PNG conversion failed: ${typedErr.message || "unknown error"}
 
 SVG output:
 
 ${svg}` }],
         isError: true
-      };
+      });
     }
   }
-  return {
+  return capRenderChartResult({
     content: [
       { type: "text", text: svg },
       ...evidenceBlock ? [evidenceBlock] : []
     ]
-  };
+  });
 }
-async function renderInteractiveChartHandler(args) {
+async function renderInteractiveChartHandler(args, context = {}) {
+  const limits = context.limits ?? resolveMcpRenderExecutionLimits();
+  const signal = context.signal;
   const component = args.component;
   const props = args.props ?? {};
   const rendered = await renderChartHandler({
@@ -32958,10 +33913,31 @@ async function renderInteractiveChartHandler(args) {
     props,
     theme: args.theme,
     format: "svg"
-  });
+  }, context);
   if (rendered.isError) return rendered;
-  const svg = stripUnsafeSvg(rendered.content[0]?.text ?? "");
-  const evidence = parseRenderEvidence(rendered);
+  const svgBlock = rendered.content.find(
+    (block) => block.type === "text" && block.text.trimStart().startsWith("<")
+  );
+  let svg;
+  try {
+    svg = await runRenderStep(
+      "interactive SVG sanitization",
+      limits.maxInteractiveSanitizeMs,
+      signal,
+      () => sanitizeSvgForWidget(svgBlock?.text ?? "")
+    );
+  } catch (err) {
+    if (isRenderExecutionError(err)) {
+      return capInteractiveWidgetResult(renderExecutionErrorResult(err.message, err.code));
+    }
+    return capInteractiveWidgetResult({
+      content: [{ type: "text", text: "Interactive SVG sanitization failed." }],
+      isError: true
+    });
+  }
+  const outputLimits = resolveMcpRenderOutputLimits();
+  const evidence = createWidgetEvidencePreview(parseRenderEvidence(rendered), outputLimits);
+  const dataPreview = createWidgetDataPreview(props, outputLimits);
   const title = chartTitleFromProps(component || "Semiotic chart", props);
   const datumCount = chartDatumCount(props);
   const summary = [
@@ -32969,7 +33945,7 @@ async function renderInteractiveChartHandler(args) {
     datumCount == null ? "No row count was inferred from props." : `${datumCount} input row${datumCount === 1 ? "" : "s"} available in the widget data drawer.`,
     "Use the widget controls to zoom, fit width, inspect data, and inspect render evidence."
   ].join(" ");
-  return {
+  return capInteractiveWidgetResult({
     content: [{
       type: "text",
       text: `Rendered ${title} (${component}) as an interactive ChatGPT Apps widget.`
@@ -32982,15 +33958,14 @@ async function renderInteractiveChartHandler(args) {
       evidence
     },
     _meta: {
-      component,
+      component: component ?? "SemioticChart",
       title,
-      props,
-      theme: args.theme ?? null,
+      dataPreview,
       svg,
       evidence,
       generatedAt: (/* @__PURE__ */ new Date()).toISOString()
     }
-  };
+  });
 }
 function filterUsageModeDiagnoses(component, usageMode, diagnoses) {
   if (dataRequiredForUsageMode(component, usageMode)) return diagnoses;
@@ -33053,6 +34028,26 @@ async function auditAccessibilityHandler(args) {
     isError: !result.ok
   };
 }
+async function auditMobileVisualizationHandler(args) {
+  const component = args.component;
+  const props = args.props ?? {};
+  if (!component) {
+    return {
+      content: [{ type: "text", text: "Missing 'component' field. Provide { component: 'LineChart', props: { ... } }." }],
+      isError: true
+    };
+  }
+  const result = (0, import_ai3.auditMobileVisualization)(component, props, {
+    viewportWidth: typeof args.viewportWidth === "number" ? args.viewportWidth : void 0,
+    targetSize: typeof args.targetSize === "number" ? args.targetSize : void 0,
+    inChartContainer: args.inChartContainer === true
+  });
+  return {
+    content: [{ type: "text", text: (0, import_ai3.formatMobileVisualizationAudit)(result) }],
+    // Block only on high-risk mobile issues; medium/low warnings remain advisory.
+    isError: !result.ok
+  };
+}
 async function reportIssueHandler(args) {
   const title = args.title;
   const body = args.body;
@@ -33275,6 +34270,74 @@ async function suggestChartsHandler(args) {
     structuredContent: { suggestions }
   };
 }
+var ALLOWED_TOKEN_TASK_INTENTS = [
+  "precise-comparison",
+  "frequency-reasoning",
+  "probability-estimation",
+  "risk-communication",
+  "memory",
+  "editorial-engagement",
+  "public-explanation",
+  "support-decision",
+  "measure",
+  "estimate probability",
+  "understand risk",
+  "remember",
+  "decide"
+];
+function isTokenTaskIntent(value) {
+  return ALLOWED_TOKEN_TASK_INTENTS.includes(value);
+}
+async function suggestTokenEncodingHandler(args) {
+  if (!args.taskIntent) {
+    return {
+      content: [{
+        type: "text",
+        text: "Missing 'taskIntent'. Provide a token task such as 'estimate probability', 'understand risk', 'remember', 'measure', or 'decide'."
+      }],
+      isError: true
+    };
+  }
+  if (!isTokenTaskIntent(args.taskIntent)) {
+    return {
+      content: [{
+        type: "text",
+        text: `Invalid 'taskIntent': "${args.taskIntent}". Expected one of: ${ALLOWED_TOKEN_TASK_INTENTS.join(", ")}.`
+      }],
+      isError: true
+    };
+  }
+  const taskIntent = args.taskIntent;
+  const suggestion = (0, import_ai3.suggestTokenEncoding)({
+    taskIntent,
+    dataType: args.dataType,
+    audience: args.audience,
+    precisionNeed: args.precisionNeed,
+    availableSpace: args.availableSpace,
+    concreteEntity: args.concreteEntity
+  });
+  const capabilityIntents = (0, import_ai3.tokenTaskIntentToCapabilityIntents)(taskIntent);
+  const warnings = suggestion.warnings.length ? `
+Warnings:
+${suggestion.warnings.map((warning) => `- [${warning.code}] ${warning.message}`).join("\n")}` : "";
+  const encoding = suggestion.tokenEncoding ? `
+Encoding:
+${JSON.stringify(suggestion.tokenEncoding, null, 2)}` : "";
+  return {
+    content: [{
+      type: "text",
+      text: [
+        `Recommended token encoding: ${suggestion.recommendedEncoding}`,
+        `Rationale: ${suggestion.rationale}`,
+        `Capability intents: ${capabilityIntents.join(", ")}`,
+        encoding.trim(),
+        warnings.trim(),
+        `Alternatives: ${suggestion.alternatives.join(", ")}`
+      ].filter(Boolean).join("\n\n")
+    }],
+    structuredContent: { suggestion, capabilityIntents }
+  };
+}
 async function suggestStreamChartsHandler(args) {
   const { schema: schema2, intent, maxResults } = args;
   const intentArg = Array.isArray(intent) ? intent : intent ? [intent] : void 0;
@@ -33437,16 +34500,124 @@ async function groundChartHandler(args) {
     structuredContent: grounding
   };
 }
+function compactPublicChartProps(props) {
+  const compact = { ...props };
+  delete compact.data;
+  delete compact.nodes;
+  delete compact.edges;
+  return compact;
+}
+function compactPublicSuggestion(suggestion) {
+  return { ...suggestion, props: compactPublicChartProps(suggestion.props) };
+}
+async function createChartHandler(args, context = {}) {
+  const intent = Array.isArray(args.intent) ? args.intent : args.intent ? [args.intent] : void 0;
+  const suggestions = (0, import_ai3.suggestCharts)(args.data, { intent, audience: args.audience, maxResults: 40 }).filter((suggestion) => metadataForComponent(suggestion.component).renderable).slice(0, 8);
+  const selected = args.component ? suggestions.find((suggestion) => suggestion.component === args.component) : suggestions[0];
+  if (!selected) {
+    return {
+      content: [{ type: "text", text: "No renderable Semiotic chart was suggested for this data. Use getChartSchema for code-level guidance." }],
+      isError: true,
+      structuredContent: profileResult({
+        status: "no-suggestion",
+        suggestions: suggestions.map(compactPublicSuggestion),
+        dataRowCount: args.data.length
+      })
+    };
+  }
+  const props = { data: args.data, ...selected.props, ...args.props };
+  const publicProps = compactPublicChartProps(props);
+  const publicSuggestion = compactPublicSuggestion(selected);
+  const diagnosis = (0, import_ai3.diagnoseConfig)(selected.component, props);
+  const blocking = diagnosis.diagnoses.filter((item) => item.severity === "error");
+  if (blocking.length) {
+    return {
+      content: [{ type: "text", text: `Selected ${selected.component}, but blocking diagnostics require repair before rendering.` }],
+      isError: true,
+      structuredContent: profileResult({
+        status: "blocked",
+        component: selected.component,
+        props: publicProps,
+        dataRowCount: args.data.length,
+        suggestion: publicSuggestion,
+        diagnostics: diagnosis.diagnoses
+      })
+    };
+  }
+  const rendered = await renderInteractiveChartHandler({ component: selected.component, props, theme: args.theme }, context);
+  if (rendered.isError) {
+    return {
+      ...rendered,
+      structuredContent: profileResult({
+        status: "blocked",
+        component: selected.component,
+        props: publicProps,
+        dataRowCount: args.data.length,
+        suggestion: publicSuggestion,
+        diagnostics: diagnosis.diagnoses,
+        render: rendered.structuredContent ?? null
+      })
+    };
+  }
+  const output = rendered.structuredContent ?? {};
+  return {
+    ...rendered,
+    structuredContent: profileResult({
+      status: "render-proven",
+      component: selected.component,
+      props: publicProps,
+      dataRowCount: args.data.length,
+      suggestion: publicSuggestion,
+      diagnostics: diagnosis.diagnoses,
+      render: output
+    })
+  };
+}
+async function improveChartHandler(args) {
+  const data = args.data ?? (Array.isArray(args.props.data) ? args.props.data : []);
+  const intent = Array.isArray(args.intent) ? args.intent : args.intent ? [args.intent] : void 0;
+  const diagnosis = (0, import_ai3.diagnoseConfig)(args.component, args.props);
+  const repair = (0, import_ai3.repairChartConfig)(args.component, data, { intent });
+  const capability = (0, import_ai3.getCapability)(args.component);
+  const variants = capability ? (0, import_ai3.proposeVariant)(args.component, capability, { profile: (0, import_ai3.profileData)(data), intent }) : [];
+  return {
+    content: [{ type: "text", text: `Improvement analysis for ${args.component}: ${diagnosis.diagnoses.length} diagnosis item(s), repair status ${repair.status}, ${variants.length} variant proposal(s).` }],
+    structuredContent: profileResult({ status: repair.status === "ok" ? "reviewed" : "repair-needed", component: args.component, diagnostics: diagnosis.diagnoses, repair, variants })
+  };
+}
+async function explainChartHandler(args) {
+  const grounded = await groundChartHandler(args);
+  return {
+    ...grounded,
+    structuredContent: grounded.structuredContent ? profileResult({ status: "grounded", grounding: grounded.structuredContent }) : void 0
+  };
+}
+async function auditChartHandler(args) {
+  const diagnosis = (0, import_ai3.diagnoseConfig)(args.component, args.props);
+  const accessibility = (0, import_ai3.auditAccessibility)(args.component, args.props, { inChartContainer: true, describe: true, navigable: true });
+  const mobile = (0, import_ai3.auditMobileVisualization)(args.component, args.props, { viewportWidth: args.viewportWidth, inChartContainer: true });
+  const blocking = diagnosis.diagnoses.some((item) => item.severity === "error") || !accessibility.ok || !mobile.ok;
+  return {
+    content: [{ type: "text", text: `Audit for ${args.component}: ${blocking ? "blocking findings need attention" : "no blocking findings"}.` }],
+    isError: blocking,
+    structuredContent: profileResult({ status: blocking ? "findings" : "passed", component: args.component, diagnostics: diagnosis.diagnoses, accessibility, mobile })
+  };
+}
 var READ_ONLY_TOOL_ANNOTATIONS = {
   readOnlyHint: true,
   destructiveHint: false,
   idempotentHint: true,
   openWorldHint: false
 };
-function createServer2() {
+function createServer2(profile = "developer", options = {}) {
+  const serverRenderContext = {
+    signal: options.signal,
+    limits: options.limits ?? resolveMcpRenderExecutionLimits()
+  };
   const srv = new McpServer({
     name: "semiotic",
-    version: schema.version || "3.0.0"
+    version: schema.version || "3.0.0",
+    description: "Deterministic Semiotic chart selection, validation, rendering, and non-visual chart grounding. Use suggestCharts, getSchema, diagnoseConfig, and renderChart in that order for static chart generation."
   });
   srv.registerResource(
     "semiotic-schema",
@@ -33468,6 +34639,16 @@ function createServer2() {
     },
     (uri) => textResource(uri, "application/json", componentIndexJSON())
   );
+  srv.registerResource(
+    "semiotic-surface-manifest",
+    "semiotic://surface-manifest",
+    {
+      title: "Semiotic AI Surface Manifest",
+      description: "Generated inventory of schema components, AI exports, MCP renderability, tools, resources, and prompts.",
+      mimeType: "application/json"
+    },
+    (uri) => textResource(uri, "application/json", readAIFile("surface-manifest.json"))
+  );
   srv.registerResource(
     "semiotic-behavior-contracts",
     "semiotic://behavior-contracts",
@@ -33583,6 +34764,51 @@ function createServer2() {
       "Return the smallest safe fix first, then mention any follow-up cleanup or issue-reporting step."
     ].join("\n"))
   );
+  if (profile === "public") {
+    srv.registerTool("createChart", {
+      title: "Create and prove a chart",
+      description: "Select, validate, diagnose, render, and prove a static-data Semiotic chart. This is the default public workflow.",
+      inputSchema: {
+        data: external_exports3.array(external_exports3.record(external_exports3.string(), external_exports3.unknown())).min(1),
+        intent: external_exports3.union([external_exports3.string(), external_exports3.array(external_exports3.string())]).optional(),
+        audience: external_exports3.object({ name: external_exports3.string().optional(), receptionModality: external_exports3.enum(["visual", "screen-reader", "sonified", "agent"]).optional() }).passthrough().optional(),
+        component: external_exports3.string().optional().describe("Optional chart preference; the fit-ranked result remains authoritative."),
+        props: external_exports3.record(external_exports3.string(), external_exports3.unknown()).optional().describe("Optional props to merge over the selected chart recipe."),
+        theme: external_exports3.record(external_exports3.string(), external_exports3.string()).optional()
+      },
+      outputSchema: { status: external_exports3.enum(["render-proven", "blocked", "no-suggestion"]), component: external_exports3.string().optional(), surfaceVersion: external_exports3.string() },
+      annotations: READ_ONLY_TOOL_ANNOTATIONS,
+      _meta: { ui: { resourceUri: SEMIOTIC_CHART_WIDGET_URI }, "openai/outputTemplate": SEMIOTIC_CHART_WIDGET_URI }
+    }, (args) => createChartHandler(args, serverRenderContext));
+    srv.registerTool("improveChart", {
+      title: "Improve an existing chart",
+      description: "Diagnose a chart configuration, assess data fit, and propose repairs or variants.",
+      inputSchema: { component: external_exports3.string(), props: external_exports3.record(external_exports3.string(), external_exports3.unknown()), data: external_exports3.array(external_exports3.record(external_exports3.string(), external_exports3.unknown())).optional(), intent: external_exports3.union([external_exports3.string(), external_exports3.array(external_exports3.string())]).optional() },
+      outputSchema: { status: external_exports3.enum(["reviewed", "repair-needed"]), component: external_exports3.string(), surfaceVersion: external_exports3.string() },
+      annotations: READ_ONLY_TOOL_ANNOTATIONS
+    }, improveChartHandler);
+    srv.registerTool("explainChart", {
+      title: "Explain a chart without pixels",
+      description: "Return reader grounding: chart description, communicative intent, and navigable data structure.",
+      inputSchema: { component: external_exports3.string(), props: external_exports3.record(external_exports3.string(), external_exports3.unknown()) },
+      outputSchema: { status: external_exports3.literal("grounded"), grounding: external_exports3.record(external_exports3.string(), external_exports3.unknown()), surfaceVersion: external_exports3.string() },
+      annotations: READ_ONLY_TOOL_ANNOTATIONS
+    }, explainChartHandler);
+    srv.registerTool("auditChart", {
+      title: "Audit chart quality and accessibility",
+      description: "Run design diagnostics plus accessibility and mobile audits, returning prioritized structured findings.",
+      inputSchema: { component: external_exports3.string(), props: external_exports3.record(external_exports3.string(), external_exports3.unknown()), viewportWidth: external_exports3.number().int().min(240).max(1600).optional() },
+      outputSchema: { status: external_exports3.enum(["passed", "findings"]), component: external_exports3.string(), surfaceVersion: external_exports3.string() },
+      annotations: READ_ONLY_TOOL_ANNOTATIONS
+    }, auditChartHandler);
+    srv.registerTool("getChartSchema", {
+      title: "Get a chart schema",
+      description: "Return canonical Semiotic prop-schema guidance for code editing and advanced configuration.",
+      inputSchema: { component: external_exports3.string().optional() },
+      annotations: READ_ONLY_TOOL_ANNOTATIONS
+    }, getSchemaHandler);
+    return srv;
+  }
   srv.tool(
     "getSchema",
     `Return the prop schema for a Semiotic chart component. Pass { component: '<name>' } to get its props, or omit component to list all available components. Components marked [renderable] can be passed to renderChart for static SVG output.`,
@@ -33613,15 +34839,15 @@ function createServer2() {
   );
   srv.tool(
     "renderChart",
-    `Render a Semiotic chart to static SVG or PNG. This is a static snapshot path: props must include data immediately, and ref/push-mode charts cannot be rendered through this tool. Returns SVG string (default) or Base64-encoded PNG image, plus a "Render evidence" JSON block (mark counts by type, resolved axis domains, empty flag, annotation count, accessible name) \u2014 read the evidence instead of parsing the SVG to verify the chart actually rendered data marks. Optionally pass theme CSS custom properties (--semiotic-bg, --semiotic-text, etc.) to style the output. PNG requires the 'sharp' package to be installed. Available components: ${componentNames.join(", ")}.`,
+    `Render a Semiotic chart to static SVG or PNG. This is a static snapshot path: props must include data immediately, and ref/push-mode charts cannot be rendered through this tool. Returns SVG text by default or an image/png artifact when format='png', plus a "Render evidence" JSON block (mark counts by type, resolved axis domains, empty flag, annotation count, accessible name) \u2014 read the evidence instead of parsing the SVG to verify the chart actually rendered data marks. Optionally pass theme CSS custom properties (--semiotic-bg, --semiotic-text, etc.) to style the output. PNG requires the 'sharp' package to be installed. Available components: ${componentNames.join(", ")}.`,
     {
       component: external_exports3.string().describe("Chart component name, e.g. 'LineChart', 'BarChart'"),
       props: external_exports3.record(external_exports3.string(), external_exports3.unknown()).optional().describe("Chart props object, e.g. { data: [...], xAccessor: 'x' }."),
       theme: external_exports3.record(external_exports3.string(), external_exports3.string()).optional().describe("CSS custom properties for theming, e.g. { '--semiotic-bg': '#1a1a2e', '--semiotic-text': '#ededed' }. Only --semiotic-* variables are applied."),
-      format: external_exports3.enum(["svg", "png"]).optional().describe("Output format: 'svg' (default) returns SVG markup, 'png' returns a Base64-encoded PNG image. PNG requires the 'sharp' package.")
+      format: external_exports3.enum(["svg", "png"]).optional().describe("Output format: 'svg' (default) returns SVG markup, 'png' returns image/png artifact data. PNG requires the 'sharp' package.")
     },
     READ_ONLY_TOOL_ANNOTATIONS,
-    renderChartHandler
+    (args) => renderChartHandler(args, serverRenderContext)
   );
   srv.registerTool(
     "renderInteractiveChart",
@@ -33653,7 +34879,7 @@ function createServer2() {
         "openai/toolInvocation/invoked": "Rendered Semiotic chart."
       }
     },
-    renderInteractiveChartHandler
+    (args) => renderInteractiveChartHandler(args, serverRenderContext)
   );
   srv.tool(
     "diagnoseConfig",
@@ -33679,6 +34905,19 @@ function createServer2() {
     READ_ONLY_TOOL_ANNOTATIONS,
     auditAccessibilityHandler
   );
+  srv.tool(
+    "auditMobileVisualization",
+    "Audit a Semiotic chart configuration for mobile visualization risks. Use before generating phone-sized charts or when adapting a desktop chart to mobile. Flags fixed desktop widths, rough mark-density overload, hover-only detail, small touch targets, complex gestures without controls, legend dependence, annotation overload, and missing mobile transformation hints. Static analysis only: still verify rendered charts at phone widths.",
+    {
+      component: external_exports3.string().describe("Chart component name, e.g. 'LineChart', 'Scatterplot', or 'BarChart'."),
+      props: external_exports3.record(external_exports3.string(), external_exports3.unknown()).optional().describe("Chart props/config to audit."),
+      viewportWidth: external_exports3.number().int().min(240).max(1600).optional().describe("Mobile viewport width in CSS pixels. Defaults to 390."),
+      targetSize: external_exports3.number().int().min(24).max(80).optional().describe("Desired comfortable touch target size in CSS pixels. Defaults to 44."),
+      inChartContainer: external_exports3.boolean().optional().describe("Whether the chart is wrapped in ChartContainer or an equivalent summary/control surface.")
+    },
+    READ_ONLY_TOOL_ANNOTATIONS,
+    auditMobileVisualizationHandler
+  );
   srv.tool(
     "reportIssue",
     "Generate a GitHub issue URL for Semiotic bug reports or feature requests. Returns a URL the user can open to submit. For rendering bugs, include the component name, props summary, and any diagnoseConfig output in the body.",
@@ -33710,14 +34949,25 @@ function createServer2() {
     READ_ONLY_TOOL_ANNOTATIONS,
     interrogateChartHandler
   );
-  srv.tool(
+  srv.registerTool(
     "groundChart",
-    "Build the agent-reader grounding payload for a Semiotic chart: the layered L1\u2013L3 natural-language description, the L4 communicative-act sentence (what the chart is asking the reader to do \u2014 'this is an alerting chart; the spike warrants a closer look'), and a structured navigation tree (chart \u2192 axes/series \u2192 datum). This is the documented thing an LLM reads to interpret a chart faithfully without seeing the pixels \u2014 the reader-side complement to a capability descriptor. The L4 act is resolved from the chart's registered capability. Returns prose plus the full structured payload (description/intent/structure/text).",
     {
-      component: external_exports3.string().describe("Chart component name, e.g. 'LineChart'"),
-      props: external_exports3.record(external_exports3.string(), external_exports3.unknown()).describe("The full chart props including data")
+      title: "Ground a Semiotic chart for a non-visual reader",
+      description: "Build the agent-reader grounding payload for a Semiotic chart: the layered L1\u2013L3 natural-language description, the L4 communicative-act sentence (what the chart is asking the reader to do), and a structured navigation tree (chart \u2192 axes/series \u2192 datum). Use this to interpret a chart faithfully without pixels.",
+      inputSchema: {
+        component: external_exports3.string().describe("Chart component name, e.g. 'LineChart'"),
+        props: external_exports3.record(external_exports3.string(), external_exports3.unknown()).describe("The full chart props including data")
+      },
+      outputSchema: {
+        component: external_exports3.string(),
+        description: external_exports3.record(external_exports3.string(), external_exports3.unknown()),
+        intent: external_exports3.record(external_exports3.string(), external_exports3.unknown()).optional(),
+        structure: external_exports3.record(external_exports3.string(), external_exports3.unknown()).optional(),
+        physics: external_exports3.record(external_exports3.string(), external_exports3.unknown()).optional(),
+        text: external_exports3.string()
+      },
+      annotations: READ_ONLY_TOOL_ANNOTATIONS
     },
-    READ_ONLY_TOOL_ANNOTATIONS,
     groundChartHandler
   );
   srv.tool(
@@ -33753,6 +35003,20 @@ function createServer2() {
     READ_ONLY_TOOL_ANNOTATIONS,
     suggestDashboardHandler
   );
+  srv.tool(
+    "suggestTokenEncoding",
+    "Recommend a semantic token / ISOTYPE encoding for a reader task. Use before drawing repeated dots, icons, glyphs, natural-frequency grids, quantile dotplots, or hybrid bar-token views. Returns the recommended tokenEncoding, warnings, alternatives, and matching suggestCharts capability intents. Accepts canonical token intents (precise-comparison, probability-estimation, risk-communication, memory, support-decision, etc.) and friendly aliases (measure, estimate probability, understand risk, remember, decide).",
+    {
+      taskIntent: external_exports3.string().describe("Reader task intent, e.g. 'estimate probability', 'understand risk', 'remember', 'measure', 'decide', or canonical token intents like 'probability-estimation'."),
+      dataType: external_exports3.enum(["count", "measure", "distribution", "probability", "risk", "category"]).optional().describe("Data shape or meaning behind the tokenized view."),
+      audience: external_exports3.enum(["expert", "general-public", "internal"]).optional().describe("Audience for the recommendation."),
+      precisionNeed: external_exports3.enum(["low", "medium", "high"]).optional().describe("How much exact magnitude reading matters."),
+      availableSpace: external_exports3.enum(["small", "medium", "large"]).optional().describe("Space budget for visible tokens."),
+      concreteEntity: external_exports3.string().optional().describe("Concrete icon/glyph concept, e.g. person, bus, server. Becomes tokenEncoding.icon when useful.")
+    },
+    READ_ONLY_TOOL_ANNOTATIONS,
+    suggestTokenEncodingHandler
+  );
   srv.tool(
     "suggestStretchCharts",
     "Recommend literacy-growth chart picks for a dataset given an AudienceProfile. Returns charts the data supports but the audience is unfamiliar with (familiarity \u2264 3, or \u2264 4 at exposureLevel 2), each paired with the familiar chart it could substitute for and a rationale. Use when the consumer wants to gently expose users to less familiar but more analytically appropriate visualizations.",
@@ -33778,16 +35042,27 @@ function createServer2() {
     READ_ONLY_TOOL_ANNOTATIONS,
     suggestStretchChartsHandler
   );
-  srv.tool(
+  srv.registerTool(
     "repairChartConfig",
-    "Validate that a chart component is a sensible choice for a dataset, and if not, propose alternatives that fit. Use when a user asks for a specific chart and you want to confirm it's appropriate, or when you've drafted a config and want to verify it. Returns either ok (no change needed), alternative (chart doesn't fit; here are ranked replacements with rationale), or unknown (no capability registered).",
     {
-      component: external_exports3.string().describe("Chart component name to validate, e.g. 'PieChart'"),
-      data: external_exports3.array(external_exports3.record(external_exports3.string(), external_exports3.unknown())).describe("Row data \u2014 array of objects."),
-      intent: external_exports3.union([external_exports3.string(), external_exports3.array(external_exports3.string())]).optional().describe("User intent \u2014 informs ranking of alternatives when the chart doesn't fit."),
-      maxAlternatives: external_exports3.number().int().min(1).max(10).optional().describe("Cap on alternatives returned (default 3).")
+      title: "Repair an unsuitable chart choice",
+      description: "Validate that a chart component is a sensible choice for a dataset, and if not, propose ranked alternatives that fit. Returns a structured status of ok, alternative, or unknown.",
+      inputSchema: {
+        component: external_exports3.string().describe("Chart component name to validate, e.g. 'PieChart'"),
+        data: external_exports3.array(external_exports3.record(external_exports3.string(), external_exports3.unknown())).describe("Row data \u2014 array of objects."),
+        intent: external_exports3.union([external_exports3.string(), external_exports3.array(external_exports3.string())]).optional().describe("User intent \u2014 informs ranking of alternatives when the chart doesn't fit."),
+        maxAlternatives: external_exports3.number().int().min(1).max(10).optional().describe("Cap on alternatives returned (default 3).")
+      },
+      outputSchema: {
+        status: external_exports3.enum(["ok", "alternative", "unknown"]),
+        component: external_exports3.string(),
+        reason: external_exports3.string().optional(),
+        alternatives: external_exports3.array(external_exports3.unknown()).optional(),
+        profile: external_exports3.record(external_exports3.string(), external_exports3.unknown()),
+        repairs: external_exports3.array(external_exports3.string()).optional()
+      },
+      annotations: READ_ONLY_TOOL_ANNOTATIONS
     },
-    READ_ONLY_TOOL_ANNOTATIONS,
     repairChartConfigHandler
   );
   srv.tool(
@@ -33817,44 +35092,137 @@ function createServer2() {
     READ_ONLY_TOOL_ANNOTATIONS,
     proposeChartVariantsHandler
   );
-  srv.tool(
+  srv.registerTool(
     "suggestCharts",
-    "Recommend Semiotic charts for a dataset using heuristic capability descriptors. Each chart declares which data shapes it serves and which intents (trend, compare-categories, distribution, correlation, part-to-whole, etc.) it answers \u2014 the engine returns a ranked list with scores, reasons, caveats, and ready-to-use props. Heuristic only; no LLM call. Use the result as structured context when answering 'what chart should I use?' or generating chart code.",
     {
-      data: external_exports3.array(external_exports3.record(external_exports3.string(), external_exports3.unknown())).describe("Row data \u2014 array of objects."),
-      intent: external_exports3.union([external_exports3.string(), external_exports3.array(external_exports3.string())]).optional().describe("Ranking intent. One of: trend, compare-series, compare-categories, rank, part-to-whole, distribution, correlation, flow, hierarchy, geo, outlier-detection, composition-over-time, change-detection. Custom intents accepted."),
-      maxResults: external_exports3.number().int().min(1).max(40).optional().describe("Cap on suggestions returned (default 8)."),
-      allow: external_exports3.array(external_exports3.string()).optional().describe("Restrict to these component names."),
-      deny: external_exports3.array(external_exports3.string()).optional().describe("Exclude these component names."),
-      audience: external_exports3.object({
-        name: external_exports3.string().optional(),
-        familiarity: external_exports3.record(external_exports3.string(), external_exports3.number()).optional(),
-        targets: external_exports3.record(
-          external_exports3.string(),
-          external_exports3.object({
-            direction: external_exports3.enum(["increase", "decrease"]),
-            weight: external_exports3.number().int().min(1).max(3).optional(),
-            reason: external_exports3.string().optional()
-          })
-        ).optional(),
-        exposureLevel: external_exports3.union([external_exports3.literal(0), external_exports3.literal(1), external_exports3.literal(2)]).optional(),
-        receptionModality: external_exports3.enum(["visual", "screen-reader", "sonified", "agent"]).optional().describe("Reception channel. A non-visual value down-ranks charts the audience can't receive in that channel (e.g. a many-slice pie for a screen reader) and adds receivability caveats.")
-      }).optional().describe("Audience profile \u2014 familiarity, adoption targets, exposure level, and reception modality.")
+      title: "Recommend Semiotic charts",
+      description: "Recommend Semiotic charts for a dataset using heuristic capability descriptors. Returns ranked, structured suggestions with scores, reasons, caveats, and ready-to-use props; no LLM call is made.",
+      inputSchema: {
+        data: external_exports3.array(external_exports3.record(external_exports3.string(), external_exports3.unknown())).describe("Row data \u2014 array of objects."),
+        intent: external_exports3.union([external_exports3.string(), external_exports3.array(external_exports3.string())]).optional().describe("Ranking intent. One of: trend, compare-series, compare-categories, rank, part-to-whole, distribution, correlation, flow, hierarchy, geo, outlier-detection, composition-over-time, change-detection. Custom intents accepted."),
+        maxResults: external_exports3.number().int().min(1).max(40).optional().describe("Cap on suggestions returned (default 8)."),
+        allow: external_exports3.array(external_exports3.string()).optional().describe("Restrict to these component names."),
+        deny: external_exports3.array(external_exports3.string()).optional().describe("Exclude these component names."),
+        audience: external_exports3.object({
+          name: external_exports3.string().optional(),
+          familiarity: external_exports3.record(external_exports3.string(), external_exports3.number()).optional(),
+          targets: external_exports3.record(
+            external_exports3.string(),
+            external_exports3.object({
+              direction: external_exports3.enum(["increase", "decrease"]),
+              weight: external_exports3.number().int().min(1).max(3).optional(),
+              reason: external_exports3.string().optional()
+            })
+          ).optional(),
+          exposureLevel: external_exports3.union([external_exports3.literal(0), external_exports3.literal(1), external_exports3.literal(2)]).optional(),
+          receptionModality: external_exports3.enum(["visual", "screen-reader", "sonified", "agent"]).optional().describe("Reception channel. A non-visual value down-ranks charts the audience can't receive in that channel and adds receivability caveats.")
+        }).optional().describe("Audience profile \u2014 familiarity, adoption targets, exposure level, and reception modality.")
+      },
+      outputSchema: { suggestions: external_exports3.array(external_exports3.unknown()) },
+      annotations: READ_ONLY_TOOL_ANNOTATIONS
     },
-    READ_ONLY_TOOL_ANNOTATIONS,
     suggestChartsHandler
   );
   return srv;
 }
 var cliArgs = process.argv.slice(2);
 var httpMode = cliArgs.includes("--http");
+var profileFlagIndex = cliArgs.indexOf("--profile");
+var requestedProfile = profileFlagIndex !== -1 ? cliArgs[profileFlagIndex + 1] : process.env.MCP_TOOL_PROFILE;
+var toolProfile = requestedProfile === "public" ? "public" : "developer";
 var portFlagIndex = cliArgs.indexOf("--port");
 var parsedPort = portFlagIndex !== -1 && cliArgs[portFlagIndex + 1] != null ? parseInt(cliArgs[portFlagIndex + 1], 10) : NaN;
 var port = Number.isFinite(parsedPort) ? parsedPort : 3001;
+var host = resolveHTTPListenHost(cliArgs);
+function operationLimitForMcpRequest(body, limits) {
+  const requests = Array.isArray(body) ? body : [body];
+  for (const candidate of requests) {
+    if (!candidate || typeof candidate !== "object" || Array.isArray(candidate)) continue;
+    const request = candidate;
+    if (request.method !== "tools/call") continue;
+    if (!request.params || typeof request.params !== "object" || Array.isArray(request.params)) continue;
+    const params = request.params;
+    if (!("arguments" in params)) continue;
+    const result = inspectMcpOperationInput(params.arguments, limits);
+    if (!result.ok) return result;
+  }
+  return null;
+}
 async function main() {
   if (httpMode) {
     const allowedHosts = (process.env.MCP_ALLOWED_HOSTS || "").split(",").map((h) => h.trim().toLowerCase()).filter(Boolean);
+    const allowedOrigins = (process.env.MCP_ALLOWED_ORIGINS || "").split(",").map((o) => o.trim().toLowerCase()).filter(Boolean);
+    const parsedMaxBody = parseInt(process.env.MCP_MAX_BODY_BYTES || "", 10);
+    const maxBodyBytes = Number.isFinite(parsedMaxBody) && parsedMaxBody > 0 ? parsedMaxBody : 4194304;
+    const operationLimits = resolveMcpOperationLimits();
     const openaiAppsChallengeToken = (process.env.OPENAI_APPS_CHALLENGE_TOKEN || "").trim();
+    const renderExecutionLimits = resolveMcpRenderExecutionLimits();
+    const requestLimits = resolveMcpRequestLimits();
+    const requestLimiter = createMcpRequestLimiter(requestLimits);
+    const protocolVersions = (process.env.MCP_SUPPORTED_PROTOCOL_VERSIONS || "").split(",").map((version2) => version2.trim()).filter(Boolean);
+    const protocolVersion = protocolVersions[0] || DEFAULT_MCP_SUPPORTED_PROTOCOL_VERSION;
+    const authToken = (process.env.MCP_AUTH_TOKEN || "").trim();
+    const authScheme = (process.env.MCP_AUTH_SCHEME || "Bearer").trim() || "Bearer";
+    const readJsonBodyWithLimit = (req) => new Promise((resolve2) => {
+      let size = 0;
+      let done = false;
+      const chunks = [];
+      const finish = (result) => {
+        if (done) return;
+        done = true;
+        resolve2(result);
+      };
+      req.on("data", (chunk) => {
+        if (done) return;
+        size += chunk.length;
+        if (size > maxBodyBytes) {
+          finish({
+            ok: false,
+            status: 413,
+            code: -32600,
+            message: "Request body too large",
+            reason: "request_body_too_large"
+          });
+          return;
+        }
+        chunks.push(chunk);
+      });
+      req.on("end", () => {
+        if (done) return;
+        const raw = Buffer.concat(chunks).toString("utf-8");
+        if (!raw) return finish({ ok: true, body: void 0, bodyBytes: size });
+        try {
+          const body = JSON.parse(raw);
+          const operationLimit = operationLimitForMcpRequest(body, operationLimits);
+          if (operationLimit && !operationLimit.ok) {
+            finish({
+              ok: false,
+              status: 413,
+              code: -32602,
+              message: formatMcpOperationLimitError(operationLimit),
+              reason: "operation_limit"
+            });
+            return;
+          }
+          finish({ ok: true, body, bodyBytes: size });
+        } catch {
+          finish({
+            ok: false,
+            status: 400,
+            code: -32600,
+            message: "Invalid JSON body",
+            reason: "invalid_json"
+          });
+        }
+      });
+      req.on("error", () => finish({
+        ok: false,
+        status: 400,
+        code: -32600,
+        message: "Request stream error",
+        reason: "request_stream_error"
+      }));
+    });
     const healthBody = () => JSON.stringify({
       status: "ok",
       name: "semiotic-mcp",
@@ -33863,7 +35231,25 @@ async function main() {
       mode: "stateless"
     });
     const httpServer = http.createServer(async (req, res) => {
-      res.setHeader("Access-Control-Allow-Origin", "*");
+      const requestStartedAt = Date.now();
+      const requestAbortController = new AbortController();
+      const abortRequest = () => requestAbortController.abort();
+      req.on("aborted", abortRequest);
+      req.on("close", abortRequest);
+      const pathname = (() => {
+        try {
+          return new URL(req.url || "/", "http://localhost").pathname;
+        } catch {
+          return "/";
+        }
+      })();
+      const origin = String(req.headers.origin || "").trim().toLowerCase();
+      if (allowedOrigins.length > 0) {
+        res.setHeader("Access-Control-Allow-Origin", allowedOrigins.includes(origin) ? origin : allowedOrigins[0]);
+        res.setHeader("Vary", "Origin");
+      } else {
+        res.setHeader("Access-Control-Allow-Origin", "*");
+      }
       res.setHeader("Access-Control-Allow-Methods", "GET, POST, OPTIONS");
       res.setHeader(
         "Access-Control-Allow-Headers",
@@ -33875,17 +35261,28 @@ async function main() {
         res.end();
         return;
       }
-      const pathname = (() => {
-        try {
-          return new URL(req.url || "/", "http://localhost").pathname;
-        } catch {
-          return "/";
-        }
-      })();
+      if (allowedOrigins.length > 0 && origin && !allowedOrigins.includes(origin)) {
+        mcpLogger.warn("request_rejected", {
+          reason: "forbidden_origin",
+          method: req.method,
+          route: pathname,
+          status: 403
+        });
+        res.writeHead(403, { "Content-Type": "application/json" });
+        res.end(JSON.stringify({ jsonrpc: "2.0", error: { code: -32e3, message: "Forbidden origin" }, id: null }));
+        return;
+      }
+      res.setHeader("MCP-Protocol-Version", protocolVersion);
       if (allowedHosts.length > 0) {
         const rawHost = String(req.headers.host || "").trim().toLowerCase();
         const normalizedHost = rawHost.startsWith("[") ? rawHost.replace(/^\[([^\]]+)\](?::\d+)?$/, "$1") : rawHost.split(":")[0];
         if (!allowedHosts.includes(rawHost) && !allowedHosts.includes(normalizedHost)) {
+          mcpLogger.warn("request_rejected", {
+            reason: "forbidden_host",
+            method: req.method,
+            route: pathname,
+            status: 403
+          });
           res.writeHead(403, { "Content-Type": "application/json" });
           res.end(JSON.stringify({ jsonrpc: "2.0", error: { code: -32e3, message: "Forbidden host" }, id: null }));
           return;
@@ -33910,55 +35307,155 @@ async function main() {
         return;
       }
       if (req.method === "GET") {
+        if (pathname === "/mcp") {
+          res.writeHead(405, { "Content-Type": "application/json", Allow: "POST, OPTIONS" });
+          res.end(JSON.stringify({ jsonrpc: "2.0", error: { code: -32e3, message: "Method not allowed (stateless server offers no SSE stream)" }, id: null }));
+          return;
+        }
         res.writeHead(200, { "Content-Type": "application/json" });
         res.end(healthBody());
         return;
       }
       if (req.method !== "POST") {
-        res.writeHead(405, { "Content-Type": "application/json" });
+        res.writeHead(405, { "Content-Type": "application/json", Allow: "POST, OPTIONS" });
         res.end(JSON.stringify({ jsonrpc: "2.0", error: { code: -32e3, message: "Method not allowed" }, id: null }));
         return;
       }
-      const srv = createServer2();
-      const transport = new StreamableHTTPServerTransport({
-        sessionIdGenerator: void 0,
-        enableJsonResponse: true
-      });
-      let torndown = false;
-      const teardown = () => {
-        if (torndown) return;
-        torndown = true;
-        Promise.resolve(transport.close()).catch(() => {
+      if (!hasSupportedAccept(String(req.headers.accept || ""))) {
+        mcpLogger.warn("request_rejected", {
+          reason: "unsupported_accept",
+          method: req.method,
+          route: pathname,
+          status: 406
         });
-        Promise.resolve(srv.close()).catch(() => {
+        writeJsonRpcError(
+          res,
+          406,
+          -32e3,
+          "Not Acceptable: this endpoint supports JSON transport only"
+        );
+        return;
+      }
+      if (!isSupportedProtocolVersion(
+        String(req.headers["mcp-protocol-version"] || ""),
+        protocolVersions
+      )) {
+        mcpLogger.warn("request_rejected", {
+          reason: "unsupported_protocol_version",
+          method: req.method,
+          route: pathname,
+          status: 400,
+          // The header's value can be attacker-controlled; presence is enough
+          // operationally and keeps it out of the log boundary.
+          protocolVersionPresent: Boolean(req.headers["mcp-protocol-version"])
         });
-      };
-      res.on("close", teardown);
+        writeJsonRpcError(
+          res,
+          400,
+          -32e3,
+          "Unsupported MCP protocol version"
+        );
+        return;
+      }
+      if (authToken && !isAuthorizedRequest(req, authToken, authScheme)) {
+        mcpLogger.warn("request_rejected", {
+          reason: "unauthorized",
+          method: req.method,
+          route: pathname,
+          status: 401
+        });
+        res.setHeader("WWW-Authenticate", `${authScheme} realm="semiotic-mcp"`);
+        writeJsonRpcError(res, 401, -32e3, "Unauthorized");
+        return;
+      }
+      const requestSlot = requestLimiter.tryAcquire();
+      if (!requestSlot.ok) {
+        res.setHeader("Retry-After", String(Math.max(1, Math.ceil(requestSlot.retryAfterMs / 1e3))));
+        mcpLogger.warn("request_rejected", {
+          reason: requestSlot.code === "MCP_REQUEST_CONCURRENCY" ? "request_concurrency" : "request_rate",
+          method: req.method,
+          route: pathname,
+          status: 429
+        });
+        writeJsonRpcError(res, 429, -32e3, requestSlot.message);
+        return;
+      }
       try {
-        await srv.connect(transport);
-        await transport.handleRequest(req, res);
-      } catch (err) {
-        console.error("Request handling error:", err);
-        if (!res.headersSent) {
-          res.writeHead(500, { "Content-Type": "application/json" });
-          res.end(JSON.stringify({ jsonrpc: "2.0", error: { code: -32603, message: "Internal server error" }, id: null }));
+        const bodyResult = await readJsonBodyWithLimit(req);
+        if (!bodyResult.ok) {
+          mcpLogger.warn("request_rejected", {
+            reason: bodyResult.reason,
+            method: req.method,
+            route: pathname,
+            status: bodyResult.status
+          });
+          if (!res.headersSent) {
+            res.writeHead(bodyResult.status, { "Content-Type": "application/json" });
+            res.end(JSON.stringify({ jsonrpc: "2.0", error: { code: bodyResult.code, message: bodyResult.message }, id: null }));
+          }
+          return;
+        }
+        const srv = createServer2(toolProfile, {
+          signal: requestAbortController.signal,
+          limits: renderExecutionLimits
+        });
+        const transport = new StreamableHTTPServerTransport({
+          sessionIdGenerator: void 0,
+          enableJsonResponse: true
+        });
+        let torndown = false;
+        const teardown = () => {
+          if (torndown) return;
+          torndown = true;
+          Promise.resolve(transport.close()).catch(() => {
+          });
+          Promise.resolve(srv.close()).catch(() => {
+          });
+        };
+        res.on("close", teardown);
+        try {
+          await srv.connect(transport);
+          await transport.handleRequest(req, res, bodyResult.body);
+          mcpLogger.info("request_completed", {
+            method: req.method,
+            route: pathname,
+            status: res.statusCode,
+            durationMs: Date.now() - requestStartedAt,
+            bodyBytes: bodyResult.bodyBytes
+          });
+        } catch {
+          mcpLogger.error("request_failed", {
+            reason: "request_handler_error",
+            method: req.method,
+            route: pathname,
+            status: 500,
+            durationMs: Date.now() - requestStartedAt,
+            bodyBytes: bodyResult.bodyBytes
+          });
+          if (!res.headersSent) {
+            res.writeHead(500, { "Content-Type": "application/json" });
+            res.end(JSON.stringify({ jsonrpc: "2.0", error: { code: -32603, message: "Internal server error" }, id: null }));
+          }
+        } finally {
+          teardown();
         }
       } finally {
-        teardown();
+        requestSlot.release();
       }
     });
-    httpServer.listen(port, () => {
-      console.error(`Semiotic MCP server (HTTP) listening on http://localhost:${port}`);
-      console.error("Tools: getSchema, suggestChart, suggestCharts, proposeChartVariants, suggestStreamCharts, suggestDashboard, suggestStretchCharts, repairChartConfig, renderChart, renderInteractiveChart, interrogateChart, groundChart, diagnoseConfig, auditAccessibility, reportIssue, applyTheme");
-      console.error("Resources: semiotic://schema, semiotic://components, semiotic://behavior-contracts, semiotic://system-prompt, semiotic://examples, ui://semiotic/chart-widget.html");
+    httpServer.listen(port, host, () => {
+      mcpLogger.info("service_started", {
+        profile: toolProfile,
+        retentionDays: mcpLoggingPolicy.retentionDays
+      });
     });
   } else {
-    const srv = createServer2();
+    const srv = createServer2(toolProfile);
     const transport = new StdioServerTransport();
     await srv.connect(transport);
   }
 }
-main().catch((err) => {
-  console.error("MCP server error:", err);
+main().catch(() => {
+  mcpLogger.error("service_fatal", { reason: "service_startup_failure" });
   process.exit(1);
 });