eventmodeler 0.6.13 → 0.6.15

package/dist/index.js

@@ -2573,6 +2573,15 @@ function registerStatusCommands(program, conn) {
 }
 // ../packages/canvas-model/src/build.ts
 import * as Y2 from "yjs";
+function buildYMap(props) {
+  const m = new Y2.Map;
+  for (const [k, v] of Object.entries(props)) {
+    if (v === undefined)
+      continue;
+    m.set(k, v);
+  }
+  return m;
+}
 function buildYArray(items) {
   const arr = new Y2.Array;
   if (items.length > 0)
@@ -2630,6 +2639,7 @@ var ELEMENT_DIMENSIONS = {
   aggregate: { width: 300, height: 200 },
   actor: { width: 300, height: 200 },
   chapter: { width: 800, height: 1200 },
+  sheet: { width: 800, height: 1200 },
   note: { width: 200, height: 150 },
   externalEvent: { width: 160, height: 100 },
   context: { width: 300, height: 200 },
@@ -2834,6 +2844,7 @@ var SliceSchema = baseContainer("sliceId").extend({
 var AggregateSchema = baseContainer("aggregateId");
 var ActorSchema = baseContainer("actorId");
 var ChapterSchema = baseContainer("chapterId");
+var SheetSchema = baseContainer("sheetId");
 var ContextSchema = baseContainer("contextId");
 var LaneKindSchema = z.enum(["actor", "interaction", "swimlane", "specification"]);
 var SwimLaneSchema = baseContainer("swimLaneId").extend({
@@ -2937,9 +2948,9 @@ var FlowSchema = z.object({
 var SheetFlowSchema = z.object({
   sheetFlowId: z.string().uuid().optional(),
   modelId: z.string().uuid().optional(),
-  sourceChapterId: z.string().uuid(),
+  sourceSheetId: z.string().uuid(),
   sourceHandle: z.string().min(1),
-  targetChapterId: z.string().uuid(),
+  targetSheetId: z.string().uuid(),
   targetHandle: z.string().min(1)
 });
 var CellRefSchema = z.object({
@@ -2958,6 +2969,7 @@ var SheetStructureSchema = z.object({
   columns: z.array(z.string().uuid()),
   rows: z.array(z.string().uuid()),
   cells: z.record(z.string(), z.array(CellRefSchema)),
+  columnSlices: z.record(z.string(), z.string().uuid()).optional(),
   cellNotes: z.record(z.string(), z.string()).optional()
 });
 var SCOPE_SCHEMAS = {
@@ -2971,6 +2983,7 @@ var SCOPE_SCHEMAS = {
   aggregates: AggregateSchema,
   actors: ActorSchema,
   chapters: ChapterSchema,
+  sheets: SheetSchema,
   contexts: ContextSchema,
   swimLanes: SwimLaneSchema,
   notes: NoteSchema,
@@ -3005,36 +3018,69 @@ var GRID_SCOPE = "grid";
 function getGridMap(doc) {
   return doc.getMap(GRID_SCOPE);
 }
-function cellKey(sliceId, swimLaneId) {
-  return `${sliceId}:${swimLaneId}`;
+function cellKey(columnId, swimLaneId) {
+  return `${columnId}:${swimLaneId}`;
 }
-function resolveSheet(doc, chapterId) {
+function resolveSheet(doc, sheetId) {
   const grid = getGridMap(doc);
-  let sheet = grid.get(chapterId);
+  let sheet = grid.get(sheetId);
   if (!sheet) {
     sheet = new Y6.Map;
     sheet.set("columns", new Y6.Array);
     sheet.set("rows", new Y6.Array);
     sheet.set("cells", new Y6.Map);
-    grid.set(chapterId, sheet);
+    sheet.set("columnSlices", new Y6.Map);
+    grid.set(sheetId, sheet);
+  }
+  let columnSlices = sheet.get("columnSlices");
+  if (!columnSlices) {
+    columnSlices = new Y6.Map;
+    sheet.set("columnSlices", columnSlices);
   }
   return {
     sheet,
     columns: sheet.get("columns"),
     rows: sheet.get("rows"),
-    cells: sheet.get("cells")
+    cells: sheet.get("cells"),
+    columnSlices
   };
 }
-function ensureSheet(doc, chapterId) {
+function sliceOf(columnSlices, columnId) {
+  return columnSlices[columnId] ?? columnId;
+}
+function ensureSheet(doc, sheetId) {
   doc.transact(() => {
-    resolveSheet(doc, chapterId);
+    resolveSheet(doc, sheetId);
   });
 }
-function readSheet(doc, chapterId) {
-  const sheet = getGridMap(doc).get(chapterId);
+function readSheet(doc, sheetId) {
+  const sheet = getGridMap(doc).get(sheetId);
   if (!sheet)
     return;
-  return sheet.toJSON();
+  const json = sheet.toJSON();
+  const columns = json.columns ?? [];
+  const columnSlices = { ...json.columnSlices ?? {} };
+  for (const c of columns)
+    if (!(c in columnSlices))
+      columnSlices[c] = c;
+  return { ...json, columns, columnSlices };
+}
+function sliceOrder(structure) {
+  const cs = structure.columnSlices ?? {};
+  const seen = new Set;
+  const out = [];
+  for (const colId of structure.columns) {
+    const sid = sliceOf(cs, colId);
+    if (!seen.has(sid)) {
+      seen.add(sid);
+      out.push(sid);
+    }
+  }
+  return out;
+}
+function sliceColumns(structure, sliceId) {
+  const cs = structure.columnSlices ?? {};
+  return structure.columns.filter((c) => sliceOf(cs, c) === sliceId);
 }
 function clampIndex(at, length) {
   if (at === undefined || at > length)
@@ -3046,52 +3092,91 @@ function insertUnique(arr, value, at) {
     return;
   arr.insert(clampIndex(at, arr.length), [value]);
 }
-function addColumn(doc, chapterId, sliceId, at) {
+function addColumn(doc, sheetId, sliceId, at) {
+  doc.transact(() => {
+    const { columns, columnSlices } = resolveSheet(doc, sheetId);
+    if (columns.toArray().includes(sliceId))
+      return;
+    columns.insert(clampIndex(at, columns.length), [sliceId]);
+    columnSlices.set(sliceId, sliceId);
+  });
+}
+function addColumnToSlice(doc, sheetId, sliceId, columnId, atWithin) {
   doc.transact(() => {
-    const { columns } = resolveSheet(doc, chapterId);
-    insertUnique(columns, sliceId, at);
+    const { columns, columnSlices } = resolveSheet(doc, sheetId);
+    const arr = columns.toArray();
+    if (arr.includes(columnId))
+      return;
+    const slices = columnSlices.toJSON();
+    const flatIdxs = arr.map((c, i) => [c, i]).filter(([c]) => sliceOf(slices, c) === sliceId).map(([, i]) => i);
+    let flat;
+    if (flatIdxs.length === 0) {
+      flat = columns.length;
+    } else {
+      const within = atWithin === undefined ? flatIdxs.length : Math.max(0, Math.min(flatIdxs.length, atWithin));
+      flat = within < flatIdxs.length ? flatIdxs[within] : flatIdxs[flatIdxs.length - 1] + 1;
+    }
+    columns.insert(flat, [columnId]);
+    columnSlices.set(columnId, sliceId);
   });
 }
-function moveColumn(doc, chapterId, sliceId, toIndex) {
+function moveColumn(doc, sheetId, columnId, toIndex) {
   doc.transact(() => {
-    const { columns } = resolveSheet(doc, chapterId);
-    const from = columns.toArray().indexOf(sliceId);
+    const { columns } = resolveSheet(doc, sheetId);
+    const from = columns.toArray().indexOf(columnId);
     if (from === -1)
       return;
     columns.delete(from, 1);
-    columns.insert(clampIndex(toIndex, columns.length), [sliceId]);
+    columns.insert(clampIndex(toIndex, columns.length), [columnId]);
   });
 }
-function removeColumn(doc, chapterId, sliceId) {
+function removeColumn(doc, sheetId, columnId) {
   doc.transact(() => {
-    const sheet = getGridMap(doc).get(chapterId);
+    const sheet = getGridMap(doc).get(sheetId);
     if (!sheet)
       return;
     const columns = sheet.get("columns");
     const cells = sheet.get("cells");
     const cellNotes = sheet.get("cellNotes");
-    const idx = columns.toArray().indexOf(sliceId);
+    const columnSlices = sheet.get("columnSlices");
+    const idx = columns.toArray().indexOf(columnId);
     if (idx !== -1)
       columns.delete(idx, 1);
+    columnSlices?.delete(columnId);
     for (const key of [...cells.keys()]) {
-      if (key.startsWith(`${sliceId}:`))
+      if (key.startsWith(`${columnId}:`))
         cells.delete(key);
     }
     for (const key of [...cellNotes?.keys() ?? []]) {
-      if (key.startsWith(`${sliceId}:`))
+      if (key.startsWith(`${columnId}:`))
         cellNotes.delete(key);
     }
   });
 }
-function addRow(doc, chapterId, swimLaneId, at) {
+function setColumnSlice(doc, sheetId, columnId, sliceId) {
+  doc.transact(() => {
+    const { columnSlices } = resolveSheet(doc, sheetId);
+    columnSlices.set(columnId, sliceId);
+  });
+}
+function ensureColumnSlices(doc, sheetId) {
+  doc.transact(() => {
+    const { columns, columnSlices } = resolveSheet(doc, sheetId);
+    for (const columnId of columns.toArray()) {
+      if (!columnSlices.has(columnId))
+        columnSlices.set(columnId, columnId);
+    }
+  });
+}
+function addRow(doc, sheetId, swimLaneId, at) {
   doc.transact(() => {
-    const { rows } = resolveSheet(doc, chapterId);
+    const { rows } = resolveSheet(doc, sheetId);
     insertUnique(rows, swimLaneId, at);
   });
 }
-function moveRow(doc, chapterId, swimLaneId, toIndex) {
+function moveRow(doc, sheetId, swimLaneId, toIndex) {
   doc.transact(() => {
-    const { rows } = resolveSheet(doc, chapterId);
+    const { rows } = resolveSheet(doc, sheetId);
     const from = rows.toArray().indexOf(swimLaneId);
     if (from === -1)
       return;
@@ -3099,9 +3184,9 @@ function moveRow(doc, chapterId, swimLaneId, toIndex) {
     rows.insert(clampIndex(toIndex, rows.length), [swimLaneId]);
   });
 }
-function removeRow(doc, chapterId, swimLaneId) {
+function removeRow(doc, sheetId, swimLaneId) {
   doc.transact(() => {
-    const sheet = getGridMap(doc).get(chapterId);
+    const sheet = getGridMap(doc).get(sheetId);
     if (!sheet)
       return;
     const rows = sheet.get("rows");
@@ -3137,9 +3222,9 @@ function findStickyCell(cells, stickyId) {
   }
   return;
 }
-function placeInCell(doc, chapterId, sliceId, swimLaneId, ref, at) {
+function placeInCell(doc, sheetId, sliceId, swimLaneId, ref, at) {
   doc.transact(() => {
-    const { cells } = resolveSheet(doc, chapterId);
+    const { cells } = resolveSheet(doc, sheetId);
     const existing = findStickyCell(cells, ref.stickyId);
     if (existing)
       cells.get(existing.key).delete(existing.index, 1);
@@ -3154,9 +3239,9 @@ function placeInCell(doc, chapterId, sliceId, swimLaneId, ref, at) {
     ]);
   });
 }
-function removeSticky(doc, chapterId, stickyId) {
+function removeSticky(doc, sheetId, stickyId) {
   doc.transact(() => {
-    const sheet = getGridMap(doc).get(chapterId);
+    const sheet = getGridMap(doc).get(sheetId);
     if (!sheet)
       return;
     const cells = sheet.get("cells");
@@ -3166,13 +3251,13 @@ function removeSticky(doc, chapterId, stickyId) {
     cells.get(loc.key).delete(loc.index, 1);
   });
 }
-function removeSheet(doc, chapterId) {
+function removeSheet(doc, sheetId) {
   doc.transact(() => {
-    getGridMap(doc).delete(chapterId);
+    getGridMap(doc).delete(sheetId);
   });
 }
-function getCellNotesMap(doc, chapterId, create) {
-  const sheet = getGridMap(doc).get(chapterId);
+function getCellNotesMap(doc, sheetId, create) {
+  const sheet = getGridMap(doc).get(sheetId);
   if (!sheet)
     return;
   let notes = sheet.get("cellNotes");
@@ -3182,30 +3267,117 @@ function getCellNotesMap(doc, chapterId, create) {
   }
   return notes;
 }
-function readCellNotes(doc, chapterId) {
-  const notes = getGridMap(doc).get(chapterId)?.get("cellNotes");
+function readCellNotes(doc, sheetId) {
+  const notes = getGridMap(doc).get(sheetId)?.get("cellNotes");
   return notes ? notes.toJSON() : {};
 }
-function setCellNote(doc, chapterId, sliceId, swimLaneId, text) {
+function setCellNote(doc, sheetId, sliceId, swimLaneId, text) {
   doc.transact(() => {
     const key = cellKey(sliceId, swimLaneId);
     const trimmed = text.trim();
     if (!trimmed) {
-      getCellNotesMap(doc, chapterId, false)?.delete(key);
+      getCellNotesMap(doc, sheetId, false)?.delete(key);
       return;
     }
-    getCellNotesMap(doc, chapterId, true).set(key, trimmed);
+    getCellNotesMap(doc, sheetId, true).set(key, trimmed);
   });
 }
-// ../packages/canvas-model/src/sheet-delete.ts
-var CHAPTERS_SCOPE = "chapters";
+// ../packages/canvas-model/src/slice-span.ts
 var SLICES_SCOPE2 = "slices";
+var SHEET_FLOWS_SCOPE = "sheetFlows";
+function sliceIdFromHandle(handleId) {
+  if (typeof handleId !== "string")
+    return;
+  const parts = handleId.split(":");
+  if (parts[0] === "sf" && parts[1] === "slice" && parts.length >= 5)
+    return parts.slice(4).join(":");
+  return;
+}
+function pruneSheetFlowsForSlice(doc, sliceId) {
+  const map = getScopeMap(doc, SHEET_FLOWS_SCOPE);
+  for (const [id, f] of [...map.entries()]) {
+    if (sliceIdFromHandle(f.get("sourceHandle")) === sliceId || sliceIdFromHandle(f.get("targetHandle")) === sliceId) {
+      map.delete(id);
+    }
+  }
+}
+function resizeSliceSpan(doc, sheetId, sliceId, targetLast) {
+  doc.transact(() => {
+    const structure = readSheet(doc, sheetId);
+    if (!structure)
+      return;
+    const cols = structure.columns;
+    const owned = sliceColumns(structure, sliceId);
+    if (owned.length === 0)
+      return;
+    const firstFlat = cols.indexOf(owned[0]);
+    const currentLast = cols.indexOf(owned[owned.length - 1]);
+    const target = Math.max(firstFlat, Math.min(targetLast, cols.length - 1));
+    if (target === currentLast)
+      return;
+    const owner = (c) => structure.columnSlices?.[c] ?? c;
+    const slices = getScopeMap(doc, SLICES_SCOPE2);
+    const modelId = getEntry(doc, SLICES_SCOPE2, sliceId)?.modelId;
+    const d = ELEMENT_DIMENSIONS.slice;
+    const claimed = cols.slice(firstFlat, target + 1);
+    const prevOwners = new Set(claimed.map(owner).filter((s) => s !== sliceId));
+    for (const colId of claimed)
+      setColumnSlice(doc, sheetId, colId, sliceId);
+    for (const colId of cols.slice(target + 1, currentLast + 1)) {
+      const newSliceId = crypto.randomUUID();
+      const base = { sliceId: newSliceId, name: "Slice", x: 0, y: 0, width: d.width, height: d.height };
+      slices.set(newSliceId, buildYMap(modelId ? { ...base, modelId } : base));
+      setColumnSlice(doc, sheetId, colId, newSliceId);
+    }
+    const after = readSheet(doc, sheetId);
+    for (const sid of prevOwners) {
+      if (sliceColumns(after, sid).length === 0) {
+        slices.delete(sid);
+        pruneSheetFlowsForSlice(doc, sid);
+      }
+    }
+  });
+}
+// ../packages/canvas-model/src/migrate.ts
+function migrateChaptersToSheets(doc) {
+  const chapters = getScopeMap(doc, "chapters");
+  const sheets = getScopeMap(doc, "sheets");
+  const sheetFlows = getScopeMap(doc, "sheetFlows");
+  const needsEntityMove = sheets.size === 0 && chapters.size > 0;
+  const needsFlowRename = [...sheetFlows.values()].some((f) => f.has("sourceChapterId") || f.has("targetChapterId"));
+  if (!needsEntityMove && !needsFlowRename)
+    return;
+  doc.transact(() => {
+    if (needsEntityMove) {
+      for (const [id, ch] of [...chapters.entries()]) {
+        const json = ch.toJSON();
+        delete json.chapterId;
+        json.sheetId = id;
+        sheets.set(id, deepToY(json));
+        chapters.delete(id);
+      }
+    }
+    for (const f of sheetFlows.values()) {
+      if (f.has("sourceChapterId")) {
+        f.set("sourceSheetId", f.get("sourceChapterId"));
+        f.delete("sourceChapterId");
+      }
+      if (f.has("targetChapterId")) {
+        f.set("targetSheetId", f.get("targetChapterId"));
+        f.delete("targetChapterId");
+      }
+    }
+  });
+}
+// ../packages/canvas-model/src/sheet-delete.ts
+var SHEETS_SCOPE = "sheets";
+var SLICES_SCOPE3 = "slices";
 var SWIM_LANES_SCOPE = "swimLanes";
 var SCENARIOS_SCOPE2 = "scenarios";
-var SHEET_FLOWS_SCOPE = "sheetFlows";
-function deleteSheet(doc, chapterId) {
+var SHEET_FLOWS_SCOPE2 = "sheetFlows";
+function deleteSheet(doc, sheetId) {
   doc.transact(() => {
-    const sheet = getGridMap(doc).get(chapterId);
+    const sheet = getGridMap(doc).get(sheetId);
     const removedStickies = new Set;
     const sliceIds = new Set;
     const laneIds = new Set;
@@ -3224,7 +3396,7 @@ function deleteSheet(doc, chapterId) {
       }
     }
     for (const id of sliceIds)
-      getScopeMap(doc, SLICES_SCOPE2).delete(id);
+      getScopeMap(doc, SLICES_SCOPE3).delete(id);
     for (const id of laneIds)
       getScopeMap(doc, SWIM_LANES_SCOPE).delete(id);
     const scenarios = getScopeMap(doc, SCENARIOS_SCOPE2);
@@ -3235,14 +3407,14 @@ function deleteSheet(doc, chapterId) {
       }
     }
     cascadeStickyRemoval(doc, removedStickies);
-    const sheetFlows = getScopeMap(doc, SHEET_FLOWS_SCOPE);
+    const sheetFlows = getScopeMap(doc, SHEET_FLOWS_SCOPE2);
     for (const [id, f] of sheetFlows.entries()) {
-      if (f.get("sourceChapterId") === chapterId || f.get("targetChapterId") === chapterId) {
+      if (f.get("sourceSheetId") === sheetId || f.get("targetSheetId") === sheetId) {
         sheetFlows.delete(id);
       }
     }
-    removeSheet(doc, chapterId);
-    getScopeMap(doc, CHAPTERS_SCOPE).delete(chapterId);
+    removeSheet(doc, sheetId);
+    getScopeMap(doc, SHEETS_SCOPE).delete(sheetId);
   });
 }
 // ../packages/canvas-model/src/sheet-layout.ts
@@ -3295,8 +3467,8 @@ function cellContentSize(refs) {
   });
   return { width, height };
 }
-function pruneOrphanCellRefs(doc, chapterId) {
-  const sheet = getGridMap(doc).get(chapterId);
+function pruneOrphanCellRefs(doc, sheetId) {
+  const sheet = getGridMap(doc).get(sheetId);
   if (!sheet)
     return 0;
   const cells = sheet.get("cells");
@@ -3315,19 +3487,21 @@ function pruneOrphanCellRefs(doc, chapterId) {
   }
   return pruned;
 }
-function computeSheetLayout(doc, chapterId, override) {
-  const structure = readSheet(doc, chapterId);
+function computeSheetLayout(doc, sheetId, override) {
+  const structure = readSheet(doc, sheetId);
   if (!structure)
     return;
-  const chapter = getEntry(doc, "chapters", chapterId);
-  const originX = snap(chapter?.x ?? 0);
-  const originY = snap(chapter?.y ?? 0);
+  const sheet = getEntry(doc, "sheets", sheetId);
+  const originX = snap(sheet?.x ?? 0);
+  const originY = snap(sheet?.y ?? 0);
   const { columns, rows } = structure;
+  const columnSlices = structure.columnSlices ?? {};
+  const ownerOf = (columnId) => columnSlices[columnId] ?? columnId;
   const cells = override ? applyLayoutOverride(structure.cells, override) : structure.cells;
-  const colWidths = columns.map((sliceId) => {
+  const colWidths = columns.map((columnId) => {
     let w = 0;
     for (const swimLaneId of rows) {
-      const refs = cells[cellKey(sliceId, swimLaneId)] ?? [];
+      const refs = cells[cellKey(columnId, swimLaneId)] ?? [];
       const c = cellContentSize(refs);
       if (c.width > 0)
         w = Math.max(w, c.width + SHEET_LAYOUT.cellPadX * 2);
@@ -3336,8 +3510,8 @@ function computeSheetLayout(doc, chapterId, override) {
   });
   const rowHeights = rows.map((swimLaneId) => {
     let h = 0;
-    for (const sliceId of columns) {
-      const refs = cells[cellKey(sliceId, swimLaneId)] ?? [];
+    for (const columnId of columns) {
+      const refs = cells[cellKey(columnId, swimLaneId)] ?? [];
       const c = cellContentSize(refs);
       if (c.height > 0)
         h = Math.max(h, c.height + SHEET_LAYOUT.cellPadY * 2);
@@ -3358,14 +3532,33 @@ function computeSheetLayout(doc, chapterId, override) {
   });
   const gridWidth = SHEET_LAYOUT.headerLeft + colWidths.reduce((a, b) => a + b, 0);
   const gridHeight = SHEET_LAYOUT.headerTop + rowHeights.reduce((a, b) => a + b, 0);
-  const columnLayouts = columns.map((sliceId, i) => ({
-    sliceId,
+  const columnLayouts = columns.map((columnId, i) => ({
+    columnId,
+    sliceId: ownerOf(columnId),
     index: i,
     x: colX[i],
     y: originY,
     width: colWidths[i],
     height: gridHeight
   }));
+  const sliceLayouts = [];
+  for (const col of columnLayouts) {
+    const last = sliceLayouts[sliceLayouts.length - 1];
+    if (last && last.sliceId === col.sliceId) {
+      last.columnIds.push(col.columnId);
+      last.width += col.width;
+    } else {
+      sliceLayouts.push({
+        sliceId: col.sliceId,
+        columnIds: [col.columnId],
+        index: sliceLayouts.length,
+        x: col.x,
+        y: originY,
+        width: col.width,
+        height: gridHeight
+      });
+    }
+  }
   const rowLayouts = rows.map((swimLaneId, i) => ({
     swimLaneId,
     index: i,
@@ -3375,9 +3568,10 @@ function computeSheetLayout(doc, chapterId, override) {
     height: rowHeights[i]
   }));
   const stickies = [];
-  columns.forEach((sliceId, ci) => {
+  columns.forEach((columnId, ci) => {
+    const sliceId = ownerOf(columnId);
     rows.forEach((swimLaneId, ri) => {
-      const refs = cells[cellKey(sliceId, swimLaneId)] ?? [];
+      const refs = cells[cellKey(columnId, swimLaneId)] ?? [];
       if (refs.length === 0)
         return;
       const content = cellContentSize(refs);
@@ -3392,6 +3586,7 @@ function computeSheetLayout(doc, chapterId, override) {
           stickies.push({
             stickyId: ref.stickyId,
             scope: ref.scope,
+            columnId,
             sliceId,
             swimLaneId,
             x: Math.round(midX - size.width / 2),
@@ -3408,6 +3603,7 @@ function computeSheetLayout(doc, chapterId, override) {
           stickies.push({
             stickyId: ref.stickyId,
             scope: ref.scope,
+            columnId,
             sliceId,
             swimLaneId,
             x: Math.round(cursorX),
@@ -3421,17 +3617,18 @@ function computeSheetLayout(doc, chapterId, override) {
     });
   });
   return {
-    chapterId,
-    chapter: { x: originX, y: originY, width: gridWidth, height: gridHeight },
+    sheetId,
+    sheet: { x: originX, y: originY, width: gridWidth, height: gridHeight },
     columns: columnLayouts,
+    slices: sliceLayouts,
     rows: rowLayouts,
     stickies
   };
 }
 // ../packages/canvas-model/src/reflow.ts
 var REFLOW_ORIGIN = Symbol("sheet-reflow");
-var CHAPTERS_SCOPE2 = "chapters";
-var SLICES_SCOPE3 = "slices";
+var SHEETS_SCOPE2 = "sheets";
+var SLICES_SCOPE4 = "slices";
 var SWIM_LANES_SCOPE2 = "swimLanes";
 var STICKY_SCOPES = [
   "commands",
@@ -3457,27 +3654,30 @@ function applyBox(m, box, size = true) {
   }
 }
 function reflowAllSheets(doc, origin = REFLOW_ORIGIN) {
-  const chapters = getScopeMap(doc, CHAPTERS_SCOPE2);
-  if (chapters.size === 0)
+  migrateChaptersToSheets(doc);
+  const sheets = getScopeMap(doc, SHEETS_SCOPE2);
+  if (sheets.size === 0)
     return;
   doc.transact(() => {
-    for (const chapterId of chapters.keys())
-      ensureSheet(doc, chapterId);
-    const slices = getScopeMap(doc, SLICES_SCOPE3);
+    for (const sheetId of sheets.keys()) {
+      ensureSheet(doc, sheetId);
+      ensureColumnSlices(doc, sheetId);
+    }
+    const slices = getScopeMap(doc, SLICES_SCOPE4);
     const lanes = getScopeMap(doc, SWIM_LANES_SCOPE2);
     const stickyMaps = STICKY_SCOPES.map((s) => getScopeMap(doc, s));
-    for (const chapterId of getGridMap(doc).keys()) {
-      pruneOrphanCellRefs(doc, chapterId);
-      const layout = computeSheetLayout(doc, chapterId);
+    for (const sheetId of getGridMap(doc).keys()) {
+      pruneOrphanCellRefs(doc, sheetId);
+      const layout = computeSheetLayout(doc, sheetId);
       if (!layout)
         continue;
-      const ch = chapters.get(chapterId);
+      const ch = sheets.get(sheetId);
       if (ch) {
-        setIfChanged(ch, "width", layout.chapter.width);
-        setIfChanged(ch, "height", layout.chapter.height);
+        setIfChanged(ch, "width", layout.sheet.width);
+        setIfChanged(ch, "height", layout.sheet.height);
       }
-      for (const col of layout.columns)
-        applyBox(slices.get(col.sliceId), col);
+      for (const band of layout.slices)
+        applyBox(slices.get(band.sliceId), band);
       for (const row of layout.rows)
         applyBox(lanes.get(row.swimLaneId), row);
       const scenarioOrder = new Map;
@@ -4937,25 +5137,36 @@ function pad(s, width) {
   return s.length >= width ? s : s + " ".repeat(width - s.length);
 }
 var NOTE = "†";
-function resolve4(doc, chapterId) {
-  const structure = readSheet(doc, chapterId);
+function resolve4(doc, sheetId) {
+  const structure = readSheet(doc, sheetId);
   if (!structure)
     return;
   const { columns, rows, cells } = structure;
-  const notes = readCellNotes(doc, chapterId);
-  const cols = columns.map((sliceId, i) => ({
-    label: colLabel(i),
-    name: entityName(doc, "slices", sliceId),
-    note: Boolean(getEntry(doc, "slices", sliceId)?.note)
-  }));
+  const notes = readCellNotes(doc, sheetId);
+  const cols = columns.map((_, i) => ({ label: colLabel(i) }));
+  const slices = sliceOrder(structure).map((sliceId) => {
+    const cids = sliceColumns(structure, sliceId);
+    const firstCol = columns.indexOf(cids[0]);
+    const lastCol = columns.indexOf(cids[cids.length - 1]);
+    const e = getEntry(doc, "slices", sliceId);
+    return {
+      label: firstCol === lastCol ? colLabel(firstCol) : `${colLabel(firstCol)}–${colLabel(lastCol)}`,
+      name: e?.name?.trim() || "(unnamed)",
+      status: e?.status ?? "",
+      note: Boolean(e?.note),
+      firstCol,
+      lastCol
+    };
+  });
   const lanes2 = rows.map((swimLaneId, i) => {
     const e = getEntry(doc, "swimLanes", swimLaneId);
     return { label: String(i + 1), name: e?.name?.trim() || "(unnamed)", kind: e?.laneKind ?? "?", note: Boolean(e?.note) };
   });
-  const elems = columns.map((sliceId) => rows.map((swimLaneId) => (cells[cellKey(sliceId, swimLaneId)] ?? []).map((r) => elementText(doc, r))));
-  const cellNote = columns.map((sliceId) => rows.map((swimLaneId) => Boolean(notes[cellKey(sliceId, swimLaneId)])));
+  const elems = columns.map((columnId) => rows.map((swimLaneId) => (cells[cellKey(columnId, swimLaneId)] ?? []).map((r) => elementText(doc, r))));
+  const cellNote = columns.map((columnId) => rows.map((swimLaneId) => Boolean(notes[cellKey(columnId, swimLaneId)])));
   return {
-    title: entityName(doc, "chapters", chapterId),
+    title: entityName(doc, "sheets", sheetId),
+    slices,
     columns: cols,
     rows: lanes2,
     elems,
@@ -4968,7 +5179,12 @@ function rowLabel(r) {
   return r.note ? `${base} ${NOTE}` : base;
 }
 function header(r) {
-  return `Sheet "${r.title}"  (${r.columns.length} slices × ${r.rows.length} lanes)`;
+  return `Sheet "${r.title}"  (${r.slices.length} slices · ${r.columns.length} columns × ${r.rows.length} lanes)`;
+}
+function bandLabel(s) {
+  const status = s.status && s.status !== "draft" ? ` · ${s.status}` : "";
+  const note = s.note ? ` ${NOTE}` : "";
+  return `⟦ ${s.label}  ${s.name}${status}${note} ⟧`;
 }
 function cellLines(elems, width, hasNote) {
   const lines = elems.length === 0 ? [EMPTY] : (() => {
@@ -4979,22 +5195,27 @@ function cellLines(elems, width, hasNote) {
     lines[lines.length - 1] = `${lines[lines.length - 1]} ${NOTE}`;
   return lines;
 }
-function colHead(c) {
-  return c.note ? `${c.label} ${c.name} ${NOTE}` : `${c.label} ${c.name}`;
+function spanWidth(s, colWidths) {
+  let w = 2 * (s.lastCol - s.firstCol);
+  for (let i = s.firstCol;i <= s.lastCol; i += 1)
+    w += colWidths[i];
+  return w;
 }
 function renderTable(r, opts) {
   const gutter = Math.max(...r.rows.map(rowLabel).map((s) => s.length), 0);
   const colWidths = r.columns.map((c, ci) => {
-    const widest = Math.max(colHead(c).length, ...r.elems[ci].map((cell, ri) => Math.max(0, ...cell.map((e) => e.length)) + (r.cellNote[ci][ri] ? 2 : 0)), EMPTY.length);
+    const widest = Math.max(c.label.length, ...r.elems[ci].map((cell, ri) => Math.max(0, ...cell.map((e) => e.length)) + (r.cellNote[ci][ri] ? 2 : 0)), EMPTY.length);
     return Math.min(widest, opts.maxColWidth + 2);
   });
+  for (const s of r.slices) {
+    const deficit = bandLabel(s).length - spanWidth(s, colWidths);
+    if (deficit > 0)
+      colWidths[s.lastCol] += deficit;
+  }
   const totalWidth = gutter + colWidths.reduce((a, w) => a + w + 2, 0);
   const lines = [header(r), LEGEND, ""];
-  const headCells = r.columns.map((c, ci) => wrap(colHead(c), colWidths[ci]));
-  const headHeight = Math.max(...headCells.map((h) => h.length));
-  for (let i = 0;i < headHeight; i += 1) {
-    lines.push(pad("", gutter) + "  " + r.columns.map((_, ci) => pad(headCells[ci][i] ?? "", colWidths[ci])).join("  "));
-  }
+  lines.push(pad("", gutter) + "  " + r.slices.map((s) => pad(bandLabel(s), spanWidth(s, colWidths))).join("  "));
+  lines.push(pad("", gutter) + "  " + r.columns.map((c, ci) => pad(c.label, colWidths[ci])).join("  "));
   lines.push("─".repeat(totalWidth));
   r.rows.forEach((row, ri) => {
     const cellsLines = r.columns.map((_, ci) => cellLines(r.elems[ci][ri], colWidths[ci], r.cellNote[ci][ri]));
@@ -5012,24 +5233,28 @@ function renderTable(r, opts) {
 }
 function renderListing(r) {
   const lines = [header(r), LEGEND, ""];
-  r.columns.forEach((c, ci) => {
-    lines.push(`${c.label} "${c.name}"${c.note ? ` ${NOTE}` : ""}`);
+  r.slices.forEach((s) => {
+    const status = s.status && s.status !== "draft" ? ` · ${s.status}` : "";
+    lines.push(`⟦ ${s.label} ⟧ "${s.name}"${status}${s.note ? ` ${NOTE}` : ""}`);
     let any = false;
-    r.rows.forEach((row, ri) => {
-      const elems = r.elems[ci][ri];
-      const noted = r.cellNote[ci][ri];
-      if (elems.length === 0 && !noted)
-        return;
-      any = true;
-      const addr = `${c.label}${row.label}`;
-      const mark = noted ? ` ${NOTE}` : "";
-      if (elems.length <= 1) {
-        lines.push(`  ${addr}  ${elems[0] ?? EMPTY}  [${row.kind}]${mark}`);
-      } else {
-        lines.push(`  ${addr}  [${row.kind}]${mark}`);
-        elems.forEach((e, i) => lines.push(`    ${addr}.${i + 1}  ${e}`));
-      }
-    });
+    for (let ci = s.firstCol;ci <= s.lastCol; ci += 1) {
+      const col = r.columns[ci];
+      r.rows.forEach((row, ri) => {
+        const elems = r.elems[ci][ri];
+        const noted = r.cellNote[ci][ri];
+        if (elems.length === 0 && !noted)
+          return;
+        any = true;
+        const addr = `${col.label}${row.label}`;
+        const mark = noted ? ` ${NOTE}` : "";
+        if (elems.length <= 1) {
+          lines.push(`  ${addr}  ${elems[0] ?? EMPTY}  [${row.kind}]${mark}`);
+        } else {
+          lines.push(`  ${addr}  [${row.kind}]${mark}`);
+          elems.forEach((e, i) => lines.push(`    ${addr}.${i + 1}  ${e}`));
+        }
+      });
+    }
     if (!any)
       lines.push("  (empty)");
     lines.push("");
@@ -5037,9 +5262,9 @@ function renderListing(r) {
   return lines.join(`
 `).trimEnd();
 }
-function renderSheetOverview(doc, chapterId, options = {}) {
+function renderSheetOverview(doc, sheetId, options = {}) {
   const opts = { ...DEFAULTS, ...options };
-  const r = resolve4(doc, chapterId);
+  const r = resolve4(doc, sheetId);
   if (!r)
     return;
   if (r.empty)
@@ -5073,23 +5298,23 @@ function resolveSheet2(doc, ref) {
   const ids = [...grid2.keys()];
   if (ids.length === 0)
     throw new SheetAddressError("This model has no sheets.");
-  const done = (chapterId) => ({ chapterId, structure: readSheet(doc, chapterId) });
+  const done = (sheetId) => ({ sheetId, structure: readSheet(doc, sheetId) });
   if (ref && grid2.has(ref))
     return done(ref);
   if (!ref) {
     if (ids.length === 1)
       return done(ids[0]);
-    const list = ids.map((id) => `"${name(doc, "chapters", id)}"`).join(", ");
+    const list = ids.map((id) => `"${name(doc, "sheets", id)}"`).join(", ");
     throw new SheetAddressError(`Multiple sheets — name one. Available: ${list}`);
   }
   const lower = ref.toLowerCase();
-  const matches = ids.filter((id) => name(doc, "chapters", id).toLowerCase() === lower);
+  const matches = ids.filter((id) => name(doc, "sheets", id).toLowerCase() === lower);
   if (matches.length === 0) {
-    const list = ids.map((id) => `"${name(doc, "chapters", id)}"`).join(", ") || "(none)";
+    const list = ids.map((id) => `"${name(doc, "sheets", id)}"`).join(", ") || "(none)";
     throw new SheetAddressError(`No sheet named "${ref}". Available: ${list}`);
   }
   if (matches.length > 1)
-    throw new SheetAddressError(`Ambiguous sheet name "${ref}" — pass the chapterId instead.`);
+    throw new SheetAddressError(`Ambiguous sheet name "${ref}" — pass the sheetId instead.`);
   return done(matches[0]);
 }
 function resolveColumn(doc, s, ref) {
@@ -5127,6 +5352,36 @@ function resolveRow(doc, s, ref) {
     throw new SheetAddressError(`Ambiguous row name "${ref}" — use its number instead.`);
   throw new SheetAddressError(numeric ? `No row "${ref}" — not a lane name, and row ${ref} is out of range (sheet has ${rows.length} rows).` : `No row named "${ref}".`);
 }
+function resolveSlice(doc, s, ref) {
+  const { columns, columnSlices } = s.structure;
+  const order = sliceOrder(s.structure);
+  const make = (sliceId) => {
+    const columnIds = sliceColumns(s.structure, sliceId);
+    const firstIndex = columns.indexOf(columnIds[0]);
+    const lastIndex = columns.indexOf(columnIds[columnIds.length - 1]);
+    return {
+      sliceId,
+      columnIds,
+      firstIndex,
+      lastIndex,
+      label: firstIndex === lastIndex ? labelOf(firstIndex) : `${labelOf(firstIndex)}–${labelOf(lastIndex)}`
+    };
+  };
+  const lower = ref.toLowerCase();
+  const byName = order.filter((sid) => name(doc, "slices", sid).toLowerCase() === lower);
+  if (byName.length === 1)
+    return make(byName[0]);
+  if (byName.length > 1)
+    throw new SheetAddressError(`Ambiguous slice name "${ref}" — use its leading column letter instead.`);
+  const byLabel = colIndexFromLabel(ref);
+  if (byLabel >= 0 && byLabel < columns.length) {
+    const columnId = columns[byLabel];
+    return make((columnSlices ?? {})[columnId] ?? columnId);
+  }
+  if (order.includes(ref))
+    return make(ref);
+  throw new SheetAddressError(`No slice "${ref}" — not a slice name, a leading column letter, or a sliceId.`);
+}
 function labelOf(index) {
   let n = index;
   let str = "";
@@ -5285,18 +5540,58 @@ function rejectLane(doc, swimLaneId, rowIndex, kind, type) {
   const allowed = (LANE_ELEMENT_SCOPES[kind] ?? []).map((sc) => TYPE_LABEL[sc] ?? sc).join(", ");
   throw new SheetAddressError(`Lane "${nameOf(doc, "swimLanes", swimLaneId)}" (row ${rowIndex + 1}, kind=${kind}) accepts ${allowed || "(nothing)"}, not ${type}.`);
 }
-function insertColumn(doc, s, modelId, name2, at) {
+function insertColumn(doc, s, modelId, name2, at, cols = 1) {
   const id = crypto.randomUUID();
   const d = ELEMENT_DIMENSIONS.slice;
   const v = validateEntry("slices", { name: name2, x: 0, y: 0, width: d.width, height: d.height });
   if (!v.ok)
     throw new SheetAddressError(`Invalid slice: ${v.issues.join("; ")}`);
+  const span = Math.max(1, cols);
   doc.transact(() => {
     getScopeMap(doc, "slices").set(id, deepToY({ ...v.data, sliceId: id, modelId }));
-    addColumn(doc, s.chapterId, id, at);
+    addColumn(doc, s.sheetId, id, at);
+    for (let i = 1;i < span; i += 1)
+      addColumnToSlice(doc, s.sheetId, id, crypto.randomUUID());
+  });
+  const idx = readSheet(doc, s.sheetId).columns.indexOf(id);
+  const note = span > 1 ? ` (${span} cols)` : "";
+  return `${colLabel2(idx)}  "${name2}"${note}  ${id}`;
+}
+function spanSlice(doc, s, ref, toCol) {
+  const slice = resolveSlice(doc, s, ref);
+  const col = resolveColumn(doc, s, toCol);
+  const sliceName = getEntry(doc, "slices", slice.sliceId)?.name ?? "(unnamed)";
+  doc.transact(() => resizeSliceSpan(doc, s.sheetId, slice.sliceId, col.index));
+  const after = resolveSlice(doc, { sheetId: s.sheetId, structure: readSheet(doc, s.sheetId) }, slice.sliceId);
+  return `slice "${sliceName}" now spans ${after.label}`;
+}
+function splitSlice(doc, s, modelId, colRef) {
+  const col = resolveColumn(doc, s, colRef);
+  const columnId = col.sliceId;
+  const owningSlice = (s.structure.columnSlices ?? {})[columnId] ?? columnId;
+  const cols = sliceColumns(s.structure, owningSlice);
+  const pos = cols.indexOf(columnId);
+  if (pos <= 0)
+    throw new SheetAddressError(`Column ${col.label} already begins its slice — nothing to split.`);
+  const newId = crypto.randomUUID();
+  const d = ELEMENT_DIMENSIONS.slice;
+  doc.transact(() => {
+    getScopeMap(doc, "slices").set(newId, deepToY({ sliceId: newId, modelId, name: "Slice", x: 0, y: 0, width: d.width, height: d.height }));
+    for (const c of cols.slice(pos))
+      setColumnSlice(doc, s.sheetId, c, newId);
   });
-  const idx = readSheet(doc, s.chapterId).columns.indexOf(id);
-  return `${colLabel2(idx)}  "${name2}"  ${id}`;
+  return `split at ${col.label} — a new slice now covers ${col.label} onward  ${newId}`;
+}
+function renameSlice(doc, s, ref, newName) {
+  const slice = resolveSlice(doc, s, ref);
+  if (!newName.trim())
+    throw new SheetAddressError("A slice name cannot be empty.");
+  doc.transact(() => {
+    const e = getScopeMap(doc, "slices").get(slice.sliceId);
+    if (e)
+      e.set("name", newName.trim());
+  });
+  return `renamed slice ${slice.label} → "${newName.trim()}"`;
 }
 function insertLane(doc, s, modelId, kind, name2, at) {
   const id = crypto.randomUUID();
@@ -5306,9 +5601,9 @@ function insertLane(doc, s, modelId, kind, name2, at) {
     throw new SheetAddressError(`Invalid lane: ${v.issues.join("; ")}`);
   doc.transact(() => {
     getScopeMap(doc, "swimLanes").set(id, deepToY({ ...v.data, swimLaneId: id, modelId }));
-    addRow(doc, s.chapterId, id, at);
+    addRow(doc, s.sheetId, id, at);
   });
-  const idx = readSheet(doc, s.chapterId).rows.indexOf(id);
+  const idx = readSheet(doc, s.sheetId).rows.indexOf(id);
   return `${idx + 1}  "${name2}" (${kind})  ${id}`;
 }
 function insertElement(doc, s, modelId, type, cellArg, nameOrJson) {
@@ -5337,7 +5632,7 @@ function insertElement(doc, s, modelId, type, cellArg, nameOrJson) {
     };
     doc.transact(() => {
       getScopeMap(doc, "scenarios").set(id, deepToY(entry2));
-      placeInCell(doc, s.chapterId, cell.sliceId, cell.swimLaneId, { stickyId: id, scope: "scenarios" });
+      placeInCell(doc, s.sheetId, cell.sliceId, cell.swimLaneId, { stickyId: id, scope: "scenarios" });
     });
     return addressOf(doc, s, cell.sliceId, cell.swimLaneId, id, cell.address);
   }
@@ -5352,12 +5647,12 @@ function insertElement(doc, s, modelId, type, cellArg, nameOrJson) {
   const final = { ...v.data, [meta.idKey]: id, modelId };
   doc.transact(() => {
     getScopeMap(doc, meta.scope).set(id, deepToY(final));
-    placeInCell(doc, s.chapterId, cell.sliceId, cell.swimLaneId, { stickyId: id, scope: meta.scope });
+    placeInCell(doc, s.sheetId, cell.sliceId, cell.swimLaneId, { stickyId: id, scope: meta.scope });
   });
   return addressOf(doc, s, cell.sliceId, cell.swimLaneId, id, cell.address);
 }
 function addressOf(doc, s, sliceId, swimLaneId, id, cellAddr) {
-  const refs = readSheet(doc, s.chapterId).cells[cellKey(sliceId, swimLaneId)] ?? [];
+  const refs = readSheet(doc, s.sheetId).cells[cellKey(sliceId, swimLaneId)] ?? [];
   const ord = refs.findIndex((r) => r.stickyId === id) + 1;
   return `${cellAddr}.${ord}  ${id}`;
 }
@@ -5368,7 +5663,7 @@ function moveElement(doc, s, elAddr, toCell) {
   if (!laneAllows(kind, el.scope))
     rejectLane(doc, dest.swimLaneId, dest.rowIndex, kind, TYPE_LABEL[el.scope] ?? el.scope);
   doc.transact(() => {
-    placeInCell(doc, s.chapterId, dest.sliceId, dest.swimLaneId, { stickyId: el.stickyId, scope: el.scope });
+    placeInCell(doc, s.sheetId, dest.sliceId, dest.swimLaneId, { stickyId: el.stickyId, scope: el.scope });
   });
   return addressOf(doc, s, dest.sliceId, dest.swimLaneId, el.stickyId, dest.address);
 }
@@ -5376,14 +5671,14 @@ function reorderAxis(doc, s, ref, to) {
   const toIndex = to - 1;
   if (/^\d+$/.test(ref)) {
     const row = resolveRow(doc, s, ref);
-    doc.transact(() => moveRow(doc, s.chapterId, row.swimLaneId, toIndex));
-    const idx = readSheet(doc, s.chapterId).rows.indexOf(row.swimLaneId);
+    doc.transact(() => moveRow(doc, s.sheetId, row.swimLaneId, toIndex));
+    const idx = readSheet(doc, s.sheetId).rows.indexOf(row.swimLaneId);
     return `row → ${idx + 1}`;
   }
   if (colIndexFromLabel(ref) >= 0 || s.structure.columns.length > 0) {
     const col = resolveColumn(doc, s, ref);
-    doc.transact(() => moveColumn(doc, s.chapterId, col.sliceId, toIndex));
-    const idx = readSheet(doc, s.chapterId).columns.indexOf(col.sliceId);
+    doc.transact(() => moveColumn(doc, s.sheetId, col.sliceId, toIndex));
+    const idx = readSheet(doc, s.sheetId).columns.indexOf(col.sliceId);
     return `column → ${colLabel2(idx)}`;
   }
   throw new SheetAddressError(`reorder takes a column letter (A) or row number (1), got "${ref}".`);
@@ -5392,7 +5687,7 @@ function removeTarget(doc, s, target) {
   if (/^[A-Za-z]+\d+(\.\d+)?$/.test(target)) {
     const el = resolveElement(doc, s, target);
     doc.transact(() => {
-      removeSticky(doc, s.chapterId, el.stickyId);
+      removeSticky(doc, s.sheetId, el.stickyId);
       getScopeMap(doc, el.scope).delete(el.stickyId);
       cascadeStickyRemoval(doc, new Set([el.stickyId]));
     });
@@ -5403,7 +5698,7 @@ function removeTarget(doc, s, target) {
     const laneName = nameOf(doc, "swimLanes", row.swimLaneId);
     const refs2 = s.structure.columns.flatMap((sliceId) => s.structure.cells[cellKey(sliceId, row.swimLaneId)] ?? []);
     doc.transact(() => {
-      removeRow(doc, s.chapterId, row.swimLaneId);
+      removeRow(doc, s.sheetId, row.swimLaneId);
       getScopeMap(doc, "swimLanes").delete(row.swimLaneId);
       for (const r of refs2)
         getScopeMap(doc, r.scope).delete(r.stickyId);
@@ -5415,7 +5710,7 @@ function removeTarget(doc, s, target) {
   const sliceName = nameOf(doc, "slices", col.sliceId);
   const refs = s.structure.rows.flatMap((swimLaneId) => s.structure.cells[cellKey(col.sliceId, swimLaneId)] ?? []);
   doc.transact(() => {
-    removeColumn(doc, s.chapterId, col.sliceId);
+    removeColumn(doc, s.sheetId, col.sliceId);
     getScopeMap(doc, "slices").delete(col.sliceId);
     for (const r of refs)
       getScopeMap(doc, r.scope).delete(r.stickyId);
@@ -5493,7 +5788,7 @@ function sheetEdgeHandle(side, dir) {
 }
 function resolveAnchor(doc, sheet, dir, col, side) {
   const flag = dir === "source" ? "from" : "to";
-  const sheetName = nameOf(doc, "chapters", sheet.chapterId);
+  const sheetName = nameOf(doc, "sheets", sheet.sheetId);
   if (col !== undefined) {
     const c = resolveColumn(doc, sheet, col);
     const s2 = side ?? (dir === "source" ? "bottom" : "top");
@@ -5511,7 +5806,7 @@ function resolveAnchor(doc, sheet, dir, col, side) {
 function connectSheets(doc, modelId, fromRef, toRef, opts) {
   const src = resolveSheet2(doc, fromRef);
   const dst = resolveSheet2(doc, toRef);
-  if (src.chapterId === dst.chapterId) {
+  if (src.sheetId === dst.sheetId) {
     throw new SheetAddressError("Connect joins two different sheets — source and target are the same sheet.");
   }
   const from = resolveAnchor(doc, src, "source", opts.from, opts.fromSide);
@@ -5519,9 +5814,9 @@ function connectSheets(doc, modelId, fromRef, toRef, opts) {
   const id = crypto.randomUUID();
   const entry = {
     sheetFlowId: id,
-    sourceChapterId: src.chapterId,
+    sourceSheetId: src.sheetId,
     sourceHandle: from.handle,
-    targetChapterId: dst.chapterId,
+    targetSheetId: dst.sheetId,
     targetHandle: to.handle
   };
   const v = validateEntry("sheetFlows", entry);
@@ -5554,7 +5849,7 @@ function copyElement(doc, s, modelId, srcAddr, toCell) {
   const dim = FIXED_SIZE_DIM(src.scope);
   doc.transact(() => {
     getScopeMap(doc, src.scope).set(id, deepToY({ [meta.idKey]: id, modelId, name: "", x: 0, y: 0, width: dim.width, height: dim.height, isLinkedCopy: true, [meta.originalIdKey]: originalId }));
-    placeInCell(doc, s.chapterId, dest.sliceId, dest.swimLaneId, { stickyId: id, scope: src.scope });
+    placeInCell(doc, s.sheetId, dest.sliceId, dest.swimLaneId, { stickyId: id, scope: src.scope });
   });
   return addressOf(doc, s, dest.sliceId, dest.swimLaneId, id, dest.address);
 }
@@ -5584,7 +5879,7 @@ function noteTarget(doc, s, target, text) {
   }
   if (/^[A-Za-z]+\d+$/.test(target)) {
     const cell = resolveCell(doc, s, target);
-    setCellNote(doc, s.chapterId, cell.sliceId, cell.swimLaneId, t);
+    setCellNote(doc, s.sheetId, cell.sliceId, cell.swimLaneId, t);
     return `${verb} cell ${cell.address}`;
   }
   if (/^\d+$/.test(target)) {
@@ -5684,12 +5979,12 @@ function buildFromSpec(doc, modelId, nameArg, spec) {
     if (f.type && f.type !== inferred)
       throw new SheetAddressError(`Flow ${f.from}→${f.to} is ${inferred}, not ${f.type}.`);
   }
-  const chapterId = crypto.randomUUID();
+  const sheetId = crypto.randomUUID();
   const idByAddress = {};
   doc.transact(() => {
-    const cd = ELEMENT_DIMENSIONS.chapter;
-    getScopeMap(doc, "chapters").set(chapterId, deepToY({ chapterId, modelId, name: sheetName, x: 0, y: 0, width: cd.width, height: cd.height }));
-    ensureSheet(doc, chapterId);
+    const cd = ELEMENT_DIMENSIONS.sheet;
+    getScopeMap(doc, "sheets").set(sheetId, deepToY({ sheetId, modelId, name: sheetName, x: 0, y: 0, width: cd.width, height: cd.height }));
+    ensureSheet(doc, sheetId);
     const sd = ELEMENT_DIMENSIONS.slice;
     const sliceIds = cols.map((c) => {
       const id = crypto.randomUUID();
@@ -5699,7 +5994,7 @@ function buildFromSpec(doc, modelId, nameArg, spec) {
       if (c.note)
         entry.note = c.note;
       getScopeMap(doc, "slices").set(id, deepToY(entry));
-      addColumn(doc, chapterId, id);
+      addColumn(doc, sheetId, id);
       return id;
     });
     const ld = ELEMENT_DIMENSIONS.swimLane;
@@ -5709,7 +6004,7 @@ function buildFromSpec(doc, modelId, nameArg, spec) {
       if (r.note)
         entry.note = r.note;
       getScopeMap(doc, "swimLanes").set(id, deepToY(entry));
-      addRow(doc, chapterId, id);
+      addRow(doc, sheetId, id);
       return id;
     });
     for (const op of ops) {
@@ -5731,10 +6026,10 @@ function buildFromSpec(doc, modelId, nameArg, spec) {
           width: SCENARIO_CARD.width,
           height: SCENARIO_CARD.height
         }));
-        placeInCell(doc, chapterId, sliceIds[op.ci], laneIds[op.ri], { stickyId: id, scope: "scenarios" });
+        placeInCell(doc, sheetId, sliceIds[op.ci], laneIds[op.ri], { stickyId: id, scope: "scenarios" });
       } else {
         getScopeMap(doc, op.scope).set(id, deepToY({ ...op.data, [op.idKey]: id, modelId }));
-        placeInCell(doc, chapterId, sliceIds[op.ci], laneIds[op.ri], { stickyId: id, scope: op.scope });
+        placeInCell(doc, sheetId, sliceIds[op.ci], laneIds[op.ri], { stickyId: id, scope: op.scope });
       }
       idByAddress[op.address] = id;
     }
@@ -5745,7 +6040,7 @@ function buildFromSpec(doc, modelId, nameArg, spec) {
       const id = crypto.randomUUID();
       const dim = FIXED_SIZE_DIM(op.scope);
       getScopeMap(doc, op.scope).set(id, deepToY({ [meta.idKey]: id, modelId, name: "", x: 0, y: 0, width: dim.width, height: dim.height, isLinkedCopy: true, [meta.originalIdKey]: idByAddress[op.copyOf] }));
-      placeInCell(doc, chapterId, sliceIds[op.ci], laneIds[op.ri], { stickyId: id, scope: op.scope });
+      placeInCell(doc, sheetId, sliceIds[op.ci], laneIds[op.ri], { stickyId: id, scope: op.scope });
       idByAddress[op.address] = id;
     }
     for (const f of specFlows) {
@@ -5760,25 +6055,37 @@ function buildFromSpec(doc, modelId, nameArg, spec) {
       const ci = colIndexFromLabel(cl);
       const ri = rowNum - 1;
       if (ci >= 0 && ci < cols.length && ri >= 0 && ri < rows.length && text) {
-        setCellNote(doc, chapterId, sliceIds[ci], laneIds[ri], text);
+        setCellNote(doc, sheetId, sliceIds[ci], laneIds[ri], text);
       }
     }
   });
   reflowAllSheets(doc);
   const nElems = ops.length;
-  return `built sheet "${sheetName}" — ${cols.length} slices, ${rows.length} lanes, ${nElems} elements, ${specFlows.length} flows  ${chapterId}`;
+  return `built sheet "${sheetName}" — ${cols.length} slices, ${rows.length} lanes, ${nElems} elements, ${specFlows.length} flows  ${sheetId}`;
 }
 function buildSheetJson(doc, s) {
   const { columns, rows, cells } = s.structure;
-  const columnViews = columns.map((sliceId, i) => {
+  const ownerOf = (columnId) => (s.structure.columnSlices ?? {})[columnId] ?? columnId;
+  const columnViews = columns.map((columnId, i) => {
+    const e = getEntry(doc, "slices", ownerOf(columnId));
+    return { label: colLabel2(i), columnId, name: e?.name ?? "(unnamed)", status: e?.status ?? null, note: e?.note ?? null };
+  });
+  const slices = sliceOrder(s.structure).map((sliceId) => {
+    const cids = sliceColumns(s.structure, sliceId);
     const e = getEntry(doc, "slices", sliceId);
-    return { label: colLabel2(i), name: e?.name ?? "(unnamed)", sliceId, status: e?.status ?? null, note: e?.note ?? null };
+    return {
+      sliceId,
+      name: e?.name ?? "(unnamed)",
+      status: e?.status ?? null,
+      note: e?.note ?? null,
+      cols: cids.map((c) => colLabel2(columns.indexOf(c)))
+    };
   });
   const rowViews = rows.map((swimLaneId, i) => {
     const e = getEntry(doc, "swimLanes", swimLaneId);
     return { label: String(i + 1), name: e?.name ?? "(unnamed)", laneKind: e?.laneKind ?? null, swimLaneId, note: e?.note ?? null };
   });
-  const cellNotes = readCellNotes(doc, s.chapterId);
+  const cellNotes = readCellNotes(doc, s.sheetId);
   const cellNotesByAddr = {};
   for (const [k, text] of Object.entries(cellNotes)) {
     const [sliceId, swimLaneId] = k.split(":");
@@ -5801,7 +6108,7 @@ function buildSheetJson(doc, s) {
       }));
     });
   });
-  return { sheet: nameOf(doc, "chapters", s.chapterId), chapterId: s.chapterId, columns: columnViews, rows: rowViews, cells: cellViews, cellNotes: cellNotesByAddr };
+  return { sheet: nameOf(doc, "sheets", s.sheetId), sheetId: s.sheetId, slices, columns: columnViews, rows: rowViews, cells: cellViews, cellNotes: cellNotesByAddr };
 }
 function buildCellView(doc, s, cellArg) {
   const { ordinal } = parseCellAddress(cellArg);
@@ -5818,7 +6125,7 @@ function buildCellView(doc, s, cellArg) {
   const flows = getEntries(doc, "flows");
   return {
     cell: cell.address,
-    note: readCellNotes(doc, s.chapterId)[cellKey(cell.sliceId, cell.swimLaneId)] ?? null,
+    note: readCellNotes(doc, s.sheetId)[cellKey(cell.sliceId, cell.swimLaneId)] ?? null,
     slice: { label: colLabel2(cell.colIndex), name: slice?.name ?? "(unnamed)", sliceId: cell.sliceId, note: slice?.note ?? null },
     lane: { label: String(cell.rowIndex + 1), name: lane?.name ?? "(unnamed)", laneKind: lane?.laneKind ?? null, swimLaneId: cell.swimLaneId, note: lane?.note ?? null },
     elements: refs.map((r) => ({
@@ -5864,7 +6171,7 @@ function registerSheetCommands(program) {
           return JSON.stringify(buildCellView(doc, s, cellArg), null, 2);
         if (opts.json)
           return JSON.stringify(buildSheetJson(doc, s), null, 2);
-        return renderSheetOverview(doc, s.chapterId) ?? "(empty sheet)";
+        return renderSheetOverview(doc, s.sheetId) ?? "(empty sheet)";
       });
       console.log(output);
     } catch (err) {
@@ -5895,13 +6202,13 @@ function registerSheetCommands(program) {
       if (!name2)
         throw new SheetAddressError("Pass a <name> (or --from <file>).");
       const id = crypto.randomUUID();
-      const d = ELEMENT_DIMENSIONS.chapter;
-      const v = validateEntry("chapters", { name: name2, x: 0, y: 0, width: d.width, height: d.height });
+      const d = ELEMENT_DIMENSIONS.sheet;
+      const v = validateEntry("sheets", { name: name2, x: 0, y: 0, width: d.width, height: d.height });
       if (!v.ok)
         throw new SheetAddressError(`Invalid sheet: ${v.issues.join("; ")}`);
       const out = await withDoc(modelId, (doc) => {
         doc.transact(() => {
-          getScopeMap(doc, "chapters").set(id, deepToY({ ...v.data, chapterId: id, modelId }));
+          getScopeMap(doc, "sheets").set(id, deepToY({ ...v.data, sheetId: id, modelId }));
           ensureSheet(doc, id);
         });
         reflowAllSheets(doc);
@@ -5921,14 +6228,14 @@ function registerSheetCommands(program) {
     try {
       const out = await withDoc(modelId, (doc) => {
         const s = resolveSheet2(doc, sheetRef);
-        const name2 = getEntry(doc, "chapters", s.chapterId)?.name ?? s.chapterId;
+        const name2 = getEntry(doc, "sheets", s.sheetId)?.name ?? s.sheetId;
         const elements = Object.values(s.structure.cells).reduce((n, refs) => n + refs.length, 0);
         const summary = `sheet "${name2}" — ${s.structure.columns.length} slice(s), ${s.structure.rows.length} lane(s), ${elements} element(s)`;
         if (!opts.yes) {
           return `Would delete ${summary}.
 This cannot be undone. Re-run with --yes to confirm.`;
         }
-        deleteSheet(doc, s.chapterId);
+        deleteSheet(doc, s.sheetId);
         reflowAllSheets(doc);
         return `Deleted ${summary}.`;
       });
@@ -5942,15 +6249,19 @@ This cannot be undone. Re-run with --yes to confirm.`;
     }
   });
   const insert = sheet.command("insert").description("Insert a slice (column), a lane (row), or an element into a cell");
-  insert.command("slice <name>").description("Insert a new slice (column)").option("--at <n>", "Position (1-based); appends if omitted").option("--sheet <ref>", "Which sheet (name or chapterId) when the model has several").option("--model <id>", "Target model id").action((name2, opts) => runWrite(opts, (doc, s, modelId) => insertColumn(doc, s, modelId, name2, atIndex(opts.at))));
+  insert.command("slice <name>").description("Insert a new slice; --cols N makes it span N contiguous columns").option("--at <n>", "Position (1-based); appends if omitted").option("--cols <n>", "How many columns the slice spans (default 1)").option("--sheet <ref>", "Which sheet (name or sheetId) when the model has several").option("--model <id>", "Target model id").action((name2, opts) => runWrite(opts, (doc, s, modelId) => insertColumn(doc, s, modelId, name2, atIndex(opts.at), opts.cols ? Math.max(1, parseInt(opts.cols, 10) || 1) : 1)));
   for (const kind of LANE_KINDS) {
-    insert.command(`${kind} <name>`).description(`Insert a ${kind} lane (row)`).option("--at <n>", "Position (1-based); appends if omitted").option("--sheet <ref>", "Which sheet (name or chapterId) when the model has several").option("--model <id>", "Target model id").action((name2, opts) => runWrite(opts, (doc, s, modelId) => insertLane(doc, s, modelId, kind, name2, atIndex(opts.at))));
+    insert.command(`${kind} <name>`).description(`Insert a ${kind} lane (row)`).option("--at <n>", "Position (1-based); appends if omitted").option("--sheet <ref>", "Which sheet (name or sheetId) when the model has several").option("--model <id>", "Target model id").action((name2, opts) => runWrite(opts, (doc, s, modelId) => insertLane(doc, s, modelId, kind, name2, atIndex(opts.at))));
   }
   for (const type of ELEMENT_TYPES) {
-    insert.command(`${type} <cell> <element>`).description(`Insert a ${type} into a cell (e.g. B2). <element> is a name or a JSON object.`).option("--sheet <ref>", "Which sheet (name or chapterId) when the model has several").option("--model <id>", "Target model id").action((cell, element, opts) => runWrite(opts, (doc, s, modelId) => insertElement(doc, s, modelId, type, cell, element)));
+    insert.command(`${type} <cell> <element>`).description(`Insert a ${type} into a cell (e.g. B2). <element> is a name or a JSON object.`).option("--sheet <ref>", "Which sheet (name or sheetId) when the model has several").option("--model <id>", "Target model id").action((cell, element, opts) => runWrite(opts, (doc, s, modelId) => insertElement(doc, s, modelId, type, cell, element)));
   }
   sheet.command("move <element>").description("Move an element to another cell, e.g. `move B2.1 --to C2` (keeps its id + flows)").requiredOption("--to <cell>", "Destination cell (e.g. C2)").option("--sheet <ref>", "Which sheet when the model has several").option("--model <id>", "Target model id").action((element, opts) => runWrite(opts, (doc, s) => moveElement(doc, s, element, opts.to)));
   sheet.command("reorder <ref>").description("Reorder a slice (column letter) or lane (row number), e.g. `reorder A --to 3`").requiredOption("--to <n>", "New 1-based position").option("--sheet <ref>", "Which sheet when the model has several").option("--model <id>", "Target model id").action((ref, opts) => runWrite(opts, (doc, s) => reorderAxis(doc, s, ref, parseInt(opts.to, 10))));
+  const slice = sheet.command("slice").description("Slice (work-ticket) ops: span across columns, split, rename");
+  slice.command("span <slice>").description("Set a slice to span up to a column, e.g. `slice span A --to C` (grows or shrinks)").requiredOption("--to <col>", "The column the slice should end at (letter or name)").option("--sheet <ref>", "Which sheet when the model has several").option("--model <id>", "Target model id").action((sliceRef, opts) => runWrite(opts, (doc, s) => spanSlice(doc, s, sliceRef, opts.to)));
+  slice.command("split <col>").description("Split a slice so <col> begins a new slice (the columns from <col> onward break off)").option("--sheet <ref>", "Which sheet when the model has several").option("--model <id>", "Target model id").action((col, opts) => runWrite(opts, (doc, s, modelId) => splitSlice(doc, s, modelId, col)));
+  slice.command("rename <slice> <name>").description("Rename a slice (by name, leading column letter, or id)").option("--sheet <ref>", "Which sheet when the model has several").option("--model <id>", "Target model id").action((sliceRef, name2, opts) => runWrite(opts, (doc, s) => renameSlice(doc, s, sliceRef, name2)));
   sheet.command("rm <target>").description("Remove an element (B2.1), a column (A), or a lane (2) — cascades to flows/scenarios").option("--sheet <ref>", "Which sheet when the model has several").option("--model <id>", "Target model id").action((target, opts) => runWrite(opts, (doc, s) => removeTarget(doc, s, target)));
   sheet.command("update <address> <json>").description(`Replace an element's shape in place (e.g. \`update A2.1 '{"name":"PlaceOrderV2","fields":[…]}'\`)`).option("--sheet <ref>", "Which sheet when the model has several").option("--model <id>", "Target model id").action((address, json, opts) => runWrite(opts, (doc, s, modelId) => updateElement(doc, s, modelId, address, json)));
   sheet.command("flow <from> <to>").description("Connect two elements, e.g. `flow A2.1 A3.1` (flow type inferred from the element kinds)").option("--type <flowType>", "Force a flow type (otherwise inferred)").option("--sheet <ref>", "Which sheet when the model has several").option("--model <id>", "Target model id").action((from, to, opts) => runWrite(opts, (doc, s, modelId) => flowBetween(doc, s, modelId, from, to, opts.type)));

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "eventmodeler",
-  "version": "0.6.13",
+  "version": "0.6.15",
   "description": "CLI tool for event modeling - explore, design, and generate code from your event models",
   "type": "module",
   "repository": {