grist-widget-sdk 0.3.27 → 0.5.0

package/dist/{chunk-YQNMIL33.js → chunk-OXA2VITC.js}

@@ -1,9 +1,3 @@
-import {
-  normalizeReplicaDocumentInput
-} from "./chunk-GTTD5HPO.js";
-import {
-  resolveMappings
-} from "./chunk-PM3B4WYV.js";
 import {
   coerceGristDocApiRefRowId,
   gristAddRecordAction,
@@ -12,172 +6,75 @@ import {
   gristBulkUpdateRecordAction,
   gristRemoveRecordAction,
   gristUpdateRecordAction,
-  inferDisplayHelpersByRef
-} from "./chunk-64SVRWW7.js";
-
-// src/emulator/transports/iframe.ts
-import { MsgType, Rpc } from "grain-rpc";
+  normalizeReplicaDocumentInput
+} from "./chunk-4ZGVKGDF.js";
 
-// src/emulator/theme-message.ts
-function buildGristThemeHostMessage(appearance, options) {
-  return {
-    theme: {
-      appearance,
-      name: appearance,
-      colors: {}
-    },
-    ...options?.fromReady ? { fromReady: true } : {}
-  };
+// src/emulator/core/mappings.ts
+function resolveMappings(state) {
+  if (state.selection.mappings !== void 0 && state.selection.mappings !== null) {
+    return state.selection.mappings;
+  }
+  return null;
 }
 
-// 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;
+// src/emulator/core/display-helpers.ts
+function inferDisplayHelpersByRef(columns) {
+  const out = {};
+  const helperColumns = Object.entries(columns).filter(
+    ([colId]) => colId.startsWith("gristHelper_")
+  );
+  const usedHelpers = /* @__PURE__ */ new Set();
+  const colRefToColId = /* @__PURE__ */ new Map();
+  for (const [colId, col] of Object.entries(columns)) {
+    if (typeof col?.colRef === "number" && Number.isFinite(col.colRef)) {
+      colRefToColId.set(col.colRef, colId);
     }
-    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 }));
+  for (const [colId, col] of Object.entries(columns)) {
+    const type = col?.type;
+    if (typeof type !== "string" || !type.startsWith("Ref:") && !type.startsWith("RefList:")) {
+      continue;
     }
-    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;
+    if (typeof col.displayColRef === "number" && Number.isFinite(col.displayColRef)) {
+      const helperColId = colRefToColId.get(col.displayColRef);
+      if (helperColId) {
+        out[colId] = helperColId;
+        usedHelpers.add(helperColId);
+        continue;
       }
-      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);
+    const match = helperColumns.find(([, helper]) => {
+      const formula = helper?.formula;
+      return typeof formula === "string" && (formula.includes(`$${colId}.`) || formula.includes(`$${colId}`));
+    });
+    if (match) {
+      out[colId] = match[0];
+      usedHelpers.add(match[0]);
     }
   }
-  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
-  });
+  const unresolvedRefs = Object.entries(columns).filter(([colId, col]) => {
+    const type = col?.type;
+    return !out[colId] && typeof type === "string" && (type.startsWith("Ref:") || type.startsWith("RefList:"));
+  }).sort((a, b) => (a[1]?.parentPos ?? Number.MAX_SAFE_INTEGER) - (b[1]?.parentPos ?? Number.MAX_SAFE_INTEGER));
+  const helperByPos = helperColumns.filter(([helperId]) => !usedHelpers.has(helperId)).sort((a, b) => (a[1]?.parentPos ?? Number.MAX_SAFE_INTEGER) - (b[1]?.parentPos ?? Number.MAX_SAFE_INTEGER));
+  for (const [refId, refCol] of unresolvedRefs) {
+    const refPos = refCol?.parentPos ?? Number.MAX_SAFE_INTEGER;
+    const candidate = helperByPos.find(([, helperCol]) => {
+      const helperPos = helperCol?.parentPos ?? Number.MAX_SAFE_INTEGER;
+      return helperPos > refPos;
+    });
+    if (!candidate) continue;
+    out[refId] = candidate[0];
+    usedHelpers.add(candidate[0]);
+  }
+  for (const [refId] of unresolvedRefs) {
+    if (out[refId]) continue;
+    const candidate = helperByPos.find(([helperId]) => !usedHelpers.has(helperId));
+    if (!candidate) continue;
+    out[refId] = candidate[0];
+    usedHelpers.add(candidate[0]);
+  }
+  return out;
 }
 
 // src/emulator/core/document.ts
@@ -750,6 +647,7 @@ function normalizeColumnarForTable(table, columns) {
 }
 function normalizeCellValueForType(value, type) {
   if (value === null || value === void 0 || typeof type !== "string") return value;
+  if (isListColumnType(type) && Array.isArray(value) && value[0] !== "L") return ["E", "KeyError"];
   if (type.startsWith("Ref:")) return normalizeRefValue(value);
   if (type.startsWith("RefList:")) return normalizeRefListValue(value);
   return value;
@@ -767,6 +665,9 @@ function extractRefRowId(value) {
   if (fromTuple !== void 0 && fromTuple > 0) return Math.trunc(fromTuple);
   return toPositiveInt(value);
 }
+function isListColumnType(type) {
+  return type === "ChoiceList" || type === "Attachments" || type.startsWith("RefList:");
+}
 function normalizeRefValue(value) {
   return extractRefRowId(value);
 }
@@ -798,6 +699,310 @@ function toPositiveInt(value) {
   return null;
 }
 
+// src/emulator/validators.ts
+import { z } from "zod";
+var emulatorRowSchema = z.object({ id: z.number() }).catchall(z.unknown());
+var formulaKindSchema = z.enum(["computed", "trigger", "none", "empty_slot"]);
+var replicaColumnSchema = z.object({
+  colRef: z.number().optional(),
+  type: z.string().optional(),
+  label: z.string().optional(),
+  parentPos: z.number().optional(),
+  isFormula: z.boolean().optional(),
+  formulaKind: formulaKindSchema.optional(),
+  formula: z.string().optional(),
+  description: z.string().optional(),
+  widgetOptions: z.record(z.string(), z.unknown()).optional(),
+  displayColRef: z.number().optional(),
+  visibleColRef: z.number().optional()
+}).strict();
+var replicaTableSchema = z.object({
+  label: z.string().optional(),
+  columns: z.record(z.string(), replicaColumnSchema).optional(),
+  rows: z.array(emulatorRowSchema).optional(),
+  rowCount: z.number().optional(),
+  dataOmitted: z.boolean().optional(),
+  dataOmittedReason: z.string().optional(),
+  error: z.string().optional()
+}).strict();
+var replicaSelectionSchema = z.object({
+  tableId: z.string().optional(),
+  rowId: z.union([z.number(), z.literal("new"), z.null()]).optional(),
+  mappings: z.unknown().nullable().optional(),
+  cursor: z.unknown().optional()
+}).strict();
+var replicaWidgetConfigurationSchema = z.object({
+  requiredAccess: z.string().optional(),
+  columns: z.unknown().optional(),
+  allowSelectBy: z.boolean().optional(),
+  hasCustomOptions: z.boolean().optional()
+}).strict();
+var replicaAccessTokenSchema = z.object({
+  token: z.string(),
+  baseUrl: z.string(),
+  ttlMsecs: z.number()
+}).strict();
+var replicaDocumentSchema = z.object({
+  generatedAt: z.string(),
+  source: z.string().optional(),
+  docName: z.string().optional(),
+  mode: z.enum(["schema-only", "schema+samples", "schema+data"]).optional(),
+  tables: z.record(z.string(), replicaTableSchema),
+  selection: replicaSelectionSchema.optional(),
+  widgetOptions: z.record(z.string(), z.unknown()).optional(),
+  widgetInteraction: z.unknown().optional(),
+  configuration: replicaWidgetConfigurationSchema.optional(),
+  accessToken: replicaAccessTokenSchema.nullable().optional()
+}).strict().refine((value) => Object.keys(value.tables).length > 0, {
+  message: "at least one table is required",
+  path: ["tables"]
+});
+function formatZodError(prefix, error) {
+  const details = error.issues.map((issue) => {
+    const where = issue.path.length > 0 ? issue.path.join(".") : "<root>";
+    return `${where}: ${issue.message}`;
+  }).join("; ");
+  return new Error(`${prefix}: ${details}`);
+}
+function safeParseDocument(input) {
+  return replicaDocumentSchema.safeParse(input);
+}
+function parseDocument(input) {
+  const result = safeParseDocument(input);
+  if (!result.success) {
+    throw formatZodError("parseDocument", result.error);
+  }
+  return result.data;
+}
+
+// src/emulator/api/command-api.ts
+function createCommandApiImpl(bus) {
+  return {
+    async run(name) {
+      bus.emit({ type: "user-action", action: ["RunCommand", name] });
+    }
+  };
+}
+
+// src/emulator/api/custom-section-api.ts
+function createCustomSectionApiImpl(state, bus) {
+  return {
+    async configure(settings) {
+      const config = {
+        requiredAccess: settings.requiredAccess,
+        columns: settings.columns,
+        allowSelectBy: settings.allowSelectBy,
+        hasCustomOptions: settings.hasCustomOptions
+      };
+      state.configuration = config;
+      bus.emit({ type: "ready", configuration: config });
+      bus.emit({ type: "mappings-change", mappings: resolveMappings(state) });
+    },
+    async mappings() {
+      return resolveMappings(state);
+    }
+  };
+}
+
+// src/emulator/api/grist-api.ts
+function createGristApiImpl() {
+  return {
+    async ping() {
+      return "pong";
+    }
+  };
+}
+
+// src/emulator/core/columnar.ts
+function rowsToColumnar(table, rows, options = {}) {
+  const cols = Object.keys(table.columns);
+  const out = { id: rows.map((r) => r.id) };
+  for (const col of cols) {
+    out[col] = rows.map((r) => encodeForWire(r[col], table.columns[col]?.type, options.keepEncoded));
+  }
+  return out;
+}
+function rowToRecord(table, row, options = {}) {
+  const out = { id: row.id };
+  for (const col of Object.keys(table.columns)) {
+    out[col] = encodeForWire(row[col], table.columns[col]?.type, options.keepEncoded);
+  }
+  return out;
+}
+function encodeForWire(value, type, keepEncoded) {
+  if (value instanceof Date) {
+    const epoch = Math.floor(value.getTime() / 1e3);
+    if (keepEncoded) {
+      return type && type.startsWith("DateTime") ? ["D", epoch, "UTC"] : ["d", epoch];
+    }
+    return epoch;
+  }
+  return value;
+}
+
+// src/emulator/api/grist-doc-api.ts
+function createGristDocApiImpl(state, bus) {
+  return {
+    async getDocName() {
+      return state.docName;
+    },
+    async listTables() {
+      return [...state.tables.keys()];
+    },
+    async fetchTable(tableId) {
+      if (tableId === "_grist_Tables") {
+        return synthesizeTablesMeta(state);
+      }
+      if (tableId === "_grist_Tables_column") {
+        return synthesizeTablesColumnMeta(state);
+      }
+      const table = getTable(state, tableId);
+      return rowsToColumnar(table, table.rows);
+    },
+    async applyUserActions(actions) {
+      const result = applyUserActions(state, bus, actions);
+      return { retValues: result.retValues };
+    },
+    async getAccessToken() {
+      if (!state.accessToken) {
+        const err = new Error("getAccessToken not available (no token configured on emulator)");
+        throw err;
+      }
+      return { ...state.accessToken };
+    }
+  };
+}
+
+// src/emulator/api/grist-view.ts
+function createGristViewImpl(state, bus) {
+  return {
+    async fetchSelectedTable(options) {
+      const table = getSelectedTable(state);
+      return rowsToColumnar(table, table.rows, { keepEncoded: options?.keepEncoded });
+    },
+    async fetchSelectedRecord(rowId, options) {
+      const table = getSelectedTable(state);
+      const row = findRow(table, rowId);
+      if (!row) throw new Error(`No row ${rowId} in ${table.tableId}`);
+      return rowToRecord(table, row, { keepEncoded: options?.keepEncoded });
+    },
+    async allowSelectBy() {
+      return state.configuration?.allowSelectBy ?? false;
+    },
+    async setSelectedRows(rowIds) {
+      if (!rowIds || rowIds.length === 0) {
+        state.selection.rowId = null;
+      } else {
+        state.selection.rowId = rowIds[0];
+      }
+      bus.emit({
+        type: "cursor-change",
+        tableId: state.selection.tableId,
+        rowId: state.selection.rowId
+      });
+    },
+    async setCursorPos(cursor) {
+      const tableId = state.selection.tableId;
+      if (typeof cursor.rowId === "number") state.selection.rowId = cursor.rowId;
+      state.selection.cursor = { ...state.selection.cursor, ...cursor };
+      bus.emit({
+        type: "cursor-change",
+        tableId,
+        rowId: state.selection.rowId,
+        cursor: state.selection.cursor
+      });
+    }
+  };
+}
+
+// src/emulator/api/widget-api.ts
+function createWidgetApiImpl(state, bus) {
+  function emit() {
+    bus.emit({
+      type: "options-change",
+      options: { ...state.widgetOptions },
+      interaction: { ...state.widgetInteraction }
+    });
+  }
+  return {
+    async getOption(key) {
+      return state.widgetOptions[key];
+    },
+    async setOption(key, value) {
+      state.widgetOptions[key] = value;
+      emit();
+    },
+    async getOptions() {
+      return Object.keys(state.widgetOptions).length > 0 ? { ...state.widgetOptions } : null;
+    },
+    // Replaces every option, as Grist's WidgetAPI.setOptions does.
+    async setOptions(options) {
+      state.widgetOptions = { ...options };
+      emit();
+    },
+    async clearOptions() {
+      state.widgetOptions = {};
+      emit();
+    }
+  };
+}
+
+// src/emulator/api/index.ts
+function createApiBundle(state, bus) {
+  return {
+    GristView: createGristViewImpl(state, bus),
+    GristDocAPI: createGristDocApiImpl(state, bus),
+    WidgetAPI: createWidgetApiImpl(state, bus),
+    CustomSectionAPI: createCustomSectionApiImpl(state, bus),
+    GristAPI: createGristApiImpl(),
+    CommandAPI: createCommandApiImpl(bus)
+  };
+}
+
+// src/emulator/core/event-bus.ts
+function createEventBus(options = {}) {
+  const limit = options.historyLimit ?? 200;
+  const listeners = /* @__PURE__ */ new Set();
+  const history = [];
+  return {
+    emit(event) {
+      history.push(event);
+      if (history.length > limit) history.shift();
+      for (const fn of [...listeners]) {
+        try {
+          fn(event);
+        } catch (err) {
+          console.error("[grist-emulator] event listener threw:", err);
+        }
+      }
+    },
+    on(listener) {
+      listeners.add(listener);
+      return () => {
+        listeners.delete(listener);
+      };
+    },
+    history() {
+      return history;
+    },
+    clear() {
+      history.length = 0;
+    }
+  };
+}
+
+// src/emulator/theme-message.ts
+function buildGristThemeHostMessage(appearance, options) {
+  return {
+    theme: {
+      appearance,
+      name: appearance,
+      colors: {}
+    },
+    ...options?.fromReady ? { fromReady: true } : {}
+  };
+}
+
 // src/emulator/transports/inline.ts
 function createInlineTransport(options) {
   const { state, bus, api } = options;
@@ -827,14 +1032,6 @@ function createInlineTransport(options) {
           logErr(err);
         }
       }
-      lastRecord = { record: null, mappings };
-      for (const [cb] of recordCbs) {
-        try {
-          cb(null, mappings);
-        } catch (err) {
-          logErr(err);
-        }
-      }
       return;
     }
     if (rowId === null) {
@@ -1172,18 +1369,172 @@ function installFakeIframeContext(target) {
   }
 }
 
+// src/emulator/create-grist-emulator.ts
+function createGristEmulator(options) {
+  const validatedDocument = parseDocument(options.document);
+  const state = createDocument({
+    ...validatedDocument,
+    widgetOptions: options.widgetOptions ?? validatedDocument.widgetOptions,
+    // No access_level by default: the emulator then grants the access the
+    // widget asks for in grist.ready(), as a user accepting it in Grist would.
+    widgetInteraction: options.widgetInteraction ?? validatedDocument.widgetInteraction ?? {}
+  });
+  const bus = createEventBus();
+  const api = createApiBundle(state, bus);
+  const inline = createInlineTransport({
+    state,
+    bus,
+    api,
+    initialTheme: options.initialTheme,
+    target: options.transport?.target
+  });
+  const transport = inline;
+  const grist = inline.grist;
+  function apply(actions) {
+    return applyUserActions(state, bus, actions);
+  }
+  return {
+    state,
+    bus,
+    api,
+    transport,
+    grist,
+    apply,
+    mutate: {
+      addRow: (tableId, fields) => apply([["AddRecord", tableId, null, fields]]).retValues[0],
+      updateRow: (tableId, rowId, fields) => {
+        apply([["UpdateRecord", tableId, rowId, fields]]);
+      },
+      removeRow: (tableId, rowId) => {
+        apply([["RemoveRecord", tableId, rowId]]);
+      }
+    },
+    selectRow(rowId) {
+      state.selection.rowId = rowId;
+      bus.emit({ type: "cursor-change", tableId: state.selection.tableId, rowId });
+    },
+    selectTable(tableId) {
+      if (!state.tables.has(tableId)) throw new Error(`Unknown table: ${tableId}`);
+      state.selection.tableId = tableId;
+      const first = state.tables.get(tableId).rows[0]?.id ?? null;
+      state.selection.rowId = first;
+      bus.emit({ type: "data-change", tableId });
+      bus.emit({ type: "cursor-change", tableId, rowId: first });
+    },
+    setColumnMappings(mappings) {
+      if (mappings === void 0) {
+        delete state.selection.mappings;
+      } else {
+        state.selection.mappings = mappings;
+      }
+      bus.emit({ type: "mappings-change", mappings: resolveMappings(state) });
+    },
+    async setOptions(opts) {
+      await api.WidgetAPI.setOptions(opts);
+    },
+    setInteraction(interaction) {
+      state.widgetInteraction = { ...interaction };
+      bus.emit({ type: "options-change", options: { ...state.widgetOptions }, interaction: { ...interaction } });
+    },
+    theme: {
+      set(next) {
+        bus.emit({ type: "theme-change", message: buildGristThemeHostMessage(next) });
+      }
+    },
+    dispose() {
+      transport.dispose();
+      bus.clear();
+    }
+  };
+}
+
+// src/emulator/templates.ts
+var PRESET_GENERATED_AT = "1970-01-01T00:00:00.000Z";
+function replicaBase(overrides) {
+  return {
+    generatedAt: PRESET_GENERATED_AT,
+    ...overrides
+  };
+}
+var presets = {
+  /**
+   * Default starter fixture for demos / sandboxes that need a neutral document
+   * without choosing a domain-specific preset.
+   */
+  defaultTemplate() {
+    return replicaBase({
+      docName: "Default",
+      tables: {
+        Table1: {
+          label: "Table1",
+          rows: [
+            { id: 1, Name: "Alice" },
+            { id: 2, Name: "Bob" }
+          ]
+        }
+      }
+    });
+  },
+  blank() {
+    return replicaBase({
+      docName: "Blank",
+      tables: {
+        Table1: { rows: [{ id: 1 }] }
+      }
+    });
+  },
+  todoList() {
+    return replicaBase({
+      docName: "Todo list",
+      mode: "schema+data",
+      tables: {
+        Tasks: {
+          label: "Tasks",
+          columns: {
+            title: { type: "Text", label: "Title" },
+            done: { type: "Bool", label: "Done" },
+            priority: { type: "Choice", label: "Priority" }
+          },
+          rows: [
+            { id: 1, title: "Buy milk", done: false, priority: "high" },
+            { id: 2, title: "Write the SOTA emulator", done: true, priority: "high" },
+            { id: 3, title: "Ship it", done: false, priority: "medium" }
+          ]
+        }
+      }
+    });
+  },
+  contacts() {
+    return replicaBase({
+      docName: "Contacts",
+      mode: "schema+data",
+      tables: {
+        Contacts: {
+          label: "Contacts",
+          columns: {
+            firstName: { type: "Text" },
+            lastName: { type: "Text" },
+            email: { type: "Text" },
+            company: { type: "Text" }
+          },
+          rows: [
+            { id: 1, firstName: "Ada", lastName: "Lovelace", email: "ada@analytical.engine", company: "British Crown" },
+            { id: 2, firstName: "Linus", lastName: "Torvalds", email: "linus@kernel.org", company: "Linux Foundation" },
+            { id: 3, firstName: "Margaret", lastName: "Hamilton", email: "margaret@apollo.nasa", company: "NASA" }
+          ]
+        }
+      }
+    });
+  }
+};
+
 export {
+  resolveMappings,
   enrichEmulatorColumnMetadata,
-  createDocument,
-  getTable,
-  getSelectedTable,
-  findRow,
-  synthesizeTablesMeta,
-  synthesizeTablesColumnMeta,
   EmulatorActionError,
-  applyUserActions,
-  buildGristThemeHostMessage,
-  createIframeTransport,
-  createInlineTransport
+  safeParseDocument,
+  parseDocument,
+  createGristEmulator,
+  presets
 };
-//# sourceMappingURL=chunk-YQNMIL33.js.map
+//# sourceMappingURL=chunk-OXA2VITC.js.map