history: surface document body content in version history

Resource.getLoroHistory() materialized each historical version by reading
`doc.getMap('properties').toJSON()` — the Atomic propval root. Document
bodies live in a SEPARATE top-level Loro container (`doc`, owned by
loro-prosemirror), so the history page silently dropped every body edit
and surfaced only title/metadata changes.

Capture every top-level container besides `properties` (and the internal
`datatypes` metadata root) into a new `Version.containers` field. Include
containers in the content-dedup signature so body-only edits register as
distinct versions instead of collapsing into a previous propvals-identical
bucket.

Render the captured containers in HistoryDesktopView and HistoryMobileView
via a shared `VersionContent` component. For the `doc` container the
ProseMirror JSON tree is walked to extract readable text (block nodes get
newline separation); other containers fall back to pretty-printed JSON.

`setVersion()` still restores propvals only — replaying historical
container state into the live doc is distinct work, noted in a doc comment
for follow-up.

Test: resource.test.ts asserts a body edit on the `doc` container surfaces
in Version.containers. All 55 lib tests pass.

browser/data-browser/src/routes/History/HistoryDesktopView.tsx

@@ -6,6 +6,7 @@ import { Column, Row } from '../../components/Row';
 import { Title } from '../../components/Title';
 import { VersionTitle } from './VersionTitle';
 import { VersionScroller } from './VersionScroller';
+import { VersionContent } from './VersionContent';
 
 export function HistoryDesktopView({
   resource,
@@ -40,6 +41,7 @@ export function HistoryDesktopView({
                       </PropertyRow>
                     ))}
                 </PropertiesList>
+                <VersionContent containers={selectedVersion.containers} />
               </StyledCard>
               <Row>
                 <Button onClick={onVersionAccept} disabled={isCurrentVersion}>

browser/data-browser/src/routes/History/HistoryMobileView.tsx

@@ -6,6 +6,7 @@ import { Card } from '../../components/Card';
 import { Column } from '../../components/Row';
 import { VersionTitle } from './VersionTitle';
 import { VersionScroller } from './VersionScroller';
+import { VersionContent } from './VersionContent';
 import {
   Dialog,
   DialogActions,
@@ -60,6 +61,7 @@ export function HistoryMobileView({
                         </div>
                       ))}
                   </PropertiesList>
+                  <VersionContent containers={selectedVersion.containers} />
                 </StyledCard>
               </>
             )}

browser/data-browser/src/routes/History/VersionContent.tsx

@@ -0,0 +1,100 @@
+import { styled } from 'styled-components';
+
+interface VersionContentProps {
+  containers: Map<string, unknown>;
+}
+
+/**
+ * Renders the non-propval content captured at a Version — top-level Loro
+ * containers that aren't part of the `properties` map. The chief consumer is
+ * the `doc` container that loro-prosemirror writes Document bodies into; its
+ * shape is a ProseMirror JSON tree and we surface the readable text.
+ *
+ * Renders nothing when there are no containers, so resources without a
+ * rich-text body (folders, agents, etc.) don't get an empty section.
+ */
+export function VersionContent({ containers }: VersionContentProps) {
+  if (containers.size === 0) return null;
+
+  return (
+    <Wrap>
+      {[...containers.entries()].map(([key, value]) => {
+        const isProseMirror = key === 'doc';
+        const body = isProseMirror
+          ? extractProseMirrorText(value).trim()
+          : JSON.stringify(value, null, 2);
+
+        return (
+          <Section key={key}>
+            <Heading>{isProseMirror ? 'Document body' : key}</Heading>
+            {body ? <Pre>{body}</Pre> : <Muted>(empty)</Muted>}
+          </Section>
+        );
+      })}
+    </Wrap>
+  );
+}
+
+/**
+ * Extract readable text from a ProseMirror JSON tree. Walks the doc,
+ * concatenates text nodes, and adds a newline after each block-level node so
+ * paragraphs don't run together. Best-effort: this is for human-readable
+ * history previews, not for round-tripping ProseMirror state.
+ */
+function extractProseMirrorText(node: unknown): string {
+  if (node === null || node === undefined) return '';
+
+  if (Array.isArray(node)) {
+    return node.map(extractProseMirrorText).join('');
+  }
+
+  if (typeof node !== 'object') return '';
+
+  const obj = node as Record<string, unknown>;
+
+  if (typeof obj.text === 'string') {
+    return obj.text;
+  }
+
+  const children = Array.isArray(obj.content) ? obj.content : null;
+
+  if (!children) return '';
+
+  const joined = children.map(extractProseMirrorText).join('');
+  const type = typeof obj.type === 'string' ? obj.type : '';
+  // Add a newline after block-level nodes so paragraphs separate; inline
+  // marks/text nodes stay inline.
+  const isBlock = type !== '' && type !== 'text' && type !== 'hardBreak';
+
+  return joined + (isBlock ? '\n' : '');
+}
+
+const Wrap = styled.div`
+  display: flex;
+  flex-direction: column;
+  gap: 1rem;
+  padding: 1rem;
+  border-top: 1px solid ${p => p.theme.colors.bg2};
+`;
+
+const Section = styled.div`
+  display: flex;
+  flex-direction: column;
+  gap: 0.25rem;
+`;
+
+const Heading = styled.div`
+  font-weight: bold;
+  color: ${p => p.theme.colors.textLight};
+`;
+
+const Pre = styled.pre`
+  white-space: pre-wrap;
+  font-family: inherit;
+  margin: 0;
+`;
+
+const Muted = styled.span`
+  color: ${p => p.theme.colors.textLight};
+  font-style: italic;
+`;

browser/lib/src/resource.test.ts

@@ -138,4 +138,58 @@ describe('resource.ts', () => {
     const peerAfter = (resource as any)._loroDoc.peerIdStr as string;
     expect(peerAfter).toBe(peerBefore);
   });
+
+  /**
+   * Regression: the resource history page used to read only `getMap('properties')`,
+   * so a Document's body content (which loro-prosemirror writes into a separate
+   * top-level `doc` container) never showed up — only title/metadata edits did.
+   * `getLoroHistory()` must surface every top-level container besides
+   * `properties` in `Version.containers`.
+   */
+  it('captures body container content in version history', async ({
+    expect,
+  }) => {
+    const subject = 'https://example.com/loro-history-doc';
+    const name = 'https://atomicdata.dev/properties/name';
+
+    const resource = new Resource(subject);
+    await resource.set(name, 'Initial title', false);
+    const doc = resource.getLoroDoc()!;
+    doc.commit();
+
+    // Simulate what loro-prosemirror does for Document bodies: write to a
+    // top-level `doc` map, not the `properties` map.
+    const docMap = doc.getMap('doc');
+    docMap.set('content', 'Hello world body');
+    doc.commit();
+
+    await resource.set(name, 'Updated title', false);
+    doc.commit();
+
+    const history = resource.getLoroHistory();
+    expect(history.length).toBeGreaterThan(0);
+
+    // Every Version exposes `containers`, and at least one must carry the
+    // body content we wrote into `doc`.
+    for (const v of history) {
+      expect(v.containers).toBeInstanceOf(Map);
+    }
+
+    const docContents = history
+      .map(v => v.containers.get('doc'))
+      .filter((c): c is Record<string, unknown> => c !== undefined);
+
+    expect(docContents.length).toBeGreaterThan(0);
+    expect(
+      docContents.some(
+        c => (c as Record<string, unknown>).content === 'Hello world body',
+      ),
+    ).toBe(true);
+
+    // Sanity: the `properties` root must NOT leak into containers — it's
+    // already exposed as propvals and would double-render in the UI.
+    for (const v of history) {
+      expect(v.containers.has('properties')).toBe(false);
+    }
+  });
 });

browser/lib/src/resource.ts

@@ -1152,18 +1152,28 @@ export class Resource<C extends OptionalClass = any> {
       contentKey: string;
       step: Step;
       propvals: Map<string, JSONValue>;
+      containers: Map<string, JSONValue>;
     };
     const grouped: GroupedVersion[] = [];
 
-    /** Stable signature of the propvals minus `lastCommit`, used to detect
-     *  versions that represent the same observable state arrived at from
-     *  different peers (e.g. the same snapshot reimported during sync). */
-    const contentSignature = (pv: Map<string, JSONValue>): string => {
-      const entries = Array.from(pv.entries())
+    /** Stable signature of propvals (minus `lastCommit`) plus other top-level
+     *  containers, used to detect versions that represent the same observable
+     *  state arrived at from different peers (e.g. the same snapshot
+     *  reimported during sync). Including containers is what lets body-only
+     *  edits register as distinct versions instead of collapsing into the
+     *  previous propvals-identical bucket. */
+    const contentSignature = (
+      pv: Map<string, JSONValue>,
+      ct: Map<string, JSONValue>,
+    ): string => {
+      const propEntries = Array.from(pv.entries())
         .filter(([k]) => k !== lastCommitProp)
         .sort(([a], [b]) => a.localeCompare(b));
+      const containerEntries = Array.from(ct.entries()).sort(([a], [b]) =>
+        a.localeCompare(b),
+      );
 
-      return JSON.stringify(entries);
+      return JSON.stringify([propEntries, containerEntries]);
     };
 
     for (const step of steps) {
@@ -1177,15 +1187,32 @@ export class Resource<C extends OptionalClass = any> {
         continue;
       }
 
-      const propsMap = doc.getMap('properties');
+      // Materialize *the whole doc* at this version, not just `properties`.
+      // The `properties` root holds Atomic propvals; loro-prosemirror writes
+      // a Document's body into a separate top-level `doc` root container.
+      // Reading only `properties` is why the history page silently dropped
+      // every document-body edit, surfacing only title/metadata changes.
+      const fullJson = doc.toJSON() as
+        | Record<string, JSONValue>
+        | null
+        | undefined;
       const propvals = new Map<string, JSONValue>();
-
-      if (propsMap) {
-        const json = propsMap.toJSON();
-
-        if (json && typeof json === 'object') {
-          for (const [key, value] of Object.entries(json)) {
-            propvals.set(key, value as JSONValue);
+      const containers = new Map<string, JSONValue>();
+
+      if (fullJson && typeof fullJson === 'object') {
+        for (const [key, value] of Object.entries(fullJson)) {
+          if (key === 'properties') {
+            if (value && typeof value === 'object' && !Array.isArray(value)) {
+              for (const [pk, pv] of Object.entries(
+                value as Record<string, JSONValue>,
+              )) {
+                propvals.set(pk, pv);
+              }
+            }
+          } else if (key !== 'datatypes') {
+            // `datatypes` is internal property-type metadata, not content
+            // anyone should see in a history view.
+            containers.set(key, value);
           }
         }
       }
@@ -1194,20 +1221,22 @@ export class Resource<C extends OptionalClass = any> {
       // bucket. The latest entry per bucket wins — that's the final saved
       // state under that commit.
       const lastCommitKey = String(propvals.get(lastCommitProp) ?? '');
-      const cKey = contentSignature(propvals);
+      const cKey = contentSignature(propvals, containers);
 
       const existing = grouped.find(g => g.lastCommitKey === lastCommitKey);
 
       if (existing) {
         existing.step = step;
         existing.propvals = propvals;
+        existing.containers = containers;
         existing.contentKey = cKey;
       } else {
         grouped.push({
           lastCommitKey,
           contentKey: cKey,
           step,
           propvals,
+          containers,
         });
       }
     }
@@ -1237,6 +1266,7 @@ export class Resource<C extends OptionalClass = any> {
       ],
       message: g.step.message,
       propvals: g.propvals,
+      containers: g.containers,
     }));
 
     return versions;
@@ -1245,6 +1275,14 @@ export class Resource<C extends OptionalClass = any> {
   /**
    * Sets the resource to the specified version and saves it.
    * @param version The version to set the resource to, you can get this using `resource.getHistory()`
+   *
+   * NOTE: restores **propvals only**. Top-level Loro containers in
+   * `version.containers` (most importantly the `doc` body for Documents) are
+   * not replayed back into the live doc, so restoring a historical version
+   * leaves the body at its current state. A complete restore needs to
+   * either checkout the historical frontiers and re-export, or import a
+   * targeted snapshot of each container — distinct work from this view-side
+   * fix.
    */
   public async setVersion(version: Version): Promise<void> {
     // Remove any prop that doesn't exist in this version
@@ -2189,6 +2227,10 @@ export interface Version {
   message?: string;
   /** Materialized property values at this version */
   propvals: Map<string, JSONValue>;
+  /** Top-level Loro containers besides `properties` at this version — most
+   *  notably `doc`, the loro-prosemirror rich-text root that holds a
+   *  Document's body. Empty when the resource has no extra containers. */
+  containers: Map<string, JSONValue>;
 }
 
 /** Returns true if the error is a network/fetch failure (server unreachable). */