@ai-matrx/records 0.93.2 → 0.93.4

package/dist/views/index.d.ts

@@ -1,14 +1,402 @@
-import { V as ViewPresentationDocument, S as SavedViewSpec, b as SavedView, a as ViewPresentationCodec, c as ViewSettings, d as ViewSettingsPatch } from '../views-Bny6SBX0.js';
-export { L as LAYOUT_FIELD_KIND, e as LAYOUT_LABEL, P as PAGE_VIEWS, f as PAGE_VIEW_LABEL, g as PageView, h as STORE_KEEPS_TIMELINE, i as STORE_KEPT_LAYOUTS, j as VIEW_KEYS, k as VIEW_LAYOUTS, l as VIEW_NEEDS, m as ViewKeyDeclaration, n as ViewKeyLayout, o as ViewKeyWriter, p as ViewLayout, q as ViewNeed, r as ViewNeedKind, s as ViewOrder, t as ViewSort, u as ViewSortKey, v as declareView, w as defaultViewOf, x as designateView, y as freeColumnName, z as makeDefaultLabel, A as pageViewFromParam, B as plainPresentation, C as saveViewPatch, D as storeKeepsLayout, E as unknownViewLine, F as viewDocument, G as viewFromRow, H as viewKeysFor, I as viewOrderOf, J as viewPatchDocument, K as viewPatchFor, M as viewSettings, N as viewSettingsFor, O as viewSettingsPatch, Q as wordsList } from '../views-Bny6SBX0.js';
-import { R as RecordsClient } from '../client-BKhJ6Ezn.js';
-import { U as Uuid, R as RecordsResult } from '../record-Bo1ahH3_.js';
-import { R as RecordFilter, e as SavedViewRow } from '../subscription-1ik9orQK.js';
-import '../rule-BojwTDvi.js';
-import '../table-kind-C2bMlOaV.js';
-import '../field-GR--cya9.js';
-import '../ports-CCPhsr-V.js';
-import '../relation-D8UmOxPh.js';
-import '../portal-o9FhryoU.js';
+import { R as RuleExpression } from '../rule-BVX1C83I.js';
+import { R as RecordFilter, n as SavedViewRow } from '../subscription-DucBLG-Y.js';
+import { R as RecordsClient } from '../client-DM3dRewB.js';
+import { U as Uuid, R as RecordsResult } from '../record-zwSBU5PQ.js';
+import '../table-kind-BGokuDJj.js';
+import '../field-D-1OKy5r.js';
+import '../ports-YOhD5T7h.js';
+import '../relation-Dk9-VzY0.js';
+import '../portal-DDOmQR1f.js';
+
+/** A view's look as the store keeps it: one JSON object under `definition.presentation`. */
+type ViewPresentationDocument = Record<string, unknown>;
+/**
+ * HOW A VIEW'S LOOK IS READ AND WRITTEN — a PORT. The store keeps the look as one JSON object; what it
+ * means (colors, formats, frozen columns) belongs to the screens that draw it, so the screens hand their
+ * codec in (`@ai-matrx/records-ui` binds its grid presentation). Left out, the look stays the plain
+ * document the store keeps — a headless host reads and writes it untouched.
+ */
+interface ViewPresentationCodec<P> {
+    parse(raw: unknown): P;
+    isEmpty(presentation: P): boolean;
+    /** The look as the JSON object the store keeps. */
+    toDocument(presentation: P): Record<string, unknown>;
+}
+/** The look as the plain JSON document the store keeps (no screen's meaning applied). */
+declare const plainPresentation: ViewPresentationCodec<ViewPresentationDocument>;
+/** Every surface a saved view is drawn by. */
+type ViewKeyLayout = "grid" | "kanban" | "calendar" | "gallery" | "timeline" | "list";
+/**
+ * 🚩 THE ONE SWITCH FOR THE TIMELINE'S STORE KEYS (lane VIEWS-AND-FIELDS, sublane TL).
+ *
+ * `vk_a_calendar_keeps_where_a_record_ends_and_a_timeline_is_a_view.sql` (sublane VK) teaches
+ * `custom.view_keys()` the layout `timeline`, the keys `start_field` and `end_field` (calendar +
+ * timeline), and `group_field` for the timeline. Until that migration is on production this stays
+ * `false`, and:
+ *   · `timeline` is not a layout the store keeps (`STORE_KEPT_LAYOUTS`), so it is drawn for the visit;
+ *   · `start_field` / `end_field` are held for the visit, never sent (`viewSettingsPatch`), and the
+ *     Start also rides `date_field`, which the store already keeps;
+ *   · the timeline's toolbar says "Kept for this visit only".
+ * Flipped to `true`, VIEW_KEYS below mirrors the migrated registry row for row (the live walk
+ * compares them) and every one of those is kept on the view.
+ */
+declare const STORE_KEEPS_TIMELINE = true;
+/** Who may write a key: anyone who may save the view, an input the door rewrites, or the server only. */
+type ViewKeyWriter = "caller" | "input" | "server";
+interface ViewKeyDeclaration {
+    /** Where it lives in `platform.saved_view.definition` (dotted under `presentation`). */
+    path: string;
+    /** What the store's guard checks (`custom._view_key_value`). */
+    shape: string;
+    /** The layouts that read it. */
+    layouts: readonly ViewKeyLayout[];
+    writer: ViewKeyWriter;
+}
+/**
+ * THE REGISTRY, as `custom.view_keys()` declares it (uichamp_s1_a_view_keeps_every_setting_it_is_given.sql).
+ * Order and content are compared with the store by the live walk.
+ */
+declare const VIEW_KEYS: readonly ViewKeyDeclaration[];
+/**
+ * THE LAYOUTS THE STORE KEEPS ON A VIEW. `custom.view_keys()` judges a view's `layout` against its
+ * own list (grid, kanban, calendar, gallery) and refuses any other word by name. A layout this
+ * package draws before the store keeps it — the timeline, 2026-10-02 — is never sent as a view's or a
+ * look's layout (`viewSettingsPatch`, `viewDocument`): it is drawn for this visit and says so. When the
+ * store's registry admits it, add it here and nothing else changes.
+ */
+declare const STORE_KEPT_LAYOUTS: readonly string[];
+/** Whether the store keeps this layout on a saved view. */
+declare function storeKeepsLayout(layout: string): boolean;
+/** The keys one layout reads, by path. */
+declare function viewKeysFor(layout: ViewKeyLayout): string[];
+/** One sort clause: a Field key and a direction. */
+interface ViewSortKey {
+    field: string;
+    direction: "asc" | "desc";
+}
+/**
+ * EVERY DECLARED KEY OF A VIEW, TYPED. Absent keys are `null` / empty, never guessed.
+ * `presentation` is the parsed look (colour field, pinned fields, row height, grouping with its
+ * sub-groups and shut sections, hidden fields, gallery size, summaries).
+ */
+interface ViewSettings<P = ViewPresentationDocument> {
+    layout: "grid" | "kanban" | "calendar" | "gallery" | "timeline" | "list";
+    filters: RecordFilter | null;
+    where: RuleExpression | null;
+    groupField: string | null;
+    swimlaneField: string | null;
+    collapsedColumns: string[];
+    measure: string | null;
+    dateField: string | null;
+    /** Timeline: where a record's bar starts (`start_field`). */
+    startField: string | null;
+    /** Calendar and timeline: where a record ends (`end_field`). */
+    endField: string | null;
+    imageField: string | null;
+    sorts: ViewSortKey[];
+    ruleId: string | null;
+    isDefault: boolean;
+    presentation: P;
+    movedFrom: Record<string, unknown> | null;
+}
+/** THE READER. A stored `definition` (and the row's flat `filters`) in, every declared key out. */
+declare function viewSettings<P = ViewPresentationDocument>(definition: Record<string, unknown> | null | undefined, rowFilters?: RecordFilter | null, codec?: ViewPresentationCodec<P>): ViewSettings<P>;
+/** The settings as the spec names them — what `viewSettingsPatch` takes. */
+type ViewSettingsPatch<P = ViewPresentationDocument> = Partial<Omit<ViewSettings<P>, "movedFrom" | "layout">> & {
+    /** Any layout the package draws; one the store does not keep is not sent. */
+    layout?: string;
+};
+/**
+ * THE KEYS ONE LAYOUT READS, and nothing else. A layout that does not use a key never sees it:
+ * a calendar is not told the board's swimlanes, a board is not told the grid's pinned fields.
+ */
+declare function viewSettingsFor<P extends object = ViewPresentationDocument>(settings: ViewSettings<P>, layout: ViewKeyLayout): Partial<ViewSettings<P>>;
+/**
+ * THE WRITER'S SHAPE. Only the keys a press changed; a cleared Field is `null` (the door removes
+ * it); lists are sent whole. `presentation` is sent whole because the door judges it as one key.
+ */
+declare function viewSettingsPatch<P = ViewPresentationDocument>(patch: ViewSettingsPatch<P>, codec?: ViewPresentationCodec<P>): Record<string, unknown>;
+
+/** The ways one saved view can be looked at (SCR-6; the timeline, lane VIEWS-AND-FIELDS TL). */
+declare const VIEW_LAYOUTS: readonly ["grid", "kanban", "calendar", "gallery", "timeline", "list"];
+type ViewLayout = (typeof VIEW_LAYOUTS)[number];
+declare const LAYOUT_LABEL: Record<ViewLayout, string>;
+/**
+ * ─────────────────────────────────────────────────────────────────────────────
+ * WHAT EACH LAYOUT NEEDS FROM THE TABLE, AND HOW THE SCREEN SUPPLIES IT
+ * (lane DATA-V2-VIEWS-1, Arman 2026-09-28).
+ *
+ * THE DEFECT. A plain table opened as a Kanban said "A kanban board needs a Field to make its
+ * columns from … Add column, then Select — and it appears here." It told the person what to do
+ * instead of doing it, and on an AI platform it offered no AI. The ruling: ONE primitive, used by
+ * every view (`ViewNeeds`) — the empty state says in one plain sentence what is missing and what
+ * pressing will do, offers "Make it work" (the column is declared through the store's
+ * `custom.field_declare`, its key minted by the store, its name and choices editable before the
+ * press) and "Ask AI" (the agent does it through the same door, held for the person's approval by
+ * the organization's "Agent changes to this organization's data" setting).
+ *
+ * THE CENSUS — every layout this package draws, and what it reads:
+ *   · grid      nothing.
+ *   · kanban    a CHOICE column (its options become the board's columns). Blocking.
+ *   · calendar  a DATE column (it places each record on a day). Blocking.
+ *   · gallery   a FILE column for the card's picture. NOT blocking: the cards draw without one,
+ *               so the offer sits above them instead of in place of them.
+ *   · timeline  a DATE column each bar starts on (the calendar's `dateField`). Blocking.
+ * `PAGE_VIEWS`' two extra values (dashboards, archived) read
+ * nothing a table can lack. This package ships no map layout; the day it does,
+ * `Record<ViewLayout, …>` below refuses to compile until the new layout names what it needs.
+ */
+type ViewNeedKind = "choice" | "date" | "file";
+interface ViewNeed {
+    /** What the layout reads, as a kind a column declares (`offerableFields`). */
+    kind: ViewNeedKind;
+    /** The view key the made column is written onto, so the layout opens drawn by it. */
+    viewKey: "groupField" | "dateField" | "imageField";
+    /** True when the layout cannot draw at all without it (kanban, calendar). */
+    blocking: boolean;
+    /** The column the press makes, before the person edits it: its name, the store's word, its choices. */
+    starter: {
+        label: string;
+        type: "select" | "datetime" | "attachment";
+        options?: readonly string[];
+    };
+    /** The table HAS columns this layout can use and none is chosen: the sentence over the picker. */
+    pick: string;
+    /** One plain sentence: what the table is missing (all a person who may not change it is told). */
+    missing: string;
+    /** One plain sentence: what pressing Make it work will do, with the column's name. */
+    does: (label: string) => string;
+    /** The sentence an agent is asked with — the same act, said in words. */
+    ask: (label: string, options: readonly string[]) => string;
+}
+/** A list of words as a person says it: "To do, In progress and Done". */
+declare function wordsList(words: readonly string[]): string;
+declare const VIEW_NEEDS: Record<ViewLayout, ViewNeed | null>;
+/**
+ * A NAME NO COLUMN OF THIS TABLE ALREADY HAS: the starter's own, else "Status 2", "Status 3"…
+ * A table that already holds a text column called Status must not be refused the board.
+ */
+declare function freeColumnName(wanted: string, taken: readonly string[]): string;
+/** One sort clause. The Field's key and a direction; nothing else is a sort. */
+interface ViewSort {
+    field: string;
+    direction: "asc" | "desc";
+}
+/** How a saved view is ordered: by hand, by its sort, or it never said (the same as sorted). */
+type ViewOrder = "manual" | "sorted" | null;
+/** The order word a stored definition carries. Only the two words the store writes are read. */
+declare function viewOrderOf(definition: Record<string, unknown> | null | undefined): ViewOrder;
+/**
+ * THE DECLARATIVE SPEC. An agent writes this whole object; a person tweaks it.
+ * Every builder component in this package takes one of these as a prop.
+ */
+interface SavedViewSpec<P = ViewPresentationDocument> {
+    name: string;
+    /** The Table this view looks at. */
+    subject: Uuid;
+    layout: ViewLayout;
+    /** Kanban: the Field whose value becomes a column. */
+    groupField?: string | null;
+    /**
+     * Kanban: a number Field to TOTAL under each column heading. It lives on the VIEW for
+     * the same reason the colours do — two people read one board two ways and neither
+     * reading is a fact about the records.
+     */
+    measure?: string | null;
+    /**
+     * Kanban: the Field whose values cut the board into SWIMLANES across the columns — a
+     * dispatcher's board by Status, one lane per Technician (S1-PRIME VIEW-KEYS). Never the
+     * column Field itself; the store refuses that.
+     */
+    swimlaneField?: string | null;
+    /** Kanban: the columns this view keeps shut to a strip, by the column's stored value. */
+    collapsedColumns?: string[];
+    /** Calendar: the Field that places a record in the month. */
+    dateField?: string | null;
+    /** Timeline: the Field a record's bar starts on (`start_field`). */
+    startField?: string | null;
+    /** Calendar and timeline: the Field a record ends on (`end_field`). */
+    endField?: string | null;
+    /** Gallery: the Field shown large on the card. */
+    imageField?: string | null;
+    sorts?: ViewSort[];
+    /**
+     * HOW THE VIEW IS ORDERED (ORDER-FIX): `"manual"` — the positions a person set by hand ARE the
+     * view's sort, and it carries no `sorts`; `"sorted"` or null — by `sorts`. READ ONLY: the store
+     * writes "manual" only when the rows are placed (`custom.view_record_order_set`) and turns it
+     * off itself when a sort is saved, so no patch ever sends it (`viewSettingsPatch` does not).
+     */
+    order?: ViewOrder;
+    /**
+     * The membership Rule. The STORE decides who is in this view; this is a
+     * reference to its Rule record, never a predicate this package evaluates.
+     */
+    ruleId?: Uuid | null;
+    /**
+     * THE FLAT FILTER a digest or a notify rule wrote the view with — the one shape
+     * `custom.record_filter_sql` compiles, by Field KEY. A view saved in the bar has
+     * none; a view saved by `DigestScheduler` ("where Status is Open") does, and the
+     * grid and the board show exactly the records it names.
+     */
+    filters?: RecordFilter;
+    /**
+     * S2-PRIME — THE VIEW'S OWN QUESTION, as the condition builder writes it: the store's Rule
+     * shape `{op, args}`, ALL / ANY / NOT groups nested to any depth, Fields by id. Kept in the
+     * definition as `where` and asked of the store unchanged — the grid's list door, the board's
+     * headings and the dashboard's numbers compile it into the one WHERE clause
+     * (`custom.record_filter_sql`). Never stored under `filters`: that key is the flat map the
+     * digests and the notifier read, and they would refuse it by name.
+     */
+    where?: RuleExpression | null;
+    isDefault?: boolean;
+    /**
+     * HOW THIS VIEW LOOKS — its colors, its per-column formats and its frozen
+     * column (`presentation.ts`).
+     *
+     * It lives on the VIEW and not on the Fields because two people read one
+     * table two ways and neither reading is a fact about the records; it lives on
+     * a RECORD, not a new column, because that is what makes it something an
+     * agent writes with the same `records` tool as everything else.
+     */
+    presentation?: P;
+}
+/**
+ * A saved view as it comes back out of the store, with its row's own id.
+ *
+ * It carries no version: `custom.view_declare` MERGES one key at a time, so two
+ * tabs pressing two different controls on one view both stand, and one control
+ * pressed in both keeps the latest — how Airtable and Notion keep a view change.
+ */
+interface SavedView<P = ViewPresentationDocument> extends SavedViewSpec<P> {
+    id: Uuid;
+    /** Where the view came from when it was moved in (the mover, the S0 repair), else null. */
+    movedFrom: Record<string, unknown> | null;
+}
+/** THE TABLE'S DEFAULT VIEW: the first view that says it is. */
+declare function defaultViewOf<V extends Pick<SavedView, "isDefault">>(views: readonly V[]): V | undefined;
+/**
+ * WHICH FIELD EACH LAYOUT CAN BE DRAWN FROM, decided from the FIELD'S OWN
+ * DECLARATION and never from the values it happens to hold.
+ *
+ * A kanban makes columns from a choice: the Field whose value is one of a
+ * closed set (FLD-5 / FLD-6 — a pick-list is a Table, and a select stores the
+ * id of one of its records). Grouping by a free-text Field produces one column
+ * per record, which is not a board. A calendar places a record in time, so it
+ * needs a Field that holds a date.
+ *
+ * These two answers are here, beside the layouts, because the picker on the
+ * screen and any agent writing a view spec must agree about what is offerable.
+ */
+declare const LAYOUT_FIELD_KIND: Record<ViewLayout, ViewNeedKind | null>;
+/**
+ * ─────────────────────────────────────────────────────────────────────────────
+ * WHICH VIEW A LINK NAMES — the address bar as a first-class control.
+ *
+ * 🚨 THE DEFECT THIS CLOSES (lane FRONT-DOOR, 2026-09-21; VERIFIER-8 HIGH-2).
+ * `/data/<table>?view=kanban` returned 200 and rendered THE GRID. The
+ * switcher was there, the four buttons worked, and the parameter was read by
+ * nobody — so a person who bookmarked a board, or sent one to a colleague, got
+ * a grid, and nothing on the screen said the view had been dropped. A link that
+ * does not land is the inbox-link defect (`activeRecordId`) and the dashboard
+ * defect (`activeDashboardId`) for the third time, so this is the same shape of
+ * fix: the URL names it, the page opens on it, and the URL FOLLOWS the person
+ * when they pick another.
+ *
+ * The dashboards are a fifth value and not a special case: to the person, "the
+ * dashboard" is one of the ways to look at this table, and a link to it has to
+ * work like a link to the board.
+ */
+/**
+ * 🚨 `archived` IS THE SIXTH VALUE, AND IT IS NOT A SPECIAL CASE EITHER (lane
+ * FIX-10A-ARCHIVE, 2026-09-22; VERIFIER-10 F4).
+ *
+ * Archiving a record used to be a ONE-WAY DOOR: the grid's row action soft-
+ * deletes correctly — `deleted_at` set, version bumped, nothing removed — and
+ * then no screen anywhere in the platform could bring it back. The store's
+ * `custom.record_restore` was there the whole time and did exactly the right
+ * thing; nothing reached it, because every read door answers live rows only.
+ *
+ * So the archive is a WAY OF LOOKING AT THIS TABLE, like the board and the
+ * dashboards, reached by the same row of buttons and named by the same
+ * `?view=` parameter — never a Trash area of the app somebody has to know
+ * exists, and never a per-table screen. Every Table inherits it the moment it
+ * is in this list.
+ */
+declare const PAGE_VIEWS: readonly ["grid", "kanban", "calendar", "gallery", "timeline", "list", "dashboards", "archived"];
+type PageView = (typeof PAGE_VIEWS)[number];
+declare const PAGE_VIEW_LABEL: Record<PageView, string>;
+/**
+ * What a `?view=` value means, or `null` when it means nothing here.
+ *
+ * `null` is NOT "show the grid": the caller is expected to say that the link
+ * named something this table has no view for, because silently substituting a
+ * different view is exactly the defect above wearing a parser.
+ */
+declare function pageViewFromParam(raw: string | null | undefined): PageView | null;
+/** The sentence a link that named a view nobody has says. Never silent. */
+declare function unknownViewLine(raw: string): string;
+/**
+ * THE SPEC AS THE ONE DEFINITION `platform.saved_view` HOLDS — the keys
+ * `custom.view_declare` documents, by Field KEY. `subject` is not in it: the door
+ * takes the Table as its own argument and writes `table_id` itself.
+ */
+declare function viewDocument<P = ViewPresentationDocument>(spec: SavedViewSpec<P>, codec?: ViewPresentationCodec<P>): Record<string, unknown>;
+/**
+ * One row of `custom.views` back into the spec a screen and an agent both read — THROUGH THE ONE
+ * ACCESSOR (`viewSettings`, viewKeys.ts), so every layout sees every declared key the same way.
+ */
+declare function viewFromRow<P = ViewPresentationDocument>(row: SavedViewRow, codec?: ViewPresentationCodec<P>): SavedView<P>;
+/**
+ * SAVE ONE NEW VIEW of a Table — the bar's "New view" and an agent's seed spec.
+ * One `view_declare` with no `view_id`; the answer is the new view's id.
+ */
+declare function declareView<P = ViewPresentationDocument>(client: Pick<RecordsClient, "viewDeclare">, spec: SavedViewSpec<P>, codec?: ViewPresentationCodec<P>): Promise<RecordsResult<Uuid>>;
+/**
+ * WRITE A CHANGE ONTO A SAVED VIEW, AND KEEP IT.
+ *
+ * `custom.view_declare` with the view's id MERGES: only the keys in `patch` are
+ * written, a key cleared to null is removed, and everything the patch did not
+ * name — the grid's own choices, a hand-set order, where the view was moved from,
+ * a colour set in another tab — stays exactly as it was (S0, 2026-09-23: the door
+ * used to rebuild the whole definition from what one press sent).
+ *
+ * There is no version to be stale against (VERIFIER-15 M4 is closed by the shape,
+ * not by a retry): a saved view is a person's own arrangement of a table, and
+ * their latest press on a control is the one that stands. A refusal — the view
+ * was removed, or belongs to a table this person cannot open — is handed back for
+ * the page to say through the one notice.
+ */
+declare function saveViewPatch<P = ViewPresentationDocument>(client: Pick<RecordsClient, "viewDeclare">, tableId: Uuid, viewId: Uuid, patch: Partial<SavedViewSpec<P>>, codec?: ViewPresentationCodec<P>): Promise<RecordsResult<Uuid>>;
+/**
+ * A PARTIAL change to a saved view, as the definition keys the door merges. Only
+ * the keys the caller actually changed are sent; a Field cleared (a board with no
+ * "Group by") is sent as `null`, which the door removes.
+ */
+declare function viewPatchDocument<P = ViewPresentationDocument>(patch: Partial<SavedViewSpec<P>>, codec?: ViewPresentationCodec<P>): Record<string, unknown>;
+/**
+ * A LOOK AT A TABLE NEVER CHANGES HOW IT OPENS (lane VIEW-SWITCH-NOT-DESIGNATION, VERIFIER-21).
+ *
+ * On production the owner pressed Kanban, then Calendar, and the office member's table opened in
+ * the Calendar: every layout press was saved onto the DEFAULT view, which is how the table opens
+ * for everyone. The table's default view's `layout` and `isDefault` are its DESIGNATION, changed
+ * only by an editor's deliberate "Make this the default" (`designateView`); the store refuses them
+ * through `view_declare` by name. So a press on the default view carries every other key it
+ * changed — a board's grouping, a calendar's date, a colour — and never those two.
+ */
+declare function viewPatchFor<S extends {
+    layout?: unknown;
+    isDefault?: boolean;
+}>(view: {
+    isDefault?: boolean;
+}, patch: Partial<S>): Partial<S>;
+/** The one words for the explicit designation, with the layout it would make the default. */
+declare function makeDefaultLabel(layoutLabel: string): string;
+/**
+ * MAKE THIS THE DEFAULT — the ONE designation door (`custom.view_designate`, editor on the table).
+ * `layout` is the layout this table should open in for everyone: one of the layouts the store keeps. The view
+ * becomes the table's only default.
+ */
+declare function designateView(client: Pick<RecordsClient, "viewDesignate">, tableId: Uuid, viewId: Uuid, layout: string | null): Promise<RecordsResult<Uuid>>;
 
 /**
  * WHAT A LOOK MAY HOLD — how a person looks, never what the view is: not its name, not whether it is the default,
@@ -53,4 +441,4 @@ declare function bindViewCodec<P>(codec: ViewPresentationCodec<P>): {
     keepLook: (client: Pick<RecordsClient, "viewLookSet">, tableId: Uuid, viewId: Uuid, look: ViewLook<P> | null) => Promise<RecordsResult<Record<string, unknown> | null>>;
 };
 
-export { SavedView, SavedViewSpec, type ViewLook, ViewPresentationCodec, ViewPresentationDocument, ViewSettings, ViewSettingsPatch, applyLook, bindViewCodec, keepLook, lookDiffers, lookDocument, lookFromDocument, lookPart, readLooks, saveToViewPlan };
+export { LAYOUT_FIELD_KIND, LAYOUT_LABEL, PAGE_VIEWS, PAGE_VIEW_LABEL, type PageView, STORE_KEEPS_TIMELINE, STORE_KEPT_LAYOUTS, type SavedView, type SavedViewSpec, VIEW_KEYS, VIEW_LAYOUTS, VIEW_NEEDS, type ViewKeyDeclaration, type ViewKeyLayout, type ViewKeyWriter, type ViewLayout, type ViewLook, type ViewNeed, type ViewNeedKind, type ViewOrder, type ViewPresentationCodec, type ViewPresentationDocument, type ViewSettings, type ViewSettingsPatch, type ViewSort, type ViewSortKey, applyLook, bindViewCodec, declareView, defaultViewOf, designateView, freeColumnName, keepLook, lookDiffers, lookDocument, lookFromDocument, lookPart, makeDefaultLabel, pageViewFromParam, plainPresentation, readLooks, saveToViewPlan, saveViewPatch, storeKeepsLayout, unknownViewLine, viewDocument, viewFromRow, viewKeysFor, viewOrderOf, viewPatchDocument, viewPatchFor, viewSettings, viewSettingsFor, viewSettingsPatch, wordsList };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ai-matrx/records",
-  "version": "0.93.2",
+  "version": "0.93.4",
   "description": "The headless client of the AI Matrx record store: the Table / Field / Rule / Record / Relation / Home types, the closed vocabularies and refusal codes read from the store itself, the typed calls over the store's doors and nothing else, the merge-field declaration, a validation mirror that predicts only what the store's own triggers refuse, and the never-throw result envelope. Zero React, zero DOM in the root and /core.",
   "type": "module",
   "main": "./dist/index.cjs",
@@ -320,5 +320,5 @@
     "describe-bench:run": "../../../.venv/bin/python scripts/describe-bench/score-env.py run",
     "describe-bench:arms": "../../../.venv/bin/python scripts/describe-bench/score-env.py arms"
   },
-  "gitHead": "f0c9d2820cbe5bef9bcd8e136dcce9358371c49e"
+  "gitHead": "58cf6cf4b39debf76a01dc2f2cbd5ab7ad8cbbfe"
 }

package/dist/seed-CQkIf8UR.d.cts

@@ -1,37 +0,0 @@
-import { R as RecordsDataSource } from './ports-BTDZ9ydi.cjs';
-
-/** One door's answer, under its exact arguments. Plain JSON: it crosses from server to browser. */
-interface RecordsSeedAnswer {
-    door: string;
-    args: Record<string, unknown>;
-    data: unknown;
-}
-/** What a server asked for a page, as the person, and when. */
-interface RecordsSeed {
-    /** Epoch ms when the server asked. */
-    at: number;
-    answers: RecordsSeedAnswer[];
-}
-/** The match key: a door and every argument, keys sorted at every depth. */
-declare function seedKey(door: string, args: Record<string, unknown>): string;
-/**
- * A data source that asks `source` and keeps every answer a door GAVE (errors are not kept). For a
- * server render: create a records client over it, ask what the page will ask, then `seed()`.
- */
-declare function recordingDataSource(source: RecordsDataSource): {
-    source: RecordsDataSource;
-    seed: () => RecordsSeed;
-};
-/** The seed as a lookup, built once per seed. */
-declare function seedIndex(seed: RecordsSeed): Map<string, unknown>;
-/**
- * ONE RUN AGAINST THE SEED: a data source answering from `index` only, and whether the run asked a
- * door the seed does not hold. It never opens a bundle itself (`opensInOneCall` off): the bundle's
- * parts are already answers in the index.
- */
-declare function seededDataSource(index: Map<string, unknown>): {
-    source: RecordsDataSource;
-    missed: () => boolean;
-};
-
-export { type RecordsSeed as R, type RecordsSeedAnswer as a, seedKey as b, seededDataSource as c, recordingDataSource as r, seedIndex as s };

package/dist/seed-Dz8Hi2LZ.d.ts

@@ -1,37 +0,0 @@
-import { R as RecordsDataSource } from './ports-CCPhsr-V.js';
-
-/** One door's answer, under its exact arguments. Plain JSON: it crosses from server to browser. */
-interface RecordsSeedAnswer {
-    door: string;
-    args: Record<string, unknown>;
-    data: unknown;
-}
-/** What a server asked for a page, as the person, and when. */
-interface RecordsSeed {
-    /** Epoch ms when the server asked. */
-    at: number;
-    answers: RecordsSeedAnswer[];
-}
-/** The match key: a door and every argument, keys sorted at every depth. */
-declare function seedKey(door: string, args: Record<string, unknown>): string;
-/**
- * A data source that asks `source` and keeps every answer a door GAVE (errors are not kept). For a
- * server render: create a records client over it, ask what the page will ask, then `seed()`.
- */
-declare function recordingDataSource(source: RecordsDataSource): {
-    source: RecordsDataSource;
-    seed: () => RecordsSeed;
-};
-/** The seed as a lookup, built once per seed. */
-declare function seedIndex(seed: RecordsSeed): Map<string, unknown>;
-/**
- * ONE RUN AGAINST THE SEED: a data source answering from `index` only, and whether the run asked a
- * door the seed does not hold. It never opens a bundle itself (`opensInOneCall` off): the bundle's
- * parts are already answers in the index.
- */
-declare function seededDataSource(index: Map<string, unknown>): {
-    source: RecordsDataSource;
-    missed: () => boolean;
-};
-
-export { type RecordsSeed as R, type RecordsSeedAnswer as a, seedKey as b, seededDataSource as c, recordingDataSource as r, seedIndex as s };