@jxsuite/studio 6.1.1 → 8.0.0

package/src/content/entry-editor.ts

@@ -3,11 +3,11 @@
  * The **Entry editor** (site-architecture.md §7.4): a content entry's fields, as a form, in a pane.
  *
  * Until now a markdown entry could be edited two ways and neither was its schema: the canvas edited
- * its BODY, and the Document Header card drew a field list from `panels/frontmatter-fields.ts`'s
- * own type→widget ladder, which is a second implementation of `ui/schema-form.ts` with no reference
- * branch, no validation and no value-source ladder. A JSON entry (`authors/ada.json`) had no field
- * editor at all — it opened as a component tree, so `bio` was a node's property and `links` was a
- * child array.
+ * its BODY, and the Document Header card (since removed) drew a field list from
+ * `panels/frontmatter-fields.ts`'s own type→widget ladder, which is a second implementation of
+ * `ui/schema-form.ts` with no reference branch, no validation and no value-source ladder. A JSON
+ * entry (`authors/ada.json`) had no field editor at all — it opened as a component tree, so `bio`
+ * was a node's property and `links` was a child array.
  *
  * This is one editor over the schema form, so every improvement to the engine reaches content
  * entries, settings and the inspector at once — and the `reference` control in particular arrives
@@ -25,7 +25,7 @@
  * it unshifts its mode onto the tab the file already has, so ⌘S, the dirty flag, the transaction
  * log and undo are the ordinary document verbs. Every field commits through
  * {@link mutateEntryField}, so an edit made here is undone by ⌘Z and replayed by a collaborator
- * exactly as one made in the Document Header card.
+ * exactly as one made in the Inspector's Page tab.
  *
  * **One editor, two storage shapes.** A markdown entry keeps its fields in frontmatter; a JSON
  * entry IS its fields. `content/entry-fields.ts` owns that single question, and this file never
@@ -50,17 +50,23 @@ import { mountEntryEditorSurface } from "../surfaces/entry-editor";
 import { paneRegion } from "../ui/regions";
 import { activateTab, workspace } from "../workspace/workspace";
 import { commitEntryFields, entryFields, mutateEntryField } from "./entry-fields";
+import type { EntryFields } from "./entry-fields";
 import { DRAFT_FIELD, DRAFT_MEANING, hasDraftAxis, isDraftEntry } from "./draft-state";
-import { collectionOfPath, missingRequired } from "./entry-model";
+import { collectionOfPath, missingRequired, recordCollectionOfPath } from "./entry-model";
+import { ENTRY_MODE, isRecordTab, recordPlace, showRecord } from "./record-entry";
+import { requestGridReveal } from "../grid/grid-reveal";
+import { titleFieldOf } from "./entry-summaries";
 import type { EntryCollection } from "./entry-model";
 import type { EntryEditorSurfaceHandle, EntryEditorView } from "../surfaces/entry-editor";
 import type { JsonSchema, SchemaFormContext } from "../ui/schema-form";
 import type { Tab } from "../tabs/tab";
 import type { CanvasSurface } from "../canvas/canvas-surface";
-import type { JsonValue } from "../types";
+import type { ContentTypeSchema, JsonObject } from "@jxsuite/schema/types";
+import { isString } from "@jxsuite/schema/guards";
+import { fieldTitle } from "../browse/library-source";
 
-/** The `canvasMode` the entry form draws under. */
-export const ENTRY_MODE = "entry";
+/** The `canvasMode` the entry form draws under (defined with the record a form may be over). */
+export { ENTRY_MODE } from "./record-entry";
 
 /** What an entry tab's mode list becomes when the Entry editor opens it: the form leads. */
 const ENTRY_TAB_MODES = [ENTRY_MODE];
@@ -120,7 +126,7 @@ export function detachEntryPane(paneId: string): void {
  * has explicitly published something should be able to see that they did.
  */
 export function setEntryDraft(tab: Tab, draft: boolean): void {
-  transactDoc(tab, (t) => mutateEntryField(t, DRAFT_FIELD, draft as JsonValue));
+  transactDoc(tab, (t) => mutateEntryField(t, DRAFT_FIELD, draft));
 }
 
 /** What the tab chip's draft pill says. A value, drawn by `surfaces/tab-strip.json`. */
@@ -148,7 +154,7 @@ export interface DraftPill {
  * chip's `status` slot, and `.entry-pill`'s rules in `styles/overlays.css` are dead with it.
  */
 export function entryDraftPill(tab: Tab): DraftPill | null {
-  const collection = collectionOfPath(tab.documentPath);
+  const collection = entryCollectionOf(tab);
   const fields = entryFields(tab);
   if (!collection || !hasDraftAxis(collection.schema, fields)) {
     return null;
@@ -163,13 +169,29 @@ export function entryDraftPill(tab: Tab): DraftPill | null {
 
 // ─── The form ────────────────────────────────────────────────────────────────
 
+/**
+ * The words each field's row is titled with: the schema's own `title` where it states one, else the
+ * key in words (`publishedAt` → "Published at"), the spelling the Content home's columns use. A raw
+ * key is a storage name, and an author reads "Cover", not `cover`.
+ */
+export function fieldLabels(
+  schema: ContentTypeSchema | null | undefined,
+): Record<string, { label: string }> {
+  return Object.fromEntries(
+    Object.entries(schema?.properties ?? {}).map(([name, field]) => [
+      name,
+      { label: isString(field.title) && field.title !== "" ? field.title : fieldTitle(name) },
+    ]),
+  );
+}
+
 /** The form's host context: enum pointers resolve against this project's configuration. */
-function formContext(tab: Tab): SchemaFormContext {
+export function formContext(tab: Tab): SchemaFormContext {
   return {
     fieldKeyPrefix: `entry:${tab.id}`,
     resolvePointer: (pointer, scope) =>
       resolveContextPointer(pointer, {
-        projectConfig: (projectState?.projectConfig ?? {}) as Record<string, unknown>,
+        projectConfig: projectState?.projectConfig ?? {},
         scope,
       }),
   };
@@ -183,15 +205,42 @@ function formContext(tab: Tab): SchemaFormContext {
  * missing from the file is a fact about the document, and saying so is the whole reason the form
  * knows the schema.
  */
-function absentRequiredErrors(
+export function absentRequiredErrors(
   collection: EntryCollection,
-  fields: Record<string, unknown>,
+  fields: EntryFields,
 ): Record<string, string> {
-  const errors: Record<string, string> = {};
-  for (const field of missingRequired(collection.schema, fields)) {
-    errors[field] = "Required — this entry does not have one.";
+  return Object.fromEntries(
+    missingRequired(collection.schema, fields).map((field) => [
+      field,
+      "Required — this entry does not have one.",
+    ]),
+  );
+}
+
+/** The collection an entry tab's form is typed by: its file's, or for a record its file's records'. */
+function entryCollectionOf(tab: Tab): EntryCollection | null {
+  return isRecordTab(tab)
+    ? recordCollectionOfPath(tab.documentPath)
+    : collectionOfPath(tab.documentPath);
+}
+
+/**
+ * The schema with the entry's title field moved to the top: what an entry is called is the first
+ * thing an author looks for, and a schema imported from a CMS lists its properties alphabetically,
+ * which put `title` after forty other fields.
+ */
+export function titleFirst(
+  form: JsonSchema,
+  schema: ContentTypeSchema | null,
+  fields: EntryFields,
+): JsonSchema {
+  const title = titleFieldOf(schema, fields);
+  const properties = form.properties ?? {};
+  const held = title === null ? undefined : properties[title];
+  if (title === null || held === undefined) {
+    return form;
   }
-  return errors;
+  return { ...form, properties: { [title]: held, ...properties } };
 }
 
 /** What the document says when the file belongs to no collection: the reason, then the fix. */
@@ -212,14 +261,20 @@ function entryView(paneId: string, tab: Tab, collection: EntryCollection | null)
       emptyLine: emptyLine(tab),
       fieldsRegion,
       name: "",
+      nextDisabled: true,
       note: "",
       noteState: "hidden",
+      place: "",
+      previousDisabled: true,
+      recordNav: "hidden",
       region,
       stage: "empty",
     };
   }
   const fields = entryFields(tab);
   const draft = isDraftEntry(fields);
+  const record = isRecordTab(tab);
+  const place = recordPlace(tab);
   return {
     collection: collection.name,
     draft,
@@ -227,14 +282,31 @@ function entryView(paneId: string, tab: Tab, collection: EntryCollection | null)
     draftHint: DRAFT_MEANING,
     emptyLine: "",
     fieldsRegion,
-    name: tab.documentPath?.split("/").pop() ?? "Untitled",
+    // A record is called what the Content home calls it: its title field, else its row.
+    name: record
+      ? recordName(collection, fields, place.index)
+      : (tab.documentPath?.split("/").pop() ?? "Untitled"),
+    nextDisabled: place.next === null,
     note: DRAFT_MEANING,
     noteState: draft ? "shown" : "hidden",
+    place: place.index === -1 ? "" : `${place.index + 1} of ${place.total}`,
+    previousDisabled: place.previous === null,
+    recordNav: record ? "shown" : "hidden",
     region,
     stage: "entry",
   };
 }
 
+/** A record's heading: its title field's text, else its first text, else "Row n". */
+function recordName(collection: EntryCollection, fields: EntryFields, index: number): string {
+  const field = titleFieldOf(collection.schema, fields);
+  const named = field === null ? undefined : fields[field];
+  if (isString(named) && named.trim() !== "") {
+    return named.trim();
+  }
+  return index === -1 ? "Record" : `Row ${index + 1}`;
+}
+
 /**
  * Mount the entry form into the pane.
  *
@@ -280,19 +352,30 @@ export function renderEntryMode(surface: CanvasSurface, tab: Tab): void {
       return;
     }
     const fields = entryFields(tab);
-    const form = mountSchemaForm(`entry:${paneId}`, collection.schema as JsonSchema, fields, {
-      context: formContext(tab),
-      errors: absentRequiredErrors(collection, fields),
-      onChange: (patch) => commitEntryFields(tab, patch),
-      rerender: redraw,
-    });
+    /* SAFETY: `collection` comes from `collectionOfPath`, which matches only a content type that
+       declares a `schema` (`findContentTypeSchema` refuses one without), and that schema is the
+       collection's JSON Schema — the shape `JsonSchema` names for the form. `fields` is a
+       frontmatter block or a JSON entry's own root (entry-fields.ts), both parsed from YAML or
+       JSON text, so every value is JSON; a key an editor cleared reads as absent either way. */
+    const form = mountSchemaForm(
+      `entry:${paneId}`,
+      titleFirst(collection.schema as JsonSchema, collection.schema, fields),
+      fields as JsonObject,
+      {
+        context: formContext(tab),
+        errors: absentRequiredErrors(collection, fields),
+        onChange: (patch) => commitEntryFields(tab, patch),
+        rerender: redraw,
+        ui: fieldLabels(collection.schema),
+      },
+    );
     if (form.parentNode !== formHost) {
       formHost.replaceChildren(form);
     }
   };
 
   const draw = () => {
-    const collection = collectionOfPath(tab.documentPath);
+    const collection = entryCollectionOf(tab);
     if (!collection) {
       /* The `fields` node goes with the case that held it, so the handle is dropped here rather
          than left pointing at a node the reconciler is about to remove. */
@@ -305,17 +388,37 @@ export function renderEntryMode(surface: CanvasSurface, tab: Tab): void {
   const scope = effectScope();
   const mounted = mountEntryEditorSurface(
     canvasWrap,
-    entryView(paneId, tab, collectionOfPath(tab.documentPath)),
+    entryView(paneId, tab, entryCollectionOf(tab)),
     {
       openContentTypes: () => {
         void activeRegistry()?.run("settings.open", { section: "content" });
       },
+      openGrid: () => {
+        // The grid lands on the row this form was showing (`grid/grid-reveal.ts`).
+        const { index } = recordPlace(tab);
+        if (index !== -1 && tab.documentPath) {
+          requestGridReveal(tab.documentPath, index);
+        }
+        tab.session.ui.canvasMode = "grid";
+      },
       setDraft: (draft) => setEntryDraft(tab, draft),
+      showNext: () => {
+        const { next } = recordPlace(tab);
+        if (next !== null) {
+          showRecord(tab, next);
+        }
+      },
+      showPrevious: () => {
+        const { previous } = recordPlace(tab);
+        if (previous !== null) {
+          showRecord(tab, previous);
+        }
+      },
     },
     {
       fieldsSlot: (host) => {
         formHost = host;
-        paintForm(collectionOfPath(tab.documentPath));
+        paintForm(entryCollectionOf(tab));
       },
     },
   );
@@ -332,8 +435,10 @@ export function renderEntryMode(surface: CanvasSurface, tab: Tab): void {
       // Never this effect's guess. `tab.doc.document` is also the reference every transaction
       // Replaces, so it is how an undo reaches the form whichever store the edit was in.
       void tab.doc.document;
-      void tab.doc.content?.frontmatter;
+      void tab.doc.content.frontmatter;
       void projectState?.projectConfig?.content;
+      // A record's fields are its grid's rows and pending cells, read through `entryFields`, which
+      // Tracks them. Which record is shown is tracked by `recordOf` the same way.
       draw();
     });
   });
@@ -365,7 +470,7 @@ export async function openEntryEditor(path: string): Promise<Tab | null> {
     tab.session.ui.canvasMode = ENTRY_MODE;
     tab.session.ui.preview = false;
     activateTab(id);
-    return tab as Tab;
+    return tab;
   }
   return null;
 }

package/src/content/entry-fields.ts

@@ -32,9 +32,17 @@ import { cloneValue } from "@jxsuite/schema/doc-ops";
 import { notePreviewOverlayEdit } from "../preview/preview-overlay";
 import { recordDocOp } from "../tabs/patch-ops";
 import { mutateUpdateFrontmatter, transactDoc } from "../tabs/transact";
+import { commitRecordFields, isRecordTab, recordFields } from "./record-entry";
+import type { JxDocumentValue } from "@jxsuite/schema/types";
 import type { Tab } from "../tabs/tab";
 import type { JsonValue } from "../types";
 
+/**
+ * An entry's fields, whichever record holds them: a frontmatter block's keys, or a JSON entry's own
+ * document keys. `undefined` is a key an editor has cleared.
+ */
+export type EntryFields = Record<string, JxDocumentValue | undefined>;
+
 /**
  * Whether this tab's entry fields are the document itself rather than a frontmatter block.
  *
@@ -56,10 +64,12 @@ function fieldsAreDocument(tab: Tab): boolean {
  * reactive tab, and a copy would break that. It is also the identity a caller can compare against
  * `tab.doc.document` to see which store answered.
  */
-export function entryFields(tab: Tab): Record<string, unknown> {
-  return fieldsAreDocument(tab)
-    ? (tab.doc.document as unknown as Record<string, unknown>)
-    : (tab.doc.content?.frontmatter ?? {});
+export function entryFields(tab: Tab): EntryFields {
+  // A record of a file-backed collection keeps its fields in a row of its file's grid.
+  if (isRecordTab(tab)) {
+    return recordFields(tab);
+  }
+  return fieldsAreDocument(tab) ? tab.doc.document : tab.doc.content.frontmatter;
 }
 
 /**
@@ -72,7 +82,7 @@ export function entryFields(tab: Tab): Record<string, unknown> {
  * is already the "not surgically patchable, fall back" signal `transactDoc` reads.
  */
 function mutateDocumentField(tab: Tab, field: string, value?: JsonValue): void {
-  const doc = tab.doc.document as unknown as Record<string, unknown>;
+  const doc = tab.doc.document;
   const before = Object.hasOwn(doc, field) ? cloneValue(doc[field]) : undefined;
   const deletes = value === undefined || value === null || value === "";
   if (deletes) {
@@ -100,7 +110,9 @@ function mutateDocumentField(tab: Tab, field: string, value?: JsonValue): void {
  * step.
  */
 export function mutateEntryField(tab: Tab, field: string, value?: JsonValue): void {
-  if (fieldsAreDocument(tab)) {
+  if (isRecordTab(tab)) {
+    commitRecordFields(tab, { [field]: value });
+  } else if (fieldsAreDocument(tab)) {
     mutateDocumentField(tab, field, value);
   } else {
     mutateUpdateFrontmatter(tab, field, value);
@@ -113,10 +125,15 @@ export function mutateEntryField(tab: Tab, field: string, value?: JsonValue): vo
  * `renderForm` emits single-key patches today, but committing per key would put a multi-key patch
  * on the undo stack as several steps — and an author who changed one thing expects one ⌘Z.
  */
-export function commitEntryFields(tab: Tab, patch: Record<string, unknown>): void {
+export function commitEntryFields(tab: Tab, patch: Record<string, JsonValue | undefined>): void {
+  // A record's edit is the grid buffer's, whose own undo group is the one ⌘Z reverts.
+  if (isRecordTab(tab)) {
+    commitRecordFields(tab, patch);
+    return;
+  }
   transactDoc(tab, (t) => {
     for (const [field, value] of Object.entries(patch)) {
-      mutateEntryField(t, field, value as JsonValue);
+      mutateEntryField(t, field, value);
     }
   });
 }

package/src/content/entry-inspector.ts

@@ -0,0 +1,225 @@
+/// <reference lib="dom" />
+/**
+ * The Inspector's Entry tab: what the Page tab draws while a collection entry is the focused
+ * document (`specs/studio.md` §6, §22.5; the Content-Entry board's sidebar).
+ *
+ * Four things, in the board's order: the entry's **status** (its draft flag, when the collection
+ * has a draft workflow, `content/draft-state.ts`), its **fields** as the collection's schema types
+ * them (`ui/schema-form.ts` over `content/entry-fields.ts`, the same form and the same transacted
+ * commits as the form-only editor, so ⌘Z undoes a field here exactly as it does there), the **URL**
+ * its collection page publishes it at (`content/collection-pages.ts`), and the **file** it is
+ * stored in, with what that file holds.
+ *
+ * The body is written on the canvas beside it; this tab is the entry's frontmatter (or, for a JSON
+ * entry opened on the canvas by hand, its root). The form-only `entry` editor stays for the entries
+ * the canvas cannot write.
+ *
+ * @docs studio/projects/content-types
+ */
+
+import { effect, effectScope } from "../reactivity";
+import { projectState } from "../store";
+import { runActiveReported } from "../commands/run-reported";
+import { mountSchemaForm } from "../ui/schema-form";
+import { collectionForFile } from "./collection-match";
+import { capitalise, contentCollection } from "./content-collections";
+import {
+  entryLocale,
+  entryUrl,
+  onCollectionPagesRead,
+  peekCollectionPage,
+} from "./collection-pages";
+import { commitEntryFields, entryFields } from "./entry-fields";
+import { DRAFT_MEANING, hasDraftAxis, isDraftEntry } from "./draft-state";
+import { entryCollection } from "./entry-model";
+import {
+  absentRequiredErrors,
+  fieldLabels,
+  formContext,
+  setEntryDraft,
+  titleFirst,
+} from "./entry-editor";
+import { mountEntryInspectorSurface } from "../surfaces/entry-inspector";
+import type { EntryInspectorHandle, EntryInspectorView } from "../surfaces/entry-inspector";
+import type { JsonSchema } from "../ui/schema-form";
+import type { JsonObject } from "@jxsuite/schema/types";
+import type { EffectScope } from "@vue/reactivity";
+import type { Tab } from "../tabs/tab";
+
+/** The region the tab's root carries. */
+export const ENTRY_INSPECTOR_REGION = "inspector/entry";
+
+/** A word with its first letter in capitals. */
+
+/** Whether a tab's document is a collection entry: what titles the Page tab "Entry" (§6). */
+export function isEntryTab(tab: Tab | null): boolean {
+  const match = collectionForFile(tab?.documentPath);
+  return match !== null && !match.fileBacked;
+}
+
+/** What the tab draws for an entry. */
+export function entryInspectorView(tab: Tab): EntryInspectorView {
+  const path = tab.documentPath ?? "";
+  const match = collectionForFile(path);
+  const name = match?.name ?? "";
+  const collection = entryCollection(name);
+  const fields = entryFields(tab);
+  const draftAxis = hasDraftAxis(collection?.schema, fields);
+  const draft = isDraftEntry(fields);
+  const page = name === "" ? null : peekCollectionPage(name, entryLocale(path));
+  const url = page ? entryUrl(page, path, fields) : null;
+  const isJson = path.endsWith(".json");
+  return {
+    draft,
+    draftAxis: draftAxis ? "shown" : "hidden",
+    draftHint: DRAFT_MEANING,
+    fieldsState: collection?.schema ? "form" : "none",
+    kind: capitalise(contentCollection(name)?.item ?? "entry"),
+    path,
+    region: ENTRY_INSPECTOR_REGION,
+    status: draftAxis ? (draft ? "Draft" : "Published") : "",
+    storage: isJson
+      ? ". Its fields are the file itself."
+      : ". Fields are its frontmatter, and the body is its Markdown.",
+    url: url ?? "",
+    urlState: page === undefined ? "loading" : url ? "shown" : page ? "unlisted" : "none",
+  };
+}
+
+// ─── Mounting ────────────────────────────────────────────────────────────────
+
+interface StandingInspector {
+  host: HTMLElement;
+  tabId: string;
+  handle: EntryInspectorHandle;
+  scope: EffectScope;
+  formHost: HTMLElement | null;
+  /**
+   * Repaint this tab, if it is still the one standing: the form's, the pages index's and the
+   * effect's.
+   */
+  redraw: () => void;
+  unlisten: () => void;
+}
+
+let _standing: StandingInspector | null = null;
+
+/** Put the field form into the node the document made for it, or bring it up to date. */
+function paintForm(standing: StandingInspector, tab: Tab): void {
+  const collection = entryCollection(collectionForFile(tab.documentPath)?.name ?? "");
+  if (!standing.formHost || !collection?.schema) {
+    return;
+  }
+  const fields = entryFields(tab);
+  /* SAFETY: `collection.schema` is the collection's JSON Schema, the shape `JsonSchema` names for
+     the form; `fields` is a frontmatter block or a JSON entry's root, both parsed from YAML or JSON
+     text, so every value is JSON. The same reading `entry-editor.ts` makes. */
+  const form = mountSchemaForm(
+    "entry-inspector",
+    titleFirst(collection.schema as JsonSchema, collection.schema, fields),
+    fields as JsonObject,
+    {
+      context: formContext(tab),
+      errors: absentRequiredErrors(collection, fields),
+      onChange: (patch) => commitEntryFields(tab, patch),
+      rerender: standing.redraw,
+      ui: fieldLabels(collection.schema),
+    },
+  );
+  if (form.parentNode !== standing.formHost) {
+    standing.formHost.replaceChildren(form);
+  }
+}
+
+/** Repaint the tab and its form. */
+function draw(standing: StandingInspector, tab: Tab): void {
+  const view = entryInspectorView(tab);
+  if (view.fieldsState === "none") {
+    standing.formHost = null;
+  }
+  standing.handle.update(view);
+  paintForm(standing, tab);
+}
+
+/** Take the tab down. Idempotent. */
+export function unmountEntryInspector(host?: HTMLElement): void {
+  if (!_standing || (host !== undefined && _standing.host !== host)) {
+    return;
+  }
+  _standing.unlisten();
+  _standing.scope.stop();
+  _standing.handle.dispose();
+  _standing = null;
+}
+
+/**
+ * Draw the Entry tab for `tab` into `host`, or bring the one already there up to date.
+ *
+ * Owns its own effect over the entry's fields, like the form-only editor, so a field commit
+ * repaints the tab and nothing else.
+ */
+export function renderEntryInspector(host: HTMLElement, tab: Tab): void {
+  if (
+    _standing &&
+    _standing.host === host &&
+    _standing.tabId === tab.id &&
+    _standing.handle.attached()
+  ) {
+    draw(_standing, tab);
+    return;
+  }
+  unmountEntryInspector();
+  const scope = effectScope();
+  const redraw = (): void => {
+    if (_standing === standing) {
+      draw(standing, tab);
+    }
+  };
+  const standing: StandingInspector = {
+    formHost: null,
+    handle: mountEntryInspectorSurface(
+      host,
+      entryInspectorView(tab),
+      {
+        openFields: () => {
+          const name = collectionForFile(tab.documentPath)?.name;
+          void runActiveReported(
+            "settings.open",
+            name ? { entry: name, section: "content" } : { section: "content" },
+            "Entry",
+          );
+        },
+        /* The command, not a local open(): Search appearance has one definition site, and an
+           entry's search title, description and image are frontmatter it commits into. */
+        openSeo: () => {
+          void runActiveReported("document.openSeo", undefined, "Entry");
+        },
+        setDraft: (draft) => setEntryDraft(tab, draft),
+      },
+      {
+        fieldsSlot: (element) => {
+          if (_standing === standing) {
+            standing.formHost = element;
+            paintForm(standing, tab);
+          }
+        },
+      },
+    ),
+    host,
+    redraw,
+    scope,
+    tabId: tab.id,
+    unlisten: onCollectionPagesRead(redraw),
+  };
+  _standing = standing;
+  scope.run(() => {
+    effect(() => {
+      // Both stores, for the reason `entry-editor.ts` gives: which one holds the fields is
+      // `entry-fields.ts`'s answer, and the document is the reference every transaction replaces.
+      void tab.doc.document;
+      void tab.doc.content.frontmatter;
+      void projectState?.projectConfig?.content;
+      redraw();
+    });
+  });
+}