@richardmcquiston01/dashboard-widgets-toolkit 0.9.0 → 0.11.0

package/dist/core.cjs

@@ -634,21 +634,44 @@ function fillColumnSpans(items, columns, largeSpan = 2) {
 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) => {
-        spans.set(item.key, span + share + (index < remainder ? 1 : 0));
+        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;
   }
@@ -659,10 +682,13 @@ function placeAndFill(items, columns, spanOf) {
     used += span;
   }
   closeRow();
-  return spans;
+  return { spans, rows };
 }
 
 // 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([]),
@@ -692,16 +718,66 @@ function parseLayout(raw) {
   const order = uniqueStrings(record["order"]);
   const hidden = uniqueStrings(record["hidden"]);
   const minimized = uniqueStrings(record["minimized"]);
+  const pages = parsePages(record["pages"]);
+  if (pages.length > 0) {
+    return {
+      order: EMPTY_LAYOUT.order,
+      hidden: EMPTY_LAYOUT.hidden,
+      minimized: EMPTY_LAYOUT.minimized,
+      pages
+    };
+  }
   if (order.length === 0 && hidden.length === 0 && minimized.length === 0) {
     return EMPTY_LAYOUT;
   }
   return { order, hidden, minimized };
 }
+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;
+}
 function serializeLayout(layout) {
   return JSON.stringify({
     order: [...layout.order],
     hidden: [...layout.hidden],
-    minimized: [...layout.minimized]
+    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 }
+      }))
+    }
   });
 }
 function bySortOrder(items) {
@@ -824,13 +900,28 @@ function toggleMinimized(layout, key) {
 }
 function pruneLayout(definitions, layout) {
   const known = new Set(definitions.map((d) => d.key));
-  const keep = (keys) => keys.filter((k) => known.has(k));
-  const next = {
-    order: keep(layout.order),
-    hidden: keep(layout.hidden),
-    minimized: keep(layout.minimized)
+  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 }
   };
-  return next.order.length === layout.order.length && next.hidden.length === layout.hidden.length && next.minimized.length === layout.minimized.length ? layout : next;
 }
 function enforceLocks(definitions, layout, options = {}) {
   if (options.overrideLocks === true) return layout;
@@ -843,11 +934,289 @@ function enforceLocks(definitions, layout, options = {}) {
     if (lock.hide) noHide.add(definition.key);
     if (lock.minimize) noMinimize.add(definition.key);
   }
-  const without = (keys, drop) => keys.some((key) => drop.has(key)) ? keys.filter((key) => !drop.has(key)) : keys;
-  const order = without(layout.order, noMove);
-  const hidden = without(layout.hidden, noHide);
-  const minimized = without(layout.minimized, noMinimize);
-  return order === layout.order && hidden === layout.hidden && minimized === layout.minimized ? layout : { ...layout, order, hidden, minimized };
+  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/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 isClientApplied(option) {
+  return (option.type === "sort" || option.type === "columns") && option.apply === "client";
+}
+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 toIso(epochMs) {
+  return new Date(epochMs).toISOString().slice(0, 10);
+}
+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 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 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];
+    }
+  }
+}
+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;
+  }
+}
+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 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 sameOptionValues(a, b) {
+  const keys = Object.keys({ ...a, ...b });
+  return keys.every((key) => sameValue(a[key], b[key]));
+}
+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 tableColumnIndex(key) {
+  const match = /^c(\d+)$/.exec(key);
+  return match === null ? void 0 : Number(match[1]);
+}
+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"
+  );
+  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;
 }
 
 // src/core/validate.ts
@@ -1138,6 +1507,284 @@ function checkLockedOption(locked, problems) {
   optionalBoolean(locked, "hide", "locked", problems);
   optionalBoolean(locked, "minimize", "locked", problems);
 }
+function checkOptionColumns(option, path, kind, problems) {
+  const columns = option["columns"];
+  if (!Array.isArray(columns) || columns.length === 0) {
+    problems.push(
+      `${join(path, "columns")} must be a non-empty array of { key, label }, got ${describeType2(columns)}.`
+    );
+    return [];
+  }
+  const keys = [];
+  columns.forEach((entry, index) => {
+    const entryPath = `${path}.columns[${index}]`;
+    if (!isRecord(entry)) {
+      problems.push(
+        `${entryPath} must be an object, got ${describeType2(entry)}.`
+      );
+      return;
+    }
+    requireString(entry, "label", entryPath, problems);
+    const key = entry["key"];
+    if (typeof key !== "string") {
+      problems.push(
+        `${entryPath}.key must be a string, got ${describeType2(key)}.`
+      );
+    } else if (typeof kind === "string" && !isColumnKeyFor(kind, key)) {
+      problems.push(
+        `${entryPath}.key "${key}" is not a column of a ${kind} widget (${kind === "TABLE" ? '"c0", "c1", ...' : '"label" or "value"'}).`
+      );
+    } else if (keys.includes(key)) {
+      problems.push(`${entryPath}.key "${key}" is used twice.`);
+    } else {
+      keys.push(key);
+    }
+  });
+  return keys;
+}
+function checkOption(option, path, kind, seenKeys, seenTypes, problems) {
+  if (!isRecord(option)) {
+    problems.push(`${path} must be an object, got ${describeType2(option)}.`);
+    return;
+  }
+  const type = option["type"];
+  if (typeof type !== "string" || !WIDGET_OPTION_TYPES.includes(type)) {
+    requireOneOf(option, "type", WIDGET_OPTION_TYPES, path, problems);
+    return;
+  }
+  const key = option["key"];
+  if (typeof key !== "string" || !OPTION_KEY_PATTERN.test(key)) {
+    problems.push(
+      `${path}.key must be letters, digits, "_" or "-", starting with a letter (40 characters at most), got ${typeof key === "string" ? JSON.stringify(key) : describeType2(key)}.`
+    );
+  } else if (seenKeys.has(key)) {
+    problems.push(`${path}.key "${key}" is used by another option.`);
+  } else {
+    seenKeys.add(key);
+  }
+  requireString(option, "label", path, problems);
+  const fallback = option["default"];
+  switch (type) {
+    case "choice": {
+      const choices = option["choices"];
+      const values = [];
+      if (!Array.isArray(choices) || choices.length === 0) {
+        problems.push(
+          `${path}.choices must be a non-empty array of { value, label }, got ${describeType2(choices)}.`
+        );
+      } else {
+        choices.forEach((choice, index) => {
+          const choicePath = `${path}.choices[${index}]`;
+          if (!isRecord(choice)) {
+            problems.push(
+              `${choicePath} must be an object, got ${describeType2(choice)}.`
+            );
+            return;
+          }
+          requireString(choice, "label", choicePath, problems);
+          const value = choice["value"];
+          if (typeof value !== "string" || value === "") {
+            problems.push(
+              `${choicePath}.value must be a non-empty string, got ${describeType2(value)}.`
+            );
+          } else if (values.includes(value)) {
+            problems.push(`${choicePath}.value "${value}" is used twice.`);
+          } else {
+            values.push(value);
+          }
+        });
+      }
+      if (values.length > 0)
+        requireOneOf(option, "default", values, path, problems);
+      break;
+    }
+    case "number": {
+      const { min, max, step } = option;
+      requireNumber(option, "min", path, problems);
+      requireNumber(option, "max", path, problems);
+      if (typeof min === "number" && typeof max === "number" && min > max) {
+        problems.push(
+          `${path}.min (${min}) must not be more than max (${max}).`
+        );
+      }
+      if (step !== void 0 && !(typeof step === "number" && Number.isFinite(step) && step > 0)) {
+        problems.push(
+          `${path}.step must be a number above 0, got ${describeType2(step)}.`
+        );
+      }
+      if (typeof fallback !== "number" || !Number.isFinite(fallback)) {
+        problems.push(
+          `${path}.default must be a finite number, got ${describeType2(fallback)}.`
+        );
+      } else if (typeof min === "number" && typeof max === "number" && (fallback < min || fallback > max)) {
+        problems.push(
+          `${path}.default (${fallback}) must be between min (${min}) and max (${max}).`
+        );
+      } else if (typeof min === "number" && typeof step === "number" && step > 0 && Math.abs(
+        (fallback - min) / step - Math.round((fallback - min) / step)
+      ) > 1e-9) {
+        problems.push(
+          `${path}.default (${fallback}) must be ${min} plus a whole number of steps of ${step}.`
+        );
+      }
+      break;
+    }
+    case "boolean":
+      if (typeof fallback !== "boolean") {
+        problems.push(
+          `${path}.default must be a boolean, got ${describeType2(fallback)}.`
+        );
+      }
+      break;
+    case "text": {
+      const maxLength = option["maxLength"];
+      if (typeof maxLength !== "number" || !Number.isInteger(maxLength) || maxLength < 1 || maxLength > MAX_TEXT_OPTION_LENGTH) {
+        problems.push(
+          `${path}.maxLength must be a whole number from 1 to ${MAX_TEXT_OPTION_LENGTH}, got ${typeof maxLength === "number" ? maxLength : describeType2(maxLength)}.`
+        );
+      }
+      if (typeof fallback !== "string") {
+        problems.push(
+          `${path}.default must be a string, got ${describeType2(fallback)}.`
+        );
+      } else if (typeof maxLength === "number" && fallback.length > maxLength) {
+        problems.push(
+          `${path}.default is ${fallback.length} characters; maxLength is ${maxLength}.`
+        );
+      }
+      break;
+    }
+    case "dateRange": {
+      const presets = option["presets"];
+      const offered = [];
+      if (presets !== void 0) {
+        if (!Array.isArray(presets) || presets.length === 0) {
+          problems.push(
+            `${path}.presets must be a non-empty array of { value, label }, got ${describeType2(presets)}.`
+          );
+        } else {
+          presets.forEach((preset, index) => {
+            const presetPath = `${path}.presets[${index}]`;
+            if (!isRecord(preset)) {
+              problems.push(
+                `${presetPath} must be an object, got ${describeType2(preset)}.`
+              );
+              return;
+            }
+            requireString(preset, "label", presetPath, problems);
+            requireOneOf(
+              preset,
+              "value",
+              DATE_RANGE_PRESETS,
+              presetPath,
+              problems
+            );
+            if (typeof preset["value"] === "string")
+              offered.push(preset["value"]);
+          });
+        }
+      }
+      const allowed = offered.length > 0 ? offered : DATE_RANGE_PRESETS;
+      if (typeof fallback !== "string" || !(allowed.includes(fallback) || isIsoInterval(fallback))) {
+        problems.push(
+          `${path}.default must be one of ${allowed.map((p) => `"${p}"`).join(", ")} or an interval like "2026-01-01/2026-01-31", got ${typeof fallback === "string" ? JSON.stringify(fallback) : describeType2(fallback)}.`
+        );
+      }
+      break;
+    }
+    case "color":
+      if (typeof fallback !== "string" || !/^#[0-9a-fA-F]{6}$/.test(fallback)) {
+        problems.push(
+          `${path}.default must be a color like "#1c5cab", got ${typeof fallback === "string" ? JSON.stringify(fallback) : describeType2(fallback)}.`
+        );
+      }
+      break;
+    case "sort":
+    case "columns": {
+      const supported = type === "sort" ? kind === "TABLE" || kind === "BAR_LIST" : kind === "TABLE";
+      if (!supported && typeof kind === "string") {
+        problems.push(
+          `${path} is a ${type} option, which only applies to ${type === "sort" ? "TABLE and BAR_LIST" : "TABLE"} widgets, but kind is "${kind}".`
+        );
+      }
+      if (seenTypes.has(type)) {
+        problems.push(
+          `${path} is a second ${type} option; a widget has at most one.`
+        );
+      }
+      seenTypes.add(type);
+      const columnKeys = checkOptionColumns(
+        option,
+        path,
+        supported ? kind : void 0,
+        problems
+      );
+      if (option["apply"] !== void 0) {
+        requireOneOf(option, "apply", ["provider", "client"], path, problems);
+      }
+      if (type === "sort") {
+        if (fallback !== void 0) {
+          const sort = typeof fallback === "string" ? parseSortValue(fallback) : void 0;
+          if (sort === void 0) {
+            problems.push(
+              `${path}.default must look like "c1:desc" ("column:asc" or "column:desc"), got ${typeof fallback === "string" ? JSON.stringify(fallback) : describeType2(fallback)}.`
+            );
+          } else if (columnKeys.length > 0 && !columnKeys.includes(sort.column)) {
+            requireOneOf(
+              { default: sort.column },
+              "default",
+              columnKeys,
+              path,
+              problems
+            );
+          }
+        }
+      } else if (!Array.isArray(fallback) || fallback.length === 0 || fallback.some((k) => typeof k !== "string")) {
+        problems.push(
+          `${path}.default must be a non-empty array of column keys, got ${describeType2(fallback)}.`
+        );
+      } else {
+        const shown = /* @__PURE__ */ new Set();
+        for (const columnKey of fallback) {
+          if (columnKeys.length > 0 && !columnKeys.includes(columnKey)) {
+            problems.push(
+              `${path}.default has "${columnKey}", which is not one of the columns (${columnKeys.map((c) => `"${c}"`).join(", ")}).`
+            );
+          } else if (shown.has(columnKey)) {
+            problems.push(`${path}.default lists "${columnKey}" twice.`);
+          }
+          shown.add(columnKey);
+        }
+      }
+      break;
+    }
+  }
+}
+function checkOptions(options, kind, problems) {
+  if (options === void 0) return;
+  if (!Array.isArray(options)) {
+    problems.push(`options must be an array, got ${describeType2(options)}.`);
+    return;
+  }
+  if (options.length > MAX_WIDGET_OPTIONS) {
+    problems.push(
+      `options lists ${options.length} options; the most a widget may declare is ${MAX_WIDGET_OPTIONS}.`
+    );
+    return;
+  }
+  const seenKeys = /* @__PURE__ */ new Set();
+  const seenTypes = /* @__PURE__ */ new Set();
+  options.forEach((option, index) => {
+    checkOption(
+      option,
+      `options[${index}]`,
+      kind,
+      seenKeys,
+      seenTypes,
+      problems
+    );
+  });
+}
 function formatProblems(prefix, problems) {
   const shown = problems.slice(0, MAX_REPORTED_PROBLEMS);
   const more = problems.length - shown.length;
@@ -1212,6 +1859,14 @@ function validateWidgetDefinition(value) {
   checkDetailOption(value["detail"], problems);
   checkTableControlsOption(value["tableControls"], value["kind"], problems);
   checkLockedOption(value["locked"], problems);
+  checkOptions(value["options"], value["kind"], problems);
+  if (value["page"] !== void 0) {
+    if (typeof value["page"] !== "string" || value["page"].trim() === "") {
+      problems.push(
+        `page must be a non-empty page key or title, got ${describeType2(value["page"])}.`
+      );
+    }
+  }
   if (value["fill"] !== void 0) {
     requireOneOf(value, "fill", WIDGET_FILLS, "", problems);
   }
@@ -1248,12 +1903,40 @@ function failedWidget(definition, error) {
 function loadingWidgets(definitions) {
   return definitions.map((definition) => ({ definition, status: "loading" }));
 }
-function cacheKeyFor(definition, options) {
-  return options.cacheKey === void 0 ? definition.key : options.cacheKey(definition);
+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)}`;
+}
+function optionValuesFor(definition, options) {
+  return resolveOptionValues(
+    definition,
+    options.optionValues?.[definition.key],
+    options
+  );
+}
+function finalizeWidget(widget, values) {
+  if (Object.keys(values).length === 0) return widget;
+  if (widget.status === "ok") {
+    const data = applyClientOptions(
+      widget.definition,
+      widget.data,
+      values
+    );
+    return { ...widget, data, options: values };
+  }
+  return { ...widget, options: values };
 }
 var LoadInterruption = class extends Error {
 };
 async function resolveWidget(definition, provider, context, options = {}) {
+  const values = optionValuesFor(definition, options);
+  return finalizeWidget(
+    await resolveWidgetUnapplied(definition, provider, context, options),
+    values
+  );
+}
+async function resolveWidgetUnapplied(definition, provider, context, options = {}) {
+  const values = optionValuesFor(definition, options);
   const quotedKey = JSON.stringify(definition.key);
   if (provider === void 0) {
     return failedWidget(
@@ -1288,7 +1971,10 @@ async function resolveWidget(definition, provider, context, options = {}) {
     payload = await Promise.race([
       Promise.resolve().then(() => {
         if (controller.signal.aborted) throw new LoadInterruption();
-        return provider(context, definition, { signal: controller.signal });
+        return provider(context, definition, {
+          signal: controller.signal,
+          options: values
+        });
       }),
       interrupted
     ]);
@@ -1312,7 +1998,7 @@ async function resolveWidget(definition, provider, context, options = {}) {
   const storedAt = Date.now();
   if (options.cache !== void 0) {
     try {
-      await options.cache.set(cacheKeyFor(definition, options), {
+      await options.cache.set(cacheKeyFor(definition, options, values), {
         payload: resolved.data,
         storedAt
       });
@@ -1342,7 +2028,17 @@ async function resolveWidgets(definitions, providers, context, options = {}) {
 
 // src/core/loader.ts
 function createWidgetLoader(options) {
-  const { definitions, providers, context, ...resolveOptions } = options;
+  const { definitions, providers, context, ...baseOptions } = options;
+  const chosen = new Map(
+    Object.entries(baseOptions.optionValues ?? {}).flatMap(
+      ([key, values]) => values === void 0 ? [] : [[key, values]]
+    )
+  );
+  const resolveOptions = baseOptions;
+  function currentOptions() {
+    return { ...resolveOptions, optionValues: Object.fromEntries(chosen) };
+  }
+  const unapplied = /* @__PURE__ */ new Map();
   const visible = widgetsFor(definitions, context.roles);
   let snapshot = loadingWidgets(visible);
   const listeners = /* @__PURE__ */ new Set();
@@ -1383,19 +2079,19 @@ function createWidgetLoader(options) {
     const controller = new AbortController();
     inFlight.set(key, controller);
     const isCurrent = () => !disposed && generations.get(key) === generation;
-    if (readCache && resolveOptions.cache !== void 0) {
+    const runOptions = currentOptions();
+    const values = optionValuesFor(definition, runOptions);
+    if (readCache && runOptions.cache !== void 0) {
       try {
-        const entry = await resolveOptions.cache.get(
-          cacheKeyFor(definition, resolveOptions)
+        const entry = await runOptions.cache.get(
+          cacheKeyFor(definition, runOptions, values)
         );
         if (entry !== void 0 && isCurrent()) {
-          const cached = resolvePayload(
-            definition,
-            entry.payload,
-            resolveOptions
-          );
+          const cached = resolvePayload(definition, entry.payload, runOptions);
           if (cached.status === "ok") {
-            replace(key, { ...cached, updatedAt: entry.storedAt, stale: true });
+            const stale = { ...cached, updatedAt: entry.storedAt, stale: true };
+            unapplied.set(key, stale);
+            replace(key, finalizeWidget(stale, values));
           }
         }
       } catch {
@@ -1403,13 +2099,15 @@ function createWidgetLoader(options) {
     }
     if (!isCurrent()) return;
     const provider = Object.prototype.hasOwnProperty.call(providers, key) ? providers[key] : void 0;
-    const result = await resolveWidget(definition, provider, context, {
-      ...resolveOptions,
+    const result = await resolveWidgetUnapplied(definition, provider, context, {
+      ...runOptions,
       signal: controller.signal
     });
     if (!isCurrent()) return;
     inFlight.delete(key);
-    replace(key, result);
+    if (result.status === "ok") unapplied.set(key, result);
+    else unapplied.delete(key);
+    replace(key, finalizeWidget(result, values));
   }
   function start(definition, readCache) {
     started.add(definition.key);
@@ -1444,6 +2142,29 @@ function createWidgetLoader(options) {
       start(definition, false);
     }
   }
+  function setOptions(key, values) {
+    if (disposed) return;
+    const definition = definitionFor(key);
+    if (definition === void 0) return;
+    const before = optionValuesFor(definition, currentOptions());
+    chosen.set(key, { ...values });
+    const runOptions = currentOptions();
+    const after = optionValuesFor(definition, runOptions);
+    if (sameOptionValues(before, after) || !started.has(key)) return;
+    const kept = unapplied.get(key);
+    if (kept !== void 0 && optionsCacheSuffix(definition, before, runOptions) === optionsCacheSuffix(definition, after, runOptions)) {
+      replace(key, finalizeWidget(kept, after));
+      return;
+    }
+    const current = snapshot.find(
+      (widget) => widget.definition.key === key
+    );
+    if (current?.status === "ok") replace(key, { ...current, stale: true });
+    else if (current?.status === "error") {
+      replace(key, { definition, status: "loading" });
+    }
+    start(definition, true);
+  }
   function dispose() {
     disposed = true;
     abortAll(new Error("The widget loader was disposed."));
@@ -1461,10 +2182,480 @@ function createWidgetLoader(options) {
     load,
     loadAll,
     refresh,
+    setOptions,
     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 uniqueTitle(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 locked = enforceLocks(definitions, known, options);
+  if (!hasPages(locked)) return locked === layout ? layout : locked;
+  const defs = options.overrideLocks === true ? definitions.map(withoutLockField) : definitions;
+  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: uniqueTitle(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 = uniqueTitle(
+        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) ? layout : result;
+}
+
 // src/core/scale.ts
 function niceStep(value) {
   if (!(value > 0) || !Number.isFinite(value)) return 1;
@@ -1495,26 +2686,594 @@ function labelStride(count, maxLabels = 6) {
   return Math.max(1, Math.ceil(count / Math.max(1, maxLabels)));
 }
 
+// src/core/storage.ts
+function failure(code, error) {
+  return { ok: false, code, error };
+}
+function utf8Length(text) {
+  let bytes = 0;
+  for (const char of text) {
+    const point = char.codePointAt(0) ?? 0;
+    bytes += point < 128 ? 1 : point < 2048 ? 2 : point < 65536 ? 3 : 4;
+  }
+  return bytes;
+}
+function memoryAdapter(initial = {}) {
+  const entries = /* @__PURE__ */ new Map();
+  const listeners = /* @__PURE__ */ new Map();
+  let counter = 0;
+  for (const [key, value] of Object.entries(initial)) {
+    counter += 1;
+    entries.set(key, { value, revision: String(counter) });
+  }
+  const notify = (key, stored) => {
+    for (const listener of listeners.get(key) ?? []) listener(stored);
+  };
+  return {
+    get: (key) => Promise.resolve({ ok: true, value: entries.get(key) ?? null }),
+    set: (key, value, options) => {
+      const current = entries.get(key);
+      if (options.ifRevision !== void 0 && (current?.revision ?? void 0) !== options.ifRevision) {
+        return Promise.resolve(
+          failure(
+            "conflict",
+            `Could not save "${key}": it changed since revision ${options.ifRevision} (now ${current?.revision ?? "none"}).`
+          )
+        );
+      }
+      counter += 1;
+      const stored = { value, revision: String(counter) };
+      entries.set(key, stored);
+      notify(key, stored);
+      return Promise.resolve({ ok: true, value: stored });
+    },
+    remove: (key) => {
+      entries.delete(key);
+      notify(key, null);
+      return Promise.resolve({ ok: true, value: null });
+    },
+    subscribe: (key, onChange) => {
+      const set = listeners.get(key) ?? /* @__PURE__ */ new Set();
+      set.add(onChange);
+      listeners.set(key, set);
+      return () => {
+        set.delete(onChange);
+      };
+    }
+  };
+}
+function withPrefix(adapter, prefix) {
+  return {
+    get: (key, options) => adapter.get(prefix + key, options),
+    set: (key, value, options) => adapter.set(prefix + key, value, options),
+    ...adapter.remove === void 0 ? {} : {
+      remove: (key, options) => adapter.remove?.(prefix + key, options) ?? Promise.resolve(failure("invalid", "remove is not supported."))
+    },
+    ...adapter.subscribe === void 0 ? {} : {
+      subscribe: (key, onChange) => adapter.subscribe?.(prefix + key, onChange) ?? (() => void 0)
+    }
+  };
+}
+function withFallback(primary, secondary) {
+  return {
+    async get(key, options) {
+      const first = await primary.get(key, options);
+      if (first.ok && first.value !== null) return first;
+      const second = await secondary.get(key, options);
+      if (second.ok && second.value !== null) return second;
+      return first;
+    },
+    async set(key, value, options) {
+      const first = await primary.set(key, value, options);
+      if (!first.ok && first.code === "conflict") return first;
+      const second = await secondary.set(key, value, {
+        signal: options.signal
+      });
+      if (first.ok) return first;
+      return second.ok ? second : first;
+    },
+    async remove(key, options) {
+      const first = await primary.remove?.(key, options) ?? {
+        ok: true,
+        value: null
+      };
+      await secondary.remove?.(key, options);
+      return first;
+    },
+    subscribe: (key, onChange) => {
+      const stops = [primary, secondary].flatMap((adapter) => {
+        const stop = adapter.subscribe?.(
+          key,
+          onChange
+        );
+        return stop === void 0 ? [] : [stop];
+      });
+      return () => {
+        for (const stop of stops) stop();
+      };
+    }
+  };
+}
+function withReadCache(adapter) {
+  const cache = /* @__PURE__ */ new Map();
+  return {
+    async get(key, options) {
+      const cached = cache.get(key);
+      if (cached !== void 0) return { ok: true, value: cached };
+      const result = await adapter.get(key, options);
+      if (result.ok) cache.set(key, result.value);
+      return result;
+    },
+    async set(key, value, options) {
+      const result = await adapter.set(key, value, options);
+      if (result.ok) cache.set(key, result.value);
+      else cache.delete(key);
+      return result;
+    },
+    async remove(key, options) {
+      cache.delete(key);
+      return await adapter.remove?.(key, options) ?? failure(
+        "invalid",
+        `Could not remove "${key}": remove is not supported.`
+      );
+    },
+    ...adapter.subscribe === void 0 ? {} : {
+      subscribe: (key, onChange) => adapter.subscribe?.(key, (stored) => {
+        cache.set(key, stored);
+        onChange(stored);
+      }) ?? (() => void 0)
+    }
+  };
+}
+function readOnly(adapter) {
+  return {
+    get: (key, options) => adapter.get(key, options),
+    set: (key) => Promise.resolve(
+      failure(
+        "forbidden",
+        `Could not save "${key}": this store is read-only.`
+      )
+    ),
+    remove: (key) => Promise.resolve(
+      failure(
+        "forbidden",
+        `Could not remove "${key}": this store is read-only.`
+      )
+    ),
+    ...adapter.subscribe === void 0 ? {} : { subscribe: adapter.subscribe.bind(adapter) }
+  };
+}
+function withRetry(adapter, options) {
+  const attempts = Math.max(1, Math.floor(options.attempts ?? 3));
+  const baseDelay = options.delayMs ?? 200;
+  const retrying = async (signal, run) => {
+    let result = await run();
+    for (let attempt = 1; attempt < attempts && !result.ok && result.code === "unavailable" && !signal.aborted; attempt += 1) {
+      await options.sleep(baseDelay * 2 ** (attempt - 1), signal);
+      result = await run();
+    }
+    return result;
+  };
+  return {
+    get: (key, o) => retrying(o.signal, () => adapter.get(key, o)),
+    set: (key, value, o) => retrying(o.signal, () => adapter.set(key, value, o)),
+    ...adapter.remove === void 0 ? {} : {
+      remove: (key, o) => retrying(
+        o.signal,
+        () => adapter.remove?.(key, o) ?? Promise.resolve(failure("invalid", "remove is not supported."))
+      )
+    },
+    ...adapter.subscribe === void 0 ? {} : { subscribe: adapter.subscribe.bind(adapter) }
+  };
+}
+function withEncoding(adapter, codec) {
+  const decodeStored = async (key, stored) => {
+    try {
+      const value = await codec.decode(stored.value);
+      return {
+        ok: true,
+        value: stored.revision === void 0 ? { value } : { value, revision: stored.revision }
+      };
+    } catch (cause) {
+      return failure(
+        "corrupt",
+        `Could not decode the value stored at "${key}": ${describeUnknownError(cause)}`
+      );
+    }
+  };
+  return {
+    async get(key, options) {
+      const result = await adapter.get(key, options);
+      if (!result.ok || result.value === null) return result;
+      return decodeStored(key, result.value);
+    },
+    async set(key, value, options) {
+      let encoded;
+      try {
+        encoded = await codec.encode(value);
+      } catch (cause) {
+        return failure(
+          "invalid",
+          `Could not encode the value for "${key}": ${describeUnknownError(cause)}`
+        );
+      }
+      const result = await adapter.set(key, encoded, options);
+      if (!result.ok) return result;
+      return result.value.revision === void 0 ? { ok: true, value: { value } } : { ok: true, value: { value, revision: result.value.revision } };
+    },
+    ...adapter.remove === void 0 ? {} : { remove: adapter.remove.bind(adapter) },
+    ...adapter.subscribe === void 0 ? {} : {
+      subscribe: (key, onChange) => adapter.subscribe?.(key, (stored) => {
+        if (stored === null) {
+          onChange(null);
+          return;
+        }
+        void decodeStored(key, stored).then((decoded) => {
+          if (decoded.ok) onChange(decoded.value);
+        });
+      }) ?? (() => void 0)
+    }
+  };
+}
+function withLogging(adapter, log) {
+  const report = (operation, key, result) => {
+    try {
+      log(
+        result.ok ? { operation, key, ok: true } : { operation, key, ok: false, code: result.code }
+      );
+    } catch {
+    }
+    return result;
+  };
+  return {
+    get: async (key, o) => report("get", key, await adapter.get(key, o)),
+    set: async (key, value, o) => report("set", key, await adapter.set(key, value, o)),
+    ...adapter.remove === void 0 ? {} : {
+      remove: async (key, o) => report(
+        "remove",
+        key,
+        await adapter.remove?.(key, o) ?? failure("invalid", "remove is not supported.")
+      )
+    },
+    ...adapter.subscribe === void 0 ? {} : { subscribe: adapter.subscribe.bind(adapter) }
+  };
+}
+var LAYOUT_ENVELOPE_VERSION = 1;
+var DEFAULT_MAX_LAYOUT_BYTES = 64 * 1024;
+function keyPart(text) {
+  return encodeURIComponent(text);
+}
+function readEnvelope(key, stored) {
+  let parsed;
+  try {
+    parsed = JSON.parse(stored.value);
+  } catch (cause) {
+    return failure(
+      "corrupt",
+      `The layout stored at "${key}" is not valid JSON: ${describeUnknownError(cause)}`
+    );
+  }
+  if (typeof parsed !== "object" || parsed === null || Array.isArray(parsed)) {
+    return failure(
+      "corrupt",
+      `The layout stored at "${key}" is not an object.`
+    );
+  }
+  const record = parsed;
+  const version = record["v"];
+  if (version === void 0) {
+    return { ok: true, value: { layout: parseLayout(parsed) } };
+  }
+  if (typeof version !== "number" || !Number.isInteger(version)) {
+    return failure(
+      "corrupt",
+      `The layout stored at "${key}" has an invalid version ${JSON.stringify(version)}.`
+    );
+  }
+  if (version > LAYOUT_ENVELOPE_VERSION) {
+    return failure(
+      "invalid",
+      `The layout stored at "${key}" is version ${version}, newer than this toolkit reads (${LAYOUT_ENVELOPE_VERSION}). Update the package.`
+    );
+  }
+  const envelope = record;
+  return {
+    ok: true,
+    value: {
+      layout: parseLayout(envelope.layout),
+      ...typeof envelope.savedAt === "string" ? { savedAt: envelope.savedAt } : {}
+    }
+  };
+}
+function createLayoutPersistence(adapter, options = {}) {
+  const maxBytes = options.maxBytes ?? DEFAULT_MAX_LAYOUT_BYTES;
+  const policy = options.onConflict ?? "ask";
+  const fallbackSignal = new AbortController().signal;
+  const signal = options.signal ?? fallbackSignal;
+  const now = options.now ?? Date.now;
+  const revisions = /* @__PURE__ */ new Map();
+  const lastWritten = /* @__PURE__ */ new Map();
+  const inFlight = /* @__PURE__ */ new Set();
+  const pending = /* @__PURE__ */ new Map();
+  const keyFor = (scope, part = "layout") => `dwt:${keyPart(scope.dashboardKey)}:${keyPart(scope.userKey ?? "_")}:${part}`;
+  const checkScope = (scope) => scope.dashboardKey.trim() === "" ? failure("invalid", "The storage scope needs a non-empty dashboardKey.") : { ok: true, value: null };
+  const encode = (layout, key) => {
+    const envelope = {
+      v: LAYOUT_ENVELOPE_VERSION,
+      savedAt: new Date(now()).toISOString(),
+      layout: JSON.parse(serializeLayout(layout))
+    };
+    const text = JSON.stringify(envelope);
+    const size = utf8Length(text);
+    if (size > maxBytes) {
+      return failure(
+        "invalid",
+        `Could not save "${key}": the layout is ${size} bytes, over the ${maxBytes} byte limit.`
+      );
+    }
+    return { ok: true, value: text };
+  };
+  const guarded = async (key, action, run) => {
+    try {
+      return await run();
+    } catch (cause) {
+      return failure(
+        "unavailable",
+        `Could not ${action} "${key}": the adapter threw ${describeUnknownError(cause)}`
+      );
+    }
+  };
+  const readLayout = async (scope, part) => {
+    const key = keyFor(scope, part);
+    const result = await guarded(
+      key,
+      "load",
+      () => adapter.get(key, { signal })
+    );
+    if (!result.ok) return result;
+    if (result.value === null) {
+      if (part === "layout") revisions.delete(key);
+      return { ok: true, value: { layout: null } };
+    }
+    const read = readEnvelope(key, result.value);
+    if (!read.ok) return read;
+    if (part === "layout" && result.value.revision !== void 0) {
+      revisions.set(key, result.value.revision);
+    }
+    return {
+      ok: true,
+      value: {
+        layout: read.value.layout,
+        ...result.value.revision === void 0 ? {} : { revision: result.value.revision },
+        ...read.value.savedAt === void 0 ? {} : { savedAt: read.value.savedAt }
+      }
+    };
+  };
+  const repair = (loaded, definitions, normalizeOptions) => loaded.layout === null ? loaded : {
+    ...loaded,
+    layout: normalizeLayout(definitions, loaded.layout, normalizeOptions)
+  };
+  const write = async (scope, layout, force) => {
+    const key = keyFor(scope);
+    const text = encode(layout, key);
+    if (!text.ok) return text;
+    const known = revisions.get(key);
+    lastWritten.set(key, text.value);
+    const stored = await guarded(
+      key,
+      "save",
+      () => adapter.set(key, text.value, {
+        signal,
+        ...force || known === void 0 ? {} : { ifRevision: known }
+      })
+    );
+    if (stored.ok) {
+      if (stored.value.revision !== void 0) {
+        revisions.set(key, stored.value.revision);
+      }
+      return {
+        ok: true,
+        value: {
+          outcome: "saved",
+          layout,
+          ...stored.value.revision === void 0 ? {} : { revision: stored.value.revision }
+        }
+      };
+    }
+    if (stored.code !== "conflict") return stored;
+    const theirs = await readLayout(scope, "layout");
+    if (!theirs.ok) return theirs;
+    const theirLayout = theirs.value.layout ?? layout;
+    const theirRevision = theirs.value.revision;
+    const asResult = (outcome) => ({
+      ok: true,
+      value: {
+        outcome,
+        layout: theirLayout,
+        ...theirRevision === void 0 ? {} : { revision: theirRevision }
+      }
+    });
+    if (policy === "overwrite") return write(scope, layout, true);
+    if (policy === "keep-theirs") return asResult("kept-theirs");
+    if (policy === "ask") return asResult("conflict");
+    let merged;
+    try {
+      merged = policy(layout, theirLayout);
+    } catch (cause) {
+      return failure(
+        "invalid",
+        `Could not save "${key}": the conflict merge function threw ${describeUnknownError(cause)}`
+      );
+    }
+    const second = await write(scope, merged, false);
+    if (second.ok && second.value.outcome === "saved") return second;
+    return second.ok ? asResult("conflict") : second;
+  };
+  const drain = async (scope, key, first) => {
+    let job = first;
+    inFlight.add(key);
+    while (job !== void 0) {
+      const current = job;
+      pending.delete(key);
+      const result = await write(
+        scope,
+        current.layout,
+        current.force
+      );
+      for (const waiter of current.waiters) waiter(result);
+      job = pending.get(key);
+    }
+    inFlight.delete(key);
+  };
+  return {
+    keyFor,
+    async load(scope, definitions, normalizeOptions) {
+      const valid = checkScope(scope);
+      if (!valid.ok) return valid;
+      const read = await readLayout(scope, "layout");
+      if (!read.ok) return read;
+      return {
+        ok: true,
+        value: repair(read.value, definitions, normalizeOptions)
+      };
+    },
+    save(scope, layout, saveOptions = {}) {
+      const valid = checkScope(scope);
+      if (!valid.ok) return Promise.resolve(valid);
+      const key = keyFor(scope);
+      const force = saveOptions.force === true;
+      return new Promise((resolve) => {
+        const queued = pending.get(key);
+        if (queued !== void 0) {
+          queued.layout = layout;
+          queued.force = queued.force || force;
+          queued.waiters.push(resolve);
+          return;
+        }
+        const job = { layout, force, waiters: [resolve] };
+        if (inFlight.has(key)) {
+          pending.set(key, job);
+          return;
+        }
+        void drain(scope, key, job);
+      });
+    },
+    async loadBackup(scope) {
+      const valid = checkScope(scope);
+      if (!valid.ok) return valid;
+      const read = await readLayout(scope, "backup");
+      return read.ok ? { ok: true, value: read.value.layout } : read;
+    },
+    async saveBackup(scope, layout) {
+      const valid = checkScope(scope);
+      if (!valid.ok) return valid;
+      const key = keyFor(scope, "backup");
+      const text = encode(layout, key);
+      if (!text.ok) return text;
+      const stored = await guarded(
+        key,
+        "save",
+        () => adapter.set(key, text.value, { signal })
+      );
+      return stored.ok ? { ok: true, value: null } : stored;
+    },
+    async reset(scope) {
+      const valid = checkScope(scope);
+      if (!valid.ok) return valid;
+      const layoutKey = keyFor(scope);
+      const backupKey = keyFor(scope, "backup");
+      if (adapter.remove === void 0) {
+        return failure(
+          "invalid",
+          `Could not reset "${layoutKey}": the adapter has no remove method.`
+        );
+      }
+      const remove = adapter.remove.bind(adapter);
+      const first = await guarded(
+        layoutKey,
+        "remove",
+        () => remove(layoutKey, { signal })
+      );
+      revisions.delete(layoutKey);
+      if (!first.ok) return first;
+      const second = await guarded(
+        backupKey,
+        "remove",
+        () => remove(backupKey, { signal })
+      );
+      return second.ok ? { ok: true, value: null } : second;
+    },
+    watch(scope, definitions, onChange, normalizeOptions) {
+      const key = keyFor(scope);
+      const stop = adapter.subscribe?.(
+        key,
+        (stored) => {
+          if (stored === null) {
+            revisions.delete(key);
+            onChange({ layout: null });
+            return;
+          }
+          if (stored.value === lastWritten.get(key) || stored.revision !== void 0 && stored.revision === revisions.get(key)) {
+            return;
+          }
+          const read = readEnvelope(key, stored);
+          if (!read.ok) return;
+          onChange(
+            repair(
+              {
+                layout: read.value.layout,
+                ...stored.revision === void 0 ? {} : { revision: stored.revision },
+                ...read.value.savedAt === void 0 ? {} : { savedAt: read.value.savedAt }
+              },
+              definitions,
+              normalizeOptions
+            )
+          );
+        }
+      );
+      return stop ?? (() => void 0);
+    }
+  };
+}
+
+exports.DATE_RANGE_PRESETS = DATE_RANGE_PRESETS;
 exports.DEFAULT_COMPARISON_LABEL = DEFAULT_COMPARISON_LABEL;
 exports.DEFAULT_CURRENCY = DEFAULT_CURRENCY;
 exports.DEFAULT_DETAIL_PAGE_SIZE = DEFAULT_DETAIL_PAGE_SIZE;
 exports.DEFAULT_EMPTY_TEXT = DEFAULT_EMPTY_TEXT;
+exports.DEFAULT_MAX_LAYOUT_BYTES = DEFAULT_MAX_LAYOUT_BYTES;
+exports.DEFAULT_PAGE_KEY = DEFAULT_PAGE_KEY;
+exports.DEFAULT_PAGE_ROWS = DEFAULT_PAGE_ROWS;
 exports.DETAIL_MODES = DETAIL_MODES;
 exports.EMPTY_LAYOUT = EMPTY_LAYOUT;
+exports.LAYOUT_ENVELOPE_VERSION = LAYOUT_ENVELOPE_VERSION;
 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_PAGES = MAX_PARSED_PAGES;
 exports.MAX_REPORTED_PROBLEMS = MAX_REPORTED_PROBLEMS;
+exports.MAX_TEXT_OPTION_LENGTH = MAX_TEXT_OPTION_LENGTH;
+exports.MAX_WIDGET_OPTIONS = MAX_WIDGET_OPTIONS;
 exports.MAX_WIDGET_WIDTH = MAX_WIDGET_WIDTH;
 exports.MIN_WIDGET_WIDTH = MIN_WIDGET_WIDTH;
+exports.OPTION_KEY_PATTERN = OPTION_KEY_PATTERN;
 exports.VALUE_FORMATS = VALUE_FORMATS;
 exports.WIDGET_FILLS = WIDGET_FILLS;
 exports.WIDGET_KINDS = WIDGET_KINDS;
+exports.WIDGET_OPTION_TYPES = WIDGET_OPTION_TYPES;
 exports.WIDGET_SIZES = WIDGET_SIZES;
 exports.WIDTH_COLUMNS = WIDTH_COLUMNS;
+exports.addPage = addPage;
+exports.applyClientOptions = applyClientOptions;
+exports.assignPages = assignPages;
 exports.baseColumnSpan = baseColumnSpan;
 exports.cacheKeyFor = cacheKeyFor;
+exports.coerceOptionValue = coerceOptionValue;
+exports.createLayoutPersistence = createLayoutPersistence;
 exports.createWidgetLoader = createWidgetLoader;
 exports.defaultDetailQuery = defaultDetailQuery;
+exports.defaultOptionValue = defaultOptionValue;
 exports.defineWidget = defineWidget;
 exports.deriveDetailData = deriveDetailData;
 exports.describeUnknownError = describeUnknownError;
@@ -1527,13 +3286,19 @@ exports.fillColumnSpans = fillColumnSpans;
 exports.fillWidthSpans = fillWidthSpans;
 exports.fillsHeight = fillsHeight;
 exports.fillsWidth = fillsWidth;
+exports.finalizeWidget = finalizeWidget;
+exports.fitCount = fitCount;
 exports.formatCount = formatCount;
 exports.formatPercentChange = formatPercentChange;
 exports.formatValue = formatValue;
 exports.fromLegacyDefinition = fromLegacyDefinition;
+exports.hasPages = hasPages;
 exports.hiddenWidgets = hiddenWidgets;
 exports.hideWidget = hideWidget;
+exports.isClientApplied = isClientApplied;
+exports.isColumnKeyFor = isColumnKeyFor;
 exports.isHidden = isHidden;
+exports.isIsoInterval = isIsoInterval;
 exports.isMinimized = isMinimized;
 exports.isSafeHref = isSafeHref;
 exports.isSafeImageUrl = isSafeImageUrl;
@@ -1545,41 +3310,72 @@ exports.itemWidth = itemWidth;
 exports.kpiDelta = kpiDelta;
 exports.labelStride = labelStride;
 exports.loadingWidgets = loadingWidgets;
+exports.memoryAdapter = memoryAdapter;
 exports.minimizeWidget = minimizeWidget;
+exports.movePage = movePage;
 exports.moveWidget = moveWidget;
 exports.moveWidgetBy = moveWidgetBy;
 exports.moveWidgetDown = moveWidgetDown;
+exports.moveWidgetToPage = moveWidgetToPage;
 exports.moveWidgetUp = moveWidgetUp;
+exports.nextPageKey = nextPageKey;
 exports.niceDomain = niceDomain;
 exports.niceStep = niceStep;
+exports.normalizeLayout = normalizeLayout;
 exports.ok = ok;
+exports.optionValuesFor = optionValuesFor;
+exports.optionsCacheSuffix = optionsCacheSuffix;
+exports.pageLayout = pageLayout;
+exports.pageList = pageList;
+exports.pageOf = pageOf;
+exports.pageRoom = pageRoom;
+exports.pageWidgets = pageWidgets;
 exports.parseDetailQuery = parseDetailQuery;
 exports.parseLayout = parseLayout;
+exports.parseSortValue = parseSortValue;
 exports.percentChange = percentChange;
+exports.placeRows = placeRows;
 exports.pruneLayout = pruneLayout;
 exports.queryRows = queryRows;
+exports.readOnly = readOnly;
+exports.removePage = removePage;
+exports.renamePage = renamePage;
+exports.resolveDateRange = resolveDateRange;
 exports.resolveDetailOptions = resolveDetailOptions;
+exports.resolveOptionValues = resolveOptionValues;
+exports.resolvePageKey = resolvePageKey;
 exports.resolvePayload = resolvePayload;
 exports.resolveTableControls = resolveTableControls;
 exports.resolveWidget = resolveWidget;
 exports.resolveWidgetLock = resolveWidgetLock;
+exports.resolveWidgetUnapplied = resolveWidgetUnapplied;
 exports.resolveWidgets = resolveWidgets;
 exports.restoreWidget = restoreWidget;
+exports.sameOptionValues = sameOptionValues;
 exports.serializeDetailQuery = serializeDetailQuery;
 exports.serializeLayout = serializeLayout;
 exports.shareOf = shareOf;
 exports.showWidget = showWidget;
 exports.sortDefinitions = sortDefinitions;
+exports.sortFromOptions = sortFromOptions;
 exports.tableDetailData = tableDetailData;
 exports.toggleHidden = toggleHidden;
 exports.toggleMinimized = toggleMinimized;
 exports.upgradeLegacyWidgetData = upgradeLegacyWidgetData;
 exports.usesWidthColumns = usesWidthColumns;
+exports.utf8Length = utf8Length;
 exports.validateDetailData = validateDetailData;
 exports.validateWidgetData = validateWidgetData;
 exports.validateWidgetDefinition = validateWidgetDefinition;
 exports.visibleWidgets = visibleWidgets;
 exports.widgetsFor = widgetsFor;
 exports.widthForSize = widthForSize;
+exports.withEncoding = withEncoding;
+exports.withFallback = withFallback;
+exports.withLogging = withLogging;
+exports.withPageLayout = withPageLayout;
+exports.withPrefix = withPrefix;
+exports.withReadCache = withReadCache;
+exports.withRetry = withRetry;
 //# sourceMappingURL=core.cjs.map
 //# sourceMappingURL=core.cjs.map