@abraca/nuxt 0.1.0

package/dist/runtime/utils/markdownToYjs.js

@@ -0,0 +1,440 @@
+import * as Y from "yjs";
+export function filenameToLabel(raw) {
+  const base = raw.replace(/\.[^.]+$/, "");
+  const spaced = base.replace(/([a-z])([A-Z])/g, "$1 $2");
+  const clean = spaced.replace(/[-_.]+/g, " ").replace(/\s+/g, " ").trim();
+  return clean.charAt(0).toUpperCase() + clean.slice(1);
+}
+function coerceScalar(raw) {
+  const trimmed = raw.trim();
+  if (trimmed === "true") return true;
+  if (trimmed === "false") return false;
+  const num = Number(trimmed);
+  if (!Number.isNaN(num) && trimmed !== "") return num;
+  if (trimmed.startsWith('"') && trimmed.endsWith('"') || trimmed.startsWith("'") && trimmed.endsWith("'")) {
+    return trimmed.slice(1, -1);
+  }
+  return trimmed;
+}
+void coerceScalar;
+function parseInlineArray(raw) {
+  return raw.slice(1, -1).split(",").map((s) => s.trim()).filter(Boolean);
+}
+export function parseFrontmatter(markdown) {
+  const noResult = { meta: {}, body: markdown };
+  const match = markdown.match(/^---\r?\n([\s\S]*?)\r?\n---\r?\n?/);
+  if (!match) return noResult;
+  const yamlBlock = match[1];
+  const body = markdown.slice(match[0].length);
+  const raw = {};
+  const lines = yamlBlock.split("\n");
+  let i = 0;
+  while (i < lines.length) {
+    const line = lines[i];
+    const blockSeqKey = line.match(/^(\w[\w-]*):\s*$/);
+    if (blockSeqKey && i + 1 < lines.length && /^\s+-\s/.test(lines[i + 1])) {
+      const key = blockSeqKey[1];
+      const items = [];
+      i++;
+      while (i < lines.length && /^\s+-\s/.test(lines[i])) {
+        items.push(lines[i].replace(/^\s+-\s/, "").trim());
+        i++;
+      }
+      raw[key] = items;
+      continue;
+    }
+    const kvMatch = line.match(/^(\w[\w-]*):\s*(.*)$/);
+    if (kvMatch) {
+      const key = kvMatch[1];
+      const val = kvMatch[2].trim();
+      if (val.startsWith("[") && val.endsWith("]")) {
+        raw[key] = parseInlineArray(val);
+      } else {
+        raw[key] = val;
+      }
+    }
+    i++;
+  }
+  const meta = {};
+  const getStr = (keys) => {
+    for (const k of keys) {
+      const v = raw[k];
+      if (typeof v === "string" && v) return v;
+    }
+  };
+  const getArr = (keys) => {
+    for (const k of keys) {
+      const v = raw[k];
+      if (Array.isArray(v)) return v;
+      if (typeof v === "string" && v) return [v];
+    }
+  };
+  if (raw["tags"]) meta.tags = Array.isArray(raw["tags"]) ? raw["tags"] : [raw["tags"]];
+  const color = getStr(["color"]);
+  if (color) meta.color = color;
+  const icon = getStr(["icon"]);
+  if (icon) meta.icon = icon;
+  const status = getStr(["status"]);
+  if (status) meta.status = status;
+  const priorityRaw = getStr(["priority"]);
+  if (priorityRaw !== void 0) {
+    const map = { low: 1, medium: 2, high: 3, urgent: 4 };
+    meta.priority = map[priorityRaw.toLowerCase()] ?? (Number(priorityRaw) || 0);
+  }
+  const checkedRaw = raw["checked"] ?? raw["done"];
+  if (checkedRaw !== void 0) meta.checked = checkedRaw === "true" || checkedRaw === true;
+  const dateStart = getStr(["date", "created"]);
+  if (dateStart) meta.dateStart = dateStart;
+  const dateEnd = getStr(["due"]);
+  if (dateEnd) meta.dateEnd = dateEnd;
+  const subtitle = getStr(["description", "subtitle"]);
+  if (subtitle) meta.subtitle = subtitle;
+  const url = getStr(["url"]);
+  if (url) meta.url = url;
+  const ratingRaw = getStr(["rating"]);
+  if (ratingRaw !== void 0) {
+    const n = Number(ratingRaw);
+    if (!Number.isNaN(n)) meta.rating = Math.min(5, Math.max(0, n));
+  }
+  const tagsResult = getArr(["tags"]);
+  if (tagsResult) meta.tags = tagsResult;
+  const title = typeof raw["title"] === "string" ? raw["title"] : void 0;
+  const type = getStr(["type"]);
+  return { title, type, meta, body };
+}
+function parseMdcProps(propsStr) {
+  if (!propsStr) return {};
+  const result = {};
+  const re = /(\w[\w-]*)="([^"]*)"/g;
+  let m;
+  while ((m = re.exec(propsStr)) !== null) {
+    result[m[1]] = m[2];
+  }
+  return result;
+}
+function parseInline(text) {
+  const stripped = text.replace(/\{lang="[^"]*"\}/g, "").replace(/:(?!badge|icon|kbd)(\w[\w-]*)\[([^\]]*)\](\{[^}]*\})?/g, "$2").replace(/:(?!badge|icon|kbd)(\w[\w-]*)(\{[^}]*\})/g, "");
+  const tokens = [];
+  const re = /:badge\[([^\]]*)\](\{[^}]*\})?|:icon\{([^}]*)\}|:kbd\{([^}]*)\}|!?\[\[([^\]|]+?)(?:\|([^\]]+?))?\]\]|~~(.+?)~~|\*\*(.+?)\*\*|\*(.+?)\*|_(.+?)_|`(.+?)`|\[(.+?)\]\((.+?)\)/g;
+  let lastIndex = 0;
+  let match;
+  while ((match = re.exec(stripped)) !== null) {
+    if (match.index > lastIndex) {
+      tokens.push({ text: stripped.slice(lastIndex, match.index) });
+    }
+    if (match[1] !== void 0) {
+      const badgeProps = parseMdcProps(match[2]);
+      tokens.push({ text: match[1] || "Badge", attrs: { badge: { label: match[1] || "Badge", color: badgeProps["color"] || "neutral", variant: badgeProps["variant"] || "subtle" } } });
+    } else if (match[3] !== void 0) {
+      const iconProps = parseMdcProps(`{${match[3]}}`);
+      tokens.push({ text: "\u200B", attrs: { proseIcon: { name: iconProps["name"] || "i-lucide-star" } } });
+    } else if (match[4] !== void 0) {
+      const kbdProps = parseMdcProps(`{${match[4]}}`);
+      tokens.push({ text: kbdProps["value"] || "", attrs: { kbd: { value: kbdProps["value"] || "" } } });
+    } else if (match[5] !== void 0) {
+      const displayText = match[6] ?? match[5];
+      tokens.push({ text: displayText });
+    } else if (match[7] !== void 0) {
+      tokens.push({ text: match[7], attrs: { strike: true } });
+    } else if (match[8] !== void 0) {
+      tokens.push({ text: match[8], attrs: { bold: true } });
+    } else if (match[9] !== void 0) {
+      tokens.push({ text: match[9], attrs: { italic: true } });
+    } else if (match[10] !== void 0) {
+      tokens.push({ text: match[10], attrs: { italic: true } });
+    } else if (match[11] !== void 0) {
+      tokens.push({ text: match[11], attrs: { code: true } });
+    } else if (match[12] !== void 0 && match[13] !== void 0) {
+      tokens.push({ text: match[12], attrs: { link: { href: match[13] } } });
+    }
+    lastIndex = match.index + match[0].length;
+  }
+  if (lastIndex < stripped.length) {
+    tokens.push({ text: stripped.slice(lastIndex) });
+  }
+  return tokens.filter((t) => t.text.length > 0);
+}
+function parseTableRow(line) {
+  const parts = line.split("|");
+  return parts.slice(1, parts.length - 1).map((c) => c.trim());
+}
+function isTableSeparator(line) {
+  return /^\|[\s|:-]+\|$/.test(line.trim());
+}
+const TASK_RE = /^[-*+]\s+\[([ xX])\]\s+(.*)/;
+function parseBlocks(markdown) {
+  const rawLines = markdown.split("\n");
+  let firstContentLine = 0;
+  while (firstContentLine < rawLines.length) {
+    const l = rawLines[firstContentLine];
+    if (l.trim() === "" || /^import\s/.test(l) || /^export\s/.test(l)) {
+      firstContentLine++;
+    } else {
+      break;
+    }
+  }
+  const stripped = rawLines.slice(firstContentLine).join("\n");
+  const blocks = [];
+  const lines = stripped.split("\n");
+  let i = 0;
+  while (i < lines.length) {
+    const line = lines[i];
+    const fenceBlockMatch = line.match(/^(`{3,})(.*)$/);
+    if (fenceBlockMatch) {
+      const fence = fenceBlockMatch[1];
+      const lang = fenceBlockMatch[2].trim().replace(/\{[^}]*\}$/, "").replace(/\s*\[.*\]$/, "").trim();
+      const codeLines = [];
+      i++;
+      while (i < lines.length && !lines[i].startsWith(fence)) {
+        codeLines.push(lines[i]);
+        i++;
+      }
+      i++;
+      blocks.push({ type: "codeBlock", lang, code: codeLines.join("\n") });
+      continue;
+    }
+    const headingMatch = line.match(/^(#{1,6})\s+(.*)/);
+    if (headingMatch) {
+      blocks.push({ type: "heading", level: headingMatch[1].length, text: headingMatch[2].trim() });
+      i++;
+      continue;
+    }
+    if (/^[-*_]{3,}\s*$/.test(line)) {
+      blocks.push({ type: "hr" });
+      i++;
+      continue;
+    }
+    const imgMatch = line.match(/^!\[([^\]]*)\]\(([^)]+)\)(\{[^}]*\})?\s*$/);
+    if (imgMatch) {
+      const alt = imgMatch[1] ?? "";
+      const src = imgMatch[2] ?? "";
+      const attrs = parseMdcProps(imgMatch[3]);
+      blocks.push({ type: "image", src, alt, width: attrs["width"], height: attrs["height"] });
+      i++;
+      continue;
+    }
+    if (line.startsWith("> ") || line === ">") {
+      const bqLines = [];
+      while (i < lines.length && (lines[i].startsWith("> ") || lines[i] === ">")) {
+        bqLines.push(lines[i].replace(/^>\s?/, ""));
+        i++;
+      }
+      blocks.push({ type: "blockquote", lines: bqLines });
+      continue;
+    }
+    if (/^\s*\|/.test(line)) {
+      const tableLines = [];
+      while (i < lines.length && /^\s*\|/.test(lines[i])) {
+        tableLines.push(lines[i]);
+        i++;
+      }
+      if (tableLines.length >= 2 && isTableSeparator(tableLines[1])) {
+        const headerRow = parseTableRow(tableLines[0]);
+        const dataRows = tableLines.slice(2).filter((l) => !isTableSeparator(l)).map(parseTableRow);
+        blocks.push({ type: "table", headerRow, dataRows });
+      } else {
+        for (const l of tableLines) blocks.push({ type: "paragraph", text: l });
+      }
+      continue;
+    }
+    const MDC_OPEN = /^\s*(:{2,})(\w[\w-]*)(\{[^}]*\})?\s*$/;
+    if (MDC_OPEN.test(line)) {
+      const colons = line.match(/^\s*(:+)/)?.[1]?.length ?? 2;
+      i++;
+      while (i < lines.length) {
+        const l = lines[i];
+        if (new RegExp(`^\\s*:{${colons}}\\s*$`).test(l)) {
+          i++;
+          break;
+        }
+        i++;
+      }
+      continue;
+    }
+    if (TASK_RE.test(line)) {
+      const items = [];
+      while (i < lines.length && TASK_RE.test(lines[i])) {
+        const m = lines[i].match(TASK_RE);
+        items.push({ checked: m[1].toLowerCase() === "x", text: m[2] });
+        i++;
+      }
+      blocks.push({ type: "taskList", items });
+      continue;
+    }
+    if (/^[-*+]\s+/.test(line)) {
+      const items = [];
+      while (i < lines.length && /^[-*+]\s+/.test(lines[i]) && !TASK_RE.test(lines[i])) {
+        items.push(lines[i].replace(/^[-*+]\s+/, ""));
+        i++;
+      }
+      if (items.length) {
+        blocks.push({ type: "bulletList", items });
+        continue;
+      }
+    }
+    if (/^\d+\.\s+/.test(line)) {
+      const items = [];
+      while (i < lines.length && /^\d+\.\s+/.test(lines[i])) {
+        items.push(lines[i].replace(/^\d+\.\s+/, ""));
+        i++;
+      }
+      blocks.push({ type: "orderedList", items });
+      continue;
+    }
+    if (line.trim() === "") {
+      i++;
+      continue;
+    }
+    const paraLines = [];
+    while (i < lines.length && lines[i].trim() !== "" && !/^(#{1,6}\s|[-*+]\s|\d+\.\s|>|`{3,}|\s*\||[-*_]{3,}\s*$|\s*:{2,}\w)/.test(lines[i])) {
+      paraLines.push(lines[i]);
+      i++;
+    }
+    if (paraLines.length) {
+      blocks.push({ type: "paragraph", text: paraLines.join(" ") });
+    }
+  }
+  return blocks;
+}
+function fillTextInto(el, tokens) {
+  const filtered = tokens.filter((t) => t.text.length > 0);
+  if (!filtered.length) return;
+  const xtNodes = filtered.map(() => new Y.XmlText());
+  el.insert(0, xtNodes);
+  filtered.forEach((tok, i) => {
+    if (tok.attrs) {
+      xtNodes[i].insert(0, tok.text, tok.attrs);
+    } else {
+      xtNodes[i].insert(0, tok.text);
+    }
+  });
+}
+function blockElName(b) {
+  switch (b.type) {
+    case "heading":
+      return "heading";
+    case "paragraph":
+      return "paragraph";
+    case "bulletList":
+      return "bulletList";
+    case "orderedList":
+      return "orderedList";
+    case "taskList":
+      return "taskList";
+    case "codeBlock":
+      return "codeBlock";
+    case "blockquote":
+      return "blockquote";
+    case "table":
+      return "table";
+    case "hr":
+      return "horizontalRule";
+    case "image":
+      return "image";
+  }
+}
+function fillBlock(el, block) {
+  switch (block.type) {
+    case "heading": {
+      el.setAttribute("level", block.level);
+      fillTextInto(el, parseInline(block.text));
+      break;
+    }
+    case "paragraph": {
+      fillTextInto(el, parseInline(block.text));
+      break;
+    }
+    case "bulletList":
+    case "orderedList": {
+      const listItemEls = block.items.map(() => new Y.XmlElement("listItem"));
+      el.insert(0, listItemEls);
+      block.items.forEach((text, i) => {
+        const paraEl = new Y.XmlElement("paragraph");
+        listItemEls[i].insert(0, [paraEl]);
+        fillTextInto(paraEl, parseInline(text));
+      });
+      break;
+    }
+    case "taskList": {
+      const taskItemEls = block.items.map(() => new Y.XmlElement("taskItem"));
+      el.insert(0, taskItemEls);
+      block.items.forEach((item, i) => {
+        taskItemEls[i].setAttribute("checked", item.checked);
+        const paraEl = new Y.XmlElement("paragraph");
+        taskItemEls[i].insert(0, [paraEl]);
+        fillTextInto(paraEl, parseInline(item.text));
+      });
+      break;
+    }
+    case "codeBlock": {
+      if (block.lang) el.setAttribute("language", block.lang);
+      const xt = new Y.XmlText();
+      el.insert(0, [xt]);
+      xt.insert(0, block.code);
+      break;
+    }
+    case "blockquote": {
+      const paraEls = block.lines.map(() => new Y.XmlElement("paragraph"));
+      el.insert(0, paraEls);
+      block.lines.forEach((line, i) => fillTextInto(paraEls[i], parseInline(line)));
+      break;
+    }
+    case "table": {
+      const headerRowEl = new Y.XmlElement("tableRow");
+      const dataRowEls = block.dataRows.map(() => new Y.XmlElement("tableRow"));
+      el.insert(0, [headerRowEl, ...dataRowEls]);
+      const headerCellEls = block.headerRow.map(() => new Y.XmlElement("tableHeader"));
+      headerRowEl.insert(0, headerCellEls);
+      block.headerRow.forEach((cellText, i) => {
+        const paraEl = new Y.XmlElement("paragraph");
+        headerCellEls[i].insert(0, [paraEl]);
+        fillTextInto(paraEl, parseInline(cellText));
+      });
+      block.dataRows.forEach((row, ri) => {
+        const cellEls = row.map(() => new Y.XmlElement("tableCell"));
+        dataRowEls[ri].insert(0, cellEls);
+        row.forEach((cellText, ci) => {
+          const paraEl = new Y.XmlElement("paragraph");
+          cellEls[ci].insert(0, [paraEl]);
+          fillTextInto(paraEl, parseInline(cellText));
+        });
+      });
+      break;
+    }
+    case "hr":
+      break;
+    case "image": {
+      el.setAttribute("src", block.src);
+      if (block.alt) el.setAttribute("alt", block.alt);
+      if (block.width) el.setAttribute("width", block.width);
+      if (block.height) el.setAttribute("height", block.height);
+      break;
+    }
+  }
+}
+export function populateYDocFromMarkdown(fragment, markdown, fallbackTitle = "Untitled") {
+  const ydoc = fragment.doc;
+  if (!ydoc) {
+    console.warn("[markdownToYjs] fragment has no doc \u2014 skipping population");
+    return;
+  }
+  const blocks = parseBlocks(markdown);
+  let title = fallbackTitle;
+  let contentBlocks = blocks;
+  const h1 = blocks.findIndex((b) => b.type === "heading" && b.level === 1);
+  if (h1 !== -1) {
+    title = blocks[h1].text;
+    contentBlocks = blocks.filter((_, i) => i !== h1);
+  }
+  if (!contentBlocks.length) contentBlocks = [{ type: "paragraph", text: "" }];
+  ydoc.transact(() => {
+    const headerEl = new Y.XmlElement("documentHeader");
+    const metaEl = new Y.XmlElement("documentMeta");
+    const bodyEls = contentBlocks.map((b) => new Y.XmlElement(blockElName(b)));
+    fragment.insert(0, [headerEl, metaEl, ...bodyEls]);
+    const headerXt = new Y.XmlText();
+    headerEl.insert(0, [headerXt]);
+    headerXt.insert(0, title);
+    contentBlocks.forEach((block, i) => fillBlock(bodyEls[i], block));
+  });
+}

package/dist/runtime/utils/metaFieldDefinitions.d.ts

@@ -0,0 +1,7 @@
+export interface MetaFieldDefinition {
+    label: string;
+    icon: string;
+    kind: string;
+    buildAttrs: () => Record<string, unknown>;
+}
+export declare const META_FIELD_DEFINITIONS: MetaFieldDefinition[];

package/dist/runtime/utils/metaFieldDefinitions.js

@@ -0,0 +1,182 @@
+export const META_FIELD_DEFINITIONS = [
+  {
+    label: "Date Range",
+    icon: "i-lucide-calendar-range",
+    kind: "metaFieldDate",
+    buildAttrs: () => {
+      const t = Date.now();
+      return { fieldType: "daterange", fieldLabel: "Date", userDefined: true, startKey: `_start_${t}`, endKey: `_end_${t}` };
+    }
+  },
+  {
+    label: "Date & Time",
+    icon: "i-lucide-calendar-clock",
+    kind: "metaFieldDateTime",
+    buildAttrs: () => {
+      const t = Date.now();
+      return { fieldType: "datetimerange", fieldLabel: "Date & Time", userDefined: true, startKey: `_dtstart_${t}`, endKey: `_dtend_${t}`, allDayKey: `_allday_${t}` };
+    }
+  },
+  {
+    label: "Date",
+    icon: "i-lucide-calendar",
+    kind: "metaFieldDateSingle",
+    buildAttrs: () => {
+      const t = Date.now();
+      return { fieldType: "date", fieldLabel: "Date", userDefined: true, metaKey: `_date_${t}` };
+    }
+  },
+  {
+    label: "Datetime",
+    icon: "i-lucide-calendar-clock",
+    kind: "metaFieldDatetimeSingle",
+    buildAttrs: () => {
+      const t = Date.now();
+      return { fieldType: "datetime", fieldLabel: "Datetime", userDefined: true, metaKey: `_datetime_${t}` };
+    }
+  },
+  {
+    label: "Time",
+    icon: "i-lucide-clock",
+    kind: "metaFieldTime",
+    buildAttrs: () => {
+      const t = Date.now();
+      return { fieldType: "time", fieldLabel: "Time", userDefined: true, metaKey: `_time_${t}` };
+    }
+  },
+  {
+    label: "Time Range",
+    icon: "i-lucide-clock-4",
+    kind: "metaFieldTimeRange",
+    buildAttrs: () => {
+      const t = Date.now();
+      return { fieldType: "timerange", fieldLabel: "Time Range", userDefined: true, startKey: `_tstart_${t}`, endKey: `_tend_${t}` };
+    }
+  },
+  {
+    label: "Number",
+    icon: "i-lucide-hash",
+    kind: "metaFieldNumber",
+    buildAttrs: () => {
+      const t = Date.now();
+      return { fieldType: "number", fieldLabel: "Number", userDefined: true, metaKey: `_num_${t}` };
+    }
+  },
+  {
+    label: "Slider",
+    icon: "i-lucide-sliders-horizontal",
+    kind: "metaFieldSlider",
+    buildAttrs: () => {
+      const t = Date.now();
+      return { fieldType: "slider", fieldLabel: "Slider", userDefined: true, metaKey: `_slider_${t}`, sliderMin: 0, sliderMax: 100 };
+    }
+  },
+  {
+    label: "Progress",
+    icon: "i-lucide-bar-chart-2",
+    kind: "metaFieldProgress",
+    buildAttrs: () => {
+      const t = Date.now();
+      return { fieldType: "slider", fieldLabel: "Progress", userDefined: true, metaKey: `_progress_${t}`, sliderMin: 0, sliderMax: 100 };
+    }
+  },
+  {
+    label: "Rating",
+    icon: "i-lucide-star",
+    kind: "metaFieldRating",
+    buildAttrs: () => {
+      const t = Date.now();
+      return { fieldType: "rating", fieldLabel: "Rating", userDefined: true, metaKey: `_rating_${t}`, sliderMax: 5 };
+    }
+  },
+  {
+    label: "Toggle",
+    icon: "i-lucide-toggle-right",
+    kind: "metaFieldToggle",
+    buildAttrs: () => {
+      const t = Date.now();
+      return { fieldType: "toggle", fieldLabel: "Toggle", userDefined: true, metaKey: `_toggle_${t}` };
+    }
+  },
+  {
+    label: "Color Preset",
+    icon: "i-lucide-palette",
+    kind: "metaFieldColor",
+    buildAttrs: () => {
+      const t = Date.now();
+      return { fieldType: "colorPreset", fieldLabel: "Color", userDefined: true, metaKey: `_color_${t}`, presets: JSON.stringify(["#6366f1", "#f97316", "#22c55e", "#ef4444", "#a855f7"]) };
+    }
+  },
+  {
+    label: "Color Picker",
+    icon: "i-lucide-pipette",
+    kind: "metaFieldColorPicker",
+    buildAttrs: () => {
+      const t = Date.now();
+      return { fieldType: "colorPicker", fieldLabel: "Color", userDefined: true, metaKey: `_cpick_${t}` };
+    }
+  },
+  {
+    label: "Select",
+    icon: "i-lucide-chevron-down-circle",
+    kind: "metaFieldSelect",
+    buildAttrs: () => {
+      const t = Date.now();
+      return { fieldType: "select", fieldLabel: "Select", userDefined: true, metaKey: `_sel_${t}`, options: JSON.stringify([]) };
+    }
+  },
+  {
+    label: "Multi Select",
+    icon: "i-lucide-list-checks",
+    kind: "metaFieldMultiSelect",
+    buildAttrs: () => {
+      const t = Date.now();
+      return { fieldType: "multiselect", fieldLabel: "Multi Select", userDefined: true, metaKey: `_msel_${t}`, options: JSON.stringify([]) };
+    }
+  },
+  {
+    label: "Tags",
+    icon: "i-lucide-tags",
+    kind: "metaFieldTags",
+    buildAttrs: () => {
+      const t = Date.now();
+      return { fieldType: "tags", fieldLabel: "Tags", userDefined: true, metaKey: `_tags_${t}` };
+    }
+  },
+  {
+    label: "URL",
+    icon: "i-lucide-link",
+    kind: "metaFieldUrl",
+    buildAttrs: () => {
+      const t = Date.now();
+      return { fieldType: "url", fieldLabel: "URL", userDefined: true, metaKey: `_url_${t}` };
+    }
+  },
+  {
+    label: "Text Area",
+    icon: "i-lucide-align-left",
+    kind: "metaFieldTextarea",
+    buildAttrs: () => {
+      const t = Date.now();
+      return { fieldType: "textarea", fieldLabel: "Text", userDefined: true, metaKey: `_text_${t}` };
+    }
+  },
+  {
+    label: "Location",
+    icon: "i-lucide-map-pin",
+    kind: "metaFieldLocation",
+    buildAttrs: () => {
+      const t = Date.now();
+      return { fieldType: "location", fieldLabel: "Location", userDefined: true, latKey: `_lat_${t}`, lngKey: `_lng_${t}` };
+    }
+  },
+  {
+    label: "Icon",
+    icon: "i-lucide-smile",
+    kind: "metaFieldIcon",
+    buildAttrs: () => {
+      const t = Date.now();
+      return { fieldType: "icon", fieldLabel: "Icon", userDefined: true, metaKey: `_icon_${t}` };
+    }
+  }
+];

package/dist/runtime/utils/voiceErrors.d.ts

@@ -0,0 +1,33 @@
+export declare enum VoiceErrorCode {
+    CONNECT_FAILED = "CONNECT_FAILED",
+    CONNECT_TIMEOUT = "CONNECT_TIMEOUT",
+    MEDIA_PERMISSION_DENIED = "MEDIA_PERMISSION_DENIED",
+    MEDIA_NOT_FOUND = "MEDIA_NOT_FOUND",
+    MEDIA_GENERIC = "MEDIA_GENERIC",
+    PEER_CONNECTION_FAILED = "PEER_CONNECTION_FAILED",
+    ICE_FAILED = "ICE_FAILED",
+    OFFER_FAILED = "OFFER_FAILED",
+    ANSWER_FAILED = "ANSWER_FAILED",
+    ROOM_FULL = "ROOM_FULL",
+    ROOM_FORBIDDEN = "ROOM_FORBIDDEN",
+    WEBSOCKET_ERROR = "WEBSOCKET_ERROR",
+    INSECURE_CONTEXT = "INSECURE_CONTEXT",
+    MICROPHONE_NOT_FOUND = "MICROPHONE_NOT_FOUND",
+    MICROPHONE_PERMISSION_DENIED = "MICROPHONE_PERMISSION_DENIED",
+    CAMERA_PERMISSION_DENIED = "CAMERA_PERMISSION_DENIED",
+    CAMERA_NOT_FOUND = "CAMERA_NOT_FOUND",
+    SCREENSHARE_FAILED = "SCREENSHARE_FAILED",
+    UNKNOWN = "UNKNOWN"
+}
+export declare const VoiceErrorMessages: Record<VoiceErrorCode, string>;
+export interface VoiceError {
+    code: VoiceErrorCode;
+    message: string;
+}
+export declare function createVoiceError(code: VoiceErrorCode, detail?: string): VoiceError;
+/**
+ * Errors that should NOT set the persistent voiceError state.
+ * These are non-fatal — the audio call is still working.
+ * They should be shown as transient toasts instead.
+ */
+export declare const TRANSIENT_ERROR_CODES: Set<VoiceErrorCode>;