@richardmcquiston01/dashboard-widgets-toolkit 0.15.0 → 0.17.0

package/dist/core.cjs

@@ -1,88 +1,5 @@
 'use strict';
 
-// src/core/payload.ts
-var WIDGET_KINDS = [
-  "TEXT",
-  "KPI",
-  "GAUGE",
-  "TABLE",
-  "BAR_LIST",
-  "ALERT_LIST",
-  "GRAPH"
-];
-function isWidgetKind(value) {
-  return typeof value === "string" && WIDGET_KINDS.includes(value);
-}
-var VALUE_FORMATS = ["number", "currency", "percent"];
-var MAX_GRAPH_SERIES = 8;
-var DEFAULT_EMPTY_TEXT = "Nothing to show yet.";
-function emptyWidget(text = DEFAULT_EMPTY_TEXT) {
-  return { empty: true, text };
-}
-function isWidgetEmptyState(payload) {
-  return "empty" in payload && payload.empty === true;
-}
-function emptyTextFor(payload) {
-  if (isWidgetEmptyState(payload)) {
-    return payload.text;
-  }
-  switch (payload.kind) {
-    case "TABLE":
-      return payload.rows.length === 0 ? DEFAULT_EMPTY_TEXT : null;
-    case "BAR_LIST":
-      return payload.items.length === 0 ? DEFAULT_EMPTY_TEXT : null;
-    case "ALERT_LIST":
-      return payload.items.length === 0 ? payload.emptyText : null;
-    case "GRAPH":
-      return payload.series.every((series) => series.points.length === 0) ? DEFAULT_EMPTY_TEXT : null;
-    case "TEXT":
-    case "KPI":
-    case "GAUGE":
-      return null;
-  }
-}
-
-// src/core/compat.ts
-function isStringArray(value) {
-  return Array.isArray(value) && value.every((v) => typeof v === "string");
-}
-function upgradeLegacyWidgetData(value) {
-  if (typeof value !== "object" || value === null || Array.isArray(value)) {
-    return value;
-  }
-  const record = value;
-  if (record["kind"] === "TABLE" && isStringArray(record["columns"]) && Array.isArray(record["rows"]) && record["rows"].every(isStringArray)) {
-    const rows = record["rows"];
-    return {
-      ...record,
-      columns: record["columns"].map((label) => ({ label })),
-      rows: rows.map((row) => row.map((text) => ({ text })))
-    };
-  }
-  if (record["kind"] === "GRAPH" && Array.isArray(record["points"]) && record["series"] === void 0) {
-    const { points, ...rest } = record;
-    return {
-      ...rest,
-      series: [{ name: "Value", points }],
-      chartType: "bar",
-      valueFormat: "number"
-    };
-  }
-  return value;
-}
-function fromLegacyDefinition(legacy) {
-  if (!isWidgetKind(legacy.viewType)) {
-    return null;
-  }
-  return {
-    key: legacy.widgetKey,
-    title: legacy.title,
-    ...legacy.description === null ? {} : { description: legacy.description },
-    kind: legacy.viewType,
-    sortOrder: legacy.sortOrder
-  };
-}
-
 // src/core/definition.ts
 var WIDGET_SIZES = ["small", "medium", "large", "full"];
 var WIDGET_FILLS = ["height", "width", "both"];
@@ -90,13 +7,15 @@ var NOT_LOCKED = Object.freeze({
   move: false,
   hide: false,
   minimize: false,
-  options: false
+  options: false,
+  clone: false
 });
 var FULLY_LOCKED = Object.freeze({
   move: true,
   hide: true,
   minimize: true,
-  options: true
+  options: true,
+  clone: true
 });
 function resolveWidgetLock(definition) {
   const setting = definition.locked;
@@ -106,7 +25,8 @@ function resolveWidgetLock(definition) {
     move: setting.move === true,
     hide: setting.hide === true,
     minimize: setting.minimize === true,
-    options: setting.options === true
+    options: setting.options === true,
+    clone: setting.clone === true
   };
 }
 function defineWidget(definition) {
@@ -130,6 +50,103 @@ function isWidgetVisibleTo(definition, roles) {
   return definition.roles.some((role) => roles.includes(role));
 }
 
+// src/core/grid.ts
+var WIDTH_COLUMNS = 12;
+var MIN_WIDGET_WIDTH = 2;
+var MAX_WIDGET_WIDTH = 12;
+function isWidgetWidth(value) {
+  return typeof value === "number" && Number.isInteger(value) && value >= MIN_WIDGET_WIDTH && value <= MAX_WIDGET_WIDTH;
+}
+function widthForSize(size) {
+  switch (size) {
+    case "small":
+      return 3;
+    case "large":
+      return 6;
+    case "full":
+      return 12;
+    default:
+      return 4;
+  }
+}
+function itemWidth(item) {
+  return isWidgetWidth(item.width) ? item.width : widthForSize(item.defaultSize);
+}
+function usesWidthColumns(items) {
+  return items.some((item) => item.width !== void 0);
+}
+function fillsWidth(fill) {
+  return fill === "width" || fill === "both";
+}
+function fillsHeight(fill) {
+  return fill === "height" || fill === "both";
+}
+function baseColumnSpan(size, columns, largeSpan = 2) {
+  if (size === "full") return columns;
+  if (size === "large") return Math.min(largeSpan, columns);
+  return 1;
+}
+function fillColumnSpans(items, columns, largeSpan = 2) {
+  return placeAndFill(
+    items,
+    columns,
+    (item, trackCount) => baseColumnSpan(item.defaultSize, trackCount, largeSpan)
+  );
+}
+function fillWidthSpans(items) {
+  return placeAndFill(items, WIDTH_COLUMNS, itemWidth);
+}
+function placeRows(items) {
+  return placeAndFillRows(items, WIDTH_COLUMNS, itemWidth).rows;
+}
+function fitCount(items, maxRows) {
+  const rows = placeRows(items);
+  let count = 0;
+  for (const row of rows.slice(0, Math.max(0, Math.floor(maxRows)))) {
+    count += row.keys.length;
+  }
+  return count;
+}
+function placeAndFill(items, columns, spanOf) {
+  return placeAndFillRows(items, columns, spanOf).spans;
+}
+function placeAndFillRows(items, columns, spanOf) {
+  const trackCount = Math.max(1, Math.floor(columns));
+  const spans = /* @__PURE__ */ new Map();
+  const rows = [];
+  let row = [];
+  let used = 0;
+  function closeRow() {
+    if (row.length === 0) return;
+    const fillers = row.filter(({ item }) => fillsWidth(item.fill));
+    const leftover = trackCount - used;
+    const finalSpans = /* @__PURE__ */ new Map();
+    if (fillers.length > 0) {
+      const share = Math.floor(leftover / fillers.length);
+      const remainder = leftover % fillers.length;
+      fillers.forEach(({ item, span }, index) => {
+        const grown = span + share + (index < remainder ? 1 : 0);
+        spans.set(item.key, grown);
+        finalSpans.set(item.key, grown);
+      });
+    }
+    rows.push({
+      keys: row.map(({ item }) => item.key),
+      spans: row.map(({ item, span }) => finalSpans.get(item.key) ?? span)
+    });
+    row = [];
+    used = 0;
+  }
+  for (const item of items) {
+    const span = Math.min(spanOf(item, trackCount), trackCount);
+    if (used + span > trackCount && row.length > 0) closeRow();
+    row.push({ item, span });
+    used += span;
+  }
+  closeRow();
+  return { spans, rows };
+}
+
 // src/core/format.ts
 var DEFAULT_CURRENCY = "USD";
 function localeArgument(locale) {
@@ -215,6 +232,48 @@ function kpiDelta(current, previous, options = {}) {
   };
 }
 
+// src/core/payload.ts
+var WIDGET_KINDS = [
+  "TEXT",
+  "KPI",
+  "GAUGE",
+  "TABLE",
+  "BAR_LIST",
+  "ALERT_LIST",
+  "GRAPH"
+];
+function isWidgetKind(value) {
+  return typeof value === "string" && WIDGET_KINDS.includes(value);
+}
+var VALUE_FORMATS = ["number", "currency", "percent"];
+var MAX_GRAPH_SERIES = 8;
+var DEFAULT_EMPTY_TEXT = "Nothing to show yet.";
+function emptyWidget(text = DEFAULT_EMPTY_TEXT) {
+  return { empty: true, text };
+}
+function isWidgetEmptyState(payload) {
+  return "empty" in payload && payload.empty === true;
+}
+function emptyTextFor(payload) {
+  if (isWidgetEmptyState(payload)) {
+    return payload.text;
+  }
+  switch (payload.kind) {
+    case "TABLE":
+      return payload.rows.length === 0 ? DEFAULT_EMPTY_TEXT : null;
+    case "BAR_LIST":
+      return payload.items.length === 0 ? DEFAULT_EMPTY_TEXT : null;
+    case "ALERT_LIST":
+      return payload.items.length === 0 ? payload.emptyText : null;
+    case "GRAPH":
+      return payload.series.every((series) => series.points.length === 0) ? DEFAULT_EMPTY_TEXT : null;
+    case "TEXT":
+    case "KPI":
+    case "GAUGE":
+      return null;
+  }
+}
+
 // src/core/result.ts
 function ok(value) {
   return { ok: true, value };
@@ -237,20 +296,308 @@ function describeUnknownError(cause) {
   }
 }
 
-// src/core/url.ts
-var SCHEME_PATTERN = /^([a-z][a-z0-9+.-]*):/i;
-var IGNORED_IN_SCHEME = /[\u0000- \u007f]/g;
-function schemeOf(url) {
-  const match = SCHEME_PATTERN.exec(
-    url.replace(IGNORED_IN_SCHEME, "")
-  );
-  return match === null ? null : (match[1] ?? "").toLowerCase();
+// src/core/views.ts
+var BASE_VIEW_KEY = "base";
+var MAX_WIDGET_VIEWS = 8;
+var VIEW_CONVERSIONS = {
+  tableToBarList: { from: "TABLE", to: "BAR_LIST" },
+  tableToGraph: { from: "TABLE", to: "GRAPH" },
+  barListToTable: { from: "BAR_LIST", to: "TABLE" },
+  graphToTable: { from: "GRAPH", to: "TABLE" },
+  barListToGraph: { from: "BAR_LIST", to: "GRAPH" }
+};
+var KIND_LABELS = {
+  TEXT: "Text",
+  KPI: "Number",
+  GAUGE: "Gauge",
+  TABLE: "Table",
+  BAR_LIST: "Bars",
+  ALERT_LIST: "List",
+  GRAPH: "Chart"
+};
+function kindLabel(kind) {
+  return KIND_LABELS[kind];
 }
-function isSafeHref(url) {
-  if (url.trim() === "") {
-    return false;
-  }
-  const scheme = schemeOf(url);
+function hasViews(item) {
+  return item.views !== void 0 && item.views.length > 0;
+}
+function findView(item, key) {
+  return item.views?.find((view) => view.key === key);
+}
+function viewChoices(item) {
+  if (!hasViews(item)) return [];
+  return [
+    {
+      key: BASE_VIEW_KEY,
+      label: item.baseViewLabel ?? kindLabel(item.kind),
+      kind: item.kind
+    },
+    ...(item.views ?? []).map(({ key, label, kind }) => ({
+      key,
+      label,
+      kind
+    }))
+  ];
+}
+function isProviderView(view) {
+  return view.convert === void 0;
+}
+function isKnownView(item, key) {
+  return key !== void 0 && (key === BASE_VIEW_KEY || findView(item, key) !== void 0);
+}
+function effectiveViewKey(item, chosen) {
+  if (!hasViews(item)) return BASE_VIEW_KEY;
+  if (isKnownView(item, chosen)) return chosen;
+  if (isKnownView(item, item.defaultView)) return item.defaultView;
+  return BASE_VIEW_KEY;
+}
+function viewKind(item, chosen) {
+  return findView(item, effectiveViewKey(item, chosen))?.kind ?? item.kind;
+}
+function loadViewKey(item, chosen) {
+  const key = effectiveViewKey(item, chosen);
+  const view = findView(item, key);
+  return view !== void 0 && isProviderView(view) ? key : BASE_VIEW_KEY;
+}
+function loadViewKind(item, chosen) {
+  return findView(item, loadViewKey(item, chosen))?.kind ?? item.kind;
+}
+function cellValue(cell) {
+  const value = cell?.value;
+  return typeof value === "number" && Number.isFinite(value) ? value : void 0;
+}
+function columnName(table, index) {
+  return table.columns[index]?.label ?? `#${index + 1}`;
+}
+function checkColumn(table, index, field, context) {
+  if (!Number.isInteger(index) || index < 0 || index >= table.columns.length) {
+    return `${context.where}: ${field} column ${index} does not exist (the table has ${table.columns.length} columns, numbered from 0).`;
+  }
+  return void 0;
+}
+function numericColumn(table, index, context) {
+  const numbers = [];
+  for (const [rowIndex, row] of table.rows.entries()) {
+    const value = cellValue(row[index]);
+    if (value === void 0) {
+      return err(
+        `${context.where}: row ${rowIndex + 1}, column ${index + 1} ("${columnName(table, index)}") has no numeric value. Add value to the cells.`
+      );
+    }
+    numbers.push(value);
+  }
+  return ok(numbers);
+}
+function tableToBarList(table, conversion, context) {
+  const bad = checkColumn(table, conversion.label, "label", context) ?? checkColumn(table, conversion.value, "value", context);
+  if (bad !== void 0) return err(bad);
+  const numbers = numericColumn(table, conversion.value, context);
+  if (!numbers.ok) return numbers;
+  const items = table.rows.map((row, index) => ({
+    label: row[conversion.label]?.text ?? "",
+    value: numbers.value[index],
+    display: row[conversion.value]?.text ?? String(numbers.value[index])
+  }));
+  return ok({ kind: "BAR_LIST", items });
+}
+function tableToGraph(table, conversion, context) {
+  if (conversion.values.length === 0 || conversion.values.length > MAX_GRAPH_SERIES) {
+    return err(
+      `${context.where}: a chart needs 1 to ${MAX_GRAPH_SERIES} series columns, got ${conversion.values.length}.`
+    );
+  }
+  let bad = checkColumn(
+    table,
+    conversion.label,
+    "label",
+    context
+  );
+  for (const index of conversion.values) {
+    bad ??= checkColumn(table, index, "series", context);
+  }
+  if (bad !== void 0) return err(bad);
+  const series = [];
+  for (const index of conversion.values) {
+    const numbers = numericColumn(table, index, context);
+    if (!numbers.ok) return numbers;
+    series.push({
+      name: columnName(table, index),
+      points: table.rows.map((row, rowIndex) => ({
+        label: row[conversion.label]?.text ?? "",
+        value: numbers.value[rowIndex]
+      }))
+    });
+  }
+  return ok({
+    kind: "GRAPH",
+    series,
+    chartType: conversion.chartType,
+    valueFormat: conversion.valueFormat ?? "number",
+    ...conversion.currency === void 0 ? {} : { currency: conversion.currency },
+    xLabel: columnName(table, conversion.label)
+  });
+}
+function barListToTable(list, conversion) {
+  return ok({
+    kind: "TABLE",
+    columns: [
+      { label: conversion.labelHeading ?? "Name" },
+      { label: conversion.valueHeading ?? "Value", numeric: true }
+    ],
+    rows: list.items.map((item) => [
+      { text: item.label },
+      { text: item.display ?? String(item.value), value: item.value }
+    ])
+  });
+}
+function graphToTable(graph, context) {
+  const first = graph.series[0];
+  if (first === void 0)
+    return err(`${context.where}: the chart has no series.`);
+  const format = {
+    ...graph.currency === void 0 ? {} : { currency: graph.currency },
+    ...context.locale === void 0 ? {} : { locale: context.locale }
+  };
+  return ok({
+    kind: "TABLE",
+    columns: [
+      { label: graph.xLabel ?? "Label" },
+      ...graph.series.map((series) => ({ label: series.name, numeric: true }))
+    ],
+    rows: first.points.map((point, index) => [
+      { text: point.label },
+      ...graph.series.map((series) => {
+        const value = series.points[index]?.value;
+        return value === void 0 ? { text: "\u2014" } : { text: formatValue(value, graph.valueFormat, format), value };
+      })
+    ])
+  });
+}
+function barListToGraph(list, conversion) {
+  return ok({
+    kind: "GRAPH",
+    series: [
+      {
+        name: conversion.seriesName ?? "Value",
+        points: list.items.map((item) => ({
+          label: item.label,
+          value: item.value
+        }))
+      }
+    ],
+    chartType: conversion.chartType,
+    valueFormat: conversion.valueFormat ?? "number",
+    ...conversion.currency === void 0 ? {} : { currency: conversion.currency }
+  });
+}
+function convertView(widgetKey, view, data, options = {}) {
+  const conversion = view.convert;
+  const context = {
+    where: `Widget ${JSON.stringify(widgetKey)} view ${JSON.stringify(view.key)}`,
+    ...options.locale === void 0 ? {} : { locale: options.locale }
+  };
+  if (conversion === void 0) {
+    return err(
+      `${context.where}: the provider supplies this view, so there is nothing to convert.`
+    );
+  }
+  const expected = VIEW_CONVERSIONS[conversion.type]?.from;
+  if (expected === void 0) {
+    return err(
+      `${context.where}: unknown conversion type ${JSON.stringify(conversion.type)}.`
+    );
+  }
+  if (data.kind !== expected) {
+    return err(
+      `${context.where}: ${conversion.type} reads a ${expected} payload, but the widget returned ${data.kind}.`
+    );
+  }
+  switch (conversion.type) {
+    case "tableToBarList":
+      return tableToBarList(data, conversion, context);
+    case "tableToGraph":
+      return tableToGraph(data, conversion, context);
+    case "barListToTable":
+      return barListToTable(data, conversion);
+    case "graphToTable":
+      return graphToTable(data, context);
+    case "barListToGraph":
+      return barListToGraph(data, conversion);
+  }
+}
+function viewNote(view, data) {
+  const conversion = view.convert;
+  if (data?.kind !== "TABLE" || conversion === void 0) return "";
+  let indexes;
+  if (conversion.type === "tableToBarList") {
+    indexes = [conversion.label, conversion.value];
+  } else if (conversion.type === "tableToGraph") {
+    indexes = [conversion.label, ...conversion.values];
+  } else {
+    return "";
+  }
+  const names = indexes.map(
+    (index) => data.columns[index]?.label ?? `#${index + 1}`
+  );
+  return `Shows ${names.join(", ")} only.`;
+}
+function applyView(widget, chosen, options = {}) {
+  const key = effectiveViewKey(widget.definition, chosen);
+  const view = findView(widget.definition, key);
+  const wanted = loadViewKey(widget.definition, chosen);
+  const loaded = widget.status === "ok" ? widget.view ?? BASE_VIEW_KEY : void 0;
+  const mismatched = loaded !== void 0 && loaded !== wanted;
+  if (view === void 0) {
+    return mismatched ? {
+      definition: widget.definition,
+      status: "loading",
+      ...widget.options === void 0 ? {} : { options: widget.options }
+    } : widget;
+  }
+  const definition = {
+    ...widget.definition,
+    kind: view.kind
+  };
+  if (widget.status !== "ok") return { ...widget, definition };
+  if (mismatched) {
+    return {
+      definition,
+      status: "loading",
+      ...widget.options === void 0 ? {} : { options: widget.options }
+    };
+  }
+  if (isProviderView(view)) return { ...widget, definition };
+  const converted = convertView(
+    widget.definition.key,
+    view,
+    widget.data,
+    options
+  );
+  if (!converted.ok) {
+    return {
+      definition,
+      status: "error",
+      error: converted.error,
+      ...widget.options === void 0 ? {} : { options: widget.options }
+    };
+  }
+  return { ...widget, definition, data: converted.value };
+}
+
+// src/core/url.ts
+var SCHEME_PATTERN = /^([a-z][a-z0-9+.-]*):/i;
+var IGNORED_IN_SCHEME = /[\u0000- \u007f]/g;
+function schemeOf(url) {
+  const match = SCHEME_PATTERN.exec(
+    url.replace(IGNORED_IN_SCHEME, "")
+  );
+  return match === null ? null : (match[1] ?? "").toLowerCase();
+}
+function isSafeHref(url) {
+  if (url.trim() === "") {
+    return false;
+  }
+  const scheme = schemeOf(url);
   return scheme === null || scheme === "http" || scheme === "https" || scheme === "mailto";
 }
 function isSafeImageUrl(url) {
@@ -291,15 +638,15 @@ function defaultDetailQuery(pageSize = DEFAULT_DETAIL_PAGE_SIZE) {
 function fold(text) {
   return text.normalize("NFD").replace(/\p{M}/gu, "").toLowerCase();
 }
-function cellValue(cell) {
+function cellValue2(cell) {
   return cell.value ?? cell.text;
 }
 function cellMatches(cell, needle) {
-  return fold(String(cellValue(cell))).includes(needle);
+  return fold(String(cellValue2(cell))).includes(needle);
 }
 function compareCells(a, b, collator) {
-  const left = cellValue(a);
-  const right = cellValue(b);
+  const left = cellValue2(a);
+  const right = cellValue2(b);
   if (typeof left === "number" && typeof right === "number") {
     return left - right;
   }
@@ -591,1492 +938,1878 @@ function deriveDetailData(data, locale) {
   return void 0;
 }
 
-// src/core/grid.ts
-var WIDTH_COLUMNS = 12;
-var MIN_WIDGET_WIDTH = 2;
-var MAX_WIDGET_WIDTH = 12;
-function isWidgetWidth(value) {
-  return typeof value === "number" && Number.isInteger(value) && value >= MIN_WIDGET_WIDTH && value <= MAX_WIDGET_WIDTH;
-}
-function widthForSize(size) {
-  switch (size) {
-    case "small":
-      return 3;
-    case "large":
-      return 6;
-    case "full":
-      return 12;
-    default:
-      return 4;
-  }
-}
-function itemWidth(item) {
-  return isWidgetWidth(item.width) ? item.width : widthForSize(item.defaultSize);
-}
-function usesWidthColumns(items) {
-  return items.some((item) => item.width !== void 0);
+// src/core/options.ts
+var DATE_RANGE_PRESETS = [
+  "today",
+  "yesterday",
+  "last7",
+  "last30",
+  "last90",
+  "thisMonth",
+  "lastMonth",
+  "thisYear",
+  "lastYear"
+];
+var WIDGET_OPTION_TYPES = [
+  "choice",
+  "number",
+  "boolean",
+  "text",
+  "dateRange",
+  "color",
+  "sort",
+  "columns"
+];
+var MAX_WIDGET_OPTIONS = 20;
+var MAX_TEXT_OPTION_LENGTH = 500;
+var OPTION_KEY_PATTERN = /^[A-Za-z][A-Za-z0-9_-]{0,39}$/;
+var COLOR_PATTERN = /^#[0-9a-fA-F]{6}$/;
+var INTERVAL_PATTERN = /^(\d{4}-\d{2}-\d{2})\/(\d{4}-\d{2}-\d{2})$/;
+var CONTROL_CHARACTERS = /[\u0000-\u001f\u007f]/;
+function isColumnKeyFor(kind, key) {
+  if (kind === "TABLE") return /^c\d+$/.test(key);
+  if (kind === "BAR_LIST") return key === "label" || key === "value";
+  return false;
 }
-function fillsWidth(fill) {
-  return fill === "width" || fill === "both";
+function isClientApplied(option) {
+  return (option.type === "sort" || option.type === "columns") && option.apply === "client";
 }
-function fillsHeight(fill) {
-  return fill === "height" || fill === "both";
+function civilToday(context) {
+  const now = context.now ?? Date.now();
+  let timeZone = context.timeZone ?? "UTC";
+  try {
+    new Intl.DateTimeFormat("en-US", { timeZone });
+  } catch {
+    timeZone = "UTC";
+  }
+  const parts = new Intl.DateTimeFormat("en-US", {
+    timeZone,
+    year: "numeric",
+    month: "2-digit",
+    day: "2-digit"
+  }).formatToParts(new Date(now));
+  const pick = (type) => Number(parts.find((part) => part.type === type)?.value ?? "0");
+  return { year: pick("year"), month: pick("month"), day: pick("day") };
 }
-function baseColumnSpan(size, columns, largeSpan = 2) {
-  if (size === "full") return columns;
-  if (size === "large") return Math.min(largeSpan, columns);
-  return 1;
+function toIso(epochMs) {
+  return new Date(epochMs).toISOString().slice(0, 10);
 }
-function fillColumnSpans(items, columns, largeSpan = 2) {
-  return placeAndFill(
-    items,
-    columns,
-    (item, trackCount) => baseColumnSpan(item.defaultSize, trackCount, largeSpan)
+var DAY_MS = 864e5;
+function parseIsoDay(text) {
+  const match = /^(\d{4})-(\d{2})-(\d{2})$/.exec(text);
+  if (match === null) return void 0;
+  const epoch = Date.UTC(
+    Number(match[1]),
+    Number(match[2]) - 1,
+    Number(match[3])
   );
+  return toIso(epoch) === text ? epoch : void 0;
 }
-function fillWidthSpans(items) {
-  return placeAndFill(items, WIDTH_COLUMNS, itemWidth);
+function isIsoInterval(value) {
+  const match = INTERVAL_PATTERN.exec(value);
+  if (match === null) return false;
+  const start = parseIsoDay(match[1]);
+  const end = parseIsoDay(match[2]);
+  return start !== void 0 && end !== void 0 && start <= end;
 }
-function placeRows(items) {
-  return placeAndFillRows(items, WIDTH_COLUMNS, itemWidth).rows;
+function isPreset(value) {
+  return DATE_RANGE_PRESETS.includes(value);
 }
-function fitCount(items, maxRows) {
-  const rows = placeRows(items);
-  let count = 0;
-  for (const row of rows.slice(0, Math.max(0, Math.floor(maxRows)))) {
-    count += row.keys.length;
+function resolveDateRange(value, context = {}) {
+  if (isIsoInterval(value)) return value;
+  if (!isPreset(value)) return void 0;
+  const today = civilToday(context);
+  const todayMs = Date.UTC(today.year, today.month - 1, today.day);
+  const range = (startMs, endMs) => `${toIso(startMs)}/${toIso(endMs)}`;
+  switch (value) {
+    case "today":
+      return range(todayMs, todayMs);
+    case "yesterday":
+      return range(todayMs - DAY_MS, todayMs - DAY_MS);
+    case "last7":
+      return range(todayMs - 6 * DAY_MS, todayMs);
+    case "last30":
+      return range(todayMs - 29 * DAY_MS, todayMs);
+    case "last90":
+      return range(todayMs - 89 * DAY_MS, todayMs);
+    case "thisMonth":
+      return range(Date.UTC(today.year, today.month - 1, 1), todayMs);
+    case "lastMonth":
+      return range(
+        Date.UTC(today.year, today.month - 2, 1),
+        Date.UTC(today.year, today.month - 1, 1) - DAY_MS
+      );
+    case "thisYear":
+      return range(Date.UTC(today.year, 0, 1), todayMs);
+    case "lastYear":
+      return range(
+        Date.UTC(today.year - 1, 0, 1),
+        Date.UTC(today.year, 0, 1) - DAY_MS
+      );
   }
-  return count;
 }
-function placeAndFill(items, columns, spanOf) {
-  return placeAndFillRows(items, columns, spanOf).spans;
+function onStepGrid(option, value) {
+  if (option.step === void 0) return true;
+  const steps = (value - option.min) / option.step;
+  return Math.abs(steps - Math.round(steps)) < 1e-9;
 }
-function placeAndFillRows(items, columns, spanOf) {
-  const trackCount = Math.max(1, Math.floor(columns));
-  const spans = /* @__PURE__ */ new Map();
-  const rows = [];
-  let row = [];
-  let used = 0;
-  function closeRow() {
-    if (row.length === 0) return;
-    const fillers = row.filter(({ item }) => fillsWidth(item.fill));
-    const leftover = trackCount - used;
-    const finalSpans = /* @__PURE__ */ new Map();
-    if (fillers.length > 0) {
-      const share = Math.floor(leftover / fillers.length);
-      const remainder = leftover % fillers.length;
-      fillers.forEach(({ item, span }, index) => {
-        const grown = span + share + (index < remainder ? 1 : 0);
-        spans.set(item.key, grown);
-        finalSpans.set(item.key, grown);
-      });
+function parseSortValue(value) {
+  const separator = value.lastIndexOf(":");
+  if (separator <= 0) return void 0;
+  const column = value.slice(0, separator);
+  const direction = value.slice(separator + 1);
+  if (direction !== "asc" && direction !== "desc") return void 0;
+  return { column, direction };
+}
+function sortFromOptions(definition, values) {
+  if (values === void 0) return void 0;
+  const sortOption = definition.options?.find(
+    (option) => option.type === "sort"
+  );
+  if (sortOption === void 0) return void 0;
+  const chosen = values[sortOption.key];
+  return typeof chosen === "string" ? parseSortValue(chosen) : void 0;
+}
+function coerceOptionValue(option, value, context = {}) {
+  switch (option.type) {
+    case "choice":
+      return typeof value === "string" && option.choices.some((choice) => choice.value === value) ? value : void 0;
+    case "number":
+      return typeof value === "number" && Number.isFinite(value) && value >= option.min && value <= option.max && onStepGrid(option, value) ? value : void 0;
+    case "boolean":
+      return typeof value === "boolean" ? value : void 0;
+    case "text": {
+      if (typeof value !== "string") return void 0;
+      const trimmed = value.trim();
+      return trimmed.length <= option.maxLength && !CONTROL_CHARACTERS.test(trimmed) ? trimmed : void 0;
+    }
+    case "dateRange": {
+      if (typeof value !== "string") return void 0;
+      if (isPreset(value) && option.presets !== void 0 && !option.presets.some((preset) => preset.value === value)) {
+        return void 0;
+      }
+      return resolveDateRange(value, context);
+    }
+    case "color":
+      return typeof value === "string" && COLOR_PATTERN.test(value) ? value.toLowerCase() : void 0;
+    case "sort": {
+      if (typeof value !== "string") return void 0;
+      const sort = parseSortValue(value);
+      return sort !== void 0 && option.columns.some((column) => column.key === sort.column) ? value : void 0;
+    }
+    case "columns": {
+      if (!Array.isArray(value) || value.length === 0) return void 0;
+      const keys = value;
+      const allowed = new Set(option.columns.map((c) => c.key));
+      const seen = /* @__PURE__ */ new Set();
+      for (const key of keys) {
+        if (typeof key !== "string" || !allowed.has(key) || seen.has(key)) {
+          return void 0;
+        }
+        seen.add(key);
+      }
+      return [...seen];
     }
-    rows.push({
-      keys: row.map(({ item }) => item.key),
-      spans: row.map(({ item, span }) => finalSpans.get(item.key) ?? span)
-    });
-    row = [];
-    used = 0;
   }
-  for (const item of items) {
-    const span = Math.min(spanOf(item, trackCount), trackCount);
-    if (used + span > trackCount && row.length > 0) closeRow();
-    row.push({ item, span });
-    used += span;
+}
+function defaultOptionValue(option, context = {}) {
+  switch (option.type) {
+    case "dateRange":
+      return resolveDateRange(option.default, context);
+    case "sort":
+      return option.default;
+    case "columns":
+      return [...option.default];
+    default:
+      return option.default;
   }
-  closeRow();
-  return { spans, rows };
 }
-
-// src/core/views.ts
-var BASE_VIEW_KEY = "base";
-var MAX_WIDGET_VIEWS = 8;
-var VIEW_CONVERSIONS = {
-  tableToBarList: { from: "TABLE", to: "BAR_LIST" },
-  tableToGraph: { from: "TABLE", to: "GRAPH" },
-  barListToTable: { from: "BAR_LIST", to: "TABLE" },
-  graphToTable: { from: "GRAPH", to: "TABLE" },
-  barListToGraph: { from: "BAR_LIST", to: "GRAPH" }
-};
-var KIND_LABELS = {
-  TEXT: "Text",
-  KPI: "Number",
-  GAUGE: "Gauge",
-  TABLE: "Table",
-  BAR_LIST: "Bars",
-  ALERT_LIST: "List",
-  GRAPH: "Chart"
-};
-function kindLabel(kind) {
-  return KIND_LABELS[kind];
-}
-function hasViews(item) {
-  return item.views !== void 0 && item.views.length > 0;
+var NO_VALUES = Object.freeze({});
+function resolveOptionValues(definition, chosen, context = {}) {
+  const options = definition.options;
+  if (options === void 0 || options.length === 0) return NO_VALUES;
+  const values = {};
+  for (const option of options) {
+    const picked = chosen?.[option.key];
+    const value = (picked === void 0 ? void 0 : coerceOptionValue(option, picked, context)) ?? defaultOptionValue(option, context);
+    if (value !== void 0) values[option.key] = value;
+  }
+  return values;
 }
-function findView(item, key) {
-  return item.views?.find((view) => view.key === key);
+function sameValue(a, b) {
+  if (Array.isArray(a) && Array.isArray(b)) {
+    return a.length === b.length && a.every((item, i) => item === b[i]);
+  }
+  return a === b;
 }
-function viewChoices(item) {
-  if (!hasViews(item)) return [];
-  return [
-    {
-      key: BASE_VIEW_KEY,
-      label: item.baseViewLabel ?? kindLabel(item.kind),
-      kind: item.kind
-    },
-    ...(item.views ?? []).map(({ key, label, kind }) => ({
-      key,
-      label,
-      kind
-    }))
-  ];
+function sameOptionValues(a, b) {
+  const keys = Object.keys({ ...a, ...b });
+  return keys.every((key) => sameValue(a[key], b[key]));
 }
-function isKnownView(item, key) {
-  return key !== void 0 && (key === BASE_VIEW_KEY || findView(item, key) !== void 0);
+function optionsCacheSuffix(definition, values, context = {}) {
+  const parts = [];
+  for (const option of definition.options ?? []) {
+    if (isClientApplied(option)) continue;
+    const value = values[option.key];
+    if (sameValue(value, defaultOptionValue(option, context))) continue;
+    parts.push(
+      `${option.key}=${encodeURIComponent(JSON.stringify(value ?? null))}`
+    );
+  }
+  parts.sort();
+  return parts.length === 0 ? "" : `?${parts.join("&")}`;
 }
-function effectiveViewKey(item, chosen) {
-  if (!hasViews(item)) return BASE_VIEW_KEY;
-  if (isKnownView(item, chosen)) return chosen;
-  if (isKnownView(item, item.defaultView)) return item.defaultView;
-  return BASE_VIEW_KEY;
+function tableColumnIndex(key) {
+  const match = /^c(\d+)$/.exec(key);
+  return match === null ? void 0 : Number(match[1]);
 }
-function viewKind(item, chosen) {
-  return findView(item, effectiveViewKey(item, chosen))?.kind ?? item.kind;
+function sortBarItems(items, sort) {
+  const sign = sort.direction === "desc" ? -1 : 1;
+  return items.map((item, index) => ({ item, index })).sort((a, b) => {
+    const order = sort.column === "value" ? a.item.value - b.item.value : a.item.label.localeCompare(b.item.label);
+    return order * sign || a.index - b.index;
+  }).map(({ item }) => item);
 }
-function cellValue2(cell) {
-  const value = cell?.value;
-  return typeof value === "number" && Number.isFinite(value) ? value : void 0;
+function applyClientOptions(definition, data, values) {
+  const options = definition.options ?? [];
+  const sortOption = options.find(
+    (o) => o.type === "sort" && o.apply === "client"
+  );
+  const columnsOption = options.find(
+    (o) => o.type === "columns" && o.apply === "client"
+  );
+  const sortValue = sortOption === void 0 ? void 0 : values[sortOption.key];
+  const columnsValue = columnsOption === void 0 ? void 0 : values[columnsOption.key];
+  let next = data;
+  if (typeof sortValue === "string") {
+    const sort = parseSortValue(sortValue);
+    if (sort !== void 0 && next.kind === "BAR_LIST") {
+      if (sort.column === "label" || sort.column === "value") {
+        next = { ...next, items: sortBarItems(next.items, sort) };
+      }
+    } else if (sort !== void 0 && next.kind === "TABLE") {
+      const index = tableColumnIndex(sort.column);
+      if (index !== void 0 && index < next.columns.length) {
+        const sorted = queryRows(tableDetailData(next), {
+          page: 1,
+          pageSize: Math.max(1, next.rows.length),
+          sort
+        });
+        if (sorted.ok) next = { ...next, rows: sorted.value.rows };
+      }
+    }
+  }
+  if (Array.isArray(columnsValue) && next.kind === "TABLE") {
+    const table = next;
+    const indexes = columnsValue.map(tableColumnIndex).filter(
+      (index) => index !== void 0 && index < table.columns.length
+    );
+    if (indexes.length > 0) {
+      next = {
+        ...table,
+        columns: indexes.map((i) => table.columns[i]),
+        rows: table.rows.map((row) => indexes.map((i) => row[i]))
+      };
+    }
+  }
+  return next;
 }
-function columnName(table, index) {
-  return table.columns[index]?.label ?? `#${index + 1}`;
+
+// src/core/settings.ts
+var MAX_WIDGET_TITLE_LENGTH = 80;
+var MAX_PARSED_SETTINGS = 500;
+var MAX_COLUMN_LIST = 100;
+var MAX_VALUE_LENGTH = 500;
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
 }
-function checkColumn(table, index, field, context) {
-  if (!Number.isInteger(index) || index < 0 || index >= table.columns.length) {
-    return `${context.where}: ${field} column ${index} does not exist (the table has ${table.columns.length} columns, numbered from 0).`;
+function parseOptionValue(value) {
+  if (typeof value === "string") {
+    return value.length <= MAX_VALUE_LENGTH ? value : void 0;
+  }
+  if (typeof value === "number")
+    return Number.isFinite(value) ? value : void 0;
+  if (typeof value === "boolean") return value;
+  if (Array.isArray(value) && value.length <= MAX_COLUMN_LIST) {
+    return value.every(
+      (entry) => typeof entry === "string" && entry.length <= MAX_VALUE_LENGTH
+    ) ? value : void 0;
   }
   return void 0;
 }
-function numericColumn(table, index, context) {
-  const numbers = [];
-  for (const [rowIndex, row] of table.rows.entries()) {
-    const value = cellValue2(row[index]);
-    if (value === void 0) {
-      return err(
-        `${context.where}: row ${rowIndex + 1}, column ${index + 1} ("${columnName(table, index)}") has no numeric value. Add value to the cells.`
-      );
+function parseOne(raw) {
+  if (!isRecord(raw)) return void 0;
+  const title = raw["title"];
+  const width = raw["width"];
+  const flexible = raw["flexible"];
+  const options = raw["options"];
+  const view = raw["view"];
+  const cleanTitle = typeof title === "string" ? title.trim().slice(0, MAX_WIDGET_TITLE_LENGTH) : "";
+  const chosen = {};
+  if (isRecord(options)) {
+    for (const [key, value] of Object.entries(options)) {
+      const parsed = parseOptionValue(value);
+      if (parsed !== void 0) chosen[key] = parsed;
     }
-    numbers.push(value);
   }
-  return ok(numbers);
-}
-function tableToBarList(table, conversion, context) {
-  const bad = checkColumn(table, conversion.label, "label", context) ?? checkColumn(table, conversion.value, "value", context);
-  if (bad !== void 0) return err(bad);
-  const numbers = numericColumn(table, conversion.value, context);
-  if (!numbers.ok) return numbers;
-  const items = table.rows.map((row, index) => ({
-    label: row[conversion.label]?.text ?? "",
-    value: numbers.value[index],
-    display: row[conversion.value]?.text ?? String(numbers.value[index])
-  }));
-  return ok({ kind: "BAR_LIST", items });
+  const settings = {
+    ...cleanTitle === "" ? {} : { title: cleanTitle },
+    ...isWidgetWidth(width) ? { width } : {},
+    ...typeof flexible === "boolean" ? { flexible } : {},
+    ...Object.keys(chosen).length === 0 ? {} : { options: chosen },
+    ...typeof view === "string" && view !== "" && view.length <= 80 ? { view } : {}
+  };
+  return Object.keys(settings).length === 0 ? void 0 : settings;
 }
-function tableToGraph(table, conversion, context) {
-  if (conversion.values.length === 0 || conversion.values.length > MAX_GRAPH_SERIES) {
-    return err(
-      `${context.where}: a chart needs 1 to ${MAX_GRAPH_SERIES} series columns, got ${conversion.values.length}.`
-    );
-  }
-  let bad = checkColumn(
-    table,
-    conversion.label,
-    "label",
-    context
-  );
-  for (const index of conversion.values) {
-    bad ??= checkColumn(table, index, "series", context);
-  }
-  if (bad !== void 0) return err(bad);
-  const series = [];
-  for (const index of conversion.values) {
-    const numbers = numericColumn(table, index, context);
-    if (!numbers.ok) return numbers;
-    series.push({
-      name: columnName(table, index),
-      points: table.rows.map((row, rowIndex) => ({
-        label: row[conversion.label]?.text ?? "",
-        value: numbers.value[rowIndex]
-      }))
-    });
+function parseSettings(raw) {
+  if (!isRecord(raw)) return void 0;
+  const parsed = {};
+  for (const [key, value] of Object.entries(raw).slice(
+    0,
+    MAX_PARSED_SETTINGS
+  )) {
+    if (key === "") continue;
+    const one = parseOne(value);
+    if (one !== void 0) parsed[key] = one;
   }
-  return ok({
-    kind: "GRAPH",
-    series,
-    chartType: conversion.chartType,
-    valueFormat: conversion.valueFormat ?? "number",
-    ...conversion.currency === void 0 ? {} : { currency: conversion.currency },
-    xLabel: columnName(table, conversion.label)
-  });
+  return Object.keys(parsed).length === 0 ? void 0 : parsed;
 }
-function barListToTable(list, conversion) {
-  return ok({
-    kind: "TABLE",
-    columns: [
-      { label: conversion.labelHeading ?? "Name" },
-      { label: conversion.valueHeading ?? "Value", numeric: true }
-    ],
-    rows: list.items.map((item) => [
-      { text: item.label },
-      { text: item.display ?? String(item.value), value: item.value }
-    ])
-  });
+function serializeSettings(settings) {
+  if (settings === void 0) return void 0;
+  const out = {};
+  for (const key of Object.keys(settings)) {
+    const one = settings[key];
+    if (one === void 0) continue;
+    const piece = {
+      ...one.title === void 0 ? {} : { title: one.title },
+      ...one.width === void 0 ? {} : { width: one.width },
+      ...one.flexible === void 0 ? {} : { flexible: one.flexible },
+      ...one.options === void 0 || Object.keys(one.options).length === 0 ? {} : { options: { ...one.options } },
+      ...one.view === void 0 ? {} : { view: one.view }
+    };
+    if (Object.keys(piece).length > 0) out[key] = piece;
+  }
+  return Object.keys(out).length === 0 ? void 0 : out;
 }
-function graphToTable(graph, context) {
-  const first = graph.series[0];
-  if (first === void 0)
-    return err(`${context.where}: the chart has no series.`);
-  const format = {
-    ...graph.currency === void 0 ? {} : { currency: graph.currency },
-    ...context.locale === void 0 ? {} : { locale: context.locale }
-  };
-  return ok({
-    kind: "TABLE",
-    columns: [
-      { label: graph.xLabel ?? "Label" },
-      ...graph.series.map((series) => ({ label: series.name, numeric: true }))
-    ],
-    rows: first.points.map((point, index) => [
-      { text: point.label },
-      ...graph.series.map((series) => {
-        const value = series.points[index]?.value;
-        return value === void 0 ? { text: "\u2014" } : { text: formatValue(value, graph.valueFormat, format), value };
-      })
-    ])
-  });
+function widthRange(item) {
+  const min = isWidgetWidth(item.minWidth) ? item.minWidth : MIN_WIDGET_WIDTH;
+  const max = isWidgetWidth(item.maxWidth) ? item.maxWidth : MAX_WIDGET_WIDTH;
+  return { min, max: Math.max(min, max) };
 }
-function barListToGraph(list, conversion) {
-  return ok({
-    kind: "GRAPH",
-    series: [
-      {
-        name: conversion.seriesName ?? "Value",
-        points: list.items.map((item) => ({
-          label: item.label,
-          value: item.value
-        }))
-      }
-    ],
-    chartType: conversion.chartType,
-    valueFormat: conversion.valueFormat ?? "number",
-    ...conversion.currency === void 0 ? {} : { currency: conversion.currency }
-  });
+var WIDTH_SHARES = {
+  2: "1/6",
+  3: "1/4",
+  4: "1/3",
+  5: "5/12",
+  6: "1/2",
+  7: "7/12",
+  8: "2/3",
+  9: "3/4",
+  10: "5/6",
+  11: "11/12",
+  12: "Full"
+};
+function widthShareLabel(width) {
+  return WIDTH_SHARES[width] ?? `${width}/12`;
 }
-function convertView(widgetKey, view, data, options = {}) {
-  const conversion = view.convert;
-  const context = {
-    where: `Widget ${JSON.stringify(widgetKey)} view ${JSON.stringify(view.key)}`,
-    ...options.locale === void 0 ? {} : { locale: options.locale }
-  };
-  const expected = VIEW_CONVERSIONS[conversion.type]?.from;
-  if (expected === void 0) {
-    return err(
-      `${context.where}: unknown conversion type ${JSON.stringify(conversion.type)}.`
-    );
+function isOptionsLocked(item) {
+  return resolveWidgetLock(item).options;
+}
+function fillWith(fill, flexible) {
+  const heightToo = fill === "height" || fill === "both";
+  if (flexible) return heightToo ? "both" : "width";
+  return heightToo ? "height" : void 0;
+}
+function isFlexible(item, settings) {
+  if (settings?.flexible !== void 0) return settings.flexible;
+  return item.fill === "width" || item.fill === "both";
+}
+function applySettings(definition, settings) {
+  if (settings === void 0) return definition;
+  const range = widthRange(definition);
+  const width = settings.width === void 0 ? void 0 : Math.min(range.max, Math.max(range.min, settings.width));
+  const title = settings.title === void 0 || settings.title.trim() === "" ? void 0 : settings.title;
+  const flexibleChanged = settings.flexible !== void 0 && settings.flexible !== isFlexible(definition, void 0);
+  if (title === void 0 && width === void 0 && !flexibleChanged) {
+    return definition;
   }
-  if (data.kind !== expected) {
-    return err(
-      `${context.where}: ${conversion.type} reads a ${expected} payload, but the widget returned ${data.kind}.`
+  const next = { ...definition };
+  if (title !== void 0) next.title = title;
+  if (width !== void 0) next.width = width;
+  if (flexibleChanged) {
+    const fill = fillWith(
+      definition.fill,
+      settings.flexible === true
     );
+    if (fill === void 0) {
+      delete next.fill;
+    } else {
+      next.fill = fill;
+    }
   }
-  switch (conversion.type) {
-    case "tableToBarList":
-      return tableToBarList(data, conversion, context);
-    case "tableToGraph":
-      return tableToGraph(data, conversion, context);
-    case "barListToTable":
-      return barListToTable(data, conversion);
-    case "graphToTable":
-      return graphToTable(data, context);
-    case "barListToGraph":
-      return barListToGraph(data, conversion);
-  }
+  return next;
 }
-function viewNote(view, data) {
-  if (data?.kind !== "TABLE") return "";
-  const conversion = view.convert;
-  let indexes;
-  if (conversion.type === "tableToBarList") {
-    indexes = [conversion.label, conversion.value];
-  } else if (conversion.type === "tableToGraph") {
-    indexes = [conversion.label, ...conversion.values];
-  } else {
-    return "";
-  }
-  const names = indexes.map(
-    (index) => data.columns[index]?.label ?? `#${index + 1}`
+function effectiveDefinitions(definitions, layout, options = {}) {
+  return definitions.map(
+    (definition) => options.overrideLocks !== true && isOptionsLocked(definition) ? definition : applySettings(definition, layout.settings?.[definition.key])
   );
-  return `Shows ${names.join(", ")} only.`;
 }
-function applyView(widget, chosen, options = {}) {
-  const key = effectiveViewKey(widget.definition, chosen);
-  const view = findView(widget.definition, key);
-  if (view === void 0) return widget;
-  const definition = {
-    ...widget.definition,
-    kind: view.kind
-  };
-  if (widget.status === "loading") return { ...widget, definition };
-  if (widget.status === "empty") return { ...widget, definition };
-  if (widget.status === "error") return { ...widget, definition };
-  const converted = convertView(
-    widget.definition.key,
-    view,
-    widget.data,
-    options
-  );
-  if (!converted.ok) {
-    return {
-      definition,
-      status: "error",
-      error: converted.error,
-      ...widget.options === void 0 ? {} : { options: widget.options }
-    };
+function widgetOptionValues(definition, settings) {
+  const declared = definition.options ?? [];
+  const values = {};
+  for (const option of declared) {
+    const picked = settings?.options?.[option.key];
+    const value = (picked === void 0 ? void 0 : coerceOptionValue(option, picked)) ?? defaultOptionValue(option);
+    if (value !== void 0) values[option.key] = value;
   }
-  return { ...widget, definition, data: converted.value };
-}
-
-// src/core/options.ts
-var DATE_RANGE_PRESETS = [
-  "today",
-  "yesterday",
-  "last7",
-  "last30",
-  "last90",
-  "thisMonth",
-  "lastMonth",
-  "thisYear",
-  "lastYear"
-];
-var WIDGET_OPTION_TYPES = [
-  "choice",
-  "number",
-  "boolean",
-  "text",
-  "dateRange",
-  "color",
-  "sort",
-  "columns"
-];
-var MAX_WIDGET_OPTIONS = 20;
-var MAX_TEXT_OPTION_LENGTH = 500;
-var OPTION_KEY_PATTERN = /^[A-Za-z][A-Za-z0-9_-]{0,39}$/;
-var COLOR_PATTERN = /^#[0-9a-fA-F]{6}$/;
-var INTERVAL_PATTERN = /^(\d{4}-\d{2}-\d{2})\/(\d{4}-\d{2}-\d{2})$/;
-var CONTROL_CHARACTERS = /[\u0000-\u001f\u007f]/;
-function isColumnKeyFor(kind, key) {
-  if (kind === "TABLE") return /^c\d+$/.test(key);
-  if (kind === "BAR_LIST") return key === "label" || key === "value";
-  return false;
+  return values;
 }
-function isClientApplied(option) {
-  return (option.type === "sort" || option.type === "columns") && option.apply === "client";
+function optionValuesFromLayout(definitions, layout, options = {}) {
+  const out = {};
+  for (const definition of definitions) {
+    if (definition.options === void 0 || definition.options.length === 0) {
+      continue;
+    }
+    const locked = options.overrideLocks !== true && isOptionsLocked(definition);
+    out[definition.key] = locked ? {} : layout.settings?.[definition.key]?.options ?? {};
+  }
+  return out;
 }
-function civilToday(context) {
-  const now = context.now ?? Date.now();
-  let timeZone = context.timeZone ?? "UTC";
-  try {
-    new Intl.DateTimeFormat("en-US", { timeZone });
-  } catch {
-    timeZone = "UTC";
+function viewValuesFromLayout(definitions, layout, options = {}) {
+  const out = {};
+  for (const definition of definitions) {
+    if (!(definition.views ?? []).some(isProviderView)) continue;
+    const locked = options.overrideLocks !== true && isOptionsLocked(definition);
+    out[definition.key] = locked ? "" : layout.settings?.[definition.key]?.view ?? "";
   }
-  const parts = new Intl.DateTimeFormat("en-US", {
-    timeZone,
-    year: "numeric",
-    month: "2-digit",
-    day: "2-digit"
-  }).formatToParts(new Date(now));
-  const pick = (type) => Number(parts.find((part) => part.type === type)?.value ?? "0");
-  return { year: pick("year"), month: pick("month"), day: pick("day") };
+  return out;
 }
-function toIso(epochMs) {
-  return new Date(epochMs).toISOString().slice(0, 10);
+function sameSettings(a, b) {
+  if (a === b) return true;
+  return a?.title === b?.title && a?.width === b?.width && a?.flexible === b?.flexible && a?.view === b?.view && sameOptionValues(a?.options ?? {}, b?.options ?? {});
 }
-var DAY_MS = 864e5;
-function parseIsoDay(text) {
-  const match = /^(\d{4})-(\d{2})-(\d{2})$/.exec(text);
-  if (match === null) return void 0;
-  const epoch = Date.UTC(
-    Number(match[1]),
-    Number(match[2]) - 1,
-    Number(match[3])
-  );
-  return toIso(epoch) === text ? epoch : void 0;
-}
-function isIsoInterval(value) {
-  const match = INTERVAL_PATTERN.exec(value);
-  if (match === null) return false;
-  const start = parseIsoDay(match[1]);
-  const end = parseIsoDay(match[2]);
-  return start !== void 0 && end !== void 0 && start <= end;
-}
-function isPreset(value) {
-  return DATE_RANGE_PRESETS.includes(value);
-}
-function resolveDateRange(value, context = {}) {
-  if (isIsoInterval(value)) return value;
-  if (!isPreset(value)) return void 0;
-  const today = civilToday(context);
-  const todayMs = Date.UTC(today.year, today.month - 1, today.day);
-  const range = (startMs, endMs) => `${toIso(startMs)}/${toIso(endMs)}`;
-  switch (value) {
-    case "today":
-      return range(todayMs, todayMs);
-    case "yesterday":
-      return range(todayMs - DAY_MS, todayMs - DAY_MS);
-    case "last7":
-      return range(todayMs - 6 * DAY_MS, todayMs);
-    case "last30":
-      return range(todayMs - 29 * DAY_MS, todayMs);
-    case "last90":
-      return range(todayMs - 89 * DAY_MS, todayMs);
-    case "thisMonth":
-      return range(Date.UTC(today.year, today.month - 1, 1), todayMs);
-    case "lastMonth":
-      return range(
-        Date.UTC(today.year, today.month - 2, 1),
-        Date.UTC(today.year, today.month - 1, 1) - DAY_MS
-      );
-    case "thisYear":
-      return range(Date.UTC(today.year, 0, 1), todayMs);
-    case "lastYear":
-      return range(
-        Date.UTC(today.year - 1, 0, 1),
-        Date.UTC(today.year, 0, 1) - DAY_MS
-      );
+function setWidgetSettings(layout, key, patch) {
+  const before = layout.settings?.[key];
+  const draft = { ...before };
+  for (const field of [
+    "title",
+    "width",
+    "flexible",
+    "options",
+    "view"
+  ]) {
+    if (!(field in patch)) continue;
+    const value = patch[field];
+    if (value === void 0) {
+      delete draft[field];
+    } else {
+      draft[field] = value;
+    }
+  }
+  const merged = parseOne(draft);
+  if (sameSettings(before, merged)) return layout;
+  const rest = { ...layout.settings };
+  if (merged === void 0) {
+    delete rest[key];
+  } else {
+    rest[key] = merged;
   }
+  const { settings: _previous, ...others } = layout;
+  return Object.keys(rest).length === 0 ? others : { ...others, settings: rest };
 }
-function onStepGrid(option, value) {
-  if (option.step === void 0) return true;
-  const steps = (value - option.min) / option.step;
-  return Math.abs(steps - Math.round(steps)) < 1e-9;
+function clearWidgetSettings(layout, key) {
+  if (layout.settings?.[key] === void 0) return layout;
+  return setWidgetSettings(layout, key, {
+    title: void 0,
+    width: void 0,
+    flexible: void 0,
+    options: void 0,
+    view: void 0
+  });
 }
-function parseSortValue(value) {
-  const separator = value.lastIndexOf(":");
-  if (separator <= 0) return void 0;
-  const column = value.slice(0, separator);
-  const direction = value.slice(separator + 1);
-  if (direction !== "asc" && direction !== "desc") return void 0;
-  return { column, direction };
+function normalizeTitle(title) {
+  return title.normalize("NFKC").trim().toLowerCase();
 }
-function sortFromOptions(definition, values) {
-  if (values === void 0) return void 0;
-  const sortOption = definition.options?.find(
-    (option) => option.type === "sort"
+function isTitleInUse(definitions, layout, key, title) {
+  const wanted = normalizeTitle(title);
+  if (wanted === "") return false;
+  return effectiveDefinitions(definitions, layout, {
+    overrideLocks: true
+  }).some(
+    (other) => other.key !== key && normalizeTitle(other.title ?? other.key) === wanted
   );
-  if (sortOption === void 0) return void 0;
-  const chosen = values[sortOption.key];
-  return typeof chosen === "string" ? parseSortValue(chosen) : void 0;
 }
-function coerceOptionValue(option, value, context = {}) {
-  switch (option.type) {
-    case "choice":
-      return typeof value === "string" && option.choices.some((choice) => choice.value === value) ? value : void 0;
-    case "number":
-      return typeof value === "number" && Number.isFinite(value) && value >= option.min && value <= option.max && onStepGrid(option, value) ? value : void 0;
-    case "boolean":
-      return typeof value === "boolean" ? value : void 0;
-    case "text": {
-      if (typeof value !== "string") return void 0;
-      const trimmed = value.trim();
-      return trimmed.length <= option.maxLength && !CONTROL_CHARACTERS.test(trimmed) ? trimmed : void 0;
-    }
-    case "dateRange": {
-      if (typeof value !== "string") return void 0;
-      if (isPreset(value) && option.presets !== void 0 && !option.presets.some((preset) => preset.value === value)) {
-        return void 0;
+function uniqueTitle(taken, title) {
+  if (!taken.has(normalizeTitle(title))) return title;
+  for (let n = 2; ; n += 1) {
+    const suffix = ` (#${n})`;
+    const candidate = `${title.slice(0, MAX_WIDGET_TITLE_LENGTH - suffix.length)}${suffix}`;
+    if (!taken.has(normalizeTitle(candidate))) return candidate;
+  }
+}
+function normalizeSettings(definitions, layout, options = {}) {
+  const settings = layout.settings;
+  if (settings === void 0) return layout;
+  const cleaned = {};
+  const taken = /* @__PURE__ */ new Set();
+  for (const definition of definitions) {
+    const renamed = settings[definition.key]?.title !== void 0 && (options.overrideLocks === true || !isOptionsLocked(definition));
+    if (!renamed) taken.add(normalizeTitle(definition.title ?? definition.key));
+  }
+  for (const definition of definitions) {
+    const one = settings[definition.key];
+    if (one === void 0) continue;
+    if (options.overrideLocks !== true && isOptionsLocked(definition)) continue;
+    const range = widthRange(definition);
+    const chosen = {};
+    for (const option of definition.options ?? []) {
+      const picked = one.options?.[option.key];
+      if (picked === void 0) continue;
+      const value = coerceOptionValue(option, picked);
+      if (value !== void 0) {
+        chosen[option.key] = option.type === "dateRange" ? picked : value;
       }
-      return resolveDateRange(value, context);
-    }
-    case "color":
-      return typeof value === "string" && COLOR_PATTERN.test(value) ? value.toLowerCase() : void 0;
-    case "sort": {
-      if (typeof value !== "string") return void 0;
-      const sort = parseSortValue(value);
-      return sort !== void 0 && option.columns.some((column) => column.key === sort.column) ? value : void 0;
     }
-    case "columns": {
-      if (!Array.isArray(value) || value.length === 0) return void 0;
-      const keys = value;
-      const allowed = new Set(option.columns.map((c) => c.key));
-      const seen = /* @__PURE__ */ new Set();
-      for (const key of keys) {
-        if (typeof key !== "string" || !allowed.has(key) || seen.has(key)) {
-          return void 0;
-        }
-        seen.add(key);
+    let title = one.title;
+    if (title !== void 0) {
+      title = title.trim().slice(0, MAX_WIDGET_TITLE_LENGTH);
+      if (title === "") {
+        title = void 0;
+      } else {
+        title = uniqueTitle(taken, title);
+        taken.add(normalizeTitle(title));
       }
-      return [...seen];
+    }
+    const next = {
+      ...title === void 0 ? {} : { title },
+      ...one.width === void 0 ? {} : { width: Math.min(range.max, Math.max(range.min, one.width)) },
+      ...one.flexible === void 0 ? {} : { flexible: one.flexible },
+      ...Object.keys(chosen).length === 0 ? {} : { options: chosen },
+      ...one.view !== void 0 && (one.view === BASE_VIEW_KEY || findView(definition, one.view) !== void 0) ? { view: one.view } : {}
+    };
+    if (Object.keys(next).length > 0) {
+      cleaned[definition.key] = sameSettings(one, next) ? one : next;
     }
   }
+  const keys = Object.keys(cleaned);
+  const unchanged = keys.length === Object.keys(settings).length && keys.every((key) => cleaned[key] === settings[key]);
+  if (unchanged) return layout;
+  const { settings: _previous, ...others } = layout;
+  return keys.length === 0 ? others : { ...others, settings: cleaned };
 }
-function defaultOptionValue(option, context = {}) {
-  switch (option.type) {
-    case "dateRange":
-      return resolveDateRange(option.default, context);
-    case "sort":
-      return option.default;
-    case "columns":
-      return [...option.default];
-    default:
-      return option.default;
-  }
+
+// src/core/clones.ts
+var MAX_PARSED_CLONES = 500;
+function isRecord2(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
 }
-var NO_VALUES = Object.freeze({});
-function resolveOptionValues(definition, chosen, context = {}) {
-  const options = definition.options;
-  if (options === void 0 || options.length === 0) return NO_VALUES;
-  const values = {};
-  for (const option of options) {
-    const picked = chosen?.[option.key];
-    const value = (picked === void 0 ? void 0 : coerceOptionValue(option, picked, context)) ?? defaultOptionValue(option, context);
-    if (value !== void 0) values[option.key] = value;
+function parseClones(raw) {
+  if (!Array.isArray(raw)) return void 0;
+  const seen = /* @__PURE__ */ new Set();
+  const clones = [];
+  for (const entry of raw.slice(0, MAX_PARSED_CLONES)) {
+    if (!isRecord2(entry)) continue;
+    const key = entry["key"];
+    const from = entry["from"];
+    if (typeof key !== "string" || typeof from !== "string" || key === "" || from === "" || key === from || seen.has(key)) {
+      continue;
+    }
+    seen.add(key);
+    clones.push({ key, from });
   }
-  return values;
+  return clones.length === 0 ? void 0 : clones;
 }
-function sameValue(a, b) {
-  if (Array.isArray(a) && Array.isArray(b)) {
-    return a.length === b.length && a.every((item, i) => item === b[i]);
-  }
-  return a === b;
+function serializeClones(clones) {
+  if (clones === void 0 || clones.length === 0) return void 0;
+  return clones.map(({ key, from }) => ({ key, from }));
 }
-function sameOptionValues(a, b) {
-  const keys = Object.keys({ ...a, ...b });
-  return keys.every((key) => sameValue(a[key], b[key]));
+function cloneNumber(key) {
+  const match = /#(\d+)$/.exec(key);
+  return match === null ? void 0 : Number(match[1]);
 }
-function optionsCacheSuffix(definition, values, context = {}) {
-  const parts = [];
-  for (const option of definition.options ?? []) {
-    if (isClientApplied(option)) continue;
-    const value = values[option.key];
-    if (sameValue(value, defaultOptionValue(option, context))) continue;
-    parts.push(
-      `${option.key}=${encodeURIComponent(JSON.stringify(value ?? null))}`
-    );
+function cleanClones(definitions, clones, options = {}) {
+  if (clones === void 0) return void 0;
+  const byKey = new Map(definitions.map((d) => [d.key, d]));
+  const seen = /* @__PURE__ */ new Set();
+  const kept = [];
+  for (const clone of clones) {
+    if (seen.has(clone.key)) continue;
+    const original = byKey.get(clone.from);
+    if (original === void 0 || original.sourceKey !== void 0) continue;
+    const existing = byKey.get(clone.key);
+    if (existing !== void 0 && existing.sourceKey !== clone.from) continue;
+    if (options.overrideLocks !== true && resolveWidgetLock(original).clone) {
+      continue;
+    }
+    seen.add(clone.key);
+    kept.push(clone);
   }
-  parts.sort();
-  return parts.length === 0 ? "" : `?${parts.join("&")}`;
+  if (kept.length === 0) return void 0;
+  return kept.length === clones.length && kept.every((c, i) => c === clones[i]) ? clones : kept;
 }
-function tableColumnIndex(key) {
-  const match = /^c(\d+)$/.exec(key);
-  return match === null ? void 0 : Number(match[1]);
+function defaultCloneTitle(original, clone, index) {
+  const base = original.title ?? original.key;
+  const suffix = ` (#${cloneNumber(clone.key) ?? index + 1})`;
+  return `${base.slice(0, MAX_WIDGET_TITLE_LENGTH - suffix.length)}${suffix}`;
 }
-function sortBarItems(items, sort) {
-  const sign = sort.direction === "desc" ? -1 : 1;
-  return items.map((item, index) => ({ item, index })).sort((a, b) => {
-    const order = sort.column === "value" ? a.item.value - b.item.value : a.item.label.localeCompare(b.item.label);
-    return order * sign || a.index - b.index;
-  }).map(({ item }) => item);
-}
-function applyClientOptions(definition, data, values) {
-  const options = definition.options ?? [];
-  const sortOption = options.find(
-    (o) => o.type === "sort" && o.apply === "client"
-  );
-  const columnsOption = options.find(
-    (o) => o.type === "columns" && o.apply === "client"
+function withClones(definitions, layout, options = {}) {
+  const valid = cleanClones(
+    definitions,
+    layout.clones,
+    options
   );
-  const sortValue = sortOption === void 0 ? void 0 : values[sortOption.key];
-  const columnsValue = columnsOption === void 0 ? void 0 : values[columnsOption.key];
-  let next = data;
-  if (typeof sortValue === "string") {
-    const sort = parseSortValue(sortValue);
-    if (sort !== void 0 && next.kind === "BAR_LIST") {
-      if (sort.column === "label" || sort.column === "value") {
-        next = { ...next, items: sortBarItems(next.items, sort) };
-      }
-    } else if (sort !== void 0 && next.kind === "TABLE") {
-      const index = tableColumnIndex(sort.column);
-      if (index !== void 0 && index < next.columns.length) {
-        const sorted = queryRows(tableDetailData(next), {
-          page: 1,
-          pageSize: Math.max(1, next.rows.length),
-          sort
-        });
-        if (sorted.ok) next = { ...next, rows: sorted.value.rows };
-      }
-    }
-  }
-  if (Array.isArray(columnsValue) && next.kind === "TABLE") {
-    const table = next;
-    const indexes = columnsValue.map(tableColumnIndex).filter(
-      (index) => index !== void 0 && index < table.columns.length
-    );
-    if (indexes.length > 0) {
-      next = {
-        ...table,
-        columns: indexes.map((i) => table.columns[i]),
-        rows: table.rows.map((row) => indexes.map((i) => row[i]))
-      };
-    }
+  if (valid === void 0) return definitions;
+  const present = new Set(definitions.map((d) => d.key));
+  const toAdd = valid.filter((c) => !present.has(c.key));
+  if (toAdd.length === 0) return definitions;
+  const out = [];
+  for (const definition of definitions) {
+    out.push(definition);
+    toAdd.forEach((clone, index) => {
+      if (clone.from !== definition.key) return;
+      const copy = { ...definition };
+      copy.key = clone.key;
+      copy.sourceKey = definition.key;
+      copy.title = defaultCloneTitle(definition, clone, index);
+      delete copy.locked;
+      out.push(copy);
+    });
   }
-  return next;
+  return out;
 }
 
-// src/core/settings.ts
-var MAX_WIDGET_TITLE_LENGTH = 80;
-var MAX_PARSED_SETTINGS = 500;
-var MAX_COLUMN_LIST = 100;
-var MAX_VALUE_LENGTH = 500;
-function isRecord(value) {
-  return typeof value === "object" && value !== null && !Array.isArray(value);
+// src/core/compat.ts
+function isStringArray(value) {
+  return Array.isArray(value) && value.every((v) => typeof v === "string");
 }
-function parseOptionValue(value) {
-  if (typeof value === "string") {
-    return value.length <= MAX_VALUE_LENGTH ? value : void 0;
+function upgradeLegacyWidgetData(value) {
+  if (typeof value !== "object" || value === null || Array.isArray(value)) {
+    return value;
   }
-  if (typeof value === "number")
-    return Number.isFinite(value) ? value : void 0;
-  if (typeof value === "boolean") return value;
-  if (Array.isArray(value) && value.length <= MAX_COLUMN_LIST) {
-    return value.every(
-      (entry) => typeof entry === "string" && entry.length <= MAX_VALUE_LENGTH
-    ) ? value : void 0;
+  const record = value;
+  if (record["kind"] === "TABLE" && isStringArray(record["columns"]) && Array.isArray(record["rows"]) && record["rows"].every(isStringArray)) {
+    const rows = record["rows"];
+    return {
+      ...record,
+      columns: record["columns"].map((label) => ({ label })),
+      rows: rows.map((row) => row.map((text) => ({ text })))
+    };
   }
-  return void 0;
+  if (record["kind"] === "GRAPH" && Array.isArray(record["points"]) && record["series"] === void 0) {
+    const { points, ...rest } = record;
+    return {
+      ...rest,
+      series: [{ name: "Value", points }],
+      chartType: "bar",
+      valueFormat: "number"
+    };
+  }
+  return value;
 }
-function parseOne(raw) {
-  if (!isRecord(raw)) return void 0;
-  const title = raw["title"];
-  const width = raw["width"];
-  const flexible = raw["flexible"];
-  const options = raw["options"];
-  const view = raw["view"];
-  const cleanTitle = typeof title === "string" ? title.trim().slice(0, MAX_WIDGET_TITLE_LENGTH) : "";
-  const chosen = {};
-  if (isRecord(options)) {
-    for (const [key, value] of Object.entries(options)) {
-      const parsed = parseOptionValue(value);
-      if (parsed !== void 0) chosen[key] = parsed;
-    }
+function fromLegacyDefinition(legacy) {
+  if (!isWidgetKind(legacy.viewType)) {
+    return null;
   }
-  const settings = {
-    ...cleanTitle === "" ? {} : { title: cleanTitle },
-    ...isWidgetWidth(width) ? { width } : {},
-    ...typeof flexible === "boolean" ? { flexible } : {},
-    ...Object.keys(chosen).length === 0 ? {} : { options: chosen },
-    ...typeof view === "string" && view !== "" && view.length <= 80 ? { view } : {}
+  return {
+    key: legacy.widgetKey,
+    title: legacy.title,
+    ...legacy.description === null ? {} : { description: legacy.description },
+    kind: legacy.viewType,
+    sortOrder: legacy.sortOrder
   };
-  return Object.keys(settings).length === 0 ? void 0 : settings;
 }
-function parseSettings(raw) {
-  if (!isRecord(raw)) return void 0;
-  const parsed = {};
-  for (const [key, value] of Object.entries(raw).slice(
-    0,
-    MAX_PARSED_SETTINGS
-  )) {
-    if (key === "") continue;
-    const one = parseOne(value);
-    if (one !== void 0) parsed[key] = one;
+
+// src/core/layout.ts
+var MAX_PAGE_TITLE_LENGTH = 30;
+var MAX_PARSED_PAGES = 50;
+var MAX_PAGE_ROWS = 20;
+var EMPTY_LAYOUT = Object.freeze({
+  order: Object.freeze([]),
+  hidden: Object.freeze([]),
+  minimized: Object.freeze([])
+});
+function uniqueStrings(value) {
+  if (!Array.isArray(value)) return [];
+  const seen = /* @__PURE__ */ new Set();
+  for (const entry of value) {
+    if (typeof entry === "string" && entry !== "") seen.add(entry);
   }
-  return Object.keys(parsed).length === 0 ? void 0 : parsed;
+  return [...seen];
 }
-function serializeSettings(settings) {
-  if (settings === void 0) return void 0;
-  const out = {};
-  for (const key of Object.keys(settings)) {
-    const one = settings[key];
-    if (one === void 0) continue;
-    const piece = {
-      ...one.title === void 0 ? {} : { title: one.title },
-      ...one.width === void 0 ? {} : { width: one.width },
-      ...one.flexible === void 0 ? {} : { flexible: one.flexible },
-      ...one.options === void 0 || Object.keys(one.options).length === 0 ? {} : { options: { ...one.options } },
-      ...one.view === void 0 ? {} : { view: one.view }
+function parseLayout(raw) {
+  let value = raw;
+  if (typeof raw === "string") {
+    try {
+      value = JSON.parse(raw);
+    } catch {
+      return EMPTY_LAYOUT;
+    }
+  }
+  if (typeof value !== "object" || value === null || Array.isArray(value)) {
+    return EMPTY_LAYOUT;
+  }
+  const record = value;
+  const order = uniqueStrings(record["order"]);
+  const hidden = uniqueStrings(record["hidden"]);
+  const minimized = uniqueStrings(record["minimized"]);
+  const pages = parsePages(record["pages"]);
+  const settings = parseSettings(
+    record["settings"]
+  );
+  const clones = parseClones(
+    record["clones"]
+  );
+  const extras = {
+    ...settings === void 0 ? {} : { settings },
+    ...clones === void 0 ? {} : { clones }
+  };
+  if (pages.length > 0) {
+    return {
+      order: EMPTY_LAYOUT.order,
+      hidden: EMPTY_LAYOUT.hidden,
+      minimized: EMPTY_LAYOUT.minimized,
+      pages,
+      ...extras
     };
-    if (Object.keys(piece).length > 0) out[key] = piece;
   }
-  return Object.keys(out).length === 0 ? void 0 : out;
+  if (order.length === 0 && hidden.length === 0 && minimized.length === 0) {
+    return Object.keys(extras).length === 0 ? EMPTY_LAYOUT : { ...EMPTY_LAYOUT, ...extras };
+  }
+  return { order, hidden, minimized, ...extras };
 }
-function widthRange(item) {
-  const min = isWidgetWidth(item.minWidth) ? item.minWidth : MIN_WIDGET_WIDTH;
-  const max = isWidgetWidth(item.maxWidth) ? item.maxWidth : MAX_WIDGET_WIDTH;
-  return { min, max: Math.max(min, max) };
+function parsePages(value) {
+  if (!Array.isArray(value)) return [];
+  const pages = [];
+  const keys = /* @__PURE__ */ new Set();
+  for (const entry of value.slice(0, MAX_PARSED_PAGES)) {
+    if (typeof entry !== "object" || entry === null || Array.isArray(entry)) {
+      continue;
+    }
+    const record = entry;
+    const key = record["key"];
+    if (typeof key !== "string" || key === "" || keys.has(key)) continue;
+    keys.add(key);
+    const rawTitle = record["title"];
+    const title = typeof rawTitle === "string" && rawTitle.trim() !== "" ? rawTitle.trim().slice(0, MAX_PAGE_TITLE_LENGTH) : `Page ${pages.length + 1}`;
+    const maxRows = record["maxRows"];
+    const held = /* @__PURE__ */ new Set();
+    for (const earlier of pages) {
+      for (const k of [...earlier.order, ...earlier.hidden]) held.add(k);
+    }
+    const keep = (list) => uniqueStrings(list).filter((k) => !held.has(k));
+    pages.push({
+      key,
+      title,
+      order: keep(record["order"]),
+      hidden: keep(record["hidden"]),
+      minimized: keep(record["minimized"]),
+      ...typeof maxRows === "number" && Number.isInteger(maxRows) && maxRows >= 1 && maxRows <= MAX_PAGE_ROWS ? { maxRows } : {}
+    });
+  }
+  return pages;
 }
-var WIDTH_SHARES = {
-  2: "1/6",
-  3: "1/4",
-  4: "1/3",
-  5: "5/12",
-  6: "1/2",
-  7: "7/12",
-  8: "2/3",
-  9: "3/4",
-  10: "5/6",
-  11: "11/12",
-  12: "Full"
-};
-function widthShareLabel(width) {
-  return WIDTH_SHARES[width] ?? `${width}/12`;
+function serializeLayout(layout) {
+  return JSON.stringify({
+    order: [...layout.order],
+    hidden: [...layout.hidden],
+    minimized: [...layout.minimized],
+    ...layout.pages === void 0 || layout.pages.length === 0 ? {} : {
+      pages: layout.pages.map((page) => ({
+        key: page.key,
+        title: page.title,
+        order: [...page.order],
+        hidden: [...page.hidden],
+        minimized: [...page.minimized],
+        ...page.maxRows === void 0 ? {} : { maxRows: page.maxRows }
+      }))
+    },
+    ...serializeSettings(layout.settings) === void 0 ? {} : { settings: serializeSettings(layout.settings) },
+    ...serializeClones(layout.clones) === void 0 ? {} : { clones: serializeClones(layout.clones) }
+  });
 }
-function isOptionsLocked(item) {
-  return resolveWidgetLock(item).options;
-}
-function fillWith(fill, flexible) {
-  const heightToo = fill === "height" || fill === "both";
-  if (flexible) return heightToo ? "both" : "width";
-  return heightToo ? "height" : void 0;
+function bySortOrder(items) {
+  return items.map((item, index) => ({ item, index })).sort(
+    (a, b) => (a.item.sortOrder ?? 0) - (b.item.sortOrder ?? 0) || a.index - b.index
+  ).map(({ item }) => item);
 }
-function isFlexible(item, settings) {
-  if (settings?.flexible !== void 0) return settings.flexible;
-  return item.fill === "width" || item.fill === "both";
+function isPinned(item) {
+  return resolveWidgetLock(item).move;
 }
-function applySettings(definition, settings) {
-  if (settings === void 0) return definition;
-  const range = widthRange(definition);
-  const width = settings.width === void 0 ? void 0 : Math.min(range.max, Math.max(range.min, settings.width));
-  const title = settings.title === void 0 || settings.title.trim() === "" ? void 0 : settings.title;
-  const flexibleChanged = settings.flexible !== void 0 && settings.flexible !== isFlexible(definition, void 0);
-  if (title === void 0 && width === void 0 && !flexibleChanged) {
-    return definition;
-  }
-  const next = { ...definition };
-  if (title !== void 0) next.title = title;
-  if (width !== void 0) next.width = width;
-  if (flexibleChanged) {
-    const fill = fillWith(
-      definition.fill,
-      settings.flexible === true
-    );
-    if (fill === void 0) {
-      delete next.fill;
-    } else {
-      next.fill = fill;
+function viewerOrder(visible, layout) {
+  const byKey = new Map(visible.map((d) => [d.key, d]));
+  const ordered = [];
+  for (const key of layout.order) {
+    const definition = byKey.get(key);
+    if (definition !== void 0) {
+      ordered.push(definition);
+      byKey.delete(key);
     }
   }
-  return next;
+  for (const definition of bySortOrder(visible)) {
+    if (byKey.has(definition.key)) ordered.push(definition);
+  }
+  return ordered;
 }
-function effectiveDefinitions(definitions, layout, options = {}) {
-  return definitions.map(
-    (definition) => options.overrideLocks !== true && isOptionsLocked(definition) ? definition : applySettings(definition, layout.settings?.[definition.key])
+function placeAroundPinned(visible, free) {
+  const slots = bySortOrder(visible).map(
+    (item) => isPinned(item) ? item : void 0
   );
+  let next = 0;
+  return slots.map((pinned) => pinned ?? free[next++]);
 }
-function widgetOptionValues(definition, settings) {
-  const declared = definition.options ?? [];
-  const values = {};
-  for (const option of declared) {
-    const picked = settings?.options?.[option.key];
-    const value = (picked === void 0 ? void 0 : coerceOptionValue(option, picked)) ?? defaultOptionValue(option);
-    if (value !== void 0) values[option.key] = value;
-  }
-  return values;
-}
-function optionValuesFromLayout(definitions, layout, options = {}) {
-  const out = {};
-  for (const definition of definitions) {
-    if (definition.options === void 0 || definition.options.length === 0) {
-      continue;
-    }
-    const locked = options.overrideLocks !== true && isOptionsLocked(definition);
-    out[definition.key] = locked ? {} : layout.settings?.[definition.key]?.options ?? {};
-  }
-  return out;
+function visibleWidgets(definitions, layout) {
+  const hidden = new Set(layout.hidden);
+  const visible = definitions.filter((d) => !hidden.has(d.key));
+  const ordered = viewerOrder(visible, layout);
+  if (!visible.some(isPinned)) return ordered;
+  return placeAroundPinned(
+    visible,
+    ordered.filter((item) => !isPinned(item))
+  );
 }
-function sameSettings(a, b) {
-  if (a === b) return true;
-  return a?.title === b?.title && a?.width === b?.width && a?.flexible === b?.flexible && a?.view === b?.view && sameOptionValues(a?.options ?? {}, b?.options ?? {});
+function hiddenWidgets(definitions, layout) {
+  const hidden = new Set(layout.hidden);
+  return bySortOrder(definitions.filter((d) => hidden.has(d.key)));
 }
-function setWidgetSettings(layout, key, patch) {
-  const before = layout.settings?.[key];
-  const draft = { ...before };
-  for (const field of [
-    "title",
-    "width",
-    "flexible",
-    "options",
-    "view"
-  ]) {
-    if (!(field in patch)) continue;
-    const value = patch[field];
-    if (value === void 0) {
-      delete draft[field];
-    } else {
-      draft[field] = value;
-    }
-  }
-  const merged = parseOne(draft);
-  if (sameSettings(before, merged)) return layout;
-  const rest = { ...layout.settings };
-  if (merged === void 0) {
-    delete rest[key];
-  } else {
-    rest[key] = merged;
+function moveWidget(definitions, layout, key, toIndex) {
+  const current = visibleWidgets(definitions, layout);
+  const fromIndex = current.findIndex((d) => d.key === key);
+  const mover = current[fromIndex];
+  if (mover === void 0 || !Number.isInteger(toIndex) || toIndex < 0 || toIndex >= current.length || toIndex === fromIndex || isPinned(mover) || isPinned(current[toIndex])) {
+    return layout;
   }
-  const { settings: _previous, ...others } = layout;
-  return Object.keys(rest).length === 0 ? others : { ...others, settings: rest };
+  const freeSlots = freeSlotIndexes(current);
+  const free = current.filter((item) => !isPinned(item));
+  const fromFree = freeSlots.indexOf(fromIndex);
+  const toFree = freeSlots.indexOf(toIndex);
+  free.splice(fromFree, 1);
+  free.splice(toFree, 0, mover);
+  const next = placeAroundPinned(current, free);
+  return { ...layout, order: next.map((d) => d.key) };
 }
-function clearWidgetSettings(layout, key) {
-  if (layout.settings?.[key] === void 0) return layout;
-  return setWidgetSettings(layout, key, {
-    title: void 0,
-    width: void 0,
-    flexible: void 0,
-    options: void 0,
-    view: void 0
+function freeSlotIndexes(ordered) {
+  const slots = [];
+  ordered.forEach((item, index) => {
+    if (!isPinned(item)) slots.push(index);
   });
+  return slots;
 }
-function normalizeTitle(title) {
-  return title.normalize("NFKC").trim().toLowerCase();
-}
-function isTitleInUse(definitions, layout, key, title) {
-  const wanted = normalizeTitle(title);
-  if (wanted === "") return false;
-  return effectiveDefinitions(definitions, layout, {
-    overrideLocks: true
-  }).some(
-    (other) => other.key !== key && normalizeTitle(other.title ?? other.key) === wanted
+function moveWidgetBy(definitions, layout, key, offset) {
+  const current = visibleWidgets(definitions, layout);
+  const fromIndex = current.findIndex((d) => d.key === key);
+  if (fromIndex === -1) return layout;
+  const freeSlots = freeSlotIndexes(current);
+  const fromFree = freeSlots.indexOf(fromIndex);
+  if (fromFree === -1) return layout;
+  const toFree = Math.max(
+    0,
+    Math.min(freeSlots.length - 1, fromFree + Math.trunc(offset))
   );
+  return moveWidget(definitions, layout, key, freeSlots[toFree]);
 }
-function uniqueTitle(taken, title) {
-  if (!taken.has(normalizeTitle(title))) return title;
-  for (let n = 2; ; n += 1) {
-    const suffix = ` (#${n})`;
-    const candidate = `${title.slice(0, MAX_WIDGET_TITLE_LENGTH - suffix.length)}${suffix}`;
-    if (!taken.has(normalizeTitle(candidate))) return candidate;
+function moveWidgetUp(definitions, layout, key) {
+  return moveWidgetBy(definitions, layout, key, -1);
+}
+function moveWidgetDown(definitions, layout, key) {
+  return moveWidgetBy(definitions, layout, key, 1);
+}
+function isHidden(layout, key) {
+  return layout.hidden.includes(key);
+}
+function isMinimized(layout, key) {
+  return layout.minimized.includes(key);
+}
+function hideWidget(layout, key) {
+  if (isHidden(layout, key)) return layout;
+  return { ...layout, hidden: [...layout.hidden, key] };
+}
+function showWidget(layout, key) {
+  if (!isHidden(layout, key)) return layout;
+  return {
+    ...layout,
+    hidden: layout.hidden.filter((k) => k !== key),
+    minimized: layout.minimized.filter((k) => k !== key)
+  };
+}
+function toggleHidden(layout, key) {
+  return isHidden(layout, key) ? showWidget(layout, key) : hideWidget(layout, key);
+}
+function minimizeWidget(layout, key) {
+  if (isMinimized(layout, key)) return layout;
+  return { ...layout, minimized: [...layout.minimized, key] };
+}
+function restoreWidget(layout, key) {
+  if (!isMinimized(layout, key)) return layout;
+  return { ...layout, minimized: layout.minimized.filter((k) => k !== key) };
+}
+function toggleMinimized(layout, key) {
+  return isMinimized(layout, key) ? restoreWidget(layout, key) : minimizeWidget(layout, key);
+}
+function pruneLayout(definitions, layout) {
+  const known = new Set(definitions.map((d) => d.key));
+  const keep = (keys) => keys.every((k) => known.has(k)) ? keys : keys.filter((k) => known.has(k));
+  return mapLayoutLists(layout, (lists) => ({
+    order: keep(lists.order),
+    hidden: keep(lists.hidden),
+    minimized: keep(lists.minimized)
+  }));
+}
+function mapLayoutLists(layout, change) {
+  const top = change(layout);
+  const pages = layout.pages?.map((page) => {
+    const next = change(page);
+    return next.order === page.order && next.hidden === page.hidden && next.minimized === page.minimized ? page : { ...page, ...next };
+  });
+  const pagesChanged = pages !== void 0 && pages.some((page, i) => page !== layout.pages?.[i]);
+  if (top.order === layout.order && top.hidden === layout.hidden && top.minimized === layout.minimized && !pagesChanged) {
+    return layout;
   }
+  return {
+    ...layout,
+    ...top,
+    ...pages === void 0 ? {} : { pages }
+  };
 }
-function normalizeSettings(definitions, layout, options = {}) {
-  const settings = layout.settings;
-  if (settings === void 0) return layout;
-  const cleaned = {};
-  const taken = /* @__PURE__ */ new Set();
+function enforceLocks(definitions, layout, options = {}) {
+  if (options.overrideLocks === true) return layout;
+  const noMove = /* @__PURE__ */ new Set();
+  const noHide = /* @__PURE__ */ new Set();
+  const noMinimize = /* @__PURE__ */ new Set();
   for (const definition of definitions) {
-    const renamed = settings[definition.key]?.title !== void 0 && (options.overrideLocks === true || !isOptionsLocked(definition));
-    if (!renamed) taken.add(normalizeTitle(definition.title ?? definition.key));
+    const lock = resolveWidgetLock(definition);
+    if (lock.move) noMove.add(definition.key);
+    if (lock.hide) noHide.add(definition.key);
+    if (lock.minimize) noMinimize.add(definition.key);
   }
-  for (const definition of definitions) {
-    const one = settings[definition.key];
-    if (one === void 0) continue;
-    if (options.overrideLocks !== true && isOptionsLocked(definition)) continue;
-    const range = widthRange(definition);
-    const chosen = {};
-    for (const option of definition.options ?? []) {
-      const picked = one.options?.[option.key];
-      if (picked === void 0) continue;
-      const value = coerceOptionValue(option, picked);
-      if (value !== void 0) {
-        chosen[option.key] = option.type === "dateRange" ? picked : value;
-      }
-    }
-    let title = one.title;
-    if (title !== void 0) {
-      title = title.trim().slice(0, MAX_WIDGET_TITLE_LENGTH);
-      if (title === "") {
-        title = void 0;
-      } else {
-        title = uniqueTitle(taken, title);
-        taken.add(normalizeTitle(title));
-      }
-    }
-    const next = {
-      ...title === void 0 ? {} : { title },
-      ...one.width === void 0 ? {} : { width: Math.min(range.max, Math.max(range.min, one.width)) },
-      ...one.flexible === void 0 ? {} : { flexible: one.flexible },
-      ...Object.keys(chosen).length === 0 ? {} : { options: chosen },
-      ...one.view !== void 0 && (one.view === BASE_VIEW_KEY || findView(definition, one.view) !== void 0) ? { view: one.view } : {}
-    };
-    if (Object.keys(next).length > 0) {
-      cleaned[definition.key] = sameSettings(one, next) ? one : next;
-    }
-  }
-  const keys = Object.keys(cleaned);
-  const unchanged = keys.length === Object.keys(settings).length && keys.every((key) => cleaned[key] === settings[key]);
-  if (unchanged) return layout;
-  const { settings: _previous, ...others } = layout;
-  return keys.length === 0 ? others : { ...others, settings: cleaned };
+  const without2 = (keys, drop) => keys.some((key) => drop.has(key)) ? keys.filter((key) => !drop.has(key)) : keys;
+  return mapLayoutLists(layout, (lists) => ({
+    order: without2(lists.order, noMove),
+    hidden: without2(lists.hidden, noHide),
+    minimized: without2(lists.minimized, noMinimize)
+  }));
 }
 
-// src/core/layout.ts
-var MAX_PAGE_TITLE_LENGTH = 30;
-var MAX_PARSED_PAGES = 50;
-var MAX_PAGE_ROWS = 20;
-var EMPTY_LAYOUT = Object.freeze({
-  order: Object.freeze([]),
-  hidden: Object.freeze([]),
-  minimized: Object.freeze([])
-});
-function uniqueStrings(value) {
-  if (!Array.isArray(value)) return [];
-  const seen = /* @__PURE__ */ new Set();
-  for (const entry of value) {
-    if (typeof entry === "string" && entry !== "") seen.add(entry);
-  }
-  return [...seen];
+// src/core/pages.ts
+var DEFAULT_PAGE_KEY = "default";
+var DEFAULT_PAGE_ROWS = 4;
+function rowsAllowed(page, options) {
+  const rows = page.maxRows ?? options.maxRows ?? DEFAULT_PAGE_ROWS;
+  return Math.max(1, Math.min(MAX_PAGE_ROWS, Math.floor(rows)));
 }
-function parseLayout(raw) {
-  let value = raw;
-  if (typeof raw === "string") {
-    try {
-      value = JSON.parse(raw);
-    } catch {
-      return EMPTY_LAYOUT;
-    }
-  }
-  if (typeof value !== "object" || value === null || Array.isArray(value)) {
-    return EMPTY_LAYOUT;
+function hasPages(layout) {
+  return layout.pages !== void 0 && layout.pages.length > 0;
+}
+function pageList(layout) {
+  if (layout.pages !== void 0 && layout.pages.length > 0) {
+    return layout.pages;
   }
-  const record = value;
-  const order = uniqueStrings(record["order"]);
-  const hidden = uniqueStrings(record["hidden"]);
-  const minimized = uniqueStrings(record["minimized"]);
-  const pages = parsePages(record["pages"]);
-  const settings = parseSettings(
-    record["settings"]
+  return [
+    {
+      key: DEFAULT_PAGE_KEY,
+      title: "Page 1",
+      order: layout.order,
+      hidden: layout.hidden,
+      minimized: layout.minimized
+    }
+  ];
+}
+function withExplicitPages(layout) {
+  if (hasPages(layout)) return layout;
+  return {
+    ...layout,
+    order: [],
+    hidden: [],
+    minimized: [],
+    pages: pageList(layout)
+  };
+}
+function sameKeys(a, b) {
+  return a === b || a.length === b.length && a.every((k, i) => k === b[i]);
+}
+function pageLayout(layout, pageKey) {
+  if (!hasPages(layout))
+    return pageKey === DEFAULT_PAGE_KEY ? layout : void 0;
+  const page = layout.pages?.find(
+    (p) => p.key === pageKey
   );
-  const withSettings = settings === void 0 ? {} : { settings };
-  if (pages.length > 0) {
+  if (page === void 0) return void 0;
+  const { pages, ...rest } = layout;
+  return {
+    ...rest,
+    order: page.order,
+    hidden: page.hidden,
+    minimized: page.minimized
+  };
+}
+function withPageLayout(layout, pageKey, next) {
+  const current = pageLayout(layout, pageKey);
+  if (current === void 0 || sameKeys(current.order, next.order) && sameKeys(current.hidden, next.hidden) && sameKeys(current.minimized, next.minimized)) {
+    return layout;
+  }
+  if (!hasPages(layout)) {
     return {
-      order: EMPTY_LAYOUT.order,
-      hidden: EMPTY_LAYOUT.hidden,
-      minimized: EMPTY_LAYOUT.minimized,
-      pages,
-      ...withSettings
+      ...layout,
+      order: next.order,
+      hidden: next.hidden,
+      minimized: next.minimized
     };
   }
-  if (order.length === 0 && hidden.length === 0 && minimized.length === 0) {
-    return settings === void 0 ? EMPTY_LAYOUT : { ...EMPTY_LAYOUT, settings };
-  }
-  return { order, hidden, minimized, ...withSettings };
-}
-function parsePages(value) {
-  if (!Array.isArray(value)) return [];
-  const pages = [];
-  const keys = /* @__PURE__ */ new Set();
-  for (const entry of value.slice(0, MAX_PARSED_PAGES)) {
-    if (typeof entry !== "object" || entry === null || Array.isArray(entry)) {
-      continue;
-    }
-    const record = entry;
-    const key = record["key"];
-    if (typeof key !== "string" || key === "" || keys.has(key)) continue;
-    keys.add(key);
-    const rawTitle = record["title"];
-    const title = typeof rawTitle === "string" && rawTitle.trim() !== "" ? rawTitle.trim().slice(0, MAX_PAGE_TITLE_LENGTH) : `Page ${pages.length + 1}`;
-    const maxRows = record["maxRows"];
-    const held = /* @__PURE__ */ new Set();
-    for (const earlier of pages) {
-      for (const k of [...earlier.order, ...earlier.hidden]) held.add(k);
-    }
-    const keep = (list) => uniqueStrings(list).filter((k) => !held.has(k));
-    pages.push({
-      key,
-      title,
-      order: keep(record["order"]),
-      hidden: keep(record["hidden"]),
-      minimized: keep(record["minimized"]),
-      ...typeof maxRows === "number" && Number.isInteger(maxRows) && maxRows >= 1 && maxRows <= MAX_PAGE_ROWS ? { maxRows } : {}
-    });
-  }
-  return pages;
+  return {
+    ...layout,
+    pages: (layout.pages ?? []).map(
+      (page) => page.key === pageKey ? {
+        ...page,
+        order: next.order,
+        hidden: next.hidden,
+        minimized: next.minimized
+      } : page
+    )
+  };
 }
-function serializeLayout(layout) {
-  return JSON.stringify({
-    order: [...layout.order],
-    hidden: [...layout.hidden],
-    minimized: [...layout.minimized],
-    ...layout.pages === void 0 || layout.pages.length === 0 ? {} : {
-      pages: layout.pages.map((page) => ({
-        key: page.key,
-        title: page.title,
-        order: [...page.order],
-        hidden: [...page.hidden],
-        minimized: [...page.minimized],
-        ...page.maxRows === void 0 ? {} : { maxRows: page.maxRows }
-      }))
-    },
-    ...serializeSettings(layout.settings) === void 0 ? {} : { settings: serializeSettings(layout.settings) }
-  });
+function normalizedTitle(title) {
+  return title.trim().normalize("NFKC").toLowerCase();
 }
-function bySortOrder(items) {
-  return items.map((item, index) => ({ item, index })).sort(
-    (a, b) => (a.item.sortOrder ?? 0) - (b.item.sortOrder ?? 0) || a.index - b.index
-  ).map(({ item }) => item);
+function resolvePageKey(layout, reference) {
+  if (reference === void 0 || reference === "") return void 0;
+  const pages = pageList(layout);
+  const byKey = pages.find((p) => p.key === reference);
+  if (byKey !== void 0) return byKey.key;
+  const wanted = normalizedTitle(reference);
+  return pages.find((p) => normalizedTitle(p.title) === wanted)?.key;
 }
-function isPinned(item) {
-  return resolveWidgetLock(item).move;
+function homePageKey(layout, item) {
+  return resolvePageKey(layout, item.page) ?? pageList(layout)[0].key;
 }
-function viewerOrder(visible, layout) {
-  const byKey = new Map(visible.map((d) => [d.key, d]));
-  const ordered = [];
-  for (const key of layout.order) {
-    const definition = byKey.get(key);
-    if (definition !== void 0) {
-      ordered.push(definition);
-      byKey.delete(key);
+function assignPages(definitions, layout) {
+  const pages = pageList(layout);
+  const assigned = new Map(pages.map((p) => [p.key, []]));
+  for (const definition of definitions) {
+    let pageKey;
+    if (!resolveWidgetLock(definition).move) {
+      pageKey = pages.find(
+        (p) => p.order.includes(definition.key) || p.hidden.includes(definition.key)
+      )?.key;
     }
+    assigned.get(pageKey ?? homePageKey(layout, definition))?.push(definition);
   }
-  for (const definition of bySortOrder(visible)) {
-    if (byKey.has(definition.key)) ordered.push(definition);
+  return assigned;
+}
+function pageOf(definitions, layout, key) {
+  for (const [pageKey, widgets] of assignPages(definitions, layout)) {
+    if (widgets.some((w) => w.key === key)) return pageKey;
   }
-  return ordered;
+  return void 0;
 }
-function placeAroundPinned(visible, free) {
-  const slots = bySortOrder(visible).map(
-    (item) => isPinned(item) ? item : void 0
-  );
-  let next = 0;
-  return slots.map((pinned) => pinned ?? free[next++]);
+function pageWidgets(definitions, layout, pageKey) {
+  const onPage = assignPages(definitions, layout).get(pageKey) ?? [];
+  const view = pageLayout(layout, pageKey);
+  return view === void 0 ? [] : visibleWidgets(onPage, view);
 }
-function visibleWidgets(definitions, layout) {
-  const hidden = new Set(layout.hidden);
-  const visible = definitions.filter((d) => !hidden.has(d.key));
-  const ordered = viewerOrder(visible, layout);
-  if (!visible.some(isPinned)) return ordered;
-  return placeAroundPinned(
-    visible,
-    ordered.filter((item) => !isPinned(item))
+function pageRoom(definitions, layout, pageKey, options = {}) {
+  const page = pageList(layout).find(
+    (p) => p.key === pageKey
   );
+  if (page === void 0) return void 0;
+  const maxRows = rowsAllowed(page, options);
+  const rowsUsed = placeRows(
+    pageWidgets(definitions, layout, pageKey)
+  ).length;
+  return { maxRows, rowsUsed, rowsFree: Math.max(0, maxRows - rowsUsed) };
 }
-function hiddenWidgets(definitions, layout) {
-  const hidden = new Set(layout.hidden);
-  return bySortOrder(definitions.filter((d) => hidden.has(d.key)));
-}
-function moveWidget(definitions, layout, key, toIndex) {
-  const current = visibleWidgets(definitions, layout);
-  const fromIndex = current.findIndex((d) => d.key === key);
-  const mover = current[fromIndex];
-  if (mover === void 0 || !Number.isInteger(toIndex) || toIndex < 0 || toIndex >= current.length || toIndex === fromIndex || isPinned(mover) || isPinned(current[toIndex])) {
-    return layout;
-  }
-  const freeSlots = freeSlotIndexes(current);
-  const free = current.filter((item) => !isPinned(item));
-  const fromFree = freeSlots.indexOf(fromIndex);
-  const toFree = freeSlots.indexOf(toIndex);
-  free.splice(fromFree, 1);
-  free.splice(toFree, 0, mover);
-  const next = placeAroundPinned(current, free);
-  return { ...layout, order: next.map((d) => d.key) };
+function describePage(page) {
+  return `Page "${page.title}"`;
 }
-function freeSlotIndexes(ordered) {
-  const slots = [];
-  ordered.forEach((item, index) => {
-    if (!isPinned(item)) slots.push(index);
-  });
-  return slots;
+function titleOf(item) {
+  return item.title ?? item.key;
 }
-function moveWidgetBy(definitions, layout, key, offset) {
-  const current = visibleWidgets(definitions, layout);
-  const fromIndex = current.findIndex((d) => d.key === key);
-  if (fromIndex === -1) return layout;
-  const freeSlots = freeSlotIndexes(current);
-  const fromFree = freeSlots.indexOf(fromIndex);
-  if (fromFree === -1) return layout;
-  const toFree = Math.max(
-    0,
-    Math.min(freeSlots.length - 1, fromFree + Math.trunc(offset))
+function checkTitle(layout, title, exceptKey) {
+  const trimmed = title.trim();
+  if (trimmed === "") return err("A page title must not be empty.");
+  if (trimmed.length > MAX_PAGE_TITLE_LENGTH) {
+    return err(
+      `Page title "${trimmed}" is ${trimmed.length} characters; the most is ${MAX_PAGE_TITLE_LENGTH}.`
+    );
+  }
+  const wanted = normalizedTitle(trimmed);
+  const clash = pageList(layout).find(
+    (p) => p.key !== exceptKey && normalizedTitle(p.title) === wanted
   );
-  return moveWidget(definitions, layout, key, freeSlots[toFree]);
-}
-function moveWidgetUp(definitions, layout, key) {
-  return moveWidgetBy(definitions, layout, key, -1);
-}
-function moveWidgetDown(definitions, layout, key) {
-  return moveWidgetBy(definitions, layout, key, 1);
-}
-function isHidden(layout, key) {
-  return layout.hidden.includes(key);
+  if (clash !== void 0) {
+    return err(`Another page is already called "${clash.title}".`);
+  }
+  return ok(trimmed);
 }
-function isMinimized(layout, key) {
-  return layout.minimized.includes(key);
+function nextPageKey(layout) {
+  const keys = new Set(pageList(layout).map((p) => p.key));
+  let n = 1;
+  while (keys.has(`page-${n}`)) n += 1;
+  return `page-${n}`;
 }
-function hideWidget(layout, key) {
-  if (isHidden(layout, key)) return layout;
-  return { ...layout, hidden: [...layout.hidden, key] };
+function nextPageTitle(layout) {
+  const used = new Set(
+    pageList(layout).map((p) => normalizedTitle(p.title))
+  );
+  let n = pageList(layout).length + 1;
+  while (used.has(normalizedTitle(`Page ${n}`))) n += 1;
+  return `Page ${n}`;
 }
-function showWidget(layout, key) {
-  if (!isHidden(layout, key)) return layout;
-  return {
-    ...layout,
-    hidden: layout.hidden.filter((k) => k !== key),
-    minimized: layout.minimized.filter((k) => k !== key)
+function addPage(layout, options = {}) {
+  if (pageList(layout).length >= MAX_PARSED_PAGES) {
+    return err(
+      `The layout already has ${MAX_PARSED_PAGES} pages, the most it can keep.`
+    );
+  }
+  const key = options.key ?? nextPageKey(layout);
+  if (pageList(layout).some((p) => p.key === key)) {
+    return err(`A page with the key "${key}" already exists.`);
+  }
+  const title = checkTitle(
+    layout,
+    options.title ?? nextPageTitle(layout)
+  );
+  if (!title.ok) return title;
+  const base = withExplicitPages(layout);
+  const page = {
+    key,
+    title: title.value,
+    order: [],
+    hidden: [],
+    minimized: []
   };
+  return ok({ ...base, pages: [...base.pages ?? [], page] });
 }
-function toggleHidden(layout, key) {
-  return isHidden(layout, key) ? showWidget(layout, key) : hideWidget(layout, key);
-}
-function minimizeWidget(layout, key) {
-  if (isMinimized(layout, key)) return layout;
-  return { ...layout, minimized: [...layout.minimized, key] };
-}
-function restoreWidget(layout, key) {
-  if (!isMinimized(layout, key)) return layout;
-  return { ...layout, minimized: layout.minimized.filter((k) => k !== key) };
+function renamePage(layout, pageKey, title) {
+  const page = pageList(layout).find(
+    (p) => p.key === pageKey
+  );
+  if (page === void 0) return err(`Page "${pageKey}" doesn't exist.`);
+  const checked = checkTitle(layout, title, pageKey);
+  if (!checked.ok) return checked;
+  if (checked.value === page.title) return ok(layout);
+  const base = withExplicitPages(layout);
+  return ok({
+    ...base,
+    pages: (base.pages ?? []).map(
+      (p) => p.key === pageKey ? { ...p, title: checked.value } : p
+    )
+  });
 }
-function toggleMinimized(layout, key) {
-  return isMinimized(layout, key) ? restoreWidget(layout, key) : minimizeWidget(layout, key);
+function movePage(layout, pageKey, offset) {
+  const pages = layout.pages ?? [];
+  const from = pages.findIndex((p) => p.key === pageKey);
+  if (from === -1) return layout;
+  const to = Math.max(
+    0,
+    Math.min(pages.length - 1, from + Math.trunc(offset))
+  );
+  if (to === from) return layout;
+  const next = [...pages];
+  const [moved] = next.splice(from, 1);
+  next.splice(to, 0, moved);
+  return { ...layout, pages: next };
 }
-function pruneLayout(definitions, layout) {
-  const known = new Set(definitions.map((d) => d.key));
-  const keep = (keys) => keys.every((k) => known.has(k)) ? keys : keys.filter((k) => known.has(k));
-  return mapLayoutLists(layout, (lists) => ({
-    order: keep(lists.order),
-    hidden: keep(lists.hidden),
-    minimized: keep(lists.minimized)
-  }));
+function overflowing(definitions, layout, options) {
+  return pageList(layout).find(
+    (page) => placeRows(pageWidgets(definitions, layout, page.key)).length > rowsAllowed(page, options)
+  );
 }
-function mapLayoutLists(layout, change) {
-  const top = change(layout);
-  const pages = layout.pages?.map((page) => {
-    const next = change(page);
-    return next.order === page.order && next.hidden === page.hidden && next.minimized === page.minimized ? page : { ...page, ...next };
-  });
-  const pagesChanged = pages !== void 0 && pages.some((page, i) => page !== layout.pages?.[i]);
-  if (top.order === layout.order && top.hidden === layout.hidden && top.minimized === layout.minimized && !pagesChanged) {
-    return layout;
+function removePage(definitions, layout, pageKey, options = {}) {
+  const pages = pageList(layout);
+  const index = pages.findIndex((p) => p.key === pageKey);
+  const page = pages[index];
+  if (page === void 0) return err(`Page "${pageKey}" doesn't exist.`);
+  if (pages.length === 1) {
+    return err(
+      `${describePage(page)} is the only page, so it can't be removed.`
+    );
   }
-  return {
+  const target = pages[index > 0 ? index - 1 : 1];
+  const merged = {
     ...layout,
-    ...top,
-    ...pages === void 0 ? {} : { pages }
+    pages: pages.filter((p) => p.key !== pageKey).map(
+      (p) => p.key === target.key ? {
+        ...p,
+        order: index > 0 ? [...p.order, ...page.order] : [...page.order, ...p.order],
+        hidden: [...p.hidden, ...page.hidden],
+        minimized: [...p.minimized, ...page.minimized]
+      } : p
+    )
   };
-}
-function enforceLocks(definitions, layout, options = {}) {
-  if (options.overrideLocks === true) return layout;
-  const noMove = /* @__PURE__ */ new Set();
-  const noHide = /* @__PURE__ */ new Set();
-  const noMinimize = /* @__PURE__ */ new Set();
-  for (const definition of definitions) {
-    const lock = resolveWidgetLock(definition);
-    if (lock.move) noMove.add(definition.key);
-    if (lock.hide) noHide.add(definition.key);
-    if (lock.minimize) noMinimize.add(definition.key);
-  }
-  const without2 = (keys, drop) => keys.some((key) => drop.has(key)) ? keys.filter((key) => !drop.has(key)) : keys;
-  return mapLayoutLists(layout, (lists) => ({
-    order: without2(lists.order, noMove),
-    hidden: without2(lists.hidden, noHide),
-    minimized: without2(lists.minimized, noMinimize)
-  }));
-}
-
-// src/core/validate.ts
-var MAX_REPORTED_PROBLEMS = 10;
-function describeType2(value) {
-  if (value === null) return "null";
-  if (Array.isArray(value)) return "array";
-  if (typeof value === "number" && !Number.isFinite(value)) {
-    return String(value);
-  }
-  return typeof value;
-}
-function isRecord2(value) {
-  return typeof value === "object" && value !== null && !Array.isArray(value);
-}
-function join(path, field) {
-  return path === "" ? field : `${path}.${field}`;
-}
-function requireString(record, field, path, problems) {
-  const value = record[field];
-  if (typeof value !== "string") {
-    problems.push(
-      `${join(path, field)} must be a string, got ${describeType2(value)}.`
+  const full = overflowing(
+    definitions,
+    merged,
+    options
+  );
+  if (full !== void 0) {
+    return err(
+      `${describePage(page)} has widgets that don't fit on the other pages (${describePage(full)} would need more than ${rowsAllowed(full, options)} rows). Move or hide some first.`
     );
   }
+  return ok(merged);
 }
-function optionalString(record, field, path, problems) {
-  if (record[field] !== void 0) {
-    requireString(record, field, path, problems);
-  }
-}
-function requireNumber(record, field, path, problems) {
-  const value = record[field];
-  if (typeof value !== "number" || !Number.isFinite(value)) {
-    problems.push(
-      `${join(path, field)} must be a finite number, got ${describeType2(value)}.`
-    );
-  }
-}
-function optionalNumber(record, field, path, problems) {
-  if (record[field] !== void 0) {
-    requireNumber(record, field, path, problems);
-  }
+function without(keys, key) {
+  return keys.includes(key) ? keys.filter((k) => k !== key) : keys;
 }
-function optionalSortValue(record, path, problems) {
-  const value = record["value"];
-  if (value !== void 0 && typeof value !== "string" && !(typeof value === "number" && Number.isFinite(value))) {
-    problems.push(
-      `${path}.value must be a string or a finite number, got ${describeType2(value)}.`
+function moveWidgetToPage(definitions, layout, widgetKey, targetKey, options = {}) {
+  const widget = definitions.find((d) => d.key === widgetKey);
+  if (widget === void 0) {
+    return err(
+      `Widget "${widgetKey}" isn't one of the widgets, so it can't be moved to a page.`
     );
   }
-}
-function optionalBoolean(record, field, path, problems) {
-  const value = record[field];
-  if (value !== void 0 && typeof value !== "boolean") {
-    problems.push(
-      `${join(path, field)} must be a boolean, got ${describeType2(value)}.`
+  const pages = pageList(layout);
+  const target = pages.find((p) => p.key === targetKey);
+  if (target === void 0) return err(`Page "${targetKey}" doesn't exist.`);
+  const sourceKey = pageOf(definitions, layout, widgetKey);
+  if (sourceKey === targetKey) return ok(layout);
+  if (resolveWidgetLock(widget).move) {
+    return err(
+      `Widget "${titleOf(widget)}" is locked against moving, so it can't be moved to ${describePage(target)}.`
     );
   }
-}
-function optionalUrl(record, field, path, problems, isSafe, allowed) {
-  const value = record[field];
-  if (value === void 0) return;
-  if (typeof value !== "string") {
-    problems.push(
-      `${join(path, field)} must be a string, got ${describeType2(value)}.`
-    );
-  } else if (!isSafe(value)) {
-    problems.push(
-      `${join(path, field)} must be ${allowed}, got ${JSON.stringify(value.slice(0, 80))}.`
-    );
+  const base = withExplicitPages(layout);
+  const source = (base.pages ?? []).find(
+    (p) => p.key === sourceKey
+  );
+  const hidden = source.hidden.includes(widgetKey);
+  const minimized = source.minimized.includes(widgetKey);
+  const targetOrder = pageWidgets(
+    definitions,
+    base,
+    targetKey
+  ).map((d) => d.key);
+  const moved = {
+    ...base,
+    pages: (base.pages ?? []).map((p) => {
+      if (p.key === sourceKey) {
+        return {
+          ...p,
+          order: without(p.order, widgetKey),
+          hidden: without(p.hidden, widgetKey),
+          minimized: without(p.minimized, widgetKey)
+        };
+      }
+      if (p.key === targetKey) {
+        return {
+          ...p,
+          order: hidden ? p.order : [...targetOrder, widgetKey],
+          hidden: hidden ? [...p.hidden, widgetKey] : p.hidden,
+          minimized: minimized ? [...p.minimized, widgetKey] : p.minimized
+        };
+      }
+      return p;
+    })
+  };
+  if (!hidden) {
+    const allowed = rowsAllowed(target, options);
+    const needed = placeRows(
+      pageWidgets(definitions, moved, targetKey)
+    ).length;
+    if (needed > allowed) {
+      return err(
+        `${describePage(target)} has no room for "${titleOf(widget)}": it would need row ${needed}, and the page allows ${allowed}.`
+      );
+    }
   }
+  return ok(moved);
 }
-function requireArray(record, field, path, problems) {
-  const value = record[field];
-  if (!Array.isArray(value)) {
-    problems.push(
-      `${join(path, field)} must be an array, got ${describeType2(value)}.`
-    );
-    return null;
-  }
-  return value;
+function withoutLockField(definition) {
+  if (definition.locked === void 0) return definition;
+  const copy = { ...definition };
+  delete copy.locked;
+  return copy;
 }
-function requireOneOf(record, field, options, path, problems) {
-  const value = record[field];
-  if (typeof value !== "string" || !options.includes(value)) {
-    problems.push(
-      `${join(path, field)} must be one of ${options.map((o) => `"${o}"`).join(", ")}, got ${typeof value === "string" ? JSON.stringify(value) : describeType2(value)}.`
-    );
+function uniqueTitle2(taken, title, index) {
+  let base = title.trim().slice(0, MAX_PAGE_TITLE_LENGTH);
+  if (base === "") base = `Page ${index + 1}`;
+  let candidate = base;
+  let n = 1;
+  while (taken.has(normalizedTitle(candidate))) {
+    const suffix = ` (#${n})`;
+    candidate = `${base.slice(0, MAX_PAGE_TITLE_LENGTH - suffix.length)}${suffix}`;
+    n += 1;
   }
+  taken.add(normalizedTitle(candidate));
+  return candidate;
 }
-function eachRecord(items, path, problems, check) {
-  items.forEach((item, index) => {
-    const itemPath = `${path}[${index}]`;
-    if (isRecord2(item)) {
-      check(item, itemPath);
-    } else {
-      problems.push(
-        `${itemPath} must be an object, got ${describeType2(item)}.`
-      );
-    }
+function samePages(a, b) {
+  return a.length === b.length && a.every((p, i) => {
+    const q = b[i];
+    return p.key === q.key && p.title === q.title && p.maxRows === q.maxRows && sameKeys(p.order, q.order) && sameKeys(p.hidden, q.hidden) && sameKeys(p.minimized, q.minimized);
   });
 }
-var HREF_RULE = "an http(s), mailto or relative URL";
-var IMAGE_RULE = "an http(s) or relative URL";
-function checkPayloadFields(kind, data, problems) {
-  switch (kind) {
-    case "TEXT":
-      requireString(data, "value", "", problems);
-      requireString(data, "label", "", problems);
-      return;
-    case "KPI":
-      requireNumber(data, "value", "", problems);
-      if (data["previous"] !== null) {
-        optionalNumber(data, "previous", "", problems);
+function normalizeLayout(definitions, layout, options = {}) {
+  const clones = cleanClones(definitions, layout.clones, options);
+  let base = layout;
+  if (clones !== layout.clones) {
+    const { clones: _dropped, ...others } = layout;
+    base = clones === void 0 ? others : { ...others, clones };
+  }
+  return normalizeWidgets(
+    withClones(definitions, base, options),
+    base,
+    options
+  );
+}
+function normalizeWidgets(definitions, layout, options) {
+  const known = pruneLayout(definitions, layout);
+  const enforced = enforceLocks(definitions, known, options);
+  const locked = normalizeSettings(
+    definitions,
+    enforced,
+    options
+  );
+  if (!hasPages(locked)) return locked === layout ? layout : locked;
+  const defs = effectiveDefinitions(
+    options.overrideLocks === true ? definitions.map(withoutLockField) : definitions,
+    locked,
+    options
+  );
+  const taken = /* @__PURE__ */ new Set();
+  const seenKeys = /* @__PURE__ */ new Set();
+  const held = /* @__PURE__ */ new Set();
+  let pages = [];
+  (locked.pages ?? []).forEach((page, index) => {
+    if (seenKeys.has(page.key)) return;
+    seenKeys.add(page.key);
+    const keep = (list) => [
+      ...new Set(list.filter((k) => !held.has(k)))
+    ];
+    const next = {
+      ...page,
+      title: uniqueTitle2(taken, page.title, index),
+      order: keep(page.order),
+      hidden: keep(page.hidden),
+      minimized: keep(page.minimized)
+    };
+    for (const k of [...next.order, ...next.hidden]) held.add(k);
+    pages.push(next);
+  });
+  const work = () => ({ ...locked, pages });
+  const pinned = defs.filter((d) => resolveWidgetLock(d).move);
+  for (const widget of pinned) {
+    const home = homePageKey(work(), widget);
+    const keysHere = (p, list) => p.key !== home && p[list].includes(widget.key);
+    const wasHidden = pages.some((p) => keysHere(p, "hidden"));
+    const wasMinimized = pages.some((p) => keysHere(p, "minimized"));
+    if (!wasHidden && !wasMinimized) continue;
+    pages = pages.map((p) => {
+      let next = p;
+      if (keysHere(p, "hidden")) {
+        next = { ...next, hidden: without(next.hidden, widget.key) };
       }
-      requireOneOf(data, "format", VALUE_FORMATS, "", problems);
-      optionalString(data, "currency", "", problems);
-      requireString(data, "label", "", problems);
-      optionalString(data, "hint", "", problems);
-      optionalBoolean(data, "higherIsBetter", "", problems);
-      return;
-    case "GAUGE":
-      requireNumber(data, "value", "", problems);
-      requireNumber(data, "max", "", problems);
-      requireString(data, "label", "", problems);
-      if (typeof data["max"] === "number" && data["max"] <= 0) {
-        problems.push(`max must be greater than 0, got ${data["max"]}.`);
+      if (keysHere(p, "minimized")) {
+        next = { ...next, minimized: without(next.minimized, widget.key) };
       }
-      return;
-    case "TABLE": {
-      const columns = requireArray(data, "columns", "", problems);
-      if (columns !== null) {
-        eachRecord(columns, "columns", problems, (column, path) => {
-          requireString(column, "label", path, problems);
-          optionalBoolean(column, "numeric", path, problems);
-        });
+      if (p.key === home) {
+        next = {
+          ...next,
+          hidden: wasHidden && !next.hidden.includes(widget.key) ? [...next.hidden, widget.key] : next.hidden,
+          minimized: wasMinimized && !next.minimized.includes(widget.key) ? [...next.minimized, widget.key] : next.minimized
+        };
       }
-      const rows = requireArray(data, "rows", "", problems);
-      if (rows !== null) {
-        rows.forEach((row, rowIndex) => {
-          const rowPath = `rows[${rowIndex}]`;
-          if (!Array.isArray(row)) {
-            problems.push(
-              `${rowPath} must be an array of cells, got ${describeType2(row)}.`
-            );
-            return;
-          }
-          if (columns !== null && row.length !== columns.length) {
-            problems.push(
-              `${rowPath} has ${row.length} cell(s) but there are ${columns.length} column(s).`
-            );
-          }
-          eachRecord(row, rowPath, problems, (cell, cellPath) => {
-            requireString(cell, "text", cellPath, problems);
-            optionalSortValue(cell, cellPath, problems);
-            optionalUrl(
-              cell,
-              "href",
-              cellPath,
-              problems,
-              isSafeHref,
-              HREF_RULE
-            );
-          });
-        });
-      }
-      optionalString(data, "footer", "", problems);
-      return;
-    }
-    case "BAR_LIST": {
-      const items = requireArray(data, "items", "", problems);
-      if (items !== null) {
-        eachRecord(items, "items", problems, (item, path) => {
-          requireString(item, "label", path, problems);
-          requireNumber(item, "value", path, problems);
-          optionalString(item, "display", path, problems);
-        });
+      return next;
+    });
+  }
+  const placedKeys = /* @__PURE__ */ new Set();
+  for (const p of pages) {
+    for (const k of [...p.order, ...p.hidden]) placedKeys.add(k);
+  }
+  const pinnedKeys = new Set(pinned.map((d) => d.key));
+  const unplaced = defs.filter((d) => !placedKeys.has(d.key) && !pinnedKeys.has(d.key)).map((definition, index) => ({ definition, index })).sort(
+    (a, b) => (a.definition.sortOrder ?? 0) - (b.definition.sortOrder ?? 0) || a.index - b.index
+  ).map(({ definition }) => definition);
+  for (const widget of unplaced) {
+    const home = homePageKey(work(), widget);
+    pages = pages.map(
+      (p) => p.key === home ? { ...p, order: [...p.order, widget.key] } : p
+    );
+  }
+  for (let i = 0; i < pages.length; i += 1) {
+    const page = pages[i];
+    const shown = pageWidgets(defs, work(), page.key);
+    const fits = fitCount(shown, rowsAllowed(page, options));
+    if (fits >= shown.length) continue;
+    const moving = shown.slice(fits).filter((d) => !pinnedKeys.has(d.key)).map((d) => d.key);
+    if (moving.length === 0) continue;
+    const moveSet = new Set(moving);
+    const movedMinimized = page.minimized.filter(
+      (k) => moveSet.has(k)
+    );
+    pages = pages.map(
+      (p) => p.key === page.key ? {
+        ...p,
+        order: p.order.filter((k) => !moveSet.has(k)),
+        minimized: p.minimized.filter((k) => !moveSet.has(k))
+      } : p
+    );
+    let placed = false;
+    for (let j = i + 1; j < pages.length && !placed; j += 1) {
+      const candidate = pages[j];
+      const trial = pages.map(
+        (p) => p.key === candidate.key ? {
+          ...p,
+          order: [...moving, ...p.order],
+          minimized: [...p.minimized, ...movedMinimized]
+        } : p
+      );
+      const items = pageWidgets(
+        defs,
+        { ...locked, pages: trial },
+        candidate.key
+      );
+      if (placeRows(items).length <= rowsAllowed(candidate, options)) {
+        pages = trial;
+        placed = true;
       }
-      optionalNumber(data, "total", "", problems);
-      return;
     }
-    case "ALERT_LIST": {
-      const items = requireArray(data, "items", "", problems);
-      if (items !== null) {
-        eachRecord(items, "items", problems, (item, path) => {
-          requireString(item, "title", path, problems);
-          optionalUrl(item, "href", path, problems, isSafeHref, HREF_RULE);
-          optionalUrl(
-            item,
-            "thumbnailUrl",
-            path,
-            problems,
-            isSafeImageUrl,
-            IMAGE_RULE
-          );
-          requireString(item, "valueLabel", path, problems);
-          optionalString(item, "detail", path, problems);
-        });
-      }
-      requireNumber(data, "total", "", problems);
-      requireString(data, "emptyText", "", problems);
-      if (items !== null && typeof data["total"] === "number" && data["total"] < items.length) {
-        problems.push(
-          `total (${data["total"]}) must be at least the number of items (${items.length}).`
-        );
-      }
-      return;
+    if (!placed) {
+      const key = nextPageKey(work());
+      const title = uniqueTitle2(
+        new Set(pages.map((p) => normalizedTitle(p.title))),
+        `Page ${pages.length + 1}`,
+        pages.length
+      );
+      pages = [
+        ...pages,
+        { key, title, order: moving, hidden: [], minimized: movedMinimized }
+      ];
     }
-    case "GRAPH": {
-      const series = requireArray(data, "series", "", problems);
-      if (series !== null) {
-        if (series.length > MAX_GRAPH_SERIES) {
-          problems.push(
-            `series has ${series.length} entries; at most ${MAX_GRAPH_SERIES} are allowed (fold the rest into "Other").`
-          );
-        }
-        eachRecord(series, "series", problems, (entry, path) => {
-          requireString(entry, "name", path, problems);
-          const points = requireArray(entry, "points", path, problems);
-          if (points !== null) {
-            eachRecord(
-              points,
-              `${path}.points`,
-              problems,
-              (point, pointPath) => {
-                requireString(point, "label", pointPath, problems);
-                requireNumber(point, "value", pointPath, problems);
-              }
-            );
-          }
-        });
-      }
-      requireOneOf(data, "chartType", ["bar", "line"], "", problems);
-      requireOneOf(data, "valueFormat", VALUE_FORMATS, "", problems);
-      optionalString(data, "currency", "", problems);
-      optionalString(data, "xLabel", "", problems);
-      return;
+  }
+  const result = work();
+  return samePages(layout.pages ?? [], pages) && sameKeys(layout.order, result.order) && locked.settings === layout.settings ? layout : result;
+}
+
+// src/core/duplicate.ts
+function canDuplicate(definitions, key, options = {}) {
+  const definition = definitions.find(
+    (d) => d.key === key
+  );
+  if (definition === void 0) return false;
+  if (options.overrideLocks === true) return true;
+  const sourceKey = definition.sourceKey ?? definition.key;
+  const original = definitions.find(
+    (d) => d.key === sourceKey
+  );
+  return original !== void 0 && !resolveWidgetLock(original).clone;
+}
+function nextCloneKey(definitions, layout, fromKey) {
+  const taken = /* @__PURE__ */ new Set([
+    ...definitions.map((d) => d.key),
+    ...(layout.clones ?? []).map((c) => c.key)
+  ]);
+  let highest = 0;
+  for (const clone of layout.clones ?? []) {
+    if (clone.from === fromKey) {
+      highest = Math.max(highest, cloneNumber(clone.key) ?? 0);
     }
   }
+  let n = highest + 1;
+  while (taken.has(`${fromKey}#${n}`)) n += 1;
+  return `${fromKey}#${n}`;
 }
-function checkDetailOption(detail, problems) {
-  if (detail === void 0 || typeof detail === "boolean") return;
-  if (!isRecord2(detail)) {
-    problems.push(
-      `detail must be true, false or an options object, got ${describeType2(detail)}.`
-    );
-    return;
+function suggestedViewTitle(title, viewLabel) {
+  return `${title} ${viewLabel}`.trim().slice(0, MAX_WIDGET_TITLE_LENGTH);
+}
+function duplicateWidget(definitions, layout, key, options = {}) {
+  const widget = definitions.find((d) => d.key === key);
+  if (widget === void 0) {
+    return err(`Widget ${JSON.stringify(key)} isn't on this dashboard.`);
   }
-  optionalString(detail, "title", "detail", problems);
-  const pageSize = detail["pageSize"];
-  if (pageSize !== void 0 && !(typeof pageSize === "number" && Number.isInteger(pageSize) && pageSize >= 1 && pageSize <= MAX_DETAIL_PAGE_SIZE)) {
-    problems.push(
-      `detail.pageSize must be a whole number from 1 to ${MAX_DETAIL_PAGE_SIZE}, got ${typeof pageSize === "number" ? String(pageSize) : describeType2(pageSize)}.`
+  const originalKey = widget.sourceKey ?? widget.key;
+  if (!canDuplicate(definitions, key, options)) {
+    return err(
+      `Widget ${JSON.stringify(originalKey)} is locked against duplicating.`
     );
   }
-  if (detail["mode"] !== void 0) {
-    requireOneOf(detail, "mode", DETAIL_MODES, "detail", problems);
+  const cloneKey = nextCloneKey(definitions, layout, originalKey);
+  const copiedSettings = (() => {
+    const mine = layout.settings?.[key];
+    if (mine === void 0) return void 0;
+    const { title: _title, ...rest } = mine;
+    return Object.keys(rest).length === 0 ? void 0 : rest;
+  })();
+  const settings = copiedSettings === void 0 ? layout.settings : { ...layout.settings, [cloneKey]: copiedSettings };
+  let next = {
+    ...layout,
+    clones: [...layout.clones ?? [], { key: cloneKey, from: originalKey }],
+    ...settings === void 0 ? {} : { settings }
+  };
+  const all = withClones(definitions, next, options);
+  const assigned = assignPages(all, next);
+  const pageKey = [...assigned].find(
+    ([, widgets]) => widgets.some((w) => w.key === key)
+  )?.[0];
+  if (pageKey !== void 0) {
+    const view = pageLayout(next, pageKey);
+    const onPage = assigned.get(pageKey) ?? [];
+    if (view !== void 0) {
+      const shown = visibleWidgets(onPage, view).filter((d) => !resolveWidgetLock(d).move && d.key !== cloneKey).map((d) => d.key);
+      const at = shown.indexOf(key);
+      const order = at === -1 ? [...shown, cloneKey] : [...shown.slice(0, at + 1), cloneKey, ...shown.slice(at + 1)];
+      next = withPageLayout(next, pageKey, { ...view, order });
+    }
+  }
+  if (hasPages(next) && pageKey !== void 0) {
+    const effective = effectiveDefinitions(all, next, options);
+    const room = pageRoom(effective, next, pageKey, options);
+    if (room !== void 0 && room.rowsUsed > room.maxRows) {
+      const page = next.pages?.find(
+        (p) => p.key === pageKey
+      );
+      const width = effective.find(
+        (d) => d.key === cloneKey
+      )?.width;
+      return err(
+        `Page "${page?.title ?? pageKey}" has no room for a widget${width === void 0 ? "" : ` ${width} wide`} (it holds ${room.maxRows} rows).`
+      );
+    }
   }
+  return ok({ layout: next, key: cloneKey });
 }
-function checkTableControlsOption(controls, kind, problems) {
-  if (controls === void 0 || controls === false) return;
-  if (typeof controls !== "boolean" && !isRecord2(controls)) {
+function deleteClone(layout, key) {
+  if (layout.clones?.some((clone) => clone.key === key) !== true) return layout;
+  const without2 = (keys) => keys.includes(key) ? keys.filter((k) => k !== key) : keys;
+  const { clones, settings, ...rest } = layout;
+  const remaining = (clones ?? []).filter((c) => c.key !== key);
+  const { [key]: _gone, ...otherSettings } = settings ?? {};
+  return {
+    ...rest,
+    order: without2(layout.order),
+    hidden: without2(layout.hidden),
+    minimized: without2(layout.minimized),
+    ...layout.pages === void 0 ? {} : {
+      pages: layout.pages.map((page) => ({
+        ...page,
+        order: without2(page.order),
+        hidden: without2(page.hidden),
+        minimized: without2(page.minimized)
+      }))
+    },
+    ...Object.keys(otherSettings).length === 0 ? {} : { settings: otherSettings },
+    ...remaining.length === 0 ? {} : { clones: remaining }
+  };
+}
+
+// src/core/validate.ts
+var MAX_REPORTED_PROBLEMS = 10;
+function describeType2(value) {
+  if (value === null) return "null";
+  if (Array.isArray(value)) return "array";
+  if (typeof value === "number" && !Number.isFinite(value)) {
+    return String(value);
+  }
+  return typeof value;
+}
+function isRecord3(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function join(path, field) {
+  return path === "" ? field : `${path}.${field}`;
+}
+function requireString(record, field, path, problems) {
+  const value = record[field];
+  if (typeof value !== "string") {
     problems.push(
-      `tableControls must be true, false or an options object, got ${describeType2(controls)}.`
+      `${join(path, field)} must be a string, got ${describeType2(value)}.`
     );
-    return;
   }
-  if (isRecord2(controls)) {
-    optionalBoolean(controls, "search", "tableControls", problems);
-    optionalBoolean(controls, "sort", "tableControls", problems);
+}
+function optionalString(record, field, path, problems) {
+  if (record[field] !== void 0) {
+    requireString(record, field, path, problems);
   }
-  if (typeof kind === "string" && kind !== "TABLE") {
+}
+function requireNumber(record, field, path, problems) {
+  const value = record[field];
+  if (typeof value !== "number" || !Number.isFinite(value)) {
     problems.push(
-      `tableControls only applies to TABLE widgets, but kind is "${kind}".`
+      `${join(path, field)} must be a finite number, got ${describeType2(value)}.`
     );
   }
 }
-function checkWidthLimits(value, problems) {
-  for (const field of ["minWidth", "maxWidth"]) {
-    const limit = value[field];
-    if (limit !== void 0 && !isWidgetWidth(limit)) {
-      problems.push(
-        `${field} must be an integer from ${MIN_WIDGET_WIDTH} to ${MAX_WIDGET_WIDTH} (twelfths of the row), got ${typeof limit === "number" ? String(limit) : describeType2(limit)}.`
-      );
-      return;
-    }
+function optionalNumber(record, field, path, problems) {
+  if (record[field] !== void 0) {
+    requireNumber(record, field, path, problems);
   }
-  const { minWidth, maxWidth, width } = value;
-  if (isWidgetWidth(minWidth) && isWidgetWidth(maxWidth) && minWidth > maxWidth) {
+}
+function optionalSortValue(record, path, problems) {
+  const value = record["value"];
+  if (value !== void 0 && typeof value !== "string" && !(typeof value === "number" && Number.isFinite(value))) {
     problems.push(
-      `minWidth (${minWidth}) must not be more than maxWidth (${maxWidth}).`
+      `${path}.value must be a string or a finite number, got ${describeType2(value)}.`
     );
-    return;
-  }
-  if (isWidgetWidth(width)) {
-    if (isWidgetWidth(minWidth) && width < minWidth) {
-      problems.push(
-        `width (${width}) must not be less than minWidth (${minWidth}).`
-      );
-    }
-    if (isWidgetWidth(maxWidth) && width > maxWidth) {
-      problems.push(
-        `width (${width}) must not be more than maxWidth (${maxWidth}).`
-      );
-    }
   }
 }
-function checkLockedOption(locked, problems) {
-  if (locked === void 0 || typeof locked === "boolean") return;
-  if (!isRecord2(locked)) {
+function optionalBoolean(record, field, path, problems) {
+  const value = record[field];
+  if (value !== void 0 && typeof value !== "boolean") {
     problems.push(
-      `locked must be true, false or an object, got ${describeType2(locked)}.`
+      `${join(path, field)} must be a boolean, got ${describeType2(value)}.`
     );
-    return;
   }
-  optionalBoolean(locked, "move", "locked", problems);
+}
+function optionalUrl(record, field, path, problems, isSafe, allowed) {
+  const value = record[field];
+  if (value === void 0) return;
+  if (typeof value !== "string") {
+    problems.push(
+      `${join(path, field)} must be a string, got ${describeType2(value)}.`
+    );
+  } else if (!isSafe(value)) {
+    problems.push(
+      `${join(path, field)} must be ${allowed}, got ${JSON.stringify(value.slice(0, 80))}.`
+    );
+  }
+}
+function requireArray(record, field, path, problems) {
+  const value = record[field];
+  if (!Array.isArray(value)) {
+    problems.push(
+      `${join(path, field)} must be an array, got ${describeType2(value)}.`
+    );
+    return null;
+  }
+  return value;
+}
+function requireOneOf(record, field, options, path, problems) {
+  const value = record[field];
+  if (typeof value !== "string" || !options.includes(value)) {
+    problems.push(
+      `${join(path, field)} must be one of ${options.map((o) => `"${o}"`).join(", ")}, got ${typeof value === "string" ? JSON.stringify(value) : describeType2(value)}.`
+    );
+  }
+}
+function eachRecord(items, path, problems, check) {
+  items.forEach((item, index) => {
+    const itemPath = `${path}[${index}]`;
+    if (isRecord3(item)) {
+      check(item, itemPath);
+    } else {
+      problems.push(
+        `${itemPath} must be an object, got ${describeType2(item)}.`
+      );
+    }
+  });
+}
+var HREF_RULE = "an http(s), mailto or relative URL";
+var IMAGE_RULE = "an http(s) or relative URL";
+function checkPayloadFields(kind, data, problems) {
+  switch (kind) {
+    case "TEXT":
+      requireString(data, "value", "", problems);
+      requireString(data, "label", "", problems);
+      return;
+    case "KPI":
+      requireNumber(data, "value", "", problems);
+      if (data["previous"] !== null) {
+        optionalNumber(data, "previous", "", problems);
+      }
+      requireOneOf(data, "format", VALUE_FORMATS, "", problems);
+      optionalString(data, "currency", "", problems);
+      requireString(data, "label", "", problems);
+      optionalString(data, "hint", "", problems);
+      optionalBoolean(data, "higherIsBetter", "", problems);
+      return;
+    case "GAUGE":
+      requireNumber(data, "value", "", problems);
+      requireNumber(data, "max", "", problems);
+      requireString(data, "label", "", problems);
+      if (typeof data["max"] === "number" && data["max"] <= 0) {
+        problems.push(`max must be greater than 0, got ${data["max"]}.`);
+      }
+      return;
+    case "TABLE": {
+      const columns = requireArray(data, "columns", "", problems);
+      if (columns !== null) {
+        eachRecord(columns, "columns", problems, (column, path) => {
+          requireString(column, "label", path, problems);
+          optionalBoolean(column, "numeric", path, problems);
+        });
+      }
+      const rows = requireArray(data, "rows", "", problems);
+      if (rows !== null) {
+        rows.forEach((row, rowIndex) => {
+          const rowPath = `rows[${rowIndex}]`;
+          if (!Array.isArray(row)) {
+            problems.push(
+              `${rowPath} must be an array of cells, got ${describeType2(row)}.`
+            );
+            return;
+          }
+          if (columns !== null && row.length !== columns.length) {
+            problems.push(
+              `${rowPath} has ${row.length} cell(s) but there are ${columns.length} column(s).`
+            );
+          }
+          eachRecord(row, rowPath, problems, (cell, cellPath) => {
+            requireString(cell, "text", cellPath, problems);
+            optionalSortValue(cell, cellPath, problems);
+            optionalUrl(
+              cell,
+              "href",
+              cellPath,
+              problems,
+              isSafeHref,
+              HREF_RULE
+            );
+          });
+        });
+      }
+      optionalString(data, "footer", "", problems);
+      return;
+    }
+    case "BAR_LIST": {
+      const items = requireArray(data, "items", "", problems);
+      if (items !== null) {
+        eachRecord(items, "items", problems, (item, path) => {
+          requireString(item, "label", path, problems);
+          requireNumber(item, "value", path, problems);
+          optionalString(item, "display", path, problems);
+        });
+      }
+      optionalNumber(data, "total", "", problems);
+      return;
+    }
+    case "ALERT_LIST": {
+      const items = requireArray(data, "items", "", problems);
+      if (items !== null) {
+        eachRecord(items, "items", problems, (item, path) => {
+          requireString(item, "title", path, problems);
+          optionalUrl(item, "href", path, problems, isSafeHref, HREF_RULE);
+          optionalUrl(
+            item,
+            "thumbnailUrl",
+            path,
+            problems,
+            isSafeImageUrl,
+            IMAGE_RULE
+          );
+          requireString(item, "valueLabel", path, problems);
+          optionalString(item, "detail", path, problems);
+        });
+      }
+      requireNumber(data, "total", "", problems);
+      requireString(data, "emptyText", "", problems);
+      if (items !== null && typeof data["total"] === "number" && data["total"] < items.length) {
+        problems.push(
+          `total (${data["total"]}) must be at least the number of items (${items.length}).`
+        );
+      }
+      return;
+    }
+    case "GRAPH": {
+      const series = requireArray(data, "series", "", problems);
+      if (series !== null) {
+        if (series.length > MAX_GRAPH_SERIES) {
+          problems.push(
+            `series has ${series.length} entries; at most ${MAX_GRAPH_SERIES} are allowed (fold the rest into "Other").`
+          );
+        }
+        eachRecord(series, "series", problems, (entry, path) => {
+          requireString(entry, "name", path, problems);
+          const points = requireArray(entry, "points", path, problems);
+          if (points !== null) {
+            eachRecord(
+              points,
+              `${path}.points`,
+              problems,
+              (point, pointPath) => {
+                requireString(point, "label", pointPath, problems);
+                requireNumber(point, "value", pointPath, problems);
+              }
+            );
+          }
+        });
+      }
+      requireOneOf(data, "chartType", ["bar", "line"], "", problems);
+      requireOneOf(data, "valueFormat", VALUE_FORMATS, "", problems);
+      optionalString(data, "currency", "", problems);
+      optionalString(data, "xLabel", "", problems);
+      return;
+    }
+  }
+}
+function checkDetailOption(detail, problems) {
+  if (detail === void 0 || typeof detail === "boolean") return;
+  if (!isRecord3(detail)) {
+    problems.push(
+      `detail must be true, false or an options object, got ${describeType2(detail)}.`
+    );
+    return;
+  }
+  optionalString(detail, "title", "detail", problems);
+  const pageSize = detail["pageSize"];
+  if (pageSize !== void 0 && !(typeof pageSize === "number" && Number.isInteger(pageSize) && pageSize >= 1 && pageSize <= MAX_DETAIL_PAGE_SIZE)) {
+    problems.push(
+      `detail.pageSize must be a whole number from 1 to ${MAX_DETAIL_PAGE_SIZE}, got ${typeof pageSize === "number" ? String(pageSize) : describeType2(pageSize)}.`
+    );
+  }
+  if (detail["mode"] !== void 0) {
+    requireOneOf(detail, "mode", DETAIL_MODES, "detail", problems);
+  }
+}
+function checkTableControlsOption(controls, kind, problems) {
+  if (controls === void 0 || controls === false) return;
+  if (typeof controls !== "boolean" && !isRecord3(controls)) {
+    problems.push(
+      `tableControls must be true, false or an options object, got ${describeType2(controls)}.`
+    );
+    return;
+  }
+  if (isRecord3(controls)) {
+    optionalBoolean(controls, "search", "tableControls", problems);
+    optionalBoolean(controls, "sort", "tableControls", problems);
+  }
+  if (typeof kind === "string" && kind !== "TABLE") {
+    problems.push(
+      `tableControls only applies to TABLE widgets, but kind is "${kind}".`
+    );
+  }
+}
+function checkWidthLimits(value, problems) {
+  for (const field of ["minWidth", "maxWidth"]) {
+    const limit = value[field];
+    if (limit !== void 0 && !isWidgetWidth(limit)) {
+      problems.push(
+        `${field} must be an integer from ${MIN_WIDGET_WIDTH} to ${MAX_WIDGET_WIDTH} (twelfths of the row), got ${typeof limit === "number" ? String(limit) : describeType2(limit)}.`
+      );
+      return;
+    }
+  }
+  const { minWidth, maxWidth, width } = value;
+  if (isWidgetWidth(minWidth) && isWidgetWidth(maxWidth) && minWidth > maxWidth) {
+    problems.push(
+      `minWidth (${minWidth}) must not be more than maxWidth (${maxWidth}).`
+    );
+    return;
+  }
+  if (isWidgetWidth(width)) {
+    if (isWidgetWidth(minWidth) && width < minWidth) {
+      problems.push(
+        `width (${width}) must not be less than minWidth (${minWidth}).`
+      );
+    }
+    if (isWidgetWidth(maxWidth) && width > maxWidth) {
+      problems.push(
+        `width (${width}) must not be more than maxWidth (${maxWidth}).`
+      );
+    }
+  }
+}
+function checkLockedOption(locked, problems) {
+  if (locked === void 0 || typeof locked === "boolean") return;
+  if (!isRecord3(locked)) {
+    problems.push(
+      `locked must be true, false or an object, got ${describeType2(locked)}.`
+    );
+    return;
+  }
+  optionalBoolean(locked, "move", "locked", problems);
   optionalBoolean(locked, "hide", "locked", problems);
   optionalBoolean(locked, "minimize", "locked", problems);
   optionalBoolean(locked, "options", "locked", problems);
+  optionalBoolean(locked, "clone", "locked", problems);
 }
 function checkOptionColumns(option, path, kind, problems) {
   const columns = option["columns"];
@@ -2089,7 +2822,7 @@ function checkOptionColumns(option, path, kind, problems) {
   const keys = [];
   columns.forEach((entry, index) => {
     const entryPath = `${path}.columns[${index}]`;
-    if (!isRecord2(entry)) {
+    if (!isRecord3(entry)) {
       problems.push(
         `${entryPath} must be an object, got ${describeType2(entry)}.`
       );
@@ -2114,7 +2847,7 @@ function checkOptionColumns(option, path, kind, problems) {
   return keys;
 }
 function checkOption(option, path, kind, seenKeys, seenTypes, problems) {
-  if (!isRecord2(option)) {
+  if (!isRecord3(option)) {
     problems.push(`${path} must be an object, got ${describeType2(option)}.`);
     return;
   }
@@ -2146,7 +2879,7 @@ function checkOption(option, path, kind, seenKeys, seenTypes, problems) {
       } else {
         choices.forEach((choice, index) => {
           const choicePath = `${path}.choices[${index}]`;
-          if (!isRecord2(choice)) {
+          if (!isRecord3(choice)) {
             problems.push(
               `${choicePath} must be an object, got ${describeType2(choice)}.`
             );
@@ -2236,7 +2969,7 @@ function checkOption(option, path, kind, seenKeys, seenTypes, problems) {
         } else {
           presets.forEach((preset, index) => {
             const presetPath = `${path}.presets[${index}]`;
-            if (!isRecord2(preset)) {
+            if (!isRecord3(preset)) {
               problems.push(
                 `${presetPath} must be an object, got ${describeType2(preset)}.`
               );
@@ -2365,7 +3098,7 @@ function checkColumnIndex(value, path, problems) {
   }
 }
 function checkConversion(conversion, path, baseKind, viewKind2, problems) {
-  if (!isRecord2(conversion)) {
+  if (!isRecord3(conversion)) {
     problems.push(
       `${path} must be an object with a type, got ${describeType2(conversion)}.`
     );
@@ -2443,7 +3176,7 @@ function checkViews(value, problems) {
     } else {
       views.forEach((view, index) => {
         const path = `views[${index}]`;
-        if (!isRecord2(view)) {
+        if (!isRecord3(view)) {
           problems.push(
             `${path} must be an object, got ${describeType2(view)}.`
           );
@@ -2463,11 +3196,7 @@ function checkViews(value, problems) {
           problems.push(`${path}.label must be a non-empty string.`);
         }
         requireOneOf(view, "kind", WIDGET_KINDS, path, problems);
-        if (view["convert"] === void 0) {
-          problems.push(
-            `${path}.convert is required: views supplied by a provider are not supported yet.`
-          );
-        } else {
+        if (view["convert"] !== void 0) {
           checkConversion(
             view["convert"],
             `${path}.convert`,
@@ -2494,7 +3223,7 @@ function formatProblems(prefix, problems) {
 }
 function validateWidgetData(value, options = {}) {
   const subject = options.widgetKey === void 0 ? "Widget data" : `Widget ${JSON.stringify(options.widgetKey)}`;
-  if (!isRecord2(value)) {
+  if (!isRecord3(value)) {
     return err(`${subject}: must be an object, got ${describeType2(value)}.`);
   }
   if (value["empty"] === true) {
@@ -2524,7 +3253,7 @@ function validateWidgetData(value, options = {}) {
   return ok(value);
 }
 function validateWidgetDefinition(value) {
-  if (!isRecord2(value)) {
+  if (!isRecord3(value)) {
     return err(
       `Widget definition: must be an object, got ${describeType2(value)}.`
     );
@@ -2588,7 +3317,10 @@ function resolvePayload(definition, payload, options = {}) {
   } else {
     const result = validateWidgetData(payload, {
       widgetKey: definition.key,
-      expectedKind: definition.kind
+      expectedKind: loadViewKind(
+        definition,
+        options.viewValues?.[definition.key]
+      )
     });
     if (!result.ok) {
       return { definition, status: "error", error: result.error };
@@ -2599,7 +3331,14 @@ function resolvePayload(definition, payload, options = {}) {
   if (emptyText !== null) {
     return { definition, status: "empty", emptyText };
   }
-  return { definition, status: "ok", data: checked };
+  return {
+    definition,
+    status: "ok",
+    data: checked,
+    ...hasViews(definition) ? {
+      view: loadViewKey(definition, options.viewValues?.[definition.key])
+    } : {}
+  };
 }
 function failedWidget(definition, error) {
   return { definition, status: "error", error };
@@ -2608,8 +3347,15 @@ function loadingWidgets(definitions) {
   return definitions.map((definition) => ({ definition, status: "loading" }));
 }
 function cacheKeyFor(definition, options, values) {
-  const base = options.cacheKey === void 0 ? definition.key : options.cacheKey(definition);
-  return values === void 0 ? base : `${base}${optionsCacheSuffix(definition, values, options)}`;
+  const base = options.cacheKey === void 0 ? definition.sourceKey ?? definition.key : options.cacheKey(definition);
+  const view = loadViewKey(
+    definition,
+    options.viewValues?.[definition.key]
+  );
+  const viewPart = view === BASE_VIEW_KEY ? "" : `view=${encodeURIComponent(view)}`;
+  const optionPart = values === void 0 ? "" : optionsCacheSuffix(definition, values, options);
+  if (viewPart === "") return `${base}${optionPart}`;
+  return optionPart === "" ? `${base}?${viewPart}` : `${base}?${viewPart}&${optionPart.slice(1)}`;
 }
 function optionValuesFor(definition, options) {
   return resolveOptionValues(
@@ -2620,6 +3366,9 @@ function optionValuesFor(definition, options) {
 }
 function finalizeWidget(widget, values) {
   if (Object.keys(values).length === 0) return widget;
+  if (widget.status === "ok" && widget.view !== void 0 && widget.view !== BASE_VIEW_KEY) {
+    return { ...widget, options: values };
+  }
   if (widget.status === "ok") {
     const data = applyClientOptions(
       widget.definition,
@@ -2677,7 +3426,8 @@ async function resolveWidgetUnapplied(definition, provider, context, options = {
         if (controller.signal.aborted) throw new LoadInterruption();
         return provider(context, definition, {
           signal: controller.signal,
-          options: values
+          options: values,
+          view: loadViewKey(definition, options.viewValues?.[definition.key])
         });
       }),
       interrupted
@@ -2722,7 +3472,10 @@ async function resolveWidgets(definitions, providers, context, options = {}) {
     visible.map(
       (definition) => resolveWidget(
         definition,
-        Object.prototype.hasOwnProperty.call(providers, definition.key) ? providers[definition.key] : void 0,
+        Object.prototype.hasOwnProperty.call(
+          providers,
+          definition.sourceKey ?? definition.key
+        ) ? providers[definition.sourceKey ?? definition.key] : void 0,
         context,
         options
       )
@@ -2738,9 +3491,18 @@ function createWidgetLoader(options) {
       ([key, values]) => values === void 0 ? [] : [[key, values]]
     )
   );
+  const chosenViews = new Map(
+    Object.entries(baseOptions.viewValues ?? {}).flatMap(
+      ([key, view]) => view === void 0 ? [] : [[key, view]]
+    )
+  );
   const resolveOptions = baseOptions;
   function currentOptions() {
-    return { ...resolveOptions, optionValues: Object.fromEntries(chosen) };
+    return {
+      ...resolveOptions,
+      optionValues: Object.fromEntries(chosen),
+      viewValues: Object.fromEntries(chosenViews)
+    };
   }
   const unapplied = /* @__PURE__ */ new Map();
   const visible = widgetsFor(definitions, context.roles);
@@ -2802,7 +3564,11 @@ function createWidgetLoader(options) {
       }
     }
     if (!isCurrent()) return;
-    const provider = Object.prototype.hasOwnProperty.call(providers, key) ? providers[key] : void 0;
+    const providerKey = definition.sourceKey ?? key;
+    const provider = Object.prototype.hasOwnProperty.call(
+      providers,
+      providerKey
+    ) ? providers[providerKey] : void 0;
     const result = await resolveWidgetUnapplied(definition, provider, context, {
       ...runOptions,
       signal: controller.signal
@@ -2869,6 +3635,23 @@ function createWidgetLoader(options) {
     }
     start(definition, true);
   }
+  function setView(key, view) {
+    if (disposed) return;
+    const definition = definitionFor(key);
+    if (definition === void 0) return;
+    const before = loadViewKey(definition, chosenViews.get(key));
+    if (view === void 0 || view === "") chosenViews.delete(key);
+    else chosenViews.set(key, view);
+    const after = loadViewKey(definition, chosenViews.get(key));
+    if (before === after || !started.has(key)) return;
+    const current = snapshot.find(
+      (widget) => widget.definition.key === key
+    );
+    if (current !== void 0 && current.status !== "loading") {
+      replace(key, { definition, status: "loading" });
+    }
+    start(definition, true);
+  }
   function dispose() {
     disposed = true;
     abortAll(new Error("The widget loader was disposed."));
@@ -2887,488 +3670,11 @@ function createWidgetLoader(options) {
     loadAll,
     refresh,
     setOptions,
+    setView,
     dispose
   };
 }
 
-// src/core/pages.ts
-var DEFAULT_PAGE_KEY = "default";
-var DEFAULT_PAGE_ROWS = 4;
-function rowsAllowed(page, options) {
-  const rows = page.maxRows ?? options.maxRows ?? DEFAULT_PAGE_ROWS;
-  return Math.max(1, Math.min(MAX_PAGE_ROWS, Math.floor(rows)));
-}
-function hasPages(layout) {
-  return layout.pages !== void 0 && layout.pages.length > 0;
-}
-function pageList(layout) {
-  if (layout.pages !== void 0 && layout.pages.length > 0) {
-    return layout.pages;
-  }
-  return [
-    {
-      key: DEFAULT_PAGE_KEY,
-      title: "Page 1",
-      order: layout.order,
-      hidden: layout.hidden,
-      minimized: layout.minimized
-    }
-  ];
-}
-function withExplicitPages(layout) {
-  if (hasPages(layout)) return layout;
-  return {
-    ...layout,
-    order: [],
-    hidden: [],
-    minimized: [],
-    pages: pageList(layout)
-  };
-}
-function sameKeys(a, b) {
-  return a === b || a.length === b.length && a.every((k, i) => k === b[i]);
-}
-function pageLayout(layout, pageKey) {
-  if (!hasPages(layout))
-    return pageKey === DEFAULT_PAGE_KEY ? layout : void 0;
-  const page = layout.pages?.find(
-    (p) => p.key === pageKey
-  );
-  if (page === void 0) return void 0;
-  const { pages, ...rest } = layout;
-  return {
-    ...rest,
-    order: page.order,
-    hidden: page.hidden,
-    minimized: page.minimized
-  };
-}
-function withPageLayout(layout, pageKey, next) {
-  const current = pageLayout(layout, pageKey);
-  if (current === void 0 || sameKeys(current.order, next.order) && sameKeys(current.hidden, next.hidden) && sameKeys(current.minimized, next.minimized)) {
-    return layout;
-  }
-  if (!hasPages(layout)) {
-    return {
-      ...layout,
-      order: next.order,
-      hidden: next.hidden,
-      minimized: next.minimized
-    };
-  }
-  return {
-    ...layout,
-    pages: (layout.pages ?? []).map(
-      (page) => page.key === pageKey ? {
-        ...page,
-        order: next.order,
-        hidden: next.hidden,
-        minimized: next.minimized
-      } : page
-    )
-  };
-}
-function normalizedTitle(title) {
-  return title.trim().normalize("NFKC").toLowerCase();
-}
-function resolvePageKey(layout, reference) {
-  if (reference === void 0 || reference === "") return void 0;
-  const pages = pageList(layout);
-  const byKey = pages.find((p) => p.key === reference);
-  if (byKey !== void 0) return byKey.key;
-  const wanted = normalizedTitle(reference);
-  return pages.find((p) => normalizedTitle(p.title) === wanted)?.key;
-}
-function homePageKey(layout, item) {
-  return resolvePageKey(layout, item.page) ?? pageList(layout)[0].key;
-}
-function assignPages(definitions, layout) {
-  const pages = pageList(layout);
-  const assigned = new Map(pages.map((p) => [p.key, []]));
-  for (const definition of definitions) {
-    let pageKey;
-    if (!resolveWidgetLock(definition).move) {
-      pageKey = pages.find(
-        (p) => p.order.includes(definition.key) || p.hidden.includes(definition.key)
-      )?.key;
-    }
-    assigned.get(pageKey ?? homePageKey(layout, definition))?.push(definition);
-  }
-  return assigned;
-}
-function pageOf(definitions, layout, key) {
-  for (const [pageKey, widgets] of assignPages(definitions, layout)) {
-    if (widgets.some((w) => w.key === key)) return pageKey;
-  }
-  return void 0;
-}
-function pageWidgets(definitions, layout, pageKey) {
-  const onPage = assignPages(definitions, layout).get(pageKey) ?? [];
-  const view = pageLayout(layout, pageKey);
-  return view === void 0 ? [] : visibleWidgets(onPage, view);
-}
-function pageRoom(definitions, layout, pageKey, options = {}) {
-  const page = pageList(layout).find(
-    (p) => p.key === pageKey
-  );
-  if (page === void 0) return void 0;
-  const maxRows = rowsAllowed(page, options);
-  const rowsUsed = placeRows(
-    pageWidgets(definitions, layout, pageKey)
-  ).length;
-  return { maxRows, rowsUsed, rowsFree: Math.max(0, maxRows - rowsUsed) };
-}
-function describePage(page) {
-  return `Page "${page.title}"`;
-}
-function titleOf(item) {
-  return item.title ?? item.key;
-}
-function checkTitle(layout, title, exceptKey) {
-  const trimmed = title.trim();
-  if (trimmed === "") return err("A page title must not be empty.");
-  if (trimmed.length > MAX_PAGE_TITLE_LENGTH) {
-    return err(
-      `Page title "${trimmed}" is ${trimmed.length} characters; the most is ${MAX_PAGE_TITLE_LENGTH}.`
-    );
-  }
-  const wanted = normalizedTitle(trimmed);
-  const clash = pageList(layout).find(
-    (p) => p.key !== exceptKey && normalizedTitle(p.title) === wanted
-  );
-  if (clash !== void 0) {
-    return err(`Another page is already called "${clash.title}".`);
-  }
-  return ok(trimmed);
-}
-function nextPageKey(layout) {
-  const keys = new Set(pageList(layout).map((p) => p.key));
-  let n = 1;
-  while (keys.has(`page-${n}`)) n += 1;
-  return `page-${n}`;
-}
-function nextPageTitle(layout) {
-  const used = new Set(
-    pageList(layout).map((p) => normalizedTitle(p.title))
-  );
-  let n = pageList(layout).length + 1;
-  while (used.has(normalizedTitle(`Page ${n}`))) n += 1;
-  return `Page ${n}`;
-}
-function addPage(layout, options = {}) {
-  if (pageList(layout).length >= MAX_PARSED_PAGES) {
-    return err(
-      `The layout already has ${MAX_PARSED_PAGES} pages, the most it can keep.`
-    );
-  }
-  const key = options.key ?? nextPageKey(layout);
-  if (pageList(layout).some((p) => p.key === key)) {
-    return err(`A page with the key "${key}" already exists.`);
-  }
-  const title = checkTitle(
-    layout,
-    options.title ?? nextPageTitle(layout)
-  );
-  if (!title.ok) return title;
-  const base = withExplicitPages(layout);
-  const page = {
-    key,
-    title: title.value,
-    order: [],
-    hidden: [],
-    minimized: []
-  };
-  return ok({ ...base, pages: [...base.pages ?? [], page] });
-}
-function renamePage(layout, pageKey, title) {
-  const page = pageList(layout).find(
-    (p) => p.key === pageKey
-  );
-  if (page === void 0) return err(`Page "${pageKey}" doesn't exist.`);
-  const checked = checkTitle(layout, title, pageKey);
-  if (!checked.ok) return checked;
-  if (checked.value === page.title) return ok(layout);
-  const base = withExplicitPages(layout);
-  return ok({
-    ...base,
-    pages: (base.pages ?? []).map(
-      (p) => p.key === pageKey ? { ...p, title: checked.value } : p
-    )
-  });
-}
-function movePage(layout, pageKey, offset) {
-  const pages = layout.pages ?? [];
-  const from = pages.findIndex((p) => p.key === pageKey);
-  if (from === -1) return layout;
-  const to = Math.max(
-    0,
-    Math.min(pages.length - 1, from + Math.trunc(offset))
-  );
-  if (to === from) return layout;
-  const next = [...pages];
-  const [moved] = next.splice(from, 1);
-  next.splice(to, 0, moved);
-  return { ...layout, pages: next };
-}
-function overflowing(definitions, layout, options) {
-  return pageList(layout).find(
-    (page) => placeRows(pageWidgets(definitions, layout, page.key)).length > rowsAllowed(page, options)
-  );
-}
-function removePage(definitions, layout, pageKey, options = {}) {
-  const pages = pageList(layout);
-  const index = pages.findIndex((p) => p.key === pageKey);
-  const page = pages[index];
-  if (page === void 0) return err(`Page "${pageKey}" doesn't exist.`);
-  if (pages.length === 1) {
-    return err(
-      `${describePage(page)} is the only page, so it can't be removed.`
-    );
-  }
-  const target = pages[index > 0 ? index - 1 : 1];
-  const merged = {
-    ...layout,
-    pages: pages.filter((p) => p.key !== pageKey).map(
-      (p) => p.key === target.key ? {
-        ...p,
-        order: index > 0 ? [...p.order, ...page.order] : [...page.order, ...p.order],
-        hidden: [...p.hidden, ...page.hidden],
-        minimized: [...p.minimized, ...page.minimized]
-      } : p
-    )
-  };
-  const full = overflowing(
-    definitions,
-    merged,
-    options
-  );
-  if (full !== void 0) {
-    return err(
-      `${describePage(page)} has widgets that don't fit on the other pages (${describePage(full)} would need more than ${rowsAllowed(full, options)} rows). Move or hide some first.`
-    );
-  }
-  return ok(merged);
-}
-function without(keys, key) {
-  return keys.includes(key) ? keys.filter((k) => k !== key) : keys;
-}
-function moveWidgetToPage(definitions, layout, widgetKey, targetKey, options = {}) {
-  const widget = definitions.find((d) => d.key === widgetKey);
-  if (widget === void 0) {
-    return err(
-      `Widget "${widgetKey}" isn't one of the widgets, so it can't be moved to a page.`
-    );
-  }
-  const pages = pageList(layout);
-  const target = pages.find((p) => p.key === targetKey);
-  if (target === void 0) return err(`Page "${targetKey}" doesn't exist.`);
-  const sourceKey = pageOf(definitions, layout, widgetKey);
-  if (sourceKey === targetKey) return ok(layout);
-  if (resolveWidgetLock(widget).move) {
-    return err(
-      `Widget "${titleOf(widget)}" is locked against moving, so it can't be moved to ${describePage(target)}.`
-    );
-  }
-  const base = withExplicitPages(layout);
-  const source = (base.pages ?? []).find(
-    (p) => p.key === sourceKey
-  );
-  const hidden = source.hidden.includes(widgetKey);
-  const minimized = source.minimized.includes(widgetKey);
-  const targetOrder = pageWidgets(
-    definitions,
-    base,
-    targetKey
-  ).map((d) => d.key);
-  const moved = {
-    ...base,
-    pages: (base.pages ?? []).map((p) => {
-      if (p.key === sourceKey) {
-        return {
-          ...p,
-          order: without(p.order, widgetKey),
-          hidden: without(p.hidden, widgetKey),
-          minimized: without(p.minimized, widgetKey)
-        };
-      }
-      if (p.key === targetKey) {
-        return {
-          ...p,
-          order: hidden ? p.order : [...targetOrder, widgetKey],
-          hidden: hidden ? [...p.hidden, widgetKey] : p.hidden,
-          minimized: minimized ? [...p.minimized, widgetKey] : p.minimized
-        };
-      }
-      return p;
-    })
-  };
-  if (!hidden) {
-    const allowed = rowsAllowed(target, options);
-    const needed = placeRows(
-      pageWidgets(definitions, moved, targetKey)
-    ).length;
-    if (needed > allowed) {
-      return err(
-        `${describePage(target)} has no room for "${titleOf(widget)}": it would need row ${needed}, and the page allows ${allowed}.`
-      );
-    }
-  }
-  return ok(moved);
-}
-function withoutLockField(definition) {
-  if (definition.locked === void 0) return definition;
-  const copy = { ...definition };
-  delete copy.locked;
-  return copy;
-}
-function uniqueTitle2(taken, title, index) {
-  let base = title.trim().slice(0, MAX_PAGE_TITLE_LENGTH);
-  if (base === "") base = `Page ${index + 1}`;
-  let candidate = base;
-  let n = 1;
-  while (taken.has(normalizedTitle(candidate))) {
-    const suffix = ` (#${n})`;
-    candidate = `${base.slice(0, MAX_PAGE_TITLE_LENGTH - suffix.length)}${suffix}`;
-    n += 1;
-  }
-  taken.add(normalizedTitle(candidate));
-  return candidate;
-}
-function samePages(a, b) {
-  return a.length === b.length && a.every((p, i) => {
-    const q = b[i];
-    return p.key === q.key && p.title === q.title && p.maxRows === q.maxRows && sameKeys(p.order, q.order) && sameKeys(p.hidden, q.hidden) && sameKeys(p.minimized, q.minimized);
-  });
-}
-function normalizeLayout(definitions, layout, options = {}) {
-  const known = pruneLayout(definitions, layout);
-  const enforced = enforceLocks(definitions, known, options);
-  const locked = normalizeSettings(
-    definitions,
-    enforced,
-    options
-  );
-  if (!hasPages(locked)) return locked === layout ? layout : locked;
-  const defs = effectiveDefinitions(
-    options.overrideLocks === true ? definitions.map(withoutLockField) : definitions,
-    locked,
-    options
-  );
-  const taken = /* @__PURE__ */ new Set();
-  const seenKeys = /* @__PURE__ */ new Set();
-  const held = /* @__PURE__ */ new Set();
-  let pages = [];
-  (locked.pages ?? []).forEach((page, index) => {
-    if (seenKeys.has(page.key)) return;
-    seenKeys.add(page.key);
-    const keep = (list) => [
-      ...new Set(list.filter((k) => !held.has(k)))
-    ];
-    const next = {
-      ...page,
-      title: uniqueTitle2(taken, page.title, index),
-      order: keep(page.order),
-      hidden: keep(page.hidden),
-      minimized: keep(page.minimized)
-    };
-    for (const k of [...next.order, ...next.hidden]) held.add(k);
-    pages.push(next);
-  });
-  const work = () => ({ ...locked, pages });
-  const pinned = defs.filter((d) => resolveWidgetLock(d).move);
-  for (const widget of pinned) {
-    const home = homePageKey(work(), widget);
-    const keysHere = (p, list) => p.key !== home && p[list].includes(widget.key);
-    const wasHidden = pages.some((p) => keysHere(p, "hidden"));
-    const wasMinimized = pages.some((p) => keysHere(p, "minimized"));
-    if (!wasHidden && !wasMinimized) continue;
-    pages = pages.map((p) => {
-      let next = p;
-      if (keysHere(p, "hidden")) {
-        next = { ...next, hidden: without(next.hidden, widget.key) };
-      }
-      if (keysHere(p, "minimized")) {
-        next = { ...next, minimized: without(next.minimized, widget.key) };
-      }
-      if (p.key === home) {
-        next = {
-          ...next,
-          hidden: wasHidden && !next.hidden.includes(widget.key) ? [...next.hidden, widget.key] : next.hidden,
-          minimized: wasMinimized && !next.minimized.includes(widget.key) ? [...next.minimized, widget.key] : next.minimized
-        };
-      }
-      return next;
-    });
-  }
-  const placedKeys = /* @__PURE__ */ new Set();
-  for (const p of pages) {
-    for (const k of [...p.order, ...p.hidden]) placedKeys.add(k);
-  }
-  const pinnedKeys = new Set(pinned.map((d) => d.key));
-  const unplaced = defs.filter((d) => !placedKeys.has(d.key) && !pinnedKeys.has(d.key)).map((definition, index) => ({ definition, index })).sort(
-    (a, b) => (a.definition.sortOrder ?? 0) - (b.definition.sortOrder ?? 0) || a.index - b.index
-  ).map(({ definition }) => definition);
-  for (const widget of unplaced) {
-    const home = homePageKey(work(), widget);
-    pages = pages.map(
-      (p) => p.key === home ? { ...p, order: [...p.order, widget.key] } : p
-    );
-  }
-  for (let i = 0; i < pages.length; i += 1) {
-    const page = pages[i];
-    const shown = pageWidgets(defs, work(), page.key);
-    const fits = fitCount(shown, rowsAllowed(page, options));
-    if (fits >= shown.length) continue;
-    const moving = shown.slice(fits).filter((d) => !pinnedKeys.has(d.key)).map((d) => d.key);
-    if (moving.length === 0) continue;
-    const moveSet = new Set(moving);
-    const movedMinimized = page.minimized.filter(
-      (k) => moveSet.has(k)
-    );
-    pages = pages.map(
-      (p) => p.key === page.key ? {
-        ...p,
-        order: p.order.filter((k) => !moveSet.has(k)),
-        minimized: p.minimized.filter((k) => !moveSet.has(k))
-      } : p
-    );
-    let placed = false;
-    for (let j = i + 1; j < pages.length && !placed; j += 1) {
-      const candidate = pages[j];
-      const trial = pages.map(
-        (p) => p.key === candidate.key ? {
-          ...p,
-          order: [...moving, ...p.order],
-          minimized: [...p.minimized, ...movedMinimized]
-        } : p
-      );
-      const items = pageWidgets(
-        defs,
-        { ...locked, pages: trial },
-        candidate.key
-      );
-      if (placeRows(items).length <= rowsAllowed(candidate, options)) {
-        pages = trial;
-        placed = true;
-      }
-    }
-    if (!placed) {
-      const key = nextPageKey(work());
-      const title = uniqueTitle2(
-        new Set(pages.map((p) => normalizedTitle(p.title))),
-        `Page ${pages.length + 1}`,
-        pages.length
-      );
-      pages = [
-        ...pages,
-        { key, title, order: moving, hidden: [], minimized: movedMinimized }
-      ];
-    }
-  }
-  const result = work();
-  return samePages(layout.pages ?? [], pages) && sameKeys(layout.order, result.order) && locked.settings === layout.settings ? layout : result;
-}
-
 // src/core/scale.ts
 function niceStep(value) {
   if (!(value > 0) || !Number.isFinite(value)) return 1;
@@ -4214,6 +4520,7 @@ exports.MAX_DETAIL_PAGE_SIZE = MAX_DETAIL_PAGE_SIZE;
 exports.MAX_GRAPH_SERIES = MAX_GRAPH_SERIES;
 exports.MAX_PAGE_ROWS = MAX_PAGE_ROWS;
 exports.MAX_PAGE_TITLE_LENGTH = MAX_PAGE_TITLE_LENGTH;
+exports.MAX_PARSED_CLONES = MAX_PARSED_CLONES;
 exports.MAX_PARSED_PAGES = MAX_PARSED_PAGES;
 exports.MAX_PARSED_SETTINGS = MAX_PARSED_SETTINGS;
 exports.MAX_REPORTED_PROBLEMS = MAX_REPORTED_PROBLEMS;
@@ -4239,7 +4546,10 @@ exports.applyView = applyView;
 exports.assignPages = assignPages;
 exports.baseColumnSpan = baseColumnSpan;
 exports.cacheKeyFor = cacheKeyFor;
+exports.canDuplicate = canDuplicate;
+exports.cleanClones = cleanClones;
 exports.clearWidgetSettings = clearWidgetSettings;
+exports.cloneNumber = cloneNumber;
 exports.coerceOptionValue = coerceOptionValue;
 exports.convertView = convertView;
 exports.createLayoutPersistence = createLayoutPersistence;
@@ -4248,8 +4558,10 @@ exports.createWidgetLoader = createWidgetLoader;
 exports.defaultDetailQuery = defaultDetailQuery;
 exports.defaultOptionValue = defaultOptionValue;
 exports.defineWidget = defineWidget;
+exports.deleteClone = deleteClone;
 exports.deriveDetailData = deriveDetailData;
 exports.describeUnknownError = describeUnknownError;
+exports.duplicateWidget = duplicateWidget;
 exports.effectiveDefinitions = effectiveDefinitions;
 exports.effectiveViewKey = effectiveViewKey;
 exports.emptyTextFor = emptyTextFor;
@@ -4279,6 +4591,7 @@ exports.isHidden = isHidden;
 exports.isIsoInterval = isIsoInterval;
 exports.isMinimized = isMinimized;
 exports.isOptionsLocked = isOptionsLocked;
+exports.isProviderView = isProviderView;
 exports.isSafeHref = isSafeHref;
 exports.isSafeImageUrl = isSafeImageUrl;
 exports.isTitleInUse = isTitleInUse;
@@ -4290,6 +4603,8 @@ exports.itemWidth = itemWidth;
 exports.kindLabel = kindLabel;
 exports.kpiDelta = kpiDelta;
 exports.labelStride = labelStride;
+exports.loadViewKey = loadViewKey;
+exports.loadViewKind = loadViewKind;
 exports.loadingWidgets = loadingWidgets;
 exports.memoryAdapter = memoryAdapter;
 exports.minimizeWidget = minimizeWidget;
@@ -4299,6 +4614,7 @@ exports.moveWidgetBy = moveWidgetBy;
 exports.moveWidgetDown = moveWidgetDown;
 exports.moveWidgetToPage = moveWidgetToPage;
 exports.moveWidgetUp = moveWidgetUp;
+exports.nextCloneKey = nextCloneKey;
 exports.nextPageKey = nextPageKey;
 exports.niceDomain = niceDomain;
 exports.niceStep = niceStep;
@@ -4314,6 +4630,7 @@ exports.pageList = pageList;
 exports.pageOf = pageOf;
 exports.pageRoom = pageRoom;
 exports.pageWidgets = pageWidgets;
+exports.parseClones = parseClones;
 exports.parseDetailQuery = parseDetailQuery;
 exports.parseLayout = parseLayout;
 exports.parseSettings = parseSettings;
@@ -4337,6 +4654,7 @@ exports.resolveWidgetUnapplied = resolveWidgetUnapplied;
 exports.resolveWidgets = resolveWidgets;
 exports.restoreWidget = restoreWidget;
 exports.sameOptionValues = sameOptionValues;
+exports.serializeClones = serializeClones;
 exports.serializeDetailQuery = serializeDetailQuery;
 exports.serializeLayout = serializeLayout;
 exports.serializeSettings = serializeSettings;
@@ -4345,6 +4663,7 @@ exports.shareOf = shareOf;
 exports.showWidget = showWidget;
 exports.sortDefinitions = sortDefinitions;
 exports.sortFromOptions = sortFromOptions;
+exports.suggestedViewTitle = suggestedViewTitle;
 exports.tableDetailData = tableDetailData;
 exports.toggleHidden = toggleHidden;
 exports.toggleMinimized = toggleMinimized;
@@ -4357,12 +4676,14 @@ exports.validateWidgetDefinition = validateWidgetDefinition;
 exports.viewChoices = viewChoices;
 exports.viewKind = viewKind;
 exports.viewNote = viewNote;
+exports.viewValuesFromLayout = viewValuesFromLayout;
 exports.visibleWidgets = visibleWidgets;
 exports.widgetOptionValues = widgetOptionValues;
 exports.widgetsFor = widgetsFor;
 exports.widthForSize = widthForSize;
 exports.widthRange = widthRange;
 exports.widthShareLabel = widthShareLabel;
+exports.withClones = withClones;
 exports.withEncoding = withEncoding;
 exports.withFallback = withFallback;
 exports.withLogging = withLogging;