@mstone6969/graph 0.1.0 → 0.2.0

package/dist/charts/diagrams/SequenceLayout.js

@@ -0,0 +1,422 @@
+import { DiagramText } from "./DiagramText.js";
+import { SequenceFragmentKind, SequenceMessageKind, SequenceNoteSide, SequenceNumbering, SequenceSpacing } from "./sequenceEnums.js";
+// src/charts/diagrams/SequenceLayout.ts
+var SIZE = 10.5;
+var HEAD_HEIGHT = 28;
+var HEAD_MIN = 56;
+var HEAD_MAX = 148;
+var BAR = 10;
+var STEP = 5;
+var LOOP_WIDTH = 26;
+var LOOP_HEIGHT = 15;
+var LABEL_ROOM = 16;
+var LABEL_CAP = 220;
+var HEADER = 21;
+var GUARD_ROW = 18;
+var FRAME_PAD = 12;
+var NOTE_WIDTH = 156;
+var NOTE_LINES = 4;
+var NOTE_LINE = 13;
+var PILL_HEIGHT = 14;
+var GAP_MIN = 40;
+var GAP_MAX = 250;
+var ROW_GAP_MIN = 2;
+var ROW_GAP_MAX = 11;
+/** Below this the text is too small to be worth keeping whole, so labels are cut instead. */
+var SHRINK_LIMIT = .75;
+/** Places a sequence diagram top to bottom: every message, operand guard and note has a band of its own, so vertical collisions cannot occur, and gaps widen to fit their labels. */
+var SequenceLayout = class SequenceLayout {
+	static width(text, size = SIZE) {
+		return DiagramText.width(text, size);
+	}
+	static fit(text, room, size = SIZE) {
+		return DiagramText.fit(text, room, size);
+	}
+	/** Greedy word wrap, cutting the text where it would pass `NOTE_LINES`. */
+	static wrap(text) {
+		const lines = [];
+		for (const word of text.split(/\s+/).filter(Boolean)) {
+			const joined = lines.length ? `${lines.at(-1)} ${word}` : word;
+			if (lines.length && SequenceLayout.width(joined) <= NOTE_WIDTH) lines[lines.length - 1] = joined;
+			else lines.push(SequenceLayout.fit(word, NOTE_WIDTH));
+		}
+		if (lines.length <= NOTE_LINES) return lines;
+		const kept = lines.slice(0, NOTE_LINES);
+		kept[3] = `${SequenceLayout.fit(kept[3], 144).replace(/…$/, "")}…`;
+		return kept;
+	}
+	static number(step, index, numbering) {
+		if (numbering === SequenceNumbering.Flat) return String(index + 1);
+		return numbering === SequenceNumbering.Nested ? step.decimal : "";
+	}
+	static place(scene, options) {
+		const { lanes } = scene;
+		const headHeight = lanes.some((lane) => lane.actor) ? 46 : HEAD_HEIGHT;
+		const measured = SequenceLayout.vertical(scene, headHeight, 0, options.foot);
+		const bands = scene.steps.length + scene.remarks.length + 1;
+		const rowGap = Math.max(ROW_GAP_MIN, Math.min(ROW_GAP_MAX, (options.height - measured.height) / bands));
+		const rows = SequenceLayout.vertical(scene, headHeight, rowGap, options.foot);
+		const tall = Math.min(1, options.height / rows.height);
+		let gaps = SequenceLayout.gaps(scene, options);
+		const measure = (candidate) => SequenceLayout.horizontal(scene, options, rows, headHeight, candidate);
+		const natural = measure(gaps).width;
+		const room = options.width / tall, limit = options.width / Math.min(tall, SHRINK_LIMIT);
+		if (gaps.length && natural > limit) {
+			const excess = natural - limit, spare = gaps.reduce((sum, gap) => sum + Math.max(0, gap - GAP_MIN), 0);
+			gaps = gaps.map((gap) => gap - Math.max(0, gap - GAP_MIN) * Math.min(1, spare ? excess / spare : 0));
+		} else if (gaps.length && natural < room) {
+			const extra = (room - natural) / gaps.length;
+			gaps = gaps.map((gap) => Math.max(gap, Math.min(GAP_MAX, gap + extra)));
+		}
+		const plan = measure(gaps);
+		return {
+			...plan,
+			scale: plan.width ? Math.min(1, options.width / plan.width, options.height / plan.height) : 1
+		};
+	}
+	/** Top-to-bottom bands, so a row can only ever hold one message, operand guard, note or fragment header. */
+	static vertical(scene, headHeight, rowGap, foot) {
+		const { steps, frames, remarks } = scene;
+		const rows = {
+			y: [],
+			end: [],
+			frameTop: /* @__PURE__ */ new Map(),
+			frameBottom: /* @__PURE__ */ new Map(),
+			branchY: /* @__PURE__ */ new Map(),
+			noteY: /* @__PURE__ */ new Map(),
+			top: headHeight,
+			bottom: 0,
+			height: 0
+		};
+		let y = headHeight + 8;
+		const notesAfter = (index) => {
+			for (const remark of remarks.filter((other) => other.after === index)) {
+				y += rowGap / 2;
+				rows.noteY.set(remark.key, y);
+				y += SequenceLayout.noteHeight(remark) + rowGap / 2 + 4;
+			}
+		};
+		notesAfter(-1);
+		const outerFirst = [...frames].sort((a, b) => a.depth - b.depth);
+		steps.forEach((step, index) => {
+			for (const frame of outerFirst) {
+				const branch = frame.branches.find((other) => other.first === index);
+				if (branch) {
+					rows.branchY.set(`${frame.key}:${branch.first}`, y);
+					y += GUARD_ROW;
+				}
+			}
+			for (const frame of outerFirst) if (frame.first === index) {
+				rows.frameTop.set(frame.key, y);
+				y += HEADER;
+			}
+			y += LABEL_ROOM + rowGap / 2;
+			rows.y[index] = y;
+			y += step.from === step.to ? 23 : 0;
+			rows.end[index] = y;
+			y += 4 + rowGap / 2;
+			notesAfter(index);
+			for (const frame of [...outerFirst].reverse()) if (frame.last === index) {
+				y += 2;
+				rows.frameBottom.set(frame.key, y);
+				y += 5;
+			}
+		});
+		rows.bottom = y + 8;
+		rows.height = rows.bottom + (foot ? headHeight : 0);
+		return rows;
+	}
+	static noteHeight(remark) {
+		return SequenceLayout.wrap(remark.text).length * NOTE_LINE + 9;
+	}
+	/** Label widths become minimum gaps, narrow spans first; each shortfall is shared across the gaps it covers. */
+	static gaps(scene, options) {
+		const { lanes, steps, bars } = scene;
+		const heads = lanes.map((lane) => SequenceLayout.headWidth(lane.label));
+		const gaps = heads.slice(1).map((width, i) => Math.max(GAP_MIN, (heads[i] + width) / 2 + 12));
+		const reach = BAR + (options.activations ? Math.max(0, ...bars.map((bar) => bar.depth)) * STEP * 2 : 0);
+		const needs = steps.map((step, index) => {
+			const labelled = Math.min(options.width, SequenceLayout.width(step.label));
+			const pill = SequenceLayout.pillWidth(SequenceLayout.number(step, index, options.numbering));
+			if (step.from === step.to) return {
+				a: step.from,
+				b: step.from + 1,
+				need: Math.max(32, pill + 4) + labelled + reach + 14
+			};
+			return {
+				a: Math.min(step.from, step.to),
+				b: Math.max(step.from, step.to),
+				need: labelled + pill + reach + 14
+			};
+		}).filter(({ b }) => b < lanes.length).sort((x, y) => x.b - x.a - (y.b - y.a));
+		for (const { a, b, need } of needs) {
+			const span = gaps.slice(a, b).reduce((sum, gap) => sum + gap, 0);
+			if (span < need) for (let i = a; i < b; i++) gaps[i] += (need - span) / (b - a);
+		}
+		const widest = Math.max(0, ...gaps);
+		return options.spacing === SequenceSpacing.Even ? gaps.map(() => widest) : gaps;
+	}
+	static headWidth(label) {
+		return Math.max(HEAD_MIN, Math.min(HEAD_MAX, SequenceLayout.width(label, 11.5) + 20));
+	}
+	static pillWidth(number) {
+		return number ? Math.max(PILL_HEIGHT, number.length * 5 + 8) : 0;
+	}
+	static horizontal(scene, options, rows, headHeight, gaps) {
+		const { lanes, steps, bars, remarks } = scene;
+		const xs = [0];
+		for (const gap of gaps) xs.push(xs.at(-1) + gap);
+		const depthOf = (depth) => options.activations ? depth : null;
+		const edge = (lane, depth, side) => depth === null ? xs[lane] : xs[lane] + depth * STEP + side * BAR / 2;
+		const heads = lanes.flatMap((lane, i) => {
+			const clear = Math.min(gaps[i - 1] ?? Infinity, gaps[i] ?? Infinity) - 8;
+			const width = Math.min(SequenceLayout.headWidth(lane.label), clear);
+			const text = SequenceLayout.fit(lane.label, width - (lane.actor ? 0 : 12), 11.5);
+			const at = (y, boxY, tag) => ({
+				key: `${tag}${lane.id}`,
+				lane: i,
+				x: xs[i] - width / 2,
+				y,
+				boxY,
+				width,
+				height: headHeight,
+				text,
+				actor: lane.actor,
+				textY: lane.actor ? y + headHeight - 3 : boxY + HEAD_HEIGHT / 2 + 4
+			});
+			const top = at(0, headHeight - HEAD_HEIGHT, "h:");
+			return options.foot ? [top, at(rows.bottom, rows.bottom, "f:")] : [top];
+		});
+		const lifelines = lanes.map((lane, i) => ({
+			key: lane.id,
+			x: xs[i],
+			y1: rows.top,
+			y2: rows.bottom
+		}));
+		const placedBars = options.activations ? bars.map((bar, i) => {
+			const y = bar.leaf ? rows.y[bar.first] + LOOP_HEIGHT - 3 : rows.y[bar.first] - 2;
+			const bottom = bar.leaf ? rows.end[bar.first] : rows.end[bar.last] + (bar.returned ? 2 : 7);
+			return {
+				key: `b${i}`,
+				bar,
+				x: xs[bar.lane] + bar.depth * STEP - BAR / 2,
+				y,
+				width: BAR,
+				height: Math.max(8, bottom - y)
+			};
+		}) : [];
+		const arrows = steps.map((step, index) => SequenceLayout.arrow(step, index, rows.y[index], xs, edge, depthOf, options));
+		const noteBoxes = remarks.map((remark) => SequenceLayout.note(remark, rows.noteY.get(remark.key), xs));
+		const frames = SequenceLayout.frames(scene, rows, xs, arrows, noteBoxes);
+		const ends = [
+			...heads.flatMap((head) => [head.x, head.x + head.width]),
+			...placedBars.flatMap((bar) => [bar.x, bar.x + bar.width]),
+			...frames.flatMap((frame) => [frame.x, frame.x + frame.width]),
+			...noteBoxes.flatMap((note) => [note.x, note.x + note.width]),
+			...arrows.flatMap((arrow, i) => SequenceLayout.reach(arrow, xs[steps[i].from]))
+		];
+		const left = ends.length ? Math.min(...ends) : 0;
+		return {
+			width: (ends.length ? Math.max(...ends) : 0) - left,
+			height: lanes.length ? rows.height : 0,
+			left,
+			heads,
+			lifelines,
+			bars: placedBars,
+			arrows,
+			frames,
+			notes: noteBoxes
+		};
+	}
+	/** Horizontal extent of an arrow's parts, for bounding boxes. */
+	static reach(arrow, x) {
+		const { label, pill, loop } = arrow;
+		const out = [x];
+		if (loop !== null) out.push(loop);
+		if (label) out.push(label.anchor === "start" ? label.x + SequenceLayout.width(label.text) : label.x);
+		if (pill) out.push(pill.x, pill.x + pill.width);
+		return out;
+	}
+	static arrow(step, index, y, xs, edge, depthOf, options) {
+		const fromDepth = depthOf(step.fromDepth), toDepth = depthOf(step.toDepth);
+		const dashed = step.kind === SequenceMessageKind.Return;
+		const filled = step.kind === SequenceMessageKind.Sync || step.kind === SequenceMessageKind.Self;
+		const number = SequenceLayout.number(step, index, options.numbering);
+		const pillWide = SequenceLayout.pillWidth(number);
+		const shared = {
+			key: `m${index}`,
+			step,
+			number,
+			filled,
+			dashed
+		};
+		if (step.from === step.to) {
+			const start = edge(step.from, fromDepth, 1), back = edge(step.to, toDepth, 1);
+			const out = Math.max(start, back) + LOOP_WIDTH, bottom = y + LOOP_HEIGHT;
+			const textX = Math.max(out + 6, start + pillWide + 4);
+			const next = xs[step.from + 1];
+			const room = next === void 0 ? LABEL_CAP : next - textX - BAR - 2;
+			const text = SequenceLayout.fit(step.label, room);
+			return {
+				...shared,
+				d: `M${start},${y}L${out},${y}L${out},${bottom}L${back},${bottom}`,
+				head: SequenceLayout.tip(back, bottom, -1, filled),
+				loop: out,
+				label: text ? {
+					x: textX,
+					y: y + LOOP_HEIGHT / 2 + 4,
+					text,
+					anchor: "start"
+				} : null,
+				pill: pillWide ? {
+					x: start,
+					y: y - PILL_HEIGHT / 2,
+					width: pillWide
+				} : null
+			};
+		}
+		const way = step.to > step.from ? 1 : -1;
+		const start = edge(step.from, fromDepth, way), tip = edge(step.to, toDepth, -way);
+		const pill = pillWide ? {
+			x: way > 0 ? start + 2 : start - 2 - pillWide,
+			y: y - PILL_HEIGHT / 2,
+			width: pillWide
+		} : null;
+		const low = Math.min(start, tip) + (way > 0 ? pillWide + 2 : 0), high = Math.max(start, tip) - (way < 0 ? pillWide + 2 : 0);
+		return {
+			...shared,
+			d: `M${start},${y}L${tip},${y}`,
+			head: SequenceLayout.tip(tip, y, way, filled),
+			label: SequenceLayout.label(step, y, low, high, xs, way),
+			pill,
+			loop: null
+		};
+	}
+	/** Prefers the first gap from the sender that holds the label whole, so it does not sit across a lifeline. */
+	static label(step, y, low, high, xs, way) {
+		const width = SequenceLayout.width(step.label);
+		const above = y - 5;
+		if (!step.label) return null;
+		const a = Math.min(step.from, step.to), b = Math.max(step.from, step.to);
+		const seats = Array.from({ length: b - a }, (_, i) => a + i);
+		for (const seat of way > 0 ? seats : seats.reverse()) {
+			const from = Math.max(low, xs[seat] + BAR), to = Math.min(high, xs[seat + 1] - BAR);
+			if (to - from >= width + 4) return {
+				x: (from + to) / 2,
+				y: above,
+				text: step.label,
+				anchor: "middle"
+			};
+		}
+		const text = SequenceLayout.fit(step.label, high - low - 6);
+		return text ? {
+			x: (low + high) / 2,
+			y: above,
+			text,
+			anchor: "middle"
+		} : null;
+	}
+	/** `way` is the direction of travel. UML draws a filled triangle on synchronous calls, an open head otherwise. */
+	static tip(x, y, way, filled) {
+		const back = x - way * 10;
+		return filled ? `M${x},${y}L${back},${y - 5}L${back},${y + 5}Z` : `M${back},${y - 5}L${x},${y}L${back},${y + 5}`;
+	}
+	static note(remark, y, xs) {
+		const lines = SequenceLayout.wrap(remark.text);
+		const textWidth = Math.max(...lines.map((line) => SequenceLayout.width(line))) + 18;
+		const height = lines.length * NOTE_LINE + 9;
+		const a = xs[remark.lanes[0]], b = xs[remark.lanes[1]];
+		const width = remark.side === SequenceNoteSide.Over ? Math.max(textWidth, b - a + 24) : textWidth;
+		const x = remark.side === SequenceNoteSide.Left ? a - BAR - width : remark.side === SequenceNoteSide.Right ? a + BAR : (a + b - width) / 2;
+		const fold = 7;
+		return {
+			key: remark.key,
+			remark,
+			x,
+			y,
+			width,
+			height,
+			d: `M${x},${y}L${x + width - fold},${y}L${x + width},${y + fold}L${x + width},${y + height}L${x},${y + height}ZM${x + width - fold},${y}L${x + width - fold},${y + fold}L${x + width},${y + fold}`,
+			lines: lines.map((text, i) => ({
+				key: `${remark.key}:${i}`,
+				text,
+				x: x + 7,
+				y: y + 14 + i * NOTE_LINE
+			}))
+		};
+	}
+	/** Each frame wraps what it holds, and an outer frame wraps its inner frames, so nesting always reads. */
+	static frames(scene, rows, xs, arrows, notes) {
+		const { steps, remarks } = scene;
+		const spans = /* @__PURE__ */ new Map();
+		return [...scene.frames].sort((a, b) => b.depth - a.depth).map((frame) => {
+			const held = steps.flatMap((step, i) => i >= frame.first && i <= frame.last ? [
+				xs[step.from],
+				xs[step.to],
+				...SequenceLayout.reach(arrows[i], xs[step.from])
+			] : []);
+			const noted = remarks.flatMap((remark, i) => remark.after >= frame.first && remark.after <= frame.last ? [notes[i].x + 4, notes[i].x + notes[i].width - 4] : []);
+			const inner = scene.frames.filter((other) => other.depth > frame.depth && other.first >= frame.first && other.last <= frame.last).flatMap((other) => {
+				const span = spans.get(other.key);
+				return [span.x0 - 8 + FRAME_PAD, span.x1 + 8 - FRAME_PAD];
+			});
+			const tabText = frame.bounds && frame.kind === SequenceFragmentKind.Loop ? `loop(${frame.bounds})` : frame.kind;
+			const tabWidth = SequenceLayout.width(tabText, 10.5) * 1.08 + 16;
+			const guard = frame.guard ? `[${frame.guard}]` : "";
+			const all = [
+				...held,
+				...noted,
+				...inner
+			];
+			const x0 = Math.min(...all) - FRAME_PAD;
+			const x1 = Math.max(Math.max(...all) + FRAME_PAD, x0 + tabWidth + 10 + Math.min(120, SequenceLayout.width(guard)));
+			spans.set(frame.key, {
+				x0,
+				x1
+			});
+			const y = rows.frameTop.get(frame.key), bottom = rows.frameBottom.get(frame.key);
+			const guards = [];
+			const fitted = SequenceLayout.fit(guard, x1 - x0 - tabWidth - 10);
+			if (fitted) guards.push({
+				key: `${frame.key}:g`,
+				x: x0 + tabWidth + 6,
+				y: y + 14,
+				text: fitted,
+				anchor: "start"
+			});
+			const separators = frame.branches.map((branch) => {
+				const at = rows.branchY.get(`${frame.key}:${branch.first}`);
+				const text = SequenceLayout.fit(branch.guard ? `[${branch.guard}]` : "[else]", x1 - x0 - 12);
+				if (text) guards.push({
+					key: `${frame.key}:${branch.first}`,
+					x: x0 + 8,
+					y: at + 13,
+					text,
+					anchor: "start"
+				});
+				return {
+					key: `${frame.key}:${branch.first}`,
+					x1: x0,
+					x2: x1,
+					y: at
+				};
+			});
+			const h = 16, notch = 5;
+			return {
+				key: frame.key,
+				frame,
+				x: x0,
+				y,
+				width: x1 - x0,
+				height: bottom - y,
+				separators,
+				guards,
+				tabText,
+				tabX: x0 + 7,
+				tabY: y + 12,
+				tab: `M${x0},${y}L${x0 + tabWidth},${y}L${x0 + tabWidth},${y + h - notch}L${x0 + tabWidth - notch},${y + h}L${x0},${y + h}Z`
+			};
+		}).sort((a, b) => a.frame.depth - b.frame.depth);
+	}
+};
+export { SequenceLayout };

package/dist/charts/diagrams/SequenceModel.js

@@ -0,0 +1,221 @@
+import { SequenceFragmentKind, SequenceMessageKind, SequenceNoteSide, SequenceParticipantKind } from "./sequenceEnums.js";
+// src/charts/diagrams/SequenceModel.ts
+var present = (cell) => cell !== null && cell !== void 0 && cell !== "";
+var KINDS = new Set(Object.values(SequenceMessageKind));
+var FRAGMENTS = new Set(Object.values(SequenceFragmentKind));
+var SIDES = new Set(Object.values(SequenceNoteSide));
+var list = (value) => Array.isArray(value) ? value : [];
+/** UML prints guards in square brackets, so a guard that already has them keeps one pair. */
+var guardOf = (guard) => present(guard) ? String(guard).trim().replace(/^\[(.*)\]$/, "$1") : "";
+/** Turns raw rows into lanes, ordered steps and well-nested fragments, then replays the calls to find each activation. */
+var SequenceModel = class SequenceModel {
+	static rows(data) {
+		const rows = Array.isArray(data) ? data : data?.messages;
+		return Array.isArray(rows) ? rows : [];
+	}
+	static build(data, columns) {
+		const source = Array.isArray(data) ? { messages: data } : data;
+		const lanes = /* @__PURE__ */ new Map();
+		const enlist = (id, label = id, actor = false) => {
+			if (!lanes.has(id)) lanes.set(id, {
+				id,
+				label,
+				actor
+			});
+		};
+		for (const entry of list(source.participants)) if (typeof entry === "number" || typeof entry === "string" && entry) enlist(String(entry));
+		else if (typeof entry === "object" && entry && present(entry.id)) enlist(String(entry.id), entry.label || String(entry.id), entry.kind === SequenceParticipantKind.Actor);
+		const kept = [];
+		const drafts = SequenceModel.rows(data).flatMap((row, index) => {
+			const draft = SequenceModel.message(row, columns);
+			if (!draft) return [];
+			kept.push(index);
+			enlist(draft.from);
+			enlist(draft.to);
+			return [draft];
+		});
+		const order = [...lanes.values()];
+		const seat = new Map(order.map((lane, i) => [lane.id, i]));
+		const steps = drafts.map((draft, i) => ({
+			...draft,
+			row: kept[i],
+			from: seat.get(draft.from),
+			to: seat.get(draft.to),
+			decimal: "",
+			fromDepth: null,
+			toDepth: null
+		}));
+		const frames = SequenceModel.fragments(list(source.fragments), kept);
+		return {
+			lanes: order,
+			steps,
+			frames,
+			remarks: SequenceModel.notes(list(source.notes), kept, seat),
+			bars: SequenceModel.replay(steps, order, frames)
+		};
+	}
+	/** A row needs a sender. A self call may leave out `to`, and a self kind between two lifelines is a plain call. */
+	static message(row, columns) {
+		if (row === null || typeof row !== "object") return null;
+		const sender = row[columns.from];
+		if (!present(sender)) return null;
+		const from = String(sender);
+		const given = String(row[columns.kind] ?? "").toLowerCase();
+		const named = KINDS.has(given) ? given : SequenceMessageKind.Sync;
+		const target = row[columns.to];
+		if (!present(target) && named !== SequenceMessageKind.Self) return null;
+		const to = present(target) ? String(target) : from;
+		return {
+			from,
+			to,
+			kind: named === SequenceMessageKind.Self && to !== from ? SequenceMessageKind.Sync : named,
+			label: present(row[columns.label]) ? String(row[columns.label]) : ""
+		};
+	}
+	/** Maps row indexes onto kept messages, then drops what is empty or crosses a fragment already accepted. */
+	static fragments(fragments, kept) {
+		const after = (index) => {
+			const at = kept.findIndex((row) => row >= index);
+			return at < 0 ? kept.length : at;
+		};
+		const before = (index) => after(index + 1) - 1;
+		const ranges = fragments.flatMap((fragment, i) => {
+			if (!fragment || !FRAGMENTS.has(fragment.kind) || !Number.isInteger(fragment.first) || !Number.isInteger(fragment.last)) return [];
+			const first = after(fragment.first), last = before(fragment.last);
+			if (first > last) return [];
+			const seen = /* @__PURE__ */ new Set();
+			const branches = (fragment.kind === SequenceFragmentKind.Alt ? list(fragment.branches) : []).filter((branch) => Number.isInteger(branch?.first)).map((branch) => ({
+				first: after(branch.first),
+				guard: guardOf(branch.guard)
+			})).filter((branch) => branch.first > first && branch.first <= last && !seen.has(branch.first) && !!seen.add(branch.first)).sort((a, b) => a.first - b.first);
+			return [{
+				key: `f${i}`,
+				kind: fragment.kind,
+				first,
+				last,
+				guard: guardOf(fragment.guard),
+				bounds: fragment.bounds ?? "",
+				branches,
+				depth: 0
+			}];
+		}).sort((a, b) => a.first - b.first || b.last - a.last);
+		const accepted = [];
+		for (const frame of ranges) {
+			const hosts = accepted.filter((other) => frame.first >= other.first && frame.last <= other.last);
+			const crossesFrame = accepted.some((other) => frame.first > other.first && frame.first <= other.last && frame.last > other.last);
+			const crossesBranch = hosts.some((host) => host.branches.some((branch) => frame.first < branch.first && branch.first <= frame.last));
+			if (crossesFrame || crossesBranch) continue;
+			accepted.push({
+				...frame,
+				depth: hosts.length
+			});
+		}
+		return accepted;
+	}
+	static notes(notes, kept, seat) {
+		return notes.flatMap((note, i) => {
+			if (!note || !present(note.text)) return [];
+			const named = (Array.isArray(note.over) ? note.over : [note.over]).map((id) => seat.get(String(id)));
+			const lanes = [...new Set(named.filter((lane) => lane !== void 0))].sort((a, b) => a - b);
+			if (!lanes.length) return [];
+			const after = typeof note.after === "number" && Number.isFinite(note.after) ? kept.findLastIndex((row) => row <= note.after) : kept.length - 1;
+			const side = lanes.length === 1 && SIDES.has(note.side) ? note.side : SequenceNoteSide.Over;
+			return [{
+				key: `n${i}`,
+				after,
+				lanes: [lanes[0], lanes.at(-1)],
+				side,
+				text: String(note.text)
+			}];
+		});
+	}
+	/**
+	* Replays messages as calls. A return ends the sender's innermost activation; a caller that sends again
+	* must have got control back, so its unreturned calls end too. Asynchronous work has no caller and
+	* ends when its lifeline next receives a message while idle. Each `alt` operand restarts from the
+	* activations open when the fragment began, since only one operand runs.
+	*/
+	static replay(steps, lanes, frames) {
+		const calls = [];
+		const entry = /* @__PURE__ */ new Map();
+		let open = [];
+		let roots = 0;
+		const top = (lane) => open.findLast((call) => call.lane === lane);
+		const begin = (lane, first, caller, hidden = false, leaf = false) => {
+			const depth = open.filter((call) => call.lane === lane && !call.hidden).length;
+			const call = {
+				lane,
+				depth: hidden ? 0 : depth,
+				first,
+				last: first,
+				returned: false,
+				leaf,
+				caller,
+				hidden,
+				decimal: "",
+				calls: 0
+			};
+			calls.push(call);
+			open.push(call);
+			return call;
+		};
+		const end = (call) => {
+			open = open.filter((other) => other !== call);
+			if (call.caller) call.caller.last = Math.max(call.caller.last, call.last);
+		};
+		const release = (call) => {
+			for (const callee of open.filter((other) => other.caller === call).reverse()) {
+				release(callee);
+				end(callee);
+			}
+		};
+		const seen = (call) => call && !call.hidden ? call.depth : null;
+		steps.forEach((step, index) => {
+			for (const frame of frames.filter((other) => other.branches.some((branch) => branch.first === index)).sort((a, b) => a.depth - b.depth)) {
+				for (const call of [...open].reverse()) if (!entry.get(frame).includes(call)) end(call);
+				open = [...entry.get(frame)];
+			}
+			for (const frame of frames) if (frame.first === index) entry.set(frame, [...open]);
+			const sender = top(step.from) ?? begin(step.from, index, null, lanes[step.from].actor);
+			release(sender);
+			step.fromDepth = seen(sender);
+			sender.last = index;
+			const number = () => sender.decimal ? `${sender.decimal}.${++sender.calls}` : String(++roots);
+			if (step.kind === SequenceMessageKind.Return) {
+				if (step.from === step.to) {
+					step.toDepth = step.fromDepth;
+					return;
+				}
+				if (!sender.hidden) {
+					sender.returned = true;
+					end(sender);
+				}
+				const receiver = top(step.to);
+				if (receiver) receiver.last = index;
+				step.toDepth = seen(receiver);
+				return;
+			}
+			step.decimal = number();
+			if (step.from === step.to) {
+				const leaf = begin(step.to, index, null, false, true);
+				step.toDepth = leaf.depth;
+				end(leaf);
+				return;
+			}
+			const current = top(step.to);
+			if (current && !current.hidden && !current.caller && !open.some((other) => other.caller === current)) end(current);
+			const callee = begin(step.to, index, step.kind === SequenceMessageKind.Sync ? sender : null);
+			callee.decimal = step.decimal;
+			step.toDepth = callee.depth;
+		});
+		return calls.filter((call) => !call.hidden).map(({ lane, depth, first, last, returned, leaf }) => ({
+			lane,
+			depth,
+			first,
+			last,
+			returned,
+			leaf
+		}));
+	}
+};
+export { SequenceModel };