@meissa_a/meissa 0.1.0

package/dist/client.cjs

@@ -0,0 +1,3558 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+function __accessProp(key) {
+  return this[key];
+}
+var __toCommonJS = (from) => {
+  var entry = (__moduleCache ??= new WeakMap).get(from), desc;
+  if (entry)
+    return entry;
+  entry = __defProp({}, "__esModule", { value: true });
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (var key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(entry, key))
+        __defProp(entry, key, {
+          get: __accessProp.bind(from, key),
+          enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+        });
+  }
+  __moduleCache.set(from, entry);
+  return entry;
+};
+var __moduleCache;
+var __returnValue = (v) => v;
+function __exportSetter(name, newValue) {
+  this[name] = __returnValue.bind(null, newValue);
+}
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, {
+      get: all[name],
+      enumerable: true,
+      configurable: true,
+      set: __exportSetter.bind(all, name)
+    });
+};
+
+// src/client/index.ts
+var exports_client = {};
+__export(exports_client, {
+  handleMcpContent: () => handleMcpContent,
+  applyPatches: () => applyPatches,
+  MeissaContentWithRef: () => MeissaContentWithRef,
+  MeissaContent: () => MeissaContent,
+  MeissaClientRenderer: () => MeissaClientRenderer
+});
+module.exports = __toCommonJS(exports_client);
+
+// src/client/renderer.ts
+var import_react14 = require("react");
+var import_client = require("react-dom/client");
+
+// src/renderer/MeissaRenderer.tsx
+var import_react13 = require("react");
+
+// src/renderer/core/normalizer.ts
+var PRIMARY_PROPS = {
+  text: "content",
+  heading: "content",
+  code: "content",
+  btn: "label",
+  badge: "content",
+  alert: "content",
+  img: "src",
+  progress: "value",
+  list: "items",
+  stat: "value",
+  input: "name",
+  select: "options",
+  table: "data",
+  chart: "data",
+  card: "title",
+  tabs: "items",
+  form: "submit"
+};
+var DEFAULTS = {
+  text: { variant: "default", bold: false, align: "left" },
+  heading: { level: 2, align: "left" },
+  btn: { variant: "primary", size: "md", disabled: false },
+  input: { type: "text", required: false, disabled: false },
+  table: { sortable: true },
+  chart: { type: "line", legend: true, h: 256 },
+  stat: { variant: "default" },
+  alert: { variant: "info", dismissible: false },
+  badge: { variant: "default" },
+  progress: { value: 0, indeterminate: false },
+  card: { variant: "default", padding: 4 },
+  row: { gap: 4, align: "center", wrap: true },
+  col: { gap: 4, align: "stretch" },
+  grid: { cols: 2, gap: 4 },
+  split: { ratio: "1:1", gap: 4 }
+};
+var CONTAINERS = new Set(["row", "col", "grid", "split", "card", "form", "fragment"]);
+function normalize(input) {
+  if (Array.isArray(input)) {
+    return normalizeTuple(input);
+  }
+  if (typeof input === "object" && input !== null) {
+    return normalizeObject(input);
+  }
+  return { type: "text", content: `[Invalid node]` };
+}
+function normalizeTuple(tuple) {
+  const type = tuple[0];
+  if (!type || typeof type !== "string") {
+    return { type: "text", content: "[Invalid: missing type]" };
+  }
+  if (type === "switch") {
+    return normalizeSwitch(tuple);
+  }
+  if (type === "each") {
+    return normalizeEach(tuple);
+  }
+  if (type === "ref") {
+    return { type: "ref", name: tuple[1] };
+  }
+  const node = { type };
+  const second = tuple[1];
+  const third = tuple[2];
+  if (tuple.length === 1) {} else if (tuple.length === 2) {
+    assignSecond(node, type, second);
+  } else if (tuple.length >= 3) {
+    assignSecond(node, type, second);
+    if (Array.isArray(third)) {
+      node.children = normalizeChildren(third);
+    }
+  }
+  applyDefaults(node);
+  return node;
+}
+function assignSecond(node, type, second) {
+  if (second === null || second === undefined) {
+    const primaryProp = PRIMARY_PROPS[type];
+    if (primaryProp) {
+      node[primaryProp] = null;
+    }
+  } else if (typeof second === "string" || typeof second === "number" || typeof second === "boolean") {
+    const primaryProp = PRIMARY_PROPS[type];
+    if (primaryProp) {
+      node[primaryProp] = second;
+    }
+  } else if (Array.isArray(second)) {
+    if (second.length > 0 && Array.isArray(second[0])) {
+      node.children = normalizeChildren(second);
+    } else {
+      const primaryProp = PRIMARY_PROPS[type];
+      if (primaryProp) {
+        node[primaryProp] = second;
+      }
+    }
+  } else if (typeof second === "object") {
+    const obj = second;
+    if ("type" in obj && typeof obj.type === "string") {
+      Object.assign(node, obj);
+      node.type = type;
+    } else {
+      if (type === "tabs" && !("items" in obj)) {
+        const hasTabContent = Object.values(obj).some((v) => Array.isArray(v));
+        if (hasTabContent) {
+          node.items = obj;
+          return;
+        }
+      }
+      Object.assign(node, obj);
+    }
+  }
+}
+function normalizeSwitch(tuple) {
+  const binding = tuple[1];
+  const cases = tuple[2];
+  const normalizedCases = {};
+  if (cases && typeof cases === "object") {
+    for (const [key, value] of Object.entries(cases)) {
+      normalizedCases[key] = normalize(value);
+    }
+  }
+  return { type: "switch", binding, cases: normalizedCases };
+}
+function normalizeEach(tuple) {
+  const binding = tuple[1];
+  const template = tuple[2];
+  return {
+    type: "each",
+    binding,
+    template: normalize(template)
+  };
+}
+function normalizeChildren(arr) {
+  const result = [];
+  for (const item of arr) {
+    if (item === null || item === undefined)
+      continue;
+    result.push(normalize(item));
+  }
+  return result;
+}
+function normalizeObject(obj) {
+  const node = { type: obj.type };
+  for (const [key, value] of Object.entries(obj)) {
+    if (key === "children" && Array.isArray(value)) {
+      node.children = normalizeChildren(value);
+    } else {
+      node[key] = value;
+    }
+  }
+  applyDefaults(node);
+  return node;
+}
+function applyDefaults(node) {
+  const defaults = DEFAULTS[node.type];
+  if (!defaults)
+    return;
+  for (const [key, value] of Object.entries(defaults)) {
+    if (!(key in node)) {
+      node[key] = value;
+    }
+  }
+}
+
+// src/renderer/core/resolver.ts
+function resolveRefs(nodes, defs) {
+  if (Object.keys(defs).length === 0)
+    return nodes;
+  return nodes.map((node) => resolveNode(node, defs));
+}
+function resolveNode(node, defs) {
+  if (node.type === "ref") {
+    const name = node.name;
+    const def = defs[name];
+    if (def) {
+      return structuredClone(def);
+    }
+    return { type: "text", content: `[Unknown ref: ${name}]` };
+  }
+  if (node.children) {
+    node.children = node.children.map((child) => resolveNode(child, defs));
+  }
+  if (node.type === "each" && node.template) {
+    node.template = resolveNode(node.template, defs);
+  }
+  if (node.type === "switch" && node.cases) {
+    const cases = node.cases;
+    for (const key of Object.keys(cases)) {
+      cases[key] = resolveNode(cases[key], defs);
+    }
+  }
+  return node;
+}
+
+// src/renderer/core/parser.ts
+function parse(input) {
+  if (isDocument(input)) {
+    const doc = input;
+    const defs = normalizeDefs(doc.defs);
+    const nodes = normalizeArray(doc.ui);
+    const resolved = resolveRefs(nodes, defs);
+    return {
+      nodes: resolved,
+      defs,
+      data: doc.data ?? {},
+      theme: doc.theme
+    };
+  }
+  if (Array.isArray(input) && input.length > 0) {
+    if (typeof input[0] === "string" && !Array.isArray(input[1]?.constructor === Array ? input[1] : null)) {
+      if (input.length <= 3 && isComponentType(input[0])) {
+        const node = normalize(input);
+        return { nodes: [node], defs: {}, data: {} };
+      }
+    }
+    const nodes = normalizeArray(input);
+    return { nodes, defs: {}, data: {} };
+  }
+  if (typeof input === "object" && input !== null && "type" in input) {
+    const node = normalize(input);
+    return { nodes: [node], defs: {}, data: {} };
+  }
+  return { nodes: [], defs: {}, data: {} };
+}
+function isDocument(input) {
+  return typeof input === "object" && input !== null && !Array.isArray(input) && "ui" in input && Array.isArray(input.ui);
+}
+function isComponentType(value) {
+  const types = new Set([
+    "text",
+    "heading",
+    "code",
+    "img",
+    "btn",
+    "input",
+    "select",
+    "form",
+    "table",
+    "list",
+    "chart",
+    "stat",
+    "card",
+    "tabs",
+    "alert",
+    "badge",
+    "progress",
+    "divider",
+    "row",
+    "col",
+    "grid",
+    "split",
+    "each",
+    "switch",
+    "ref",
+    "fragment"
+  ]);
+  return types.has(value);
+}
+function normalizeArray(arr) {
+  const result = [];
+  for (const item of arr) {
+    if (item === null || item === undefined)
+      continue;
+    if (Array.isArray(item)) {
+      if (typeof item[0] === "string") {
+        result.push(normalize(item));
+      }
+    } else if (typeof item === "object" && "type" in item) {
+      result.push(normalize(item));
+    }
+  }
+  return result;
+}
+function normalizeDefs(defs) {
+  if (!defs)
+    return {};
+  const result = {};
+  for (const [name, def] of Object.entries(defs)) {
+    result[name] = normalize(def);
+  }
+  return result;
+}
+
+// src/renderer/context/DataContext.tsx
+var import_react = require("react");
+var DataContext = import_react.createContext({
+  data: {},
+  root: {}
+});
+var DataProvider = DataContext.Provider;
+function useData() {
+  return import_react.useContext(DataContext);
+}
+
+// src/renderer/context/ActionContext.tsx
+var import_react2 = require("react");
+var noop = () => {};
+var ActionContext = import_react2.createContext({
+  onAction: noop,
+  onNavigate: noop
+});
+var ActionProvider = ActionContext.Provider;
+function useAction() {
+  return import_react2.useContext(ActionContext);
+}
+
+// src/renderer/ComponentRenderer.tsx
+var import_react12 = require("react");
+
+// src/renderer/utils/filters.ts
+var filters = {
+  currency(value) {
+    const num = Number(value);
+    if (isNaN(num))
+      return value;
+    return new Intl.NumberFormat("en-US", {
+      style: "currency",
+      currency: "USD"
+    }).format(num);
+  },
+  percent(value) {
+    const num = Number(value);
+    if (isNaN(num))
+      return value;
+    const pct = num <= 1 && num >= 0 ? num * 100 : num;
+    return `${Math.round(pct)}%`;
+  },
+  number(value) {
+    const num = Number(value);
+    if (isNaN(num))
+      return value;
+    return new Intl.NumberFormat("en-US").format(num);
+  },
+  relative(value) {
+    if (!value)
+      return "";
+    const date = new Date(value);
+    if (isNaN(date.getTime()))
+      return String(value);
+    const now = Date.now();
+    const diff = now - date.getTime();
+    const seconds = Math.floor(diff / 1000);
+    const minutes = Math.floor(seconds / 60);
+    const hours = Math.floor(minutes / 60);
+    const days = Math.floor(hours / 24);
+    const months = Math.floor(days / 30);
+    const years = Math.floor(days / 365);
+    if (seconds < 60)
+      return "just now";
+    if (minutes < 60)
+      return `${minutes} minute${minutes > 1 ? "s" : ""} ago`;
+    if (hours < 24)
+      return `${hours} hour${hours > 1 ? "s" : ""} ago`;
+    if (days < 30)
+      return `${days} day${days > 1 ? "s" : ""} ago`;
+    if (months < 12)
+      return `${months} month${months > 1 ? "s" : ""} ago`;
+    return `${years} year${years > 1 ? "s" : ""} ago`;
+  },
+  date(value, format) {
+    if (!value)
+      return "";
+    const date = new Date(value);
+    if (isNaN(date.getTime()))
+      return String(value);
+    switch (format) {
+      case "short":
+        return date.toLocaleDateString("en-US", { month: "short", day: "numeric", year: "numeric" });
+      case "long":
+        return date.toLocaleDateString("en-US", { month: "long", day: "numeric", year: "numeric" });
+      case "iso":
+        return date.toISOString().split("T")[0];
+      case "time":
+        return date.toLocaleTimeString("en-US", { hour: "numeric", minute: "2-digit" });
+      case "datetime":
+        return date.toLocaleDateString("en-US", { month: "short", day: "numeric", year: "numeric" }) + " " + date.toLocaleTimeString("en-US", { hour: "numeric", minute: "2-digit" });
+      default:
+        return date.toLocaleDateString("en-US", { month: "short", day: "numeric", year: "numeric" });
+    }
+  },
+  uppercase(value) {
+    return typeof value === "string" ? value.toUpperCase() : value;
+  },
+  lowercase(value) {
+    return typeof value === "string" ? value.toLowerCase() : value;
+  },
+  truncate(value, arg) {
+    if (typeof value !== "string")
+      return value;
+    const max = parseInt(arg || "50", 10);
+    if (value.length <= max)
+      return value;
+    return value.slice(0, max) + "...";
+  },
+  default(value, arg) {
+    if (value === null || value === undefined || value === "") {
+      if (arg && arg.startsWith('"') && arg.endsWith('"')) {
+        return arg.slice(1, -1);
+      }
+      if (arg && /^-?\d+(\.\d+)?$/.test(arg)) {
+        return Number(arg);
+      }
+      return arg ?? "";
+    }
+    return value;
+  }
+};
+function applyFilter(filterExpr, value) {
+  const colonIdx = filterExpr.indexOf(":");
+  const name = colonIdx >= 0 ? filterExpr.slice(0, colonIdx) : filterExpr;
+  const arg = colonIdx >= 0 ? filterExpr.slice(colonIdx + 1) : undefined;
+  const fn = filters[name];
+  if (!fn)
+    return value;
+  return fn(value, arg);
+}
+
+// src/renderer/core/binder.ts
+function resolveBindings(template, data) {
+  if (typeof template !== "string")
+    return template;
+  if (!template.includes("{{"))
+    return template;
+  const exactMatch = template.match(/^\{\{(.+?)\}\}$/);
+  if (exactMatch) {
+    return resolveExpression(exactMatch[1], data);
+  }
+  return template.replace(/\{\{(.+?)\}\}/g, (_, expr) => {
+    const result = resolveExpression(expr, data);
+    return result == null ? "" : String(result);
+  });
+}
+function resolveExpression(expr, data) {
+  const parts = expr.split("|").map((s) => s.trim());
+  const path = parts[0];
+  const filters2 = parts.slice(1);
+  if (hasComparison(path)) {
+    return evaluateComparison(path, data);
+  }
+  let value = resolvePath(path, data);
+  for (const filter of filters2) {
+    value = applyFilter(filter, value);
+  }
+  return value;
+}
+function resolvePath(path, data) {
+  if (!path)
+    return;
+  if (path.startsWith("!")) {
+    const value = resolvePath(path.slice(1), data);
+    return !isTruthy(value);
+  }
+  const segments = parsePath(path);
+  let current = data;
+  for (const segment of segments) {
+    if (current === null || current === undefined)
+      return;
+    if (typeof current === "object") {
+      current = current[segment];
+    } else {
+      return;
+    }
+  }
+  return current;
+}
+function parsePath(path) {
+  const segments = [];
+  let current = "";
+  for (let i = 0;i < path.length; i++) {
+    const char = path[i];
+    if (char === ".") {
+      if (current)
+        segments.push(current);
+      current = "";
+    } else if (char === "[") {
+      if (current)
+        segments.push(current);
+      current = "";
+    } else if (char === "]") {
+      if (current)
+        segments.push(current);
+      current = "";
+    } else {
+      current += char;
+    }
+  }
+  if (current)
+    segments.push(current);
+  return segments;
+}
+function hasComparison(expr) {
+  return /\s*(==|!=|<=|>=|<|>)\s*/.test(expr);
+}
+function evaluateComparison(expr, data) {
+  const match = expr.match(/^(.+?)\s*(==|!=|<=|>=|<|>)\s*(.+)$/);
+  if (!match)
+    return false;
+  const [, leftExpr, op, rightExpr] = match;
+  const left = resolveOperand(leftExpr.trim(), data);
+  const right = resolveOperand(rightExpr.trim(), data);
+  switch (op) {
+    case "==":
+      return left == right;
+    case "!=":
+      return left != right;
+    case "<":
+      return Number(left) < Number(right);
+    case ">":
+      return Number(left) > Number(right);
+    case "<=":
+      return Number(left) <= Number(right);
+    case ">=":
+      return Number(left) >= Number(right);
+    default:
+      return false;
+  }
+}
+function resolveOperand(expr, data) {
+  if (expr.startsWith("'") && expr.endsWith("'") || expr.startsWith('"') && expr.endsWith('"')) {
+    return expr.slice(1, -1);
+  }
+  if (/^-?\d+(\.\d+)?$/.test(expr)) {
+    return Number(expr);
+  }
+  if (expr === "true")
+    return true;
+  if (expr === "false")
+    return false;
+  if (expr === "null")
+    return null;
+  return resolvePath(expr, data);
+}
+function isTruthy(value) {
+  if (value === null || value === undefined)
+    return false;
+  if (value === false)
+    return false;
+  if (value === 0)
+    return false;
+  if (value === "")
+    return false;
+  if (Array.isArray(value) && value.length === 0)
+    return false;
+  return true;
+}
+
+// src/renderer/core/evaluator.ts
+function evaluate(node, data) {
+  if (node.type === "switch") {
+    return evaluateSwitch(node, data);
+  }
+  if (node.if !== undefined) {
+    const value = resolveBindings(node.if, data);
+    const negated = typeof node.if === "string" && node.if.startsWith("!{{");
+    const truthy = negated ? value : isTruthy(value);
+    if (!truthy) {
+      return { node: null, hidden: false };
+    }
+  }
+  let hidden = false;
+  if (node.show !== undefined) {
+    const value = resolveBindings(node.show, data);
+    if (!isTruthy(value)) {
+      hidden = true;
+    }
+  }
+  return { node, hidden };
+}
+function evaluateSwitch(node, data) {
+  const binding = node.binding;
+  const cases = node.cases;
+  if (!binding || !cases) {
+    return { node: null, hidden: false };
+  }
+  const value = resolveBindings(binding, data);
+  const key = String(value);
+  if (key in cases) {
+    return { node: cases[key], hidden: false };
+  }
+  if ("_" in cases) {
+    return { node: cases["_"], hidden: false };
+  }
+  return { node: null, hidden: false };
+}
+
+// src/renderer/core/iterator.ts
+function expandEach(node, data) {
+  const binding = node.binding;
+  const template = node.template;
+  if (!binding || !template)
+    return [];
+  const items = resolveBindings(binding, data);
+  if (!Array.isArray(items))
+    return [];
+  return items.map((item, index) => ({
+    node: template,
+    data: {
+      ...data,
+      $: item,
+      $i: index,
+      $first: index === 0,
+      $last: index === items.length - 1
+    }
+  }));
+}
+
+// ../../node_modules/.bun/clsx@2.1.1/node_modules/clsx/dist/clsx.mjs
+function r(e) {
+  var t, f, n = "";
+  if (typeof e == "string" || typeof e == "number")
+    n += e;
+  else if (typeof e == "object")
+    if (Array.isArray(e)) {
+      var o = e.length;
+      for (t = 0;t < o; t++)
+        e[t] && (f = r(e[t])) && (n && (n += " "), n += f);
+    } else
+      for (f in e)
+        e[f] && (n && (n += " "), n += f);
+  return n;
+}
+function clsx() {
+  for (var e, t, f = 0, n = "", o = arguments.length;f < o; f++)
+    (e = arguments[f]) && (t = r(e)) && (n && (n += " "), n += t);
+  return n;
+}
+
+// ../../node_modules/.bun/tailwind-merge@2.6.1/node_modules/tailwind-merge/dist/bundle-mjs.mjs
+var CLASS_PART_SEPARATOR = "-";
+var createClassGroupUtils = (config) => {
+  const classMap = createClassMap(config);
+  const {
+    conflictingClassGroups,
+    conflictingClassGroupModifiers
+  } = config;
+  const getClassGroupId = (className) => {
+    const classParts = className.split(CLASS_PART_SEPARATOR);
+    if (classParts[0] === "" && classParts.length !== 1) {
+      classParts.shift();
+    }
+    return getGroupRecursive(classParts, classMap) || getGroupIdForArbitraryProperty(className);
+  };
+  const getConflictingClassGroupIds = (classGroupId, hasPostfixModifier) => {
+    const conflicts = conflictingClassGroups[classGroupId] || [];
+    if (hasPostfixModifier && conflictingClassGroupModifiers[classGroupId]) {
+      return [...conflicts, ...conflictingClassGroupModifiers[classGroupId]];
+    }
+    return conflicts;
+  };
+  return {
+    getClassGroupId,
+    getConflictingClassGroupIds
+  };
+};
+var getGroupRecursive = (classParts, classPartObject) => {
+  if (classParts.length === 0) {
+    return classPartObject.classGroupId;
+  }
+  const currentClassPart = classParts[0];
+  const nextClassPartObject = classPartObject.nextPart.get(currentClassPart);
+  const classGroupFromNextClassPart = nextClassPartObject ? getGroupRecursive(classParts.slice(1), nextClassPartObject) : undefined;
+  if (classGroupFromNextClassPart) {
+    return classGroupFromNextClassPart;
+  }
+  if (classPartObject.validators.length === 0) {
+    return;
+  }
+  const classRest = classParts.join(CLASS_PART_SEPARATOR);
+  return classPartObject.validators.find(({
+    validator
+  }) => validator(classRest))?.classGroupId;
+};
+var arbitraryPropertyRegex = /^\[(.+)\]$/;
+var getGroupIdForArbitraryProperty = (className) => {
+  if (arbitraryPropertyRegex.test(className)) {
+    const arbitraryPropertyClassName = arbitraryPropertyRegex.exec(className)[1];
+    const property = arbitraryPropertyClassName?.substring(0, arbitraryPropertyClassName.indexOf(":"));
+    if (property) {
+      return "arbitrary.." + property;
+    }
+  }
+};
+var createClassMap = (config) => {
+  const {
+    theme,
+    prefix
+  } = config;
+  const classMap = {
+    nextPart: new Map,
+    validators: []
+  };
+  const prefixedClassGroupEntries = getPrefixedClassGroupEntries(Object.entries(config.classGroups), prefix);
+  prefixedClassGroupEntries.forEach(([classGroupId, classGroup]) => {
+    processClassesRecursively(classGroup, classMap, classGroupId, theme);
+  });
+  return classMap;
+};
+var processClassesRecursively = (classGroup, classPartObject, classGroupId, theme) => {
+  classGroup.forEach((classDefinition) => {
+    if (typeof classDefinition === "string") {
+      const classPartObjectToEdit = classDefinition === "" ? classPartObject : getPart(classPartObject, classDefinition);
+      classPartObjectToEdit.classGroupId = classGroupId;
+      return;
+    }
+    if (typeof classDefinition === "function") {
+      if (isThemeGetter(classDefinition)) {
+        processClassesRecursively(classDefinition(theme), classPartObject, classGroupId, theme);
+        return;
+      }
+      classPartObject.validators.push({
+        validator: classDefinition,
+        classGroupId
+      });
+      return;
+    }
+    Object.entries(classDefinition).forEach(([key, classGroup2]) => {
+      processClassesRecursively(classGroup2, getPart(classPartObject, key), classGroupId, theme);
+    });
+  });
+};
+var getPart = (classPartObject, path) => {
+  let currentClassPartObject = classPartObject;
+  path.split(CLASS_PART_SEPARATOR).forEach((pathPart) => {
+    if (!currentClassPartObject.nextPart.has(pathPart)) {
+      currentClassPartObject.nextPart.set(pathPart, {
+        nextPart: new Map,
+        validators: []
+      });
+    }
+    currentClassPartObject = currentClassPartObject.nextPart.get(pathPart);
+  });
+  return currentClassPartObject;
+};
+var isThemeGetter = (func) => func.isThemeGetter;
+var getPrefixedClassGroupEntries = (classGroupEntries, prefix) => {
+  if (!prefix) {
+    return classGroupEntries;
+  }
+  return classGroupEntries.map(([classGroupId, classGroup]) => {
+    const prefixedClassGroup = classGroup.map((classDefinition) => {
+      if (typeof classDefinition === "string") {
+        return prefix + classDefinition;
+      }
+      if (typeof classDefinition === "object") {
+        return Object.fromEntries(Object.entries(classDefinition).map(([key, value]) => [prefix + key, value]));
+      }
+      return classDefinition;
+    });
+    return [classGroupId, prefixedClassGroup];
+  });
+};
+var createLruCache = (maxCacheSize) => {
+  if (maxCacheSize < 1) {
+    return {
+      get: () => {
+        return;
+      },
+      set: () => {}
+    };
+  }
+  let cacheSize = 0;
+  let cache = new Map;
+  let previousCache = new Map;
+  const update = (key, value) => {
+    cache.set(key, value);
+    cacheSize++;
+    if (cacheSize > maxCacheSize) {
+      cacheSize = 0;
+      previousCache = cache;
+      cache = new Map;
+    }
+  };
+  return {
+    get(key) {
+      let value = cache.get(key);
+      if (value !== undefined) {
+        return value;
+      }
+      if ((value = previousCache.get(key)) !== undefined) {
+        update(key, value);
+        return value;
+      }
+    },
+    set(key, value) {
+      if (cache.has(key)) {
+        cache.set(key, value);
+      } else {
+        update(key, value);
+      }
+    }
+  };
+};
+var IMPORTANT_MODIFIER = "!";
+var createParseClassName = (config) => {
+  const {
+    separator,
+    experimentalParseClassName
+  } = config;
+  const isSeparatorSingleCharacter = separator.length === 1;
+  const firstSeparatorCharacter = separator[0];
+  const separatorLength = separator.length;
+  const parseClassName = (className) => {
+    const modifiers = [];
+    let bracketDepth = 0;
+    let modifierStart = 0;
+    let postfixModifierPosition;
+    for (let index = 0;index < className.length; index++) {
+      let currentCharacter = className[index];
+      if (bracketDepth === 0) {
+        if (currentCharacter === firstSeparatorCharacter && (isSeparatorSingleCharacter || className.slice(index, index + separatorLength) === separator)) {
+          modifiers.push(className.slice(modifierStart, index));
+          modifierStart = index + separatorLength;
+          continue;
+        }
+        if (currentCharacter === "/") {
+          postfixModifierPosition = index;
+          continue;
+        }
+      }
+      if (currentCharacter === "[") {
+        bracketDepth++;
+      } else if (currentCharacter === "]") {
+        bracketDepth--;
+      }
+    }
+    const baseClassNameWithImportantModifier = modifiers.length === 0 ? className : className.substring(modifierStart);
+    const hasImportantModifier = baseClassNameWithImportantModifier.startsWith(IMPORTANT_MODIFIER);
+    const baseClassName = hasImportantModifier ? baseClassNameWithImportantModifier.substring(1) : baseClassNameWithImportantModifier;
+    const maybePostfixModifierPosition = postfixModifierPosition && postfixModifierPosition > modifierStart ? postfixModifierPosition - modifierStart : undefined;
+    return {
+      modifiers,
+      hasImportantModifier,
+      baseClassName,
+      maybePostfixModifierPosition
+    };
+  };
+  if (experimentalParseClassName) {
+    return (className) => experimentalParseClassName({
+      className,
+      parseClassName
+    });
+  }
+  return parseClassName;
+};
+var sortModifiers = (modifiers) => {
+  if (modifiers.length <= 1) {
+    return modifiers;
+  }
+  const sortedModifiers = [];
+  let unsortedModifiers = [];
+  modifiers.forEach((modifier) => {
+    const isArbitraryVariant = modifier[0] === "[";
+    if (isArbitraryVariant) {
+      sortedModifiers.push(...unsortedModifiers.sort(), modifier);
+      unsortedModifiers = [];
+    } else {
+      unsortedModifiers.push(modifier);
+    }
+  });
+  sortedModifiers.push(...unsortedModifiers.sort());
+  return sortedModifiers;
+};
+var createConfigUtils = (config) => ({
+  cache: createLruCache(config.cacheSize),
+  parseClassName: createParseClassName(config),
+  ...createClassGroupUtils(config)
+});
+var SPLIT_CLASSES_REGEX = /\s+/;
+var mergeClassList = (classList, configUtils) => {
+  const {
+    parseClassName,
+    getClassGroupId,
+    getConflictingClassGroupIds
+  } = configUtils;
+  const classGroupsInConflict = [];
+  const classNames = classList.trim().split(SPLIT_CLASSES_REGEX);
+  let result = "";
+  for (let index = classNames.length - 1;index >= 0; index -= 1) {
+    const originalClassName = classNames[index];
+    const {
+      modifiers,
+      hasImportantModifier,
+      baseClassName,
+      maybePostfixModifierPosition
+    } = parseClassName(originalClassName);
+    let hasPostfixModifier = Boolean(maybePostfixModifierPosition);
+    let classGroupId = getClassGroupId(hasPostfixModifier ? baseClassName.substring(0, maybePostfixModifierPosition) : baseClassName);
+    if (!classGroupId) {
+      if (!hasPostfixModifier) {
+        result = originalClassName + (result.length > 0 ? " " + result : result);
+        continue;
+      }
+      classGroupId = getClassGroupId(baseClassName);
+      if (!classGroupId) {
+        result = originalClassName + (result.length > 0 ? " " + result : result);
+        continue;
+      }
+      hasPostfixModifier = false;
+    }
+    const variantModifier = sortModifiers(modifiers).join(":");
+    const modifierId = hasImportantModifier ? variantModifier + IMPORTANT_MODIFIER : variantModifier;
+    const classId = modifierId + classGroupId;
+    if (classGroupsInConflict.includes(classId)) {
+      continue;
+    }
+    classGroupsInConflict.push(classId);
+    const conflictGroups = getConflictingClassGroupIds(classGroupId, hasPostfixModifier);
+    for (let i = 0;i < conflictGroups.length; ++i) {
+      const group = conflictGroups[i];
+      classGroupsInConflict.push(modifierId + group);
+    }
+    result = originalClassName + (result.length > 0 ? " " + result : result);
+  }
+  return result;
+};
+function twJoin() {
+  let index = 0;
+  let argument;
+  let resolvedValue;
+  let string = "";
+  while (index < arguments.length) {
+    if (argument = arguments[index++]) {
+      if (resolvedValue = toValue(argument)) {
+        string && (string += " ");
+        string += resolvedValue;
+      }
+    }
+  }
+  return string;
+}
+var toValue = (mix) => {
+  if (typeof mix === "string") {
+    return mix;
+  }
+  let resolvedValue;
+  let string = "";
+  for (let k = 0;k < mix.length; k++) {
+    if (mix[k]) {
+      if (resolvedValue = toValue(mix[k])) {
+        string && (string += " ");
+        string += resolvedValue;
+      }
+    }
+  }
+  return string;
+};
+function createTailwindMerge(createConfigFirst, ...createConfigRest) {
+  let configUtils;
+  let cacheGet;
+  let cacheSet;
+  let functionToCall = initTailwindMerge;
+  function initTailwindMerge(classList) {
+    const config = createConfigRest.reduce((previousConfig, createConfigCurrent) => createConfigCurrent(previousConfig), createConfigFirst());
+    configUtils = createConfigUtils(config);
+    cacheGet = configUtils.cache.get;
+    cacheSet = configUtils.cache.set;
+    functionToCall = tailwindMerge;
+    return tailwindMerge(classList);
+  }
+  function tailwindMerge(classList) {
+    const cachedResult = cacheGet(classList);
+    if (cachedResult) {
+      return cachedResult;
+    }
+    const result = mergeClassList(classList, configUtils);
+    cacheSet(classList, result);
+    return result;
+  }
+  return function callTailwindMerge() {
+    return functionToCall(twJoin.apply(null, arguments));
+  };
+}
+var fromTheme = (key) => {
+  const themeGetter = (theme) => theme[key] || [];
+  themeGetter.isThemeGetter = true;
+  return themeGetter;
+};
+var arbitraryValueRegex = /^\[(?:([a-z-]+):)?(.+)\]$/i;
+var fractionRegex = /^\d+\/\d+$/;
+var stringLengths = /* @__PURE__ */ new Set(["px", "full", "screen"]);
+var tshirtUnitRegex = /^(\d+(\.\d+)?)?(xs|sm|md|lg|xl)$/;
+var lengthUnitRegex = /\d+(%|px|r?em|[sdl]?v([hwib]|min|max)|pt|pc|in|cm|mm|cap|ch|ex|r?lh|cq(w|h|i|b|min|max))|\b(calc|min|max|clamp)\(.+\)|^0$/;
+var colorFunctionRegex = /^(rgba?|hsla?|hwb|(ok)?(lab|lch)|color-mix)\(.+\)$/;
+var shadowRegex = /^(inset_)?-?((\d+)?\.?(\d+)[a-z]+|0)_-?((\d+)?\.?(\d+)[a-z]+|0)/;
+var imageRegex = /^(url|image|image-set|cross-fade|element|(repeating-)?(linear|radial|conic)-gradient)\(.+\)$/;
+var isLength = (value) => isNumber(value) || stringLengths.has(value) || fractionRegex.test(value);
+var isArbitraryLength = (value) => getIsArbitraryValue(value, "length", isLengthOnly);
+var isNumber = (value) => Boolean(value) && !Number.isNaN(Number(value));
+var isArbitraryNumber = (value) => getIsArbitraryValue(value, "number", isNumber);
+var isInteger = (value) => Boolean(value) && Number.isInteger(Number(value));
+var isPercent = (value) => value.endsWith("%") && isNumber(value.slice(0, -1));
+var isArbitraryValue = (value) => arbitraryValueRegex.test(value);
+var isTshirtSize = (value) => tshirtUnitRegex.test(value);
+var sizeLabels = /* @__PURE__ */ new Set(["length", "size", "percentage"]);
+var isArbitrarySize = (value) => getIsArbitraryValue(value, sizeLabels, isNever);
+var isArbitraryPosition = (value) => getIsArbitraryValue(value, "position", isNever);
+var imageLabels = /* @__PURE__ */ new Set(["image", "url"]);
+var isArbitraryImage = (value) => getIsArbitraryValue(value, imageLabels, isImage);
+var isArbitraryShadow = (value) => getIsArbitraryValue(value, "", isShadow);
+var isAny = () => true;
+var getIsArbitraryValue = (value, label, testValue) => {
+  const result = arbitraryValueRegex.exec(value);
+  if (result) {
+    if (result[1]) {
+      return typeof label === "string" ? result[1] === label : label.has(result[1]);
+    }
+    return testValue(result[2]);
+  }
+  return false;
+};
+var isLengthOnly = (value) => lengthUnitRegex.test(value) && !colorFunctionRegex.test(value);
+var isNever = () => false;
+var isShadow = (value) => shadowRegex.test(value);
+var isImage = (value) => imageRegex.test(value);
+var getDefaultConfig = () => {
+  const colors = fromTheme("colors");
+  const spacing = fromTheme("spacing");
+  const blur = fromTheme("blur");
+  const brightness = fromTheme("brightness");
+  const borderColor = fromTheme("borderColor");
+  const borderRadius = fromTheme("borderRadius");
+  const borderSpacing = fromTheme("borderSpacing");
+  const borderWidth = fromTheme("borderWidth");
+  const contrast = fromTheme("contrast");
+  const grayscale = fromTheme("grayscale");
+  const hueRotate = fromTheme("hueRotate");
+  const invert = fromTheme("invert");
+  const gap = fromTheme("gap");
+  const gradientColorStops = fromTheme("gradientColorStops");
+  const gradientColorStopPositions = fromTheme("gradientColorStopPositions");
+  const inset = fromTheme("inset");
+  const margin = fromTheme("margin");
+  const opacity = fromTheme("opacity");
+  const padding = fromTheme("padding");
+  const saturate = fromTheme("saturate");
+  const scale = fromTheme("scale");
+  const sepia = fromTheme("sepia");
+  const skew = fromTheme("skew");
+  const space = fromTheme("space");
+  const translate = fromTheme("translate");
+  const getOverscroll = () => ["auto", "contain", "none"];
+  const getOverflow = () => ["auto", "hidden", "clip", "visible", "scroll"];
+  const getSpacingWithAutoAndArbitrary = () => ["auto", isArbitraryValue, spacing];
+  const getSpacingWithArbitrary = () => [isArbitraryValue, spacing];
+  const getLengthWithEmptyAndArbitrary = () => ["", isLength, isArbitraryLength];
+  const getNumberWithAutoAndArbitrary = () => ["auto", isNumber, isArbitraryValue];
+  const getPositions = () => ["bottom", "center", "left", "left-bottom", "left-top", "right", "right-bottom", "right-top", "top"];
+  const getLineStyles = () => ["solid", "dashed", "dotted", "double", "none"];
+  const getBlendModes = () => ["normal", "multiply", "screen", "overlay", "darken", "lighten", "color-dodge", "color-burn", "hard-light", "soft-light", "difference", "exclusion", "hue", "saturation", "color", "luminosity"];
+  const getAlign = () => ["start", "end", "center", "between", "around", "evenly", "stretch"];
+  const getZeroAndEmpty = () => ["", "0", isArbitraryValue];
+  const getBreaks = () => ["auto", "avoid", "all", "avoid-page", "page", "left", "right", "column"];
+  const getNumberAndArbitrary = () => [isNumber, isArbitraryValue];
+  return {
+    cacheSize: 500,
+    separator: ":",
+    theme: {
+      colors: [isAny],
+      spacing: [isLength, isArbitraryLength],
+      blur: ["none", "", isTshirtSize, isArbitraryValue],
+      brightness: getNumberAndArbitrary(),
+      borderColor: [colors],
+      borderRadius: ["none", "", "full", isTshirtSize, isArbitraryValue],
+      borderSpacing: getSpacingWithArbitrary(),
+      borderWidth: getLengthWithEmptyAndArbitrary(),
+      contrast: getNumberAndArbitrary(),
+      grayscale: getZeroAndEmpty(),
+      hueRotate: getNumberAndArbitrary(),
+      invert: getZeroAndEmpty(),
+      gap: getSpacingWithArbitrary(),
+      gradientColorStops: [colors],
+      gradientColorStopPositions: [isPercent, isArbitraryLength],
+      inset: getSpacingWithAutoAndArbitrary(),
+      margin: getSpacingWithAutoAndArbitrary(),
+      opacity: getNumberAndArbitrary(),
+      padding: getSpacingWithArbitrary(),
+      saturate: getNumberAndArbitrary(),
+      scale: getNumberAndArbitrary(),
+      sepia: getZeroAndEmpty(),
+      skew: getNumberAndArbitrary(),
+      space: getSpacingWithArbitrary(),
+      translate: getSpacingWithArbitrary()
+    },
+    classGroups: {
+      aspect: [{
+        aspect: ["auto", "square", "video", isArbitraryValue]
+      }],
+      container: ["container"],
+      columns: [{
+        columns: [isTshirtSize]
+      }],
+      "break-after": [{
+        "break-after": getBreaks()
+      }],
+      "break-before": [{
+        "break-before": getBreaks()
+      }],
+      "break-inside": [{
+        "break-inside": ["auto", "avoid", "avoid-page", "avoid-column"]
+      }],
+      "box-decoration": [{
+        "box-decoration": ["slice", "clone"]
+      }],
+      box: [{
+        box: ["border", "content"]
+      }],
+      display: ["block", "inline-block", "inline", "flex", "inline-flex", "table", "inline-table", "table-caption", "table-cell", "table-column", "table-column-group", "table-footer-group", "table-header-group", "table-row-group", "table-row", "flow-root", "grid", "inline-grid", "contents", "list-item", "hidden"],
+      float: [{
+        float: ["right", "left", "none", "start", "end"]
+      }],
+      clear: [{
+        clear: ["left", "right", "both", "none", "start", "end"]
+      }],
+      isolation: ["isolate", "isolation-auto"],
+      "object-fit": [{
+        object: ["contain", "cover", "fill", "none", "scale-down"]
+      }],
+      "object-position": [{
+        object: [...getPositions(), isArbitraryValue]
+      }],
+      overflow: [{
+        overflow: getOverflow()
+      }],
+      "overflow-x": [{
+        "overflow-x": getOverflow()
+      }],
+      "overflow-y": [{
+        "overflow-y": getOverflow()
+      }],
+      overscroll: [{
+        overscroll: getOverscroll()
+      }],
+      "overscroll-x": [{
+        "overscroll-x": getOverscroll()
+      }],
+      "overscroll-y": [{
+        "overscroll-y": getOverscroll()
+      }],
+      position: ["static", "fixed", "absolute", "relative", "sticky"],
+      inset: [{
+        inset: [inset]
+      }],
+      "inset-x": [{
+        "inset-x": [inset]
+      }],
+      "inset-y": [{
+        "inset-y": [inset]
+      }],
+      start: [{
+        start: [inset]
+      }],
+      end: [{
+        end: [inset]
+      }],
+      top: [{
+        top: [inset]
+      }],
+      right: [{
+        right: [inset]
+      }],
+      bottom: [{
+        bottom: [inset]
+      }],
+      left: [{
+        left: [inset]
+      }],
+      visibility: ["visible", "invisible", "collapse"],
+      z: [{
+        z: ["auto", isInteger, isArbitraryValue]
+      }],
+      basis: [{
+        basis: getSpacingWithAutoAndArbitrary()
+      }],
+      "flex-direction": [{
+        flex: ["row", "row-reverse", "col", "col-reverse"]
+      }],
+      "flex-wrap": [{
+        flex: ["wrap", "wrap-reverse", "nowrap"]
+      }],
+      flex: [{
+        flex: ["1", "auto", "initial", "none", isArbitraryValue]
+      }],
+      grow: [{
+        grow: getZeroAndEmpty()
+      }],
+      shrink: [{
+        shrink: getZeroAndEmpty()
+      }],
+      order: [{
+        order: ["first", "last", "none", isInteger, isArbitraryValue]
+      }],
+      "grid-cols": [{
+        "grid-cols": [isAny]
+      }],
+      "col-start-end": [{
+        col: ["auto", {
+          span: ["full", isInteger, isArbitraryValue]
+        }, isArbitraryValue]
+      }],
+      "col-start": [{
+        "col-start": getNumberWithAutoAndArbitrary()
+      }],
+      "col-end": [{
+        "col-end": getNumberWithAutoAndArbitrary()
+      }],
+      "grid-rows": [{
+        "grid-rows": [isAny]
+      }],
+      "row-start-end": [{
+        row: ["auto", {
+          span: [isInteger, isArbitraryValue]
+        }, isArbitraryValue]
+      }],
+      "row-start": [{
+        "row-start": getNumberWithAutoAndArbitrary()
+      }],
+      "row-end": [{
+        "row-end": getNumberWithAutoAndArbitrary()
+      }],
+      "grid-flow": [{
+        "grid-flow": ["row", "col", "dense", "row-dense", "col-dense"]
+      }],
+      "auto-cols": [{
+        "auto-cols": ["auto", "min", "max", "fr", isArbitraryValue]
+      }],
+      "auto-rows": [{
+        "auto-rows": ["auto", "min", "max", "fr", isArbitraryValue]
+      }],
+      gap: [{
+        gap: [gap]
+      }],
+      "gap-x": [{
+        "gap-x": [gap]
+      }],
+      "gap-y": [{
+        "gap-y": [gap]
+      }],
+      "justify-content": [{
+        justify: ["normal", ...getAlign()]
+      }],
+      "justify-items": [{
+        "justify-items": ["start", "end", "center", "stretch"]
+      }],
+      "justify-self": [{
+        "justify-self": ["auto", "start", "end", "center", "stretch"]
+      }],
+      "align-content": [{
+        content: ["normal", ...getAlign(), "baseline"]
+      }],
+      "align-items": [{
+        items: ["start", "end", "center", "baseline", "stretch"]
+      }],
+      "align-self": [{
+        self: ["auto", "start", "end", "center", "stretch", "baseline"]
+      }],
+      "place-content": [{
+        "place-content": [...getAlign(), "baseline"]
+      }],
+      "place-items": [{
+        "place-items": ["start", "end", "center", "baseline", "stretch"]
+      }],
+      "place-self": [{
+        "place-self": ["auto", "start", "end", "center", "stretch"]
+      }],
+      p: [{
+        p: [padding]
+      }],
+      px: [{
+        px: [padding]
+      }],
+      py: [{
+        py: [padding]
+      }],
+      ps: [{
+        ps: [padding]
+      }],
+      pe: [{
+        pe: [padding]
+      }],
+      pt: [{
+        pt: [padding]
+      }],
+      pr: [{
+        pr: [padding]
+      }],
+      pb: [{
+        pb: [padding]
+      }],
+      pl: [{
+        pl: [padding]
+      }],
+      m: [{
+        m: [margin]
+      }],
+      mx: [{
+        mx: [margin]
+      }],
+      my: [{
+        my: [margin]
+      }],
+      ms: [{
+        ms: [margin]
+      }],
+      me: [{
+        me: [margin]
+      }],
+      mt: [{
+        mt: [margin]
+      }],
+      mr: [{
+        mr: [margin]
+      }],
+      mb: [{
+        mb: [margin]
+      }],
+      ml: [{
+        ml: [margin]
+      }],
+      "space-x": [{
+        "space-x": [space]
+      }],
+      "space-x-reverse": ["space-x-reverse"],
+      "space-y": [{
+        "space-y": [space]
+      }],
+      "space-y-reverse": ["space-y-reverse"],
+      w: [{
+        w: ["auto", "min", "max", "fit", "svw", "lvw", "dvw", isArbitraryValue, spacing]
+      }],
+      "min-w": [{
+        "min-w": [isArbitraryValue, spacing, "min", "max", "fit"]
+      }],
+      "max-w": [{
+        "max-w": [isArbitraryValue, spacing, "none", "full", "min", "max", "fit", "prose", {
+          screen: [isTshirtSize]
+        }, isTshirtSize]
+      }],
+      h: [{
+        h: [isArbitraryValue, spacing, "auto", "min", "max", "fit", "svh", "lvh", "dvh"]
+      }],
+      "min-h": [{
+        "min-h": [isArbitraryValue, spacing, "min", "max", "fit", "svh", "lvh", "dvh"]
+      }],
+      "max-h": [{
+        "max-h": [isArbitraryValue, spacing, "min", "max", "fit", "svh", "lvh", "dvh"]
+      }],
+      size: [{
+        size: [isArbitraryValue, spacing, "auto", "min", "max", "fit"]
+      }],
+      "font-size": [{
+        text: ["base", isTshirtSize, isArbitraryLength]
+      }],
+      "font-smoothing": ["antialiased", "subpixel-antialiased"],
+      "font-style": ["italic", "not-italic"],
+      "font-weight": [{
+        font: ["thin", "extralight", "light", "normal", "medium", "semibold", "bold", "extrabold", "black", isArbitraryNumber]
+      }],
+      "font-family": [{
+        font: [isAny]
+      }],
+      "fvn-normal": ["normal-nums"],
+      "fvn-ordinal": ["ordinal"],
+      "fvn-slashed-zero": ["slashed-zero"],
+      "fvn-figure": ["lining-nums", "oldstyle-nums"],
+      "fvn-spacing": ["proportional-nums", "tabular-nums"],
+      "fvn-fraction": ["diagonal-fractions", "stacked-fractions"],
+      tracking: [{
+        tracking: ["tighter", "tight", "normal", "wide", "wider", "widest", isArbitraryValue]
+      }],
+      "line-clamp": [{
+        "line-clamp": ["none", isNumber, isArbitraryNumber]
+      }],
+      leading: [{
+        leading: ["none", "tight", "snug", "normal", "relaxed", "loose", isLength, isArbitraryValue]
+      }],
+      "list-image": [{
+        "list-image": ["none", isArbitraryValue]
+      }],
+      "list-style-type": [{
+        list: ["none", "disc", "decimal", isArbitraryValue]
+      }],
+      "list-style-position": [{
+        list: ["inside", "outside"]
+      }],
+      "placeholder-color": [{
+        placeholder: [colors]
+      }],
+      "placeholder-opacity": [{
+        "placeholder-opacity": [opacity]
+      }],
+      "text-alignment": [{
+        text: ["left", "center", "right", "justify", "start", "end"]
+      }],
+      "text-color": [{
+        text: [colors]
+      }],
+      "text-opacity": [{
+        "text-opacity": [opacity]
+      }],
+      "text-decoration": ["underline", "overline", "line-through", "no-underline"],
+      "text-decoration-style": [{
+        decoration: [...getLineStyles(), "wavy"]
+      }],
+      "text-decoration-thickness": [{
+        decoration: ["auto", "from-font", isLength, isArbitraryLength]
+      }],
+      "underline-offset": [{
+        "underline-offset": ["auto", isLength, isArbitraryValue]
+      }],
+      "text-decoration-color": [{
+        decoration: [colors]
+      }],
+      "text-transform": ["uppercase", "lowercase", "capitalize", "normal-case"],
+      "text-overflow": ["truncate", "text-ellipsis", "text-clip"],
+      "text-wrap": [{
+        text: ["wrap", "nowrap", "balance", "pretty"]
+      }],
+      indent: [{
+        indent: getSpacingWithArbitrary()
+      }],
+      "vertical-align": [{
+        align: ["baseline", "top", "middle", "bottom", "text-top", "text-bottom", "sub", "super", isArbitraryValue]
+      }],
+      whitespace: [{
+        whitespace: ["normal", "nowrap", "pre", "pre-line", "pre-wrap", "break-spaces"]
+      }],
+      break: [{
+        break: ["normal", "words", "all", "keep"]
+      }],
+      hyphens: [{
+        hyphens: ["none", "manual", "auto"]
+      }],
+      content: [{
+        content: ["none", isArbitraryValue]
+      }],
+      "bg-attachment": [{
+        bg: ["fixed", "local", "scroll"]
+      }],
+      "bg-clip": [{
+        "bg-clip": ["border", "padding", "content", "text"]
+      }],
+      "bg-opacity": [{
+        "bg-opacity": [opacity]
+      }],
+      "bg-origin": [{
+        "bg-origin": ["border", "padding", "content"]
+      }],
+      "bg-position": [{
+        bg: [...getPositions(), isArbitraryPosition]
+      }],
+      "bg-repeat": [{
+        bg: ["no-repeat", {
+          repeat: ["", "x", "y", "round", "space"]
+        }]
+      }],
+      "bg-size": [{
+        bg: ["auto", "cover", "contain", isArbitrarySize]
+      }],
+      "bg-image": [{
+        bg: ["none", {
+          "gradient-to": ["t", "tr", "r", "br", "b", "bl", "l", "tl"]
+        }, isArbitraryImage]
+      }],
+      "bg-color": [{
+        bg: [colors]
+      }],
+      "gradient-from-pos": [{
+        from: [gradientColorStopPositions]
+      }],
+      "gradient-via-pos": [{
+        via: [gradientColorStopPositions]
+      }],
+      "gradient-to-pos": [{
+        to: [gradientColorStopPositions]
+      }],
+      "gradient-from": [{
+        from: [gradientColorStops]
+      }],
+      "gradient-via": [{
+        via: [gradientColorStops]
+      }],
+      "gradient-to": [{
+        to: [gradientColorStops]
+      }],
+      rounded: [{
+        rounded: [borderRadius]
+      }],
+      "rounded-s": [{
+        "rounded-s": [borderRadius]
+      }],
+      "rounded-e": [{
+        "rounded-e": [borderRadius]
+      }],
+      "rounded-t": [{
+        "rounded-t": [borderRadius]
+      }],
+      "rounded-r": [{
+        "rounded-r": [borderRadius]
+      }],
+      "rounded-b": [{
+        "rounded-b": [borderRadius]
+      }],
+      "rounded-l": [{
+        "rounded-l": [borderRadius]
+      }],
+      "rounded-ss": [{
+        "rounded-ss": [borderRadius]
+      }],
+      "rounded-se": [{
+        "rounded-se": [borderRadius]
+      }],
+      "rounded-ee": [{
+        "rounded-ee": [borderRadius]
+      }],
+      "rounded-es": [{
+        "rounded-es": [borderRadius]
+      }],
+      "rounded-tl": [{
+        "rounded-tl": [borderRadius]
+      }],
+      "rounded-tr": [{
+        "rounded-tr": [borderRadius]
+      }],
+      "rounded-br": [{
+        "rounded-br": [borderRadius]
+      }],
+      "rounded-bl": [{
+        "rounded-bl": [borderRadius]
+      }],
+      "border-w": [{
+        border: [borderWidth]
+      }],
+      "border-w-x": [{
+        "border-x": [borderWidth]
+      }],
+      "border-w-y": [{
+        "border-y": [borderWidth]
+      }],
+      "border-w-s": [{
+        "border-s": [borderWidth]
+      }],
+      "border-w-e": [{
+        "border-e": [borderWidth]
+      }],
+      "border-w-t": [{
+        "border-t": [borderWidth]
+      }],
+      "border-w-r": [{
+        "border-r": [borderWidth]
+      }],
+      "border-w-b": [{
+        "border-b": [borderWidth]
+      }],
+      "border-w-l": [{
+        "border-l": [borderWidth]
+      }],
+      "border-opacity": [{
+        "border-opacity": [opacity]
+      }],
+      "border-style": [{
+        border: [...getLineStyles(), "hidden"]
+      }],
+      "divide-x": [{
+        "divide-x": [borderWidth]
+      }],
+      "divide-x-reverse": ["divide-x-reverse"],
+      "divide-y": [{
+        "divide-y": [borderWidth]
+      }],
+      "divide-y-reverse": ["divide-y-reverse"],
+      "divide-opacity": [{
+        "divide-opacity": [opacity]
+      }],
+      "divide-style": [{
+        divide: getLineStyles()
+      }],
+      "border-color": [{
+        border: [borderColor]
+      }],
+      "border-color-x": [{
+        "border-x": [borderColor]
+      }],
+      "border-color-y": [{
+        "border-y": [borderColor]
+      }],
+      "border-color-s": [{
+        "border-s": [borderColor]
+      }],
+      "border-color-e": [{
+        "border-e": [borderColor]
+      }],
+      "border-color-t": [{
+        "border-t": [borderColor]
+      }],
+      "border-color-r": [{
+        "border-r": [borderColor]
+      }],
+      "border-color-b": [{
+        "border-b": [borderColor]
+      }],
+      "border-color-l": [{
+        "border-l": [borderColor]
+      }],
+      "divide-color": [{
+        divide: [borderColor]
+      }],
+      "outline-style": [{
+        outline: ["", ...getLineStyles()]
+      }],
+      "outline-offset": [{
+        "outline-offset": [isLength, isArbitraryValue]
+      }],
+      "outline-w": [{
+        outline: [isLength, isArbitraryLength]
+      }],
+      "outline-color": [{
+        outline: [colors]
+      }],
+      "ring-w": [{
+        ring: getLengthWithEmptyAndArbitrary()
+      }],
+      "ring-w-inset": ["ring-inset"],
+      "ring-color": [{
+        ring: [colors]
+      }],
+      "ring-opacity": [{
+        "ring-opacity": [opacity]
+      }],
+      "ring-offset-w": [{
+        "ring-offset": [isLength, isArbitraryLength]
+      }],
+      "ring-offset-color": [{
+        "ring-offset": [colors]
+      }],
+      shadow: [{
+        shadow: ["", "inner", "none", isTshirtSize, isArbitraryShadow]
+      }],
+      "shadow-color": [{
+        shadow: [isAny]
+      }],
+      opacity: [{
+        opacity: [opacity]
+      }],
+      "mix-blend": [{
+        "mix-blend": [...getBlendModes(), "plus-lighter", "plus-darker"]
+      }],
+      "bg-blend": [{
+        "bg-blend": getBlendModes()
+      }],
+      filter: [{
+        filter: ["", "none"]
+      }],
+      blur: [{
+        blur: [blur]
+      }],
+      brightness: [{
+        brightness: [brightness]
+      }],
+      contrast: [{
+        contrast: [contrast]
+      }],
+      "drop-shadow": [{
+        "drop-shadow": ["", "none", isTshirtSize, isArbitraryValue]
+      }],
+      grayscale: [{
+        grayscale: [grayscale]
+      }],
+      "hue-rotate": [{
+        "hue-rotate": [hueRotate]
+      }],
+      invert: [{
+        invert: [invert]
+      }],
+      saturate: [{
+        saturate: [saturate]
+      }],
+      sepia: [{
+        sepia: [sepia]
+      }],
+      "backdrop-filter": [{
+        "backdrop-filter": ["", "none"]
+      }],
+      "backdrop-blur": [{
+        "backdrop-blur": [blur]
+      }],
+      "backdrop-brightness": [{
+        "backdrop-brightness": [brightness]
+      }],
+      "backdrop-contrast": [{
+        "backdrop-contrast": [contrast]
+      }],
+      "backdrop-grayscale": [{
+        "backdrop-grayscale": [grayscale]
+      }],
+      "backdrop-hue-rotate": [{
+        "backdrop-hue-rotate": [hueRotate]
+      }],
+      "backdrop-invert": [{
+        "backdrop-invert": [invert]
+      }],
+      "backdrop-opacity": [{
+        "backdrop-opacity": [opacity]
+      }],
+      "backdrop-saturate": [{
+        "backdrop-saturate": [saturate]
+      }],
+      "backdrop-sepia": [{
+        "backdrop-sepia": [sepia]
+      }],
+      "border-collapse": [{
+        border: ["collapse", "separate"]
+      }],
+      "border-spacing": [{
+        "border-spacing": [borderSpacing]
+      }],
+      "border-spacing-x": [{
+        "border-spacing-x": [borderSpacing]
+      }],
+      "border-spacing-y": [{
+        "border-spacing-y": [borderSpacing]
+      }],
+      "table-layout": [{
+        table: ["auto", "fixed"]
+      }],
+      caption: [{
+        caption: ["top", "bottom"]
+      }],
+      transition: [{
+        transition: ["none", "all", "", "colors", "opacity", "shadow", "transform", isArbitraryValue]
+      }],
+      duration: [{
+        duration: getNumberAndArbitrary()
+      }],
+      ease: [{
+        ease: ["linear", "in", "out", "in-out", isArbitraryValue]
+      }],
+      delay: [{
+        delay: getNumberAndArbitrary()
+      }],
+      animate: [{
+        animate: ["none", "spin", "ping", "pulse", "bounce", isArbitraryValue]
+      }],
+      transform: [{
+        transform: ["", "gpu", "none"]
+      }],
+      scale: [{
+        scale: [scale]
+      }],
+      "scale-x": [{
+        "scale-x": [scale]
+      }],
+      "scale-y": [{
+        "scale-y": [scale]
+      }],
+      rotate: [{
+        rotate: [isInteger, isArbitraryValue]
+      }],
+      "translate-x": [{
+        "translate-x": [translate]
+      }],
+      "translate-y": [{
+        "translate-y": [translate]
+      }],
+      "skew-x": [{
+        "skew-x": [skew]
+      }],
+      "skew-y": [{
+        "skew-y": [skew]
+      }],
+      "transform-origin": [{
+        origin: ["center", "top", "top-right", "right", "bottom-right", "bottom", "bottom-left", "left", "top-left", isArbitraryValue]
+      }],
+      accent: [{
+        accent: ["auto", colors]
+      }],
+      appearance: [{
+        appearance: ["none", "auto"]
+      }],
+      cursor: [{
+        cursor: ["auto", "default", "pointer", "wait", "text", "move", "help", "not-allowed", "none", "context-menu", "progress", "cell", "crosshair", "vertical-text", "alias", "copy", "no-drop", "grab", "grabbing", "all-scroll", "col-resize", "row-resize", "n-resize", "e-resize", "s-resize", "w-resize", "ne-resize", "nw-resize", "se-resize", "sw-resize", "ew-resize", "ns-resize", "nesw-resize", "nwse-resize", "zoom-in", "zoom-out", isArbitraryValue]
+      }],
+      "caret-color": [{
+        caret: [colors]
+      }],
+      "pointer-events": [{
+        "pointer-events": ["none", "auto"]
+      }],
+      resize: [{
+        resize: ["none", "y", "x", ""]
+      }],
+      "scroll-behavior": [{
+        scroll: ["auto", "smooth"]
+      }],
+      "scroll-m": [{
+        "scroll-m": getSpacingWithArbitrary()
+      }],
+      "scroll-mx": [{
+        "scroll-mx": getSpacingWithArbitrary()
+      }],
+      "scroll-my": [{
+        "scroll-my": getSpacingWithArbitrary()
+      }],
+      "scroll-ms": [{
+        "scroll-ms": getSpacingWithArbitrary()
+      }],
+      "scroll-me": [{
+        "scroll-me": getSpacingWithArbitrary()
+      }],
+      "scroll-mt": [{
+        "scroll-mt": getSpacingWithArbitrary()
+      }],
+      "scroll-mr": [{
+        "scroll-mr": getSpacingWithArbitrary()
+      }],
+      "scroll-mb": [{
+        "scroll-mb": getSpacingWithArbitrary()
+      }],
+      "scroll-ml": [{
+        "scroll-ml": getSpacingWithArbitrary()
+      }],
+      "scroll-p": [{
+        "scroll-p": getSpacingWithArbitrary()
+      }],
+      "scroll-px": [{
+        "scroll-px": getSpacingWithArbitrary()
+      }],
+      "scroll-py": [{
+        "scroll-py": getSpacingWithArbitrary()
+      }],
+      "scroll-ps": [{
+        "scroll-ps": getSpacingWithArbitrary()
+      }],
+      "scroll-pe": [{
+        "scroll-pe": getSpacingWithArbitrary()
+      }],
+      "scroll-pt": [{
+        "scroll-pt": getSpacingWithArbitrary()
+      }],
+      "scroll-pr": [{
+        "scroll-pr": getSpacingWithArbitrary()
+      }],
+      "scroll-pb": [{
+        "scroll-pb": getSpacingWithArbitrary()
+      }],
+      "scroll-pl": [{
+        "scroll-pl": getSpacingWithArbitrary()
+      }],
+      "snap-align": [{
+        snap: ["start", "end", "center", "align-none"]
+      }],
+      "snap-stop": [{
+        snap: ["normal", "always"]
+      }],
+      "snap-type": [{
+        snap: ["none", "x", "y", "both"]
+      }],
+      "snap-strictness": [{
+        snap: ["mandatory", "proximity"]
+      }],
+      touch: [{
+        touch: ["auto", "none", "manipulation"]
+      }],
+      "touch-x": [{
+        "touch-pan": ["x", "left", "right"]
+      }],
+      "touch-y": [{
+        "touch-pan": ["y", "up", "down"]
+      }],
+      "touch-pz": ["touch-pinch-zoom"],
+      select: [{
+        select: ["none", "text", "all", "auto"]
+      }],
+      "will-change": [{
+        "will-change": ["auto", "scroll", "contents", "transform", isArbitraryValue]
+      }],
+      fill: [{
+        fill: [colors, "none"]
+      }],
+      "stroke-w": [{
+        stroke: [isLength, isArbitraryLength, isArbitraryNumber]
+      }],
+      stroke: [{
+        stroke: [colors, "none"]
+      }],
+      sr: ["sr-only", "not-sr-only"],
+      "forced-color-adjust": [{
+        "forced-color-adjust": ["auto", "none"]
+      }]
+    },
+    conflictingClassGroups: {
+      overflow: ["overflow-x", "overflow-y"],
+      overscroll: ["overscroll-x", "overscroll-y"],
+      inset: ["inset-x", "inset-y", "start", "end", "top", "right", "bottom", "left"],
+      "inset-x": ["right", "left"],
+      "inset-y": ["top", "bottom"],
+      flex: ["basis", "grow", "shrink"],
+      gap: ["gap-x", "gap-y"],
+      p: ["px", "py", "ps", "pe", "pt", "pr", "pb", "pl"],
+      px: ["pr", "pl"],
+      py: ["pt", "pb"],
+      m: ["mx", "my", "ms", "me", "mt", "mr", "mb", "ml"],
+      mx: ["mr", "ml"],
+      my: ["mt", "mb"],
+      size: ["w", "h"],
+      "font-size": ["leading"],
+      "fvn-normal": ["fvn-ordinal", "fvn-slashed-zero", "fvn-figure", "fvn-spacing", "fvn-fraction"],
+      "fvn-ordinal": ["fvn-normal"],
+      "fvn-slashed-zero": ["fvn-normal"],
+      "fvn-figure": ["fvn-normal"],
+      "fvn-spacing": ["fvn-normal"],
+      "fvn-fraction": ["fvn-normal"],
+      "line-clamp": ["display", "overflow"],
+      rounded: ["rounded-s", "rounded-e", "rounded-t", "rounded-r", "rounded-b", "rounded-l", "rounded-ss", "rounded-se", "rounded-ee", "rounded-es", "rounded-tl", "rounded-tr", "rounded-br", "rounded-bl"],
+      "rounded-s": ["rounded-ss", "rounded-es"],
+      "rounded-e": ["rounded-se", "rounded-ee"],
+      "rounded-t": ["rounded-tl", "rounded-tr"],
+      "rounded-r": ["rounded-tr", "rounded-br"],
+      "rounded-b": ["rounded-br", "rounded-bl"],
+      "rounded-l": ["rounded-tl", "rounded-bl"],
+      "border-spacing": ["border-spacing-x", "border-spacing-y"],
+      "border-w": ["border-w-s", "border-w-e", "border-w-t", "border-w-r", "border-w-b", "border-w-l"],
+      "border-w-x": ["border-w-r", "border-w-l"],
+      "border-w-y": ["border-w-t", "border-w-b"],
+      "border-color": ["border-color-s", "border-color-e", "border-color-t", "border-color-r", "border-color-b", "border-color-l"],
+      "border-color-x": ["border-color-r", "border-color-l"],
+      "border-color-y": ["border-color-t", "border-color-b"],
+      "scroll-m": ["scroll-mx", "scroll-my", "scroll-ms", "scroll-me", "scroll-mt", "scroll-mr", "scroll-mb", "scroll-ml"],
+      "scroll-mx": ["scroll-mr", "scroll-ml"],
+      "scroll-my": ["scroll-mt", "scroll-mb"],
+      "scroll-p": ["scroll-px", "scroll-py", "scroll-ps", "scroll-pe", "scroll-pt", "scroll-pr", "scroll-pb", "scroll-pl"],
+      "scroll-px": ["scroll-pr", "scroll-pl"],
+      "scroll-py": ["scroll-pt", "scroll-pb"],
+      touch: ["touch-x", "touch-y", "touch-pz"],
+      "touch-x": ["touch"],
+      "touch-y": ["touch"],
+      "touch-pz": ["touch"]
+    },
+    conflictingClassGroupModifiers: {
+      "font-size": ["leading"]
+    }
+  };
+};
+var twMerge = /* @__PURE__ */ createTailwindMerge(getDefaultConfig);
+
+// src/renderer/utils/cn.ts
+function cn(...inputs) {
+  return twMerge(clsx(inputs));
+}
+
+// src/renderer/components/Text.tsx
+var jsx_dev_runtime = require("react/jsx-dev-runtime");
+var variantClasses = {
+  default: "text-meissa-fg",
+  muted: "text-meissa-muted",
+  success: "text-meissa-success",
+  warning: "text-meissa-warning",
+  error: "text-meissa-destructive"
+};
+var alignClasses = {
+  left: "text-left",
+  center: "text-center",
+  right: "text-right"
+};
+function Text({ node }) {
+  const variant = node.variant || "default";
+  const bold = node.bold;
+  const align = node.align || "left";
+  const content = node.content;
+  return /* @__PURE__ */ jsx_dev_runtime.jsxDEV("p", {
+    className: cn(variantClasses[variant], alignClasses[align], bold && "font-semibold", node.class),
+    children: content
+  }, undefined, false, undefined, this);
+}
+
+// src/renderer/components/Heading.tsx
+var jsx_dev_runtime2 = require("react/jsx-dev-runtime");
+var levelClasses = {
+  1: "text-3xl font-bold",
+  2: "text-2xl font-semibold",
+  3: "text-xl font-semibold",
+  4: "text-lg font-medium",
+  5: "text-base font-medium",
+  6: "text-sm font-medium"
+};
+var alignClasses2 = {
+  left: "text-left",
+  center: "text-center",
+  right: "text-right"
+};
+function Heading({ node }) {
+  const level = node.level || 2;
+  const align = node.align || "left";
+  const content = node.content;
+  const Tag = `h${level}`;
+  return /* @__PURE__ */ jsx_dev_runtime2.jsxDEV(Tag, {
+    className: cn(levelClasses[level], alignClasses2[align], "text-meissa-fg", node.class),
+    children: content
+  }, undefined, false, undefined, this);
+}
+
+// src/renderer/components/Code.tsx
+var jsx_dev_runtime3 = require("react/jsx-dev-runtime");
+function Code({ node }) {
+  const content = node.content;
+  const lang = node.lang;
+  const inline = node.inline;
+  if (inline) {
+    return /* @__PURE__ */ jsx_dev_runtime3.jsxDEV("code", {
+      className: cn("bg-meissa-fg/10 rounded px-1.5 py-0.5 text-sm font-mono text-meissa-fg", node.class),
+      children: content
+    }, undefined, false, undefined, this);
+  }
+  return /* @__PURE__ */ jsx_dev_runtime3.jsxDEV("pre", {
+    className: cn("bg-meissa-fg/10 rounded-lg p-4 overflow-x-auto", node.class),
+    children: /* @__PURE__ */ jsx_dev_runtime3.jsxDEV("code", {
+      className: "text-sm font-mono text-meissa-fg",
+      "data-lang": lang,
+      children: content
+    }, undefined, false, undefined, this)
+  }, undefined, false, undefined, this);
+}
+
+// src/renderer/utils/sanitize.ts
+function sanitizeUrl(url) {
+  const trimmed = url.trim().toLowerCase();
+  if (trimmed.startsWith("javascript:") || trimmed.startsWith("data:text/html")) {
+    return "about:blank";
+  }
+  return url;
+}
+
+// src/renderer/components/Img.tsx
+var jsx_dev_runtime4 = require("react/jsx-dev-runtime");
+var fitClasses = {
+  cover: "object-cover",
+  contain: "object-contain",
+  fill: "object-fill"
+};
+function Img({ node }) {
+  const src = sanitizeUrl(node.src);
+  const alt = node.alt || "";
+  const w = node.w;
+  const h = node.h;
+  const fit = node.fit || "cover";
+  return /* @__PURE__ */ jsx_dev_runtime4.jsxDEV("img", {
+    src,
+    alt,
+    width: w,
+    height: h,
+    className: cn("rounded", fitClasses[fit], node.class)
+  }, undefined, false, undefined, this);
+}
+
+// src/renderer/components/Btn.tsx
+var import_react4 = require("react");
+
+// src/renderer/context/FormContext.tsx
+var import_react3 = require("react");
+var jsx_dev_runtime5 = require("react/jsx-dev-runtime");
+var FormContext = import_react3.createContext(null);
+function useForm() {
+  return import_react3.useContext(FormContext);
+}
+function FormProvider({ submitAction, onSubmit, children }) {
+  const [values, setValues] = import_react3.useState({});
+  const setValue = import_react3.useCallback((name, value) => {
+    setValues((prev) => ({ ...prev, [name]: value }));
+  }, []);
+  const submit = import_react3.useCallback((action, extraArgs) => {
+    onSubmit(action || submitAction, { ...values, ...extraArgs });
+  }, [submitAction, onSubmit, values]);
+  return /* @__PURE__ */ jsx_dev_runtime5.jsxDEV(FormContext.Provider, {
+    value: { values, setValue, submit },
+    children
+  }, undefined, false, undefined, this);
+}
+
+// src/renderer/components/Btn.tsx
+var jsx_dev_runtime6 = require("react/jsx-dev-runtime");
+var variantClasses2 = {
+  primary: "bg-meissa-primary text-white hover:opacity-90",
+  secondary: "bg-meissa-fg/10 text-meissa-fg hover:bg-meissa-fg/15",
+  destructive: "bg-meissa-destructive text-white hover:opacity-90",
+  ghost: "hover:bg-meissa-fg/10 text-meissa-fg",
+  outline: "border border-meissa-border text-meissa-fg hover:bg-meissa-fg/5"
+};
+var sizeClasses = {
+  sm: "px-2.5 py-1 text-xs",
+  md: "px-4 py-2 text-sm",
+  lg: "px-6 py-3 text-base"
+};
+function Btn({ node }) {
+  const { onAction, onNavigate } = useAction();
+  const form = useForm();
+  const label = node.label;
+  const variant = node.variant || "primary";
+  const size = node.size || "md";
+  const disabled = node.disabled;
+  const action = node.action;
+  const args = node.args;
+  const confirm = node.confirm;
+  const navigate = node.navigate;
+  const handleClick = import_react4.useCallback(() => {
+    if (disabled)
+      return;
+    if (confirm) {
+      if (!window.confirm(confirm))
+        return;
+    }
+    if (navigate) {
+      onNavigate(navigate);
+    } else if (action) {
+      onAction(action, args);
+    } else if (form) {
+      form.submit(undefined, args);
+    }
+  }, [disabled, confirm, navigate, action, args, form, onAction, onNavigate]);
+  return /* @__PURE__ */ jsx_dev_runtime6.jsxDEV("button", {
+    type: "button",
+    disabled,
+    onClick: handleClick,
+    className: cn("inline-flex items-center justify-center rounded-md font-medium transition-colors", "focus-visible:outline-none focus-visible:ring-2 focus-visible:ring-meissa-primary", "disabled:opacity-50 disabled:pointer-events-none", variantClasses2[variant], sizeClasses[size], node.class),
+    children: label
+  }, undefined, false, undefined, this);
+}
+
+// src/renderer/components/Input.tsx
+var import_react5 = require("react");
+var jsx_dev_runtime7 = require("react/jsx-dev-runtime");
+function Input({ node }) {
+  const form = useForm();
+  const name = node.name;
+  const type = node.type || "text";
+  const label = node.label;
+  const placeholder = node.placeholder;
+  const required = node.required;
+  const disabled = node.disabled;
+  const value = form?.values[name] ?? node.value ?? "";
+  const handleChange = import_react5.useCallback((e) => {
+    form?.setValue(name, e.target.value);
+  }, [form, name]);
+  const inputClasses = cn("w-full rounded-md border border-meissa-border bg-meissa-bg px-3 py-2 text-sm", "placeholder:text-meissa-muted", "focus:outline-none focus:ring-2 focus:ring-meissa-primary focus:border-transparent", "disabled:opacity-50 disabled:cursor-not-allowed", node.class);
+  return /* @__PURE__ */ jsx_dev_runtime7.jsxDEV("div", {
+    className: "flex flex-col gap-1.5",
+    children: [
+      label && /* @__PURE__ */ jsx_dev_runtime7.jsxDEV("label", {
+        className: "text-sm font-medium text-meissa-fg",
+        children: [
+          label,
+          required && /* @__PURE__ */ jsx_dev_runtime7.jsxDEV("span", {
+            className: "text-meissa-destructive ml-1",
+            children: "*"
+          }, undefined, false, undefined, this)
+        ]
+      }, undefined, true, undefined, this),
+      type === "textarea" ? /* @__PURE__ */ jsx_dev_runtime7.jsxDEV("textarea", {
+        name,
+        placeholder,
+        required,
+        disabled,
+        value,
+        onChange: handleChange,
+        className: cn(inputClasses, "min-h-[80px] resize-y"),
+        rows: 4
+      }, undefined, false, undefined, this) : /* @__PURE__ */ jsx_dev_runtime7.jsxDEV("input", {
+        name,
+        type,
+        placeholder,
+        required,
+        disabled,
+        value,
+        onChange: handleChange,
+        className: inputClasses
+      }, undefined, false, undefined, this)
+    ]
+  }, undefined, true, undefined, this);
+}
+
+// src/renderer/components/Select.tsx
+var import_react6 = require("react");
+var jsx_dev_runtime8 = require("react/jsx-dev-runtime");
+function normalizeOptions(raw) {
+  return raw.map((item) => {
+    if (typeof item === "string")
+      return { label: item, value: item };
+    const obj = item;
+    return { label: obj.label || obj.value, value: obj.value || obj.label };
+  });
+}
+function Select({ node }) {
+  const form = useForm();
+  const name = node.name;
+  const label = node.label;
+  const placeholder = node.placeholder || "Select...";
+  const required = node.required;
+  const multiple = node.multiple;
+  const rawOptions = node.options || [];
+  const options = normalizeOptions(rawOptions);
+  const value = form?.values[name] ?? node.value ?? "";
+  const handleChange = import_react6.useCallback((e) => {
+    form?.setValue(name, e.target.value);
+  }, [form, name]);
+  return /* @__PURE__ */ jsx_dev_runtime8.jsxDEV("div", {
+    className: "flex flex-col gap-1.5",
+    children: [
+      label && /* @__PURE__ */ jsx_dev_runtime8.jsxDEV("label", {
+        className: "text-sm font-medium text-meissa-fg",
+        children: [
+          label,
+          required && /* @__PURE__ */ jsx_dev_runtime8.jsxDEV("span", {
+            className: "text-meissa-destructive ml-1",
+            children: "*"
+          }, undefined, false, undefined, this)
+        ]
+      }, undefined, true, undefined, this),
+      /* @__PURE__ */ jsx_dev_runtime8.jsxDEV("select", {
+        name,
+        required,
+        multiple,
+        value,
+        onChange: handleChange,
+        className: cn("w-full rounded-md border border-meissa-border bg-meissa-bg px-3 py-2 text-sm", "focus:outline-none focus:ring-2 focus:ring-meissa-primary focus:border-transparent", "disabled:opacity-50 disabled:cursor-not-allowed", node.class),
+        children: [
+          !multiple && /* @__PURE__ */ jsx_dev_runtime8.jsxDEV("option", {
+            value: "",
+            children: placeholder
+          }, undefined, false, undefined, this),
+          options.map((opt) => /* @__PURE__ */ jsx_dev_runtime8.jsxDEV("option", {
+            value: opt.value,
+            children: opt.label
+          }, opt.value, false, undefined, this))
+        ]
+      }, undefined, true, undefined, this)
+    ]
+  }, undefined, true, undefined, this);
+}
+
+// src/renderer/components/Form.tsx
+var import_react7 = require("react");
+var jsx_dev_runtime9 = require("react/jsx-dev-runtime");
+function Form({ node, children }) {
+  const { onAction } = useAction();
+  const submit = node.submit;
+  const args = node.args || {};
+  const handleSubmit = import_react7.useCallback((action, formValues) => {
+    onAction(action || submit, { ...args, ...formValues });
+  }, [onAction, submit, args]);
+  const onFormSubmit = import_react7.useCallback((e) => {
+    e.preventDefault();
+  }, []);
+  return /* @__PURE__ */ jsx_dev_runtime9.jsxDEV(FormProvider, {
+    submitAction: submit,
+    onSubmit: handleSubmit,
+    children: /* @__PURE__ */ jsx_dev_runtime9.jsxDEV("form", {
+      onSubmit: onFormSubmit,
+      className: cn("flex flex-col gap-4", node.class),
+      children
+    }, undefined, false, undefined, this)
+  }, undefined, false, undefined, this);
+}
+
+// src/renderer/components/Table.tsx
+var import_react8 = require("react");
+var jsx_dev_runtime10 = require("react/jsx-dev-runtime");
+function toTitleCase(key) {
+  return key.replace(/([A-Z])/g, " $1").replace(/[_-]/g, " ").replace(/\b\w/g, (c) => c.toUpperCase()).trim();
+}
+function isNumeric(val) {
+  return typeof val === "number" || typeof val === "string" && !isNaN(Number(val)) && val.trim() !== "";
+}
+function Table({ node }) {
+  const { onAction } = useAction();
+  const data = node.data || [];
+  const customColumns = node.columns;
+  const headers = node.headers || {};
+  const sortable = node.sortable !== false;
+  const paginate = node.paginate;
+  const actions = node.actions;
+  const [sortKey, setSortKey] = import_react8.useState(null);
+  const [sortDir, setSortDir] = import_react8.useState("asc");
+  const [page, setPage] = import_react8.useState(0);
+  const columns = import_react8.useMemo(() => {
+    if (customColumns)
+      return customColumns;
+    if (data.length === 0)
+      return [];
+    return Object.keys(data[0]);
+  }, [customColumns, data]);
+  const numericCols = import_react8.useMemo(() => {
+    if (data.length === 0)
+      return new Set;
+    const set = new Set;
+    for (const col of columns) {
+      if (data.every((row) => row[col] == null || isNumeric(row[col]))) {
+        set.add(col);
+      }
+    }
+    return set;
+  }, [columns, data]);
+  const sortedData = import_react8.useMemo(() => {
+    if (!sortKey)
+      return data;
+    return [...data].sort((a, b) => {
+      const av = a[sortKey];
+      const bv = b[sortKey];
+      if (av == null && bv == null)
+        return 0;
+      if (av == null)
+        return 1;
+      if (bv == null)
+        return -1;
+      const cmp = numericCols.has(sortKey) ? Number(av) - Number(bv) : String(av).localeCompare(String(bv));
+      return sortDir === "asc" ? cmp : -cmp;
+    });
+  }, [data, sortKey, sortDir, numericCols]);
+  const paginatedData = import_react8.useMemo(() => {
+    if (!paginate)
+      return sortedData;
+    const start = page * paginate;
+    return sortedData.slice(start, start + paginate);
+  }, [sortedData, page, paginate]);
+  const totalPages = paginate ? Math.ceil(data.length / paginate) : 1;
+  const handleSort = import_react8.useCallback((col) => {
+    if (!sortable)
+      return;
+    if (sortKey === col) {
+      setSortDir((d) => d === "asc" ? "desc" : "asc");
+    } else {
+      setSortKey(col);
+      setSortDir("asc");
+    }
+  }, [sortable, sortKey]);
+  const handleAction = import_react8.useCallback((action, row) => {
+    const resolvedArgs = {};
+    if (action.args) {
+      for (const [k, v] of Object.entries(action.args)) {
+        if (typeof v === "string" && v.startsWith("{{$.") && v.endsWith("}}")) {
+          const path = v.slice(4, -2);
+          resolvedArgs[k] = row[path];
+        } else {
+          resolvedArgs[k] = v;
+        }
+      }
+    }
+    onAction(action.action, resolvedArgs);
+  }, [onAction]);
+  return /* @__PURE__ */ jsx_dev_runtime10.jsxDEV("div", {
+    className: cn("w-full overflow-x-auto", node.class),
+    children: [
+      /* @__PURE__ */ jsx_dev_runtime10.jsxDEV("table", {
+        className: "w-full text-sm",
+        children: [
+          /* @__PURE__ */ jsx_dev_runtime10.jsxDEV("thead", {
+            children: /* @__PURE__ */ jsx_dev_runtime10.jsxDEV("tr", {
+              className: "border-b border-meissa-border",
+              children: [
+                columns.map((col) => /* @__PURE__ */ jsx_dev_runtime10.jsxDEV("th", {
+                  onClick: () => handleSort(col),
+                  className: cn("px-3 py-2 font-medium text-meissa-muted", numericCols.has(col) ? "text-right" : "text-left", sortable && "cursor-pointer select-none hover:text-meissa-fg"),
+                  children: [
+                    headers[col] || toTitleCase(col),
+                    sortKey === col && /* @__PURE__ */ jsx_dev_runtime10.jsxDEV("span", {
+                      className: "ml-1",
+                      children: sortDir === "asc" ? "↑" : "↓"
+                    }, undefined, false, undefined, this)
+                  ]
+                }, col, true, undefined, this)),
+                actions && /* @__PURE__ */ jsx_dev_runtime10.jsxDEV("th", {
+                  className: "px-3 py-2"
+                }, undefined, false, undefined, this)
+              ]
+            }, undefined, true, undefined, this)
+          }, undefined, false, undefined, this),
+          /* @__PURE__ */ jsx_dev_runtime10.jsxDEV("tbody", {
+            children: paginatedData.map((row, i) => /* @__PURE__ */ jsx_dev_runtime10.jsxDEV("tr", {
+              className: cn("border-b border-meissa-border last:border-0", i % 2 === 1 && "bg-meissa-fg/[0.03]"),
+              children: [
+                columns.map((col) => /* @__PURE__ */ jsx_dev_runtime10.jsxDEV("td", {
+                  className: cn("px-3 py-2 text-meissa-fg", numericCols.has(col) ? "text-right" : "text-left"),
+                  children: row[col] != null ? String(row[col]) : ""
+                }, col, false, undefined, this)),
+                actions && /* @__PURE__ */ jsx_dev_runtime10.jsxDEV("td", {
+                  className: "px-3 py-2 text-right",
+                  children: /* @__PURE__ */ jsx_dev_runtime10.jsxDEV("div", {
+                    className: "flex justify-end gap-1",
+                    children: actions.map((action, ai) => /* @__PURE__ */ jsx_dev_runtime10.jsxDEV("button", {
+                      type: "button",
+                      onClick: () => handleAction(action, row),
+                      className: cn("px-2 py-1 text-xs rounded font-medium", action.variant === "destructive" ? "text-meissa-destructive hover:bg-meissa-destructive/10" : "text-meissa-primary hover:bg-meissa-primary/10"),
+                      children: action.label
+                    }, ai, false, undefined, this))
+                  }, undefined, false, undefined, this)
+                }, undefined, false, undefined, this)
+              ]
+            }, i, true, undefined, this))
+          }, undefined, false, undefined, this)
+        ]
+      }, undefined, true, undefined, this),
+      paginate && totalPages > 1 && /* @__PURE__ */ jsx_dev_runtime10.jsxDEV("div", {
+        className: "flex items-center justify-between px-3 py-2 border-t border-meissa-border",
+        children: [
+          /* @__PURE__ */ jsx_dev_runtime10.jsxDEV("span", {
+            className: "text-xs text-meissa-muted",
+            children: [
+              "Page ",
+              page + 1,
+              " of ",
+              totalPages
+            ]
+          }, undefined, true, undefined, this),
+          /* @__PURE__ */ jsx_dev_runtime10.jsxDEV("div", {
+            className: "flex gap-1",
+            children: [
+              /* @__PURE__ */ jsx_dev_runtime10.jsxDEV("button", {
+                type: "button",
+                disabled: page === 0,
+                onClick: () => setPage((p) => p - 1),
+                className: "px-2 py-1 text-xs rounded border border-meissa-border disabled:opacity-50",
+                children: "Prev"
+              }, undefined, false, undefined, this),
+              /* @__PURE__ */ jsx_dev_runtime10.jsxDEV("button", {
+                type: "button",
+                disabled: page >= totalPages - 1,
+                onClick: () => setPage((p) => p + 1),
+                className: "px-2 py-1 text-xs rounded border border-meissa-border disabled:opacity-50",
+                children: "Next"
+              }, undefined, false, undefined, this)
+            ]
+          }, undefined, true, undefined, this)
+        ]
+      }, undefined, true, undefined, this)
+    ]
+  }, undefined, true, undefined, this);
+}
+
+// src/renderer/components/List.tsx
+var jsx_dev_runtime11 = require("react/jsx-dev-runtime");
+var variantClasses3 = {
+  default: "space-y-1",
+  compact: "space-y-0.5",
+  spaced: "space-y-3"
+};
+function List({ node }) {
+  const items = node.items || [];
+  const ordered = node.ordered;
+  const variant = node.variant || "default";
+  const Tag = ordered ? "ol" : "ul";
+  return /* @__PURE__ */ jsx_dev_runtime11.jsxDEV(Tag, {
+    className: cn(ordered ? "list-decimal" : "list-disc", "pl-5 text-sm text-meissa-fg", variantClasses3[variant], node.class),
+    children: items.map((item, i) => /* @__PURE__ */ jsx_dev_runtime11.jsxDEV("li", {
+      children: String(item)
+    }, i, false, undefined, this))
+  }, undefined, false, undefined, this);
+}
+
+// src/renderer/components/Chart.tsx
+var import_react9 = require("react");
+var jsx_dev_runtime12 = require("react/jsx-dev-runtime");
+var rechartsPromise = import("recharts");
+var COLORS = ["#6366f1", "#10b981", "#f59e0b", "#ef4444", "#8b5cf6", "#06b6d4"];
+function ChartInner({ node }) {
+  const data = node.data || [];
+  const type = node.type || "line";
+  const x = node.x;
+  const y = node.y;
+  const title = node.title;
+  const legend = node.legend !== false;
+  const h = node.h || 256;
+  const colors = node.colors || COLORS;
+  const { xKey, yKeys } = import_react9.useMemo(() => {
+    if (data.length === 0)
+      return { xKey: "", yKeys: [] };
+    const keys = Object.keys(data[0]);
+    const resolvedX = x || keys[0];
+    const resolvedY = y ? Array.isArray(y) ? y : [y] : keys.filter((k) => k !== resolvedX);
+    return { xKey: resolvedX, yKeys: resolvedY };
+  }, [data, x, y]);
+  if (data.length === 0) {
+    return /* @__PURE__ */ jsx_dev_runtime12.jsxDEV("div", {
+      className: "text-sm text-meissa-muted italic",
+      children: "No data"
+    }, undefined, false, undefined, this);
+  }
+  return /* @__PURE__ */ jsx_dev_runtime12.jsxDEV("div", {
+    className: cn("w-full", node.class),
+    style: { height: h },
+    children: [
+      title && /* @__PURE__ */ jsx_dev_runtime12.jsxDEV("p", {
+        className: "text-sm font-medium text-meissa-fg mb-2",
+        children: title
+      }, undefined, false, undefined, this),
+      /* @__PURE__ */ jsx_dev_runtime12.jsxDEV(import_react9.Suspense, {
+        fallback: /* @__PURE__ */ jsx_dev_runtime12.jsxDEV("div", {
+          className: "animate-pulse bg-meissa-fg/10 rounded w-full h-full"
+        }, undefined, false, undefined, this),
+        children: /* @__PURE__ */ jsx_dev_runtime12.jsxDEV(RechartsChart, {
+          data,
+          type,
+          xKey,
+          yKeys,
+          colors,
+          legend,
+          h: h - (title ? 28 : 0)
+        }, undefined, false, undefined, this)
+      }, undefined, false, undefined, this)
+    ]
+  }, undefined, true, undefined, this);
+}
+function RechartsChart({ data, type, xKey, yKeys, colors, legend, h }) {
+  const recharts = import_react9.use(rechartsPromise);
+  const {
+    ResponsiveContainer,
+    LineChart,
+    Line,
+    BarChart,
+    Bar,
+    AreaChart,
+    Area,
+    PieChart,
+    Pie,
+    Cell,
+    XAxis,
+    YAxis,
+    CartesianGrid,
+    Tooltip,
+    Legend
+  } = recharts;
+  if (type === "sparkline") {
+    return /* @__PURE__ */ jsx_dev_runtime12.jsxDEV(ResponsiveContainer, {
+      width: "100%",
+      height: h,
+      children: /* @__PURE__ */ jsx_dev_runtime12.jsxDEV(LineChart, {
+        data,
+        children: /* @__PURE__ */ jsx_dev_runtime12.jsxDEV(Line, {
+          type: "monotone",
+          dataKey: yKeys[0],
+          stroke: colors[0],
+          strokeWidth: 2,
+          dot: false
+        }, undefined, false, undefined, this)
+      }, undefined, false, undefined, this)
+    }, undefined, false, undefined, this);
+  }
+  if (type === "pie" || type === "donut") {
+    return /* @__PURE__ */ jsx_dev_runtime12.jsxDEV(ResponsiveContainer, {
+      width: "100%",
+      height: h,
+      children: /* @__PURE__ */ jsx_dev_runtime12.jsxDEV(PieChart, {
+        children: [
+          /* @__PURE__ */ jsx_dev_runtime12.jsxDEV(Pie, {
+            data,
+            dataKey: yKeys[0],
+            nameKey: xKey,
+            innerRadius: type === "donut" ? "60%" : 0,
+            outerRadius: "80%",
+            children: data.map((_, i) => /* @__PURE__ */ jsx_dev_runtime12.jsxDEV(Cell, {
+              fill: colors[i % colors.length]
+            }, i, false, undefined, this))
+          }, undefined, false, undefined, this),
+          /* @__PURE__ */ jsx_dev_runtime12.jsxDEV(Tooltip, {}, undefined, false, undefined, this),
+          legend && /* @__PURE__ */ jsx_dev_runtime12.jsxDEV(Legend, {}, undefined, false, undefined, this)
+        ]
+      }, undefined, true, undefined, this)
+    }, undefined, false, undefined, this);
+  }
+  const ChartComponent = type === "bar" ? BarChart : type === "area" ? AreaChart : LineChart;
+  const SeriesComponent = type === "bar" ? Bar : type === "area" ? Area : Line;
+  return /* @__PURE__ */ jsx_dev_runtime12.jsxDEV(ResponsiveContainer, {
+    width: "100%",
+    height: h,
+    children: /* @__PURE__ */ jsx_dev_runtime12.jsxDEV(ChartComponent, {
+      data,
+      children: [
+        /* @__PURE__ */ jsx_dev_runtime12.jsxDEV(CartesianGrid, {
+          strokeDasharray: "3 3"
+        }, undefined, false, undefined, this),
+        /* @__PURE__ */ jsx_dev_runtime12.jsxDEV(XAxis, {
+          dataKey: xKey,
+          tick: { fontSize: 12 }
+        }, undefined, false, undefined, this),
+        /* @__PURE__ */ jsx_dev_runtime12.jsxDEV(YAxis, {
+          tick: { fontSize: 12 }
+        }, undefined, false, undefined, this),
+        /* @__PURE__ */ jsx_dev_runtime12.jsxDEV(Tooltip, {}, undefined, false, undefined, this),
+        legend && yKeys.length > 1 && /* @__PURE__ */ jsx_dev_runtime12.jsxDEV(Legend, {}, undefined, false, undefined, this),
+        yKeys.map((key, i) => /* @__PURE__ */ jsx_dev_runtime12.jsxDEV(SeriesComponent, {
+          type: "monotone",
+          dataKey: key,
+          stroke: colors[i % colors.length],
+          fill: colors[i % colors.length],
+          ...type === "area" ? { fillOpacity: 0.3 } : {}
+        }, key, false, undefined, this))
+      ]
+    }, undefined, true, undefined, this)
+  }, undefined, false, undefined, this);
+}
+function Chart({ node }) {
+  return /* @__PURE__ */ jsx_dev_runtime12.jsxDEV(ChartInner, {
+    node
+  }, undefined, false, undefined, this);
+}
+
+// src/renderer/components/Stat.tsx
+var jsx_dev_runtime13 = require("react/jsx-dev-runtime");
+var variantClasses4 = {
+  default: "",
+  success: "text-green-600",
+  warning: "text-yellow-600",
+  destructive: "text-red-600"
+};
+function Stat({ node }) {
+  const value = node.value;
+  const label = node.label;
+  const trend = node.trend;
+  const variant = node.variant || "default";
+  const trendPositive = trend?.startsWith("+");
+  const trendNegative = trend?.startsWith("-");
+  return /* @__PURE__ */ jsx_dev_runtime13.jsxDEV("div", {
+    className: cn("flex flex-col gap-1", node.class),
+    children: [
+      label && /* @__PURE__ */ jsx_dev_runtime13.jsxDEV("span", {
+        className: "text-sm text-meissa-muted",
+        children: label
+      }, undefined, false, undefined, this),
+      /* @__PURE__ */ jsx_dev_runtime13.jsxDEV("div", {
+        className: "flex items-baseline gap-2",
+        children: [
+          /* @__PURE__ */ jsx_dev_runtime13.jsxDEV("span", {
+            className: cn("text-2xl font-semibold", variantClasses4[variant] || "text-meissa-fg"),
+            children: value
+          }, undefined, false, undefined, this),
+          trend && /* @__PURE__ */ jsx_dev_runtime13.jsxDEV("span", {
+            className: cn("text-sm font-medium", trendPositive && "text-green-600", trendNegative && "text-red-600", !trendPositive && !trendNegative && "text-meissa-muted"),
+            children: [
+              trendPositive && "↑",
+              trendNegative && "↓",
+              trend
+            ]
+          }, undefined, true, undefined, this)
+        ]
+      }, undefined, true, undefined, this)
+    ]
+  }, undefined, true, undefined, this);
+}
+
+// src/renderer/components/Card.tsx
+var jsx_dev_runtime14 = require("react/jsx-dev-runtime");
+var variantClasses5 = {
+  default: "border border-meissa-border bg-meissa-bg",
+  outline: "border-2 border-meissa-border bg-transparent",
+  elevated: "border border-meissa-border bg-meissa-bg shadow-md"
+};
+var paddingClasses = {
+  0: "p-0",
+  1: "p-1",
+  2: "p-2",
+  3: "p-3",
+  4: "p-4",
+  6: "p-6",
+  8: "p-8"
+};
+function Card({ node, children }) {
+  const title = node.title;
+  const subtitle = node.subtitle;
+  const variant = node.variant || "default";
+  const padding = node.padding ?? 4;
+  return /* @__PURE__ */ jsx_dev_runtime14.jsxDEV("div", {
+    className: cn("rounded-lg", variantClasses5[variant], node.class),
+    children: [
+      (title || subtitle) && /* @__PURE__ */ jsx_dev_runtime14.jsxDEV("div", {
+        className: cn("border-b border-meissa-border", paddingClasses[padding] || "p-4"),
+        children: [
+          title && /* @__PURE__ */ jsx_dev_runtime14.jsxDEV("h3", {
+            className: "font-semibold text-meissa-fg",
+            children: title
+          }, undefined, false, undefined, this),
+          subtitle && /* @__PURE__ */ jsx_dev_runtime14.jsxDEV("p", {
+            className: "text-sm text-meissa-muted mt-0.5",
+            children: subtitle
+          }, undefined, false, undefined, this)
+        ]
+      }, undefined, true, undefined, this),
+      /* @__PURE__ */ jsx_dev_runtime14.jsxDEV("div", {
+        className: cn("flex flex-col gap-4", paddingClasses[padding] || "p-4"),
+        children
+      }, undefined, false, undefined, this)
+    ]
+  }, undefined, true, undefined, this);
+}
+
+// src/renderer/components/Tabs.tsx
+var import_react10 = require("react");
+var jsx_dev_runtime15 = require("react/jsx-dev-runtime");
+var tabVariantClasses = {
+  default: "border-b-2 border-transparent data-[active=true]:border-meissa-primary data-[active=true]:text-meissa-primary",
+  pills: "rounded-md data-[active=true]:bg-meissa-primary data-[active=true]:text-white",
+  underline: "border-b-2 border-transparent data-[active=true]:border-meissa-fg data-[active=true]:text-meissa-fg"
+};
+function Tabs({ node, children }) {
+  const items = node.items || {};
+  const defaultTab = node.default || Object.keys(items)[0];
+  const variant = node.variant || "default";
+  const [activeTab, setActiveTab] = import_react10.useState(defaultTab);
+  const tabKeys = Object.keys(items);
+  return /* @__PURE__ */ jsx_dev_runtime15.jsxDEV("div", {
+    className: cn("w-full", node.class),
+    children: [
+      /* @__PURE__ */ jsx_dev_runtime15.jsxDEV("div", {
+        className: cn("flex", variant === "default" || variant === "underline" ? "border-b border-meissa-border" : "gap-1"),
+        role: "tablist",
+        children: tabKeys.map((key) => /* @__PURE__ */ jsx_dev_runtime15.jsxDEV("button", {
+          type: "button",
+          role: "tab",
+          "aria-selected": activeTab === key,
+          "data-active": activeTab === key,
+          onClick: () => setActiveTab(key),
+          className: cn("px-4 py-2 text-sm font-medium text-meissa-muted transition-colors", "hover:text-meissa-fg", tabVariantClasses[variant]),
+          children: key
+        }, key, false, undefined, this))
+      }, undefined, false, undefined, this),
+      /* @__PURE__ */ jsx_dev_runtime15.jsxDEV("div", {
+        className: "pt-4",
+        role: "tabpanel",
+        children
+      }, undefined, false, undefined, this)
+    ]
+  }, undefined, true, undefined, this);
+}
+
+// src/renderer/components/Alert.tsx
+var import_react11 = require("react");
+var jsx_dev_runtime16 = require("react/jsx-dev-runtime");
+var variantClasses6 = {
+  info: "bg-meissa-primary/10 border-meissa-primary/20 text-meissa-primary",
+  success: "bg-meissa-success/10 border-meissa-success/20 text-meissa-success",
+  warning: "bg-meissa-warning/10 border-meissa-warning/20 text-meissa-warning",
+  error: "bg-meissa-destructive/10 border-meissa-destructive/20 text-meissa-destructive"
+};
+function Alert({ node }) {
+  const [dismissed, setDismissed] = import_react11.useState(false);
+  const content = node.content;
+  const variant = node.variant || "info";
+  const title = node.title;
+  const dismissible = node.dismissible;
+  const handleDismiss = import_react11.useCallback(() => setDismissed(true), []);
+  if (dismissed)
+    return null;
+  return /* @__PURE__ */ jsx_dev_runtime16.jsxDEV("div", {
+    role: "alert",
+    className: cn("rounded-md border p-4", variantClasses6[variant], node.class),
+    children: /* @__PURE__ */ jsx_dev_runtime16.jsxDEV("div", {
+      className: "flex items-start justify-between",
+      children: [
+        /* @__PURE__ */ jsx_dev_runtime16.jsxDEV("div", {
+          className: "flex-1",
+          children: [
+            title && /* @__PURE__ */ jsx_dev_runtime16.jsxDEV("p", {
+              className: "font-medium mb-1",
+              children: title
+            }, undefined, false, undefined, this),
+            /* @__PURE__ */ jsx_dev_runtime16.jsxDEV("p", {
+              className: "text-sm",
+              children: content
+            }, undefined, false, undefined, this)
+          ]
+        }, undefined, true, undefined, this),
+        dismissible && /* @__PURE__ */ jsx_dev_runtime16.jsxDEV("button", {
+          type: "button",
+          onClick: handleDismiss,
+          className: "ml-3 inline-flex shrink-0 rounded p-1 opacity-70 hover:opacity-100",
+          "aria-label": "Dismiss",
+          children: /* @__PURE__ */ jsx_dev_runtime16.jsxDEV("svg", {
+            className: "h-4 w-4",
+            fill: "none",
+            viewBox: "0 0 24 24",
+            stroke: "currentColor",
+            children: /* @__PURE__ */ jsx_dev_runtime16.jsxDEV("path", {
+              strokeLinecap: "round",
+              strokeLinejoin: "round",
+              strokeWidth: 2,
+              d: "M6 18L18 6M6 6l12 12"
+            }, undefined, false, undefined, this)
+          }, undefined, false, undefined, this)
+        }, undefined, false, undefined, this)
+      ]
+    }, undefined, true, undefined, this)
+  }, undefined, false, undefined, this);
+}
+
+// src/renderer/components/Badge.tsx
+var jsx_dev_runtime17 = require("react/jsx-dev-runtime");
+var variantClasses7 = {
+  default: "bg-meissa-fg/10 text-meissa-fg",
+  primary: "bg-meissa-primary/10 text-meissa-primary",
+  success: "bg-meissa-success/10 text-meissa-success",
+  warning: "bg-meissa-warning/10 text-meissa-warning",
+  error: "bg-meissa-destructive/10 text-meissa-destructive",
+  outline: "border border-meissa-border text-meissa-fg"
+};
+function Badge({ node }) {
+  const content = node.content;
+  const variant = node.variant || "default";
+  return /* @__PURE__ */ jsx_dev_runtime17.jsxDEV("span", {
+    className: cn("inline-flex items-center rounded-full px-2.5 py-0.5 text-xs font-medium", variantClasses7[variant], node.class),
+    children: content
+  }, undefined, false, undefined, this);
+}
+
+// src/renderer/components/Progress.tsx
+var jsx_dev_runtime18 = require("react/jsx-dev-runtime");
+var variantClasses8 = {
+  default: "bg-meissa-primary",
+  success: "bg-green-500",
+  warning: "bg-yellow-500",
+  error: "bg-red-500"
+};
+function Progress({ node }) {
+  const value = node.value ?? 0;
+  const label = node.label;
+  const showValue = node.showValue;
+  const variant = node.variant || "default";
+  const indeterminate = node.indeterminate;
+  return /* @__PURE__ */ jsx_dev_runtime18.jsxDEV("div", {
+    className: cn("w-full", node.class),
+    children: [
+      (label || showValue) && /* @__PURE__ */ jsx_dev_runtime18.jsxDEV("div", {
+        className: "flex justify-between mb-1",
+        children: [
+          label && /* @__PURE__ */ jsx_dev_runtime18.jsxDEV("span", {
+            className: "text-sm text-meissa-fg",
+            children: label
+          }, undefined, false, undefined, this),
+          showValue && !indeterminate && /* @__PURE__ */ jsx_dev_runtime18.jsxDEV("span", {
+            className: "text-sm text-meissa-muted",
+            children: [
+              Math.round(value),
+              "%"
+            ]
+          }, undefined, true, undefined, this)
+        ]
+      }, undefined, true, undefined, this),
+      /* @__PURE__ */ jsx_dev_runtime18.jsxDEV("div", {
+        className: "w-full h-2 bg-meissa-fg/10 rounded-full overflow-hidden",
+        children: /* @__PURE__ */ jsx_dev_runtime18.jsxDEV("div", {
+          className: cn("h-full rounded-full transition-all duration-300", variantClasses8[variant], indeterminate && "animate-pulse w-full"),
+          style: !indeterminate ? { width: `${Math.min(100, Math.max(0, value))}%` } : undefined,
+          role: "progressbar",
+          "aria-valuenow": indeterminate ? undefined : value,
+          "aria-valuemin": 0,
+          "aria-valuemax": 100
+        }, undefined, false, undefined, this)
+      }, undefined, false, undefined, this)
+    ]
+  }, undefined, true, undefined, this);
+}
+
+// src/renderer/components/Divider.tsx
+var jsx_dev_runtime19 = require("react/jsx-dev-runtime");
+var spacingClasses = {
+  0: "my-0",
+  1: "my-1",
+  2: "my-2",
+  3: "my-3",
+  4: "my-4",
+  6: "my-6",
+  8: "my-8",
+  10: "my-10",
+  12: "my-12",
+  16: "my-16"
+};
+function Divider({ node }) {
+  const label = node.label;
+  const spacing = node.spacing ?? 4;
+  if (label) {
+    return /* @__PURE__ */ jsx_dev_runtime19.jsxDEV("div", {
+      className: cn("flex items-center", spacingClasses[spacing] || "my-4", node.class),
+      children: [
+        /* @__PURE__ */ jsx_dev_runtime19.jsxDEV("div", {
+          className: "flex-1 border-t border-meissa-border"
+        }, undefined, false, undefined, this),
+        /* @__PURE__ */ jsx_dev_runtime19.jsxDEV("span", {
+          className: "px-3 text-sm text-meissa-muted",
+          children: label
+        }, undefined, false, undefined, this),
+        /* @__PURE__ */ jsx_dev_runtime19.jsxDEV("div", {
+          className: "flex-1 border-t border-meissa-border"
+        }, undefined, false, undefined, this)
+      ]
+    }, undefined, true, undefined, this);
+  }
+  return /* @__PURE__ */ jsx_dev_runtime19.jsxDEV("hr", {
+    className: cn("border-t border-meissa-border", spacingClasses[spacing] || "my-4", node.class)
+  }, undefined, false, undefined, this);
+}
+
+// src/renderer/components/Row.tsx
+var jsx_dev_runtime20 = require("react/jsx-dev-runtime");
+var alignClasses3 = {
+  start: "items-start",
+  center: "items-center",
+  end: "items-end",
+  stretch: "items-stretch"
+};
+var justifyClasses = {
+  start: "justify-start",
+  center: "justify-center",
+  end: "justify-end",
+  between: "justify-between",
+  around: "justify-around"
+};
+var gapClasses = {
+  0: "gap-0",
+  1: "gap-1",
+  2: "gap-2",
+  3: "gap-3",
+  4: "gap-4",
+  6: "gap-6",
+  8: "gap-8",
+  10: "gap-10",
+  12: "gap-12",
+  16: "gap-16"
+};
+function Row({ node, children }) {
+  const gap = node.gap ?? 4;
+  const align = node.align || "center";
+  const justify = node.justify || "start";
+  const wrap = node.wrap;
+  return /* @__PURE__ */ jsx_dev_runtime20.jsxDEV("div", {
+    className: cn("flex flex-row", gapClasses[gap] || "gap-4", alignClasses3[align], justifyClasses[justify], wrap && "flex-wrap", "max-sm:flex-wrap", node.class),
+    children
+  }, undefined, false, undefined, this);
+}
+
+// src/renderer/components/Col.tsx
+var jsx_dev_runtime21 = require("react/jsx-dev-runtime");
+var alignClasses4 = {
+  start: "items-start",
+  center: "items-center",
+  end: "items-end",
+  stretch: "items-stretch"
+};
+var justifyClasses2 = {
+  start: "justify-start",
+  center: "justify-center",
+  end: "justify-end",
+  between: "justify-between",
+  around: "justify-around"
+};
+var gapClasses2 = {
+  0: "gap-0",
+  1: "gap-1",
+  2: "gap-2",
+  3: "gap-3",
+  4: "gap-4",
+  6: "gap-6",
+  8: "gap-8",
+  10: "gap-10",
+  12: "gap-12",
+  16: "gap-16"
+};
+function Col({ node, children }) {
+  const gap = node.gap ?? 4;
+  const align = node.align || "stretch";
+  const justify = node.justify || "start";
+  return /* @__PURE__ */ jsx_dev_runtime21.jsxDEV("div", {
+    className: cn("flex flex-col", gapClasses2[gap] || "gap-4", alignClasses4[align], justifyClasses2[justify], node.class),
+    children
+  }, undefined, false, undefined, this);
+}
+
+// src/renderer/components/Grid.tsx
+var jsx_dev_runtime22 = require("react/jsx-dev-runtime");
+var colsClasses = {
+  1: "grid-cols-1",
+  2: "grid-cols-2",
+  3: "grid-cols-3",
+  4: "grid-cols-4",
+  5: "grid-cols-5",
+  6: "grid-cols-6"
+};
+var gapClasses3 = {
+  0: "gap-0",
+  1: "gap-1",
+  2: "gap-2",
+  3: "gap-3",
+  4: "gap-4",
+  6: "gap-6",
+  8: "gap-8",
+  10: "gap-10",
+  12: "gap-12",
+  16: "gap-16"
+};
+var alignClasses5 = {
+  start: "items-start",
+  center: "items-center",
+  end: "items-end",
+  stretch: "items-stretch"
+};
+function Grid({ node, children }) {
+  const cols = node.cols ?? 3;
+  const gap = node.gap ?? 4;
+  const align = node.align || "stretch";
+  return /* @__PURE__ */ jsx_dev_runtime22.jsxDEV("div", {
+    className: cn("grid", colsClasses[cols] || `grid-cols-${cols}`, gapClasses3[gap] || "gap-4", alignClasses5[align], "max-sm:grid-cols-1 max-md:grid-cols-2", node.class),
+    children
+  }, undefined, false, undefined, this);
+}
+
+// src/renderer/components/Split.tsx
+var jsx_dev_runtime23 = require("react/jsx-dev-runtime");
+var ratioMap = {
+  "1/4": ["w-1/4", "w-3/4"],
+  "1/3": ["w-1/3", "w-2/3"],
+  "1/2": ["w-1/2", "w-1/2"],
+  "2/3": ["w-2/3", "w-1/3"],
+  "3/4": ["w-3/4", "w-1/4"]
+};
+var gapClasses4 = {
+  0: "gap-0",
+  1: "gap-1",
+  2: "gap-2",
+  3: "gap-3",
+  4: "gap-4",
+  6: "gap-6",
+  8: "gap-8",
+  10: "gap-10",
+  12: "gap-12",
+  16: "gap-16"
+};
+function Split({ node, children }) {
+  const ratio = node.ratio || "1/3";
+  const gap = node.gap ?? 4;
+  const dir = node.dir || "row";
+  const isCol = dir === "col";
+  const [firstSize, secondSize] = ratioMap[ratio] || ["w-1/3", "w-2/3"];
+  const childArray = Array.isArray(children) ? children : [children];
+  return /* @__PURE__ */ jsx_dev_runtime23.jsxDEV("div", {
+    className: cn("flex", isCol ? "flex-col" : "flex-row", gapClasses4[gap] || "gap-4", "max-sm:flex-col", node.class),
+    children: [
+      childArray[0] && /* @__PURE__ */ jsx_dev_runtime23.jsxDEV("div", {
+        className: cn(!isCol && firstSize, "max-sm:w-full"),
+        children: childArray[0]
+      }, undefined, false, undefined, this),
+      childArray[1] && /* @__PURE__ */ jsx_dev_runtime23.jsxDEV("div", {
+        className: cn(!isCol && secondSize, "max-sm:w-full"),
+        children: childArray[1]
+      }, undefined, false, undefined, this)
+    ]
+  }, undefined, true, undefined, this);
+}
+
+// src/renderer/components/index.ts
+var COMPONENT_REGISTRY = {
+  text: Text,
+  heading: Heading,
+  code: Code,
+  img: Img,
+  btn: Btn,
+  input: Input,
+  select: Select,
+  form: Form,
+  table: Table,
+  list: List,
+  chart: Chart,
+  stat: Stat,
+  card: Card,
+  tabs: Tabs,
+  alert: Alert,
+  badge: Badge,
+  progress: Progress,
+  divider: Divider,
+  row: Row,
+  col: Col,
+  grid: Grid,
+  split: Split
+};
+
+// src/renderer/ComponentRenderer.tsx
+var jsx_dev_runtime24 = require("react/jsx-dev-runtime");
+function ComponentRenderer({ node }) {
+  const { data } = useData();
+  const evalResult = import_react12.useMemo(() => evaluate(node, data), [node, data]);
+  if (!evalResult.node)
+    return null;
+  const evaluatedNode = evalResult.node;
+  if (evaluatedNode.type === "each") {
+    return /* @__PURE__ */ jsx_dev_runtime24.jsxDEV(EachRenderer, {
+      node: evaluatedNode
+    }, undefined, false, undefined, this);
+  }
+  if (evaluatedNode.type === "fragment") {
+    return /* @__PURE__ */ jsx_dev_runtime24.jsxDEV(FragmentRenderer, {
+      node: evaluatedNode
+    }, undefined, false, undefined, this);
+  }
+  const boundNode = import_react12.useMemo(() => bindNode(evaluatedNode, data), [evaluatedNode, data]);
+  const Component = COMPONENT_REGISTRY[boundNode.type];
+  if (!Component) {
+    if (typeof globalThis !== "undefined" && globalThis.process?.env?.NODE_ENV !== "production") {
+      console.warn(`[Meissa] Unknown component type: "${boundNode.type}"`);
+    }
+    return null;
+  }
+  const children = boundNode.children?.map((child, i) => /* @__PURE__ */ jsx_dev_runtime24.jsxDEV(ComponentRenderer, {
+    node: child
+  }, child.id || i, false, undefined, this));
+  const element = /* @__PURE__ */ jsx_dev_runtime24.jsxDEV(Component, {
+    node: boundNode,
+    children
+  }, undefined, false, undefined, this);
+  if (evalResult.hidden) {
+    return /* @__PURE__ */ jsx_dev_runtime24.jsxDEV("div", {
+      style: { display: "none" },
+      children: element
+    }, undefined, false, undefined, this);
+  }
+  return element;
+}
+function EachRenderer({ node }) {
+  const { data, root } = useData();
+  const items = import_react12.useMemo(() => expandEach(node, data), [node, data]);
+  return /* @__PURE__ */ jsx_dev_runtime24.jsxDEV(jsx_dev_runtime24.Fragment, {
+    children: items.map((item, i) => /* @__PURE__ */ jsx_dev_runtime24.jsxDEV(DataProvider, {
+      value: { data: item.data, root },
+      children: /* @__PURE__ */ jsx_dev_runtime24.jsxDEV(ComponentRenderer, {
+        node: item.node
+      }, undefined, false, undefined, this)
+    }, i, false, undefined, this))
+  }, undefined, false, undefined, this);
+}
+function FragmentRenderer({ node }) {
+  if (!node.children)
+    return null;
+  return /* @__PURE__ */ jsx_dev_runtime24.jsxDEV(jsx_dev_runtime24.Fragment, {
+    children: node.children.map((child, i) => /* @__PURE__ */ jsx_dev_runtime24.jsxDEV(ComponentRenderer, {
+      node: child
+    }, child.id || i, false, undefined, this))
+  }, undefined, false, undefined, this);
+}
+function bindNode(node, data) {
+  const bound = { type: node.type };
+  for (const [key, value] of Object.entries(node)) {
+    if (key === "type")
+      continue;
+    if (key === "children") {
+      bound.children = node.children;
+      continue;
+    }
+    bound[key] = bindValue(value, data);
+  }
+  return bound;
+}
+function bindValue(value, data) {
+  if (typeof value === "string") {
+    return resolveBindings(value, data);
+  }
+  if (Array.isArray(value)) {
+    return value.map((item) => bindValue(item, data));
+  }
+  if (value !== null && typeof value === "object") {
+    const result = {};
+    for (const [k, v] of Object.entries(value)) {
+      result[k] = bindValue(v, data);
+    }
+    return result;
+  }
+  return value;
+}
+
+// src/renderer/MeissaRenderer.tsx
+var jsx_dev_runtime25 = require("react/jsx-dev-runtime");
+var noop2 = () => {};
+function MeissaRenderer({
+  schema,
+  data: externalData,
+  theme,
+  onAction = noop2,
+  onNavigate = noop2,
+  className
+}) {
+  const parsed = import_react13.useMemo(() => parse(schema), [schema]);
+  const mergedData = import_react13.useMemo(() => ({ ...parsed.data, ...externalData }), [parsed.data, externalData]);
+  const themeStyles = import_react13.useMemo(() => {
+    const mergedTheme = { ...parsed.theme, ...theme };
+    if (!mergedTheme?.colors)
+      return;
+    const vars = {};
+    const { colors } = mergedTheme;
+    if (colors.primary)
+      vars["--meissa-primary"] = colors.primary;
+    if (colors.destructive)
+      vars["--meissa-destructive"] = colors.destructive;
+    if (colors.success)
+      vars["--meissa-success"] = colors.success;
+    if (colors.warning)
+      vars["--meissa-warning"] = colors.warning;
+    if (colors.bg)
+      vars["--meissa-bg"] = colors.bg;
+    if (colors.fg)
+      vars["--meissa-fg"] = colors.fg;
+    if (colors.muted)
+      vars["--meissa-muted"] = colors.muted;
+    if (colors.border)
+      vars["--meissa-border"] = colors.border;
+    return vars;
+  }, [parsed.theme, theme]);
+  return /* @__PURE__ */ jsx_dev_runtime25.jsxDEV("div", {
+    className: cn("flex flex-col gap-4", className),
+    style: themeStyles,
+    children: /* @__PURE__ */ jsx_dev_runtime25.jsxDEV(ActionProvider, {
+      value: { onAction, onNavigate },
+      children: /* @__PURE__ */ jsx_dev_runtime25.jsxDEV(DataProvider, {
+        value: { data: mergedData, root: mergedData },
+        children: parsed.nodes.map((node, i) => /* @__PURE__ */ jsx_dev_runtime25.jsxDEV(ComponentRenderer, {
+          node
+        }, node.id || i, false, undefined, this))
+      }, undefined, false, undefined, this)
+    }, undefined, false, undefined, this)
+  }, undefined, false, undefined, this);
+}
+// src/client/patch.ts
+function parsePointer(pointer) {
+  if (pointer === "" || pointer === "/")
+    return [];
+  if (!pointer.startsWith("/")) {
+    throw new Error(`Invalid JSON Pointer: "${pointer}" — must start with "/"`);
+  }
+  return pointer.slice(1).split("/").map((seg) => seg.replace(/~1/g, "/").replace(/~0/g, "~"));
+}
+function traverse(obj, segments) {
+  if (segments.length === 0) {
+    throw new Error("Cannot operate on root with empty path");
+  }
+  let current = obj;
+  for (let i = 0;i < segments.length - 1; i++) {
+    const seg = segments[i];
+    if (Array.isArray(current)) {
+      const idx = parseInt(seg, 10);
+      if (isNaN(idx))
+        throw new Error(`Invalid array index: "${seg}"`);
+      current = current[idx];
+    } else if (current !== null && typeof current === "object") {
+      current = current[seg];
+    } else {
+      throw new Error(`Cannot traverse into ${typeof current} at segment "${seg}"`);
+    }
+  }
+  return [current, segments[segments.length - 1]];
+}
+function applyOp(data, op) {
+  const segments = parsePointer(op.path);
+  if (segments.length === 0) {
+    if (op.op === "replace") {
+      throw new Error("Cannot replace root — use update() instead");
+    }
+    throw new Error(`Cannot ${op.op} at root path`);
+  }
+  const [parent, lastKey] = traverse(data, segments);
+  if (Array.isArray(parent)) {
+    const isAppend = lastKey === "-";
+    const idx = isAppend ? parent.length : parseInt(lastKey, 10);
+    switch (op.op) {
+      case "add":
+        if (isAppend) {
+          parent.push(op.value);
+        } else {
+          if (isNaN(idx))
+            throw new Error(`Invalid array index: "${lastKey}"`);
+          parent.splice(idx, 0, op.value);
+        }
+        break;
+      case "replace":
+        if (isNaN(idx))
+          throw new Error(`Invalid array index: "${lastKey}"`);
+        parent[idx] = op.value;
+        break;
+      case "remove":
+        if (isNaN(idx))
+          throw new Error(`Invalid array index: "${lastKey}"`);
+        parent.splice(idx, 1);
+        break;
+    }
+  } else if (parent !== null && typeof parent === "object") {
+    const obj = parent;
+    switch (op.op) {
+      case "add":
+      case "replace":
+        obj[lastKey] = op.value;
+        break;
+      case "remove":
+        delete obj[lastKey];
+        break;
+    }
+  } else {
+    throw new Error(`Cannot apply patch at "${op.path}" — parent is not an object or array`);
+  }
+}
+function applyPatches(data, patches) {
+  const cloned = structuredClone(data);
+  for (const patch of patches) {
+    applyOp(cloned, patch);
+  }
+  return cloned;
+}
+
+// src/client/renderer.ts
+class MeissaClientRenderer {
+  root;
+  container;
+  theme;
+  onAction;
+  onNavigate;
+  currentSchema = null;
+  currentData = {};
+  destroyed = false;
+  constructor(options) {
+    this.container = options.container;
+    this.theme = options.theme;
+    this.onAction = options.onAction;
+    this.onNavigate = options.onNavigate;
+    this.root = import_client.createRoot(this.container);
+  }
+  render(schema, data) {
+    if (this.destroyed) {
+      throw new Error("MeissaClientRenderer has been destroyed");
+    }
+    this.currentSchema = schema;
+    if (data !== undefined) {
+      this.currentData = data;
+    }
+    this.commitRender();
+  }
+  patch(patches) {
+    if (this.destroyed) {
+      throw new Error("MeissaClientRenderer has been destroyed");
+    }
+    if (!this.currentSchema) {
+      throw new Error("Cannot patch before initial render");
+    }
+    this.currentData = applyPatches(this.currentData, patches);
+    this.commitRender();
+  }
+  update(data) {
+    if (this.destroyed) {
+      throw new Error("MeissaClientRenderer has been destroyed");
+    }
+    if (!this.currentSchema) {
+      throw new Error("Cannot update before initial render");
+    }
+    this.currentData = data;
+    this.commitRender();
+  }
+  destroy() {
+    if (this.destroyed)
+      return;
+    this.destroyed = true;
+    this.root.unmount();
+    this.currentSchema = null;
+    this.currentData = {};
+  }
+  commitRender() {
+    if (!this.currentSchema)
+      return;
+    const handleAction = (name, args) => {
+      if (this.onAction) {
+        this.onAction(name, args ?? {});
+      }
+    };
+    const handleNavigate = (uri) => {
+      if (this.onNavigate) {
+        this.onNavigate(uri);
+      }
+    };
+    this.root.render(import_react14.createElement(MeissaRenderer, {
+      schema: this.currentSchema,
+      data: this.currentData,
+      theme: this.theme,
+      onAction: handleAction,
+      onNavigate: handleNavigate
+    }));
+  }
+}
+// src/client/component.tsx
+var import_react15 = require("react");
+var import_react16 = require("react");
+var jsx_dev_runtime26 = require("react/jsx-dev-runtime");
+function MeissaContent({
+  schema,
+  data: externalData,
+  theme,
+  onAction,
+  onNavigate,
+  className
+}) {
+  const [patchedData, setPatchedData] = import_react15.useState(externalData);
+  const dataRef = import_react15.useRef(patchedData);
+  dataRef.current = patchedData;
+  const prevExternalRef = import_react15.useRef(externalData);
+  if (externalData !== prevExternalRef.current) {
+    prevExternalRef.current = externalData;
+    setPatchedData(externalData);
+    dataRef.current = externalData;
+  }
+  const applyPatch = import_react15.useCallback((patches) => {
+    setPatchedData((current) => {
+      const base = current ?? {};
+      return applyPatches(base, patches);
+    });
+  }, []);
+  const handleAction = import_react15.useCallback((name, args) => {
+    if (onAction) {
+      onAction(name, args ?? {});
+    }
+  }, [onAction]);
+  const handleNavigate = import_react15.useCallback((uri) => {
+    if (onNavigate) {
+      onNavigate(uri);
+    }
+  }, [onNavigate]);
+  return /* @__PURE__ */ jsx_dev_runtime26.jsxDEV(MeissaRenderer, {
+    schema,
+    data: patchedData,
+    theme,
+    onAction: handleAction,
+    onNavigate: handleNavigate,
+    className
+  }, undefined, false, undefined, this);
+}
+var MeissaContentWithRef = import_react16.forwardRef(function MeissaContentWithRef2(props, ref) {
+  const [patchedData, setPatchedData] = import_react15.useState(props.data);
+  const dataRef = import_react15.useRef(patchedData);
+  dataRef.current = patchedData;
+  const prevExternalRef = import_react15.useRef(props.data);
+  if (props.data !== prevExternalRef.current) {
+    prevExternalRef.current = props.data;
+    setPatchedData(props.data);
+    dataRef.current = props.data;
+  }
+  const applyPatchFn = import_react15.useCallback((patches) => {
+    setPatchedData((current) => {
+      const base = current ?? {};
+      return applyPatches(base, patches);
+    });
+  }, []);
+  import_react16.useImperativeHandle(ref, () => ({
+    applyPatch: applyPatchFn
+  }), [applyPatchFn]);
+  const handleAction = import_react15.useCallback((name, args) => {
+    if (props.onAction) {
+      props.onAction(name, args ?? {});
+    }
+  }, [props.onAction]);
+  const handleNavigate = import_react15.useCallback((uri) => {
+    if (props.onNavigate) {
+      props.onNavigate(uri);
+    }
+  }, [props.onNavigate]);
+  return /* @__PURE__ */ jsx_dev_runtime26.jsxDEV(MeissaRenderer, {
+    schema: props.schema,
+    data: patchedData,
+    theme: props.theme,
+    onAction: handleAction,
+    onNavigate: handleNavigate,
+    className: props.className
+  }, undefined, false, undefined, this);
+});
+// src/client/content.ts
+function handleMcpContent(contentBlocks) {
+  for (const block of contentBlocks) {
+    if (block.type === "meissa/patch") {
+      const patchBlock = block;
+      return {
+        type: "meissa/patch",
+        target: patchBlock.target,
+        patches: patchBlock.patches
+      };
+    }
+  }
+  for (const block of contentBlocks) {
+    if (block.type === "meissa") {
+      const meissaBlock = block;
+      return {
+        type: "meissa",
+        schema: meissaBlock.schema,
+        data: meissaBlock.data,
+        theme: meissaBlock.theme,
+        fallback: meissaBlock.fallback
+      };
+    }
+  }
+  const textParts = [];
+  for (const block of contentBlocks) {
+    if (block.type === "text") {
+      textParts.push(block.text);
+    }
+  }
+  return {
+    type: "text",
+    text: textParts.join(`
+`)
+  };
+}