@dlh.io/bideux 0.1.0

package/dist/chunk-IMNUQGHE.js

@@ -0,0 +1,2864 @@
+import { parseDocument, isMap, LineCounter, isSeq, isScalar, Document } from 'yaml';
+
+// ../dashboard-core/src/dashboard-template.ts
+function dashboardTemplate(options) {
+  const { slug, name, description = "" } = options;
+  return [
+    'version: "1.0"',
+    "kind: dashboard",
+    "metadata:",
+    `  id: ${slug}`,
+    `  name: ${JSON.stringify(name)}`,
+    `  description: ${JSON.stringify(description)}`,
+    "spec:",
+    "  config:",
+    "    filterPanel:",
+    "      position: top",
+    "      collapsible: true",
+    "  tabs:",
+    "    - id: main",
+    "      label: Main",
+    "      widgets: []",
+    ""
+  ].join("\n");
+}
+
+// ../dashboard-core/src/grid-config.ts
+var MAX_LAYOUT_WIDTHS = {
+  mobile: 480,
+  tablet: 768,
+  desktop: 1024,
+  wide: 1440
+};
+var DEFAULT_GRID_CONFIG = {
+  compactType: "vertical",
+  preventCollision: false,
+  allowOverlap: false,
+  isBounded: true,
+  draggableHandle: ".custom-drag-handle",
+  draggableCancel: ".widget-edit-btn, .widget-remove-btn",
+  resizeHandles: ["se", "sw"],
+  containerPadding: null,
+  maxRows: 12,
+  maxLayoutWidth: "wide",
+  snap: false,
+  squareCells: true
+};
+function resolveSnap(grid, snap) {
+  if (grid.allowOverlap) {
+    return { compactType: null, preventCollision: false };
+  }
+  if (!snap) {
+    return { compactType: null, preventCollision: true };
+  }
+  return {
+    compactType: grid.compactType ?? "vertical",
+    preventCollision: false
+  };
+}
+
+// ../dashboard-core/src/layout.ts
+var BREAKPOINT_MAP = {
+  lg: "wide",
+  md: "desktop",
+  sm: "tablet",
+  xs: "mobile",
+  xxs: "mobile"
+};
+var NARROW_KEYS = ["xs", "xxs"];
+var CONTROL_COMPONENTS = /* @__PURE__ */ new Set(["filter", "select"]);
+function isControlComponent(component) {
+  return CONTROL_COMPONENTS.has(component);
+}
+function filterPanelConfig(dashboard) {
+  const config = dashboard.spec.config;
+  if (config === void 0 || config === null) return void 0;
+  const panel = config.filterPanel ?? config["filter_panel"];
+  if (typeof panel !== "object" || panel === null || Array.isArray(panel)) {
+    return void 0;
+  }
+  return panel;
+}
+function isPanelledControl(widget, dashboard) {
+  return Boolean(filterPanelConfig(dashboard)) && isControlComponent(widget.spec.component ?? "echarts");
+}
+function stripPanelledControls(layouts, widgets, dashboard) {
+  const controls = new Set(
+    Object.values(widgets).filter((widget) => isPanelledControl(widget, dashboard)).map((widget) => widget.metadata.id)
+  );
+  if (controls.size === 0) return layouts;
+  const out = {};
+  for (const [key, list] of Object.entries(layouts)) {
+    out[key] = (list ?? []).filter((item) => !controls.has(item.i));
+  }
+  return out;
+}
+function clamp(n, min, max) {
+  return Math.max(min, Math.min(n, max));
+}
+function layoutForBreakpoint(widget, bp, colCount, maxRows) {
+  const base = widget.spec.layout ?? {};
+  const responsive = base.responsive ?? {};
+  const bpLayout = responsive[bp] ?? base;
+  const minW = clamp(bpLayout.minW ?? base.minW ?? 2, 1, colCount);
+  const minH = Math.max(1, bpLayout.minH ?? base.minH ?? 2);
+  const w = clamp(bpLayout.w ?? base.w ?? 4, minW, colCount);
+  const x = clamp(bpLayout.x ?? base.x ?? 0, 0, colCount - w);
+  let h = Math.max(minH, bpLayout.h ?? base.h ?? 4);
+  const y = Math.max(0, bpLayout.y ?? base.y ?? 0);
+  if (maxRows !== void 0 && maxRows > 0) {
+    h = Math.min(h, maxRows);
+  }
+  const layout = {
+    i: widget.metadata.id,
+    x,
+    y,
+    w,
+    h,
+    minW,
+    minH
+  };
+  const maxW = bpLayout.maxW ?? base.maxW;
+  if (typeof maxW === "number" && maxW > 0) {
+    layout.maxW = clamp(maxW, 1, colCount);
+  }
+  const maxH = bpLayout.maxH ?? base.maxH;
+  if (typeof maxH === "number" && maxH > 0) {
+    layout.maxH = Math.max(1, maxH);
+  }
+  const isBounded = bpLayout.isBounded ?? base.isBounded;
+  if (typeof isBounded === "boolean") layout.isBounded = isBounded;
+  const isDraggable = bpLayout.isDraggable ?? base.isDraggable;
+  if (typeof isDraggable === "boolean") layout.isDraggable = isDraggable;
+  const isResizable = bpLayout.isResizable ?? base.isResizable;
+  if (typeof isResizable === "boolean") layout.isResizable = isResizable;
+  const resizeHandles = bpLayout.resizeHandles ?? base.resizeHandles;
+  if (Array.isArray(resizeHandles) && resizeHandles.length > 0) {
+    layout.resizeHandles = resizeHandles;
+  }
+  return layout;
+}
+function itemsCollide(a, b) {
+  if (a.i === b.i) return false;
+  return a.x < b.x + b.w && a.x + a.w > b.x && a.y < b.y + b.h && a.y + a.h > b.y;
+}
+function firstFreeSlot(existing, w, h, colCount) {
+  const width = Math.min(w, colCount);
+  const bottomY = existing.reduce(
+    (max, item) => Math.max(max, item.y + item.h),
+    0
+  );
+  for (let y = 0; y <= bottomY; y += 1) {
+    for (let x = 0; x + width <= colCount; x += 1) {
+      const candidate = { i: "__probe__", x, y, w: width, h };
+      if (!existing.some((item) => itemsCollide(candidate, item))) {
+        return { x, y };
+      }
+    }
+  }
+  return { x: 0, y: bottomY };
+}
+function resolveCollisions(items) {
+  const ordered = [...items].sort((a, b) => a.y - b.y || a.x - b.x);
+  const placed = [];
+  for (const item of ordered) {
+    let y = Math.max(0, item.y);
+    let candidate = { ...item, y };
+    while (placed.some((other) => itemsCollide(candidate, other))) {
+      y += 1;
+      candidate = { ...item, y };
+    }
+    placed.push(candidate);
+  }
+  const byId = new Map(placed.map((item) => [item.i, item]));
+  return items.map((item) => byId.get(item.i) ?? item);
+}
+function requiredRows(layouts) {
+  let rows = 0;
+  for (const list of Object.values(layouts)) {
+    for (const item of list ?? []) {
+      rows = Math.max(rows, item.y + item.h);
+    }
+  }
+  return rows;
+}
+function overlappingIds(layouts) {
+  const found = /* @__PURE__ */ new Set();
+  for (const list of Object.values(layouts)) {
+    const items = list ?? [];
+    for (let i = 0; i < items.length; i += 1) {
+      for (let j = i + 1; j < items.length; j += 1) {
+        const first = items[i];
+        const second = items[j];
+        if (first !== void 0 && second !== void 0 && itemsCollide(first, second)) {
+          found.add(first.i);
+          found.add(second.i);
+        }
+      }
+    }
+  }
+  return [...found];
+}
+function movedIds(before, after, only) {
+  const found = /* @__PURE__ */ new Set();
+  for (const [key, list] of Object.entries(before)) {
+    if (only !== void 0 && key !== only) continue;
+    const afterById = new Map(
+      (after[key] ?? []).map((item) => [item.i, item])
+    );
+    for (const item of list ?? []) {
+      const moved = afterById.get(item.i);
+      if (!moved) continue;
+      if (moved.x !== item.x || moved.y !== item.y || moved.w !== item.w || moved.h !== item.h) {
+        found.add(item.i);
+      }
+    }
+  }
+  return [...found];
+}
+function maybeResolve(items, resolve) {
+  return resolve ? resolveCollisions(items) : items;
+}
+function placeWidgetInFirstGap(widget, bp, colCount, existing, maxRows) {
+  const layout = layoutForBreakpoint(widget, bp, colCount, maxRows);
+  const slot = firstFreeSlot(existing, layout.w, layout.h, colCount);
+  layout.x = slot.x;
+  layout.y = slot.y;
+  return layout;
+}
+function dashboardColumns(dashboard, gridOverrides) {
+  const responsive = dashboard.spec.responsive;
+  return {
+    lg: gridOverrides.wide?.cols ?? responsive?.wide?.cols ?? 24,
+    md: gridOverrides.desktop?.cols ?? responsive?.desktop?.cols ?? 24,
+    sm: gridOverrides.tablet?.cols ?? responsive?.tablet?.cols ?? 24,
+    xs: gridOverrides.mobile?.cols ?? responsive?.mobile?.cols ?? 24,
+    xxs: gridOverrides.mobile?.cols ?? responsive?.mobile?.cols ?? 24
+  };
+}
+var LAYOUT_BREAKPOINTS = {
+  lg: { bp: "wide", cols: "lg" },
+  md: { bp: "desktop", cols: "md" },
+  sm: { bp: "tablet", cols: "sm" },
+  xs: { bp: "mobile", cols: "xs" },
+  xxs: { bp: "mobile", cols: "xxs" }
+};
+function ensureLayoutCoverage(layouts, widgets, dashboard, gridOverrides = {}, unplacedWidgetIds = [], maxRows) {
+  const cols = dashboardColumns(dashboard, gridOverrides);
+  const base = buildBaseLayouts(
+    widgets,
+    dashboard,
+    gridOverrides,
+    unplacedWidgetIds,
+    maxRows,
+    { resolve: false }
+  );
+  const out = {};
+  const excluded = new Set(unplacedWidgetIds);
+  for (const [key, { bp, cols: colsKey }] of Object.entries(
+    LAYOUT_BREAKPOINTS
+  )) {
+    const existing = [...layouts[key] ?? []].filter(
+      (item) => {
+        const widget = widgets[item.i];
+        return widget !== void 0 && !excluded.has(item.i) && !isPanelledControl(widget, dashboard);
+      }
+    );
+    const ids = new Set(existing.map((item) => item.i));
+    const colCount = cols[colsKey];
+    for (const widget of Object.values(widgets)) {
+      if (ids.has(widget.metadata.id)) continue;
+      if (!(base[key] ?? []).some((item) => item.i === widget.metadata.id)) {
+        continue;
+      }
+      existing.push(
+        placeWidgetInFirstGap(widget, bp, colCount, existing, maxRows)
+      );
+      ids.add(widget.metadata.id);
+    }
+    out[key] = existing;
+  }
+  return out;
+}
+function rescaleLayoutColumns(layouts, key, oldCols, newCols) {
+  const safeOldCols = Math.max(1, Math.floor(oldCols));
+  const safeNewCols = Math.max(1, Math.floor(newCols));
+  if (safeOldCols === safeNewCols) return layouts;
+  const list = layouts[key];
+  if (!list) return layouts;
+  return {
+    ...layouts,
+    [key]: list.map((item) => {
+      const w = clamp(
+        Math.round(item.w * safeNewCols / safeOldCols),
+        1,
+        safeNewCols
+      );
+      const x = clamp(
+        Math.round(item.x * safeNewCols / safeOldCols),
+        0,
+        safeNewCols - w
+      );
+      const minW = item.minW === void 0 ? void 0 : clamp(Math.round(item.minW * safeNewCols / safeOldCols), 1, w);
+      const maxW = item.maxW === void 0 ? void 0 : clamp(
+        Math.round(item.maxW * safeNewCols / safeOldCols),
+        w,
+        safeNewCols
+      );
+      return {
+        ...item,
+        x,
+        w,
+        ...minW === void 0 ? {} : { minW },
+        ...maxW === void 0 ? {} : { maxW }
+      };
+    })
+  };
+}
+function computeRequiredMaxRows(layouts, widget, dashboard, gridOverrides = {}, currentMaxRows) {
+  if (isPanelledControl(widget, dashboard)) return currentMaxRows;
+  const cols = dashboardColumns(dashboard, gridOverrides);
+  const bpMap = {
+    lg: { bp: "wide", cols: cols.lg },
+    md: { bp: "desktop", cols: cols.md },
+    sm: { bp: "tablet", cols: cols.sm },
+    xs: { bp: "mobile", cols: cols.xs },
+    xxs: { bp: "mobile", cols: cols.xxs }
+  };
+  let required = 0;
+  for (const [key, { bp, cols: colCount }] of Object.entries(bpMap)) {
+    const list = layouts[key] ?? [];
+    const bottomY = list.reduce(
+      (max, item) => Math.max(max, item.y + item.h),
+      0
+    );
+    const h = layoutForBreakpoint(widget, bp, colCount, void 0).h;
+    required = Math.max(required, bottomY + h);
+  }
+  if (currentMaxRows === void 0 || !Number.isFinite(currentMaxRows)) {
+    return currentMaxRows;
+  }
+  return Math.max(currentMaxRows, required);
+}
+function addWidgetToLayouts(layouts, widget, dashboard, gridOverrides = {}, maxRows) {
+  if (isPanelledControl(widget, dashboard)) {
+    const cleared = {};
+    for (const [key, list] of Object.entries(layouts)) {
+      cleared[key] = (list ?? []).filter(
+        (item) => item.i !== widget.metadata.id
+      );
+    }
+    return cleared;
+  }
+  const cols = dashboardColumns(dashboard, gridOverrides);
+  const bpMap = {
+    lg: { bp: "wide", cols: cols.lg },
+    md: { bp: "desktop", cols: cols.md },
+    sm: { bp: "tablet", cols: cols.sm },
+    xs: { bp: "mobile", cols: cols.xs },
+    xxs: { bp: "mobile", cols: cols.xxs }
+  };
+  const next = {};
+  for (const [key, { bp, cols: colCount }] of Object.entries(bpMap)) {
+    const list = (layouts[key] ?? []).filter(
+      (item) => item.i !== widget.metadata.id
+    );
+    next[key] = [
+      ...list,
+      placeWidgetInFirstGap(widget, bp, colCount, list, maxRows)
+    ];
+  }
+  return next;
+}
+function filterLayoutsByIds(layouts, ids) {
+  const out = {};
+  for (const [key, list] of Object.entries(layouts)) {
+    out[key] = (list ?? []).filter((item) => ids.has(item.i));
+  }
+  return out;
+}
+function clampLayoutItem(item, colCount, maxRows) {
+  const w = Math.min(item.w, colCount);
+  const x = Math.max(0, Math.min(item.x, colCount - w));
+  let h = item.h;
+  const y = Math.max(0, item.y);
+  if (maxRows !== void 0 && maxRows > 0) {
+    h = Math.min(h, maxRows);
+  }
+  return { ...item, x, y, w, h };
+}
+function sanitizeLayouts(layouts, cols, maxRows) {
+  const colCounts = {
+    lg: cols.lg,
+    md: cols.md,
+    sm: cols.sm,
+    xs: cols.xs,
+    xxs: cols.xxs
+  };
+  const out = {};
+  for (const [key, list] of Object.entries(layouts)) {
+    const colCount = colCounts[key] ?? cols.md;
+    out[key] = resolveCollisions(
+      (list ?? []).map((item) => clampLayoutItem(item, colCount, maxRows))
+    );
+  }
+  return out;
+}
+function mergeLayouts(base, overlay) {
+  const out = {};
+  const keys = /* @__PURE__ */ new Set([...Object.keys(base), ...Object.keys(overlay)]);
+  for (const key of keys) {
+    const baseList = base[key] ?? [];
+    const overlayList = overlay[key] ?? [];
+    const map = new Map(baseList.map((item) => [item.i, item]));
+    for (const item of overlayList) {
+      map.set(item.i, item);
+    }
+    out[key] = Array.from(map.values());
+  }
+  return out;
+}
+function syncDesktopWideLayouts(layouts, cols) {
+  if (cols.lg !== cols.md) return layouts;
+  const md = layouts.md ?? [];
+  const lg = layouts.lg ?? [];
+  if (md.length === 0 && lg.length === 0) return layouts;
+  const out = { ...layouts };
+  if (md.length === 0 && lg.length > 0) {
+    out.md = lg.map((item) => ({ ...item }));
+  } else if (lg.length === 0 && md.length > 0) {
+    out.lg = md.map((item) => ({ ...item }));
+  }
+  return out;
+}
+function syncActiveLayoutToDesktopWide(layouts, activeKey, cols) {
+  if (cols.lg !== cols.md) return layouts;
+  if (activeKey !== "md" && activeKey !== "lg") return layouts;
+  const sibling = activeKey === "md" ? "lg" : "md";
+  const activeList = layouts[activeKey] ?? [];
+  if (activeList.length === 0) return layouts;
+  return { ...layouts, [sibling]: activeList.map((item) => ({ ...item })) };
+}
+function stackItems(items, colCount) {
+  const ordered = [...items].sort((a, b) => a.y - b.y || a.x - b.x);
+  let y = 0;
+  const placed = /* @__PURE__ */ new Map();
+  for (const item of ordered) {
+    placed.set(item.i, {
+      ...item,
+      x: 0,
+      y,
+      w: colCount,
+      ...item.minW === void 0 ? {} : { minW: Math.min(item.minW, colCount) },
+      // An authored ceiling of half the grid would undo the full width.
+      ...item.maxW !== void 0 ? { maxW: colCount } : {}
+    });
+    y += item.h;
+  }
+  return items.map((item) => placed.get(item.i) ?? item);
+}
+function stackNarrowLayouts(layouts, cols) {
+  const out = { ...layouts };
+  for (const key of NARROW_KEYS) {
+    const list = layouts[key] ?? [];
+    if (list.length === 0) continue;
+    out[key] = stackItems(list, cols[key]);
+  }
+  return out;
+}
+function buildBaseLayouts(widgets, dashboard, gridOverrides = {}, unplacedWidgetIds, maxRows, options = {}) {
+  const resolve = options.resolve !== false;
+  const exclude = new Set(unplacedWidgetIds ?? []);
+  const controlsArePanelled = Boolean(filterPanelConfig(dashboard));
+  const widgetList = Object.values(widgets).filter(
+    (w) => !exclude.has(w.metadata.id) && !(controlsArePanelled && isControlComponent(w.spec.component ?? "echarts"))
+  );
+  const cols = dashboardColumns(dashboard, gridOverrides);
+  const bpMap = {
+    lg: { bp: "wide", cols: cols.lg },
+    md: { bp: "desktop", cols: cols.md },
+    sm: { bp: "tablet", cols: cols.sm },
+    xs: { bp: "mobile", cols: cols.xs },
+    xxs: { bp: "mobile", cols: cols.xxs }
+  };
+  return Object.fromEntries(
+    Object.entries(bpMap).map(([key, { bp, cols: colCount }]) => [
+      key,
+      // Saved specs can declare the same cell twice, and a widget written by the
+      // Builder or the assistant starts at 0,0 by default, so the positions are
+      // separated here rather than drawn on top of each other.
+      maybeResolve(
+        widgetList.map((w) => layoutForBreakpoint(w, bp, colCount, maxRows)),
+        resolve
+      )
+    ])
+  );
+}
+function layoutsForSave(layouts) {
+  const out = {};
+  for (const key of ["lg", "md", "sm", "xs", "xxs"]) {
+    const items = layouts[key];
+    const bp = BREAKPOINT_MAP[key];
+    if (!items || bp === void 0 || out[bp] !== void 0) continue;
+    out[bp] = items.map((item) => ({ ...item }));
+  }
+  return out;
+}
+var DATASET_KEYS = /* @__PURE__ */ new Set([
+  "id",
+  "name",
+  "description",
+  "data_store_id",
+  "source",
+  "from",
+  "source_type",
+  "filter_field",
+  "filter_param",
+  "dimensions",
+  "fields",
+  "metrics",
+  "materialization",
+  "cache"
+]);
+var RELATIONSHIP_KEYS = /* @__PURE__ */ new Set([
+  "name",
+  "description",
+  "from",
+  "to",
+  "from_columns",
+  "to_columns",
+  "relationship"
+]);
+var MODEL_METRIC_KEYS = /* @__PURE__ */ new Set([
+  "id",
+  "name",
+  "label",
+  "description",
+  "expression",
+  "type",
+  "format"
+]);
+var AGGREGATIONS = ["SUM", "AVG", "MIN", "MAX", "COUNT"];
+function dimensionTypeFor(warehouseType) {
+  const type = warehouseType.toUpperCase();
+  if (/DATE|TIME|TIMESTAMP/.test(type)) return "date";
+  if (/INT|NUM|DEC|FLOAT|DOUBLE|REAL/.test(type)) return "number";
+  if (/BOOL/.test(type)) return "boolean";
+  return "string";
+}
+function aggregationExpression(aggregation, column) {
+  return `${aggregation}(${column})`;
+}
+function parseAggregation(expression) {
+  const match = /^\s*(\w+)\s*\(\s*([\w."]+)\s*\)\s*$/.exec(expression);
+  if (!match) return null;
+  const rawName = match[1];
+  const column = match[2];
+  if (rawName === void 0 || column === void 0) return null;
+  const name = rawName.toUpperCase();
+  if (!AGGREGATIONS.includes(name)) return null;
+  return { aggregation: name, column };
+}
+function parseModelDocument(specYaml) {
+  const doc = parseDocument(specYaml);
+  const first = doc.errors[0];
+  if (first) {
+    return {
+      doc: null,
+      error: {
+        message: first.message,
+        line: first.linePos?.[0].line ?? 1
+      }
+    };
+  }
+  if (!isMap(doc.contents)) {
+    return {
+      doc: null,
+      error: { message: "The model must be a YAML mapping.", line: 1 }
+    };
+  }
+  return { doc, error: null };
+}
+function str(node) {
+  return typeof node === "string" && node !== "" ? node : null;
+}
+function seqOf(doc, key) {
+  const node = doc.get(key, true);
+  return isSeq(node) ? node : null;
+}
+function mapsOf(seq) {
+  if (!seq) return [];
+  return seq.items.filter((item) => isMap(item));
+}
+function findByKey(seq, key, value) {
+  return mapsOf(seq).find((item) => item.get(key) === value) ?? null;
+}
+function findById(seq, id) {
+  return findByKey(seq, "id", id);
+}
+function setStringSeq(doc, map, key, values) {
+  if (values.length === 0) {
+    if (map.has(key)) map.delete(key);
+    return;
+  }
+  const current = stringList(map.get(key, true));
+  if (current.length === values.length && current.every((value, index) => value === values[index])) {
+    return;
+  }
+  map.set(key, doc.createNode(values));
+}
+function setOrDelete(map, key, value) {
+  if (value === null || value === void 0 || value === "") {
+    if (map.has(key)) map.delete(key);
+    return;
+  }
+  map.set(key, value);
+}
+function readDataStores(doc) {
+  return mapsOf(seqOf(doc, "data_stores")).flatMap((item) => {
+    const id = str(item.get("id"));
+    if (!id) return [];
+    return [
+      {
+        id,
+        name: str(item.get("name")),
+        vendor: str(item.get("vendor")),
+        dataModelId: str(item.get("data_model_id")),
+        isDefault: item.get("default") === true
+      }
+    ];
+  });
+}
+function readDimensions(item) {
+  const node = item.get("dimensions", true) ?? item.get("fields", true);
+  if (!isSeq(node)) return [];
+  return mapsOf(node).flatMap((dim) => {
+    const id = str(dim.get("id"));
+    if (!id) return [];
+    const type = str(dim.get("type")) ?? "string";
+    return [
+      {
+        id,
+        column: str(dim.get("column")),
+        type: ["string", "number", "date", "time", "boolean"].includes(type) ? type : "string",
+        isTime: dim.get("is_time") === true
+      }
+    ];
+  });
+}
+function readMetrics(item) {
+  const node = item.get("metrics", true);
+  if (!isSeq(node)) return [];
+  return mapsOf(node).flatMap((metric) => {
+    const id = str(metric.get("id"));
+    const expression = metric.get("expression");
+    if (!id || typeof expression !== "string") return [];
+    return [
+      {
+        id,
+        label: str(metric.get("label")) ?? str(metric.get("name")),
+        expression,
+        type: metric.get("type") === "formula" ? "formula" : "sql"
+      }
+    ];
+  });
+}
+function stringList(node) {
+  if (!isSeq(node)) return [];
+  return node.items.flatMap((item) => {
+    const value = isScalar(item) ? item.value : item;
+    return typeof value === "string" ? [value] : [];
+  });
+}
+function readRollup(item) {
+  const node = item.get("materialization", true);
+  if (!isMap(node)) return null;
+  return {
+    source: str(node.get("source")),
+    grain: stringList(node.get("grain", true)),
+    metrics: stringList(node.get("metrics", true))
+  };
+}
+function keyName(key) {
+  const value = isScalar(key) ? key.value : key;
+  return typeof value === "string" ? value : null;
+}
+var PRESERVED_KEYS = /* @__PURE__ */ new Set([
+  "ai_context",
+  "primary_key",
+  "tags",
+  "labels",
+  "owner",
+  "synonyms",
+  "grain",
+  "params",
+  "time_dimension",
+  "default_time_dimension"
+]);
+function blockingKeys(keys) {
+  return keys.filter((key) => !PRESERVED_KEYS.has(key));
+}
+function preservedKeys(keys) {
+  return keys.filter((key) => PRESERVED_KEYS.has(key));
+}
+function unsupportedKeys(item, owned) {
+  return item.items.map((pair) => keyName(pair.key)).filter((key) => key !== null && !owned.has(key));
+}
+function readDatasets(doc) {
+  return mapsOf(seqOf(doc, "datasets")).flatMap((item) => {
+    const id = str(item.get("id"));
+    if (!id) return [];
+    return [
+      {
+        id,
+        name: str(item.get("name")),
+        dataStoreId: str(item.get("data_store_id")),
+        source: str(item.get("source")) ?? str(item.get("from")),
+        sourceType: str(item.get("source_type")),
+        filterField: str(item.get("filter_field")),
+        dimensions: readDimensions(item),
+        metrics: readMetrics(item),
+        rollup: readRollup(item),
+        unsupportedKeys: unsupportedKeys(item, DATASET_KEYS)
+      }
+    ];
+  });
+}
+var CARDINALITIES = [
+  "one_to_one",
+  "many_to_one",
+  "one_to_many",
+  "many_to_many"
+];
+function readRelationships(doc) {
+  return mapsOf(seqOf(doc, "relationships")).flatMap((item) => {
+    const name = str(item.get("name"));
+    if (!name) return [];
+    const cardinality = str(item.get("relationship"));
+    return [
+      {
+        name,
+        from: str(item.get("from")),
+        to: str(item.get("to")),
+        fromColumns: stringList(item.get("from_columns", true)),
+        toColumns: stringList(item.get("to_columns", true)),
+        cardinality: CARDINALITIES.includes(cardinality ?? "") ? cardinality : null,
+        unsupportedKeys: unsupportedKeys(item, RELATIONSHIP_KEYS)
+      }
+    ];
+  });
+}
+function readModelMetrics(doc) {
+  return mapsOf(seqOf(doc, "metrics")).flatMap((item) => {
+    const id = str(item.get("id"));
+    if (!id) return [];
+    const expression = item.get("expression");
+    return [
+      {
+        id,
+        label: str(item.get("name")) ?? str(item.get("label")),
+        description: str(item.get("description")),
+        // A per-dialect expression map is beyond this editor: an empty
+        // expression is how the panel knows to stay read-only.
+        expression: typeof expression === "string" ? expression : "",
+        type: item.get("type") === "formula" ? "formula" : "sql",
+        format: str(item.get("format")),
+        unsupportedKeys: unsupportedKeys(item, MODEL_METRIC_KEYS)
+      }
+    ];
+  });
+}
+function modelText(doc) {
+  return doc.toString({ lineWidth: 0, flowCollectionPadding: false });
+}
+function ensureSeq(doc, key) {
+  const existing = seqOf(doc, key);
+  if (existing) return existing;
+  doc.set(key, doc.createNode([]));
+  const created = seqOf(doc, key);
+  if (!created) throw new Error(`Could not create ${key} in the model`);
+  return created;
+}
+function upsertDataStore(specYaml, store, originalId) {
+  const { doc } = parseModelDocument(specYaml);
+  if (!doc) return specYaml;
+  const seq = ensureSeq(doc, "data_stores");
+  const existing = findById(seq, originalId ?? store.id);
+  const target = existing ?? doc.createNode({ id: store.id });
+  target.set("id", store.id);
+  setOrDelete(target, "name", store.name);
+  setOrDelete(target, "vendor", store.vendor);
+  setOrDelete(target, "data_model_id", store.dataModelId);
+  if (store.isDefault) {
+    target.set("default", true);
+    for (const other of mapsOf(seq)) {
+      if (other !== target && other.get("default") === true)
+        other.delete("default");
+    }
+  } else if (target.has("default")) {
+    target.delete("default");
+  }
+  if (!existing) seq.add(target);
+  return modelText(doc);
+}
+function removeDataStore(specYaml, id) {
+  const { doc } = parseModelDocument(specYaml);
+  if (!doc) return specYaml;
+  const seq = seqOf(doc, "data_stores");
+  if (!seq) return specYaml;
+  const index = seq.items.findIndex(
+    (item) => isMap(item) && item.get("id") === id
+  );
+  if (index >= 0) seq.delete(index);
+  return modelText(doc);
+}
+function dimensionNode(doc, dimension) {
+  const node = {
+    id: dimension.id,
+    type: dimension.type
+  };
+  if (dimension.column && dimension.column !== dimension.id) {
+    node.column = dimension.column;
+  }
+  if (dimension.isTime) node.is_time = true;
+  const created = doc.createNode(node);
+  if (!isMap(created)) throw new Error("Could not create a dimension");
+  created.flow = false;
+  return created;
+}
+function metricNode(doc, metric) {
+  const node = {
+    id: metric.id,
+    type: metric.type,
+    expression: metric.expression
+  };
+  if (metric.label) node.label = metric.label;
+  const created = doc.createNode(node);
+  if (!isMap(created)) throw new Error("Could not create a metric");
+  created.flow = false;
+  return created;
+}
+function upsertDataset(specYaml, dataset, originalId) {
+  const { doc } = parseModelDocument(specYaml);
+  if (!doc) return specYaml;
+  const seq = ensureSeq(doc, "datasets");
+  const existing = findById(seq, originalId ?? dataset.id);
+  const target = existing ?? doc.createNode({ id: dataset.id });
+  target.set("id", dataset.id);
+  setOrDelete(target, "name", dataset.name);
+  setOrDelete(target, "data_store_id", dataset.dataStoreId);
+  if (target.has("from") && !target.has("source")) {
+    setOrDelete(target, "from", dataset.source);
+  } else {
+    setOrDelete(target, "source", dataset.source);
+  }
+  setOrDelete(target, "source_type", dataset.sourceType);
+  setOrDelete(target, "filter_field", dataset.filterField);
+  const dimensionsKey = target.has("fields") && !target.has("dimensions") ? "fields" : "dimensions";
+  if (dataset.dimensions.length > 0) {
+    target.set(
+      dimensionsKey,
+      doc.createNode(dataset.dimensions.map((d) => dimensionNode(doc, d)))
+    );
+  } else if (target.has(dimensionsKey)) {
+    target.delete(dimensionsKey);
+  }
+  if (dataset.metrics.length > 0) {
+    target.set(
+      "metrics",
+      doc.createNode(dataset.metrics.map((m) => metricNode(doc, m)))
+    );
+  } else if (target.has("metrics")) {
+    target.delete("metrics");
+  }
+  if (dataset.rollup) {
+    const rollup = { enabled: true };
+    if (dataset.rollup.source) rollup.source = dataset.rollup.source;
+    rollup.grain = dataset.rollup.grain;
+    rollup.metrics = dataset.rollup.metrics;
+    target.set("materialization", doc.createNode(rollup));
+  } else if (target.has("materialization")) {
+    target.delete("materialization");
+  }
+  if (!existing) seq.add(target);
+  return modelText(doc);
+}
+function removeDataset(specYaml, id) {
+  const { doc } = parseModelDocument(specYaml);
+  if (!doc) return specYaml;
+  const seq = seqOf(doc, "datasets");
+  if (!seq) return specYaml;
+  const index = seq.items.findIndex(
+    (item) => isMap(item) && item.get("id") === id
+  );
+  if (index >= 0) seq.delete(index);
+  return modelText(doc);
+}
+function upsertRelationship(specYaml, relationship, originalName) {
+  const { doc } = parseModelDocument(specYaml);
+  if (!doc) return specYaml;
+  const seq = ensureSeq(doc, "relationships");
+  const existing = findByKey(seq, "name", originalName ?? relationship.name);
+  const target = existing ?? doc.createNode({ name: relationship.name });
+  target.set("name", relationship.name);
+  setOrDelete(target, "from", relationship.from);
+  setOrDelete(target, "to", relationship.to);
+  setStringSeq(doc, target, "from_columns", relationship.fromColumns);
+  setStringSeq(doc, target, "to_columns", relationship.toColumns);
+  setOrDelete(target, "relationship", relationship.cardinality);
+  if (!existing) seq.add(target);
+  return modelText(doc);
+}
+function removeRelationship(specYaml, name) {
+  const { doc } = parseModelDocument(specYaml);
+  if (!doc) return specYaml;
+  const seq = seqOf(doc, "relationships");
+  if (!seq) return specYaml;
+  const index = seq.items.findIndex(
+    (item) => isMap(item) && item.get("name") === name
+  );
+  if (index >= 0) seq.delete(index);
+  return modelText(doc);
+}
+function upsertModelMetric(specYaml, metric, originalId) {
+  const { doc } = parseModelDocument(specYaml);
+  if (!doc) return specYaml;
+  const seq = ensureSeq(doc, "metrics");
+  const existing = findById(seq, originalId ?? metric.id);
+  const target = existing ?? doc.createNode({ id: metric.id });
+  target.set("id", metric.id);
+  if (target.has("label") && !target.has("name")) {
+    setOrDelete(target, "label", metric.label);
+  } else {
+    setOrDelete(target, "name", metric.label);
+  }
+  setOrDelete(target, "description", metric.description);
+  target.set("type", metric.type);
+  target.set("expression", metric.expression);
+  setOrDelete(target, "format", metric.format);
+  if (!existing) seq.add(target);
+  return modelText(doc);
+}
+function removeModelMetric(specYaml, id) {
+  const { doc } = parseModelDocument(specYaml);
+  if (!doc) return specYaml;
+  const seq = seqOf(doc, "metrics");
+  if (!seq) return specYaml;
+  const index = seq.items.findIndex(
+    (item) => isMap(item) && item.get("id") === id
+  );
+  if (index >= 0) seq.delete(index);
+  return modelText(doc);
+}
+function ratioExpression(numerator, denominator) {
+  const top = `${numerator.aggregation}(${numerator.dataset}.${numerator.column})`;
+  const bottom = `${denominator.aggregation}(${denominator.dataset}.${denominator.column})`;
+  return `${top} / NULLIF(${bottom}, 0)`;
+}
+var RATIO_PATTERN = /^\s*(\w+)\(([\w$]+)\.([\w$]+)\)\s*\/\s*NULLIF\(\s*(\w+)\(([\w$]+)\.([\w$]+)\)\s*,\s*0\s*\)\s*(\*\s*100)?\s*$/i;
+function parseRatioExpression(expression) {
+  const match = RATIO_PATTERN.exec(expression);
+  if (!match) return null;
+  const topAggregation = match[1];
+  const topDataset = match[2];
+  const topColumn = match[3];
+  const bottomAggregation = match[4];
+  const bottomDataset = match[5];
+  const bottomColumn = match[6];
+  if (topAggregation === void 0 || topDataset === void 0 || topColumn === void 0 || bottomAggregation === void 0 || bottomDataset === void 0 || bottomColumn === void 0) {
+    return null;
+  }
+  const topAgg = topAggregation.toUpperCase();
+  const bottomAgg = bottomAggregation.toUpperCase();
+  if (!AGGREGATIONS.includes(topAgg) || !AGGREGATIONS.includes(bottomAgg)) {
+    return null;
+  }
+  return {
+    numerator: {
+      aggregation: topAgg,
+      dataset: topDataset,
+      column: topColumn
+    },
+    denominator: {
+      aggregation: bottomAgg,
+      dataset: bottomDataset,
+      column: bottomColumn
+    },
+    scaledBy100: Boolean(match[7])
+  };
+}
+function isDoubleScaledPercent(expression, format) {
+  if (format !== "percent") return false;
+  return /\*\s*100\s*$/.test(expression.trim());
+}
+function fragmentOf(specYaml, collection, value, key = "id") {
+  const { doc } = parseModelDocument(specYaml);
+  if (!doc) return "";
+  const item = findByKey(seqOf(doc, collection), key, value);
+  if (!item) return "";
+  return modelText(new Document(item)).trimEnd();
+}
+function datasetFragment(specYaml, id) {
+  return fragmentOf(specYaml, "datasets", id);
+}
+function dataStoreFragment(specYaml, id) {
+  return fragmentOf(specYaml, "data_stores", id);
+}
+function relationshipFragment(specYaml, name) {
+  return fragmentOf(specYaml, "relationships", name, "name");
+}
+function modelMetricFragment(specYaml, id) {
+  return fragmentOf(specYaml, "metrics", id);
+}
+function readModelOutline(specYaml) {
+  const { doc, error } = parseModelDocument(specYaml);
+  if (!doc) {
+    return {
+      dataStores: [],
+      datasets: [],
+      relationships: [],
+      modelMetrics: [],
+      error
+    };
+  }
+  return {
+    dataStores: readDataStores(doc),
+    datasets: readDatasets(doc),
+    relationships: readRelationships(doc),
+    modelMetrics: readModelMetrics(doc),
+    error: null
+  };
+}
+
+// ../dashboard-core/src/model-builder-checks.ts
+function storeOf(dataset, stores) {
+  if (dataset.dataStoreId) return dataset.dataStoreId;
+  return stores.find((s) => s.isDefault)?.id ?? stores[0]?.id ?? null;
+}
+function relationshipIssues(relationship, datasets, stores) {
+  const issues = [];
+  if (!relationship.name.trim()) issues.push("This join has no name.");
+  const from = datasets.find((d) => d.id === relationship.from);
+  const to = datasets.find((d) => d.id === relationship.to);
+  if (!relationship.from || !relationship.to) {
+    issues.push("Pick the dataset on each side of the join.");
+  } else if (!from) {
+    issues.push(`No dataset called ${relationship.from}.`);
+  } else if (!to) {
+    issues.push(`No dataset called ${relationship.to}.`);
+  } else if (relationship.from === relationship.to) {
+    issues.push("Both sides are the same dataset, so this join does nothing.");
+  }
+  if (relationship.fromColumns.length === 0 || relationship.toColumns.length === 0) {
+    issues.push("A join needs at least one pair of columns.");
+  } else if (relationship.fromColumns.length !== relationship.toColumns.length) {
+    issues.push(
+      "The columns are matched in pairs, so both sides need the same number."
+    );
+  }
+  if (from && to && storeOf(from, stores) !== storeOf(to, stores) && relationship.from !== relationship.to) {
+    issues.push(
+      `${from.id} and ${to.id} read different data stores, so this join cannot run. Combine them in a mesh dataset instead.`
+    );
+  }
+  return issues;
+}
+function datasetsInExpression(expression, datasetIds) {
+  return datasetIds.filter(
+    (id) => new RegExp(`(^|[^\\w.])${id}\\.`, "i").test(expression)
+  );
+}
+function datasetsAreJoined(a, b, relationships) {
+  const seen = /* @__PURE__ */ new Set([a]);
+  const queue = [a];
+  while (queue.length > 0) {
+    const current = queue.shift();
+    if (current === b) return true;
+    for (const relationship of relationships) {
+      for (const [left, right] of [
+        [relationship.from, relationship.to],
+        [relationship.to, relationship.from]
+      ]) {
+        if (left === current && right && !seen.has(right)) {
+          seen.add(right);
+          queue.push(right);
+        }
+      }
+    }
+  }
+  return seen.has(b);
+}
+function modelMetricIssues(metric, datasets, relationships) {
+  const issues = [];
+  if (!metric.id.trim())
+    issues.push("This metric has no id for widgets to ask for.");
+  if (!metric.expression.trim()) {
+    issues.push("This metric has no plain expression, so edit it in YAML.");
+    return issues;
+  }
+  const ids = datasets.map((d) => d.id);
+  const referenced = datasetsInExpression(metric.expression, ids);
+  const qualified = [
+    ...new Set(
+      Array.from(metric.expression.matchAll(/(?:^|[^\w.])([A-Za-z_]\w*)\./g)).map((match) => match[1]).filter((name) => name !== void 0)
+    )
+  ];
+  for (const name of qualified) {
+    if (!ids.includes(name)) {
+      issues.push(`${name} is not a dataset in this model.`);
+    }
+  }
+  if (referenced.length === 0) {
+    issues.push(
+      "Qualify each column with its dataset, for example daily_sales.NET_SALES, so the engine knows where to read it."
+    );
+  }
+  const first = referenced[0];
+  for (const other of referenced.slice(1)) {
+    if (first !== void 0 && !datasetsAreJoined(first, other, relationships)) {
+      issues.push(
+        `${first} and ${other} are not connected by any relationship, so this metric cannot be computed.`
+      );
+    }
+  }
+  if (isDoubleScaledPercent(metric.expression, metric.format)) {
+    issues.push(
+      "This multiplies by 100 and the percent format multiplies by 100 again, so a share of 0.133 reads 1,333%. Drop the * 100 and keep the percent format."
+    );
+  }
+  return issues;
+}
+var MODEL_TEMPLATES = [
+  {
+    id: "data_store",
+    label: "Data store",
+    section: "data_stores",
+    description: "A warehouse connection. Leave data_model_id out to use the host's default store.",
+    yaml: `  - id: ops_dw
+    name: Operations warehouse
+    vendor: snowflake
+    default: true
+`
+  },
+  {
+    id: "dataset_table",
+    label: "Dataset from a table",
+    section: "datasets",
+    description: "A table or view with the dimensions and metrics widgets may ask for.",
+    yaml: `  - id: daily_sales
+    name: Daily sales
+    data_store_id: ops_dw
+    source_type: table
+    source: "{mart_schema}.RPT_DAILY_SALES_SUMMARY"
+    filter_field: store_key
+    dimensions:
+      - {id: business_date, type: date, is_time: true}
+      - {id: store_key, type: string}
+    metrics:
+      - {id: net_sales, type: sql, expression: SUM(NET_SALES)}
+      - {id: order_count, type: sql, expression: SUM(ORDER_COUNT)}
+`
+  },
+  {
+    id: "dataset_query",
+    label: "Dataset from SQL",
+    section: "datasets",
+    description: "Use when no single table has the shape you need.",
+    yaml: `  - id: sales_by_daypart
+    data_store_id: ops_dw
+    source_type: query
+    filter_field: store_key
+    query: |
+      SELECT store_key, business_date, daypart, SUM(net_sales) AS net_sales
+      FROM {mart_schema}.FCT_ORDERS
+      GROUP BY 1, 2, 3
+    dimensions:
+      - {id: business_date, type: date, is_time: true}
+      - {id: daypart, type: string}
+    metrics:
+      - {id: net_sales, type: sql, expression: SUM(net_sales)}
+`
+  },
+  {
+    id: "relationship",
+    label: "Relationship (join)",
+    section: "relationships",
+    description: "Lets one widget mix fields from both datasets. Column lists are matched in order.",
+    yaml: `  - name: sales_to_labor
+    from: daily_sales
+    to: daily_labor
+    from_columns: [store_key, business_date]
+    to_columns: [store_key, business_date]
+    relationship: one_to_one
+`
+  },
+  {
+    id: "metric_formula",
+    label: "Metric across datasets",
+    section: "metrics",
+    description: "A formula over dataset metrics, computed after the query. Needs a relationship when it spans datasets.",
+    yaml: `  - id: labor_pct
+    name: Labor percent
+    type: formula
+    expression: "daily_labor.labor_cost / daily_sales.net_sales"
+    format: percent
+`
+  }
+];
+function insertModelTemplate(specYaml, template) {
+  const block = template.yaml.endsWith("\n") ? template.yaml : `${template.yaml}
+`;
+  const lineCounter = new LineCounter();
+  const doc = parseDocument(specYaml, { lineCounter });
+  const section = doc.get(template.section, true);
+  const text2 = specYaml.endsWith("\n") ? specYaml : `${specYaml}
+`;
+  if (isSeq(section) && section.items.length > 0) {
+    const last = section.items[section.items.length - 1];
+    const range = last.range;
+    if (range) {
+      const at = range[2];
+      const head = text2.slice(0, at);
+      return `${head.endsWith("\n") ? head : `${head}
+`}${block}${text2.slice(at)}`;
+    }
+  }
+  const emptySection = new RegExp(
+    `^${template.section}:[ \\t]*(\\[\\s*\\])?[ \\t]*$`,
+    "m"
+  );
+  if (emptySection.test(text2)) {
+    return text2.replace(
+      emptySection,
+      `${template.section}:
+${block.trimEnd()}`
+    );
+  }
+  return `${text2}${template.section}:
+${block}`;
+}
+var KEYED_BY_ID = ["data_stores", "datasets", "metrics"];
+function positionOf(node, lineCounter) {
+  if (!node.range) return null;
+  const [start, valueEnd] = node.range;
+  const startPos = lineCounter.linePos(start);
+  const endPos = lineCounter.linePos(valueEnd);
+  return {
+    line: startPos.line,
+    column: startPos.col,
+    endLine: endPos.line,
+    endColumn: endPos.col
+  };
+}
+function indexModelYaml(specYaml) {
+  const lineCounter = new LineCounter();
+  const doc = parseDocument(specYaml, { lineCounter, keepSourceTokens: true });
+  const index = /* @__PURE__ */ new Map();
+  if (!isMap(doc.contents)) return index;
+  for (const collection of [...KEYED_BY_ID, "relationships"]) {
+    const seq = doc.get(collection, true);
+    if (!isSeq(seq)) continue;
+    for (const item of seq.items) {
+      if (!isMap(item)) continue;
+      const keyNode = collection === "relationships" ? "name" : "id";
+      const id = item.get(keyNode);
+      if (typeof id !== "string") continue;
+      const position = positionOf(item, lineCounter);
+      if (position) index.set(`${collection}:${id}`, position);
+    }
+  }
+  return index;
+}
+function yamlSyntaxMarkers(specYaml) {
+  const lineCounter = new LineCounter();
+  const doc = parseDocument(specYaml, { lineCounter });
+  return doc.errors.map((err) => {
+    const start = lineCounter.linePos(err.pos[0]);
+    const end = lineCounter.linePos(err.pos[1]);
+    return {
+      startLineNumber: start.line,
+      startColumn: start.col,
+      endLineNumber: end.line,
+      endColumn: end.col,
+      message: err.message,
+      severity: "error"
+    };
+  });
+}
+function marker(position, message, severity) {
+  const at = position ?? { line: 1, column: 1, endLine: 1, endColumn: 1 };
+  return {
+    startLineNumber: at.line,
+    startColumn: at.column,
+    // Underlining a whole dataset block buries the code in red, so mark its
+    // first line only.
+    endLineNumber: at.line,
+    endColumn: at.line === at.endLine ? at.endColumn : Number.MAX_SAFE_INTEGER,
+    message,
+    severity
+  };
+}
+function diagnosticsToMarkers(specYaml, diagnostics) {
+  const index = indexModelYaml(specYaml);
+  const markers = [];
+  for (const issue of diagnostics.model.issues) {
+    markers.push(marker(void 0, issue, "error"));
+  }
+  for (const store of diagnostics.data_stores) {
+    const position = index.get(`data_stores:${store.id}`);
+    for (const issue of store.issues) {
+      markers.push(marker(position, issue, "error"));
+    }
+    for (const note of store.notes ?? []) {
+      markers.push(marker(position, note, "info"));
+    }
+  }
+  for (const dataset of diagnostics.datasets) {
+    const position = index.get(`datasets:${dataset.id}`);
+    for (const issue of dataset.issues) {
+      markers.push(marker(position, issue, "error"));
+    }
+  }
+  for (const relationship of diagnostics.relationships) {
+    const position = index.get(`relationships:${relationship.name}`);
+    for (const issue of relationship.issues) {
+      markers.push(marker(position, issue, "error"));
+    }
+  }
+  for (const metric of diagnostics.metrics) {
+    const id = metric.metric.id;
+    const position = typeof id === "string" ? index.get(`metrics:${id}`) : void 0;
+    for (const issue of metric.issues) {
+      markers.push(marker(position, issue, "error"));
+    }
+  }
+  return markers;
+}
+function countModelIssues(diagnostics) {
+  return diagnostics.model.issues.length + diagnostics.data_stores.reduce((n, s) => n + s.issues.length, 0) + diagnostics.datasets.reduce((n, d) => n + d.issues.length, 0) + diagnostics.relationships.reduce((n, r) => n + r.issues.length, 0) + diagnostics.metrics.reduce((n, m) => n + m.issues.length, 0);
+}
+
+// ../dashboard-core/src/widget-builder-checks.ts
+function widgetColumns(datasetId, model) {
+  const base = model.datasets.find((d) => d.id === datasetId);
+  if (!base) return [];
+  const columns = [
+    ...base.dimensions.map((dimension) => ({
+      key: dimension.id,
+      label: dimension.id,
+      kind: "dimension",
+      dataset: base.id,
+      joined: false
+    })),
+    ...base.metrics.map((metric) => ({
+      key: metric.id,
+      label: metric.label ?? metric.id,
+      kind: "metric",
+      dataset: base.id,
+      joined: false
+    }))
+  ];
+  for (const other of model.datasets) {
+    if (other.id === base.id) continue;
+    if (!datasetsAreJoined(base.id, other.id, model.relationships)) continue;
+    for (const metric of other.metrics) {
+      columns.push({
+        key: `${other.id}.${metric.id}`,
+        label: `${metric.label ?? metric.id} (${other.id})`,
+        kind: "metric",
+        dataset: other.id,
+        joined: true
+      });
+    }
+  }
+  const taken = new Set(columns.map((column) => column.key));
+  for (const metric of model.modelMetrics) {
+    if (taken.has(metric.id)) continue;
+    columns.push({
+      key: metric.id,
+      label: metric.label ?? metric.id,
+      kind: "metric",
+      dataset: null,
+      joined: true
+    });
+  }
+  return columns;
+}
+function numericColumns(columns) {
+  return columns.filter((column) => column.kind === "metric");
+}
+function labelColumns(columns) {
+  return columns.filter((column) => column.kind === "dimension");
+}
+function widgetFindings(widget, model) {
+  const findings = [];
+  const add = (message, at) => {
+    findings.push({ message, at });
+  };
+  if (!widget.id.trim()) add("This widget has no id.", { kind: "id" });
+  if (!widget.datasetId) {
+    add("Pick the dataset this widget reads.", { kind: "dataset" });
+    return findings;
+  }
+  const base = model.datasets.find((d) => d.id === widget.datasetId);
+  if (!base) {
+    add(
+      `No dataset called ${widget.datasetId} in the semantic model, so this widget cannot run.`,
+      { kind: "dataset" }
+    );
+    return findings;
+  }
+  if (widget.columns.length === 0) {
+    add("Pick at least one column, or the query returns nothing.", {
+      kind: "columns"
+    });
+    return findings;
+  }
+  const available = widgetColumns(widget.datasetId, model);
+  const availableKeys = new Set(available.map((column) => column.key));
+  for (const column of widget.columns) {
+    if (availableKeys.has(column)) continue;
+    const [prefix] = column.split(".");
+    if (column.includes(".") && model.datasets.some((d) => d.id === prefix)) {
+      add(
+        `${column} comes from ${prefix}, which no relationship connects to ${base.id}, so the query cannot join it.`,
+        { kind: "column", key: column }
+      );
+    } else {
+      add(
+        `${column} is not a dimension or metric of ${base.id}, so the query would fail.`,
+        { kind: "column", key: column }
+      );
+    }
+  }
+  const selected = new Set(widget.columns);
+  function checkPoints(field, what, at) {
+    if (!field) return;
+    if (!selected.has(field)) {
+      add(
+        `${what} reads ${field}, which this widget does not select, so it would draw nothing.`,
+        at
+      );
+    }
+  }
+  checkPoints(widget.mappings.x, "The horizontal axis", {
+    kind: "mapping",
+    slot: "x"
+  });
+  checkPoints(widget.mappings.category, "The category", {
+    kind: "mapping",
+    slot: "category"
+  });
+  checkPoints(widget.mappings.value, "The value", {
+    kind: "mapping",
+    slot: "value"
+  });
+  checkPoints(widget.mappings.series, "The series split", {
+    kind: "mapping",
+    slot: "series"
+  });
+  checkPoints(widget.mappings.delta, "The comparison", {
+    kind: "mapping",
+    slot: "delta"
+  });
+  widget.series.forEach((entry, index) => {
+    checkPoints(entry.field, `Series ${entry.name ?? entry.field}`, {
+      kind: "series",
+      index
+    });
+  });
+  if (widget.component === "echarts") {
+    const axis = widget.chartType === "pie" ? widget.mappings.category : widget.mappings.x;
+    if (!axis) {
+      add(
+        widget.chartType === "pie" ? "Pick the column that names each slice." : "Pick the column that runs along the horizontal axis.",
+        {
+          kind: "mapping",
+          slot: widget.chartType === "pie" ? "category" : "x"
+        }
+      );
+    }
+    if (!widget.mappings.value && widget.series.length === 0) {
+      add("Pick the column to plot, or add at least one series.", {
+        kind: "mapping",
+        slot: "value"
+      });
+    }
+  }
+  const numericKeys = new Set(numericColumns(available).map((c) => c.key));
+  if ((widget.component === "kpi" || widget.component === "echarts") && widget.mappings.value && availableKeys.has(widget.mappings.value) && !numericKeys.has(widget.mappings.value)) {
+    add(
+      `${widget.mappings.value} is a label rather than a measure, so there is no number to ${widget.component === "kpi" ? "show" : "plot"}.`,
+      { kind: "mapping", slot: "value" }
+    );
+  }
+  if (widget.component === "kpi") {
+    if (!widget.mappings.value) {
+      add("Pick the column the number comes from.", {
+        kind: "mapping",
+        slot: "value"
+      });
+    }
+    if (widget.mappings.delta && widget.mappings.delta === widget.mappings.value) {
+      add(
+        "The comparison reads the same column as the number, so the change would always be zero. Pick another column or leave it unset.",
+        { kind: "mapping", slot: "delta" }
+      );
+    }
+    const grouping = available.filter(
+      (column) => column.kind === "dimension" && selected.has(column.key)
+    );
+    for (const column of grouping) {
+      add(
+        `A single number cannot group by ${column.label}: the query returns one row per ${column.label} and the card shows only the first. Untick it in step 4.`,
+        { kind: "column", key: column.key }
+      );
+    }
+  }
+  if (widget.component === "pivot_table") {
+    findings.push(...pivotFindings(widget, available));
+  }
+  return findings;
+}
+function pivotFindings(widget, available) {
+  const findings = [];
+  const add = (message, at) => {
+    findings.push({ message, at });
+  };
+  const pivot = widget.pivot;
+  const byKey = new Map(available.map((column) => [column.key, column]));
+  if (pivot.rows.length === 0) {
+    add("Pick at least one field to run down the side of the pivot.", {
+      kind: "pivotRows"
+    });
+  }
+  if (pivot.measures.length === 0) {
+    add("Add at least one measure, or every cell in the pivot is empty.", {
+      kind: "pivotMeasures"
+    });
+  }
+  function checkDimension(field, where, at) {
+    const column = byKey.get(field);
+    if (!column) {
+      add(
+        `${field} is not a dimension or metric of ${widget.datasetId}, so the pivot cannot group ${where} by it.`,
+        at
+      );
+      return;
+    }
+    if (column.kind !== "dimension") {
+      add(
+        `${field} is a measure rather than a dimension, so it cannot run ${where}. Put it under the measures instead.`,
+        at
+      );
+    }
+  }
+  for (const field of pivot.rows) {
+    checkDimension(field, "down the side", { kind: "pivotRows" });
+    if (pivot.columns.includes(field)) {
+      add(
+        `${field} runs down the side and across the top at once, so every figure would fall on one diagonal. Pick it in one place.`,
+        { kind: "pivotColumns" }
+      );
+    }
+  }
+  for (const field of pivot.columns) {
+    checkDimension(field, "across the top", { kind: "pivotColumns" });
+  }
+  if (pivot.columns.length > 2) {
+    add(
+      "At most two fields can be nested across the top. A third level generates more columns than a grid can read.",
+      { kind: "pivotColumns" }
+    );
+  }
+  pivot.measures.forEach((measure, index) => {
+    const column = byKey.get(measure.field);
+    if (!column) {
+      add(
+        `${measure.field} is not a dimension or metric of ${widget.datasetId}, so there is no figure to put in the cells.`,
+        { kind: "pivotMeasure", index }
+      );
+      return;
+    }
+    if (column.kind !== "metric") {
+      add(
+        `${measure.field} is a label rather than a measure, so there is no number to total.`,
+        { kind: "pivotMeasure", index }
+      );
+    }
+  });
+  const measured = new Set(pivot.measures.map((measure) => measure.field));
+  if (pivot.heatmap && !measured.has(pivot.heatmap)) {
+    add(
+      `The shading reads ${pivot.heatmap}, which is not one of this pivot's measures, so nothing would be shaded.`,
+      { kind: "pivotHeatmap" }
+    );
+  }
+  if (pivot.sortMeasure && !measured.has(pivot.sortMeasure)) {
+    add(
+      `The rows are ordered by ${pivot.sortMeasure}, which is not one of this pivot's measures, so the order would fall back to the labels.`,
+      { kind: "pivotSort" }
+    );
+  }
+  if (pivot.topRowsMeasure && !measured.has(pivot.topRowsMeasure)) {
+    add(
+      `The biggest rows are picked by ${pivot.topRowsMeasure}, which is not one of this pivot's measures, so nothing would decide which rows are kept.`,
+      { kind: "pivotTopRows" }
+    );
+  }
+  return findings;
+}
+function widgetIssues(widget, model) {
+  return widgetFindings(widget, model).map((finding) => finding.message);
+}
+function text(node) {
+  return typeof node === "string" && node.length > 0 ? node : null;
+}
+function mapAt(parent, key) {
+  const node = parent.get(key, true);
+  return isMap(node) ? node : null;
+}
+function readDashboardOutline(specYaml) {
+  const empty = {
+    id: null,
+    name: null,
+    tabIds: [],
+    widgetRefs: [],
+    issues: []
+  };
+  const doc = parseDocument(specYaml);
+  const first = doc.errors[0];
+  if (first) {
+    return {
+      ...empty,
+      issues: [
+        `Line ${String(first.linePos?.[0].line ?? 1)}: ${first.message.trim()}`
+      ]
+    };
+  }
+  if (!isMap(doc.contents)) {
+    return { ...empty, issues: ["A dashboard must be a YAML mapping."] };
+  }
+  const root = doc.contents;
+  const issues = [];
+  if (text(root.get("kind")) !== "dashboard") {
+    issues.push("kind must be dashboard.");
+  }
+  const metadata = mapAt(root, "metadata");
+  const id = metadata ? text(metadata.get("id")) : null;
+  const name = metadata ? text(metadata.get("name")) : null;
+  if (id === null) issues.push("metadata.id is required.");
+  if (name === null) issues.push("metadata.name is required.");
+  const spec = mapAt(root, "spec");
+  const tabs = spec ? spec.get("tabs", true) : null;
+  const tabIds = [];
+  const widgetRefs = [];
+  if (!isSeq(tabs) || tabs.items.length === 0) {
+    issues.push("spec.tabs must list at least one page.");
+  } else {
+    tabs.items.forEach((tab, index) => {
+      if (!isMap(tab)) {
+        issues.push(`Tab ${String(index + 1)} must be a mapping.`);
+        return;
+      }
+      const tabId = text(tab.get("id"));
+      if (tabId === null) {
+        issues.push(`Tab ${String(index + 1)} needs an id.`);
+      } else if (tabIds.includes(tabId)) {
+        issues.push(`Tab id ${tabId} is used twice.`);
+      } else {
+        tabIds.push(tabId);
+      }
+      const widgets = tab.get("widgets", true);
+      if (!isSeq(widgets)) return;
+      for (const item of widgets.items) {
+        const ref = isMap(item) ? text(item.get("ref")) : text(item);
+        if (ref === null) {
+          issues.push(
+            `Tab ${tabId ?? String(index + 1)} has a widget without a ref.`
+          );
+        } else {
+          widgetRefs.push(ref);
+        }
+      }
+    });
+  }
+  return { id, name, tabIds, widgetRefs, issues };
+}
+var BUILDER_COMPONENTS = [
+  "echarts",
+  "table",
+  "tabulator",
+  "pivot_table",
+  "kpi"
+];
+var ALL_COMPONENTS = [
+  "echarts",
+  "table",
+  "tabulator",
+  "pivot_table",
+  "kpi",
+  "text",
+  "markdown",
+  "image",
+  "filter"
+];
+function isBuilderComponent(component) {
+  return BUILDER_COMPONENTS.includes(component);
+}
+var CHART_TYPES = ["line", "bar", "area", "pie", "scatter"];
+var DELTA_FORMATS = ["percent", "number", "currency"];
+var NUMBER_FORMATS = ["number", "currency", "percent"];
+var SORT_ORDERS = ["none", "asc", "desc"];
+var PIVOT_AGGREGATIONS = [
+  "sum",
+  "avg",
+  "min",
+  "max",
+  "count",
+  "count_distinct"
+];
+var PIVOT_SUBTOTALS = ["collapsed", "expanded", "none"];
+var PIVOT_DIRECTIONS = ["asc", "desc"];
+function str2(node) {
+  return typeof node === "string" && node !== "" ? node : null;
+}
+function mapAt2(parent, key) {
+  const node = parent.get(key, true);
+  return isMap(node) ? node : null;
+}
+function seqAt(parent, key) {
+  const node = parent.get(key, true);
+  return isSeq(node) ? node : null;
+}
+function mapsOf2(seq) {
+  if (!seq) return [];
+  return seq.items.filter((item) => isMap(item));
+}
+function readSelectedColumns(data) {
+  const merged = [
+    ...stringList2(data.get("columns", true)),
+    ...stringList2(data.get("dimensions", true)),
+    ...stringList2(data.get("metrics", true))
+  ];
+  return [...new Set(merged)];
+}
+function stringList2(node) {
+  if (!isSeq(node)) return [];
+  return node.items.flatMap((item) => {
+    const value = isScalar(item) ? item.value : item;
+    return typeof value === "string" ? [value] : [];
+  });
+}
+function setStringSeq2(doc, map, key, values) {
+  const current = stringList2(map.get(key, true));
+  if (current.length === values.length && current.every((value, index) => value === values[index])) {
+    return;
+  }
+  map.set(key, doc.createNode(values));
+}
+function setOrDelete2(map, key, value) {
+  if (value === null || value === void 0 || value === "") {
+    if (map.has(key)) map.delete(key);
+    return;
+  }
+  map.set(key, value);
+}
+function parseWidgetDocument(specYaml) {
+  const doc = parseDocument(specYaml);
+  const first = doc.errors[0];
+  if (first) {
+    return {
+      doc: null,
+      error: { message: first.message, line: first.linePos?.[0].line ?? 1 }
+    };
+  }
+  if (!isMap(doc.contents)) {
+    return {
+      doc: null,
+      error: { message: "A widget must be a YAML mapping.", line: 1 }
+    };
+  }
+  return { doc, error: null };
+}
+function readChartType(display) {
+  const echarts = display ? mapAt2(display, "echarts") : null;
+  const option = echarts ? mapAt2(echarts, "option") : null;
+  const first = mapsOf2(option ? seqAt(option, "series") : null)[0] ?? null;
+  const type = first ? str2(first.get("type")) : null;
+  if (type === "line" && first?.has("areaStyle")) return "area";
+  return CHART_TYPES.includes(type ?? "") ? type : "line";
+}
+function readDeltaFormat(display) {
+  const kpi = display ? mapAt2(display, "kpi") : null;
+  const delta = kpi ? mapAt2(kpi, "delta") : null;
+  const format = delta ? str2(delta.get("format")) : null;
+  return DELTA_FORMATS.includes(format ?? "") ? format : "percent";
+}
+function num(node) {
+  return typeof node === "number" && Number.isFinite(node) ? node : null;
+}
+function bool(node, fallback) {
+  return typeof node === "boolean" ? node : fallback;
+}
+function readAppearance(display) {
+  const kpi = display ? mapAt2(display, "kpi") : null;
+  const echarts = display ? mapAt2(display, "echarts") : null;
+  const option = echarts ? mapAt2(echarts, "option") : null;
+  const legend = option ? mapAt2(option, "legend") : null;
+  const xSort = echarts ? mapAt2(echarts, "xSort") : null;
+  const table = display ? mapAt2(display, "table") ?? mapAt2(display, "tabulator") : null;
+  const tabulator = display ? mapAt2(display, "tabulator") : null;
+  const label = kpi ? mapAt2(kpi, "label") : null;
+  const format = kpi ? str2(kpi.get("format")) : null;
+  const order = xSort ? str2(xSort.get("order")) : null;
+  const position = (label ? str2(label.get("position")) : null) ?? (kpi ? str2(kpi.get("position")) : null);
+  return {
+    format: NUMBER_FORMATS.includes(format ?? "") ? format : "number",
+    prefix: kpi ? str2(kpi.get("prefix")) : null,
+    suffix: kpi ? str2(kpi.get("suffix")) : null,
+    compact: bool(kpi?.get("compact"), false),
+    decimals: kpi ? num(kpi.get("decimals")) : null,
+    labelPosition: position === "bottom" ? "bottom" : "top",
+    showLegend: bool(legend?.get("show"), true),
+    horizontal: (echarts ? str2(echarts.get("orientation")) : null) === "horizontal",
+    sortOrder: order === "asc" || order === "desc" ? order : "none",
+    pageSize: table ? num(table.get("page_size")) : null,
+    sortable: bool(table?.get("sortable"), true),
+    groupBy: tabulator ? str2(tabulator.get("group_by")) : null
+  };
+}
+function readPivot(display) {
+  const pivot = display ? mapAt2(display, "pivot_table") : null;
+  const totals = pivot ? mapAt2(pivot, "totals") : null;
+  const heatmap = pivot ? mapAt2(pivot, "heatmap") : null;
+  const snapshot = pivot ? mapAt2(pivot, "snapshot") : null;
+  const limits = pivot ? mapAt2(pivot, "limits") : null;
+  const sort = pivot ? mapAt2(pivot, "sort") : null;
+  const topRows = pivot ? mapAt2(pivot, "top_rows") : null;
+  const subtotals = pivot ? str2(pivot.get("subtotals")) : null;
+  const direction = sort ? str2(sort.get("direction")) : null;
+  return {
+    rows: stringList2(pivot?.get("rows", true)),
+    columns: stringList2(pivot?.get("columns", true)),
+    measures: mapsOf2(pivot ? seqAt(pivot, "measures") : null).flatMap(
+      (entry) => {
+        const field = str2(entry.get("field"));
+        if (!field) return [];
+        const agg = str2(entry.get("agg"));
+        const format = str2(entry.get("format"));
+        return [
+          {
+            field,
+            agg: PIVOT_AGGREGATIONS.includes(agg ?? "") ? agg : "sum",
+            label: str2(entry.get("label")),
+            format: NUMBER_FORMATS.includes(format ?? "") ? format : null,
+            decimals: num(entry.get("decimals"))
+          }
+        ];
+      }
+    ),
+    rowTotals: bool(totals?.get("row"), true),
+    columnTotals: bool(totals?.get("column"), true),
+    grandTotal: bool(totals?.get("grand"), true),
+    subtotals: PIVOT_SUBTOTALS.includes(subtotals ?? "") ? subtotals : "collapsed",
+    emptyValue: pivot ? str2(pivot.get("empty_value")) : null,
+    heatmap: heatmap ? str2(heatmap.get("measure")) : null,
+    snapshotExpand: snapshot ? num(snapshot.get("expand")) : null,
+    snapshotExpandColumns: snapshot ? num(snapshot.get("expand_columns")) : null,
+    sortMeasure: sort ? str2(sort.get("measure")) : null,
+    sortDirection: PIVOT_DIRECTIONS.includes(
+      direction ?? ""
+    ) ? direction : null,
+    topRows: topRows ? num(topRows.get("count")) : null,
+    topRowsMeasure: topRows ? str2(topRows.get("measure")) : null,
+    topRowsOther: bool(topRows?.get("other"), true),
+    rowGroupLimit: limits ? num(limits.get("row_groups")) : null,
+    columnLimit: limits ? num(limits.get("columns")) : null,
+    explore: bool(pivot?.get("explore"), true)
+  };
+}
+function readSeries(display) {
+  const echarts = display ? mapAt2(display, "echarts") : null;
+  return mapsOf2(echarts ? seqAt(echarts, "series") : null).flatMap((item) => {
+    const field = str2(item.get("field"));
+    if (!field) return [];
+    return [{ name: str2(item.get("name")), field }];
+  });
+}
+function readWidgetOutline(specYaml) {
+  const { doc, error } = parseWidgetDocument(specYaml);
+  if (!doc || !isMap(doc.contents)) {
+    return {
+      widget: null,
+      identity: { id: "", name: null, component: "echarts" },
+      readOnlyReason: null,
+      error
+    };
+  }
+  const root = doc.contents;
+  const metadata = mapAt2(root, "metadata");
+  const spec = mapAt2(root, "spec");
+  const identity = {
+    id: (metadata ? str2(metadata.get("id")) : null) ?? "",
+    name: metadata ? str2(metadata.get("name")) : null,
+    component: (spec ? str2(spec.get("component")) : null) ?? "echarts"
+  };
+  if (!spec) {
+    return {
+      widget: null,
+      identity,
+      readOnlyReason: "This widget has no spec block yet.",
+      error: null
+    };
+  }
+  const component = identity.component;
+  if (!isBuilderComponent(component)) {
+    return {
+      widget: null,
+      identity,
+      readOnlyReason: `A ${component} widget holds content rather than data, so its wording lives in YAML.`,
+      error: null
+    };
+  }
+  const data = mapAt2(spec, "data");
+  const dataKind = data ? str2(data.get("kind")) ?? "static" : "static";
+  const mappings = mapAt2(spec, "mappings");
+  const display = mapAt2(spec, "display");
+  return {
+    identity,
+    widget: {
+      id: identity.id,
+      name: identity.name,
+      component,
+      chartType: readChartType(display),
+      deltaFormat: readDeltaFormat(display),
+      dataKind,
+      datasetId: data ? str2(data.get("dataset")) : null,
+      columns: data ? readSelectedColumns(data) : [],
+      mappings: {
+        x: mappings ? str2(mappings.get("x")) : null,
+        category: mappings ? str2(mappings.get("category")) : null,
+        value: mappings ? str2(mappings.get("value")) : null,
+        series: mappings ? str2(mappings.get("series")) : null,
+        delta: mappings ? str2(mappings.get("delta")) : null
+      },
+      series: readSeries(display),
+      appearance: readAppearance(display),
+      pivot: readPivot(display)
+    },
+    readOnlyReason: dataKind === "dataset" || dataKind === "static" ? null : `This widget reads a ${dataKind} source rather than a dataset, so the Builder leaves it to YAML.`,
+    error: null
+  };
+}
+function ensureMap(doc, parent, key) {
+  const existing = mapAt2(parent, key);
+  if (existing) return existing;
+  const created = doc.createNode({});
+  if (!isMap(created)) throw new Error(`Could not create ${key}`);
+  parent.set(key, created);
+  return created;
+}
+function widgetText(doc) {
+  return doc.toString({ lineWidth: 0, flowCollectionPadding: false });
+}
+function writeChartType(doc, display, chartType) {
+  const echarts = ensureMap(doc, display, "echarts");
+  const option = ensureMap(doc, echarts, "option");
+  const existing = mapsOf2(seqAt(option, "series"))[0] ?? null;
+  const target = existing ?? doc.createNode({});
+  target.set("type", chartType === "area" ? "line" : chartType);
+  if (chartType === "area") {
+    if (!target.has("areaStyle")) target.set("areaStyle", doc.createNode({}));
+  } else if (target.has("areaStyle")) {
+    target.delete("areaStyle");
+  }
+  if (!existing) option.set("series", doc.createNode([target]));
+}
+function writeSeries(doc, display, series) {
+  const echarts = mapAt2(display, "echarts");
+  if (series.length === 0) {
+    if (echarts?.has("series")) echarts.delete("series");
+    return;
+  }
+  const target = echarts ?? ensureMap(doc, display, "echarts");
+  target.set(
+    "series",
+    doc.createNode(
+      series.map(
+        (entry) => entry.name ? { name: entry.name, field: entry.field } : { field: entry.field }
+      )
+    )
+  );
+}
+function writeWidget(specYaml, widget) {
+  const { doc } = parseWidgetDocument(specYaml);
+  if (!doc || !isMap(doc.contents)) return specYaml;
+  const root = doc.contents;
+  const metadata = ensureMap(doc, root, "metadata");
+  if (widget.id) metadata.set("id", widget.id);
+  setOrDelete2(metadata, "name", widget.name);
+  const spec = ensureMap(doc, root, "spec");
+  spec.set("component", widget.component);
+  if (widget.datasetId) {
+    const data = ensureMap(doc, spec, "data");
+    data.set("kind", "dataset");
+    data.set("dataset", widget.datasetId);
+    if (widget.columns.length > 0) {
+      setStringSeq2(doc, data, "columns", widget.columns);
+    } else if (data.has("columns")) {
+      data.delete("columns");
+    }
+    if (data.has("dimensions")) data.delete("dimensions");
+    if (data.has("metrics")) data.delete("metrics");
+  }
+  const mappings = ensureMap(doc, spec, "mappings");
+  setOrDelete2(mappings, "x", widget.mappings.x);
+  setOrDelete2(mappings, "category", widget.mappings.category);
+  setOrDelete2(mappings, "value", widget.mappings.value);
+  setOrDelete2(mappings, "series", widget.mappings.series);
+  setOrDelete2(mappings, "delta", widget.mappings.delta);
+  if (mappings.items.length === 0) spec.delete("mappings");
+  if (widget.component === "echarts") {
+    const display = ensureMap(doc, spec, "display");
+    writeChartType(doc, display, widget.chartType);
+    writeSeries(doc, display, widget.series);
+  }
+  if (widget.component === "kpi") {
+    writeKpiDelta(doc, spec, widget);
+  }
+  writeAppearance(doc, spec, widget);
+  return widgetText(doc);
+}
+function writeAppearance(doc, spec, widget) {
+  const look = widget.appearance;
+  if (widget.component === "kpi") {
+    const kpi = ensureMap(doc, ensureMap(doc, spec, "display"), "kpi");
+    kpi.set("format", look.format);
+    setOrDelete2(kpi, "prefix", look.prefix);
+    setOrDelete2(kpi, "suffix", look.suffix);
+    setOrDelete2(kpi, "compact", look.compact ? true : null);
+    setOrDelete2(kpi, "decimals", look.decimals);
+    const label = mapAt2(kpi, "label");
+    const target = label ?? kpi;
+    setOrDelete2(
+      target,
+      "position",
+      look.labelPosition === "bottom" ? "bottom" : null
+    );
+    return;
+  }
+  if (widget.component === "echarts") {
+    const echarts = ensureMap(doc, ensureMap(doc, spec, "display"), "echarts");
+    setOrDelete2(echarts, "orientation", look.horizontal ? "horizontal" : null);
+    if (look.sortOrder === "none") {
+      if (echarts.has("xSort")) echarts.delete("xSort");
+    } else {
+      const xSort = ensureMap(doc, echarts, "xSort");
+      setOrDelete2(xSort, "by", widget.mappings.x ?? widget.mappings.category);
+      xSort.set("order", look.sortOrder);
+    }
+    const option = ensureMap(doc, echarts, "option");
+    if (look.showLegend) {
+      const legend = mapAt2(option, "legend");
+      if (legend?.has("show")) legend.delete("show");
+      if (legend && legend.items.length === 0) option.delete("legend");
+    } else {
+      ensureMap(doc, option, "legend").set("show", false);
+    }
+    if (option.items.length === 0) echarts.delete("option");
+    return;
+  }
+  if (widget.component === "pivot_table") {
+    writePivot(doc, spec, widget.pivot);
+    return;
+  }
+  if (widget.component === "table" || widget.component === "tabulator") {
+    const block = ensureMap(
+      doc,
+      ensureMap(doc, spec, "display"),
+      widget.component
+    );
+    setOrDelete2(block, "page_size", look.pageSize);
+    setOrDelete2(block, "sortable", look.sortable ? null : false);
+    if (widget.component === "tabulator") {
+      setOrDelete2(block, "group_by", look.groupBy);
+    }
+  }
+}
+function writePivot(doc, spec, pivot) {
+  const block = ensureMap(doc, ensureMap(doc, spec, "display"), "pivot_table");
+  setStringSeq2(doc, block, "rows", pivot.rows);
+  if (pivot.columns.length > 0) {
+    setStringSeq2(doc, block, "columns", pivot.columns);
+  } else if (block.has("columns")) {
+    block.delete("columns");
+  }
+  block.set(
+    "measures",
+    doc.createNode(
+      pivot.measures.map((measure) => ({
+        field: measure.field,
+        agg: measure.agg,
+        ...measure.label ? { label: measure.label } : {},
+        ...measure.format ? { format: measure.format } : {},
+        ...measure.decimals === null ? {} : { decimals: measure.decimals }
+      }))
+    )
+  );
+  const defaultTotals = pivot.rowTotals && pivot.columnTotals && pivot.grandTotal;
+  if (defaultTotals) {
+    if (block.has("totals")) block.delete("totals");
+  } else {
+    const totals = ensureMap(doc, block, "totals");
+    totals.set("row", pivot.rowTotals);
+    totals.set("column", pivot.columnTotals);
+    totals.set("grand", pivot.grandTotal);
+  }
+  setOrDelete2(
+    block,
+    "subtotals",
+    pivot.subtotals === "collapsed" ? null : pivot.subtotals
+  );
+  setOrDelete2(
+    block,
+    "empty_value",
+    pivot.emptyValue === "-" ? null : pivot.emptyValue
+  );
+  setOrDelete2(block, "explore", pivot.explore ? null : false);
+  if (pivot.heatmap) {
+    ensureMap(doc, block, "heatmap").set("measure", pivot.heatmap);
+  } else if (block.has("heatmap")) {
+    block.delete("heatmap");
+  }
+  if (pivot.snapshotExpand === null && pivot.snapshotExpandColumns === null) {
+    if (block.has("snapshot")) block.delete("snapshot");
+  } else {
+    const snapshot = ensureMap(doc, block, "snapshot");
+    setOrDelete2(snapshot, "expand", pivot.snapshotExpand);
+    setOrDelete2(snapshot, "expand_columns", pivot.snapshotExpandColumns);
+  }
+  if (pivot.sortMeasure === null && pivot.sortDirection === null) {
+    if (block.has("sort")) block.delete("sort");
+  } else {
+    const sort = ensureMap(doc, block, "sort");
+    setOrDelete2(sort, "measure", pivot.sortMeasure);
+    setOrDelete2(sort, "direction", pivot.sortDirection);
+  }
+  if (pivot.topRows === null) {
+    if (block.has("top_rows")) block.delete("top_rows");
+  } else {
+    const top = ensureMap(doc, block, "top_rows");
+    top.set("count", pivot.topRows);
+    setOrDelete2(top, "measure", pivot.topRowsMeasure);
+    setOrDelete2(top, "other", pivot.topRowsOther ? null : false);
+  }
+  if (pivot.rowGroupLimit === null && pivot.columnLimit === null) {
+    if (block.has("limits")) block.delete("limits");
+  } else {
+    const limits = ensureMap(doc, block, "limits");
+    setOrDelete2(limits, "row_groups", pivot.rowGroupLimit);
+    setOrDelete2(limits, "columns", pivot.columnLimit);
+  }
+}
+function writePivotLayout(specYaml, layout) {
+  const { doc } = parseWidgetDocument(specYaml);
+  if (!doc || !isMap(doc.contents)) return specYaml;
+  const spec = ensureMap(doc, doc.contents, "spec");
+  const block = ensureMap(doc, ensureMap(doc, spec, "display"), "pivot_table");
+  setStringSeq2(doc, block, "rows", layout.rows);
+  if (layout.columns.length > 0) {
+    setStringSeq2(doc, block, "columns", layout.columns);
+  } else if (block.has("columns")) {
+    block.delete("columns");
+  }
+  const existing = /* @__PURE__ */ new Map();
+  for (const entry of mapsOf2(seqAt(block, "measures"))) {
+    const field = str2(entry.get("field"));
+    if (field && !existing.has(field)) existing.set(field, entry);
+  }
+  block.set(
+    "measures",
+    doc.createNode(
+      layout.measures.map((measure) => {
+        const entry = existing.get(measure.field);
+        const label = entry ? str2(entry.get("label")) : null;
+        const format = entry ? str2(entry.get("format")) : null;
+        const decimals = entry ? num(entry.get("decimals")) : null;
+        return {
+          field: measure.field,
+          agg: measure.agg,
+          ...label ? { label } : {},
+          ...format ? { format } : {},
+          ...decimals === null ? {} : { decimals }
+        };
+      })
+    )
+  );
+  return widgetText(doc);
+}
+function writeKpiDelta(doc, spec, widget) {
+  const comparison = widget.mappings.delta;
+  const display = mapAt2(spec, "display");
+  const kpi = display ? mapAt2(display, "kpi") : null;
+  if (!comparison) {
+    const delta2 = kpi ? mapAt2(kpi, "delta") : null;
+    if (!delta2) return;
+    delta2.delete("metric");
+    delta2.delete("compare_label");
+    if (delta2.items.length === 0) kpi?.delete("delta");
+    if (kpi && kpi.items.length === 0) display?.delete("kpi");
+    return;
+  }
+  const kpiMap = ensureMap(doc, ensureMap(doc, spec, "display"), "kpi");
+  const delta = ensureMap(doc, kpiMap, "delta");
+  delta.set("metric", comparison);
+  delta.set("format", widget.deltaFormat);
+  delta.set("compare_label", humanizeColumn(comparison));
+}
+function humanizeColumn(column) {
+  const words = column.replace(/[_.]+/g, " ").trim();
+  if (!words) return column;
+  return words.charAt(0).toUpperCase() + words.slice(1);
+}
+function writeComponent(specYaml, component) {
+  const { doc } = parseWidgetDocument(specYaml);
+  if (!doc || !isMap(doc.contents)) return specYaml;
+  ensureMap(doc, doc.contents, "spec").set("component", component);
+  return widgetText(doc);
+}
+function writeIdentity(specYaml, field, value) {
+  const { doc } = parseWidgetDocument(specYaml);
+  if (!doc || !isMap(doc.contents)) return specYaml;
+  const metadata = ensureMap(doc, doc.contents, "metadata");
+  if (field === "id") {
+    if (value) metadata.set("id", value);
+  } else {
+    setOrDelete2(metadata, "name", value);
+  }
+  return widgetText(doc);
+}
+function widgetFragment(specYaml) {
+  const { doc } = parseWidgetDocument(specYaml);
+  if (!doc) return "";
+  return widgetText(doc).trimEnd();
+}
+
+// ../dashboard-core/src/widget-template.ts
+var TEMPLATE_COMPONENTS = [
+  "kpi",
+  "filter",
+  "table",
+  "tabulator",
+  "pivot_table",
+  "text",
+  "echarts",
+  "image",
+  "markdown"
+];
+var FILTER_CONTROLS = [
+  "select",
+  "date",
+  "date_range",
+  "custom"
+];
+var COMPONENT_LABELS = {
+  kpi: "KPI",
+  filter: "Filter",
+  table: "Table",
+  tabulator: "Tabulator",
+  pivot_table: "Pivot table",
+  text: "Text",
+  echarts: "Chart",
+  image: "Image",
+  markdown: "Markdown"
+};
+function templateComponentLabel(component) {
+  return COMPONENT_LABELS[component];
+}
+function sanitizeId(name) {
+  return name.toLowerCase().replace(/[^a-z0-9]+/g, "_").replace(/^_+|_+$/g, "");
+}
+var LAYOUT = `    x: 0
+    y: 0
+    w: 2
+    h: 2
+    minW: 2
+    minH: 2
+    unplaced: true`;
+function randomSuffix() {
+  return Math.random().toString(36).slice(2, 10);
+}
+function filterTemplate(id, widgetName, control) {
+  const baseYaml = `version: "1.0"
+kind: widget
+metadata:
+  id: ${id}
+  name: ${widgetName}
+  description: ""
+  platform:
+    scope: dashboard
+    roles: []
+spec:
+  component: filter
+  layout:
+${LAYOUT}`;
+  switch (control) {
+    case "date":
+      return `${baseYaml}
+  data:
+    kind: static
+  display:
+    filter:
+      control: date
+      default_value: today
+      placeholder: Pick a date
+      date_format: yyyy-MM-dd
+      show_icon: true
+      label:
+        text: ${widgetName}
+        tooltip: ""
+        tooltip_icon: info
+`;
+    case "date_range":
+      return `${baseYaml}
+  data:
+    kind: static
+  display:
+    filter:
+      control: date_range
+      default_value: this month
+      placeholder: Pick a range
+      date_format: yyyy-MM-dd
+      show_icon: true
+      presets:
+        - today
+        - yesterday
+        - last 7 days
+        - this month
+        - last month
+      label:
+        text: ${widgetName}
+        tooltip: ""
+        tooltip_icon: info
+`;
+    case "custom":
+      return `${baseYaml}
+  data:
+    kind: static
+  display:
+    filter:
+      control: custom
+      default_value: ""
+      placeholder: Enter a value
+      label:
+        text: ${widgetName}
+        tooltip: ""
+        tooltip_icon: info
+`;
+    case "select":
+      return `${baseYaml}
+  data:
+    kind: static
+    options:
+      - value: option1
+        label: Option 1
+      - value: option2
+        label: Option 2
+      - value: option3
+        label: Option 3
+    default_value: option1
+  display:
+    filter:
+      control: select
+      placeholder: Select...
+      label:
+        text: ${widgetName}
+        tooltip: ""
+        tooltip_icon: info
+`;
+  }
+}
+function widgetTemplate(component, options = {}) {
+  const widgetName = options.name ?? `New ${COMPONENT_LABELS[component]}`;
+  const id = `${sanitizeId(widgetName)}_${options.suffix ?? randomSuffix()}`;
+  const head = `version: "1.0"
+kind: widget
+metadata:
+  id: ${id}
+  name: ${widgetName}
+  description: ""
+  platform:
+    scope: dashboard
+    roles: []
+spec:
+  component: ${component}
+  layout:
+${LAYOUT}`;
+  switch (component) {
+    case "kpi":
+      return `${head}
+  data:
+    kind: dataset
+    dataset: ""
+    dimensions: []
+    metrics: []
+    filters: []
+    params: {}
+  mappings:
+    value: ""
+  display:
+    kpi:
+      format: number
+      label:
+        text: ${widgetName}
+        tooltip: ""
+        tooltip_icon: info
+`;
+    case "filter":
+      return filterTemplate(id, widgetName, options.filterControl ?? "select");
+    case "text":
+      return `${head}
+  data:
+    kind: static
+    rows: []
+    columns: []
+  display:
+    text:
+      content: ${widgetName}
+      markdown: false
+      text_align: center
+      vertical_align: middle
+      label:
+        text: ""
+        tooltip: ""
+        tooltip_icon: info
+`;
+    case "table":
+      return `${head}
+  data:
+    kind: dataset
+    dataset: ""
+    dimensions: []
+    metrics: []
+    filters: []
+    params: {}
+  display:
+    table:
+      page_size: 10
+      export:
+        csv: true
+        excel: true
+      label:
+        text: ${widgetName}
+        tooltip: ""
+        tooltip_icon: info
+`;
+    case "tabulator":
+      return `${head}
+  data:
+    kind: dataset
+    dataset: ""
+    dimensions: []
+    metrics: []
+    filters: []
+    params: {}
+  display:
+    tabulator:
+      page_size: 25
+      sortable: true
+      layout: fitColumns
+      export:
+        csv: true
+        excel: true
+      label:
+        text: ${widgetName}
+        tooltip: ""
+        tooltip_icon: info
+`;
+    case "pivot_table":
+      return `${head}
+  data:
+    kind: dataset
+    dataset: ""
+    dimensions: []
+    metrics: []
+    filters: []
+    params: {}
+  display:
+    pivot_table:
+      rows: []
+      columns: []
+      measures: []
+      totals:
+        row: true
+        column: true
+        grand: true
+      subtotals: collapsed
+      empty_value: "-"
+      export:
+        csv: true
+        excel: true
+      label:
+        text: ${widgetName}
+        tooltip: ""
+        tooltip_icon: info
+`;
+    case "echarts":
+      return `${head}
+  data:
+    kind: dataset
+    dataset: ""
+    dimensions: []
+    metrics: []
+    filters: []
+    params: {}
+  display:
+    echarts:
+      option:
+        series:
+          - type: line
+      label:
+        text: ${widgetName}
+        tooltip: ""
+        tooltip_icon: info
+`;
+    case "image":
+      return `${head}
+  data:
+    kind: static
+    rows: []
+    columns: []
+  display:
+    image:
+      url: ""
+      alt: ${widgetName}
+      object_fit: contain
+      label:
+        text: ${widgetName}
+        tooltip: ""
+        tooltip_icon: info
+`;
+    case "markdown":
+      return `${head}
+  data:
+    kind: static
+    rows: []
+    columns: []
+  display:
+    markdown:
+      content: "# ${widgetName}"
+      label:
+        text: ${widgetName}
+        tooltip: ""
+        tooltip_icon: info
+`;
+  }
+}
+function positionOf2(node, lineCounter) {
+  if (!node?.range) return null;
+  const [start, valueEnd] = node.range;
+  const startPos = lineCounter.linePos(start);
+  const endPos = lineCounter.linePos(valueEnd);
+  return {
+    line: startPos.line,
+    column: startPos.col,
+    endColumn: endPos.line === startPos.line ? endPos.col : Number.MAX_SAFE_INTEGER
+  };
+}
+function anchorNode(specYaml, anchor) {
+  const doc = parseDocument(specYaml);
+  if (!isMap(doc.contents)) return null;
+  const root = doc.contents;
+  const spec = root.get("spec", true);
+  const specMap = isMap(spec) ? spec : null;
+  const data = specMap?.get("data", true);
+  const dataMap = isMap(data) ? data : null;
+  switch (anchor.kind) {
+    case "id": {
+      const metadata = root.get("metadata", true);
+      return isMap(metadata) ? metadata.get("id", true) ?? metadata : null;
+    }
+    case "dataset":
+      return dataMap ? dataMap.get("dataset", true) ?? dataMap : specMap;
+    case "columns":
+      return dataMap ? dataMap.get("columns", true) ?? dataMap : specMap;
+    case "column": {
+      const columns = dataMap?.get("columns", true);
+      if (!isSeq(columns)) return dataMap;
+      const item = columns.items.find(
+        (entry) => isScalar(entry) && entry.value === anchor.key
+      );
+      return item ?? columns;
+    }
+    case "mapping": {
+      const mappings = specMap?.get("mappings", true);
+      if (!isMap(mappings)) return specMap;
+      return mappings.get(anchor.slot, true) ?? mappings;
+    }
+    case "series": {
+      const display = specMap?.get("display", true);
+      const echarts = isMap(display) ? display.get("echarts", true) : null;
+      const series = isMap(echarts) ? echarts.get("series", true) : null;
+      if (!isSeq(series)) return specMap;
+      return series.items[anchor.index] ?? series;
+    }
+    case "pivotRows":
+    case "pivotColumns":
+    case "pivotMeasures":
+    case "pivotHeatmap":
+    case "pivotSort":
+    case "pivotTopRows": {
+      const pivot = pivotBlock(specMap);
+      if (!pivot) return specMap;
+      const key = PIVOT_ANCHOR_KEYS[anchor.kind];
+      return pivot.get(key, true) ?? pivot;
+    }
+    case "pivotMeasure": {
+      const pivot = pivotBlock(specMap);
+      const measures = pivot?.get("measures", true);
+      if (!isSeq(measures)) return pivot ?? specMap;
+      return measures.items[anchor.index] ?? measures;
+    }
+    default:
+      return null;
+  }
+}
+var PIVOT_ANCHOR_KEYS = {
+  pivotRows: "rows",
+  pivotColumns: "columns",
+  pivotMeasures: "measures",
+  pivotHeatmap: "heatmap",
+  pivotSort: "sort",
+  pivotTopRows: "top_rows"
+};
+function pivotBlock(specMap) {
+  if (!isMap(specMap)) return null;
+  const display = specMap.get("display", true);
+  const pivot = isMap(display) ? display.get("pivot_table", true) : null;
+  return isMap(pivot) ? pivot : null;
+}
+function widgetMarkers(specYaml, model) {
+  const lineCounter = new LineCounter();
+  const doc = parseDocument(specYaml, { lineCounter });
+  if (doc.errors.length > 0) {
+    return doc.errors.map((err) => {
+      const start = lineCounter.linePos(err.pos[0]);
+      const end = lineCounter.linePos(err.pos[1]);
+      return {
+        startLineNumber: start.line,
+        startColumn: start.col,
+        endLineNumber: end.line,
+        endColumn: end.col,
+        message: err.message,
+        severity: "error"
+      };
+    });
+  }
+  const outline = readWidgetOutline(specYaml);
+  if (!outline.widget) return [];
+  return widgetFindings(outline.widget, model).map((finding) => {
+    const at = positionOf2(anchorNode(specYaml, finding.at), lineCounter) ?? {
+      line: 1,
+      column: 1,
+      endColumn: Number.MAX_SAFE_INTEGER
+    };
+    return {
+      startLineNumber: at.line,
+      startColumn: at.column,
+      endLineNumber: at.line,
+      endColumn: at.endColumn,
+      message: finding.message,
+      severity: "warning"
+    };
+  });
+}
+
+// ../dashboard-renderers/src/dashboard-tabs.ts
+function tabWidgetIds(tab) {
+  const entries = tab.widgets ?? [];
+  const ids = [];
+  for (const entry of entries) {
+    if (typeof entry === "string") {
+      ids.push(entry);
+      continue;
+    }
+    const ref = entry["ref"];
+    if (typeof ref === "string") {
+      const base = ref.split("/").pop() ?? ref;
+      ids.push(base.replace(/\.ya?ml$/u, ""));
+      continue;
+    }
+    const metadata = entry["metadata"];
+    if (typeof metadata === "object" && metadata !== null) {
+      const id = metadata.id;
+      if (typeof id === "string") ids.push(id);
+    }
+  }
+  return ids;
+}
+function dashboardTabs(dashboard) {
+  return dashboard.spec.tabs ?? [];
+}
+function defaultTabId(tabs) {
+  const chosen = tabs.find((tab) => tab.default === true) ?? tabs[0];
+  return chosen?.id;
+}
+
+// ../dashboard-renderers/src/responsive.ts
+var LAYOUT_BREAKPOINT_WIDTHS = {
+  lg: 1200,
+  md: 960,
+  sm: 720,
+  xs: 480,
+  xxs: 0
+};
+var DEFAULTS = {
+  wide: { cols: 24, row_height: 30, margin: [8, 8] },
+  desktop: { cols: 24, row_height: 30, margin: [8, 8] },
+  tablet: { cols: 24, row_height: 30, margin: [10, 10] },
+  mobile: { cols: 24, row_height: 30, margin: [10, 10] }
+};
+function layoutKeyForWidth(width) {
+  const keys = ["lg", "md", "sm", "xs", "xxs"];
+  return keys.find((key) => width >= LAYOUT_BREAKPOINT_WIDTHS[key]) ?? "xxs";
+}
+function resolveResponsive(dashboard) {
+  const configured = dashboard.spec.responsive;
+  return {
+    wide: { ...DEFAULTS.wide, ...configured?.wide ?? {} },
+    desktop: { ...DEFAULTS.desktop, ...configured?.desktop ?? {} },
+    tablet: { ...DEFAULTS.tablet, ...configured?.tablet ?? {} },
+    mobile: { ...DEFAULTS.mobile, ...configured?.mobile ?? {} }
+  };
+}
+
+// ../dashboard-renderers/src/reader-grid.ts
+function buildReaderGrid(input) {
+  const { dashboard, widgets, width } = input;
+  const responsive = resolveResponsive(dashboard);
+  const gridConfig = {
+    ...DEFAULT_GRID_CONFIG,
+    ...dashboard.spec.config?.grid ?? {}
+  };
+  const cols = {
+    lg: responsive.wide.cols ?? 24,
+    md: responsive.desktop.cols ?? 24,
+    sm: responsive.tablet.cols ?? 24,
+    xs: responsive.mobile.cols ?? 24,
+    xxs: responsive.mobile.cols ?? 24
+  };
+  const layoutKey = layoutKeyForWidth(width);
+  const breakpoint = BREAKPOINT_MAP[layoutKey] ?? "desktop";
+  const gridWidgets = Object.values(widgets).filter(
+    (widget) => !isPanelledControl(widget, dashboard)
+  );
+  const configuredMaxRows = gridConfig.maxRows ?? void 0;
+  const declared = buildBaseLayouts(
+    widgets,
+    dashboard,
+    {},
+    [],
+    configuredMaxRows
+  );
+  const safe = sanitizeLayouts(declared, cols, configuredMaxRows);
+  const covered = ensureLayoutCoverage(
+    safe,
+    widgets,
+    dashboard,
+    {},
+    [],
+    configuredMaxRows
+  );
+  const placed = filterLayoutsByIds(
+    covered,
+    new Set(gridWidgets.map((widget) => widget.metadata.id))
+  );
+  const layouts = stackNarrowLayouts(placed, {
+    xs: cols.xs,
+    xxs: cols.xxs
+  });
+  const breakpointConfig = responsive[breakpoint];
+  const margin = breakpointConfig.margin ?? [8, 8];
+  const containerPadding = breakpointConfig.containerPadding ?? gridConfig.containerPadding ?? margin;
+  const columnCount = cols[layoutKey];
+  const marginX = margin[0] ?? 8;
+  const marginY = margin[1] ?? 8;
+  const paddingX = containerPadding[0] ?? marginX;
+  const paddingY = containerPadding[1] ?? marginY;
+  const columnWidth = (width - 2 * paddingX - marginX * (columnCount - 1)) / columnCount;
+  const smallBreakpoint = breakpoint === "mobile" || breakpoint === "tablet";
+  const rowHeightFloor = breakpointConfig.row_height ?? 30;
+  const squareHeight = smallBreakpoint ? Math.max(columnWidth, rowHeightFloor, 1) : Math.max(columnWidth, 1);
+  const rowHeight = Math.max(
+    1,
+    gridConfig.squareCells === false ? rowHeightFloor : squareHeight
+  );
+  const items = layouts[layoutKey] ?? [];
+  const gridBottom = items.reduce(
+    (lowest, item) => Math.max(lowest, item.y + item.h),
+    0
+  );
+  return {
+    layoutKey,
+    breakpoint,
+    height: gridBottom * rowHeight + Math.max(0, gridBottom - 1) * marginY + 2 * paddingY,
+    columnCount,
+    columnWidth,
+    rowHeight,
+    tiles: items.filter((item) => widgets[item.i] !== void 0).map((item) => ({
+      widgetId: item.i,
+      left: paddingX + item.x * (columnWidth + marginX),
+      top: paddingY + item.y * (rowHeight + marginY),
+      width: item.w * columnWidth + Math.max(0, item.w - 1) * marginX,
+      height: item.h * rowHeight + Math.max(0, item.h - 1) * marginY
+    }))
+  };
+}
+function readerRendererContext(dashboard) {
+  const widgetDefaults = dashboard.spec.config?.widgetDefaults;
+  return widgetDefaults === void 0 || widgetDefaults === null ? {} : {
+    widgetDefaults
+  };
+}
+
+// ../dashboard-renderers/src/result-table.ts
+function resultRows(result) {
+  const rows = result?.rows;
+  if (!Array.isArray(rows)) return [];
+  return rows.filter(
+    (row) => typeof row === "object" && row !== null && !Array.isArray(row)
+  );
+}
+function resultColumns(result, rows) {
+  const columns = result?.columns;
+  if (Array.isArray(columns)) {
+    const named = columns.map(
+      (column) => typeof column === "string" ? column : typeof column === "object" && column !== null ? String(column.name ?? "") : ""
+    ).filter((column) => column !== "");
+    if (named.length > 0) return named;
+  }
+  const first = rows[0];
+  return first === void 0 ? [] : Object.keys(first);
+}
+function cellText(value) {
+  if (value === null || value === void 0 || value === "") return "-";
+  if (typeof value === "number") return value.toLocaleString();
+  if (typeof value === "boolean") return value ? "true" : "false";
+  return String(value);
+}
+function csvCell(value) {
+  const text2 = value === null || value === void 0 ? "" : String(value);
+  return /[",\n]/u.test(text2) ? `"${text2.replaceAll('"', '""')}"` : text2;
+}
+function formatTableCsv(table) {
+  const header = table.columns.map(csvCell).join(",");
+  const body = table.rows.map(
+    (row) => table.columns.map((column) => csvCell(row[column])).join(",")
+  );
+  return [header, ...body].join("\r\n");
+}
+
+export { AGGREGATIONS, ALL_COMPONENTS, BREAKPOINT_MAP, BUILDER_COMPONENTS, CHART_TYPES, CONTROL_COMPONENTS, DEFAULT_GRID_CONFIG, DELTA_FORMATS, FILTER_CONTROLS, LAYOUT_BREAKPOINT_WIDTHS, MAX_LAYOUT_WIDTHS, MODEL_TEMPLATES, NUMBER_FORMATS, PIVOT_AGGREGATIONS, PIVOT_DIRECTIONS, PIVOT_SUBTOTALS, SORT_ORDERS, TEMPLATE_COMPONENTS, addWidgetToLayouts, aggregationExpression, blockingKeys, buildBaseLayouts, buildReaderGrid, cellText, computeRequiredMaxRows, countModelIssues, dashboardTabs, dashboardTemplate, dataStoreFragment, datasetFragment, datasetsAreJoined, datasetsInExpression, defaultTabId, diagnosticsToMarkers, dimensionTypeFor, ensureLayoutCoverage, filterLayoutsByIds, filterPanelConfig, firstFreeSlot, formatTableCsv, humanizeColumn, indexModelYaml, insertModelTemplate, isBuilderComponent, isControlComponent, isDoubleScaledPercent, isPanelledControl, itemsCollide, labelColumns, layoutForBreakpoint, layoutKeyForWidth, layoutsForSave, mergeLayouts, modelMetricFragment, modelMetricIssues, modelText, movedIds, numericColumns, overlappingIds, parseAggregation, parseModelDocument, parseRatioExpression, preservedKeys, ratioExpression, readDashboardOutline, readDataStores, readDatasets, readModelMetrics, readModelOutline, readRelationships, readWidgetOutline, readerRendererContext, relationshipFragment, relationshipIssues, removeDataStore, removeDataset, removeModelMetric, removeRelationship, requiredRows, rescaleLayoutColumns, resolveCollisions, resolveResponsive, resolveSnap, resultColumns, resultRows, sanitizeLayouts, stackNarrowLayouts, storeOf, stripPanelledControls, syncActiveLayoutToDesktopWide, syncDesktopWideLayouts, tabWidgetIds, templateComponentLabel, upsertDataStore, upsertDataset, upsertModelMetric, upsertRelationship, widgetColumns, widgetFindings, widgetFragment, widgetIssues, widgetMarkers, widgetTemplate, writeComponent, writeIdentity, writePivotLayout, writeWidget, yamlSyntaxMarkers };
+//# sourceMappingURL=chunk-IMNUQGHE.js.map
+//# sourceMappingURL=chunk-IMNUQGHE.js.map