@databrainhq/mcp-server 0.3.0-rc.13 → 0.3.0-rc.14

package/dist/{chunk-Q5EYDKSA.js → chunk-2F7V6RZR.js}

@@ -7,10 +7,10 @@ import { join as join2, resolve as resolve2, sep } from "path";
 import { build as esbuild } from "esbuild";
 
 // src/custom-chart/assets.ts
-import { buildSync } from "esbuild";
 import { existsSync, readdirSync, readFileSync, statSync } from "fs";
 import { dirname, join, resolve } from "path";
 import { fileURLToPath } from "url";
+import { buildSync } from "esbuild";
 var cachedDir;
 function customChartAssetDir() {
   if (cachedDir) return cachedDir;
@@ -311,9 +311,10 @@ var cleanAttributes = (element, rawAttributes) => {
   let dropElement = false;
   const kept = [];
   ATTRIBUTE_RE.lastIndex = 0;
-  let match;
-  while ((match = ATTRIBUTE_RE.exec(rawAttributes)) !== null) {
+  let match = ATTRIBUTE_RE.exec(rawAttributes);
+  while (match !== null) {
     const [whole, name, dq, sq, bare] = match;
+    match = ATTRIBUTE_RE.exec(rawAttributes);
     if (!name || name === "/") continue;
     const lower = name.toLowerCase();
     const value = dq ?? sq ?? bare ?? "";
@@ -464,17 +465,47 @@ var MAX_OPTIONS = 32;
 // src/custom-chart/icon.ts
 var UNSAFE = "bundle.icon.unsafe";
 var RULES = [
-  { pattern: /<\s*script\b/i, message: "Remove every <script> element from icon.svg." },
-  { pattern: /<\s*foreignObject\b/i, message: "Remove every <foreignObject> element from icon.svg." },
-  { pattern: /<\s*image\b/i, message: "Remove every <image> element from icon.svg. Draw with paths and shapes." },
-  { pattern: /[\s/]on[a-z]+\s*=/i, message: "Remove every on*= event attribute from icon.svg." },
+  {
+    pattern: /<\s*script\b/i,
+    message: "Remove every <script> element from icon.svg."
+  },
+  {
+    pattern: /<\s*foreignObject\b/i,
+    message: "Remove every <foreignObject> element from icon.svg."
+  },
+  {
+    pattern: /<\s*image\b/i,
+    message: "Remove every <image> element from icon.svg. Draw with paths and shapes."
+  },
+  {
+    pattern: /[\s/]on[a-z]+\s*=/i,
+    message: "Remove every on*= event attribute from icon.svg."
+  },
   { pattern: /<!--/, message: "Remove every <!-- comment --> from icon.svg." },
-  { pattern: /<!(?:ENTITY|DOCTYPE)\b/i, message: "Remove the DOCTYPE and entity declarations from icon.svg." },
-  { pattern: /<!\[CDATA\[/, message: "Remove every CDATA section from icon.svg." },
-  { pattern: /(?:xlink:)?href\s*=\s*["']\s*(?!#)/i, message: "Every href in icon.svg must start with # (no external or data references)." },
-  { pattern: /javascript\s*:/i, message: "Remove every javascript: reference from icon.svg." },
-  { pattern: /@import|expression\s*\(|-moz-binding/i, message: "Remove @import, expression() and -moz-binding from icon.svg styles." },
-  { pattern: /url\s*\(\s*['"]?\s*(?!#)/i, message: "Every url() in icon.svg must point at a same-document #id." }
+  {
+    pattern: /<!(?:ENTITY|DOCTYPE)\b/i,
+    message: "Remove the DOCTYPE and entity declarations from icon.svg."
+  },
+  {
+    pattern: /<!\[CDATA\[/,
+    message: "Remove every CDATA section from icon.svg."
+  },
+  {
+    pattern: /(?:xlink:)?href\s*=\s*["']\s*(?!#)/i,
+    message: "Every href in icon.svg must start with # (no external or data references)."
+  },
+  {
+    pattern: /javascript\s*:/i,
+    message: "Remove every javascript: reference from icon.svg."
+  },
+  {
+    pattern: /@import|expression\s*\(|-moz-binding/i,
+    message: "Remove @import, expression() and -moz-binding from icon.svg styles."
+  },
+  {
+    pattern: /url\s*\(\s*['"]?\s*(?!#)/i,
+    message: "Every url() in icon.svg must point at a same-document #id."
+  }
 ];
 var GENERIC_UNSAFE = "icon.svg must use only plain SVG drawing elements and attributes: no script, event handlers, foreignObject, image, animation, external hrefs, url() styles, comments, DOCTYPE or unknown attributes.";
 var XML_DECLARATION = /^\s*<\?xml[^>]*\?>\s*/i;
@@ -484,18 +515,38 @@ function isSingleSvgRoot(svg) {
 }
 function validateIcon(svg, path = "/icon.svg") {
   if (typeof svg !== "string" || svg.trim().length === 0) {
-    return [{ code: "bundle.icon.required", path, message: "icon.svg is required and must not be empty." }];
+    return [
+      {
+        code: "bundle.icon.required",
+        path,
+        message: "icon.svg is required and must not be empty."
+      }
+    ];
   }
   if (Buffer.byteLength(svg, "utf8") > MAX_ICON_BYTES) {
-    return [{ code: "bundle.icon.size", path, message: `icon.svg must be at most ${MAX_ICON_BYTES} bytes.` }];
+    return [
+      {
+        code: "bundle.icon.size",
+        path,
+        message: `icon.svg must be at most ${MAX_ICON_BYTES} bytes.`
+      }
+    ];
   }
   const cleaned = sanitizeSvg(svg);
   if (!cleaned.isSvg || !isSingleSvgRoot(cleaned.svg)) {
-    return [{ code: "bundle.icon.notSvg", path, message: "icon.svg must be one <svg> element with nothing after it." }];
+    return [
+      {
+        code: "bundle.icon.notSvg",
+        path,
+        message: "icon.svg must be one <svg> element with nothing after it."
+      }
+    ];
   }
   if (cleaned.removed > 0 || /<\s*image\b/i.test(svg)) {
     const rule = RULES.find((candidate) => candidate.pattern.test(svg));
-    return [{ code: UNSAFE, path, message: rule ? rule.message : GENERIC_UNSAFE }];
+    return [
+      { code: UNSAFE, path, message: rule ? rule.message : GENERIC_UNSAFE }
+    ];
   }
   return [];
 }
@@ -559,13 +610,21 @@ var Collector = class {
     let ok = true;
     for (const key of Object.keys(value)) {
       if (!allowed.has(key)) {
-        this.add(`${scope}.unknownKey`, `${path}/${key}`, `Remove "${key}". It is not a known key here.`);
+        this.add(
+          `${scope}.unknownKey`,
+          `${path}/${key}`,
+          `Remove "${key}". It is not a known key here.`
+        );
         ok = false;
       }
     }
     for (const key of required) {
       if (!Object.hasOwn(value, key)) {
-        this.add(missingCode(key), `${path}/${key}`, `Add the required key "${key}".`);
+        this.add(
+          missingCode(key),
+          `${path}/${key}`,
+          `Add the required key "${key}".`
+        );
         ok = false;
       }
     }
@@ -577,29 +636,64 @@ function validateSlot(c, value, path, v2) {
     c.add("manifest.slot.invalid", path, "A slot must be an object.");
     return;
   }
-  if (!c.checkKeys(value, path, "manifest.slot", V1_SLOT_KEYS, v2 ? V2_SLOT_EXTRA_KEYS : [])) return;
+  if (!c.checkKeys(
+    value,
+    path,
+    "manifest.slot",
+    V1_SLOT_KEYS,
+    v2 ? V2_SLOT_EXTRA_KEYS : []
+  ))
+    return;
   if (!isId(value.id)) {
-    c.add("manifest.slot.id", `${path}/id`, "A slot id is lowercase, starts with a letter, and uses only a-z, 0-9, _ and -, up to 64 characters.");
+    c.add(
+      "manifest.slot.id",
+      `${path}/id`,
+      "A slot id is lowercase, starts with a letter, and uses only a-z, 0-9, _ and -, up to 64 characters."
+    );
   }
   if (!isText(value.label)) {
-    c.add("manifest.slot.label", `${path}/label`, `A slot label is 1 to ${MAX_TEXT} characters.`);
+    c.add(
+      "manifest.slot.label",
+      `${path}/label`,
+      `A slot label is 1 to ${MAX_TEXT} characters.`
+    );
   }
   const role = value.role;
   if (role !== "dimension" && role !== "measure") {
-    c.add("manifest.slot.role", `${path}/role`, 'A slot role is "dimension" or "measure".');
+    c.add(
+      "manifest.slot.role",
+      `${path}/role`,
+      'A slot role is "dimension" or "measure".'
+    );
   }
   if (typeof value.required !== "boolean") {
-    c.add("manifest.slot.required", `${path}/required`, "required is true or false.");
+    c.add(
+      "manifest.slot.required",
+      `${path}/required`,
+      "required is true or false."
+    );
   }
   const types = value.types;
   const typesOk = Array.isArray(types) && types.length > 0 && types.length <= 3 && new Set(types).size === types.length && types.every((type) => FIELD_TYPES.includes(type));
   if (!typesOk) {
-    c.add("manifest.slot.types", `${path}/types`, 'types is a list of 1 to 3 distinct values from "string", "number" and "boolean".');
+    c.add(
+      "manifest.slot.types",
+      `${path}/types`,
+      'types is a list of 1 to 3 distinct values from "string", "number" and "boolean".'
+    );
   } else if (role === "measure" && (types.length !== 1 || types[0] !== "number")) {
-    c.add("manifest.slot.types", `${path}/types`, 'A measure slot accepts only ["number"].');
+    c.add(
+      "manifest.slot.types",
+      `${path}/types`,
+      'A measure slot accepts only ["number"].'
+    );
   }
   if (Object.hasOwn(value, "description") && !isText(value.description)) {
-    c.add("manifest.slot.description", `${path}/description`, `A slot description is 1 to ${MAX_TEXT} characters.`);
+    c.add(
+      "manifest.slot.description",
+      `${path}/description`,
+      `A slot description is 1 to ${MAX_TEXT} characters.`
+    );
   }
 }
 function validateOption(c, value, path, v2) {
@@ -609,7 +703,11 @@ function validateOption(c, value, path, v2) {
   }
   const id = value.id;
   if (typeof id === "string" && (id === "theme" || id.startsWith("theme."))) {
-    c.add("manifest.option.reserved", `${path}/id`, 'The option id "theme" (and any id starting with "theme.") is reserved for the host theme.');
+    c.add(
+      "manifest.option.reserved",
+      `${path}/id`,
+      'The option id "theme" (and any id starting with "theme.") is reserved for the host theme.'
+    );
     return;
   }
   const type = typeof value.type === "string" ? value.type : "";
@@ -622,46 +720,89 @@ function validateOption(c, value, path, v2) {
     );
     return;
   }
-  if (!c.checkKeys(value, path, "manifest.option", [...OPTION_BASE_KEYS, ...typeKeys], v2 ? V2_OPTION_EXTRA_KEYS[type] : [])) return;
+  if (!c.checkKeys(
+    value,
+    path,
+    "manifest.option",
+    [...OPTION_BASE_KEYS, ...typeKeys],
+    v2 ? V2_OPTION_EXTRA_KEYS[type] : []
+  ))
+    return;
   if (!isId(id)) {
-    c.add("manifest.option.id", `${path}/id`, "An option id is lowercase, starts with a letter, and uses only a-z, 0-9, _ and -, up to 64 characters.");
+    c.add(
+      "manifest.option.id",
+      `${path}/id`,
+      "An option id is lowercase, starts with a letter, and uses only a-z, 0-9, _ and -, up to 64 characters."
+    );
   }
   if (!isText(value.label)) {
-    c.add("manifest.option.label", `${path}/label`, `An option label is 1 to ${MAX_TEXT} characters.`);
+    c.add(
+      "manifest.option.label",
+      `${path}/label`,
+      `An option label is 1 to ${MAX_TEXT} characters.`
+    );
   }
   if (Object.hasOwn(value, "group") && !isText(value.group, MAX_GROUP)) {
-    c.add("manifest.option.group", `${path}/group`, `An option group is 1 to ${MAX_GROUP} characters.`);
+    c.add(
+      "manifest.option.group",
+      `${path}/group`,
+      `An option group is 1 to ${MAX_GROUP} characters.`
+    );
   }
   switch (type) {
     case "boolean":
       if (typeof value.default !== "boolean") {
-        c.add("manifest.option.default", `${path}/default`, "A boolean default is true or false.");
+        c.add(
+          "manifest.option.default",
+          `${path}/default`,
+          "A boolean default is true or false."
+        );
       }
       break;
     case "number": {
       const rangeOk = isFiniteNumber(value.min) && isFiniteNumber(value.max) && value.min <= value.max;
       if (!rangeOk) {
-        c.add("manifest.option.range", `${path}/min`, "Set finite min and max with min <= max.");
+        c.add(
+          "manifest.option.range",
+          `${path}/min`,
+          "Set finite min and max with min <= max."
+        );
         break;
       }
       const min = value.min;
       const max = value.max;
       if (!isFiniteNumber(value.default) || value.default < min || value.default > max) {
-        c.add("manifest.option.default", `${path}/default`, "A number default is a finite number between min and max.");
+        c.add(
+          "manifest.option.default",
+          `${path}/default`,
+          "A number default is a finite number between min and max."
+        );
       }
       if (Object.hasOwn(value, "step") && (!isFiniteNumber(value.step) || value.step <= 0 || value.step > max - min)) {
-        c.add("manifest.option.step", `${path}/step`, "step is a positive number no larger than max - min.");
+        c.add(
+          "manifest.option.step",
+          `${path}/step`,
+          "step is a positive number no larger than max - min."
+        );
       }
       break;
     }
     case "string": {
       const maxLength = value.maxLength;
       if (!isFiniteNumber(maxLength) || !Number.isInteger(maxLength) || maxLength < 1 || maxLength > MAX_STRING_OPTION_LENGTH) {
-        c.add("manifest.option.maxLength", `${path}/maxLength`, `A string option needs an integer "maxLength" from 1 to ${MAX_STRING_OPTION_LENGTH}.`);
+        c.add(
+          "manifest.option.maxLength",
+          `${path}/maxLength`,
+          `A string option needs an integer "maxLength" from 1 to ${MAX_STRING_OPTION_LENGTH}.`
+        );
         break;
       }
       if (typeof value.default !== "string" || value.default.length > maxLength) {
-        c.add("manifest.option.default", `${path}/default`, "A string default is a string no longer than maxLength.");
+        c.add(
+          "manifest.option.default",
+          `${path}/default`,
+          "A string default is a string no longer than maxLength."
+        );
       }
       break;
     }
@@ -671,17 +812,29 @@ function validateOption(c, value, path, v2) {
         (choice) => isRecord(choice) && Object.keys(choice).length === 2 && isId(choice.value) && isText(choice.label)
       ) && new Set(choices.map((choice) => choice.value)).size === choices.length;
       if (!choicesOk) {
-        c.add("manifest.option.choices", `${path}/choices`, `choices is a list of 1 to ${MAX_CHOICES} distinct { value, label } pairs; a value follows the id rule.`);
+        c.add(
+          "manifest.option.choices",
+          `${path}/choices`,
+          `choices is a list of 1 to ${MAX_CHOICES} distinct { value, label } pairs; a value follows the id rule.`
+        );
         break;
       }
       if (!choices.some((choice) => choice.value === value.default)) {
-        c.add("manifest.option.default", `${path}/default`, "A select default is the value of one of its choices.");
+        c.add(
+          "manifest.option.default",
+          `${path}/default`,
+          "A select default is the value of one of its choices."
+        );
       }
       break;
     }
     case "color":
       if (typeof value.default !== "string" || !COLOR_PATTERN.test(value.default)) {
-        c.add("manifest.option.color", `${path}/default`, 'A color default is a 6 digit hex colour like "#3366cc".');
+        c.add(
+          "manifest.option.color",
+          `${path}/default`,
+          'A color default is a 6 digit hex colour like "#3366cc".'
+        );
       }
       break;
     default:
@@ -691,44 +844,90 @@ function validateOption(c, value, path, v2) {
 function validateTranslations(c, value, slots, options) {
   const path = "/translations";
   if (!isRecord(value)) {
-    c.add("manifest.translations.invalid", path, "translations is an object keyed by language code.");
+    c.add(
+      "manifest.translations.invalid",
+      path,
+      "translations is an object keyed by language code."
+    );
     return;
   }
   for (const [language, entry] of Object.entries(value)) {
     const langPath = `${path}/${language}`;
     if (!LANGUAGE_PATTERN.test(language)) {
-      c.add("manifest.translations.language", langPath, `"${language}" is not a language code like "fr" or "pt-BR".`);
+      c.add(
+        "manifest.translations.language",
+        langPath,
+        `"${language}" is not a language code like "fr" or "pt-BR".`
+      );
       continue;
     }
     if (!isRecord(entry)) {
-      c.add("manifest.translations.invalid", langPath, "A translation is an object with optional name, description, slots and options.");
+      c.add(
+        "manifest.translations.invalid",
+        langPath,
+        "A translation is an object with optional name, description, slots and options."
+      );
       continue;
     }
-    if (!c.checkKeys(entry, langPath, "manifest.translations", [], TRANSLATION_KEYS)) continue;
+    if (!c.checkKeys(
+      entry,
+      langPath,
+      "manifest.translations",
+      [],
+      TRANSLATION_KEYS
+    ))
+      continue;
     for (const key of ["name", "description"]) {
       if (Object.hasOwn(entry, key) && !isTranslationText(entry[key])) {
-        c.add("manifest.translations.text", `${langPath}/${key}`, `A translated string is at most ${MAX_TEXT} characters.`);
+        c.add(
+          "manifest.translations.text",
+          `${langPath}/${key}`,
+          `A translated string is at most ${MAX_TEXT} characters.`
+        );
       }
     }
     if (Object.hasOwn(entry, "slots")) {
       const entrySlots = entry.slots;
       if (!isRecord(entrySlots)) {
-        c.add("manifest.translations.invalid", `${langPath}/slots`, "slots is an object keyed by slot id.");
+        c.add(
+          "manifest.translations.invalid",
+          `${langPath}/slots`,
+          "slots is an object keyed by slot id."
+        );
       } else {
         for (const [slotId, slotEntry] of Object.entries(entrySlots)) {
           const slotPath = `${langPath}/slots/${slotId}`;
           if (!slots.some((slot) => slot.id === slotId)) {
-            c.add("manifest.translations.slot", slotPath, `"${slotId}" is not a slot id in this manifest.`);
+            c.add(
+              "manifest.translations.slot",
+              slotPath,
+              `"${slotId}" is not a slot id in this manifest.`
+            );
             continue;
           }
           if (!isRecord(slotEntry)) {
-            c.add("manifest.translations.invalid", slotPath, "A slot translation is an object with optional label and description.");
+            c.add(
+              "manifest.translations.invalid",
+              slotPath,
+              "A slot translation is an object with optional label and description."
+            );
             continue;
           }
-          if (!c.checkKeys(slotEntry, slotPath, "manifest.translations", [], SLOT_TRANSLATION_KEYS)) continue;
+          if (!c.checkKeys(
+            slotEntry,
+            slotPath,
+            "manifest.translations",
+            [],
+            SLOT_TRANSLATION_KEYS
+          ))
+            continue;
           for (const key of ["label", "description"]) {
             if (Object.hasOwn(slotEntry, key) && !isTranslationText(slotEntry[key])) {
-              c.add("manifest.translations.text", `${slotPath}/${key}`, `A translated string is at most ${MAX_TEXT} characters.`);
+              c.add(
+                "manifest.translations.text",
+                `${slotPath}/${key}`,
+                `A translated string is at most ${MAX_TEXT} characters.`
+              );
             }
           }
         }
@@ -737,37 +936,74 @@ function validateTranslations(c, value, slots, options) {
     if (Object.hasOwn(entry, "options")) {
       const entryOptions = entry.options;
       if (!isRecord(entryOptions)) {
-        c.add("manifest.translations.invalid", `${langPath}/options`, "options is an object keyed by option id.");
+        c.add(
+          "manifest.translations.invalid",
+          `${langPath}/options`,
+          "options is an object keyed by option id."
+        );
       } else {
         for (const [optionId, optionEntry] of Object.entries(entryOptions)) {
           const optionPath = `${langPath}/options/${optionId}`;
           const option = options.find((item) => item.id === optionId);
           if (!option) {
-            c.add("manifest.translations.option", optionPath, `"${optionId}" is not an option id in this manifest.`);
+            c.add(
+              "manifest.translations.option",
+              optionPath,
+              `"${optionId}" is not an option id in this manifest.`
+            );
             continue;
           }
           if (!isRecord(optionEntry)) {
-            c.add("manifest.translations.invalid", optionPath, "An option translation is an object with optional label, group and choices.");
+            c.add(
+              "manifest.translations.invalid",
+              optionPath,
+              "An option translation is an object with optional label, group and choices."
+            );
             continue;
           }
-          if (!c.checkKeys(optionEntry, optionPath, "manifest.translations", [], OPTION_TRANSLATION_KEYS)) continue;
+          if (!c.checkKeys(
+            optionEntry,
+            optionPath,
+            "manifest.translations",
+            [],
+            OPTION_TRANSLATION_KEYS
+          ))
+            continue;
           for (const key of ["label", "group"]) {
             if (Object.hasOwn(optionEntry, key) && !isTranslationText(optionEntry[key])) {
-              c.add("manifest.translations.text", `${optionPath}/${key}`, `A translated string is at most ${MAX_TEXT} characters.`);
+              c.add(
+                "manifest.translations.text",
+                `${optionPath}/${key}`,
+                `A translated string is at most ${MAX_TEXT} characters.`
+              );
             }
           }
           if (!Object.hasOwn(optionEntry, "choices")) continue;
           const choices = optionEntry.choices;
           if (!isRecord(choices)) {
-            c.add("manifest.translations.invalid", `${optionPath}/choices`, "choices is an object keyed by choice value.");
+            c.add(
+              "manifest.translations.invalid",
+              `${optionPath}/choices`,
+              "choices is an object keyed by choice value."
+            );
             continue;
           }
           for (const [choiceValue, label] of Object.entries(choices)) {
             const choicePath = `${optionPath}/choices/${choiceValue}`;
-            if (option.type !== "select" || !(option.choices ?? []).some((choice) => choice.value === choiceValue)) {
-              c.add("manifest.translations.choice", choicePath, `"${choiceValue}" is not a choice of option "${optionId}".`);
+            if (option.type !== "select" || !(option.choices ?? []).some(
+              (choice) => choice.value === choiceValue
+            )) {
+              c.add(
+                "manifest.translations.choice",
+                choicePath,
+                `"${choiceValue}" is not a choice of option "${optionId}".`
+              );
             } else if (!isTranslationText(label)) {
-              c.add("manifest.translations.text", choicePath, `A translated string is at most ${MAX_TEXT} characters.`);
+              c.add(
+                "manifest.translations.text",
+                choicePath,
+                `A translated string is at most ${MAX_TEXT} characters.`
+              );
             }
           }
         }
@@ -783,24 +1019,51 @@ function validateManifest(value) {
   }
   const schemaVersion = value.schemaVersion;
   if (schemaVersion !== 1 && schemaVersion !== 2) {
-    c.add("manifest.schemaVersion.unsupported", "/schemaVersion", "schemaVersion must be 1 or 2.");
+    c.add(
+      "manifest.schemaVersion.unsupported",
+      "/schemaVersion",
+      "schemaVersion must be 1 or 2."
+    );
     return c.problems;
   }
   const v2 = schemaVersion === 2;
-  if (!c.checkKeys(value, "", "manifest", V1_TOP_KEYS, v2 ? V2_TOP_EXTRA_KEYS : [], (key) => `manifest.${key}.required`)) {
+  if (!c.checkKeys(
+    value,
+    "",
+    "manifest",
+    V1_TOP_KEYS,
+    v2 ? V2_TOP_EXTRA_KEYS : [],
+    (key) => `manifest.${key}.required`
+  )) {
     return c.problems;
   }
   if (!isId(value.id)) {
-    c.add("manifest.id.invalid", "/id", 'id is lowercase, starts with a letter, and uses only a-z, 0-9, _ and -, up to 64 characters. It becomes the chart type "custom:<id>".');
+    c.add(
+      "manifest.id.invalid",
+      "/id",
+      'id is lowercase, starts with a letter, and uses only a-z, 0-9, _ and -, up to 64 characters. It becomes the chart type "custom:<id>".'
+    );
   }
   if (!isText(value.name)) {
-    c.add("manifest.name.invalid", "/name", `name is 1 to ${MAX_TEXT} characters.`);
+    c.add(
+      "manifest.name.invalid",
+      "/name",
+      `name is 1 to ${MAX_TEXT} characters.`
+    );
   }
   if (Object.hasOwn(value, "version") && (typeof value.version !== "string" || !SEMVER_PATTERN.test(value.version))) {
-    c.add("manifest.version.invalid", "/version", 'version is a semver string like "1.2.0".');
+    c.add(
+      "manifest.version.invalid",
+      "/version",
+      'version is a semver string like "1.2.0".'
+    );
   }
   if (Object.hasOwn(value, "description") && !isText(value.description, MAX_DESCRIPTION)) {
-    c.add("manifest.description.invalid", "/description", `description is 1 to ${MAX_DESCRIPTION} characters.`);
+    c.add(
+      "manifest.description.invalid",
+      "/description",
+      `description is 1 to ${MAX_DESCRIPTION} characters.`
+    );
   }
   const slots = value.slots;
   if (!Array.isArray(slots)) {
@@ -808,30 +1071,54 @@ function validateManifest(value) {
   } else if (slots.length === 0) {
     c.add("manifest.slots.empty", "/slots", "Declare at least one slot.");
   } else if (slots.length > MAX_SLOTS) {
-    c.add("manifest.slots.tooMany", "/slots", `Declare at most ${MAX_SLOTS} slots.`);
+    c.add(
+      "manifest.slots.tooMany",
+      "/slots",
+      `Declare at most ${MAX_SLOTS} slots.`
+    );
   } else {
-    slots.forEach((slot, index) => validateSlot(c, slot, `/slots/${index}`, v2));
+    for (const [index, slot] of slots.entries()) {
+      validateSlot(c, slot, `/slots/${index}`, v2);
+    }
     const seen = /* @__PURE__ */ new Set();
     slots.forEach((slot, index) => {
       if (!isRecord(slot) || typeof slot.id !== "string") return;
       if (seen.has(slot.id)) {
-        c.add("manifest.slot.duplicate", `/slots/${index}/id`, `Slot id "${slot.id}" is used more than once.`);
+        c.add(
+          "manifest.slot.duplicate",
+          `/slots/${index}/id`,
+          `Slot id "${slot.id}" is used more than once.`
+        );
       }
       seen.add(slot.id);
     });
   }
   const options = value.options;
   if (!Array.isArray(options)) {
-    c.add("manifest.options.invalid", "/options", "options must be an array (it may be empty).");
+    c.add(
+      "manifest.options.invalid",
+      "/options",
+      "options must be an array (it may be empty)."
+    );
   } else if (options.length > MAX_OPTIONS) {
-    c.add("manifest.options.tooMany", "/options", `Declare at most ${MAX_OPTIONS} options.`);
+    c.add(
+      "manifest.options.tooMany",
+      "/options",
+      `Declare at most ${MAX_OPTIONS} options.`
+    );
   } else {
-    options.forEach((option, index) => validateOption(c, option, `/options/${index}`, v2));
+    for (const [index, option] of options.entries()) {
+      validateOption(c, option, `/options/${index}`, v2);
+    }
     const seen = /* @__PURE__ */ new Set();
     options.forEach((option, index) => {
       if (!isRecord(option) || typeof option.id !== "string") return;
       if (seen.has(option.id)) {
-        c.add("manifest.option.duplicate", `/options/${index}/id`, `Option id "${option.id}" is used more than once.`);
+        c.add(
+          "manifest.option.duplicate",
+          `/options/${index}/id`,
+          `Option id "${option.id}" is used more than once.`
+        );
       }
       seen.add(option.id);
     });
@@ -845,7 +1132,11 @@ function validateManifest(value) {
     );
   }
   if (c.problems.length === 0 && jsonBytes(value) > MAX_MANIFEST_BYTES) {
-    c.add("manifest.size", "", `manifest.json must be at most ${MAX_MANIFEST_BYTES} bytes as JSON.`);
+    c.add(
+      "manifest.size",
+      "",
+      `manifest.json must be at most ${MAX_MANIFEST_BYTES} bytes as JSON.`
+    );
   }
   return c.problems;
 }
@@ -877,13 +1168,14 @@ var manifestSchema = z.object({
   description: z.string().optional(),
   slots: z.array(slotSchema),
   options: z.array(optionSchema),
-  translations: z.record(z.unknown()).optional()
+  translations: z.record(z.string(), z.unknown()).optional()
 });
 function sortKeys(value) {
   if (Array.isArray(value)) return value.map((item) => sortKeys(item));
   if (isRecord(value)) {
     const out = {};
-    for (const key of Object.keys(value).sort()) out[key] = sortKeys(value[key]);
+    for (const key of Object.keys(value).sort())
+      out[key] = sortKeys(value[key]);
     return out;
   }
   return value;
@@ -891,14 +1183,22 @@ function sortKeys(value) {
 
 // src/custom-chart/zip.ts
 import { strFromU8, strToU8, unzipSync, zipSync } from "fflate";
-var BUNDLE_ZIP_FILES = ["index.js", "manifest.json", "icon.svg", "index.css"];
+var BUNDLE_ZIP_FILES = [
+  "index.js",
+  "manifest.json",
+  "icon.svg",
+  "index.css"
+];
 function writeBundleZip(files) {
   const entries = {};
   for (const name of BUNDLE_ZIP_FILES) {
     const content = files[name];
     if (typeof content === "string") entries[name] = strToU8(content);
   }
-  return zipSync(entries, { level: 6, mtime: /* @__PURE__ */ new Date("2000-01-01T00:00:00Z") });
+  return zipSync(entries, {
+    level: 6,
+    mtime: /* @__PURE__ */ new Date("2000-01-01T00:00:00Z")
+  });
 }
 
 // src/custom-chart/bundle.ts
@@ -919,9 +1219,17 @@ function validateBundle(input) {
   const problems = validateManifest(input.manifest);
   if (input.bundleJs !== void 0) {
     if (typeof input.bundleJs !== "string") {
-      problems.push({ code: "bundle.js.type", path: "/bundleJs", message: "bundleJs must be a string." });
+      problems.push({
+        code: "bundle.js.type",
+        path: "/bundleJs",
+        message: "bundleJs must be a string."
+      });
     } else if (input.bundleJs.trim().length === 0) {
-      problems.push({ code: "bundle.js.empty", path: "/bundleJs", message: "bundleJs must contain JavaScript." });
+      problems.push({
+        code: "bundle.js.empty",
+        path: "/bundleJs",
+        message: "bundleJs must contain JavaScript."
+      });
     } else if (utf8Bytes(input.bundleJs) > MAX_BUNDLE_JS_BYTES) {
       problems.push({
         code: "bundle.js.size",
@@ -932,7 +1240,11 @@ function validateBundle(input) {
   }
   if (input.bundleCss !== void 0) {
     if (typeof input.bundleCss !== "string") {
-      problems.push({ code: "bundle.css.type", path: "/bundleCss", message: "bundleCss must be a string when present." });
+      problems.push({
+        code: "bundle.css.type",
+        path: "/bundleCss",
+        message: "bundleCss must be a string when present."
+      });
     } else if (utf8Bytes(input.bundleCss) > MAX_BUNDLE_CSS_BYTES) {
       problems.push({
         code: "bundle.css.size",
@@ -941,7 +1253,8 @@ function validateBundle(input) {
       });
     }
   }
-  if (input.iconSvg !== void 0) problems.push(...validateIcon(input.iconSvg, "/iconSvg"));
+  if (input.iconSvg !== void 0)
+    problems.push(...validateIcon(input.iconSvg, "/iconSvg"));
   return problems;
 }
 function readProject(dirInput) {
@@ -950,7 +1263,11 @@ function readProject(dirInput) {
   const project = { dir, manifest: void 0, problems };
   const manifestPath = join2(dir, "manifest.json");
   if (!existsSync2(manifestPath)) {
-    problems.push({ code: "project.manifest.missing", path: "/manifest.json", message: `No manifest.json in ${dir}.` });
+    problems.push({
+      code: "project.manifest.missing",
+      path: "/manifest.json",
+      message: `No manifest.json in ${dir}.`
+    });
   } else {
     project.manifestText = readFileSync2(manifestPath, "utf8");
     try {
@@ -965,7 +1282,11 @@ function readProject(dirInput) {
   }
   const entry = ["chart.ts", "chart.js"].map((name) => join2(dir, name)).find((path) => existsSync2(path));
   if (!entry) {
-    problems.push({ code: "project.chart.missing", path: "/chart.ts", message: `No chart.ts in ${dir}. It must export render(ctx).` });
+    problems.push({
+      code: "project.chart.missing",
+      path: "/chart.ts",
+      message: `No chart.ts in ${dir}. It must export render(ctx).`
+    });
   } else {
     project.chartEntry = entry;
   }
@@ -973,7 +1294,11 @@ function readProject(dirInput) {
   if (existsSync2(cssPath)) project.css = readFileSync2(cssPath, "utf8");
   const iconPath = join2(dir, "icon.svg");
   if (!existsSync2(iconPath)) {
-    problems.push({ code: "bundle.icon.required", path: "/icon.svg", message: `No icon.svg in ${dir}.` });
+    problems.push({
+      code: "bundle.icon.required",
+      path: "/icon.svg",
+      message: `No icon.svg in ${dir}.`
+    });
   } else {
     project.icon = readFileSync2(iconPath, "utf8");
   }
@@ -994,21 +1319,34 @@ function readProject(dirInput) {
 function validateProject(dir) {
   const project = readProject(dir);
   const problems = [...project.problems];
-  if (project.manifest !== void 0) problems.push(...validateManifest(project.manifest));
-  if (project.icon !== void 0) problems.push(...validateIcon(sanitizeIcon(project.icon)));
+  if (project.manifest !== void 0)
+    problems.push(...validateManifest(project.manifest));
+  if (project.icon !== void 0)
+    problems.push(...validateIcon(sanitizeIcon(project.icon)));
   if (project.css !== void 0 && utf8Bytes(project.css) > MAX_BUNDLE_CSS_BYTES) {
-    problems.push({ code: "bundle.css.size", path: "/chart.css", message: `chart.css must be at most ${MAX_BUNDLE_CSS_BYTES} bytes.` });
+    problems.push({
+      code: "bundle.css.size",
+      path: "/chart.css",
+      message: `chart.css must be at most ${MAX_BUNDLE_CSS_BYTES} bytes.`
+    });
   }
   return { ok: problems.length === 0, problems, project };
 }
-var DIST_FILES = ["index.js", "manifest.json", "icon.svg", "index.css", "bundle.zip"];
+var DIST_FILES = [
+  "index.js",
+  "manifest.json",
+  "icon.svg",
+  "index.css",
+  "bundle.zip"
+];
 function insideProjectOnly(dir) {
   const root = dir.endsWith(sep) ? dir : `${dir}${sep}`;
   return {
     name: "databrain-inside-project-only",
     setup(build) {
       build.onResolve({ filter: /.*/ }, async (args) => {
-        if (args.kind === "entry-point" || args.pluginData?.databrainChecked) return void 0;
+        if (args.kind === "entry-point" || args.pluginData?.databrainChecked)
+          return void 0;
         const resolved = await build.resolve(args.path, {
           kind: args.kind,
           resolveDir: args.resolveDir,
@@ -1016,7 +1354,8 @@ function insideProjectOnly(dir) {
           pluginData: { databrainChecked: true }
         });
         if (resolved.errors.length > 0) return { errors: resolved.errors };
-        if (resolved.external || resolved.path.startsWith(root)) return resolved;
+        if (resolved.external || resolved.path.startsWith(root))
+          return resolved;
         return {
           errors: [
             {
@@ -1072,10 +1411,18 @@ async function buildProject(dir, options = {}) {
     if (Array.isArray(errors) && errors.length > 0) {
       for (const error of errors) {
         const where = error.location ? `${error.location.file ?? "chart.ts"}:${error.location.line ?? 0}` : "chart.ts";
-        problems.push({ code: "bundle.build.failed", path: `/${where}`, message: error.text });
+        problems.push({
+          code: "bundle.build.failed",
+          path: `/${where}`,
+          message: error.text
+        });
       }
     } else {
-      problems.push({ code: "bundle.build.failed", path: "/chart.ts", message: err.message });
+      problems.push({
+        code: "bundle.build.failed",
+        path: "/chart.ts",
+        message: err.message
+      });
     }
     return { ok: false, problems, written: [] };
   }
@@ -1101,7 +1448,8 @@ globalThis.__dbnCustomChart=__dbnCustomChart;
   if (options.write !== false) {
     const dist = join2(project.dir, "dist");
     mkdirSync(dist, { recursive: true });
-    const manifestJson = JSON.stringify(manifest, null, 2) + "\n";
+    const manifestJson = `${JSON.stringify(manifest, null, 2)}
+`;
     const write = (name, content) => {
       const path = join2(dist, name);
       writeFileSync(path, content);
@@ -1129,7 +1477,11 @@ function readDist(dir) {
   const need = ["index.js", "manifest.json", "icon.svg"];
   for (const name of need) {
     if (!existsSync2(join2(dist, name))) {
-      problems.push({ code: "project.dist.missing", path: `/dist/${name}`, message: `dist/${name} is missing. Run databrain custom-chart build first.` });
+      problems.push({
+        code: "project.dist.missing",
+        path: `/dist/${name}`,
+        message: `dist/${name} is missing. Run databrain custom-chart build first.`
+      });
     }
   }
   if (problems.length > 0) return { problems };
@@ -1137,7 +1489,15 @@ function readDist(dir) {
   try {
     manifest = JSON.parse(readFileSync2(join2(dist, "manifest.json"), "utf8"));
   } catch (err) {
-    return { problems: [{ code: "project.dist.parse", path: "/dist/manifest.json", message: err.message }] };
+    return {
+      problems: [
+        {
+          code: "project.dist.parse",
+          path: "/dist/manifest.json",
+          message: err.message
+        }
+      ]
+    };
   }
   const manifestProblems = validateManifest(manifest);
   if (manifestProblems.length > 0) return { problems: manifestProblems };
@@ -1158,16 +1518,31 @@ async function buildSource(input) {
   const manifest = input.manifest;
   try {
     const common = {
-      stdin: { contents: input.chartTs, loader: "ts", sourcefile: "chart.ts" },
+      stdin: {
+        contents: input.chartTs,
+        loader: "ts",
+        sourcefile: "chart.ts"
+      },
       bundle: true,
       platform: "browser",
       target: "es2020",
       write: false,
       legalComments: "none",
       logLevel: "silent",
-      plugins: [{ name: "no-host-imports", setup(build) {
-        build.onResolve({ filter: /.*/ }, (args) => ({ errors: [{ text: `Import "${args.path}" is unavailable in hosted chart source. Use browser APIs or pass a prebuilt bundle.` }] }));
-      } }]
+      plugins: [
+        {
+          name: "no-host-imports",
+          setup(build) {
+            build.onResolve({ filter: /.*/ }, (args) => ({
+              errors: [
+                {
+                  text: `Import "${args.path}" is unavailable in hosted chart source. Use browser APIs or pass a prebuilt bundle.`
+                }
+              ]
+            }));
+          }
+        }
+      ]
     };
     let shape = await esbuild({ ...common, format: "esm", metafile: true });
     if (!Object.values(shape.metafile.outputs)[0]?.exports.includes("render")) {
@@ -1175,9 +1550,24 @@ async function buildSource(input) {
       shape = await esbuild({ ...common, format: "esm", metafile: true });
     }
     if (!Object.values(shape.metafile.outputs)[0]?.exports.includes("render")) {
-      return { ok: false, problems: [{ code: "bundle.build.noRender", path: "/chart.ts", message: "Export function render(ctx)." }], written: [] };
+      return {
+        ok: false,
+        problems: [
+          {
+            code: "bundle.build.noRender",
+            path: "/chart.ts",
+            message: "Export function render(ctx)."
+          }
+        ],
+        written: []
+      };
     }
-    const built = await esbuild({ ...common, format: "iife", globalName: "__dbnCustomChart", minify: true });
+    const built = await esbuild({
+      ...common,
+      format: "iife",
+      globalName: "__dbnCustomChart",
+      minify: true
+    });
     const bundle = {
       manifest,
       bundleCss: input.bundleCss,
@@ -1193,20 +1583,34 @@ globalThis.__dbnCustomChart=__dbnCustomChart;
       ok: true,
       problems: [],
       written: [],
-      outputs: { ...bundle, contentHash: contentHash(bundle), sizeBytes: bundleSizeBytes(bundle) }
+      outputs: {
+        ...bundle,
+        contentHash: contentHash(bundle),
+        sizeBytes: bundleSizeBytes(bundle)
+      }
     };
   } catch (error) {
-    return { ok: false, problems: [{ code: "bundle.build.failed", path: "/chart.ts", message: error.message }], written: [] };
+    return {
+      ok: false,
+      problems: [
+        {
+          code: "bundle.build.failed",
+          path: "/chart.ts",
+          message: error.message
+        }
+      ],
+      written: []
+    };
   }
 }
 
 export {
-  readTemplateFiles,
-  readCustomChartBrowserRuntime,
   MAX_MANIFEST_BYTES,
   MAX_BUNDLE_JS_BYTES,
   MAX_BUNDLE_CSS_BYTES,
   MAX_ICON_BYTES,
+  readTemplateFiles,
+  readCustomChartBrowserRuntime,
   isId,
   validateManifest,
   slotSchema,
@@ -1221,4 +1625,4 @@ export {
   readDist,
   buildSource
 };
-//# sourceMappingURL=chunk-Q5EYDKSA.js.map
+//# sourceMappingURL=chunk-2F7V6RZR.js.map