grist-widget-sdk 0.2.0

package/dist/chunk-QKXKZ27D.js

@@ -0,0 +1,1189 @@
+import {
+  normalizeReplicaDocumentInput
+} from "./chunk-GTTD5HPO.js";
+import {
+  resolveMappings
+} from "./chunk-PM3B4WYV.js";
+import {
+  coerceGristDocApiRefRowId,
+  gristAddRecordAction,
+  gristBulkAddRecordAction,
+  gristBulkRemoveRecordAction,
+  gristBulkUpdateRecordAction,
+  gristRemoveRecordAction,
+  gristUpdateRecordAction,
+  inferDisplayHelpersByRef
+} from "./chunk-64SVRWW7.js";
+
+// src/emulator/transports/iframe.ts
+import { MsgType, Rpc } from "grain-rpc";
+
+// src/emulator/theme-message.ts
+function buildGristThemeHostMessage(appearance, options) {
+  return {
+    theme: {
+      appearance,
+      name: appearance,
+      colors: {}
+    },
+    ...options?.fromReady ? { fromReady: true } : {}
+  };
+}
+
+// src/emulator/transports/iframe.ts
+function createIframeTransport(options) {
+  const { iframe, state, bus, api, targetOrigin = "*" } = options;
+  const timers = /* @__PURE__ */ new Set();
+  const rpc = new Rpc({
+    sendMessage: (msg) => {
+      const target = iframe.contentWindow;
+      if (!target) return;
+      target.postMessage(msg, targetOrigin);
+    },
+    logger: { info: () => {
+    }, warn: () => {
+    } }
+  });
+  rpc.queueOutgoingUntilReadyMessage();
+  const receiveFromWidget = rpc.receiveMessage.bind(rpc);
+  rpc.receiveMessage = (msg) => {
+    if (msg && typeof msg === "object" && msg.mtype === MsgType.RpcCall && msg.mdest === "grist") {
+      const copy = { ...msg };
+      delete copy.mdest;
+      receiveFromWidget(copy);
+      return;
+    }
+    receiveFromWidget(msg);
+  };
+  const onMessage = (event) => {
+    if (event.source !== iframe.contentWindow) return;
+    if (!isRpcEnvelope(event.data)) return;
+    rpc.receiveMessage(event.data);
+  };
+  window.addEventListener("message", onMessage);
+  rpc.registerImpl("GristView", api.GristView);
+  rpc.registerImpl("GristDocAPI", api.GristDocAPI);
+  rpc.registerImpl("WidgetAPI", api.WidgetAPI);
+  rpc.registerImpl("CustomSectionAPI", api.CustomSectionAPI);
+  rpc.registerImpl("_grist_api", api.GristAPI);
+  rpc.registerImpl("CommandAPI", api.CommandAPI);
+  const buildInteraction = options.buildInteraction ?? defaultInteraction(state);
+  const cursorOf = options.cursor ?? (() => state.selection.cursor);
+  const initialCursorOf = options.initialCursor ?? (() => state.selection.rowId);
+  function fireDataChange(tableId, opts) {
+    safePostMessage({
+      tableId: tableId ?? state.selection.tableId,
+      dataChange: true,
+      ...opts?.mappingsChange ? { mappingsChange: true } : {}
+    });
+  }
+  function fireCursor(rowId, opts) {
+    const id = rowId === void 0 ? initialCursorOf() : rowId;
+    if (id === null) return;
+    safePostMessage({
+      tableId: state.selection.tableId,
+      rowId: id,
+      cursor: cursorOf(),
+      ...opts?.mappingsChange ? { mappingsChange: true } : {}
+    });
+  }
+  function fireOptions() {
+    safePostMessage({
+      options: hasOptions(state.widgetOptions) ? { ...state.widgetOptions } : null,
+      settings: { ...buildInteraction() }
+    });
+  }
+  function fireTheme(message) {
+    safePostMessage(message);
+  }
+  function emitInitialState(opts) {
+    fireOptions();
+    if (options.initialTheme) {
+      fireTheme(buildGristThemeHostMessage(options.initialTheme, { fromReady: true }));
+    }
+    fireDataChange(void 0, opts);
+    fireCursor(void 0, opts);
+  }
+  function emitInitialStateWithReplay(opts) {
+    emitInitialState(opts);
+    queueMicrotask(() => emitInitialState(opts));
+    const timer = setTimeout(() => {
+      timers.delete(timer);
+      emitInitialState(opts);
+    }, 0);
+    timers.add(timer);
+  }
+  const offBus = bus.on((event) => {
+    switch (event.type) {
+      case "ready":
+        emitInitialStateWithReplay();
+        break;
+      case "data-change":
+        fireDataChange(event.tableId);
+        break;
+      case "cursor-change": {
+        const rowId = event.rowId === null ? state.selection.rowId : event.rowId;
+        if (rowId !== null) {
+          safePostMessage({
+            tableId: event.tableId,
+            rowId,
+            cursor: cursorOf()
+          });
+        }
+        fireDataChange(event.tableId);
+        break;
+      }
+      case "options-change":
+        fireOptions();
+        break;
+      case "mappings-change":
+        emitInitialStateWithReplay({ mappingsChange: true });
+        break;
+      case "theme-change":
+        fireTheme(event.message);
+        break;
+    }
+  });
+  rpc.processIncoming();
+  function safePostMessage(payload) {
+    try {
+      rpc.postMessage(payload);
+    } catch (err) {
+      console.warn("[grist-emulator/iframe] failed to deliver postMessage", err);
+    }
+  }
+  return {
+    dispose() {
+      window.removeEventListener("message", onMessage);
+      offBus();
+      for (const timer of timers) clearTimeout(timer);
+      timers.clear();
+    },
+    fireDataChange,
+    fireCursor,
+    fireOptions,
+    fireTheme,
+    emitInitialState
+  };
+}
+function hasOptions(options) {
+  return Object.keys(options).length > 0;
+}
+function isRpcEnvelope(data) {
+  if (!data || typeof data !== "object") return false;
+  return typeof data.mtype === "number";
+}
+function defaultInteraction(state) {
+  return () => ({
+    access_level: state.configuration?.requiredAccess ?? "read table",
+    ...state.widgetInteraction
+  });
+}
+
+// src/emulator/core/document.ts
+var SYSTEM_COLUMN = "id";
+var EMULATOR_JS_FORMULA_PLACEHOLDER = "(emulator JavaScript formula)";
+function enrichEmulatorColumnMetadata(col) {
+  const originalTrimmed = col.formula?.trim() ?? "";
+  const explicitInferred = col.inferredFormula?.trim() ?? "";
+  if (col.formulaFn) {
+    const inferredFormula = explicitInferred || originalTrimmed || EMULATOR_JS_FORMULA_PLACEHOLDER;
+    return {
+      ...col,
+      ...originalTrimmed ? { formula: col.formula } : {},
+      inferredFormula
+    };
+  }
+  if (explicitInferred || originalTrimmed) {
+    return {
+      ...col,
+      inferredFormula: explicitInferred || originalTrimmed || void 0
+    };
+  }
+  return col;
+}
+function sortEmulatorColumnsByParentPos(columns) {
+  const entries = Object.entries(columns);
+  entries.sort(([ka, a], [kb, b]) => {
+    const pa = a.parentPos;
+    const pb = 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 ka.localeCompare(kb);
+  });
+  return Object.fromEntries(entries);
+}
+function inferColumnsFromRows(rows) {
+  const columns = {};
+  for (const row of rows) {
+    for (const key of Object.keys(row)) {
+      if (key === SYSTEM_COLUMN) continue;
+      if (!columns[key]) columns[key] = inferColumnType(row[key]);
+    }
+  }
+  return columns;
+}
+function inferColumnType(sample) {
+  switch (typeof sample) {
+    case "number":
+      return { type: "Numeric" };
+    case "boolean":
+      return { type: "Bool" };
+    case "string":
+      return { type: "Text" };
+    default:
+      return { type: "Any" };
+  }
+}
+function buildTable(tableId, input) {
+  const rows = input.rows ?? [];
+  const inferred = inferColumnsFromRows(rows);
+  const merged = {};
+  for (const [colId, col] of Object.entries({ ...inferred, ...input.columns ?? {} })) {
+    merged[colId] = enrichEmulatorColumnMetadata(col);
+  }
+  const columns = sortEmulatorColumnsByParentPos(merged);
+  return {
+    tableId,
+    label: input.label,
+    columns,
+    rows: rows.map((row) => ({ ...row }))
+  };
+}
+function createDocument(input) {
+  if (!input.tables || Object.keys(input.tables).length === 0) {
+    throw new Error("createDocument: at least one table is required");
+  }
+  const normalized = normalizeReplicaDocumentInput(input);
+  const tables = /* @__PURE__ */ new Map();
+  for (const [tableId, tableInput] of Object.entries(normalized.tables)) {
+    tables.set(tableId, buildTable(tableId, tableInput));
+  }
+  const firstTableId = tables.keys().next().value;
+  const requestedTableId = normalized.selection?.tableId;
+  const selectedTableId = requestedTableId && tables.has(requestedTableId) ? requestedTableId : firstTableId;
+  const selectedTable = tables.get(selectedTableId);
+  const fallbackRowId = typeof selectedTable.rows[0]?.id === "number" ? selectedTable.rows[0].id : null;
+  const selection = {
+    tableId: selectedTableId,
+    rowId: normalized.selection?.rowId ?? fallbackRowId,
+    mappings: normalized.selection?.mappings,
+    cursor: normalized.selection?.cursor
+  };
+  return {
+    docName: normalized.docName ?? "Untitled emulator document",
+    tables,
+    selection,
+    widgetOptions: { ...normalized.widgetOptions ?? {} },
+    widgetInteraction: { ...normalized.widgetInteraction ?? {} },
+    configuration: normalized.configuration ?? null,
+    accessToken: normalized.accessToken ?? null
+  };
+}
+function getTable(state, tableId) {
+  const table = state.tables.get(tableId);
+  if (!table) throw new Error(`Unknown table: ${tableId}`);
+  return table;
+}
+function getSelectedTable(state) {
+  return getTable(state, state.selection.tableId);
+}
+function nextRowId(table) {
+  let max = 0;
+  for (const row of table.rows) {
+    if (typeof row.id === "number" && row.id > max) max = row.id;
+  }
+  return max + 1;
+}
+function findRow(table, rowId) {
+  return table.rows.find((r) => r.id === rowId);
+}
+function findRowIndex(table, rowId) {
+  return table.rows.findIndex((r) => r.id === rowId);
+}
+function evaluateRowFormulas(state, table, row) {
+  for (const [colId, col] of Object.entries(table.columns)) {
+    if (col.formulaFn) {
+      try {
+        row[colId] = col.formulaFn(row, { table, document: state });
+      } catch (err) {
+        row[colId] = formulaError(err);
+      }
+    }
+  }
+}
+function escapeRegExp(s) {
+  return s.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+function extractRefListIdsFromWire(raw) {
+  if (raw == null) return [];
+  if (!Array.isArray(raw)) return [];
+  const items = raw[0] === "L" ? raw.slice(1) : raw;
+  const out = [];
+  for (const item of items) {
+    if (typeof item === "number" && Number.isFinite(item) && item > 0) {
+      out.push(Math.trunc(item));
+      continue;
+    }
+    if (item && typeof item === "object" && "rowId" in item) {
+      const r = item.rowId;
+      if (typeof r === "number" && Number.isFinite(r) && r > 0) {
+        out.push(Math.trunc(r));
+        continue;
+      }
+    }
+    const t = coerceGristDocApiRefRowId(item);
+    if (t !== void 0 && t > 0) out.push(Math.trunc(t));
+  }
+  return Array.from(new Set(out));
+}
+function fieldFromRefListHelperFormula(formula, refColId) {
+  if (!formula) return null;
+  const re = new RegExp(`\\$${escapeRegExp(refColId)}\\.([A-Za-z_]\\w*)`);
+  const m = formula.match(re);
+  return m?.[1] ?? null;
+}
+function firstTextLikeColumnId(columns) {
+  let best = null;
+  for (const [colId, col] of Object.entries(columns)) {
+    if (colId === "id" || colId.startsWith("gristHelper_")) continue;
+    const t = col.type;
+    if (t !== "Text" && t !== "Choice") continue;
+    const pos = col.parentPos ?? 99999;
+    if (!best || pos < best.pos) best = { id: colId, pos };
+  }
+  return best?.id ?? null;
+}
+function formatLabelFromCell(value) {
+  if (value == null) return "";
+  if (typeof value === "string") return value.trim();
+  if (typeof value === "number" || typeof value === "boolean") return String(value);
+  if (value instanceof Date) return value.toISOString();
+  if (Array.isArray(value) && value[0] === "E") return "";
+  if (typeof value === "object" && value && "__ref" in value) {
+    const r = value.rowId;
+    return typeof r === "number" && Number.isFinite(r) ? String(r) : "";
+  }
+  return "";
+}
+function syncRefListDisplayHelpers(state, table, row) {
+  const displayHelpersByRef = inferDisplayHelpersByRef(table.columns);
+  for (const [colId, col] of Object.entries(table.columns)) {
+    const type = col.type;
+    if (typeof type !== "string" || !type.startsWith("RefList:")) continue;
+    const helperColId = displayHelpersByRef[colId];
+    if (!helperColId) continue;
+    const helperMeta = table.columns[helperColId];
+    if (!helperMeta || helperMeta.formulaFn) continue;
+    const targetTableId = type.slice("RefList:".length);
+    const targetTable = state.tables.get(targetTableId);
+    if (!targetTable) continue;
+    const ids = extractRefListIdsFromWire(row[colId]);
+    if (ids.length === 0) {
+      row[helperColId] = [];
+      continue;
+    }
+    const fieldId = fieldFromRefListHelperFormula(helperMeta.formula, colId) ?? firstTextLikeColumnId(targetTable.columns);
+    const labels = ids.map((rid) => {
+      if (!fieldId) return String(rid);
+      const trow = findRow(targetTable, rid);
+      if (!trow) return String(rid);
+      const lbl = formatLabelFromCell(trow[fieldId]);
+      return lbl !== "" ? lbl : String(rid);
+    });
+    row[helperColId] = labels;
+  }
+}
+function formulaError(err) {
+  const message = err instanceof Error ? err.message : String(err);
+  return ["E", "Error", message];
+}
+function synthesizeTablesMeta(state) {
+  const ids = [];
+  const tableIds = [];
+  const labels = [];
+  let nextId = 1;
+  for (const [tableId, table] of state.tables.entries()) {
+    ids.push(nextId);
+    tableIds.push(tableId);
+    labels.push(table.label ?? null);
+    nextId += 1;
+  }
+  return {
+    id: ids,
+    tableId: tableIds,
+    // Optional human-readable label; real Grist keeps more fields, but these
+    // are sufficient for `buildReplicaDocumentFromDocApi` to resolve table ids.
+    label: labels
+  };
+}
+function synthesizeTablesColumnMeta(state) {
+  const parentIds = [];
+  const colIds = [];
+  const columnIds = [];
+  const types = [];
+  const labels = [];
+  const parentPos = [];
+  const isFormula = [];
+  const formulas = [];
+  const descriptions = [];
+  const widgetOptions = [];
+  const displayCol = [];
+  const visibleCol = [];
+  const tableIdToInternalId = /* @__PURE__ */ new Map();
+  {
+    let nextId = 1;
+    for (const [tableId] of state.tables.entries()) {
+      tableIdToInternalId.set(tableId, nextId);
+      nextId += 1;
+    }
+  }
+  for (const [tableId, table] of state.tables.entries()) {
+    const parentInternalId = tableIdToInternalId.get(tableId);
+    if (parentInternalId === void 0) continue;
+    for (const [colId, col] of Object.entries(table.columns)) {
+      parentIds.push(parentInternalId);
+      colIds.push(colId);
+      const ref = typeof col.colRef === "number" ? col.colRef : columnIds.length + 1;
+      columnIds.push(ref);
+      types.push(col.type ?? null);
+      labels.push(col.label ?? null);
+      parentPos.push(col.parentPos ?? null);
+      isFormula.push(Boolean(col.isFormula));
+      const formula = typeof col.formula === "string" ? col.formula : null;
+      formulas.push(formula);
+      descriptions.push(col.description ?? null);
+      widgetOptions.push(col.widgetOptions ?? null);
+      displayCol.push(typeof col.displayColRef === "number" ? col.displayColRef : null);
+      visibleCol.push(typeof col.visibleColRef === "number" ? col.visibleColRef : null);
+    }
+  }
+  return {
+    parentId: parentIds,
+    colId: colIds,
+    id: columnIds,
+    type: types,
+    label: labels,
+    parentPos,
+    isFormula,
+    formula: formulas,
+    description: descriptions,
+    // Also expose legacy `descr` for robustness.
+    descr: descriptions,
+    widgetOptions,
+    displayCol,
+    visibleCol
+  };
+}
+
+// src/emulator/core/action-engine.ts
+var EmulatorActionError = class extends Error {
+  constructor(action, message) {
+    super(message);
+    this.action = action;
+    this.name = "EmulatorActionError";
+  }
+};
+function applyUserActions(state, bus, actions) {
+  const retValues = [];
+  const changed = /* @__PURE__ */ new Set();
+  for (const action of actions) {
+    bus.emit({ type: "user-action", action });
+    const ret = applySingle(state, action, changed);
+    retValues.push(ret);
+  }
+  for (const tableId of changed) {
+    bus.emit({ type: "data-change", tableId });
+  }
+  return { retValues, changedTableIds: [...changed] };
+}
+function applySingle(state, action, changed) {
+  const [name, ...args] = action;
+  switch (name) {
+    case "AddRecord":
+      return addRecord(state, args, changed);
+    case "BulkAddRecord":
+      return bulkAddRecord(state, args, changed);
+    case "UpdateRecord":
+      return updateRecord(state, args, changed);
+    case "BulkUpdateRecord":
+      return bulkUpdateRecord(state, args, changed);
+    case "RemoveRecord":
+      return removeRecord(state, args, changed);
+    case "BulkRemoveRecord":
+      return bulkRemoveRecord(state, args, changed);
+    case "AddColumn":
+      return addColumn(state, args);
+    case "AddVisibleColumn":
+      return addColumn(state, args);
+    case "RemoveColumn":
+      return removeColumn(state, args, changed);
+    case "RenameColumn":
+      return renameColumn(state, args, changed);
+    case "ModifyColumn":
+      return modifyColumn(state, args, changed);
+    case "AddTable":
+      return addTable(state, args);
+    case "RemoveTable":
+      return removeTable(state, args);
+    case "RenameTable":
+      return renameTable(state, args);
+    default:
+      throw new EmulatorActionError(action, `Unsupported user action: ${String(name)}`);
+  }
+}
+function addRecord(state, [tableId, rowId, values], changed) {
+  const table = getTable(state, requireString(tableId, "AddRecord.tableId"));
+  const id = typeof rowId === "number" ? rowId : nextRowId(table);
+  const normalizedValues = normalizeValuesForTable(
+    table,
+    values ?? {}
+  );
+  const row = { id, ...normalizedValues };
+  ensureColumns(table, normalizedValues);
+  evaluateRowFormulas(state, table, row);
+  syncRefListDisplayHelpers(state, table, row);
+  table.rows.push(row);
+  changed.add(table.tableId);
+  return id;
+}
+function bulkAddRecord(state, [tableId, rowIds, columnar], changed) {
+  const table = getTable(state, requireString(tableId, "BulkAddRecord.tableId"));
+  const cols = normalizeColumnarForTable(
+    table,
+    columnar ?? {}
+  );
+  const ids = Array.isArray(rowIds) ? rowIds : [];
+  const length = ids.length || lengthOf(cols);
+  const out = [];
+  ensureColumns(table, cols, true);
+  for (let i = 0; i < length; i++) {
+    const id = typeof ids[i] === "number" ? ids[i] : nextRowId(table);
+    const row = { id };
+    for (const colId of Object.keys(cols)) row[colId] = cols[colId][i];
+    evaluateRowFormulas(state, table, row);
+    syncRefListDisplayHelpers(state, table, row);
+    table.rows.push(row);
+    out.push(id);
+  }
+  changed.add(table.tableId);
+  return out;
+}
+function updateRecord(state, [tableId, rowId, values], changed) {
+  const table = getTable(state, requireString(tableId, "UpdateRecord.tableId"));
+  const id = requireNumber(rowId, "UpdateRecord.rowId");
+  const row = findRow(table, id);
+  if (!row) throw new EmulatorActionError(["UpdateRecord", tableId, rowId, values], `Row ${id} not found in ${table.tableId}`);
+  const normalizedValues = normalizeValuesForTable(
+    table,
+    values ?? {}
+  );
+  ensureColumns(table, normalizedValues);
+  Object.assign(row, normalizedValues);
+  evaluateRowFormulas(state, table, row);
+  syncRefListDisplayHelpers(state, table, row);
+  changed.add(table.tableId);
+  return null;
+}
+function bulkUpdateRecord(state, [tableId, rowIds, columnar], changed) {
+  const table = getTable(state, requireString(tableId, "BulkUpdateRecord.tableId"));
+  const ids = rowIds;
+  const cols = normalizeColumnarForTable(
+    table,
+    columnar ?? {}
+  );
+  ensureColumns(table, cols, true);
+  ids.forEach((id, idx) => {
+    const row = findRow(table, id);
+    if (!row) throw new EmulatorActionError(["BulkUpdateRecord", tableId, ids, cols], `Row ${id} not found in ${table.tableId}`);
+    for (const colId of Object.keys(cols)) row[colId] = cols[colId][idx];
+    evaluateRowFormulas(state, table, row);
+    syncRefListDisplayHelpers(state, table, row);
+  });
+  changed.add(table.tableId);
+  return null;
+}
+function removeRecord(state, [tableId, rowId], changed) {
+  const table = getTable(state, requireString(tableId, "RemoveRecord.tableId"));
+  const id = requireNumber(rowId, "RemoveRecord.rowId");
+  const idx = findRowIndex(table, id);
+  if (idx >= 0) table.rows.splice(idx, 1);
+  if (state.selection.tableId === table.tableId && state.selection.rowId === id) {
+    state.selection.rowId = table.rows[0]?.id ?? null;
+  }
+  changed.add(table.tableId);
+  return null;
+}
+function bulkRemoveRecord(state, [tableId, rowIds], changed) {
+  const table = getTable(state, requireString(tableId, "BulkRemoveRecord.tableId"));
+  const ids = new Set(rowIds);
+  table.rows = table.rows.filter((r) => !ids.has(r.id));
+  if (state.selection.tableId === table.tableId && typeof state.selection.rowId === "number" && ids.has(state.selection.rowId)) {
+    state.selection.rowId = table.rows[0]?.id ?? null;
+  }
+  changed.add(table.tableId);
+  return null;
+}
+function addColumn(state, [tableId, colId, info]) {
+  const table = getTable(state, requireString(tableId, "AddColumn.tableId"));
+  const col = requireString(colId, "AddColumn.colId");
+  if (table.columns[col]) throw new EmulatorActionError(["AddColumn", tableId, colId], `Column ${col} already exists`);
+  table.columns[col] = info ?? {};
+  for (const row of table.rows) {
+    if (!(col in row)) row[col] = null;
+  }
+  return null;
+}
+function removeColumn(state, [tableId, colId], changed) {
+  const table = getTable(state, requireString(tableId, "RemoveColumn.tableId"));
+  const col = requireString(colId, "RemoveColumn.colId");
+  delete table.columns[col];
+  for (const row of table.rows) delete row[col];
+  changed.add(table.tableId);
+  return null;
+}
+function renameColumn(state, [tableId, colId, newColId], changed) {
+  const table = getTable(state, requireString(tableId, "RenameColumn.tableId"));
+  const from = requireString(colId, "RenameColumn.colId");
+  const to = requireString(newColId, "RenameColumn.newColId");
+  if (!table.columns[from]) throw new EmulatorActionError(["RenameColumn", tableId, from, to], `Column ${from} not found`);
+  if (from === to) return null;
+  table.columns[to] = table.columns[from];
+  delete table.columns[from];
+  for (const row of table.rows) {
+    if (from in row) {
+      row[to] = row[from];
+      delete row[from];
+    }
+  }
+  changed.add(table.tableId);
+  return null;
+}
+function modifyColumn(state, [tableId, colId, info], changed) {
+  const table = getTable(state, requireString(tableId, "ModifyColumn.tableId"));
+  const col = requireString(colId, "ModifyColumn.colId");
+  if (!table.columns[col]) throw new EmulatorActionError(["ModifyColumn", tableId, colId], `Column ${col} not found`);
+  table.columns[col] = { ...table.columns[col], ...info };
+  changed.add(table.tableId);
+  return null;
+}
+function addTable(state, [tableId, columns]) {
+  const id = requireString(tableId, "AddTable.tableId");
+  if (state.tables.has(id)) throw new EmulatorActionError(["AddTable", tableId], `Table ${id} already exists`);
+  const cols = {};
+  for (const c of columns ?? []) {
+    cols[c.id] = { ...c };
+  }
+  state.tables.set(id, { tableId: id, columns: cols, rows: [] });
+  return id;
+}
+function removeTable(state, [tableId]) {
+  const id = requireString(tableId, "RemoveTable.tableId");
+  state.tables.delete(id);
+  if (state.selection.tableId === id) {
+    const fallback = state.tables.keys().next().value;
+    if (fallback) {
+      state.selection.tableId = fallback;
+      state.selection.rowId = null;
+    }
+  }
+  return null;
+}
+function renameTable(state, [from, to]) {
+  const fromId = requireString(from, "RenameTable.from");
+  const toId = requireString(to, "RenameTable.to");
+  const table = state.tables.get(fromId);
+  if (!table) throw new EmulatorActionError(["RenameTable", fromId], `Table ${fromId} not found`);
+  state.tables.delete(fromId);
+  table.tableId = toId;
+  state.tables.set(toId, table);
+  if (state.selection.tableId === fromId) state.selection.tableId = toId;
+  return null;
+}
+function ensureColumns(table, values, bulk = false) {
+  for (const col of Object.keys(values)) {
+    if (!table.columns[col]) {
+      const sample = bulk ? values[col]?.[0] : values[col];
+      table.columns[col] = inferType(sample);
+    }
+  }
+}
+function inferType(sample) {
+  switch (typeof sample) {
+    case "number":
+      return { type: "Numeric" };
+    case "boolean":
+      return { type: "Bool" };
+    case "string":
+      return { type: "Text" };
+    default:
+      return { type: "Any" };
+  }
+}
+function lengthOf(cols) {
+  for (const arr of Object.values(cols)) if (Array.isArray(arr)) return arr.length;
+  return 0;
+}
+function requireString(value, name) {
+  if (typeof value !== "string" || !value) throw new Error(`Expected non-empty string for ${name}`);
+  return value;
+}
+function requireNumber(value, name) {
+  if (typeof value !== "number" || Number.isNaN(value)) throw new Error(`Expected number for ${name}`);
+  return value;
+}
+function normalizeValuesForTable(table, values) {
+  const out = {};
+  for (const [colId, value] of Object.entries(values)) {
+    out[colId] = normalizeCellValueForType(value, table.columns[colId]?.type);
+  }
+  return out;
+}
+function normalizeColumnarForTable(table, columns) {
+  const out = {};
+  for (const [colId, values] of Object.entries(columns)) {
+    const type = table.columns[colId]?.type;
+    out[colId] = Array.isArray(values) ? values.map((value) => normalizeCellValueForType(value, type)) : [];
+  }
+  return out;
+}
+function normalizeCellValueForType(value, type) {
+  if (value === null || value === void 0 || typeof type !== "string") return value;
+  if (type.startsWith("Ref:")) return normalizeRefValue(value);
+  if (type.startsWith("RefList:")) return normalizeRefListValue(value);
+  return value;
+}
+function extractRefRowId(value) {
+  if (value === null || value === void 0) return null;
+  if (value && typeof value === "object" && "__ref" in value) {
+    const inner = value.rowId;
+    return extractRefRowId(inner);
+  }
+  if (value && typeof value === "object" && "rowId" in value) {
+    return extractRefRowId(value.rowId);
+  }
+  const fromTuple = coerceGristDocApiRefRowId(value);
+  if (fromTuple !== void 0 && fromTuple > 0) return Math.trunc(fromTuple);
+  return toPositiveInt(value);
+}
+function normalizeRefValue(value) {
+  return extractRefRowId(value);
+}
+function normalizeRefListValue(value) {
+  const toIdList = (items) => Array.from(
+    new Set(items.map((item) => extractRefRowId(item)).filter((item) => item !== null))
+  );
+  if (Array.isArray(value) && value[0] === "L") {
+    return ["L", ...toIdList(value.slice(1))];
+  }
+  if (Array.isArray(value)) {
+    return ["L", ...toIdList(value)];
+  }
+  if (typeof value === "string") {
+    const tokens = value.split(",").map((t) => t.trim()).filter(Boolean);
+    return ["L", ...toIdList(tokens)];
+  }
+  if (value && typeof value === "object" && Array.isArray(value.rowIds)) {
+    return ["L", ...toIdList(value.rowIds)];
+  }
+  return ["L"];
+}
+function toPositiveInt(value) {
+  if (typeof value === "number" && Number.isFinite(value) && value > 0) return Math.trunc(value);
+  if (typeof value === "string") {
+    const n = Number.parseInt(value.trim(), 10);
+    if (Number.isFinite(n) && n > 0) return n;
+  }
+  return null;
+}
+
+// src/emulator/transports/inline.ts
+function createInlineTransport(options) {
+  const { state, bus, api } = options;
+  const target = options.target ?? globalThis;
+  installFakeIframeContext(target);
+  const recordCbs = /* @__PURE__ */ new Map();
+  const recordsCbs = /* @__PURE__ */ new Map();
+  const optionsCbs = /* @__PURE__ */ new Set();
+  const newRecordCbs = /* @__PURE__ */ new Set();
+  const generic = /* @__PURE__ */ new Map();
+  let lastRecord = null;
+  let lastRecords = null;
+  let lastOptions = null;
+  let lastNewRecord = void 0;
+  const buildInteraction = options.buildInteraction ?? (() => ({
+    access_level: state.configuration?.requiredAccess ?? "read table",
+    ...state.widgetInteraction
+  }));
+  async function pushRecord(rowId) {
+    const mappings = resolveMappings(state);
+    if (rowId === "new") {
+      lastNewRecord = mappings;
+      for (const cb of newRecordCbs) {
+        try {
+          cb(mappings);
+        } catch (err) {
+          logErr(err);
+        }
+      }
+      lastRecord = { record: null, mappings };
+      for (const [cb] of recordCbs) {
+        try {
+          cb(null, mappings);
+        } catch (err) {
+          logErr(err);
+        }
+      }
+      return;
+    }
+    if (rowId === null) {
+      lastRecord = { record: null, mappings };
+      for (const [cb] of recordCbs) {
+        try {
+          cb(null, mappings);
+        } catch (err) {
+          logErr(err);
+        }
+      }
+      return;
+    }
+    let record = null;
+    try {
+      record = await api.GristView.fetchSelectedRecord(rowId);
+    } catch (err) {
+      logErr(err);
+    }
+    lastRecord = { record, mappings };
+    for (const [cb, opts] of recordCbs) {
+      try {
+        const r = opts?.keepEncoded ? await api.GristView.fetchSelectedRecord(rowId, { keepEncoded: true }) : record;
+        cb(r, mappings);
+      } catch (err) {
+        logErr(err);
+      }
+    }
+  }
+  async function pushRecords() {
+    const mappings = resolveMappings(state);
+    let baseRows = [];
+    try {
+      const columnar = await api.GristView.fetchSelectedTable({});
+      baseRows = columnsToRows(columnar);
+    } catch (err) {
+      logErr(err);
+    }
+    lastRecords = { records: baseRows, mappings };
+    for (const [cb, opts] of recordsCbs) {
+      try {
+        const fetchOptions = coerceFetchOptions(opts);
+        const rows = fetchOptions?.keepEncoded ? columnsToRows(await api.GristView.fetchSelectedTable({ keepEncoded: true })) : baseRows;
+        cb(rows, mappings);
+      } catch (err) {
+        logErr(err);
+      }
+    }
+  }
+  async function fetchSelectedTableShaped(opts) {
+    const fetchOptions = coerceFetchOptions(opts);
+    const columnar = await api.GristView.fetchSelectedTable(
+      fetchOptions ? { keepEncoded: fetchOptions.keepEncoded } : {}
+    );
+    if (fetchOptions?.format === "rows") return columnsToRows(columnar);
+    return columnar;
+  }
+  function pushOptions() {
+    const opts = Object.keys(state.widgetOptions).length > 0 ? { ...state.widgetOptions } : null;
+    const interaction = buildInteraction();
+    lastOptions = { options: opts, interaction };
+    for (const cb of optionsCbs) {
+      try {
+        cb(opts, interaction);
+      } catch (err) {
+        logErr(err);
+      }
+    }
+  }
+  const offBus = bus.on(async (event) => {
+    switch (event.type) {
+      case "data-change":
+        await pushRecords();
+        await pushRecord(state.selection.rowId);
+        break;
+      case "cursor-change":
+        await pushRecord(event.rowId);
+        break;
+      case "options-change":
+        pushOptions();
+        break;
+      case "ready":
+        pushOptions();
+        if (options.initialTheme) {
+          notify("message", buildGristThemeHostMessage(options.initialTheme, { fromReady: true }));
+        }
+        await pushRecords();
+        await pushRecord(state.selection.rowId);
+        break;
+      case "mappings-change":
+        await pushRecords();
+        await pushRecord(state.selection.rowId);
+        break;
+      case "theme-change":
+        notify("message", event.message);
+        break;
+    }
+  });
+  function makeTableOps(tableId) {
+    return {
+      async getTableId() {
+        return tableId;
+      },
+      async create(records, options2) {
+        const list = Array.isArray(records) ? records : [records];
+        const ids = [];
+        for (const r of list) {
+          const result = applyUserActions(state, bus, [
+            gristAddRecordAction(tableId, parseFields(r.fields, options2))
+          ]);
+          ids.push({ id: result.retValues[0] });
+        }
+        return Array.isArray(records) ? ids : ids[0];
+      },
+      async update(records, options2) {
+        const list = Array.isArray(records) ? records : [records];
+        const actions = list.map((r) => gristUpdateRecordAction(tableId, r.id, parseFields(r.fields, options2)));
+        applyUserActions(state, bus, actions);
+      },
+      async upsert(records, options2) {
+        const list = Array.isArray(records) ? records : [records];
+        const allowAdd = options2?.add !== false;
+        const allowUpdate = options2?.update !== false;
+        const table = getTable(state, tableId);
+        const actions = [];
+        for (const r of list) {
+          const matches = table.rows.filter(
+            (row) => Object.entries(r.require).every(([k, v]) => row[k] === v)
+          );
+          if (matches.length > 0) {
+            if (!allowUpdate) continue;
+            const fields = parseFields(r.fields ?? {}, options2);
+            for (const m of matches) actions.push(gristUpdateRecordAction(tableId, m.id, fields));
+          } else if (allowAdd) {
+            actions.push(gristAddRecordAction(tableId, { ...r.require, ...parseFields(r.fields ?? {}, options2) }));
+          }
+        }
+        if (actions.length > 0) applyUserActions(state, bus, actions);
+      },
+      async destroy(recordIds) {
+        if (Array.isArray(recordIds)) {
+          applyUserActions(state, bus, [gristBulkRemoveRecordAction(tableId, recordIds)]);
+        } else {
+          applyUserActions(state, bus, [gristRemoveRecordAction(tableId, recordIds)]);
+        }
+        void gristBulkAddRecordAction;
+        void gristBulkUpdateRecordAction;
+      }
+    };
+  }
+  function notify(event, ...args) {
+    const set = generic.get(event);
+    if (!set) return;
+    for (const fn of set) {
+      try {
+        fn(...args);
+      } catch (err) {
+        logErr(err);
+      }
+    }
+  }
+  const grist = {
+    async ready(opts) {
+      await api.CustomSectionAPI.configure(opts ? { ...opts, onEditOptions: void 0 } : {});
+    },
+    onRecord(cb, opts) {
+      recordCbs.set(cb, opts);
+      if (lastRecord) {
+        try {
+          cb(lastRecord.record, lastRecord.mappings);
+        } catch (err) {
+          logErr(err);
+        }
+      }
+    },
+    onRecords(cb, opts) {
+      recordsCbs.set(cb, opts);
+      if (lastRecords) {
+        try {
+          cb(lastRecords.records, lastRecords.mappings);
+        } catch (err) {
+          logErr(err);
+        }
+      }
+    },
+    onOptions(cb) {
+      optionsCbs.add(cb);
+      if (lastOptions) {
+        try {
+          cb(lastOptions.options, lastOptions.interaction);
+        } catch (err) {
+          logErr(err);
+        }
+      }
+    },
+    onNewRecord(cb) {
+      newRecordCbs.add(cb);
+      if (lastNewRecord !== void 0) {
+        try {
+          cb(lastNewRecord);
+        } catch (err) {
+          logErr(err);
+        }
+      }
+    },
+    mapColumnNames(data) {
+      const mappings = resolveMappings(state);
+      if (!mappings) return null;
+      const out = {};
+      let allMapped = true;
+      for (const [logical, real] of Object.entries(mappings)) {
+        if (Array.isArray(real)) {
+          out[logical] = real.map((r) => data[r]);
+        } else if (typeof real === "string") {
+          out[logical] = data[real];
+        } else {
+          allMapped = false;
+        }
+      }
+      return allMapped ? out : null;
+    },
+    mapColumnNamesBack(data) {
+      const mappings = resolveMappings(state);
+      if (!mappings) return data;
+      const out = {};
+      for (const [logical, real] of Object.entries(mappings)) {
+        if (typeof real === "string" && logical in data) {
+          out[real] = data[logical];
+        }
+      }
+      return out;
+    },
+    getOption: (k) => api.WidgetAPI.getOption(k),
+    setOption: (k, v) => api.WidgetAPI.setOption(k, v),
+    getOptions: () => api.WidgetAPI.getOptions(),
+    setOptions: (o) => api.WidgetAPI.setOptions(o),
+    clearOptions: () => api.WidgetAPI.clearOptions(),
+    setCursorPos: (pos) => api.GristView.setCursorPos(pos),
+    setSelectedRows: (rowIds) => api.GristView.setSelectedRows(rowIds),
+    fetchSelectedTable: (opts) => fetchSelectedTableShaped(opts),
+    fetchSelectedRecord: (rowId, opts) => api.GristView.fetchSelectedRecord(rowId, coerceFetchOptions(opts)),
+    docApi: {
+      getDocName: () => api.GristDocAPI.getDocName(),
+      listTables: () => api.GristDocAPI.listTables(),
+      fetchTable: (id) => api.GristDocAPI.fetchTable(id),
+      applyUserActions: (actions, options2) => api.GristDocAPI.applyUserActions(actions, options2),
+      getAccessToken: (opts) => api.GristDocAPI.getAccessToken(opts),
+      fetchSelectedTable: (opts) => fetchSelectedTableShaped(opts),
+      fetchSelectedRecord: (rowId, opts) => api.GristView.fetchSelectedRecord(rowId, coerceFetchOptions(opts))
+    },
+    get selectedTable() {
+      return makeTableOps(state.selection.tableId);
+    },
+    getTable(tableId) {
+      return makeTableOps(tableId ?? state.selection.tableId);
+    },
+    sectionApi: {
+      configure: (settings) => api.CustomSectionAPI.configure(settings),
+      mappings: () => api.CustomSectionAPI.mappings()
+    },
+    on(eventName, listener) {
+      let set = generic.get(eventName);
+      if (!set) generic.set(eventName, set = /* @__PURE__ */ new Set());
+      set.add(listener);
+      return () => set.delete(listener);
+    }
+  };
+  target.grist = grist;
+  return {
+    grist,
+    dispose() {
+      offBus();
+      const t = target;
+      if (t.grist === grist) delete t.grist;
+      recordCbs.clear();
+      recordsCbs.clear();
+      optionsCbs.clear();
+      newRecordCbs.clear();
+      generic.clear();
+      lastRecord = null;
+      lastRecords = null;
+      lastOptions = null;
+      lastNewRecord = void 0;
+    },
+    fireDataChange(tableId) {
+      bus.emit({ type: "data-change", tableId: tableId ?? state.selection.tableId });
+    },
+    fireCursor(rowId) {
+      const id = rowId === void 0 ? state.selection.rowId : rowId;
+      bus.emit({ type: "cursor-change", tableId: state.selection.tableId, rowId: id });
+    },
+    fireOptions() {
+      pushOptions();
+    },
+    fireTheme(message) {
+      bus.emit({ type: "theme-change", message });
+    },
+    emitInitialState() {
+      pushOptions();
+      void pushRecords().then(() => pushRecord(state.selection.rowId));
+    }
+  };
+}
+function columnsToRows(columnar) {
+  const cols = Object.keys(columnar);
+  if (cols.length === 0) return [];
+  const length = (columnar[cols[0]] ?? []).length;
+  const rows = [];
+  for (let i = 0; i < length; i++) {
+    const row = {};
+    for (const c of cols) row[c] = columnar[c][i];
+    rows.push(row);
+  }
+  return rows;
+}
+function parseFields(fields, _options) {
+  return { ...fields };
+}
+function coerceFetchOptions(opts) {
+  if (!opts) return void 0;
+  const format = opts.format === "rows" || opts.format === "columns" ? opts.format : void 0;
+  return { keepEncoded: opts.keepEncoded, format };
+}
+function logErr(err) {
+  console.error("[grist-emulator/inline]", err);
+}
+function installFakeIframeContext(target) {
+  try {
+    if (target.self !== target.top) return;
+    Object.defineProperty(target, "top", {
+      configurable: true,
+      get: () => ({})
+    });
+  } catch {
+  }
+}
+
+export {
+  enrichEmulatorColumnMetadata,
+  createDocument,
+  getTable,
+  getSelectedTable,
+  findRow,
+  synthesizeTablesMeta,
+  synthesizeTablesColumnMeta,
+  EmulatorActionError,
+  applyUserActions,
+  buildGristThemeHostMessage,
+  createIframeTransport,
+  createInlineTransport
+};
+//# sourceMappingURL=chunk-QKXKZ27D.js.map