eventmodeler 0.6.14 → 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)
@@ -3036,6 +3045,9 @@ function resolveSheet(doc, sheetId) {
     columnSlices
   };
 }
+function sliceOf(columnSlices, columnId) {
+  return columnSlices[columnId] ?? columnId;
+}
 function ensureSheet(doc, sheetId) {
   doc.transact(() => {
     resolveSheet(doc, sheetId);
@@ -3053,6 +3065,23 @@ function readSheet(doc, sheetId) {
       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)
     return length;
@@ -3072,6 +3101,25 @@ function addColumn(doc, sheetId, sliceId, at) {
     columnSlices.set(sliceId, sliceId);
   });
 }
+function addColumnToSlice(doc, sheetId, sliceId, columnId, atWithin) {
+  doc.transact(() => {
+    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, sheetId, columnId, toIndex) {
   doc.transact(() => {
     const { columns } = resolveSheet(doc, sheetId);
@@ -3105,6 +3153,12 @@ function removeColumn(doc, sheetId, columnId) {
     }
   });
 }
+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);
@@ -3228,6 +3282,62 @@ function setCellNote(doc, sheetId, sliceId, swimLaneId, text) {
     getCellNotesMap(doc, sheetId, true).set(key, trimmed);
   });
 }
+// ../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");
@@ -3261,10 +3371,10 @@ function migrateChaptersToSheets(doc) {
 }
 // ../packages/canvas-model/src/sheet-delete.ts
 var SHEETS_SCOPE = "sheets";
-var SLICES_SCOPE2 = "slices";
+var SLICES_SCOPE3 = "slices";
 var SWIM_LANES_SCOPE = "swimLanes";
 var SCENARIOS_SCOPE2 = "scenarios";
-var SHEET_FLOWS_SCOPE = "sheetFlows";
+var SHEET_FLOWS_SCOPE2 = "sheetFlows";
 function deleteSheet(doc, sheetId) {
   doc.transact(() => {
     const sheet = getGridMap(doc).get(sheetId);
@@ -3286,7 +3396,7 @@ function deleteSheet(doc, sheetId) {
       }
     }
     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);
@@ -3297,7 +3407,7 @@ function deleteSheet(doc, sheetId) {
       }
     }
     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("sourceSheetId") === sheetId || f.get("targetSheetId") === sheetId) {
         sheetFlows.delete(id);
@@ -3518,7 +3628,7 @@ function computeSheetLayout(doc, sheetId, override) {
 // ../packages/canvas-model/src/reflow.ts
 var REFLOW_ORIGIN = Symbol("sheet-reflow");
 var SHEETS_SCOPE2 = "sheets";
-var SLICES_SCOPE3 = "slices";
+var SLICES_SCOPE4 = "slices";
 var SWIM_LANES_SCOPE2 = "swimLanes";
 var STICKY_SCOPES = [
   "commands",
@@ -3553,7 +3663,7 @@ function reflowAllSheets(doc, origin = REFLOW_ORIGIN) {
       ensureSheet(doc, sheetId);
       ensureColumnSlices(doc, sheetId);
     }
-    const slices = getScopeMap(doc, SLICES_SCOPE3);
+    const slices = getScopeMap(doc, SLICES_SCOPE4);
     const lanes = getScopeMap(doc, SWIM_LANES_SCOPE2);
     const stickyMaps = STICKY_SCOPES.map((s) => getScopeMap(doc, s));
     for (const sheetId of getGridMap(doc).keys()) {
@@ -5033,19 +5143,30 @@ function resolve4(doc, sheetId) {
     return;
   const { columns, rows, cells } = structure;
   const notes = readCellNotes(doc, sheetId);
-  const cols = columns.map((sliceId, i) => ({
-    label: colLabel(i),
-    name: entityName(doc, "slices", sliceId),
-    note: Boolean(getEntry(doc, "slices", sliceId)?.note)
-  }));
+  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, "sheets", sheetId),
+    slices,
     columns: cols,
     rows: lanes2,
     elems,
@@ -5058,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] : (() => {
@@ -5069,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]));
@@ -5102,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("");
@@ -5217,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 = "";
@@ -5375,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.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);
-  return `${colLabel2(idx)}  "${name2}"  ${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);
+  });
+  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();
@@ -5860,9 +6065,21 @@ function buildFromSpec(doc, modelId, nameArg, spec) {
 }
 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);
@@ -5891,7 +6108,7 @@ function buildSheetJson(doc, s) {
       }));
     });
   });
-  return { sheet: nameOf(doc, "sheets", s.sheetId), sheetId: s.sheetId, 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);
@@ -6032,7 +6249,7 @@ 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 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))));
+  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 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))));
   }
@@ -6041,6 +6258,10 @@ This cannot be undone. Re-run with --yes to confirm.`;
   }
   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.14",
+  "version": "0.6.15",
   "description": "CLI tool for event modeling - explore, design, and generate code from your event models",
   "type": "module",
   "repository": {