@ai-matrx/records 0.93.1 → 0.93.3

package/dist/first-page/index.js

@@ -0,0 +1,604 @@
+// src/aggregate.ts
+function isRuleFilter(filter) {
+  if (!filter || typeof filter !== "object" || Array.isArray(filter)) return false;
+  const node = filter;
+  return typeof node.op === "string" && Array.isArray(node.args);
+}
+
+// src/coerce.ts
+import { isUuidShape } from "@ai-matrx/kit/uuid";
+function fieldKindFor(field, kernel) {
+  const format = (field.format ?? "").toLowerCase();
+  const config = field.config ?? {};
+  switch (field.type) {
+    case "boolean":
+      return "checkbox";
+    case "text":
+      if (format === "email") return "email";
+      if (format === "phone") return "phone";
+      if (format === "url") return "url";
+      if (format === "json" || config["json"] === true) return "json";
+      if (format === "long" || config["multiline"] === true) return "long_text";
+      return "text";
+    case "range": {
+      const kind = String(config["kind"] ?? "number");
+      if (kind === "date" || kind === "datetime") return "datetime";
+      if (format === "currency") return "currency";
+      if (format === "percent" || field.unit === "%") return "percent";
+      return "number";
+    }
+    case "list":
+      return field.multi ? "multi_select" : "select";
+    case "relation": {
+      if (isEntityReferenceConfig(config)) return "entity_reference";
+      const parity = String(config["parity"] ?? "");
+      if (parity === "attachment" || parity === "member") return parity;
+      if (kernel?.file && field.relation_target === kernel.file) return "attachment";
+      if (kernel?.person && field.relation_target === kernel.person) return "member";
+      return "relation";
+    }
+    case "formula": {
+      const via = config["via"];
+      if (via && config["agg"]) return "rollup";
+      if (via) return "lookup";
+      return "formula";
+    }
+    default:
+      return "text";
+  }
+}
+function isEntityReferenceConfig(config) {
+  const allowed = config?.["allowed_types"];
+  return Array.isArray(allowed) && allowed.length > 0;
+}
+
+// src/store.generated.ts
+var KERNEL_TABLES = [
+  { id: "11111111-0000-4000-8000-000000000002", name: "Field" },
+  { id: "11111111-0000-4000-8000-000000000006", name: "File" },
+  { id: "11111111-0000-4000-8000-000000000009", name: "Merge Field" },
+  { id: "11111111-0000-4000-8000-000000000004", name: "Organization" },
+  { id: "11111111-0000-4000-8000-000000000005", name: "Person" },
+  { id: "11111111-0000-4000-8000-000000000007", name: "Presentation" },
+  { id: "11111111-0000-4000-8000-000000000003", name: "Rule" },
+  { id: "11111111-0000-4000-8000-000000000001", name: "Table" },
+  { id: "11111111-0000-4000-8000-000000000008", name: "Widget" }
+];
+
+// src/fieldKind.ts
+var kernelId = (name) => KERNEL_TABLES.find((t) => t.name === name)?.id ?? "";
+var KERNEL = { file: kernelId("File"), person: kernelId("Person") };
+function storeFieldKind(field) {
+  return fieldKindFor(field, KERNEL);
+}
+
+// src/first-page/reads.ts
+function holdsNumbers(field) {
+  const kind = String(storeFieldKind(field));
+  if (kind === "number" || kind === "currency" || kind === "percent") return true;
+  return String((field.config ?? {})["system"] ?? "") === "autonumber";
+}
+function sortAsFor(field) {
+  if (holdsNumbers(field)) return "number";
+  if (String(storeFieldKind(field)) === "datetime") return "date";
+  return "text";
+}
+function pageSortFor(fields, sort) {
+  if (!sort) return [];
+  const field = fields.find((f) => f.key === sort.id);
+  if (!field) return [];
+  return [{ field: field.key, direction: sort.direction === "desc" ? "desc" : "asc", as: sortAsFor(field) }];
+}
+function defaultSortOf(table, fields) {
+  const raw = table?.default_sort ?? null;
+  const first = Array.isArray(raw) ? raw[0] : raw;
+  let name = null;
+  let direction = "asc";
+  if (typeof first === "string") {
+    const trimmed = first.trim();
+    if (trimmed === "") return null;
+    if (trimmed.startsWith("-")) {
+      name = trimmed.slice(1).trim();
+      direction = "desc";
+    } else {
+      const [head, tail] = trimmed.split(/\s+/);
+      name = head ?? null;
+      if (tail && tail.toLowerCase() === "desc") direction = "desc";
+    }
+  } else if (first && typeof first === "object") {
+    const entry = first;
+    const named = entry["field"] ?? entry["key"] ?? entry["id"];
+    name = typeof named === "string" ? named : null;
+    if (String(entry["direction"] ?? "").toLowerCase() === "desc") direction = "desc";
+  }
+  if (!name) return null;
+  const field = fields.find((f) => f.key === name) ?? fields.find((f) => f.id === name);
+  return field ? { id: field.key, direction } : null;
+}
+function isPlainGrouping(grouping) {
+  return Boolean(grouping) && !(grouping.then && grouping.then.length > 0) && !grouping.across && !(grouping.trail && grouping.trail.length > 0);
+}
+function groupedPageSort(fields, groupKey, sort) {
+  if (!groupKey) return sort;
+  const field = fields.find((f) => f.key === groupKey);
+  if (!field) return sort;
+  return [{ field: groupKey, direction: "asc", as: sortAsFor(field) }, ...sort.filter((s) => s.field !== groupKey)];
+}
+var SUMMARY_OPERATIONS = [
+  "count",
+  "sum",
+  "avg",
+  "min",
+  "max",
+  "median",
+  "filled",
+  "empty",
+  "unique",
+  "percent_empty",
+  "percent_filled",
+  "range"
+];
+function chosenEntries(chosen) {
+  return JSON.parse(JSON.stringify(Object.entries(chosen).sort())).filter(
+    ([, op]) => SUMMARY_OPERATIONS.includes(op)
+  );
+}
+function groupFactMeasures(chosen) {
+  return [{ op: "count" }, ...chosenEntries(chosen).filter(([, op]) => op !== "count").map(([key, op]) => ({ op, key }))];
+}
+function summaryBarMeasures(chosen) {
+  return chosenEntries(chosen).map(([key, op]) => op === "count" ? { op: "count" } : { op, key });
+}
+function choiceFieldKeys(fields) {
+  return fields.filter((f) => {
+    const kind = String(storeFieldKind(f));
+    return kind === "select" || kind === "multi_select";
+  }).map((f) => f.key);
+}
+var REVERSE_CELL_CHIPS = 3;
+function viewFilterOf(shown, _fields) {
+  if (!shown) return void 0;
+  const base = shown.where ?? (shown.filters && Object.keys(shown.filters).length > 0 ? shown.filters : void 0);
+  if (!base) return void 0;
+  if (isRuleFilter(base)) return base;
+  return Object.keys(base).length > 0 ? base : void 0;
+}
+
+// src/first-page/seed.ts
+import { isUuidShape as isUuidShape2 } from "@ai-matrx/kit/uuid";
+import { asRecordsDataSource, createRecordsClient, recordingDataSource } from "@ai-matrx/records/core";
+import { createSeedPort } from "@ai-matrx/records/entity";
+
+// src/versions/rowVersion.ts
+function ownVersion(row) {
+  const v = row.version;
+  return typeof v === "number" ? v : null;
+}
+
+// src/views/keys.ts
+var plainPresentation = {
+  parse: (raw) => raw && typeof raw === "object" && !Array.isArray(raw) ? { ...raw } : {},
+  isEmpty: (presentation) => Object.keys(presentation).length === 0,
+  toDocument: (presentation) => ({ ...presentation })
+};
+function plainCodec() {
+  return plainPresentation;
+}
+var STORE_KEEPS_TIMELINE = true;
+var ALL = ["grid", "kanban", "calendar", "gallery", ...STORE_KEEPS_TIMELINE ? ["timeline"] : [], "list"];
+var HIDES = ["grid", "gallery", "kanban", "calendar", ...STORE_KEEPS_TIMELINE ? ["timeline"] : [], "list"];
+var GRIDS = ["grid"];
+var VIEW_KEYS = [
+  { path: "layout", shape: "kind", layouts: ALL, writer: "caller" },
+  { path: "filters", shape: "filter", layouts: ALL, writer: "caller" },
+  { path: "where", shape: "rule", layouts: ALL, writer: "caller" },
+  { path: "group_field", shape: "field", layouts: ["kanban", ...STORE_KEEPS_TIMELINE ? ["timeline"] : []], writer: "caller" },
+  { path: "swimlane_field", shape: "field:lane", layouts: ["kanban"], writer: "caller" },
+  { path: "collapsed_columns", shape: "values", layouts: ["kanban"], writer: "caller" },
+  { path: "measure", shape: "field:number", layouts: ["kanban"], writer: "caller" },
+  { path: "date_field", shape: "field:date", layouts: ["calendar"], writer: "caller" },
+  ...STORE_KEEPS_TIMELINE ? [
+    { path: "start_field", shape: "field:date", layouts: ["timeline"], writer: "caller" },
+    { path: "end_field", shape: "field:date", layouts: ["calendar", "timeline"], writer: "caller" }
+  ] : [],
+  { path: "image_field", shape: "field", layouts: ["gallery"], writer: "caller" },
+  { path: "sorts", shape: "sorts", layouts: ALL, writer: "caller" },
+  { path: "rule_id", shape: "uuid", layouts: ALL, writer: "caller" },
+  { path: "is_default", shape: "boolean", layouts: ALL, writer: "caller" },
+  { path: "presentation", shape: "presentation", layouts: ALL, writer: "caller" },
+  { path: "presentation.style", shape: "style", layouts: ALL, writer: "caller" },
+  { path: "presentation.formats", shape: "object", layouts: GRIDS, writer: "caller" },
+  { path: "presentation.frozen", shape: "fields", layouts: GRIDS, writer: "caller" },
+  { path: "presentation.grouping", shape: "grouping", layouts: ["grid", "gallery", "list"], writer: "caller" },
+  { path: "presentation.widths", shape: "widths", layouts: GRIDS, writer: "caller" },
+  { path: "presentation.rowHeight", shape: "row_height", layouts: GRIDS, writer: "caller" },
+  { path: "presentation.hiddenFields", shape: "fields", layouts: HIDES, writer: "caller" },
+  { path: "presentation.cardHidden", shape: "fields", layouts: ["kanban", "calendar", ...STORE_KEEPS_TIMELINE ? ["timeline"] : [], "list", "gallery"], writer: "caller" },
+  { path: "presentation.columnOrder", shape: "fields", layouts: GRIDS, writer: "caller" },
+  { path: "presentation.gallerySize", shape: "gallery_size", layouts: ["gallery"], writer: "caller" },
+  { path: "presentation.wrap", shape: "boolean", layouts: GRIDS, writer: "caller" },
+  { path: "presentation.wrapColumns", shape: "fields", layouts: GRIDS, writer: "caller" },
+  { path: "presentation.fit", shape: "fit", layouts: GRIDS, writer: "caller" },
+  { path: "presentation.freezeFirst", shape: "boolean", layouts: GRIDS, writer: "caller" },
+  { path: "presentation.footer", shape: "footer", layouts: GRIDS, writer: "caller" },
+  { path: "presentation.summaries", shape: "summaries", layouts: GRIDS, writer: "caller" },
+  { path: "grid", shape: "grid", layouts: GRIDS, writer: "caller" },
+  { path: "hidden_fields", shape: "input", layouts: HIDES, writer: "input" },
+  { path: "table_id", shape: "server", layouts: ALL, writer: "server" },
+  { path: "order", shape: "server", layouts: GRIDS, writer: "server" },
+  { path: "moved_from", shape: "server", layouts: ALL, writer: "server" }
+];
+var STORE_KEPT_LAYOUTS = ["grid", "kanban", "calendar", "gallery", ...STORE_KEEPS_TIMELINE ? ["timeline"] : [], "list"];
+var KINDS = STORE_KEPT_LAYOUTS;
+function viewSettings(definition, rowFilters, codec = plainCodec()) {
+  const data = definition ?? {};
+  const text = (key) => {
+    const v = data[key];
+    return typeof v === "string" && v !== "" ? v : null;
+  };
+  const layout = String(data["layout"] ?? "grid");
+  const flat = rowFilters ?? (isObject(data["filters"]) ? data["filters"] : null);
+  const moved = data["moved_from"];
+  return {
+    layout: KINDS.includes(layout) ? layout : "grid",
+    filters: flat && Object.keys(flat).length > 0 ? flat : null,
+    where: isRule(data["where"]) ? data["where"] : null,
+    groupField: text("group_field"),
+    swimlaneField: text("swimlane_field"),
+    collapsedColumns: Array.isArray(data["collapsed_columns"]) ? data["collapsed_columns"].filter((v) => ["string", "number", "boolean"].includes(typeof v)).map(String) : [],
+    measure: text("measure"),
+    dateField: text("date_field"),
+    startField: text("start_field"),
+    endField: text("end_field"),
+    imageField: text("image_field"),
+    sorts: parseSorts(data["sorts"]),
+    ruleId: text("rule_id"),
+    isDefault: data["is_default"] === true || data["is_default"] === "true",
+    presentation: codec.parse(data["presentation"]),
+    movedFrom: isObject(moved) ? moved : null
+  };
+}
+function isObject(raw) {
+  return Boolean(raw) && typeof raw === "object" && !Array.isArray(raw);
+}
+function isRule(raw) {
+  if (!isObject(raw)) return false;
+  const node = raw;
+  return typeof node.op === "string" && Array.isArray(node.args);
+}
+function parseSorts(raw) {
+  let list = raw;
+  if (typeof raw === "string") {
+    try {
+      list = raw.trim() === "" ? [] : JSON.parse(raw);
+    } catch {
+      return [];
+    }
+  }
+  if (!Array.isArray(list)) return [];
+  return list.filter((s) => isObject(s) && typeof s.field === "string").map((s) => ({ field: s.field, direction: s.direction === "desc" ? "desc" : "asc" }));
+}
+
+// src/views/views.ts
+function plainCodec2() {
+  return plainPresentation;
+}
+var VIEW_LAYOUTS = ["grid", "kanban", "calendar", "gallery", "timeline", "list"];
+var LAYOUT_LABEL = {
+  grid: "Grid",
+  kanban: "Kanban",
+  calendar: "Calendar",
+  gallery: "Gallery",
+  timeline: "Timeline",
+  list: "List"
+};
+function viewOrderOf(definition) {
+  const raw = definition?.["order"];
+  return raw === "manual" ? "manual" : raw === "sorted" ? "sorted" : null;
+}
+function defaultViewOf(views) {
+  return views.find((v) => v.isDefault);
+}
+var PAGE_VIEWS = [...VIEW_LAYOUTS, "dashboards", "archived"];
+var PAGE_VIEW_LABEL = {
+  ...LAYOUT_LABEL,
+  dashboards: "Dashboards",
+  archived: "Archived"
+};
+function viewFromRow(row, codec = plainCodec2()) {
+  const data = row.definition ?? {};
+  const k = viewSettings(data, row.filters && Object.keys(row.filters).length > 0 ? row.filters : null, codec);
+  const tableFromDefinition = typeof data["table_id"] === "string" && data["table_id"] !== "" ? data["table_id"] : null;
+  return {
+    id: row.view_id,
+    name: row.name || "Untitled view",
+    subject: row.table_id ?? tableFromDefinition ?? "",
+    layout: k.layout,
+    groupField: k.groupField,
+    swimlaneField: k.swimlaneField,
+    collapsedColumns: k.collapsedColumns,
+    measure: k.measure,
+    dateField: k.dateField,
+    startField: k.startField,
+    endField: k.endField,
+    imageField: k.imageField,
+    sorts: k.sorts,
+    order: viewOrderOf(data),
+    ruleId: k.ruleId,
+    ...k.filters ? { filters: k.filters } : {},
+    where: k.where,
+    // The older table's own default view, carried in by the mover, IS this table's default —
+    // the mover wrote the row's column, which `custom.views` does not return. Read as anything
+    // else, the page would seed a second "All records" beside it and open on that.
+    isDefault: k.isDefault || k.movedFrom?.["kind"] === "default_view",
+    presentation: k.presentation,
+    movedFrom: k.movedFrom
+  };
+}
+
+// src/views/look.ts
+var plain = () => plainPresentation;
+function lookFromDocument(doc, codec = plain()) {
+  const data = doc ?? {};
+  const read = viewSettings(data, void 0, codec);
+  const out = {};
+  const has = (key) => Object.prototype.hasOwnProperty.call(data, key);
+  if (has("layout") && VIEW_LAYOUTS.includes(String(data["layout"]))) {
+    out.layout = data["layout"];
+  }
+  if (has("group_field")) out.groupField = read.groupField;
+  if (has("swimlane_field")) out.swimlaneField = read.swimlaneField;
+  if (has("collapsed_columns")) out.collapsedColumns = read.collapsedColumns;
+  if (has("measure")) out.measure = read.measure;
+  if (has("date_field")) out.dateField = read.dateField;
+  if (has("start_field")) out.startField = read.startField;
+  if (has("end_field")) out.endField = read.endField;
+  if (has("image_field")) out.imageField = read.imageField;
+  if (has("sorts")) out.sorts = read.sorts;
+  if (has("where")) out.where = read.where;
+  if (has("presentation")) out.presentation = codec.parse(data["presentation"]);
+  return out;
+}
+function applyLook(view, look) {
+  if (!look) return view;
+  return { ...view, ...look };
+}
+async function readLooks(client, tableId, codec = plain()) {
+  const answered = await client.viewLookRead({ table_id: tableId });
+  if (!answered.ok) return answered;
+  const out = {};
+  for (const [viewId, row] of Object.entries(answered.data ?? {})) {
+    out[viewId] = lookFromDocument(row?.look ?? null, codec);
+  }
+  return { ok: true, data: out };
+}
+
+// src/first-page/seed.ts
+var TABLE_PAGE_SIZE = 100;
+var EMBEDDED_PAGE_SIZE = 50;
+function presentationFacts(presentation) {
+  const p = presentation && typeof presentation === "object" ? presentation : {};
+  const g = p["grouping"];
+  const grouping = g && typeof g === "object" && typeof g.field === "string" ? g : void 0;
+  const s = p["summaries"];
+  return { grouping, summaries: s && typeof s === "object" ? s : {} };
+}
+function firstGridPageArgs(input) {
+  const { shown, fields } = input;
+  if (!shown) return null;
+  if ((shown.layout ?? "grid") !== "grid") return null;
+  if (shown.ruleId) return null;
+  if (shown.order === "manual") return null;
+  const { grouping } = presentationFacts(shown.presentation);
+  if (grouping && !(input.merged && isPlainGrouping(grouping))) return null;
+  const first = (shown.sorts ?? [])[0];
+  const viewSort = first && fields.some((f) => f.key === first.field) ? { id: first.field, direction: first.direction } : null;
+  const opening = viewSort ?? defaultSortOf(input.table, fields);
+  return {
+    p_table_id: input.tableId,
+    p_filter: viewFilterOf(shown) ?? {},
+    p_search: null,
+    p_sort: groupedPageSort(fields, grouping?.field ?? null, pageSortFor(fields, opening)),
+    p_view_id: null,
+    p_limit: input.pageSize ?? TABLE_PAGE_SIZE,
+    p_offset: 0
+  };
+}
+async function firstGridPageRequest(client, tableId, options = {}) {
+  return (await firstGridOpening(client, tableId, options))?.args ?? null;
+}
+function shownFromSpec(spec, tableId) {
+  return { ...spec, subject: spec.subject ?? tableId, id: "", movedFrom: null };
+}
+async function firstGridOpening(client, tableId, options) {
+  const codec = options.codec ?? plainPresentation;
+  const explicit = options.view;
+  const [table, fields, views, looks] = await Promise.all([
+    client.tableRead({ table_id: tableId }),
+    client.fields({ table_id: tableId }),
+    explicit ? Promise.resolve(null) : client.views({ table_id: tableId }),
+    explicit ? Promise.resolve(null) : readLooks(client, tableId, codec)
+  ]);
+  if (!table.ok || !fields.ok) return null;
+  let shown;
+  if (explicit) {
+    shown = shownFromSpec(explicit, tableId);
+  } else {
+    if (!views?.ok || !looks?.ok) return null;
+    const mine = views.data.map((row) => viewFromRow(row, codec)).filter((v) => v.subject === tableId);
+    const view = defaultViewOf(mine) ?? mine[0] ?? null;
+    shown = view ? applyLook(view, looks.data[view.id]) : shownFromSpec({ name: "All", subject: tableId, layout: "grid", isDefault: true }, tableId);
+  }
+  const args = firstGridPageArgs({
+    tableId,
+    table: table.data,
+    fields: fields.data,
+    shown,
+    ...options.pageSize ? { pageSize: options.pageSize } : {},
+    ...options.merged ? { merged: true } : {}
+  });
+  return args ? { args, shown, fields: fields.data } : null;
+}
+function serverRowsOf(seed) {
+  const found = seed?.answers.find((a) => a.door === "server_rows");
+  const data = found?.data;
+  if (!data || typeof data !== "object") return null;
+  return { on: data.on === true, capMs: typeof data.cap_ms === "number" && data.cap_ms > 0 ? data.cap_ms : null };
+}
+async function askTablePageSeed(input) {
+  const recording = recordingDataSource(asRecordsDataSource(input.dataSource));
+  const client = createRecordsClient({
+    dataSource: recording.source,
+    organizationId: input.organizationId,
+    actor: input.actor,
+    onError: () => {
+    }
+  });
+  const record = input.recordId ? Promise.resolve(
+    recording.source.rpc("record_page_bundle", { p_organization_id: input.organizationId, p_record_id: input.recordId }, { schema: "custom" })
+  ).catch(() => null) : null;
+  try {
+    const pageSize = input.pageSize ?? (input.embedded ? EMBEDDED_PAGE_SIZE : TABLE_PAGE_SIZE);
+    const opening = await firstGridOpening(client, input.tableId, {
+      pageSize,
+      ...input.merged ? { merged: true } : {},
+      ...input.view ? { view: input.view } : {},
+      ...input.codec ? { codec: input.codec } : {}
+    });
+    const wantRows = typeof input.rows === "function" ? input.rows(recording.seed()) : input.rows !== false;
+    if (opening && wantRows) {
+      const { args, shown, fields } = opening;
+      const page = await client.listPage({
+        table_id: args.p_table_id,
+        filter: args.p_filter,
+        search: args.p_search,
+        sort: args.p_sort,
+        view_id: args.p_view_id,
+        limit: args.p_limit,
+        offset: args.p_offset
+      });
+      if (page.ok) {
+        const { grouping, summaries: chosen } = presentationFacts(shown?.presentation);
+        const groupKey = grouping?.field ?? null;
+        const reads = [];
+        const filter = args.p_filter && Object.keys(args.p_filter).length > 0 ? args.p_filter : void 0;
+        if (groupKey) {
+          reads.push(client.recordAggregate({ table_id: input.tableId, groupBy: [groupKey], measures: groupFactMeasures(chosen), limit: 1e3, ...filter ? { filter } : {} }));
+        }
+        const bar = summaryBarMeasures(chosen);
+        if (bar.length > 0) reads.push(client.recordAggregate({ table_id: input.tableId, measures: bar, ...filter ? { filter } : {} }));
+        for (const field of fields) {
+          if (field.type !== "list" && field.type !== "relation") continue;
+          const ids = /* @__PURE__ */ new Set();
+          for (const row of page.data.rows) {
+            const value = row.document?.[field.key];
+            for (const id of Array.isArray(value) ? value.map(String) : typeof value === "string" ? [value] : []) if (isUuidShape2(id)) ids.add(id);
+          }
+          if (ids.size > 0) reads.push(client.relationWordsMany({ field_id: field.id, record_ids: [...ids] }));
+        }
+        if (input.merged) {
+          for (const key of choiceFieldKeys(fields)) {
+            reads.push(client.recordAggregate({ table_id: input.tableId, groupBy: [key], measures: [{ op: "count" }], limit: 500, ...filter ? { filter } : {} }));
+          }
+        }
+        const unversioned = page.data.rows.filter((row) => ownVersion(row) === null).map((row) => row.id);
+        if (unversioned.length > 0) reads.push(client.recordHeaders({ ids: unversioned }));
+        reads.push(
+          client.reverseColumns({ table_id: input.tableId }).then(async (columns) => {
+            if (!columns.ok || columns.data.length === 0) return null;
+            const record_ids = page.data.rows.map((row) => row.id);
+            const all = await client.reverseLinksFields({ table_id: input.tableId, source_field_ids: columns.data.map((c) => c.source_field_id), record_ids, limit: REVERSE_CELL_CHIPS });
+            if (all.ok || all.error.code !== "door_absent") return null;
+            return Promise.all(columns.data.map((c) => client.reverseLinksMany({ table_id: input.tableId, source_field_id: c.source_field_id, record_ids, limit: REVERSE_CELL_CHIPS })));
+          })
+        );
+        await Promise.all(reads.map((read) => read.catch(() => null)));
+      }
+    }
+  } catch {
+  }
+  if (record) await record;
+  return recording.seed();
+}
+function recordedClient(input) {
+  const recording = recordingDataSource(asRecordsDataSource(input.dataSource));
+  const client = createRecordsClient({ dataSource: recording.source, organizationId: input.organizationId, actor: input.actor, onError: () => {
+  } });
+  return { recording, client };
+}
+function entityTableQuery(options = {}) {
+  const search = (options.search ?? "").trim();
+  return { ...options.pageSize ? { pageSize: options.pageSize } : {}, ...search ? { search } : {} };
+}
+function entityChartQuestion(input) {
+  const m = input.measure ?? { op: "count" };
+  return {
+    ...input.by ? { by: [input.by] } : {},
+    show: [m.op === "count" ? "count" : { op: m.op, of: m.of }],
+    ...input.where ? { where: input.where } : {},
+    ...input.organization ? { organization: input.organization } : {}
+  };
+}
+function mergeSeeds(...seeds) {
+  const held = seeds.filter((s) => Boolean(s));
+  const answers = /* @__PURE__ */ new Map();
+  for (const seed of held) for (const a of seed.answers) answers.set(`${a.door}|${JSON.stringify(a.args)}`, a);
+  return { at: held.length ? Math.min(...held.map((s) => s.at)) : Date.now(), answers: [...answers.values()] };
+}
+async function askEntityBlockSeed(input) {
+  const recording = recordingDataSource(asRecordsDataSource(input.dataSource));
+  const port = createSeedPort(recording.source);
+  try {
+    await Promise.all([port.describe(input.token), port.list(input.token, entityTableQuery(input.question ?? {}))]);
+  } catch {
+  }
+  return recording.seed();
+}
+async function askChartSeed(input) {
+  const { recording, client } = recordedClient(input);
+  try {
+    await client.drillAsk({ source: input.source, question: entityChartQuestion(input.question ?? {}) });
+  } catch {
+  }
+  return recording.seed();
+}
+async function askTileSeed(input) {
+  const { recording, client } = recordedClient(input);
+  const specs = Array.isArray(input.spec) ? input.spec : [input.spec];
+  await Promise.all(specs.map((spec) => client.recordAggregate({ table_id: input.tableId, ...spec }).catch(() => null)));
+  return recording.seed();
+}
+function bindFirstPageCodec(codec) {
+  return {
+    firstGridPageRequest: (client, tableId, options = {}) => firstGridPageRequest(client, tableId, { ...options, codec }),
+    askTablePageSeed: (input) => askTablePageSeed({ ...input, codec })
+  };
+}
+export {
+  EMBEDDED_PAGE_SIZE,
+  REVERSE_CELL_CHIPS,
+  SUMMARY_OPERATIONS,
+  TABLE_PAGE_SIZE,
+  askChartSeed,
+  askEntityBlockSeed,
+  askTablePageSeed,
+  askTileSeed,
+  bindFirstPageCodec,
+  choiceFieldKeys,
+  defaultSortOf,
+  entityChartQuestion,
+  entityTableQuery,
+  firstGridPageArgs,
+  firstGridPageRequest,
+  groupFactMeasures,
+  groupedPageSort,
+  holdsNumbers,
+  isPlainGrouping,
+  mergeSeeds,
+  pageSortFor,
+  serverRowsOf,
+  sortAsFor,
+  summaryBarMeasures,
+  viewFilterOf
+};
+//# sourceMappingURL=index.js.map