@contraagent/ui 0.0.0-stage → 0.1.0

package/dist/elements/overview/graph/paths.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"paths.js","sourceRoot":"","sources":["../../../../src/elements/overview/graph/paths.ts"],"names":[],"mappings":"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"}

package/dist/elements/overview/graph/place-card.d.ts

@@ -0,0 +1,36 @@
+export interface Box {
+    left: number;
+    top: number;
+    width: number;
+    height: number;
+}
+export type Side = 'right' | 'left' | 'below' | 'above';
+export interface Placement {
+    /** The item is in view: the card shows. */
+    shown: boolean;
+    /** The card's corner, in the same coordinates as the boxes given. */
+    x: number;
+    y: number;
+    /** The side of the item the card is on: its pointer is on the card's opposite edge. */
+    side: Side;
+    /** Where the pointer is along that edge, from the card's top (left, right) or left (below, above). */
+    arrow: number;
+    /** A side had room for the whole card: it covers none of the item. */
+    fits: boolean;
+}
+/** The space between the item and the card (the pointer sits in it), and between the card and the frame's edge. */
+export declare const GAP = 12;
+export declare const PAD = 8;
+/**
+ * The card's place beside `item` within `frame`: right of it first, then left,
+ * below and above, the first side with room for the whole card. When no side
+ * has room, the side with the most, the card kept inside the frame (it may then
+ * cover part of a large item). The card points at `aim` (a mark inside the item:
+ * the card keeps clear of the whole node it is in) and hides while `aim` is
+ * outside the frame.
+ */
+export declare function placeCard(item: Box, frame: Box, card: {
+    width: number;
+    height: number;
+}, aim?: Box): Placement;
+//# sourceMappingURL=place-card.d.ts.map

package/dist/elements/overview/graph/place-card.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"place-card.d.ts","sourceRoot":"","sources":["../../../../src/elements/overview/graph/place-card.ts"],"names":[],"mappings":"AAGA,MAAM,WAAW,GAAG;IAClB,IAAI,EAAE,MAAM,CAAC;IACb,GAAG,EAAE,MAAM,CAAC;IACZ,KAAK,EAAE,MAAM,CAAC;IACd,MAAM,EAAE,MAAM,CAAC;CAChB;AAED,MAAM,MAAM,IAAI,GAAG,OAAO,GAAG,MAAM,GAAG,OAAO,GAAG,OAAO,CAAC;AAExD,MAAM,WAAW,SAAS;IACxB,2CAA2C;IAC3C,KAAK,EAAE,OAAO,CAAC;IACf,qEAAqE;IACrE,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;IACV,uFAAuF;IACvF,IAAI,EAAE,IAAI,CAAC;IACX,sGAAsG;IACtG,KAAK,EAAE,MAAM,CAAC;IACd,sEAAsE;IACtE,IAAI,EAAE,OAAO,CAAC;CACf;AAED,mHAAmH;AACnH,eAAO,MAAM,GAAG,KAAK,CAAC;AACtB,eAAO,MAAM,GAAG,IAAI,CAAC;AAerB;;;;;;;GAOG;AACH,wBAAgB,SAAS,CAAC,IAAI,EAAE,GAAG,EAAE,KAAK,EAAE,GAAG,EAAE,IAAI,EAAE;IAAE,KAAK,EAAE,MAAM,CAAC;IAAC,MAAM,EAAE,MAAM,CAAA;CAAE,EAAE,GAAG,GAAE,GAAU,GAAG,SAAS,CAyCpH"}

package/dist/elements/overview/graph/place-card.js

@@ -0,0 +1,68 @@
+// Where the pipeline graph's inspector card goes: beside the selected item,
+// inside the frame, never over the item. Pure: rectangles in, a position out.
+/** The space between the item and the card (the pointer sits in it), and between the card and the frame's edge. */
+export const GAP = 12;
+export const PAD = 8;
+/** The pointer keeps this far from the card's corners. */
+const ARROW_INSET = 14;
+const clamp = (v, lo, hi) => (hi < lo ? lo : Math.min(hi, Math.max(lo, v)));
+/** The part of `a` inside `b`, or null when they do not meet. */
+function within(a, b) {
+    const left = Math.max(a.left, b.left);
+    const top = Math.max(a.top, b.top);
+    const right = Math.min(a.left + a.width, b.left + b.width);
+    const bottom = Math.min(a.top + a.height, b.top + b.height);
+    return right > left && bottom > top ? { left, top, width: right - left, height: bottom - top } : null;
+}
+/**
+ * The card's place beside `item` within `frame`: right of it first, then left,
+ * below and above, the first side with room for the whole card. When no side
+ * has room, the side with the most, the card kept inside the frame (it may then
+ * cover part of a large item). The card points at `aim` (a mark inside the item:
+ * the card keeps clear of the whole node it is in) and hides while `aim` is
+ * outside the frame.
+ */
+export function placeCard(item, frame, card, aim = item) {
+    const seen = within(aim, frame);
+    if (!seen)
+        return { shown: false, x: 0, y: 0, side: 'right', arrow: 0, fits: false };
+    const { width: w, height: h } = card;
+    const fl = frame.left + PAD;
+    const ft = frame.top + PAD;
+    const fr = frame.left + frame.width - PAD;
+    const fb = frame.top + frame.height - PAD;
+    const ir = item.left + item.width;
+    const ib = item.top + item.height;
+    // Centred on the part of the item in view, kept in the frame.
+    const cy = seen.top + seen.height / 2;
+    const cx = seen.left + seen.width / 2;
+    const yAt = clamp(cy - h / 2, ft, fb - h);
+    const xAt = clamp(cx - w / 2, fl, fr - w);
+    const room = {
+        right: fr - (ir + GAP) - w,
+        left: item.left - GAP - w - fl,
+        below: fb - (ib + GAP) - h,
+        above: item.top - GAP - h - ft,
+    };
+    const order = ['right', 'left', 'below', 'above'];
+    const side = order.find((s) => room[s] >= 0) ?? order.reduce((a, b) => (room[b] > room[a] ? b : a));
+    let x;
+    let y;
+    switch (side) {
+        case 'right':
+            [x, y] = [clamp(ir + GAP, fl, fr - w), yAt];
+            break;
+        case 'left':
+            [x, y] = [clamp(item.left - GAP - w, fl, fr - w), yAt];
+            break;
+        case 'below':
+            [x, y] = [xAt, clamp(ib + GAP, ft, fb - h)];
+            break;
+        case 'above':
+            [x, y] = [xAt, clamp(item.top - GAP - h, ft, fb - h)];
+            break;
+    }
+    const along = side === 'right' || side === 'left' ? clamp(cy - y, ARROW_INSET, h - ARROW_INSET) : clamp(cx - x, ARROW_INSET, w - ARROW_INSET);
+    return { shown: true, x, y, side, arrow: along, fits: room[side] >= 0 };
+}
+//# sourceMappingURL=place-card.js.map

package/dist/elements/overview/graph/place-card.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"place-card.js","sourceRoot":"","sources":["../../../../src/elements/overview/graph/place-card.ts"],"names":[],"mappings":"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"}

package/dist/elements/overview/graph/project.d.ts

@@ -0,0 +1,31 @@
+import { type FlowCallNode, type Plan } from '@contraagent/api';
+import { type FlowIndex, type FlowTask } from './flow-index.js';
+import { type GraphMark, type LayerGraph, type LayerOrder } from './types.js';
+export declare function taskMark(ts: readonly FlowTask[], unit: string): GraphMark;
+export interface Marks {
+    byUnit: Map<string, GraphMark>;
+    single: GraphMark[];
+    /** A function node's flow calls, and those that raised or were closed. */
+    calls?: number;
+    errors?: number;
+}
+/**
+ * A function node's marks: its flow calls, one mark per unit when a call's tasks share one unit, else one per call.
+ * A call's state is the most severe of its own (raised or closed: failed) and its tasks' (those of the calls it
+ * started included), so a call that caught a task's failure and returned still shows it.
+ */
+export declare function flowMarks(ts: readonly FlowTask[], d: number, name: string, calls: Map<string, FlowCallNode> | null): Marks;
+export interface Draft {
+    id: string;
+    type: 'kind' | 'flow';
+    name: string;
+    loops: number[];
+    tasks: FlowTask[];
+}
+export interface Projection {
+    graph: LayerGraph;
+    drafts: Map<string, Draft>;
+    ix: FlowIndex;
+}
+export declare function project(plan: Plan, path: readonly string[], prev?: LayerOrder, down?: boolean): Projection;
+//# sourceMappingURL=project.d.ts.map

package/dist/elements/overview/graph/project.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"project.d.ts","sourceRoot":"","sources":["../../../../src/elements/overview/graph/project.ts"],"names":[],"mappings":"AAwBA,OAAO,EAAY,KAAK,YAAY,EAAE,KAAK,IAAI,EAAiC,MAAM,kBAAkB,CAAC;AAEzG,OAAO,EAA+F,KAAK,SAAS,EAAE,KAAK,QAAQ,EAAE,MAAM,iBAAiB,CAAC;AAE7J,OAAO,EAIL,KAAK,SAAS,EAEd,KAAK,UAAU,EACf,KAAK,UAAU,EAIhB,MAAM,YAAY,CAAC;AAapB,wBAAgB,QAAQ,CAAC,EAAE,EAAE,SAAS,QAAQ,EAAE,EAAE,IAAI,EAAE,MAAM,GAAG,SAAS,CAIzE;AAED,MAAM,WAAW,KAAK;IACpB,MAAM,EAAE,GAAG,CAAC,MAAM,EAAE,SAAS,CAAC,CAAC;IAC/B,MAAM,EAAE,SAAS,EAAE,CAAC;IACpB,0EAA0E;IAC1E,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,MAAM,CAAC,EAAE,MAAM,CAAC;CACjB;AAmCD;;;;GAIG;AACH,wBAAgB,SAAS,CAAC,EAAE,EAAE,SAAS,QAAQ,EAAE,EAAE,CAAC,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,EAAE,KAAK,EAAE,GAAG,CAAC,MAAM,EAAE,YAAY,CAAC,GAAG,IAAI,GAAG,KAAK,CAwB1H;AAiCD,MAAM,WAAW,KAAK;IACpB,EAAE,EAAE,MAAM,CAAC;IACX,IAAI,EAAE,MAAM,GAAG,MAAM,CAAC;IACtB,IAAI,EAAE,MAAM,CAAC;IACb,KAAK,EAAE,MAAM,EAAE,CAAC;IAChB,KAAK,EAAE,QAAQ,EAAE,CAAC;CACnB;AAED,MAAM,WAAW,UAAU;IACzB,KAAK,EAAE,UAAU,CAAC;IAClB,MAAM,EAAE,GAAG,CAAC,MAAM,EAAE,KAAK,CAAC,CAAC;IAC3B,EAAE,EAAE,SAAS,CAAC;CACf;AAED,wBAAgB,OAAO,CAAC,IAAI,EAAE,IAAI,EAAE,IAAI,EAAE,SAAS,MAAM,EAAE,EAAE,IAAI,CAAC,EAAE,UAAU,EAAE,IAAI,UAAQ,GAAG,UAAU,CA2TxG"}

package/dist/elements/overview/graph/project.js

@@ -0,0 +1,455 @@
+// The pipeline graph, by layer: the plan projected onto one layer of its flow.
+// --- the pipeline graph, by layer ---------------------------------------------------
+//
+// The run as a graph of what its flow's code did, one layer at a time. A layer is
+// a prefix of the flow path (the names of the functions a task was created in,
+// outermost first). At a layer, a task created in the layer's own function is
+// shown in a kind node (its plan group); a task created deeper is shown in the
+// node of the function the layer's function called on the way (a function node).
+// The same rule applies at every depth. Nodes whose call sites sit in the same
+// loop of the layer's function are drawn in one loop box, a nested loop's box
+// inside it; each box counts its own loop's passes (`flow[].loops[].pass`). Edges
+// are the tasks' `after` (data) and `created_from` (created after those results),
+// projected onto the layer's nodes; an edge from a task outside the layer is an
+// incoming stub. Inside each node, one mark per unit, in the same unit order
+// everywhere in the layer.
+//
+// The drawing is a layered (Sugiyama) layout of the compound graph, by container
+// (the layer's top level, then each loop box, a box being one item of its parent):
+// layers by longest path, with the edges that go back to a loop's next pass left
+// out; a point (`~...`) on every layer a long edge crosses, so no edge runs over a
+// node; crossings reduced by barycentre sweeps; then coordinates from the measured
+// sizes (`layoutGraph`), every edge routed through those points and bending only in
+// the gaps between layers. The order depends on structure only, never on states,
+// and keeps a previous order: nodes that appear later are appended to their layer.
+import { isPython } from '@contraagent/api';
+import { orderRows, push, rankLayers, isPoint } from './arrange.js';
+import { boxChain, cmpPasses, indexOf, instanceOf, loopsAt, passesAt, placeOf, shortName, startsWith } from './flow-index.js';
+import { worstOf, worstState } from './states.js';
+import { LOOP_SEGMENT, } from './types.js';
+/** Who runs a kind node's tasks: a coding agent, Python, or both (`mixed`). */
+function executorOf(ns) {
+    const py = ns.filter(isPython).length;
+    return py === 0 ? 'agent' : py === ns.length ? 'python' : 'mixed';
+}
+const CALL_STATE = { running: 'running', returned: 'done', raised: 'failed', closed: 'failed' };
+/** A flow call stopped with an error: it raised, or it was closed. */
+const callFailed = (c) => c?.state === 'raised' || c?.state === 'closed';
+export function taskMark(ts, unit) {
+    const ns = ts.map((t) => t.n);
+    const key = (ns.find((n) => n.state === 'running') ?? ns[ns.length - 1] ?? { key: '' }).key;
+    return { key, unit, state: worstState(ns), count: ns.length, keys: ns.map((n) => n.key) };
+}
+/** A kind node's marks: one per unit, and one per task without a unit. */
+function kindMarks(ts) {
+    const byUnit = new Map();
+    const single = [];
+    for (const t of ts) {
+        if (t.n.unit)
+            push(byUnit, t.n.unit, t);
+        else
+            single.push(taskMark([t], ''));
+    }
+    return { byUnit: new Map([...byUnit].map(([u, xs]) => [u, taskMark(xs, u)])), single };
+}
+function instances(ts, d, calls) {
+    const by = new Map();
+    for (const t of ts) {
+        const { id, own } = instanceOf(t, d, calls);
+        const x = by.get(id) ?? by.set(id, { id, own, tasks: [], unit: '' }).get(id);
+        x?.tasks.push(t);
+    }
+    for (const x of by.values()) {
+        const us = new Set(x.tasks.map((t) => t.n.unit || ''));
+        x.unit = us.size === 1 ? [...us][0] : '';
+    }
+    return [...by.values()];
+}
+/**
+ * A function node's marks: its flow calls, one mark per unit when a call's tasks share one unit, else one per call.
+ * A call's state is the most severe of its own (raised or closed: failed) and its tasks' (those of the calls it
+ * started included), so a call that caught a task's failure and returned still shows it.
+ */
+export function flowMarks(ts, d, name, calls) {
+    const markOf = (xs, unit) => {
+        const own = xs.map((x) => (x.own ? calls?.get(x.id) : undefined));
+        const states = xs.map((x, i) => {
+            const c = own[i];
+            const tasks = worstState(x.tasks.map((t) => t.n));
+            return c && CALL_STATE[c.state] ? worstOf([CALL_STATE[c.state], tasks]) : tasks;
+        });
+        const tasks = xs.flatMap((x) => x.tasks);
+        const keys = tasks.map((t) => t.n.key);
+        const last = xs.find((_, i) => states[i] === 'running') ?? xs[xs.length - 1];
+        const failed = own.find(callFailed);
+        const mark = { key: last?.id ?? '', unit, state: worstOf(states), count: keys.length, keys, flow: name, counts: taskCounts(tasks) };
+        return failed ? { ...mark, error: failed.error ?? '' } : mark;
+    };
+    const byUnit = new Map();
+    const single = [];
+    const xs = instances(ts, d, calls);
+    for (const x of xs) {
+        if (x.unit)
+            push(byUnit, x.unit, x);
+        else
+            single.push(markOf([x], ''));
+    }
+    const errors = calls ? xs.filter((x) => x.own && callFailed(calls.get(x.id))).length : 0;
+    return { byUnit: new Map([...byUnit].map(([u, ys]) => [u, markOf(ys, u)])), single, calls: xs.length, errors };
+}
+/** Tasks by state. */
+function taskCounts(ts) {
+    const c = { total: ts.length, done: 0, failed: 0, running: 0, pending: 0, skipped: 0, blocked: 0 };
+    for (const t of ts)
+        c[t.n.state] += 1;
+    return c;
+}
+/** The tasks of each unit's latest pass, by the passes of the loops around them at depth `d` (tasks without a unit count as one unit). */
+function latestPass(ts, d) {
+    const most = new Map();
+    for (const t of ts) {
+        const u = t.n.unit || '';
+        const had = most.get(u);
+        if (!had || cmpPasses(passesAt(t, d), had) > 0)
+            most.set(u, passesAt(t, d));
+    }
+    return ts.filter((t) => cmpPasses(passesAt(t, d), most.get(t.n.unit || '') ?? []) === 0);
+}
+/** How many passes each unit's tasks in a node ran in (distinct pass lists at depth `d`). */
+function passesByUnit(ts, d) {
+    const seen = new Map();
+    for (const t of ts) {
+        const u = t.n.unit || '';
+        (seen.get(u) ?? seen.set(u, new Set()).get(u))?.add(passesAt(t, d).join('.'));
+    }
+    return new Map([...seen].map(([u, s]) => [u, s.size]));
+}
+/** A mark with its pass count, when it is more than 1. */
+const withPasses = (m, n) => (n && n > 1 ? { ...m, passes: n } : m);
+export function project(plan, path, prev, down = false) {
+    const ix = indexOf(plan);
+    const d = path.length;
+    const inside = ix.tasks.filter((t) => startsWith(t.path, path));
+    const drafts = new Map();
+    const nodeOfKey = new Map();
+    for (const t of inside) {
+        const p = placeOf(t, d);
+        const x = drafts.get(p.id) ?? drafts.set(p.id, { ...p, tasks: [] }).get(p.id);
+        x?.tasks.push(t);
+        nodeOfKey.set(t.n.key, p.id);
+    }
+    const marks = new Map();
+    const shownOf = new Map(); // node id -> the tasks it counts
+    const boxOf = new Map(); // node id -> its innermost loop box
+    const boxParent = new Map(); // loop box -> the box it nests in
+    for (const x of drafts.values()) {
+        const chain = boxChain(x.loops);
+        const inner = chain[chain.length - 1] ?? null;
+        chain.forEach((box, i) => boxParent.set(box, chain[i - 1] ?? null));
+        if (inner)
+            boxOf.set(x.id, inner);
+        // In a loop box, a unit's mark is its latest pass, and counts the passes it ran in.
+        const shown = inner ? latestPass(x.tasks, d) : x.tasks;
+        shownOf.set(x.id, shown);
+        const m = x.type === 'kind' ? kindMarks(shown) : flowMarks(shown, d, x.name, ix.calls);
+        if (inner) {
+            const per = passesByUnit(x.tasks, d);
+            m.byUnit = new Map([...m.byUnit].map(([u, mk]) => [u, withPasses(mk, per.get(u))]));
+        }
+        marks.set(x.id, m);
+    }
+    const units = [...new Set([...marks.values()].flatMap((m) => [...m.byUnit.keys()]))].sort((a, b) => (ix.unitRank.get(a) ?? 0) - (ix.unitRank.get(b) ?? 0));
+    // Each box's own loop: its last pass, and the passes each unit ran of it (its
+    // distinct passes, those of the loops around it included).
+    const boxLast = new Map();
+    const boxRan = new Map();
+    for (const x of drafts.values()) {
+        const chain = boxChain(x.loops);
+        for (const t of x.tasks) {
+            const ps = passesAt(t, d);
+            chain.forEach((box, i) => {
+                boxLast.set(box, Math.max(boxLast.get(box) ?? 1, ps[i] ?? 1));
+                const per = boxRan.get(box) ?? boxRan.set(box, new Map()).get(box);
+                const u = t.n.unit || '';
+                (per?.get(u) ?? per?.set(u, new Set()).get(u))?.add(ps.slice(0, i + 1).join('.'));
+            });
+        }
+    }
+    // The loop boxes an id sits in, innermost first (for a box id, itself first).
+    const boxPath = (id) => {
+        const out = [];
+        let b = id.startsWith(LOOP_SEGMENT) ? id : (boxOf.get(id) ?? null);
+        while (b) {
+            out.push(b);
+            b = boxParent.get(b) ?? null;
+        }
+        return out;
+    };
+    // The direct child of `container` (a box, or '' for the layer's top level) that holds a node `id`.
+    const itemIn = (id, container) => {
+        const bp = boxPath(id);
+        if (container === '')
+            return bp[bp.length - 1] ?? id;
+        const i = bp.indexOf(container);
+        return i < 0 ? undefined : i === 0 ? id : bp[i - 1];
+    };
+    // The deepest loop box holding both ends of an edge (the layer's top level when none).
+    const commonBox = (a, b) => {
+        const bp = boxPath(a);
+        return bp.find((x) => boxPath(b).includes(x)) ?? '';
+    };
+    // The container a slot is in: a stub's is the top level.
+    const containerOf = (id) => (id.startsWith('stub:') ? '' : (boxOf.get(id) ?? ''));
+    // Edges, projected onto the layer's nodes; from outside it, stubs. An edge whose
+    // every task joins a later pass of a loop around both ends goes back to the next pass.
+    const inOrder = new Set();
+    const pairs = new Map();
+    const stubs = new Map();
+    const outside = (o) => {
+        let c = 0;
+        while (c < d && o.path[c] === path[c])
+            c++;
+        const p = placeOf(o, c);
+        return { id: `stub:${c}:${p.id}`, label: p.type === 'kind' ? (ix.labels.get(p.name) ?? p.name) : shortName(p.name) };
+    };
+    for (const t of inside) {
+        const to = nodeOfKey.get(t.n.key);
+        const link = (dep, type) => {
+            const from = nodeOfKey.get(dep);
+            if (from === to) {
+                if (type === 'after')
+                    inOrder.add(to);
+                return;
+            }
+            if (from !== undefined) {
+                const o = ix.byKey.get(dep);
+                const a = loopsAt(o, d);
+                const b = loopsAt(t, d);
+                let k = 0;
+                while (k < a.length && a[k] === b[k])
+                    k++;
+                const same = cmpPasses(passesAt(o, d).slice(0, k), passesAt(t, d).slice(0, k)) === 0;
+                const key = `${from}\u0000${to}\u0000${type}`;
+                const e = pairs.get(key) ?? pairs.set(key, { from, to, type, tasks: new Set(), samePass: false }).get(key);
+                e?.tasks.add(t.n.key);
+                if (e && same)
+                    e.samePass = true;
+                return;
+            }
+            const o = ix.byKey.get(dep);
+            if (!o)
+                return; // not in the plan yet
+            const s = outside(o);
+            const k = `${s.id}\u0000${to}\u0000${type}`;
+            (stubs.get(k) ?? stubs.set(k, { ...s, to, type, tasks: new Set() }).get(k))?.tasks.add(t.n.key);
+        };
+        for (const dep of t.n.after ?? [])
+            link(dep, 'after');
+        for (const dep of t.from)
+            link(dep, 'created');
+    }
+    // A created_from edge is drawn only where no after edge joins the same two.
+    const all = [...pairs.values()].filter((e) => e.type === 'after' || !pairs.has(`${e.from}\u0000${e.to}\u0000after`));
+    const stubList = [...stubs.values()].filter((s) => s.type === 'after' || !stubs.has(`${s.id}\u0000${s.to}\u0000after`));
+    // Layers, by container: the layer's top level, then each loop box (its own nodes
+    // and the loop boxes nested in it). Each box is one item of its parent.
+    const containers = ['', ...boxParent.keys()];
+    const kidsOf = new Map(containers.map((c) => [c, []]));
+    for (const id of drafts.keys()) {
+        for (const c of containers) {
+            const it = itemIn(id, c);
+            if (it !== undefined && !kidsOf.get(c)?.includes(it))
+                kidsOf.get(c)?.push(it);
+        }
+    }
+    const lay = new Map();
+    for (const c of containers) {
+        const kids = kidsOf.get(c) ?? [];
+        const prevRows = c === '' ? prev?.layers : prev?.boxes[c];
+        const fixed = new Map();
+        prevRows?.forEach((row, i) => row.forEach((id) => kids.includes(id) && fixed.set(id, i)));
+        // An edge back to a loop's next pass does not set the layers.
+        const es = all
+            .filter((e) => e.samePass && commonBox(e.from, e.to) === c)
+            .map((e) => [itemIn(e.from, c), itemIn(e.to, c)]);
+        lay.set(c, rankLayers(kids, es, fixed));
+    }
+    // Stubs, in the top level: in the layer before the first they lead to (a new first layer when that is the first).
+    const top = lay.get('');
+    const stubIds = [...new Set(stubList.map((s) => s.id))];
+    const prevTop = new Map();
+    prev?.layers.forEach((row, i) => row.forEach((id) => prevTop.set(id, i)));
+    const stubAt = new Map(stubIds.map((id) => [id, prevTop.get(id) ?? Math.min(...stubList.filter((s) => s.id === id).map((s) => top.get(itemIn(s.to, '')) ?? 0)) - 1]));
+    if ([...stubAt.values()].some((l) => l < 0)) {
+        for (const [id, l] of top)
+            top.set(id, l + 1);
+        for (const [id, l] of stubAt)
+            stubAt.set(id, l + 1);
+    }
+    for (const [id, l] of stubAt)
+        top.set(id, l);
+    const layerOf = (c, id) => lay.get(c)?.get(id) ?? 0;
+    const lastLayer = (c) => Math.max(0, ...(lay.get(c)?.values() ?? []));
+    // Every edge whose ends are not in a later layer than its start goes back: not drawn.
+    const isBack = (from, to) => {
+        const c = commonBox(from, to);
+        return layerOf(c, itemIn(from, c)) >= layerOf(c, itemIn(to, c));
+    };
+    const edges = all.map((e) => ({ from: e.from, to: e.to, tasks: e.tasks.size, type: e.type, back: isBack(e.from, e.to) }));
+    // Each container's rows: its items by layer, a previous order kept, new items after it.
+    const rows = new Map();
+    for (const c of containers) {
+        const prevRows = c === '' ? prev?.layers : prev?.boxes[c];
+        const kept = (prevRows ?? []).flat();
+        const ids = [...(c === '' ? [...stubIds] : []), ...(kidsOf.get(c) ?? [])];
+        ids.sort((a, b) => {
+            const ka = kept.indexOf(a);
+            const kb = kept.indexOf(b);
+            return (ka < 0 ? Infinity : ka) - (kb < 0 ? Infinity : kb);
+        });
+        const r = Array.from({ length: lastLayer(c) + 1 }, () => []);
+        for (const id of ids)
+            r[layerOf(c, id)]?.push(id);
+        rows.set(c, r);
+    }
+    // Routes: the drawn edges through points on the layers they cross. The points of
+    // edges from one place (of one type) are shared, so their lines run as one.
+    const routes = [];
+    const points = new Set();
+    const point = (c, origin, type, l) => {
+        const id = `~${c}|${origin}|${type}|${l}`;
+        if (!points.has(id)) {
+            points.add(id);
+            rows.get(c)?.[l]?.push(id);
+        }
+        return { id, in: c };
+    };
+    // A point beside a box, in its layer of the container around it: an edge that leaves or
+    // enters the box through its side, between two of its layers, passes there.
+    const byPoint = (c, box, origin, type) => {
+        const l = layerOf(c, box);
+        const id = `~${c}|by:${box}|${origin}|${type}|${l}`;
+        if (!points.has(id)) {
+            points.add(id);
+            rows.get(c)?.[l]?.push(id);
+        }
+        return { id, in: c };
+    };
+    // An edge enters a box at its near side only to reach the box's first layer (and,
+    // top to bottom, not even then: the box's label is on that side); else through its
+    // side, next to the layer it goes to. It leaves at the far side only from the box's
+    // last layer, else through its side. So it runs inside a box only where it starts or ends.
+    const route = (from, to, type) => {
+        const c = from.startsWith('stub:') ? '' : commonBox(from, to);
+        let curIn = containerOf(from);
+        let cur = from;
+        const steps = [{ id: from, in: curIn }];
+        // Out of the boxes around the source, up to the common container.
+        while (curIn !== c) {
+            const up = boxParent.get(curIn) ?? '';
+            steps.push({ id: curIn, in: up });
+            if (layerOf(curIn, cur) < lastLayer(curIn))
+                steps.push(byPoint(up, curIn, cur, type));
+            cur = curIn;
+            curIn = up;
+        }
+        // Across the common container, then into the boxes around the target.
+        const target = itemIn(to, c);
+        for (let l = layerOf(c, cur) + 1; l < layerOf(c, target); l++)
+            steps.push(point(c, cur, type, l));
+        const bp = boxPath(to);
+        const inward = bp.slice(0, c === '' ? bp.length : bp.indexOf(c)).reverse();
+        const origin = `>${c}:${cur}`;
+        let k = c;
+        for (const box of inward) {
+            const n = itemIn(to, box);
+            if (layerOf(box, n) > 0 || down)
+                steps.push(byPoint(k, box, origin, type));
+            steps.push({ id: box, in: k });
+            k = box;
+        }
+        steps.push({ id: to, in: k });
+        return steps;
+    };
+    for (const e of edges)
+        if (!e.back)
+            routes.push({ from: e.from, to: e.to, type: e.type, steps: route(e.from, e.to, e.type) });
+    for (const s of stubList)
+        routes.push({ from: s.id, to: s.to, type: s.type, steps: route(s.id, s.to, s.type) });
+    // The order within each layer.
+    const slots = {};
+    for (const c of containers) {
+        const links = [];
+        const lv = new Map((rows.get(c) ?? []).flatMap((r, i) => r.map((id) => [id, i])));
+        for (const r of routes)
+            for (let i = 1; i < r.steps.length; i++) {
+                const a = r.steps[i - 1];
+                const b = r.steps[i];
+                if (a.in === c && b.in === c && lv.get(a.id) !== lv.get(b.id))
+                    links.push([a.id, b.id]);
+            }
+        const hasPrev = c === '' ? !!prev : !!prev?.boxes[c];
+        // A point beside a box is right after it.
+        slots[c] = orderRows(rows.get(c) ?? [], links, hasPrev).map((row) => {
+            const by = row.filter((id) => id.includes('|by:'));
+            const rest = row.filter((id) => !id.includes('|by:'));
+            return rest.flatMap((id) => [id, ...by.filter((p) => p.includes(`|by:${id}|`))]);
+        });
+    }
+    const real = (r) => r.map((row) => row.filter((id) => !isPoint(id)));
+    const boxes = [...boxParent.keys()].map((id) => {
+        const spread = new Map();
+        for (const [u, ran] of boxRan.get(id) ?? [])
+            if (u)
+                spread.set(ran.size, (spread.get(ran.size) ?? 0) + 1);
+        return {
+            id,
+            loop: Number(id.slice(LOOP_SEGMENT.length).split('.').pop()),
+            file: inside[0]?.frames[d - 1]?.file ?? '',
+            parent: boxParent.get(id) ?? null,
+            passes: boxLast.get(id) ?? 1,
+            spread: [...spread].sort((a, b) => a[0] - b[0]),
+            layers: real(slots[id] ?? []).filter((r) => r.length),
+        };
+    });
+    const outerRows = real(slots[''] ?? []).map((row) => row.filter((id) => !id.startsWith('stub:')));
+    const nodeOf = (x) => {
+        const m = marks.get(x.id);
+        const hasUnits = m.byUnit.size > 0;
+        return {
+            id: x.id,
+            type: x.type,
+            name: x.name,
+            label: x.type === 'kind' ? (ix.labels.get(x.name) ?? x.name) : shortName(x.name),
+            kinds: [...new Set(x.tasks.map((t) => t.n.kind))],
+            executor: x.type === 'flow' ? null : executorOf(x.tasks.map((t) => t.n)),
+            box: boxOf.get(x.id) ?? null,
+            units: hasUnits ? units.map((u) => m.byUnit.get(u) ?? null) : [],
+            single: m.single,
+            inOrder: inOrder.has(x.id),
+            counts: taskCounts(shownOf.get(x.id) ?? []),
+            calls: m.calls ?? 0,
+            errors: m.errors ?? 0,
+        };
+    };
+    const byBox = new Map(boxes.map((b) => [b.id, b]));
+    // Every node id, in drawing order: expand each loop box to the nodes nested in it.
+    const expand = (ids) => ids.flatMap((id) => (id.startsWith(LOOP_SEGMENT) ? expand((byBox.get(id)?.layers ?? []).flat()) : [id]));
+    return {
+        graph: {
+            path: [...path],
+            nodes: expand(outerRows.flat()).map((id) => nodeOf(drafts.get(id))),
+            layers: outerRows.filter((r) => r.length),
+            boxes,
+            edges,
+            stubs: stubList.map((s) => ({ id: s.id, label: s.label, to: s.to, tasks: s.tasks.size, type: s.type })),
+            units,
+            slots,
+            routes,
+            order: { layers: real(slots[''] ?? []), boxes: Object.fromEntries(boxes.map((b) => [b.id, real(slots[b.id] ?? [])])) },
+        },
+        drafts,
+        ix,
+    };
+}
+//# sourceMappingURL=project.js.map