feat(workspace): unify document content model — timeline-backed DocumentHandle

[braden-w]

Promotes the timeline abstraction from packages/filesystem into packages/workspace, kills the dual-store trap on DocumentHandle, removes binary mode, and adds mode-aware asText()/asRichText()/asSheet() conversion methods. Every app that uses .withDocument() now gets timeline-backed content access through the handle—no one imports createTimeline() or works with raw shared types directly.

The problem

DocumentHandle had read()/write() methods that operated on a raw Y.Text('content') shared type. The filesystem had a separate timeline (Y.Array('timeline')) for the same content. Two stores in one Y.Doc, and the handle methods silently wrote to the one nothing else read:

BEFORE: Two stores, handle methods are traps

Y.Doc (per row)
├── Y.Text('content')          ← handle.read()/write() — nobody reads this
├── Y.Array('timeline')        ← fs.content only
└── ...

Opensidian writes via handle.write()  → goes to Y.Text('content')
Filesystem reads via fs.content.read() → reads from Y.Array('timeline')
Result: content appears empty

The solution

One content model. The handle IS the interface:

AFTER: Single store, handle is the canonical API

DocumentHandle
├── read()            → string           (always works, flattens any mode)
├── write(text)       → void             (replaces or pushes text entry)
├── asText()          → Y.Text           (converts if needed — editor binding)
├── asRichText()      → Y.XmlFragment    (converts if needed — Tiptap binding)
├── asSheet()         → SheetBinding     (converts if needed — spreadsheet)
├── mode              → 'text' | 'richtext' | 'sheet' | undefined
├── timeline          → Timeline         (escape hatch for advanced ops)
├── batch(fn)         → void             (wraps ydoc.transact)
├── ydoc              → Y.Doc            (escape hatch — prefer handle methods)
└── exports           → Record           (extension exports)

The as*() methods are the key design decision. All conversions between modes are infallible—richtext→text strips formatting, text→sheet parses as CSV (any string is valid CSV, worst case: single cell), sheet→text serializes to CSV. No Result wrapping, no error handling at call sites.

What moved where

packages/filesystem/                    packages/workspace/src/timeline/
├── content/entry-types.ts ─────────►   ├── entries.ts
├── content/timeline.ts    ─────────►   ├── timeline.ts  (+ readEntry, ValidatedEntry)
├── formats/sheet.ts (CSV) ─────────►   ├── sheet.ts
└── content/content.ts (deleted) ────   ├── richtext.ts  (new: conversion helpers)
                                        └── index.ts

filesystem now re-exports from workspace (no consumer breakage)

The dependency direction required this move—workspace cannot import from filesystem, but filesystem already depends on workspace.

What was removed

Binary mode: pushBinary(), BinaryEntry, readAsBuffer() all deleted. Binary content was an artifact of the filesystem's in-memory map days—no app ever used it via the timeline. Content is text, richtext, or sheet.

Legacy migration: No migrateIfNeeded(). Clean break from Y.Text('content'). Old data is orphaned, not migrated. The dual-store period was short, and Opensidian was already switched to the filesystem path before this PR.

ContentHelpers type: Deleted entirely. Content operations are inlined into createYjsFileSystem() using handle.content directly. One less indirection layer.

readAsBuffer(): With binary mode gone, this was just TextEncoder.encode(readAsString()). Callers that need bytes encode themselves.

App migrations

// Fuji (text editor with Tiptap)
// BEFORE: raw Yjs access
const ytext = handle.ydoc.getText('content');
// AFTER: handle API, auto-creates entry if needed
const ytext = handle.asText();

// Honeycrisp (richtext editor with Tiptap)
// BEFORE: raw Yjs access
const fragment = handle.ydoc.getXmlFragment('content');
// AFTER: handle API, converts from text/sheet if needed
const fragment = handle.asRichText();

// Filesystem content read/write
// BEFORE: created its own timeline
const { ydoc } = await documents.open(fileId);
return createTimeline(ydoc).readAsString();
// AFTER: delegates to handle
const handle = await documents.open(fileId);
return handle.read();

Timeline internals

Each entry now has a createdAt timestamp for future revision history:

type TextEntry = { type: 'text'; content: Y.Text; createdAt: number };
type RichTextEntry = { type: 'richtext'; content: Y.XmlFragment; frontmatter: Y.Map; createdAt: number };
type SheetEntry = { type: 'sheet'; columns: Y.Map; rows: Y.Map; createdAt: number };

readEntry() validates raw Y.Map entries into a ValidatedEntry discriminated union, eliminating all as Y.Text casts. Corrupt entries gracefully degrade to { mode: 'empty' }.

Also in this PR

• Opensidian UI modernization: replace raw inputs with @epicenter/ui primitives, adopt tree-view from shadcn-svelte-extras, replace inline SVGs with lucide-svelte icons
• Content model fix: switch Opensidian from old handle.read()/handle.write() (wrong store) to fs.content (timeline-backed), then further to handle.read() in the new model
• Documentation sweep: update all AGENTS.md, README, and skill files to reference the new handle API

Deferred

• SheetBinding usage in a real spreadsheet app
• Revision history UI using createdAt timestamps