@sobree/core 0.1.29 → 0.1.31

package/dist/ydoc/apply.d.ts

@@ -23,8 +23,13 @@ import * as Y from "yjs";
  *     JSON blob on the Y.Map's `props` field. Concurrent property
  *     edits clobber. Phase 1c may split into per-key Y.Map.
  *
- *   - **Non-paragraph blocks (section_break, table):** stored as
- *     JSON-encoded `_ast`. Concurrent edits clobber.
+ *   - **Tables:** nested per-cell — `rows`/`cells`/`content` Y.Arrays
+ *     with per-cell JSON props (see `./blockCodec.ts`). Concurrent edits
+ *     to *different* cells merge; cell text merges char-level. A legacy
+ *     whole-table `_ast` migrates to the nested shape on first edit.
+ *
+ *   - **Section breaks / inline frames:** JSON-encoded `_ast` leaf.
+ *     Concurrent edits clobber.
  *
  *   - **Document meta (sections, styles, numbering, fonts,
  *     headerFooterBodies):** JSON-encoded on a `meta` Y.Map.

package/dist/ydoc/blockCodec.d.ts

@@ -0,0 +1,55 @@
+import { Block } from '../doc/types';
+/**
+ * Recursive block ↔ Y.Map codec — the single place that maps a
+ * `SobreeDocument` block to/from its Y.Doc representation, at ANY depth.
+ *
+ * The same block-Y.Map shape is used at the top level (`body` array) and
+ * nested inside composite blocks (a table cell's `content`, a frame
+ * textbox's `body`). Three operations, all recursive:
+ *
+ *   - {@link buildBlockSkeleton} + {@link populateBlock} — AST → Y, two
+ *     phase: skeleton builds the full nested STRUCTURE (Y.Arrays / Y.Maps /
+ *     empty Y.Texts + all JSON); populate applies the text deltas, which
+ *     requires the Y.Text to be integrated (so it runs after the root is
+ *     inserted into an integrated parent).
+ *   - {@link projectBlock} — Y → AST.
+ *   - {@link updateBlockYMap} — diff an AST block into an existing integrated
+ *     map (minimal Y ops; paragraph text via smart diff so concurrent
+ *     char edits merge).
+ *
+ * Per-kind storage:
+ *   - paragraph    → `text` Y.Text (char CRDT) + `props` JSON
+ *   - table        → `grid`/`props` JSON + `rows` Y.Array (rows → cells →
+ *                    each cell `props` JSON + `content` Y.Array<blockMap>).
+ *                    Per-CELL props ⇒ concurrent styling of *different*
+ *                    cells merges; cell text merges char-level.
+ *   - section_break / inline_frame → `_ast` leaf (whole-block JSON)
+ *
+ * The `content` array helpers ({@link buildContent} / {@link projectContent}
+ * / {@link updateContent}) are exported for reuse by the anchored-frame
+ * meta restructuring, whose textbox bodies are the same `Block[]`.
+ *
+ * Nested content arrays diff POSITIONALLY (a cell holds ~one paragraph);
+ * the top-level body stays id-matched (see `apply.ts`). Migration: a
+ * pre-nesting table is a leaf `_ast`; {@link projectBlock} reads it via the
+ * fallback, and {@link updateBlockYMap} rebuilds it nested on first edit.
+ */
+import * as Y from "yjs";
+type YMap = Y.Map<unknown>;
+type YArr = Y.Array<YMap>;
+/** Build a detached block Y.Map skeleton — full nested structure + JSON,
+ *  empty Y.Texts. Call {@link populateBlock} after it's integrated. */
+export declare function buildBlockSkeleton(id: string, block: Block): YMap;
+/** Build a detached `Y.Array` of block skeletons for a `Block[]` content
+ *  list (cell content, frame body). Nested blocks have no stable id —
+ *  matched positionally — so they carry an empty id. */
+export declare function buildContent(blocks: readonly Block[]): YArr;
+export declare function populateBlock(map: YMap, block: Block): void;
+/** Apply text deltas across an integrated content array. */
+export declare function populateContent(arr: YArr, blocks: readonly Block[]): void;
+export declare function projectBlock(map: YMap): Block | null;
+export declare function projectContent(arr: YArr): Block[];
+export declare function updateBlockYMap(map: YMap, block: Block): void;
+/** Diff a `Block[]` into an integrated content array (positional). */
+export declare function updateContent(arr: YArr, blocks: readonly Block[]): void;
+export {};

package/dist/ydoc/frameCodec.d.ts

@@ -0,0 +1,33 @@
+import { AnchoredFrame } from '../doc/types';
+/**
+ * Recursive AnchoredFrame ↔ Y.Map codec — the floating-layer analogue of
+ * `./blockCodec.ts`. Anchored frames (the textbox "pills", brochure panels,
+ * grouped drawings) previously rode in `meta` as one JSON blob, so a
+ * concurrent edit to ANY frame clobbered the whole layer. Here each frame is
+ * its own Y.Map, and a textbox frame's editable `body` reuses the block
+ * codec's content arrays — so concurrent edits to DIFFERENT frames merge,
+ * and text inside a frame merges char-level like body paragraphs.
+ *
+ * Per-content storage on a frameMap:
+ *   - `_ast`     — the AnchoredFrame MINUS its editable parts (geometry,
+ *                  position, fill/border, content discriminator)
+ *   - textbox    → `body`     Y.Array<blockMap>      (the editable body)
+ *   - group      → `children` Y.Array<frameMap>      (recurse)
+ *   - picture / shape → no child arrays (the `_ast` is the whole frame)
+ *
+ * Two-phase build (skeleton → integrate → populate) mirrors blockCodec, so a
+ * textbox body's Y.Texts are integrated before their deltas apply.
+ */
+import * as Y from "yjs";
+type YMap = Y.Map<unknown>;
+type YArr = Y.Array<YMap>;
+export declare function buildFrameSkeleton(frame: AnchoredFrame): YMap;
+export declare function buildFrames(frames: readonly AnchoredFrame[]): YArr;
+export declare function populateFrame(m: YMap, frame: AnchoredFrame): void;
+export declare function populateFrames(arr: YArr, frames: readonly AnchoredFrame[]): void;
+export declare function projectFrame(m: YMap): AnchoredFrame | null;
+export declare function projectFrames(arr: YArr): AnchoredFrame[];
+export declare function updateFrame(m: YMap, frame: AnchoredFrame): void;
+/** Diff a frame list into an integrated `Y.Array<frameMap>` (positional). */
+export declare function updateFrames(arr: YArr, frames: readonly AnchoredFrame[]): void;
+export {};

package/dist/ydoc/index.d.ts

@@ -11,8 +11,9 @@
  * that preserves CRDT semantics across applies.
  */
 export { Y_BLOCK_AST_KEY, Y_BLOCK_ID_KEY, Y_BLOCK_KIND_KEY, Y_BLOCK_PROPS_KEY, Y_BLOCK_TEXT_KEY, Y_BODY_KEY, Y_META_FIELDS, Y_META_KEY, Y_PARTREFS_KEY, Y_PARTS_KEY, } from './schema';
-export { seedYDoc, buildBlockYMap, buildSkeletonBlockYMap, populateBlockContent, populateParagraphContent, populateParagraphYMap, } from './seed';
-export { projectYDoc, projectBlock } from './project';
+export { seedYDoc } from './seed';
+export { buildBlockSkeleton, buildContent, populateBlock, populateContent, projectBlock, projectContent, updateBlockYMap, updateContent, } from './blockCodec';
+export { projectYDoc } from './project';
 export { applyDocumentToYDoc, applyPartRefsToYDoc, removePartRefsFromYDoc, } from './apply';
 export { type DeltaOp, type EmbedContent, type LinkMark, attrsToRunProps, deepEqual, deltaToRuns, runPropsToAttrs, runsToDelta, } from './runs';
 export { diffApplyText } from './textDiff';

package/dist/ydoc/project.d.ts

@@ -1,4 +1,4 @@
-import { Block, SobreeDocument } from '../doc/types';
+import { SobreeDocument } from '../doc/types';
 import type * as Y from "yjs";
 /**
  * Read the SobreeDocument projection out of a Y.Doc.
@@ -34,8 +34,3 @@ export declare function projectYDoc(ydoc: Y.Doc): {
     ids: string[];
     partRefs: Record<string, string>;
 };
-/**
- * Read a single block Y.Map into a Block. Returns `null` if the map
- * is empty / unrecognizable (defensive — projectYDoc skips nulls).
- */
-export declare function projectBlock(map: Y.Map<unknown>): Block | null;

package/dist/ydoc/schema.d.ts

@@ -10,12 +10,17 @@
  * ```
  * ydoc
  * ├── getArray("body")  : Y.Array<Y.Map>     — block list, one Y.Map per block
+ * ├── getArray("anchoredFrames")   : Y.Array<frameMap>      — body floating layer
+ * │                                            (per-frame CRDT; `./frameCodec.ts`).
+ * ├── getMap("headerFooterFrames") : Y.Map<zoneId, Y.Array> — per-zone floating
+ * │                                            layers (per-frame CRDT).
  * ├── getMap("meta")    : Y.Map              — sections, styles, numbering,
  * │                                            headerFooterBodies, fonts.
  * │                                            Stored as JSON-encoded values
  * │                                            (rarely edited concurrently).
- * │                                            Phase 1c may split fields into
- * │                                            per-key Y types.
+ * │                                            Legacy `anchoredFrames` /
+ * │                                            `headerFooterFrames` keys are read
+ * │                                            only as a migration fallback.
  * ├── getMap("parts")    : Y.Map<Uint8Array>  — inline binary parts
  * │                                              (legacy / no-BlobStore path).
  * └── getMap("partRefs") : Y.Map<string>       — partPath → SHA-256 hex hash
@@ -49,16 +54,48 @@
  *
  * # Block Y.Map shape — non-paragraphs
  *
- * Section breaks and tables stay JSON-encoded — neither has inline
- * text content with concurrent-edit demand. Tables get their own
- * structural CRDT in a future Phase 1c (per-cell Y.Map<body Y.Array>).
+ * Section breaks stay fully JSON-encoded — no editable inline content:
  *
  * ```
- * otherBlockMap
+ * sectionBreakMap
  * ├── get("id")    : string             — stable block id
  * └── get("_ast")  : string (JSON)      — JSON-encoded Block
  * ```
  *
+ * # Composite blocks — per-part CRDT (Phase 1c)
+ *
+ * Tables and textbox inline-frames hold nested editable `Block[]`, so
+ * their content lives in nested Y structures (not one opaque `_ast`):
+ * concurrent edits to *different* cells / frame paragraphs merge, and
+ * cell text merges char-level like body paragraphs. The block-Y.Map ↔
+ * `Block` mapping is recursive (`./blockCodec.ts`) — a `content` /
+ * `body` array holds the same block-Y.Map shape used at the top level.
+ *
+ * ```
+ * tableMap
+ * ├── get("id")    : string             — stable block id
+ * ├── get("kind")  : "table"            — discriminator
+ * ├── get("grid")  : string (JSON)      — number[] column widths (per-table LWW)
+ * ├── get("props") : string (JSON)      — TableProperties (per-table LWW)
+ * └── get("rows")  : Y.Array<rowMap>
+ *       rowMap.get("props")  : string (JSON)  — { isHeader? } (per-row LWW)
+ *       rowMap.get("cells")  : Y.Array<cellMap>
+ *         cellMap.get("props")   : string (JSON)  — gridSpan/vMerge/shading/… (per-CELL LWW)
+ *         cellMap.get("content") : Y.Array<blockMap>  — recurse
+ *
+ * inlineFrameMap
+ * ├── get("id")    : string             — stable block id
+ * ├── get("kind")  : "inline_frame"     — discriminator
+ * ├── get("_ast")  : string (JSON)      — the frame MINUS textbox.body (geometry/props)
+ * └── get("body")  : Y.Array<blockMap>  — textbox body, recurse
+ * ```
+ *
+ * Migration: a pre-Phase-1c table/frame is one whole-block `_ast` (no
+ * `rows`/`body` array). Projection reads that fallback; the first edit
+ * rebuilds it in the nested shape. Nested content arrays diff
+ * positionally (cell content is typically one paragraph); the body
+ * array stays id-matched.
+ *
  * # Y.Text mark conventions
  *
  * The mapping between Sobree's `RunProperties` and Y.Text marks is
@@ -110,9 +147,30 @@ export declare const Y_BLOCK_KIND_KEY = "kind";
 export declare const Y_BLOCK_TEXT_KEY = "text";
 /** Phase 1b.5+: JSON-encoded ParagraphProperties on paragraph blocks. */
 export declare const Y_BLOCK_PROPS_KEY = "props";
-/** Phase 1a: JSON-encoded Block on non-paragraph blocks (and on
- *  Phase 1a-shaped paragraph blocks for backwards compat). */
+/** JSON-encoded Block on leaf non-paragraph blocks (section_break), on
+ *  Phase 1a-shaped blocks for backwards compat, and — for inline-frame
+ *  composites — the frame MINUS its textbox body (geometry / props). */
 export declare const Y_BLOCK_AST_KEY = "_ast";
+/** Table: JSON-encoded `number[]` column-width grid. */
+export declare const Y_TABLE_GRID_KEY = "grid";
+/** Table: `Y.Array` of row Y.Maps. */
+export declare const Y_TABLE_ROWS_KEY = "rows";
+/** Table row: `Y.Array` of cell Y.Maps. */
+export declare const Y_ROW_CELLS_KEY = "cells";
+/** Table cell: `Y.Array` of block Y.Maps (the cell's content). */
+export declare const Y_CELL_CONTENT_KEY = "content";
+/** Textbox frame: `Y.Array` of block Y.Maps (the frame's editable body). */
+export declare const Y_FRAME_BODY_KEY = "body";
+/** Group frame: `Y.Array` of child frame Y.Maps (recurse). */
+export declare const Y_FRAME_CHILDREN_KEY = "children";
+/** Top-level `Y.Array<frameMap>` — the body floating layer (`anchoredFrames`).
+ *  Replaces the `meta.anchoredFrames` JSON blob; that meta key is read only
+ *  as a migration fallback for docs seeded before this. */
+export declare const Y_ANCHORED_FRAMES_KEY = "anchoredFrames";
+/** Top-level `Y.Map<zoneId, Y.Array<frameMap>>` — per header/footer zone
+ *  floating layers (`headerFooterFrames`). Migration fallback: the
+ *  `meta.headerFooterFrames` JSON blob. */
+export declare const Y_HEADER_FOOTER_FRAMES_KEY = "headerFooterFrames";
 /** Keys stored on the `meta` Y.Map. */
 export declare const Y_META_FIELDS: {
     readonly sections: "sections";

package/dist/ydoc/seed.d.ts

@@ -1,5 +1,5 @@
-import { Block, Paragraph, SobreeDocument } from '../doc/types';
-import * as Y from "yjs";
+import { SobreeDocument } from '../doc/types';
+import type * as Y from "yjs";
 /**
  * Populate a fresh (or reset) Y.Doc with the contents of a SobreeDocument.
  *
@@ -12,34 +12,3 @@ import * as Y from "yjs";
  * stack.
  */
 export declare function seedYDoc(ydoc: Y.Doc, doc: SobreeDocument, ids: readonly string[]): void;
-/**
- * Build a *skeleton* block Y.Map — id + kind discriminator + empty
- * containers, no content. Content lands in `populateBlockContent`
- * after the map is integrated. Used internally by `seedYDoc` and by
- * `applyDocumentToYDoc` (`buildBlockYMap` is a one-shot wrapper that
- * does both phases on an orphan map; only safe for callers that will
- * insert it inside a transact within the same call stack).
- */
-export declare function buildSkeletonBlockYMap(id: string, block: Block): Y.Map<unknown>;
-/** Populate the content of an *integrated* block Y.Map. */
-export declare function populateBlockContent(map: Y.Map<unknown>, block: Block): void;
-/**
- * Populate paragraph content. Caller guarantees the map is integrated
- * (so its child Y.Text is too).
- */
-export declare function populateParagraphContent(map: Y.Map<unknown>, block: Paragraph): void;
-/**
- * One-shot block Y.Map builder — skeleton + content in a single call.
- * Only safe inside a `Y.Doc.transact` block where the returned map
- * will be inserted into an integrated parent before any read of its
- * Y.Text. Otherwise prefer the two-phase builders above.
- *
- * Kept for backwards compat with callers that don't yet use the
- * two-phase pattern.
- */
-export declare function buildBlockYMap(id: string, block: Block): Y.Map<unknown>;
-/**
- * @deprecated Use `populateParagraphContent` (renamed for clarity).
- * Kept as a re-export so callers don't break during migration.
- */
-export declare const populateParagraphYMap: typeof populateParagraphContent;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sobree/core",
-  "version": "0.1.29",
+  "version": "0.1.31",
   "publishConfig": {
     "access": "public"
   },