@frontmcp/uipack 0.6.2 → 0.7.1

package/bundler/index.js

@@ -65,14 +65,14 @@ __export(filesystem_exports, {
 function createFilesystemStorage(options) {
   return new FilesystemStorage(options);
 }
-var import_promises, import_path, import_fs, import_crypto, CacheInitializationError, CacheOperationError, StorageNotInitializedError, DEFAULT_FS_OPTIONS, FilesystemStorage;
+var import_path, import_fs, import_crypto, import_utils, CacheInitializationError, CacheOperationError, StorageNotInitializedError, DEFAULT_FS_OPTIONS, FilesystemStorage;
 var init_filesystem = __esm({
   "libs/uipack/src/bundler/file-cache/storage/filesystem.ts"() {
     "use strict";
-    import_promises = require("fs/promises");
     import_path = require("path");
     import_fs = require("fs");
     import_crypto = require("crypto");
+    import_utils = require("@frontmcp/utils");
     init_interface();
     CacheInitializationError = class extends Error {
       cause;
@@ -124,7 +124,7 @@ var init_filesystem = __esm({
       async initialize() {
         if (this.initialized) return;
         try {
-          await (0, import_promises.mkdir)(this.options.cacheDir, { recursive: true });
+          await (0, import_utils.mkdir)(this.options.cacheDir, { recursive: true });
           await this.loadStats();
           this.initialized = true;
         } catch (error) {
@@ -143,7 +143,7 @@ var init_filesystem = __esm({
             this.updateHitRate();
             return void 0;
           }
-          const content = await (0, import_promises.readFile)(filePath, "utf8");
+          const content = await (0, import_utils.readFile)(filePath, "utf8");
           const entry = JSON.parse(content);
           if (Date.now() > entry.metadata.expiresAt) {
             await this.delete(key);
@@ -199,7 +199,7 @@ var init_filesystem = __esm({
         const filePath = this.getFilePath(key);
         try {
           if (!(0, import_fs.existsSync)(filePath)) return false;
-          const content = await (0, import_promises.readFile)(filePath, "utf8");
+          const content = await (0, import_utils.readFile)(filePath, "utf8");
           const entry = JSON.parse(content);
           if (Date.now() > entry.metadata.expiresAt) {
             await this.delete(key);
@@ -218,9 +218,9 @@ var init_filesystem = __esm({
         const filePath = this.getFilePath(key);
         try {
           if (!(0, import_fs.existsSync)(filePath)) return false;
-          const content = await (0, import_promises.readFile)(filePath, "utf8");
+          const content = await (0, import_utils.readFile)(filePath, "utf8");
           const entry = JSON.parse(content);
-          await (0, import_promises.unlink)(filePath);
+          await (0, import_utils.unlink)(filePath);
           this.stats.entries = Math.max(0, this.stats.entries - 1);
           this.stats.totalSize = Math.max(0, this.stats.totalSize - entry.metadata.size);
           return true;
@@ -234,8 +234,8 @@ var init_filesystem = __esm({
       async clear() {
         this.ensureInitialized();
         try {
-          await (0, import_promises.rm)(this.options.cacheDir, { recursive: true, force: true });
-          await (0, import_promises.mkdir)(this.options.cacheDir, { recursive: true });
+          await (0, import_utils.rm)(this.options.cacheDir, { recursive: true, force: true });
+          await (0, import_utils.mkdir)(this.options.cacheDir, { recursive: true });
           this.stats = {
             entries: 0,
             totalSize: 0,
@@ -260,21 +260,21 @@ var init_filesystem = __esm({
         this.ensureInitialized();
         let removed = 0;
         try {
-          const files = await (0, import_promises.readdir)(this.options.cacheDir);
+          const files = await (0, import_utils.readdir)(this.options.cacheDir);
           for (const file of files) {
             if (!file.endsWith(this.options.extension)) continue;
             const filePath = (0, import_path.join)(this.options.cacheDir, file);
             try {
-              const content = await (0, import_promises.readFile)(filePath, "utf8");
+              const content = await (0, import_utils.readFile)(filePath, "utf8");
               const entry = JSON.parse(content);
               if (Date.now() > entry.metadata.expiresAt) {
-                await (0, import_promises.unlink)(filePath);
+                await (0, import_utils.unlink)(filePath);
                 this.stats.entries = Math.max(0, this.stats.entries - 1);
                 this.stats.totalSize = Math.max(0, this.stats.totalSize - entry.metadata.size);
                 removed++;
               }
             } catch {
-              await (0, import_promises.unlink)(filePath).catch(() => {
+              await (0, import_utils.unlink)(filePath).catch(() => {
               });
               removed++;
             }
@@ -300,8 +300,8 @@ var init_filesystem = __esm({
        * Write a cache entry to disk.
        */
       async writeEntry(filePath, entry) {
-        await (0, import_promises.mkdir)((0, import_path.dirname)(filePath), { recursive: true });
-        await (0, import_promises.writeFile)(filePath, JSON.stringify(entry, null, 2), "utf8");
+        await (0, import_utils.mkdir)((0, import_path.dirname)(filePath), { recursive: true });
+        await (0, import_utils.writeFile)(filePath, JSON.stringify(entry, null, 2));
       }
       /**
        * Ensure the storage is initialized.
@@ -317,14 +317,14 @@ var init_filesystem = __esm({
        */
       async loadStats() {
         try {
-          const files = await (0, import_promises.readdir)(this.options.cacheDir);
+          const files = await (0, import_utils.readdir)(this.options.cacheDir);
           let entries = 0;
           let totalSize = 0;
           for (const file of files) {
             if (!file.endsWith(this.options.extension)) continue;
             const filePath = (0, import_path.join)(this.options.cacheDir, file);
             try {
-              const content = await (0, import_promises.readFile)(filePath, "utf8");
+              const content = await (0, import_utils.readFile)(filePath, "utf8");
               const entry = JSON.parse(content);
               entries++;
               totalSize += entry.metadata.size;
@@ -353,7 +353,7 @@ var init_filesystem = __esm({
        */
       async evictLRU() {
         try {
-          const files = await (0, import_promises.readdir)(this.options.cacheDir);
+          const files = await (0, import_utils.readdir)(this.options.cacheDir);
           let oldestKey = null;
           let oldestTime = Infinity;
           let corruptedFile = null;
@@ -361,7 +361,7 @@ var init_filesystem = __esm({
             if (!file.endsWith(this.options.extension)) continue;
             const filePath = (0, import_path.join)(this.options.cacheDir, file);
             try {
-              const content = await (0, import_promises.readFile)(filePath, "utf8");
+              const content = await (0, import_utils.readFile)(filePath, "utf8");
               const entry = JSON.parse(content);
               if (entry.metadata.lastAccessedAt < oldestTime) {
                 oldestTime = entry.metadata.lastAccessedAt;
@@ -373,7 +373,7 @@ var init_filesystem = __esm({
           }
           if (corruptedFile) {
             try {
-              await (0, import_promises.unlink)(corruptedFile);
+              await (0, import_utils.unlink)(corruptedFile);
               this.stats.entries = Math.max(0, this.stats.entries - 1);
               return true;
             } catch {
@@ -1462,9 +1462,9 @@ init_redis();
 
 // libs/uipack/src/bundler/file-cache/hash-calculator.ts
 var import_crypto2 = require("crypto");
-var import_promises2 = require("fs/promises");
 var import_fs2 = require("fs");
 var import_path2 = require("path");
+var import_utils2 = require("@frontmcp/utils");
 function sha256(content) {
   return (0, import_crypto2.createHash)("sha256").update(content, "utf8").digest("hex");
 }
@@ -1473,7 +1473,7 @@ function sha256Buffer(buffer) {
 }
 async function hashFile(filePath) {
   try {
-    const content = await (0, import_promises2.readFile)(filePath);
+    const content = await (0, import_utils2.readFileBuffer)(filePath);
     return sha256Buffer(content);
   } catch {
     return void 0;
@@ -1534,7 +1534,7 @@ async function collectLocalDependencies(filePath, baseDir, collected, maxDepth,
   if (!(0, import_fs2.existsSync)(filePath)) return;
   collected.add(filePath);
   try {
-    const content = await (0, import_promises2.readFile)(filePath, "utf8");
+    const content = await (0, import_utils2.readFile)(filePath);
     const imports = extractImportPaths(content);
     for (const importPath of imports) {
       if (!importPath.startsWith(".") && !importPath.startsWith("/")) {
@@ -1608,10 +1608,10 @@ function buildIdFromHash(hash) {
 }
 
 // libs/uipack/src/bundler/file-cache/component-builder.ts
-var import_promises3 = require("fs/promises");
 var import_fs3 = require("fs");
 var import_path3 = require("path");
 var import_crypto3 = require("crypto");
+var import_utils5 = require("@frontmcp/utils");
 
 // libs/uipack/src/dependency/cdn-registry.ts
 var DEFAULT_CDN_REGISTRY = {
@@ -2374,10 +2374,8 @@ function parseImports(source) {
   };
 }
 
-// libs/uipack/src/utils/escape-html.ts
-function escapeHtmlAttr(str) {
-  return str.replace(/&/g, "&amp;").replace(/"/g, "&quot;");
-}
+// libs/uipack/src/utils/index.ts
+var import_utils3 = require("@frontmcp/utils");
 
 // libs/uipack/src/dependency/import-map.ts
 function createImportMap(dependencies) {
@@ -2424,13 +2422,16 @@ function generateUMDShim(dependencies, options = {}) {
     console.warn('UMD shim failed:', e);
   }
 })();` : `window.__esm_shim = ${shimObject};`;
-  return minify ? code.replace(/\s+/g, " ").replace(/\s*([{},:])\s*/g, "$1") : code;
+  if (minify && code.length <= 1e5) {
+    return code.replace(/\s+/g, " ").replace(/\s*([{},:])\s*/g, "$1");
+  }
+  return code;
 }
 function generateCDNScriptTags(dependencies) {
   return dependencies.filter((dep) => !dep.esm).map((dep) => {
-    const attrs = [`src="${escapeHtmlAttr(dep.cdnUrl)}"`];
+    const attrs = [`src="${(0, import_utils3.escapeHtmlAttr)(dep.cdnUrl)}"`];
     if (dep.integrity) {
-      attrs.push(`integrity="${escapeHtmlAttr(dep.integrity)}"`);
+      attrs.push(`integrity="${(0, import_utils3.escapeHtmlAttr)(dep.integrity)}"`);
     }
     attrs.push('crossorigin="anonymous"');
     return `<script ${attrs.join(" ")}></script>`;
@@ -2438,9 +2439,9 @@ function generateCDNScriptTags(dependencies) {
 }
 function generateESMScriptTags(dependencies) {
   return dependencies.filter((dep) => dep.esm).map((dep) => {
-    const attrs = ['type="module"', `src="${escapeHtmlAttr(dep.cdnUrl)}"`];
+    const attrs = ['type="module"', `src="${(0, import_utils3.escapeHtmlAttr)(dep.cdnUrl)}"`];
     if (dep.integrity) {
-      attrs.push(`integrity="${escapeHtmlAttr(dep.integrity)}"`);
+      attrs.push(`integrity="${(0, import_utils3.escapeHtmlAttr)(dep.integrity)}"`);
     }
     attrs.push('crossorigin="anonymous"');
     return `<script ${attrs.join(" ")}></script>`;
@@ -2681,7 +2682,7 @@ var ComponentBuilder = class {
     } = options;
     const absoluteEntryPath = (0, import_path3.resolve)(entryPath);
     if (!(0, import_fs3.existsSync)(absoluteEntryPath)) {
-      throw new Error(`Entry file not found: ${absoluteEntryPath}`);
+      throw new Error(`Entry file not found: ${(0, import_path3.basename)(absoluteEntryPath)}`);
     }
     const hashResult = await calculateComponentHash({
       entryPath: absoluteEntryPath,
@@ -2699,7 +2700,7 @@ var ComponentBuilder = class {
         };
       }
     }
-    const source = await (0, import_promises3.readFile)(absoluteEntryPath, "utf8");
+    const source = await (0, import_utils5.readFile)(absoluteEntryPath, "utf8");
     const resolver = new DependencyResolver({ platform });
     const resolvedDeps = [];
     for (const pkg of externals) {
@@ -2855,7 +2856,10 @@ var ComponentBuilder = class {
         bundlerVersion: this.esbuild.version
       };
     } catch (error) {
-      throw new Error(`Bundle failed for ${entryPath}: ${error}`);
+      const fileName = (0, import_path3.basename)(entryPath);
+      const rawMessage = error instanceof Error ? error.message : String(error);
+      const sanitizedMessage = rawMessage.replace(/(?:\/[\w./-]+|[A-Z]:\\[\w.\\-]+)/g, (match) => (0, import_path3.basename)(match));
+      throw new Error(`Bundle failed for ${fileName}: ${sanitizedMessage}`);
     }
   }
   /**

package/dependency/import-map.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"import-map.d.ts","sourceRoot":"","sources":["../../src/dependency/import-map.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AAEH,OAAO,KAAK,EAAE,SAAS,EAAE,kBAAkB,EAAE,aAAa,EAAE,MAAM,SAAS,CAAC;AAO5E;;;;;;;;;;;;;;;;;;;GAmBG;AACH,wBAAgB,eAAe,CAAC,YAAY,EAAE,kBAAkB,EAAE,GAAG,SAAS,CAgB7E;AAED;;;;;GAKG;AACH,wBAAgB,4BAA4B,CAAC,YAAY,EAAE,MAAM,CAAC,MAAM,EAAE,aAAa,CAAC,GAAG,SAAS,CAgBnG;AAED;;;;;;;GAOG;AACH,wBAAgB,eAAe,CAAC,GAAG,IAAI,EAAE,SAAS,EAAE,GAAG,SAAS,CAwB/D;AAED;;;;;;;;;GASG;AACH,wBAAgB,QAAQ,CAAC,GAAG,EAAE,SAAS,EAAE,QAAQ,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,GAAG,SAAS,CAQtG;AAMD;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,0BAA0B,CAAC,GAAG,EAAE,SAAS,GAAG,MAAM,CAIjE;AAED;;;;;GAKG;AACH,wBAAgB,kCAAkC,CAAC,GAAG,EAAE,SAAS,GAAG,MAAM,CAIzE;AAED;;GAEG;AACH,MAAM,WAAW,cAAc;IAC7B;;;OAGG;IACH,IAAI,CAAC,EAAE,OAAO,CAAC;IAEf;;;OAGG;IACH,MAAM,CAAC,EAAE,OAAO,CAAC;CAClB;AAED;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,wBAAgB,eAAe,CAAC,YAAY,EAAE,kBAAkB,EAAE,EAAE,OAAO,GAAE,cAAmB,GAAG,MAAM,CA4BxG;AAED;;;;;GAKG;AACH,wBAAgB,qBAAqB,CAAC,YAAY,EAAE,kBAAkB,EAAE,GAAG,MAAM,EAAE,CAclF;AAED;;;;;GAKG;AACH,wBAAgB,qBAAqB,CAAC,YAAY,EAAE,kBAAkB,EAAE,GAAG,MAAM,EAAE,CAclF;AAED;;GAEG;AACH,MAAM,WAAW,qBAAqB;IACpC;;;OAGG;IACH,MAAM,CAAC,EAAE,OAAO,CAAC;IAEjB;;;OAGG;IACH,WAAW,CAAC,EAAE,OAAO,CAAC;IAEtB;;;OAGG;IACH,KAAK,CAAC,EAAE,OAAO,CAAC;CACjB;AAED;;;;;;;;;;;;;;;;;;GAkBG;AACH,wBAAgB,sBAAsB,CACpC,YAAY,EAAE,kBAAkB,EAAE,EAClC,OAAO,GAAE,qBAA0B,GAClC,MAAM,CA2BR;AAMD;;;;;GAKG;AACH,wBAAgB,iBAAiB,CAAC,GAAG,EAAE,OAAO,GAAG;IAAE,KAAK,EAAE,OAAO,CAAC;IAAC,MAAM,EAAE,MAAM,EAAE,CAAA;CAAE,CAiDpF"}
+{"version":3,"file":"import-map.d.ts","sourceRoot":"","sources":["../../src/dependency/import-map.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AAEH,OAAO,KAAK,EAAE,SAAS,EAAE,kBAAkB,EAAE,aAAa,EAAE,MAAM,SAAS,CAAC;AAO5E;;;;;;;;;;;;;;;;;;;GAmBG;AACH,wBAAgB,eAAe,CAAC,YAAY,EAAE,kBAAkB,EAAE,GAAG,SAAS,CAgB7E;AAED;;;;;GAKG;AACH,wBAAgB,4BAA4B,CAAC,YAAY,EAAE,MAAM,CAAC,MAAM,EAAE,aAAa,CAAC,GAAG,SAAS,CAgBnG;AAED;;;;;;;GAOG;AACH,wBAAgB,eAAe,CAAC,GAAG,IAAI,EAAE,SAAS,EAAE,GAAG,SAAS,CAwB/D;AAED;;;;;;;;;GASG;AACH,wBAAgB,QAAQ,CAAC,GAAG,EAAE,SAAS,EAAE,QAAQ,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,GAAG,SAAS,CAQtG;AAMD;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,0BAA0B,CAAC,GAAG,EAAE,SAAS,GAAG,MAAM,CAIjE;AAED;;;;;GAKG;AACH,wBAAgB,kCAAkC,CAAC,GAAG,EAAE,SAAS,GAAG,MAAM,CAIzE;AAED;;GAEG;AACH,MAAM,WAAW,cAAc;IAC7B;;;OAGG;IACH,IAAI,CAAC,EAAE,OAAO,CAAC;IAEf;;;OAGG;IACH,MAAM,CAAC,EAAE,OAAO,CAAC;CAClB;AAED;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,wBAAgB,eAAe,CAAC,YAAY,EAAE,kBAAkB,EAAE,EAAE,OAAO,GAAE,cAAmB,GAAG,MAAM,CAgCxG;AAED;;;;;GAKG;AACH,wBAAgB,qBAAqB,CAAC,YAAY,EAAE,kBAAkB,EAAE,GAAG,MAAM,EAAE,CAclF;AAED;;;;;GAKG;AACH,wBAAgB,qBAAqB,CAAC,YAAY,EAAE,kBAAkB,EAAE,GAAG,MAAM,EAAE,CAclF;AAED;;GAEG;AACH,MAAM,WAAW,qBAAqB;IACpC;;;OAGG;IACH,MAAM,CAAC,EAAE,OAAO,CAAC;IAEjB;;;OAGG;IACH,WAAW,CAAC,EAAE,OAAO,CAAC;IAEtB;;;OAGG;IACH,KAAK,CAAC,EAAE,OAAO,CAAC;CACjB;AAED;;;;;;;;;;;;;;;;;;GAkBG;AACH,wBAAgB,sBAAsB,CACpC,YAAY,EAAE,kBAAkB,EAAE,EAClC,OAAO,GAAE,qBAA0B,GAClC,MAAM,CA2BR;AAMD;;;;;GAKG;AACH,wBAAgB,iBAAiB,CAAC,GAAG,EAAE,OAAO,GAAG;IAAE,KAAK,EAAE,OAAO,CAAC;IAAC,MAAM,EAAE,MAAM,EAAE,CAAA;CAAE,CAiDpF"}

package/dependency/index.js

@@ -1192,23 +1192,8 @@ function getImportStats(source) {
   };
 }
 
-// libs/uipack/src/utils/escape-html.ts
-function escapeHtml(str) {
-  if (str === null || str === void 0) {
-    return "";
-  }
-  const s = String(str);
-  return s.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;").replace(/'/g, "&#39;").replace(/\u2028/g, "\\u2028").replace(/\u2029/g, "\\u2029");
-}
-function escapeHtmlAttr(str) {
-  return str.replace(/&/g, "&amp;").replace(/"/g, "&quot;");
-}
-function escapeJsString(str) {
-  return str.replace(/\\/g, "\\\\").replace(/'/g, "\\'").replace(/"/g, '\\"').replace(/\n/g, "\\n").replace(/\r/g, "\\r").replace(/\t/g, "\\t").replace(/\u2028/g, "\\u2028").replace(/\u2029/g, "\\u2029");
-}
-function escapeScriptClose(jsonString) {
-  return jsonString.replace(/<\//g, "<\\/");
-}
+// libs/uipack/src/utils/index.ts
+var import_utils = require("@frontmcp/utils");
 
 // libs/uipack/src/dependency/import-map.ts
 function createImportMap(dependencies) {
@@ -1299,13 +1284,16 @@ function generateUMDShim(dependencies, options = {}) {
     console.warn('UMD shim failed:', e);
   }
 })();` : `window.__esm_shim = ${shimObject};`;
-  return minify ? code.replace(/\s+/g, " ").replace(/\s*([{},:])\s*/g, "$1") : code;
+  if (minify && code.length <= 1e5) {
+    return code.replace(/\s+/g, " ").replace(/\s*([{},:])\s*/g, "$1");
+  }
+  return code;
 }
 function generateCDNScriptTags(dependencies) {
   return dependencies.filter((dep) => !dep.esm).map((dep) => {
-    const attrs = [`src="${escapeHtmlAttr(dep.cdnUrl)}"`];
+    const attrs = [`src="${(0, import_utils.escapeHtmlAttr)(dep.cdnUrl)}"`];
     if (dep.integrity) {
-      attrs.push(`integrity="${escapeHtmlAttr(dep.integrity)}"`);
+      attrs.push(`integrity="${(0, import_utils.escapeHtmlAttr)(dep.integrity)}"`);
     }
     attrs.push('crossorigin="anonymous"');
     return `<script ${attrs.join(" ")}></script>`;
@@ -1313,9 +1301,9 @@ function generateCDNScriptTags(dependencies) {
 }
 function generateESMScriptTags(dependencies) {
   return dependencies.filter((dep) => dep.esm).map((dep) => {
-    const attrs = ['type="module"', `src="${escapeHtmlAttr(dep.cdnUrl)}"`];
+    const attrs = ['type="module"', `src="${(0, import_utils.escapeHtmlAttr)(dep.cdnUrl)}"`];
     if (dep.integrity) {
-      attrs.push(`integrity="${escapeHtmlAttr(dep.integrity)}"`);
+      attrs.push(`integrity="${(0, import_utils.escapeHtmlAttr)(dep.integrity)}"`);
     }
     attrs.push('crossorigin="anonymous"');
     return `<script ${attrs.join(" ")}></script>`;
@@ -1598,6 +1586,7 @@ var import_path = require("path");
 
 // libs/uipack/src/bundler/file-cache/hash-calculator.ts
 var import_crypto = require("crypto");
+var import_utils3 = require("@frontmcp/utils");
 function sha256(content) {
   return (0, import_crypto.createHash)("sha256").update(content, "utf8").digest("hex");
 }
@@ -1966,7 +1955,7 @@ function classNames(...classes) {
 }
 var builtinHelpers = {
   // Escaping
-  escapeHtml,
+  escapeHtml: import_utils.escapeHtml,
   // Formatting
   formatDate,
   formatCurrency,
@@ -2279,7 +2268,11 @@ function containsHandlebars(template) {
 }
 
 // libs/uipack/src/renderers/utils/detect.ts
+var MAX_TEMPLATE_LENGTH = 5e4;
 function containsMdxSyntax(source) {
+  if (source.length > MAX_TEMPLATE_LENGTH) {
+    return false;
+  }
   if (/<[A-Z][a-zA-Z0-9]*/.test(source)) {
     return true;
   }
@@ -2566,12 +2559,12 @@ var MdxClientRenderer = class {
       ...outputProps,
       ...props
     };
-    const escapedMdx = escapeScriptClose(JSON.stringify(template));
-    const escapedProps = escapeScriptClose(JSON.stringify(spreadProps));
-    const safeContainerId = escapeJsString(containerId);
-    const loadingHtml = showLoading ? `<div class="mdx-loading">${escapeHtml(loadingMessage)}</div>` : "";
+    const escapedMdx = (0, import_utils.escapeScriptClose)(JSON.stringify(template));
+    const escapedProps = (0, import_utils.escapeScriptClose)(JSON.stringify(spreadProps));
+    const safeContainerId = (0, import_utils.escapeJsString)(containerId);
+    const loadingHtml = showLoading ? `<div class="mdx-loading">${(0, import_utils.escapeHtml)(loadingMessage)}</div>` : "";
     return `
-<div id="${escapeHtml(containerId)}">${loadingHtml}</div>
+<div id="${(0, import_utils.escapeHtml)(containerId)}">${loadingHtml}</div>
 <script type="module">
 (async function() {
   try {
@@ -2912,7 +2905,7 @@ function safeInputToRecord(input) {
   return {};
 }
 var defaultHelpers = {
-  escapeHtml,
+  escapeHtml: import_utils.escapeHtml,
   formatDate: (date, format) => {
     const d = date instanceof Date ? date : new Date(date);
     if (format === "iso") return d.toISOString();

package/esm/adapters/index.mjs

@@ -28,16 +28,13 @@ function buildUIMeta(options) {
     case "generic-mcp":
     case "gemini":
     default:
-      meta["frontmcp/html"] = html;
-      meta["frontmcp/mimeType"] = "text/html+mcp";
-      if (rendererType) meta["frontmcp/type"] = rendererType;
-      if (contentHash) meta["frontmcp/contentHash"] = contentHash;
-      if (manifestUri) meta["frontmcp/manifestUri"] = manifestUri;
-      if (token) meta["frontmcp/widgetToken"] = token;
-      if (directUrl) meta["frontmcp/directUrl"] = directUrl;
       meta["ui/html"] = html;
       meta["ui/mimeType"] = "text/html+mcp";
       if (rendererType) meta["ui/type"] = rendererType;
+      if (contentHash) meta["ui/contentHash"] = contentHash;
+      if (manifestUri) meta["ui/manifestUri"] = manifestUri;
+      if (token) meta["ui/widgetToken"] = token;
+      if (directUrl) meta["ui/directUrl"] = directUrl;
       if (platformType === "claude") {
         return buildClaudeMeta(meta, uiConfig);
       } else if (platformType === "gemini") {
@@ -107,23 +104,36 @@ function buildFrontMCPCSP(csp) {
   return result;
 }
 function buildGenericMeta(meta, uiConfig) {
-  if (uiConfig.widgetAccessible) {
-    meta["frontmcp/widgetAccessible"] = true;
-  }
   if (uiConfig.csp) {
-    meta["frontmcp/widgetCSP"] = buildFrontMCPCSP(uiConfig.csp);
+    const csp = {};
+    if (uiConfig.csp.connectDomains?.length) {
+      csp.connectDomains = uiConfig.csp.connectDomains;
+    }
+    if (uiConfig.csp.resourceDomains?.length) {
+      csp.resourceDomains = uiConfig.csp.resourceDomains;
+    }
+    if (Object.keys(csp).length > 0) {
+      meta["ui/csp"] = csp;
+    }
   }
   if (uiConfig.displayMode) {
-    meta["frontmcp/displayMode"] = uiConfig.displayMode;
-  }
-  if (uiConfig.widgetDescription) {
-    meta["frontmcp/widgetDescription"] = uiConfig.widgetDescription;
+    const displayModeMap = {
+      inline: "inline",
+      fullscreen: "fullscreen",
+      pip: "pip",
+      widget: "inline",
+      panel: "fullscreen"
+    };
+    const mappedMode = displayModeMap[uiConfig.displayMode];
+    if (mappedMode) {
+      meta["ui/displayMode"] = mappedMode;
+    }
   }
   if (uiConfig.prefersBorder !== void 0) {
-    meta["frontmcp/prefersBorder"] = uiConfig.prefersBorder;
+    meta["ui/prefersBorder"] = uiConfig.prefersBorder;
   }
   if (uiConfig.sandboxDomain) {
-    meta["frontmcp/domain"] = uiConfig.sandboxDomain;
+    meta["ui/domain"] = uiConfig.sandboxDomain;
   }
   return meta;
 }
@@ -353,25 +363,15 @@ function platformSupportsWidgets(platformType) {
   return capabilities.supportsWidgets;
 }
 
-// libs/uipack/src/utils/safe-stringify.ts
-function safeStringify(value, space) {
-  const seen = /* @__PURE__ */ new WeakSet();
-  try {
-    return JSON.stringify(
-      value,
-      (_key, val) => {
-        if (typeof val === "object" && val !== null) {
-          if (seen.has(val)) return "[Circular]";
-          seen.add(val);
-        }
-        return val;
-      },
-      space
-    );
-  } catch {
-    return JSON.stringify({ error: "Output could not be serialized" });
-  }
-}
+// libs/uipack/src/utils/index.ts
+import {
+  safeStringify,
+  escapeHtml,
+  escapeHtmlAttr,
+  escapeJsString,
+  escapeScriptClose,
+  safeJsonForScript
+} from "@frontmcp/utils";
 
 // libs/uipack/src/adapters/response-builder.ts
 function buildToolResponseContent(options) {
@@ -394,12 +394,22 @@ function buildToolResponseContent(options) {
   }
   if (useStructuredContent) {
     if (htmlContent) {
-      return {
-        content: [{ type: "text", text: htmlContent }],
-        structuredContent: rawOutput,
-        contentCleared: false,
-        format: "structured-content"
-      };
+      const htmlInContent = platformType === "openai" || platformType === "ext-apps";
+      if (htmlInContent) {
+        return {
+          content: [{ type: "text", text: htmlContent }],
+          structuredContent: rawOutput,
+          contentCleared: false,
+          format: "structured-content"
+        };
+      } else {
+        return {
+          content: [{ type: "text", text: safeStringify(rawOutput) }],
+          structuredContent: rawOutput,
+          contentCleared: false,
+          format: "structured-content"
+        };
+      }
     }
     return {
       content: [{ type: "text", text: safeStringify(rawOutput) }],

package/esm/bridge-runtime/index.mjs

@@ -823,7 +823,11 @@ FrontMcpBridge.prototype._setupDataToolCallHandler = function() {
 };
 `.trim();
 }
+var MAX_MINIFY_CODE_LENGTH = 5e5;
 function minifyJS(code) {
+  if (code.length > MAX_MINIFY_CODE_LENGTH) {
+    return code;
+  }
   return code.replace(/\/\*[\s\S]*?\*\//g, "").replace(/\/\/.*$/gm, "").replace(/\s+/g, " ").replace(/\s*([{};,:()[\]])\s*/g, "$1").replace(/;\}/g, "}").trim();
 }
 function generatePlatformBundle(platform, options = {}) {