grist-widget-sdk 0.3.25 → 0.3.26

package/dist/index.js

@@ -1,45 +1,63 @@
 import {
-  GristAttachmentsRestContext,
-  GristCoreContext,
-  GristCurrentTableContext,
-  GristHandshakeManagerContext,
-  GristLinkingContext,
-  GristReadsContext,
-  GristSectionApiContext,
-  GristSelectionContext,
-  GristThemeContext,
-  GristWidgetOptionsApiContext,
-  GristWritesContext,
-  buildManagerOptionsFromGristOptions,
+  GRIST_BOUNDARY_PREPARING_COPY,
+  GristBoundary,
+  GristBoundaryScreen,
+  GristWidgetProvider,
+  buildReplicaColumnsFromColumnar,
+  buildReplicaDocumentFromDocApi,
+  deriveBoundaryBootLabel,
+  deriveBoundaryBootPhase,
+  deriveBoundaryView,
+  extractAttachmentIdsFromUploadPayload,
+  extractFirstAttachmentIdFromUploadPayload,
+  extractGristAttachmentId,
+  extractGristAttachmentIdsFromCell,
+  fetchAttachmentBase64,
+  fetchAttachmentBase64ForCell,
+  fetchAttachmentBlob,
+  formatAccessInsufficientMessage,
+  formatBoundaryUserMessage,
+  formatColumnMappingAlertMessage,
+  formatLinkStaleAlertMessage,
+  formatMappingPendingAlertMessage,
+  formatMappingUnreportedAlertMessage,
+  formatSectionNotLinkedAlertMessage,
+  formatSourceNotWiredAlertMessage,
+  getAttachmentDownloadUrl,
+  getAttachmentDownloadUrlForCell,
+  getGristSdkAlertDescriptors,
+  getGristSdkAlertSeverity,
+  getGristSdkAlertTitle,
+  gristAttachmentCellValue,
+  gristAttachmentCellValues,
+  inferGristFormulaKind,
+  isAccessInsufficientError,
+  isWidgetSectionNotLinked,
+  loadColumnMetadataByTable,
+  mergeGristAttachmentCellValue,
+  orderedColumnIds,
+  parseGristAttachmentUploadResponse,
+  parseGristAttachmentUploadResponseIds,
+  resolveGristFormulaKind,
+  serializeJsonFriendly,
+  uploadGristAttachment,
+  useGrist,
+  useGristContext,
+  useGristOptional,
+  useGristSchema,
+  useGristSdkAlertDescriptors,
+  useGristSelection,
+  useGristStatus,
+  useGristTheme,
+  useGristWrites,
+  useWidgetMetadata
+} from "./chunk-PDGEZ24B.js";
+import {
   fetchWithGristAuth,
   getGristAccessToken,
-  mergeGristResultFromSlices,
-  useGristCore,
-  useGristCoreContext,
-  useGristCurrentTableContext,
-  useGristFromProvider,
-  useGristManager,
-  useGristManagerOptional,
-  useGristReady,
-  useGristSelectionContext,
-  useGristThemeContext,
-  useGristWidgetOptionsFromContext,
-  useGristWritesContext,
-  useRpcHeartbeatCoalesce
+  useGristWidgetOptionsFromContext
 } from "./chunk-EPEBKXVN.js";
 import {
-  createGristHandshakeManager,
-  deriveCapabilities,
-  deriveColumnMappingStatus,
-  deriveErrorMessage,
-  deriveStatus,
-  extractResolvedMappings,
-  initialGristSnapshot,
-  newRecordEvent,
-  optionsEvent,
-  parseGristWidgetLinkingInfo,
-  recordEvent,
-  recordsEvent,
   validateColumnMappings
 } from "./chunk-TZB3OZA6.js";
 import {
@@ -62,9 +80,7 @@ import {
   sortRowsByGristOrder,
   tableDataToRows
 } from "./chunk-JASMM2YC.js";
-import {
-  gristAccessLevelLabel
-} from "./chunk-N3X46JW2.js";
+import "./chunk-N3X46JW2.js";
 import {
   coerceGristDocApiRefRowId,
   decodeGristValue,
@@ -96,2256 +112,6 @@ import {
   safeParseGristTableData,
   safeParseGristValues
 } from "./chunk-64SVRWW7.js";
-
-// src/sdk/helpers/grist-attachment-download.ts
-function attachmentIdFromObjectRecord(record) {
-  for (const candidate of [record.id, record.attachmentId, record.fileId]) {
-    if (candidate === void 0 || candidate === null) continue;
-    return String(candidate);
-  }
-  return void 0;
-}
-function extractGristAttachmentIdsFromCell(value) {
-  const out = [];
-  const seen = /* @__PURE__ */ new Set();
-  const push = (id) => {
-    if (seen.has(id)) return;
-    seen.add(id);
-    out.push(id);
-  };
-  const walk = (v) => {
-    if (v === void 0 || v === null) return;
-    if (typeof v === "number") {
-      push(String(v));
-      return;
-    }
-    if (typeof v === "string") {
-      const trimmed = v.trim();
-      if (!trimmed) return;
-      if (/^\d+$/.test(trimmed)) {
-        push(trimmed);
-        return;
-      }
-      try {
-        walk(JSON.parse(trimmed));
-      } catch {
-      }
-      return;
-    }
-    if (Array.isArray(v)) {
-      for (const item of v) walk(item);
-      return;
-    }
-    if (typeof v === "object") {
-      const record = v;
-      const direct = attachmentIdFromObjectRecord(record);
-      if (direct !== void 0) {
-        push(direct);
-        return;
-      }
-      for (const nested of Object.values(record)) walk(nested);
-    }
-  };
-  walk(value);
-  return out;
-}
-function extractGristAttachmentId(value) {
-  return extractGristAttachmentIdsFromCell(value)[0];
-}
-async function getAttachmentDownloadUrl(docApi, attachmentId, options) {
-  const getAccessToken = docApi.getAccessToken;
-  if (!getAccessToken) {
-    throw new Error("getAccessToken is not available on docApi");
-  }
-  const { token, baseUrl } = await getAccessToken({ readOnly: options?.readOnly ?? false });
-  return `${baseUrl}/attachments/${attachmentId}/download?auth=${token}`;
-}
-async function getAttachmentDownloadUrlForCell(docApi, cellValue, index, options) {
-  const ids = extractGristAttachmentIdsFromCell(cellValue);
-  const id = ids[index];
-  if (!id) return null;
-  return getAttachmentDownloadUrl(docApi, id, options);
-}
-async function fetchBytesFromSignedAttachmentUrl(url) {
-  const response = await fetch(url);
-  const contentType = response.headers.get("content-type")?.trim() || "application/octet-stream";
-  if (!response.ok) {
-    throw new Error(`Attachment download failed (${response.status})`);
-  }
-  const buffer = await response.arrayBuffer();
-  return { buffer, contentType };
-}
-function bufferToBase64(buffer) {
-  const bytes = new Uint8Array(buffer);
-  let binary = "";
-  for (let i = 0; i < bytes.length; i++) binary += String.fromCharCode(bytes[i]);
-  return btoa(binary);
-}
-async function fetchAttachmentBase64(docApi, attachmentId, options) {
-  const url = await getAttachmentDownloadUrl(docApi, attachmentId, options);
-  const { buffer, contentType } = await fetchBytesFromSignedAttachmentUrl(url);
-  return { base64: bufferToBase64(buffer), contentType };
-}
-async function fetchAttachmentBlob(docApi, attachmentId, options) {
-  const url = await getAttachmentDownloadUrl(docApi, attachmentId, options);
-  const { buffer, contentType } = await fetchBytesFromSignedAttachmentUrl(url);
-  return { blob: new Blob([buffer], { type: contentType }), contentType };
-}
-async function fetchAttachmentBase64ForCell(docApi, cellValue, index, options) {
-  const url = await getAttachmentDownloadUrlForCell(docApi, cellValue, index, options);
-  if (!url) return null;
-  const { buffer, contentType } = await fetchBytesFromSignedAttachmentUrl(url);
-  return { base64: bufferToBase64(buffer), contentType };
-}
-
-// src/sdk/helpers/grist-attachment-upload.ts
-var ATTACHMENTS_COLUMN = { type: "Attachments" };
-function parseGristAttachmentUploadResponseIds(raw, options) {
-  const trimmed = raw.trim();
-  if (!trimmed) {
-    throw new Error("Attachment upload returned an empty response.");
-  }
-  let parsed;
-  try {
-    parsed = JSON.parse(trimmed);
-  } catch {
-    if (options?.strict) {
-      throw new Error("Attachment upload returned non-JSON response.");
-    }
-    parsed = trimmed;
-  }
-  return extractAttachmentIdsFromUploadPayload(parsed, options);
-}
-function parseGristAttachmentUploadResponse(raw, options) {
-  const ids = parseGristAttachmentUploadResponseIds(raw, options);
-  return ids[0];
-}
-function extractAttachmentIdsFromUploadPayload(parsed, options) {
-  if (options?.strict) {
-    return extractAttachmentIdsFromUploadPayloadStrict(parsed);
-  }
-  const first = extractFirstAttachmentIdFromUploadPayload(parsed);
-  if (first !== void 0) {
-    if (Array.isArray(parsed)) {
-      const ids = [];
-      const seen = /* @__PURE__ */ new Set();
-      for (const item of parsed) {
-        const id = coerceAttachmentId(item);
-        if (id && !seen.has(id)) {
-          seen.add(id);
-          ids.push(id);
-        }
-      }
-      return ids.length > 0 ? ids : [first];
-    }
-    return [first];
-  }
-  throw new Error("Attachment upload returned an unexpected response shape.");
-}
-function extractAttachmentIdsFromUploadPayloadStrict(parsed) {
-  if (typeof parsed === "number" && Number.isFinite(parsed)) {
-    return [String(parsed)];
-  }
-  if (Array.isArray(parsed)) {
-    const ids = [];
-    const seen = /* @__PURE__ */ new Set();
-    for (const item of parsed) {
-      if (typeof item !== "number" || !Number.isFinite(item)) {
-        throw new Error("Attachment upload returned an unexpected response shape.");
-      }
-      const id = String(item);
-      if (!seen.has(id)) {
-        seen.add(id);
-        ids.push(id);
-      }
-    }
-    if (ids.length === 0) {
-      throw new Error("Attachment upload returned an empty id list.");
-    }
-    return ids;
-  }
-  throw new Error("Attachment upload returned an unexpected response shape.");
-}
-function extractFirstAttachmentIdFromUploadPayload(parsed) {
-  if (typeof parsed === "number" && Number.isFinite(parsed)) {
-    return String(parsed);
-  }
-  if (typeof parsed === "string" && parsed.trim()) {
-    return parsed.trim();
-  }
-  if (Array.isArray(parsed)) {
-    for (const item of parsed) {
-      const id = coerceAttachmentId(item);
-      if (id) return id;
-    }
-    return void 0;
-  }
-  if (parsed && typeof parsed === "object") {
-    const record = parsed;
-    for (const key of ["id", "attachmentId", "fileId"]) {
-      const id = coerceAttachmentId(record[key]);
-      if (id) return id;
-    }
-  }
-  return void 0;
-}
-function coerceAttachmentId(value) {
-  if (typeof value === "number" && Number.isFinite(value)) {
-    return String(value);
-  }
-  if (typeof value === "string" && value.trim()) {
-    return value.trim();
-  }
-  return void 0;
-}
-function normalizeAttachmentIdForWire(id) {
-  const numeric = typeof id === "number" ? id : Number(id);
-  if (Number.isFinite(numeric) && String(numeric) === String(id).trim()) {
-    return numeric;
-  }
-  return typeof id === "number" ? String(id) : id.trim();
-}
-function gristAttachmentCellValues(attachmentIds) {
-  const items = attachmentIds.map(normalizeAttachmentIdForWire);
-  const encoded = encodeGristValue(items, ATTACHMENTS_COLUMN);
-  if (!Array.isArray(encoded) || encoded[0] !== "L") {
-    return ["L", ...items];
-  }
-  return encoded;
-}
-function gristAttachmentCellValue(attachmentId) {
-  return gristAttachmentCellValues([attachmentId]);
-}
-function mergeGristAttachmentCellValue(existingCell, newIds) {
-  const existing = extractGristAttachmentIdsFromCell(existingCell);
-  const merged = [];
-  const seen = /* @__PURE__ */ new Set();
-  const push = (raw) => {
-    const id = String(raw).trim();
-    if (!id || seen.has(id)) return;
-    seen.add(id);
-    merged.push(id);
-  };
-  for (const id of existing) push(id);
-  for (const id of newIds) push(id);
-  return gristAttachmentCellValues(merged);
-}
-var UPLOAD_HEADERS = {
-  "X-Requested-With": "XMLHttpRequest",
-  Accept: "application/json"
-};
-async function uploadGristAttachment(docApi, file, options) {
-  const form = new FormData();
-  const fileName = options?.fileName ?? (file instanceof File && file.name ? file.name : "upload");
-  form.append("upload", file, fileName);
-  let response;
-  try {
-    response = await fetchWithGristAuth(docApi, "/attachments", {
-      method: "POST",
-      body: form,
-      readOnly: false,
-      headers: UPLOAD_HEADERS
-    });
-  } catch (err) {
-    const msg = err instanceof Error ? err.message : String(err);
-    if (/failed to fetch/i.test(msg)) {
-      const widgetOrigin = typeof globalThis.location !== "undefined" ? globalThis.location.origin : "this widget origin";
-      throw new Error(
-        `Attachment upload was blocked by the Grist host (CORS). The browser could not POST from ${widgetOrigin} to the document API. If upload worked from a dev URL (e.g. ngrok) but fails after deploy, add the new widget URL to your Grist server CORS allowlist (see grist-core#2040).`,
-        { cause: err }
-      );
-    }
-    throw err;
-  }
-  const raw = await response.text();
-  if (!response.ok) {
-    throw new Error(
-      raw.trim() ? `Attachment upload failed (${response.status}): ${raw.slice(0, 200)}` : `Attachment upload failed (${response.status})`
-    );
-  }
-  const ids = parseGristAttachmentUploadResponseIds(raw);
-  return { ids, firstId: ids[0] };
-}
-
-// src/sdk/helpers/grist-schema-formula.ts
-function inferGristFormulaKind(isFormula, formulaTrimmed) {
-  if (formulaTrimmed.length > 0) return isFormula ? "computed" : "trigger";
-  return isFormula ? "empty_slot" : "none";
-}
-function resolveGristFormulaKind(col) {
-  if (col.formulaKind) return col.formulaKind;
-  const f = col.formula?.trim() ?? "";
-  if (f.length > 0) return col.isFormula === true ? "computed" : "trigger";
-  return col.isFormula === true ? "empty_slot" : "none";
-}
-function serializeJsonFriendly(value) {
-  if (value === null || value === void 0) return null;
-  if (typeof value === "string" || typeof value === "number" || typeof value === "boolean") return value;
-  try {
-    return JSON.parse(JSON.stringify(value));
-  } catch {
-    return String(value);
-  }
-}
-
-// src/sdk/helpers/build-replica-document.ts
-var FORMULA_PREVIEW_MAX = 500;
-function readCellStr(table, key, rowIndex) {
-  const col = table[key];
-  if (!Array.isArray(col)) return void 0;
-  const v = col[rowIndex];
-  if (v === null || v === void 0) return void 0;
-  if (typeof v === "string") return v;
-  if (typeof v === "number" || typeof v === "boolean") return String(v);
-  return void 0;
-}
-function readCellNum(table, key, rowIndex) {
-  const col = table[key];
-  if (!Array.isArray(col)) return void 0;
-  const v = col[rowIndex];
-  if (typeof v === "number" && !Number.isNaN(v)) return v;
-  if (typeof v === "string" && v.trim() !== "") {
-    const n = Number(v);
-    if (!Number.isNaN(n)) return n;
-  }
-  return void 0;
-}
-function pickColumnMeta(meta) {
-  if (!meta) return {};
-  const out = {};
-  if (meta.colRef !== void 0) out.colRef = meta.colRef;
-  if (meta.type) out.type = meta.type;
-  if (meta.label) out.label = meta.label;
-  if (meta.parentPos !== void 0) out.parentPos = meta.parentPos;
-  if (meta.isFormula) out.isFormula = true;
-  const formulaRaw = meta.formula?.trim() ?? "";
-  out.formulaKind = inferGristFormulaKind(Boolean(meta.isFormula), formulaRaw);
-  if (formulaRaw) {
-    out.formula = formulaRaw.length > FORMULA_PREVIEW_MAX ? `${formulaRaw.slice(0, FORMULA_PREVIEW_MAX)}...` : formulaRaw;
-  }
-  if (meta.description) out.description = meta.description;
-  if (meta.widgetOptions && Object.keys(meta.widgetOptions).length > 0) {
-    out.widgetOptions = meta.widgetOptions;
-  }
-  if (meta.displayColRef !== void 0) out.displayColRef = meta.displayColRef;
-  if (meta.visibleColRef !== void 0) out.visibleColRef = meta.visibleColRef;
-  return out;
-}
-async function loadColumnMetadataByTable(docApi) {
-  const byTable = /* @__PURE__ */ new Map();
-  try {
-    const tables = await docApi.fetchTable("_grist_Tables");
-    const columns = await docApi.fetchTable("_grist_Tables_column");
-    const tableIds = tables.tableId;
-    const tableInternalIds = tables.id;
-    if (!Array.isArray(tableIds) || !Array.isArray(tableInternalIds)) return byTable;
-    const internalIdToTableId = /* @__PURE__ */ new Map();
-    for (let i = 0; i < tableInternalIds.length; i++) {
-      const tid = tableIds[i];
-      const iid = coerceGristDocApiRefRowId(tableInternalIds[i]);
-      if (typeof tid === "string" && iid !== void 0) internalIdToTableId.set(iid, tid);
-    }
-    const parentIds = columns.parentId;
-    const colIds = columns.colId;
-    const columnIds = columns.id;
-    if (!Array.isArray(parentIds) || !Array.isArray(colIds) || !Array.isArray(columnIds) || parentIds.length !== colIds.length || colIds.length !== columnIds.length) {
-      return byTable;
-    }
-    const n = parentIds.length;
-    for (let i = 0; i < n; i++) {
-      const parentRowId = coerceGristDocApiRefRowId(parentIds[i]);
-      const colRef = coerceGristDocApiRefRowId(columnIds[i]);
-      const colId = colIds[i];
-      if (parentRowId === void 0 || colRef === void 0 || typeof colId !== "string") continue;
-      const tableId = internalIdToTableId.get(parentRowId);
-      if (!tableId) continue;
-      let colMap = byTable.get(tableId);
-      if (!colMap) {
-        colMap = /* @__PURE__ */ new Map();
-        byTable.set(tableId, colMap);
-      }
-      const parentPos = readCellNum(columns, "parentPos", i);
-      const isFormulaCol = columns.isFormula;
-      const isFormula = Array.isArray(isFormulaCol) ? Boolean(isFormulaCol[i]) : false;
-      const woCol = columns.widgetOptions;
-      const widgetOptions = Array.isArray(woCol) && i < woCol.length ? parseGristWidgetOptionsCell(woCol[i]) : void 0;
-      const displayColRef = coerceGristDocApiRefRowId(
-        Array.isArray(columns.displayCol) ? columns.displayCol[i] : void 0
-      );
-      const visibleColRef = coerceGristDocApiRefRowId(
-        Array.isArray(columns.visibleCol) ? columns.visibleCol[i] : void 0
-      );
-      colMap.set(colId, {
-        colRef,
-        type: readCellStr(columns, "type", i),
-        label: readCellStr(columns, "label", i),
-        parentPos: parentPos !== void 0 ? parentPos : void 0,
-        isFormula,
-        formula: readCellStr(columns, "formula", i),
-        description: readCellStr(columns, "description", i) ?? readCellStr(columns, "descr", i),
-        widgetOptions,
-        displayColRef,
-        visibleColRef
-      });
-    }
-  } catch {
-  }
-  return byTable;
-}
-function orderedColumnIds(data, metaByCol) {
-  const keys = Object.keys(data).filter((k) => Array.isArray(data[k]));
-  keys.sort((a, b) => {
-    const pa = metaByCol.get(a)?.parentPos;
-    const pb = metaByCol.get(b)?.parentPos;
-    if (pa !== void 0 && pb !== void 0 && pa !== pb) return pa - pb;
-    if (pa !== void 0 && pb === void 0) return -1;
-    if (pa === void 0 && pb !== void 0) return 1;
-    return a.localeCompare(b);
-  });
-  return keys;
-}
-function buildReplicaColumnsFromColumnar(data, colMeta) {
-  const columnIds = orderedColumnIds(data, colMeta);
-  const columns = {};
-  for (const colId of columnIds) {
-    const arr = data[colId];
-    if (!Array.isArray(arr)) continue;
-    const meta = colMeta.get(colId);
-    columns[colId] = pickColumnMeta(meta);
-  }
-  return columns;
-}
-function rowModeFromIncludeRows(includeRows) {
-  if (includeRows === false) return "schema-only";
-  if (includeRows === "samples") return "schema+samples";
-  return "schema+data";
-}
-async function buildReplicaDocumentFromDocApi(docApi, options) {
-  const includeSystemTableData = options?.includeSystemTableData ?? false;
-  const includeRows = options?.includeRows ?? "samples";
-  const sampleRowLimit = options?.sampleRowLimit ?? 10;
-  const rowMode = rowModeFromIncludeRows(includeRows);
-  const metaByTable = await loadColumnMetadataByTable(docApi);
-  let docName;
-  try {
-    docName = String(await Promise.resolve(docApi.getDocName()));
-  } catch {
-    docName = void 0;
-  }
-  const tableIdsRaw = await Promise.resolve(docApi.listTables());
-  const tableIds = Array.isArray(tableIdsRaw) ? [...tableIdsRaw] : [];
-  const tables = {};
-  for (const tableId of tableIds) {
-    const omitData = !includeSystemTableData && tableId.startsWith("_grist");
-    if (omitData) {
-      tables[tableId] = {
-        rowCount: 0,
-        dataOmitted: true,
-        dataOmittedReason: "Row scan skipped for tables whose id starts with `_grist` unless `includeSystemTableData` is true.",
-        columns: {}
-      };
-      continue;
-    }
-    try {
-      const data = await docApi.fetchTable(tableId);
-      const rowCount = computeRowCount(data);
-      const colMeta = metaByTable.get(tableId) ?? /* @__PURE__ */ new Map();
-      const columnIds = orderedColumnIds(data, colMeta);
-      const columns = buildReplicaColumnsFromColumnar(data, colMeta);
-      const table = { columns, rowCount };
-      if (includeRows === "full") {
-        table.rows = decodeColumnarToReplicaRows(data, columnIds, columns);
-      } else if (includeRows === "samples") {
-        table.rows = decodeColumnarToReplicaRows(data, columnIds, columns, sampleRowLimit);
-      }
-      tables[tableId] = table;
-    } catch (err) {
-      tables[tableId] = {
-        rowCount: 0,
-        error: err instanceof Error ? err.message : String(err),
-        columns: {}
-      };
-    }
-  }
-  const out = {
-    generatedAt: (/* @__PURE__ */ new Date()).toISOString(),
-    docName,
-    mode: rowMode,
-    tables
-  };
-  if (options?.source !== void 0 && options.source !== "") {
-    out.source = options.source;
-  }
-  return out;
-}
-
-// src/sdk/helpers/grist-boundary-view.ts
-function deriveBoundaryBootLabel(snapshot) {
-  const { lifecycle } = snapshot;
-  switch (lifecycle.phase) {
-    case "idle":
-      return "Starting\u2026";
-    case "detecting":
-      return lifecycle.attempts > 0 ? `Looking for Grist\u2026 (attempt ${lifecycle.attempts})` : "Looking for Grist\u2026";
-    case "negotiating":
-      return "Asking Grist for the access this widget needs\u2026";
-    case "online":
-      return "Connected";
-    case "terminated":
-      return "Connection ended";
-  }
-}
-function deriveBoundaryBootPhase(snapshot) {
-  switch (snapshot.lifecycle.phase) {
-    case "idle":
-      return "idle";
-    case "detecting":
-      return "detecting";
-    case "negotiating":
-      return "negotiating";
-    default:
-      return "generic";
-  }
-}
-function formatBoundaryUserMessage(raw, snapshot) {
-  if (snapshot.authz.state === "denied") {
-    return snapshot.authz.message ?? `Set Access level to at least "${gristAccessLevelLabel(snapshot.authz.declared)}" in the Custom widget settings.`;
-  }
-  if (!raw?.trim()) {
-    return "Something went wrong connecting to Grist. Try reconnecting below, or reload the page.";
-  }
-  const text = raw.trim();
-  if (/timed out/i.test(text)) {
-    return "Grist took too long to respond. Check your network, then try reconnecting.";
-  }
-  if (/link lost/i.test(text)) {
-    return "The link to Grist was interrupted. Try reconnecting to restore live data.";
-  }
-  if (/not embedded|custom widget inside/i.test(text)) {
-    return text;
-  }
-  if (/plugin API did not load/i.test(text)) {
-    return "The Grist plugin did not load in time. Reload the page, or open this URL as a custom widget inside a Grist document.";
-  }
-  if (/denied requested access/i.test(text)) {
-    const declared = snapshot.authz.state === "pending" ? snapshot.authz.declared : snapshot.authz.state === "granted" ? snapshot.authz.declared : null;
-    if (declared) {
-      return `Set Access level to at least "${gristAccessLevelLabel(declared)}" in the Custom widget settings.`;
-    }
-  }
-  return text;
-}
-function blockingTitle(kind, bootPhase, snapshot) {
-  if (kind === "error" && snapshot.authz.state === "denied") {
-    return "More access needed";
-  }
-  if (kind === "unavailable") return "Open inside Grist";
-  if (kind === "error") return "Something went wrong";
-  switch (bootPhase) {
-    case "detecting":
-      return "Connecting to Grist";
-    case "negotiating":
-      return "Setting up access";
-    case "idle":
-      return "Starting";
-    default:
-      return "Connecting to Grist";
-  }
-}
-function blockingMessage(snapshot, status, error) {
-  if (status === "unavailable") {
-    if (snapshot.lifecycle.phase === "terminated") {
-      if (snapshot.lifecycle.reason.kind === "not_embedded") {
-        return "Open this page as a custom widget inside a Grist document (it runs in an embedded panel, not on its own).";
-      }
-      if (snapshot.lifecycle.reason.kind === "script_timeout") {
-        return formatBoundaryUserMessage(
-          error ?? "The Grist plugin API did not load in time.",
-          snapshot
-        );
-      }
-    }
-    return "This page must be opened from a Grist document as a custom widget.";
-  }
-  if (status === "error") {
-    return formatBoundaryUserMessage(error, snapshot);
-  }
-  return deriveBoundaryBootLabel(snapshot);
-}
-function deriveBoundaryView(snapshot) {
-  const status = deriveStatus(snapshot);
-  if (status === "ready") {
-    return { mode: "ready" };
-  }
-  const kind = status === "unavailable" ? "unavailable" : status === "error" ? "error" : "booting";
-  const bootPhase = kind === "booting" ? deriveBoundaryBootPhase(snapshot) : void 0;
-  const error = deriveErrorMessage(snapshot);
-  return {
-    mode: "blocking",
-    kind,
-    bootPhase,
-    title: blockingTitle(kind, bootPhase ?? "generic", snapshot),
-    message: blockingMessage(snapshot, status, error),
-    showRetry: kind === "unavailable" || kind === "error"
-  };
-}
-var GRIST_BOUNDARY_PREPARING_COPY = {
-  title: "Map your columns",
-  message: "Open the widget settings in Grist (Creator Panel \u2192 Custom widget) and connect each required column to your table."
-};
-
-// src/sdk/helpers/grist-sdk-alerts.ts
-function getGristSdkAlertTitle(kind) {
-  switch (kind) {
-    case "column-mapping":
-      return "Column mapping";
-    case "mapping-pending":
-      return "Column mapping";
-    case "mapping-unreported":
-      return "Column mapping";
-    case "link-stale":
-      return "Grist connection";
-    case "section-not-linked":
-      return "Widget linking";
-    case "source-not-wired":
-      return "Widget linking";
-    case "current-table-error":
-      return "Current table";
-    case "action-error":
-      return "Action error";
-    case "access-insufficient":
-      return "Access level";
-    case "map-back-skip":
-      return "Write skipped";
-  }
-}
-function getGristSdkAlertSeverity(kind) {
-  switch (kind) {
-    case "action-error":
-    case "current-table-error":
-    case "access-insufficient":
-      return "error";
-    case "column-mapping":
-    case "mapping-unreported":
-    case "link-stale":
-    case "section-not-linked":
-    case "source-not-wired":
-    case "map-back-skip":
-      return "warning";
-    case "mapping-pending":
-      return "info";
-  }
-}
-function formatColumnMappingAlertMessage(status, hint) {
-  const parts = ["Column mapping is incomplete."];
-  if (status.missing.length > 0) {
-    parts.push(`Required columns: ${status.missing.join(", ")}.`);
-  }
-  if (status.emptyMultiples.length > 0) {
-    parts.push(
-      `Assign at least one sheet column for: ${status.emptyMultiples.join(", ")}.`
-    );
-  }
-  if (hint?.trim()) {
-    parts.push(hint.trim());
-  }
-  return parts.join(" ");
-}
-function formatMappingPendingAlertMessage(hint) {
-  const base = "Waiting for Grist to report column mappings.";
-  return hint?.trim() ? `${base} ${hint.trim()}` : base;
-}
-function formatMappingUnreportedAlertMessage(hint) {
-  const base = "Grist has not reported column mappings yet. Open the widget panel to map columns.";
-  return hint?.trim() ? `${base} ${hint.trim()}` : base;
-}
-function formatLinkStaleAlertMessage(snapshot) {
-  const missed = snapshot.link.missedPings;
-  const suffix = missed > 0 ? ` (${missed} missed heartbeat${missed === 1 ? "" : "s"})` : "";
-  return `Connection to Grist is stale. Edits may fail until the link recovers.${suffix}`;
-}
-function isWidgetSectionNotLinked(interaction) {
-  if (!interaction || typeof interaction !== "object") return false;
-  const linking = parseGristWidgetLinkingInfo(
-    interaction.linking ?? interaction.linking
-  );
-  if (!linking) return false;
-  return linking.asTarget == null;
-}
-function formatSectionNotLinkedAlertMessage(hint) {
-  const base = "This widget section is not linked to a table or selector. Link it from the page settings so the selected row is sent to the widget.";
-  return hint?.trim() ? `${base} ${hint.trim()}` : base;
-}
-function formatSourceNotWiredAlertMessage(hint) {
-  const base = "This widget is configured as a selector (allowSelectBy) but no other section is using it as a link source yet. Link another section to read from this widget.";
-  return hint?.trim() ? `${base} ${hint.trim()}` : base;
-}
-function pushDescriptor(out, partial) {
-  out.push({
-    title: partial.title ?? getGristSdkAlertTitle(partial.kind),
-    severity: partial.severity ?? getGristSdkAlertSeverity(partial.kind),
-    id: partial.id,
-    kind: partial.kind,
-    ariaRole: partial.ariaRole,
-    message: partial.message
-  });
-}
-function appendSnapshotAlerts(snapshot, options, out) {
-  const { config, link, sync } = snapshot;
-  if (config.mappings.state === "unreported") {
-    pushDescriptor(out, {
-      id: "mapping-unreported",
-      kind: "mapping-unreported",
-      ariaRole: "status",
-      message: formatMappingUnreportedAlertMessage(options?.columnMappingHint)
-    });
-  }
-  if (link.state === "stale") {
-    pushDescriptor(out, {
-      id: "link-stale",
-      kind: "link-stale",
-      ariaRole: "status",
-      message: formatLinkStaleAlertMessage(snapshot)
-    });
-  }
-  if (sync.currentTable.state === "errored") {
-    pushDescriptor(out, {
-      id: "current-table-error",
-      kind: "current-table-error",
-      ariaRole: "alert",
-      message: sync.currentTable.message
-    });
-  }
-}
-function getGristSdkAlertDescriptors(widget, options) {
-  const out = [];
-  if (widget.status !== "ready") {
-    return out;
-  }
-  if (widget.columnMappingStatus.pending) {
-    pushDescriptor(out, {
-      id: "mapping-pending",
-      kind: "mapping-pending",
-      ariaRole: "status",
-      message: formatMappingPendingAlertMessage(options?.mappingPendingHint)
-    });
-  } else if (!widget.columnMappingStatus.ok) {
-    pushDescriptor(out, {
-      id: "column-mapping",
-      kind: "column-mapping",
-      ariaRole: "status",
-      message: formatColumnMappingAlertMessage(
-        widget.columnMappingStatus,
-        options?.columnMappingHint
-      )
-    });
-  }
-  const accessErrorSource = widget.actionError ?? widget.readError;
-  if (accessErrorSource && isAccessInsufficientError(accessErrorSource)) {
-    pushDescriptor(out, {
-      id: "access-insufficient",
-      kind: "access-insufficient",
-      ariaRole: "alert",
-      message: formatAccessInsufficientMessage(options?.accessInsufficientHint)
-    });
-  } else if (widget.actionError) {
-    pushDescriptor(out, {
-      id: "action-error",
-      kind: "action-error",
-      ariaRole: "alert",
-      message: widget.actionError
-    });
-  } else if (widget.readError) {
-    pushDescriptor(out, {
-      id: "action-error",
-      kind: "action-error",
-      ariaRole: "alert",
-      message: widget.readError
-    });
-  }
-  const skipped = widget.mapBackSkipped ?? [];
-  if (skipped.length > 0) {
-    pushDescriptor(out, {
-      id: "map-back-skip",
-      kind: "map-back-skip",
-      ariaRole: "status",
-      message: formatMapBackSkipMessage(skipped, options?.mapBackHint)
-    });
-  }
-  if (widget.allowSelectBy) {
-    const linking = widget.widgetInteraction ? parseGristWidgetLinkingInfo(
-      widget.widgetInteraction.linking ?? widget.widgetInteraction.linking
-    ) : void 0;
-    if (linking && !linking.asSource) {
-      pushDescriptor(out, {
-        id: "source-not-wired",
-        kind: "source-not-wired",
-        ariaRole: "status",
-        message: formatSourceNotWiredAlertMessage(options?.sourceNotWiredHint)
-      });
-    }
-  } else if (isWidgetSectionNotLinked(widget.widgetInteraction)) {
-    pushDescriptor(out, {
-      id: "section-not-linked",
-      kind: "section-not-linked",
-      ariaRole: "status",
-      message: formatSectionNotLinkedAlertMessage(options?.sectionNotLinkedHint)
-    });
-  }
-  if (options?.snapshot) {
-    appendSnapshotAlerts(options.snapshot, options, out);
-  }
-  if (options?.suppressKinds?.length) {
-    return out.filter((a) => !options.suppressKinds.includes(a.kind));
-  }
-  return out;
-}
-function formatMapBackSkipMessage(skipped, hint) {
-  const list = skipped.join(", ");
-  const base = `mapBack skipped multi-mapped column${skipped.length === 1 ? "" : "s"}: ${list}.`;
-  return hint?.trim() ? `${base} ${hint.trim()}` : base;
-}
-var ACCESS_ERROR_PATTERNS = [
-  /access not granted/i,
-  /need higher access level/i,
-  /requires.*full.*access/i,
-  /RPC_ONCALL_ERROR Access/i
-];
-function isAccessInsufficientError(message) {
-  return ACCESS_ERROR_PATTERNS.some((re) => re.test(message));
-}
-function formatAccessInsufficientMessage(hint) {
-  const base = 'This operation requires "Full document access". Set the Access level to "Full document access" in the Custom widget configuration panel.';
-  return hint?.trim() ? `${base} ${hint.trim()}` : base;
-}
-
-// src/sdk/hooks/use-grist-sdk-alert-descriptors.ts
-import { useMemo as useMemo12, useSyncExternalStore as useSyncExternalStore2 } from "react";
-
-// src/sdk/components/grist-widget-provider.tsx
-import {
-  useContext,
-  useEffect as useEffect4,
-  useRef as useRef5
-} from "react";
-
-// src/sdk/internal/grist-widget-context-tree.tsx
-import { createContext, useMemo as useMemo11 } from "react";
-
-// src/sdk/internal/compose-grist-widget.ts
-import { useMemo as useMemo10 } from "react";
-
-// src/sdk/internal/hooks/use-grist-current-table.ts
-import { useCallback, useEffect, useMemo, useSyncExternalStore } from "react";
-function useGristCurrentTable(docApi) {
-  const manager = useGristManager();
-  const coalesceRpc = useRpcHeartbeatCoalesce();
-  const snapshot = useSyncExternalStore(
-    manager.subscribe,
-    manager.getSnapshot,
-    initialGristSnapshot
-  );
-  const currentTable = snapshot.sync.currentTable;
-  const currentTableId = currentTable.state === "known" ? currentTable.tableId : null;
-  const currentTableLoading = currentTable.state === "known" ? currentTable.refreshing : false;
-  const tableError = currentTable.state === "errored" ? currentTable.message : null;
-  const refreshCurrentTable = useCallback(async () => {
-    if (!docApi) return;
-    if (typeof grist === "undefined") return;
-    const atMs = Date.now();
-    manager.dispatch({ type: "CURRENT_TABLE_REFRESH_START", atMs });
-    try {
-      const next = await coalesceRpc(
-        () => Promise.resolve(grist.selectedTable?.getTableId())
-      );
-      if (next) {
-        manager.dispatch({ type: "CURRENT_TABLE_KNOWN", tableId: next, atMs: Date.now() });
-      }
-    } catch (err) {
-      const message = err instanceof Error ? err.message : String(err);
-      manager.dispatch({ type: "CURRENT_TABLE_ERROR", message, atMs: Date.now() });
-    }
-  }, [docApi, coalesceRpc, manager]);
-  useEffect(() => {
-    if (docApi) void refreshCurrentTable();
-  }, [docApi, refreshCurrentTable]);
-  useEffect(() => {
-    return recordEvent.subscribe(() => {
-      if (!docApi) return;
-      void refreshCurrentTable();
-    });
-  }, [docApi, refreshCurrentTable]);
-  return useMemo(
-    () => ({
-      currentTableId,
-      currentTableLoading,
-      refreshCurrentTable,
-      tableError
-    }),
-    [currentTableId, currentTableLoading, refreshCurrentTable, tableError]
-  );
-}
-
-// src/sdk/internal/hooks/use-grist-selection.ts
-import { useCallback as useCallback2, useEffect as useEffect2, useMemo as useMemo2, useRef, useState } from "react";
-var EMPTY_MAPPINGS = Object.freeze({});
-function stableColumnMappingStatus(prev, mappingState, columns) {
-  const next = deriveColumnMappingStatus(mappingState, columns);
-  if (prev && prev.ok === next.ok && prev.pending === next.pending && prev.missing.length === next.missing.length && prev.emptyMultiples.length === next.emptyMultiples.length && prev.missing.every((m, i) => m === next.missing[i]) && prev.emptyMultiples.every((m, i) => m === next.emptyMultiples[i])) {
-    return prev;
-  }
-  return next;
-}
-function copyRowRecord(record) {
-  if (!record) return null;
-  return { ...record };
-}
-function copyRowRecords(records) {
-  if (!records) return null;
-  return records.map((row) => ({ ...row }));
-}
-function copyMappedRecord(mapped) {
-  if (mapped === null || mapped === void 0) return null;
-  if (typeof mapped !== "object") return mapped;
-  return { ...mapped };
-}
-function mappingStateKey(state) {
-  return JSON.stringify(state);
-}
-function useMappingProjection() {
-  const manager = useGristManager();
-  const [mappingState, setMappingState] = useState(
-    () => manager.getSnapshot().config.mappings
-  );
-  useEffect2(() => {
-    let lastKey = mappingStateKey(manager.getSnapshot().config.mappings);
-    return manager.subscribe(() => {
-      const next = manager.getSnapshot().config.mappings;
-      const nextKey = mappingStateKey(next);
-      if (nextKey !== lastKey) {
-        lastKey = nextKey;
-        setMappingState(next);
-      }
-    });
-  }, [manager]);
-  return mappingState;
-}
-function useGristSelectionSubscription(docApi, options) {
-  const subscribeToWidgetOptions = options?.subscribeToWidgetOptions ?? true;
-  const subscribeToNewRecord = options?.subscribeToNewRecord ?? true;
-  const mappingState = useMappingProjection();
-  const [record, setRecord] = useState(null);
-  const [records, setRecords] = useState(null);
-  const [mappedRecord, setMappedRecord] = useState(null);
-  const [streamMappings, setStreamMappings] = useState(null);
-  const [recordsMappings, setRecordsMappings] = useState(null);
-  const [widgetOptions, setWidgetOptionsMirror] = useState(null);
-  const [widgetInteraction, setWidgetInteraction] = useState(null);
-  const [isNewRecord, setIsNewRecord] = useState(false);
-  const [newRecordMappings, setNewRecordMappings] = useState(null);
-  const [mapBackSkipped, setMapBackSkipped] = useState([]);
-  const mapBackSkippedRef = useRef([]);
-  const fsmMappings = extractResolvedMappings(mappingState);
-  const mappings = useMemo2(
-    () => fsmMappings ?? streamMappings ?? EMPTY_MAPPINGS,
-    [fsmMappings, streamMappings]
-  );
-  const columnMappingStatusRef = useRef(void 0);
-  const columnMappingStatus = useMemo2(() => {
-    const next = stableColumnMappingStatus(
-      columnMappingStatusRef.current,
-      mappingState,
-      options?.columns
-    );
-    columnMappingStatusRef.current = next;
-    return next;
-  }, [mappingState, options?.columns]);
-  const applyRecordPayload = useCallback2(
-    ({ record: next, mappings: nextMappings }) => {
-      setStreamMappings(nextMappings);
-      setRecord(copyRowRecord(next));
-      if (!next) {
-        setMappedRecord(null);
-        return;
-      }
-      setIsNewRecord(false);
-      if (typeof grist !== "undefined" && typeof grist.mapColumnNames === "function") {
-        setMappedRecord(copyMappedRecord(grist.mapColumnNames(next)));
-      } else {
-        setMappedRecord(copyMappedRecord(next));
-      }
-    },
-    []
-  );
-  useEffect2(() => {
-    if (typeof grist === "undefined") return;
-    return recordEvent.subscribe(applyRecordPayload);
-  }, [applyRecordPayload]);
-  useEffect2(() => {
-    if (typeof grist === "undefined") return;
-    return recordsEvent.subscribe(({ records: next, mappings: nextMappings }) => {
-      setRecords(copyRowRecords(next));
-      setRecordsMappings(nextMappings);
-    });
-  }, []);
-  useEffect2(() => {
-    if (!subscribeToWidgetOptions || typeof grist === "undefined") return;
-    return optionsEvent.subscribe(({ options: next, interaction }) => {
-      setWidgetOptionsMirror(next);
-      setWidgetInteraction(interaction);
-    });
-  }, [subscribeToWidgetOptions]);
-  useEffect2(() => {
-    if (!subscribeToNewRecord || typeof grist === "undefined") return;
-    if (typeof grist.onNewRecord !== "function") return;
-    return newRecordEvent.subscribe(({ mappings: nextMappings }) => {
-      setIsNewRecord(true);
-      setNewRecordMappings(nextMappings);
-    });
-  }, [subscribeToNewRecord]);
-  const prevDocApiRef = useRef(null);
-  useEffect2(() => {
-    const hadDocApi = prevDocApiRef.current !== null;
-    prevDocApiRef.current = docApi;
-    if (docApi) {
-      if (!hadDocApi && recordEvent.ready) {
-        const cached = recordEvent.peek();
-        if (cached !== void 0) applyRecordPayload(cached);
-      }
-      return;
-    }
-    if (!hadDocApi) return;
-    setRecord(null);
-    setRecords(null);
-    setMappedRecord(null);
-    setStreamMappings(null);
-    setRecordsMappings(null);
-    setIsNewRecord(false);
-    setNewRecordMappings(null);
-    setWidgetOptionsMirror(null);
-    setWidgetInteraction(null);
-  }, [docApi, applyRecordPayload]);
-  const resolveMappedColumnId = useCallback2(
-    (logicalFieldName) => {
-      const value = mappings[logicalFieldName];
-      if (typeof value === "string") return value;
-      if (Array.isArray(value) && typeof value[0] === "string") return value[0];
-      return logicalFieldName;
-    },
-    [mappings]
-  );
-  const mapBack = useCallback2(
-    (patch) => {
-      const skipped = [];
-      for (const name of Object.keys(patch)) {
-        if (Array.isArray(mappings[name])) skipped.push(name);
-      }
-      const computeResult = () => {
-        if (typeof grist.mapColumnNamesBack === "function") {
-          const out2 = grist.mapColumnNamesBack(patch);
-          for (const key of Object.keys(out2)) {
-            if (out2[key] === void 0) {
-              delete out2[key];
-            }
-          }
-          return out2;
-        }
-        const out = {};
-        for (const [name, value] of Object.entries(patch)) {
-          const target = mappings[name];
-          if (Array.isArray(target)) continue;
-          out[target ?? name] = value;
-        }
-        return out;
-      };
-      const result = computeResult();
-      const previous = mapBackSkippedRef.current;
-      const same = previous.length === skipped.length && previous.every((name, i) => name === skipped[i]);
-      if (!same) {
-        mapBackSkippedRef.current = skipped;
-        setMapBackSkipped(skipped);
-      }
-      return result;
-    },
-    [mappings]
-  );
-  const mode = isNewRecord ? "new-row" : record ? "row" : "empty";
-  return useMemo2(
-    () => ({
-      record,
-      records,
-      mappedRecord,
-      mappings,
-      recordsMappings,
-      columnMappingStatus,
-      mode,
-      resolveMappedColumnId,
-      mapBack,
-      mapBackSkipped,
-      isNewRecord,
-      newRecordMappings,
-      widgetOptions,
-      widgetInteraction
-    }),
-    [
-      record,
-      records,
-      mappedRecord,
-      mappings,
-      recordsMappings,
-      columnMappingStatus,
-      mode,
-      resolveMappedColumnId,
-      mapBack,
-      mapBackSkipped,
-      isNewRecord,
-      newRecordMappings,
-      widgetOptions,
-      widgetInteraction
-    ]
-  );
-}
-
-// src/sdk/internal/hooks/use-grist-table-ops-bound.ts
-import { useCallback as useCallback3, useMemo as useMemo3, useRef as useRef2, useState as useState2 } from "react";
-function resolveSelectedTableOps() {
-  if (grist.selectedTable) return grist.selectedTable;
-  throw new Error("grist.selectedTable is not available in this Grist version");
-}
-function resolveTableOps(tableId) {
-  if (typeof grist.getTable !== "function") {
-    throw new Error("grist.getTable is not available in this Grist version");
-  }
-  return grist.getTable(tableId);
-}
-function useGristTableOpsBound(docApi) {
-  const [actionStatus, setActionStatus] = useState2("idle");
-  const [actionError, setActionError] = useState2(null);
-  const tableCacheRef = useRef2(/* @__PURE__ */ new Map());
-  const coalesceRpc = useRpcHeartbeatCoalesce();
-  const trackOp = useCallback3(
-    async (fn) => {
-      if (!docApi) throw new Error("Grist is not ready");
-      setActionStatus("running");
-      setActionError(null);
-      try {
-        const out = await coalesceRpc(fn);
-        setActionStatus("idle");
-        return out;
-      } catch (err) {
-        const message = err instanceof Error ? err.message : String(err);
-        setActionError(message);
-        setActionStatus("error");
-        throw err;
-      }
-    },
-    [docApi, coalesceRpc]
-  );
-  const wrapTableOps = useCallback3(
-    (resolve) => ({
-      getTableId: () => trackOp(() => resolve().getTableId()),
-      create: (records, opOptions) => trackOp(() => resolve().create(records, opOptions)),
-      update: (records, opOptions) => trackOp(() => resolve().update(records, opOptions)),
-      upsert: (records, opOptions) => trackOp(() => resolve().upsert(records, opOptions)),
-      destroy: (recordIds) => trackOp(() => resolve().destroy(recordIds))
-    }),
-    [trackOp]
-  );
-  const table = useMemo3(() => wrapTableOps(() => resolveSelectedTableOps()), [wrapTableOps]);
-  const getTable = useCallback3(
-    (tableId) => {
-      const cached = tableCacheRef.current.get(tableId);
-      if (cached) return cached;
-      const wrapped = wrapTableOps(() => resolveTableOps(tableId));
-      tableCacheRef.current.set(tableId, wrapped);
-      return wrapped;
-    },
-    [wrapTableOps]
-  );
-  const applyActions = useCallback3(
-    async (actions, applyOptions) => {
-      if (!docApi) throw new Error("Grist docApi is not ready");
-      setActionStatus("running");
-      setActionError(null);
-      try {
-        const out = await coalesceRpc(() => docApi.applyUserActions(actions, applyOptions));
-        setActionStatus("idle");
-        return out;
-      } catch (err) {
-        const message = err instanceof Error ? err.message : String(err);
-        setActionError(message);
-        setActionStatus("error");
-        throw err;
-      }
-    },
-    [docApi, coalesceRpc]
-  );
-  return useMemo3(
-    () => ({ table, getTable, actionStatus, actionError, applyActions }),
-    [table, getTable, actionStatus, actionError, applyActions]
-  );
-}
-
-// src/sdk/internal/hooks/use-grist-reads.ts
-import { useCallback as useCallback4, useMemo as useMemo4, useRef as useRef3, useState as useState3 } from "react";
-var SELECTED_FETCH_DEFAULTS = {
-  keepEncoded: false,
-  format: "rows"
-};
-function useGristReads(docApi) {
-  const coalesceRpc = useRpcHeartbeatCoalesce();
-  const manager = useGristManagerOptional();
-  const [readError, setReadError] = useState3(null);
-  const readErrorRef = useRef3(null);
-  const requireFullAccess = useCallback4(
-    (label) => {
-      const snap = manager?.getSnapshot();
-      if (!snap) return;
-      const { authz, sync } = snap;
-      if (sync.options.state !== "hot") return;
-      if (authz.state === "granted" && authz.level !== "full") {
-        const msg = `${label} requires "Full document access". Current access level is "${authz.level}". Set Access level to "Full document access" in the Custom widget configuration panel.`;
-        if (readErrorRef.current !== msg) {
-          readErrorRef.current = msg;
-          setReadError(msg);
-        }
-        throw new Error(msg);
-      }
-    },
-    [manager]
-  );
-  const guardedRpc = useCallback4(
-    async (fn) => {
-      try {
-        const result = await coalesceRpc(fn);
-        if (readErrorRef.current !== null) {
-          readErrorRef.current = null;
-          setReadError(null);
-        }
-        return result;
-      } catch (err) {
-        const msg = err instanceof Error ? err.message : String(err);
-        if (isAccessInsufficientError(msg)) {
-          if (readErrorRef.current !== msg) {
-            readErrorRef.current = msg;
-            setReadError(msg);
-          }
-        }
-        throw err;
-      }
-    },
-    [coalesceRpc]
-  );
-  const fetchTable = useCallback4(
-    async (tableId) => {
-      if (!docApi) throw new Error("Grist is not ready");
-      requireFullAccess("fetchTable");
-      return guardedRpc(() => docApi.fetchTable(tableId));
-    },
-    [docApi, requireFullAccess, guardedRpc]
-  );
-  const fetchRow = useCallback4(
-    async (tableId, rowId) => {
-      if (!docApi) throw new Error("Grist is not ready");
-      requireFullAccess("fetchRow");
-      return guardedRpc(() => fetchGristRow(docApi, tableId, rowId));
-    },
-    [docApi, requireFullAccess, guardedRpc]
-  );
-  const fetchTableRows = useCallback4(
-    async (tableId, options) => {
-      if (!docApi) throw new Error("Grist is not ready");
-      requireFullAccess("fetchTableRows");
-      if (options?.safeParse) {
-        return guardedRpc(
-          () => fetchGristTableRows(
-            docApi,
-            tableId,
-            options
-          )
-        );
-      }
-      if (options) {
-        return guardedRpc(() => fetchGristTableRows(docApi, tableId, options));
-      }
-      return guardedRpc(() => fetchGristTableRows(docApi, tableId));
-    },
-    [docApi, requireFullAccess, guardedRpc]
-  );
-  const listTables = useCallback4(
-    async (options) => {
-      if (!docApi) throw new Error("Grist is not ready");
-      return guardedRpc(async () => {
-        const out = await Promise.resolve(docApi.listTables());
-        const tables = [...out];
-        if (options?.includeSystem) return tables;
-        return tables.filter(
-          (t) => !t.startsWith("_grist") && !t.startsWith("GristHidden_")
-        );
-      });
-    },
-    [docApi, guardedRpc]
-  );
-  const listColumns = useCallback4(
-    async (tableId, options) => {
-      if (!docApi) throw new Error("Grist is not ready");
-      requireFullAccess("listColumns");
-      return guardedRpc(async () => {
-        const metaByTable = await loadColumnMetadataByTable(docApi);
-        const colMeta = metaByTable.get(tableId);
-        if (!colMeta) return [];
-        const noiseOpts = {
-          excludeId: options?.excludeId ?? true,
-          excludeGristHelpers: options?.excludeGristHelpers ?? true,
-          excludeLoggingColumns: options?.excludeLoggingColumns ?? true,
-          excludeManualSort: options?.excludeManualSort ?? true
-        };
-        const result = [];
-        for (const [colId, meta] of colMeta) {
-          if (!options?.includeSystem && isGristNoiseColumn(colId, meta, noiseOpts)) {
-            continue;
-          }
-          result.push({
-            colId,
-            type: meta.type,
-            label: meta.label,
-            isFormula: meta.isFormula,
-            formula: meta.formula,
-            description: meta.description
-          });
-        }
-        return result;
-      });
-    },
-    [docApi, requireFullAccess, guardedRpc]
-  );
-  const getDocName = useCallback4(async () => {
-    if (!docApi) throw new Error("Grist is not ready");
-    return guardedRpc(async () => String(await Promise.resolve(docApi.getDocName())));
-  }, [docApi, guardedRpc]);
-  const buildReplicaDocumentFromDocApi2 = useCallback4(
-    async (opts) => {
-      if (!docApi) throw new Error("Grist is not ready");
-      requireFullAccess("buildReplicaDocumentFromDocApi");
-      return guardedRpc(() => buildReplicaDocumentFromDocApi(docApi, opts));
-    },
-    [docApi, requireFullAccess, guardedRpc]
-  );
-  const fetchSelectedTable = useCallback4(
-    async (fetchOptions) => {
-      if (!docApi) throw new Error("Grist is not ready");
-      const impl = docApi.fetchSelectedTable ?? grist.fetchSelectedTable;
-      if (!impl) throw new Error("fetchSelectedTable is not available in this Grist version");
-      const merged = { ...SELECTED_FETCH_DEFAULTS, ...fetchOptions };
-      return guardedRpc(async () => await impl(merged));
-    },
-    [docApi, guardedRpc]
-  );
-  const fetchSelectedRecord = useCallback4(
-    async (rowId, fetchOptions) => {
-      if (!docApi) throw new Error("Grist is not ready");
-      const impl = docApi.fetchSelectedRecord ?? grist.fetchSelectedRecord;
-      if (!impl) throw new Error("fetchSelectedRecord is not available in this Grist version");
-      const merged = { ...SELECTED_FETCH_DEFAULTS, ...fetchOptions };
-      return guardedRpc(async () => await impl(rowId, merged));
-    },
-    [docApi, guardedRpc]
-  );
-  return useMemo4(
-    () => ({
-      fetchTable,
-      fetchTableRows,
-      fetchRow,
-      listTables,
-      listColumns,
-      getDocName,
-      buildReplicaDocumentFromDocApi: buildReplicaDocumentFromDocApi2,
-      fetchSelectedTable,
-      fetchSelectedRecord,
-      readError
-    }),
-    [
-      fetchTable,
-      fetchTableRows,
-      fetchRow,
-      listTables,
-      listColumns,
-      getDocName,
-      buildReplicaDocumentFromDocApi2,
-      fetchSelectedTable,
-      fetchSelectedRecord,
-      readError
-    ]
-  );
-}
-
-// src/sdk/internal/hooks/use-grist-widget-options-api.ts
-import { useCallback as useCallback5, useMemo as useMemo5 } from "react";
-function useGristWidgetOptionsApi() {
-  const coalesceRpc = useRpcHeartbeatCoalesce();
-  const getWidgetOptions = useCallback5(
-    async () => coalesceRpc(async () => {
-      const next = await grist.getOptions();
-      return next;
-    }),
-    [coalesceRpc]
-  );
-  const getWidgetOption = useCallback5(
-    async (key) => coalesceRpc(() => Promise.resolve(grist.getOption(key))),
-    [coalesceRpc]
-  );
-  const setWidgetOption = useCallback5(
-    async (key, value) => {
-      await coalesceRpc(() => Promise.resolve(grist.setOption(key, value)));
-    },
-    [coalesceRpc]
-  );
-  const setWidgetOptions = useCallback5(
-    async (next) => {
-      await coalesceRpc(() => Promise.resolve(grist.setOptions(next)));
-    },
-    [coalesceRpc]
-  );
-  const patchWidgetOptions = useCallback5(
-    async (patch) => {
-      await coalesceRpc(async () => {
-        const current = await grist.getOptions();
-        await grist.setOptions({ ...current ?? {}, ...patch });
-      });
-    },
-    [coalesceRpc]
-  );
-  const clearWidgetOptions = useCallback5(
-    async () => {
-      await coalesceRpc(() => Promise.resolve(grist.clearOptions()));
-    },
-    [coalesceRpc]
-  );
-  return useMemo5(
-    () => ({
-      getWidgetOptions,
-      getWidgetOption,
-      setWidgetOption,
-      setWidgetOptions,
-      patchWidgetOptions,
-      clearWidgetOptions
-    }),
-    [
-      getWidgetOptions,
-      getWidgetOption,
-      setWidgetOption,
-      setWidgetOptions,
-      patchWidgetOptions,
-      clearWidgetOptions
-    ]
-  );
-}
-
-// src/sdk/internal/hooks/use-grist-linking.ts
-import { useCallback as useCallback6, useMemo as useMemo6 } from "react";
-function useGristLinking() {
-  const coalesceRpc = useRpcHeartbeatCoalesce();
-  const setCursorPosition = useCallback6(
-    async (pos) => {
-      if (!grist.setCursorPos) throw new Error("setCursorPos is not available in this Grist version");
-      await coalesceRpc(() => Promise.resolve(grist.setCursorPos(pos)));
-    },
-    [coalesceRpc]
-  );
-  const setLinkedRowSelection = useCallback6(
-    async (rowIds) => {
-      if (!grist.setSelectedRows) throw new Error("setSelectedRows is not available in this Grist version");
-      await coalesceRpc(() => Promise.resolve(grist.setSelectedRows(rowIds)));
-    },
-    [coalesceRpc]
-  );
-  return useMemo6(
-    () => ({ setCursorPosition, setLinkedRowSelection }),
-    [setCursorPosition, setLinkedRowSelection]
-  );
-}
-
-// src/sdk/internal/hooks/use-grist-attachments-rest.ts
-import { useCallback as useCallback7, useMemo as useMemo7, useRef as useRef4, useState as useState4 } from "react";
-function useGristAttachmentsRest(docApi) {
-  const coalesceRpc = useRpcHeartbeatCoalesce();
-  const [readError, setReadError] = useState4(null);
-  const readErrorRef = useRef4(null);
-  const guardedRpc = useCallback7(
-    async (fn) => {
-      try {
-        const result = await coalesceRpc(fn);
-        if (readErrorRef.current !== null) {
-          readErrorRef.current = null;
-          setReadError(null);
-        }
-        return result;
-      } catch (err) {
-        const msg = err instanceof Error ? err.message : String(err);
-        if (isAccessInsufficientError(msg)) {
-          if (readErrorRef.current !== msg) {
-            readErrorRef.current = msg;
-            setReadError(msg);
-          }
-        }
-        throw err;
-      }
-    },
-    [coalesceRpc]
-  );
-  const getAttachmentUrl = useCallback7(
-    async (attachmentId, opts) => {
-      if (!docApi) throw new Error("Grist is not ready");
-      return guardedRpc(() => getAttachmentDownloadUrl(docApi, attachmentId, opts));
-    },
-    [docApi, guardedRpc]
-  );
-  const fetchAttachmentBase642 = useCallback7(
-    async (attachmentId, opts) => {
-      if (!docApi) throw new Error("Grist is not ready");
-      return guardedRpc(() => fetchAttachmentBase64(docApi, attachmentId, opts));
-    },
-    [docApi, guardedRpc]
-  );
-  const fetchAttachmentBlob2 = useCallback7(
-    async (attachmentId, opts) => {
-      if (!docApi) throw new Error("Grist is not ready");
-      return guardedRpc(() => fetchAttachmentBlob(docApi, attachmentId, opts));
-    },
-    [docApi, guardedRpc]
-  );
-  const getAccessToken = useCallback7(
-    async (opts) => {
-      if (!docApi) throw new Error("Grist is not ready");
-      return guardedRpc(() => getGristAccessToken(docApi, opts));
-    },
-    [docApi, guardedRpc]
-  );
-  const fetchWithAuth = useCallback7(
-    (path, init) => {
-      if (!docApi) throw new Error("Grist is not ready");
-      return guardedRpc(() => fetchWithGristAuth(docApi, path, init));
-    },
-    [docApi, guardedRpc]
-  );
-  const uploadAttachment = useCallback7(
-    (file, opts) => {
-      if (!docApi) throw new Error("Grist is not ready");
-      return guardedRpc(() => uploadGristAttachment(docApi, file, opts));
-    },
-    [docApi, guardedRpc]
-  );
-  return useMemo7(
-    () => ({
-      getAttachmentUrl,
-      fetchAttachmentBase64: fetchAttachmentBase642,
-      fetchAttachmentBlob: fetchAttachmentBlob2,
-      getAccessToken,
-      fetchWithAuth,
-      uploadAttachment,
-      readError
-    }),
-    [
-      getAttachmentUrl,
-      fetchAttachmentBase642,
-      fetchAttachmentBlob2,
-      getAccessToken,
-      fetchWithAuth,
-      uploadAttachment,
-      readError
-    ]
-  );
-}
-
-// src/sdk/internal/hooks/use-grist-theme.ts
-import { useEffect as useEffect3, useMemo as useMemo8, useState as useState5 } from "react";
-
-// src/sdk/helpers/grist-theme-payload.ts
-function parseGristThemePayload(payload) {
-  if (!payload || typeof payload !== "object") return null;
-  const raw = payload;
-  const top = raw.theme;
-  if (top === "light" || top === "dark") return top;
-  if (top && typeof top === "object") {
-    const appearance = top.appearance;
-    if (appearance === "light" || appearance === "dark") return appearance;
-  }
-  return null;
-}
-
-// src/sdk/internal/hooks/use-grist-theme.ts
-function useGristTheme(_docApi) {
-  const [theme, setTheme] = useState5(null);
-  useEffect3(() => {
-    if (typeof grist === "undefined" || typeof grist.on !== "function") return;
-    const apply = (payload) => {
-      const next = parseGristThemePayload(payload);
-      if (next) setTheme(next);
-    };
-    grist.on("message", (msg) => {
-      if (!msg || typeof msg !== "object") return;
-      if (!("theme" in msg)) return;
-      apply(msg);
-    });
-  }, []);
-  return useMemo8(() => ({ theme }), [theme]);
-}
-
-// src/sdk/internal/hooks/use-grist-section-api.ts
-import { useCallback as useCallback8, useMemo as useMemo9 } from "react";
-function useGristSectionApi() {
-  const coalesceRpc = useRpcHeartbeatCoalesce();
-  const configure = useCallback8(
-    async (next) => {
-      if (!grist.sectionApi?.configure) {
-        throw new Error("grist.sectionApi.configure is not available in this Grist version");
-      }
-      await coalesceRpc(() => Promise.resolve(grist.sectionApi.configure(next)));
-    },
-    [coalesceRpc]
-  );
-  const refreshMappings = useCallback8(
-    async () => {
-      if (!grist.sectionApi?.mappings) {
-        throw new Error("grist.sectionApi.mappings is not available in this Grist version");
-      }
-      return coalesceRpc(() => grist.sectionApi.mappings());
-    },
-    [coalesceRpc]
-  );
-  return useMemo9(() => ({ configure, refreshMappings }), [configure, refreshMappings]);
-}
-
-// src/sdk/internal/compose-grist-widget.ts
-function useComposeGristWidgetSlices(options) {
-  const core = useGristCore(options);
-  const currentTable = useGristCurrentTable(core.docApi);
-  const selection = useGristSelectionSubscription(core.docApi, options);
-  const writes = useGristTableOpsBound(core.docApi);
-  const reads = useGristReads(core.docApi);
-  const widgetOptionsApi = useGristWidgetOptionsApi();
-  const linking = useGristLinking();
-  const attachmentsRest = useGristAttachmentsRest(core.docApi);
-  const theme = useGristTheme(core.docApi);
-  const sectionApi = useGristSectionApi();
-  const coreSlice = useMemo10(
-    () => ({
-      ...core,
-      tableError: currentTable.tableError
-    }),
-    [core, currentTable.tableError]
-  );
-  const suppressAlerts = options?.suppressAlerts;
-  const allowSelectBy = options?.allowSelectBy;
-  return useMemo10(
-    () => ({
-      core: coreSlice,
-      selection,
-      currentTable,
-      writes,
-      reads,
-      widgetOptionsApi,
-      linking,
-      attachmentsRest,
-      theme,
-      sectionApi,
-      suppressAlerts,
-      allowSelectBy
-    }),
-    [
-      coreSlice,
-      selection,
-      currentTable,
-      writes,
-      reads,
-      widgetOptionsApi,
-      linking,
-      attachmentsRest,
-      theme,
-      sectionApi,
-      suppressAlerts,
-      allowSelectBy
-    ]
-  );
-}
-
-// src/sdk/internal/grist-widget-context-tree.tsx
-import { jsx } from "react/jsx-runtime";
-var GristContext = createContext(null);
-function GristWidgetContextTree({ options, children }) {
-  const slices = useComposeGristWidgetSlices(options);
-  const fullResult = useMemo11(
-    () => mergeGristResultFromSlices(slices),
-    [
-      slices.core,
-      slices.selection,
-      slices.currentTable,
-      slices.writes,
-      slices.reads,
-      slices.widgetOptionsApi,
-      slices.linking,
-      slices.attachmentsRest,
-      slices.theme,
-      slices.sectionApi
-    ]
-  );
-  return /* @__PURE__ */ jsx(GristCoreContext.Provider, { value: slices.core, children: /* @__PURE__ */ jsx(GristSelectionContext.Provider, { value: slices.selection, children: /* @__PURE__ */ jsx(GristCurrentTableContext.Provider, { value: slices.currentTable, children: /* @__PURE__ */ jsx(GristWritesContext.Provider, { value: slices.writes, children: /* @__PURE__ */ jsx(GristReadsContext.Provider, { value: slices.reads, children: /* @__PURE__ */ jsx(GristWidgetOptionsApiContext.Provider, { value: slices.widgetOptionsApi, children: /* @__PURE__ */ jsx(GristLinkingContext.Provider, { value: slices.linking, children: /* @__PURE__ */ jsx(GristAttachmentsRestContext.Provider, { value: slices.attachmentsRest, children: /* @__PURE__ */ jsx(GristThemeContext.Provider, { value: slices.theme, children: /* @__PURE__ */ jsx(GristSectionApiContext.Provider, { value: slices.sectionApi, children: /* @__PURE__ */ jsx(GristContext.Provider, { value: fullResult, children }) }) }) }) }) }) }) }) }) }) });
-}
-
-// src/sdk/components/grist-widget-provider.tsx
-import { jsx as jsx2 } from "react/jsx-runtime";
-function GristWidgetProvider({ options, children }) {
-  const managerRef = useRef5(null);
-  if (managerRef.current === null) {
-    managerRef.current = createGristHandshakeManager(buildManagerOptionsFromGristOptions(options));
-  }
-  const manager = managerRef.current;
-  useEffect4(() => {
-    manager.start();
-    return () => {
-      manager.stop();
-    };
-  }, [manager]);
-  return /* @__PURE__ */ jsx2(GristHandshakeManagerContext.Provider, { value: manager, children: /* @__PURE__ */ jsx2(GristWidgetContextTree, { options, children }) });
-}
-function useGristContext() {
-  const ctx = useContext(GristContext);
-  if (!ctx) {
-    throw new Error("useGristContext() must be used inside <GristWidgetProvider>");
-  }
-  return useGristFromProvider();
-}
-function useGristOptional() {
-  return useContext(GristContext);
-}
-
-// src/sdk/hooks/use-grist-sdk-alert-descriptors.ts
-function noopSubscribe() {
-  return () => {
-  };
-}
-function useGristSdkAlertDescriptors(widget, options) {
-  const fromContext = useGristOptional();
-  const w = widget ?? fromContext;
-  const manager = useGristManagerOptional();
-  const snapshot = useSyncExternalStore2(
-    manager?.subscribe ?? noopSubscribe,
-    manager?.getSnapshot ?? initialGristSnapshot,
-    initialGristSnapshot
-  );
-  const resolvedSnapshot = options?.snapshot ?? (manager ? snapshot : void 0);
-  const widgetInteraction = w?.widgetInteraction;
-  const readError = w && "readError" in w ? w.readError : null;
-  const alertInputs = w ? [
-    w.status,
-    w.mode,
-    widgetInteraction,
-    w.columnMappingStatus,
-    w.actionError,
-    readError,
-    w.mapBackSkipped
-  ] : null;
-  const suppressFromSlice = w?.suppressAlerts;
-  return useMemo12(
-    () => w ? getGristSdkAlertDescriptors(w, {
-      ...options,
-      suppressKinds: options?.suppressKinds ?? suppressFromSlice,
-      snapshot: resolvedSnapshot
-    }) : [],
-    [alertInputs, options, resolvedSnapshot, w, suppressFromSlice]
-  );
-}
-
-// src/sdk/components/grist-boundary.tsx
-import {
-  useCallback as useCallback9,
-  useEffect as useEffect5,
-  useMemo as useMemo13,
-  useState as useState6,
-  useSyncExternalStore as useSyncExternalStore3
-} from "react";
-import { Fragment, jsx as jsx3, jsxs } from "react/jsx-runtime";
-var shellStyle = {
-  alignItems: "center",
-  background: "var(--background)",
-  boxSizing: "border-box",
-  color: "var(--foreground)",
-  display: "flex",
-  flexDirection: "column",
-  justifyContent: "center",
-  minHeight: "100%",
-  padding: "clamp(16px, 5vh, 32px)",
-  width: "100%"
-};
-var cardStyle = {
-  background: "var(--card)",
-  border: "1px solid var(--border)",
-  borderRadius: 12,
-  boxShadow: "0 1px 3px rgb(0 0 0 / 0.12)",
-  maxWidth: 420,
-  padding: "20px 22px",
-  textAlign: "center",
-  width: "100%"
-};
-var titleStyle = {
-  color: "var(--foreground)",
-  fontSize: 15,
-  fontWeight: 600,
-  lineHeight: 1.35,
-  margin: 0
-};
-var messageStyle = {
-  color: "var(--muted-foreground)",
-  fontSize: 14,
-  lineHeight: 1.5,
-  margin: "10px 0 0"
-};
-var buttonStyle = {
-  background: "var(--background)",
-  border: "1px solid var(--border)",
-  borderRadius: 8,
-  color: "var(--foreground)",
-  cursor: "pointer",
-  fontSize: 13,
-  fontWeight: 500,
-  marginTop: 16,
-  padding: "8px 14px"
-};
-function noopSubscribe2() {
-  return () => {
-  };
-}
-function GristBoundaryScreen({
-  title,
-  message,
-  tone = "default",
-  showRetry = false,
-  actions,
-  retryLabel = "Try reconnecting",
-  retryBusyLabel = "Reconnecting\u2026"
-}) {
-  return /* @__PURE__ */ jsx3("div", { style: shellStyle, role: tone === "error" ? "alert" : "status", children: /* @__PURE__ */ jsxs("div", { style: cardStyle, children: [
-    /* @__PURE__ */ jsx3("h2", { style: titleStyle, children: title }),
-    /* @__PURE__ */ jsx3("p", { style: messageStyle, children: message }),
-    showRetry && actions ? /* @__PURE__ */ jsx3(
-      "button",
-      {
-        disabled: actions.isReloading,
-        onClick: () => void actions.reload(),
-        style: {
-          ...buttonStyle,
-          cursor: actions.isReloading ? "not-allowed" : "pointer",
-          opacity: actions.isReloading ? 0.7 : 1
-        },
-        type: "button",
-        children: actions.isReloading ? retryBusyLabel : retryLabel
-      }
-    ) : null
-  ] }) });
-}
-function BootingScreen({ message }) {
-  return /* @__PURE__ */ jsx3(
-    GristBoundaryScreen,
-    {
-      title: "Connecting to Grist",
-      message,
-      showRetry: false
-    }
-  );
-}
-function blockingScreenFromView(view, actions) {
-  return /* @__PURE__ */ jsx3(
-    GristBoundaryScreen,
-    {
-      title: view.title,
-      message: view.message,
-      tone: view.kind === "error" ? "error" : "default",
-      showRetry: view.showRetry,
-      actions,
-      retryLabel: view.kind === "error" ? "Try again" : "Try reconnecting",
-      retryBusyLabel: view.kind === "error" ? "Retrying\u2026" : "Reconnecting\u2026"
-    }
-  );
-}
-function legacyBlockingFromWidget(w, actions) {
-  if (w.status === "unavailable") {
-    return /* @__PURE__ */ jsx3(
-      GristBoundaryScreen,
-      {
-        title: "Open inside Grist",
-        message: "This page must be opened from a Grist document as a custom widget.",
-        showRetry: true,
-        actions
-      }
-    );
-  }
-  if (w.status === "error") {
-    return /* @__PURE__ */ jsx3(
-      GristBoundaryScreen,
-      {
-        title: "Something went wrong",
-        message: w.error ?? "Something went wrong connecting to Grist. Try reconnecting below, or reload the page.",
-        tone: "error",
-        showRetry: true,
-        actions,
-        retryLabel: "Try again",
-        retryBusyLabel: "Retrying\u2026"
-      }
-    );
-  }
-  if (w.status !== "ready") {
-    return /* @__PURE__ */ jsx3(BootingScreen, { message: "Connecting to Grist\u2026" });
-  }
-  return null;
-}
-function GristBoundary({
-  widget,
-  gate = "ready",
-  bootingFallback,
-  preparingFallback,
-  unavailableFallback,
-  errorFallback,
-  unavailableGraceMs = 5e3,
-  children
-}) {
-  const fromContext = useGristOptional();
-  const w = widget ?? fromContext;
-  const manager = useGristManagerOptional();
-  const snapshot = useSyncExternalStore3(
-    manager?.subscribe ?? noopSubscribe2,
-    manager?.getSnapshot ?? initialGristSnapshot,
-    initialGristSnapshot
-  );
-  if (!w) {
-    throw new Error(
-      "<GristBoundary> requires either a `widget` prop or a parent <GristWidgetProvider>"
-    );
-  }
-  const boundaryView = useMemo13(
-    () => manager ? deriveBoundaryView(snapshot) : null,
-    [manager, snapshot]
-  );
-  const [showUnavailable, setShowUnavailable] = useState6(false);
-  const [isReloading, setIsReloading] = useState6(false);
-  useEffect5(() => {
-    if (w.status !== "unavailable") {
-      setShowUnavailable(false);
-      return;
-    }
-    const timer = window.setTimeout(() => setShowUnavailable(true), unavailableGraceMs);
-    return () => window.clearTimeout(timer);
-  }, [unavailableGraceMs, w.status]);
-  const reload = useCallback9(async () => {
-    const MIN_RELOAD_VISIBILITY_MS = 700;
-    const startedAt = Date.now();
-    setIsReloading(true);
-    try {
-      await w.reload();
-    } catch (error) {
-      console.error("[grist-sdk] reload failed:", error);
-    } finally {
-      const elapsed = Date.now() - startedAt;
-      const remaining = Math.max(0, MIN_RELOAD_VISIBILITY_MS - elapsed);
-      if (remaining > 0) {
-        await new Promise((resolve) => window.setTimeout(resolve, remaining));
-      }
-      setIsReloading(false);
-    }
-  }, [w]);
-  const actions = useMemo13(
-    () => ({ reload, isReloading }),
-    [isReloading, reload]
-  );
-  const canRender = gate !== "canRender" || !manager || deriveCapabilities(snapshot).canRender;
-  const defaultPreparing = /* @__PURE__ */ jsx3(
-    GristBoundaryScreen,
-    {
-      title: GRIST_BOUNDARY_PREPARING_COPY.title,
-      message: GRIST_BOUNDARY_PREPARING_COPY.message,
-      showRetry: false
-    }
-  );
-  if (!manager) {
-    const legacy = legacyBlockingFromWidget(w, actions);
-    if (legacy) return /* @__PURE__ */ jsx3(Fragment, { children: legacy });
-    if (!canRender) return /* @__PURE__ */ jsx3(Fragment, { children: preparingFallback ?? defaultPreparing });
-    return /* @__PURE__ */ jsx3(Fragment, { children });
-  }
-  if (w.status === "unavailable") {
-    if (!showUnavailable) {
-      const boot = boundaryView?.mode === "blocking" && boundaryView.kind === "booting" ? boundaryView.message : "Connecting to Grist\u2026";
-      return /* @__PURE__ */ jsx3(Fragment, { children: bootingFallback ?? /* @__PURE__ */ jsx3(BootingScreen, { message: boot }) });
-    }
-    if (typeof unavailableFallback === "function") {
-      return /* @__PURE__ */ jsx3(Fragment, { children: unavailableFallback(actions) });
-    }
-    if (unavailableFallback) return /* @__PURE__ */ jsx3(Fragment, { children: unavailableFallback });
-    if (boundaryView?.mode === "blocking") {
-      return /* @__PURE__ */ jsx3(Fragment, { children: blockingScreenFromView(boundaryView, actions) });
-    }
-  }
-  if (w.status === "error") {
-    if (errorFallback) {
-      return /* @__PURE__ */ jsx3(Fragment, { children: errorFallback(w.error ?? "Grist connection error", actions) });
-    }
-    if (boundaryView?.mode === "blocking") {
-      return /* @__PURE__ */ jsx3(Fragment, { children: blockingScreenFromView(boundaryView, actions) });
-    }
-  }
-  if (w.status !== "ready") {
-    if (boundaryView?.mode === "blocking" && boundaryView.kind === "booting") {
-      return /* @__PURE__ */ jsx3(Fragment, { children: bootingFallback ?? /* @__PURE__ */ jsx3(BootingScreen, { message: boundaryView.message }) });
-    }
-    return /* @__PURE__ */ jsx3(Fragment, { children: bootingFallback ?? /* @__PURE__ */ jsx3(BootingScreen, { message: "Connecting to Grist\u2026" }) });
-  }
-  if (!canRender) {
-    return /* @__PURE__ */ jsx3(Fragment, { children: preparingFallback ?? defaultPreparing });
-  }
-  return /* @__PURE__ */ jsx3(Fragment, { children });
-}
-
-// src/sdk/use-grist.ts
-import { useMemo as useMemo14 } from "react";
-import { useContext as useContext2 } from "react";
-function useGristStandalone(options) {
-  const slices = useComposeGristWidgetSlices(options);
-  return useMemo14(() => mergeGristResultFromSlices(slices), [slices]);
-}
-function useGrist(options) {
-  if (useContext2(GristCoreContext)) {
-    return useGristFromProvider();
-  }
-  return useGristStandalone(options);
-}
-function useGristStatus() {
-  const core = useGristCoreContext();
-  const currentTable = useGristCurrentTableContext();
-  return useMemo14(() => ({ ...core, ...currentTable }), [core, currentTable]);
-}
-function useGristSelection() {
-  return useGristSelectionContext();
-}
-function useGristWrites() {
-  return useGristWritesContext();
-}
-function useGristTheme2() {
-  return useGristThemeContext();
-}
-
-// src/sdk/use-grist-schema.ts
-import { useCallback as useCallback10, useContext as useContext3, useEffect as useEffect6, useMemo as useMemo15, useState as useState7 } from "react";
-function filterReplicaDocumentColumns(document2, options, extraExcludeColumn) {
-  return {
-    ...document2,
-    tables: Object.fromEntries(
-      Object.entries(document2.tables).map(([tableId, table]) => [
-        tableId,
-        {
-          ...table,
-          columns: Object.fromEntries(
-            Object.entries(table.columns ?? {}).filter(([colId, col]) => {
-              if (isGristNoiseColumn(colId, col, options)) return false;
-              if (extraExcludeColumn?.({ tableId, colId, col })) return false;
-              return true;
-            })
-          )
-        }
-      ])
-    )
-  };
-}
-function useGristSchema(options) {
-  const requiredAccess = options?.requiredAccess ?? "read table";
-  const requestedTableId = options?.tableId;
-  const excludeSystemTableData = options?.excludeSystemTableData ?? true;
-  const replicaRowMode = options?.replicaRowMode ?? "schema+samples";
-  const sampleRowLimit = options?.sampleRowLimit ?? 10;
-  const replicaSource = options?.source;
-  const excludeId = options?.excludeId ?? true;
-  const excludeGristHelpers = options?.excludeGristHelpers ?? true;
-  const excludeLoggingColumns = options?.excludeLoggingColumns ?? true;
-  const excludeManualSort = options?.excludeManualSort ?? false;
-  const extraExcludeColumn = options?.extraExcludeColumn;
-  const { isAvailable, docApi, error: readyError } = useGristReady({
-    requiredAccess,
-    columns: options?.columns,
-    allowSelectBy: options?.allowSelectBy,
-    hasCustomOptions: options?.hasCustomOptions,
-    onEditOptions: options?.onEditOptions
-  });
-  const providerBuildReplica = useContext3(GristReadsContext)?.buildReplicaDocumentFromDocApi;
-  const [document2, setDocument] = useState7(null);
-  const [loading, setLoading] = useState7(false);
-  const [error, setError] = useState7(null);
-  const includeRowsForBuild = replicaRowMode === "schema-only" ? false : replicaRowMode === "schema+data" ? "full" : "samples";
-  const load = useCallback10(async () => {
-    if (!docApi) return;
-    setLoading(true);
-    setError(null);
-    try {
-      const buildOpts = {
-        includeSystemTableData: !excludeSystemTableData,
-        includeRows: includeRowsForBuild,
-        sampleRowLimit,
-        source: replicaSource
-      };
-      const raw = providerBuildReplica ? await providerBuildReplica(buildOpts) : await buildReplicaDocumentFromDocApi(docApi, buildOpts);
-      const filtered = filterReplicaDocumentColumns(
-        raw,
-        {
-          excludeId,
-          excludeGristHelpers,
-          excludeLoggingColumns,
-          excludeManualSort
-        },
-        extraExcludeColumn
-      );
-      setDocument(filtered);
-    } catch (err) {
-      setDocument(null);
-      setError(err instanceof Error ? err.message : String(err));
-    } finally {
-      setLoading(false);
-    }
-  }, [
-    docApi,
-    providerBuildReplica,
-    excludeSystemTableData,
-    replicaRowMode,
-    sampleRowLimit,
-    excludeId,
-    excludeGristHelpers,
-    excludeLoggingColumns,
-    excludeManualSort,
-    extraExcludeColumn,
-    replicaSource
-  ]);
-  useEffect6(() => {
-    if (docApi) void load();
-  }, [docApi, load]);
-  const buildDocumentJson = useCallback10((target, options2) => {
-    const includeRows = options2?.includeRows ?? "full";
-    const space = options2?.space ?? 2;
-    const payload = buildReplicaJsonPayload(target, {
-      includeRows,
-      sampleRowLimit: options2?.sampleRowLimit ?? sampleRowLimit
-    });
-    return JSON.stringify(payload, null, space);
-  }, [sampleRowLimit]);
-  const getDocumentJson = useCallback10(
-    (options2) => {
-      if (!document2) return null;
-      return buildDocumentJson(document2, options2);
-    },
-    [document2, buildDocumentJson]
-  );
-  const table = useMemo15(() => {
-    if (!document2 || !requestedTableId) return null;
-    const slice = document2.tables[requestedTableId];
-    if (!slice) return null;
-    return { tableId: requestedTableId, ...slice };
-  }, [document2, requestedTableId]);
-  const buildTableJson = useCallback10(
-    (target, options2) => {
-      const includeRows = options2?.includeRows ?? "full";
-      const limit = options2?.sampleRowLimit ?? sampleRowLimit;
-      const space = options2?.space ?? 2;
-      const { tableId, ...rest } = target;
-      let body = { ...rest };
-      if (includeRows === "none") {
-        const { rows: _r, ...r } = body;
-        body = r;
-      } else if (includeRows === "samples") {
-        const r = body.rows ?? [];
-        body = { ...body, rows: r.slice(0, limit) };
-      }
-      return JSON.stringify({ tableId, ...body }, null, space);
-    },
-    [sampleRowLimit]
-  );
-  const getTableJson = useCallback10(
-    (options2) => {
-      if (!table) return null;
-      return buildTableJson(table, options2);
-    },
-    [table, buildTableJson]
-  );
-  const noiseColumnMatcher = useCallback10(
-    (colId, col) => isGristNoiseColumn(colId, col, {
-      excludeId,
-      excludeGristHelpers,
-      excludeLoggingColumns,
-      excludeManualSort
-    }),
-    [excludeId, excludeGristHelpers, excludeLoggingColumns, excludeManualSort]
-  );
-  const sortColumns = useCallback10((colIds, columns) => {
-    return [...colIds].sort((a, b) => {
-      const la = (columns[a]?.label || a).toLowerCase();
-      const lb = (columns[b]?.label || b).toLowerCase();
-      if (la !== lb) return la.localeCompare(lb);
-      return a.localeCompare(b);
-    });
-  }, []);
-  return {
-    isAvailable,
-    document: document2,
-    replicaDocument: document2,
-    table,
-    documentJson: document2 ? buildDocumentJson(document2) : null,
-    getDocumentJson,
-    buildDocumentJson,
-    tableJson: table ? buildTableJson(table) : null,
-    getTableJson,
-    buildTableJson,
-    isNoiseColumnId: noiseColumnMatcher,
-    sortColumnIds: sortColumns,
-    loading,
-    error: readyError ?? error,
-    reload: load
-  };
-}
-
-// src/sdk/use-widget-metadata.ts
-import { useEffect as useEffect7 } from "react";
-function useWidgetMetadata(input) {
-  useEffect7(() => {
-    if (!input) return;
-    const { title, description, syncToParent = true } = input;
-    const canonicalUrl = window.location.href;
-    document.title = title;
-    setMetaTag("name", "title", title);
-    setMetaTag("name", "description", description);
-    setMetaTag("property", "og:title", title);
-    setMetaTag("property", "og:description", description);
-    setMetaTag("property", "og:type", "website");
-    setMetaTag("property", "og:url", canonicalUrl);
-    setMetaTag("name", "twitter:card", "summary");
-    setMetaTag("name", "twitter:title", title);
-    setMetaTag("name", "twitter:description", description);
-    if (!syncToParent) return;
-    window.parent?.postMessage(
-      {
-        source: "grist-playground-widget",
-        type: "metadata",
-        title,
-        description
-      },
-      "*"
-    );
-  }, [input]);
-}
-function setMetaTag(key, value, content) {
-  let meta = document.head.querySelector(
-    `meta[${key}="${value}"]`
-  );
-  if (!meta) {
-    meta = document.createElement("meta");
-    meta.setAttribute(key, value);
-    document.head.appendChild(meta);
-  }
-  meta.setAttribute("content", content);
-}
 export {
   GRIST_BOUNDARY_PREPARING_COPY,
   GristBoundary,
@@ -2441,7 +207,7 @@ export {
   useGristSdkAlertDescriptors,
   useGristSelection,
   useGristStatus,
-  useGristTheme2 as useGristTheme,
+  useGristTheme,
   useGristWidgetOptionsFromContext,
   useGristWrites,
   useWidgetMetadata,